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