[PATCH v6 4/6] fs/resctrl: Stop the limbo handler while resctrl is unmounted
From: Jinjie Ruan
Date: Thu Nov 19 2026 - 04:51:15 EST
A monitoring group's RMID is not returned to the free list when the
group is removed. It stays in limbo until the cache occupancy still
counted against it has dropped low enough for the RMID to be reused,
which the limbo handler checks once a second.
The limbo handler keeps running after resctrl is unmounted, where there
is nothing for it to achieve. An RMID is only allocated when a group is
created, which needs resctrl to be mounted, so no RMID the limbo handler
returns to the free list can be used before the next mount, and that
mount can check them itself. The MBM overflow handler already stops for
this reason once resctrl_mounted is cleared.
Reading the RMIDs in limbo while resctrl is unmounted is not safe on
every architecture. On MPAM the counter of an RMID is selected by the
CLOSID that owns it, and the CLOSID depends on the CDP state. Unmount
clears the CDP state, so the limbo handler that keeps running reads the
RMIDs freed under CDP through the CLOSIDs of the cleared state.
Stop the limbo handler while resctrl is unmounted, as the overflow
handler does, and restart it after a mount on every domain that still
has RMIDs in limbo. The worker can stay queued across the unmount, so
cancel it before queuing it again.
Fixes: 6789fb99282c ("arm_mpam: resctrl: Add CDP emulation")
Suggested-by: Reinette Chatre <reinette.chatre@xxxxxxxxx>
Signed-off-by: Jinjie Ruan <ruanjinjie@xxxxxxxxxx>
Cc: <stable@xxxxxxxxxxxxxxx>
---
v6:
- Explain first why stopping the limbo handler is fine on every
architecture, and describe MPAM by CLOSID only (Reinette).
- Rename resctrl_limbo_resume() to cqm_resume_limbo_handler() and declare
it with the other limbo handler helpers (Reinette).
- Return early when the L3 resource is not mon_capable (Reinette).
- Drop the stable version range, the Fixes tag already gives it.
---
fs/resctrl/internal.h | 2 ++
fs/resctrl/monitor.c | 42 ++++++++++++++++++++++++++++++++++++++++--
fs/resctrl/rdtgroup.c | 2 ++
3 files changed, 44 insertions(+), 2 deletions(-)
diff --git a/fs/resctrl/internal.h b/fs/resctrl/internal.h
index 1c85e06f09bf..f52e0937702a 100644
--- a/fs/resctrl/internal.h
+++ b/fs/resctrl/internal.h
@@ -401,6 +401,8 @@ bool is_mba_sc(struct rdt_resource *r);
void cqm_setup_limbo_handler(struct rdt_l3_mon_domain *dom, unsigned long delay_ms,
int exclude_cpu);
+void cqm_resume_limbo_handler(void);
+
void cqm_handle_limbo(struct work_struct *work);
bool has_busy_rmid(struct rdt_l3_mon_domain *d);
diff --git a/fs/resctrl/monitor.c b/fs/resctrl/monitor.c
index ae9ddd380515..ede1708b920e 100644
--- a/fs/resctrl/monitor.c
+++ b/fs/resctrl/monitor.c
@@ -852,6 +852,13 @@ void cqm_handle_limbo(struct work_struct *work)
*/
mutex_lock(&rdtgroup_mutex);
+ /*
+ * If the filesystem has been unmounted this work no longer needs to
+ * run. cqm_resume_limbo_handler() restarts it on the next mount.
+ */
+ if (!resctrl_mounted)
+ goto out_unlock;
+
/*
* Ensure the worker is dedicated to a CPU as intended and not
* relocated by workqueue subsystem as part of CPU going offline.
@@ -1001,8 +1008,8 @@ int setup_rmid_lru_list(void)
/*
* Called on every mount, but the number of RMIDs cannot change
* after the first mount, so keep using the same set of rmid_ptrs[]
- * until resctrl_exit(). Note that the limbo handler continues to
- * access rmid_ptrs[] after resctrl is unmounted.
+ * until resctrl_exit(). Note that the RMIDs in limbo stay in limbo
+ * across an unmount and are checked again after the next mount.
*/
if (rmid_ptrs)
return 0;
@@ -1033,6 +1040,37 @@ int setup_rmid_lru_list(void)
return 0;
}
+/**
+ * cqm_resume_limbo_handler() - Restart the limbo handler after a mount.
+ *
+ * The limbo handler stops while resctrl is unmounted. Restart it on every
+ * domain that still has RMIDs in limbo.
+ */
+void cqm_resume_limbo_handler(void)
+{
+ struct rdt_resource *r = resctrl_arch_get_resource(RDT_RESOURCE_L3);
+ struct rdt_l3_mon_domain *d;
+
+ lockdep_assert_cpus_held();
+ lockdep_assert_held(&rdtgroup_mutex);
+
+ if (!r->mon_capable || !resctrl_is_mon_event_enabled(QOS_L3_OCCUP_EVENT_ID))
+ return;
+
+ list_for_each_entry_rcu(d, &r->mon_domains, hdr.list,
+ lockdep_is_cpus_held()) {
+ if (!has_busy_rmid(d))
+ continue;
+
+ /*
+ * The unmount may have left the worker queued. Cancel it so
+ * it is queued again on a CPU picked now.
+ */
+ cancel_delayed_work(&d->cqm_limbo);
+ cqm_setup_limbo_handler(d, 0, RESCTRL_PICK_ANY_CPU);
+ }
+}
+
void free_rmid_lru_list(void)
{
if (!resctrl_arch_mon_capable())
diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c
index 3312637fb514..c7c4f618208d 100644
--- a/fs/resctrl/rdtgroup.c
+++ b/fs/resctrl/rdtgroup.c
@@ -3267,6 +3267,8 @@ static int rdt_get_tree(struct fs_context *fc)
RESCTRL_PICK_ANY_CPU);
}
+ cqm_resume_limbo_handler();
+
/*
* Ensure root remains accessible after mutex is unlocked so that
* kernfs_kill_sb() can run safely if called by kernfs_get_tree()'s
--
2.34.1