[RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[Liew Rui Yan]

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.

Signed-off-by: Liew Rui Yan <aethernet65535@gmail.com>
---

Changes from v1:
- v1: https://lore.kernel.org/damon/20260831113735.3349-1-aethernet65535@gmail.com
- Resend since the dependent patch is merged into mm-new, that would
  help us getting AI review help.

---
 mm/damon/tests/core-kunit.h | 43 +++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
index 4a536d41cdb2..90b0fda34fba 100644
--- a/mm/damon/tests/core-kunit.h
+++ b/mm/damon/tests/core-kunit.h
@@ -1632,6 +1632,48 @@ 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 = 10;
+	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 +1706,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),
 	{},
 };
 
-- 
2.55.0

Re: [RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[sashiko-bot]

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] mm: invalid non-power-of-two alignment in damon test
--

commit a99d6a5362b525870f71ce4be82705b420aea7ef
Author: Liew Rui Yan <aethernet65535@gmail.com>

mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

This commit adds a kunit test to ensure the last region is not skipped
before it is processed.

> diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
> index 5ff0436c58441..84e50f08f417d 100644
> --- a/mm/damon/tests/core-kunit.h
> +++ b/mm/damon/tests/core-kunit.h

[ ... ]

> @@ -1929,6 +1929,48 @@ 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 = 10;

[Severity: Low]
Is it safe to initialize min_region_sz to a non-power-of-two value?

The ALIGN_DOWN() macro inside damos_skip_charged_region() relies on bitwise
masking and mathematically guarantees correct alignment arithmetic only when
the alignment boundary is a strict power of two. Passing 10 yields incorrect
values (e.g., ALIGN_DOWN(120, 10) incorrectly evaluates to 112).

> +	bool skipped;
> +
> +	t = damon_new_target();

[ ... ]

> +	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);

[Severity: Low]
Can this call silently corrupt the region skip calculation in the future?

While the current test parameters bypass the ALIGN_DOWN() logic inside
damos_skip_charged_region(), any future expansion or variation of the test
that hits the branch will encounter the incorrect alignment arithmetic
caused by min_region_sz being set to 10.

> +
> +	/* 'r2' is not processed, it should not skip */
> +	KUNIT_EXPECT_EQ(test, skipped, false);

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260919080453.628679-1-aethernet65535@gmail.com?part=1

Re: [RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[SJ Park]

On Sat, 19 Sep 2026 16:01:58 +0800 Liew Rui Yan <aethernet65535@gmail.com> wrote:

> 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.
> 
> Signed-off-by: Liew Rui Yan <aethernet65535@gmail.com>

Other than a trivial style that I commented below,

Reviewed-by: SJ Park <sj@kernel.org>

[...]
> +static void damon_test_last_region_quota_reset(struct kunit *test)
> +{
[...]
> +	t = damon_new_target();
> +	if (!t) {
> +		kunit_skip(test, "target alloc fail");
> +	}

Let's drop braces for single line, as suggested [1] in coding-style.

[1] https://docs.kernel.org/process/coding-style.html#placing-braces-and-spaces


Thanks,
SJ

Re: [RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[Liew Rui Yan]

On Sat, 19 Sep 2026 09:07:25 -0700 SJ Park <sj@kernel.org> wrote:

> On Sat, 19 Sep 2026 16:01:58 +0800 Liew Rui Yan <aethernet65535@gmail.com> wrote:
> 
> > 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.
> > 
> > Signed-off-by: Liew Rui Yan <aethernet65535@gmail.com>
> 
> Other than a trivial style that I commented below,
> 
> Reviewed-by: SJ Park <sj@kernel.org>
> 
> [...]
> > +static void damon_test_last_region_quota_reset(struct kunit *test)
> > +{
> [...]
> > +	t = damon_new_target();
> > +	if (!t) {
> > +		kunit_skip(test, "target alloc fail");
> > +	}
> 
> Let's drop braces for single line, as suggested [1] in coding-style.

I will change this in next revision.

By the way, Sashiko reported an issue [1]: min_region_sz is not
power-of-2.  While this do not cause any real issue in this test,
non-power-of-2's min_region_sz is not legal.  Should min_region_sz
initial value set to power-of-2 value (e.g., PAGE_SIZE) in the next
revision?

> 
> [1] https://docs.kernel.org/process/coding-style.html#placing-braces-and-spaces
> 

[1] https://lore.kernel.org/damon/20260919081239.8A3D91F000FF@smtp.kernel.org

Best regards,
Rui Yan

Re: [RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[Liew Rui Yan]

Hi SJ,

Just a reminder, I think you might have missed the question I asked.

On Sun, 20 Sep 2026 03:09:10 +0800 Liew Rui Yan <aethernet65535@gmail.com> wrote:

> On Sat, 19 Sep 2026 09:07:25 -0700 SJ Park <sj@kernel.org> wrote:
> 
> > On Sat, 19 Sep 2026 16:01:58 +0800 Liew Rui Yan <aethernet65535@gmail.com> wrote:
> > 
> > > 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.
> > > 
> > > Signed-off-by: Liew Rui Yan <aethernet65535@gmail.com>
> > 
> > Other than a trivial style that I commented below,
> > 
> > Reviewed-by: SJ Park <sj@kernel.org>
> > 
> > [...]
> > > +static void damon_test_last_region_quota_reset(struct kunit *test)
> > > +{
> > [...]
> > > +	t = damon_new_target();
> > > +	if (!t) {
> > > +		kunit_skip(test, "target alloc fail");
> > > +	}
> > 
> > Let's drop braces for single line, as suggested [1] in coding-style.
> 
> I will change this in next revision.
> 
> By the way, Sashiko reported an issue [1]: min_region_sz is not
> power-of-2.  While this do not cause any real issue in this test,
> non-power-of-2's min_region_sz is not legal.  Should min_region_sz
> initial value set to power-of-2 value (e.g., PAGE_SIZE) in the next
> revision?
> 

[...]

> [1] https://lore.kernel.org/damon/20260919081239.8A3D91F000FF@smtp.kernel.org

[...]

Best regards,
Rui Yan

Re: [RESEND PATCH] mm/damon/tests/core-kunit: add test for unconditionally skipping the last region

[SJ Park]

On Thu, 24 Sep 2026 15:57:42 +0800 Liew Rui Yan <aethernet65535@gmail.com> wrote:

> Hi SJ,
> 
> Just a reminder, I think you might have missed the question I asked.

Sorry, I dropped the ball.  Thank you for reminding, Liew!

> 
> On Sun, 20 Sep 2026 03:09:10 +0800 Liew Rui Yan <aethernet65535@gmail.com> wrote:
[...]
> > By the way, Sashiko reported an issue [1]: min_region_sz is not
> > power-of-2.  While this do not cause any real issue in this test,
> > non-power-of-2's min_region_sz is not legal.  Should min_region_sz
> > initial value set to power-of-2 value (e.g., PAGE_SIZE) in the next
> > revision?

Yes, let's use a power-of-2 value.  '1' should also be suffice.


Thanks,
SJ

[...]