1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/export.h>
24#include <linux/slab.h>
25#include <linux/acct.h>
26#include <linux/blkdev.h>
27#include <linux/mount.h>
28#include <linux/security.h>
29#include <linux/writeback.h>
30#include <linux/idr.h>
31#include <linux/mutex.h>
32#include <linux/backing-dev.h>
33#include <linux/rculist_bl.h>
34#include <linux/cleancache.h>
35#include <linux/fsnotify.h>
36#include <linux/lockdep.h>
37#include "internal.h"
38
39
40LIST_HEAD(super_blocks);
41DEFINE_SPINLOCK(sb_lock);
42
43static char *sb_writers_name[SB_FREEZE_LEVELS] = {
44 "sb_writers",
45 "sb_pagefaults",
46 "sb_internal",
47};
48
49
50
51
52
53
54
55
56static int prune_super(struct shrinker *shrink, struct shrink_control *sc)
57{
58 struct super_block *sb;
59 int fs_objects = 0;
60 int total_objects;
61
62 sb = container_of(shrink, struct super_block, s_shrink);
63
64
65
66
67
68 if (sc->nr_to_scan && !(sc->gfp_mask & __GFP_FS))
69 return -1;
70
71 if (!grab_super_passive(sb))
72 return -1;
73
74 if (sb->s_op && sb->s_op->nr_cached_objects)
75 fs_objects = sb->s_op->nr_cached_objects(sb);
76
77 total_objects = sb->s_nr_dentry_unused +
78 sb->s_nr_inodes_unused + fs_objects + 1;
79
80 if (sc->nr_to_scan) {
81 int dentries;
82 int inodes;
83
84
85 dentries = (sc->nr_to_scan * sb->s_nr_dentry_unused) /
86 total_objects;
87 inodes = (sc->nr_to_scan * sb->s_nr_inodes_unused) /
88 total_objects;
89 if (fs_objects)
90 fs_objects = (sc->nr_to_scan * fs_objects) /
91 total_objects;
92
93
94
95
96 prune_dcache_sb(sb, dentries);
97 prune_icache_sb(sb, inodes);
98
99 if (fs_objects && sb->s_op->free_cached_objects) {
100 sb->s_op->free_cached_objects(sb, fs_objects);
101 fs_objects = sb->s_op->nr_cached_objects(sb);
102 }
103 total_objects = sb->s_nr_dentry_unused +
104 sb->s_nr_inodes_unused + fs_objects;
105 }
106
107 total_objects = (total_objects / 100) * sysctl_vfs_cache_pressure;
108 drop_super(sb);
109 return total_objects;
110}
111
112static int init_sb_writers(struct super_block *s, struct file_system_type *type)
113{
114 int err;
115 int i;
116
117 for (i = 0; i < SB_FREEZE_LEVELS; i++) {
118 err = percpu_counter_init(&s->s_writers.counter[i], 0);
119 if (err < 0)
120 goto err_out;
121 lockdep_init_map(&s->s_writers.lock_map[i], sb_writers_name[i],
122 &type->s_writers_key[i], 0);
123 }
124 init_waitqueue_head(&s->s_writers.wait);
125 init_waitqueue_head(&s->s_writers.wait_unfrozen);
126 return 0;
127err_out:
128 while (--i >= 0)
129 percpu_counter_destroy(&s->s_writers.counter[i]);
130 return err;
131}
132
133static void destroy_sb_writers(struct super_block *s)
134{
135 int i;
136
137 for (i = 0; i < SB_FREEZE_LEVELS; i++)
138 percpu_counter_destroy(&s->s_writers.counter[i]);
139}
140
141
142
143
144
145
146
147
148
149static struct super_block *alloc_super(struct file_system_type *type, int flags)
150{
151 struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
152 static const struct super_operations default_op;
153
154 if (s) {
155 if (security_sb_alloc(s)) {
156
157
158
159
160 kfree(s);
161 s = NULL;
162 goto out;
163 }
164#ifdef CONFIG_SMP
165 s->s_files = alloc_percpu(struct list_head);
166 if (!s->s_files)
167 goto err_out;
168 else {
169 int i;
170
171 for_each_possible_cpu(i)
172 INIT_LIST_HEAD(per_cpu_ptr(s->s_files, i));
173 }
174#else
175 INIT_LIST_HEAD(&s->s_files);
176#endif
177 if (init_sb_writers(s, type))
178 goto err_out;
179 s->s_flags = flags;
180 s->s_bdi = &default_backing_dev_info;
181 INIT_HLIST_NODE(&s->s_instances);
182 INIT_HLIST_BL_HEAD(&s->s_anon);
183 INIT_LIST_HEAD(&s->s_inodes);
184 INIT_LIST_HEAD(&s->s_dentry_lru);
185 INIT_LIST_HEAD(&s->s_inode_lru);
186 spin_lock_init(&s->s_inode_lru_lock);
187 INIT_LIST_HEAD(&s->s_mounts);
188 init_rwsem(&s->s_umount);
189 lockdep_set_class(&s->s_umount, &type->s_umount_key);
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205 down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
206 s->s_count = 1;
207 atomic_set(&s->s_active, 1);
208 mutex_init(&s->s_vfs_rename_mutex);
209 lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
210 mutex_init(&s->s_dquot.dqio_mutex);
211 mutex_init(&s->s_dquot.dqonoff_mutex);
212 init_rwsem(&s->s_dquot.dqptr_sem);
213 s->s_maxbytes = MAX_NON_LFS;
214 s->s_op = &default_op;
215 s->s_time_gran = 1000000000;
216 s->cleancache_poolid = -1;
217
218 s->s_shrink.seeks = DEFAULT_SEEKS;
219 s->s_shrink.shrink = prune_super;
220 s->s_shrink.batch = 1024;
221 }
222out:
223 return s;
224err_out:
225 security_sb_free(s);
226#ifdef CONFIG_SMP
227 if (s->s_files)
228 free_percpu(s->s_files);
229#endif
230 destroy_sb_writers(s);
231 kfree(s);
232 s = NULL;
233 goto out;
234}
235
236
237
238
239
240
241
242static inline void destroy_super(struct super_block *s)
243{
244#ifdef CONFIG_SMP
245 free_percpu(s->s_files);
246#endif
247 destroy_sb_writers(s);
248 security_sb_free(s);
249 WARN_ON(!list_empty(&s->s_mounts));
250 kfree(s->s_subtype);
251 kfree(s->s_options);
252 kfree(s);
253}
254
255
256
257
258
259
260static void __put_super(struct super_block *sb)
261{
262 if (!--sb->s_count) {
263 list_del_init(&sb->s_list);
264 destroy_super(sb);
265 }
266}
267
268
269
270
271
272
273
274
275static void put_super(struct super_block *sb)
276{
277 spin_lock(&sb_lock);
278 __put_super(sb);
279 spin_unlock(&sb_lock);
280}
281
282
283
284
285
286
287
288
289
290
291
292
293
294void deactivate_locked_super(struct super_block *s)
295{
296 struct file_system_type *fs = s->s_type;
297 if (atomic_dec_and_test(&s->s_active)) {
298 cleancache_invalidate_fs(s);
299 fs->kill_sb(s);
300
301
302 unregister_shrinker(&s->s_shrink);
303 put_filesystem(fs);
304 put_super(s);
305 } else {
306 up_write(&s->s_umount);
307 }
308}
309
310EXPORT_SYMBOL(deactivate_locked_super);
311
312
313
314
315
316
317
318
319
320void deactivate_super(struct super_block *s)
321{
322 if (!atomic_add_unless(&s->s_active, -1, 1)) {
323 down_write(&s->s_umount);
324 deactivate_locked_super(s);
325 }
326}
327
328EXPORT_SYMBOL(deactivate_super);
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343static int grab_super(struct super_block *s) __releases(sb_lock)
344{
345 s->s_count++;
346 spin_unlock(&sb_lock);
347 down_write(&s->s_umount);
348 if ((s->s_flags & MS_BORN) && atomic_inc_not_zero(&s->s_active)) {
349 put_super(s);
350 return 1;
351 }
352 up_write(&s->s_umount);
353 put_super(s);
354 return 0;
355}
356
357
358
359
360
361
362
363
364
365
366
367
368
369bool grab_super_passive(struct super_block *sb)
370{
371 spin_lock(&sb_lock);
372 if (hlist_unhashed(&sb->s_instances)) {
373 spin_unlock(&sb_lock);
374 return false;
375 }
376
377 sb->s_count++;
378 spin_unlock(&sb_lock);
379
380 if (down_read_trylock(&sb->s_umount)) {
381 if (sb->s_root && (sb->s_flags & MS_BORN))
382 return true;
383 up_read(&sb->s_umount);
384 }
385
386 put_super(sb);
387 return false;
388}
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404void generic_shutdown_super(struct super_block *sb)
405{
406 const struct super_operations *sop = sb->s_op;
407
408 if (sb->s_root) {
409 shrink_dcache_for_umount(sb);
410 sync_filesystem(sb);
411 sb->s_flags &= ~MS_ACTIVE;
412
413 fsnotify_unmount_inodes(&sb->s_inodes);
414
415 evict_inodes(sb);
416
417 if (sop->put_super)
418 sop->put_super(sb);
419
420 if (!list_empty(&sb->s_inodes)) {
421 printk("VFS: Busy inodes after unmount of %s. "
422 "Self-destruct in 5 seconds. Have a nice day...\n",
423 sb->s_id);
424 }
425 }
426 spin_lock(&sb_lock);
427
428 hlist_del_init(&sb->s_instances);
429 spin_unlock(&sb_lock);
430 up_write(&sb->s_umount);
431}
432
433EXPORT_SYMBOL(generic_shutdown_super);
434
435
436
437
438
439
440
441
442
443struct super_block *sget(struct file_system_type *type,
444 int (*test)(struct super_block *,void *),
445 int (*set)(struct super_block *,void *),
446 int flags,
447 void *data)
448{
449 struct super_block *s = NULL;
450 struct super_block *old;
451 int err;
452
453retry:
454 spin_lock(&sb_lock);
455 if (test) {
456 hlist_for_each_entry(old, &type->fs_supers, s_instances) {
457 if (!test(old, data))
458 continue;
459 if (!grab_super(old))
460 goto retry;
461 if (s) {
462 up_write(&s->s_umount);
463 destroy_super(s);
464 s = NULL;
465 }
466 return old;
467 }
468 }
469 if (!s) {
470 spin_unlock(&sb_lock);
471 s = alloc_super(type, flags);
472 if (!s)
473 return ERR_PTR(-ENOMEM);
474 goto retry;
475 }
476
477 err = set(s, data);
478 if (err) {
479 spin_unlock(&sb_lock);
480 up_write(&s->s_umount);
481 destroy_super(s);
482 return ERR_PTR(err);
483 }
484 s->s_type = type;
485 strlcpy(s->s_id, type->name, sizeof(s->s_id));
486 list_add_tail(&s->s_list, &super_blocks);
487 hlist_add_head(&s->s_instances, &type->fs_supers);
488 spin_unlock(&sb_lock);
489 get_filesystem(type);
490 register_shrinker(&s->s_shrink);
491 return s;
492}
493
494EXPORT_SYMBOL(sget);
495
496void drop_super(struct super_block *sb)
497{
498 up_read(&sb->s_umount);
499 put_super(sb);
500}
501
502EXPORT_SYMBOL(drop_super);
503
504
505
506
507
508
509
510
511
512void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
513{
514 struct super_block *sb, *p = NULL;
515
516 spin_lock(&sb_lock);
517 list_for_each_entry(sb, &super_blocks, s_list) {
518 if (hlist_unhashed(&sb->s_instances))
519 continue;
520 sb->s_count++;
521 spin_unlock(&sb_lock);
522
523 down_read(&sb->s_umount);
524 if (sb->s_root && (sb->s_flags & MS_BORN))
525 f(sb, arg);
526 up_read(&sb->s_umount);
527
528 spin_lock(&sb_lock);
529 if (p)
530 __put_super(p);
531 p = sb;
532 }
533 if (p)
534 __put_super(p);
535 spin_unlock(&sb_lock);
536}
537
538
539
540
541
542
543
544
545
546
547void iterate_supers_type(struct file_system_type *type,
548 void (*f)(struct super_block *, void *), void *arg)
549{
550 struct super_block *sb, *p = NULL;
551
552 spin_lock(&sb_lock);
553 hlist_for_each_entry(sb, &type->fs_supers, s_instances) {
554 sb->s_count++;
555 spin_unlock(&sb_lock);
556
557 down_read(&sb->s_umount);
558 if (sb->s_root && (sb->s_flags & MS_BORN))
559 f(sb, arg);
560 up_read(&sb->s_umount);
561
562 spin_lock(&sb_lock);
563 if (p)
564 __put_super(p);
565 p = sb;
566 }
567 if (p)
568 __put_super(p);
569 spin_unlock(&sb_lock);
570}
571
572EXPORT_SYMBOL(iterate_supers_type);
573
574
575
576
577
578
579
580
581
582struct super_block *get_super(struct block_device *bdev)
583{
584 struct super_block *sb;
585
586 if (!bdev)
587 return NULL;
588
589 spin_lock(&sb_lock);
590rescan:
591 list_for_each_entry(sb, &super_blocks, s_list) {
592 if (hlist_unhashed(&sb->s_instances))
593 continue;
594 if (sb->s_bdev == bdev) {
595 sb->s_count++;
596 spin_unlock(&sb_lock);
597 down_read(&sb->s_umount);
598
599 if (sb->s_root && (sb->s_flags & MS_BORN))
600 return sb;
601 up_read(&sb->s_umount);
602
603 spin_lock(&sb_lock);
604 __put_super(sb);
605 goto rescan;
606 }
607 }
608 spin_unlock(&sb_lock);
609 return NULL;
610}
611
612EXPORT_SYMBOL(get_super);
613
614
615
616
617
618
619
620
621
622
623struct super_block *get_super_thawed(struct block_device *bdev)
624{
625 while (1) {
626 struct super_block *s = get_super(bdev);
627 if (!s || s->s_writers.frozen == SB_UNFROZEN)
628 return s;
629 up_read(&s->s_umount);
630 wait_event(s->s_writers.wait_unfrozen,
631 s->s_writers.frozen == SB_UNFROZEN);
632 put_super(s);
633 }
634}
635EXPORT_SYMBOL(get_super_thawed);
636
637
638
639
640
641
642
643
644
645struct super_block *get_active_super(struct block_device *bdev)
646{
647 struct super_block *sb;
648
649 if (!bdev)
650 return NULL;
651
652restart:
653 spin_lock(&sb_lock);
654 list_for_each_entry(sb, &super_blocks, s_list) {
655 if (hlist_unhashed(&sb->s_instances))
656 continue;
657 if (sb->s_bdev == bdev) {
658 if (!grab_super(sb))
659 goto restart;
660 up_write(&sb->s_umount);
661 return sb;
662 }
663 }
664 spin_unlock(&sb_lock);
665 return NULL;
666}
667
668struct super_block *user_get_super(dev_t dev)
669{
670 struct super_block *sb;
671
672 spin_lock(&sb_lock);
673rescan:
674 list_for_each_entry(sb, &super_blocks, s_list) {
675 if (hlist_unhashed(&sb->s_instances))
676 continue;
677 if (sb->s_dev == dev) {
678 sb->s_count++;
679 spin_unlock(&sb_lock);
680 down_read(&sb->s_umount);
681
682 if (sb->s_root && (sb->s_flags & MS_BORN))
683 return sb;
684 up_read(&sb->s_umount);
685
686 spin_lock(&sb_lock);
687 __put_super(sb);
688 goto rescan;
689 }
690 }
691 spin_unlock(&sb_lock);
692 return NULL;
693}
694
695
696
697
698
699
700
701
702
703
704int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
705{
706 int retval;
707 int remount_ro;
708
709 if (sb->s_writers.frozen != SB_UNFROZEN)
710 return -EBUSY;
711
712#ifdef CONFIG_BLOCK
713 if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
714 return -EACCES;
715#endif
716
717 if (flags & MS_RDONLY)
718 acct_auto_close(sb);
719 shrink_dcache_sb(sb);
720 sync_filesystem(sb);
721
722 remount_ro = (flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY);
723
724
725
726 if (remount_ro) {
727 if (force) {
728 mark_files_ro(sb);
729 } else {
730 retval = sb_prepare_remount_readonly(sb);
731 if (retval)
732 return retval;
733 }
734 }
735
736 if (sb->s_op->remount_fs) {
737 retval = sb->s_op->remount_fs(sb, &flags, data);
738 if (retval) {
739 if (!force)
740 goto cancel_readonly;
741
742 WARN(1, "forced remount of a %s fs returned %i\n",
743 sb->s_type->name, retval);
744 }
745 }
746 sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
747
748 smp_wmb();
749 sb->s_readonly_remount = 0;
750
751
752
753
754
755
756
757
758
759 if (remount_ro && sb->s_bdev)
760 invalidate_bdev(sb->s_bdev);
761 return 0;
762
763cancel_readonly:
764 sb->s_readonly_remount = 0;
765 return retval;
766}
767
768static void do_emergency_remount(struct work_struct *work)
769{
770 struct super_block *sb, *p = NULL;
771
772 spin_lock(&sb_lock);
773 list_for_each_entry(sb, &super_blocks, s_list) {
774 if (hlist_unhashed(&sb->s_instances))
775 continue;
776 sb->s_count++;
777 spin_unlock(&sb_lock);
778 down_write(&sb->s_umount);
779 if (sb->s_root && sb->s_bdev && (sb->s_flags & MS_BORN) &&
780 !(sb->s_flags & MS_RDONLY)) {
781
782
783
784 do_remount_sb(sb, MS_RDONLY, NULL, 1);
785 }
786 up_write(&sb->s_umount);
787 spin_lock(&sb_lock);
788 if (p)
789 __put_super(p);
790 p = sb;
791 }
792 if (p)
793 __put_super(p);
794 spin_unlock(&sb_lock);
795 kfree(work);
796 printk("Emergency Remount complete\n");
797}
798
799void emergency_remount(void)
800{
801 struct work_struct *work;
802
803 work = kmalloc(sizeof(*work), GFP_ATOMIC);
804 if (work) {
805 INIT_WORK(work, do_emergency_remount);
806 schedule_work(work);
807 }
808}
809
810
811
812
813
814
815static DEFINE_IDA(unnamed_dev_ida);
816static DEFINE_SPINLOCK(unnamed_dev_lock);
817static int unnamed_dev_start = 0;
818
819int get_anon_bdev(dev_t *p)
820{
821 int dev;
822 int error;
823
824 retry:
825 if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
826 return -ENOMEM;
827 spin_lock(&unnamed_dev_lock);
828 error = ida_get_new_above(&unnamed_dev_ida, unnamed_dev_start, &dev);
829 if (!error)
830 unnamed_dev_start = dev + 1;
831 spin_unlock(&unnamed_dev_lock);
832 if (error == -EAGAIN)
833
834 goto retry;
835 else if (error)
836 return -EAGAIN;
837
838 if (dev == (1 << MINORBITS)) {
839 spin_lock(&unnamed_dev_lock);
840 ida_remove(&unnamed_dev_ida, dev);
841 if (unnamed_dev_start > dev)
842 unnamed_dev_start = dev;
843 spin_unlock(&unnamed_dev_lock);
844 return -EMFILE;
845 }
846 *p = MKDEV(0, dev & MINORMASK);
847 return 0;
848}
849EXPORT_SYMBOL(get_anon_bdev);
850
851void free_anon_bdev(dev_t dev)
852{
853 int slot = MINOR(dev);
854 spin_lock(&unnamed_dev_lock);
855 ida_remove(&unnamed_dev_ida, slot);
856 if (slot < unnamed_dev_start)
857 unnamed_dev_start = slot;
858 spin_unlock(&unnamed_dev_lock);
859}
860EXPORT_SYMBOL(free_anon_bdev);
861
862int set_anon_super(struct super_block *s, void *data)
863{
864 int error = get_anon_bdev(&s->s_dev);
865 if (!error)
866 s->s_bdi = &noop_backing_dev_info;
867 return error;
868}
869
870EXPORT_SYMBOL(set_anon_super);
871
872void kill_anon_super(struct super_block *sb)
873{
874 dev_t dev = sb->s_dev;
875 generic_shutdown_super(sb);
876 free_anon_bdev(dev);
877}
878
879EXPORT_SYMBOL(kill_anon_super);
880
881void kill_litter_super(struct super_block *sb)
882{
883 if (sb->s_root)
884 d_genocide(sb->s_root);
885 kill_anon_super(sb);
886}
887
888EXPORT_SYMBOL(kill_litter_super);
889
890static int ns_test_super(struct super_block *sb, void *data)
891{
892 return sb->s_fs_info == data;
893}
894
895static int ns_set_super(struct super_block *sb, void *data)
896{
897 sb->s_fs_info = data;
898 return set_anon_super(sb, NULL);
899}
900
901struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
902 void *data, int (*fill_super)(struct super_block *, void *, int))
903{
904 struct super_block *sb;
905
906 sb = sget(fs_type, ns_test_super, ns_set_super, flags, data);
907 if (IS_ERR(sb))
908 return ERR_CAST(sb);
909
910 if (!sb->s_root) {
911 int err;
912 err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
913 if (err) {
914 deactivate_locked_super(sb);
915 return ERR_PTR(err);
916 }
917
918 sb->s_flags |= MS_ACTIVE;
919 }
920
921 return dget(sb->s_root);
922}
923
924EXPORT_SYMBOL(mount_ns);
925
926#ifdef CONFIG_BLOCK
927static int set_bdev_super(struct super_block *s, void *data)
928{
929 s->s_bdev = data;
930 s->s_dev = s->s_bdev->bd_dev;
931
932
933
934
935
936 s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
937 return 0;
938}
939
940static int test_bdev_super(struct super_block *s, void *data)
941{
942 return (void *)s->s_bdev == data;
943}
944
945struct dentry *mount_bdev(struct file_system_type *fs_type,
946 int flags, const char *dev_name, void *data,
947 int (*fill_super)(struct super_block *, void *, int))
948{
949 struct block_device *bdev;
950 struct super_block *s;
951 fmode_t mode = FMODE_READ | FMODE_EXCL;
952 int error = 0;
953
954 if (!(flags & MS_RDONLY))
955 mode |= FMODE_WRITE;
956
957 bdev = blkdev_get_by_path(dev_name, mode, fs_type);
958 if (IS_ERR(bdev))
959 return ERR_CAST(bdev);
960
961
962
963
964
965
966 mutex_lock(&bdev->bd_fsfreeze_mutex);
967 if (bdev->bd_fsfreeze_count > 0) {
968 mutex_unlock(&bdev->bd_fsfreeze_mutex);
969 error = -EBUSY;
970 goto error_bdev;
971 }
972 s = sget(fs_type, test_bdev_super, set_bdev_super, flags | MS_NOSEC,
973 bdev);
974 mutex_unlock(&bdev->bd_fsfreeze_mutex);
975 if (IS_ERR(s))
976 goto error_s;
977
978 if (s->s_root) {
979 if ((flags ^ s->s_flags) & MS_RDONLY) {
980 deactivate_locked_super(s);
981 error = -EBUSY;
982 goto error_bdev;
983 }
984
985
986
987
988
989
990
991
992 up_write(&s->s_umount);
993 blkdev_put(bdev, mode);
994 down_write(&s->s_umount);
995 } else {
996 char b[BDEVNAME_SIZE];
997
998 s->s_mode = mode;
999 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1000 sb_set_blocksize(s, block_size(bdev));
1001 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
1002 if (error) {
1003 deactivate_locked_super(s);
1004 goto error;
1005 }
1006
1007 s->s_flags |= MS_ACTIVE;
1008 bdev->bd_super = s;
1009 }
1010
1011 return dget(s->s_root);
1012
1013error_s:
1014 error = PTR_ERR(s);
1015error_bdev:
1016 blkdev_put(bdev, mode);
1017error:
1018 return ERR_PTR(error);
1019}
1020EXPORT_SYMBOL(mount_bdev);
1021
1022void kill_block_super(struct super_block *sb)
1023{
1024 struct block_device *bdev = sb->s_bdev;
1025 fmode_t mode = sb->s_mode;
1026
1027 bdev->bd_super = NULL;
1028 generic_shutdown_super(sb);
1029 sync_blockdev(bdev);
1030 WARN_ON_ONCE(!(mode & FMODE_EXCL));
1031 blkdev_put(bdev, mode | FMODE_EXCL);
1032}
1033
1034EXPORT_SYMBOL(kill_block_super);
1035#endif
1036
1037struct dentry *mount_nodev(struct file_system_type *fs_type,
1038 int flags, void *data,
1039 int (*fill_super)(struct super_block *, void *, int))
1040{
1041 int error;
1042 struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
1043
1044 if (IS_ERR(s))
1045 return ERR_CAST(s);
1046
1047 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
1048 if (error) {
1049 deactivate_locked_super(s);
1050 return ERR_PTR(error);
1051 }
1052 s->s_flags |= MS_ACTIVE;
1053 return dget(s->s_root);
1054}
1055EXPORT_SYMBOL(mount_nodev);
1056
1057static int compare_single(struct super_block *s, void *p)
1058{
1059 return 1;
1060}
1061
1062struct dentry *mount_single(struct file_system_type *fs_type,
1063 int flags, void *data,
1064 int (*fill_super)(struct super_block *, void *, int))
1065{
1066 struct super_block *s;
1067 int error;
1068
1069 s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
1070 if (IS_ERR(s))
1071 return ERR_CAST(s);
1072 if (!s->s_root) {
1073 error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
1074 if (error) {
1075 deactivate_locked_super(s);
1076 return ERR_PTR(error);
1077 }
1078 s->s_flags |= MS_ACTIVE;
1079 } else {
1080 do_remount_sb(s, flags, data, 0);
1081 }
1082 return dget(s->s_root);
1083}
1084EXPORT_SYMBOL(mount_single);
1085
1086struct dentry *
1087mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
1088{
1089 struct dentry *root;
1090 struct super_block *sb;
1091 char *secdata = NULL;
1092 int error = -ENOMEM;
1093
1094 if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
1095 secdata = alloc_secdata();
1096 if (!secdata)
1097 goto out;
1098
1099 error = security_sb_copy_data(data, secdata);
1100 if (error)
1101 goto out_free_secdata;
1102 }
1103
1104 root = type->mount(type, flags, name, data);
1105 if (IS_ERR(root)) {
1106 error = PTR_ERR(root);
1107 goto out_free_secdata;
1108 }
1109 sb = root->d_sb;
1110 BUG_ON(!sb);
1111 WARN_ON(!sb->s_bdi);
1112 WARN_ON(sb->s_bdi == &default_backing_dev_info);
1113 sb->s_flags |= MS_BORN;
1114
1115 error = security_sb_kern_mount(sb, flags, secdata);
1116 if (error)
1117 goto out_sb;
1118
1119
1120
1121
1122
1123
1124
1125 WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
1126 "negative value (%lld)\n", type->name, sb->s_maxbytes);
1127
1128 up_write(&sb->s_umount);
1129 free_secdata(secdata);
1130 return root;
1131out_sb:
1132 dput(root);
1133 deactivate_locked_super(sb);
1134out_free_secdata:
1135 free_secdata(secdata);
1136out:
1137 return ERR_PTR(error);
1138}
1139
1140
1141
1142
1143
1144void __sb_end_write(struct super_block *sb, int level)
1145{
1146 percpu_counter_dec(&sb->s_writers.counter[level-1]);
1147
1148
1149
1150
1151 smp_mb();
1152 if (waitqueue_active(&sb->s_writers.wait))
1153 wake_up(&sb->s_writers.wait);
1154 rwsem_release(&sb->s_writers.lock_map[level-1], 1, _RET_IP_);
1155}
1156EXPORT_SYMBOL(__sb_end_write);
1157
1158#ifdef CONFIG_LOCKDEP
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168static void acquire_freeze_lock(struct super_block *sb, int level, bool trylock,
1169 unsigned long ip)
1170{
1171 int i;
1172
1173 if (!trylock) {
1174 for (i = 0; i < level - 1; i++)
1175 if (lock_is_held(&sb->s_writers.lock_map[i])) {
1176 trylock = true;
1177 break;
1178 }
1179 }
1180 rwsem_acquire_read(&sb->s_writers.lock_map[level-1], 0, trylock, ip);
1181}
1182#endif
1183
1184
1185
1186
1187
1188int __sb_start_write(struct super_block *sb, int level, bool wait)
1189{
1190retry:
1191 if (unlikely(sb->s_writers.frozen >= level)) {
1192 if (!wait)
1193 return 0;
1194 wait_event(sb->s_writers.wait_unfrozen,
1195 sb->s_writers.frozen < level);
1196 }
1197
1198#ifdef CONFIG_LOCKDEP
1199 acquire_freeze_lock(sb, level, !wait, _RET_IP_);
1200#endif
1201 percpu_counter_inc(&sb->s_writers.counter[level-1]);
1202
1203
1204
1205
1206 smp_mb();
1207 if (unlikely(sb->s_writers.frozen >= level)) {
1208 __sb_end_write(sb, level);
1209 goto retry;
1210 }
1211 return 1;
1212}
1213EXPORT_SYMBOL(__sb_start_write);
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225static void sb_wait_write(struct super_block *sb, int level)
1226{
1227 s64 writers;
1228
1229
1230
1231
1232
1233 rwsem_acquire(&sb->s_writers.lock_map[level-1], 0, 0, _THIS_IP_);
1234 rwsem_release(&sb->s_writers.lock_map[level-1], 1, _THIS_IP_);
1235
1236 do {
1237 DEFINE_WAIT(wait);
1238
1239
1240
1241
1242
1243 prepare_to_wait(&sb->s_writers.wait, &wait,
1244 TASK_UNINTERRUPTIBLE);
1245
1246 writers = percpu_counter_sum(&sb->s_writers.counter[level-1]);
1247 if (writers)
1248 schedule();
1249
1250 finish_wait(&sb->s_writers.wait, &wait);
1251 } while (writers);
1252}
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287int freeze_super(struct super_block *sb)
1288{
1289 int ret;
1290
1291 atomic_inc(&sb->s_active);
1292 down_write(&sb->s_umount);
1293 if (sb->s_writers.frozen != SB_UNFROZEN) {
1294 deactivate_locked_super(sb);
1295 return -EBUSY;
1296 }
1297
1298 if (!(sb->s_flags & MS_BORN)) {
1299 up_write(&sb->s_umount);
1300 return 0;
1301 }
1302
1303 if (sb->s_flags & MS_RDONLY) {
1304
1305 sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1306 up_write(&sb->s_umount);
1307 return 0;
1308 }
1309
1310
1311 sb->s_writers.frozen = SB_FREEZE_WRITE;
1312 smp_wmb();
1313
1314
1315 up_write(&sb->s_umount);
1316
1317 sb_wait_write(sb, SB_FREEZE_WRITE);
1318
1319
1320 down_write(&sb->s_umount);
1321 sb->s_writers.frozen = SB_FREEZE_PAGEFAULT;
1322 smp_wmb();
1323
1324 sb_wait_write(sb, SB_FREEZE_PAGEFAULT);
1325
1326
1327 sync_filesystem(sb);
1328
1329
1330 sb->s_writers.frozen = SB_FREEZE_FS;
1331 smp_wmb();
1332 sb_wait_write(sb, SB_FREEZE_FS);
1333
1334 if (sb->s_op->freeze_fs) {
1335 ret = sb->s_op->freeze_fs(sb);
1336 if (ret) {
1337 printk(KERN_ERR
1338 "VFS:Filesystem freeze failed\n");
1339 sb->s_writers.frozen = SB_UNFROZEN;
1340 smp_wmb();
1341 wake_up(&sb->s_writers.wait_unfrozen);
1342 deactivate_locked_super(sb);
1343 return ret;
1344 }
1345 }
1346
1347
1348
1349
1350 sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1351 up_write(&sb->s_umount);
1352 return 0;
1353}
1354EXPORT_SYMBOL(freeze_super);
1355
1356
1357
1358
1359
1360
1361
1362int thaw_super(struct super_block *sb)
1363{
1364 int error;
1365
1366 down_write(&sb->s_umount);
1367 if (sb->s_writers.frozen == SB_UNFROZEN) {
1368 up_write(&sb->s_umount);
1369 return -EINVAL;
1370 }
1371
1372 if (sb->s_flags & MS_RDONLY)
1373 goto out;
1374
1375 if (sb->s_op->unfreeze_fs) {
1376 error = sb->s_op->unfreeze_fs(sb);
1377 if (error) {
1378 printk(KERN_ERR
1379 "VFS:Filesystem thaw failed\n");
1380 up_write(&sb->s_umount);
1381 return error;
1382 }
1383 }
1384
1385out:
1386 sb->s_writers.frozen = SB_UNFROZEN;
1387 smp_wmb();
1388 wake_up(&sb->s_writers.wait_unfrozen);
1389 deactivate_locked_super(sb);
1390
1391 return 0;
1392}
1393EXPORT_SYMBOL(thaw_super);
1394