Re: [RFC PATCH v2 v2 1/5] mm: swap: introduce swap tier infrastructure

Chris Li
2026-02-12T09:08:01Z

Hi Yongjun,

On Sun, Jan 25, 2026 at 10:53 PM Youngjun Park <youngjun.park@lge.com> wrote:
>
> This patch introduces the "Swap tier" concept, which serves as an
> abstraction layer for managing swap devices based on their performance
> characteristics (e.g., NVMe, HDD, Network swap).
>
> Swap tiers are user-named groups representing priority ranges.
> These tiers collectively cover the entire priority
> space from -1 (`DEF_SWAP_PRIO`) to `SHRT_MAX`.
>
> To configure tiers, a new sysfs interface is exposed at
> `/sys/kernel/mm/swap/tiers`. The input parser evaluates commands from
> left to right and supports batch input, allowing users to add, remove or
> modify multiple tiers in a single write operation.
>
> Tier management enforces continuous priority ranges anchored by start
> priorities. Operations trigger range splitting or merging, but overwriting
> start priorities is forbidden. Merging expands lower tiers upwards to
> preserve configured start priorities, except when removing `DEF_SWAP_PRIO`,
> which merges downwards.
>
> Suggested-by: Chris Li <chrisl@kernel.org>
> Signed-off-by: Youngjun Park <youngjun.park@lge.com>
> ---
> MAINTAINERS | 2 +
> mm/Makefile | 2 +-
> mm/swap.h | 4 +
> mm/swap_state.c | 70 +++++++++++
> mm/swap_tier.c | 304 ++++++++++++++++++++++++++++++++++++++++++++++++
> mm/swap_tier.h | 38 ++++++
> mm/swapfile.c | 7 +-
> 7 files changed, 423 insertions(+), 4 deletions(-)
> create mode 100644 mm/swap_tier.c
> create mode 100644 mm/swap_tier.h
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 18d1ebf053db..501bf46adfb4 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -16743,6 +16743,8 @@ F: mm/swap.c
> F: mm/swap.h
> F: mm/swap_table.h
> F: mm/swap_state.c
> +F: mm/swap_tier.c
> +F: mm/swap_tier.h
> F: mm/swapfile.c
>
> MEMORY MANAGEMENT - THP (TRANSPARENT HUGE PAGE)
> diff --git a/mm/Makefile b/mm/Makefile
> index 53ca5d4b1929..3b3de2de7285 100644
> --- a/mm/Makefile
> +++ b/mm/Makefile
> @@ -75,7 +75,7 @@ ifdef CONFIG_MMU
> obj-$(CONFIG_ADVISE_SYSCALLS) += madvise.o
> endif
>
> -obj-$(CONFIG_SWAP) += page_io.o swap_state.o swapfile.o
> +obj-$(CONFIG_SWAP) += page_io.o swap_state.o swapfile.o swap_tier.o
> obj-$(CONFIG_ZSWAP) += zswap.o
> obj-$(CONFIG_HAS_DMA) += dmapool.o
> obj-$(CONFIG_HUGETLBFS) += hugetlb.o hugetlb_sysfs.o hugetlb_sysctl.o
> diff --git a/mm/swap.h b/mm/swap.h
> index bfafa637c458..55f230cbe4e7 100644
> --- a/mm/swap.h
> +++ b/mm/swap.h
> @@ -16,6 +16,10 @@ extern int page_cluster;
> #define swap_entry_order(order) 0
> #endif
>
> +#define DEF_SWAP_PRIO -1
> +
> +extern spinlock_t swap_lock;
> +extern struct plist_head swap_active_head;
> extern struct swap_info_struct *swap_info[];
>
> /*
> diff --git a/mm/swap_state.c b/mm/swap_state.c
> index 6d0eef7470be..f1a7d9cdc648 100644
> --- a/mm/swap_state.c
> +++ b/mm/swap_state.c
> @@ -25,6 +25,7 @@
> #include "internal.h"
> #include "swap_table.h"
> #include "swap.h"
> +#include "swap_tier.h"
>
> /*
> * swapper_space is a fiction, retained to simplify the path through
> @@ -947,8 +948,77 @@ static ssize_t vma_ra_enabled_store(struct kobject *kobj,
> }
> static struct kobj_attribute vma_ra_enabled_attr = __ATTR_RW(vma_ra_enabled);
>
> +static ssize_t tiers_show(struct kobject *kobj,
> + struct kobj_attribute *attr, char *buf)
> +{
> + return swap_tiers_sysfs_show(buf);
> +}
> +
> +static ssize_t tiers_store(struct kobject *kobj,
> + struct kobj_attribute *attr,
> + const char *buf, size_t count)
> +{
> + char *p, *token, *name, *tmp;
> + int ret = 0;
> + short prio;
> + DEFINE_SWAP_TIER_SAVE_CTX(ctx);
> +
> + tmp = kstrdup(buf, GFP_KERNEL);
> + if (!tmp)
> + return -ENOMEM;
> +
> + spin_lock(&swap_lock);
> + spin_lock(&swap_tier_lock);
> +
> + p = tmp;
> + swap_tiers_save(ctx);
> +
> + while (!ret && (token = strsep(&p, ", \t\n")) != NULL) {
> + if (!*token)
> + continue;
> +
> + if (token[0] == '-') {
> + ret = swap_tiers_remove(token + 1);
> + } else {
> +
> + name = strsep(&token, ":");
> + if (!token || kstrtos16(token, 10, &prio)) {
> + ret = -EINVAL;
> + goto out;
> + }
> +
> + if (name[0] == '+')
> + ret = swap_tiers_add(name + 1, prio);
> + else
> + ret = swap_tiers_modify(name, prio);
> + }
> +
> + if (ret)
> + goto restore;
> + }

This function can use some simplification to make the indentation flater.

> +
> + if (!swap_tiers_validate()) {
> + ret = -EINVAL;
> + goto restore;
> + }
> +
> +out:
> + spin_unlock(&swap_tier_lock);
> + spin_unlock(&swap_lock);
> +
> + kfree(tmp);
> + return ret ? ret : count;
> +
> +restore:
> + swap_tiers_restore(ctx);
> + goto out;
> +}
> +
> +static struct kobj_attribute tier_attr = __ATTR_RW(tiers);
> +
> static struct attribute *swap_attrs[] = {
> &vma_ra_enabled_attr.attr,
> + &tier_attr.attr,
> NULL,
> };
>
> diff --git a/mm/swap_tier.c b/mm/swap_tier.c
> new file mode 100644
> index 000000000000..87882272eec8
> --- /dev/null
> +++ b/mm/swap_tier.c
> @@ -0,0 +1,304 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#include <linux/swap.h>
> +#include <linux/memcontrol.h>
> +#include "memcontrol-v1.h"
> +#include <linux/sysfs.h>
> +#include <linux/plist.h>
> +
> +#include "swap.h"
> +#include "swap_tier.h"
> +
> +/*
> + * struct swap_tier - structure representing a swap tier.
> + *
> + * @name: name of the swap_tier.
> + * @prio: starting value of priority.
> + * @list: linked list of tiers.
> +*/
> +static struct swap_tier {
> + char name[MAX_TIERNAME];
> + short prio;
> + struct list_head list;
> +} swap_tiers[MAX_SWAPTIER];

We can have a CONFIG option for the MAX_SWAPTIER. I think the default
should be a small number like 4.

> +
> +DEFINE_SPINLOCK(swap_tier_lock);
> +/* active swap priority list, sorted in descending order */
> +static LIST_HEAD(swap_tier_active_list);
> +/* unused swap_tier object */
> +static LIST_HEAD(swap_tier_inactive_list);
> +
> +#define TIER_IDX(tier) ((tier) - swap_tiers)
> +#define TIER_MASK(tier) (1 << TIER_IDX(tier))
> +#define TIER_INVALID_PRIO (DEF_SWAP_PRIO - 1)
> +#define TIER_END_PRIO(tier) \
> + (!list_is_first(&(tier)->list, &swap_tier_active_list) ? \
> + list_prev_entry((tier), list)->prio - 1 : SHRT_MAX)
> +
> +#define for_each_tier(tier, idx) \
> + for (idx = 0, tier = &swap_tiers[0]; idx < MAX_SWAPTIER; \
> + idx++, tier = &swap_tiers[idx])
> +
> +#define for_each_active_tier(tier) \
> + list_for_each_entry(tier, &swap_tier_active_list, list)
> +
> +#define for_each_inactive_tier(tier) \
> + list_for_each_entry(tier, &swap_tier_inactive_list, list)
> +
> +/*
> + * Naming Convention:
> + * swap_tiers_*() - Public/exported functions
> + * swap_tier_*() - Private/internal functions
> + */
> +
> +static bool swap_tier_is_active(void)
> +{
> + return !list_empty(&swap_tier_active_list) ? true : false;
> +}
> +
> +static struct swap_tier *swap_tier_lookup(const char *name)
> +{
> + struct swap_tier *tier;
> +
> + for_each_active_tier(tier) {
> + if (!strcmp(tier->name, name))
> + return tier;
> + }
> +
> + return NULL;
> +}
> +
> +void swap_tiers_init(void)
> +{
> + struct swap_tier *tier;
> + int idx;
> +
> + BUILD_BUG_ON(BITS_PER_TYPE(int) < MAX_SWAPTIER);
> +
> + for_each_tier(tier, idx) {
> + INIT_LIST_HEAD(&tier->list);
> + list_add_tail(&tier->list, &swap_tier_inactive_list);
> + }
> +}
> +
> +ssize_t swap_tiers_sysfs_show(char *buf)
> +{
> + struct swap_tier *tier;
> + ssize_t len = 0;
> +
> + len += sysfs_emit_at(buf, len, "%-16s %-5s %-11s %-11s\n",
> + "Name", "Idx", "PrioStart", "PrioEnd");
> +
> + spin_lock(&swap_tier_lock);
> + for_each_active_tier(tier) {
> + len += sysfs_emit_at(buf, len, "%-16s %-5ld %-11d %-11d\n",
> + tier->name,
> + TIER_IDX(tier),
> + tier->prio,
> + TIER_END_PRIO(tier));
> + if (len >= PAGE_SIZE)
> + break;
> + }
> + spin_unlock(&swap_tier_lock);
> +
> + return len;
> +}
> +
> +static void swap_tier_insert_by_prio(struct swap_tier *new)
> +{
> + struct swap_tier *tier;
> +
> + for_each_active_tier(tier) {
> + if (tier->prio > new->prio)
> + continue;
> +
> + list_add_tail(&new->list, &tier->list);
> + return;
> + }
> + /* First addition, or becomes the first tier */
> + list_add_tail(&new->list, &swap_tier_active_list);
> +}
> +
> +static void __swap_tier_prepare(struct swap_tier *tier, const char *name,
> + short prio)
> +{
> + list_del_init(&tier->list);
> + strscpy(tier->name, name, MAX_TIERNAME);
> + tier->prio = prio;
> +}
> +
> +static struct swap_tier *swap_tier_prepare(const char *name, short prio)
> +{
> + struct swap_tier *tier;
> +
> + lockdep_assert_held(&swap_tier_lock);
> +
> + if (prio < DEF_SWAP_PRIO)
> + return NULL;
> +
> + if (list_empty(&swap_tier_inactive_list))
> + return ERR_PTR(-EPERM);
> +
> + tier = list_first_entry(&swap_tier_inactive_list,
> + struct swap_tier, list);
> +
> + __swap_tier_prepare(tier, name, prio);
> + return tier;
> +}
> +
> +static int swap_tier_check_range(short prio)
> +{
> + struct swap_tier *tier;
> +
> + lockdep_assert_held(&swap_lock);
> + lockdep_assert_held(&swap_tier_lock);
> +
> + for_each_active_tier(tier) {
> + /* No overwrite */
> + if (tier->prio == prio)
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +int swap_tiers_add(const char *name, int prio)

When we add, modify, remove a tier. The simple case is there is no
swap file under any tiers.
But if the modification causes some swap files to jump to different
tiers. That might be problematic.

> +{
> + int ret;
> + struct swap_tier *tier;
> +
> + lockdep_assert_held(&swap_lock);
> + lockdep_assert_held(&swap_tier_lock);
> +
> + /* Duplicate check */
> + if (swap_tier_lookup(name))
> + return -EPERM;
> +
> + ret = swap_tier_check_range(prio);
> + if (ret)
> + return ret;
> +
> + tier = swap_tier_prepare(name, prio);
> + if (IS_ERR(tier)) {
> + ret = PTR_ERR(tier);
> + return ret;
> + }
> +
> +
> + swap_tier_insert_by_prio(tier);
> + return ret;
> +}
> +
> +int swap_tiers_remove(const char *name)
> +{
> + int ret = 0;
> + struct swap_tier *tier;
> +
> + lockdep_assert_held(&swap_lock);
> + lockdep_assert_held(&swap_tier_lock);
> +
> + tier = swap_tier_lookup(name);
> + if (!tier)
> + return -EINVAL;
> +
> + list_move(&tier->list, &swap_tier_inactive_list);
> +
> + /* Removing DEF_SWAP_PRIO merges into the higher tier. */
> + if (swap_tier_is_active() && tier->prio == DEF_SWAP_PRIO)
> + list_prev_entry(tier, list)->prio = DEF_SWAP_PRIO;
> +
> + return ret;
> +}
> +
> +int swap_tiers_modify(const char *name, int prio)
> +{
> + int ret;
> + struct swap_tier *tier;
> +
> + lockdep_assert_held(&swap_lock);
> + lockdep_assert_held(&swap_tier_lock);
> +
> + tier = swap_tier_lookup(name);
> + if (!tier)
> + return -EINVAL;
> +
> + /* No need to modify */
> + if (tier->prio == prio)
> + return 0;
> +
> + ret = swap_tier_check_range(prio);
> + if (ret)
> + return ret;
> +
> + list_del_init(&tier->list);
> + tier->prio = prio;
> + swap_tier_insert_by_prio(tier);
> +
> + return ret;
> +}
> +
> +/*
> + * XXX: Reverting individual operations becomes complex as the number of
> + * operations grows. Instead, we save the original state beforehand and
> + * fully restore it if any operation fails.
> + */
> +void swap_tiers_save(struct swap_tier_save_ctx ctx[])

I really hope we don't have to do the save and restore thing. Is there
another design we can simplify this?

> +{
> + struct swap_tier *tier;
> + int idx;
> +
> + lockdep_assert_held(&swap_lock);
> + lockdep_assert_held(&swap_tier_lock);
> +
> + for_each_active_tier(tier) {
> + idx = TIER_IDX(tier);
> + strcpy(ctx[idx].name, tier->name);
> + ctx[idx].prio = tier->prio;
> + }
> +
> + for_each_inactive_tier(tier) {
> + idx = TIER_IDX(tier);
> + /* Indicator of inactive */
> + ctx[idx].prio = TIER_INVALID_PRIO;
> + }
> +}
> +
> +void swap_tiers_restore(struct swap_tier_save_ctx ctx[])
> +{
> + struct swap_tier *tier;
> + int idx;
> +
> + lockdep_assert_held(&swap_lock);
> + lockdep_assert_held(&swap_tier_lock);
> +
> + /* Invalidate active list */
> + list_splice_tail_init(&swap_tier_active_list,
> + &swap_tier_inactive_list);
> +
> + for_each_tier(tier, idx) {
> + if (ctx[idx].prio != TIER_INVALID_PRIO) {
> + /* Preserve idx(mask) */
> + __swap_tier_prepare(tier, ctx[idx].name, ctx[idx].prio);
> + swap_tier_insert_by_prio(tier);
> + }
> + }
> +}
> +
> +bool swap_tiers_validate(void)
> +{
> + struct swap_tier *tier;
> +
> + /*
> + * Initial setting might not cover DEF_SWAP_PRIO.
> + * Swap tier must cover the full range (DEF_SWAP_PRIO to SHRT_MAX).
> + * Also, modify operation can change only one remaining priority.
> + */
> + if (swap_tier_is_active()) {
> + tier = list_last_entry(&swap_tier_active_list,
> + struct swap_tier, list);
> +
> + if (tier->prio != DEF_SWAP_PRIO)
> + return false;
> + }
> +
> + return true;
> +}
> diff --git a/mm/swap_tier.h b/mm/swap_tier.h
> new file mode 100644
> index 000000000000..4b1b0602d691
> --- /dev/null
> +++ b/mm/swap_tier.h
> @@ -0,0 +1,38 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#ifndef _SWAP_TIER_H
> +#define _SWAP_TIER_H
> +
> +#include <linux/types.h>
> +#include <linux/spinlock.h>
> +
> +#define MAX_TIERNAME 16
> +
> +/* Ensure MAX_SWAPTIER does not exceed MAX_SWAPFILES */
> +#if 8 > MAX_SWAPFILES
> +#define MAX_SWAPTIER MAX_SWAPFILES
> +#else
> +#define MAX_SWAPTIER 8
> +#endif
> +
> +extern spinlock_t swap_tier_lock;
> +
> +struct swap_tier_save_ctx {
> + char name[MAX_TIERNAME];
> + short prio;
> +};
> +
> +#define DEFINE_SWAP_TIER_SAVE_CTX(_name) \
> + struct swap_tier_save_ctx _name[MAX_SWAPTIER] = {0}
> +
> +/* Initialization and application */
> +void swap_tiers_init(void);
> +ssize_t swap_tiers_sysfs_show(char *buf);
> +
> +int swap_tiers_add(const char *name, int prio);
> +int swap_tiers_remove(const char *name);
> +int swap_tiers_modify(const char *name, int prio);
> +
> +void swap_tiers_save(struct swap_tier_save_ctx ctx[]);
> +void swap_tiers_restore(struct swap_tier_save_ctx ctx[]);
> +bool swap_tiers_validate(void);
> +#endif /* _SWAP_TIER_H */
> diff --git a/mm/swapfile.c b/mm/swapfile.c
> index 7b055f15d705..c27952b41d4f 100644
> --- a/mm/swapfile.c
> +++ b/mm/swapfile.c
> @@ -50,6 +50,7 @@
> #include "internal.h"
> #include "swap_table.h"
> #include "swap.h"
> +#include "swap_tier.h"
>
> static bool swap_count_continued(struct swap_info_struct *, pgoff_t,
> unsigned char);
> @@ -65,7 +66,7 @@ static void move_cluster(struct swap_info_struct *si,
> struct swap_cluster_info *ci, struct list_head *list,
> enum swap_cluster_flags new_flags);
>
> -static DEFINE_SPINLOCK(swap_lock);
> +DEFINE_SPINLOCK(swap_lock);
> static unsigned int nr_swapfiles;
> atomic_long_t nr_swap_pages;
> /*
> @@ -76,7 +77,6 @@ atomic_long_t nr_swap_pages;
> EXPORT_SYMBOL_GPL(nr_swap_pages);
> /* protected with swap_lock. reading in vm_swap_full() doesn't need lock */
> long total_swap_pages;
> -#define DEF_SWAP_PRIO -1
> unsigned long swapfile_maximum_size;
> #ifdef CONFIG_MIGRATION
> bool swap_migration_ad_supported;
> @@ -89,7 +89,7 @@ static const char Bad_offset[] = "Bad swap offset entry ";
> * all active swap_info_structs
> * protected with swap_lock, and ordered by priority.
> */
> -static PLIST_HEAD(swap_active_head);
> +PLIST_HEAD(swap_active_head);

One idea is to make each tier have swap_active_head. So different swap
entry releases on different tiers don't need to be competing on the
same swap_active_head.

That will require the swapfile don't jump to another tiers.

Chris