From: Greg Kroah-Hartman Date: Thu, 8 Jan 2026 13:03:42 +0000 (+0100) Subject: 5.15-stable patches X-Git-Tag: v6.1.160~46 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=3077d59b6ed2b50d886b5c931c5549147b368f1a;p=thirdparty%2Fkernel%2Fstable-queue.git 5.15-stable patches added patches: mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch --- diff --git a/queue-5.15/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch b/queue-5.15/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch new file mode 100644 index 0000000000..e31f366aaf --- /dev/null +++ b/queue-5.15/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch @@ -0,0 +1,68 @@ +From eded254cb69044bd4abde87394ea44909708d7c0 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:20:02 -0700 +Subject: mm/damon/tests/core-kunit: handle alloc failures on damon_test_split_regions_of() + +From: SeongJae Park + +commit eded254cb69044bd4abde87394ea44909708d7c0 upstream. + +damon_test_split_regions_of() is assuming all dynamic memory allocation in +it will succeed. Those are indeed likely in the real use cases since +those allocations are too small to fail, but theoretically those could +fail. In the case, inappropriate memory access can happen. Fix it by +appropriately cleanup pre-allocated memory and skip the execution of the +remaining tests in the failure cases. + +Link: https://lkml.kernel.org/r/20251101182021.74868-9-sj@kernel.org +Fixes: 17ccae8bb5c9 ("mm/damon: add kunit tests") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [5.15+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 21 +++++++++++++++++++++ + 1 file changed, 21 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -255,15 +255,36 @@ static void damon_test_split_regions_of( + struct damon_target *t; + struct damon_region *r; + ++ if (!c) ++ kunit_skip(test, "ctx alloc fail"); ++ + t = damon_new_target(42); ++ if (!t) { ++ damon_destroy_ctx(c); ++ kunit_skip(test, "target alloc fail"); ++ } + r = damon_new_region(0, 22); ++ if (!r) { ++ damon_destroy_ctx(c); ++ damon_free_target(t); ++ kunit_skip(test, "region alloc fail"); ++ } + damon_add_region(r, t); + damon_split_regions_of(c, t, 2); + KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u); + damon_free_target(t); + + t = damon_new_target(42); ++ if (!t) { ++ damon_destroy_ctx(c); ++ kunit_skip(test, "second target alloc fail"); ++ } + r = damon_new_region(0, 220); ++ if (!r) { ++ damon_destroy_ctx(c); ++ damon_free_target(t); ++ kunit_skip(test, "second region alloc fail"); ++ } + damon_add_region(r, t); + damon_split_regions_of(c, t, 4); + KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u); diff --git a/queue-5.15/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch b/queue-5.15/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch new file mode 100644 index 0000000000..9673e0cf9a --- /dev/null +++ b/queue-5.15/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch @@ -0,0 +1,55 @@ +From f79f2fc44ebd0ed655239046be3e80e8804b5545 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:19:58 -0700 +Subject: mm/damon/tests/core-kunit: handle memory alloc failure from damon_test_aggregate() + +From: SeongJae Park + +commit f79f2fc44ebd0ed655239046be3e80e8804b5545 upstream. + +damon_test_aggregate() is assuming all dynamic memory allocation in it +will succeed. Those are indeed likely in the real use cases since those +allocations are too small to fail, but theoretically those could fail. In +the case, inappropriate memory access can happen. Fix it by appropriately +cleanup pre-allocated memory and skip the execution of the remaining tests +in the failure cases. + +Link: https://lkml.kernel.org/r/20251101182021.74868-5-sj@kernel.org +Fixes: 17ccae8bb5c9 ("mm/damon: add kunit tests") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [5.15+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 12 +++++++++++- + 1 file changed, 11 insertions(+), 1 deletion(-) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -99,12 +99,22 @@ static void damon_test_aggregate(struct + struct damon_region *r; + int it, ir; + +- damon_set_targets(ctx, target_ids, 3); ++ if (!ctx) ++ kunit_skip(test, "ctx alloc fail"); ++ ++ if (damon_set_targets(ctx, target_ids, 3)) { ++ damon_destroy_ctx(ctx); ++ kunit_skip(test, "target alloc fail"); ++ } + + it = 0; + damon_for_each_target(t, ctx) { + for (ir = 0; ir < 3; ir++) { + r = damon_new_region(saddr[it][ir], eaddr[it][ir]); ++ if (!r) { ++ damon_destroy_ctx(ctx); ++ kunit_skip(test, "region alloc fail"); ++ } + r->nr_accesses = accesses[it][ir]; + damon_add_region(r, t); + } diff --git a/queue-5.15/mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch b/queue-5.15/mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch new file mode 100644 index 0000000000..763b39673a --- /dev/null +++ b/queue-5.15/mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch @@ -0,0 +1,46 @@ +From fafe953de2c661907c94055a2497c6b8dbfd26f3 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:19:57 -0700 +Subject: mm/damon/tests/core-kunit: handle memory failure from damon_test_target() + +From: SeongJae Park + +commit fafe953de2c661907c94055a2497c6b8dbfd26f3 upstream. + +damon_test_target() is assuming all dynamic memory allocation in it will +succeed. Those are indeed likely in the real use cases since those +allocations are too small to fail, but theoretically those could fail. In +the case, inappropriate memory access can happen. Fix it by appropriately +cleanup pre-allocated memory and skip the execution of the remaining tests +in the failure cases. + +Link: https://lkml.kernel.org/r/20251101182021.74868-4-sj@kernel.org +Fixes: 17ccae8bb5c9 ("mm/damon: add kunit tests") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [5.15+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 7 +++++++ + 1 file changed, 7 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -58,7 +58,14 @@ static void damon_test_target(struct kun + struct damon_ctx *c = damon_new_ctx(); + struct damon_target *t; + ++ if (!c) ++ kunit_skip(test, "ctx alloc fail"); ++ + t = damon_new_target(42); ++ if (!t) { ++ damon_destroy_ctx(c); ++ kunit_skip(test, "target alloc fail"); ++ } + KUNIT_EXPECT_EQ(test, 42ul, t->id); + KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c)); + diff --git a/queue-5.15/series b/queue-5.15/series index 4dee93ea0e..a79ba7faa2 100644 --- a/queue-5.15/series +++ b/queue-5.15/series @@ -417,3 +417,6 @@ mm-damon-tests-core-kunit-handle-allocation-failures-in-damon_test_regions.patch mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_at.patch mm-damon-tests-core-kunit-handle-alloc-failures-on-dasmon_test_merge_regions_of.patch mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_merge_two.patch +mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch +mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch +mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch