Skip to contentSkip to conversation

bdi, blk-cgroup: Fix potential UAF of blkcg

PATCH In review Waiman Long 4 participants 5 messages Nov 29, 2022 – Nov 30, 2022

Subsystems (5)
lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 bdi, blk-cgroup: Fix potential UAF of blkcg

Commit 59b57717fff8 ("blkcg: delay blkg destruction until after writeback has finished") delayed call to blkcg_destroy_blkgs() to cgwb_release_workfn(). However, it is done after a css_put() of blkcg which may be the final put that causes the blkcg to be freed as RCU read lock isn't held.

By adding a css_tryget() into blkcg_destroy_blkgs() and warning its failure, the following stack trace was produced in a test system on bootup.

[   34.254240] RIP: 0010:blkcg_destroy_blkgs+0x16a/0x1a0
      :
[   34.339943] Call Trace:
[   34.342395]  <TASK>
[   34.344510]  blkcg_unpin_online+0x38/0x60
[   34.348523]  cgwb_release_workfn+0x6a/0x200
[   34.352708]  process_one_work+0x1e5/0x3b0
[   34.356742]  ? rescuer_thread+0x390/0x390
[   34.360758]  worker_thread+0x50/0x3a0
[   34.364425]  ? rescuer_thread+0x390/0x390
[   34.368447]  kthread+0xd9/0x100
[   34.371592]  ? kthread_complete_and_exit+0x20/0x20
[   34.376386]  ret_from_fork+0x22/0x30
[   34.379982]  </TASK>

This confirms that a potential UAF situation can happen.

Fix that by delaying the css_put() until after the blkcg_unpin_online() call. Also use css_tryget() in blkcg_destroy_blkgs() and issue a warning if css_tryget() fails with no RCU read lock held.

The reproducing system can no longer produce a warning with this patch. All the runnable block/0* tests including block/027 were run successfully without failure.

Fixes 59b57717fff8 ("blkcg: delay blkg destruction until after writeback has finished")
---
 block/blk-cgroup.c | 10 +++++++++-
 mm/backing-dev.c   |  8 ++++++--
 2 files changed, 15 insertions(+), 3 deletions(-)
block/blk-cgroup.c +9 -1
index 57941d2a8ba3..904372bb96f1 100644
@@ -1088,7 +1088,15 @@ static void blkcg_destroy_blkgs(struct blkcg *blkcg)
 
 	might_sleep();
 
-	css_get(&blkcg->css);
+	/*
+	 * blkcg_destroy_blkgs() shouldn't be called with all the blkcg
+	 * references gone and rcu_read_lock not held.
+	 */
+	if (!css_tryget(&blkcg->css)) {
+		WARN_ON_ONCE(!rcu_read_lock_held());
+		return;
+	}
+
 	spin_lock_irq(&blkcg->lock);
 	while (!hlist_empty(&blkcg->blkg_list)) {
 		struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,
mm/backing-dev.c +6 -2
index c30419a5e119..36f75b072325 100644
@@ -390,11 +390,15 @@ static void cgwb_release_workfn(struct work_struct *work)
 	wb_shutdown(wb);
 
 	css_put(wb->memcg_css);
-	css_put(wb->blkcg_css);
 	mutex_unlock(&wb->bdi->cgwb_release_mutex);
 
-	/* triggers blkg destruction if no online users left */
+	/*
+	 * Triggers blkg destruction if no online users left
+	 * The final blkcg css_put() has to be done after blkcg_unpin_online()
+	 * to avoid use-after-free.
+	 */
 	blkcg_unpin_online(wb->blkcg_css);
+	css_put(wb->blkcg_css);
 
 	fprop_local_destroy_percpu(&wb->memcg_completions);
 
Signature · 1 line
2.31.1
#1 lore raw
Quoted 10 lines · Waiman Long

Commit 59b57717fff8 ("blkcg: delay blkg destruction until after writeback has finished") delayed call to blkcg_destroy_blkgs() to cgwb_release_workfn(). However, it is done after a css_put() of blkcg which may be the final put that causes the blkcg to be freed as RCU read lock isn't held.

By adding a css_tryget() into blkcg_destroy_blkgs() and warning its failure, the following stack trace was produced in a test system on bootup.

Quoted 14 lines
[   34.254240] RIP: 0010:blkcg_destroy_blkgs+0x16a/0x1a0
      :
[   34.339943] Call Trace:
[   34.342395]  <TASK>
[   34.344510]  blkcg_unpin_online+0x38/0x60
[   34.348523]  cgwb_release_workfn+0x6a/0x200
[   34.352708]  process_one_work+0x1e5/0x3b0
[   34.356742]  ? rescuer_thread+0x390/0x390
[   34.360758]  worker_thread+0x50/0x3a0
[   34.364425]  ? rescuer_thread+0x390/0x390
[   34.368447]  kthread+0xd9/0x100
[   34.371592]  ? kthread_complete_and_exit+0x20/0x20
[   34.376386]  ret_from_fork+0x22/0x30
[   34.379982]  </TASK>

https://www.kernel.org/doc/html/latest/process/submitting-patches.html#backtraces-in-commit-messages

Quoted 9 lines

This confirms that a potential UAF situation can happen.

Fix that by delaying the css_put() until after the blkcg_unpin_online() call. Also use css_tryget() in blkcg_destroy_blkgs() and issue a warning if css_tryget() fails with no RCU read lock held.

The reproducing system can no longer produce a warning with this patch. All the runnable block/0* tests including block/027 were run successfully without failure.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
maintainer
#2 lore raw
In reply to Waiman Long
Quoted 3 lines · Waiman Long

The reproducing system can no longer produce a warning with this patch. All the runnable block/0* tests including block/027 were run successfully without failure.

Thanks for the test!

block/blk-cgroup.c static void blkcg_destroy_blkgs(struct blkcg *blkcg) · line 1098

Quoted 13 lines
block/blk-cgroup.c +8 -1
@@ -1088,7 +1088,15 @@ static void blkcg_destroy_blkgs(struct blkcg *blkcg)
 
 	might_sleep();
 
-	css_get(&blkcg->css);
+	/*
+	 * blkcg_destroy_blkgs() shouldn't be called with all the blkcg
+	 * references gone and rcu_read_lock not held.
+	 */
+	if (!css_tryget(&blkcg->css)) {
+		WARN_ON_ONCE(!rcu_read_lock_held());
+		return;
+	}

As I followed the previous discussion, the principle is that obtaining a reference or being inside an RCU read section is sufficient.

Consequently, I'd expect the two situations handled equally but here the no-ref but RCU bails out. (Which is OK because blkg_list must be empty?)

However, the might_sleep() in (non-sleepable) RCU reader section combo makes me wary anyway (not with the early return but tools would likely complain).

All in all, can't the contract of blkcg_destroy_blkgs() declare that a caller must pass blkcg with a valid reference? (The body of blkcg_destroy_blkgs then wouldn't need to get neither put the inner reference).

HTH,
Michal

maintainer
#3 lore raw
Quoted 27 lines · Michal Koutn?
Quoted 3 lines · Waiman Long

The reproducing system can no longer produce a warning with this patch. All the runnable block/0* tests including block/027 were run successfully without failure.

Thanks for the test!

block/blk-cgroup.c static void blkcg_destroy_blkgs(struct blkcg *blkcg) · line 1098

Quoted 13 lines
block/blk-cgroup.c +8 -1
@@ -1088,7 +1088,15 @@ static void blkcg_destroy_blkgs(struct blkcg *blkcg)
 
 	might_sleep();
 
-	css_get(&blkcg->css);
+	/*
+	 * blkcg_destroy_blkgs() shouldn't be called with all the blkcg
+	 * references gone and rcu_read_lock not held.
+	 */
+	if (!css_tryget(&blkcg->css)) {
+		WARN_ON_ONCE(!rcu_read_lock_held());
+		return;
+	}

As I followed the previous discussion, the principle is that obtaining a reference or being inside an RCU read section is sufficient.

Consequently, I'd expect the two situations handled equally but here the no-ref but RCU bails out. (Which is OK because blkg_list must be empty?)

Quoted 8 lines

However, the might_sleep() in (non-sleepable) RCU reader section combo makes me wary anyway (not with the early return but tools would likely complain).

All in all, can't the contract of blkcg_destroy_blkgs() declare that a caller must pass blkcg with a valid reference? (The body of blkcg_destroy_blkgs then wouldn't need to get neither put the inner reference).

Totally agree, the proposed patch feels more like a hacky workaround rather than a true solution. Either the contract should be that it's ALWAYS entered with RCU lock held and hence the tryget is fine, OR that a reference always is held when entered.

I'm going to revert the offending patch for now, and then we can queue up a proper patch when that exists.

Signature · 1 line
Jens Axboe
#4 lore raw
In reply to Michal Koutný
Quoted 25 lines · Michal Koutný
Quoted 3 lines · Waiman Long

The reproducing system can no longer produce a warning with this patch. All the runnable block/0* tests including block/027 were run successfully without failure.

Thanks for the test!

block/blk-cgroup.c static void blkcg_destroy_blkgs(struct blkcg *blkcg) · line 1098

Quoted 13 lines
block/blk-cgroup.c +8 -1
@@ -1088,7 +1088,15 @@ static void blkcg_destroy_blkgs(struct blkcg *blkcg)
 
  	might_sleep();
 
-	css_get(&blkcg->css);
+	/*
+	 * blkcg_destroy_blkgs() shouldn't be called with all the blkcg
+	 * references gone and rcu_read_lock not held.
+	 */
+	if (!css_tryget(&blkcg->css)) {
+		WARN_ON_ONCE(!rcu_read_lock_held());
+		return;
+	}

As I followed the previous discussion, the principle is that obtaining a reference or being inside an RCU read section is sufficient.

Consequently, I'd expect the two situations handled equally but here the no-ref but RCU bails out. (Which is OK because blkg_list must be empty?)

Quoted 8 lines

However, the might_sleep() in (non-sleepable) RCU reader section combo makes me wary anyway (not with the early return but tools would likely complain).

All in all, can't the contract of blkcg_destroy_blkgs() declare that a caller must pass blkcg with a valid reference? (The body of blkcg_destroy_blkgs then wouldn't need to get neither put the inner reference).

You are right. I should have pushed the might_sleep down(). Will post a new version to fix that.

Thanks,
Longman