super.c 28.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 *  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:
18
 *    Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
L
Linus Torvalds 已提交
19 20 21 22 23 24 25 26 27 28 29 30
 *  Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
 *  Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/acct.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>
I
Ingo Molnar 已提交
31
#include <linux/mutex.h>
32
#include <linux/backing-dev.h>
33
#include <linux/rculist_bl.h>
34
#include <linux/cleancache.h>
35
#include "internal.h"
L
Linus Torvalds 已提交
36 37 38 39 40


LIST_HEAD(super_blocks);
DEFINE_SPINLOCK(sb_lock);

41 42 43 44 45 46 47 48 49 50
/*
 * 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.
 */
static int prune_super(struct shrinker *shrink, struct shrink_control *sc)
{
	struct super_block *sb;
51 52
	int	fs_objects = 0;
	int	total_objects;
53 54 55 56 57 58 59 60 61 62 63

	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..
	 */
	if (sc->nr_to_scan && !(sc->gfp_mask & __GFP_FS))
		return -1;

	if (!grab_super_passive(sb))
64
		return !sc->nr_to_scan ? 0 : -1;
65

66 67 68 69 70 71
	if (sb->s_op && sb->s_op->nr_cached_objects)
		fs_objects = sb->s_op->nr_cached_objects(sb);

	total_objects = sb->s_nr_dentry_unused +
			sb->s_nr_inodes_unused + fs_objects + 1;

72
	if (sc->nr_to_scan) {
73 74
		int	dentries;
		int	inodes;
75

76 77 78 79 80 81 82 83 84 85 86 87 88 89
		/* proportion the scan between the caches */
		dentries = (sc->nr_to_scan * sb->s_nr_dentry_unused) /
							total_objects;
		inodes = (sc->nr_to_scan * sb->s_nr_inodes_unused) /
							total_objects;
		if (fs_objects)
			fs_objects = (sc->nr_to_scan * fs_objects) /
							total_objects;
		/*
		 * prune the dcache first as the icache is pinned by it, then
		 * prune the icache, followed by the filesystem specific caches
		 */
		prune_dcache_sb(sb, dentries);
		prune_icache_sb(sb, inodes);
90

91 92 93 94 95 96
		if (fs_objects && sb->s_op->free_cached_objects) {
			sb->s_op->free_cached_objects(sb, fs_objects);
			fs_objects = sb->s_op->nr_cached_objects(sb);
		}
		total_objects = sb->s_nr_dentry_unused +
				sb->s_nr_inodes_unused + fs_objects;
97 98
	}

99
	total_objects = (total_objects / 100) * sysctl_vfs_cache_pressure;
100
	drop_super(sb);
101
	return total_objects;
102 103
}

L
Linus Torvalds 已提交
104 105
/**
 *	alloc_super	-	create new superblock
106
 *	@type:	filesystem type superblock should belong to
L
Linus Torvalds 已提交
107 108 109 110
 *
 *	Allocates and initializes a new &struct super_block.  alloc_super()
 *	returns a pointer new superblock or %NULL if allocation had failed.
 */
I
Ingo Molnar 已提交
111
static struct super_block *alloc_super(struct file_system_type *type)
L
Linus Torvalds 已提交
112
{
113
	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
114
	static const struct super_operations default_op;
L
Linus Torvalds 已提交
115 116 117 118 119 120 121

	if (s) {
		if (security_sb_alloc(s)) {
			kfree(s);
			s = NULL;
			goto out;
		}
N
Nick Piggin 已提交
122 123 124 125 126 127 128 129 130 131 132 133 134 135
#ifdef CONFIG_SMP
		s->s_files = alloc_percpu(struct list_head);
		if (!s->s_files) {
			security_sb_free(s);
			kfree(s);
			s = NULL;
			goto out;
		} else {
			int i;

			for_each_possible_cpu(i)
				INIT_LIST_HEAD(per_cpu_ptr(s->s_files, i));
		}
#else
L
Linus Torvalds 已提交
136
		INIT_LIST_HEAD(&s->s_files);
N
Nick Piggin 已提交
137
#endif
138
		s->s_bdi = &default_backing_dev_info;
L
Linus Torvalds 已提交
139
		INIT_LIST_HEAD(&s->s_instances);
140
		INIT_HLIST_BL_HEAD(&s->s_anon);
L
Linus Torvalds 已提交
141
		INIT_LIST_HEAD(&s->s_inodes);
142
		INIT_LIST_HEAD(&s->s_dentry_lru);
143
		INIT_LIST_HEAD(&s->s_inode_lru);
D
Dave Chinner 已提交
144
		spin_lock_init(&s->s_inode_lru_lock);
L
Linus Torvalds 已提交
145
		init_rwsem(&s->s_umount);
146
		mutex_init(&s->s_lock);
147
		lockdep_set_class(&s->s_umount, &type->s_umount_key);
I
Ingo Molnar 已提交
148 149 150 151 152 153
		/*
		 * The locking rules for s_lock are up to the
		 * filesystem. For example ext3fs has different
		 * lock ordering than usbfs:
		 */
		lockdep_set_class(&s->s_lock, &type->s_lock_key);
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
		/*
		 * 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);
A
Al Viro 已提交
170
		s->s_count = 1;
L
Linus Torvalds 已提交
171
		atomic_set(&s->s_active, 1);
172
		mutex_init(&s->s_vfs_rename_mutex);
173
		lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
I
Ingo Molnar 已提交
174 175
		mutex_init(&s->s_dquot.dqio_mutex);
		mutex_init(&s->s_dquot.dqonoff_mutex);
L
Linus Torvalds 已提交
176 177 178 179 180
		init_rwsem(&s->s_dquot.dqptr_sem);
		init_waitqueue_head(&s->s_wait_unfrozen);
		s->s_maxbytes = MAX_NON_LFS;
		s->s_op = &default_op;
		s->s_time_gran = 1000000000;
181
		s->cleancache_poolid = -1;
182 183 184

		s->s_shrink.seeks = DEFAULT_SEEKS;
		s->s_shrink.shrink = prune_super;
D
Dave Chinner 已提交
185
		s->s_shrink.batch = 1024;
L
Linus Torvalds 已提交
186 187 188 189 190 191 192 193 194 195 196 197 198
	}
out:
	return s;
}

/**
 *	destroy_super	-	frees a superblock
 *	@s: superblock to free
 *
 *	Frees a superblock.
 */
static inline void destroy_super(struct super_block *s)
{
N
Nick Piggin 已提交
199 200 201
#ifdef CONFIG_SMP
	free_percpu(s->s_files);
#endif
L
Linus Torvalds 已提交
202
	security_sb_free(s);
M
Miklos Szeredi 已提交
203
	kfree(s->s_subtype);
204
	kfree(s->s_options);
L
Linus Torvalds 已提交
205 206 207 208 209 210
	kfree(s);
}

/* Superblock refcounting  */

/*
A
Al Viro 已提交
211
 * Drop a superblock's refcount.  The caller must hold sb_lock.
L
Linus Torvalds 已提交
212
 */
A
Al Viro 已提交
213
void __put_super(struct super_block *sb)
L
Linus Torvalds 已提交
214 215
{
	if (!--sb->s_count) {
216
		list_del_init(&sb->s_list);
L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224 225 226 227
		destroy_super(sb);
	}
}

/**
 *	put_super	-	drop a temporary reference to superblock
 *	@sb: superblock in question
 *
 *	Drops a temporary reference, frees superblock if there's no
 *	references left.
 */
228
void put_super(struct super_block *sb)
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236
{
	spin_lock(&sb_lock);
	__put_super(sb);
	spin_unlock(&sb_lock);
}


/**
237
 *	deactivate_locked_super	-	drop an active reference to superblock
L
Linus Torvalds 已提交
238 239
 *	@s: superblock to deactivate
 *
240 241
 *	Drops an active reference to superblock, converting it into a temprory
 *	one if there is no other active references left.  In that case we
L
Linus Torvalds 已提交
242 243
 *	tell fs driver to shut it down and drop the temporary reference we
 *	had just acquired.
244 245
 *
 *	Caller holds exclusive lock on superblock; that lock is released.
L
Linus Torvalds 已提交
246
 */
247
void deactivate_locked_super(struct super_block *s)
L
Linus Torvalds 已提交
248 249
{
	struct file_system_type *fs = s->s_type;
A
Al Viro 已提交
250
	if (atomic_dec_and_test(&s->s_active)) {
251
		cleancache_flush_fs(s);
L
Linus Torvalds 已提交
252
		fs->kill_sb(s);
253 254 255 256

		/* caches are now gone, we can safely kill the shrinker now */
		unregister_shrinker(&s->s_shrink);

257 258 259 260 261
		/*
		 * We need to call rcu_barrier so all the delayed rcu free
		 * inodes are flushed before we release the fs module.
		 */
		rcu_barrier();
L
Linus Torvalds 已提交
262 263
		put_filesystem(fs);
		put_super(s);
264 265
	} else {
		up_write(&s->s_umount);
L
Linus Torvalds 已提交
266 267 268
	}
}

269
EXPORT_SYMBOL(deactivate_locked_super);
L
Linus Torvalds 已提交
270

A
Al Viro 已提交
271
/**
272
 *	deactivate_super	-	drop an active reference to superblock
A
Al Viro 已提交
273 274
 *	@s: superblock to deactivate
 *
275 276 277
 *	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.
A
Al Viro 已提交
278
 */
279
void deactivate_super(struct super_block *s)
A
Al Viro 已提交
280
{
281 282 283
        if (!atomic_add_unless(&s->s_active, -1, 1)) {
		down_write(&s->s_umount);
		deactivate_locked_super(s);
A
Al Viro 已提交
284 285 286
	}
}

287
EXPORT_SYMBOL(deactivate_super);
A
Al Viro 已提交
288

L
Linus Torvalds 已提交
289 290 291 292 293 294 295 296 297 298 299
/**
 *	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
 *	dying when grab_super() had been called).
 */
300
static int grab_super(struct super_block *s) __releases(sb_lock)
L
Linus Torvalds 已提交
301
{
A
Al Viro 已提交
302 303 304 305 306
	if (atomic_inc_not_zero(&s->s_active)) {
		spin_unlock(&sb_lock);
		return 1;
	}
	/* it's going away */
L
Linus Torvalds 已提交
307 308
	s->s_count++;
	spin_unlock(&sb_lock);
309
	/* wait for it to die */
L
Linus Torvalds 已提交
310 311 312 313 314 315
	down_write(&s->s_umount);
	up_write(&s->s_umount);
	put_super(s);
	return 0;
}

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
/*
 *	grab_super_passive - acquire a passive reference
 *	@s: reference we are trying to grab
 *
 *	Tries to acquire a passive reference. This is used in places where we
 *	cannot take an active reference but we need to ensure that the
 *	superblock does not go away while we are working on it. It returns
 *	false if a reference was not gained, and returns true with the s_umount
 *	lock held in read mode if a reference is gained. On successful return,
 *	the caller must drop the s_umount lock and the passive reference when
 *	done.
 */
bool grab_super_passive(struct super_block *sb)
{
	spin_lock(&sb_lock);
	if (list_empty(&sb->s_instances)) {
		spin_unlock(&sb_lock);
		return false;
	}

	sb->s_count++;
	spin_unlock(&sb_lock);

	if (down_read_trylock(&sb->s_umount)) {
		if (sb->s_root)
			return true;
		up_read(&sb->s_umount);
	}

	put_super(sb);
	return false;
}

349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
/*
 * Superblock locking.  We really ought to get rid of these two.
 */
void lock_super(struct super_block * sb)
{
	mutex_lock(&sb->s_lock);
}

void unlock_super(struct super_block * sb)
{
	mutex_unlock(&sb->s_lock);
}

EXPORT_SYMBOL(lock_super);
EXPORT_SYMBOL(unlock_super);

L
Linus Torvalds 已提交
365 366 367 368 369 370 371 372 373
/**
 *	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.
374 375 376 377
 *
 *	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.
L
Linus Torvalds 已提交
378 379 380
 */
void generic_shutdown_super(struct super_block *sb)
{
381
	const struct super_operations *sop = sb->s_op;
L
Linus Torvalds 已提交
382

383 384
	if (sb->s_root) {
		shrink_dcache_for_umount(sb);
385
		sync_filesystem(sb);
L
Linus Torvalds 已提交
386
		sb->s_flags &= ~MS_ACTIVE;
387

A
Al Viro 已提交
388 389 390
		fsnotify_unmount_inodes(&sb->s_inodes);

		evict_inodes(sb);
L
Linus Torvalds 已提交
391 392 393 394

		if (sop->put_super)
			sop->put_super(sb);

A
Al Viro 已提交
395
		if (!list_empty(&sb->s_inodes)) {
396 397 398
			printk("VFS: Busy inodes after unmount of %s. "
			   "Self-destruct in 5 seconds.  Have a nice day...\n",
			   sb->s_id);
L
Linus Torvalds 已提交
399 400 401 402
		}
	}
	spin_lock(&sb_lock);
	/* should be initialized for __put_super_and_need_restart() */
403
	list_del_init(&sb->s_instances);
L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
	spin_unlock(&sb_lock);
	up_write(&sb->s_umount);
}

EXPORT_SYMBOL(generic_shutdown_super);

/**
 *	sget	-	find or create a superblock
 *	@type:	filesystem type superblock should belong to
 *	@test:	comparison callback
 *	@set:	setup callback
 *	@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 *),
			void *data)
{
	struct super_block *s = NULL;
423
	struct super_block *old;
L
Linus Torvalds 已提交
424 425 426 427
	int err;

retry:
	spin_lock(&sb_lock);
428 429 430 431 432 433
	if (test) {
		list_for_each_entry(old, &type->fs_supers, s_instances) {
			if (!test(old, data))
				continue;
			if (!grab_super(old))
				goto retry;
L
Li Zefan 已提交
434 435
			if (s) {
				up_write(&s->s_umount);
436
				destroy_super(s);
A
Al Viro 已提交
437
				s = NULL;
L
Li Zefan 已提交
438
			}
439
			down_write(&old->s_umount);
A
Al Viro 已提交
440 441 442 443
			if (unlikely(!(old->s_flags & MS_BORN))) {
				deactivate_locked_super(old);
				goto retry;
			}
444 445
			return old;
		}
L
Linus Torvalds 已提交
446 447 448
	}
	if (!s) {
		spin_unlock(&sb_lock);
I
Ingo Molnar 已提交
449
		s = alloc_super(type);
L
Linus Torvalds 已提交
450 451 452 453 454 455 456 457
		if (!s)
			return ERR_PTR(-ENOMEM);
		goto retry;
	}
		
	err = set(s, data);
	if (err) {
		spin_unlock(&sb_lock);
L
Li Zefan 已提交
458
		up_write(&s->s_umount);
L
Linus Torvalds 已提交
459 460 461 462 463 464 465 466 467
		destroy_super(s);
		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);
	list_add(&s->s_instances, &type->fs_supers);
	spin_unlock(&sb_lock);
	get_filesystem(type);
468
	register_shrinker(&s->s_shrink);
L
Linus Torvalds 已提交
469 470 471 472 473 474 475 476 477 478 479 480 481
	return s;
}

EXPORT_SYMBOL(sget);

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

EXPORT_SYMBOL(drop_super);

C
Christoph Hellwig 已提交
482 483 484 485 486 487 488 489
/**
 * sync_supers - helper for periodic superblock writeback
 *
 * Call the write_super method if present on all dirty superblocks in
 * the system.  This is for the periodic writeback used by most older
 * filesystems.  For data integrity superblock writeback use
 * sync_filesystems() instead.
 *
L
Linus Torvalds 已提交
490 491 492 493 494 495
 * Note: check the dirty flag before waiting, so we don't
 * hold up the sync while mounting a device. (The newly
 * mounted device won't need syncing.)
 */
void sync_supers(void)
{
496
	struct super_block *sb, *p = NULL;
497

L
Linus Torvalds 已提交
498
	spin_lock(&sb_lock);
499
	list_for_each_entry(sb, &super_blocks, s_list) {
500 501
		if (list_empty(&sb->s_instances))
			continue;
C
Christoph Hellwig 已提交
502
		if (sb->s_op->write_super && sb->s_dirt) {
L
Linus Torvalds 已提交
503 504
			sb->s_count++;
			spin_unlock(&sb_lock);
C
Christoph Hellwig 已提交
505

L
Linus Torvalds 已提交
506
			down_read(&sb->s_umount);
C
Christoph Hellwig 已提交
507 508
			if (sb->s_root && sb->s_dirt)
				sb->s_op->write_super(sb);
509
			up_read(&sb->s_umount);
C
Christoph Hellwig 已提交
510

511
			spin_lock(&sb_lock);
512 513 514
			if (p)
				__put_super(p);
			p = sb;
515 516
		}
	}
517 518
	if (p)
		__put_super(p);
L
Linus Torvalds 已提交
519 520 521
	spin_unlock(&sb_lock);
}

A
Al Viro 已提交
522 523 524 525 526 527 528 529 530 531
/**
 *	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)
{
532
	struct super_block *sb, *p = NULL;
A
Al Viro 已提交
533 534

	spin_lock(&sb_lock);
535
	list_for_each_entry(sb, &super_blocks, s_list) {
A
Al Viro 已提交
536 537 538 539 540 541 542 543 544 545 546
		if (list_empty(&sb->s_instances))
			continue;
		sb->s_count++;
		spin_unlock(&sb_lock);

		down_read(&sb->s_umount);
		if (sb->s_root)
			f(sb, arg);
		up_read(&sb->s_umount);

		spin_lock(&sb_lock);
547 548 549
		if (p)
			__put_super(p);
		p = sb;
A
Al Viro 已提交
550
	}
551 552
	if (p)
		__put_super(p);
A
Al Viro 已提交
553 554 555
	spin_unlock(&sb_lock);
}

A
Al Viro 已提交
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
/**
 *	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);
	list_for_each_entry(sb, &type->fs_supers, s_instances) {
		sb->s_count++;
		spin_unlock(&sb_lock);

		down_read(&sb->s_umount);
		if (sb->s_root)
			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);

L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599
/**
 *	get_super - get 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. %NULL is returned if no match is found.
 */

600
struct super_block *get_super(struct block_device *bdev)
L
Linus Torvalds 已提交
601
{
602 603
	struct super_block *sb;

L
Linus Torvalds 已提交
604 605
	if (!bdev)
		return NULL;
606

L
Linus Torvalds 已提交
607
	spin_lock(&sb_lock);
608 609
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
610 611
		if (list_empty(&sb->s_instances))
			continue;
612 613
		if (sb->s_bdev == bdev) {
			sb->s_count++;
L
Linus Torvalds 已提交
614
			spin_unlock(&sb_lock);
615
			down_read(&sb->s_umount);
616
			/* still alive? */
617 618 619
			if (sb->s_root)
				return sb;
			up_read(&sb->s_umount);
620
			/* nope, got unmounted */
621
			spin_lock(&sb_lock);
622 623
			__put_super(sb);
			goto rescan;
L
Linus Torvalds 已提交
624 625 626 627 628 629 630
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

EXPORT_SYMBOL(get_super);
631 632 633 634 635 636 637

/**
 * 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
638
 * reference or %NULL if none was found.
639 640 641 642 643 644 645 646
 */
struct super_block *get_active_super(struct block_device *bdev)
{
	struct super_block *sb;

	if (!bdev)
		return NULL;

A
Al Viro 已提交
647
restart:
648 649
	spin_lock(&sb_lock);
	list_for_each_entry(sb, &super_blocks, s_list) {
650 651
		if (list_empty(&sb->s_instances))
			continue;
A
Al Viro 已提交
652 653 654 655 656 657
		if (sb->s_bdev == bdev) {
			if (grab_super(sb)) /* drops sb_lock */
				return sb;
			else
				goto restart;
		}
658 659 660 661
	}
	spin_unlock(&sb_lock);
	return NULL;
}
L
Linus Torvalds 已提交
662
 
663
struct super_block *user_get_super(dev_t dev)
L
Linus Torvalds 已提交
664
{
665
	struct super_block *sb;
L
Linus Torvalds 已提交
666 667

	spin_lock(&sb_lock);
668 669
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
670 671
		if (list_empty(&sb->s_instances))
			continue;
672 673
		if (sb->s_dev ==  dev) {
			sb->s_count++;
L
Linus Torvalds 已提交
674
			spin_unlock(&sb_lock);
675
			down_read(&sb->s_umount);
676
			/* still alive? */
677 678 679
			if (sb->s_root)
				return sb;
			up_read(&sb->s_umount);
680
			/* nope, got unmounted */
681
			spin_lock(&sb_lock);
682 683
			__put_super(sb);
			goto rescan;
L
Linus Torvalds 已提交
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

/**
 *	do_remount_sb - asks filesystem to change mount options.
 *	@sb:	superblock in question
 *	@flags:	numeric part of options
 *	@data:	the rest of options
 *      @force: whether or not to force the change
 *
 *	Alters the mount options of a mounted file system.
 */
int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
{
	int retval;
702
	int remount_ro;
703 704 705 706

	if (sb->s_frozen != SB_UNFROZEN)
		return -EBUSY;

707
#ifdef CONFIG_BLOCK
L
Linus Torvalds 已提交
708 709
	if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
		return -EACCES;
710
#endif
711

L
Linus Torvalds 已提交
712 713 714
	if (flags & MS_RDONLY)
		acct_auto_close(sb);
	shrink_dcache_sb(sb);
715
	sync_filesystem(sb);
L
Linus Torvalds 已提交
716

717 718
	remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);

L
Linus Torvalds 已提交
719 720
	/* If we are remounting RDONLY and current sb is read/write,
	   make sure there are no rw files opened */
721
	if (remount_ro) {
L
Linus Torvalds 已提交
722 723
		if (force)
			mark_files_ro(sb);
724
		else if (!fs_may_remount_ro(sb))
L
Linus Torvalds 已提交
725 726 727 728 729
			return -EBUSY;
	}

	if (sb->s_op->remount_fs) {
		retval = sb->s_op->remount_fs(sb, &flags, data);
730 731 732 733 734 735 736
		if (retval) {
			if (!force)
				return retval;
			/* If forced remount, go ahead despite any errors */
			WARN(1, "forced remount of a %s fs returned %i\n",
			     sb->s_type->name, retval);
		}
L
Linus Torvalds 已提交
737 738
	}
	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
739

740 741 742 743 744 745 746 747 748 749
	/*
	 * 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);
L
Linus Torvalds 已提交
750 751 752
	return 0;
}

753
static void do_emergency_remount(struct work_struct *work)
L
Linus Torvalds 已提交
754
{
755
	struct super_block *sb, *p = NULL;
L
Linus Torvalds 已提交
756 757

	spin_lock(&sb_lock);
758
	list_for_each_entry(sb, &super_blocks, s_list) {
759 760
		if (list_empty(&sb->s_instances))
			continue;
L
Linus Torvalds 已提交
761 762
		sb->s_count++;
		spin_unlock(&sb_lock);
763
		down_write(&sb->s_umount);
L
Linus Torvalds 已提交
764 765 766 767 768 769
		if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
			/*
			 * What lock protects sb->s_flags??
			 */
			do_remount_sb(sb, MS_RDONLY, NULL, 1);
		}
770
		up_write(&sb->s_umount);
L
Linus Torvalds 已提交
771
		spin_lock(&sb_lock);
772 773 774
		if (p)
			__put_super(p);
		p = sb;
L
Linus Torvalds 已提交
775
	}
776 777
	if (p)
		__put_super(p);
L
Linus Torvalds 已提交
778
	spin_unlock(&sb_lock);
779
	kfree(work);
L
Linus Torvalds 已提交
780 781 782 783 784
	printk("Emergency Remount complete\n");
}

void emergency_remount(void)
{
785 786 787 788 789 790 791
	struct work_struct *work;

	work = kmalloc(sizeof(*work), GFP_ATOMIC);
	if (work) {
		INIT_WORK(work, do_emergency_remount);
		schedule_work(work);
	}
L
Linus Torvalds 已提交
792 793 794 795 796 797 798
}

/*
 * Unnamed block devices are dummy devices used by virtual
 * filesystems which don't use real block-devices.  -- jrs
 */

799
static DEFINE_IDA(unnamed_dev_ida);
L
Linus Torvalds 已提交
800
static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
801
static int unnamed_dev_start = 0; /* don't bother trying below it */
L
Linus Torvalds 已提交
802

803
int get_anon_bdev(dev_t *p)
L
Linus Torvalds 已提交
804 805 806 807 808
{
	int dev;
	int error;

 retry:
809
	if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
L
Linus Torvalds 已提交
810 811
		return -ENOMEM;
	spin_lock(&unnamed_dev_lock);
812
	error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
813 814
	if (!error)
		unnamed_dev_start = dev + 1;
L
Linus Torvalds 已提交
815 816 817 818 819 820 821 822 823
	spin_unlock(&unnamed_dev_lock);
	if (error == -EAGAIN)
		/* We raced and lost with another CPU. */
		goto retry;
	else if (error)
		return -EAGAIN;

	if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
		spin_lock(&unnamed_dev_lock);
824
		ida_remove(&unnamed_dev_ida, dev);
825 826
		if (unnamed_dev_start > dev)
			unnamed_dev_start = dev;
L
Linus Torvalds 已提交
827 828 829
		spin_unlock(&unnamed_dev_lock);
		return -EMFILE;
	}
830
	*p = MKDEV(0, dev & MINORMASK);
L
Linus Torvalds 已提交
831 832
	return 0;
}
833
EXPORT_SYMBOL(get_anon_bdev);
L
Linus Torvalds 已提交
834

835
void free_anon_bdev(dev_t dev)
L
Linus Torvalds 已提交
836
{
837
	int slot = MINOR(dev);
L
Linus Torvalds 已提交
838
	spin_lock(&unnamed_dev_lock);
839
	ida_remove(&unnamed_dev_ida, slot);
840 841
	if (slot < unnamed_dev_start)
		unnamed_dev_start = slot;
L
Linus Torvalds 已提交
842 843
	spin_unlock(&unnamed_dev_lock);
}
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
EXPORT_SYMBOL(free_anon_bdev);

int set_anon_super(struct super_block *s, void *data)
{
	int error = get_anon_bdev(&s->s_dev);
	if (!error)
		s->s_bdi = &noop_backing_dev_info;
	return error;
}

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);
}
L
Linus Torvalds 已提交
862 863 864 865 866 867 868 869 870 871 872 873

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);

874 875 876 877 878 879 880 881 882 883 884
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);
}

A
Al Viro 已提交
885 886
struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
	void *data, int (*fill_super)(struct super_block *, void *, int))
887 888 889 890 891
{
	struct super_block *sb;

	sb = sget(fs_type, ns_test_super, ns_set_super, data);
	if (IS_ERR(sb))
A
Al Viro 已提交
892
		return ERR_CAST(sb);
893 894 895 896 897 898

	if (!sb->s_root) {
		int err;
		sb->s_flags = flags;
		err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
		if (err) {
A
Al Viro 已提交
899
			deactivate_locked_super(sb);
A
Al Viro 已提交
900
			return ERR_PTR(err);
901 902 903 904 905
		}

		sb->s_flags |= MS_ACTIVE;
	}

A
Al Viro 已提交
906
	return dget(sb->s_root);
907 908
}

A
Al Viro 已提交
909
EXPORT_SYMBOL(mount_ns);
910

911
#ifdef CONFIG_BLOCK
L
Linus Torvalds 已提交
912 913 914 915
static int set_bdev_super(struct super_block *s, void *data)
{
	s->s_bdev = data;
	s->s_dev = s->s_bdev->bd_dev;
J
Jens Axboe 已提交
916 917 918 919 920 921

	/*
	 * We set the bdi here to the queue backing, file systems can
	 * overwrite this in ->fill_super()
	 */
	s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
L
Linus Torvalds 已提交
922 923 924 925 926 927 928 929
	return 0;
}

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

A
Al Viro 已提交
930
struct dentry *mount_bdev(struct file_system_type *fs_type,
L
Linus Torvalds 已提交
931
	int flags, const char *dev_name, void *data,
A
Al Viro 已提交
932
	int (*fill_super)(struct super_block *, void *, int))
L
Linus Torvalds 已提交
933 934 935
{
	struct block_device *bdev;
	struct super_block *s;
936
	fmode_t mode = FMODE_READ | FMODE_EXCL;
L
Linus Torvalds 已提交
937 938
	int error = 0;

939 940 941
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

942
	bdev = blkdev_get_by_path(dev_name, mode, fs_type);
L
Linus Torvalds 已提交
943
	if (IS_ERR(bdev))
A
Al Viro 已提交
944
		return ERR_CAST(bdev);
L
Linus Torvalds 已提交
945 946 947 948 949 950

	/*
	 * 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
	 */
951 952 953 954 955 956
	mutex_lock(&bdev->bd_fsfreeze_mutex);
	if (bdev->bd_fsfreeze_count > 0) {
		mutex_unlock(&bdev->bd_fsfreeze_mutex);
		error = -EBUSY;
		goto error_bdev;
	}
L
Linus Torvalds 已提交
957
	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
958
	mutex_unlock(&bdev->bd_fsfreeze_mutex);
L
Linus Torvalds 已提交
959
	if (IS_ERR(s))
960
		goto error_s;
L
Linus Torvalds 已提交
961 962 963

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
A
Al Viro 已提交
964
			deactivate_locked_super(s);
965 966
			error = -EBUSY;
			goto error_bdev;
L
Linus Torvalds 已提交
967
		}
968

969 970
		/*
		 * s_umount nests inside bd_mutex during
971 972 973 974
		 * __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.
975 976
		 */
		up_write(&s->s_umount);
977
		blkdev_put(bdev, mode);
978
		down_write(&s->s_umount);
L
Linus Torvalds 已提交
979 980 981
	} else {
		char b[BDEVNAME_SIZE];

A
Al Viro 已提交
982
		s->s_flags = flags | MS_NOSEC;
983
		s->s_mode = mode;
L
Linus Torvalds 已提交
984
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
985
		sb_set_blocksize(s, block_size(bdev));
986
		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
L
Linus Torvalds 已提交
987
		if (error) {
A
Al Viro 已提交
988
			deactivate_locked_super(s);
989
			goto error;
990
		}
991 992

		s->s_flags |= MS_ACTIVE;
993
		bdev->bd_super = s;
L
Linus Torvalds 已提交
994 995
	}

A
Al Viro 已提交
996
	return dget(s->s_root);
L
Linus Torvalds 已提交
997

998 999 1000
error_s:
	error = PTR_ERR(s);
error_bdev:
1001
	blkdev_put(bdev, mode);
1002
error:
A
Al Viro 已提交
1003 1004 1005 1006
	return ERR_PTR(error);
}
EXPORT_SYMBOL(mount_bdev);

L
Linus Torvalds 已提交
1007 1008 1009
void kill_block_super(struct super_block *sb)
{
	struct block_device *bdev = sb->s_bdev;
1010
	fmode_t mode = sb->s_mode;
L
Linus Torvalds 已提交
1011

1012
	bdev->bd_super = NULL;
L
Linus Torvalds 已提交
1013 1014
	generic_shutdown_super(sb);
	sync_blockdev(bdev);
1015
	WARN_ON_ONCE(!(mode & FMODE_EXCL));
1016
	blkdev_put(bdev, mode | FMODE_EXCL);
L
Linus Torvalds 已提交
1017 1018 1019
}

EXPORT_SYMBOL(kill_block_super);
1020
#endif
L
Linus Torvalds 已提交
1021

A
Al Viro 已提交
1022
struct dentry *mount_nodev(struct file_system_type *fs_type,
L
Linus Torvalds 已提交
1023
	int flags, void *data,
A
Al Viro 已提交
1024
	int (*fill_super)(struct super_block *, void *, int))
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029
{
	int error;
	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);

	if (IS_ERR(s))
A
Al Viro 已提交
1030
		return ERR_CAST(s);
L
Linus Torvalds 已提交
1031 1032 1033

	s->s_flags = flags;

1034
	error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
L
Linus Torvalds 已提交
1035
	if (error) {
A
Al Viro 已提交
1036
		deactivate_locked_super(s);
A
Al Viro 已提交
1037
		return ERR_PTR(error);
L
Linus Torvalds 已提交
1038 1039
	}
	s->s_flags |= MS_ACTIVE;
A
Al Viro 已提交
1040
	return dget(s->s_root);
L
Linus Torvalds 已提交
1041
}
A
Al Viro 已提交
1042 1043
EXPORT_SYMBOL(mount_nodev);

L
Linus Torvalds 已提交
1044 1045 1046 1047 1048
static int compare_single(struct super_block *s, void *p)
{
	return 1;
}

A
Al Viro 已提交
1049
struct dentry *mount_single(struct file_system_type *fs_type,
L
Linus Torvalds 已提交
1050
	int flags, void *data,
A
Al Viro 已提交
1051
	int (*fill_super)(struct super_block *, void *, int))
L
Linus Torvalds 已提交
1052 1053 1054 1055 1056 1057
{
	struct super_block *s;
	int error;

	s = sget(fs_type, compare_single, set_anon_super, NULL);
	if (IS_ERR(s))
A
Al Viro 已提交
1058
		return ERR_CAST(s);
L
Linus Torvalds 已提交
1059 1060
	if (!s->s_root) {
		s->s_flags = flags;
1061
		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
L
Linus Torvalds 已提交
1062
		if (error) {
A
Al Viro 已提交
1063
			deactivate_locked_super(s);
A
Al Viro 已提交
1064
			return ERR_PTR(error);
L
Linus Torvalds 已提交
1065 1066
		}
		s->s_flags |= MS_ACTIVE;
1067 1068
	} else {
		do_remount_sb(s, flags, data, 0);
L
Linus Torvalds 已提交
1069
	}
A
Al Viro 已提交
1070 1071 1072 1073
	return dget(s->s_root);
}
EXPORT_SYMBOL(mount_single);

1074 1075
struct dentry *
mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
L
Linus Torvalds 已提交
1076
{
A
Al Viro 已提交
1077
	struct dentry *root;
1078
	struct super_block *sb;
L
Linus Torvalds 已提交
1079
	char *secdata = NULL;
1080
	int error = -ENOMEM;
A
Al Viro 已提交
1081

1082
	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
L
Linus Torvalds 已提交
1083
		secdata = alloc_secdata();
1084
		if (!secdata)
1085
			goto out;
L
Linus Torvalds 已提交
1086

1087
		error = security_sb_copy_data(data, secdata);
1088
		if (error)
L
Linus Torvalds 已提交
1089 1090 1091
			goto out_free_secdata;
	}

A
Al Viro 已提交
1092 1093 1094 1095
	root = type->mount(type, flags, name, data);
	if (IS_ERR(root)) {
		error = PTR_ERR(root);
		goto out_free_secdata;
A
Al Viro 已提交
1096
	}
1097 1098 1099
	sb = root->d_sb;
	BUG_ON(!sb);
	WARN_ON(!sb->s_bdi);
1100
	WARN_ON(sb->s_bdi == &default_backing_dev_info);
1101
	sb->s_flags |= MS_BORN;
1102

1103
	error = security_sb_kern_mount(sb, flags, secdata);
J
Jörn Engel 已提交
1104 1105
	if (error)
		goto out_sb;
1106

1107 1108 1109 1110
	/*
	 * filesystems should never set s_maxbytes larger than MAX_LFS_FILESIZE
	 * but s_maxbytes was an unsigned long long for many releases. Throw
	 * this warning for a little while to try and catch filesystems that
1111
	 * violate this rule.
1112
	 */
1113 1114
	WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
		"negative value (%lld)\n", type->name, sb->s_maxbytes);
1115

1116
	up_write(&sb->s_umount);
1117
	free_secdata(secdata);
1118
	return root;
L
Linus Torvalds 已提交
1119
out_sb:
1120 1121
	dput(root);
	deactivate_locked_super(sb);
L
Linus Torvalds 已提交
1122 1123 1124
out_free_secdata:
	free_secdata(secdata);
out:
1125
	return ERR_PTR(error);
L
Linus Torvalds 已提交
1126 1127
}

1128
/**
R
Randy Dunlap 已提交
1129 1130
 * freeze_super - lock the filesystem and force it into a consistent state
 * @sb: the super to lock
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
 *
 * Syncs the super to make sure the filesystem is consistent and calls the fs's
 * freeze_fs.  Subsequent calls to this without first thawing the fs will return
 * -EBUSY.
 */
int freeze_super(struct super_block *sb)
{
	int ret;

	atomic_inc(&sb->s_active);
	down_write(&sb->s_umount);
	if (sb->s_frozen) {
		deactivate_locked_super(sb);
		return -EBUSY;
	}

	if (sb->s_flags & MS_RDONLY) {
		sb->s_frozen = SB_FREEZE_TRANS;
		smp_wmb();
		up_write(&sb->s_umount);
		return 0;
	}

	sb->s_frozen = SB_FREEZE_WRITE;
	smp_wmb();

	sync_filesystem(sb);

	sb->s_frozen = SB_FREEZE_TRANS;
	smp_wmb();

	sync_blockdev(sb->s_bdev);
	if (sb->s_op->freeze_fs) {
		ret = sb->s_op->freeze_fs(sb);
		if (ret) {
			printk(KERN_ERR
				"VFS:Filesystem freeze failed\n");
			sb->s_frozen = SB_UNFROZEN;
			deactivate_locked_super(sb);
			return ret;
		}
	}
	up_write(&sb->s_umount);
	return 0;
}
EXPORT_SYMBOL(freeze_super);

/**
 * thaw_super -- unlock filesystem
 * @sb: the super to thaw
 *
 * Unlocks the filesystem and marks it writeable again after freeze_super().
 */
int thaw_super(struct super_block *sb)
{
	int error;

	down_write(&sb->s_umount);
	if (sb->s_frozen == SB_UNFROZEN) {
		up_write(&sb->s_umount);
		return -EINVAL;
	}

	if (sb->s_flags & MS_RDONLY)
		goto out;

	if (sb->s_op->unfreeze_fs) {
		error = sb->s_op->unfreeze_fs(sb);
		if (error) {
			printk(KERN_ERR
				"VFS:Filesystem thaw failed\n");
			sb->s_frozen = SB_FREEZE_TRANS;
			up_write(&sb->s_umount);
			return error;
		}
	}

out:
	sb->s_frozen = SB_UNFROZEN;
	smp_wmb();
	wake_up(&sb->s_wait_unfrozen);
	deactivate_locked_super(sb);

	return 0;
}
EXPORT_SYMBOL(thaw_super);