Skip to contentSkip to conversation

mm/damon: optimize out nr_accesses_bp

RFC PATCH In review SeongJae Park 2 participants 26 messages Jun 20

Subsystems (4)
lore
Share & tools
lore

SeongJae Park

author maintainer
#0 lore raw

cover mm/damon: optimize out nr_accesses_bp

TLDR: Replace damon_region->nr_accesses_bp, which is easy to be wrong, with a simpler on-demand moving sum function, damon_nr_accesses_mvsum().

Background
==========

DAMON's monitoring output (access pattern snapshot, or more technically speaking, damon_region->nr_accesses) is completed once per aggregation interval, which is 100 ms by default. Users can arbitrarily increase the interval for demand. Under the suggested intervals auto-tuning setup, it can span up to 200 seconds. If the aggregation interval is too long, the snapshot users cannot use it in reasonable time. To mitigate this, we introduced a new field of damon_region, namely nr_accesses_bp. It contains a pseudo moving sum of nr_accesses in bp units and is updated for each sampling interval.

It turned out keeping it correctly updated every sampling interval is not that easy. From online parameter update feature development and more experimental hacks, we found it is easy to be corrupted. Once it is corrupted, DAMON's monitoring outputs become quite insane. Hence we added a few validation checks. It is easy to be corrupted because it requires every update per sampling interval to be correct.

Solution
========

There is no real reason to keep it updated every sampling interval. Due to the simple pseudo-moving sum mechanism and existing helper field (last_nr_accesses), we can also calculate the pseudo moving sum on demand in a much simpler way.

Implement a function for getting the pseudo moving sum on demand, and replace nr_accessses_bp uses with the new function. Also remove no more needed tests for nr_accesses_bp and the per-sampling interval update functions. Finally, remove the nr_accesses_bp. The new function is quite simple.

Discussion
==========

Depending on the use case, multiple nr_accesses readers could be executed in the same kdamond_fn() main loop iteration, which is executed once per sampling interval. Such readers include DAMON region exporting tracepoints (damon_[region_]aggregated and damos_before_apply), DAMOS, and DAMON sysfs interface logic for update_schemes_tried_regions command. In this case, the new function will be called multiple times and this could be overhead compared to the old logic, which simply reads the field without any additional work. Nonetheless, the new function is quite simple. And the new approach does nothing while there is no need to read. The old approach had to execute its update function for each region for every sampling interval. Hence the new approach is believed to be even more lightweight in common case, and the overhead is anyway negligible.

One more advantage of this change is that one field from the damon_region struct is removed. On setups that uses a high number of DAMON regions, this could be a potential memory space benefit.

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

Patch 1 introduces the new function for getting the pseudo moving sum of nr_accesses on demands. Patch 2 implements a unit test for the new function's internal logic. Patches 3-5 replace uses of nr_accesses_bp in DAMOS, tracepoints and DAMON sysfs interface with the new function, respectively. Patches 6-8 removes nr_accesses_bp validation functions in DAMON core, one by one. Patches 9 and 10 further remove tests and test helper for nr_accesses_bp, respectively. Patches 11 removes the setups and updates or nr_accesses_bp field. Patch 12 removes the function that was used for updating nr_accesses_bp field with its unit test, which is the single remaining caller of the function. Finally, patch 13 removes damon_region->nr_accesses_bp field.

Changes from RFC v1
- RFC v1: https://lore.kernel.org/[email protected]
- Avoid divide-by-zero from zero aggregation interval.
- Call damon_nr_accesses_mvsum() for damos tracing only when it is enabled.
- Remove obsolete mentioning of nr_accesses_bp in comments.

SeongJae Park (13):
mm/damon: introduce damon_nr_accesses_mvsum() mm/damon/tests/core-kunit: test damon_mvsum() mm/damon/core: use damon_nr_accesses_mvsum() in __damos_valid_target() mm/damon/core: use damon_nr_accesses_mvsum() for damos region tracing mm/damon/sysfs-schemes: use damon_nr_accesses_mvsum() for damo regions mm/damon/core: remove damon_warn_fix_nr_accesses_corruption() mm/damon/core: remove damon_verify_reset_aggregated() mm/damon/core: remove damon_verify_merge_regions_of() mm/damon/tests/core-kunit: remove nr_accesses_bp setup and tests selftests/damon/drgn_dump_damon_status: do not dump nr_accesses_bp mm/damon/core: remove nr_accesses_bp setups and updates mm/damon/core: remove damon_moving_sum() and its unit test mm/damon: remove damon_region->nr_accesses_bp

 include/linux/damon.h                         |  12 +-
 include/trace/events/damon.h                  |   8 +-
 mm/damon/core.c                               | 180 +++++++-----------
 mm/damon/sysfs-schemes.c                      |   6 +-
 mm/damon/tests/core-kunit.h                   |  37 ++--
 .../selftests/damon/drgn_dump_damon_status.py |   1 -
 6 files changed, 96 insertions(+), 148 deletions(-)

base-commit: a74bff7aaa4b3a64070425b4b367a459388a8233

Signature · 1 line
2.47.3
author maintainer
#1 lore raw

RFC PATCH 1/13 mm/damon: introduce damon_nr_accesses_mvsum()

Introduce a new DAMON core function, damon_nr_accesses_mvsum(). It returns a pseudo moving sum value of a given region's nr_accesses for the last aggregation interval. The internal logic is the same to nr_accesses_bp. The difference is that nr_accesses_bp is updated for each sampling interval, while the new function needs to be executed only when requested. Hence the function's return value is the same as the value of nr_accesses_bp.

---
 include/linux/damon.h |  2 ++
 mm/damon/core.c       | 57 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+)
include/linux/damon.h +2 -0
index 02ac34537df9a..55a743d99b567 100644
@@ -1013,6 +1013,8 @@ struct damon_probe *damon_new_probe(void);
 void damon_add_probe(struct damon_ctx *ctx, struct damon_probe *probe);
 
 struct damon_region *damon_new_region(unsigned long start, unsigned long end);
+unsigned int damon_nr_accesses_mvsum(struct damon_region *r,
+		struct damon_ctx *ctx);
 
 int damon_set_regions(struct damon_target *t, struct damon_addr_range *ranges,
 		unsigned int nr_ranges, unsigned long min_region_sz);
mm/damon/core.c +57 -0

63 lines not on this page · raw message

Signature · 1 line
2.47.3
author maintainer
#5 lore raw

RFC PATCH 2/13 mm/damon/tests/core-kunit: test damon_mvsum()

In reply to SeongJae Park

Add a simple unit test for damon_nr_accesses_mvsum()'s internal core logic, damon_mvsum(). The test contains cases for just-started windows, partially completed windows, and just-completed windows.

---
 mm/damon/tests/core-kunit.h | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
mm/damon/tests/core-kunit.h +25 -0
index 4e448c08c724a..cdab14396250f 100644
@@ -623,6 +623,30 @@ static void damon_test_moving_sum(struct kunit *test)
 	}
 }
 
+static void damon_test_mvsum(struct kunit *test)
+{
+	unsigned long input_expects[] = {
+		/* current value, last value, remaining window (bp) */
+		0, 49, 10000, 49,	/* 0 + 49 * 1 */
+		3, 10, 7000, 10,	/* 3 + 10 * 0.7 */
+		3, 10, 5000, 8,		/* 3 + 10 * 0.5 */
+		32, 100, 1000, 42,	/* 32 + 100 * 0.1 */
+		42, 49, 0, 42,		/* 42 + 49 * 0 */
+	};
+
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(input_expects); i += 4) {
+		unsigned long current_nr = input_expects[i];
+		unsigned long last_nr = input_expects[i + 1];
+		unsigned long left_window_bp = input_expects[i + 2];
+		unsigned long expect = input_expects[i + 3];
+
+		KUNIT_EXPECT_EQ(test, damon_mvsum(current_nr, last_nr,
+					left_window_bp), expect);
+	}
+}
+
 static void damos_test_new_filter(struct kunit *test)
 {
 	struct damos_filter *filter;
@@ -1501,6 +1525,7 @@ static struct kunit_case damon_test_cases[] = {
 	KUNIT_CASE(damon_test_update_monitoring_result),
 	KUNIT_CASE(damon_test_set_attrs),
 	KUNIT_CASE(damon_test_moving_sum),
+	KUNIT_CASE(damon_test_mvsum),
 	KUNIT_CASE(damos_test_new_filter),
 	KUNIT_CASE(damos_test_commit_quota_goal),
 	KUNIT_CASE(damos_test_commit_quota_goals),
Signature · 1 line
2.47.3
author maintainer
#6 lore raw

RFC PATCH 3/13 mm/damon/core: use damon_nr_accesses_mvsum() in __damos_valid_target()

In reply to SeongJae Park

damon_nr_accesses_mvsum() returns a value same to nr_accesses_bp. Also the function is more simple and therefore more tolerant to errors. Execution of the function would be more expensive than the simple read of the field, but because the function is quite simple, the overhead should be negligible. Use it in __damos_valid_target() instead of the nr_accesses_bp.

---
 mm/damon/core.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)
mm/damon/core.c +6 -5
index 687aa2ea1d013..ce0e2a4c1d523 100644
@@ -2120,10 +2120,11 @@ static noinline_for_stack void kdamond_tune_intervals(struct damon_ctx *c)
 	damon_set_attrs(c, &new_attrs);
 }
 
-static bool __damos_valid_target(struct damon_region *r, struct damos *s)
+static bool __damos_valid_target(struct damon_region *r, struct damos *s,
+		struct damon_ctx *c)
 {
 	unsigned long sz;
-	unsigned int nr_accesses = r->nr_accesses_bp / 10000;
+	unsigned int nr_accesses = damon_nr_accesses_mvsum(r, c);
 
 	sz = damon_sz_region(r);
 	return s->pattern.min_sz_region <= sz &&
@@ -2149,7 +2150,7 @@ static bool damos_quota_is_set(struct damos_quota *quota)
 static bool damos_valid_target(struct damon_ctx *c, struct damon_region *r,
 		struct damos *s)
 {
-	bool ret = __damos_valid_target(r, s);
+	bool ret = __damos_valid_target(r, s, c);
 
 	if (!ret || !damos_quota_is_set(&s->quota) || !c->ops.get_scheme_score)
 		return ret;
@@ -2735,7 +2736,7 @@ static phys_addr_t damos_calc_eligible_bytes(struct damon_ctx *c,
 		damon_for_each_region(r, t) {
 			phys_addr_t addr, end_addr;
 
-			if (!__damos_valid_target(r, s))
+			if (!__damos_valid_target(r, s, c))
 				continue;
 
 			/* Convert from core address units to physical bytes */
@@ -3024,7 +3025,7 @@ static void damos_adjust_quota(struct damon_ctx *c, struct damos *s)
 			(DAMOS_MAX_SCORE + 1));
 	damon_for_each_target(t, c) {
 		damon_for_each_region(r, t) {
-			if (!__damos_valid_target(r, s))
+			if (!__damos_valid_target(r, s, c))
 				continue;
 			if (damos_core_filter_out(c, t, r, s))
 				continue;
Signature · 1 line
2.47.3
author maintainer
#9 lore raw

RFC PATCH 4/13 mm/damon/core: use damon_nr_accesses_mvsum() for damos region tracing

In reply to SeongJae Park

damon_nr_accesses_mvsum() returns a value same to nr_accesses_bp. Also the function is more simple and therefore more tolerant to errors. Execution of the function would be more expensive than the simple read of the field, but because the function is quite simple, the overhead should be negligible. Use it in the DAMON region exporting trace points instead of the nr_accesses_bp.

---
 include/trace/events/damon.h | 8 +++++---
 mm/damon/core.c              | 5 +++--
 2 files changed, 8 insertions(+), 5 deletions(-)
include/trace/events/damon.h +5 -3
index 78388538acf44..8851727ae1627 100644
@@ -78,9 +78,11 @@ TRACE_EVENT_CONDITION(damos_before_apply,
 
 	TP_PROTO(unsigned int context_idx, unsigned int scheme_idx,
 		unsigned int target_idx, struct damon_region *r,
-		unsigned int nr_regions, bool do_trace),
+		unsigned int nr_accesses, unsigned int nr_regions,
+		bool do_trace),
 
-	TP_ARGS(context_idx, scheme_idx, target_idx, r, nr_regions, do_trace),
+	TP_ARGS(context_idx, scheme_idx, target_idx, r, nr_accesses,
+		nr_regions, do_trace),
 
 	TP_CONDITION(do_trace),
 
@@ -101,7 +103,7 @@ TRACE_EVENT_CONDITION(damos_before_apply,
 		__entry->target_idx = target_idx;
 		__entry->start = r->ar.start;
 		__entry->end = r->ar.end;
-		__entry->nr_accesses = r->nr_accesses_bp / 10000;
+		__entry->nr_accesses = nr_accesses;
 		__entry->age = r->age;
 		__entry->nr_regions = nr_regions;
 	),
mm/damon/core.c +3 -2
index ce0e2a4c1d523..710ec13e98281 100644
@@ -2434,7 +2434,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,
 	struct damos *siter;		/* schemes iterator */
 	unsigned int sidx = 0;
 	struct damon_target *titer;	/* targets iterator */
-	unsigned int tidx = 0;
+	unsigned int tidx = 0, nr_accesses = 0;
 	bool do_trace = false;
 
 	/* get indices for trace_damos_before_apply() */
@@ -2449,6 +2449,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,
 				break;
 			tidx++;
 		}
+		nr_accesses = damon_nr_accesses_mvsum(r, c);
 		do_trace = true;
 	}
 
@@ -2464,7 +2465,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,
 		if (damos_core_filter_out(c, t, r, s))
 			return;
 		ktime_get_coarse_ts64(&begin);
-		trace_damos_before_apply(cidx, sidx, tidx, r,
+		trace_damos_before_apply(cidx, sidx, tidx, r, nr_accesses,
 				damon_nr_regions(t), do_trace);
 		sz_applied = c->ops.apply_scheme(c, t, r, s,
 				&sz_ops_filter_passed);
Signature · 1 line
2.47.3
author maintainer
#10 lore raw

RFC PATCH 5/13 mm/damon/sysfs-schemes: use damon_nr_accesses_mvsum() for damo regions

In reply to SeongJae Park

damon_nr_accesses_mvsum() returns a value same to nr_accesses_bp. Also the function is more simple and therefore more tolerant to errors. Execution of the function would be more expensive than the simple read of the field, but because the function is quite simple, the overhead should be negligible. Use it in the DAMON sysfs interface for scheme-tried regions, instead of the nr_accesses_bp.

---
 mm/damon/sysfs-schemes.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
mm/damon/sysfs-schemes.c +3 -3
index 9d8fab32b80f7..30a007bcf82f4 100644
@@ -159,7 +159,7 @@ struct damon_sysfs_scheme_region {
 };
 
 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
-		struct damon_region *region)
+		struct damon_region *region, struct damon_ctx *ctx)
 {
 	struct damon_sysfs_scheme_region *sysfs_region = kmalloc_obj(*sysfs_region);
 
@@ -167,7 +167,7 @@ static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
 		return NULL;
 	sysfs_region->kobj = (struct kobject){};
 	sysfs_region->ar = region->ar;
-	sysfs_region->nr_accesses = region->nr_accesses_bp / 10000;
+	sysfs_region->nr_accesses = damon_nr_accesses_mvsum(region, ctx);
 	sysfs_region->age = region->age;
 	sysfs_region->probes = NULL;
 	INIT_LIST_HEAD(&sysfs_region->list);
@@ -3124,7 +3124,7 @@ void damos_sysfs_populate_region_dir(struct damon_sysfs_schemes *sysfs_schemes,
 	if (total_bytes_only)
 		return;
 
-	region = damon_sysfs_scheme_region_alloc(r);
+	region = damon_sysfs_scheme_region_alloc(r, ctx);
 	if (!region)
 		return;
 	region->sz_filter_passed = sz_filter_passed;
Signature · 1 line
2.47.3
author maintainer
#13 lore raw

RFC PATCH 6/13 mm/damon/core: remove damon_warn_fix_nr_accesses_corruption()

In reply to SeongJae Park

nr_accesses_bp is delicate. Once it is corrupted, the consequence is the bad madness of DAMON monitoring results. From developments of features of size, we historically found nr_accesses_bp can be corrupted by complicated bugs that are not easy to debug. Hence we added a function for finding the corruption and fixing it right away.

There are no more uses of nr_accesses_bp. Hence the function for corruption detection and fix is no more needed. Rip it out.

---
 mm/damon/core.c | 14 --------------
 1 file changed, 14 deletions(-)
mm/damon/core.c +0 -14
index 710ec13e98281..e144f0079322d 100644
@@ -1994,19 +1994,6 @@ int damos_walk(struct damon_ctx *ctx, struct damos_walk_control *control)
 	return 0;
 }
 
-/*
- * Warn and fix corrupted ->nr_accesses[_bp] for investigations and preventing
- * the problem being propagated.
- */
-static void damon_warn_fix_nr_accesses_corruption(struct damon_region *r)
-{
-	if (r->nr_accesses_bp == r->nr_accesses * 10000)
-		return;
-	WARN_ONCE(true, "invalid nr_accesses_bp at reset: %u %u\n",
-			r->nr_accesses_bp, r->nr_accesses);
-	r->nr_accesses_bp = r->nr_accesses * 10000;
-}
-
 #ifdef CONFIG_DAMON_DEBUG_SANITY
 static void damon_verify_reset_aggregated(struct damon_region *r,
 		struct damon_ctx *c)
@@ -2048,7 +2035,6 @@ static void kdamond_reset_aggregated(struct damon_ctx *c)
 			trace_damon_aggregated(ti, r, damon_nr_regions(t));
 			trace_damon_region_aggregated(ti, r,
 					damon_nr_regions(t), nr_probes);
-			damon_warn_fix_nr_accesses_corruption(r);
 			r->last_nr_accesses = r->nr_accesses;
 			r->nr_accesses = 0;
 			for (i = 0; i < DAMON_MAX_PROBES; i++)
Signature · 1 line
2.47.3
author maintainer
#14 lore raw

RFC PATCH 7/13 mm/damon/core: remove damon_verify_reset_aggregated()

In reply to SeongJae Park

nr_accesse_bp is no longer being used in real use cases. Remove its validation function.

---
 mm/damon/core.c | 18 ------------------
 1 file changed, 18 deletions(-)
mm/damon/core.c +0 -18
index e144f0079322d..84d21d21ed6c9 100644
@@ -1994,23 +1994,6 @@ int damos_walk(struct damon_ctx *ctx, struct damos_walk_control *control)
 	return 0;
 }
 
-#ifdef CONFIG_DAMON_DEBUG_SANITY
-static void damon_verify_reset_aggregated(struct damon_region *r,
-		struct damon_ctx *c)
-{
-	WARN_ONCE(r->nr_accesses_bp != r->last_nr_accesses * 10000,
-			"nr_accesses_bp %u last_nr_accesses %u sis %lu %lu\n",
-			r->nr_accesses_bp, r->last_nr_accesses,
-			c->passed_sample_intervals, c->next_aggregation_sis);
-}
-#else
-static void damon_verify_reset_aggregated(struct damon_region *r,
-		struct damon_ctx *c)
-{
-}
-#endif
-
-
 /*
  * Reset the aggregated monitoring results ('nr_accesses' of each region).
  */
@@ -2039,7 +2022,6 @@ static void kdamond_reset_aggregated(struct damon_ctx *c)
 			r->nr_accesses = 0;
 			for (i = 0; i < DAMON_MAX_PROBES; i++)
 				r->probe_hits[i] = 0;
-			damon_verify_reset_aggregated(r, c);
 		}
 		ti++;
 	}
Signature · 1 line
2.47.3
author maintainer
#15 lore raw

RFC PATCH 8/13 mm/damon/core: remove damon_verify_merge_regions_of()

In reply to SeongJae Park

damon_verify_merge_regions_of() is only for nr_accesses_bp validation. But nr_accesses_bp is no more being used for a real purpose. Remove the validation.

---
 mm/damon/core.c | 15 ---------------
 1 file changed, 15 deletions(-)
mm/damon/core.c +0 -15
index 84d21d21ed6c9..6db157ee25129 100644
@@ -3109,20 +3109,6 @@ static void damon_merge_two_regions(struct damon_target *t,
 	damon_destroy_region(r, t);
 }
 
-#ifdef CONFIG_DAMON_DEBUG_SANITY
-static void damon_verify_merge_regions_of(struct damon_region *r)
-{
-	WARN_ONCE(r->nr_accesses != r->nr_accesses_bp / 10000,
-			"nr_accesses (%u) != nr_accesses_bp (%u)\n",
-			r->nr_accesses, r->nr_accesses_bp);
-}
-#else
-static void damon_verify_merge_regions_of(struct damon_region *r)
-{
-}
-#endif
-
-
 /*
  * Merge adjacent regions having similar access frequencies
  *
@@ -3136,7 +3122,6 @@ static void damon_merge_regions_of(struct damon_target *t, unsigned int thres,
 	struct damon_region *r, *prev = NULL, *next;
 
 	damon_for_each_region_safe(r, next, t) {
-		damon_verify_merge_regions_of(r);
 		if (abs(r->nr_accesses - r->last_nr_accesses) > thres)
 			r->age = 0;
 		else if ((r->nr_accesses == 0) != (r->last_nr_accesses == 0))
Signature · 1 line
2.47.3
author maintainer
#16 lore raw

RFC PATCH 9/13 mm/damon/tests/core-kunit: remove nr_accesses_bp setup and tests

In reply to SeongJae Park

DAMON core unit tests set up nr_accesses_bp for representing realistic damon_region, and also test the field. nr_acceses_bp is no longer being used for a real use case. Remove the setup and tests.

---
 mm/damon/tests/core-kunit.h | 8 --------
 1 file changed, 8 deletions(-)
mm/damon/tests/core-kunit.h +0 -8
index cdab14396250f..d1f019ab6fc25 100644
@@ -118,7 +118,6 @@ static void damon_test_aggregate(struct kunit *test)
 				kunit_skip(test, "region alloc fail");
 			}
 			r->nr_accesses = accesses[it][ir];
-			r->nr_accesses_bp = accesses[it][ir] * 10000;
 			damon_add_region(r, t);
 		}
 		it++;
@@ -155,7 +154,6 @@ static void damon_test_split_at(struct kunit *test)
 		damon_free_target(t);
 		kunit_skip(test, "region alloc fail");
 	}
-	r->nr_accesses_bp = 420000;
 	r->nr_accesses = 42;
 	r->last_nr_accesses = 15;
 	r->age = 10;
@@ -168,7 +166,6 @@ static void damon_test_split_at(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, r_new->ar.start, 25ul);
 	KUNIT_EXPECT_EQ(test, r_new->ar.end, 100ul);
 
-	KUNIT_EXPECT_EQ(test, r->nr_accesses_bp, r_new->nr_accesses_bp);
 	KUNIT_EXPECT_EQ(test, r->nr_accesses, r_new->nr_accesses);
 	KUNIT_EXPECT_EQ(test, r->last_nr_accesses, r_new->last_nr_accesses);
 	KUNIT_EXPECT_EQ(test, r->age, r_new->age);
@@ -191,7 +188,6 @@ static void damon_test_merge_two(struct kunit *test)
 		kunit_skip(test, "region alloc fail");
 	}
 	r->nr_accesses = 10;
-	r->nr_accesses_bp = 100000;
 	r->age = 9;
 	damon_add_region(r, t);
 	r2 = damon_new_region(100, 300);
@@ -200,7 +196,6 @@ static void damon_test_merge_two(struct kunit *test)
 		kunit_skip(test, "second region alloc fail");
 	}
 	r2->nr_accesses = 20;
-	r2->nr_accesses_bp = 200000;
 	r2->age = 21;
 	damon_add_region(r2, t);
 
@@ -208,7 +203,6 @@ static void damon_test_merge_two(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
 	KUNIT_EXPECT_EQ(test, r->ar.end, 300ul);
 	KUNIT_EXPECT_EQ(test, r->nr_accesses, 16u);
-	KUNIT_EXPECT_EQ(test, r->nr_accesses_bp, 160000u);
 	KUNIT_EXPECT_EQ(test, r->age, 17u);
 
 	i = 0;
@@ -256,7 +250,6 @@ static void damon_test_merge_regions_of(struct kunit *test)
 			kunit_skip(test, "region alloc fail");
 		}
 		r->nr_accesses = nrs[i];
-		r->nr_accesses_bp = nrs[i] * 10000;
 		damon_add_region(r, t);
 	}
 
@@ -556,7 +549,6 @@ static void damon_test_update_monitoring_result(struct kunit *test)
 		kunit_skip(test, "region alloc fail");
 
 	r->nr_accesses = 15;
-	r->nr_accesses_bp = 150000;
 	r->age = 20;
 
 	new_attrs = (struct damon_attrs){
Signature · 1 line
2.47.3
author maintainer
#17 lore raw

RFC PATCH 10/13 selftests/damon/drgn_dump_damon_status: do not dump nr_accesses_bp

In reply to SeongJae Park

drgn_dump_damon_status is dumping nr_accesses_bp field for future use case. nr_accesses_bp is not being used for a real purpose, though. Hence there will be no future test for it. Do not dump it.

---
 tools/testing/selftests/damon/drgn_dump_damon_status.py | 1 -
 1 file changed, 1 deletion(-)
tools/testing/selftests/damon/drgn_dump_damon_status.py +0 -1
index 26b207e44268d..09552e91bc782 100755
@@ -59,7 +59,6 @@ def region_to_dict(region):
         ['ar', addr_range_to_dict],
         ['sampling_addr', int],
         ['nr_accesses', int],
-        ['nr_accesses_bp', int],
         ['age', int],
         ])
 
Signature · 1 line
2.47.3
author maintainer
#18 lore raw

RFC PATCH 11/13 mm/damon/core: remove nr_accesses_bp setups and updates

In reply to SeongJae Park

DAMON core sets and updates nr_accesses_bp in multiple places. It explains how delicate it is. The field is no more being used for any real purpose, and replaced by a simpler function. Remove the setups and updates.

---
 mm/damon/core.c | 17 -----------------
 1 file changed, 17 deletions(-)
mm/damon/core.c +0 -17
index 6db157ee25129..471b58e8e31b9 100644
@@ -296,7 +296,6 @@ struct damon_region *damon_new_region(unsigned long start, unsigned long end)
 	region->ar.start = start;
 	region->ar.end = end;
 	region->nr_accesses = 0;
-	region->nr_accesses_bp = 0;
 	for (i = 0; i < DAMON_MAX_PROBES; i++)
 		region->probe_hits[i] = 0;
 	INIT_LIST_HEAD(&region->list);
@@ -871,7 +870,6 @@ static void damon_update_monitoring_result(struct damon_region *r,
 	if (!aggregating) {
 		r->nr_accesses = damon_nr_accesses_for_new_attrs(
 				r->nr_accesses, old_attrs, new_attrs);
-		r->nr_accesses_bp = r->nr_accesses * 10000;
 	} else {
 		/*
 		 * if this is called in the middle of the aggregation, reset
@@ -881,7 +879,6 @@ static void damon_update_monitoring_result(struct damon_region *r,
 		 */
 		r->last_nr_accesses = damon_nr_accesses_for_new_attrs(
 				r->last_nr_accesses, old_attrs, new_attrs);
-		r->nr_accesses_bp = r->last_nr_accesses * 10000;
 		r->nr_accesses = 0;
 	}
 	r->age = damon_age_for_new_attrs(r->age, old_attrs, new_attrs);
@@ -3098,7 +3095,6 @@ static void damon_merge_two_regions(struct damon_target *t,
 
 	l->nr_accesses = (l->nr_accesses * sz_l + r->nr_accesses * sz_r) /
 			(sz_l + sz_r);
-	l->nr_accesses_bp = l->nr_accesses * 10000;
 	l->age = (l->age * sz_l + r->age * sz_r) / (sz_l + sz_r);
 	l->ar.end = r->ar.end;
 	/* todo: do this for only installed probes */
@@ -3210,7 +3206,6 @@ static void damon_split_region_at(struct damon_target *t,
 
 	new->age = r->age;
 	new->last_nr_accesses = r->last_nr_accesses;
-	new->nr_accesses_bp = r->nr_accesses_bp;
 	new->nr_accesses = r->nr_accesses;
 	/* todo: do this for only installed probes */
 	memcpy(new->probe_hits, r->probe_hits, sizeof(r->probe_hits));
@@ -3779,18 +3774,6 @@ static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum,
 void damon_update_region_access_rate(struct damon_region *r, bool accessed,
 		struct damon_attrs *attrs)
 {
-	unsigned int len_window = 1;
-
-	/*
-	 * sample_interval can be zero, but cannot be larger than
-	 * aggr_interval, owing to validation of damon_set_attrs().
-	 */
-	if (attrs->sample_interval)
-		len_window = damon_max_nr_accesses(attrs);
-	r->nr_accesses_bp = damon_moving_sum(r->nr_accesses_bp,
-			r->last_nr_accesses * 10000, len_window,
-			accessed ? 10000 : 0);
-
 	if (accessed)
 		r->nr_accesses++;
 }
Signature · 1 line
2.47.3
author maintainer
#22 lore raw

RFC PATCH 12/13 mm/damon/core: remove damon_moving_sum() and its unit test

In reply to SeongJae Park

damon_moving_sum() is no longer being called for real purpose but its unit test. Testing a function that is not being used for real users makes no sense. Remove the test and the function.

---
 mm/damon/core.c             | 40 -------------------------------------
 mm/damon/tests/core-kunit.h | 16 ---------------
 2 files changed, 56 deletions(-)
mm/damon/core.c +0 -40
index 471b58e8e31b9..f96f54a7f178a 100644
@@ -3720,46 +3720,6 @@ int damon_set_region_system_rams_default(struct damon_target *t,
 	return damon_set_regions(t, &addr_range, 1, min_region_sz);
 }
 
-/*
- * damon_moving_sum() - Calculate an inferred moving sum value.
- * @mvsum:	Inferred sum of the last @len_window values.
- * @nomvsum:	Non-moving sum of the last discrete @len_window window values.
- * @len_window:	The number of last values to take care of.
- * @new_value:	New value that will be added to the pseudo moving sum.
- *
- * Moving sum (moving average * window size) is good for handling noise, but
- * the cost of keeping past values can be high for arbitrary window size.  This
- * function implements a lightweight pseudo moving sum function that doesn't
- * keep the past window values.
- *
- * It simply assumes there was no noise in the past, and get the no-noise
- * assumed past value to drop from @nomvsum and @len_window.  @nomvsum is a
- * non-moving sum of the last window.  For example, if @len_window is 10 and we
- * have 25 values, @nomvsum is the sum of the 11th to 20th values of the 25
- * values.  Hence, this function simply drops @nomvsum / @len_window from
- * given @mvsum and add @new_value.
- *
- * For example, if @len_window is 10 and @nomvsum is 50, the last 10 values for
- * the last window could be vary, e.g., 0, 10, 0, 10, 0, 10, 0, 0, 0, 20.  For
- * calculating next moving sum with a new value, we should drop 0 from 50 and
- * add the new value.  However, this function assumes it got value 5 for each
- * of the last ten times.  Based on the assumption, when the next value is
- * measured, it drops the assumed past value, 5 from the current sum, and add
- * the new value to get the updated pseduo-moving average.
- *
- * This means the value could have errors, but the errors will be disappeared
- * for every @len_window aligned calls.  For example, if @len_window is 10, the
- * pseudo moving sum with 11th value to 19th value would have an error.  But
- * the sum with 20th value will not have the error.
- *
- * Return: Pseudo-moving average after getting the @new_value.
- */
-static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum,
-		unsigned int len_window, unsigned int new_value)
-{
-	return mvsum - nomvsum / len_window + new_value;
-}
-
 /**
  * damon_update_region_access_rate() - Update the access rate of a region.
  * @r:		The DAMON region to update for its access check result.
mm/damon/tests/core-kunit.h +0 -16
index d1f019ab6fc25..df16cc070eeb0 100644
@@ -600,21 +600,6 @@ static void damon_test_set_attrs(struct kunit *test)
 	damon_destroy_ctx(c);
 }
 
-static void damon_test_moving_sum(struct kunit *test)
-{
-	unsigned int mvsum = 50000, nomvsum = 50000, len_window = 10;
-	unsigned int new_values[] = {10000, 0, 10000, 0, 0, 0, 10000, 0, 0, 0};
-	unsigned int expects[] = {55000, 50000, 55000, 50000, 45000, 40000,
-		45000, 40000, 35000, 30000};
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(new_values); i++) {
-		mvsum = damon_moving_sum(mvsum, nomvsum, len_window,
-				new_values[i]);
-		KUNIT_EXPECT_EQ(test, mvsum, expects[i]);
-	}
-}
-
 static void damon_test_mvsum(struct kunit *test)
 {
 	unsigned long input_expects[] = {
@@ -1516,7 +1501,6 @@ static struct kunit_case damon_test_cases[] = {
 	KUNIT_CASE(damon_test_nr_accesses_to_accesses_bp),
 	KUNIT_CASE(damon_test_update_monitoring_result),
 	KUNIT_CASE(damon_test_set_attrs),
-	KUNIT_CASE(damon_test_moving_sum),
 	KUNIT_CASE(damon_test_mvsum),
 	KUNIT_CASE(damos_test_new_filter),
 	KUNIT_CASE(damos_test_commit_quota_goal),
Signature · 1 line
2.47.3
author maintainer
#25 lore raw

RFC PATCH 13/13 mm/damon: remove damon_region->nr_accesses_bp

In reply to SeongJae Park

No code touches damon_region->nr_accesses_bp field. Remove it.

---
 include/linux/damon.h | 10 ----------
 mm/damon/core.c       |  3 +--
 2 files changed, 1 insertion(+), 12 deletions(-)
include/linux/damon.h +0 -10
index 55a743d99b567..90d2910b3217a 100644
@@ -47,8 +47,6 @@ struct damon_size_range {
  * @ar:			The address range of the region.
  * @sampling_addr:	Address of the sample for the next access check.
  * @nr_accesses:	Access frequency of this region.
- * @nr_accesses_bp:	@nr_accesses in basis point (0.01%) that updated for
- *			each sampling interval.
  * @probe_hits:		Number of probe-positive region samples.
  * @list:		List head for siblings.
  * @age:		Age of this region.
@@ -61,13 +59,6 @@ struct damon_size_range {
  * not be done with direct access but with the helper function,
  * damon_update_region_access_rate().
  *
- * @nr_accesses_bp is another representation of @nr_accesses in basis point
- * (1 in 10,000) that updated for every &damon_attrs->sample_interval in a
- * manner similar to moving sum.  By the algorithm, this value becomes
- * @nr_accesses * 10000 for every &struct damon_attrs->aggr_interval.  This can
- * be used when the aggregation interval is too huge and therefore cannot wait
- * for it before getting the access monitoring results.
- *
  * @age is initially zero, increased for each aggregation interval, and reset
  * to zero again if the access frequency is significantly changed.  If two
  * regions are merged into a new region, both @nr_accesses and @age of the new
@@ -77,7 +68,6 @@ struct damon_region {
 	struct damon_addr_range ar;
 	unsigned long sampling_addr;
 	unsigned int nr_accesses;
-	unsigned int nr_accesses_bp;
 	unsigned char probe_hits[DAMON_MAX_PROBES];
 	struct list_head list;
 
mm/damon/core.c +1 -2
index f96f54a7f178a..abccac9e9f9e8 100644
@@ -3580,8 +3580,7 @@ static int kdamond_fn(void *data)
 				 * aggregation, and make aggregation
 				 * information reset for all regions.  Then,
 				 * following kdamond_reset_aggregated() call
-				 * will make the region information invalid,
-				 * particularly for ->nr_accesses_bp.
+				 * will make the region information invalid.
 				 *
 				 * Reset ->next_aggregation_sis to avoid that.
 				 * It will anyway correctly updated after this
Signature · 1 line
2.47.3
#19 lore raw

Re: [RFC PATCH v1.1 11/13] mm/damon/core: remove nr_accesses_bp setups and updates

In reply to SeongJae Park
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The `attrs` parameter in `damon_update_region_access_rate()` is completely unused after this patch.…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The attrs parameter in damon_update_region_access_rate() is completely unused after this patch. --

commit ecb338097e9822ecdcbfa5f88676102211ac76ca
Author: SeongJae Park <[email protected]>

mm/damon/core: remove nr_accesses_bp setups and updates

This commit removes the setups and updates of the nr_accesses_bp field in the DAMON core. The field is no longer used for any real purpose and has been replaced by a simpler function.

Quoted 4 lines
mm/damon/core.c +0 -0
index 53568a3c3ad9b..a41b66b26a472 100644

[ ... ]

Quoted 9 lines
mm/damon/core.c +0 -5
@@ -3779,18 +3774,6 @@ static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum,
 void damon_update_region_access_rate(struct damon_region *r, bool accessed,
 		struct damon_attrs *attrs)
 {
-	unsigned int len_window = 1;
-
-	/*
-	 * sample_interval can be zero, but cannot be larger than
-	 * aggr_interval, owing to validation of damon_set_attrs().

mm/damon/core.c static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum, · line 3779

Quoted 10 lines
mm/damon/core.c +0 -7
-	 */
-	if (attrs->sample_interval)
-		len_window = damon_max_nr_accesses(attrs);
-	r->nr_accesses_bp = damon_moving_sum(r->nr_accesses_bp,
-			r->last_nr_accesses * 10000, len_window,
-			accessed ? 10000 : 0);
-
 	if (accessed)
 		r->nr_accesses++;
 }

[Severity: Low]
Does this leave the attrs parameter completely unused in damon_update_region_access_rate()?

Since the removal of the damon_moving_sum() logic removes the only use of attrs inside this function, could we also drop the struct damon_attrs *attrs parameter from the signature and its callers to fully clean up the API?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
#23 lore raw

Re: [RFC PATCH v1.1 12/13] mm/damon/core: remove damon_moving_sum() and its unit test

In reply to SeongJae Park
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The `attrs` parameter in `damon_update_region_access_rate()` is completely unused and should be…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The attrs parameter in damon_update_region_access_rate() is completely unused and should be removed. --

commit 4c4d26b15dff409f33a357a198fe9f93686b61be
Author: SeongJae Park <[email protected]>

mm/damon/core: remove damon_moving_sum() and its unit test

This commit removes the damon_moving_sum() function and its associated unit test, as the function is no longer used for any practical purpose.

Quoted 4 lines
mm/damon/core.c +0 -0
index a41b66b26a472..670cbfdf880ce 100644

[ ... ]

mm/damon/core.c int damon_set_region_system_rams_default(struct damon_target *t, · line 3725

Quoted 9 lines
mm/damon/core.c +0 -6
-static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum,
-		unsigned int len_window, unsigned int new_value)
-{
-	return mvsum - nomvsum / len_window + new_value;
-}
-
 /**
  * damon_update_region_access_rate() - Update the access rate of a region.
  * @r:		The DAMON region to update for its access check result.

[Severity: Low]
Are we able to drop the attrs parameter from this function now?

Following the removal of damon_moving_sum(), the attrs parameter is no longer used in the body of damon_update_region_access_rate():

mm/damon/core.c:damon_update_region_access_rate() {
	if (accessed)
		r->nr_accesses++;
}

Would it make sense to remove the attrs parameter from the prototype in include/linux/damon.h and from this function definition?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
#2 lore raw

Re: [RFC PATCH v1.1 01/13] mm/damon: introduce damon_nr_accesses_mvsum()

In reply to SeongJae Park
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Integer overflow in `mult_frac` within `damon_nr_accesses_mvsum()` corrupts DAMON moving sum…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Integer overflow in mult_frac within damon_nr_accesses_mvsum() corrupts DAMON moving sum access score on 32-bit architectures. --

commit 33b6652e4ab7390d9a1e1c6a292edc9a0fec212a
Author: SeongJae Park <[email protected]>

mm/damon: introduce damon_nr_accesses_mvsum()

This commit introduces damon_nr_accesses_mvsum() which returns a pseudo moving sum of a given region's nr_accesses for the last aggregation interval.

Quoted 4 lines
mm/damon/core.c +0 -0
index 7e4b9affc5b06..af95783d3402a 100644

[ ... ]

Quoted 7 lines
mm/damon/core.c +3 -0
@@ -210,6 +210,63 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)
 	return NULL;
 }
 
+/*
+ * damon_mvsum() - Returns pseudo moving sum value for a time window.
+ * @current_nr:		The value of the current aggregation window.

[ ... ]

mm/damon/core.c static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx) · line 264

Quoted 11 lines
mm/damon/core.c +11 -0
+unsigned int damon_nr_accesses_mvsum(struct damon_region *r,
+		struct damon_ctx *ctx)
+{
+	unsigned long sample_interval, aggr_interval;
+	unsigned long window_len, left_window, left_window_bp;
+
+	sample_interval = ctx->attrs.sample_interval ? : 1;
+	aggr_interval = ctx->attrs.aggr_interval ? : 1;
+	window_len = aggr_interval / sample_interval;
+	left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
+	left_window_bp = mult_frac(left_window, 10000, window_len);

[Severity: High]
Can the intermediate multiplication inside mult_frac() overflow on 32-bit architectures?

The mult_frac(x, n, d) macro computes (x / d) * n + (x % d) * n / d. Since left_window is generally less than window_len, the remainder (x % d) evaluates directly to left_window.

On 32-bit architectures, both left_window and the resulting product are 32-bit unsigned long values. If window_len exceeds 429,496 (for example, a 5ms sample_interval coupled with a ~36 minute aggr_interval), the intermediate calculation of left_window * 10000 can exceed ULONG_MAX (4,294,967,295) and silently wrap around.

This wrap around would cause left_window_bp to calculate as a truncated, artificially low value, leading to an incorrect access frequency score that might affect memory reclaim or protection decisions.

Quoted 4 lines
mm/damon/core.c +4 -0
+
+	return damon_mvsum(r->nr_accesses, r->last_nr_accesses,
+			left_window_bp);
+}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#11 lore raw

Re: [RFC PATCH v1.1 05/13] mm/damon/sysfs-schemes: use damon_nr_accesses_mvsum() for damo regions

In reply to SeongJae Park
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] If a user configures `sample_interval=0` and `aggr_interval=0`, the time difference calculation…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] If a user configures sample_interval=0 and aggr_interval=0, the time difference calculation inside damon_nr_accesses_mvsum() underflows, resulting in a huge garbage value for nr_accesses. This corrupts sysfs outputs and erratically influences DAMOS operations. --

commit 2a77ab9c787a549b18af4699f5ffa8d3e4d60ca2
Author: SeongJae Park <[email protected]>

mm/damon/sysfs-schemes: use damon_nr_accesses_mvsum() for damo regions

This commit modifies the DAMON sysfs interface to calculate region accesses using damon_nr_accesses_mvsum() rather than a simple division.

Quoted 14 lines
mm/damon/sysfs-schemes.c +1 -1
index 329cfd0bbe9f3..e648b0f809332 100644
@@ -159,7 +159,7 @@ struct damon_sysfs_scheme_region {
 };
 
 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
-		struct damon_region *region)
+		struct damon_region *region, struct damon_ctx *ctx)
 {
 	struct damon_sysfs_scheme_region *sysfs_region = kmalloc_obj(*sysfs_region);
 

mm/damon/sysfs-schemes.c static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc( · line 170

Quoted 5 lines
mm/damon/sysfs-schemes.c +1 -1
@@ -167,7 +167,7 @@ static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
 		return NULL;
 	sysfs_region->kobj = (struct kobject){};
 	sysfs_region->ar = region->ar;
-	sysfs_region->nr_accesses = region->nr_accesses_bp / 10000;
+	sysfs_region->nr_accesses = damon_nr_accesses_mvsum(region, ctx);

[Severity: High]
Could this lead to an unsigned integer underflow if a user configures both sample_us and aggr_us to 0 via sysfs?

If a user configures sample_interval=0 and aggr_interval=0, the intervals bypass the validation in damon_set_attrs(). Inside kdamond_fn(), ctx->next_aggregation_sis is updated by adding 0 and never advances, but ctx->passed_sample_intervals continues to increment on every loop iteration.

When damon_nr_accesses_mvsum() is called, it calculates the difference:

mm/damon/core.c:damon_nr_accesses_mvsum() {
        ...
        left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
        ...
}

Because ctx->passed_sample_intervals quickly exceeds ctx->next_aggregation_sis, does this subtraction result in an unsigned integer underflow?

If left_window becomes a massive value, it appears it would propagate through mult_frac() and damon_mvsum() to yield a garbage value for nr_accesses. Since __damos_valid_target() evaluates scheme criteria using this value, could this cause DAMON to act on wildly inaccurate access scores and disrupt system stability?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
author maintainer
#3 lore raw

Re: [RFC PATCH v1.1 01/13] mm/damon: introduce damon_nr_accesses_mvsum()

In reply to [email protected]
Quoted 55 lines · On Sat, 20 Jun 2026 17:36:32 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Integer overflow in mult_frac within damon_nr_accesses_mvsum() corrupts DAMON moving sum access score on 32-bit architectures. --

commit 33b6652e4ab7390d9a1e1c6a292edc9a0fec212a
Author: SeongJae Park <[email protected]>

mm/damon: introduce damon_nr_accesses_mvsum()

This commit introduces damon_nr_accesses_mvsum() which returns a pseudo moving sum of a given region's nr_accesses for the last aggregation interval.

Quoted 4 lines
mm/damon/core.c +0 -0
index 7e4b9affc5b06..af95783d3402a 100644

[ ... ]

Quoted 7 lines
mm/damon/core.c +3 -0
@@ -210,6 +210,63 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)
 	return NULL;
 }
 
+/*
+ * damon_mvsum() - Returns pseudo moving sum value for a time window.
+ * @current_nr:		The value of the current aggregation window.

[ ... ]

mm/damon/core.c static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx) · line 264

Quoted 11 lines
mm/damon/core.c +11 -0
+unsigned int damon_nr_accesses_mvsum(struct damon_region *r,
+		struct damon_ctx *ctx)
+{
+	unsigned long sample_interval, aggr_interval;
+	unsigned long window_len, left_window, left_window_bp;
+
+	sample_interval = ctx->attrs.sample_interval ? : 1;
+	aggr_interval = ctx->attrs.aggr_interval ? : 1;
+	window_len = aggr_interval / sample_interval;
+	left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
+	left_window_bp = mult_frac(left_window, 10000, window_len);

[Severity: High]
Can the intermediate multiplication inside mult_frac() overflow on 32-bit architectures?

The mult_frac(x, n, d) macro computes (x / d) * n + (x % d) * n / d. Since left_window is generally less than window_len, the remainder (x % d) evaluates directly to left_window.

On 32-bit architectures, both left_window and the resulting product are 32-bit unsigned long values. If window_len exceeds 429,496 (for example, a 5ms sample_interval coupled with a ~36 minute aggr_interval), the intermediate calculation of left_window * 10000 can exceed ULONG_MAX (4,294,967,295) and silently wrap around.

Quoted 3 lines

This wrap around would cause left_window_bp to calculate as a truncated, artificially low value, leading to an incorrect access frequency score that might affect memory reclaim or protection decisions.

This can happen only under a weird setup that we are not aiming to support for now. We could revisit this if a real user claims this as an issue and ask a support.

Thanks,
SJ

[....]

author maintainer
#4 lore raw

Re: [RFC PATCH v1.1 01/13] mm/damon: introduce damon_nr_accesses_mvsum()

Quoted 57 lines · On Sat, 20 Jun 2026 10:39:30 -0700 SeongJae Park <[email protected]> wrote:
Quoted 55 lines · On Sat, 20 Jun 2026 17:36:32 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Integer overflow in mult_frac within damon_nr_accesses_mvsum() corrupts DAMON moving sum access score on 32-bit architectures. --

commit 33b6652e4ab7390d9a1e1c6a292edc9a0fec212a
Author: SeongJae Park <[email protected]>

mm/damon: introduce damon_nr_accesses_mvsum()

This commit introduces damon_nr_accesses_mvsum() which returns a pseudo moving sum of a given region's nr_accesses for the last aggregation interval.

Quoted 4 lines
mm/damon/core.c +0 -0
index 7e4b9affc5b06..af95783d3402a 100644

[ ... ]

Quoted 7 lines
mm/damon/core.c +3 -0
@@ -210,6 +210,63 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)
 	return NULL;
 }
 
+/*
+ * damon_mvsum() - Returns pseudo moving sum value for a time window.
+ * @current_nr:		The value of the current aggregation window.

[ ... ]

mm/damon/core.c static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx) · line 264

Quoted 11 lines
mm/damon/core.c +11 -0
+unsigned int damon_nr_accesses_mvsum(struct damon_region *r,
+		struct damon_ctx *ctx)
+{
+	unsigned long sample_interval, aggr_interval;
+	unsigned long window_len, left_window, left_window_bp;
+
+	sample_interval = ctx->attrs.sample_interval ? : 1;
+	aggr_interval = ctx->attrs.aggr_interval ? : 1;
+	window_len = aggr_interval / sample_interval;
+	left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
+	left_window_bp = mult_frac(left_window, 10000, window_len);

[Severity: High]
Can the intermediate multiplication inside mult_frac() overflow on 32-bit architectures?

The mult_frac(x, n, d) macro computes (x / d) * n + (x % d) * n / d. Since left_window is generally less than window_len, the remainder (x % d) evaluates directly to left_window.

On 32-bit architectures, both left_window and the resulting product are 32-bit unsigned long values. If window_len exceeds 429,496 (for example, a 5ms sample_interval coupled with a ~36 minute aggr_interval), the intermediate calculation of left_window * 10000 can exceed ULONG_MAX (4,294,967,295) and silently wrap around.

Quoted 7 lines
Quoted 3 lines

This wrap around would cause left_window_bp to calculate as a truncated, artificially low value, leading to an incorrect access frequency score that might affect memory reclaim or protection decisions.

This can happen only under a weird setup that we are not aiming to support for now. We could revisit this if a real user claims this as an issue and ask a support.

FYI, I'm hacking on making a central validation point of DAMON parameters. Once it is done, we may be able to strictly avoid the weird setup by adding a validation for that.

Thanks,
SJ

[...]

#7 lore raw

Re: [RFC PATCH v1.1 03/13] mm/damon/core: use damon_nr_accesses_mvsum() in __damos_valid_target()

In reply to SeongJae Park
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] The new __damos_valid_target implementation uses damon_nr_accesses_mvsum(), which is vulnerable to…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] The new __damos_valid_target implementation uses damon_nr_accesses_mvsum(), which is vulnerable to time-of-check state desynchronization if ctx->next_aggregation_sis is updated asynchronously via kdamond_call(). This causes massive over-estimation of the target access frequency. --

commit 2274522ec6ea648db508697b0a1f57a8bf4e864d
Author: SeongJae Park <[email protected]>
Subject: mm/damon/core: use damon_nr_accesses_mvsum() in __damos_valid_target()

This commit replaces the direct read of r->nr_accesses_bp with a call to damon_nr_accesses_mvsum() inside __damos_valid_target(). The author notes that while execution is slightly more expensive, the function is simpler and more tolerant to errors.

Quoted 5 lines
mm/damon/core.c +0 -0
index af95783d3402a..ee4f0f0e583bd 100644

mm/damon/core.c static void kdamond_tune_intervals(struct damon_ctx *c) · line 2127

Quoted 10 lines
mm/damon/core.c +3 -2
@@ -2120,10 +2120,11 @@ static void kdamond_tune_intervals(struct damon_ctx *c)
 	damon_set_attrs(c, &new_attrs);
 }
 
-static bool __damos_valid_target(struct damon_region *r, struct damos *s)
+static bool __damos_valid_target(struct damon_region *r, struct damos *s,
+		struct damon_ctx *c)
 {
 	unsigned long sz;
-	unsigned int nr_accesses = r->nr_accesses_bp / 10000;
+	unsigned int nr_accesses = damon_nr_accesses_mvsum(r, c);

[Severity: High]
Could this lead to double-counting access scores if the context attributes are updated asynchronously?

In kdamond_fn(), when an aggregation interval finishes, pending API requests are processed via kdamond_call(ctx, false) right before kdamond_apply_schemes() is called. If a processed request triggers damon_set_attrs() (e.g., via sysfs), ctx->next_aggregation_sis is eagerly advanced to the end of the newly configured interval.

When __damos_valid_target() subsequently calls damon_nr_accesses_mvsum(), it calculates the time window based on ctx->next_aggregation_sis:

mm/damon/core.c:damon_nr_accesses_mvsum() {
    left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
    left_window_bp = mult_frac(left_window, 10000, window_len);
    return damon_mvsum(r->nr_accesses, r->last_nr_accesses, left_window_bp);
}

Because ctx->next_aggregation_sis was just advanced, left_window equals the full new window length, resulting in a left_window_bp of 10000.

Since damon_mvsum() assumes it is at the start of the window, it will add the unscaled r->last_nr_accesses to the current r->nr_accesses. Because the aggregation interval just finished, r->nr_accesses already holds the fully-accumulated access count. Adding last_nr_accesses effectively doubles the access score and could misclassify regions during target validation.

The pre-patch code avoided this by safely reading the decoupled r->nr_accesses_bp, which preserved the correct scaled value across kdamond_call() boundary transitions.

Quoted 2 lines
mm/damon/core.c +0 -0
 	sz = damon_sz_region(r);
 	return s->pattern.min_sz_region <= sz &&

[ ... ]

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
author maintainer
#20 lore raw

Re: [RFC PATCH v1.1 11/13] mm/damon/core: remove nr_accesses_bp setups and updates

In reply to [email protected]
Quoted 44 lines · On Sat, 20 Jun 2026 17:34:30 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The attrs parameter in damon_update_region_access_rate() is completely unused after this patch. --

commit ecb338097e9822ecdcbfa5f88676102211ac76ca
Author: SeongJae Park <[email protected]>

mm/damon/core: remove nr_accesses_bp setups and updates

This commit removes the setups and updates of the nr_accesses_bp field in the DAMON core. The field is no longer used for any real purpose and has been replaced by a simpler function.

Quoted 4 lines
mm/damon/core.c +0 -0
index 53568a3c3ad9b..a41b66b26a472 100644

[ ... ]

Quoted 9 lines
mm/damon/core.c +0 -5
@@ -3779,18 +3774,6 @@ static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum,
 void damon_update_region_access_rate(struct damon_region *r, bool accessed,
 		struct damon_attrs *attrs)
 {
-	unsigned int len_window = 1;
-
-	/*
-	 * sample_interval can be zero, but cannot be larger than
-	 * aggr_interval, owing to validation of damon_set_attrs().

mm/damon/core.c static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum, · line 3779

Quoted 10 lines
mm/damon/core.c +0 -7
-	 */
-	if (attrs->sample_interval)
-		len_window = damon_max_nr_accesses(attrs);
-	r->nr_accesses_bp = damon_moving_sum(r->nr_accesses_bp,
-			r->last_nr_accesses * 10000, len_window,
-			accessed ? 10000 : 0);
-
 	if (accessed)
 		r->nr_accesses++;
 }

[Severity: Low]
Does this leave the attrs parameter completely unused in damon_update_region_access_rate()?

Quoted 3 lines

Since the removal of the damon_moving_sum() logic removes the only use of attrs inside this function, could we also drop the struct damon_attrs *attrs parameter from the signature and its callers to fully clean up the API?

Good finding. But not necessarily as a part of this series. I will add this as a todo.

Thanks,
SJ

[...]

author maintainer
#24 lore raw

Re: [RFC PATCH v1.1 12/13] mm/damon/core: remove damon_moving_sum() and its unit test

In reply to [email protected]
Quoted 2 lines · On Sat, 20 Jun 2026 17:35:46 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The attrs parameter in damon_update_region_access_rate() is completely unused and should be removed.

As I replied to the same report, I will do the cleanup out of this series.

Thanks,
SJ

[...]

author maintainer
#8 lore raw

Re: [RFC PATCH v1.1 03/13] mm/damon/core: use damon_nr_accesses_mvsum() in __damos_valid_target()

In reply to [email protected]
Quoted 57 lines · On Sat, 20 Jun 2026 17:41:36 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] The new __damos_valid_target implementation uses damon_nr_accesses_mvsum(), which is vulnerable to time-of-check state desynchronization if ctx->next_aggregation_sis is updated asynchronously via kdamond_call(). This causes massive over-estimation of the target access frequency. --

commit 2274522ec6ea648db508697b0a1f57a8bf4e864d
Author: SeongJae Park <[email protected]>
Subject: mm/damon/core: use damon_nr_accesses_mvsum() in __damos_valid_target()

This commit replaces the direct read of r->nr_accesses_bp with a call to damon_nr_accesses_mvsum() inside __damos_valid_target(). The author notes that while execution is slightly more expensive, the function is simpler and more tolerant to errors.

Quoted 5 lines
mm/damon/core.c +0 -0
index af95783d3402a..ee4f0f0e583bd 100644

mm/damon/core.c static void kdamond_tune_intervals(struct damon_ctx *c) · line 2127

Quoted 10 lines
mm/damon/core.c +3 -2
@@ -2120,10 +2120,11 @@ static void kdamond_tune_intervals(struct damon_ctx *c)
 	damon_set_attrs(c, &new_attrs);
 }
 
-static bool __damos_valid_target(struct damon_region *r, struct damos *s)
+static bool __damos_valid_target(struct damon_region *r, struct damos *s,
+		struct damon_ctx *c)
 {
 	unsigned long sz;
-	unsigned int nr_accesses = r->nr_accesses_bp / 10000;
+	unsigned int nr_accesses = damon_nr_accesses_mvsum(r, c);

[Severity: High]
Could this lead to double-counting access scores if the context attributes are updated asynchronously?

In kdamond_fn(), when an aggregation interval finishes, pending API requests are processed via kdamond_call(ctx, false) right before kdamond_apply_schemes() is called. If a processed request triggers damon_set_attrs() (e.g., via sysfs), ctx->next_aggregation_sis is eagerly advanced to the end of the newly configured interval.

When __damos_valid_target() subsequently calls damon_nr_accesses_mvsum(), it calculates the time window based on ctx->next_aggregation_sis:

mm/damon/core.c:damon_nr_accesses_mvsum() {
    left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
    left_window_bp = mult_frac(left_window, 10000, window_len);
    return damon_mvsum(r->nr_accesses, r->last_nr_accesses, left_window_bp);
}

Because ctx->next_aggregation_sis was just advanced, left_window equals the full new window length, resulting in a left_window_bp of 10000.

Since damon_mvsum() assumes it is at the start of the window, it will add the unscaled r->last_nr_accesses to the current r->nr_accesses. Because the aggregation interval just finished, r->nr_accesses already holds the fully-accumulated access count. Adding last_nr_accesses effectively doubles the access score and could misclassify regions during target validation.

Quoted 3 lines

The pre-patch code avoided this by safely reading the decoupled r->nr_accesses_bp, which preserved the correct scaled value across kdamond_call() boundary transitions.

Nice finding. This should be a minor impact that persists for only one aggregation interval, but I think the issue is bettter to not introduced. I will scale r->last_nr_accesses together to avoid this issue in the next revision.

Thanks,
SJ

[...]

author maintainer
#12 lore raw

Re: [RFC PATCH v1.1 05/13] mm/damon/sysfs-schemes: use damon_nr_accesses_mvsum() for damo regions

In reply to [email protected]
Quoted 54 lines · On Sat, 20 Jun 2026 17:37:48 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] If a user configures sample_interval=0 and aggr_interval=0, the time difference calculation inside damon_nr_accesses_mvsum() underflows, resulting in a huge garbage value for nr_accesses. This corrupts sysfs outputs and erratically influences DAMOS operations. --

commit 2a77ab9c787a549b18af4699f5ffa8d3e4d60ca2
Author: SeongJae Park <[email protected]>

mm/damon/sysfs-schemes: use damon_nr_accesses_mvsum() for damo regions

This commit modifies the DAMON sysfs interface to calculate region accesses using damon_nr_accesses_mvsum() rather than a simple division.

Quoted 14 lines
mm/damon/sysfs-schemes.c +1 -1
index 329cfd0bbe9f3..e648b0f809332 100644
@@ -159,7 +159,7 @@ struct damon_sysfs_scheme_region {
 };
 
 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
-		struct damon_region *region)
+		struct damon_region *region, struct damon_ctx *ctx)
 {
 	struct damon_sysfs_scheme_region *sysfs_region = kmalloc_obj(*sysfs_region);
 

mm/damon/sysfs-schemes.c static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc( · line 170

Quoted 5 lines
mm/damon/sysfs-schemes.c +1 -1
@@ -167,7 +167,7 @@ static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
 		return NULL;
 	sysfs_region->kobj = (struct kobject){};
 	sysfs_region->ar = region->ar;
-	sysfs_region->nr_accesses = region->nr_accesses_bp / 10000;
+	sysfs_region->nr_accesses = damon_nr_accesses_mvsum(region, ctx);

[Severity: High]
Could this lead to an unsigned integer underflow if a user configures both sample_us and aggr_us to 0 via sysfs?

If a user configures sample_interval=0 and aggr_interval=0, the intervals bypass the validation in damon_set_attrs(). Inside kdamond_fn(), ctx->next_aggregation_sis is updated by adding 0 and never advances, but ctx->passed_sample_intervals continues to increment on every loop iteration.

When damon_nr_accesses_mvsum() is called, it calculates the difference:

mm/damon/core.c:damon_nr_accesses_mvsum() {
        ...
        left_window = ctx->next_aggregation_sis - ctx->passed_sample_intervals;
        ...
}

Because ctx->passed_sample_intervals quickly exceeds ctx->next_aggregation_sis, does this subtraction result in an unsigned integer underflow?

Quoted 5 lines

If left_window becomes a massive value, it appears it would propagate through mult_frac() and damon_mvsum() to yield a garbage value for nr_accesses. Since __damos_valid_target() evaluates scheme criteria using this value, could this cause DAMON to act on wildly inaccurate access scores and disrupt system stability?

Good finding. I will fix this by making damon_nr_accesses_mvsum() aware of this case.

Thanks,
SJ

[...]

author maintainer
#21 lore raw

Re: [RFC PATCH v1.1 11/13] mm/damon/core: remove nr_accesses_bp setups and updates

In reply to SeongJae Park
Quoted 46 lines · On Sat, 20 Jun 2026 10:45:52 -0700 SeongJae Park <[email protected]> wrote:
Quoted 44 lines · On Sat, 20 Jun 2026 17:34:30 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The attrs parameter in damon_update_region_access_rate() is completely unused after this patch. --

commit ecb338097e9822ecdcbfa5f88676102211ac76ca
Author: SeongJae Park <[email protected]>

mm/damon/core: remove nr_accesses_bp setups and updates

This commit removes the setups and updates of the nr_accesses_bp field in the DAMON core. The field is no longer used for any real purpose and has been replaced by a simpler function.

Quoted 4 lines
mm/damon/core.c +0 -0
index 53568a3c3ad9b..a41b66b26a472 100644

[ ... ]

Quoted 9 lines
mm/damon/core.c +0 -5
@@ -3779,18 +3774,6 @@ static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum,
 void damon_update_region_access_rate(struct damon_region *r, bool accessed,
 		struct damon_attrs *attrs)
 {
-	unsigned int len_window = 1;
-
-	/*
-	 * sample_interval can be zero, but cannot be larger than
-	 * aggr_interval, owing to validation of damon_set_attrs().

mm/damon/core.c static unsigned int damon_moving_sum(unsigned int mvsum, unsigned int nomvsum, · line 3779

Quoted 10 lines
mm/damon/core.c +0 -7
-	 */
-	if (attrs->sample_interval)
-		len_window = damon_max_nr_accesses(attrs);
-	r->nr_accesses_bp = damon_moving_sum(r->nr_accesses_bp,
-			r->last_nr_accesses * 10000, len_window,
-			accessed ? 10000 : 0);
-
 	if (accessed)
 		r->nr_accesses++;
 }

[Severity: Low]
Does this leave the attrs parameter completely unused in damon_update_region_access_rate()?

Quoted 6 lines
Quoted 3 lines

Since the removal of the damon_moving_sum() logic removes the only use of attrs inside this function, could we also drop the struct damon_attrs *attrs parameter from the signature and its callers to fully clean up the API?

Good finding. But not necessarily as a part of this series. I will add this as a todo.

I changed my mind. I will do this as part of this series in the next revision.

Thanks,
SJ

[...]