Lines Matching refs:sb
43 static int thaw_super_locked(struct super_block *sb);
55 * One thing we have to be careful of with a per-sb shrinker is that we don't
64 struct super_block *sb;
71 sb = container_of(shrink, struct super_block, s_shrink);
80 if (!trylock_super(sb))
83 if (sb->s_op->nr_cached_objects)
84 fs_objects = sb->s_op->nr_cached_objects(sb, sc);
86 inodes = list_lru_shrink_count(&sb->s_inode_lru, sc);
87 dentries = list_lru_shrink_count(&sb->s_dentry_lru, sc);
105 freed = prune_dcache_sb(sb, sc);
107 freed += prune_icache_sb(sb, sc);
111 freed += sb->s_op->free_cached_objects(sb, sc);
114 up_read(&sb->s_umount);
121 struct super_block *sb;
124 sb = container_of(shrink, struct super_block, s_shrink);
140 if (!(sb->s_flags & SB_BORN))
144 if (sb->s_op && sb->s_op->nr_cached_objects)
145 total_objects = sb->s_op->nr_cached_objects(sb, sc);
147 total_objects += list_lru_shrink_count(&sb->s_dentry_lru, sc);
148 total_objects += list_lru_shrink_count(&sb->s_inode_lru, sc);
217 * When it cannot find a suitable sb, it allocates a new
305 * @sb: superblock in question
310 static void put_super(struct super_block *sb)
313 __put_super(sb);
401 * @sb: reference we are trying to grab
416 bool trylock_super(struct super_block *sb)
418 if (down_read_trylock(&sb->s_umount)) {
419 if (!hlist_unhashed(&sb->s_instances) &&
420 sb->s_root && (sb->s_flags & SB_BORN))
422 up_read(&sb->s_umount);
430 * @sb: superblock to kill
442 void generic_shutdown_super(struct super_block *sb)
444 const struct super_operations *sop = sb->s_op;
446 if (sb->s_root) {
447 shrink_dcache_for_umount(sb);
448 sync_filesystem(sb);
449 sb->s_flags &= ~SB_ACTIVE;
454 evict_inodes(sb);
456 fsnotify_sb_delete(sb);
457 fscrypt_destroy_keyring(sb);
459 if (sb->s_dio_done_wq) {
460 destroy_workqueue(sb->s_dio_done_wq);
461 sb->s_dio_done_wq = NULL;
465 sop->put_super(sb);
467 if (!list_empty(&sb->s_inodes)) {
470 sb->s_id);
475 hlist_del_init(&sb->s_instances);
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;
637 void drop_super(struct super_block *sb)
639 up_read(&sb->s_umount);
640 put_super(sb);
645 void drop_super_exclusive(struct super_block *sb)
647 up_write(&sb->s_umount);
648 put_super(sb);
654 struct super_block *sb, *p = NULL;
657 list_for_each_entry(sb, &super_blocks, s_list) {
658 if (hlist_unhashed(&sb->s_instances))
660 sb->s_count++;
663 f(sb);
668 p = sb;
684 struct super_block *sb, *p = NULL;
687 list_for_each_entry(sb, &super_blocks, s_list) {
688 if (hlist_unhashed(&sb->s_instances))
690 sb->s_count++;
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);
701 p = sb;
720 struct super_block *sb, *p = NULL;
723 hlist_for_each_entry(sb, &type->fs_supers, s_instances) {
724 sb->s_count++;
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);
735 p = sb;
746 struct super_block *sb;
753 list_for_each_entry(sb, &super_blocks, s_list) {
754 if (hlist_unhashed(&sb->s_instances))
756 if (sb->s_bdev == bdev) {
757 sb->s_count++;
760 down_read(&sb->s_umount);
762 down_write(&sb->s_umount);
764 if (sb->s_root && (sb->s_flags & SB_BORN))
765 return sb;
767 up_read(&sb->s_umount);
769 up_write(&sb->s_umount);
772 __put_super(sb);
850 struct super_block *sb;
857 list_for_each_entry(sb, &super_blocks, s_list) {
858 if (hlist_unhashed(&sb->s_instances))
860 if (sb->s_bdev == bdev) {
861 if (!grab_super(sb))
863 up_write(&sb->s_umount);
864 return sb;
873 struct super_block *sb;
877 list_for_each_entry(sb, &super_blocks, s_list) {
878 if (hlist_unhashed(&sb->s_instances))
880 if (sb->s_dev == dev) {
881 sb->s_count++;
883 down_read(&sb->s_umount);
885 if (sb->s_root && (sb->s_flags & SB_BORN))
886 return sb;
887 up_read(&sb->s_umount);
890 __put_super(sb);
906 struct super_block *sb = fc->root->d_sb;
914 if (sb->s_writers.frozen != SB_UNFROZEN)
917 retval = security_sb_remount(sb, fc->security);
923 if (!(fc->sb_flags & SB_RDONLY) && bdev_read_only(sb->s_bdev))
926 remount_rw = !(fc->sb_flags & SB_RDONLY) && sb_rdonly(sb);
927 remount_ro = (fc->sb_flags & SB_RDONLY) && !sb_rdonly(sb);
931 if (!hlist_empty(&sb->s_pins)) {
932 up_write(&sb->s_umount);
933 group_pin_kill(&sb->s_pins);
934 down_write(&sb->s_umount);
935 if (!sb->s_root)
937 if (sb->s_writers.frozen != SB_UNFROZEN)
939 remount_ro = !sb_rdonly(sb);
942 shrink_dcache_sb(sb);
944 /* If we are reconfiguring to RDONLY and current sb is read/write,
949 sb->s_readonly_remount = 1;
952 retval = sb_prepare_remount_readonly(sb);
962 sb->s_readonly_remount = 1;
973 sb->s_type->name, retval);
977 WRITE_ONCE(sb->s_flags, ((sb->s_flags & ~fc->sb_flags_mask) |
981 sb->s_readonly_remount = 0;
991 if (remount_ro && sb->s_bdev)
992 invalidate_bdev(sb->s_bdev);
996 sb->s_readonly_remount = 0;
1000 static void do_emergency_remount_callback(struct super_block *sb)
1002 down_write(&sb->s_umount);
1003 if (sb->s_root && sb->s_bdev && (sb->s_flags & SB_BORN) &&
1004 !sb_rdonly(sb)) {
1007 fc = fs_context_for_reconfigure(sb->s_root,
1015 up_write(&sb->s_umount);
1036 static void do_thaw_all_callback(struct super_block *sb)
1038 down_write(&sb->s_umount);
1039 if (sb->s_root && sb->s_flags & SB_BORN) {
1040 emergency_thaw_bdev(sb);
1041 thaw_super_locked(sb);
1043 up_write(&sb->s_umount);
1115 void kill_anon_super(struct super_block *sb)
1117 dev_t dev = sb->s_dev;
1118 generic_shutdown_super(sb);
1123 void kill_litter_super(struct super_block *sb)
1125 if (sb->s_root)
1126 d_genocide(sb->s_root);
1127 kill_anon_super(sb);
1131 int set_anon_super_fc(struct super_block *sb, struct fs_context *fc)
1133 return set_anon_super(sb, NULL);
1137 static int test_keyed_super(struct super_block *sb, struct fs_context *fc)
1139 return sb->s_fs_info == fc->s_fs_info;
1174 int (*fill_super)(struct super_block *sb,
1178 struct super_block *sb;
1196 sb = sget_fc(fc, test, set_anon_super_fc);
1197 if (IS_ERR(sb))
1198 return PTR_ERR(sb);
1200 if (!sb->s_root) {
1201 err = fill_super(sb, fc);
1205 sb->s_flags |= SB_ACTIVE;
1206 fc->root = dget(sb->s_root);
1208 fc->root = dget(sb->s_root);
1222 deactivate_locked_super(sb);
1228 int (*fill_super)(struct super_block *sb,
1236 int (*fill_super)(struct super_block *sb,
1244 int (*fill_super)(struct super_block *sb,
1252 int (*fill_super)(struct super_block *sb,
1450 void kill_block_super(struct super_block *sb)
1452 struct block_device *bdev = sb->s_bdev;
1453 fmode_t mode = sb->s_mode;
1456 generic_shutdown_super(sb);
1550 struct super_block *sb;
1572 sb = fc->root->d_sb;
1573 WARN_ON(!sb->s_bdi);
1582 sb->s_flags |= SB_BORN;
1584 error = security_sb_set_mnt_opts(sb, fc->security, 0, NULL);
1596 WARN((sb->s_maxbytes < 0), "%s set sb->s_maxbytes to "
1597 "negative value (%lld)\n", fc->fs_type->name, sb->s_maxbytes);
1607 int super_setup_bdi_name(struct super_block *sb, char *fmt, ...)
1624 WARN_ON(sb->s_bdi != &noop_backing_dev_info);
1625 sb->s_bdi = bdi;
1635 int super_setup_bdi(struct super_block *sb)
1639 return super_setup_bdi_name(sb, "%.28s-%ld", sb->s_type->name,
1646 * @sb: the super for which we wait
1652 static void sb_wait_write(struct super_block *sb, int level)
1654 percpu_down_write(sb->s_writers.rw_sem + level-1);
1661 static void lockdep_sb_freeze_release(struct super_block *sb)
1666 percpu_rwsem_release(sb->s_writers.rw_sem + level, 0, _THIS_IP_);
1670 * Tell lockdep we are holding these locks before we call ->unfreeze_fs(sb).
1672 static void lockdep_sb_freeze_acquire(struct super_block *sb)
1677 percpu_rwsem_acquire(sb->s_writers.rw_sem + level, 0, _THIS_IP_);
1680 static void sb_freeze_unlock(struct super_block *sb, int level)
1683 percpu_up_write(sb->s_writers.rw_sem + level);
1688 * @sb: the super to lock
1694 * During this function, sb->s_writers.frozen goes through these values:
1717 * sb->s_writers.frozen is protected by sb->s_umount.
1719 int freeze_super(struct super_block *sb)
1723 atomic_inc(&sb->s_active);
1724 down_write(&sb->s_umount);
1725 if (sb->s_writers.frozen != SB_UNFROZEN) {
1726 deactivate_locked_super(sb);
1730 if (!(sb->s_flags & SB_BORN)) {
1731 up_write(&sb->s_umount);
1735 if (sb_rdonly(sb)) {
1737 sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1738 up_write(&sb->s_umount);
1742 sb->s_writers.frozen = SB_FREEZE_WRITE;
1744 up_write(&sb->s_umount);
1745 sb_wait_write(sb, SB_FREEZE_WRITE);
1746 down_write(&sb->s_umount);
1749 sb->s_writers.frozen = SB_FREEZE_PAGEFAULT;
1750 sb_wait_write(sb, SB_FREEZE_PAGEFAULT);
1753 ret = sync_filesystem(sb);
1755 sb->s_writers.frozen = SB_UNFROZEN;
1756 sb_freeze_unlock(sb, SB_FREEZE_PAGEFAULT);
1757 wake_up(&sb->s_writers.wait_unfrozen);
1758 deactivate_locked_super(sb);
1763 sb->s_writers.frozen = SB_FREEZE_FS;
1764 sb_wait_write(sb, SB_FREEZE_FS);
1766 if (sb->s_op->freeze_fs) {
1767 ret = sb->s_op->freeze_fs(sb);
1771 sb->s_writers.frozen = SB_UNFROZEN;
1772 sb_freeze_unlock(sb, SB_FREEZE_FS);
1773 wake_up(&sb->s_writers.wait_unfrozen);
1774 deactivate_locked_super(sb);
1782 sb->s_writers.frozen = SB_FREEZE_COMPLETE;
1783 lockdep_sb_freeze_release(sb);
1784 up_write(&sb->s_umount);
1791 * @sb: the super to thaw
1795 static int thaw_super_locked(struct super_block *sb)
1799 if (sb->s_writers.frozen != SB_FREEZE_COMPLETE) {
1800 up_write(&sb->s_umount);
1804 if (sb_rdonly(sb)) {
1805 sb->s_writers.frozen = SB_UNFROZEN;
1809 lockdep_sb_freeze_acquire(sb);
1811 if (sb->s_op->unfreeze_fs) {
1812 error = sb->s_op->unfreeze_fs(sb);
1816 lockdep_sb_freeze_release(sb);
1817 up_write(&sb->s_umount);
1822 sb->s_writers.frozen = SB_UNFROZEN;
1823 sb_freeze_unlock(sb, SB_FREEZE_FS);
1825 wake_up(&sb->s_writers.wait_unfrozen);
1826 deactivate_locked_super(sb);
1830 int thaw_super(struct super_block *sb)
1832 down_write(&sb->s_umount);
1833 return thaw_super_locked(sb);