archives/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-03-08 03:44:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

mm, swap: swap entry of a bad slot should not be considered as swapped out

Browse source 
When checking if a swap entry is swapped out, we simply check if the
bitwise result of the count value is larger than 0.  But SWAP_MAP_BAD will
also be considered as a swao count value larger than 0.

SWAP_MAP_BAD being considered as a count value larger than 0 is useful for
the swap allocator: they will be seen as a used slot, so the allocator
will skip them.  But for the swapped out check, this isn't correct.

There is currently no observable issue.  The swapped out check is only
useful for readahead and folio swapped-out status check.  For readahead,
the swap cache layer will abort upon checking and updating the swap map. 
For the folio swapped out status check, the swap allocator will never
allocate an entry of bad slots to folio, so that part is fine too.  The
worst that could happen now is redundant allocation/freeing of folios and
waste CPU time.

This also makes it easier to get rid of swap map checking and update
during folio insertion in the swap cache layer.

Link: https://lkml.kernel.org/r/20251220-swap-table-p2-v5-9-8862a265a033@tencent.com
Signed-off-by: Kairui Song <kasong@tencent.com>
Reviewed-by: Baoquan He <bhe@redhat.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: Chris Li <chrisl@kernel.org>
Cc: Nhat Pham <nphamcs@gmail.com>
Cc: Rafael J. Wysocki (Intel) <rafael@kernel.org>
Cc: Yosry Ahmed <yosry.ahmed@linux.dev>
Cc: Deepanshu Kartikey <kartikey406@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Kairui Song <ryncsn@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
Kairui Song 2025-12-20 03:43:38 +08:00 • committed by Andrew Morton
parent bc617c990e
commit f7ad377a92
2 changed files with 10 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

2
mm/swap_state.c
View file

@ -526,7 +526,7 @@ struct folio *swap_cache_alloc_folio(swp_entry_t entry, gfp_t gfp_mask,
if (folio)
return folio;
/* Skip allocation for unused swap slot for readahead path. */
/* Skip allocation for unused and bad swap slot for readahead. */
if (!swap_entry_swapped(si, entry))
return NULL;

17
mm/swapfile.c
View file

@ -1766,10 +1766,10 @@ int __swap_count(swp_entry_t entry)
return swap_count(si->swap_map[offset]);
}
/*
* How many references to @entry are currently swapped out?
* This does not give an exact answer when swap count is continued,
* but does include the high COUNT_CONTINUED flag to allow for that.
/**
* swap_entry_swapped - Check if the swap entry is swapped.
* @si: the swap device.
* @entry: the swap entry.
*/
bool swap_entry_swapped(struct swap_info_struct *si, swp_entry_t entry)
{
@ -1780,7 +1780,8 @@ bool swap_entry_swapped(struct swap_info_struct *si, swp_entry_t entry)
ci = swap_cluster_lock(si, offset);
count = swap_count(si->swap_map[offset]);
swap_cluster_unlock(ci);
return !!count;
return count && count != SWAP_MAP_BAD;
}
/*
@ -3677,10 +3678,10 @@ static int __swap_duplicate(swp_entry_t entry, unsigned char usage, int nr)
count = si->swap_map[offset + i];
/*
* swapin_readahead() doesn't check if a swap entry is valid, so the
* swap entry could be SWAP_MAP_BAD. Check here with lock held.
* For swapin out, allocator never allocates bad slots. for
* swapin, readahead is guarded by swap_entry_swapped.
*/
if (unlikely(swap_count(count) == SWAP_MAP_BAD)) {
if (WARN_ON(swap_count(count) == SWAP_MAP_BAD)) {
err = -ENOENT;
goto unlock_out;
}