From: Greg Kroah-Hartman Date: Thu, 8 Jan 2026 13:04:07 +0000 (+0100) Subject: 6.6-stable patches X-Git-Tag: v6.1.160~44 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=13bce7b5c1723cf54fabcd0b6fc033d09dee7b5e;p=thirdparty%2Fkernel%2Fstable-queue.git 6.6-stable patches added patches: mm-damon-tests-core-kunit-handle-alloc-failure-on-damon_test_set_attrs.patch mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_ops_registration.patch mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_update_monitoring_result.patch mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch mm-damon-tests-core-kunit-handle-alloc-failures-on-damos_test_filter_out.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.6/mm-damon-tests-core-kunit-handle-alloc-failure-on-damon_test_set_attrs.patch b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failure-on-damon_test_set_attrs.patch new file mode 100644 index 0000000000..50018e7f48 --- /dev/null +++ b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failure-on-damon_test_set_attrs.patch @@ -0,0 +1,41 @@ +From 915a2453d824a9b6bf724e3f970d86ae1d092a61 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:20:06 -0700 +Subject: mm/damon/tests/core-kunit: handle alloc failure on damon_test_set_attrs() + +From: SeongJae Park + +commit 915a2453d824a9b6bf724e3f970d86ae1d092a61 upstream. + +damon_test_set_attrs() 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-13-sj@kernel.org +Fixes: aa13779be6b7 ("mm/damon/core-test: add a test for damon_set_attrs()") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [6.5+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 3 +++ + 1 file changed, 3 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -413,6 +413,9 @@ static void damon_test_set_attrs(struct + .sample_interval = 5000, .aggr_interval = 100000,}; + struct damon_attrs invalid_attrs; + ++ if (!c) ++ kunit_skip(test, "ctx alloc fail"); ++ + KUNIT_EXPECT_EQ(test, damon_set_attrs(c, &valid_attrs), 0); + + invalid_attrs = valid_attrs; diff --git a/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_ops_registration.patch b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_ops_registration.patch new file mode 100644 index 0000000000..cc4b091452 --- /dev/null +++ b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_ops_registration.patch @@ -0,0 +1,41 @@ +From 4f835f4e8c863985f15abd69db033c2f66546094 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:20:03 -0700 +Subject: mm/damon/tests/core-kunit: handle alloc failures in damon_test_ops_registration() + +From: SeongJae Park + +commit 4f835f4e8c863985f15abd69db033c2f66546094 upstream. + +damon_test_ops_registration() 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-10-sj@kernel.org +Fixes: 4f540f5ab4f2 ("mm/damon/core-test: add a kunit test case for ops registration") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [5.19+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 3 +++ + 1 file changed, 3 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -308,6 +308,9 @@ static void damon_test_ops_registration( + struct damon_ctx *c = damon_new_ctx(); + struct damon_operations ops, bak; + ++ if (!c) ++ kunit_skip(test, "ctx alloc fail"); ++ + /* DAMON_OPS_{V,P}ADDR are registered on subsys_initcall */ + KUNIT_EXPECT_EQ(test, damon_select_ops(c, DAMON_OPS_VADDR), 0); + KUNIT_EXPECT_EQ(test, damon_select_ops(c, DAMON_OPS_PADDR), 0); diff --git a/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch b/queue-6.6/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.6/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.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_update_monitoring_result.patch b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_update_monitoring_result.patch new file mode 100644 index 0000000000..bb6ad3ce07 --- /dev/null +++ b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_update_monitoring_result.patch @@ -0,0 +1,41 @@ +From 8cf298c01b7fdb08eef5b6b26d0fe98d48134d72 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:20:05 -0700 +Subject: mm/damon/tests/core-kunit: handle alloc failures in damon_test_update_monitoring_result() + +From: SeongJae Park + +commit 8cf298c01b7fdb08eef5b6b26d0fe98d48134d72 upstream. + +damon_test_update_monitoring_result() 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-12-sj@kernel.org +Fixes: f4c978b6594b ("mm/damon/core-test: add a test for damon_update_monitoring_results()") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [6.3+] +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/damon/core-test.h | 3 +++ + 1 file changed, 3 insertions(+) + +--- a/mm/damon/core-test.h ++++ b/mm/damon/core-test.h +@@ -383,6 +383,9 @@ static void damon_test_update_monitoring + struct damon_attrs new_attrs; + struct damon_region *r = damon_new_region(3, 7); + ++ if (!r) ++ kunit_skip(test, "region alloc fail"); ++ + r->nr_accesses = 15; + r->age = 20; + diff --git a/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-on-damon_test_split_regions_of.patch b/queue-6.6/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.6/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.6/mm-damon-tests-core-kunit-handle-alloc-failures-on-damos_test_filter_out.patch b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-on-damos_test_filter_out.patch new file mode 100644 index 0000000000..0c25ef9482 --- /dev/null +++ b/queue-6.6/mm-damon-tests-core-kunit-handle-alloc-failures-on-damos_test_filter_out.patch @@ -0,0 +1,54 @@ +From d14d5671e7c9cc788c5a1edfa94e6f9064275905 Mon Sep 17 00:00:00 2001 +From: SeongJae Park +Date: Sat, 1 Nov 2025 11:20:09 -0700 +Subject: mm/damon/tests/core-kunit: handle alloc failures on damos_test_filter_out() + +From: SeongJae Park + +commit d14d5671e7c9cc788c5a1edfa94e6f9064275905 upstream. + +damon_test_filter_out() 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-16-sj@kernel.org +Fixes: 26713c890875 ("mm/damon/core-test: add a unit test for __damos_filter_out()") +Signed-off-by: SeongJae Park +Cc: Brendan Higgins +Cc: David Gow +Cc: Kefeng Wang +Cc: [6.6+] +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 +@@ -433,11 +433,22 @@ static void damos_test_filter_out(struct + struct damos_filter *f; + + f = damos_new_filter(DAMOS_FILTER_TYPE_ADDR, true); ++ if (!f) ++ kunit_skip(test, "filter alloc fail"); + f->addr_range = (struct damon_addr_range){ + .start = DAMON_MIN_REGION * 2, .end = DAMON_MIN_REGION * 6}; + + t = damon_new_target(); ++ if (!t) { ++ damos_destroy_filter(f); ++ kunit_skip(test, "target alloc fail"); ++ } + r = damon_new_region(DAMON_MIN_REGION * 3, DAMON_MIN_REGION * 5); ++ if (!r) { ++ damos_destroy_filter(f); ++ damon_free_target(t); ++ kunit_skip(test, "region alloc fail"); ++ } + damon_add_region(r, t); + + /* region in the range */ diff --git a/queue-6.6/mm-damon-tests-core-kunit-handle-memory-alloc-failure-from-damon_test_aggregate.patch b/queue-6.6/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.6/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.6/mm-damon-tests-core-kunit-handle-memory-failure-from-damon_test_target.patch b/queue-6.6/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.6/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.6/series b/queue-6.6/series index 2b6e83b3e4..70868e9191 100644 --- a/queue-6.6/series +++ b/queue-6.6/series @@ -719,3 +719,11 @@ 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-on-damos_test_filter_out.patch +mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_set_regions.patch +mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_ops_registration.patch +mm-damon-tests-core-kunit-handle-alloc-failure-on-damon_test_set_attrs.patch +mm-damon-tests-core-kunit-handle-alloc-failures-in-damon_test_update_monitoring_result.patch