f2fs: fix potential deadlock due to unpaired node_write lock use

If S_NOQUOTA is cleared from inode during data page writeback of quota
file, it may miss to unlock node_write lock, result in potential
deadlock, fix to use the lock in paired.

Kworker					Thread
- writepage
 if (IS_NOQUOTA())
   f2fs_down_read(&sbi->node_write);
					- vfs_cleanup_quota_inode
					 - inode->i_flags &= ~S_NOQUOTA;
 if (IS_NOQUOTA())
   f2fs_up_read(&sbi->node_write);

Fixes: 79963d967b49 ("f2fs: shrink node_write lock coverage")
Signed-off-by: Chao Yu <[email protected]>
Signed-off-by: Jaegeuk Kim <[email protected]>

diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index 10b545a1088e53d3aacdde6c3ee519947b175ce6..905b7c39a2b321b7daa4f3ea6fdcbfcf0dce6c56 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1215,6 +1215,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
        unsigned int last_index = cc->cluster_size - 1;
        loff_t psize;
        int i, err;
+       bool quota_inode = IS_NOQUOTA(inode);
 
        /* we should bypass data pages to proceed the kworker jobs */
        if (unlikely(f2fs_cp_error(sbi))) {
@@ -1222,7 +1223,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
                goto out_free;
        }
 
-       if (IS_NOQUOTA(inode)) {
+       if (quota_inode) {
                /*
                 * We need to wait for node_write to avoid block allocation during
                 * checkpoint. This can only happen to quota writes which can cause
@@ -1344,7 +1345,7 @@ unlock_continue:
                set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
 
        f2fs_put_dnode(&dn);
-       if (IS_NOQUOTA(inode))
+       if (quota_inode)
                f2fs_up_read(&sbi->node_write);
        else
                f2fs_unlock_op(sbi);
@@ -1370,7 +1371,7 @@ out_put_cic:
 out_put_dnode:
        f2fs_put_dnode(&dn);
 out_unlock_op:
-       if (IS_NOQUOTA(inode))
+       if (quota_inode)
                f2fs_up_read(&sbi->node_write);
        else
                f2fs_unlock_op(sbi);

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 0990d7f0536634a768de651ae9642982e77c66f2..3fad7a23a507c4f88866b9bd12a68338dd9367dd 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2832,6 +2832,7 @@ int f2fs_write_single_data_page(struct page *page, int *submitted,
        loff_t psize = (loff_t)(page->index + 1) << PAGE_SHIFT;
        unsigned offset = 0;
        bool need_balance_fs = false;
+       bool quota_inode = IS_NOQUOTA(inode);
        int err = 0;
        struct f2fs_io_info fio = {
                .sbi = sbi,
@@ -2893,19 +2894,19 @@ write:
                goto out;
 
        /* Dentry/quota blocks are controlled by checkpoint */
-       if (S_ISDIR(inode->i_mode) || IS_NOQUOTA(inode)) {
+       if (S_ISDIR(inode->i_mode) || quota_inode) {
                /*
                 * We need to wait for node_write to avoid block allocation during
                 * checkpoint. This can only happen to quota writes which can cause
                 * the below discard race condition.
                 */
-               if (IS_NOQUOTA(inode))
+               if (quota_inode)
                        f2fs_down_read(&sbi->node_write);
 
                fio.need_lock = LOCK_DONE;
                err = f2fs_do_write_data_page(&fio);
 
-               if (IS_NOQUOTA(inode))
+               if (quota_inode)
                        f2fs_up_read(&sbi->node_write);
 
                goto done;