FAILED: patch "[PATCH] mm/kmemleak: fix checksum computation for per-cpu objects" failed to apply to 6.12-stable tree
Subsystems (3)
[email protected]
maintainerThe 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 <[email protected]>.
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 79c37ae3733e93d9d8ea12ecb44f717e61439024
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026072949-quarry-sleet-f3e6@gregkh' --subject-prefix 'PATCH 6.12.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 79c37ae3733e93d9d8ea12ecb44f717e61439024 Mon Sep 17 00:00:00 2001
From: Breno Leitao <[email protected]>
Date: Fri, 3 Jul 2026 09:17:24 -0700
Subject: [PATCH] mm/kmemleak: fix checksum computation for per-cpu objects
The per-cpu object checksum folds each CPU's CRC together with XOR and seeds every CRC with 0. Both choices make update_checksum() miss content changes:
- XOR is self-cancelling, so equal contents on two CPUs cancel out and simultaneous identical changes leave the checksum unchanged.
- crc32(0, ...) over all-zero content is 0, so a freshly allocated, zeroed per-cpu area checksums to 0, matching the initial value, and the object is never seen to change.
See discussions at [0].
When update_checksum() wrongly reports an actively modified object as unchanged, kmemleak stops greying it for an extra scan and can report a live per-cpu object as a leak.
Fold the per-cpu CRC as a single rolling checksum across all CPUs and initialise the object checksum to ~0 so the first computed value always registers as a change, even for content that hashes to 0. reset_checksum() is seeded the same way.
mm/kmemleak.c +4 -3
@@ -687,7 +687,7 @@ static struct kmemleak_object *__alloc_object(gfp_t gfp)atomic_set (&object->use_count,1 ); object->excess_ref =0 ; object->count =0 ;/* white color initially */ - object->checksum =0 ; + object->checksum = ~0 ; object->del_state =0 ;/* task information */
@@ -981,7 +981,7 @@ static void reset_checksum(unsigned long ptr) }raw_spin_lock_irqsave (&object->lock, flags); - object->checksum =0 ; + object->checksum = ~0 ;raw_spin_unlock_irqrestore (&object->lock, flags);put_object (object); }
@@ -1410,7 +1410,8 @@ static bool update_checksum(struct kmemleak_object *object)for_each_possible_cpu (cpu) {void *ptr =per_cpu_ptr ((void __percpu *)object->pointer, cpu); - object->checksum ^=crc32 (0 ,kasan_reset_tag ((void *)ptr), object->size); + object->checksum =crc32 (object->checksum, +kasan_reset_tag ((void *)ptr), object->size); } }else { object->checksum =crc32 (0 ,kasan_reset_tag ((void *)object->pointer), object->size);
Sasha Levin
maintainerPATCH 1/2 kmemleak: iommu/iova: fix transient kmemleak false positive
From: Catalin Marinas <[email protected]>
[ Upstream commit 7591c127f3b17d5879f18819cad7058bf3a2e276 ]
The introduction of iova_depot_pop() in 911aa1245da8 ("iommu/iova: Make the rcache depot scale better") confused kmemleak by moving a struct iova_magazine object from a singly linked list to rcache->depot and resetting the 'next' pointer referencing it. Unlike doubly linked lists, the content of the object being referred is never changed on removal from a singly linked list and the kmemleak checksum heuristics do not detect such scenario. This leads to false positives like:
unreferenced object 0xffff8881a5301000 (size 1024):
comm "softirq", pid 0, jiffies 4306297099 (age 462.991s) hex dump (first 32 bytes):
00 00 00 00 00 00 00 00 e7 7d 05 00 00 00 00 00 .........}......
0f b4 05 00 00 00 00 00 b4 96 05 00 00 00 00 00 ................
backtrace:
[<ffffffff819f5f08>] __kmem_cache_alloc_node+0x1e8/0x320
[<ffffffff818a239a>] kmalloc_trace+0x2a/0x60
[<ffffffff8231d31e>] free_iova_fast+0x28e/0x4e0
[<ffffffff82310860>] fq_ring_free_locked+0x1b0/0x310
[<ffffffff8231225d>] fq_flush_timeout+0x19d/0x2e0
[<ffffffff813e95ba>] call_timer_fn+0x19a/0x5c0
[<ffffffff813ea16b>] __run_timers+0x78b/0xb80
[<ffffffff813ea5bd>] run_timer_softirq+0x5d/0xd0
[<ffffffff82f1d915>] __do_softirq+0x205/0x8b5Introduce kmemleak_transient_leak() which resets the object checksum requiring another scan pass before it is reported (if still unreferenced). Call this new API in iova_depot_pop().
Stable-dep-of: 79c37ae3733e ("mm/kmemleak: fix checksum computation for per-cpu objects")
--- Documentation/dev-tools/kmemleak.rst | 1 + drivers/iommu/iova.c | 6 +++++ include/linux/kmemleak.h | 4 +++ mm/kmemleak.c | 39 ++++++++++++++++++++++++++++ 4 files changed, 50 insertions(+)
Documentation/dev-tools/kmemleak.rst +1 -0
@@ -161,6 +161,7 @@ See the include/linux/kmemleak.h header for the functions prototype. - ``kmemleak_free_percpu`` - notify of a percpu memory block freeing - ``kmemleak_update_trace`` - update object allocation stack trace - ``kmemleak_not_leak`` - mark an object as not a leak +- ``kmemleak_transient_leak`` - mark an object as a transient leak - ``kmemleak_ignore`` - do not scan or report an object as leak - ``kmemleak_scan_area`` - add scan areas inside a memory block - ``kmemleak_no_scan`` - do not scan a memory block
drivers/iommu/iova.c +6 -0
@@ -6,6 +6,7 @@*/ #include <linux/iova.h> +#include <linux/kmemleak.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/smp.h>
@@ -673,6 +674,11 @@ static struct iova_magazine *iova_depot_pop(struct iova_rcache *rcache) {struct iova_magazine *mag = rcache->depot; +/* +* As the mag->next pointer is moved to rcache->depot and reset via +* the mag->size assignment, mark it as a transient false positive. +*/ +kmemleak_transient_leak (mag->next); rcache->depot = mag->next; mag->size =IOVA_MAG_SIZE ; rcache->depot_size--;
include/linux/kmemleak.h +4 -0
@@ -26,6 +26,7 @@ extern void kmemleak_free_part(const void *ptr, size_t size) __ref;extern void kmemleak_free_percpu (const void __percpu *ptr)__ref ;extern void kmemleak_update_trace (const void *ptr)__ref ;extern void kmemleak_not_leak (const void *ptr)__ref ; +extern void kmemleak_transient_leak (const void *ptr)__ref ;extern void kmemleak_ignore (const void *ptr)__ref ;extern void kmemleak_scan_area (const void *ptr,size_t size,gfp_t gfp)__ref ;extern void kmemleak_no_scan (const void *ptr)__ref ;
@@ -93,6 +94,9 @@ static inline void kmemleak_update_trace(const void *ptr)static inline void kmemleak_not_leak (const void *ptr) { } +static inline void kmemleak_transient_leak (const void *ptr) +{ +}static inline void kmemleak_ignore (const void *ptr) { }
mm/kmemleak.c +39 -0
@@ -950,6 +950,28 @@ static void make_black_object(unsigned long ptr, unsigned int objflags)paint_ptr (ptr,KMEMLEAK_BLACK , objflags); } +/* +* Reset the checksum of an object. The immediate effect is that it will not +* be reported as a leak during the next scan until its checksum is updated. +*/ +static void reset_checksum (unsigned long ptr) +{ +unsigned long flags; +struct kmemleak_object *object; + + object =find_and_get_object (ptr,0 ); +if (!object) { +kmemleak_warn ("Not resetting the checksum of an unknown object at 0x%08lx\n" , + ptr); +return ; + } + +raw_spin_lock_irqsave (&object->lock, flags); + object->checksum =0 ; +raw_spin_unlock_irqrestore (&object->lock, flags); +put_object (object); +} +/* * Add a scanning area to the object. If at least one such area is added, * kmemleak will only scan these ranges rather than the whole memory block.
@@ -1218,6 +1240,23 @@ void __ref kmemleak_not_leak(const void *ptr) }EXPORT_SYMBOL (kmemleak_not_leak); +/** +* kmemleak_transient_leak - mark an allocated object as transient false positive +* @ptr: pointer to beginning of the object +* +* Calling this function on an object will cause the memory block to not be +* reported as a leak temporarily. This may happen, for example, if the object +* is part of a singly linked list and the ->next reference to it is changed. +*/ +void __ref kmemleak_transient_leak (const void *ptr) +{ +pr_debug ("%s(0x%px)\n" , __func__, ptr); + +if (kmemleak_enabled && ptr && !IS_ERR (ptr)) +reset_checksum ((unsigned long )ptr); +} +EXPORT_SYMBOL (kmemleak_transient_leak); +/** * kmemleak_ignore - ignore an allocated object * @ptr: pointer to beginning of the object
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 mm/kmemleak: fix checksum computation for per-cpu objects
From: Breno Leitao <[email protected]>
[ Upstream commit 79c37ae3733e93d9d8ea12ecb44f717e61439024 ]
The per-cpu object checksum folds each CPU's CRC together with XOR and seeds every CRC with 0. Both choices make update_checksum() miss content changes:
- XOR is self-cancelling, so equal contents on two CPUs cancel out and simultaneous identical changes leave the checksum unchanged.
- crc32(0, ...) over all-zero content is 0, so a freshly allocated, zeroed per-cpu area checksums to 0, matching the initial value, and the object is never seen to change.
See discussions at [0].
When update_checksum() wrongly reports an actively modified object as unchanged, kmemleak stops greying it for an extra scan and can report a live per-cpu object as a leak.
Fold the per-cpu CRC as a single rolling checksum across all CPUs and initialise the object checksum to ~0 so the first computed value always registers as a change, even for content that hashes to 0. reset_checksum() is seeded the same way.
--- mm/kmemleak.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
mm/kmemleak.c +4 -3
@@ -671,7 +671,7 @@ static struct kmemleak_object *__alloc_object(gfp_t gfp)atomic_set (&object->use_count,1 ); object->excess_ref =0 ; object->count =0 ;/* white color initially */ - object->checksum =0 ; + object->checksum = ~0 ; object->del_state =0 ;/* task information */
@@ -967,7 +967,7 @@ static void reset_checksum(unsigned long ptr) }raw_spin_lock_irqsave (&object->lock, flags); - object->checksum =0 ; + object->checksum = ~0 ;raw_spin_unlock_irqrestore (&object->lock, flags);put_object (object); }
@@ -1382,7 +1382,8 @@ static bool update_checksum(struct kmemleak_object *object)for_each_possible_cpu (cpu) {void *ptr =per_cpu_ptr ((void __percpu *)object->pointer, cpu); - object->checksum ^=crc32 (0 ,kasan_reset_tag ((void *)ptr), object->size); + object->checksum =crc32 (object->checksum, +kasan_reset_tag ((void *)ptr), object->size); } }else { object->checksum =crc32 (0 ,kasan_reset_tag ((void *)object->pointer), object->size);
Signature · 1 line
2.53.0