mm/damon/tests/core-kunit: add test for unconditionally skipping the last region
Subsystems (2)
PATCH v2 1/1 mm/damon/tests/core-kunit: add test for unconditionally skipping the last region
Commit 50585192bc2e ("mm/damon/schemes: skip already charged targets and regions") introduced a minor issue that causes the last region to be skipped before it is processed.
Example:
1. Target has 2 regions: R1 (0-100 bytes) and R2 (100-200 bytes).
2. Quota is configured to process only 100 bytes per window.
3. Window 1: Processes R1 (0-100). Quota is full. charge_{target, addr}_from is saved at (Target, 100).
4. Window 2: The loop reaches R2. Because R2 is damon_last_region(t), the old code unconditionally returns true, skipping R2 entirely and resetting the charge_{target,addr}_from.
Result: R2 is permanently skipped even though it has never been processed.
Add a test to prevent this regression in the future.
---
Changes from v1 RESEND:
- v1 RESEND: https://lore.kernel.org/damon/[email protected]
- Drop braces for single line, as suggested [1] in coding-style.
- Set min_region_sz initial value to power-of-2 value, '1'.
- [1] https://docs.kernel.org/process/coding-style.html#placing-braces-and-spaces
Changes from v1:
- v1: https://lore.kernel.org/damon/[email protected]
- Resend since the dependent patch is merged into mm-new, that would help us getting AI review help.
--- mm/damon/tests/core-kunit.h | 42 +++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+)
mm/damon/tests/core-kunit.h +42 -0
@@ -1632,6 +1632,47 @@ static void damon_test_rand(struct kunit *test) } } +static void damon_test_last_region_quota_reset (struct kunit *test) +{ +struct damos s = {0 }; +struct damon_target *t; +struct damon_region *r1, *r2; +unsigned long min_region_sz =1 ; +bool skipped; + + t =damon_new_target (); +if (!t) +kunit_skip (test,"target alloc fail" ); + + r1 =damon_new_region (0 ,100 ); +if (!r1) { +damon_free_target (t); +kunit_skip (test,"region 1 alloc fail" ); + } +damon_add_region (r1, t); + + r2 =damon_new_region (100 ,200 ); +if (!r2) { +damon_free_target (t); +kunit_skip (test,"region 2 alloc fail" ); + } +damon_add_region (r2, t); + + s.quota.charge_target_from = t; + s.quota.charge_addr_from = r1->ar.end; + + skipped =damos_skip_charged_region (t, r2, &s, min_region_sz); + +/* 'r2' is not processed, it should not skip */ +KUNIT_EXPECT_EQ (test, skipped, false); + +/* 'r2' is last region, it should reset charge_{target,addr}_from */ +KUNIT_EXPECT_PTR_EQ (test, s.quota.charge_target_from,NULL ); +KUNIT_EXPECT_EQ (test, s.quota.charge_addr_from,0 ); + +damon_free_target (t); +} +static struct kunit_case damon_test_cases[] = {KUNIT_CASE (damon_test_target),KUNIT_CASE (damon_test_regions),
@@ -1664,6 +1705,7 @@ static struct kunit_case damon_test_cases[] = {KUNIT_CASE (damon_test_is_last_region),KUNIT_CASE (damon_test_walk_control_obsolete),KUNIT_CASE (damon_test_rand), + KUNIT_CASE(damon_test_last_region_quota_reset), {}, };
Signature · 1 line
2.55.0
[email protected]
AI reviewSashiko has reviewed this patch and found no issues. It looks great!
Quoted 14 lines
Commit
50585192bc2e("mm/damon/schemes: skip already charged targets and regions") introduced a minor issue that causes the last region to be skipped before it is processed.Example:
1. Target has 2 regions: R1 (0-100 bytes) and R2 (100-200 bytes).
2. Quota is configured to process only 100 bytes per window.
3. Window 1: Processes R1 (0-100). Quota is full. charge_{target, addr}_from is saved at (Target, 100).
4. Window 2: The loop reaches R2. Because R2 isdamon_last_region(t), the old code unconditionally returns true, skipping R2 entirely and resetting the charge_{target,addr}_from.
Quoted 6 lines
Result: R2 is permanently skipped even though it has never been processed.
Add a test to prevent this regression in the future.
Signed-off-by Liew Rui Yan <[email protected]>
Sashiko has reviewed this patch and found no issues. It looks great!
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
SJ Park
maintainerQuoted 14 lines · On Fri, 25 Sep 2026 12:53:35 +0800 Liew Rui Yan <[email protected]>…
Commit
50585192bc2e("mm/damon/schemes: skip already charged targets and regions") introduced a minor issue that causes the last region to be skipped before it is processed.Example:
1. Target has 2 regions: R1 (0-100 bytes) and R2 (100-200 bytes).
2. Quota is configured to process only 100 bytes per window.
3. Window 1: Processes R1 (0-100). Quota is full. charge_{target, addr}_from is saved at (Target, 100).
4. Window 2: The loop reaches R2. Because R2 isdamon_last_region(t), the old code unconditionally returns true, skipping R2 entirely and resetting the charge_{target,addr}_from.
Quoted 4 lines
Result: R2 is permanently skipped even though it has never been processed.
Add a test to prevent this regression in the future.
The bug is fixed by commit b3723b596b54 ("mm/damon/core: fix unconditionally skip last region"), which is merged into the mainline for 7.3-rc5. Could you update the commit message to mention the fix, rather than the original bug? The fix commit already has a quite good description of the bug, so I don't think we need to duplicate it here.
Other than that, looks good to me.
Thanks,
SJ
[...]
Quoted 21 lines · On Fri, 25 Sep 2026 02:02:38 -0700 SJ Park <[email protected]> wrote:
Quoted 14 lines · On Fri, 25 Sep 2026 12:53:35 +0800 Liew Rui Yan <[email protected]>…
Commit
50585192bc2e("mm/damon/schemes: skip already charged targets and regions") introduced a minor issue that causes the last region to be skipped before it is processed.Example:
1. Target has 2 regions: R1 (0-100 bytes) and R2 (100-200 bytes).
2. Quota is configured to process only 100 bytes per window.
3. Window 1: Processes R1 (0-100). Quota is full. charge_{target, addr}_from is saved at (Target, 100).
4. Window 2: The loop reaches R2. Because R2 isdamon_last_region(t), the old code unconditionally returns true, skipping R2 entirely and resetting the charge_{target,addr}_from.Quoted 4 lines
Result: R2 is permanently skipped even though it has never been processed.
Add a test to prevent this regression in the future.
Quoted 7 lines
The bug is fixed by commit
b3723b596b54("mm/damon/core: fix unconditionally skip last region"), which is merged into the mainline for 7.3-rc5. Could you update the commit message to mention the fix, rather than the original bug? The fix commit already has a quite good description of the bug, so I don't think we need to duplicate it here.Other than that, looks good to me.
Okay, I will change the commit message in the next revision.
Commit b3723b596b54 ("mm/damon/core: fix unconditionally skip last region") fixed a minor bug.
Add a KUnit test case to cover this behavior and prevent regressions in the future.
[...]
Best regards,
Rui Yan
SJ Park
maintainerOn Sun, 27 Sep 2026 05:07:09 +0800 Liew Rui Yan <[email protected]> wrote:
[...]
Quoted 7 lines
Okay, I will change the commit message in the next revision.
Commit
b3723b596b54("mm/damon/core: fix unconditionally skip last region") fixed a minor bug.Add a KUnit test case to cover this behavior and prevent regressions in the future.
Sounds good, looking forward to the next version of the patch!
Thanks,
SJ
[...]