From: Chengguang Xu Now overlayfs can only sync own dirty inodes during syncfs, so remove unnecessary sync_filesystem() on upper file system. Do that with fsync=relaxed only. Call ->sync_fs() and write the block device of the upper filesystem instead, which is what sync_filesystem() does after it has written the inodes. Do the same for a read-only remount. Upper inodes that have no overlay inode, like whiteouts and the work directories, are not tracked. It is up to ->sync_fs() and the block device to get them to disk. ext4, xfs and btrfs log all metadata, and ext4 without a journal keeps it in the buffers of the block device. With many containers on one upper filesystem, stopping one of them no longer writes out the dirty data of all the others. Signed-off-by: Chengguang Xu [josef: everything after the first paragraph, no wait_sb_inodes() on the upper filesystem] Signed-off-by: Josef Bacik --- Documentation/filesystems/overlayfs.rst | 2 +- fs/overlayfs/params.c | 14 +++-------- fs/overlayfs/super.c | 41 ++++++++++++++++++++++++++------- 3 files changed, 37 insertions(+), 20 deletions(-) diff --git a/Documentation/filesystems/overlayfs.rst b/Documentation/filesystems/overlayfs.rst index 1a59500834a1..34fc4e6f8a84 100644 --- a/Documentation/filesystems/overlayfs.rst +++ b/Documentation/filesystems/overlayfs.rst @@ -830,7 +830,7 @@ Traditionally, syncfs(2) and unmount of an overlay sync the entire upper filesystem, including the dirty data of other overlays that share it. Overlayfs can be told to only write back the files that were modified through the overlay, and then ask the upper filesystem to commit its -metadata. +metadata and write its block device. On traditional local filesystems with a single journal (e.g. ext4, xfs), fsync on a file also persists the parent directory changes, because they diff --git a/fs/overlayfs/params.c b/fs/overlayfs/params.c index 549fc1e83ac9..6de99e79eb6b 100644 --- a/fs/overlayfs/params.c +++ b/fs/overlayfs/params.c @@ -774,22 +774,14 @@ static int ovl_reconfigure(struct fs_context *fc) { struct super_block *sb = fc->root->d_sb; struct ovl_fs *ofs = OVL_FS(sb); - struct super_block *upper_sb; - int ret = 0; if (!(fc->sb_flags & SB_RDONLY) && ovl_force_readonly(ofs)) return -EROFS; - if (fc->sb_flags & SB_RDONLY && !sb_rdonly(sb)) { - upper_sb = ovl_upper_mnt(ofs)->mnt_sb; - if (ovl_should_sync(ofs)) { - down_read(&upper_sb->s_umount); - ret = sync_filesystem(upper_sb); - up_read(&upper_sb->s_umount); - } - } + if (fc->sb_flags & SB_RDONLY && !sb_rdonly(sb) && ovl_should_sync(ofs)) + return sync_filesystem(sb); - return ret; + return 0; } static const struct fs_context_operations ovl_context_ops = { diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c index 27e30d0ace80..7e1703814a56 100644 --- a/fs/overlayfs/super.c +++ b/fs/overlayfs/super.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -270,18 +271,42 @@ static int ovl_sync_fs(struct super_block *sb, int wait) /* * Not called for sync(2) call or an emergency sync (SB_I_SKIP_SYNC). * All the super blocks will be iterated, including upper_sb. - * - * If this is a syncfs(2) call, then we do need to call - * sync_filesystem() on upper_sb, but enough if we do it when being - * called with wait == 1. */ - if (!wait) - return 0; - upper_sb = ovl_upper_mnt(ofs)->mnt_sb; + if (ovl_should_sync_upper_fs(ofs)) { + /* Enough if we do it when being called with wait == 1 */ + if (!wait) + return 0; + + down_read(&upper_sb->s_umount); + ret = sync_filesystem(upper_sb); + up_read(&upper_sb->s_umount); + + return ret; + } + + /* + * sync_filesystem() has already written the dirty inodes of this + * overlay through ovl_write_inode(). What is left are the last two + * steps of sync_filesystem() on the upper filesystem. They have to + * take care of the upper inodes that have no overlay inode, like + * whiteouts and the work directories. Do not write the inodes that + * others have dirtied on the upper filesystem. + */ down_read(&upper_sb->s_umount); - ret = sync_filesystem(upper_sb); + /* Like sync_filesystem(), do not call ->sync_fs() on a read-only sb */ + ret = 0; + if (sb_rdonly(upper_sb)) + goto out; + + if (upper_sb->s_op->sync_fs) + ret = upper_sb->s_op->sync_fs(upper_sb, wait); + if (!ret && wait) + ret = sync_blockdev(upper_sb->s_bdev); + else if (!ret) + ret = sync_blockdev_nowait(upper_sb->s_bdev); +out: up_read(&upper_sb->s_umount); return ret; -- 2.55.0