mm/damon: introduce data attributes only monitoring
Subsystems (4)
SJ Park
maintainercover mm/damon: introduce data attributes only monitoring
TL;DR: Introduce a way to get DAMON's best effort accuracy monitoring of user-demanding non-access data attributes.
Background
==========
DAMON was initially designed for only access monitoring. It turned out users want to get the information together with more data attributes. For example, some users want to know how much of a hot memory region belongs to huge pages or specific cgroups. Page level properties based monitoring was introduced with commit 626ffabe67c2 ("mm/damon: clarify trying vs applying on damos_stat kernel-doc comment") to fill the gap. Because it works only at snapshot level and snapshot capturing in the mode can induce high overhead, commit 45c49d9fd608 ("mm/damon/core:
introduce struct damon_probe") introduced data attributes monitoring.
Data attributes monitoring treats the attributes as only additional and subordinate information. Data access monitoring is always turned on, and regions are adjusted for best accuracy of the access information. In some cases, users may be primarily interested in the attributes more than the access. They might even not care about the access information at all. Because DAMON treats data accesses as the only primary information, such users cannot get high quality attributes information.
Design and Implementation
=========================
Introduce another way for treating data attributes as the primary information. Add 'weight' property to each data attribute probe. When any of the weights are set, the mode is enabled. Data access monitoring is completely turned off in the mode. For region adjustment, the weighted sum of probe hit counters is used instead of the nr_accesses.
Using the weights, users can specify to what attributes they are interested in to what degree. DAMON will adjust the regions and provide the best-effort quality monitoring that is optimized for the user demands.
Extend damon_operations for efficient use of probe hits. Update regions merge and kdamond main logic to support the new mode. Add a new struct field and a sysfs file for API callers and ABI users, respectively.
Test
====
On ~7 GiB memory idle system, run a simple AI-assisted program. The program allocates and faults 2 GiB anonymous pages. Then, it does nothing but wait until the user terminates it. Hence, the system ~2 GiB of anonymous pages with no active accesses.
Monitor the distribution of the anonymous pages using DAMON attributes monitoring mode, using DAMON user-space tool, damo [1].
$ sudo ./damo start --probe_filter allow anon
$ sudo ./damo report access --dont_merge_regions
heatmap: 00000000000000000000000000000000000000000000000399999995111111146666666666666666
# min/max temperatures: -2,470,000,000, -1,620,000,000, column size: 99.800 MiB
intervals: sample 5 ms aggr 100 ms (max access hz 200)
# <start> <size> <freq> <age> <probe hits>
0 4.000 KiB 79.840 MiB 0 hz 24.700 s 2
1 79.844 MiB 718.562 MiB 0 hz 24.700 s 8
2 798.406 MiB 793.148 MiB 0 hz 24.700 s 7
3 1.554 GiB 797.828 MiB 0 hz 24.700 s 7
4 2.333 GiB 794.668 MiB 0 hz 24.600 s 8
5 3.109 GiB 791.117 MiB 0 hz 24.500 s 0
6 3.882 GiB 785.312 MiB 0 hz 24 s 2
7 4.649 GiB 787.867 MiB 0 hz 16.200 s 6
8 5.418 GiB 784.477 MiB 0 hz 23.300 s 6
9 6.184 GiB 783.820 MiB 0 hz 18.200 s 9
10 6.950 GiB 797.730 MiB 0 hz 18.900 s 7
11 7.729 GiB 69.625 MiB 0 hz 18.900 s 0
memory bw estimate: 0 B per second
total size: 7.797 GiB
record DAMON intervals: sample 5 ms, aggr 100 msNote that the line after the line starting with "intervals:" is not provided by the current version of 'damo'. I manually added the legends line for easier understanding of these results.
Each of the 12 lines after the legend line shows the DAMON-found regions. Each line shows 1) index of the region, 2) start address of the region, 3) size of the region, 4) access frequency of the region, 5) age (how long the access frequency on the region was kept) of the region, and finally 6) the probe hit count.
Because data access is the primary information that adjusts region for, and there is only nearly zero access on the system, regions are naively adjusted with the same size. Still <probe hits> show different distribution of the anonymous pages, but it is obviously very rough information.
Switch to the attributes only mode and show how it changes the picture:
$ sudo ./damo tune --probe_filter allow anon --probe_weight 100
$ sudo ./damo report access --dont_merge_regions
heatmap: 88888888888888888889888999999889999999000004888888888888889999988888898888888888
# min/max temperatures: -4,430,000,000, 0, column size: 99.800 MiB
intervals: sample 5 ms aggr 100 ms (max access hz 200)
# <start> <size> <freq> <age> <probe hits>
0 4.000 KiB 60.445 MiB 0 hz 700 ms 0
1 60.449 MiB 1.363 MiB 0 hz 600 ms 18
2 61.812 MiB 144.000 KiB 0 hz 0 ns 1
3 61.953 MiB 1.922 MiB 0 hz 2.400 s 19
4 63.875 MiB 12.133 MiB 0 hz 200 ms 0
[...]
500 5.132 GiB 8.000 KiB 0 hz 2 m 15.800 s 20
501 5.132 GiB 8.000 KiB 0 hz 2 m 16.200 s 0
502 5.132 GiB 16.000 KiB 0 hz 2 m 16.900 s 20
503 5.132 GiB 24.000 KiB 0 hz 2 m 14.200 s 0
504 5.132 GiB 8.000 KiB 0 hz 2 m 14.900 s 20
[...]
923 7.534 GiB 126.637 MiB 0 hz 0 ns 6
924 7.658 GiB 252.000 KiB 0 hz 54.800 s 20
925 7.658 GiB 142.242 MiB 0 hz 300 ms 0
memory bw estimate: 0 B per second
total size: 7.797 GiB
record DAMON intervals: sample 5 ms, aggr 100 msAs expected, regions are adjusted to provide the best accurate picture for the anonymous pages distribution (<probe hits>). The region 0 (60.445 MiB memory from the address 4.000 KiB) has nearly zero anonymous pages. The region 1 (1.363 MiB memory from the address 60.449 MiB) is nearly full with anonymous pages. Region 500 (8 KiB memory from the address 5.132 GiB) is certainly two anonymous pages.
Future Work
===========
Attributes only monitoring disables access monitoring. We will enable that in future, by extending the supported attributes to include data accesses. This patch series, and the future work are parts of the ongoing project [2] for extending DAMON. The project aims to extend DAMON with primitives other than page table accessed bits such as AMD IBS, Intel PEBS, and Arm SPE, to provide more powerful and detailed information like per-CPUs/threads/reads/writes monitoring.
Patches Sequence
================
Patch 1 introduces damon_probe->weight for specifying the weights of each attribute. Patches 2-6 extends apply_probe() damon_ops callback to efficiently support the new mode. Patch 7 fixes wrong use of abs() in the regions merge code. Patch 8 extends regions merge function to work with probe hits in the mode. Patch 8 also introduces the function for detecting the mode enablement but always returns false, for safe and incremental changes. Patches 9 and 10 adds user parameters validation to prevent theoretical overflow of probe hits and the weighted sum. Patches 11-14 incrementally update kdamond_fn() to support the mode. Patch 15 completes the mode detection function implementation, so that the new mode really works. Patch 16 introduces a new sysfs file for ABI users. Finally, patches 17-19 respectively updates design, usage and ABI documents for the new feature and interfaces.
[1] https://github.com/damonitor/damo
[2] https://lore.kernel.org/[email protected]/
Changelog
=========
Changes from RFC v1.1
- RFC v1.1: https://lore.kernel.org/[email protected]
- Fix typos in comments.
- Fix wrong use of abs() with abs_diff().
- Prevent probe hits and its weighted sum overflow.
Changes from RFC
- RFC: https://lore.kernel.org/[email protected]
- Add kernel-doc comment for damon_probe->weight.
- Fix typos in kernel-doc, design and usage documents.
SJ Park (19):
mm/damon/core: introduce damon_probe->weight mm/damon/core: ask apply_probes() ops callback to set sampling address mm/damon/paddr: set samples in apply_probes() if requested mm/damon/core: ask apply_probe() to return max probe hits weighted sum mm/damon/core: implement damon_probe_hits_wsum() mm/damon/paddr: respect return_max_wsum
mm/damon/core: use abs_diff() instead of abs() mm/damon/core: extend merge function to work with probe hits mm/damon/core: disallow probe_hits overflow on attrs only monitoring mm/damon/core: validate params for probe hits weighted sum overflow mm/damon/core: disable access monitoring when probe weights are set mm/damon/core: set samples in apply_probes() if probe weights are set mm/damon/core: s/max_nr_accesses/max_merge_score/ in kdamond_fn() mm/damon/core: get merge threshold from probe hits when weights are
set
mm/damon/core: implement damon_has_probe_weight() mm/damon/sysfs: implement probe/weight file Docs/mm/damon/design: document attrs-only monitoring Docs/admin-guide/mm/damon/usage: document weight sysfs file Docs/ABI/damon: document probe weight file
.../ABI/testing/sysfs-kernel-mm-damon | 6 + Documentation/admin-guide/mm/damon/usage.rst | 11 +- Documentation/mm/damon/design.rst | 25 ++++ include/linux/damon.h | 12 +- mm/damon/core.c | 139 +++++++++++++++--- mm/damon/paddr.c | 11 +- mm/damon/sysfs.c | 25 ++++ mm/damon/tests/core-kunit.h | 13 +- 8 files changed, 217 insertions(+), 25 deletions(-)
base-commit: a66302e2d7c338da29ec97fd90065d1251af8c31
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 1/19 mm/damon/core: introduce damon_probe->weight
Add a new field, weight to damon_probe struct. The field is used to specify the degree of the API caller's interest to the data attribute of the probe.
--- include/linux/damon.h | 2 ++ mm/damon/core.c | 3 +++ 2 files changed, 5 insertions(+)
include/linux/damon.h +2 -0
@@ -760,10 +760,12 @@ struct damon_filter {/** * struct damon_probe - Data region attribute probe. * +* @weight: Relative priority of the attribute for this probe. * @filters: Filters for assessing if a given region is for this probe. * @list: Siblings list. */ struct damon_probe { +unsigned int weight;struct list_head filters;struct list_head list; };
mm/damon/core.c +3 -0
@@ -166,6 +166,7 @@ struct damon_probe *damon_new_probe(void) p =kmalloc_obj (*p);if (!p)return NULL ; + p->weight =0 ;INIT_LIST_HEAD (&p->filters);INIT_LIST_HEAD (&p->list);return p;
@@ -1658,6 +1659,7 @@ static int damon_commit_probes(struct damon_ctx *dst, struct damon_ctx *src)damon_for_each_probe_safe (dst_probe, next, dst) { src_probe =damon_nth_probe (i++, src);if (src_probe) { + dst_probe->weight = src_probe->weight; err =damon_commit_filters (dst_probe, src_probe);if (err)return err;
@@ -1674,6 +1676,7 @@ static int damon_commit_probes(struct damon_ctx *dst, struct damon_ctx *src)if (!new_probe)return -ENOMEM ;damon_add_probe (dst, new_probe); + new_probe->weight = src_probe->weight; err =damon_commit_filters (new_probe, src_probe);if (err)return err;
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 2/19 mm/damon/core: ask apply_probes() ops callback to set sampling address
In reply to SJ Parkprepare_access_checks() DAMON ops callback sets the monitoring sampling address per region. In future, DAMON will be able to call only apply_probes(). In this case, applyy_probes() may need to do the sampling address setup, to minimize unnecessary regions iteration. Update the protocol for the request.
--- include/linux/damon.h | 5 +++-- mm/damon/core.c | 2 +- mm/damon/paddr.c | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-)
include/linux/damon.h +3 -2
@@ -647,7 +647,8 @@ enum damon_ops_id {* It should also return max number of observed accesses that made as a result * of its update. The value will be used for regions adjustment threshold. * @apply_probes should apply the data attribute probes to each region and -* accordingly update the probe hits counter of the region. +* accordingly update the probe hits counter of the region. It should also +* &set sampling_addr of each region if ``set_samples`` is true. * @get_scheme_score should return the priority score of a region for a scheme * as an integer in [0, &DAMOS_MAX_SCORE]. * @apply_scheme is called from @kdamond when a region for user provided
@@ -665,7 +666,7 @@ struct damon_operations {void (*update)(struct damon_ctx *context);void (*prepare_access_checks)(struct damon_ctx *context);unsigned int (*check_accesses)(struct damon_ctx *context); -void (*apply_probes)(struct damon_ctx *context); +void (*apply_probes)(struct damon_ctx *context,bool set_samples);int (*get_scheme_score)(struct damon_ctx *context,struct damon_region *r,struct damos *scheme); unsigned long (*apply_scheme)(struct damon_ctx *context,
mm/damon/core.c +1 -1
@@ -3692,7 +3692,7 @@ static int kdamond_fn(void *data)if (ctx->ops.check_accesses) max_nr_accesses = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx); + ctx->ops.apply_probes (ctx, false);if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {
mm/damon/paddr.c +1 -1
@@ -166,7 +166,7 @@ static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,return pass; } -static void damon_pa_apply_probes (struct damon_ctx *ctx) +static void damon_pa_apply_probes (struct damon_ctx *ctx,bool set_samples) {struct damon_target *t;struct damon_region *r;
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 02/19] mm/damon/core: ask apply_probes() ops callback to set sampling address
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Medium] The `damon_pa_apply_probes()` callback ignores the newly added `set_samples` parameter…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] The damon_pa_apply_probes() callback ignores the newly added set_samples parameter, violating the updated API contract documented in the header.
- [Low] The use of &set in the kernel-doc comment will generate a warning during the documentation build.
--
--- Patch [2]: [RFC PATCH v1.2 02/19] mm/damon/core: ask apply_probes() ops callback to set sampling address --- commit d206ad52f1017ca79add3bb060530dc8e4e317fd
Author: SJ Park <[email protected]>
mm/damon/core: ask apply_probes() ops callback to set sampling address
This patch updates the apply_probes() DAMON ops callback by adding a set_samples boolean argument. This allows the callback to optionally handle sampling address setup to minimize unnecessary region iteration.
include/linux/damon.h enum damon_ops_id { · line 651
Quoted 11 lines
include/linux/damon.h +2
-1@@ -647,7 +647,8 @@ enum damon_ops_id {* It should also return max number of observed accesses that made as a result * of its update. The value will be used for regions adjustment threshold. * @apply_probes should apply the data attribute probes to each region and -* accordingly update the probe hits counter of the region. +* accordingly update the probe hits counter of the region. It should also +* &set sampling_addr of each region if ``set_samples`` is true.
[Severity: Low]
This isn't a bug, but will this use of '&set' in include/linux/damon.h generate a kernel-doc build warning?
The '&' prefix in kernel-doc is strictly reserved for referencing structures, enumerations, typedefs, or unions. Using it to emphasize the verb 'set' is invalid syntax.
[ ... ]
mm/damon/paddr.c static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio, · line 172
Quoted 13 lines
mm/damon/paddr.c +1
-1@@ -166,7 +166,7 @@ static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,return pass; } -static void damon_pa_apply_probes (struct damon_ctx *ctx) +static void damon_pa_apply_probes (struct damon_ctx *ctx,bool set_samples) {struct damon_target *t;struct damon_region *r;
[Severity: Medium]
Does damon_pa_apply_probes() in mm/damon/paddr.c need to use the new set_samples parameter?
According to the updated API documentation, this callback should conditionally set r->sampling_addr if set_samples is true. However, the parameter appears to be ignored in the function body in this commit, which could lead to incorrect or stale sampling if a future caller passes true.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
SJ Park
maintainerRe: [RFC PATCH v1.2 02/19] mm/damon/core: ask apply_probes() ops callback to set sampling address
Quoted 31 lines · On Thu, 09 Jul 2026 14:16:46 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] Thedamon_pa_apply_probes()callback ignores the newly addedset_samplesparameter, violating the updated API contract documented in the header.
- [Low] The use of&setin the kernel-doc comment will generate a warning during the documentation build.
----- Patch [2]: [RFC PATCH v1.2 02/19]
mm/damon/core: askapply_probes()ops callback to set sampling address --- commitd206ad52f1017ca79add3bb060530dc8e4e317fd
Author: SJ Park <[email protected]>
mm/damon/core: askapply_probes()ops callback to set sampling addressThis patch updates the
apply_probes()DAMON ops callback by adding aset_samplesboolean argument. This allows the callback to optionally handle sampling address setup to minimize unnecessary region iteration.include/linux/damon.h enum damon_ops_id { · line 651
Quoted 11 lines
include/linux/damon.h +2
-1@@ -647,7 +647,8 @@ enum damon_ops_id {* It should also return max number of observed accesses that made as a result * of its update. The value will be used for regions adjustment threshold. * @apply_probes should apply the data attribute probes to each region and -* accordingly update the probe hits counter of the region. +* accordingly update the probe hits counter of the region. It should also +* &set sampling_addr of each region if ``set_samples`` is true. [Severity: Low]
This isn't a bug, but will this use of '&set' ininclude/linux/damon.hgenerate a kernel-doc build warning?
Quoted 3 lines
The '&' prefix in kernel-doc is strictly reserved for referencing structures, enumerations, typedefs, or unions. Using it to emphasize the verb 'set' is invalid syntax.
Good finding. It is a typo. I will fix in the next revision.
Quoted 21 lines
[ ... ]
mm/damon/paddr.c static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio, · line 172
Quoted 13 lines
mm/damon/paddr.c +1
-1@@ -166,7 +166,7 @@ static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,return pass; } -static void damon_pa_apply_probes (struct damon_ctx *ctx) +static void damon_pa_apply_probes (struct damon_ctx *ctx,bool set_samples) {struct damon_target *t;struct damon_region *r;[Severity: Medium]
Doesdamon_pa_apply_probes()inmm/damon/paddr.cneed to use the newset_samplesparameter?
Quoted 4 lines
According to the updated API documentation, this callback should conditionally set
r->sampling_addrifset_samplesis true. However, the parameter appears to be ignored in the function body in this commit, which could lead to incorrect or stale sampling if a future caller passes true.
Yes, the later patch in this series will do that.
Quoted 3 lines
Signature · 2 lines
-- Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Thanks,
SJ
SJ Park
maintainerRFC PATCH 3/19 mm/damon/paddr: set samples in apply_probes() if requested
In reply to SJ Parkapply_probe() callback implementation in DAMON_PADDR is ignoring set_samples parameter. Respect it.
--- mm/damon/paddr.c | 4 ++++ 1 file changed, 4 insertions(+)
mm/damon/paddr.c +4 -0
@@ -178,6 +178,10 @@ static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples)phys_addr_t pa;struct folio *folio; +if (set_samples) + r->sampling_addr =damon_rand (ctx, r->ar.start, + r->ar.end); + pa =damon_pa_phys_addr (r->sampling_addr, ctx->addr_unit); folio =damon_get_folio (PHYS_PFN (pa));
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 03/19] mm/damon/paddr: set samples in apply_probes() if requested
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Integer overflow in r->probe_hits[] counter when aggr_samples exceeds 255. --
--- Patch [3]: [RFC PATCH v1.2 03/19] mm/damon/paddr: set samples in apply_probes() if requested --- commit 81ba2fab5bb28d260739f7b8c81129066d602897
Author: SJ Park <[email protected]>
mm/damon/paddr: set samples in apply_probes() if requested
This commit updates the apply_probe() callback implementation in DAMON_PADDR so that it respects the set_samples parameter.
Quoted 5 lines
mm/damon/paddr.c +0
-0
mm/damon/paddr.c static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples) · line 187
Quoted 10 lines
mm/damon/paddr.c +4
-0@@ -178,6 +178,10 @@ static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples)phys_addr_t pa;struct folio *folio; +if (set_samples) + r->sampling_addr =damon_rand (ctx, r->ar.start, + r->ar.end); + pa =damon_pa_phys_addr (r->sampling_addr, ctx->addr_unit); folio =damon_get_folio (PHYS_PFN (pa));
[Severity: High]
This is a pre-existing issue, but does this code overflow probe_hits[]?
Looking at include/linux/damon.h, probe_hits is defined as an unsigned char array:
struct damon_region {
...
unsigned char probe_hits[DAMON_MAX_PROBES];
...
};Immediately following the code in this diff, damon_pa_apply_probes() unconditionally increments the counter:
folio = damon_get_folio(PHYS_PFN(pa));
damon_for_each_probe(p, ctx) {
if (damon_pa_filter_pass(pa, folio, p))
r->probe_hits[i]++;
i++;
}If a user configures DAMON via sysfs with an aggr_interval and sample_interval ratio that yields more than 255 samples per aggregation interval (for example, aggr_interval=100000us and sample_interval=100us), this counter will silently wrap around.
Could this cause heavily accessed regions to wrap to a small number and appear cold, potentially leading DAMOS to make incorrect memory eviction or migration decisions?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
SJ Park
maintainerRe: [RFC PATCH v1.2 03/19] mm/damon/paddr: set samples in apply_probes() if requested
Quoted 53 lines · On Thu, 09 Jul 2026 14:21:02 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Integer overflow inr->probe_hits[]counter whenaggr_samplesexceeds 255. ----- Patch [3]: [RFC PATCH v1.2 03/19]
mm/damon/paddr: set samples inapply_probes()if requested --- commit81ba2fab5bb28d260739f7b8c81129066d602897
Author: SJ Park <[email protected]>
mm/damon/paddr: set samples inapply_probes()if requestedThis commit updates the
apply_probe()callback implementation inDAMON_PADDRso that it respects theset_samplesparameter.Quoted 5 lines
mm/damon/paddr.c +0
-0mm/damon/paddr.c static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples) · line 187
Quoted 10 lines
mm/damon/paddr.c +4
-0@@ -178,6 +178,10 @@ static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples)phys_addr_t pa;struct folio *folio; +if (set_samples) + r->sampling_addr =damon_rand (ctx, r->ar.start, + r->ar.end); + pa =damon_pa_phys_addr (r->sampling_addr, ctx->addr_unit); folio =damon_get_folio (PHYS_PFN (pa));[Severity: High]
This is a pre-existing issue, but does this code overflow probe_hits[]?Looking at
include/linux/damon.h,probe_hitsis defined as an unsigned char array:struct damon_region { ... unsigned char probe_hits[DAMON_MAX_PROBES]; ... };Immediately following the code in this diff,
damon_pa_apply_probes()unconditionally increments the counter:folio = damon_get_folio(PHYS_PFN(pa)); damon_for_each_probe(p, ctx) { if (damon_pa_filter_pass(pa, folio, p)) r->probe_hits[i]++; i++; }
Quoted 8 lines
If a user configures DAMON via sysfs with an
aggr_intervalandsample_intervalratio that yields more than 255 samples per aggregation interval (for example, aggr_interval=100000us and sample_interval=100us), this counter will silently wrap around.Could this cause heavily accessed regions to wrap to a small number and appear cold, potentially leading DAMOS to make incorrect memory eviction or migration decisions?
Known low priority issue.
Quoted 3 lines
Signature · 2 lines
-- Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Thanks,
SJ
SJ Park
maintainerRFC PATCH 4/19 mm/damon/core: ask apply_probe() to return max probe hits weighted sum
In reply to SJ Parkcheck_accesses() DAMON ops callback returns the maximum nr_accesses of regions. DAMON core uses it to calculate a reasonable region merge threshold. The core will need to adjust regions for not nr_accesses but probe hits weighted sum in future. For that, the core needs to know the maximum weighted sum of the regions. Update the protocol for the task.
--- include/linux/damon.h | 7 +++++-- mm/damon/core.c | 2 +- mm/damon/paddr.c | 4 +++- 3 files changed, 9 insertions(+), 4 deletions(-)
include/linux/damon.h +5 -2
@@ -648,7 +648,9 @@ enum damon_ops_id {* of its update. The value will be used for regions adjustment threshold. * @apply_probes should apply the data attribute probes to each region and * accordingly update the probe hits counter of the region. It should also -* &set sampling_addr of each region if ``set_samples`` is true. +* &set sampling_addr of each region if ``set_samples`` is true. It should +* also return maximum probe hits weighted sum of regions if +* ``return_max_wsum`` is true. * @get_scheme_score should return the priority score of a region for a scheme * as an integer in [0, &DAMOS_MAX_SCORE]. * @apply_scheme is called from @kdamond when a region for user provided
@@ -666,7 +668,8 @@ struct damon_operations {void (*update)(struct damon_ctx *context);void (*prepare_access_checks)(struct damon_ctx *context);unsigned int (*check_accesses)(struct damon_ctx *context); -void (*apply_probes)(struct damon_ctx *context,bool set_samples); +unsigned int (*apply_probes)(struct damon_ctx *context, +bool set_samples,bool return_max_wsum);int (*get_scheme_score)(struct damon_ctx *context,struct damon_region *r,struct damos *scheme); unsigned long (*apply_scheme)(struct damon_ctx *context,
mm/damon/core.c +1 -1
@@ -3692,7 +3692,7 @@ static int kdamond_fn(void *data)if (ctx->ops.check_accesses) max_nr_accesses = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, false); + ctx->ops.apply_probes (ctx, false, false);if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {
mm/damon/paddr.c +3 -1
@@ -166,7 +166,8 @@ static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,return pass; } -static void damon_pa_apply_probes (struct damon_ctx *ctx,bool set_samples) +static unsigned int damon_pa_apply_probes (struct damon_ctx *ctx, +bool set_samples,bool return_max_wsum) {struct damon_target *t;struct damon_region *r;
@@ -194,6 +195,7 @@ static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples)folio_put (folio); } } +return 0 ; }/*
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 04/19] mm/damon/core: ask apply_probe() to return max probe hits weighted sum
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The `damon_pa_apply_probes` callback unconditionally returns 0 instead of computing and…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The damon_pa_apply_probes callback unconditionally returns 0 instead of computing and returning the maximum probe hits weighted sum when return_max_wsum is true, violating the updated API contract. --
--- Patch [4]: [RFC PATCH v1.2 04/19] mm/damon/core: ask apply_probe() to return max probe hits weighted sum --- commit ed82d24ec75fdb639533062e293614cb1cebe866
Author: SJ Park <[email protected]>
mm/damon/core: ask apply_probe() to return max probe hits weighted sum
This commit updates the apply_probes() callback protocol in the DAMON operations to optionally return the maximum probe hits weighted sum. This value is intended to help the core layer adjust regions in the future.
Quoted 15 lines
include/linux/damon.h +3
-1@@ -648,7 +648,9 @@ enum damon_ops_id {* of its update. The value will be used for regions adjustment threshold. * @apply_probes should apply the data attribute probes to each region and * accordingly update the probe hits counter of the region. It should also -* &set sampling_addr of each region if ``set_samples`` is true. +* &set sampling_addr of each region if ``set_samples`` is true. It should +* also return maximum probe hits weighted sum of regions if +* ``return_max_wsum`` is true. * @get_scheme_score should return the priority score of a region for a scheme * as an integer in [0, &DAMOS_MAX_SCORE]. * @apply_scheme is called from @kdamond when a region for user provided
[ ... ]
Quoted 15 lines
mm/damon/paddr.c +2
-1@@ -166,7 +166,8 @@ static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,return pass; } -static void damon_pa_apply_probes (struct damon_ctx *ctx,bool set_samples) +static unsigned int damon_pa_apply_probes (struct damon_ctx *ctx, +bool set_samples,bool return_max_wsum) {struct damon_target *t;struct damon_region *r;
mm/damon/paddr.c static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples) · line 198
Quoted 4 lines
mm/damon/paddr.c +1
-0@@ -194,6 +195,7 @@ static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples)folio_put (folio); } } +return 0 ;
[Severity: Medium]
The kernel-doc for apply_probes states it should return the maximum probe hits weighted sum if return_max_wsum is true.
However, damon_pa_apply_probes() unconditionally returns 0 here without computing the weighted sum.
Will this cause the core layer to receive an incorrect threshold of 0 when it starts passing return_max_wsum = true in the future?
Quoted 1 line
mm/damon/paddr.c +0
-0}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
SJ Park
maintainerRe: [RFC PATCH v1.2 04/19] mm/damon/core: ask apply_probe() to return max probe hits weighted sum
Quoted 56 lines · On Thu, 09 Jul 2026 14:16:38 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Thedamon_pa_apply_probescallback unconditionally returns 0 instead of computing and returning the maximum probe hits weighted sum whenreturn_max_wsumis true, violating the updated API contract. ----- Patch [4]: [RFC PATCH v1.2 04/19]
mm/damon/core: askapply_probe()to return max probe hits weighted sum --- commited82d24ec75fdb639533062e293614cb1cebe866
Author: SJ Park <[email protected]>
mm/damon/core: askapply_probe()to return max probe hits weighted sumThis commit updates the
apply_probes()callback protocol in the DAMON operations to optionally return the maximum probe hits weighted sum. This value is intended to help the core layer adjust regions in the future.Quoted 15 lines
include/linux/damon.h +3
-1@@ -648,7 +648,9 @@ enum damon_ops_id {* of its update. The value will be used for regions adjustment threshold. * @apply_probes should apply the data attribute probes to each region and * accordingly update the probe hits counter of the region. It should also -* &set sampling_addr of each region if ``set_samples`` is true. +* &set sampling_addr of each region if ``set_samples`` is true. It should +* also return maximum probe hits weighted sum of regions if +* ``return_max_wsum`` is true. * @get_scheme_score should return the priority score of a region for a scheme * as an integer in [0, &DAMOS_MAX_SCORE]. * @apply_scheme is called from @kdamond when a region for user provided [ ... ]
Quoted 15 lines
mm/damon/paddr.c +2
-1@@ -166,7 +166,8 @@ static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio,return pass; } -static void damon_pa_apply_probes (struct damon_ctx *ctx,bool set_samples) +static unsigned int damon_pa_apply_probes (struct damon_ctx *ctx, +bool set_samples,bool return_max_wsum) {struct damon_target *t;struct damon_region *r;mm/damon/paddr.c static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples) · line 198
Quoted 4 lines
mm/damon/paddr.c +1
-0@@ -194,6 +195,7 @@ static void damon_pa_apply_probes(struct damon_ctx *ctx, bool set_samples)folio_put (folio); } } +return 0 ;[Severity: Medium]
The kernel-doc forapply_probesstates it should return the maximum probe hits weighted sum ifreturn_max_wsumis true.
Quoted 5 lines
However,
damon_pa_apply_probes()unconditionally returns 0 here without computing the weighted sum.Will this cause the core layer to receive an incorrect threshold of 0 when it starts passing
return_max_wsum= true in the future?
This is intentional. The later patch in this series will implement it.
Quoted 5 lines
Quoted 2 lines
mm/damon/paddr.c +0
-0}Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
Thanks,
SJ
SJ Park
maintainerRFC PATCH 5/19 mm/damon/core: implement damon_probe_hits_wsum()
In reply to SJ ParkWhen damon_probe->weight is set, the weighted sum of probe hits will be useful. It will be useful for not only the users but also DAMON internal logics like regions merging. Implement a function for calculating it.
--- include/linux/damon.h | 2 ++ mm/damon/core.c | 24 ++++++++++++++++++++++++ 2 files changed, 26 insertions(+)
include/linux/damon.h +2 -0
@@ -1012,6 +1012,8 @@ 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, +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 +24 -0
@@ -393,6 +393,30 @@ static bool damon_is_last_region(struct damon_region *r,return list_is_last (&r->list, &t->regions_list); } +/** +* 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. +* @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, +struct damon_ctx *ctx) +{ +struct damon_probe *probe; +unsigned int sum =0 ; +int i =0 ; + +damon_for_each_probe (probe, ctx) { +if (last) + sum += r->last_probe_hits[i++] * probe->weight; +else + sum += r->probe_hits[i++] * probe->weight; + } +return sum; +} +/* * Check whether a region is intersecting an address range *
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 6/19 mm/damon/paddr: respect return_max_wsum
In reply to SJ Parkapply_probes() ops implementation in DAMON_PADDR is ignoring return_max_wsum. Respect it.
--- mm/damon/paddr.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
mm/damon/paddr.c +5 -2
@@ -172,6 +172,7 @@ static unsigned int damon_pa_apply_probes(struct damon_ctx *ctx,struct damon_target *t;struct damon_region *r;struct damon_probe *p; +unsigned int max_wsum =0 ;damon_for_each_target (t, ctx) {damon_for_each_region (r, t) {
@@ -182,7 +183,6 @@ static unsigned int damon_pa_apply_probes(struct damon_ctx *ctx,if (set_samples) r->sampling_addr =damon_rand (ctx, r->ar.start, r->ar.end); - pa =damon_pa_phys_addr (r->sampling_addr, ctx->addr_unit); folio =damon_get_folio (PHYS_PFN (pa));
@@ -193,9 +193,12 @@ static unsigned int damon_pa_apply_probes(struct damon_ctx *ctx, }if (folio)folio_put (folio); +if (return_max_wsum) + max_wsum =max (damon_probe_hits_wsum (r, false, + ctx), max_wsum); } } -return 0 ; +return max_wsum; }/*
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 7/19 mm/damon/core: use abs_diff() instead of abs()
In reply to SJ ParkUse of abs() in damon_merge_regions_of() could cause a silent integer overflow since the macro casts unsigned int to signed int. It is unlikely to have such a large value for nr_accesses. Even though it happens, the user impact is just degraded monitoring results. Users showing bad monitoring results for weird setup is quite trivial. But the code is obviously wrong. Use abs_diff() instead.
The issue was discovered [1] by Sashiko.
[1] https://lore.kernel.org/[email protected]/
--- mm/damon/core.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
mm/damon/core.c +2 -2
@@ -3261,7 +3261,7 @@ 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) { -if (abs (r->nr_accesses - r->last_nr_accesses) > thres) +if (abs_diff (r->nr_accesses, r->last_nr_accesses) > thres) r->age =0 ;else if ((r->nr_accesses ==0 ) != (r->last_nr_accesses ==0 )) r->age =0 ;
@@ -3269,7 +3269,7 @@ static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, r->age++;if (prev && prev->ar.end == r->ar.start && -abs (prev->nr_accesses - r->nr_accesses) <= thres && +abs_diff (prev->nr_accesses, r->nr_accesses) <= thres &&damon_sz_region (prev) +damon_sz_region (r) <= sz_limit)damon_merge_two_regions (t, prev, r);else
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 07/19] mm/damon/core: use abs_diff() instead of abs()
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
Pre-existing issues:
- [High] Potential integer overflow in weighted average calculations within damon_merge_two_regions() on 32-bit architectures.
- [High] Infinite loop in kdamond_merge_regions() causing soft lockup when aggr_interval is large.
- [High] Multiple erroneous r->age updates per aggregation interval during region merging.
--
--- Patch [7]: [RFC PATCH v1.2 07/19] mm/damon/core: use abs_diff() instead of abs() --- commit f6ab818d018c3ba8c682c6e198e98ba7a8a69b83
Author: SJ Park <[email protected]>
mm/damon/core: use abs_diff() instead of abs()
Use of abs() in damon_merge_regions_of() could cause a silent integer overflow. This patch replaces it with abs_diff().
Quoted 14 lines
mm/damon/core.c +1
-1@@ -3261,7 +3261,7 @@ 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) { -if (abs (r->nr_accesses - r->last_nr_accesses) > thres) +if (abs_diff (r->nr_accesses, r->last_nr_accesses) > thres) r->age =0 ;else if ((r->nr_accesses ==0 ) != (r->last_nr_accesses ==0 )) r->age =0 ;
mm/damon/core.c static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, · line 3269
Quoted 1 line
mm/damon/core.c +0
-0@@ -3269,7 +3269,7 @@ static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, r->age++;
[Severity: High]
This isn't a bug introduced by this patch, but does this logic apply multiple age updates per aggregation interval if damon_merge_regions_of() is called multiple times?
The function damon_merge_regions_of() is called inside a do-while loop in kdamond_merge_regions():
mm/damon/core.c:kdamond_merge_regions() {
...
do {
nr_regions = 0;
damon_for_each_target(t, c) {
damon_merge_regions_of(t, threshold, sz_limit);
nr_regions += damon_nr_regions(t);
}
threshold = max(1, threshold * 2);
} while (nr_regions > c->attrs.max_nr_regions &&
threshold / 2 < max_thres);
...
}Since last_nr_accesses isn't updated until after this loop completes, if merging fails to reduce nr_regions sufficiently, the loop repeats. Could this cause the same access counts to be evaluated repeatedly, artificially aging or resetting memory multiple times within a single aggregation interval?
[Severity: High]
This is a pre-existing issue, but can the loop in kdamond_merge_regions() run infinitely if max_thres is extremely large?
Looking at the same snippet above, max_thres is an unsigned int calculated from aggr_interval. If max_thres is >= 2,147,483,648 (for example, due to a large aggr_interval), doubling threshold will eventually overflow a 32-bit unsigned int to 0.
Then max(1, 0) resets it to 1. Since threshold / 2 (which is 0) will always be less than max_thres, could this cause a soft lockup of the kdamond thread?
mm/damon/core.c static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, · line 3274
Quoted 6 lines
mm/damon/core.c +1
-1if (prev && prev->ar.end == r->ar.start && -abs (prev->nr_accesses - r->nr_accesses) <= thres && +abs_diff (prev->nr_accesses, r->nr_accesses) <= thres &&damon_sz_region (prev) +damon_sz_region (r) <= sz_limit)damon_merge_two_regions (t, prev, r);
[Severity: High]
This is a pre-existing issue, but can the size-weighted average calculations in damon_merge_two_regions() overflow on 32-bit architectures?
mm/damon/core.c:damon_merge_two_regions() {
...
unsigned long sz_l = damon_sz_region(l), sz_r = damon_sz_region(r);
l->nr_accesses = (l->nr_accesses * sz_l + r->nr_accesses * sz_r) /
(sz_l + sz_r);
l->age = (l->age * sz_l + r->age * sz_r) / (sz_l + sz_r);
...
}If sz_l is large (e.g., 100 MB or ~104,857,600 bytes) and nr_accesses or age is moderate (e.g., 50), their product (~5.24 billion) exceeds the maximum 32-bit unsigned integer value (~4.29 billion).
Since unsigned long is 32 bits on those systems, could this silently overflow and irreversibly corrupt the merged region's statistics?
Quoted 2 lines
mm/damon/core.c +0
-0else prev = r;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
SJ Park
maintainerRe: [RFC PATCH v1.2 07/19] mm/damon/core: use abs_diff() instead of abs()
Quoted 57 lines · On Thu, 09 Jul 2026 14:32:09 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
Pre-existing issues:
- [High] Potential integer overflow in weighted average calculations withindamon_merge_two_regions()on 32-bit architectures.
- [High] Infinite loop inkdamond_merge_regions()causing soft lockup whenaggr_intervalis large.
- [High] Multiple erroneousr->ageupdates per aggregation interval during region merging.
----- Patch [7]: [RFC PATCH v1.2 07/19]
mm/damon/core: useabs_diff()instead ofabs()--- commitf6ab818d018c3ba8c682c6e198e98ba7a8a69b83
Author: SJ Park <[email protected]>
mm/damon/core: useabs_diff()instead ofabs()Use of
abs()indamon_merge_regions_of()could cause a silent integer overflow. This patch replaces it withabs_diff().Quoted 14 lines
mm/damon/core.c +1
-1@@ -3261,7 +3261,7 @@ 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) { -if (abs (r->nr_accesses - r->last_nr_accesses) > thres) +if (abs_diff (r->nr_accesses, r->last_nr_accesses) > thres) r->age =0 ;else if ((r->nr_accesses ==0 ) != (r->last_nr_accesses ==0 )) r->age =0 ;mm/damon/core.c static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, · line 3269
Quoted 1 line
mm/damon/core.c +0
-0@@ -3269,7 +3269,7 @@ static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, r->age++;[Severity: High]
This isn't a bug introduced by this patch, but does this logic apply multiple age updates per aggregation interval ifdamon_merge_regions_of()is called multiple times?The function
damon_merge_regions_of()is called inside a do-while loop inkdamond_merge_regions():mm/damon/core.c:kdamond_merge_regions() { ... do { nr_regions = 0; damon_for_each_target(t, c) { damon_merge_regions_of(t, threshold, sz_limit); nr_regions += damon_nr_regions(t); } threshold = max(1, threshold * 2); } while (nr_regions > c->attrs.max_nr_regions && threshold / 2 < max_thres); ... }
Quoted 4 lines
Since
last_nr_accessesisn't updated until after this loop completes, if merging fails to reducenr_regionssufficiently, the loop repeats. Could this cause the same access counts to be evaluated repeatedly, artificially aging or resetting memory multiple times within a single aggregation interval?
Sounds making sense. Apparently not fit to be fixed in this series, though. I will further check and separately work on this.
Quoted 14 lines
[Severity: High]
This is a pre-existing issue, but can the loop inkdamond_merge_regions()run infinitely ifmax_thresis extremely large?Looking at the same snippet above,
max_thresis an unsigned int calculated fromaggr_interval. Ifmax_thresis >= 2,147,483,648 (for example, due to a largeaggr_interval), doubling threshold will eventually overflow a 32-bit unsigned int to 0.Then
max(1, 0)resets it to 1. Since threshold / 2 (which is 0) will always be less thanmax_thres, could this cause a soft lockup of the kdamond thread?Quoted 1 line
Quoted 5 lines
mm/damon/core.c static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, · line 3274
Quoted 5 lines
mm/damon/core.c +1
-1if (prev && prev->ar.end == r->ar.start && -abs (prev->nr_accesses - r->nr_accesses) <= thres && +abs_diff (prev->nr_accesses, r->nr_accesses) <= thres &&damon_sz_region (prev) +damon_sz_region (r) <= sz_limit)damon_merge_two_regions (t, prev, r);
Seems a good finding. Not related to this series, as Sashiko also says. I will further check separatelt work on this.
Quoted 15 lines
[Severity: High]
This is a pre-existing issue, but can the size-weighted average calculations indamon_merge_two_regions()overflow on 32-bit architectures?mm/damon/core.c:damon_merge_two_regions() { ... unsigned long sz_l = damon_sz_region(l), sz_r = damon_sz_region(r); l->nr_accesses = (l->nr_accesses * sz_l + r->nr_accesses * sz_r) / (sz_l + sz_r); l->age = (l->age * sz_l + r->age * sz_r) / (sz_l + sz_r); ... }
Quoted 6 lines
If
sz_lis large (e.g., 100 MB or ~104,857,600 bytes) andnr_accessesor age is moderate (e.g., 50), their product (~5.24 billion) exceeds the maximum 32-bit unsigned integer value (~4.29 billion).Since unsigned long is 32 bits on those systems, could this silently overflow and irreversibly corrupt the merged region's statistics?
Known low priority issue.
Quoted 6 lines
Quoted 3 lines
mm/damon/core.c +0
-0else prev = r;Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Thanks,
SJ
SJ Park
maintainerRFC PATCH 8/19 mm/damon/core: extend merge function to work with probe hits
In reply to SJ ParkWhen probe weights are set, users may want DAMON monitoring results to be optimized for the weights. For that, regions adjustment should work for the weighted sum of probe hits. Extend damon_merge_regions_of() to detect if the weights are set, and work with probe hits in the case.
The weights setup detection function is incomplete. It always returns false. It is intentional, so that more changes to completely support weights can be made in an incremental but safe way. Until the function is completed, all changes depend on it is no-op, so DAMON works in the current mode.
--- mm/damon/core.c | 49 +++++++++++++++++++++++++++++-------- mm/damon/tests/core-kunit.h | 13 ++++++++-- 2 files changed, 50 insertions(+), 12 deletions(-)
mm/damon/core.c +39 -10
@@ -209,6 +209,11 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)return NULL ; } +static bool damon_has_probe_weights (struct damon_ctx *c) +{ +return false; +} +/* * damon_mvsum() - Returns pseudo moving sum value for a time window. * @current_nr: The value of the current aggregation window.
@@ -3248,6 +3253,16 @@ static void damon_merge_two_regions(struct damon_target *t,damon_destroy_region (r, t); } +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); +if (last) +return r->last_nr_accesses; +return r->nr_accesses; +} +/* * Merge adjacent regions having similar access frequencies *
@@ -3256,24 +3271,38 @@ static void damon_merge_two_regions(struct damon_target *t,* sz_limit size upper limit of each region */ static void damon_merge_regions_of (struct damon_target *t,unsigned int thres, -unsigned long sz_limit) +unsigned long sz_limit,struct damon_ctx *ctx) {struct damon_region *r, *prev =NULL , *next; +bool use_probe_hits =damon_has_probe_weights (ctx);damon_for_each_region_safe (r, next, t) { -if (abs_diff (r->nr_accesses, r->last_nr_accesses) > thres) +unsigned int score, last_score, diff; + + score =damon_merge_score (r, false, ctx, use_probe_hits); + last_score =damon_merge_score (r, true, ctx, use_probe_hits); + +if (abs_diff (score, last_score) > thres) r->age =0 ; -else if ((r->nr_accesses ==0 ) != (r->last_nr_accesses ==0 )) +else if ((score ==0 ) != (last_score ==0 )) r->age =0 ;else r->age++; -if (prev && prev->ar.end == r->ar.start && -abs_diff (prev->nr_accesses, r->nr_accesses) <= thres && -damon_sz_region (prev) +damon_sz_region (r) <= sz_limit) -damon_merge_two_regions (t, prev, r); -else - prev = r; +if (!prev) + goto set_prev_continue; +if (prev->ar.end != r->ar.start) + goto set_prev_continue; + diff =abs_diff (score,damon_merge_score (prev, false, ctx, + use_probe_hits)); +if (diff > thres) + goto set_prev_continue; +if (damon_sz_region (prev) +damon_sz_region (r) > sz_limit) + goto set_prev_continue; +damon_merge_two_regions (t, prev, r); +continue ; +set_prev_continue: + prev = r; } }
@@ -3306,7 +3335,7 @@ static void kdamond_merge_regions(struct damon_ctx *c, unsigned int threshold, do { nr_regions = 0; damon_for_each_target(t, c) { - damon_merge_regions_of(t, threshold, sz_limit); + damon_merge_regions_of(t, threshold, sz_limit, c); nr_regions += damon_nr_regions(t); } threshold = max(1, threshold * 2);
mm/damon/tests/core-kunit.h +11 -2
@@ -226,6 +226,7 @@ static struct damon_region *__nth_region_of(struct damon_target *t, int idx)static void damon_test_merge_regions_of (struct kunit *test) { +struct damon_ctx *ctx;struct damon_target *t;struct damon_region *r;unsigned long sa[] = {0 ,100 ,114 ,122 ,130 ,156 ,170 ,184 ,230 };
@@ -236,20 +237,27 @@ static void damon_test_merge_regions_of(struct kunit *test)unsigned long eaddrs[] = {112 ,130 ,156 ,170 ,230 ,10170 };int i; + ctx =damon_new_ctx (); +if (!ctx) +kunit_skip (test,"ctx alloc fail" ); + t =damon_new_target (); -if (!t) +if (!t) { +damon_destroy_ctx (ctx);kunit_skip (test,"target alloc fail" ); + }for (i =0 ; i <ARRAY_SIZE (sa); i++) { r =damon_new_region (sa[i], ea[i]);if (!r) {damon_free_target (t); +damon_destroy_ctx (ctx);kunit_skip (test,"region alloc fail" ); } r->nr_accesses = nrs[i];damon_add_region (r, t); } -damon_merge_regions_of (t,9 ,9999 ); +damon_merge_regions_of (t,9 ,9999 , ctx);/* 0-112, 114-130, 130-156, 156-170, 170-230, 230-10170 */ KUNIT_EXPECT_EQ (test,damon_nr_regions (t),6u );for (i =0 ; i <6 ; i++) {
@@ -258,6 +266,7 @@ static void damon_test_merge_regions_of(struct kunit *test)KUNIT_EXPECT_EQ (test, r->ar.end, eaddrs[i]); }damon_free_target (t); +damon_destroy_ctx (ctx); }static void damon_test_split_regions_of (struct kunit *test)
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 08/19] mm/damon/core: extend merge function to work with probe hits
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Region age is incorrectly updated multiple times per aggregation interval and evaluated against a stale last_score when the kdamond_merge_regions retry loop is triggered. --
--- Patch [8]: [RFC PATCH v1.2 08/19] mm/damon/core: extend merge function to work with probe hits --- commit 938ea22fc6c1fec3c909339503398aa70ea047c8
Author: SJ Park <[email protected]>
mm/damon/core: extend merge function to work with probe hits
When probe weights are set, users may want DAMON monitoring results to be optimized for the weights. For that, regions adjustment should work for the weighted sum of probe hits. Extend damon_merge_regions_of() to detect if the weights are set, and work with probe hits in the case.
Quoted 3 lines
mm/damon/core.c +0
-0
[ ... ]
Quoted 11 lines
mm/damon/core.c +4
-2@@ -3256,24 +3271,38 @@ static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, - unsigned long sz_limit) + unsigned long sz_limit, struct damon_ctx *ctx) { struct damon_region *r, *prev = NULL, *next; +bool use_probe_hits =damon_has_probe_weights (ctx);damon_for_each_region_safe (r, next, t) { -if (abs_diff (r->nr_accesses, r->last_nr_accesses) > thres) +unsigned int score, last_score, diff; +
mm/damon/core.c static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, · line 3287
Quoted 10 lines
mm/damon/core.c +5
-1+ score =damon_merge_score (r, false, ctx, use_probe_hits); + last_score =damon_merge_score (r, true, ctx, use_probe_hits); + +if (abs_diff (score, last_score) > thres) r->age =0 ; - else if ((r->nr_accesses == 0) != (r->last_nr_accesses == 0)) +else if ((score ==0 ) != (last_score ==0 )) r->age =0 ;else r->age++;
[Severity: High]
This is a pre-existing issue, but does this logic in damon_merge_regions_of() incorrectly increment or reset r->age multiple times per aggregation interval?
When the number of regions exceeds max_nr_regions, kdamond_merge_regions() repeatedly calls damon_merge_regions_of() with doubled thresholds. During these retries, r->age is incremented multiple times within a single aggregation interval.
Furthermore, because damon_merge_two_regions() updates the current nr_accesses and probe_hits but fails to merge their historical counterparts (last_nr_accesses and last_probe_hits), these values become stale.
On subsequent iterations of the retry loop, damon_merge_score() computes last_score using these stale unmerged values. This can cause abs_diff(score, last_score) to spuriously exceed the threshold, resetting r->age to 0 inappropriately.
Could this cause DAMOS age-based schemes to trigger prematurely or fail to trigger entirely?
Quoted 22 lines
mm/damon/core.c +14
-6-if (prev && prev->ar.end == r->ar.start && -abs_diff (prev->nr_accesses, r->nr_accesses) <= thres && -damon_sz_region (prev) +damon_sz_region (r) <= sz_limit) -damon_merge_two_regions (t, prev, r); -else - prev = r; +if (!prev) + goto set_prev_continue; +if (prev->ar.end != r->ar.start) + goto set_prev_continue; + diff =abs_diff (score,damon_merge_score (prev, false, ctx, + use_probe_hits)); +if (diff > thres) + goto set_prev_continue; +if (damon_sz_region (prev) +damon_sz_region (r) > sz_limit) + goto set_prev_continue; +damon_merge_two_regions (t, prev, r); +continue ; +set_prev_continue: + prev = r; } }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
SJ Park
maintainerRe: [RFC PATCH v1.2 08/19] mm/damon/core: extend merge function to work with probe hits
Quoted 58 lines · On Thu, 09 Jul 2026 14:32:15 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] Regionageis incorrectly updated multiple times per aggregation interval and evaluated against a stalelast_scorewhen thekdamond_merge_regionsretry loop is triggered. ----- Patch [8]: [RFC PATCH v1.2 08/19]
mm/damon/core: extend merge function to work with probe hits --- commit938ea22fc6c1fec3c909339503398aa70ea047c8
Author: SJ Park <[email protected]>
mm/damon/core: extend merge function to work with probe hitsWhen probe weights are set, users may want DAMON monitoring results to be optimized for the weights. For that, regions adjustment should work for the weighted sum of probe hits. Extend
damon_merge_regions_of()to detect if the weights are set, and work with probe hits in the case.Quoted 3 lines
mm/damon/core.c +0
-0[ ... ]
Quoted 11 lines
mm/damon/core.c +4
-2@@ -3256,24 +3271,38 @@ static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, - unsigned long sz_limit) + unsigned long sz_limit, struct damon_ctx *ctx) { struct damon_region *r, *prev = NULL, *next; +bool use_probe_hits =damon_has_probe_weights (ctx);damon_for_each_region_safe (r, next, t) { -if (abs_diff (r->nr_accesses, r->last_nr_accesses) > thres) +unsigned int score, last_score, diff; +mm/damon/core.c static void damon_merge_regions_of(struct damon_target *t, unsigned int thres, · line 3287
Quoted 10 lines
mm/damon/core.c +5
-1+ score =damon_merge_score (r, false, ctx, use_probe_hits); + last_score =damon_merge_score (r, true, ctx, use_probe_hits); + +if (abs_diff (score, last_score) > thres) r->age =0 ; - else if ((r->nr_accesses == 0) != (r->last_nr_accesses == 0)) +else if ((score ==0 ) != (last_score ==0 )) r->age =0 ;else r->age++;[Severity: High]
This is a pre-existing issue, but does this logic indamon_merge_regions_of()incorrectly increment or resetr->agemultiple times per aggregation interval?When the number of regions exceeds
max_nr_regions,kdamond_merge_regions()repeatedly callsdamon_merge_regions_of()with doubled thresholds. During these retries,r->ageis incremented multiple times within a single aggregation interval.Furthermore, because
damon_merge_two_regions()updates the currentnr_accessesandprobe_hitsbut fails to merge their historical counterparts (last_nr_accessesandlast_probe_hits), these values become stale.
Quoted 7 lines
On subsequent iterations of the retry loop,
damon_merge_score()computeslast_scoreusing these stale unmerged values. This can causeabs_diff(score, last_score)to spuriously exceed the threshold, resettingr->ageto 0 inappropriately.Could this cause DAMOS age-based schemes to trigger prematurely or fail to trigger entirely?
I already promised to separately work on this.
Quoted 15 lines
Quoted 15 lines
mm/damon/core.c +8
-6-if (prev && prev->ar.end == r->ar.start && -abs_diff (prev->nr_accesses, r->nr_accesses) <= thres && -damon_sz_region (prev) +damon_sz_region (r) <= sz_limit) -damon_merge_two_regions (t, prev, r); -else - prev = r; +if (!prev) + goto set_prev_continue; +if (prev->ar.end != r->ar.start) + goto set_prev_continue; + diff =abs_diff (score,damon_merge_score (prev, false, ctx, + use_probe_hits)); +if (diff > thres) + goto set_prev_continue;
Quoted 11 lines
Quoted 8 lines
mm/damon/core.c +6
-0+if (damon_sz_region (prev) +damon_sz_region (r) > sz_limit) + goto set_prev_continue; +damon_merge_two_regions (t, prev, r); +continue ; +set_prev_continue: + prev = r; } }Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Thanks,
SJ
SJ Park
maintainerRFC PATCH 9/19 mm/damon/core: disallow probe_hits overflow on attrs only monitoring
In reply to SJ ParkWhen any damon_probe->weight is set, DAMON will do only probe monitoring. probe_hits is 'unsigned char'. It could overflow when the aggregation interval is larger than the sampling interval times 256. damon_as_probe_weights() always return false, so such overflow cannot happen. Even if it happens, it only degrades the monitoring results.
That said, the overflow is not intentional. It is better to be prevented as long as the cost is not expensive. Disallow the overflow by adding a validation logic on the core layer parameters validation function.
--- mm/damon/core.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
mm/damon/core.c +16 -0
@@ -1332,6 +1332,19 @@ static void damos_set_filters_default_reject(struct damos *s)damos_filters_default_reject (&s->ops_filters); } +static bool damon_valid_probe_params (struct damon_ctx *ctx) +{ +unsigned long sample_interval; + +if (!damon_has_probe_weights (ctx)) +return true; + + sample_interval = ctx->attrs.sample_interval ? :1 ; +if (ctx->attrs.aggr_interval / sample_interval >U8_MAX ) +return false; +return true; +} +/* * damos_commit_dests() - Copy migration destinations from @src to @dst. * @dst: Destination structure to update.
@@ -1736,6 +1749,9 @@ static int __damon_commit_ctx(struct damon_ctx *dst, struct damon_ctx *src) } } +if (!damon_valid_probe_params (src)) +return -EINVAL ; + err =damon_commit_schemes (dst, src);if (err)return err;
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 10/19 mm/damon/core: validate params for probe hits weighted sum overflow
In reply to SJ Parkdamon_probe_hits_wsum() could overflow in weird setups. Users could set the weight unreasonably high. They could also set the aggregation interval unreasonably high compared to the sampling interval. Such user setup is unlikely. Even if such setup is used, damon_has_probe_weights() always returns false, so the overflow cannot happen. The function may be completed in future, though. Even if the overflow happens, the consequence is degraded monitoring results for the unreasonable setup. It is just a trivial user experience issue.
It is still better to be prevented unless the cost is expensive. Avoid the overflow by adding the parameter validation in the core layer parameters validation function.
--- mm/damon/core.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
mm/damon/core.c +15 -0
@@ -1335,6 +1335,9 @@ static void damos_set_filters_default_reject(struct damos *s)static bool damon_valid_probe_params (struct damon_ctx *ctx) {unsigned long sample_interval; +unsigned char max_probe_hits; +struct damon_probe *probe; +unsigned int wsum, wsum_to_add;if (!damon_has_probe_weights (ctx))return true;
@@ -1342,6 +1345,18 @@ static bool damon_valid_probe_params(struct damon_ctx *ctx) sample_interval = ctx->attrs.sample_interval ? :1 ;if (ctx->attrs.aggr_interval / sample_interval >U8_MAX )return false; + +/* invlaid if probe hits weighted sum can overflow */ + max_probe_hits =damon_nr_samples_per_aggr (&ctx->attrs); + wsum =0 ; +damon_for_each_probe (probe, ctx) { +if (probe->weight >UINT_MAX / max_probe_hits) +return false; + wsum_to_add = probe->weight * max_probe_hits; +if (UINT_MAX - wsum < wsum_to_add) +return false; + wsum += wsum_to_add; + }return true; }
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 10/19] mm/damon/core: validate params for probe hits weighted sum overflow
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] Spelling mistake in comment. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Spelling mistake in comment.
--
--- Patch [10]: [RFC PATCH v1.2 10/19] mm/damon/core: validate params for probe hits weighted sum overflow --- commit 3e76c3dde55500288f3eccb730acd26964bfdad2
Author: SJ Park <[email protected]>
mm/damon/core: validate params for probe hits weighted sum overflow
This commit adds parameter validation to prevent probe hits weighted sum overflow. It ensures that the combination of probe weights and aggregation intervals does not exceed the maximum allowed values.
Quoted 4 lines
mm/damon/core.c +0
-0
[ ... ]
mm/damon/core.c static bool damon_valid_probe_params(struct damon_ctx *ctx) · line 1349
Quoted 6 lines
mm/damon/core.c +2
-0@@ -1342,6 +1345,18 @@ static bool damon_valid_probe_params(struct damon_ctx *ctx) sample_interval = ctx->attrs.sample_interval ? :1 ;if (ctx->attrs.aggr_interval / sample_interval >U8_MAX )return false; + +/* invlaid if probe hits weighted sum can overflow */
[Severity: Low]
This isn't a bug, but there is a typo in this comment ("invlaid" instead of "invalid").
Quoted 12 lines
mm/damon/core.c +10
-0+ max_probe_hits =damon_nr_samples_per_aggr (&ctx->attrs); + wsum =0 ; +damon_for_each_probe (probe, ctx) { +if (probe->weight >UINT_MAX / max_probe_hits) +return false; + wsum_to_add = probe->weight * max_probe_hits; +if (UINT_MAX - wsum < wsum_to_add) +return false; + wsum += wsum_to_add; + }return true; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=10
SJ Park
maintainerRe: [RFC PATCH v1.2 10/19] mm/damon/core: validate params for probe hits weighted sum overflow
Quoted 19 lines · On Thu, 09 Jul 2026 14:36:51 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Spelling mistake in comment.
----- Patch [10]: [RFC PATCH v1.2 10/19]
mm/damon/core: validate params for probe hits weighted sum overflow --- commit3e76c3dde55500288f3eccb730acd26964bfdad2
Author: SJ Park <[email protected]>
mm/damon/core: validate params for probe hits weighted sum overflowThis commit adds parameter validation to prevent probe hits weighted sum overflow. It ensures that the combination of probe weights and aggregation intervals does not exceed the maximum allowed values.
Quoted 4 lines
mm/damon/core.c +0
-0[ ... ]
Quoted 10 lines
mm/damon/core.c static bool damon_valid_probe_params(struct damon_ctx *ctx) · line 1349
Quoted 6 lines
mm/damon/core.c +2
-0@@ -1342,6 +1345,18 @@ static bool damon_valid_probe_params(struct damon_ctx *ctx) sample_interval = ctx->attrs.sample_interval ? :1 ;if (ctx->attrs.aggr_interval / sample_interval >U8_MAX )return false; + +/* invlaid if probe hits weighted sum can overflow */ [Severity: Low]
This isn't a bug, but there is a typo in this comment ("invlaid" instead of "invalid").
Good finding. I will fix in the next revision.
Quoted 16 lines
Quoted 13 lines
mm/damon/core.c +10
-0+ max_probe_hits =damon_nr_samples_per_aggr (&ctx->attrs); + wsum =0 ; +damon_for_each_probe (probe, ctx) { +if (probe->weight >UINT_MAX / max_probe_hits) +return false; + wsum_to_add = probe->weight * max_probe_hits; +if (UINT_MAX - wsum < wsum_to_add) +return false; + wsum += wsum_to_add; + }return true; }Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=10
Thanks,
SJ
SJ Park
maintainerRFC PATCH 11/19 mm/damon/core: disable access monitoring when probe weights are set
In reply to SJ ParkWhen users set probe weights, they are interested in the data attributes. Not necessarily they are interested in data access patterns. Disable the data access monitoring in the case.
--- mm/damon/core.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
mm/damon/core.c +3 -2
@@ -3763,17 +3763,18 @@ static int kdamond_fn(void *data)unsigned long next_aggregation_sis = ctx->next_aggregation_sis;unsigned long next_ops_update_sis = ctx->next_ops_update_sis;unsigned long sample_interval = ctx->attrs.sample_interval; +bool access_check_disabled =damon_has_probe_weights (ctx);if (kdamond_wait_activation (ctx))break ; -if (ctx->ops.prepare_access_checks) +if (!access_check_disabled && ctx->ops.prepare_access_checks) ctx->ops.prepare_access_checks (ctx);kdamond_usleep (sample_interval); ctx->passed_sample_intervals++; -if (ctx->ops.check_accesses) +if (!access_check_disabled && ctx->ops.check_accesses) max_nr_accesses = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) ctx->ops.apply_probes (ctx, false, false);
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 12/19 mm/damon/core: set samples in apply_probes() if probe weights are set
In reply to SJ ParkWhen probe weights are set, the prepare_access_checks() ops callback is not invoked, so sampling addresses of regions are unset. Ask apply_probes() to set those together in the case.
--- mm/damon/core.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
mm/damon/core.c +2 -1
@@ -3777,7 +3777,8 @@ static int kdamond_fn(void *data)if (!access_check_disabled && ctx->ops.check_accesses) max_nr_accesses = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, false, false); + ctx->ops.apply_probes (ctx, access_check_disabled, + false);if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 12/19] mm/damon/core: set samples in apply_probes() if probe weights are set
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Medium] When access checks are disabled, `max_nr_accesses` is not updated but is still used for the…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] When access checks are disabled, max_nr_accesses is not updated but is still used for the region merge threshold. apply_probes() is incorrectly called without requesting or capturing the maximum weighted sum.
- [Medium] Setting probe weights on a context whose operations do not implement .apply_probes (e.g., vaddr) silently disables all monitoring.
--
--- Patch [12]: [RFC PATCH v1.2 12/19] mm/damon/core: set samples in apply_probes() if probe weights are set --- commit ffce494dcbbb1125634a81b14be56b2f89aefe7e
Author: SJ Park <[email protected]>
mm/damon/core: set samples in apply_probes() if probe weights are set
When probe weights are set, the prepare_access_checks() ops callback is not invoked, so sampling addresses of regions are unset. Ask apply_probes() to set those together in the case.
mm/damon/core.c static int kdamond_fn(void *data) · line 3781
Quoted 11 lines
mm/damon/core.c +2
-1@@ -3777,7 +3777,8 @@ static int kdamond_fn(void *data)if (!access_check_disabled && ctx->ops.check_accesses) max_nr_accesses = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, false, false); + ctx->ops.apply_probes (ctx, access_check_disabled, + false);
[Severity: Medium]
When access checks are disabled, check_accesses() is bypassed and max_nr_accesses is not updated.
Later in this function, kdamond_merge_regions() uses max_nr_accesses to calculate the merge threshold:
if (time_after_eq(ctx->passed_sample_intervals,
next_aggregation_sis)) {
kdamond_merge_regions(ctx,
max_nr_accesses / 10,
sz_limit);Since apply_probes() is called with return_max_wsum=false, it doesn't update or return a max weighted sum. Will kdamond_merge_regions() use an invalid or stale threshold (often 0), breaking the merge algorithm?
[Severity: Medium]
If a user sets probe weights on a context whose operations do not implement .apply_probes (e.g., vaddr), access_check_disabled will be true and check_accesses() will be bypassed.
Since .apply_probes is not implemented, this block is also skipped.
Could this completely disable all monitoring for the target with no error feedback to the user?
Validation in damon_valid_probe_params() successfully validates this state:
mm/damon/core.c:damon_valid_probe_params() {
...
if (!damon_has_probe_weights(ctx)) return true;
...
}
Should damon_valid_probe_params() check if ctx->ops.apply_probes is supported?
Quoted 3 lines
mm/damon/core.c +0
-0if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
SJ Park
maintainerRe: [RFC PATCH v1.2 12/19] mm/damon/core: set samples in apply_probes() if probe weights are set
Quoted 40 lines · On Thu, 09 Jul 2026 14:48:55 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] When access checks are disabled,max_nr_accessesis not updated but is still used for the region merge threshold.apply_probes()is incorrectly called without requesting or capturing the maximum weighted sum.
- [Medium] Setting probe weights on a context whose operations do not implement.apply_probes(e.g.,vaddr) silently disables all monitoring.
----- Patch [12]: [RFC PATCH v1.2 12/19]
mm/damon/core: set samples inapply_probes()if probe weights are set --- commitffce494dcbbb1125634a81b14be56b2f89aefe7e
Author: SJ Park <[email protected]>
mm/damon/core: set samples inapply_probes()if probe weights are setWhen probe weights are set, the
prepare_access_checks()ops callback is not invoked, so sampling addresses of regions are unset. Askapply_probes()to set those together in the case.mm/damon/core.c static int kdamond_fn(void *data) · line 3781
Quoted 11 lines
mm/damon/core.c +2
-1@@ -3777,7 +3777,8 @@ static int kdamond_fn(void *data)if (!access_check_disabled && ctx->ops.check_accesses) max_nr_accesses = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, false, false); + ctx->ops.apply_probes (ctx, access_check_disabled, + false);[Severity: Medium]
When access checks are disabled,check_accesses()is bypassed andmax_nr_accessesis not updated.Later in this function,
kdamond_merge_regions()usesmax_nr_accessesto calculate the merge threshold:if (time_after_eq(ctx->passed_sample_intervals, next_aggregation_sis)) { kdamond_merge_regions(ctx, max_nr_accesses / 10, sz_limit);
Quoted 3 lines
Since
apply_probes()is called with return_max_wsum=false, it doesn't update or return a max weighted sum. Willkdamond_merge_regions()use an invalid or stale threshold (often 0), breaking the merge algorithm?
That will be implemented by a later patch of this series.
Quoted 13 lines
[Severity: Medium]
If a user sets probe weights on a context whose operations do not implement .apply_probes (e.g., vaddr),access_check_disabledwill be true andcheck_accesses()will be bypassed.Since .apply_probes is not implemented, this block is also skipped.
Could this completely disable all monitoring for the target with no error feedback to the user?
Validation in
damon_valid_probe_params()successfully validates this state:
Quoted 8 lines
mm/damon/core.c:damon_valid_probe_params() {
...if (!damon_has_probe_weights(ctx)) return true;...
}Should
damon_valid_probe_params()check ifctx->ops.apply_probesis supported?
This is an intentional design. The user should config DAMON correctly.
Quoted 7 lines
Quoted 4 lines
mm/damon/core.c +0
-0if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
Thanks,
SJ
SJ Park
maintainerRFC PATCH 13/19 mm/damon/core: s/max_nr_accesses/max_merge_score/ in kdamond_fn()
In reply to SJ ParkWhen probe weights are set, DAMON merge logic works with the probe hits weighted sum. The core logic is setting the merge threshold based on the access frequency, though. Before using probe hits based threshold, rename the variables to look more general.
--- mm/damon/core.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
mm/damon/core.c +3 -3
@@ -3730,7 +3730,6 @@ static void kdamond_init_ctx(struct damon_ctx *ctx)static int kdamond_fn (void *data) {struct damon_ctx *ctx = data; -unsigned int max_nr_accesses =0 ;unsigned long sz_limit =0 ;pr_debug ("kdamond (%d) starts\n" , current->pid);
@@ -3764,6 +3763,7 @@ static int kdamond_fn(void *data)unsigned long next_ops_update_sis = ctx->next_ops_update_sis;unsigned long sample_interval = ctx->attrs.sample_interval;bool access_check_disabled =damon_has_probe_weights (ctx); +unsigned int max_merge_score =0 ;if (kdamond_wait_activation (ctx))break ;
@@ -3775,7 +3775,7 @@ static int kdamond_fn(void *data) ctx->passed_sample_intervals++;if (!access_check_disabled && ctx->ops.check_accesses) - max_nr_accesses = ctx->ops.check_accesses (ctx); + max_merge_score = ctx->ops.check_accesses (ctx);if (ctx->ops.apply_probes) ctx->ops.apply_probes (ctx, access_check_disabled, false);
@@ -3783,7 +3783,7 @@ static int kdamond_fn(void *data)if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {kdamond_merge_regions (ctx, - max_nr_accesses /10 , + max_merge_score /10 , sz_limit);/* online updates might be made */ sz_limit =damon_apply_min_nr_regions (ctx);
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 14/19 mm/damon/core: get merge threshold from probe hits when weights are set
In reply to SJ ParkWhen probe weights are set, DAMON merges regions based on their probe hits weighted sum. But the merge threshold is calculated based on the access frequency. Update it to retrieve the maximum probe hits weighted sum in the snapshot from apply_probes() ops callback, and generate the threshold based on it.
--- mm/damon/core.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
mm/damon/core.c +14 -4
@@ -3763,7 +3763,8 @@ static int kdamond_fn(void *data)unsigned long next_ops_update_sis = ctx->next_ops_update_sis;unsigned long sample_interval = ctx->attrs.sample_interval;bool access_check_disabled =damon_has_probe_weights (ctx); -unsigned int max_merge_score =0 ; +unsigned int max_merge_score =0 , max_wsum; +bool get_max_wsum;if (kdamond_wait_activation (ctx))break ;
@@ -3776,9 +3777,18 @@ static int kdamond_fn(void *data)if (!access_check_disabled && ctx->ops.check_accesses) max_merge_score = ctx->ops.check_accesses (ctx); -if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, access_check_disabled, - false); +if (ctx->ops.apply_probes) { +if (time_after_eq (ctx->passed_sample_intervals, + next_aggregation_sis) && + access_check_disabled) + get_max_wsum = true; +else + get_max_wsum = false; + max_wsum = ctx->ops.apply_probes (ctx, + access_check_disabled, get_max_wsum); +if (get_max_wsum) + max_merge_score = max_wsum; + }if (time_after_eq (ctx->passed_sample_intervals, next_aggregation_sis)) {
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 14/19] mm/damon/core: get merge threshold from probe hits when weights are set
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Missing validation for `apply_probes` callback when probe weights are configured leads to complete…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Missing validation for apply_probes callback when probe weights are configured leads to complete DAMON region collapse. --
--- Patch [14]: [RFC PATCH v1.2 14/19] mm/damon/core: get merge threshold from probe hits when weights are set --- commit a4d0e22d5d4d741ec6086d8f49fefbab2c3b57bd
Author: SJ Park <[email protected]>
mm/damon/core: get merge threshold from probe hits when weights are set
When probe weights are set, DAMON merges regions based on their probe hits weighted sum. But the merge threshold is calculated based on the access frequency. Update it to retrieve the maximum probe hits weighted sum in the snapshot from apply_probes() ops callback, and generate the threshold based on it.
Quoted 4 lines
mm/damon/core.c +0
-0
[ ... ]
Quoted 9 lines
mm/damon/core.c +2
-3@@ -3776,9 +3777,18 @@ static int kdamond_fn(void *data)if (!access_check_disabled && ctx->ops.check_accesses) max_merge_score = ctx->ops.check_accesses (ctx); -if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, access_check_disabled, - false); +if (ctx->ops.apply_probes) { + if (time_after_eq(ctx->passed_sample_intervals,
mm/damon/core.c static int kdamond_fn(void *data) · line 3791
Quoted 10 lines
mm/damon/core.c +10
-0+ next_aggregation_sis) && + access_check_disabled) + get_max_wsum = true; + else + get_max_wsum = false; + max_wsum = ctx->ops.apply_probes (ctx, + access_check_disabled, get_max_wsum); +if (get_max_wsum) + max_merge_score = max_wsum; + }
[Severity: High]
If a configuration has probe weights enabled (so access_check_disabled is true) but the active operations do not implement the apply_probes callback (like vaddr or fvaddr), does max_merge_score remain 0 here?
It appears that skipping both check_accesses() and apply_probes() leaves max_merge_score at 0. Later, when kdamond_merge_regions() is called with a threshold of 0, and all regions have 0 probe hits, damon_merge_regions_of() would see a difference of 0 between adjacent regions.
Could this lead to aggressive merging of all regions up to sz_limit, effectively collapsing the fine-grained region layout?
Should there be a validation check in damon_valid_probe_params() to reject configurations where probe weights are set but ctx->ops.apply_probes is missing?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=14
SJ Park
maintainerRe: [RFC PATCH v1.2 14/19] mm/damon/core: get merge threshold from probe hits when weights are set
Quoted 53 lines · On Thu, 09 Jul 2026 14:49:01 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Missing validation forapply_probescallback when probe weights are configured leads to complete DAMON region collapse. ----- Patch [14]: [RFC PATCH v1.2 14/19]
mm/damon/core: get merge threshold from probe hits when weights are set --- commita4d0e22d5d4d741ec6086d8f49fefbab2c3b57bd
Author: SJ Park <[email protected]>
mm/damon/core: get merge threshold from probe hits when weights are setWhen probe weights are set, DAMON merges regions based on their probe hits weighted sum. But the merge threshold is calculated based on the access frequency. Update it to retrieve the maximum probe hits weighted sum in the snapshot from
apply_probes()ops callback, and generate the threshold based on it.Quoted 4 lines
mm/damon/core.c +0
-0[ ... ]
Quoted 9 lines
mm/damon/core.c +2
-3@@ -3776,9 +3777,18 @@ static int kdamond_fn(void *data)if (!access_check_disabled && ctx->ops.check_accesses) max_merge_score = ctx->ops.check_accesses (ctx); -if (ctx->ops.apply_probes) - ctx->ops.apply_probes (ctx, access_check_disabled, - false); +if (ctx->ops.apply_probes) { + if (time_after_eq(ctx->passed_sample_intervals,mm/damon/core.c static int kdamond_fn(void *data) · line 3791
Quoted 10 lines
mm/damon/core.c +10
-0+ next_aggregation_sis) && + access_check_disabled) + get_max_wsum = true; + else + get_max_wsum = false; + max_wsum = ctx->ops.apply_probes (ctx, + access_check_disabled, get_max_wsum); +if (get_max_wsum) + max_merge_score = max_wsum; + }[Severity: High]
If a configuration has probe weights enabled (soaccess_check_disabledis true) but the active operations do not implement theapply_probescallback (like vaddr or fvaddr), doesmax_merge_scoreremain 0 here?It appears that skipping both
check_accesses()andapply_probes()leavesmax_merge_scoreat 0. Later, whenkdamond_merge_regions()is called with a threshold of 0, and all regions have 0 probe hits,damon_merge_regions_of()would see a difference of 0 between adjacent regions.
Quoted 6 lines
Could this lead to aggressive merging of all regions up to
sz_limit, effectively collapsing the fine-grained region layout?Should there be a validation check in
damon_valid_probe_params()to reject configurations where probe weights are set butctx->ops.apply_probesis missing?
No, this is an intentional design. The user should correctly config DAMON.
Quoted 3 lines
Signature · 2 lines
-- Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=14
Thanks,
SJ
SJ Park
maintainerRFC PATCH 15/19 mm/damon/core: implement damon_has_probe_weight()
In reply to SJ ParkDAMON monitors only data attributes when probe weights are set. However, the function for detecting it is intentionally returning false always. The intention was to make changes for complete support of the mode in a safe and incremental way. Now all the building blocks are made. Complete the mode detection function so that the mode can really start working.
--- mm/damon/core.c | 6 ++++++ 1 file changed, 6 insertions(+)
mm/damon/core.c +6 -0
@@ -211,6 +211,12 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)static bool damon_has_probe_weights (struct damon_ctx *c) { +struct damon_probe *p; + +damon_for_each_probe (p, c) { +if (p->weight) +return true; + }return false; }
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v1.2 15/19] mm/damon/core: implement damon_has_probe_weight()
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Enabling probe weights for DAMON operations that do not implement `apply_probes` (e.g., VADDR and…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Enabling probe weights for DAMON operations that do not implement apply_probes (e.g., VADDR and FVADDR) silently disables memory monitoring and region aggregation. --
--- Patch [15]: [RFC PATCH v1.2 15/19] mm/damon/core: implement damon_has_probe_weight() --- commit 13bb6c9724d49615512e0e4f353c5d02210d2c11
Author: SJ Park <[email protected]>
mm/damon/core: implement damon_has_probe_weight()
This commit completes the implementation of damon_has_probe_weights() to return true if any probe has a non-zero weight. This allows DAMON to detect probe weights and use them for monitoring.
Quoted 5 lines
mm/damon/core.c +0
-0
mm/damon/core.c static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx) · line 219
Quoted 9 lines
mm/damon/core.c +6
-0@@ -211,6 +211,12 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)static bool damon_has_probe_weights (struct damon_ctx *c) { +struct damon_probe *p; + +damon_for_each_probe (p, c) { +if (p->weight) +return true; + }
[Severity: High]
Does this silently break monitoring for operation sets that do not implement apply_probes?
When this function returns true, access_check_disabled evaluates to true in kdamond_fn():
mm/damon/core.c:kdamond_fn() {
...
bool access_check_disabled = damon_has_probe_weights(ctx);
...
if (!access_check_disabled && ctx->ops.prepare_access_checks)
ctx->ops.prepare_access_checks(ctx);
...
if (!access_check_disabled && ctx->ops.check_accesses)
max_merge_score = ctx->ops.check_accesses(ctx);
if (ctx->ops.apply_probes) {
...
}
...
}If a user configures probe weights for operation sets that lack apply_probes, all access checks are skipped. Since apply_probes is NULL, no memory access information is gathered at all. This causes regions to endlessly report 0 accesses and incorrectly merge up to the maximum limit.
Should __damon_commit_ctx() or damon_valid_probe_params() validate that ctx->ops.apply_probes is non-NULL when probe weights are used, returning -EINVAL to prevent this failure?
Quoted 2 lines
mm/damon/core.c +0
-0return false; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=15
SJ Park
maintainerRe: [RFC PATCH v1.2 15/19] mm/damon/core: implement damon_has_probe_weight()
Quoted 52 lines · On Thu, 09 Jul 2026 14:56:52 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Enabling probe weights for DAMON operations that do not implementapply_probes(e.g., VADDR and FVADDR) silently disables memory monitoring and region aggregation. ----- Patch [15]: [RFC PATCH v1.2 15/19]
mm/damon/core: implementdamon_has_probe_weight()--- commit13bb6c9724d49615512e0e4f353c5d02210d2c11
Author: SJ Park <[email protected]>
mm/damon/core: implementdamon_has_probe_weight()This commit completes the implementation of
damon_has_probe_weights()to return true if any probe has a non-zero weight. This allows DAMON to detect probe weights and use them for monitoring.Quoted 5 lines
mm/damon/core.c +0
-0mm/damon/core.c static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx) · line 219
Quoted 9 lines
mm/damon/core.c +6
-0@@ -211,6 +211,12 @@ static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)static bool damon_has_probe_weights (struct damon_ctx *c) { +struct damon_probe *p; + +damon_for_each_probe (p, c) { +if (p->weight) +return true; + }[Severity: High]
Does this silently break monitoring for operation sets that do not implementapply_probes?When this function returns true,
access_check_disabledevaluates to true inkdamond_fn():mm/damon/core.c:kdamond_fn() { ... bool access_check_disabled = damon_has_probe_weights(ctx); ... if (!access_check_disabled && ctx->ops.prepare_access_checks) ctx->ops.prepare_access_checks(ctx); ... if (!access_check_disabled && ctx->ops.check_accesses) max_merge_score = ctx->ops.check_accesses(ctx); if (ctx->ops.apply_probes) { ... } ... }
Quoted 8 lines
If a user configures probe weights for operation sets that lack
apply_probes, all access checks are skipped. Sinceapply_probesis NULL, no memory access information is gathered at all. This causes regions to endlessly report 0 accesses and incorrectly merge up to the maximum limit.Should
__damon_commit_ctx()ordamon_valid_probe_params()validate thatctx->ops.apply_probesis non-NULL when probe weights are used, returning-EINVALto prevent this failure?
This is an intentional design. Users should correctly set DAMON.
Quoted 6 lines
Quoted 3 lines
mm/damon/core.c +0
-0return false; }Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=15
Thanks,
SJ
SJ Park
maintainerRFC PATCH 16/19 mm/damon/sysfs: implement probe/weight file
In reply to SJ ParkImplement a new sysfs file, 'weight', under probe directory. Users will be able to set the probe weight and enable the attributes only monitoring using it.
--- mm/damon/sysfs.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
mm/damon/sysfs.c +25 -0
@@ -1065,6 +1065,7 @@ static const struct kobj_type damon_sysfs_filters_ktype = {struct damon_sysfs_probe {struct kobject kobj; +unsigned int weight;struct damon_sysfs_filters *filters; };
@@ -1100,12 +1101,35 @@ static void damon_sysfs_probe_rm_dirs(struct damon_sysfs_probe *probe) } } +static ssize_t weight_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_probe *probe =container_of (kobj, + struct damon_sysfs_probe, kobj); + +return sysfs_emit (buf,"%u\n" , probe->weight); +} + +static ssize_t weight_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_probe *probe =container_of (kobj, + struct damon_sysfs_probe, kobj); +int err =kstrtouint (buf,0 , &probe->weight); + +return err ? err : count; +} +static void damon_sysfs_probe_release (struct kobject *kobj) {kfree (container_of(kobj ,struct damon_sysfs_probe ,kobj )); } +static struct kobj_attribute damon_sysfs_probe_weight_attr = +__ATTR_RW_MODE (weight,0600 ); +static struct attribute *damon_sysfs_probe_attrs[] = { + &damon_sysfs_probe_weight_attr.attr,NULL , };ATTRIBUTE_GROUPS (damon_sysfs_probe);
@@ -1965,6 +1989,7 @@ static int damon_sysfs_set_probes(struct damon_ctx *ctx,return -ENOMEM ;damon_add_probe (ctx, p); sys_probe = sys_probes->probes_arr[i]; + p->weight = sys_probe->weight; err =damon_sysfs_set_probe (p, sys_probe);if (err)return err;
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 17/19 Docs/mm/damon/design: document attrs-only monitoring
In reply to SJ ParkUpdate DAMON design document for the attributes only monitoring mode.
--- Documentation/mm/damon/design.rst | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
Documentation/mm/damon/design.rst +20 -0
@@ -316,6 +316,26 @@ Another way to do this for higher accuracy is using :ref:`DAMOS filter information in page level. But, because it is operated in page level, the overhead is proportional to the size of the memory. +Data Attributes-only Monitoring +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Data access is the primary monitoring information for DAMON. Hence it +:ref:`adjusts <damon_design_data_attrs_monitoring>` regions using the access +:ref:`counter <damon_design_region_based_sampling>` (``nr_accesses``). In some +use cases, however, users may want some of :ref:`attributes +<damon_design_data_attrs_monitoring>` to be the primary information. + +Data attributes-only monitoring mode supports this use case. For the mode, +each attribute probe has their priority weight value. Users can describe by +what combination of the attributes the primary information is decided, by +setting the priority weight value. If the total sum of the weights is not +zero, the mode is enabled. The regions adjustment mechanism uses the weighted +sum of the :ref:`probe hit counts <damon_design_data_attrs_monitoring>` instead +of ``nr_accesses`` in the case. When the mode is enabled, access monitoring is +automatically turned off. The access counter (``nr_accesses``) will always be +zero and not updated. Hence the mode is called Data Attributes "only" +monitoring. + Dynamic Target Space Updates Handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 18/19 Docs/admin-guide/mm/damon/usage: document weight sysfs file
In reply to SJ ParkUpdate DAMON usage document for newly added probe weight file.
--- Documentation/admin-guide/mm/damon/usage.rst | 11 ++++++++--- Documentation/mm/damon/design.rst | 5 +++++ 2 files changed, 13 insertions(+), 3 deletions(-)
Documentation/admin-guide/mm/damon/usage.rst +8 -3
@@ -73,9 +73,10 @@ comma (","). │ │ │ │ │ │ │ intervals_goal/access_bp,aggrs,min_sample_us,max_sample_us │ │ │ │ │ │ nr_regions/min,max │ │ │ │ │ │ :ref:`probes <damon_usage_sysfs_probes>`/nr_probes - │ │ │ │ │ │ │ 0/filters/nr_filters - │ │ │ │ │ │ │ │ 0/type,matching,allow,path - │ │ │ │ │ │ │ │ ... + │ │ │ │ │ │ │ 0/weight + │ │ │ │ │ │ │ │ filters/nr_filters + │ │ │ │ │ │ │ │ │ 0/type,matching,allow,path + │ │ │ │ │ │ │ │ │ ... │ │ │ │ │ │ │ ... │ │ │ │ │ :ref:`targets <sysfs_targets>`/nr_targets │ │ │ │ │ │ :ref:`0 <sysfs_target>`/pid_target,obsolete_target
@@ -286,6 +287,10 @@ In each probe directory, one directory, ``filters`` exists. The directory contains files for installing filters for the probe, that is used to determine the data attribute for the probe. +Each probe directory also contains ``weight`` file. Reading from and writing +to the file gets and sets the :ref:`attributes-only monitoring +<damon_design_attrs_only_monitoring>` weight for the attribute of the probe. + In the beginning, ``filters`` directory has only one file, ``nr_filters``. Writing a number (``N``) to the file creates the number of child directories named ``0`` to ``N-1``. Each directory represents each filter and works in a
Documentation/mm/damon/design.rst +5 -0
@@ -316,6 +316,8 @@ Another way to do this for higher accuracy is using :ref:`DAMOS filter information in page level. But, because it is operated in page level, the overhead is proportional to the size of the memory. +.. _damon_design_attrs_only_monitoring: + Data Attributes-only Monitoring ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -336,6 +338,9 @@ automatically turned off. The access counter (``nr_accesses``) will always be zero and not updated. Hence the mode is called Data Attributes "only" monitoring. +Refer to the :ref:`admin guide <damon_usage_sysfs_probes>` to know how users +can use the mode. + Dynamic Target Space Updates Handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 19/19 Docs/ABI/damon: document probe weight file
In reply to SJ ParkUpdate DAMON ABI document for the newly added probe weight sysfs file.
--- Documentation/ABI/testing/sysfs-kernel-mm-damon | 6 ++++++ 1 file changed, 6 insertions(+)
Documentation/ABI/testing/sysfs-kernel-mm-damon +6 -0
@@ -164,6 +164,12 @@ Description: Writing a number 'N' to this file creates the number of directories for each DAMON probe named '0' to 'N-1' under the probes/ directory. +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/monitoring_attrs/probes/<P>/weight +Date: Jul 2026 +Contact: SJ Park <[email protected]> +Description: Writing to and reading from this file sets and gets the + per-probe attribute weight. + What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/monitoring_attrs/probes/<P>/filters/nr_filters Date: May 2026 Contact: SJ Park <[email protected]>
Signature · 1 line
2.47.3