From: Greg Kroah-Hartman Date: Thu, 8 Jan 2026 13:03:57 +0000 (+0100) Subject: 6.1-stable patches X-Git-Tag: v6.1.160~45 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=87054b051d32a1d010c7576a51f468b68aceb487;p=thirdparty%2Fkernel%2Fstable-queue.git 6.1-stable patches added patches: mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.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 mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch --- diff --git a/queue-6.1/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch b/queue-6.1/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch new file mode 100644 index 0000000000..544bf0e180 --- /dev/null +++ b/queue-6.1/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch @@ -0,0 +1,60 @@ +From 74d5969995d129fd59dd93b9c7daa6669cb6810f Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:20:04 -0700 +Subject: mm/damon/tests/core-kunit: handle alloc failures in damon_test_set_regions() + +From: SeongJae Park + +commit 74d5969995d129fd59dd93b9c7daa6669cb6810f upstream. + +damon_test_set_regions() 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-11-sj@kernel.org +Fixes: 62f409560eb2 ("mm/damon/core-test: test damon_set_regions") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [6.1+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 17 +++++++++++++++-- + 1 file changed, 15 insertions(+), 2 deletions(-) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -341,13 +341,26 @@ static void damon_test_ops_registration( + static void damon_test_set_regions(struct kunit *test) + { + struct damon_target *t = damon_new_target(); +- struct damon_region *r1 = damon_new_region(4, 16); +- struct damon_region *r2 = damon_new_region(24, 32); ++ struct damon_region *r1, *r2; + struct damon_addr_range range = {.start = 8, .end = 28}; + unsigned long expects[] = {8, 16, 16, 24, 24, 28}; + int expect_idx = 0; + struct damon_region *r; + ++ if (!t) ++ kunit_skip(test, "target alloc fail"); ++ r1 = damon_new_region(4, 16); ++ if (!r1) { ++ damon_free_target(t); ++ kunit_skip(test, "region alloc fail"); ++ } ++ r2 = damon_new_region(24, 32); ++ if (!r2) { ++ damon_free_target(t); ++ damon_free_region(r1); ++ kunit_skip(test, "second region alloc fail"); ++ } ++ + damon_add_region(r1, t); + damon_add_region(r2, t); + damon_set_regions(t, &range, 1); diff --git a/queue-6.1/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch b/queue-6.1/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch new file mode 100644 index 0000000000..a6aaef3f8e --- /dev/null +++ b/queue-6.1/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch @@ -0,0 +1,67 @@ +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 | 20 ++++++++++++++++++++ + 1 file changed, 20 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -256,15 +256,35 @@ 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(); ++ 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(t, 2); + KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u); + damon_free_target(t); + + t = damon_new_target(); ++ 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(t, 4); + KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u); diff --git a/queue-6.1/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch b/queue-6.1/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch new file mode 100644 index 0000000000..6a217a3c94 --- /dev/null +++ b/queue-6.1/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch @@ -0,0 +1,58 @@ +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 | 11 +++++++++++ + 1 file changed, 11 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -97,8 +97,15 @@ static void damon_test_aggregate(struct + struct damon_region *r; + int it, ir; + ++ if (!ctx) ++ kunit_skip(test, "ctx alloc fail"); ++ + for (it = 0; it < 3; it++) { + t = damon_new_target(); ++ if (!t) { ++ damon_destroy_ctx(ctx); ++ kunit_skip(test, "target alloc fail"); ++ } + damon_add_target(ctx, t); + } + +@@ -106,6 +113,10 @@ static void damon_test_aggregate(struct + 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-6.1/mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch b/queue-6.1/mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch new file mode 100644 index 0000000000..be785e82ba --- /dev/null +++ b/queue-6.1/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(); ++ if (!t) { ++ damon_destroy_ctx(c); ++ kunit_skip(test, "target alloc fail"); ++ } + KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c)); + + damon_add_target(c, t); diff --git a/queue-6.1/series b/queue-6.1/series index 8e3e77d707..f8fc457aaa 100644 --- a/queue-6.1/series +++ b/queue-6.1/series @@ -520,3 +520,7 @@ 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 +mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch