--- /dev/null
+From 915a2453d824a9b6bf724e3f970d86ae1d092a61 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [6.5+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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;
--- /dev/null
+From 4f835f4e8c863985f15abd69db033c2f66546094 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [5.19+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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);
--- /dev/null
+From 74d5969995d129fd59dd93b9c7daa6669cb6810f Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [6.1+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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);
--- /dev/null
+From 8cf298c01b7fdb08eef5b6b26d0fe98d48134d72 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [6.3+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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;
+
--- /dev/null
+From eded254cb69044bd4abde87394ea44909708d7c0 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [5.15+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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);
--- /dev/null
+From d14d5671e7c9cc788c5a1edfa94e6f9064275905 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [6.6+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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 */
--- /dev/null
+From f79f2fc44ebd0ed655239046be3e80e8804b5545 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [5.15+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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);
+ }
--- /dev/null
+From fafe953de2c661907c94055a2497c6b8dbfd26f3 Mon Sep 17 00:00:00 2001
+From: SeongJae Park <sj@kernel.org>
+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 <sj@kernel.org>
+
+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 <sj@kernel.org>
+Cc: Brendan Higgins <brendan.higgins@linux.dev>
+Cc: David Gow <davidgow@google.com>
+Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
+Cc: <stable@vger.kernel.org> [5.15+]
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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);
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
projects / thirdparty / kernel / stable-queue.git / commitdiff
