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