super.c 24 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
32
33
34
35
36
37
 *  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/init.h>
#include <linux/smp_lock.h>
#include <linux/acct.h>
#include <linux/blkdev.h>
#include <linux/quotaops.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/vfs.h>
#include <linux/writeback.h>		/* for the emergency remount stuff */
#include <linux/idr.h>
#include <linux/kobject.h>
Ingo Molnar's avatar
Ingo Molnar committed
38
#include <linux/mutex.h>
39
#include <linux/file.h>
40
#include <linux/backing-dev.h>
Linus Torvalds's avatar
Linus Torvalds committed
41
#include <asm/uaccess.h>
42
#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
43
44
45
46
47
48
49


LIST_HEAD(super_blocks);
DEFINE_SPINLOCK(sb_lock);

/**
 *	alloc_super	-	create new superblock
50
 *	@type:	filesystem type superblock should belong to
Linus Torvalds's avatar
Linus Torvalds committed
51
52
53
54
 *
 *	Allocates and initializes a new &struct super_block.  alloc_super()
 *	returns a pointer new superblock or %NULL if allocation had failed.
 */
55
static struct super_block *alloc_super(struct file_system_type *type)
Linus Torvalds's avatar
Linus Torvalds committed
56
{
57
	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
58
	static const struct super_operations default_op;
Linus Torvalds's avatar
Linus Torvalds committed
59
60
61
62
63
64
65
66
67
68
69

	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);
70
		INIT_LIST_HEAD(&s->s_dentry_lru);
Linus Torvalds's avatar
Linus Torvalds committed
71
		init_rwsem(&s->s_umount);
72
		mutex_init(&s->s_lock);
73
		lockdep_set_class(&s->s_umount, &type->s_umount_key);
74
75
76
77
78
79
		/*
		 * 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);
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
		/*
		 * 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
96
		s->s_count = 1;
Linus Torvalds's avatar
Linus Torvalds committed
97
		atomic_set(&s->s_active, 1);
98
		mutex_init(&s->s_vfs_rename_mutex);
Ingo Molnar's avatar
Ingo Molnar committed
99
100
		mutex_init(&s->s_dquot.dqio_mutex);
		mutex_init(&s->s_dquot.dqonoff_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
		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);
122
	kfree(s->s_subtype);
123
	kfree(s->s_options);
Linus Torvalds's avatar
Linus Torvalds committed
124
125
126
127
128
129
130
131
132
	kfree(s);
}

/* Superblock refcounting  */

/*
 * Drop a superblock's refcount.  Returns non-zero if the superblock was
 * destroyed.  The caller must hold sb_lock.
 */
133
int __put_super(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
134
135
136
137
{
	int ret = 0;

	if (!--sb->s_count) {
138
		list_del_init(&sb->s_list);
Linus Torvalds's avatar
Linus Torvalds committed
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
		destroy_super(sb);
		ret = 1;
	}
	return ret;
}

/*
 * Drop a superblock's refcount.
 * Returns non-zero if the superblock is about to be destroyed and
 * at least is already removed from super_blocks list, so if we are
 * making a loop through super blocks then we need to restart.
 * The caller must hold sb_lock.
 */
int __put_super_and_need_restart(struct super_block *sb)
{
	/* check for race with generic_shutdown_super() */
155
	if (list_empty(&sb->s_instances)) {
Linus Torvalds's avatar
Linus Torvalds committed
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
		/* super block is removed, need to restart... */
		__put_super(sb);
		return 1;
	}
	/* can't be the last, since s_list is still in use */
	sb->s_count--;
	BUG_ON(sb->s_count == 0);
	return 0;
}

/**
 *	put_super	-	drop a temporary reference to superblock
 *	@sb: superblock in question
 *
 *	Drops a temporary reference, frees superblock if there's no
 *	references left.
 */
173
void put_super(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
174
175
176
177
178
179
180
181
{
	spin_lock(&sb_lock);
	__put_super(sb);
	spin_unlock(&sb_lock);
}


/**
182
 *	deactivate_locked_super	-	drop an active reference to superblock
Linus Torvalds's avatar
Linus Torvalds committed
183
184
 *	@s: superblock to deactivate
 *
185
186
 *	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
187
188
 *	tell fs driver to shut it down and drop the temporary reference we
 *	had just acquired.
189
190
 *
 *	Caller holds exclusive lock on superblock; that lock is released.
Linus Torvalds's avatar
Linus Torvalds committed
191
 */
192
void deactivate_locked_super(struct super_block *s)
Linus Torvalds's avatar
Linus Torvalds committed
193
194
{
	struct file_system_type *fs = s->s_type;
Al Viro's avatar
Al Viro committed
195
	if (atomic_dec_and_test(&s->s_active)) {
196
		vfs_dq_off(s, 0);
Linus Torvalds's avatar
Linus Torvalds committed
197
198
199
		fs->kill_sb(s);
		put_filesystem(fs);
		put_super(s);
200
201
	} else {
		up_write(&s->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
202
203
204
	}
}

205
EXPORT_SYMBOL(deactivate_locked_super);
Linus Torvalds's avatar
Linus Torvalds committed
206

207
/**
208
 *	deactivate_super	-	drop an active reference to superblock
209
210
 *	@s: superblock to deactivate
 *
211
212
213
 *	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.
214
 */
215
void deactivate_super(struct super_block *s)
216
{
217
218
219
        if (!atomic_add_unless(&s->s_active, -1, 1)) {
		down_write(&s->s_umount);
		deactivate_locked_super(s);
220
221
222
	}
}

223
EXPORT_SYMBOL(deactivate_super);
224

Linus Torvalds's avatar
Linus Torvalds committed
225
226
227
228
229
230
231
232
233
234
235
/**
 *	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).
 */
236
static int grab_super(struct super_block *s) __releases(sb_lock)
Linus Torvalds's avatar
Linus Torvalds committed
237
{
Al Viro's avatar
Al Viro committed
238
239
240
241
242
243
	if (atomic_inc_not_zero(&s->s_active)) {
		spin_unlock(&sb_lock);
		down_write(&s->s_umount);
		return 1;
	}
	/* it's going away */
Linus Torvalds's avatar
Linus Torvalds committed
244
245
	s->s_count++;
	spin_unlock(&sb_lock);
246
	/* wait for it to die */
Linus Torvalds's avatar
Linus Torvalds committed
247
248
249
250
251
252
	down_write(&s->s_umount);
	up_write(&s->s_umount);
	put_super(s);
	return 0;
}

253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
/*
 * 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
271
272
273
274
275
276
277
278
279
/**
 *	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.
280
281
282
283
 *
 *	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
284
285
286
 */
void generic_shutdown_super(struct super_block *sb)
{
287
	const struct super_operations *sop = sb->s_op;
Linus Torvalds's avatar
Linus Torvalds committed
288

289

290
291
	if (sb->s_root) {
		shrink_dcache_for_umount(sb);
292
		sync_filesystem(sb);
293
		get_fs_excl();
Linus Torvalds's avatar
Linus Torvalds committed
294
		sb->s_flags &= ~MS_ACTIVE;
295

Linus Torvalds's avatar
Linus Torvalds committed
296
297
298
299
300
301
302
303
		/* 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)) {
304
305
306
			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
307
		}
308
		put_fs_excl();
Linus Torvalds's avatar
Linus Torvalds committed
309
310
311
	}
	spin_lock(&sb_lock);
	/* should be initialized for __put_super_and_need_restart() */
312
	list_del_init(&sb->s_instances);
Linus Torvalds's avatar
Linus Torvalds committed
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
	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;
332
	struct super_block *old;
Linus Torvalds's avatar
Linus Torvalds committed
333
334
335
336
	int err;

retry:
	spin_lock(&sb_lock);
337
338
339
340
341
342
	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
343
344
			if (s) {
				up_write(&s->s_umount);
345
				destroy_super(s);
Li Zefan's avatar
Li Zefan committed
346
			}
347
348
			return old;
		}
Linus Torvalds's avatar
Linus Torvalds committed
349
350
351
	}
	if (!s) {
		spin_unlock(&sb_lock);
352
		s = alloc_super(type);
Linus Torvalds's avatar
Linus Torvalds committed
353
354
355
356
357
358
359
360
		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
361
		up_write(&s->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
		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
384
385
386
387
388
389
390
391
/**
 * 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
392
393
394
395
396
397
 * 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)
{
398
	struct super_block *sb, *n;
399

Linus Torvalds's avatar
Linus Torvalds committed
400
	spin_lock(&sb_lock);
401
	list_for_each_entry_safe(sb, n, &super_blocks, s_list) {
402
403
		if (list_empty(&sb->s_instances))
			continue;
Christoph Hellwig's avatar
Christoph Hellwig committed
404
		if (sb->s_op->write_super && sb->s_dirt) {
Linus Torvalds's avatar
Linus Torvalds committed
405
406
			sb->s_count++;
			spin_unlock(&sb_lock);
Christoph Hellwig's avatar
Christoph Hellwig committed
407

Linus Torvalds's avatar
Linus Torvalds committed
408
			down_read(&sb->s_umount);
Christoph Hellwig's avatar
Christoph Hellwig committed
409
410
			if (sb->s_root && sb->s_dirt)
				sb->s_op->write_super(sb);
411
			up_read(&sb->s_umount);
Christoph Hellwig's avatar
Christoph Hellwig committed
412

413
			spin_lock(&sb_lock);
414
			__put_super(sb);
415
416
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
417
418
419
420
421
422
423
424
425
426
427
428
429
	spin_unlock(&sb_lock);
}

/**
 *	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.
 */

struct super_block * get_super(struct block_device *bdev)
{
430
431
	struct super_block *sb;

Linus Torvalds's avatar
Linus Torvalds committed
432
433
	if (!bdev)
		return NULL;
434

Linus Torvalds's avatar
Linus Torvalds committed
435
	spin_lock(&sb_lock);
436
437
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
438
439
		if (list_empty(&sb->s_instances))
			continue;
440
441
		if (sb->s_bdev == bdev) {
			sb->s_count++;
Linus Torvalds's avatar
Linus Torvalds committed
442
			spin_unlock(&sb_lock);
443
444
445
446
447
448
449
450
			down_read(&sb->s_umount);
			if (sb->s_root)
				return sb;
			up_read(&sb->s_umount);
			/* restart only when sb is no longer on the list */
			spin_lock(&sb_lock);
			if (__put_super_and_need_restart(sb))
				goto rescan;
Linus Torvalds's avatar
Linus Torvalds committed
451
452
453
454
455
456
457
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

EXPORT_SYMBOL(get_super);
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473

/**
 * 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
 * reference and s_umount held exclusively or %NULL if none was found.
 */
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
474
restart:
475
476
	spin_lock(&sb_lock);
	list_for_each_entry(sb, &super_blocks, s_list) {
477
478
		if (list_empty(&sb->s_instances))
			continue;
Al Viro's avatar
Al Viro committed
479
480
481
482
483
484
		if (sb->s_bdev == bdev) {
			if (grab_super(sb)) /* drops sb_lock */
				return sb;
			else
				goto restart;
		}
485
486
487
488
	}
	spin_unlock(&sb_lock);
	return NULL;
}
Linus Torvalds's avatar
Linus Torvalds committed
489
490
491
 
struct super_block * user_get_super(dev_t dev)
{
492
	struct super_block *sb;
Linus Torvalds's avatar
Linus Torvalds committed
493
494

	spin_lock(&sb_lock);
495
496
rescan:
	list_for_each_entry(sb, &super_blocks, s_list) {
497
498
		if (list_empty(&sb->s_instances))
			continue;
499
500
		if (sb->s_dev ==  dev) {
			sb->s_count++;
Linus Torvalds's avatar
Linus Torvalds committed
501
			spin_unlock(&sb_lock);
502
503
504
505
506
507
508
509
			down_read(&sb->s_umount);
			if (sb->s_root)
				return sb;
			up_read(&sb->s_umount);
			/* restart only when sb is no longer on the list */
			spin_lock(&sb_lock);
			if (__put_super_and_need_restart(sb))
				goto rescan;
Linus Torvalds's avatar
Linus Torvalds committed
510
511
512
513
514
515
		}
	}
	spin_unlock(&sb_lock);
	return NULL;
}

516
SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
Linus Torvalds's avatar
Linus Torvalds committed
517
518
519
520
521
522
523
524
525
{
        struct super_block *s;
        struct ustat tmp;
        struct kstatfs sbuf;
	int err = -EINVAL;

        s = user_get_super(new_decode_dev(dev));
        if (s == NULL)
                goto out;
526
	err = vfs_statfs(s->s_root, &sbuf);
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
	drop_super(s);
	if (err)
		goto out;

        memset(&tmp,0,sizeof(struct ustat));
        tmp.f_tfree = sbuf.f_bfree;
        tmp.f_tinode = sbuf.f_ffree;

        err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0;
out:
	return err;
}

/**
 *	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;
552
	int remount_rw, remount_ro;
553
554
555
556

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

557
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
558
559
	if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
		return -EACCES;
560
#endif
561

Linus Torvalds's avatar
Linus Torvalds committed
562
563
564
	if (flags & MS_RDONLY)
		acct_auto_close(sb);
	shrink_dcache_sb(sb);
565
	sync_filesystem(sb);
Linus Torvalds's avatar
Linus Torvalds committed
566

567
568
569
	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
570
571
	/* If we are remounting RDONLY and current sb is read/write,
	   make sure there are no rw files opened */
572
	if (remount_ro) {
Linus Torvalds's avatar
Linus Torvalds committed
573
574
		if (force)
			mark_files_ro(sb);
575
		else if (!fs_may_remount_ro(sb))
Linus Torvalds's avatar
Linus Torvalds committed
576
			return -EBUSY;
577
		retval = vfs_dq_off(sb, 1);
578
		if (retval < 0 && retval != -ENOSYS)
579
			return -EBUSY;
Linus Torvalds's avatar
Linus Torvalds committed
580
581
582
583
	}

	if (sb->s_op->remount_fs) {
		retval = sb->s_op->remount_fs(sb, &flags, data);
584
		if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
585
586
587
			return retval;
	}
	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
588
	if (remount_rw)
589
		vfs_dq_quota_on_remount(sb);
590
591
592
593
594
595
596
597
598
599
	/*
	 * 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
600
601
602
	return 0;
}

603
static void do_emergency_remount(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
604
{
605
	struct super_block *sb, *n;
Linus Torvalds's avatar
Linus Torvalds committed
606
607

	spin_lock(&sb_lock);
608
	list_for_each_entry_safe(sb, n, &super_blocks, s_list) {
609
610
		if (list_empty(&sb->s_instances))
			continue;
Linus Torvalds's avatar
Linus Torvalds committed
611
612
		sb->s_count++;
		spin_unlock(&sb_lock);
613
		down_write(&sb->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
614
615
616
617
618
619
		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);
		}
620
		up_write(&sb->s_umount);
Linus Torvalds's avatar
Linus Torvalds committed
621
		spin_lock(&sb_lock);
622
		__put_super(sb);
Linus Torvalds's avatar
Linus Torvalds committed
623
624
	}
	spin_unlock(&sb_lock);
625
	kfree(work);
Linus Torvalds's avatar
Linus Torvalds committed
626
627
628
629
630
	printk("Emergency Remount complete\n");
}

void emergency_remount(void)
{
631
632
633
634
635
636
637
	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
638
639
640
641
642
643
644
}

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

645
static DEFINE_IDA(unnamed_dev_ida);
Linus Torvalds's avatar
Linus Torvalds committed
646
static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
647
static int unnamed_dev_start = 0; /* don't bother trying below it */
Linus Torvalds's avatar
Linus Torvalds committed
648
649
650
651
652
653
654

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

 retry:
655
	if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
656
657
		return -ENOMEM;
	spin_lock(&unnamed_dev_lock);
658
	error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
659
660
	if (!error)
		unnamed_dev_start = dev + 1;
Linus Torvalds's avatar
Linus Torvalds committed
661
662
663
664
665
666
667
668
669
	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);
670
		ida_remove(&unnamed_dev_ida, dev);
671
672
		if (unnamed_dev_start > dev)
			unnamed_dev_start = dev;
Linus Torvalds's avatar
Linus Torvalds committed
673
674
675
676
		spin_unlock(&unnamed_dev_lock);
		return -EMFILE;
	}
	s->s_dev = MKDEV(0, dev & MINORMASK);
Jörn Engel's avatar
Jörn Engel committed
677
	s->s_bdi = &noop_backing_dev_info;
Linus Torvalds's avatar
Linus Torvalds committed
678
679
680
681
682
683
684
685
686
687
688
	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);
689
	ida_remove(&unnamed_dev_ida, slot);
690
691
	if (slot < unnamed_dev_start)
		unnamed_dev_start = slot;
Linus Torvalds's avatar
Linus Torvalds committed
692
693
694
695
696
697
698
699
700
701
702
703
704
705
	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);

706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
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) {
732
			deactivate_locked_super(sb);
733
734
735
736
737
738
739
740
741
742
743
744
			return err;
		}

		sb->s_flags |= MS_ACTIVE;
	}

	simple_set_mnt(mnt, sb);
	return 0;
}

EXPORT_SYMBOL(get_sb_ns);

745
#ifdef CONFIG_BLOCK
Linus Torvalds's avatar
Linus Torvalds committed
746
747
748
749
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
750
751
752
753
754
755

	/*
	 * 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
756
757
758
759
760
761
762
763
	return 0;
}

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

764
int get_sb_bdev(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
765
	int flags, const char *dev_name, void *data,
766
767
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
768
769
770
{
	struct block_device *bdev;
	struct super_block *s;
771
	fmode_t mode = FMODE_READ;
Linus Torvalds's avatar
Linus Torvalds committed
772
773
	int error = 0;

774
775
776
777
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	bdev = open_bdev_exclusive(dev_name, mode, fs_type);
Linus Torvalds's avatar
Linus Torvalds committed
778
	if (IS_ERR(bdev))
779
		return PTR_ERR(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
780
781
782
783
784
785

	/*
	 * 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
	 */
786
787
788
789
790
791
	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
792
	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
793
	mutex_unlock(&bdev->bd_fsfreeze_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
794
	if (IS_ERR(s))
795
		goto error_s;
Linus Torvalds's avatar
Linus Torvalds committed
796
797
798

	if (s->s_root) {
		if ((flags ^ s->s_flags) & MS_RDONLY) {
799
			deactivate_locked_super(s);
800
801
			error = -EBUSY;
			goto error_bdev;
Linus Torvalds's avatar
Linus Torvalds committed
802
		}
803

804
		close_bdev_exclusive(bdev, mode);
Linus Torvalds's avatar
Linus Torvalds committed
805
806
807
808
	} else {
		char b[BDEVNAME_SIZE];

		s->s_flags = flags;
809
		s->s_mode = mode;
Linus Torvalds's avatar
Linus Torvalds committed
810
		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
811
		sb_set_blocksize(s, block_size(bdev));
812
		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
813
		if (error) {
814
			deactivate_locked_super(s);
815
			goto error;
816
		}
817
818

		s->s_flags |= MS_ACTIVE;
819
		bdev->bd_super = s;
Linus Torvalds's avatar
Linus Torvalds committed
820
821
	}

822
823
	simple_set_mnt(mnt, s);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
824

825
826
827
error_s:
	error = PTR_ERR(s);
error_bdev:
828
	close_bdev_exclusive(bdev, mode);
829
830
error:
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
831
832
833
834
835
836
837
}

EXPORT_SYMBOL(get_sb_bdev);

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

840
	bdev->bd_super = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
841
842
	generic_shutdown_super(sb);
	sync_blockdev(bdev);
843
	close_bdev_exclusive(bdev, mode);
Linus Torvalds's avatar
Linus Torvalds committed
844
845
846
}

EXPORT_SYMBOL(kill_block_super);
847
#endif
Linus Torvalds's avatar
Linus Torvalds committed
848

849
int get_sb_nodev(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
850
	int flags, void *data,
851
852
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
853
854
855
856
857
{
	int error;
	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);

	if (IS_ERR(s))
858
		return PTR_ERR(s);
Linus Torvalds's avatar
Linus Torvalds committed
859
860
861

	s->s_flags = flags;

862
	error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
863
	if (error) {
864
		deactivate_locked_super(s);
865
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
866
867
	}
	s->s_flags |= MS_ACTIVE;
868
869
	simple_set_mnt(mnt, s);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
870
871
872
873
874
875
876
877
878
}

EXPORT_SYMBOL(get_sb_nodev);

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

879
int get_sb_single(struct file_system_type *fs_type,
Linus Torvalds's avatar
Linus Torvalds committed
880
	int flags, void *data,
881
882
	int (*fill_super)(struct super_block *, void *, int),
	struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
883
884
885
886
887
888
{
	struct super_block *s;
	int error;

	s = sget(fs_type, compare_single, set_anon_super, NULL);
	if (IS_ERR(s))
889
		return PTR_ERR(s);
Linus Torvalds's avatar
Linus Torvalds committed
890
891
	if (!s->s_root) {
		s->s_flags = flags;
892
		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
893
		if (error) {
894
			deactivate_locked_super(s);
895
			return error;
Linus Torvalds's avatar
Linus Torvalds committed
896
897
		}
		s->s_flags |= MS_ACTIVE;
898
899
	} else {
		do_remount_sb(s, flags, data, 0);
Linus Torvalds's avatar
Linus Torvalds committed
900
	}
901
902
	simple_set_mnt(mnt, s);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
903
904
905
906
907
}

EXPORT_SYMBOL(get_sb_single);

struct vfsmount *
908
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
909
910
911
{
	struct vfsmount *mnt;
	char *secdata = NULL;
912
	int error;
Linus Torvalds's avatar
Linus Torvalds committed
913
914
915
916

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

917
	error = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
918
919
920
921
	mnt = alloc_vfsmnt(name);
	if (!mnt)
		goto out;

Al Viro's avatar
Al Viro committed
922
923
924
	if (flags & MS_KERNMOUNT)
		mnt->mnt_flags = MNT_INTERNAL;

925
	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
Linus Torvalds's avatar
Linus Torvalds committed
926
		secdata = alloc_secdata();
927
		if (!secdata)
Linus Torvalds's avatar
Linus Torvalds committed
928
929
			goto out_mnt;

930
		error = security_sb_copy_data(data, secdata);
931
		if (error)
Linus Torvalds's avatar
Linus Torvalds committed
932
933
934
			goto out_free_secdata;
	}

935
936
	error = type->get_sb(type, flags, name, data, mnt);
	if (error < 0)
Linus Torvalds's avatar
Linus Torvalds committed
937
		goto out_free_secdata;
938
	BUG_ON(!mnt->mnt_sb);
Jörn Engel's avatar
Jörn Engel committed
939
	WARN_ON(!mnt->mnt_sb->s_bdi);
940

Jörn Engel's avatar
Jörn Engel committed
941
942
943
	error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);
	if (error)
		goto out_sb;
944

945
946
947
948
949
950
951
952
953
954
	/*
	 * 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);

955
	mnt->mnt_mountpoint = mnt->mnt_root;
Linus Torvalds's avatar
Linus Torvalds committed
956
	mnt->mnt_parent = mnt;
957
	up_write(&mnt->mnt_sb->s_umount);
958
	free_secdata(secdata);
Linus Torvalds's avatar
Linus Torvalds committed
959
960
	return mnt;
out_sb:
961
	dput(mnt->mnt_root);
962
	deactivate_locked_super(mnt->mnt_sb);
Linus Torvalds's avatar
Linus Torvalds committed
963
964
965
966
967
out_free_secdata:
	free_secdata(secdata);
out_mnt:
	free_vfsmnt(mnt);
out:
968
	return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
969
970
}

971
972
EXPORT_SYMBOL_GPL(vfs_kern_mount);

973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
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);
}

996
997
998
999
1000
1001
1002
1003
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);
1004
1005
1006
	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
	    !mnt->mnt_sb->s_subtype)
		mnt = fs_set_subtype(mnt, fstype);
1007
1008
1009
	put_filesystem(type);
	return mnt;
}
1010
EXPORT_SYMBOL_GPL(do_kern_mount);
1011

1012
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
1013
{
1014
	return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
Linus Torvalds's avatar
Linus Torvalds committed
1015
1016
}

1017
EXPORT_SYMBOL_GPL(kern_mount_data);