super.c 40.5 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 *  linux/fs/super.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  super.c contains code to handle: - mount structures
 *                                   - super-block tables
 *                                   - filesystem drivers list
 *                                   - mount system call
 *                                   - umount system call
 *                                   - ustat system call
 *
 * GK 2/5/95  -  Changed to support mounting the root fs via NFS
 *
 *  Added kerneld support: Jacques Gelinas and Bjorn Ekwall
 *  Added change_root: Werner Almesberger & Hans Lermen, Feb '96
 *  Added options to /proc/mounts:
19
 *    Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22 23
 *  Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
 *  Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
 */

24
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26 27 28 29 30
#include <linux/slab.h>
#include <linux/blkdev.h>
#include <linux/mount.h>
#include <linux/security.h>
#include <linux/writeback.h>		/* for the emergency remount stuff */
#include <linux/idr.h>
Ingo Molnar's avatar
Ingo Molnar committed
31
#include <linux/mutex.h>
32
#include <linux/backing-dev.h>
33
#include <linux/rculist_bl.h>
34
#include <linux/cleancache.h>
Al Viro's avatar
Al Viro committed
35
#include <linux/fsnotify.h>
36
#include <linux/lockdep.h>
37
#include <linux/user_namespace.h>
38
#include <uapi/linux/mount.h>
39
#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
40

41
static int thaw_super_locked(struct super_block *sb);
Linus Torvalds's avatar
Linus Torvalds committed
42

43 44
static LIST_HEAD(super_blocks);
static DEFINE_SPINLOCK(sb_lock);
Linus Torvalds's avatar
Linus Torvalds committed
45

46 47 48 49 50 51
static char *sb_writers_name[SB_FREEZE_LEVELS] = {
	"sb_writers",
	"sb_pagefaults",
	"sb_internal",
};

52 53 54 55 56 57 58
/*
 * One thing we have to be careful of with a per-sb shrinker is that we don't
 * drop the last active reference to the superblock from within the shrinker.
 * If that happens we could trigger unregistering the shrinker from within the
 * shrinker path and that leads to deadlock on the shrinker_rwsem. Hence we
 * take a passive reference to the superblock to avoid this from occurring.
 */
59 60
static unsigned long super_cache_scan(struct shrinker *shrink,
				      struct shrink_control *sc)
61 62
{
	struct super_block *sb;
63 64 65 66 67
	long	fs_objects = 0;
	long	total_objects;
	long	freed = 0;
	long	dentries;
	long	inodes;
68 69 70 71 72 73 74

	sb = container_of(shrink, struct super_block, s_shrink);

	/*
	 * Deadlock avoidance.  We may hold various FS locks, and we don't want
	 * to recurse into the FS that called us in clear_inode() and friends..
	 */
75 76
	if (!(sc->gfp_mask & __GFP_FS))
		return SHRINK_STOP;
77

78
	if (!trylock_super(sb))
79
		return SHRINK_STOP;
80

81
	if (sb->s_op->nr_cached_objects)
82
		fs_objects = sb->s_op->nr_cached_objects(sb, sc);
83

84 85
	inodes = list_lru_shrink_count(&sb->s_inode_lru, sc);
	dentries = list_lru_shrink_count(&sb->s_dentry_lru, sc);
86
	total_objects = dentries + inodes + fs_objects + 1;
87 88
	if (!total_objects)
		total_objects = 1;
89

90
	/* proportion the scan between the caches */
91
	dentries = mult_frac(sc->nr_to_scan, dentries, total_objects);
92
	inodes = mult_frac(sc->nr_to_scan, inodes, total_objects);
93
	fs_objects = mult_frac(sc->nr_to_scan, fs_objects, total_objects);
94

95 96 97
	/*
	 * prune the dcache first as the icache is pinned by it, then
	 * prune the icache, followed by the filesystem specific caches
98 99 100
	 *
	 * Ensure that we always scan at least one object - memcg kmem
	 * accounting uses this to fully empty the caches.
101
	 */
102
	sc->nr_to_scan = dentries + 1;
103
	freed = prune_dcache_sb(sb, sc);
104
	sc->nr_to_scan = inodes + 1;
105
	freed += prune_icache_sb(sb, sc);
106 107

	if (fs_objects) {
108
		sc->nr_to_scan = fs_objects + 1;
109
		freed += sb->s_op->free_cached_objects(sb, sc);
110 111
	}

112
	up_read(&sb->s_umount);
113 114 115 116 117 118 119 120 121 122 123
	return freed;
}

static unsigned long super_cache_count(struct shrinker *shrink,
				       struct shrink_control *sc)
{
	struct super_block *sb;
	long	total_objects = 0;

	sb = container_of(shrink, struct super_block, s_shrink);

124
	/*
125 126 127 128 129 130 131 132 133 134 135 136
	 * We don't call trylock_super() here as it is a scalability bottleneck,
	 * so we're exposed to partial setup state. The shrinker rwsem does not
	 * protect filesystem operations backing list_lru_shrink_count() or
	 * s_op->nr_cached_objects(). Counts can change between
	 * super_cache_count and super_cache_scan, so we really don't need locks
	 * here.
	 *
	 * However, if we are currently mounting the superblock, the underlying
	 * filesystem might be in a state of partial construction and hence it
	 * is dangerous to access it.  trylock_super() uses a SB_BORN check to
	 * avoid this situation, so do the same here. The memory barrier is
	 * matched with the one in mount_fs() as we don't hold locks here.
137
	 */
138 139 140 141
	if (!(sb->s_flags & SB_BORN))
		return 0;
	smp_rmb();

142
	if (sb->s_op && sb->s_op->nr_cached_objects)
143
		total_objects = sb->s_op->nr_cached_objects(sb, sc);
144

145 146
	total_objects += list_lru_shrink_count(&sb->s_dentry_lru, sc);
	total_objects += list_lru_shrink_count(&sb->s_inode_lru, sc);
147

148 149 150
	if (!total_objects)
		return SHRINK_EMPTY;

151
	total_objects = vfs_pressure_ratio(total_objects);
152
	return total_objects;
153 154
}

155 156 157 158 159 160 161
static void destroy_super_work(struct work_struct *work)
{
	struct super_block *s = container_of(work, struct super_block,
							destroy_work);
	int i;

	for (i = 0; i < SB_FREEZE_LEVELS; i++)
162
		percpu_free_rwsem(&s->s_writers.rw_sem[i]);
163 164 165 166 167 168 169 170 171 172
	kfree(s);
}

static void destroy_super_rcu(struct rcu_head *head)
{
	struct super_block *s = container_of(head, struct super_block, rcu);
	INIT_WORK(&s->destroy_work, destroy_super_work);
	schedule_work(&s->destroy_work);
}

173 174
/* Free a superblock that has never been seen by anyone */
static void destroy_unused_super(struct super_block *s)
175
{
176 177 178
	if (!s)
		return;
	up_write(&s->s_umount);
179 180 181
	list_lru_destroy(&s->s_dentry_lru);
	list_lru_destroy(&s->s_inode_lru);
	security_sb_free(s);
182
	put_user_ns(s->s_user_ns);
183
	kfree(s->s_subtype);
184
	free_prealloced_shrinker(&s->s_shrink);
185 186
	/* no delays needed */
	destroy_super_work(&s->destroy_work);
187 188
}

Linus Torvalds's avatar
Linus Torvalds committed
189 190
/**
 *	alloc_super	-	create new superblock
191
 *	@type:	filesystem type superblock should belong to
192
 *	@flags: the mount flags
193
 *	@user_ns: User namespace for the super_block
Linus Torvalds's avatar
Linus Torvalds committed
194 195 196 197
 *
 *	Allocates and initializes a new &struct super_block.  alloc_super()
 *	returns a pointer new superblock or %NULL if allocation had failed.
 */
198 199
static struct super_block *alloc_super(struct file_system_type *type, int flags,
				       struct user_namespace *user_ns)
Linus Torvalds's avatar
Linus Torvalds committed
200
{
201
	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
202
	static const struct super_operations default_op;
203 204 205 206
	int i;

	if (!s)
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
207

208
	INIT_LIST_HEAD(&s->s_mounts);
209
	s->s_user_ns = get_user_ns(user_ns);
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
	init_rwsem(&s->s_umount);
	lockdep_set_class(&s->s_umount, &type->s_umount_key);
	/*
	 * sget() can have s_umount recursion.
	 *
	 * When it cannot find a suitable sb, it allocates a new
	 * one (this one), and tries again to find a suitable old
	 * one.
	 *
	 * In case that succeeds, it will acquire the s_umount
	 * lock of the old one. Since these are clearly distrinct
	 * locks, and this object isn't exposed yet, there's no
	 * risk of deadlocks.
	 *
	 * Annotate this by putting this lock in a different
	 * subclass.
	 */
	down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
228

229 230
	if (security_sb_alloc(s))
		goto fail;
231

232
	for (i = 0; i < SB_FREEZE_LEVELS; i++) {
233 234 235
		if (__percpu_init_rwsem(&s->s_writers.rw_sem[i],
					sb_writers_name[i],
					&type->s_writers_key[i]))
236
			goto fail;
Linus Torvalds's avatar
Linus Torvalds committed
237
	}
238
	init_waitqueue_head(&s->s_writers.wait_unfrozen);
239
	s->s_bdi = &noop_backing_dev_info;
240
	s->s_flags = flags;
241
	if (s->s_user_ns != &init_user_ns)
242
		s->s_iflags |= SB_I_NODEV;
243
	INIT_HLIST_NODE(&s->s_instances);
244
	INIT_HLIST_BL_HEAD(&s->s_roots);
245
	mutex_init(&s->s_sync_lock);
246
	INIT_LIST_HEAD(&s->s_inodes);
247
	spin_lock_init(&s->s_inode_list_lock);
248 249
	INIT_LIST_HEAD(&s->s_inodes_wb);
	spin_lock_init(&s->s_inode_wblist_lock);
250 251 252 253 254

	s->s_count = 1;
	atomic_set(&s->s_active, 1);
	mutex_init(&s->s_vfs_rename_mutex);
	lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
255
	init_rwsem(&s->s_dquot.dqio_sem);
256 257 258
	s->s_maxbytes = MAX_NON_LFS;
	s->s_op = &default_op;
	s->s_time_gran = 1000000000;
259
	s->cleancache_poolid = CLEANCACHE_NO_POOL;
260 261 262 263 264

	s->s_shrink.seeks = DEFAULT_SEEKS;
	s->s_shrink.scan_objects = super_cache_scan;
	s->s_shrink.count_objects = super_cache_count;
	s->s_shrink.batch = 1024;
265
	s->s_shrink.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE;
266 267
	if (prealloc_shrinker(&s->s_shrink))
		goto fail;
268
	if (list_lru_init_memcg(&s->s_dentry_lru, &s->s_shrink))
269
		goto fail;
270
	if (list_lru_init_memcg(&s->s_inode_lru, &s->s_shrink))
271
		goto fail;
Linus Torvalds's avatar
Linus Torvalds committed
272
	return s;
273

274
fail:
275
	destroy_unused_super(s);
276
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
277 278 279 280 281
}

/* Superblock refcounting  */

/*
282
 * Drop a superblock's refcount.  The caller must hold sb_lock.
Linus Torvalds's avatar
Linus Torvalds committed
283
 */
284
static void __put_super(struct super_block *s)
Linus Torvalds's avatar
Linus Torvalds committed
285
{
286 287 288 289 290 291 292 293 294
	if (!--s->s_count) {
		list_del_init(&s->s_list);
		WARN_ON(s->s_dentry_lru.node);
		WARN_ON(s->s_inode_lru.node);
		WARN_ON(!list_empty(&s->s_mounts));
		security_sb_free(s);
		put_user_ns(s->s_user_ns);
		kfree(s->s_subtype);
		call_rcu(&s->rcu, destroy_super_rcu);
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297 298 299 300 301 302 303 304
	}
}

/**
 *	put_super	-	drop a temporary reference to superblock
 *	@sb: superblock in question
 *
 *	Drops a temporary reference, frees superblock if there's no
 *	references left.
 */
Al Viro's avatar
Al Viro committed
305
static void put_super(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309 310 311 312 313
{
	spin_lock(&sb_lock);
	__put_super(sb);
	spin_unlock(&sb_lock);
}


/**
314
 *	deactivate_locked_super	-	drop an active reference to superblock
Linus Torvalds's avatar
Linus Torvalds committed
315 316
 *	@s: superblock to deactivate
 *
317
 *	Drops an active reference to superblock, converting it into a temporary
318
 *	one if there is no other active references left.  In that case we
Linus Torvalds's avatar
Linus Torvalds committed
319 320
 *	tell fs driver to shut it down and drop the temporary reference we
 *	had just acquired.
321 322
 *
 *	Caller holds exclusive lock on superblock; that lock is released.
Linus Torvalds's avatar
Linus Torvalds committed
323
 */
324
void deactivate_locked_super(struct super_block *s)
Linus Torvalds's avatar
Linus Torvalds committed
325 326
{
	struct file_system_type *fs = s->s_type;
Al Viro's avatar
Al Viro committed
327
	if (atomic_dec_and_test(&s->s_active)) {
328
		cleancache_invalidate_fs(s);
329
		unregister_shrinker(&s->s_shrink);
330
		fs->kill_sb(s);
331

332 333 334 335 336 337 338 339
		/*
		 * Since list_lru_destroy() may sleep, we cannot call it from
		 * put_super(), where we hold the sb_lock. Therefore we destroy
		 * the lru lists right now.
		 */
		list_lru_destroy(&s->s_dentry_lru);
		list_lru_destroy(&s->s_inode_lru);

Linus Torvalds's avatar
Linus Torvalds committed
340 341
		put_filesystem(fs);
		put_super(s);
342 343
	} else {
		up_write(&s->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346
	}
}

347
EXPORT_SYMBOL(deactivate_locked_super);
Linus Torvalds's avatar
Linus Torvalds committed
348

349
/**
350
 *	deactivate_super	-	drop an active reference to superblock
351 352
 *	@s: superblock to deactivate
 *
353 354 355
 *	Variant of deactivate_locked_super(), except that superblock is *not*
 *	locked by caller.  If we are going to drop the final active reference,
 *	lock will be acquired prior to that.
356
 */
357
void deactivate_super(struct super_block *s)
358
{
359 360 361
        if (!atomic_add_unless(&s->s_active, -1, 1)) {
		down_write(&s->s_umount);
		deactivate_locked_super(s);
362 363 364
	}
}

365
EXPORT_SYMBOL(deactivate_super);
366

Linus Torvalds's avatar
Linus Torvalds committed
367 368 369 370 371 372 373 374 375
/**
 *	grab_super - acquire an active reference
 *	@s: reference we are trying to make active
 *
 *	Tries to acquire an active reference.  grab_super() is used when we
 * 	had just found a superblock in super_blocks or fs_type->fs_supers
 *	and want to turn it into a full-blown active reference.  grab_super()
 *	is called with sb_lock held and drops it.  Returns 1 in case of
 *	success, 0 if we had failed (superblock contents was already dead or
Al Viro's avatar
Al Viro committed
376 377 378
 *	dying when grab_super() had been called).  Note that this is only
 *	called for superblocks not in rundown mode (== ones still on ->fs_supers
 *	of their type), so increment of ->s_count is OK here.
Linus Torvalds's avatar
Linus Torvalds committed
379
 */
380
static int grab_super(struct super_block *s) __releases(sb_lock)
Linus Torvalds's avatar
Linus Torvalds committed
381 382 383 384
{
	s->s_count++;
	spin_unlock(&sb_lock);
	down_write(&s->s_umount);
385
	if ((s->s_flags & SB_BORN) && atomic_inc_not_zero(&s->s_active)) {
Al Viro's avatar
Al Viro committed
386 387 388
		put_super(s);
		return 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391 392 393
	up_write(&s->s_umount);
	put_super(s);
	return 0;
}

394
/*
395
 *	trylock_super - try to grab ->s_umount shared
396
 *	@sb: reference we are trying to grab
397
 *
398
 *	Try to prevent fs shutdown.  This is used in places where we
399
 *	cannot take an active reference but we need to ensure that the
400 401 402 403 404 405 406 407 408 409
 *	filesystem is not shut down while we are working on it. It returns
 *	false if we cannot acquire s_umount or if we lose the race and
 *	filesystem already got into shutdown, and returns true with the s_umount
 *	lock held in read mode in case of success. On successful return,
 *	the caller must drop the s_umount lock when done.
 *
 *	Note that unlike get_super() et.al. this one does *not* bump ->s_count.
 *	The reason why it's safe is that we are OK with doing trylock instead
 *	of down_read().  There's a couple of places that are OK with that, but
 *	it's very much not a general-purpose interface.
410
 */
411
bool trylock_super(struct super_block *sb)
412 413
{
	if (down_read_trylock(&sb->s_umount)) {
414
		if (!hlist_unhashed(&sb->s_instances) &&
415
		    sb->s_root && (sb->s_flags & SB_BORN))
416 417 418 419 420 421 422
			return true;
		up_read(&sb->s_umount);
	}

	return false;
}

Linus Torvalds's avatar
Linus Torvalds committed
423 424 425 426 427 428 429 430 431
/**
 *	generic_shutdown_super	-	common helper for ->kill_sb()
 *	@sb: superblock to kill
 *
 *	generic_shutdown_super() does all fs-independent work on superblock
 *	shutdown.  Typical ->kill_sb() should pick all fs-specific objects
 *	that need destruction out of superblock, call generic_shutdown_super()
 *	and release aforementioned objects.  Note: dentries and inodes _are_
 *	taken care of and do not need specific handling.
432 433 434 435
 *
 *	Upon calling this function, the filesystem may no longer alter or
 *	rearrange the set of dentries belonging to this super_block, nor may it
 *	change the attachments of dentries to inodes.
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438
 */
void generic_shutdown_super(struct super_block *sb)
{
439
	const struct super_operations *sop = sb->s_op;
Linus Torvalds's avatar
Linus Torvalds committed
440

441 442
	if (sb->s_root) {
		shrink_dcache_for_umount(sb);
443
		sync_filesystem(sb);
444
		sb->s_flags &= ~SB_ACTIVE;
445

446
		fsnotify_sb_delete(sb);
447
		cgroup_writeback_umount();
Al Viro's avatar
Al Viro committed
448 449

		evict_inodes(sb);
Linus Torvalds's avatar
Linus Torvalds committed
450

451 452 453 454 455
		if (sb->s_dio_done_wq) {
			destroy_workqueue(sb->s_dio_done_wq);
			sb->s_dio_done_wq = NULL;
		}

Linus Torvalds's avatar
Linus Torvalds committed
456 457 458
		if (sop->put_super)
			sop->put_super(sb);

Al Viro's avatar
Al Viro committed
459
		if (!list_empty(&sb->s_inodes)) {
460 461 462
			printk("VFS: Busy inodes after unmount of %s. "
			   "Self-destruct in 5 seconds.  Have a nice day...\n",
			   sb->s_id);
Linus Torvalds's avatar
Linus Torvalds committed
463 464 465 466
		}
	}
	spin_lock(&sb_lock);
	/* should be initialized for __put_super_and_need_restart() */
467
	hlist_del_init(&sb->s_instances);
Linus Torvalds's avatar
Linus Torvalds committed
468 469
	spin_unlock(&sb_lock);
	up_write(&sb->s_umount);
Jan Kara's avatar
Jan Kara committed
470
	if (sb->s_bdi != &noop_backing_dev_info) {
471 472 473
		bdi_put(sb->s_bdi);
		sb->s_bdi = &noop_backing_dev_info;
	}
Linus Torvalds's avatar
Linus Torvalds committed
474 475 476 477 478
}

EXPORT_SYMBOL(generic_shutdown_super);

/**
479
 *	sget_userns -	find or create a superblock
Linus Torvalds's avatar
Linus Torvalds committed
480 481 482
 *	@type:	filesystem type superblock should belong to
 *	@test:	comparison callback
 *	@set:	setup callback
483
 *	@flags:	mount flags
484
 *	@user_ns: User namespace for the super_block
Linus Torvalds's avatar
Linus Torvalds committed
485 486
 *	@data:	argument to each of them
 */
487
struct super_block *sget_userns(struct file_system_type *type,
Linus Torvalds's avatar
Linus Torvalds committed
488 489
			int (*test)(struct super_block *,void *),
			int (*set)(struct super_block *,void *),
490
			int flags, struct user_namespace *user_ns,
Linus Torvalds's avatar
Linus Torvalds committed
491 492 493
			void *data)
{
	struct super_block *s = NULL;
494
	struct super_block *old;
Linus Torvalds's avatar
Linus Torvalds committed
495 496
	int err;

497
	if (!(flags & (SB_KERNMOUNT|SB_SUBMOUNT)) &&
498 499 500
	    !(type->fs_flags & FS_USERNS_MOUNT) &&
	    !capable(CAP_SYS_ADMIN))
		return ERR_PTR(-EPERM);
Linus Torvalds's avatar
Linus Torvalds committed
501 502
retry:
	spin_lock(&sb_lock);
503
	if (test) {
504
		hlist_for_each_entry(old, &type->fs_supers, s_instances) {
505 506
			if (!test(old, data))
				continue;
507 508
			if (user_ns != old->s_user_ns) {
				spin_unlock(&sb_lock);
509
				destroy_unused_super(s);
510 511
				return ERR_PTR(-EBUSY);
			}
512 513
			if (!grab_super(old))
				goto retry;
514
			destroy_unused_super(s);
515 516
			return old;
		}
Linus Torvalds's avatar
Linus Torvalds committed
517 518 519
	}
	if (!s) {
		spin_unlock(&sb_lock);
520
		s = alloc_super(type, (flags & ~SB_SUBMOUNT), user_ns);
Linus Torvalds's avatar
Linus Torvalds committed
521 522 523 524
		if (!s)
			return ERR_PTR(-ENOMEM);
		goto retry;
	}
525

Linus Torvalds's avatar
Linus Torvalds committed
526 527 528
	err = set(s, data);
	if (err) {
		spin_unlock(&sb_lock);
529
		destroy_unused_super(s);
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532 533 534
		return ERR_PTR(err);
	}
	s->s_type = type;
	strlcpy(s->s_id, type->name, sizeof(s->s_id));
	list_add_tail(&s->s_list, &super_blocks);
535
	hlist_add_head(&s->s_instances, &type->fs_supers);
Linus Torvalds's avatar
Linus Torvalds committed
536 537
	spin_unlock(&sb_lock);
	get_filesystem(type);
538
	register_shrinker_prepared(&s->s_shrink);
Linus Torvalds's avatar
Linus Torvalds committed
539 540 541
	return s;
}

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
EXPORT_SYMBOL(sget_userns);

/**
 *	sget	-	find or create a superblock
 *	@type:	  filesystem type superblock should belong to
 *	@test:	  comparison callback
 *	@set:	  setup callback
 *	@flags:	  mount flags
 *	@data:	  argument to each of them
 */
struct super_block *sget(struct file_system_type *type,
			int (*test)(struct super_block *,void *),
			int (*set)(struct super_block *,void *),
			int flags,
			void *data)
{
	struct user_namespace *user_ns = current_user_ns();

560 561 562 563
	/* We don't yet pass the user namespace of the parent
	 * mount through to here so always use &init_user_ns
	 * until that changes.
	 */
564
	if (flags & SB_SUBMOUNT)
565 566
		user_ns = &init_user_ns;

567
	/* Ensure the requestor has permissions over the target filesystem */
568
	if (!(flags & (SB_KERNMOUNT|SB_SUBMOUNT)) && !ns_capable(user_ns, CAP_SYS_ADMIN))
569 570 571 572 573
		return ERR_PTR(-EPERM);

	return sget_userns(type, test, set, flags, user_ns, data);
}

Linus Torvalds's avatar
Linus Torvalds committed
574 575 576 577 578 579 580 581 582 583
EXPORT_SYMBOL(sget);

void drop_super(struct super_block *sb)
{
	up_read(&sb->s_umount);
	put_super(sb);
}

EXPORT_SYMBOL(drop_super);

584 585 586 587 588 589 590
void drop_super_exclusive(struct super_block *sb)
{
	up_write(&sb->s_umount);
	put_super(sb);
}
EXPORT_SYMBOL(drop_super_exclusive);

591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
static void __iterate_supers(void (*f)(struct super_block *))
{
	struct super_block *sb, *p = NULL;

	spin_lock(&sb_lock);
	list_for_each_entry(sb, &super_blocks, s_list) {
		if (hlist_unhashed(&sb->s_instances))
			continue;
		sb->s_count++;
		spin_unlock(&sb_lock);

		f(sb);

		spin_lock(&sb_lock);
		if (p)
			__put_super(p);
		p = sb;
	}
	if (p)
		__put_super(p);
	spin_unlock(&sb_lock);
}
Al Viro's avatar
Al Viro committed
613 614 615 616 617 618 619 620 621 622
/**
 *	iterate_supers - call function for all active superblocks
 *	@f: function to call
 *	@arg: argument to pass to it
 *
 *	Scans the superblock list and calls given function, passing it
 *	locked superblock and given argument.
 */
void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
{
623
	struct super_block *sb, *p = NULL;
Al Viro's avatar
Al Viro committed
624 625

	spin_lock(&sb_lock);
626
	list_for_each_entry(sb, &super_blocks, s_list) {
627
		if (hlist_unhashed(&sb->s_instances))
Al Viro's avatar
Al Viro committed
628 629 630 631 632
			continue;
		sb->s_count++;
		spin_unlock(&sb_lock);

		down_read(&sb->s_umount);
633
		if (sb->s_root && (sb->s_flags & SB_BORN))
Al Viro's avatar
Al Viro committed
634 635 636 637
			f(sb, arg);
		up_read(&sb->s_umount);

		spin_lock(&sb_lock);
638 639 640
		if (p)
			__put_super(p);
		p = sb;
Al Viro's avatar
Al Viro committed
641
	}
642 643
	if (p)
		__put_super(p);
Al Viro's avatar
Al Viro committed
644 645 646
	spin_unlock(&sb_lock);
}

647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
/**
 *	iterate_supers_type - call function for superblocks of given type
 *	@type: fs type
 *	@f: function to call
 *	@arg: argument to pass to it
 *
 *	Scans the superblock list and calls given function, passing it
 *	locked superblock and given argument.
 */
void iterate_supers_type(struct file_system_type *type,
	void (*f)(struct super_block *, void *), void *arg)
{
	struct super_block *sb, *p = NULL;

	spin_lock(&sb_lock);
662
	hlist_for_each_entry(sb, &type->fs_supers, s_instances) {
663 664 665 666
		sb->s_count++;
		spin_unlock(&sb_lock);

		down_read(&sb->s_umount);
667
		if (sb->s_root && (sb->s_flags & SB_BORN))
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
			f(sb, arg);
		up_read(&sb->s_umount);

		spin_lock(&sb_lock);
		if (p)
			__put_super(p);
		p = sb;
	}
	if (p)
		__put_super(p);
	spin_unlock(&sb_lock);
}

EXPORT_SYMBOL(iterate_supers_type);

683
static struct super_block *__get_super(struct block_device *bdev, bool excl)
Linus Torvalds's avatar
Linus Torvalds committed
684
{
685 686
	struct super_block *sb;

Linus Torvalds's avatar
Linus Torvalds committed
687 688
	if (!bdev)
		return NULL;
689

Linus Torvalds's avatar
Linus Torvalds committed
690
	spin_lock(&sb_lock);
691 692
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
693
		if (hlist_unhashed(&sb->s_instances))
694
			continue;
695 696
		if (sb->s_bdev == bdev) {
			sb->s_count++;
Linus Torvalds's avatar
Linus Torvalds committed
697
			spin_unlock(&sb_lock);
698 699 700 701
			if (!excl)
				down_read(&sb->s_umount);
			else
				down_write(&sb->s_umount);
702
			/* still alive? */
703
			if (sb->s_root && (sb->s_flags & SB_BORN))
704
				return sb;
705 706 707 708
			if (!excl)
				up_read(&sb->s_umount);
			else
				up_write(&sb->s_umount);
709
			/* nope, got unmounted */
710
			spin_lock(&sb_lock);
711 712
			__put_super(sb);
			goto rescan;
Linus Torvalds's avatar
Linus Torvalds committed
713 714 715 716 717 718
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

719
/**
720
 *	get_super - get the superblock of a device
721 722 723
 *	@bdev: device to get the superblock for
 *
 *	Scans the superblock list and finds the superblock of the file system
724
 *	mounted on the device given. %NULL is returned if no match is found.
725
 */
726 727 728 729 730 731 732 733
struct super_block *get_super(struct block_device *bdev)
{
	return __get_super(bdev, false);
}
EXPORT_SYMBOL(get_super);

static struct super_block *__get_super_thawed(struct block_device *bdev,
					      bool excl)
734 735
{
	while (1) {
736
		struct super_block *s = __get_super(bdev, excl);
737
		if (!s || s->s_writers.frozen == SB_UNFROZEN)
738
			return s;
739 740 741 742
		if (!excl)
			up_read(&s->s_umount);
		else
			up_write(&s->s_umount);
743 744
		wait_event(s->s_writers.wait_unfrozen,
			   s->s_writers.frozen == SB_UNFROZEN);
745 746 747
		put_super(s);
	}
}
748 749 750 751 752 753 754 755 756 757 758 759 760 761

/**
 *	get_super_thawed - get thawed superblock of a device
 *	@bdev: device to get the superblock for
 *
 *	Scans the superblock list and finds the superblock of the file system
 *	mounted on the device. The superblock is returned once it is thawed
 *	(or immediately if it was not frozen). %NULL is returned if no match
 *	is found.
 */
struct super_block *get_super_thawed(struct block_device *bdev)
{
	return __get_super_thawed(bdev, false);
}
762 763
EXPORT_SYMBOL(get_super_thawed);

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
/**
 *	get_super_exclusive_thawed - get thawed superblock of a device
 *	@bdev: device to get the superblock for
 *
 *	Scans the superblock list and finds the superblock of the file system
 *	mounted on the device. The superblock is returned once it is thawed
 *	(or immediately if it was not frozen) and s_umount semaphore is held
 *	in exclusive mode. %NULL is returned if no match is found.
 */
struct super_block *get_super_exclusive_thawed(struct block_device *bdev)
{
	return __get_super_thawed(bdev, true);
}
EXPORT_SYMBOL(get_super_exclusive_thawed);

779 780 781 782 783 784
/**
 * get_active_super - get an active reference to the superblock of a device
 * @bdev: device to get the superblock for
 *
 * Scans the superblock list and finds the superblock of the file system
 * mounted on the device given.  Returns the superblock with an active
785
 * reference or %NULL if none was found.
786 787 788 789 790 791 792 793
 */
struct super_block *get_active_super(struct block_device *bdev)
{
	struct super_block *sb;

	if (!bdev)
		return NULL;

794
restart:
795 796
	spin_lock(&sb_lock);
	list_for_each_entry(sb, &super_blocks, s_list) {
797
		if (hlist_unhashed(&sb->s_instances))
798
			continue;
799
		if (sb->s_bdev == bdev) {
Al Viro's avatar
Al Viro committed
800
			if (!grab_super(sb))
801
				goto restart;
Al Viro's avatar
Al Viro committed
802 803
			up_write(&sb->s_umount);
			return sb;
804
		}
805 806 807 808
	}
	spin_unlock(&sb_lock);
	return NULL;
}
809

810
struct super_block *user_get_super(dev_t dev)
Linus Torvalds's avatar
Linus Torvalds committed
811
{
812
	struct super_block *sb;
Linus Torvalds's avatar
Linus Torvalds committed
813 814

	spin_lock(&sb_lock);
815 816
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
817
		if (hlist_unhashed(&sb->s_instances))
818
			continue;
819 820
		if (sb->s_dev ==  dev) {
			sb->s_count++;
Linus Torvalds's avatar
Linus Torvalds committed
821
			spin_unlock(&sb_lock);
822
			down_read(&sb->s_umount);
823
			/* still alive? */
824
			if (sb->s_root && (sb->s_flags & SB_BORN))
825 826
				return sb;
			up_read(&sb->s_umount);
827
			/* nope, got unmounted */
828
			spin_lock(&sb_lock);
829 830
			__put_super(sb);
			goto rescan;
Linus Torvalds's avatar
Linus Torvalds committed
831 832 833 834 835 836 837 838 839
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

/**
 *	do_remount_sb - asks filesystem to change mount options.
 *	@sb:	superblock in question
840
 *	@sb_flags: revised superblock flags
Linus Torvalds's avatar
Linus Torvalds committed
841 842 843 844 845
 *	@data:	the rest of options
 *      @force: whether or not to force the change
 *
 *	Alters the mount options of a mounted file system.
 */
846
int do_remount_sb(struct super_block *sb, int sb_flags, void *data, int force)
Linus Torvalds's avatar
Linus Torvalds committed
847 848
{
	int retval;
849
	int remount_ro;
850

851
	if (sb->s_writers.frozen != SB_UNFROZEN)
852 853
		return -EBUSY;

854
#ifdef CONFIG_BLOCK
855
	if (!(sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev))
Linus Torvalds's avatar
Linus Torvalds committed
856
		return -EACCES;
857
#endif
858

859
	remount_ro = (sb_flags & SB_RDONLY) && !sb_rdonly(sb);
860

861
	if (remount_ro) {
862
		if (!hlist_empty(&sb->s_pins)) {
863
			up_write(&sb->s_umount);
864
			group_pin_kill(&sb->s_pins);
865 866 867 868 869
			down_write(&sb->s_umount);
			if (!sb->s_root)
				return 0;
			if (sb->s_writers.frozen != SB_UNFROZEN)
				return -EBUSY;
870
			remount_ro = (sb_flags & SB_RDONLY) && !sb_rdonly(sb);
871 872 873 874
		}
	}
	shrink_dcache_sb(sb);

Linus Torvalds's avatar
Linus Torvalds committed
875 876
	/* If we are remounting RDONLY and current sb is read/write,
	   make sure there are no rw files opened */
877
	if (remount_ro) {
878
		if (force) {
879 880
			sb->s_readonly_remount = 1;
			smp_wmb();
881 882 883 884 885
		} else {
			retval = sb_prepare_remount_readonly(sb);
			if (retval)
				return retval;
		}
Linus Torvalds's avatar
Linus Torvalds committed
886 887 888
	}

	if (sb->s_op->remount_fs) {
889
		retval = sb->s_op->remount_fs(sb, &sb_flags, data);
890 891
		if (retval) {
			if (!force)
892
				goto cancel_readonly;
893 894 895 896
			/* If forced remount, go ahead despite any errors */
			WARN(1, "forced remount of a %s fs returned %i\n",
			     sb->s_type->name, retval);
		}
Linus Torvalds's avatar
Linus Torvalds committed
897
	}
898
	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (sb_flags & MS_RMT_MASK);
899 900 901
	/* Needs to be ordered wrt mnt_is_readonly() */
	smp_wmb();
	sb->s_readonly_remount = 0;
902

903 904 905 906 907 908 909 910 911 912
	/*
	 * Some filesystems modify their metadata via some other path than the
	 * bdev buffer cache (eg. use a private mapping, or directories in
	 * pagecache, etc). Also file data modifications go via their own
	 * mappings. So If we try to mount readonly then copy the filesystem
	 * from bdev, we could get stale data, so invalidate it to give a best
	 * effort at coherency.
	 */
	if (remount_ro && sb->s_bdev)
		invalidate_bdev(sb->s_bdev);
Linus Torvalds's avatar
Linus Torvalds committed
913
	return 0;
914 915 916 917

cancel_readonly:
	sb->s_readonly_remount = 0;
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
918 919
}

920
static void do_emergency_remount_callback(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
921
{
922 923 924 925 926 927 928
	down_write(&sb->s_umount);
	if (sb->s_root && sb->s_bdev && (sb->s_flags & SB_BORN) &&
	    !sb_rdonly(sb)) {
		/*
		 * What lock protects sb->s_flags??
		 */
		do_remount_sb(sb, SB_RDONLY, NULL, 1);
Linus Torvalds's avatar
Linus Torvalds committed
929
	}
930 931 932 933 934 935
	up_write(&sb->s_umount);
}

static void do_emergency_remount(struct work_struct *work)
{
	__iterate_supers(do_emergency_remount_callback);
936
	kfree(work);
Linus Torvalds's avatar
Linus Torvalds committed
937 938 939 940 941
	printk("Emergency Remount complete\n");
}

void emergency_remount(void)
{
942 943 944 945 946 947 948
	struct work_struct *work;

	work = kmalloc(sizeof(*work), GFP_ATOMIC);
	if (work) {
		INIT_WORK(work, do_emergency_remount);
		schedule_work(work);
	}
Linus Torvalds's avatar
Linus Torvalds committed
949 950
}

951 952 953
static void do_thaw_all_callback(struct super_block *sb)
{
	down_write(&sb->s_umount);
Al Viro's avatar
Al Viro committed
954
	if (sb->s_root && sb->s_flags & SB_BORN) {
955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
		emergency_thaw_bdev(sb);
		thaw_super_locked(sb);
	} else {
		up_write(&sb->s_umount);
	}
}

static void do_thaw_all(struct work_struct *work)
{
	__iterate_supers(do_thaw_all_callback);
	kfree(work);
	printk(KERN_WARNING "Emergency Thaw complete\n");
}

/**
 * emergency_thaw_all -- forcibly thaw every frozen filesystem
 *
 * Used for emergency unfreeze of all filesystems via SysRq
 */
void emergency_thaw_all(void)
{
	struct work_struct *work;

	work = kmalloc(sizeof(*work), GFP_ATOMIC);
	if (work) {
		INIT_WORK(work, do_thaw_all);
		schedule_work(work);
	}
}

985
static DEFINE_IDA(unnamed_dev_ida);
Linus Torvalds's avatar
Linus Torvalds committed
986

987 988 989 990 991 992 993 994 995 996 997
/**
 * get_anon_bdev - Allocate a block device for filesystems which don't have one.
 * @p: Pointer to a dev_t.
 *
 * Filesystems which don't use real block devices can call this function
 * to allocate a virtual block device.
 *
 * Context: Any context.  Frequently called while holding sb_lock.
 * Return: 0 on success, -EMFILE if there are no anonymous bdevs left
 * or -ENOMEM if memory allocation failed.
 */
998
int get_anon_bdev(dev_t *p)
Linus Torvalds's avatar
Linus Torvalds committed
999 1000
{
	int dev;
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013

	/*
	 * Many userspace utilities consider an FSID of 0 invalid.
	 * Always return at least 1 from get_anon_bdev.
	 */
	dev = ida_alloc_range(&unnamed_dev_ida, 1, (1 << MINORBITS) - 1,
			GFP_ATOMIC);
	if (dev == -ENOSPC)
		dev = -EMFILE;
	if (dev < 0)
		return dev;

	*p = MKDEV(0, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1014 1015
	return 0;
}
1016
EXPORT_SYMBOL(get_anon_bdev);
Linus Torvalds's avatar
Linus Torvalds committed
1017

1018
void free_anon_bdev(dev_t dev)
Linus Torvalds's avatar
Linus Torvalds committed
1019
{
1020
	ida_free(&unnamed_dev_ida, MINOR(dev));
Linus Torvalds's avatar
Linus Torvalds committed
1021
}
1022 1023 1024 1025
EXPORT_SYMBOL(free_anon_bdev);

int set_anon_super(struct super_block *s, void *data)
{
1026
	return get_anon_bdev(&s->s_dev);
1027 1028 1029 1030 1031 1032 1033 1034 1035
}
EXPORT_SYMBOL(set_anon_super);

void kill_anon_super(struct super_block *sb)
{
	dev_t dev = sb->s_dev;
	generic_shutdown_super(sb);
	free_anon_bdev(dev);
}
Linus Torvalds's avatar
Linus Torvalds committed
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
EXPORT_SYMBOL(kill_anon_super);

void kill_litter_super(struct super_block *sb)
{
	if (sb->s_root)
		d_genocide(sb->s_root);
	kill_anon_super(sb);
}
EXPORT_SYMBOL(kill_litter_super);

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
static int ns_test_super(struct super_block *sb, void *data)
{
	return sb->s_fs_info == data;
}

static int ns_set_super(struct super_block *sb, void *data)
{
	sb->s_fs_info = data;
	return set_anon_super(sb, NULL);
}

1057 1058 1059
struct dentry *mount_ns(struct file_system_type *fs_type,
	int flags, void *data, void *ns, struct user_namespace *user_ns,
	int (*fill_super)(struct super_block *, void *, int))
1060 1061 1062
{
	struct super_block *sb;

1063 1064 1065
	/* Don't allow mounting unless the caller has CAP_SYS_ADMIN
	 * over the namespace.
	 */
1066
	if (!(flags & SB_KERNMOUNT) && !ns_capable(user_ns, CAP_SYS_ADMIN))
1067 1068
		return ERR_PTR(-EPERM);

1069 1070
	sb = sget_userns(fs_type, ns_test_super, ns_set_super, flags,
			 user_ns, ns);
1071
	if (IS_ERR(sb))
Al Viro's avatar
Al Viro committed
1072
		return ERR_CAST(sb);
1073 1074 1075

	if (!sb->s_root) {
		int err;
1076
		err = fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
1077
		if (err) {
1078
			deactivate_locked_super(sb);
Al Viro's avatar
Al Viro committed
1079
			return ERR_PTR(err);
1080 1081
		}

1082
		sb->s_flags |= SB_ACTIVE;
1083 1084
	}

Al Viro's avatar
Al Viro committed
1085
	return dget(sb->s_root);
1086 1087
}

Al Viro's avatar
Al Viro committed
1088
EXPORT_SYMBOL(mount_ns);
1089

1090
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092 1093 1094
static int set_bdev_super(struct super_block *s, void *data)
{
	s->s_bdev = data;
	s->s_dev = s->s_bdev->bd_dev;
1095
	s->s_bdi = bdi_get(s->s_bdev->bd_bdi);
1096

Linus Torvalds's avatar
Linus Torvalds committed
1097 1098 1099 1100 1101 1102 1103 1104
	return 0;
}

static int test_bdev_super(struct super_block *s, void *data)
{
	return (void *)s->s_bdev == data;
}

Al Viro's avatar
Al Viro committed
1105
struct dentry *mount_bdev(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
1106
	int flags, const char *dev_name, void *data,
Al Viro's avatar
Al Viro committed
1107
	int (*fill_super)(struct super_block *, void *, int))
Linus Torvalds's avatar
Linus Torvalds committed
1108 1109 1110
{
	struct block_device *bdev;
	struct super_block *s;
1111
	fmode_t mode = FMODE_READ | FMODE_EXCL;
Linus Torvalds's avatar
Linus Torvalds committed
1112 1113
	int error = 0;

1114
	if (!(flags & SB_RDONLY))
1115 1116
		mode |= FMODE_WRITE;

1117
	bdev = blkdev_get_by_path(dev_name, mode, fs_type);
Linus Torvalds's avatar
Linus Torvalds committed
1118
	if (IS_ERR(bdev))
Al Viro's avatar
Al Viro committed
1119
		return ERR_CAST(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
1120 1121 1122 1123 1124 1125

	/*
	 * once the super is inserted into the list by sget, s_umount
	 * will protect the lockfs code from trying to start a snapshot
	 * while we are mounting
	 */
1126 1127 1128 1129 1130 1131
	mutex_lock(&bdev->bd_fsfreeze_mutex);
	if (bdev->bd_fsfreeze_count > 0) {
		mutex_unlock(&bdev->bd_fsfreeze_mutex);
		error = -EBUSY;
		goto error_bdev;
	}
1132
	s = sget(fs_type, test_bdev_super, set_bdev_super, flags | SB_NOSEC,
1133
		 bdev);
1134
	mutex_unlock(&bdev->bd_fsfreeze_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1135
	if (IS_ERR(s))
1136
		goto error_s;
Linus Torvalds's avatar
Linus Torvalds committed
1137 1138

	if (s->s_root) {
1139
		if ((flags ^ s->s_flags) & SB_RDONLY) {
1140
			deactivate_locked_super(s);
1141 1142
			error = -EBUSY;
			goto error_bdev;
Linus Torvalds's avatar
Linus Torvalds committed
1143
		}
1144

1145 1146
		/*
		 * s_umount nests inside bd_mutex during
1147 1148 1149 1150
		 * __invalidate_device().  blkdev_put() acquires
		 * bd_mutex and can't be called under s_umount.  Drop
		 * s_umount temporarily.  This is safe as we're
		 * holding an active reference.
1151 1152
		 */
		up_write(&s->s_umount);
1153
		blkdev_put(bdev, mode);
1154
		down_write(&s->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
1155
	} else {
1156
		s->s_mode = mode;
1157
		snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1158
		sb_set_blocksize(s, block_size(bdev));
1159
		error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1160
		if (error) {
1161
			deactivate_locked_super(s);
1162
			goto error;
1163
		}
1164

1165
		s->s_flags |= SB_ACTIVE;
1166
		bdev->bd_super = s;
Linus Torvalds's avatar
Linus Torvalds committed
1167 1168
	}

Al Viro's avatar
Al Viro committed
1169
	return dget(s->s_root);
Linus Torvalds's avatar
Linus Torvalds committed
1170

1171 1172 1173
error_s:
	error = PTR_ERR(s);
error_bdev:
1174
	blkdev_put(bdev, mode);
1175
error:
Al Viro's avatar
Al Viro committed
1176 1177 1178 1179
	return ERR_PTR(error);
}
EXPORT_SYMBOL(mount_bdev);

Linus Torvalds's avatar
Linus Torvalds committed
1180 1181 1182
void kill_block_super(struct super_block *sb)
{
	struct block_device *bdev = sb->s_bdev;
1183
	fmode_t mode = sb->s_mode;
Linus Torvalds's avatar
Linus Torvalds committed
1184

1185
	bdev->bd_super = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1186 1187
	generic_shutdown_super(sb);
	sync_blockdev(bdev);
1188
	WARN_ON_ONCE(!(mode & FMODE_EXCL));
1189
	blkdev_put(bdev, mode | FMODE_EXCL);
Linus Torvalds's avatar
Linus Torvalds committed
1190 1191 1192
}

EXPORT_SYMBOL(kill_block_super);
1193
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1194

Al Viro's avatar
Al Viro committed
1195
struct dentry *mount_nodev(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
1196
	int flags, void *data,
Al Viro's avatar
Al Viro committed
1197
	int (*fill_super)(struct super_block *, void *, int))
Linus Torvalds's avatar
Linus Torvalds committed
1198 1199
{
	int error;
1200
	struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202

	if (IS_ERR(s))
Al Viro's avatar
Al Viro committed
1203
		return ERR_CAST(s);
Linus Torvalds's avatar
Linus Torvalds committed
1204

1205
	error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1206
	if (error) {
1207
		deactivate_locked_super(s);
Al Viro's avatar
Al Viro committed
1208
		return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
1209
	}
1210
	s->s_flags |= SB_ACTIVE;
Al Viro's avatar
Al Viro committed
1211
	return dget(s->s_root);
Linus Torvalds's avatar
Linus Torvalds committed
1212
}
Al Viro's avatar
Al Viro committed
1213 1214
EXPORT_SYMBOL(mount_nodev);

Linus Torvalds's avatar
Linus Torvalds committed
1215 1216 1217 1218 1219
static int compare_single(struct super_block *s, void *p)
{
	return 1;
}

Al Viro's avatar
Al Viro committed
1220
struct dentry *mount_single(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
1221
	int flags, void *data,
Al Viro's avatar
Al Viro committed
1222
	int (*fill_super)(struct super_block *, void *, int))
Linus Torvalds's avatar
Linus Torvalds committed
1223 1224 1225 1226
{
	struct super_block *s;
	int error;

1227
	s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
1228
	if (IS_ERR(s))
Al Viro's avatar
Al Viro committed
1229
		return ERR_CAST(s);
Linus Torvalds's avatar
Linus Torvalds committed
1230
	if (!s->s_root) {
1231
		error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1232
		if (error) {
1233
			deactivate_locked_super(s);
Al Viro's avatar
Al Viro committed
1234
			return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
1235
		}
1236
		s->s_flags |= SB_ACTIVE;
1237 1238
	} else {
		do_remount_sb(s, flags, data, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1239
	}
Al Viro's avatar
Al Viro committed
1240 1241 1242 1243
	return dget(s->s_root);
}
EXPORT_SYMBOL(mount_single);

1244 1245
struct dentry *
mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
1246
{
1247
	struct dentry *root;
1248 1249
	struct super_block *sb;
	int error = -ENOMEM;
1250
	void *sec_opts = NULL;
1251

1252
	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
1253
		error = security_sb_eat_lsm_opts(data, &sec_opts);
1254
		if (error)
1255
			return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
1256 1257
	}