FAILED: patch "[PATCH] btrfs: qgroup: fix race between quota disable and quota" failed to apply to 6.12-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 6.12-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.12.y
git checkout FETCH_HEAD
git cherry-pick -x e1249667750399a48cafcf5945761d39fa584edf
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2025081830-legroom-preshow-e033@gregkh' --subject-prefix 'PATCH 6.12.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From e1249667750399a48cafcf5945761d39fa584edf Mon Sep 17 00:00:00 2001
From: Filipe Manana <[email protected]>
Date: Mon, 30 Jun 2025 13:19:20 +0100
Subject: [PATCH] btrfs: qgroup: fix race between quota disable and quota
rescan ioctl
There's a race between a task disabling quotas and another running the rescan ioctl that can result in a use-after-free of qgroup records from the fs_info->qgroup_tree rbtree.
This happens as follows:
1) Task A enters btrfs_ioctl_quota_rescan() -> btrfs_qgroup_rescan();
2) Task B enters btrfs_quota_disable() and calls btrfs_qgroup_wait_for_completion(), which does nothing because at that point fs_info->qgroup_rescan_running is false (it wasn't set yet by task A);
3) Task B calls btrfs_free_qgroup_config() which starts freeing qgroups from fs_info->qgroup_tree without taking the lock fs_info->qgroup_lock;
4) Task A enters qgroup_rescan_zero_tracking() which starts iterating the fs_info->qgroup_tree tree while holding fs_info->qgroup_lock, but task B is freeing qgroup records from that tree without holding the lock, resulting in a use-after-free.
Fix this by taking fs_info->qgroup_lock at btrfs_free_qgroup_config(). Also at btrfs_qgroup_rescan() don't start the rescan worker if quotas were already disabled.
fs/btrfs/qgroup.c +24 -7
@@ -636,22 +636,30 @@ bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info)/* * This is called from close_ctree() or open_ctree() or btrfs_quota_disable(), -* first two are in single-threaded paths.And for the third one, we have set -* quota_root to be null with qgroup_lock held before, so it is safe to clean -* up the in-memory structures without qgroup_lock held. +* first two are in single-threaded paths. */ void btrfs_free_qgroup_config (struct btrfs_fs_info *fs_info) {struct rb_node *n;struct btrfs_qgroup *qgroup; +/* +* btrfs_quota_disable() can be called concurrently with +* btrfs_qgroup_rescan() -> qgroup_rescan_zero_tracking(), so take the +* lock. +*/ +spin_lock (&fs_info->qgroup_lock);while ((n =rb_first (&fs_info->qgroup_tree))) { qgroup = rb_entry(n, struct btrfs_qgroup, node);rb_erase (n, &fs_info->qgroup_tree);__del_qgroup_rb (qgroup); +spin_unlock (&fs_info->qgroup_lock);btrfs_sysfs_del_one_qgroup (fs_info, qgroup);kfree (qgroup); +spin_lock (&fs_info->qgroup_lock); } +spin_unlock (&fs_info->qgroup_lock); +/* * We call btrfs_free_qgroup_config() when unmounting * filesystem and disabling quota, so we set qgroup_ulist
@@ -4036,12 +4044,21 @@ btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)qgroup_rescan_zero_tracking (fs_info);mutex_lock (&fs_info->qgroup_rescan_lock); - fs_info->qgroup_rescan_running = true; -btrfs_queue_work (fs_info->qgroup_rescan_workers, - &fs_info->qgroup_rescan_work); +/* +* The rescan worker is only for full accounting qgroups, check if it's +* enabled as it is pointless to queue it otherwise. A concurrent quota +* disable may also have just cleared BTRFS_FS_QUOTA_ENABLED. +*/ +if (btrfs_qgroup_full_accounting (fs_info)) { + fs_info->qgroup_rescan_running = true; +btrfs_queue_work (fs_info->qgroup_rescan_workers, + &fs_info->qgroup_rescan_work); + }else { + ret = -ENOTCONN ; + }mutex_unlock (&fs_info->qgroup_rescan_lock); -return 0 ; +return ret; } int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,
Sasha Levin
maintainerPATCH 1/2 btrfs: qgroup: drop unused parameter fs_info from __del_qgroup_rb()
From: David Sterba <[email protected]>
[ Upstream commit 2651f43274109f2d09b74a404b82722213ef9b2d ]
We don't need fs_info here, everything is reachable from qgroup.
Stable-dep-of: e12496677503 ("btrfs: qgroup: fix race between quota disable and quota rescan ioctl")
--- fs/btrfs/qgroup.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
fs/btrfs/qgroup.c +3 -4
@@ -226,8 +226,7 @@ static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info,return qgroup; } -static void __del_qgroup_rb (struct btrfs_fs_info *fs_info, -struct btrfs_qgroup *qgroup) +static void __del_qgroup_rb (struct btrfs_qgroup *qgroup) {struct btrfs_qgroup_list *list;
@@ -258,7 +257,7 @@ static int del_qgroup_rb(struct btrfs_fs_info *fs_info, u64 qgroupid)return -ENOENT ;rb_erase (&qgroup->node, &fs_info->qgroup_tree); -__del_qgroup_rb (fs_info, qgroup); +__del_qgroup_rb (qgroup);return 0 ; }
@@ -643,7 +642,7 @@ void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info)while ((n =rb_first (&fs_info->qgroup_tree))) { qgroup = rb_entry(n, struct btrfs_qgroup, node);rb_erase (n, &fs_info->qgroup_tree); -__del_qgroup_rb (fs_info, qgroup); +__del_qgroup_rb (qgroup);btrfs_sysfs_del_one_qgroup (fs_info, qgroup);kfree (qgroup); }
Signature · 1 line
2.50.1
Sasha Levin
maintainerPATCH 2/2 btrfs: qgroup: fix race between quota disable and quota rescan ioctl
From: Filipe Manana <[email protected]>
[ Upstream commit e1249667750399a48cafcf5945761d39fa584edf ]
There's a race between a task disabling quotas and another running the rescan ioctl that can result in a use-after-free of qgroup records from the fs_info->qgroup_tree rbtree.
This happens as follows:
1) Task A enters btrfs_ioctl_quota_rescan() -> btrfs_qgroup_rescan();
2) Task B enters btrfs_quota_disable() and calls btrfs_qgroup_wait_for_completion(), which does nothing because at that point fs_info->qgroup_rescan_running is false (it wasn't set yet by task A);
3) Task B calls btrfs_free_qgroup_config() which starts freeing qgroups from fs_info->qgroup_tree without taking the lock fs_info->qgroup_lock;
4) Task A enters qgroup_rescan_zero_tracking() which starts iterating the fs_info->qgroup_tree tree while holding fs_info->qgroup_lock, but task B is freeing qgroup records from that tree without holding the lock, resulting in a use-after-free.
Fix this by taking fs_info->qgroup_lock at btrfs_free_qgroup_config(). Also at btrfs_qgroup_rescan() don't start the rescan worker if quotas were already disabled.
--- fs/btrfs/qgroup.c | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-)
fs/btrfs/qgroup.c +24 -7
@@ -630,22 +630,30 @@ bool btrfs_check_quota_leak(const struct btrfs_fs_info *fs_info)/* * This is called from close_ctree() or open_ctree() or btrfs_quota_disable(), -* first two are in single-threaded paths.And for the third one, we have set -* quota_root to be null with qgroup_lock held before, so it is safe to clean -* up the in-memory structures without qgroup_lock held. +* first two are in single-threaded paths. */ void btrfs_free_qgroup_config (struct btrfs_fs_info *fs_info) {struct rb_node *n;struct btrfs_qgroup *qgroup; +/* +* btrfs_quota_disable() can be called concurrently with +* btrfs_qgroup_rescan() -> qgroup_rescan_zero_tracking(), so take the +* lock. +*/ +spin_lock (&fs_info->qgroup_lock);while ((n =rb_first (&fs_info->qgroup_tree))) { qgroup = rb_entry(n, struct btrfs_qgroup, node);rb_erase (n, &fs_info->qgroup_tree);__del_qgroup_rb (qgroup); +spin_unlock (&fs_info->qgroup_lock);btrfs_sysfs_del_one_qgroup (fs_info, qgroup);kfree (qgroup); +spin_lock (&fs_info->qgroup_lock); } +spin_unlock (&fs_info->qgroup_lock); +/* * We call btrfs_free_qgroup_config() when unmounting * filesystem and disabling quota, so we set qgroup_ulist
@@ -4057,12 +4065,21 @@ btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)qgroup_rescan_zero_tracking (fs_info);mutex_lock (&fs_info->qgroup_rescan_lock); - fs_info->qgroup_rescan_running = true; -btrfs_queue_work (fs_info->qgroup_rescan_workers, - &fs_info->qgroup_rescan_work); +/* +* The rescan worker is only for full accounting qgroups, check if it's +* enabled as it is pointless to queue it otherwise. A concurrent quota +* disable may also have just cleared BTRFS_FS_QUOTA_ENABLED. +*/ +if (btrfs_qgroup_full_accounting (fs_info)) { + fs_info->qgroup_rescan_running = true; +btrfs_queue_work (fs_info->qgroup_rescan_workers, + &fs_info->qgroup_rescan_work); + }else { + ret = -ENOTCONN ; + }mutex_unlock (&fs_info->qgroup_rescan_lock); -return 0 ; +return ret; } int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info,
Signature · 1 line
2.50.1