mm/damon: introduce probe_hits_wsum DAMOS core filter

PATCH In review SJ Park 2 participants 19 messages Sep 10

Subsystems (4)

Memory management Documentation MM misc DAMON

lore

Share & tools

lore

SJ Park

author maintainer

2026-09-10 14:18 UTC #0 lore raw

cover mm/damon: introduce probe_hits_wsum DAMOS core filter

DAMON can do flexible data attributes monitoring. The classical data access monitoring can also be done using the attributes monitoring. The access event is just one of the data attributes that DAMON supports. Users do monitoring to make some actions based on it. DAMOS is a feature for automating that. However, DAMOS cannot utilize the data attributes monitoring results. It is still Data "Access" Monitoring-based Operation Schemes. It requires users to set the target "access" pattern.

DAMOS core filter is effectively the same as the target access pattern. It is just a more generalized and flexible way of describing the operation action target region. Introduce a new DAMOS core filter type, probe_hits_wsum. It specifies the filter target based on a range of the probe hits weighted sum. Using this, users can apply DAMOS actions to regions of specific data attributes pattern.

Note that the classic target access pattern still works. Hence the target nr_accesses range should still be properly configured. The new filter would be used in only data attributes-only mode. In the mode, classic access monitoring is just turned off, and therefore nr_accesses of regions are always zero. Users could simply set the target nr_accesses range to include the zero nr_Accesses regions.

Patches Sequence
================

Patch 1 updates the DAMON kernel API for the new filter type. Patch 2 extends damon_probe_hits_wsum() to do the calculation based on moving sum. Patch 3 implements the filter type in the core layer. Patch 4 refactors DAMON sysfs interface internal data structure for efficient reuse of data structure for the probe hits weighted sum range user inputs. Patch 5 updates DAMON sysfs interface to support the new filter type. Patches 6 and 7 update design and usage documents for the new filter type, respectively.

Changelog
=========

Changes from RFC v2.1
- RFC v2.1: https://lore.kernel.org/[email protected]
- Update kernel-doc to clarify probe_hits_wsum is a damos core filter.
- Drop RFC tag.
Changes from RFC v2
- RFC v2: https://lore.kernel.org/[email protected]
- Rebase to latest mm-new.
Changes from RFC
- RFC: https://lore.kernel.org/[email protected]
- Fix kernel-doc typo.
- Use moving sum based weighted sum.
- Fix wrong range saving field names in sysfs.

SJ Park (7):
mm/damon/api: introduce DAMOS_FILTER_TYPE_PROBE_HITS_WSUM mm/damon/core: extend probe_hits_wsum() for moving sum based
calculation
mm/damon/core: support probe_hits_wsum damos core filter mm/damon/sysfs-schemes: rename sysfs_filter->sz_range to

    range_{min,max}

mm/damon/sysfs-schemes: support probe_hits_wsum damos core filter Docs/mm/damon/design: update for probe_hits_wsum DAMOS core filter Docs/admin-guide/mm/damon/usage: update for probe_hits_wsum DAMOS
filter

 Documentation/admin-guide/mm/damon/usage.rst |  4 +++
 Documentation/mm/damon/design.rst            |  3 ++
 include/linux/damon.h                        | 22 +++++++++-----
 mm/damon/core.c                              | 20 +++++++++++--
 mm/damon/paddr.c                             |  2 +-
 mm/damon/sysfs-schemes.c                     | 30 ++++++++++++++------
 mm/damon/vaddr.c                             |  2 +-
 7 files changed, 63 insertions(+), 20 deletions(-)

base-commit: e63f7a9955d13dbec5df4df19f844e5a0fbc3ce1

Signature · 1 line

2.47.3

SJ Park

author maintainer

2026-09-10 14:19 UTC #1 lore raw

PATCH 1/7 mm/damon/api: introduce DAMOS_FILTER_TYPE_PROBE_HITS_WSUM

Update DAMON kernel API to introduce new DAMOS core filter type, PROBE_HITS_WSUM. It will allow API callers to describe the DAMOS action target regions based on their probe_hits weighted sum. For describing the filtering target weighted sum range, add two type-dependent union fields to damos_filter.

Signed-off-by SJ Park <[email protected]>

---
 include/linux/damon.h | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

include/linux/damon.h +14 -6

index 871d26adf6ae5..ef99ff778ae10 100644
@@ -399,14 +399,15 @@ struct damos_stat {
  * @DAMOS_FILTER_TYPE_UNMAPPED:	Unmapped pages.
  * @DAMOS_FILTER_TYPE_ADDR:	Address range.
  * @DAMOS_FILTER_TYPE_TARGET:	Data Access Monitoring target.
+ * @DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:	probe_hits weighted sum range.
  * @NR_DAMOS_FILTER_TYPES:	Number of filter types.
  *
- * All types except &DAMOS_FILTER_TYPE_ADDR and &DAMOS_FILTER_TYPE_TARGET
- * are handled by the underlying &struct damon_operations as a part of scheme
- * action trying, and therefore accounted as 'tried'.  In contrast,
- * &DAMOS_FILTER_TYPE_ADDR and &DAMOS_FILTER_TYPE_TARGET filters are handled
- * by the core layer before trying of the action, and therefore not accounted
- * as 'tried'.
+ * All types except &DAMOS_FILTER_TYPE_ADDR, &DAMOS_FILTER_TYPE_TARGET and
+ * &DAMOS_FILTER_TYPE_PROBE_HITS_WSUM are handled by the underlying &struct
+ * damon_operations as a part of scheme action trying, and therefore accounted
+ * as 'tried'.  In contrast, &DAMOS_FILTER_TYPE_ADDR and
+ * &DAMOS_FILTER_TYPE_TARGET filters are handled by the core layer before
+ * trying of the action, and therefore not accounted as 'tried'.
  *
  * Support for the operations-handled filters depends on the running
  * &struct damon_operations.

@@ -420,6 +421,7 @@ enum damos_filter_type {
 	DAMOS_FILTER_TYPE_UNMAPPED,
 	DAMOS_FILTER_TYPE_ADDR,
 	DAMOS_FILTER_TYPE_TARGET,
+	DAMOS_FILTER_TYPE_PROBE_HITS_WSUM,
 	NR_DAMOS_FILTER_TYPES,
 };

@@ -434,6 +436,8 @@ enum damos_filter_type {
  *		&damon_ctx->adaptive_targets if @type is
  *		DAMOS_FILTER_TYPE_TARGET.
  * @sz_range:	Size range if @type is DAMOS_FILTER_TYPE_HUGEPAGE_SIZE.
+ * @range_min:	Minimum value of range arguments.
+ * @range_max:	Maximum value of range arguments.
  *
  * Before applying the &damos->action to a memory region, DAMOS checks if each
  * byte of the region matches to this given condition and avoid applying the

@@ -450,6 +454,10 @@ struct damos_filter {
 		struct damon_addr_range addr_range;
 		int target_idx;
 		struct damon_size_range sz_range;
+		struct {
+			unsigned long range_min;
+			unsigned long range_max;
+		};
 	};
 /* private: */
 	/* List head for siblings. */

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:27 UTC #2 lore raw

Re: [PATCH 1/7] mm/damon/api: introduce DAMOS_FILTER_TYPE_PROBE_HITS_WSUM

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The kerneldoc comment for `enum damos_filter_type` leaves the handling behavior of…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The kerneldoc comment for enum damos_filter_type leaves the handling behavior of DAMOS_FILTER_TYPE_PROBE_HITS_WSUM unexplained and contradictory. --

commit 78a988db300660b08e965cf2117e7ad015861252
Author: SJ Park <[email protected]>
Subject: mm/damon/api: introduce DAMOS_FILTER_TYPE_PROBE_HITS_WSUM

This commit introduces the DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter type to allow API callers to target regions based on their probe_hits weighted sum. It also updates the damos_filter structure and associated documentation to accommodate this new filter.

Quoted 13 lines

include/linux/damon.h +1 -2

index 871d26adf6ae5..ef99ff778ae10 100644
@@ -399,14 +399,15 @@ struct damos_stat {
  * @DAMOS_FILTER_TYPE_UNMAPPED:	Unmapped pages.
  * @DAMOS_FILTER_TYPE_ADDR:	Address range.
  * @DAMOS_FILTER_TYPE_TARGET:	Data Access Monitoring target.
+ * @DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:	probe_hits weighted sum range.
  * @NR_DAMOS_FILTER_TYPES:	Number of filter types.
  *
- * All types except &DAMOS_FILTER_TYPE_ADDR and &DAMOS_FILTER_TYPE_TARGET
- * are handled by the underlying &struct damon_operations as a part of scheme

include/linux/damon.h struct damos_stat { · line 410

Quoted 10 lines

include/linux/damon.h +6 -4

- * action trying, and therefore accounted as 'tried'.  In contrast,
- * &DAMOS_FILTER_TYPE_ADDR and &DAMOS_FILTER_TYPE_TARGET filters are handled
- * by the core layer before trying of the action, and therefore not accounted
- * as 'tried'.
+ * All types except &DAMOS_FILTER_TYPE_ADDR, &DAMOS_FILTER_TYPE_TARGET and
+ * &DAMOS_FILTER_TYPE_PROBE_HITS_WSUM are handled by the underlying &struct
+ * damon_operations as a part of scheme action trying, and therefore accounted
+ * as 'tried'.  In contrast, &DAMOS_FILTER_TYPE_ADDR and
+ * &DAMOS_FILTER_TYPE_TARGET filters are handled by the core layer before
+ * trying of the action, and therefore not accounted as 'tried'.

[Severity: Low]
Does this leave the handling behavior of the new filter unexplained?

The newly updated kerneldoc for enum damos_filter_type explicitly excludes DAMOS_FILTER_TYPE_PROBE_HITS_WSUM from the list of filters handled by operations, but it appears to be missing from the subsequent sentence detailing which filters are handled by the core layer.

This creates a contradiction where its handling behavior is undefined. Should it be added to the second sentence alongside DAMOS_FILTER_TYPE_ADDR and DAMOS_FILTER_TYPE_TARGET?

Signature · 1 line

Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1

SJ Park

author maintainer

2026-09-10 14:33 UTC #3 lore raw

Re: [PATCH 1/7] mm/damon/api: introduce DAMOS_FILTER_TYPE_PROBE_HITS_WSUM

Quoted 40 lines · On Thu, 10 Sep 2026 14:27:17 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The kerneldoc comment for enum damos_filter_type leaves the handling behavior of DAMOS_FILTER_TYPE_PROBE_HITS_WSUM unexplained and contradictory. --
commit 78a988db300660b08e965cf2117e7ad015861252
Author: SJ Park <[email protected]>
Subject: mm/damon/api: introduce DAMOS_FILTER_TYPE_PROBE_HITS_WSUM
This commit introduces the DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter type to allow API callers to target regions based on their probe_hits weighted sum. It also updates the damos_filter structure and associated documentation to accommodate this new filter.
Quoted 13 lines
include/linux/damon.h +1 -2
index 871d26adf6ae5..ef99ff778ae10 100644
@@ -399,14 +399,15 @@ struct damos_stat {
  * @DAMOS_FILTER_TYPE_UNMAPPED:	Unmapped pages.
  * @DAMOS_FILTER_TYPE_ADDR:	Address range.
  * @DAMOS_FILTER_TYPE_TARGET:	Data Access Monitoring target.
+ * @DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:	probe_hits weighted sum range.
  * @NR_DAMOS_FILTER_TYPES:	Number of filter types.
  *
- * All types except &DAMOS_FILTER_TYPE_ADDR and &DAMOS_FILTER_TYPE_TARGET
- * are handled by the underlying &struct damon_operations as a part of scheme
include/linux/damon.h struct damos_stat { · line 410
Quoted 10 lines
include/linux/damon.h +6 -4
- * action trying, and therefore accounted as 'tried'.  In contrast,
- * &DAMOS_FILTER_TYPE_ADDR and &DAMOS_FILTER_TYPE_TARGET filters are handled
- * by the core layer before trying of the action, and therefore not accounted
- * as 'tried'.
+ * All types except &DAMOS_FILTER_TYPE_ADDR, &DAMOS_FILTER_TYPE_TARGET and
+ * &DAMOS_FILTER_TYPE_PROBE_HITS_WSUM are handled by the underlying &struct
+ * damon_operations as a part of scheme action trying, and therefore accounted
+ * as 'tried'.  In contrast, &DAMOS_FILTER_TYPE_ADDR and
+ * &DAMOS_FILTER_TYPE_TARGET filters are handled by the core layer before
+ * trying of the action, and therefore not accounted as 'tried'.
[Severity: Low]
Does this leave the handling behavior of the new filter unexplained?

Quoted 8 lines

The newly updated kerneldoc for enum damos_filter_type explicitly excludes DAMOS_FILTER_TYPE_PROBE_HITS_WSUM from the list of filters handled by operations, but it appears to be missing from the subsequent sentence detailing which filters are handled by the core layer.
This creates a contradiction where its handling behavior is undefined. Should it be added to the second sentence alongside DAMOS_FILTER_TYPE_ADDR and DAMOS_FILTER_TYPE_TARGET?

That's described in the design document. Maybe we could add more documentation including reference to the design document. That could be done as a followup rather than blocking this patch.

Quoted 3 lines

Signature · 2 lines

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1

Thanks,
SJ

SJ Park

author maintainer

2026-09-10 14:19 UTC #4 lore raw

PATCH 2/7 mm/damon/core: extend probe_hits_wsum() for moving sum based calculation

In reply to SJ Park

damon_probe_hits_wsum() is being called only in aggregation time. In future, it could also be used by DAMOS. In this case, since DAMOS uses its own apply_interval, it could be called in sampling time. Then using the not yet fully aggregated probe_hits could result in suboptimum outcomes. Extend damon_probe_hits_wsum() to get the weighted sum based on moving sum to prepare the DAMOS usage.

Signed-off-by SJ Park <[email protected]>

---
 include/linux/damon.h | 2 +-
 mm/damon/core.c       | 8 ++++++--
 mm/damon/paddr.c      | 2 +-
 mm/damon/vaddr.c      | 2 +-
 4 files changed, 9 insertions(+), 5 deletions(-)

include/linux/damon.h +1 -1

index ef99ff778ae10..4a36f344bbc7c 100644
@@ -1073,7 +1073,7 @@ unsigned int damon_nr_accesses_mvsum(struct damon_region *r,
 		struct damon_ctx *ctx);
 unsigned char damon_probe_hits_mvsum(int probe_idx, struct damon_region *r,
 		struct damon_ctx *ctx);
-unsigned int damon_probe_hits_wsum(struct damon_region *r, bool last,
+unsigned int damon_probe_hits_wsum(struct damon_region *r, bool last, bool mv,
 		struct damon_ctx *ctx);
 
 int damon_set_regions(struct damon_target *t, struct damon_addr_range *ranges,

mm/damon/core.c +6 -2

index 645cb367019ae..e9630f41e51fe 100644
@@ -469,11 +469,12 @@ static bool damon_is_last_region(struct damon_region *r,
  * damon_probe_hits_wsum() - Returns probe hits weighted sum of a region.
  * @r:		region to get the weighted sum of.
  * @last:	if the request is for last-window aggregated probe hits.
+ * @mv:		use moving sum.
  * @ctx:	context of &r.
  *
  * Return: the weighted sum of probe hits of the region.
  */
-unsigned int damon_probe_hits_wsum(struct damon_region *r, bool last,
+unsigned int damon_probe_hits_wsum(struct damon_region *r, bool last, bool mv,
 		struct damon_ctx *ctx)
 {
 	struct damon_probe *probe;

@@ -483,6 +484,9 @@ unsigned int damon_probe_hits_wsum(struct damon_region *r, bool last,
 	damon_for_each_probe(probe, ctx) {
 		if (last)
 			sum += r->last_probe_hits[i++] * probe->weight;
+		else if (mv)
+			sum += damon_probe_hits_mvsum(i++, r, ctx) *
+				probe->weight;
 		else
 			sum += r->probe_hits[i++] * probe->weight;
 	}

@@ -3449,7 +3453,7 @@ static unsigned int damon_merge_score(struct damon_region *r, bool last,
 		struct damon_ctx *ctx, bool use_probe_hits)
 {
 	if (use_probe_hits)
-		return damon_probe_hits_wsum(r, last, ctx);
+		return damon_probe_hits_wsum(r, last, false, ctx);
 	if (last)
 		return r->last_nr_accesses;
 	return r->nr_accesses;

mm/damon/paddr.c +1 -1

index d7c81829445ba..b8f4d28165dd7 100644
@@ -202,7 +202,7 @@ static unsigned int damon_pa_apply_probes(struct damon_ctx *ctx,
 				folio_put(folio);
 			if (return_max_wsum)
 				max_wsum = max(damon_probe_hits_wsum(r, false,
-							ctx), max_wsum);
+							false, ctx), max_wsum);
 		}
 	}
 	return max_wsum;

mm/damon/vaddr.c +1 -1

index 9a38dc89a156e..4aecf34e39be2 100644
@@ -704,7 +704,7 @@ static unsigned int damon_va_apply_probes(struct damon_ctx *ctx,
 			__damon_va_apply_probes(ctx, mm, r);
 			if (return_max_wsum)
 				max_wsum = max(damon_probe_hits_wsum(r, false,
-							ctx), max_wsum);
+							false, ctx), max_wsum);
 		}
 		if (mm)
 			mmput(mm);

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:24 UTC #5 lore raw

Re: [PATCH 2/7] mm/damon/core: extend probe_hits_wsum() for moving sum based calculation

Sashiko has reviewed this patch and found no issues. It looks great!

Quoted 8 lines

damon_probe_hits_wsum() is being called only in aggregation time. In future, it could also be used by DAMOS. In this case, since DAMOS uses its own apply_interval, it could be called in sampling time. Then using the not yet fully aggregated probe_hits could result in suboptimum outcomes. Extend damon_probe_hits_wsum() to get the weighted sum based on moving sum to prepare the DAMOS usage.
Signed-off-by SJ Park <[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=2

SJ Park

author maintainer

2026-09-10 14:19 UTC #6 lore raw

PATCH 3/7 mm/damon/core: support probe_hits_wsum damos core filter

In reply to SJ Park

Implement probe_hits_wsum DAMOS core filter support in the core layer. Make three small changes for the support. First, update damos_filter_for_ops() to treat probe_hits_wsum filter as core filter. Second, Update destination damos_filter->range_{min,max} for probe_hits_wsum type damos filter commits. Third, extend damos_filter_match() to handle probe_hits_wsum type filter. Calculate the weighted sum of the given region and compare it with the given filter's target weighted sum range.

Signed-off-by SJ Park <[email protected]>

---
 mm/damon/core.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

mm/damon/core.c +11 -1

index e9630f41e51fe..d9d56f4be1a97 100644
@@ -658,6 +658,7 @@ bool damos_filter_for_ops(enum damos_filter_type type)
 	switch (type) {
 	case DAMOS_FILTER_TYPE_ADDR:
 	case DAMOS_FILTER_TYPE_TARGET:
+	case DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:
 		return false;
 	default:
 		break;

@@ -1332,6 +1333,10 @@ static void damos_commit_filter_arg(
 	case DAMOS_FILTER_TYPE_HUGEPAGE_SIZE:
 		dst->sz_range = src->sz_range;
 		break;
+	case DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:
+		dst->range_min = src->range_min;
+		dst->range_max = src->range_max;
+		break;
 	default:
 		break;
 	}

@@ -2510,7 +2515,7 @@ static bool damos_filter_match(struct damon_ctx *ctx, struct damon_target *t,
 	bool matched = false;
 	struct damon_target *ti;
 	int target_idx = 0;
-	unsigned long start, end;
+	unsigned long start, end, wsum;
 
 	switch (filter->type) {
 	case DAMOS_FILTER_TYPE_TARGET:

@@ -2545,6 +2550,11 @@ static bool damos_filter_match(struct damon_ctx *ctx, struct damon_target *t,
 		damon_split_region_at(t, r, end - r->ar.start);
 		matched = true;
 		break;
+	case DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:
+		wsum = damon_probe_hits_wsum(r, false, true, ctx);
+		matched = filter->range_min <= wsum &&
+			wsum <= filter->range_max;
+		break;
 	default:
 		return false;
 	}

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:26 UTC #7 lore raw

Re: [PATCH 3/7] mm/damon/core: support probe_hits_wsum damos core filter

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] Missing KUnit test coverage for the new DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter. --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Missing KUnit test coverage for the new DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter. --

commit c30ab09af6b4b9ef8cab31ff2d43ce4d72f9e904
Author: SJ Park <[email protected]>

mm/damon/core: support probe_hits_wsum damos core filter

This commit implements the probe_hits_wsum DAMOS core filter support. It updates the core layer to treat it as a core filter, copy its range parameters, and match regions based on their weighted sum.

Quoted 4 lines

mm/damon/core.c +0 -0

index e9630f41e51fe..d9d56f4be1a97 100644

[ ... ]

mm/damon/core.c static void damos_commit_filter_arg( · line 1342

Quoted 11 lines

mm/damon/core.c +4 -0

@@ -1332,6 +1333,10 @@ static void damos_commit_filter_arg(
 	case DAMOS_FILTER_TYPE_HUGEPAGE_SIZE:
 		dst->sz_range = src->sz_range;
 		break;
+	case DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:
+		dst->range_min = src->range_min;
+		dst->range_max = src->range_max;
+		break;
 	default:
 		break;
 	}

[Severity: Low]
Should this patch also update the KUnit tests to cover the new filter type?

The new DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter is not validated by the DAMON core KUnit tests, leaving this argument copying logic untested.

For example, it appears missing from the validation switch in damos_test_commit_filter_for():

mm/damon/tests/core-kunit.h:damos_test_commit_filter_for() {
	switch (src->type) {
	case DAMOS_FILTER_TYPE_MEMCG:
		KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);
		break;
	...
}

And the orchestrator function damos_test_commit_filter() does not seem to invoke a test case for the new probe_hits_wsum filter.

Signature · 1 line

Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3

SJ Park

author maintainer

2026-09-10 14:34 UTC #8 lore raw

Re: [PATCH 3/7] mm/damon/core: support probe_hits_wsum damos core filter

Quoted 49 lines · On Thu, 10 Sep 2026 14:26:06 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Missing KUnit test coverage for the new DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter. --
commit c30ab09af6b4b9ef8cab31ff2d43ce4d72f9e904
Author: SJ Park <[email protected]>
mm/damon/core: support probe_hits_wsum damos core filter
This commit implements the probe_hits_wsum DAMOS core filter support. It updates the core layer to treat it as a core filter, copy its range parameters, and match regions based on their weighted sum.
Quoted 4 lines
mm/damon/core.c +0 -0
index e9630f41e51fe..d9d56f4be1a97 100644
[ ... ]
mm/damon/core.c static void damos_commit_filter_arg( · line 1342
Quoted 11 lines
mm/damon/core.c +4 -0
@@ -1332,6 +1333,10 @@ static void damos_commit_filter_arg(
 	case DAMOS_FILTER_TYPE_HUGEPAGE_SIZE:
 		dst->sz_range = src->sz_range;
 		break;
+	case DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:
+		dst->range_min = src->range_min;
+		dst->range_max = src->range_max;
+		break;
 	default:
 		break;
 	}
[Severity: Low]
Should this patch also update the KUnit tests to cover the new filter type?
The new DAMOS_FILTER_TYPE_PROBE_HITS_WSUM filter is not validated by the DAMON core KUnit tests, leaving this argument copying logic untested.
For example, it appears missing from the validation switch in damos_test_commit_filter_for():
mm/damon/tests/core-kunit.h:damos_test_commit_filter_for() {
	switch (src->type) {
	case DAMOS_FILTER_TYPE_MEMCG:
		KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);
		break;
	...
}

Quoted 2 lines

And the orchestrator function damos_test_commit_filter() does not seem to invoke a test case for the new probe_hits_wsum filter.

Good suggestion but no blocker. I will consider doing this as a followup in future.

Quoted 3 lines

Signature · 2 lines

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3

Thanks,
SJ

SJ Park

author maintainer

2026-09-10 14:19 UTC #9 lore raw

PATCH 4/7 mm/damon/sysfs-schemes: rename sysfs_filter->sz_range to range_{min,max}

In reply to SJ Park

DAMON sysfs interface provides 'min' and 'max' files under the DAMOS filter directory. The purpose is setting the general range arguments for hugepage_size like filters that require range arguments. So far, hugepage_size was the only filter using it. Hence sz_range field of damon_sysfs_scheme_filter struct was connected to the files.

In future, we could add a new filter that can reuse the 'min' and 'max' files. And the filter might use a range of a type that is not size. For example, probe_hits weighted sum. In this case, simply reusing the sz_range field would make it a little confusing. Rename sz_range to range_{min,max} to avoid such confusion.

Signed-off-by SJ Park <[email protected]>

---
 mm/damon/sysfs-schemes.c | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

mm/damon/sysfs-schemes.c +11 -8

index d9b81d7b5910e..4d9147d2a269e 100644
@@ -534,7 +534,8 @@ struct damon_sysfs_scheme_filter {
 	bool allow;
 	char *memcg_path;
 	struct damon_addr_range addr_range;
-	struct damon_size_range sz_range;
+	unsigned long range_min;
+	unsigned long range_max;
 	int target_idx;
 };

@@ -588,6 +589,7 @@ damos_sysfs_filter_type_names[] = {
 		.type = DAMOS_FILTER_TYPE_TARGET,
 		.name = "target",
 	},
+
 };
 
 static ssize_t type_show(struct kobject *kobj,

@@ -778,7 +780,7 @@ static ssize_t min_show(struct kobject *kobj,
 	struct damon_sysfs_scheme_filter *filter = container_of(kobj,
 			struct damon_sysfs_scheme_filter, kobj);
 
-	return sysfs_emit(buf, "%lu\n", filter->sz_range.min);
+	return sysfs_emit(buf, "%lu\n", filter->range_min);
 }
 
 static ssize_t min_store(struct kobject *kobj,

@@ -786,7 +788,7 @@ static ssize_t min_store(struct kobject *kobj,
 {
 	struct damon_sysfs_scheme_filter *filter = container_of(kobj,
 			struct damon_sysfs_scheme_filter, kobj);
-	int err = kstrtoul(buf, 0, &filter->sz_range.min);
+	int err = kstrtoul(buf, 0, &filter->range_min);
 
 	return err ? err : count;
 }

@@ -797,7 +799,7 @@ static ssize_t max_show(struct kobject *kobj,
 	struct damon_sysfs_scheme_filter *filter = container_of(kobj,
 			struct damon_sysfs_scheme_filter, kobj);
 
-	return sysfs_emit(buf, "%lu\n", filter->sz_range.max);
+	return sysfs_emit(buf, "%lu\n", filter->range_max);
 }
 
 static ssize_t max_store(struct kobject *kobj,

@@ -805,7 +807,7 @@ static ssize_t max_store(struct kobject *kobj,
 {
 	struct damon_sysfs_scheme_filter *filter = container_of(kobj,
 			struct damon_sysfs_scheme_filter, kobj);
-	int err = kstrtoul(buf, 0, &filter->sz_range.max);
+	int err = kstrtoul(buf, 0, &filter->range_max);
 
 	return err ? err : count;
 }

@@ -2835,12 +2837,13 @@ static int damon_sysfs_add_scheme_filters(struct damos *scheme,
 		} else if (filter->type == DAMOS_FILTER_TYPE_TARGET) {
 			filter->target_idx = sysfs_filter->target_idx;
 		} else if (filter->type == DAMOS_FILTER_TYPE_HUGEPAGE_SIZE) {
-			if (sysfs_filter->sz_range.min >
-					sysfs_filter->sz_range.max) {
+			if (sysfs_filter->range_min >
+					sysfs_filter->range_max) {
 				damos_destroy_filter(filter);
 				return -EINVAL;
 			}
-			filter->sz_range = sysfs_filter->sz_range;
+			filter->sz_range.min = sysfs_filter->range_min;
+			filter->sz_range.max = sysfs_filter->range_max;
 		}
 
 		damos_add_filter(scheme, filter);

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:27 UTC #10 lore raw

Re: [PATCH 4/7] mm/damon/sysfs-schemes: rename sysfs_filter->sz_range to range_{min,max}

Sashiko has reviewed this patch and found no issues. It looks great!

Quoted 6 lines

DAMON sysfs interface provides 'min' and 'max' files under the DAMOS filter directory. The purpose is setting the general range arguments for hugepage_size like filters that require range arguments. So far, hugepage_size was the only filter using it. Hence sz_range field of damon_sysfs_scheme_filter struct was connected to the files.

Quoted 7 lines

In future, we could add a new filter that can reuse the 'min' and 'max' files. And the filter might use a range of a type that is not size. For example, probe_hits weighted sum. In this case, simply reusing the sz_range field would make it a little confusing. Rename sz_range to range_{min,max} to avoid such confusion.
Signed-off-by SJ Park <[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=4

SJ Park

author maintainer

2026-09-10 14:19 UTC #11 lore raw

PATCH 5/7 mm/damon/sysfs-schemes: support probe_hits_wsum damos core filter

In reply to SJ Park

Extend DAMON sysfs interface to support probe_hits_wsum input. Also update sysfs input based scheme build logic to setup the min/max probe hits weighted sum range as user provided.

Signed-off-by SJ Park <[email protected]>

---
 mm/damon/sysfs-schemes.c | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

mm/damon/sysfs-schemes.c +12 -1

index 4d9147d2a269e..d9dd4ee0442c7 100644
@@ -589,7 +589,10 @@ damos_sysfs_filter_type_names[] = {
 		.type = DAMOS_FILTER_TYPE_TARGET,
 		.name = "target",
 	},
-
+	{
+		.type = DAMOS_FILTER_TYPE_PROBE_HITS_WSUM,
+		.name = "probe_hits_wsum",
+	},
 };
 
 static ssize_t type_show(struct kobject *kobj,

@@ -2844,6 +2847,14 @@ static int damon_sysfs_add_scheme_filters(struct damos *scheme,
 			}
 			filter->sz_range.min = sysfs_filter->range_min;
 			filter->sz_range.max = sysfs_filter->range_max;
+		} else if (filter->type == DAMOS_FILTER_TYPE_PROBE_HITS_WSUM) {
+			if (sysfs_filter->range_min >
+					sysfs_filter->range_max) {
+				damos_destroy_filter(filter);
+				return -EINVAL;
+			}
+			filter->range_min = sysfs_filter->range_min;
+			filter->range_max = sysfs_filter->range_max;
 		}
 
 		damos_add_filter(scheme, filter);

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:30 UTC #12 lore raw

Re: [PATCH 5/7] mm/damon/sysfs-schemes: support probe_hits_wsum damos core filter

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Time-of-Check to Time-of-Use race when validating probe_hits_wsum range allows invalid filter…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Time-of-Check to Time-of-Use race when validating probe_hits_wsum range allows invalid filter configurations to bypass validation. --

commit 27bc99697c36a87c8e4b72fe6006955a564a4bb2
Author: SJ Park <[email protected]>

mm/damon/sysfs-schemes: support probe_hits_wsum damos core filter

Extend DAMON sysfs interface to support probe_hits_wsum input. Also update sysfs input based scheme build logic to setup the min/max probe hits weighted sum range as user provided.

Quoted 4 lines

mm/damon/sysfs-schemes.c +0 -0
index 4d9147d2a269e..d9dd4ee0442c7 100644

[ ... ]

mm/damon/sysfs-schemes.c static int damon_sysfs_add_scheme_filters(struct damos *scheme, · line 2857

Quoted 12 lines

mm/damon/sysfs-schemes.c +8 -0

@@ -2844,6 +2847,14 @@ static int damon_sysfs_add_scheme_filters(struct damos *scheme,
 			}
 			filter->sz_range.min = sysfs_filter->range_min;
 			filter->sz_range.max = sysfs_filter->range_max;
+		} else if (filter->type == DAMOS_FILTER_TYPE_PROBE_HITS_WSUM) {
+			if (sysfs_filter->range_min >
+					sysfs_filter->range_max) {
+				damos_destroy_filter(filter);
+				return -EINVAL;
+			}
+			filter->range_min = sysfs_filter->range_min;
+			filter->range_max = sysfs_filter->range_max;

[Severity: Medium]
Are these repeated reads of sysfs_filter->range_min and sysfs_filter->range_max susceptible to a time-of-check to time-of-use race?

If a privileged user concurrently writes to a filter's min or max sysfs attribute between the validation check and the assignments:

    if (sysfs_filter->range_min > sysfs_filter->range_max) {
        // Validation passes
    }

    // Concurrent sysfs write updates range_min here

    filter->range_min = sysfs_filter->range_min; // Now invalid

Could this allow an invalid configuration to bypass the check and be added to the DAMON scheme? Would it be safer to read the values into local variables first, validate those local variables, and then assign them to the filter?

Quoted 3 lines

mm/damon/sysfs-schemes.c +0 -0

 		}
 
 		damos_add_filter(scheme, filter);

Signature · 1 line

Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5

SJ Park

author maintainer

2026-09-10 14:38 UTC #13 lore raw

Re: [PATCH 5/7] mm/damon/sysfs-schemes: support probe_hits_wsum damos core filter

Quoted 48 lines · On Thu, 10 Sep 2026 14:30:13 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Time-of-Check to Time-of-Use race when validating probe_hits_wsum range allows invalid filter configurations to bypass validation. --
commit 27bc99697c36a87c8e4b72fe6006955a564a4bb2
Author: SJ Park <[email protected]>
mm/damon/sysfs-schemes: support probe_hits_wsum damos core filter
Extend DAMON sysfs interface to support probe_hits_wsum input. Also update sysfs input based scheme build logic to setup the min/max probe hits weighted sum range as user provided.
Quoted 4 lines
mm/damon/sysfs-schemes.c +0 -0
index 4d9147d2a269e..d9dd4ee0442c7 100644
[ ... ]
mm/damon/sysfs-schemes.c static int damon_sysfs_add_scheme_filters(struct damos *scheme, · line 2857
Quoted 12 lines
mm/damon/sysfs-schemes.c +8 -0
@@ -2844,6 +2847,14 @@ static int damon_sysfs_add_scheme_filters(struct damos *scheme,
 			}
 			filter->sz_range.min = sysfs_filter->range_min;
 			filter->sz_range.max = sysfs_filter->range_max;
+		} else if (filter->type == DAMOS_FILTER_TYPE_PROBE_HITS_WSUM) {
+			if (sysfs_filter->range_min >
+					sysfs_filter->range_max) {
+				damos_destroy_filter(filter);
+				return -EINVAL;
+			}
+			filter->range_min = sysfs_filter->range_min;
+			filter->range_max = sysfs_filter->range_max;
[Severity: Medium]
Are these repeated reads of sysfs_filter->range_min and sysfs_filter->range_max susceptible to a time-of-check to time-of-use race?
If a privileged user concurrently writes to a filter's min or max sysfs attribute between the validation check and the assignments:
    if (sysfs_filter->range_min > sysfs_filter->range_max) {
        // Validation passes
    }

    // Concurrent sysfs write updates range_min here

    filter->range_min = sysfs_filter->range_min; // Now invalid

Quoted 3 lines

Could this allow an invalid configuration to bypass the check and be added to the DAMON scheme? Would it be safer to read the values into local variables first, validate those local variables, and then assign them to the filter?

Good finding, I agree this is better to be fixed. And maybe we could move the validation to the core layer parameters validation logic.

I will fix this in the next revision.

Quoted 7 lines

Quoted 4 lines

mm/damon/sysfs-schemes.c +0 -0

 		}
 
 		damos_add_filter(scheme, filter);

Signature · 1 line

Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5

Thanks,
SJ

SJ Park

author maintainer

2026-09-10 14:19 UTC #14 lore raw

PATCH 6/7 Docs/mm/damon/design: update for probe_hits_wsum DAMOS core filter

In reply to SJ Park

Update DAMON design document for the newly added probe hits weighted sum based DAMOS core filter type.

Signed-off-by SJ Park <[email protected]>

---
 Documentation/mm/damon/design.rst | 3 +++
 1 file changed, 3 insertions(+)

Documentation/mm/damon/design.rst +3 -0

index aac84de261aa8..8e980dde362de 100644
@@ -822,6 +822,9 @@ Below ``type`` of filters are currently supported.
         - Applied to pages that belonging to a given address range.
     - target
         - Applied to pages that belonging to a given DAMON monitoring target.
+    - probe_hits_wsum
+        - Matches to monitoring regions having a given range of :ref:`probe
+          hits weighted sum <damon_design_attrs_only_monitoring>` value.
 - Operations layer handled, supported by only ``paddr`` operations set.
     - anon
         - Applied to pages that containing data that not stored in files.

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:24 UTC #15 lore raw

Re: [PATCH 6/7] Docs/mm/damon/design: update for probe_hits_wsum DAMOS core filter

Sashiko has reviewed this patch and found no issues. It looks great!

Quoted 4 lines

Update DAMON design document for the newly added probe hits weighted sum based DAMOS core filter type.
Signed-off-by SJ Park <[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=6

SJ Park

author maintainer

2026-09-10 14:19 UTC #16 lore raw

PATCH 7/7 Docs/admin-guide/mm/damon/usage: update for probe_hits_wsum DAMOS filter

In reply to SJ Park

Update DAMON usage document for the newly added probe hits weighted sum based DAMOS core filter type.

Signed-off-by SJ Park <[email protected]>

---
 Documentation/admin-guide/mm/damon/usage.rst | 4 ++++
 1 file changed, 4 insertions(+)

Documentation/admin-guide/mm/damon/usage.rst +4 -0

index 023c6334024f8..d3e37400367bd 100644
@@ -551,6 +551,10 @@ and ``damon_target_idx``.  To ``type`` file, you can write the type of the
 filter.  Refer to :ref:`the design doc <damon_design_damos_filters>` for
 available type names, their meaning and on what layer those are handled.
 
+For ``probe_hits_wsum`` type, you can specify the minimum and maximum probe
+hits weighted sum value for the filter to ``min`` and ``max`` files,
+respectively.
+
 For ``memcg`` type, you can specify the memory cgroup of the interest by
 writing the path of the memory cgroup from the cgroups mount point to
 ``memcg_path`` file.  For ``addr`` type, you can specify the start and end

Signature · 1 line

2.47.3

[email protected]

AI review

2026-09-10 14:28 UTC #17 lore raw

Re: [PATCH 7/7] Docs/admin-guide/mm/damon/usage: update for probe_hits_wsum DAMOS filter

Sashiko has reviewed this patch and found no issues. It looks great!

Quoted 4 lines

Update DAMON usage document for the newly added probe hits weighted sum based DAMOS core filter type.
Signed-off-by SJ Park <[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=7

SJ Park

author maintainer

2026-09-10 14:40 UTC #18 lore raw

In reply to SJ Park

Quoted 9 lines · On Thu, 10 Sep 2026 07:18:40 -0700 SJ Park <[email protected]> wrote:

DAMON can do flexible data attributes monitoring. The classical data access monitoring can also be done using the attributes monitoring. The access event is just one of the data attributes that DAMON supports. Users do monitoring to make some actions based on it. DAMOS is a feature for automating that. However, DAMOS cannot utilize the data attributes monitoring results. It is still Data "Access" Monitoring-based Operation Schemes. It requires users to set the target "access" pattern.

Quoted 6 lines

DAMOS core filter is effectively the same as the target access pattern. It is just a more generalized and flexible way of describing the operation action target region. Introduce a new DAMOS core filter type, probe_hits_wsum. It specifies the filter target based on a range of the probe hits weighted sum. Using this, users can apply DAMOS actions to regions of specific data attributes pattern.

Sashiko found a minor issue in patch 5 that is better to be fixed. I will send a new version of this series after adding the fix.

Thanks,
SJ

[...]