xref: /openbmc/linux/fs/super.c (revision 9ac8d3fb)
1 /*
2  *  linux/fs/super.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *
6  *  super.c contains code to handle: - mount structures
7  *                                   - super-block tables
8  *                                   - filesystem drivers list
9  *                                   - mount system call
10  *                                   - umount system call
11  *                                   - ustat system call
12  *
13  * GK 2/5/95  -  Changed to support mounting the root fs via NFS
14  *
15  *  Added kerneld support: Jacques Gelinas and Bjorn Ekwall
16  *  Added change_root: Werner Almesberger & Hans Lermen, Feb '96
17  *  Added options to /proc/mounts:
18  *    Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
19  *  Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
20  *  Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
21  */
22 
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/init.h>
26 #include <linux/smp_lock.h>
27 #include <linux/acct.h>
28 #include <linux/blkdev.h>
29 #include <linux/quotaops.h>
30 #include <linux/namei.h>
31 #include <linux/buffer_head.h>		/* for fsync_super() */
32 #include <linux/mount.h>
33 #include <linux/security.h>
34 #include <linux/syscalls.h>
35 #include <linux/vfs.h>
36 #include <linux/writeback.h>		/* for the emergency remount stuff */
37 #include <linux/idr.h>
38 #include <linux/kobject.h>
39 #include <linux/mutex.h>
40 #include <linux/file.h>
41 #include <asm/uaccess.h>
42 #include "internal.h"
43 
44 
45 LIST_HEAD(super_blocks);
46 DEFINE_SPINLOCK(sb_lock);
47 
48 /**
49  *	alloc_super	-	create new superblock
50  *	@type:	filesystem type superblock should belong to
51  *
52  *	Allocates and initializes a new &struct super_block.  alloc_super()
53  *	returns a pointer new superblock or %NULL if allocation had failed.
54  */
55 static struct super_block *alloc_super(struct file_system_type *type)
56 {
57 	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
58 	static struct super_operations default_op;
59 
60 	if (s) {
61 		if (security_sb_alloc(s)) {
62 			kfree(s);
63 			s = NULL;
64 			goto out;
65 		}
66 		INIT_LIST_HEAD(&s->s_dirty);
67 		INIT_LIST_HEAD(&s->s_io);
68 		INIT_LIST_HEAD(&s->s_more_io);
69 		INIT_LIST_HEAD(&s->s_files);
70 		INIT_LIST_HEAD(&s->s_instances);
71 		INIT_HLIST_HEAD(&s->s_anon);
72 		INIT_LIST_HEAD(&s->s_inodes);
73 		INIT_LIST_HEAD(&s->s_dentry_lru);
74 		init_rwsem(&s->s_umount);
75 		mutex_init(&s->s_lock);
76 		lockdep_set_class(&s->s_umount, &type->s_umount_key);
77 		/*
78 		 * The locking rules for s_lock are up to the
79 		 * filesystem. For example ext3fs has different
80 		 * lock ordering than usbfs:
81 		 */
82 		lockdep_set_class(&s->s_lock, &type->s_lock_key);
83 		down_write(&s->s_umount);
84 		s->s_count = S_BIAS;
85 		atomic_set(&s->s_active, 1);
86 		mutex_init(&s->s_vfs_rename_mutex);
87 		mutex_init(&s->s_dquot.dqio_mutex);
88 		mutex_init(&s->s_dquot.dqonoff_mutex);
89 		init_rwsem(&s->s_dquot.dqptr_sem);
90 		init_waitqueue_head(&s->s_wait_unfrozen);
91 		s->s_maxbytes = MAX_NON_LFS;
92 		s->dq_op = sb_dquot_ops;
93 		s->s_qcop = sb_quotactl_ops;
94 		s->s_op = &default_op;
95 		s->s_time_gran = 1000000000;
96 	}
97 out:
98 	return s;
99 }
100 
101 /**
102  *	destroy_super	-	frees a superblock
103  *	@s: superblock to free
104  *
105  *	Frees a superblock.
106  */
107 static inline void destroy_super(struct super_block *s)
108 {
109 	security_sb_free(s);
110 	kfree(s->s_subtype);
111 	kfree(s->s_options);
112 	kfree(s);
113 }
114 
115 /* Superblock refcounting  */
116 
117 /*
118  * Drop a superblock's refcount.  Returns non-zero if the superblock was
119  * destroyed.  The caller must hold sb_lock.
120  */
121 static int __put_super(struct super_block *sb)
122 {
123 	int ret = 0;
124 
125 	if (!--sb->s_count) {
126 		destroy_super(sb);
127 		ret = 1;
128 	}
129 	return ret;
130 }
131 
132 /*
133  * Drop a superblock's refcount.
134  * Returns non-zero if the superblock is about to be destroyed and
135  * at least is already removed from super_blocks list, so if we are
136  * making a loop through super blocks then we need to restart.
137  * The caller must hold sb_lock.
138  */
139 int __put_super_and_need_restart(struct super_block *sb)
140 {
141 	/* check for race with generic_shutdown_super() */
142 	if (list_empty(&sb->s_list)) {
143 		/* super block is removed, need to restart... */
144 		__put_super(sb);
145 		return 1;
146 	}
147 	/* can't be the last, since s_list is still in use */
148 	sb->s_count--;
149 	BUG_ON(sb->s_count == 0);
150 	return 0;
151 }
152 
153 /**
154  *	put_super	-	drop a temporary reference to superblock
155  *	@sb: superblock in question
156  *
157  *	Drops a temporary reference, frees superblock if there's no
158  *	references left.
159  */
160 static void put_super(struct super_block *sb)
161 {
162 	spin_lock(&sb_lock);
163 	__put_super(sb);
164 	spin_unlock(&sb_lock);
165 }
166 
167 
168 /**
169  *	deactivate_super	-	drop an active reference to superblock
170  *	@s: superblock to deactivate
171  *
172  *	Drops an active reference to superblock, acquiring a temprory one if
173  *	there is no active references left.  In that case we lock superblock,
174  *	tell fs driver to shut it down and drop the temporary reference we
175  *	had just acquired.
176  */
177 void deactivate_super(struct super_block *s)
178 {
179 	struct file_system_type *fs = s->s_type;
180 	if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
181 		s->s_count -= S_BIAS-1;
182 		spin_unlock(&sb_lock);
183 		DQUOT_OFF(s, 0);
184 		down_write(&s->s_umount);
185 		fs->kill_sb(s);
186 		put_filesystem(fs);
187 		put_super(s);
188 	}
189 }
190 
191 EXPORT_SYMBOL(deactivate_super);
192 
193 /**
194  *	grab_super - acquire an active reference
195  *	@s: reference we are trying to make active
196  *
197  *	Tries to acquire an active reference.  grab_super() is used when we
198  * 	had just found a superblock in super_blocks or fs_type->fs_supers
199  *	and want to turn it into a full-blown active reference.  grab_super()
200  *	is called with sb_lock held and drops it.  Returns 1 in case of
201  *	success, 0 if we had failed (superblock contents was already dead or
202  *	dying when grab_super() had been called).
203  */
204 static int grab_super(struct super_block *s) __releases(sb_lock)
205 {
206 	s->s_count++;
207 	spin_unlock(&sb_lock);
208 	down_write(&s->s_umount);
209 	if (s->s_root) {
210 		spin_lock(&sb_lock);
211 		if (s->s_count > S_BIAS) {
212 			atomic_inc(&s->s_active);
213 			s->s_count--;
214 			spin_unlock(&sb_lock);
215 			return 1;
216 		}
217 		spin_unlock(&sb_lock);
218 	}
219 	up_write(&s->s_umount);
220 	put_super(s);
221 	yield();
222 	return 0;
223 }
224 
225 /*
226  * Superblock locking.  We really ought to get rid of these two.
227  */
228 void lock_super(struct super_block * sb)
229 {
230 	get_fs_excl();
231 	mutex_lock(&sb->s_lock);
232 }
233 
234 void unlock_super(struct super_block * sb)
235 {
236 	put_fs_excl();
237 	mutex_unlock(&sb->s_lock);
238 }
239 
240 EXPORT_SYMBOL(lock_super);
241 EXPORT_SYMBOL(unlock_super);
242 
243 /*
244  * Write out and wait upon all dirty data associated with this
245  * superblock.  Filesystem data as well as the underlying block
246  * device.  Takes the superblock lock.  Requires a second blkdev
247  * flush by the caller to complete the operation.
248  */
249 void __fsync_super(struct super_block *sb)
250 {
251 	sync_inodes_sb(sb, 0);
252 	DQUOT_SYNC(sb);
253 	lock_super(sb);
254 	if (sb->s_dirt && sb->s_op->write_super)
255 		sb->s_op->write_super(sb);
256 	unlock_super(sb);
257 	if (sb->s_op->sync_fs)
258 		sb->s_op->sync_fs(sb, 1);
259 	sync_blockdev(sb->s_bdev);
260 	sync_inodes_sb(sb, 1);
261 }
262 
263 /*
264  * Write out and wait upon all dirty data associated with this
265  * superblock.  Filesystem data as well as the underlying block
266  * device.  Takes the superblock lock.
267  */
268 int fsync_super(struct super_block *sb)
269 {
270 	__fsync_super(sb);
271 	return sync_blockdev(sb->s_bdev);
272 }
273 
274 /**
275  *	generic_shutdown_super	-	common helper for ->kill_sb()
276  *	@sb: superblock to kill
277  *
278  *	generic_shutdown_super() does all fs-independent work on superblock
279  *	shutdown.  Typical ->kill_sb() should pick all fs-specific objects
280  *	that need destruction out of superblock, call generic_shutdown_super()
281  *	and release aforementioned objects.  Note: dentries and inodes _are_
282  *	taken care of and do not need specific handling.
283  *
284  *	Upon calling this function, the filesystem may no longer alter or
285  *	rearrange the set of dentries belonging to this super_block, nor may it
286  *	change the attachments of dentries to inodes.
287  */
288 void generic_shutdown_super(struct super_block *sb)
289 {
290 	const struct super_operations *sop = sb->s_op;
291 
292 	if (sb->s_root) {
293 		shrink_dcache_for_umount(sb);
294 		fsync_super(sb);
295 		lock_super(sb);
296 		sb->s_flags &= ~MS_ACTIVE;
297 		/* bad name - it should be evict_inodes() */
298 		invalidate_inodes(sb);
299 		lock_kernel();
300 
301 		if (sop->write_super && sb->s_dirt)
302 			sop->write_super(sb);
303 		if (sop->put_super)
304 			sop->put_super(sb);
305 
306 		/* Forget any remaining inodes */
307 		if (invalidate_inodes(sb)) {
308 			printk("VFS: Busy inodes after unmount of %s. "
309 			   "Self-destruct in 5 seconds.  Have a nice day...\n",
310 			   sb->s_id);
311 		}
312 
313 		unlock_kernel();
314 		unlock_super(sb);
315 	}
316 	spin_lock(&sb_lock);
317 	/* should be initialized for __put_super_and_need_restart() */
318 	list_del_init(&sb->s_list);
319 	list_del(&sb->s_instances);
320 	spin_unlock(&sb_lock);
321 	up_write(&sb->s_umount);
322 }
323 
324 EXPORT_SYMBOL(generic_shutdown_super);
325 
326 /**
327  *	sget	-	find or create a superblock
328  *	@type:	filesystem type superblock should belong to
329  *	@test:	comparison callback
330  *	@set:	setup callback
331  *	@data:	argument to each of them
332  */
333 struct super_block *sget(struct file_system_type *type,
334 			int (*test)(struct super_block *,void *),
335 			int (*set)(struct super_block *,void *),
336 			void *data)
337 {
338 	struct super_block *s = NULL;
339 	struct super_block *old;
340 	int err;
341 
342 retry:
343 	spin_lock(&sb_lock);
344 	if (test) {
345 		list_for_each_entry(old, &type->fs_supers, s_instances) {
346 			if (!test(old, data))
347 				continue;
348 			if (!grab_super(old))
349 				goto retry;
350 			if (s)
351 				destroy_super(s);
352 			return old;
353 		}
354 	}
355 	if (!s) {
356 		spin_unlock(&sb_lock);
357 		s = alloc_super(type);
358 		if (!s)
359 			return ERR_PTR(-ENOMEM);
360 		goto retry;
361 	}
362 
363 	err = set(s, data);
364 	if (err) {
365 		spin_unlock(&sb_lock);
366 		destroy_super(s);
367 		return ERR_PTR(err);
368 	}
369 	s->s_type = type;
370 	strlcpy(s->s_id, type->name, sizeof(s->s_id));
371 	list_add_tail(&s->s_list, &super_blocks);
372 	list_add(&s->s_instances, &type->fs_supers);
373 	spin_unlock(&sb_lock);
374 	get_filesystem(type);
375 	return s;
376 }
377 
378 EXPORT_SYMBOL(sget);
379 
380 void drop_super(struct super_block *sb)
381 {
382 	up_read(&sb->s_umount);
383 	put_super(sb);
384 }
385 
386 EXPORT_SYMBOL(drop_super);
387 
388 static inline void write_super(struct super_block *sb)
389 {
390 	lock_super(sb);
391 	if (sb->s_root && sb->s_dirt)
392 		if (sb->s_op->write_super)
393 			sb->s_op->write_super(sb);
394 	unlock_super(sb);
395 }
396 
397 /*
398  * Note: check the dirty flag before waiting, so we don't
399  * hold up the sync while mounting a device. (The newly
400  * mounted device won't need syncing.)
401  */
402 void sync_supers(void)
403 {
404 	struct super_block *sb;
405 
406 	spin_lock(&sb_lock);
407 restart:
408 	list_for_each_entry(sb, &super_blocks, s_list) {
409 		if (sb->s_dirt) {
410 			sb->s_count++;
411 			spin_unlock(&sb_lock);
412 			down_read(&sb->s_umount);
413 			write_super(sb);
414 			up_read(&sb->s_umount);
415 			spin_lock(&sb_lock);
416 			if (__put_super_and_need_restart(sb))
417 				goto restart;
418 		}
419 	}
420 	spin_unlock(&sb_lock);
421 }
422 
423 /*
424  * Call the ->sync_fs super_op against all filesystems which are r/w and
425  * which implement it.
426  *
427  * This operation is careful to avoid the livelock which could easily happen
428  * if two or more filesystems are being continuously dirtied.  s_need_sync_fs
429  * is used only here.  We set it against all filesystems and then clear it as
430  * we sync them.  So redirtied filesystems are skipped.
431  *
432  * But if process A is currently running sync_filesystems and then process B
433  * calls sync_filesystems as well, process B will set all the s_need_sync_fs
434  * flags again, which will cause process A to resync everything.  Fix that with
435  * a local mutex.
436  *
437  * (Fabian) Avoid sync_fs with clean fs & wait mode 0
438  */
439 void sync_filesystems(int wait)
440 {
441 	struct super_block *sb;
442 	static DEFINE_MUTEX(mutex);
443 
444 	mutex_lock(&mutex);		/* Could be down_interruptible */
445 	spin_lock(&sb_lock);
446 	list_for_each_entry(sb, &super_blocks, s_list) {
447 		if (!sb->s_op->sync_fs)
448 			continue;
449 		if (sb->s_flags & MS_RDONLY)
450 			continue;
451 		sb->s_need_sync_fs = 1;
452 	}
453 
454 restart:
455 	list_for_each_entry(sb, &super_blocks, s_list) {
456 		if (!sb->s_need_sync_fs)
457 			continue;
458 		sb->s_need_sync_fs = 0;
459 		if (sb->s_flags & MS_RDONLY)
460 			continue;	/* hm.  Was remounted r/o meanwhile */
461 		sb->s_count++;
462 		spin_unlock(&sb_lock);
463 		down_read(&sb->s_umount);
464 		if (sb->s_root && (wait || sb->s_dirt))
465 			sb->s_op->sync_fs(sb, wait);
466 		up_read(&sb->s_umount);
467 		/* restart only when sb is no longer on the list */
468 		spin_lock(&sb_lock);
469 		if (__put_super_and_need_restart(sb))
470 			goto restart;
471 	}
472 	spin_unlock(&sb_lock);
473 	mutex_unlock(&mutex);
474 }
475 
476 /**
477  *	get_super - get the superblock of a device
478  *	@bdev: device to get the superblock for
479  *
480  *	Scans the superblock list and finds the superblock of the file system
481  *	mounted on the device given. %NULL is returned if no match is found.
482  */
483 
484 struct super_block * get_super(struct block_device *bdev)
485 {
486 	struct super_block *sb;
487 
488 	if (!bdev)
489 		return NULL;
490 
491 	spin_lock(&sb_lock);
492 rescan:
493 	list_for_each_entry(sb, &super_blocks, s_list) {
494 		if (sb->s_bdev == bdev) {
495 			sb->s_count++;
496 			spin_unlock(&sb_lock);
497 			down_read(&sb->s_umount);
498 			if (sb->s_root)
499 				return sb;
500 			up_read(&sb->s_umount);
501 			/* restart only when sb is no longer on the list */
502 			spin_lock(&sb_lock);
503 			if (__put_super_and_need_restart(sb))
504 				goto rescan;
505 		}
506 	}
507 	spin_unlock(&sb_lock);
508 	return NULL;
509 }
510 
511 EXPORT_SYMBOL(get_super);
512 
513 struct super_block * user_get_super(dev_t dev)
514 {
515 	struct super_block *sb;
516 
517 	spin_lock(&sb_lock);
518 rescan:
519 	list_for_each_entry(sb, &super_blocks, s_list) {
520 		if (sb->s_dev ==  dev) {
521 			sb->s_count++;
522 			spin_unlock(&sb_lock);
523 			down_read(&sb->s_umount);
524 			if (sb->s_root)
525 				return sb;
526 			up_read(&sb->s_umount);
527 			/* restart only when sb is no longer on the list */
528 			spin_lock(&sb_lock);
529 			if (__put_super_and_need_restart(sb))
530 				goto rescan;
531 		}
532 	}
533 	spin_unlock(&sb_lock);
534 	return NULL;
535 }
536 
537 asmlinkage long sys_ustat(unsigned dev, struct ustat __user * ubuf)
538 {
539         struct super_block *s;
540         struct ustat tmp;
541         struct kstatfs sbuf;
542 	int err = -EINVAL;
543 
544         s = user_get_super(new_decode_dev(dev));
545         if (s == NULL)
546                 goto out;
547 	err = vfs_statfs(s->s_root, &sbuf);
548 	drop_super(s);
549 	if (err)
550 		goto out;
551 
552         memset(&tmp,0,sizeof(struct ustat));
553         tmp.f_tfree = sbuf.f_bfree;
554         tmp.f_tinode = sbuf.f_ffree;
555 
556         err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0;
557 out:
558 	return err;
559 }
560 
561 /**
562  *	mark_files_ro - mark all files read-only
563  *	@sb: superblock in question
564  *
565  *	All files are marked read-only.  We don't care about pending
566  *	delete files so this should be used in 'force' mode only.
567  */
568 
569 static void mark_files_ro(struct super_block *sb)
570 {
571 	struct file *f;
572 
573 retry:
574 	file_list_lock();
575 	list_for_each_entry(f, &sb->s_files, f_u.fu_list) {
576 		struct vfsmount *mnt;
577 		if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
578 		       continue;
579 		if (!file_count(f))
580 			continue;
581 		if (!(f->f_mode & FMODE_WRITE))
582 			continue;
583 		f->f_mode &= ~FMODE_WRITE;
584 		if (file_check_writeable(f) != 0)
585 			continue;
586 		file_release_write(f);
587 		mnt = mntget(f->f_path.mnt);
588 		file_list_unlock();
589 		/*
590 		 * This can sleep, so we can't hold
591 		 * the file_list_lock() spinlock.
592 		 */
593 		mnt_drop_write(mnt);
594 		mntput(mnt);
595 		goto retry;
596 	}
597 	file_list_unlock();
598 }
599 
600 /**
601  *	do_remount_sb - asks filesystem to change mount options.
602  *	@sb:	superblock in question
603  *	@flags:	numeric part of options
604  *	@data:	the rest of options
605  *      @force: whether or not to force the change
606  *
607  *	Alters the mount options of a mounted file system.
608  */
609 int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
610 {
611 	int retval;
612 	int remount_rw;
613 
614 #ifdef CONFIG_BLOCK
615 	if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
616 		return -EACCES;
617 #endif
618 	if (flags & MS_RDONLY)
619 		acct_auto_close(sb);
620 	shrink_dcache_sb(sb);
621 	fsync_super(sb);
622 
623 	/* If we are remounting RDONLY and current sb is read/write,
624 	   make sure there are no rw files opened */
625 	if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) {
626 		if (force)
627 			mark_files_ro(sb);
628 		else if (!fs_may_remount_ro(sb))
629 			return -EBUSY;
630 		retval = DQUOT_OFF(sb, 1);
631 		if (retval < 0 && retval != -ENOSYS)
632 			return -EBUSY;
633 	}
634 	remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY);
635 
636 	if (sb->s_op->remount_fs) {
637 		lock_super(sb);
638 		retval = sb->s_op->remount_fs(sb, &flags, data);
639 		unlock_super(sb);
640 		if (retval)
641 			return retval;
642 	}
643 	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
644 	if (remount_rw)
645 		DQUOT_ON_REMOUNT(sb);
646 	return 0;
647 }
648 
649 static void do_emergency_remount(unsigned long foo)
650 {
651 	struct super_block *sb;
652 
653 	spin_lock(&sb_lock);
654 	list_for_each_entry(sb, &super_blocks, s_list) {
655 		sb->s_count++;
656 		spin_unlock(&sb_lock);
657 		down_read(&sb->s_umount);
658 		if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
659 			/*
660 			 * ->remount_fs needs lock_kernel().
661 			 *
662 			 * What lock protects sb->s_flags??
663 			 */
664 			lock_kernel();
665 			do_remount_sb(sb, MS_RDONLY, NULL, 1);
666 			unlock_kernel();
667 		}
668 		drop_super(sb);
669 		spin_lock(&sb_lock);
670 	}
671 	spin_unlock(&sb_lock);
672 	printk("Emergency Remount complete\n");
673 }
674 
675 void emergency_remount(void)
676 {
677 	pdflush_operation(do_emergency_remount, 0);
678 }
679 
680 /*
681  * Unnamed block devices are dummy devices used by virtual
682  * filesystems which don't use real block-devices.  -- jrs
683  */
684 
685 static DEFINE_IDA(unnamed_dev_ida);
686 static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
687 
688 int set_anon_super(struct super_block *s, void *data)
689 {
690 	int dev;
691 	int error;
692 
693  retry:
694 	if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
695 		return -ENOMEM;
696 	spin_lock(&unnamed_dev_lock);
697 	error = ida_get_new(&unnamed_dev_ida, &dev);
698 	spin_unlock(&unnamed_dev_lock);
699 	if (error == -EAGAIN)
700 		/* We raced and lost with another CPU. */
701 		goto retry;
702 	else if (error)
703 		return -EAGAIN;
704 
705 	if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
706 		spin_lock(&unnamed_dev_lock);
707 		ida_remove(&unnamed_dev_ida, dev);
708 		spin_unlock(&unnamed_dev_lock);
709 		return -EMFILE;
710 	}
711 	s->s_dev = MKDEV(0, dev & MINORMASK);
712 	return 0;
713 }
714 
715 EXPORT_SYMBOL(set_anon_super);
716 
717 void kill_anon_super(struct super_block *sb)
718 {
719 	int slot = MINOR(sb->s_dev);
720 
721 	generic_shutdown_super(sb);
722 	spin_lock(&unnamed_dev_lock);
723 	ida_remove(&unnamed_dev_ida, slot);
724 	spin_unlock(&unnamed_dev_lock);
725 }
726 
727 EXPORT_SYMBOL(kill_anon_super);
728 
729 void kill_litter_super(struct super_block *sb)
730 {
731 	if (sb->s_root)
732 		d_genocide(sb->s_root);
733 	kill_anon_super(sb);
734 }
735 
736 EXPORT_SYMBOL(kill_litter_super);
737 
738 #ifdef CONFIG_BLOCK
739 static int set_bdev_super(struct super_block *s, void *data)
740 {
741 	s->s_bdev = data;
742 	s->s_dev = s->s_bdev->bd_dev;
743 	return 0;
744 }
745 
746 static int test_bdev_super(struct super_block *s, void *data)
747 {
748 	return (void *)s->s_bdev == data;
749 }
750 
751 int get_sb_bdev(struct file_system_type *fs_type,
752 	int flags, const char *dev_name, void *data,
753 	int (*fill_super)(struct super_block *, void *, int),
754 	struct vfsmount *mnt)
755 {
756 	struct block_device *bdev;
757 	struct super_block *s;
758 	fmode_t mode = FMODE_READ;
759 	int error = 0;
760 
761 	if (!(flags & MS_RDONLY))
762 		mode |= FMODE_WRITE;
763 
764 	bdev = open_bdev_exclusive(dev_name, mode, fs_type);
765 	if (IS_ERR(bdev))
766 		return PTR_ERR(bdev);
767 
768 	/*
769 	 * once the super is inserted into the list by sget, s_umount
770 	 * will protect the lockfs code from trying to start a snapshot
771 	 * while we are mounting
772 	 */
773 	down(&bdev->bd_mount_sem);
774 	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
775 	up(&bdev->bd_mount_sem);
776 	if (IS_ERR(s))
777 		goto error_s;
778 
779 	if (s->s_root) {
780 		if ((flags ^ s->s_flags) & MS_RDONLY) {
781 			up_write(&s->s_umount);
782 			deactivate_super(s);
783 			error = -EBUSY;
784 			goto error_bdev;
785 		}
786 
787 		close_bdev_exclusive(bdev, mode);
788 	} else {
789 		char b[BDEVNAME_SIZE];
790 
791 		s->s_flags = flags;
792 		s->s_mode = mode;
793 		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
794 		sb_set_blocksize(s, block_size(bdev));
795 		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
796 		if (error) {
797 			up_write(&s->s_umount);
798 			deactivate_super(s);
799 			goto error;
800 		}
801 
802 		s->s_flags |= MS_ACTIVE;
803 	}
804 
805 	return simple_set_mnt(mnt, s);
806 
807 error_s:
808 	error = PTR_ERR(s);
809 error_bdev:
810 	close_bdev_exclusive(bdev, mode);
811 error:
812 	return error;
813 }
814 
815 EXPORT_SYMBOL(get_sb_bdev);
816 
817 void kill_block_super(struct super_block *sb)
818 {
819 	struct block_device *bdev = sb->s_bdev;
820 	fmode_t mode = sb->s_mode;
821 
822 	generic_shutdown_super(sb);
823 	sync_blockdev(bdev);
824 	close_bdev_exclusive(bdev, mode);
825 }
826 
827 EXPORT_SYMBOL(kill_block_super);
828 #endif
829 
830 int get_sb_nodev(struct file_system_type *fs_type,
831 	int flags, void *data,
832 	int (*fill_super)(struct super_block *, void *, int),
833 	struct vfsmount *mnt)
834 {
835 	int error;
836 	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
837 
838 	if (IS_ERR(s))
839 		return PTR_ERR(s);
840 
841 	s->s_flags = flags;
842 
843 	error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
844 	if (error) {
845 		up_write(&s->s_umount);
846 		deactivate_super(s);
847 		return error;
848 	}
849 	s->s_flags |= MS_ACTIVE;
850 	return simple_set_mnt(mnt, s);
851 }
852 
853 EXPORT_SYMBOL(get_sb_nodev);
854 
855 static int compare_single(struct super_block *s, void *p)
856 {
857 	return 1;
858 }
859 
860 int get_sb_single(struct file_system_type *fs_type,
861 	int flags, void *data,
862 	int (*fill_super)(struct super_block *, void *, int),
863 	struct vfsmount *mnt)
864 {
865 	struct super_block *s;
866 	int error;
867 
868 	s = sget(fs_type, compare_single, set_anon_super, NULL);
869 	if (IS_ERR(s))
870 		return PTR_ERR(s);
871 	if (!s->s_root) {
872 		s->s_flags = flags;
873 		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
874 		if (error) {
875 			up_write(&s->s_umount);
876 			deactivate_super(s);
877 			return error;
878 		}
879 		s->s_flags |= MS_ACTIVE;
880 	}
881 	do_remount_sb(s, flags, data, 0);
882 	return simple_set_mnt(mnt, s);
883 }
884 
885 EXPORT_SYMBOL(get_sb_single);
886 
887 struct vfsmount *
888 vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
889 {
890 	struct vfsmount *mnt;
891 	char *secdata = NULL;
892 	int error;
893 
894 	if (!type)
895 		return ERR_PTR(-ENODEV);
896 
897 	error = -ENOMEM;
898 	mnt = alloc_vfsmnt(name);
899 	if (!mnt)
900 		goto out;
901 
902 	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
903 		secdata = alloc_secdata();
904 		if (!secdata)
905 			goto out_mnt;
906 
907 		error = security_sb_copy_data(data, secdata);
908 		if (error)
909 			goto out_free_secdata;
910 	}
911 
912 	error = type->get_sb(type, flags, name, data, mnt);
913 	if (error < 0)
914 		goto out_free_secdata;
915 	BUG_ON(!mnt->mnt_sb);
916 
917  	error = security_sb_kern_mount(mnt->mnt_sb, secdata);
918  	if (error)
919  		goto out_sb;
920 
921 	mnt->mnt_mountpoint = mnt->mnt_root;
922 	mnt->mnt_parent = mnt;
923 	up_write(&mnt->mnt_sb->s_umount);
924 	free_secdata(secdata);
925 	return mnt;
926 out_sb:
927 	dput(mnt->mnt_root);
928 	up_write(&mnt->mnt_sb->s_umount);
929 	deactivate_super(mnt->mnt_sb);
930 out_free_secdata:
931 	free_secdata(secdata);
932 out_mnt:
933 	free_vfsmnt(mnt);
934 out:
935 	return ERR_PTR(error);
936 }
937 
938 EXPORT_SYMBOL_GPL(vfs_kern_mount);
939 
940 static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
941 {
942 	int err;
943 	const char *subtype = strchr(fstype, '.');
944 	if (subtype) {
945 		subtype++;
946 		err = -EINVAL;
947 		if (!subtype[0])
948 			goto err;
949 	} else
950 		subtype = "";
951 
952 	mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
953 	err = -ENOMEM;
954 	if (!mnt->mnt_sb->s_subtype)
955 		goto err;
956 	return mnt;
957 
958  err:
959 	mntput(mnt);
960 	return ERR_PTR(err);
961 }
962 
963 struct vfsmount *
964 do_kern_mount(const char *fstype, int flags, const char *name, void *data)
965 {
966 	struct file_system_type *type = get_fs_type(fstype);
967 	struct vfsmount *mnt;
968 	if (!type)
969 		return ERR_PTR(-ENODEV);
970 	mnt = vfs_kern_mount(type, flags, name, data);
971 	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
972 	    !mnt->mnt_sb->s_subtype)
973 		mnt = fs_set_subtype(mnt, fstype);
974 	put_filesystem(type);
975 	return mnt;
976 }
977 EXPORT_SYMBOL_GPL(do_kern_mount);
978 
979 struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
980 {
981 	return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
982 }
983 
984 EXPORT_SYMBOL_GPL(kern_mount_data);
985