1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/export.h>
25#include <linux/slab.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 <linux/user_namespace.h>
38#include <linux/fs_context.h>
39#include <uapi/linux/mount.h>
40#include "internal.h"
41
42static int thaw_super_locked(struct super_block *sb);
43
44static LIST_HEAD(super_blocks);
45static DEFINE_SPINLOCK(sb_lock);
46
47static char *sb_writers_name[SB_FREEZE_LEVELS] = {
48 "sb_writers",
49 "sb_pagefaults",
50 "sb_internal",
51};
52
53
54
55
56
57
58
59
60static unsigned long super_cache_scan(struct shrinker *shrink,
61 struct shrink_control *sc)
62{
63 struct super_block *sb;
64 long fs_objects = 0;
65 long total_objects;
66 long freed = 0;
67 long dentries;
68 long inodes;
69
70 sb = container_of(shrink, struct super_block, s_shrink);
71
72
73
74
75
76 if (!(sc->gfp_mask & __GFP_FS))
77 return SHRINK_STOP;
78
79 if (!trylock_super(sb))
80 return SHRINK_STOP;
81
82 if (sb->s_op->nr_cached_objects)
83 fs_objects = sb->s_op->nr_cached_objects(sb, sc);
84
85 inodes = list_lru_shrink_count(&sb->s_inode_lru, sc);
86 dentries = list_lru_shrink_count(&sb->s_dentry_lru, sc);
87 total_objects = dentries + inodes + fs_objects + 1;
88 if (!total_objects)
89 total_objects = 1;
90
91
92 dentries = mult_frac(sc->nr_to_scan, dentries, total_objects);
93 inodes = mult_frac(sc->nr_to_scan, inodes, total_objects);
94 fs_objects = mult_frac(sc->nr_to_scan, fs_objects, total_objects);
95
96
97
98
99
100
101
102
103 sc->nr_to_scan = dentries + 1;
104 freed = prune_dcache_sb(sb, sc);
105 sc->nr_to_scan = inodes + 1;
106 freed += prune_icache_sb(sb, sc);
107
108 if (fs_objects) {
109 sc->nr_to_scan = fs_objects + 1;
110 freed += sb->s_op->free_cached_objects(sb, sc);
111 }
112
113 up_read(&sb->s_umount);
114 return freed;
115}
116
117static unsigned long super_cache_count(struct shrinker *shrink,
118 struct shrink_control *sc)
119{
120 struct super_block *sb;
121 long total_objects = 0;
122
123 sb = container_of(shrink, struct super_block, s_shrink);
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139 if (!(sb->s_flags & SB_BORN))
140 return 0;
141 smp_rmb();
142
143 if (sb->s_op && sb->s_op->nr_cached_objects)
144 total_objects = sb->s_op->nr_cached_objects(sb, sc);
145
146 total_objects += list_lru_shrink_count(&sb->s_dentry_lru, sc);
147 total_objects += list_lru_shrink_count(&sb->s_inode_lru, sc);
148
149 if (!total_objects)
150 return SHRINK_EMPTY;
151
152 total_objects = vfs_pressure_ratio(total_objects);
153 return total_objects;
154}
155
156static void destroy_super_work(struct work_struct *work)
157{
158 struct super_block *s = container_of(work, struct super_block,
159 destroy_work);
160 int i;
161
162 for (i = 0; i < SB_FREEZE_LEVELS; i++)
163 percpu_free_rwsem(&s->s_writers.rw_sem[i]);
164 kfree(s);
165}
166
167static void destroy_super_rcu(struct rcu_head *head)
168{
169 struct super_block *s = container_of(head, struct super_block, rcu);
170 INIT_WORK(&s->destroy_work, destroy_super_work);
171 schedule_work(&s->destroy_work);
172}
173
174
175static void destroy_unused_super(struct super_block *s)
176{
177 if (!s)
178 return;
179 up_write(&s->s_umount);
180 list_lru_destroy(&s->s_dentry_lru);
181 list_lru_destroy(&s->s_inode_lru);
182 security_sb_free(s);
183 put_user_ns(s->s_user_ns);
184 kfree(s->s_subtype);
185 free_prealloced_shrinker(&s->s_shrink);
186
187 destroy_super_work(&s->destroy_work);
188}
189
190
191
192
193
194
195
196
197
198
199static struct super_block *alloc_super(struct file_system_type *type, int flags,
200 struct user_namespace *user_ns)
201{
202 struct super_block *s = kzalloc(sizeof(struct super_block), GFP_USER);
203 static const struct super_operations default_op;
204 int i;
205
206 if (!s)
207 return NULL;
208
209 INIT_LIST_HEAD(&s->s_mounts);
210 s->s_user_ns = get_user_ns(user_ns);
211 init_rwsem(&s->s_umount);
212 lockdep_set_class(&s->s_umount, &type->s_umount_key);
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228 down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
229
230 if (security_sb_alloc(s))
231 goto fail;
232
233 for (i = 0; i < SB_FREEZE_LEVELS; i++) {
234 if (__percpu_init_rwsem(&s->s_writers.rw_sem[i],
235 sb_writers_name[i],
236 &type->s_writers_key[i]))
237 goto fail;
238 }
239 init_waitqueue_head(&s->s_writers.wait_unfrozen);
240 s->s_bdi = &noop_backing_dev_info;
241 s->s_flags = flags;
242 if (s->s_user_ns != &init_user_ns)
243 s->s_iflags |= SB_I_NODEV;
244 INIT_HLIST_NODE(&s->s_instances);
245 INIT_HLIST_BL_HEAD(&s->s_roots);
246 mutex_init(&s->s_sync_lock);
247 INIT_LIST_HEAD(&s->s_inodes);
248 spin_lock_init(&s->s_inode_list_lock);
249 INIT_LIST_HEAD(&s->s_inodes_wb);
250 spin_lock_init(&s->s_inode_wblist_lock);
251
252 s->s_count = 1;
253 atomic_set(&s->s_active, 1);
254 mutex_init(&s->s_vfs_rename_mutex);
255 lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);
256 init_rwsem(&s->s_dquot.dqio_sem);
257 s->s_maxbytes = MAX_NON_LFS;
258 s->s_op = &default_op;
259 s->s_time_gran = 1000000000;
260 s->cleancache_poolid = CLEANCACHE_NO_POOL;
261
262 s->s_shrink.seeks = DEFAULT_SEEKS;
263 s->s_shrink.scan_objects = super_cache_scan;
264 s->s_shrink.count_objects = super_cache_count;
265 s->s_shrink.batch = 1024;
266 s->s_shrink.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE;
267 if (prealloc_shrinker(&s->s_shrink))
268 goto fail;
269 if (list_lru_init_memcg(&s->s_dentry_lru, &s->s_shrink))
270 goto fail;
271 if (list_lru_init_memcg(&s->s_inode_lru, &s->s_shrink))
272 goto fail;
273 return s;
274
275fail:
276 destroy_unused_super(s);
277 return NULL;
278}
279
280
281
282
283
284
285static void __put_super(struct super_block *s)
286{
287 if (!--s->s_count) {
288 list_del_init(&s->s_list);
289 WARN_ON(s->s_dentry_lru.node);
290 WARN_ON(s->s_inode_lru.node);
291 WARN_ON(!list_empty(&s->s_mounts));
292 security_sb_free(s);
293 put_user_ns(s->s_user_ns);
294 kfree(s->s_subtype);
295 call_rcu(&s->rcu, destroy_super_rcu);
296 }
297}
298
299
300
301
302
303
304
305
306static void put_super(struct super_block *sb)
307{
308 spin_lock(&sb_lock);
309 __put_super(sb);
310 spin_unlock(&sb_lock);
311}
312
313
314
315
316
317
318
319
320
321
322
323
324
325void deactivate_locked_super(struct super_block *s)
326{
327 struct file_system_type *fs = s->s_type;
328 if (atomic_dec_and_test(&s->s_active)) {
329 cleancache_invalidate_fs(s);
330 unregister_shrinker(&s->s_shrink);
331 fs->kill_sb(s);
332
333
334
335
336
337
338 list_lru_destroy(&s->s_dentry_lru);
339 list_lru_destroy(&s->s_inode_lru);
340
341 put_filesystem(fs);
342 put_super(s);
343 } else {
344 up_write(&s->s_umount);
345 }
346}
347
348EXPORT_SYMBOL(deactivate_locked_super);
349
350
351
352
353
354
355
356
357
358void deactivate_super(struct super_block *s)
359{
360 if (!atomic_add_unless(&s->s_active, -1, 1)) {
361 down_write(&s->s_umount);
362 deactivate_locked_super(s);
363 }
364}
365
366EXPORT_SYMBOL(deactivate_super);
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381static int grab_super(struct super_block *s) __releases(sb_lock)
382{
383 s->s_count++;
384 spin_unlock(&sb_lock);
385 down_write(&s->s_umount);
386 if ((s->s_flags & SB_BORN) && atomic_inc_not_zero(&s->s_active)) {
387 put_super(s);
388 return 1;
389 }
390 up_write(&s->s_umount);
391 put_super(s);
392 return 0;
393}
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412bool trylock_super(struct super_block *sb)
413{
414 if (down_read_trylock(&sb->s_umount)) {
415 if (!hlist_unhashed(&sb->s_instances) &&
416 sb->s_root && (sb->s_flags & SB_BORN))
417 return true;
418 up_read(&sb->s_umount);
419 }
420
421 return false;
422}
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438void generic_shutdown_super(struct super_block *sb)
439{
440 const struct super_operations *sop = sb->s_op;
441
442 if (sb->s_root) {
443 shrink_dcache_for_umount(sb);
444 sync_filesystem(sb);
445 sb->s_flags &= ~SB_ACTIVE;
446
447 fsnotify_sb_delete(sb);
448 cgroup_writeback_umount();
449
450 evict_inodes(sb);
451
452 if (sb->s_dio_done_wq) {
453 destroy_workqueue(sb->s_dio_done_wq);
454 sb->s_dio_done_wq = NULL;
455 }
456
457 if (sop->put_super)
458 sop->put_super(sb);
459
460 if (!list_empty(&sb->s_inodes)) {
461 printk("VFS: Busy inodes after unmount of %s. "
462 "Self-destruct in 5 seconds. Have a nice day...\n",
463 sb->s_id);
464 }
465 }
466 spin_lock(&sb_lock);
467
468 hlist_del_init(&sb->s_instances);
469 spin_unlock(&sb_lock);
470 up_write(&sb->s_umount);
471 if (sb->s_bdi != &noop_backing_dev_info) {
472 bdi_put(sb->s_bdi);
473 sb->s_bdi = &noop_backing_dev_info;
474 }
475}
476
477EXPORT_SYMBOL(generic_shutdown_super);
478
479bool mount_capable(struct fs_context *fc)
480{
481 if (!(fc->fs_type->fs_flags & FS_USERNS_MOUNT))
482 return capable(CAP_SYS_ADMIN);
483 else
484 return ns_capable(fc->user_ns, CAP_SYS_ADMIN);
485}
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505struct super_block *sget_fc(struct fs_context *fc,
506 int (*test)(struct super_block *, struct fs_context *),
507 int (*set)(struct super_block *, struct fs_context *))
508{
509 struct super_block *s = NULL;
510 struct super_block *old;
511 struct user_namespace *user_ns = fc->global ? &init_user_ns : fc->user_ns;
512 int err;
513
514retry:
515 spin_lock(&sb_lock);
516 if (test) {
517 hlist_for_each_entry(old, &fc->fs_type->fs_supers, s_instances) {
518 if (test(old, fc))
519 goto share_extant_sb;
520 }
521 }
522 if (!s) {
523 spin_unlock(&sb_lock);
524 s = alloc_super(fc->fs_type, fc->sb_flags, user_ns);
525 if (!s)
526 return ERR_PTR(-ENOMEM);
527 goto retry;
528 }
529
530 s->s_fs_info = fc->s_fs_info;
531 err = set(s, fc);
532 if (err) {
533 s->s_fs_info = NULL;
534 spin_unlock(&sb_lock);
535 destroy_unused_super(s);
536 return ERR_PTR(err);
537 }
538 fc->s_fs_info = NULL;
539 s->s_type = fc->fs_type;
540 s->s_iflags |= fc->s_iflags;
541 strlcpy(s->s_id, s->s_type->name, sizeof(s->s_id));
542 list_add_tail(&s->s_list, &super_blocks);
543 hlist_add_head(&s->s_instances, &s->s_type->fs_supers);
544 spin_unlock(&sb_lock);
545 get_filesystem(s->s_type);
546 register_shrinker_prepared(&s->s_shrink);
547 return s;
548
549share_extant_sb:
550 if (user_ns != old->s_user_ns) {
551 spin_unlock(&sb_lock);
552 destroy_unused_super(s);
553 return ERR_PTR(-EBUSY);
554 }
555 if (!grab_super(old))
556 goto retry;
557 destroy_unused_super(s);
558 return old;
559}
560EXPORT_SYMBOL(sget_fc);
561
562
563
564
565
566
567
568
569
570struct super_block *sget(struct file_system_type *type,
571 int (*test)(struct super_block *,void *),
572 int (*set)(struct super_block *,void *),
573 int flags,
574 void *data)
575{
576 struct user_namespace *user_ns = current_user_ns();
577 struct super_block *s = NULL;
578 struct super_block *old;
579 int err;
580
581
582
583
584
585 if (flags & SB_SUBMOUNT)
586 user_ns = &init_user_ns;
587
588retry:
589 spin_lock(&sb_lock);
590 if (test) {
591 hlist_for_each_entry(old, &type->fs_supers, s_instances) {
592 if (!test(old, data))
593 continue;
594 if (user_ns != old->s_user_ns) {
595 spin_unlock(&sb_lock);
596 destroy_unused_super(s);
597 return ERR_PTR(-EBUSY);
598 }
599 if (!grab_super(old))
600 goto retry;
601 destroy_unused_super(s);
602 return old;
603 }
604 }
605 if (!s) {
606 spin_unlock(&sb_lock);
607 s = alloc_super(type, (flags & ~SB_SUBMOUNT), user_ns);
608 if (!s)
609 return ERR_PTR(-ENOMEM);
610 goto retry;
611 }
612
613 err = set(s, data);
614 if (err) {
615 spin_unlock(&sb_lock);
616 destroy_unused_super(s);
617 return ERR_PTR(err);
618 }
619 s->s_type = type;
620 strlcpy(s->s_id, type->name, sizeof(s->s_id));
621 list_add_tail(&s->s_list, &super_blocks);
622 hlist_add_head(&s->s_instances, &type->fs_supers);
623 spin_unlock(&sb_lock);
624 get_filesystem(type);
625 register_shrinker_prepared(&s->s_shrink);
626 return s;
627}
628EXPORT_SYMBOL(sget);
629
630void drop_super(struct super_block *sb)
631{
632 up_read(&sb->s_umount);
633 put_super(sb);
634}
635
636EXPORT_SYMBOL(drop_super);
637
638void drop_super_exclusive(struct super_block *sb)
639{
640 up_write(&sb->s_umount);
641 put_super(sb);
642}
643EXPORT_SYMBOL(drop_super_exclusive);
644
645static void __iterate_supers(void (*f)(struct super_block *))
646{
647 struct super_block *sb, *p = NULL;
648
649 spin_lock(&sb_lock);
650 list_for_each_entry(sb, &super_blocks, s_list) {
651 if (hlist_unhashed(&sb->s_instances))
652 continue;
653 sb->s_count++;
654 spin_unlock(&sb_lock);
655
656 f(sb);
657
658 spin_lock(&sb_lock);
659 if (p)
660 __put_super(p);
661 p = sb;
662 }
663 if (p)
664 __put_super(p);
665 spin_unlock(&sb_lock);
666}
667
668
669
670
671
672
673
674
675void iterate_supers(void (*f)(struct super_block *, void *), void *arg)
676{
677 struct super_block *sb, *p = NULL;
678
679 spin_lock(&sb_lock);
680 list_for_each_entry(sb, &super_blocks, s_list) {
681 if (hlist_unhashed(&sb->s_instances))
682 continue;
683 sb->s_count++;
684 spin_unlock(&sb_lock);
685
686 down_read(&sb->s_umount);
687 if (sb->s_root && (sb->s_flags & SB_BORN))
688 f(sb, arg);
689 up_read(&sb->s_umount);
690
691 spin_lock(&sb_lock);
692 if (p)
693 __put_super(p);
694 p = sb;
695 }
696 if (p)
697 __put_super(p);
698 spin_unlock(&sb_lock);
699}
700
701
702
703
704
705
706
707
708
709
710void iterate_supers_type(struct file_system_type *type,
711 void (*f)(struct super_block *, void *), void *arg)
712{
713 struct super_block *sb, *p = NULL;
714
715 spin_lock(&sb_lock);
716 hlist_for_each_entry(sb, &type->fs_supers, s_instances) {
717 sb->s_count++;
718 spin_unlock(&sb_lock);
719
720 down_read(&sb->s_umount);
721 if (sb->s_root && (sb->s_flags & SB_BORN))
722 f(sb, arg);
723 up_read(&sb->s_umount);
724
725 spin_lock(&sb_lock);
726 if (p)
727 __put_super(p);
728 p = sb;
729 }
730 if (p)
731 __put_super(p);
732 spin_unlock(&sb_lock);
733}
734
735EXPORT_SYMBOL(iterate_supers_type);
736
737static struct super_block *__get_super(struct block_device *bdev, bool excl)
738{
739 struct super_block *sb;
740
741 if (!bdev)
742 return NULL;
743
744 spin_lock(&sb_lock);
745rescan:
746 list_for_each_entry(sb, &super_blocks, s_list) {
747 if (hlist_unhashed(&sb->s_instances))
748 continue;
749 if (sb->s_bdev == bdev) {
750 sb->s_count++;
751 spin_unlock(&sb_lock);
752 if (!excl)
753 down_read(&sb->s_umount);
754 else
755 down_write(&sb->s_umount);
756
757 if (sb->s_root && (sb->s_flags & SB_BORN))
758 return sb;
759 if (!excl)
760 up_read(&sb->s_umount);
761 else
762 up_write(&sb->s_umount);
763
764 spin_lock(&sb_lock);
765 __put_super(sb);
766 goto rescan;
767 }
768 }
769 spin_unlock(&sb_lock);
770 return NULL;
771}
772
773
774
775
776
777
778
779
780struct super_block *get_super(struct block_device *bdev)
781{
782 return __get_super(bdev, false);
783}
784EXPORT_SYMBOL(get_super);
785
786static struct super_block *__get_super_thawed(struct block_device *bdev,
787 bool excl)
788{
789 while (1) {
790 struct super_block *s = __get_super(bdev, excl);
791 if (!s || s->s_writers.frozen == SB_UNFROZEN)
792 return s;
793 if (!excl)
794 up_read(&s->s_umount);
795 else
796 up_write(&s->s_umount);
797 wait_event(s->s_writers.wait_unfrozen,
798 s->s_writers.frozen == SB_UNFROZEN);
799 put_super(s);
800 }
801}
802
803
804
805
806
807
808
809
810
811
812struct super_block *get_super_thawed(struct block_device *bdev)
813{
814 return __get_super_thawed(bdev, false);
815}
816EXPORT_SYMBOL(get_super_thawed);
817
818
819
820
821
822
823
824
825
826
827struct super_block *get_super_exclusive_thawed(struct block_device *bdev)
828{
829 return __get_super_thawed(bdev, true);
830}
831EXPORT_SYMBOL(get_super_exclusive_thawed);
832
833
834
835
836
837
838
839
840
841struct super_block *get_active_super(struct block_device *bdev)
842{
843 struct super_block *sb;
844
845 if (!bdev)
846 return NULL;
847
848restart:
849 spin_lock(&sb_lock);
850 list_for_each_entry(sb, &super_blocks, s_list) {
851 if (hlist_unhashed(&sb->s_instances))
852 continue;
853 if (sb->s_bdev == bdev) {
854 if (!grab_super(sb))
855 goto restart;
856 up_write(&sb->s_umount);
857 return sb;
858 }
859 }
860 spin_unlock(&sb_lock);
861 return NULL;
862}
863
864struct super_block *user_get_super(dev_t dev)
865{
866 struct super_block *sb;
867
868 spin_lock(&sb_lock);
869rescan:
870 list_for_each_entry(sb, &super_blocks, s_list) {
871 if (hlist_unhashed(&sb->s_instances))
872 continue;
873 if (sb->s_dev == dev) {
874 sb->s_count++;
875 spin_unlock(&sb_lock);
876 down_read(&sb->s_umount);
877
878 if (sb->s_root && (sb->s_flags & SB_BORN))
879 return sb;
880 up_read(&sb->s_umount);
881
882 spin_lock(&sb_lock);
883 __put_super(sb);
884 goto rescan;
885 }
886 }
887 spin_unlock(&sb_lock);
888 return NULL;
889}
890
891
892
893
894
895
896
897int reconfigure_super(struct fs_context *fc)
898{
899 struct super_block *sb = fc->root->d_sb;
900 int retval;
901 bool remount_ro = false;
902 bool force = fc->sb_flags & SB_FORCE;
903
904 if (fc->sb_flags_mask & ~MS_RMT_MASK)
905 return -EINVAL;
906 if (sb->s_writers.frozen != SB_UNFROZEN)
907 return -EBUSY;
908
909 retval = security_sb_remount(sb, fc->security);
910 if (retval)
911 return retval;
912
913 if (fc->sb_flags_mask & SB_RDONLY) {
914#ifdef CONFIG_BLOCK
915 if (!(fc->sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev))
916 return -EACCES;
917#endif
918
919 remount_ro = (fc->sb_flags & SB_RDONLY) && !sb_rdonly(sb);
920 }
921
922 if (remount_ro) {
923 if (!hlist_empty(&sb->s_pins)) {
924 up_write(&sb->s_umount);
925 group_pin_kill(&sb->s_pins);
926 down_write(&sb->s_umount);
927 if (!sb->s_root)
928 return 0;
929 if (sb->s_writers.frozen != SB_UNFROZEN)
930 return -EBUSY;
931 remount_ro = !sb_rdonly(sb);
932 }
933 }
934 shrink_dcache_sb(sb);
935
936
937
938
939 if (remount_ro) {
940 if (force) {
941 sb->s_readonly_remount = 1;
942 smp_wmb();
943 } else {
944 retval = sb_prepare_remount_readonly(sb);
945 if (retval)
946 return retval;
947 }
948 }
949
950 if (fc->ops->reconfigure) {
951 retval = fc->ops->reconfigure(fc);
952 if (retval) {
953 if (!force)
954 goto cancel_readonly;
955
956 WARN(1, "forced remount of a %s fs returned %i\n",
957 sb->s_type->name, retval);
958 }
959 }
960
961 WRITE_ONCE(sb->s_flags, ((sb->s_flags & ~fc->sb_flags_mask) |
962 (fc->sb_flags & fc->sb_flags_mask)));
963
964 smp_wmb();
965 sb->s_readonly_remount = 0;
966
967
968
969
970
971
972
973
974
975 if (remount_ro && sb->s_bdev)
976 invalidate_bdev(sb->s_bdev);
977 return 0;
978
979cancel_readonly:
980 sb->s_readonly_remount = 0;
981 return retval;
982}
983
984static void do_emergency_remount_callback(struct super_block *sb)
985{
986 down_write(&sb->s_umount);
987 if (sb->s_root && sb->s_bdev && (sb->s_flags & SB_BORN) &&
988 !sb_rdonly(sb)) {
989 struct fs_context *fc;
990
991 fc = fs_context_for_reconfigure(sb->s_root,
992 SB_RDONLY | SB_FORCE, SB_RDONLY);
993 if (!IS_ERR(fc)) {
994 if (parse_monolithic_mount_data(fc, NULL) == 0)
995 (void)reconfigure_super(fc);
996 put_fs_context(fc);
997 }
998 }
999 up_write(&sb->s_umount);
1000}
1001
1002static void do_emergency_remount(struct work_struct *work)
1003{
1004 __iterate_supers(do_emergency_remount_callback);
1005 kfree(work);
1006 printk("Emergency Remount complete\n");
1007}
1008
1009void emergency_remount(void)
1010{
1011 struct work_struct *work;
1012
1013 work = kmalloc(sizeof(*work), GFP_ATOMIC);
1014 if (work) {
1015 INIT_WORK(work, do_emergency_remount);
1016 schedule_work(work);
1017 }
1018}
1019
1020static void do_thaw_all_callback(struct super_block *sb)
1021{
1022 down_write(&sb->s_umount);
1023 if (sb->s_root && sb->s_flags & SB_BORN) {
1024 emergency_thaw_bdev(sb);
1025 thaw_super_locked(sb);
1026 } else {
1027 up_write(&sb->s_umount);
1028 }
1029}
1030
1031static void do_thaw_all(struct work_struct *work)
1032{
1033 __iterate_supers(do_thaw_all_callback);
1034 kfree(work);
1035 printk(KERN_WARNING "Emergency Thaw complete\n");
1036}
1037
1038
1039
1040
1041
1042
1043void emergency_thaw_all(void)
1044{
1045 struct work_struct *work;
1046
1047 work = kmalloc(sizeof(*work), GFP_ATOMIC);
1048 if (work) {
1049 INIT_WORK(work, do_thaw_all);
1050 schedule_work(work);
1051 }
1052}
1053
1054static DEFINE_IDA(unnamed_dev_ida);
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067int get_anon_bdev(dev_t *p)
1068{
1069 int dev;
1070
1071
1072
1073
1074
1075 dev = ida_alloc_range(&unnamed_dev_ida, 1, (1 << MINORBITS) - 1,
1076 GFP_ATOMIC);
1077 if (dev == -ENOSPC)
1078 dev = -EMFILE;
1079 if (dev < 0)
1080 return dev;
1081
1082 *p = MKDEV(0, dev);
1083 return 0;
1084}
1085EXPORT_SYMBOL(get_anon_bdev);
1086
1087void free_anon_bdev(dev_t dev)
1088{
1089 ida_free(&unnamed_dev_ida, MINOR(dev));
1090}
1091EXPORT_SYMBOL(free_anon_bdev);
1092
1093int set_anon_super(struct super_block *s, void *data)
1094{
1095 return get_anon_bdev(&s->s_dev);
1096}
1097EXPORT_SYMBOL(set_anon_super);
1098
1099void kill_anon_super(struct super_block *sb)
1100{
1101 dev_t dev = sb->s_dev;
1102 generic_shutdown_super(sb);
1103 free_anon_bdev(dev);
1104}
1105EXPORT_SYMBOL(kill_anon_super);
1106
1107void kill_litter_super(struct super_block *sb)
1108{
1109 if (sb->s_root)
1110 d_genocide(sb->s_root);
1111 kill_anon_super(sb);
1112}
1113EXPORT_SYMBOL(kill_litter_super);
1114
1115int set_anon_super_fc(struct super_block *sb, struct fs_context *fc)
1116{
1117 return set_anon_super(sb, NULL);
1118}
1119EXPORT_SYMBOL(set_anon_super_fc);
1120
1121static int test_keyed_super(struct super_block *sb, struct fs_context *fc)
1122{
1123 return sb->s_fs_info == fc->s_fs_info;
1124}
1125
1126static int test_single_super(struct super_block *s, struct fs_context *fc)
1127{
1128 return 1;
1129}
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156int vfs_get_super(struct fs_context *fc,
1157 enum vfs_get_super_keying keying,
1158 int (*fill_super)(struct super_block *sb,
1159 struct fs_context *fc))
1160{
1161 int (*test)(struct super_block *, struct fs_context *);
1162 struct super_block *sb;
1163
1164 switch (keying) {
1165 case vfs_get_single_super:
1166 test = test_single_super;
1167 break;
1168 case vfs_get_keyed_super:
1169 test = test_keyed_super;
1170 break;
1171 case vfs_get_independent_super:
1172 test = NULL;
1173 break;
1174 default:
1175 BUG();
1176 }
1177
1178 sb = sget_fc(fc, test, set_anon_super_fc);
1179 if (IS_ERR(sb))
1180 return PTR_ERR(sb);
1181
1182 if (!sb->s_root) {
1183 int err = fill_super(sb, fc);
1184 if (err) {
1185 deactivate_locked_super(sb);
1186 return err;
1187 }
1188
1189 sb->s_flags |= SB_ACTIVE;
1190 }
1191
1192 BUG_ON(fc->root);
1193 fc->root = dget(sb->s_root);
1194 return 0;
1195}
1196EXPORT_SYMBOL(vfs_get_super);
1197
1198int get_tree_nodev(struct fs_context *fc,
1199 int (*fill_super)(struct super_block *sb,
1200 struct fs_context *fc))
1201{
1202 return vfs_get_super(fc, vfs_get_independent_super, fill_super);
1203}
1204EXPORT_SYMBOL(get_tree_nodev);
1205
1206int get_tree_single(struct fs_context *fc,
1207 int (*fill_super)(struct super_block *sb,
1208 struct fs_context *fc))
1209{
1210 return vfs_get_super(fc, vfs_get_single_super, fill_super);
1211}
1212EXPORT_SYMBOL(get_tree_single);
1213
1214#ifdef CONFIG_BLOCK
1215static int set_bdev_super(struct super_block *s, void *data)
1216{
1217 s->s_bdev = data;
1218 s->s_dev = s->s_bdev->bd_dev;
1219 s->s_bdi = bdi_get(s->s_bdev->bd_bdi);
1220
1221 return 0;
1222}
1223
1224static int test_bdev_super(struct super_block *s, void *data)
1225{
1226 return (void *)s->s_bdev == data;
1227}
1228
1229struct dentry *mount_bdev(struct file_system_type *fs_type,
1230 int flags, const char *dev_name, void *data,
1231 int (*fill_super)(struct super_block *, void *, int))
1232{
1233 struct block_device *bdev;
1234 struct super_block *s;
1235 fmode_t mode = FMODE_READ | FMODE_EXCL;
1236 int error = 0;
1237
1238 if (!(flags & SB_RDONLY))
1239 mode |= FMODE_WRITE;
1240
1241 bdev = blkdev_get_by_path(dev_name, mode, fs_type);
1242 if (IS_ERR(bdev))
1243 return ERR_CAST(bdev);
1244
1245
1246
1247
1248
1249
1250 mutex_lock(&bdev->bd_fsfreeze_mutex);
1251 if (bdev->bd_fsfreeze_count > 0) {
1252 mutex_unlock(&bdev->bd_fsfreeze_mutex);
1253 error = -EBUSY;
1254 goto error_bdev;
1255 }
1256 s = sget(fs_type, test_bdev_super, set_bdev_super, flags | SB_NOSEC,
1257 bdev);
1258 mutex_unlock(&bdev->bd_fsfreeze_mutex);
1259 if (IS_ERR(s))
1260 goto error_s;
1261
1262 if (s->s_root) {
1263 if ((flags ^ s->s_flags) & SB_RDONLY) {
1264 deactivate_locked_super(s);
1265 error = -EBUSY;
1266 goto error_bdev;
1267 }
1268
1269
1270
1271
1272
1273
1274
1275
1276 up_write(&s->s_umount);
1277 blkdev_put(bdev, mode);
1278 down_write(&s->s_umount);
1279 } else {
1280 s->s_mode = mode;
1281 snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1282 sb_set_blocksize(s, block_size(bdev));
1283 error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
1284 if (error) {
1285 deactivate_locked_super(s);
1286 goto error;
1287 }
1288
1289 s->s_flags |= SB_ACTIVE;
1290 bdev->bd_super = s;
1291 }
1292
1293 return dget(s->s_root);
1294
1295error_s:
1296 error = PTR_ERR(s);
1297error_bdev:
1298 blkdev_put(bdev, mode);
1299error:
1300 return ERR_PTR(error);
1301}
1302EXPORT_SYMBOL(mount_bdev);
1303
1304void kill_block_super(struct super_block *sb)
1305{
1306 struct block_device *bdev = sb->s_bdev;
1307 fmode_t mode = sb->s_mode;
1308
1309 bdev->bd_super = NULL;
1310 generic_shutdown_super(sb);
1311 sync_blockdev(bdev);
1312 WARN_ON_ONCE(!(mode & FMODE_EXCL));
1313 blkdev_put(bdev, mode | FMODE_EXCL);
1314}
1315
1316EXPORT_SYMBOL(kill_block_super);
1317#endif
1318
1319struct dentry *mount_nodev(struct file_system_type *fs_type,
1320 int flags, void *data,
1321 int (*fill_super)(struct super_block *, void *, int))
1322{
1323 int error;
1324 struct super_block *s = sget(fs_type, NULL, set_anon_super, flags, NULL);
1325
1326 if (IS_ERR(s))
1327 return ERR_CAST(s);
1328
1329 error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
1330 if (error) {
1331 deactivate_locked_super(s);
1332 return ERR_PTR(error);
1333 }
1334 s->s_flags |= SB_ACTIVE;
1335 return dget(s->s_root);
1336}
1337EXPORT_SYMBOL(mount_nodev);
1338
1339static int reconfigure_single(struct super_block *s,
1340 int flags, void *data)
1341{
1342 struct fs_context *fc;
1343 int ret;
1344
1345
1346
1347
1348
1349
1350 fc = fs_context_for_reconfigure(s->s_root, flags, MS_RMT_MASK);
1351 if (IS_ERR(fc))
1352 return PTR_ERR(fc);
1353
1354 ret = parse_monolithic_mount_data(fc, data);
1355 if (ret < 0)
1356 goto out;
1357
1358 ret = reconfigure_super(fc);
1359out:
1360 put_fs_context(fc);
1361 return ret;
1362}
1363
1364static int compare_single(struct super_block *s, void *p)
1365{
1366 return 1;
1367}
1368
1369struct dentry *mount_single(struct file_system_type *fs_type,
1370 int flags, void *data,
1371 int (*fill_super)(struct super_block *, void *, int))
1372{
1373 struct super_block *s;
1374 int error;
1375
1376 s = sget(fs_type, compare_single, set_anon_super, flags, NULL);
1377 if (IS_ERR(s))
1378 return ERR_CAST(s);
1379 if (!s->s_root) {
1380 error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
1381 if (!error)
1382 s->s_flags |= SB_ACTIVE;
1383 } else {
1384 error = reconfigure_single(s, flags, data);
1385 }
1386 if (unlikely(error)) {
1387 deactivate_locked_super(s);
1388 return ERR_PTR(error);
1389 }
1390 return dget(s->s_root);
1391}
1392EXPORT_SYMBOL(mount_single);
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402int vfs_get_tree(struct fs_context *fc)
1403{
1404 struct super_block *sb;
1405 int error;
1406
1407 if (fc->root)
1408 return -EBUSY;
1409
1410
1411
1412
1413 error = fc->ops->get_tree(fc);
1414 if (error < 0)
1415 return error;
1416
1417 if (!fc->root) {
1418 pr_err("Filesystem %s get_tree() didn't set fc->root\n",
1419 fc->fs_type->name);
1420
1421
1422
1423 BUG();
1424 }
1425
1426 sb = fc->root->d_sb;
1427 WARN_ON(!sb->s_bdi);
1428
1429 if (fc->subtype && !sb->s_subtype) {
1430 sb->s_subtype = fc->subtype;
1431 fc->subtype = NULL;
1432 }
1433
1434
1435
1436
1437
1438
1439
1440 smp_wmb();
1441 sb->s_flags |= SB_BORN;
1442
1443 error = security_sb_set_mnt_opts(sb, fc->security, 0, NULL);
1444 if (unlikely(error)) {
1445 fc_drop_locked(fc);
1446 return error;
1447 }
1448
1449
1450
1451
1452
1453
1454
1455 WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
1456 "negative value (%lld)\n", fc->fs_type->name, sb->s_maxbytes);
1457
1458 return 0;
1459}
1460EXPORT_SYMBOL(vfs_get_tree);
1461
1462
1463
1464
1465
1466int super_setup_bdi_name(struct super_block *sb, char *fmt, ...)
1467{
1468 struct backing_dev_info *bdi;
1469 int err;
1470 va_list args;
1471
1472 bdi = bdi_alloc(GFP_KERNEL);
1473 if (!bdi)
1474 return -ENOMEM;
1475
1476 bdi->name = sb->s_type->name;
1477
1478 va_start(args, fmt);
1479 err = bdi_register_va(bdi, fmt, args);
1480 va_end(args);
1481 if (err) {
1482 bdi_put(bdi);
1483 return err;
1484 }
1485 WARN_ON(sb->s_bdi != &noop_backing_dev_info);
1486 sb->s_bdi = bdi;
1487
1488 return 0;
1489}
1490EXPORT_SYMBOL(super_setup_bdi_name);
1491
1492
1493
1494
1495
1496int super_setup_bdi(struct super_block *sb)
1497{
1498 static atomic_long_t bdi_seq = ATOMIC_LONG_INIT(0);
1499
1500 return super_setup_bdi_name(sb, "%.28s-%ld", sb->s_type->name,
1501 atomic_long_inc_return(&bdi_seq));
1502}
1503EXPORT_SYMBOL(super_setup_bdi);
1504
1505
1506
1507
1508
1509void __sb_end_write(struct super_block *sb, int level)
1510{
1511 percpu_up_read(sb->s_writers.rw_sem + level-1);
1512}
1513EXPORT_SYMBOL(__sb_end_write);
1514
1515
1516
1517
1518
1519int __sb_start_write(struct super_block *sb, int level, bool wait)
1520{
1521 bool force_trylock = false;
1522 int ret = 1;
1523
1524#ifdef CONFIG_LOCKDEP
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534 if (wait) {
1535 int i;
1536
1537 for (i = 0; i < level - 1; i++)
1538 if (percpu_rwsem_is_held(sb->s_writers.rw_sem + i)) {
1539 force_trylock = true;
1540 break;
1541 }
1542 }
1543#endif
1544 if (wait && !force_trylock)
1545 percpu_down_read(sb->s_writers.rw_sem + level-1);
1546 else
1547 ret = percpu_down_read_trylock(sb->s_writers.rw_sem + level-1);
1548
1549 WARN_ON(force_trylock && !ret);
1550 return ret;
1551}
1552EXPORT_SYMBOL(__sb_start_write);
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562static void sb_wait_write(struct super_block *sb, int level)
1563{
1564 percpu_down_write(sb->s_writers.rw_sem + level-1);
1565}
1566
1567
1568
1569
1570
1571static void lockdep_sb_freeze_release(struct super_block *sb)
1572{
1573 int level;
1574
1575 for (level = SB_FREEZE_LEVELS - 1; level >= 0; level--)
1576 percpu_rwsem_release(sb->s_writers.rw_sem + level, 0, _THIS_IP_);
1577}
1578
1579
1580
1581
1582static void lockdep_sb_freeze_acquire(struct super_block *sb)
1583{
1584 int level;
1585
1586 for (level = 0; level < SB_FREEZE_LEVELS; ++level)
1587 percpu_rwsem_acquire(sb->s_writers.rw_sem + level, 0, _THIS_IP_);
1588}
1589
1590static void sb_freeze_unlock(struct super_block *sb)
1591{
1592 int level;
1593
1594 for (level = SB_FREEZE_LEVELS - 1; level >= 0; level--)
1595 percpu_up_write(sb->s_writers.rw_sem + level);
1596}
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631int freeze_super(struct super_block *sb)
1632{
1633 int ret;
1634
1635 atomic_inc(&sb->s_active);
1636 down_write(&sb->s_umount);
1637 if (sb->s_writers.frozen != SB_UNFROZEN) {
1638 deactivate_locked_super(sb);
1639 return -EBUSY;
1640 }
1641
1642 if (!(sb->s_flags & SB_BORN)) {
1643 up_write(&sb->s_umount);
1644 return 0;
1645 }
1646
1647 if (sb_rdonly(sb)) {
1648
1649 sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1650 up_write(&sb->s_umount);
1651 return 0;
1652 }
1653
1654 sb->s_writers.frozen = SB_FREEZE_WRITE;
1655
1656 up_write(&sb->s_umount);
1657 sb_wait_write(sb, SB_FREEZE_WRITE);
1658 down_write(&sb->s_umount);
1659
1660
1661 sb->s_writers.frozen = SB_FREEZE_PAGEFAULT;
1662 sb_wait_write(sb, SB_FREEZE_PAGEFAULT);
1663
1664
1665 sync_filesystem(sb);
1666
1667
1668 sb->s_writers.frozen = SB_FREEZE_FS;
1669 sb_wait_write(sb, SB_FREEZE_FS);
1670
1671 if (sb->s_op->freeze_fs) {
1672 ret = sb->s_op->freeze_fs(sb);
1673 if (ret) {
1674 printk(KERN_ERR
1675 "VFS:Filesystem freeze failed\n");
1676 sb->s_writers.frozen = SB_UNFROZEN;
1677 sb_freeze_unlock(sb);
1678 wake_up(&sb->s_writers.wait_unfrozen);
1679 deactivate_locked_super(sb);
1680 return ret;
1681 }
1682 }
1683
1684
1685
1686
1687 sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1688 lockdep_sb_freeze_release(sb);
1689 up_write(&sb->s_umount);
1690 return 0;
1691}
1692EXPORT_SYMBOL(freeze_super);
1693
1694
1695
1696
1697
1698
1699
1700static int thaw_super_locked(struct super_block *sb)
1701{
1702 int error;
1703
1704 if (sb->s_writers.frozen != SB_FREEZE_COMPLETE) {
1705 up_write(&sb->s_umount);
1706 return -EINVAL;
1707 }
1708
1709 if (sb_rdonly(sb)) {
1710 sb->s_writers.frozen = SB_UNFROZEN;
1711 goto out;
1712 }
1713
1714 lockdep_sb_freeze_acquire(sb);
1715
1716 if (sb->s_op->unfreeze_fs) {
1717 error = sb->s_op->unfreeze_fs(sb);
1718 if (error) {
1719 printk(KERN_ERR
1720 "VFS:Filesystem thaw failed\n");
1721 lockdep_sb_freeze_release(sb);
1722 up_write(&sb->s_umount);
1723 return error;
1724 }
1725 }
1726
1727 sb->s_writers.frozen = SB_UNFROZEN;
1728 sb_freeze_unlock(sb);
1729out:
1730 wake_up(&sb->s_writers.wait_unfrozen);
1731 deactivate_locked_super(sb);
1732 return 0;
1733}
1734
1735int thaw_super(struct super_block *sb)
1736{
1737 down_write(&sb->s_umount);
1738 return thaw_super_locked(sb);
1739}
1740EXPORT_SYMBOL(thaw_super);
1741