super.c 24.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
19 20 21 22 23 24 25 26 27 28 29 30 31
 *  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/quotaops.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
32
#include <linux/mutex.h>
33
#include <linux/backing-dev.h>
34
#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38 39 40 41


LIST_HEAD(super_blocks);
DEFINE_SPINLOCK(sb_lock);

/**
 *	alloc_super	-	create new superblock
42
 *	@type:	filesystem type superblock should belong to
Linus Torvalds's avatar
Linus Torvalds committed
43 44 45 46
 *
 *	Allocates and initializes a new &struct super_block.  alloc_super()
 *	returns a pointer new superblock or %NULL if allocation had failed.
 */
47
static struct super_block *alloc_super(struct file_system_type *type)
Linus Torvalds's avatar
Linus Torvalds committed
48
{
49
	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
50
	static const struct super_operations default_op;
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54 55 56 57 58 59 60 61

	if (s) {
		if (security_sb_alloc(s)) {
			kfree(s);
			s = NULL;
			goto out;
		}
		INIT_LIST_HEAD(&s->s_files);
		INIT_LIST_HEAD(&s->s_instances);
		INIT_HLIST_HEAD(&s->s_anon);
		INIT_LIST_HEAD(&s->s_inodes);
62
		INIT_LIST_HEAD(&s->s_dentry_lru);
Linus Torvalds's avatar
Linus Torvalds committed
63
		init_rwsem(&s->s_umount);
64
		mutex_init(&s->s_lock);
65
		lockdep_set_class(&s->s_umount, &type->s_umount_key);
66 67 68 69 70 71
		/*
		 * 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);
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
		/*
		 * 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);
Al Viro's avatar
Al Viro committed
88
		s->s_count = 1;
Linus Torvalds's avatar
Linus Torvalds committed
89
		atomic_set(&s->s_active, 1);
90
		mutex_init(&s->s_vfs_rename_mutex);
91
		lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
Ingo Molnar's avatar
Ingo Molnar committed
92 93
		mutex_init(&s->s_dquot.dqio_mutex);
		mutex_init(&s->s_dquot.dqonoff_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
		init_rwsem(&s->s_dquot.dqptr_sem);
		init_waitqueue_head(&s->s_wait_unfrozen);
		s->s_maxbytes = MAX_NON_LFS;
		s->dq_op = sb_dquot_ops;
		s->s_qcop = sb_quotactl_ops;
		s->s_op = &default_op;
		s->s_time_gran = 1000000000;
	}
out:
	return s;
}

/**
 *	destroy_super	-	frees a superblock
 *	@s: superblock to free
 *
 *	Frees a superblock.
 */
static inline void destroy_super(struct super_block *s)
{
	security_sb_free(s);
115
	kfree(s->s_subtype);
116
	kfree(s->s_options);
Linus Torvalds's avatar
Linus Torvalds committed
117 118 119 120 121 122
	kfree(s);
}

/* Superblock refcounting  */

/*
Al Viro's avatar
Al Viro committed
123
 * Drop a superblock's refcount.  The caller must hold sb_lock.
Linus Torvalds's avatar
Linus Torvalds committed
124
 */
Al Viro's avatar
Al Viro committed
125
void __put_super(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
126 127
{
	if (!--sb->s_count) {
128
		list_del_init(&sb->s_list);
Linus Torvalds's avatar
Linus Torvalds committed
129 130 131 132 133 134 135 136 137 138 139
		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.
 */
140
void put_super(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
141 142 143 144 145 146 147 148
{
	spin_lock(&sb_lock);
	__put_super(sb);
	spin_unlock(&sb_lock);
}


/**
149
 *	deactivate_locked_super	-	drop an active reference to superblock
Linus Torvalds's avatar
Linus Torvalds committed
150 151
 *	@s: superblock to deactivate
 *
152 153
 *	Drops an active reference to superblock, converting it into a temprory
 *	one if there is no other active references left.  In that case we
Linus Torvalds's avatar
Linus Torvalds committed
154 155
 *	tell fs driver to shut it down and drop the temporary reference we
 *	had just acquired.
156 157
 *
 *	Caller holds exclusive lock on superblock; that lock is released.
Linus Torvalds's avatar
Linus Torvalds committed
158
 */
159
void deactivate_locked_super(struct super_block *s)
Linus Torvalds's avatar
Linus Torvalds committed
160 161
{
	struct file_system_type *fs = s->s_type;
Al Viro's avatar
Al Viro committed
162
	if (atomic_dec_and_test(&s->s_active)) {
163
		vfs_dq_off(s, 0);
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166
		fs->kill_sb(s);
		put_filesystem(fs);
		put_super(s);
167 168
	} else {
		up_write(&s->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171
	}
}

172
EXPORT_SYMBOL(deactivate_locked_super);
Linus Torvalds's avatar
Linus Torvalds committed
173

174
/**
175
 *	deactivate_super	-	drop an active reference to superblock
176 177
 *	@s: superblock to deactivate
 *
178 179 180
 *	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.
181
 */
182
void deactivate_super(struct super_block *s)
183
{
184 185 186
        if (!atomic_add_unless(&s->s_active, -1, 1)) {
		down_write(&s->s_umount);
		deactivate_locked_super(s);
187 188 189
	}
}

190
EXPORT_SYMBOL(deactivate_super);
191

Linus Torvalds's avatar
Linus Torvalds committed
192 193 194 195 196 197 198 199 200 201 202
/**
 *	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).
 */
203
static int grab_super(struct super_block *s) __releases(sb_lock)
Linus Torvalds's avatar
Linus Torvalds committed
204
{
Al Viro's avatar
Al Viro committed
205 206 207 208 209
	if (atomic_inc_not_zero(&s->s_active)) {
		spin_unlock(&sb_lock);
		return 1;
	}
	/* it's going away */
Linus Torvalds's avatar
Linus Torvalds committed
210 211
	s->s_count++;
	spin_unlock(&sb_lock);
212
	/* wait for it to die */
Linus Torvalds's avatar
Linus Torvalds committed
213 214 215 216 217 218
	down_write(&s->s_umount);
	up_write(&s->s_umount);
	put_super(s);
	return 0;
}

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
/*
 * Superblock locking.  We really ought to get rid of these two.
 */
void lock_super(struct super_block * sb)
{
	get_fs_excl();
	mutex_lock(&sb->s_lock);
}

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

EXPORT_SYMBOL(lock_super);
EXPORT_SYMBOL(unlock_super);

Linus Torvalds's avatar
Linus Torvalds committed
237 238 239 240 241 242 243 244 245
/**
 *	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.
246 247 248 249
 *
 *	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
250 251 252
 */
void generic_shutdown_super(struct super_block *sb)
{
253
	const struct super_operations *sop = sb->s_op;
Linus Torvalds's avatar
Linus Torvalds committed
254

255

256 257
	if (sb->s_root) {
		shrink_dcache_for_umount(sb);
258
		sync_filesystem(sb);
259
		get_fs_excl();
Linus Torvalds's avatar
Linus Torvalds committed
260
		sb->s_flags &= ~MS_ACTIVE;
261

Linus Torvalds's avatar
Linus Torvalds committed
262 263 264 265 266 267 268 269
		/* bad name - it should be evict_inodes() */
		invalidate_inodes(sb);

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

		/* Forget any remaining inodes */
		if (invalidate_inodes(sb)) {
270 271 272
			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
273
		}
274
		put_fs_excl();
Linus Torvalds's avatar
Linus Torvalds committed
275 276 277
	}
	spin_lock(&sb_lock);
	/* should be initialized for __put_super_and_need_restart() */
278
	list_del_init(&sb->s_instances);
Linus Torvalds's avatar
Linus Torvalds committed
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
	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;
298
	struct super_block *old;
Linus Torvalds's avatar
Linus Torvalds committed
299 300 301 302
	int err;

retry:
	spin_lock(&sb_lock);
303 304 305 306 307 308
	if (test) {
		list_for_each_entry(old, &type->fs_supers, s_instances) {
			if (!test(old, data))
				continue;
			if (!grab_super(old))
				goto retry;
Li Zefan's avatar
Li Zefan committed
309 310
			if (s) {
				up_write(&s->s_umount);
311
				destroy_super(s);
Li Zefan's avatar
Li Zefan committed
312
			}
313
			down_write(&old->s_umount);
314 315
			return old;
		}
Linus Torvalds's avatar
Linus Torvalds committed
316 317 318
	}
	if (!s) {
		spin_unlock(&sb_lock);
319
		s = alloc_super(type);
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324 325 326 327
		if (!s)
			return ERR_PTR(-ENOMEM);
		goto retry;
	}
		
	err = set(s, data);
	if (err) {
		spin_unlock(&sb_lock);
Li Zefan's avatar
Li Zefan committed
328
		up_write(&s->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
		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);
	return s;
}

EXPORT_SYMBOL(sget);

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

EXPORT_SYMBOL(drop_super);

Christoph Hellwig's avatar
Christoph Hellwig committed
351 352 353 354 355 356 357 358
/**
 * 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.
 *
Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363 364
 * 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)
{
365
	struct super_block *sb, *n;
366

Linus Torvalds's avatar
Linus Torvalds committed
367
	spin_lock(&sb_lock);
368
	list_for_each_entry_safe(sb, n, &super_blocks, s_list) {
369 370
		if (list_empty(&sb->s_instances))
			continue;
Christoph Hellwig's avatar
Christoph Hellwig committed
371
		if (sb->s_op->write_super && sb->s_dirt) {
Linus Torvalds's avatar
Linus Torvalds committed
372 373
			sb->s_count++;
			spin_unlock(&sb_lock);
Christoph Hellwig's avatar
Christoph Hellwig committed
374

Linus Torvalds's avatar
Linus Torvalds committed
375
			down_read(&sb->s_umount);
Christoph Hellwig's avatar
Christoph Hellwig committed
376 377
			if (sb->s_root && sb->s_dirt)
				sb->s_op->write_super(sb);
378
			up_read(&sb->s_umount);
Christoph Hellwig's avatar
Christoph Hellwig committed
379

380
			spin_lock(&sb_lock);
381
			__put_super(sb);
382 383
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
384 385 386
	spin_unlock(&sb_lock);
}

Al Viro's avatar
Al Viro committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
/**
 *	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)
{
	struct super_block *sb, *n;

	spin_lock(&sb_lock);
	list_for_each_entry_safe(sb, n, &super_blocks, s_list) {
		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);
		__put_super(sb);
	}
	spin_unlock(&sb_lock);
}

Linus Torvalds's avatar
Linus Torvalds committed
417 418 419 420 421 422 423 424
/**
 *	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.
 */

425
struct super_block *get_super(struct block_device *bdev)
Linus Torvalds's avatar
Linus Torvalds committed
426
{
427 428
	struct super_block *sb;

Linus Torvalds's avatar
Linus Torvalds committed
429 430
	if (!bdev)
		return NULL;
431

Linus Torvalds's avatar
Linus Torvalds committed
432
	spin_lock(&sb_lock);
433 434
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
435 436
		if (list_empty(&sb->s_instances))
			continue;
437 438
		if (sb->s_bdev == bdev) {
			sb->s_count++;
Linus Torvalds's avatar
Linus Torvalds committed
439
			spin_unlock(&sb_lock);
440
			down_read(&sb->s_umount);
441
			/* still alive? */
442 443 444
			if (sb->s_root)
				return sb;
			up_read(&sb->s_umount);
445
			/* nope, got unmounted */
446
			spin_lock(&sb_lock);
447 448
			__put_super(sb);
			goto rescan;
Linus Torvalds's avatar
Linus Torvalds committed
449 450 451 452 453 454 455
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

EXPORT_SYMBOL(get_super);
456 457 458 459 460 461 462

/**
 * 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
463
 * reference or %NULL if none was found.
464 465 466 467 468 469 470 471
 */
struct super_block *get_active_super(struct block_device *bdev)
{
	struct super_block *sb;

	if (!bdev)
		return NULL;

Al Viro's avatar
Al Viro committed
472
restart:
473 474
	spin_lock(&sb_lock);
	list_for_each_entry(sb, &super_blocks, s_list) {
475 476
		if (list_empty(&sb->s_instances))
			continue;
Al Viro's avatar
Al Viro committed
477 478 479 480 481 482
		if (sb->s_bdev == bdev) {
			if (grab_super(sb)) /* drops sb_lock */
				return sb;
			else
				goto restart;
		}
483 484 485 486
	}
	spin_unlock(&sb_lock);
	return NULL;
}
Linus Torvalds's avatar
Linus Torvalds committed
487
 
488
struct super_block *user_get_super(dev_t dev)
Linus Torvalds's avatar
Linus Torvalds committed
489
{
490
	struct super_block *sb;
Linus Torvalds's avatar
Linus Torvalds committed
491 492

	spin_lock(&sb_lock);
493 494
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
495 496
		if (list_empty(&sb->s_instances))
			continue;
497 498
		if (sb->s_dev ==  dev) {
			sb->s_count++;
Linus Torvalds's avatar
Linus Torvalds committed
499
			spin_unlock(&sb_lock);
500
			down_read(&sb->s_umount);
501
			/* still alive? */
502 503 504
			if (sb->s_root)
				return sb;
			up_read(&sb->s_umount);
505
			/* nope, got unmounted */
506
			spin_lock(&sb_lock);
507 508
			__put_super(sb);
			goto rescan;
Linus Torvalds's avatar
Linus Torvalds committed
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
		}
	}
	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;
527
	int remount_rw, remount_ro;
528 529 530 531

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

532
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
533 534
	if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
		return -EACCES;
535
#endif
536

Linus Torvalds's avatar
Linus Torvalds committed
537 538 539
	if (flags & MS_RDONLY)
		acct_auto_close(sb);
	shrink_dcache_sb(sb);
540
	sync_filesystem(sb);
Linus Torvalds's avatar
Linus Torvalds committed
541

542 543 544
	remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
	remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY);

Linus Torvalds's avatar
Linus Torvalds committed
545 546
	/* If we are remounting RDONLY and current sb is read/write,
	   make sure there are no rw files opened */
547
	if (remount_ro) {
Linus Torvalds's avatar
Linus Torvalds committed
548 549
		if (force)
			mark_files_ro(sb);
550
		else if (!fs_may_remount_ro(sb))
Linus Torvalds's avatar
Linus Torvalds committed
551
			return -EBUSY;
552
		retval = vfs_dq_off(sb, 1);
553
		if (retval < 0 && retval != -ENOSYS)
554
			return -EBUSY;
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557 558
	}

	if (sb->s_op->remount_fs) {
		retval = sb->s_op->remount_fs(sb, &flags, data);
559
		if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
560 561 562
			return retval;
	}
	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
563
	if (remount_rw)
564
		vfs_dq_quota_on_remount(sb);
565 566 567 568 569 570 571 572 573 574
	/*
	 * 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
575 576 577
	return 0;
}

578
static void do_emergency_remount(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
579
{
580
	struct super_block *sb, *n;
Linus Torvalds's avatar
Linus Torvalds committed
581 582

	spin_lock(&sb_lock);
583
	list_for_each_entry_safe(sb, n, &super_blocks, s_list) {
584 585
		if (list_empty(&sb->s_instances))
			continue;
Linus Torvalds's avatar
Linus Torvalds committed
586 587
		sb->s_count++;
		spin_unlock(&sb_lock);
588
		down_write(&sb->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
589 590 591 592 593 594
		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);
		}
595
		up_write(&sb->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
596
		spin_lock(&sb_lock);
597
		__put_super(sb);
Linus Torvalds's avatar
Linus Torvalds committed
598 599
	}
	spin_unlock(&sb_lock);
600
	kfree(work);
Linus Torvalds's avatar
Linus Torvalds committed
601 602 603 604 605
	printk("Emergency Remount complete\n");
}

void emergency_remount(void)
{
606 607 608 609 610 611 612
	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
613 614 615 616 617 618 619
}

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

620
static DEFINE_IDA(unnamed_dev_ida);
Linus Torvalds's avatar
Linus Torvalds committed
621
static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
622
static int unnamed_dev_start = 0; /* don't bother trying below it */
Linus Torvalds's avatar
Linus Torvalds committed
623 624 625 626 627 628 629

int set_anon_super(struct super_block *s, void *data)
{
	int dev;
	int error;

 retry:
630
	if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
631 632
		return -ENOMEM;
	spin_lock(&unnamed_dev_lock);
633
	error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
634 635
	if (!error)
		unnamed_dev_start = dev + 1;
Linus Torvalds's avatar
Linus Torvalds committed
636 637 638 639 640 641 642 643 644
	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);
645
		ida_remove(&unnamed_dev_ida, dev);
646 647
		if (unnamed_dev_start > dev)
			unnamed_dev_start = dev;
Linus Torvalds's avatar
Linus Torvalds committed
648 649 650 651
		spin_unlock(&unnamed_dev_lock);
		return -EMFILE;
	}
	s->s_dev = MKDEV(0, dev & MINORMASK);
Jörn Engel's avatar
Jörn Engel committed
652
	s->s_bdi = &noop_backing_dev_info;
Linus Torvalds's avatar
Linus Torvalds committed
653 654 655 656 657 658 659 660 661 662 663
	return 0;
}

EXPORT_SYMBOL(set_anon_super);

void kill_anon_super(struct super_block *sb)
{
	int slot = MINOR(sb->s_dev);

	generic_shutdown_super(sb);
	spin_lock(&unnamed_dev_lock);
664
	ida_remove(&unnamed_dev_ida, slot);
665 666
	if (slot < unnamed_dev_start)
		unnamed_dev_start = slot;
Linus Torvalds's avatar
Linus Torvalds committed
667 668 669 670 671 672 673 674 675 676 677 678 679 680
	spin_unlock(&unnamed_dev_lock);
}

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

681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
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);
}

int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
{
	struct super_block *sb;

	sb = sget(fs_type, ns_test_super, ns_set_super, data);
	if (IS_ERR(sb))
		return PTR_ERR(sb);

	if (!sb->s_root) {
		int err;
		sb->s_flags = flags;
		err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
		if (err) {
707
			deactivate_locked_super(sb);
708 709 710 711 712 713 714 715 716 717 718 719
			return err;
		}

		sb->s_flags |= MS_ACTIVE;
	}

	simple_set_mnt(mnt, sb);
	return 0;
}

EXPORT_SYMBOL(get_sb_ns);

720
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
721 722 723 724
static int set_bdev_super(struct super_block *s, void *data)
{
	s->s_bdev = data;
	s->s_dev = s->s_bdev->bd_dev;
Jens Axboe's avatar
Jens Axboe committed
725 726 727 728 729 730

	/*
	 * 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;
Linus Torvalds's avatar
Linus Torvalds committed
731 732 733 734 735 736 737 738
	return 0;
}

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

739
int get_sb_bdev(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
740
	int flags, const char *dev_name, void *data,
741 742
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
743 744 745
{
	struct block_device *bdev;
	struct super_block *s;
746
	fmode_t mode = FMODE_READ;
Linus Torvalds's avatar
Linus Torvalds committed
747 748
	int error = 0;

749 750 751 752
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	bdev = open_bdev_exclusive(dev_name, mode, fs_type);
Linus Torvalds's avatar
Linus Torvalds committed
753
	if (IS_ERR(bdev))
754
		return PTR_ERR(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
755 756 757 758 759 760

	/*
	 * 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
	 */
761 762 763 764 765 766
	mutex_lock(&bdev->bd_fsfreeze_mutex);
	if (bdev->bd_fsfreeze_count > 0) {
		mutex_unlock(&bdev->bd_fsfreeze_mutex);
		error = -EBUSY;
		goto error_bdev;
	}
Linus Torvalds's avatar
Linus Torvalds committed
767
	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
768
	mutex_unlock(&bdev->bd_fsfreeze_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
769
	if (IS_ERR(s))
770
		goto error_s;
Linus Torvalds's avatar
Linus Torvalds committed
771 772 773

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
774
			deactivate_locked_super(s);
775 776
			error = -EBUSY;
			goto error_bdev;
Linus Torvalds's avatar
Linus Torvalds committed
777
		}
778

779
		close_bdev_exclusive(bdev, mode);
Linus Torvalds's avatar
Linus Torvalds committed
780 781 782 783
	} else {
		char b[BDEVNAME_SIZE];

		s->s_flags = flags;
784
		s->s_mode = mode;
Linus Torvalds's avatar
Linus Torvalds committed
785
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
786
		sb_set_blocksize(s, block_size(bdev));
787
		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
788
		if (error) {
789
			deactivate_locked_super(s);
790
			goto error;
791
		}
792 793

		s->s_flags |= MS_ACTIVE;
794
		bdev->bd_super = s;
Linus Torvalds's avatar
Linus Torvalds committed
795 796
	}

797 798
	simple_set_mnt(mnt, s);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
799

800 801 802
error_s:
	error = PTR_ERR(s);
error_bdev:
803
	close_bdev_exclusive(bdev, mode);
804 805
error:
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
806 807 808 809 810 811 812
}

EXPORT_SYMBOL(get_sb_bdev);

void kill_block_super(struct super_block *sb)
{
	struct block_device *bdev = sb->s_bdev;
813
	fmode_t mode = sb->s_mode;
Linus Torvalds's avatar
Linus Torvalds committed
814

815
	bdev->bd_super = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
816 817
	generic_shutdown_super(sb);
	sync_blockdev(bdev);
818
	close_bdev_exclusive(bdev, mode);
Linus Torvalds's avatar
Linus Torvalds committed
819 820 821
}

EXPORT_SYMBOL(kill_block_super);
822
#endif
Linus Torvalds's avatar
Linus Torvalds committed
823

824
int get_sb_nodev(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
825
	int flags, void *data,
826 827
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
828 829 830 831 832
{
	int error;
	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);

	if (IS_ERR(s))
833
		return PTR_ERR(s);
Linus Torvalds's avatar
Linus Torvalds committed
834 835 836

	s->s_flags = flags;

837
	error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
838
	if (error) {
839
		deactivate_locked_super(s);
840
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
841 842
	}
	s->s_flags |= MS_ACTIVE;
843 844
	simple_set_mnt(mnt, s);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
845 846 847 848 849 850 851 852 853
}

EXPORT_SYMBOL(get_sb_nodev);

static int compare_single(struct super_block *s, void *p)
{
	return 1;
}

854
int get_sb_single(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
855
	int flags, void *data,
856 857
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
858 859 860 861 862 863
{
	struct super_block *s;
	int error;

	s = sget(fs_type, compare_single, set_anon_super, NULL);
	if (IS_ERR(s))
864
		return PTR_ERR(s);
Linus Torvalds's avatar
Linus Torvalds committed
865 866
	if (!s->s_root) {
		s->s_flags = flags;
867
		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
868
		if (error) {
869
			deactivate_locked_super(s);
870
			return error;
Linus Torvalds's avatar
Linus Torvalds committed
871 872
		}
		s->s_flags |= MS_ACTIVE;
873 874
	} else {
		do_remount_sb(s, flags, data, 0);
Linus Torvalds's avatar
Linus Torvalds committed
875
	}
876 877
	simple_set_mnt(mnt, s);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
878 879 880 881 882
}

EXPORT_SYMBOL(get_sb_single);

struct vfsmount *
883
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
884 885 886
{
	struct vfsmount *mnt;
	char *secdata = NULL;
887
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
888 889 890 891

	if (!type)
		return ERR_PTR(-ENODEV);

892
	error = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
893 894 895 896
	mnt = alloc_vfsmnt(name);
	if (!mnt)
		goto out;

Al Viro's avatar
Al Viro committed
897 898 899
	if (flags & MS_KERNMOUNT)
		mnt->mnt_flags = MNT_INTERNAL;

900
	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
Linus Torvalds's avatar
Linus Torvalds committed
901
		secdata = alloc_secdata();
902
		if (!secdata)
Linus Torvalds's avatar
Linus Torvalds committed
903 904
			goto out_mnt;

905
		error = security_sb_copy_data(data, secdata);
906
		if (error)
Linus Torvalds's avatar
Linus Torvalds committed
907 908 909
			goto out_free_secdata;
	}

910 911
	error = type->get_sb(type, flags, name, data, mnt);
	if (error < 0)
Linus Torvalds's avatar
Linus Torvalds committed
912
		goto out_free_secdata;
913
	BUG_ON(!mnt->mnt_sb);
Jörn Engel's avatar
Jörn Engel committed
914
	WARN_ON(!mnt->mnt_sb->s_bdi);
915

Jörn Engel's avatar
Jörn Engel committed
916 917 918
	error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);
	if (error)
		goto out_sb;
919

920 921 922 923 924 925 926 927 928 929
	/*
	 * 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
	 * violate this rule. This warning should be either removed or
	 * converted to a BUG() in 2.6.34.
	 */
	WARN((mnt->mnt_sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
		"negative value (%lld)\n", type->name, mnt->mnt_sb->s_maxbytes);

930
	mnt->mnt_mountpoint = mnt->mnt_root;
Linus Torvalds's avatar
Linus Torvalds committed
931
	mnt->mnt_parent = mnt;
932
	up_write(&mnt->mnt_sb->s_umount);
933
	free_secdata(secdata);
Linus Torvalds's avatar
Linus Torvalds committed
934 935
	return mnt;
out_sb:
936
	dput(mnt->mnt_root);
937
	deactivate_locked_super(mnt->mnt_sb);
Linus Torvalds's avatar
Linus Torvalds committed
938 939 940 941 942
out_free_secdata:
	free_secdata(secdata);
out_mnt:
	free_vfsmnt(mnt);
out:
943
	return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
944 945
}

946 947
EXPORT_SYMBOL_GPL(vfs_kern_mount);

948
/**
949 950
 * freeze_super - lock the filesystem and force it into a consistent state
 * @sb: the super to lock
951 952 953 954 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 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
 *
 * 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);

1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
{
	int err;
	const char *subtype = strchr(fstype, '.');
	if (subtype) {
		subtype++;
		err = -EINVAL;
		if (!subtype[0])
			goto err;
	} else
		subtype = "";

	mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
	err = -ENOMEM;
	if (!mnt->mnt_sb->s_subtype)
		goto err;
	return mnt;

 err:
	mntput(mnt);
	return ERR_PTR(err);
}

1061 1062 1063 1064 1065 1066 1067 1068
struct vfsmount *
do_kern_mount(const char *fstype, int flags, const char *name, void *data)
{
	struct file_system_type *type = get_fs_type(fstype);
	struct vfsmount *mnt;
	if (!type)
		return ERR_PTR(-ENODEV);
	mnt = vfs_kern_mount(type, flags, name, data);
1069 1070 1071
	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
	    !mnt->mnt_sb->s_subtype)
		mnt = fs_set_subtype(mnt, fstype);
1072 1073 1074
	put_filesystem(type);
	return mnt;
}
1075
EXPORT_SYMBOL_GPL(do_kern_mount);
1076

1077
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
1078
{
1079
	return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
Linus Torvalds's avatar
Linus Torvalds committed
1080 1081
}

1082
EXPORT_SYMBOL_GPL(kern_mount_data);