From d4aef1e122d8bbdc15ce3bd0bc813d6b44a7d63a Mon Sep 17 00:00:00 2001

Message-Id: <d4aef1e122d8bbdc15ce3bd0bc813d6b44a7d63a.1652142354.git.wqu@suse.com>

From: Sidong Yang <realwakka@gmail.com>

Date: Mon, 28 Feb 2022 01:43:40 +0000

Patch-mainline: v5.17-rc1

References: bsc#1199295

Git-commit: d4aef1e122d8bbdc15ce3bd0bc813d6b44a7d63a

Subject: [PATCH] btrfs: qgroup: fix deadlock between rescan worker and remove

 qgroup

The commit e804861bd4e6 ("btrfs: fix deadlock between quota disable and

qgroup rescan worker") by Kawasaki resolves deadlock between quota

disable and qgroup rescan worker. But also there is a deadlock case like

it. It's about enabling or disabling quota and creating or removing

qgroup. It can be reproduced in simple script below.

for i in {1..100}

do

    btrfs quota enable /mnt &

    btrfs qgroup create 1/0 /mnt &

    btrfs qgroup destroy 1/0 /mnt &

    btrfs quota disable /mnt &

done

Here's why the deadlock happens:

1) The quota rescan task is running.

2) Task A calls btrfs_quota_disable(), locks the qgroup_ioctl_lock

   mutex, and then calls btrfs_qgroup_wait_for_completion(), to wait for

   the quota rescan task to complete.

3) Task B calls btrfs_remove_qgroup() and it blocks when trying to lock

   the qgroup_ioctl_lock mutex, because it's being held by task A. At that

   point task B is holding a transaction handle for the current transaction.

4) The quota rescan task calls btrfs_commit_transaction(). This results

   in it waiting for all other tasks to release their handles on the

   transaction, but task B is blocked on the qgroup_ioctl_lock mutex

   while holding a handle on the transaction, and that mutex is being held

   by task A, which is waiting for the quota rescan task to complete,

   resulting in a deadlock between these 3 tasks.

To resolve this issue, the thread disabling quota should unlock

qgroup_ioctl_lock before waiting rescan completion. Move

btrfs_qgroup_wait_for_completion() after unlock of qgroup_ioctl_lock.

Fixes: e804861bd4e6 ("btrfs: fix deadlock between quota disable and qgroup rescan worker")

CC: stable@vger.kernel.org # 5.4+

Reviewed-by: Filipe Manana <fdmanana@suse.com>

Reviewed-by: Shin'ichiro Kawasaki <shinichiro.kawasaki@wdc.com>

Signed-off-by: Sidong Yang <realwakka@gmail.com>

Reviewed-by: David Sterba <dsterba@suse.com>

Signed-off-by: David Sterba <dsterba@suse.com>

Signed-off-by: Qu Wenruo <wqu@suse.com>

---

 fs/btrfs/qgroup.c | 9 ++++++++-

 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c

index f12dc687350c..30d42ea655ce 100644

--- a/fs/btrfs/qgroup.c

+++ b/fs/btrfs/qgroup.c

@@ -1196,6 +1196,14 @@ int btrfs_quota_disable(struct btrfs_fs_info *fs_info)

 	if (!fs_info->quota_root)

 		goto out;

+	/*

+	 * Unlock the qgroup_ioctl_lock mutex before waiting for the rescan worker to

+	 * complete. Otherwise we can deadlock because btrfs_remove_qgroup() needs

+	 * to lock that mutex while holding a transaction handle and the rescan

+	 * worker needs to commit a transaction.

+	 */

+	mutex_unlock(&fs_info->qgroup_ioctl_lock);

+

 	/*

 	 * Request qgroup rescan worker to complete and wait for it. This wait

 	 * must be done before transaction start for quota disable since it may

@@ -1203,7 +1211,6 @@ int btrfs_quota_disable(struct btrfs_fs_info *fs_info)

 	 */

 	clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);

 	btrfs_qgroup_wait_for_completion(fs_info, false);

-	mutex_unlock(&fs_info->qgroup_ioctl_lock);

 	/*

 	 * 1 For the root item

-- 

2.36.0