[PATCH v6 13/14] mm, swap: do not give an xswap slot to a cgroup that cannot zswap
From: Baoquan He
Date: Sun Nov 22 2026 - 07:48:49 EST
From: Baoquan He <hebaoquan@xxxxxxxxxx>
At this point, an xswap slot holds only a zswap-backed page. It has no
storage of its own. If the folio's cgroup cannot take another zswap
page, giving it an xswap slot is wasted: zswap refuses the page and the
slot cannot hold it.
Skip xswap devices when the cgroup cannot zswap, and try a physical swap
device instead.
The check is obj_cgroup_may_zswap(): zswap_store() uses the same check
but first tries to shrink the memcg, while the allocation-time check does
not, so it is stricter.
Signed-off-by: Baoquan He <hebaoquan@xxxxxxxxxx>
---
mm/swapfile.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++-----
1 file changed, 66 insertions(+), 6 deletions(-)
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 462efeef887a..90f17edce1d0 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -226,6 +226,8 @@ static DEFINE_SPINLOCK(swap_lock);
static unsigned int nr_swapfiles;
atomic_long_t nr_swap_pages;
atomic_t nr_real_swapfiles;
+/* Active xswap devices, as in nr_real_swapfiles. */
+static atomic_t nr_xswap_files;
/*
* Some modules use swappable objects and may try to swap them out under
* memory pressure (via the shrinker). Before doing so, they may wish to
@@ -1452,7 +1454,9 @@ static void del_from_avail_list(struct swap_info_struct *si, bool swapoff)
lockdep_assert_held(&si->lock);
si->flags &= ~SWP_WRITEOK;
/* Count active devices, not merely those on the avail list. */
- if (!(si->flags & SWP_XSWAP))
+ if (si->flags & SWP_XSWAP)
+ atomic_sub(1, &nr_xswap_files);
+ else
atomic_sub(1, &nr_real_swapfiles);
atomic_long_or(SWAP_USAGE_OFFLIST_BIT, &si->inuse_pages);
} else {
@@ -1488,7 +1492,9 @@ static void add_to_avail_list(struct swap_info_struct *si, bool swapon)
lockdep_assert_held(&si->lock);
si->flags |= SWP_WRITEOK;
/* A full device is still active and skips the add below. */
- if (!(si->flags & SWP_XSWAP))
+ if (si->flags & SWP_XSWAP)
+ atomic_add(1, &nr_xswap_files);
+ else
atomic_add(1, &nr_real_swapfiles);
} else {
if (!(READ_ONCE(si->flags) & SWP_WRITEOK))
@@ -1612,7 +1618,7 @@ static bool get_swap_device_info(struct swap_info_struct *si)
* Fast path try to get swap entries with specified order from current
* CPU's swap entry pool (a cluster).
*/
-static bool swap_alloc_fast(struct folio *folio)
+static bool swap_alloc_fast(struct folio *folio, bool may_zswap)
{
unsigned int order = folio_order(folio);
struct swap_cluster_info *ci;
@@ -1628,6 +1634,11 @@ static bool swap_alloc_fast(struct folio *folio)
if (!si || !offset || !get_swap_device_info(si))
return false;
+ if (!may_zswap && (si->flags & SWP_XSWAP)) {
+ put_swap_device(si);
+ return false;
+ }
+
ci = swap_cluster_lock(si, offset);
if (cluster_is_usable(ci, order)) {
if (cluster_is_empty(ci))
@@ -1642,13 +1653,19 @@ static bool swap_alloc_fast(struct folio *folio)
}
/* Rotate the device and switch to a new cluster */
-static void swap_alloc_slow(struct folio *folio)
+static void swap_alloc_slow(struct folio *folio, bool may_zswap)
{
struct swap_info_struct *si, *next;
spin_lock(&swap_avail_lock);
start_over:
plist_for_each_entry_safe(si, next, &swap_avail_head, avail_list) {
+ /*
+ * Do not rotate a skipped device: the walk follows the
+ * rotation and would spin forever.
+ */
+ if (!may_zswap && (si->flags & SWP_XSWAP))
+ continue;
/* Rotate the device and switch to a new cluster */
plist_requeue(&si->avail_list, &swap_avail_head);
spin_unlock(&swap_avail_lock);
@@ -1971,6 +1988,17 @@ static int swap_dup_entries_cluster(struct swap_info_struct *si,
return err;
}
+/* Can the folio's cgroup take another zswap page? */
+static bool folio_may_zswap(struct folio *folio)
+{
+ struct obj_cgroup *objcg = get_obj_cgroup_from_folio(folio);
+ bool may_zswap = !objcg || obj_cgroup_may_zswap(objcg);
+
+ if (objcg)
+ obj_cgroup_put(objcg);
+ return may_zswap;
+}
+
/**
* folio_alloc_swap - allocate swap space for a folio
* @folio: folio we want to move to swap
@@ -1987,10 +2015,21 @@ int folio_alloc_swap(struct folio *folio)
{
unsigned int order = folio_order(folio);
unsigned int size = 1 << order;
+ bool may_zswap = true;
+ bool zswap_checked = false;
VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);
VM_BUG_ON_FOLIO(!folio_test_uptodate(folio), folio);
+ /*
+ * A folio zswap will not take must not get an xswap slot; without
+ * a device to route away from, skip the lookup.
+ */
+ if (atomic_read(&nr_xswap_files)) {
+ may_zswap = folio_may_zswap(folio);
+ zswap_checked = true;
+ }
+
if (order) {
/*
* Reject large allocation when THP_SWAP is disabled. Check below
@@ -2011,8 +2050,8 @@ int folio_alloc_swap(struct folio *folio)
again:
local_lock(&percpu_swap_cluster.lock);
- if (!swap_alloc_fast(folio))
- swap_alloc_slow(folio);
+ if (!swap_alloc_fast(folio, may_zswap))
+ swap_alloc_slow(folio, may_zswap);
local_unlock(&percpu_swap_cluster.lock);
if (!order && unlikely(!folio_test_swapcache(folio))) {
@@ -2020,6 +2059,20 @@ int folio_alloc_swap(struct folio *folio)
goto again;
}
+ /*
+ * The gate was skipped when there was no device; one may have
+ * appeared since, so ask the slot itself.
+ */
+ if (unlikely(!zswap_checked && folio_test_swapcache(folio) &&
+ (__swap_entry_to_info(folio->swap)->flags & SWP_XSWAP))) {
+ zswap_checked = true;
+ may_zswap = folio_may_zswap(folio);
+ if (!may_zswap) {
+ swap_cache_del_folio(folio);
+ goto again;
+ }
+ }
+
/* Need to call this even if allocation failed, for MEMCG_SWAP_FAIL. */
if (unlikely(mem_cgroup_try_charge_swap(folio))) {
swap_cache_del_folio(folio);
@@ -2037,6 +2090,13 @@ int folio_alloc_swap(struct folio *folio)
if (mem_cgroup_get_folio_swap_margin(folio) <= 0)
return -ENOMEM;
+ /*
+ * Only xswap devices exist and the folio cannot use them; splitting
+ * cannot help.
+ */
+ if (!may_zswap && !atomic_read(&nr_real_swapfiles))
+ return -ENOMEM;
+
return order ? -E2BIG : -ENOMEM;
}
--
2.54.0