From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1794272966; b=Dr9XNjUojRt8z9DCsBF8ASkJshjrQUxKEyvkLP780Ca5B8Ggbzq2xebIKqWZgRyJc0+7 OfUCrbehetRIFS8r6AinviPclKA5QIAfDw0JoFdLvbTkjF7GxLVQeku1vMVPkvL31/Qjs znQ1aGsixAHlIp7xd8WGss7xs7OdZzhqAvw1Ou2G+jzZwkWcOpSWky9RuNVq0c5sbljfA /IaOPUcxUVAcdqrtXXu08YjS9L1XrbAJ8ZVzkaj+ewu+OA0topbAHV7yU7w7vVDWLT9XY TOCakXC92dhfnGHGvwL+4qmVx0qvIo8wsCjINllI0iCwMB93Q37ysdc0aX1kdgc/buQ== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1794272966; h=Received:DKIM-Signature:From:To:Cc:Subject:Date:Message-ID:X-Mailer: MIME-Version:Content-Type:Content-Transfer-Encoding; bh=Bc16yav1FZuws3KYO3Gox+CcCjEw9wElWyXZPJWz7HI=; b=POxesiLgGPkFSu8XyYQ5/AHryofNvL/LktRgDLQODtQ62jXMprmRLZmhBYfVHoGxwuIr j71KgkVYWGIKa+ajMZD8yW/41aGM+heaT7aO7X/IMFAaHEOLwoL0oGIuEXe3KdDlzpQ+8 IvGCHNLGJXV/RW9R6bHC3euJdxwMyT2bV/2h6rv1HHzKE9tc5OBsurFCstUaL482ghkhh MFtWnZS4UjEDZ69vZGzK4qZVfOItnqQQS1FHaiHLw3gpfGhHYOt+8SxU9LwQHxR7vIrUy h5xL4MOmLcKANn3iDoXFVUAq4DD9S5NBmYD2GaXyih+UINKjUEEq2mRezzeSJGxGcfA== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=n25o3yvX; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id ADBB9606A31C for ; Tue, 10 Nov 2026 01:09:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=n25o3yvX Received: by smtp.kernel.org (Postfix) with ESMTPSA id CF19D1F0089F; Tue, 10 Nov 2026 01:09:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1794272965; bh=Bc16yav1FZuws3KYO3Gox+CcCjEw9wElWyXZPJWz7HI=; h=From:To:Cc:Subject:Date; b=n25o3yvXYl852IHRXx9Us+DtYZ9+56Hckvv7OAWPVYWl5U6LE8wwyunA5RUC5xrPr l/BTZn0rl4edJAKBn/zxP2kuXUar1iBElx6gfGS8EvFl8+lhELqtQd+w5rhAnLRT8S 5ykIfF1MALv2lzbLxOzMP1hEXQXFYalJ71lTXVAI/9dfDzobt9LNzsj2qxCr1B2iO3 1/ODzck1auvrMftE8CdUliA4uubDQvc2BpLPGzSt9b+SDBs0gVG6tYnYT+WUzg1XSJ AdjfBuHucvACGd0wpc1KufcIn6GjIgtTkBwhltd6m6Vc8M8czqOeImZd5lEnAs8v/x wtvGCrQ4MCQ4g== From: Sasha Levin To: david@kernel.org, mason@kernel.org, ljs@kernel.org, xu.xin@linux.dev, usama.anjum@arm.com Cc: stable@vger.kernel.org Subject: FAILED: patch "[PATCH] mm/ksm: fix use of a freed anon_vma at swap-in" failed to apply to 6.12-stable tree Date: Mon, 9 Nov 2026 20:09:23 -0500 Message-ID: <20261109200923-failed-6.12-4c2dec1dce36@kernel.org> X-Mailer: git-send-email 2.53.0 X-Mailing-List: stable@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The patch below does not apply to the 6.12-stable tree. If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to . To reproduce the conflict and resubmit, you may use the following commands: git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.12.y git checkout FETCH_HEAD git cherry-pick -x 4c2dec1dce368ad9e9b1814307cb5ef3832fa07e # git commit -s git send-email --to '' --in-reply-to '20261109200923-failed-6.12-4c2dec1dce36@kernel.org' --subject-prefix 'PATCH 6.12.y' 'HEAD^..' Thanks, Sasha ------------------ original commit in Linus's tree ------------------ >From 4c2dec1dce368ad9e9b1814307cb5ef3832fa07e Mon Sep 17 00:00:00 2001 From: "David Hildenbrand (Arm)" Date: Sat, 31 Oct 2026 10:40:09 +0100 Subject: [PATCH] mm/ksm: fix use of a freed anon_vma at swap-in MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A folio read from a swap slot previously shared by KSM can remain in the swap cache after the process that first mapped it exits. Its anon_vma can then be freed, so ksm_might_need_to_copy() must not dereference it to compare roots. Doing so can result in some false-positives, resulting in the reverse mapping missing the new folio mapping, preventing migration and reclaim. SLAB_TYPESAFE_BY_RCU allows individual anon_vma objects to be reused immediately after freeing. A stale pointer can then refer to another anon_vma whose root matches, even though the target VMA is not linked to that anon_vma. Move the anonymous rmap compatibility checks into folio_anon_rmap_compatible(). Keep the page-index check and compare the folio's anon_vma pointer against the VMA's own anon_vma and root first. If neither matches, bite the bullet and walk the VMA's anon_vma_chain. The VMA keeps these anon_vmas alive, and finding a match guarantees that reverse mapping can find the new mapping. Lorenzo Stoakes says in a private discussion: "This isn't quite equivalent to the existing check. Every anon_vma in an anon_vma_chain shares the same root, but if you split a VMA then fork both of them like this: VMA A / \ VMA B VMA C \ / root <- anon_vma 1 ----^ ^---- / parent \ anon_vma 2 anon_vma 3 | | VMA D VMA E VMA's D and E both get their own new anon_vma's such that: VMA D: anon_vma 2 -> anon_vma 1 -> root VMA E: anon_vma 3 -> anon_vma 1 -> root And if you found a folio referencing anon_vma 2, the existing check: anon_vma->root == vma->anon-vma->root Would be true for VMA's B, C, D & E. However after your change it'd be true for VMA D only, as it's the only one with anon_vma 2 in its anon_vma_chain. Whether or not that could actually happen in practice... 🙂 I don't know. [...] after your change it'd be true for VMA D only, as it's the only one with anon_vma 2 in its anon_vma_chain. [...] I would [...] say that you are making the test stricter but more correct. " If this affects performance when KSM was never even involved, we could just track whether KSM ever merged anything and just skip these checks. There isn't really a lot we can do otherwise: for mapped folios we might be able to use folio_get_anon_vma(), but for unmapped folios there really is no easy way to see if the anon_vma is still valid. Document the (confusing) lifetime requirements of folio_anon_vma(). Fixes: ba6f0ff3981e ("ksm: fix ksm swapin time optimization") Cc: stable@vger.kernel.org Reported-by: Chris Mason Reviewed-by: Lorenzo Stoakes (ARM) Acked-by: Xu Xin Tested-by: Muhammad Usama Anjum Link: https://patch.msgid.link/20261031-fixes_core-v3-40-d6437171ecc3@kernel.org Signed-off-by: David Hildenbrand (Arm) --- mm/ksm.c | 36 +++++++++++++++++++++++++++++++----- mm/util.c | 13 +++++++++++++ 2 files changed, 44 insertions(+), 5 deletions(-) diff --git a/mm/ksm.c b/mm/ksm.c index 9c51925825cbf..e050b1bdf810d 100644 --- a/mm/ksm.c +++ b/mm/ksm.c @@ -3137,11 +3137,40 @@ void __ksm_exit(struct mm_struct *mm) trace_ksm_exit(mm); } +static bool folio_anon_rmap_compatible(const struct folio *folio, + struct vm_area_struct *vma, unsigned long addr) +{ + const struct anon_vma *anon_vma = folio_anon_vma(folio); + struct anon_vma_chain *avc; + + VM_WARN_ON_ONCE_FOLIO(!folio_test_locked(folio), folio); + VM_WARN_ON_ONCE_FOLIO(folio_test_large(folio), folio); + VM_WARN_ON_ONCE_FOLIO(folio_test_ksm(folio), folio); + vma_assert_stabilised(vma); + + if (!anon_vma) + return true; + if (folio->index != linear_anon_page_index(vma, addr)) + return false; + + /* + * Careful: anon_vma might have been freed, so we cannot safely + * dereference it. Add a fast path before we walk the anon_vma chain. + */ + if (anon_vma == vma->anon_vma || anon_vma == vma->anon_vma->root) + return true; + + list_for_each_entry(avc, &vma->anon_vma_chain, same_vma) { + if (avc->anon_vma == anon_vma) + return true; + } + return false; +} + struct folio *ksm_might_need_to_copy(struct folio *folio, struct vm_area_struct *vma, unsigned long addr) { struct page *page = folio_page(folio, 0); - struct anon_vma *anon_vma = folio_anon_vma(folio); struct folio *new_folio; if (folio_test_large(folio)) @@ -3151,10 +3180,7 @@ struct folio *ksm_might_need_to_copy(struct folio *folio, if (folio_stable_node(folio) && !(ksm_run & KSM_RUN_UNMERGE)) return folio; /* no need to copy it */ - } else if (!anon_vma) { - return folio; /* no need to copy it */ - } else if (folio->index == linear_anon_page_index(vma, addr) && - anon_vma->root == vma->anon_vma->root) { + } else if (folio_anon_rmap_compatible(folio, vma, addr)) { return folio; /* still no need to copy it */ } if (PageHWPoison(page)) diff --git a/mm/util.c b/mm/util.c index 8acfe2148ba52..80f6c714844f2 100644 --- a/mm/util.c +++ b/mm/util.c @@ -697,6 +697,19 @@ void *vcalloc_noprof(size_t n, size_t size) } EXPORT_SYMBOL(vcalloc_noprof); +/** + * folio_anon_vma - Get a folio's raw anon_vma pointer. + * @folio: The folio. + * + * The returned pointer may be stale for an unmapped folio. The caller + * must ensure the anon_vma stays alive before dereferencing it. A folio + * reference or lock alone is insufficient; use folio_get_anon_vma() when + * the anon_vma's lifetime is not otherwise protected. Note that + * folio_get_anon_vma() is only useful for folios that are still mapped. + * + * Return: The raw anon_vma pointer for an anonymous, non-KSM folio, or + * %NULL otherwise. + */ struct anon_vma *folio_anon_vma(const struct folio *folio) { unsigned long mapping = (unsigned long)folio->mapping; -- 2.53.0