mm/damon: introduce data access-as-a-data attribute
Subsystems (5)
SJ Park
maintainercover mm/damon: introduce data access-as-a-data attribute
TL;DR: extend DAMON's data attributes monitoring system to support page table accessed bit and PG_idle based access monitoring.
DAMON was initially introduced as a data access monitor. Users found data access pattern becomes more useful when it is combined with other data attributes such as belonging cgroups and backing page types. For such cases, DAMON has extended to support such data attributes monitoring in addition to the original data access monitoring. The DAMON probes system was introduced for this purpose. Users set probes for filtering data attributes of their interest. For use cases where the primary interests are the attributes but the access pattern, probe weights system has been introduced. When it is used, DAMON applies its adaptive regions adjustment based on the monitored data attributes.
However, DAMON stops access monitoring when the probe weights are used. DAMON cannot optimally help users who have interests in both data attributes and access patterns. Data access can also be thought of as another data attribute, though. Extend the probe system to support data access as a data attribute.
Introduce a new probe filter type, pgidle_unset. It shows if the page is not set as idle. Specifically, it shows the page table accessed bit and the PG_idle flag. It can inform if the region is ever accessed. But it cannot say when it is accessed. To answer the second question, introduce a new probe feature, prep actions. Using the features, Users can specify what preparation actions should be made to each region for each probe. DAMON executes the preparation actions for each sampling interval, like it is doing the preparation for access check in the access monitoring mode. To help 'pgidle_unset' probe action use case, 'set_pgidle' preparation action is introduced together. The action does exactly what the access monitoring was doing: clearing the page table accessed bits and setting the PG_idle flags.
Tests
=====
I compared the access pattern monitoring results from the classic way and the probe based way. As expected, the probe based way shows the results similar to that of the classic way. More detailed test methods and results are below.
First, do the access monitoring using the DAMON user-space tool [1] in the classic way. The system is idle. It shows no access as expected.
$ sudo ./damo/damo start
$ sudo ./damo report access
heatmap: 00000000000000000000000000000000000000000000000029300000000000002222222100019000
# min/max temperatures: -440,000,000, 0, column size: 99.800 MiB
intervals: sample 5 ms aggr 100 ms (max access hz 200)
0 addr 4.000 KiB size 4.748 GiB access 0 hz age 4.400 s
1 addr 4.748 GiB size 167.664 MiB access 0 hz age 0 ns
2 addr 4.912 GiB size 1.325 GiB access 0 hz age 4.400 s
3 addr 6.238 GiB size 744.301 MiB access 0 hz age 3.200 s
4 addr 6.964 GiB size 438.594 MiB access 0 hz age 4.400 s
5 addr 7.393 GiB size 115.883 MiB access 0 hz age 0 ns
6 addr 7.506 GiB size 298.000 MiB access 0 hz age 4.400 s
memory bw estimate: 0 B per second
total size: 7.797 GiB
record DAMON intervals: sample 5 ms, aggr 100 msStart an artificial memory access generator [2] and show the monitoring results. As expected, it captures accesses.
$ ./masim/masim ./masim/configs/zigzag.cfg
$ sudo ./damo report access
heatmap: 68888888888888888888888888888886222222210017788888888888888888888888899999998777
# min/max temperatures: -850,000,000, 40,000,500, column size: 99.800 MiB
intervals: sample 5 ms aggr 100 ms (max access hz 200)
0 addr 4.000 KiB size 28.137 MiB access 0 hz age 4.200 s
1 addr 28.141 MiB size 880.000 KiB access 170 hz age 0 ns
2 addr 29.000 MiB size 4.000 MiB access 0 hz age 3.100 s
3 addr 33.000 MiB size 500.000 KiB access 160 hz age 0 ns
4 addr 33.488 MiB size 12.000 KiB access 0 hz age 1.700 s
5 addr 33.500 MiB size 40.000 KiB access 170 hz age 0 ns
6 addr 33.539 MiB size 8.000 KiB access 0 hz age 900 ms
7 addr 33.547 MiB size 80.000 KiB access 170 hz age 0 ns
8 addr 33.625 MiB size 32.000 KiB access 0 hz age 2.300 s
9 addr 33.656 MiB size 68.000 KiB access 170 hz age 0 ns
[...]
528 addr 7.437 GiB size 368.586 MiB access 0 hz age 900 ms
memory bw estimate: 28.521 GiB per second
total size: 7.797 GiB
record DAMON intervals: sample 5 ms, aggr 100 msAfter the artificial memory access generator is terminated, restart DAMON with the probe-based access monitoring. Note that DAMON user-space tool [1] gained the support of probe-based access monitoring as an experimental feature, starting from v3.3.3. As expected, it shows no access since the system is idle again.
$ sudo ./damo/damo start --probe_prep set_pgidle --probe_filter allow pgidle_unset
$ sudo ./damo report attrs
heatmap:
99999999999999999999899866666664000000000000000277777775333333333333333333333332
# min/max temperatures: -2,250,000,000, -1,690,000,000, column size:
99.800 MiB
intervals: sample 5 ms aggr 100 ms (max access hz 200)
# addr size age probe_hits
0 4.000 KiB 2.316 GiB 16.900 s 0
1 2.316 GiB 790.730 MiB 18.400 s 0
2 3.088 GiB 794.406 MiB 22.200 s 0
3 3.864 GiB 796.473 MiB 22.500 s 0
4 4.642 GiB 786.223 MiB 17.600 s 0
5 5.410 GiB 2.326 GiB 20.600 s 0
6 7.736 GiB 62.773 MiB 20.700 s 0
memory bw estimate: 0 B per second
total size: 7.797 GiB
record DAMON intervals: sample 5 ms, aggr 100 msStart the artificial memory access generator [2] again and show the monitoring results. As expected, it captures accesses similar to the classic monitoring mode.
$ ./masim/masim ./masim/configs/zigzag.cfg
$ sudo ./damo report attrs
heatmap:
88888888888888899999999888888888400000003888888888888888888888888888888888888888
# min/max temperatures: -2,100,000,000, 500, column size: 99.800 MiB
intervals: sample 5 ms aggr 100 ms (max access hz 200)
# addr size age probe_hits
0 4.000 KiB 23.414 MiB 3.500 s 0
1 23.418 MiB 35.121 MiB 3.500 s 1
2 58.539 MiB 264.000 KiB 1.600 s 19
3 58.797 MiB 16.000 KiB 0 ns 0
4 58.812 MiB 92.000 KiB 1.400 s 20
5 58.902 MiB 996.000 KiB 600 ms 0
6 59.875 MiB 32.000 KiB 1.600 s 20
7 59.906 MiB 24.000 KiB 6.900 s 0
8 59.930 MiB 72.000 KiB 1.600 s 20
9 60.000 MiB 160.000 KiB 0 ns 0
[...]
316 6.641 GiB 754.949 MiB 1.300 s 0
317 7.378 GiB 428.676 MiB 1.500 s 0
memory bw estimate: 11.633 GiB per second
total size: 7.797 GiB
record DAMON intervals: sample 5 ms, aggr 100 msPatches Sequence
================
First four patches (patches 1-4) introduce the new probe filter type for knowing if a region is accessed. Patch 1 defines the new type in the core. Patch 2 implements the execution of the new filter in the physical address space DAMON operation set. Patch 3 implements a user interface on DAMON sysfs interface. Patch 4 updates the documentation for the new filter type.
Following 13 patches (patches 5-17) introduce the probe preparation actions feature. Patch 5 defines the data structure for specifying the preparation actions. Patch 6 completes setup of the API parameter for the prep. Patch 7 extends the DAMON operation set callback list to connect the parameter with the underlying operation set. Patch 8 implements the execution of the prep in the physical address space DAMON operation set.
Following five patches (patches 9-13) extends DAMON sysfs interface for the new prep feature. Patch 14 adds simple selftest for basic file operations of the new sysfs files. Final three patches (patches 15-17) respectively update design, usage and ABI documents for the new feature and its interface.
[1] https://github.com/damonitor/damo
[2] https://github.com/sjp38/masim
Changelog
=========
Changes from RFC v2.1
- RFC v2.1: https://lore.kernel.org/[email protected]
- Evaluate ops.prep_probes first for do_prep.
- Rebase to the latest mm-new.
Changes from RFC v2
- RFC v2: https://lore.kernel.org/[email protected]
- Rename prep iterator macro param names to make more sense.
- Document set_samples param of prep_probes().
- Set do_prep after kdamond_wait_activation().
- Use const keyword for sysfs prep action-name structure fields.
- Fix typos in documents.
- Restructure sysfs interface patches for no build warning.
- Rebase to the latest mm-new.
Changes from RFC v1
- RFC v1: https://lore.kernel.org/[email protected]
- Fix wrong sample_addr setup condition.
- Fix build warnings from sysfs part.
- Fix typos.
- Rebase to latest mm-new.
- Add the tests section to the cover letter.
SJ Park (17):
mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET mm/damon/paddr: support PGIDLE_UNSET probe filter type mm/damon/sysfs: support pgidle_unset probe filter type Docs/mm/damon/design: document pgidle_unset probe filter type mm/damon/core: introduce damon_prep struct mm/damon/core: commit preps
mm/damon/core: introduce damon_operations->prep_probes() mm/damon/paddr: support damon_prep
mm/damon/sysfs: implement preps directory mm/damon/sysfs: implement preps/nr_preps file mm/damon/sysfs: create directories for nr_preps writes mm/damon/sysfs: implement prep_action file mm/damon/sysfs: pass preps to DAMON core selftests/damon/sysfs.sh: test probe prep sysfs files Docs/mm/damon/design: document probe preps Docs/admin-guide/mm/damon/usage: document probe preps sysfs files Docs/ABI/damon: document probe prep sysfs files
.../ABI/testing/sysfs-kernel-mm-damon | 13 + Documentation/admin-guide/mm/damon/usage.rst | 18 +- Documentation/mm/damon/design.rst | 15 +- include/linux/damon.h | 43 ++- mm/damon/core.c | 105 ++++++- mm/damon/paddr.c | 41 +++ mm/damon/sysfs.c | 280 +++++++++++++++++- tools/testing/selftests/damon/sysfs.sh | 27 ++ 8 files changed, 528 insertions(+), 14 deletions(-)
base-commit: 3a39750bcff456fe1005310c0ce201c2eebcc8e4
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 1/17 mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET
Introduce a new DAMON filter type, pgidle_unset. It will match pages that have their PG_Idle flag unset, or the page table accessed bit set. In other words, it says if the page is accessed.
--- include/linux/damon.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
include/linux/damon.h +4 -2
@@ -744,12 +744,14 @@ struct damon_intervals_goal {/** * enum damon_filter_type - Type of &struct damon_filter * -* @DAMON_FILTER_TYPE_ANON: Anonymous pages. -* @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. +* @DAMON_FILTER_TYPE_ANON: Anonymous pages. +* @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. +* @DAMON_FILTER_TYPE_PGIDLE_UNSET: Pgidle is unset. */ enum damon_filter_type {DAMON_FILTER_TYPE_ANON ,DAMON_FILTER_TYPE_MEMCG , +DAMON_FILTER_TYPE_PGIDLE_UNSET , };/**
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v2.2 01/17] mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The newly introduced DAMON_FILTER_TYPE_PGIDLE_UNSET enum is unhandled in the filter matching…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The newly introduced DAMON_FILTER_TYPE_PGIDLE_UNSET enum is unhandled in the filter matching logic and sysfs interface, leaving the promised functionality completely missing. --
--- Patch [1]: [RFC PATCH v2.2 01/17] mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET --- commit 1ede3c3f87a9caeeb7ad80090cbb84d20b477505
Author: SJ Park <[email protected]>
mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET
Introduce a new DAMON filter type, pgidle_unset. It will match pages that have their PG_Idle flag unset, or the page table accessed bit set.
Quoted 8 lines
include/linux/damon.h +0
-0@@ -742,12 +742,14 @@ struct damon_intervals_goal {/** * enum damon_filter_type - Type of &struct damon_filter *
include/linux/damon.h struct damon_intervals_goal { · line 752
Quoted 10 lines
include/linux/damon.h +4
-2-* @DAMON_FILTER_TYPE_ANON: Anonymous pages. -* @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. +* @DAMON_FILTER_TYPE_ANON: Anonymous pages. +* @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. +* @DAMON_FILTER_TYPE_PGIDLE_UNSET: Pgidle is unset. */ enum damon_filter_type {DAMON_FILTER_TYPE_ANON ,DAMON_FILTER_TYPE_MEMCG , +DAMON_FILTER_TYPE_PGIDLE_UNSET ,
[Severity: Medium]
Is the implementation for this new filter type missing from this patch?
Looking at damon_pa_filter_match() in mm/damon/paddr.c, the switch statement evaluating filter types does not appear to handle DAMON_FILTER_TYPE_PGIDLE_UNSET. This means it will fall through to the default case and fail to implement the promised page matching logic:
mm/damon/paddr.c:damon_pa_filter_match() {
...
switch (filter->type) {
case DAMON_FILTER_TYPE_ANON:
...
}
}Additionally, it looks like this new filter type is missing from the sysfs name mapping array, damon_sysfs_filter_type_names, in mm/damon/sysfs.c:
mm/damon/sysfs.c:damon_sysfs_filter_type_names {
{
.type = DAMON_FILTER_TYPE_ANON,
.name = "anon",
},
...
}Without this mapping, type_store() will fail with -EINVAL, making it impossible for userspace to configure.
Will a follow-up patch add the handling logic and sysfs bindings, or should they be included directly in this commit?
Quoted 3 lines
include/linux/damon.h +0
-0};/**
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
SJ Park
maintainerRe: [RFC PATCH v2.2 01/17] mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET
Quoted 59 lines · On Tue, 28 Jul 2026 04:23:24 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The newly introducedDAMON_FILTER_TYPE_PGIDLE_UNSETenum is unhandled in the filter matching logic and sysfs interface, leaving the promised functionality completely missing. ----- Patch [1]: [RFC PATCH v2.2 01/17]
mm/damon/core: introduceDAMON_FILTER_TYPE_PGIDLE_UNSET--- commit1ede3c3f87a9caeeb7ad80090cbb84d20b477505
Author: SJ Park <[email protected]>
mm/damon/core: introduceDAMON_FILTER_TYPE_PGIDLE_UNSETIntroduce a new DAMON filter type,
pgidle_unset. It will match pages that have theirPG_Idleflag unset, or the page table accessed bit set.Quoted 8 lines
include/linux/damon.h +0
-0@@ -742,12 +742,14 @@ struct damon_intervals_goal {/** * enum damon_filter_type - Type of &struct damon_filter * include/linux/damon.h struct damon_intervals_goal { · line 752
Quoted 10 lines
include/linux/damon.h +4
-2-* @DAMON_FILTER_TYPE_ANON: Anonymous pages. -* @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. +* @DAMON_FILTER_TYPE_ANON: Anonymous pages. +* @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. +* @DAMON_FILTER_TYPE_PGIDLE_UNSET: Pgidle is unset. */ enum damon_filter_type {DAMON_FILTER_TYPE_ANON ,DAMON_FILTER_TYPE_MEMCG , +DAMON_FILTER_TYPE_PGIDLE_UNSET ,[Severity: Medium]
Is the implementation for this new filter type missing from this patch?Looking at
damon_pa_filter_match()inmm/damon/paddr.c, the switch statement evaluating filter types does not appear to handleDAMON_FILTER_TYPE_PGIDLE_UNSET. This means it will fall through to the default case and fail to implement the promised page matching logic:mm/damon/paddr.c:damon_pa_filter_match() { ... switch (filter->type) { case DAMON_FILTER_TYPE_ANON: ... } }Additionally, it looks like this new filter type is missing from the sysfs name mapping array,
damon_sysfs_filter_type_names, inmm/damon/sysfs.c:mm/damon/sysfs.c:damon_sysfs_filter_type_names { { .type = DAMON_FILTER_TYPE_ANON, .name = "anon", }, ... }
Quoted 5 lines
Without this mapping,
type_store()will fail with-EINVAL, making it impossible for userspace to configure.Will a follow-up patch add the handling logic and sysfs bindings, or should they be included directly in this commit?
A later patch if this series does that.
Quoted 7 lines
Quoted 4 lines
include/linux/damon.h +0
-0};/** Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Thanks,
SJ
SJ Park
maintainerRFC PATCH 2/17 mm/damon/paddr: support PGIDLE_UNSET probe filter type
In reply to SJ ParkImplement support of DAMON_FILTER_TYPE_PGIDLE_UNSET in the physical address space DAMON operations set. It reuses damon_folio_young(), which was being used for access monitoring.
--- mm/damon/paddr.c | 6 ++++++ 1 file changed, 6 insertions(+)
mm/damon/paddr.c +6 -0
@@ -132,6 +132,12 @@ static bool damon_pa_filter_match(struct damon_filter *filter, matched = filter->memcg_id ==mem_cgroup_id (memcg);rcu_read_unlock ();break ; +case DAMON_FILTER_TYPE_PGIDLE_UNSET : +if (!folio) + matched = false; +else + matched =damon_folio_young (folio); +break ;default :break ; }
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v2.2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] DAMON_FILTER_TYPE_PGIDLE_UNSET blindly matches almost all pages when probe weights are used…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] DAMON_FILTER_TYPE_PGIDLE_UNSET blindly matches almost all pages when probe weights are used, rendering the filter ineffective.
- [High] The newly added DAMON_FILTER_TYPE_PGIDLE_UNSET is not exposed in the sysfs interface, making it impossible for users to configure. --
--- Patch [2]: [RFC PATCH v2.2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type --- commit 98c0d4f6b2dcc4c706f1af62a258dd827b89bc7e
Author: SJ Park <[email protected]>
mm/damon/paddr: support PGIDLE_UNSET probe filter type
Implement support of DAMON_FILTER_TYPE_PGIDLE_UNSET in the physical address space DAMON operations set. It reuses damon_folio_young(), which was being used for access monitoring.
mm/damon/paddr.c static bool damon_pa_filter_match(struct damon_filter *filter, · line 135
Quoted 9 lines
mm/damon/paddr.c +1
-0@@ -132,6 +132,12 @@ static bool damon_pa_filter_match(struct damon_filter *filter, matched = filter->memcg_id ==mem_cgroup_id (memcg);rcu_read_unlock ();break ; +case DAMON_FILTER_TYPE_PGIDLE_UNSET :
[Severity: High]
Is this new filter type missing from the sysfs interface mapping?
Looking at damon_sysfs_filter_type_names[] in mm/damon/sysfs.c, there is no entry for DAMON_FILTER_TYPE_PGIDLE_UNSET:
mm/damon/sysfs.c:damon_sysfs_filter_type_names[] = {
{
.type = DAMON_FILTER_TYPE_ANON,
.name = "anon",
},
{
.type = DAMON_FILTER_TYPE_MEMCG,
.name = "memcg",
},
};Without an entry here, will users attempting to configure this new filter via sysfs receive -EINVAL, making the filter unconfigurable?
mm/damon/paddr.c static bool damon_pa_filter_match(struct damon_filter *filter, · line 139
Quoted 4 lines
mm/damon/paddr.c +4
-0+if (!folio) + matched = false; +else + matched =damon_folio_young (folio);
[Severity: High]
Will this blindly match almost all folios when probe weights are used?
In kdamond_fn(), if damon_has_probe_weights(ctx) is true, it skips ctx->ops.prepare_access_checks():
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);
...
}For physical addresses, this skips damon_pa_mkold() which normally sets the PG_idle flag on folios.
When the filter uses damon_folio_young() here to evaluate access, damon_folio_young_one() checks !folio_test_idle(folio).
Since the idle flag was never set, will this evaluate to true for all folios, causing the PGIDLE_UNSET filter to unconditionally match?
Quoted 4 lines
mm/damon/paddr.c +1
-0+break ;default :break ; }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
SJ Park
maintainerRe: [RFC PATCH v2.2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type
Quoted 42 lines · On Tue, 28 Jul 2026 04:32:59 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High]DAMON_FILTER_TYPE_PGIDLE_UNSETblindly matches almost all pages when probe weights are used, rendering the filter ineffective.
- [High] The newly addedDAMON_FILTER_TYPE_PGIDLE_UNSETis not exposed in the sysfs interface, making it impossible for users to configure. ----- Patch [2]: [RFC PATCH v2.2 02/17]
mm/damon/paddr: supportPGIDLE_UNSETprobe filter type --- commit98c0d4f6b2dcc4c706f1af62a258dd827b89bc7e
Author: SJ Park <[email protected]>
mm/damon/paddr: supportPGIDLE_UNSETprobe filter typeImplement support of
DAMON_FILTER_TYPE_PGIDLE_UNSETin the physical address space DAMON operations set. It reusesdamon_folio_young(), which was being used for access monitoring.mm/damon/paddr.c static bool damon_pa_filter_match(struct damon_filter *filter, · line 135
Quoted 9 lines
mm/damon/paddr.c +1
-0@@ -132,6 +132,12 @@ static bool damon_pa_filter_match(struct damon_filter *filter, matched = filter->memcg_id ==mem_cgroup_id (memcg);rcu_read_unlock ();break ; +case DAMON_FILTER_TYPE_PGIDLE_UNSET :[Severity: High]
Is this new filter type missing from the sysfs interface mapping?Looking at damon_sysfs_filter_type_names[] in
mm/damon/sysfs.c, there is no entry forDAMON_FILTER_TYPE_PGIDLE_UNSET:mm/damon/sysfs.c:damon_sysfs_filter_type_names[] = { { .type = DAMON_FILTER_TYPE_ANON, .name = "anon", }, { .type = DAMON_FILTER_TYPE_MEMCG, .name = "memcg", }, };
Quoted 2 lines
Without an entry here, will users attempting to configure this new filter via sysfs receive
-EINVAL, making the filter unconfigurable?
A later patch of this series does that.
Quoted 21 lines
mm/damon/paddr.c static bool damon_pa_filter_match(struct damon_filter *filter, · line 139
Quoted 5 lines
mm/damon/paddr.c +4
-0+if (!folio) + matched = false; +else + matched =damon_folio_young (folio);[Severity: High]
Will this blindly match almost all folios when probe weights are used?In
kdamond_fn(), ifdamon_has_probe_weights(ctx)is true, it skipsctx->ops.prepare_access_checks():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); ... }
Quoted 8 lines
For physical addresses, this skips
damon_pa_mkold()which normally sets thePG_idleflag on folios.When the filter uses
damon_folio_young()here to evaluate access,damon_folio_young_one()checks !folio_test_idle(folio).Since the idle flag was never set, will this evaluate to true for all folios, causing the
PGIDLE_UNSETfilter to unconditionally match?
Yes, and it is intentional.
Later patches of this series add a way to automatically do such idle flag setup.
Quoted 8 lines
Quoted 5 lines
mm/damon/paddr.c +1
-0+break ;default :break ; }Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Thanks,
SJ
SJ Park
maintainerRFC PATCH 3/17 mm/damon/sysfs: support pgidle_unset probe filter type
In reply to SJ ParkExtend DAMON sysfs interface to allow users to set DAMON_FILTER_TYPE_PGIDLE_UNSET by writing 'pgidle_unset' to the probe filter type file.
--- mm/damon/sysfs.c | 4 ++++ 1 file changed, 4 insertions(+)
mm/damon/sysfs.c +4 -0
@@ -782,6 +782,10 @@ damon_sysfs_filter_type_names[] = { .type = DAMON_FILTER_TYPE_MEMCG, .name = "memcg", }, + { + .type = DAMON_FILTER_TYPE_PGIDLE_UNSET, + .name = "pgidle_unset", + }, }; static ssize_t type_show(struct kobject *kobj,
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 4/17 Docs/mm/damon/design: document pgidle_unset probe filter type
In reply to SJ ParkUpdate DAMON design document for the newly added pgidle_unset probe filter type. Also use a list for the types, as it becomes not very easy to read the whole types in a simple sentence.
--- Documentation/mm/damon/design.rst | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
Documentation/mm/damon/design.rst +6 -2
@@ -293,8 +293,12 @@ registration is made by specifying a probe per attribute. Each of the probe specifies a rule to determine if a given memory region has the related attribute. The rule is constructed with multiple filters. The filters work same to :ref:`DAMOS filters <damon_design_damos_filters>` except the supported -filter types. Currently only ``anon`` and ``memcg`` filter types are supported -for data attributes monitoring. +filter types. Currently below filter types are supported. + +- ``anon``: Same to that for DAMOS filters. +- ``memcg``: Same to that for DAMOS filters. +- ``pgidle_unset``: Matches if the page for the memory is marked as not + access-idle. If such probes are registered, DAMON executes the probes for each region's sampling memory when it does the access :ref:`sampling
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 5/17 mm/damon/core: introduce damon_prep struct
In reply to SJ ParkSome DAMON probe filter types require preparatory actions. For example, pgilde_unset probe filter can say if the page was accessed but when. To answer the second question, the PG_Idle flag should be set at a specific time. It can make life much easier if DAMON can do such preparatory actions. Introduce a new data type called damon_prep. It specifies each of the preparation actions for each probe. DAMON will execute the action for each region per sampling interval, like it clears page table accessed bits and unsets PG_Idle flag for access monitoring.
Also introduce DAMON_PREP_SET_PGIDLE as the initial prep action. As the name says, it will do exactly what DAMON was doing as the preparation action for the access monitoring.
--- include/linux/damon.h | 32 ++++++++++++++++++++++++++++++++ mm/damon/core.c | 26 ++++++++++++++++++++++++++ 2 files changed, 58 insertions(+)
include/linux/damon.h +32 -0
@@ -741,6 +741,27 @@ struct damon_intervals_goal {unsigned long max_sample_us; }; +/** +* enum damon_prep_action - DAMON probing preparation action. +* +* @DAMON_PREP_SET_PGIDLE: Set the probing memory as idle page. +*/ +enum damon_prep_action { +DAMON_PREP_SET_PGIDLE , +}; + +/** +* struct damon_prep - DAMON probing preparation request. +* +* @action: Action to do to the probing memory for the preparation. +*/ +struct damon_prep { +enum damon_prep_action action; +/* private: */ +/* siblings list. */ +struct list_head list; +}; +/** * enum damon_filter_type - Type of &struct damon_filter *
@@ -782,6 +803,8 @@ struct damon_filter {struct damon_probe {unsigned int weight;/* private: */ +/* Preparation actions to apply to each probing memory. */ +struct list_head preps;/* Filters for assessing if a given region is for this probe. */ struct list_head filters;/* Siblings list. */
@@ -961,6 +984,12 @@ static inline unsigned long damon_sz_region(struct damon_region *r)return r->ar.end - r->ar.start; } +#define damon_for_each_prep (p, probe) \ + list_for_each_entry(p, &(probe)->preps, list) + +#define damon_for_each_prep_safe (p, next, probe) \ + list_for_each_entry_safe(p, next, &(probe)->preps, list) +#define damon_for_each_filter (f, p) \ list_for_each_entry(f, &(p)->filters, list)
@@ -1014,6 +1043,9 @@ static inline unsigned long damon_sz_region(struct damon_region *r)#ifdef CONFIG_DAMON +struct damon_prep *damon_new_prep (enum damon_prep_action action); +void damon_add_prep (struct damon_probe *p,struct damon_prep *prep); +struct damon_filter *damon_new_filter (enum damon_filter_type type,bool matching,bool allow);void damon_add_filter (struct damon_probe *probe,struct damon_filter *f);
mm/damon/core.c +26 -0
@@ -111,6 +111,28 @@ int damon_select_ops(struct damon_ctx *ctx, enum damon_ops_id id)return err; } +struct damon_prep *damon_new_prep (enum damon_prep_action action) +{ +struct damon_prep *prep; + + prep =kmalloc_obj (*prep); +if (!prep) +return NULL ; + prep->action = action; +INIT_LIST_HEAD (&prep->list); +return prep; +} + +void damon_add_prep (struct damon_probe *p,struct damon_prep *prep) +{ +list_add_tail (&prep->list, &p->preps); +} + +static void damon_free_prep (struct damon_prep *p) +{ +kfree (p); +} +struct damon_filter *damon_new_filter (enum damon_filter_type type,bool matching,bool allow) {
@@ -167,6 +189,7 @@ struct damon_probe *damon_new_probe(void)if (!p)return NULL ; p->weight =0 ; +INIT_LIST_HEAD (&p->preps);INIT_LIST_HEAD (&p->filters);INIT_LIST_HEAD (&p->list);return p;
@@ -184,8 +207,11 @@ static void damon_del_probe(struct damon_probe *p)static void damon_free_probe (struct damon_probe *p) { +struct damon_prep *prep, *prep_next;struct damon_filter *f, *next; +damon_for_each_prep_safe (prep, prep_next, p) +damon_free_prep (prep);damon_for_each_filter_safe (f, next, p)damon_free_filter (f);kfree (p);
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v2.2 05/17] mm/damon/core: introduce damon_prep struct
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Medium] The newly introduced `preps` list in `struct damon_probe` is not synchronized during…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] The newly introduced preps list in struct damon_probe is not synchronized during damon_commit_probes().
- [Medium] Missing public API to remove or destroy individual damon_prep instances dynamically.
--
--- Patch [5]: [RFC PATCH v2.2 05/17] mm/damon/core: introduce damon_prep struct --- commit d7a749334ed0e3303b955b00673d30f87ca5091c
Author: SJ Park <[email protected]>
mm/damon/core: introduce damon_prep struct
Some DAMON probe filter types require preparatory actions to operate effectively, such as setting the PG_Idle flag at a specific time. This commit introduces a new data type called damon_prep to specify these preparation actions for each probe. DAMON will execute the action for each region per sampling interval.
Quoted 4 lines
include/linux/damon.h +0
-0
[ ... ]
include/linux/damon.h struct damon_filter { · line 808
Quoted 9 lines
include/linux/damon.h +2
-0@@ -780,6 +801,8 @@ struct damon_filter {struct damon_probe {unsigned int weight;/* private: */ +/* Preparation actions to apply to each probing memory. */ +struct list_head preps;/* Filters for assessing if a given region is for this probe. */ struct list_head filters;/* Siblings list. */
[Severity: Medium]
Will this preps list be synchronized when a DAMON context is updated or cloned?
Looking at damon_commit_probes() in mm/damon/core.c, it only seems to copy the weight and filters from the source probe to the destination probe:
mm/damon/core.c:damon_commit_probes() {
...
if (src_probe) {
dst_probe->weight = src_probe->weight;
err = damon_commit_filters(dst_probe, src_probe);
if (err)
return err;
} else {
damon_destroy_probe(dst_probe);
}
...
}It appears there is no logic to copy the new preps list. Could this leave the running context's preparation actions out of sync and silently discard configurations when damon_commit_ctx() is called?
Quoted 4 lines
mm/damon/core.c +0
-0
[ ... ]
Quoted 15 lines
mm/damon/core.c +11
-0@@ -111,6 +111,28 @@ int damon_select_ops(struct damon_ctx *ctx, enum damon_ops_id id)return err; } +struct damon_prep *damon_new_prep (enum damon_prep_action action) +{ +struct damon_prep *prep; + + prep =kmalloc_obj (*prep); +if (!prep) +return NULL ; + prep->action = action; +INIT_LIST_HEAD (&prep->list); +return prep; +}
mm/damon/core.c int damon_select_ops(struct damon_ctx *ctx, enum damon_ops_id id) · line 134
Quoted 10 lines
mm/damon/core.c +10
-0+ +void damon_add_prep (struct damon_probe *p,struct damon_prep *prep) +{ +list_add_tail (&prep->list, &p->preps); +} + +static void damon_free_prep (struct damon_prep *p) +{ +kfree (p); +}
[Severity: Medium]
Should there be a public API to remove or destroy individual damon_prep instances dynamically?
Since damon_add_prep() is provided to dynamically add preparation actions to a probe, it seems there might be a need for a corresponding damon_destroy_prep() or damon_del_prep(). Without exporting such functions and with damon_free_prep() restricted to static scope, is there a way for API consumers to dynamically remove or free a prep without destroying the entire probe?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
SJ Park
maintainerRe: [RFC PATCH v2.2 05/17] mm/damon/core: introduce damon_prep struct
Quoted 54 lines · On Tue, 28 Jul 2026 04:25:18 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] The newly introducedprepslist instruct damon_probeis not synchronized duringdamon_commit_probes().
- [Medium] Missing public API to remove or destroy individualdamon_prepinstances dynamically.
----- Patch [5]: [RFC PATCH v2.2 05/17]
mm/damon/core: introducedamon_prepstruct --- commitd7a749334ed0e3303b955b00673d30f87ca5091c
Author: SJ Park <[email protected]>
mm/damon/core: introducedamon_prepstructSome DAMON probe filter types require preparatory actions to operate effectively, such as setting the
PG_Idleflag at a specific time. This commit introduces a new data type calleddamon_prepto specify these preparation actions for each probe. DAMON will execute the action for each region per sampling interval.Quoted 4 lines
include/linux/damon.h +0
-0[ ... ]
include/linux/damon.h struct damon_filter { · line 808
Quoted 9 lines
include/linux/damon.h +2
-0@@ -780,6 +801,8 @@ struct damon_filter {struct damon_probe {unsigned int weight;/* private: */ +/* Preparation actions to apply to each probing memory. */ +struct list_head preps;/* Filters for assessing if a given region is for this probe. */ struct list_head filters;/* Siblings list. */ [Severity: Medium]
Will this preps list be synchronized when a DAMON context is updated or cloned?Looking at
damon_commit_probes()inmm/damon/core.c, it only seems to copy the weight and filters from the source probe to the destination probe:mm/damon/core.c:damon_commit_probes() { ... if (src_probe) { dst_probe->weight = src_probe->weight; err = damon_commit_filters(dst_probe, src_probe); if (err) return err; } else { damon_destroy_probe(dst_probe); } ... }
Quoted 3 lines
It appears there is no logic to copy the new preps list. Could this leave the running context's preparation actions out of sync and silently discard configurations when
damon_commit_ctx()is called?
A later patch of this series does that.
Quoted 38 lines
Quoted 5 lines
mm/damon/core.c +0
-0[ ... ]
Quoted 15 lines
mm/damon/core.c +11
-0@@ -111,6 +111,28 @@ int damon_select_ops(struct damon_ctx *ctx, enum damon_ops_id id)return err; } +struct damon_prep *damon_new_prep (enum damon_prep_action action) +{ +struct damon_prep *prep; + + prep =kmalloc_obj (*prep); +if (!prep) +return NULL ; + prep->action = action; +INIT_LIST_HEAD (&prep->list); +return prep; +}mm/damon/core.c int damon_select_ops(struct damon_ctx *ctx, enum damon_ops_id id) · line 134
Quoted 10 lines
mm/damon/core.c +10
-0+ +void damon_add_prep (struct damon_probe *p,struct damon_prep *prep) +{ +list_add_tail (&prep->list, &p->preps); +} + +static void damon_free_prep (struct damon_prep *p) +{ +kfree (p); +}[Severity: Medium]
Should there be a public API to remove or destroy individualdamon_prepinstances dynamically?
Quoted 6 lines
Since
damon_add_prep()is provided to dynamically add preparation actions to a probe, it seems there might be a need for a correspondingdamon_destroy_prep()ordamon_del_prep(). Without exporting such functions and withdamon_free_prep()restricted to static scope, is there a way for API consumers to dynamically remove or free a prep without destroying the entire probe?
Users will be able to do that via damon_destroy_ctx().
Quoted 3 lines
Signature · 2 lines
-- Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Thanks,
SJ
SJ Park
maintainerRFC PATCH 6/17 mm/damon/core: commit preps
In reply to SJ Parkdamon_commit_probes() is ignoring damon_prep. Commit the prep actions, too.
--- mm/damon/core.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+)
mm/damon/core.c +59 -0
@@ -128,11 +128,34 @@ void damon_add_prep(struct damon_probe *p, struct damon_prep *prep)list_add_tail (&prep->list, &p->preps); } +static void damon_del_prep (struct damon_prep *p) +{ +list_del (&p->list); +} +static void damon_free_prep (struct damon_prep *p) {kfree (p); } +static void damon_destroy_prep (struct damon_prep *p) +{ +damon_del_prep (p); +damon_free_prep (p); +} + +static struct damon_prep *damon_nth_prep (int n,struct damon_probe *p) +{ +struct damon_prep *prep; +int i =0 ; + +damon_for_each_prep (prep, p) { +if (i++ == n) +return prep; + } +return NULL ; +} +struct damon_filter *damon_new_filter (enum damon_filter_type type,bool matching,bool allow) {
@@ -1687,6 +1710,36 @@ static int damon_commit_targets(return err; } +static void damon_commit_prep (struct damon_prep *dst,struct damon_prep *src) +{ + dst->action = src->action; +} + +static int damon_commit_preps (struct damon_probe *dst,struct damon_probe *src) +{ +struct damon_prep *dst_prep, *next, *src_prep, *new_prep; +int i =0 , j =0 ; + +damon_for_each_prep_safe (dst_prep, next, dst) { + src_prep =damon_nth_prep (i++, src); +if (src_prep) +damon_commit_prep (dst_prep, src_prep); +else +damon_destroy_prep (dst_prep); + } + +damon_for_each_prep_safe (src_prep, next, src) { +if (j++ < i) +continue ; + + new_prep =damon_new_prep (src_prep->action); +if (!new_prep) +return -ENOMEM ; +damon_add_prep (dst, new_prep); + } +return 0 ; +} +static void damon_commit_filter (struct damon_filter *dst,struct damon_filter *src) {
@@ -1745,6 +1798,9 @@ static int damon_commit_probes(struct damon_ctx *dst, struct damon_ctx *src) src_probe =damon_nth_probe (i++, src);if (src_probe) { dst_probe->weight = src_probe->weight; + err =damon_commit_preps (dst_probe, src_probe); +if (err) +return err; err =damon_commit_filters (dst_probe, src_probe);if (err)return err;
@@ -1762,6 +1818,9 @@ static int damon_commit_probes(struct damon_ctx *dst, struct damon_ctx *src)return -ENOMEM ;damon_add_probe (dst, new_probe); new_probe->weight = src_probe->weight; + err =damon_commit_preps (new_probe, src_probe); +if (err) +return err; err =damon_commit_filters (new_probe, src_probe);if (err)return err;
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 7/17 mm/damon/core: introduce damon_operations->prep_probes()
In reply to SJ Parkdamon_prep needs to be executed by the underlying DAMON operation set. Extend the operation set callback list for the execution of damon_prep actions. If the underlying operation set implements the callback, DAMON core executes it in the monitoring preparation time.
--- include/linux/damon.h | 5 +++++ mm/damon/core.c | 20 +++++++++++++++++++- 2 files changed, 24 insertions(+), 1 deletion(-)
include/linux/damon.h +5 -0
@@ -629,6 +629,7 @@ enum damon_ops_id {* @update: Update operations-related data structures. * @prepare_access_checks: Prepare next access check of target regions. * @check_accesses: Check the accesses to target regions. +* @prep_probes: Prepare applying probes for each region. * @apply_probes: Apply probes for each region. * @get_scheme_score: Get the score of a region for a scheme. * @apply_scheme: Apply a DAMON-based operation scheme.
@@ -656,6 +657,9 @@ enum damon_ops_id {* last preparation and update the number of observed accesses of each region. * 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. +* @prep_probes should execute required &struct damon_prep for next &struct +* damon_probe applications to each region. It should also set +* &damon_region->sampling_addr of each region if ``set_samples`` is true. * @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 &damon_region->sampling_addr of each region if ``set_samples`` is true.
@@ -678,6 +682,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 (*prep_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,
mm/damon/core.c +19 -1
@@ -156,6 +156,18 @@ static struct damon_prep *damon_nth_prep(int n, struct damon_probe *p)return NULL ; } +static bool damon_has_prep (struct damon_ctx *c) +{ +struct damon_prep *prep; +struct damon_probe *probe; + +damon_for_each_probe (probe, c) { +damon_for_each_prep (prep, probe) +return true; + } +return false; +} +struct damon_filter *damon_new_filter (enum damon_filter_type type,bool matching,bool allow) {
@@ -3870,14 +3882,19 @@ 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); +bool do_prep;unsigned int max_merge_score =0 , max_wsum;bool get_max_wsum;if (kdamond_wait_activation (ctx))break ; + do_prep = ctx->ops.prep_probes &&damon_has_prep (ctx); +if (!access_check_disabled && ctx->ops.prepare_access_checks) ctx->ops.prepare_access_checks (ctx); +if (do_prep) + ctx->ops.prep_probes (ctx, access_check_disabled);kdamond_usleep (sample_interval); ctx->passed_sample_intervals++;
@@ -3892,7 +3909,8 @@ static int kdamond_fn(void *data)else get_max_wsum = false; max_wsum = ctx->ops.apply_probes (ctx, - access_check_disabled, get_max_wsum); + access_check_disabled && !do_prep, + get_max_wsum);if (get_max_wsum) max_merge_score = max_wsum; }
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 8/17 mm/damon/paddr: support damon_prep
In reply to SJ ParkImplement damon_operations->prep_probes() callback. Support the only existing prep action, DAMON_PREP_SET_PGIDLE in a way similar to what it was doing for the access check preparation: unset page table accessed bits and set PG_Idle flag. Reuse the function for the access check preparation.
--- mm/damon/paddr.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+)
mm/damon/paddr.c +35 -0
@@ -105,6 +105,40 @@ static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx)return max_nr_accesses; } +static void damon_pa_prep_probes_region (struct damon_region *r, +struct damon_probe *probe,struct damon_ctx *ctx) +{ +struct damon_prep *p; + +damon_for_each_prep (p, probe) { +switch (p->action) { +case DAMON_PREP_SET_PGIDLE : +damon_pa_mkold (damon_pa_phys_addr (r->sampling_addr, + ctx->addr_unit)); +break ; +default : +break ; + } + } +} + +static void damon_pa_prep_probes (struct damon_ctx *ctx,bool set_samples) +{ +struct damon_target *t; +struct damon_region *r; +struct damon_probe *p; + +damon_for_each_target (t, ctx) { +damon_for_each_region (r, t) { +if (set_samples) + r->sampling_addr =damon_rand (ctx, r->ar.start, + r->ar.end); +damon_for_each_probe (p, ctx) +damon_pa_prep_probes_region (r, p, ctx); + } + } +} +static bool damon_pa_filter_match (struct damon_filter *filter,struct folio *folio) {
@@ -448,6 +482,7 @@ static int __init damon_pa_initcall(void) .update = NULL, .prepare_access_checks = damon_pa_prepare_access_checks, .check_accesses = damon_pa_check_accesses, + .prep_probes = damon_pa_prep_probes, .apply_probes = damon_pa_apply_probes, .target_valid = NULL, .apply_scheme = damon_pa_apply_scheme,
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v2.2 08/17] mm/damon/paddr: support damon_prep
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] damon_pa_prep_probes() executes prep actions redundantly and ignores probe filters, causing…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] damon_pa_prep_probes() executes prep actions redundantly and ignores probe filters, causing excessive rmap walks and global LRU degradation. --
--- Patch [8]: [RFC PATCH v2.2 08/17] mm/damon/paddr: support damon_prep --- commit 5d5b08fab7578294743c8bbbba6c3bfa16036115
Author: SJ Park <[email protected]>
mm/damon/paddr: support damon_prep
This commit implements the damon_operations->prep_probes() callback to support the DAMON_PREP_SET_PGIDLE action. It unsets page table accessed bits and sets the PG_Idle flag, similar to what is done for access check preparation.
Quoted 4 lines
mm/damon/paddr.c +0
-0
[ ... ]
Quoted 24 lines
mm/damon/paddr.c +20
-0@@ -105,6 +105,40 @@ static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx)return max_nr_accesses; } +static void damon_pa_prep_probes_region (struct damon_region *r, +struct damon_probe *probe,struct damon_ctx *ctx) +{ +struct damon_prep *p; + +damon_for_each_prep (p, probe) { +switch (p->action) { +case DAMON_PREP_SET_PGIDLE : +damon_pa_mkold (damon_pa_phys_addr (r->sampling_addr, + ctx->addr_unit)); +break ; +default : +break ; + } + } +} + +static void damon_pa_prep_probes (struct damon_ctx *ctx,bool set_samples) +{ +struct damon_target *t;
mm/damon/paddr.c static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx) · line 137
Quoted 10 lines
mm/damon/paddr.c +10
-0+struct damon_region *r; +struct damon_probe *p; + +damon_for_each_target (t, ctx) { +damon_for_each_region (r, t) { +if (set_samples) + r->sampling_addr =damon_rand (ctx, r->ar.start, + r->ar.end); +damon_for_each_probe (p, ctx) +damon_pa_prep_probes_region (r, p, ctx);
[Severity: High]
Does this code redundantly execute damon_pa_mkold() and ignore probe filters?
In kdamond_fn(), if standard access checks are enabled, both prepare_access_checks() and prep_probes() can execute on the same tick:
if (!access_check_disabled && ctx->ops.prepare_access_checks)
ctx->ops.prepare_access_checks(ctx);
if (do_prep)
ctx->ops.prep_probes(ctx, access_check_disabled);Because prepare_access_checks() also calls damon_pa_mkold(), the subsequent iteration over all probes here unconditionally calls it again on the exact same sampling address for every probe configured with DAMON_PREP_SET_PGIDLE. Since damon_pa_mkold() performs a costly rmap_walk, this multiplies the overhead.
Additionally, this loop does not evaluate probe filters (such as MEMCG or ANON) before applying prep actions. Could this blindly clear the accessed bit for all sampled pages globally, artificially aging pages that the user explicitly excluded and degrading system-wide memory reclaim decisions?
Quoted 4 lines
mm/damon/paddr.c +4
-0+ } + } +} +
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
SJ Park
maintainerRe: [RFC PATCH v2.2 08/17] mm/damon/paddr: support damon_prep
Quoted 68 lines · On Tue, 28 Jul 2026 04:24:56 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High]damon_pa_prep_probes()executes prep actions redundantly and ignores probe filters, causing excessive rmap walks and global LRU degradation. ----- Patch [8]: [RFC PATCH v2.2 08/17]
mm/damon/paddr: supportdamon_prep--- commit5d5b08fab7578294743c8bbbba6c3bfa16036115
Author: SJ Park <[email protected]>
mm/damon/paddr: supportdamon_prepThis commit implements the
damon_operations->prep_probes()callback to support theDAMON_PREP_SET_PGIDLEaction. It unsets page table accessed bits and sets thePG_Idleflag, similar to what is done for access check preparation.Quoted 4 lines
mm/damon/paddr.c +0
-0[ ... ]
Quoted 24 lines
mm/damon/paddr.c +20
-0@@ -105,6 +105,40 @@ static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx)return max_nr_accesses; } +static void damon_pa_prep_probes_region (struct damon_region *r, +struct damon_probe *probe,struct damon_ctx *ctx) +{ +struct damon_prep *p; + +damon_for_each_prep (p, probe) { +switch (p->action) { +case DAMON_PREP_SET_PGIDLE : +damon_pa_mkold (damon_pa_phys_addr (r->sampling_addr, + ctx->addr_unit)); +break ; +default : +break ; + } + } +} + +static void damon_pa_prep_probes (struct damon_ctx *ctx,bool set_samples) +{ +struct damon_target *t;mm/damon/paddr.c static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx) · line 137
Quoted 10 lines
mm/damon/paddr.c +10
-0+struct damon_region *r; +struct damon_probe *p; + +damon_for_each_target (t, ctx) { +damon_for_each_region (r, t) { +if (set_samples) + r->sampling_addr =damon_rand (ctx, r->ar.start, + r->ar.end); +damon_for_each_probe (p, ctx) +damon_pa_prep_probes_region (r, p, ctx);[Severity: High]
Does this code redundantly executedamon_pa_mkold()and ignore probe filters?In
kdamond_fn(), if standard access checks are enabled, bothprepare_access_checks()andprep_probes()can execute on the same tick:if (!access_check_disabled && ctx->ops.prepare_access_checks) ctx->ops.prepare_access_checks(ctx); if (do_prep) ctx->ops.prep_probes(ctx, access_check_disabled);
Quoted 4 lines
Because
prepare_access_checks()also callsdamon_pa_mkold(), the subsequent iteration over all probes here unconditionally calls it again on the exact same sampling address for every probe configured withDAMON_PREP_SET_PGIDLE. Sincedamon_pa_mkold()performs a costlyrmap_walk, this multiplies the overhead.
That's true, but no problem. Sane users may not use the classic monitoring with set_pgidle prep.
Quoted 5 lines
Additionally, this loop does not evaluate probe filters (such as MEMCG or ANON) before applying prep actions. Could this blindly clear the accessed bit for all sampled pages globally, artificially aging pages that the user explicitly excluded and degrading system-wide memory reclaim decisions?
Yes, and that's the intended behavior. If user asks to set pgidle, DAMON sets pgidle.
Quoted 8 lines
Quoted 5 lines
mm/damon/paddr.c +4
-0+ } + } +} +Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Thanks,
SJ
SJ Park
maintainerRFC PATCH 9/17 mm/damon/sysfs: implement preps directory
In reply to SJ ParkImplement a sysfs directory named 'preps' under the probe directory. It will be evolved to be used for specifying probe preps.
--- mm/damon/sysfs.c | 65 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 59 insertions(+), 6 deletions(-)
mm/damon/sysfs.c +59 -6
@@ -750,6 +750,35 @@ static const struct kobj_type damon_sysfs_intervals_ktype = { .default_groups = damon_sysfs_intervals_groups, }; +/* +* preps directory +*/ + +struct damon_sysfs_preps { +struct kobject kobj; +}; + +static struct damon_sysfs_preps *damon_sysfs_preps_alloc (void ) +{ + return kzalloc_obj(struct damon_sysfs_preps); +} + +static void damon_sysfs_preps_release (struct kobject *kobj) +{ +kfree (container_of(kobj ,struct damon_sysfs_preps ,kobj )); +} + +static struct attribute *damon_sysfs_preps_attrs[] = { +NULL , +}; +ATTRIBUTE_GROUPS (damon_sysfs_preps); + +static const struct kobj_type damon_sysfs_preps_ktype = { + .release = damon_sysfs_preps_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = damon_sysfs_preps_groups, +}; +/* * filter directory */
@@ -1070,6 +1099,7 @@ static const struct kobj_type damon_sysfs_filters_ktype = {struct damon_sysfs_probe {struct kobject kobj;unsigned int weight; +struct damon_sysfs_preps *preps;struct damon_sysfs_filters *filters; };
@@ -1080,25 +1110,48 @@ static struct damon_sysfs_probe *damon_sysfs_probe_alloc(void)static int damon_sysfs_probe_add_dirs (struct damon_sysfs_probe *probe) { +struct damon_sysfs_preps *preps;struct damon_sysfs_filters *filters;int err; - filters =damon_sysfs_filters_alloc (); -if (!filters) + preps =damon_sysfs_preps_alloc (); +if (!preps)return -ENOMEM ; + probe->preps = preps; + + err =kobject_init_and_add (&preps->kobj, &damon_sysfs_preps_ktype, + &probe->kobj,"preps" ); +if (err) + goto put_preps_out; + + filters =damon_sysfs_filters_alloc (); +if (!filters) { + err = -ENOMEM ; + goto del_preps_out; + } probe->filters = filters; err =kobject_init_and_add (&filters->kobj, &damon_sysfs_filters_ktype, &probe->kobj,"filters" ); -if (err) { -kobject_put (&filters->kobj); - probe->filters =NULL ; - } +if (err) + goto put_filters_out; +return err; + +put_filters_out: +kobject_put (&filters->kobj); + probe->filters =NULL ; +del_preps_out: +kobject_del (&preps->kobj); +put_preps_out: +kobject_put (&preps->kobj); + probe->preps =NULL ;return err; }static void damon_sysfs_probe_rm_dirs (struct damon_sysfs_probe *probe) { +if (probe->preps) +kobject_put (&probe->preps->kobj);if (probe->filters) {damon_sysfs_filters_rm_dirs (probe->filters);kobject_put (&probe->filters->kobj);
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 10/17 mm/damon/sysfs: implement preps/nr_preps file
In reply to SJ ParkImplement nr_preps file under the preps directory. It will be evolved to be used for generating sub directories that will represent each probe preparation action.
--- mm/damon/sysfs.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-)
mm/damon/sysfs.c +52 -1
@@ -756,6 +756,7 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {struct damon_sysfs_preps {struct kobject kobj; +int nr; };static struct damon_sysfs_preps *damon_sysfs_preps_alloc (void )
@@ -763,12 +764,60 @@ static struct damon_sysfs_preps *damon_sysfs_preps_alloc(void) return kzalloc_obj(struct damon_sysfs_preps); } +static void damon_sysfs_preps_rm_dirs (struct damon_sysfs_preps *preps) +{ + preps->nr =0 ; +} + +static int damon_sysfs_preps_add_dirs (struct damon_sysfs_preps *preps, +int nr_preps) +{ + preps->nr = nr_preps; +return 0 ; +} + +static ssize_t nr_preps_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_preps *preps =container_of (kobj, + struct damon_sysfs_preps, kobj); + +return sysfs_emit (buf,"%d\n" , preps->nr); +} + +static ssize_t nr_preps_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_preps *preps; +int nr, err =kstrtoint (buf,0 , &nr); + +if (err) +return err; +if (nr <0 ) +return -EINVAL ; + + preps = container_of(kobj, struct damon_sysfs_preps, kobj); + +if (!mutex_trylock (&damon_sysfs_lock)) +return -EBUSY ; + err =damon_sysfs_preps_add_dirs (preps, nr); +mutex_unlock (&damon_sysfs_lock); +if (err) +return err; + +return count; +} +static void damon_sysfs_preps_release (struct kobject *kobj) {kfree (container_of(kobj ,struct damon_sysfs_preps ,kobj )); } +static struct kobj_attribute damon_sysfs_preps_nr_attr = +__ATTR_RW_MODE (nr_preps,0600 ); +static struct attribute *damon_sysfs_preps_attrs[] = { + &damon_sysfs_preps_nr_attr.attr,NULL , };ATTRIBUTE_GROUPS (damon_sysfs_preps);
@@ -1150,8 +1199,10 @@ static int damon_sysfs_probe_add_dirs(struct damon_sysfs_probe *probe)static void damon_sysfs_probe_rm_dirs (struct damon_sysfs_probe *probe) { -if (probe->preps) +if (probe->preps) { +damon_sysfs_preps_rm_dirs (probe->preps);kobject_put (&probe->preps->kobj); + }if (probe->filters) {damon_sysfs_filters_rm_dirs (probe->filters);kobject_put (&probe->filters->kobj);
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 11/17 mm/damon/sysfs: create directories for nr_preps writes
In reply to SJ ParkImplement nr_preps write action to actually create subdirectories of the number. Each of the directory will be evolved to represent each probe preparation action.
--- mm/damon/sysfs.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-)
mm/damon/sysfs.c +79 -1
@@ -750,12 +750,50 @@ static const struct kobj_type damon_sysfs_intervals_ktype = { .default_groups = damon_sysfs_intervals_groups, }; +/* +* prep directory +*/ + +struct damon_sysfs_prep { +struct kobject kobj; +}; + +static struct damon_sysfs_prep *damon_sysfs_prep_alloc (void ) +{ +struct damon_sysfs_prep *prep; + + prep = kzalloc_obj(struct damon_sysfs_prep); +if (!prep) +return prep; +return prep; +} + +static void damon_sysfs_prep_release (struct kobject *kobj) +{ +struct damon_sysfs_prep *prep =container_of (kobj, + struct damon_sysfs_prep, kobj); + +kfree (prep); +} + +static struct attribute *damon_sysfs_prep_attrs[] = { +NULL , +}; +ATTRIBUTE_GROUPS (damon_sysfs_prep); + +static const struct kobj_type damon_sysfs_prep_ktype = { + .release = damon_sysfs_prep_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = damon_sysfs_prep_groups, +}; +/* * preps directory */ struct damon_sysfs_preps {struct kobject kobj; +struct damon_sysfs_prep **preps_arr;int nr; };
@@ -766,13 +804,53 @@ static struct damon_sysfs_preps *damon_sysfs_preps_alloc(void)static void damon_sysfs_preps_rm_dirs (struct damon_sysfs_preps *preps) { +struct damon_sysfs_prep **preps_arr = preps->preps_arr; +int i; + +for (i =0 ; i < preps->nr; i++) { +kobject_del (&preps_arr[i]->kobj); +kobject_put (&preps_arr[i]->kobj); + } preps->nr =0 ; +kfree (preps_arr); + preps->preps_arr =NULL ; }static int damon_sysfs_preps_add_dirs (struct damon_sysfs_preps *preps,int nr_preps) { - preps->nr = nr_preps; +struct damon_sysfs_prep **preps_arr, *prep; +int err, i; + +damon_sysfs_preps_rm_dirs (preps); +if (!nr_preps) +return 0 ; + + preps_arr =kmalloc_objs (*preps_arr, nr_preps, +GFP_KERNEL | __GFP_NOWARN); +if (!preps_arr) +return -ENOMEM ; + preps->preps_arr = preps_arr; + +for (i =0 ; i < nr_preps; i++) { + prep =damon_sysfs_prep_alloc (); +if (!prep) { +damon_sysfs_preps_rm_dirs (preps); +return -ENOMEM ; + } + + err =kobject_init_and_add (&prep->kobj, + &damon_sysfs_prep_ktype, &preps->kobj,"%d" , + i); +if (err) { +kobject_put (&prep->kobj); +damon_sysfs_preps_rm_dirs (preps); +return err; + } + + preps_arr[i] = prep; + preps->nr++; + }return 0 ; }
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 12/17 mm/damon/sysfs: implement prep_action file
In reply to SJ ParkAdd a file named prep_action under the prep directory. It represents the corresponding probe preparation action.
--- mm/damon/sysfs.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+)
mm/damon/sysfs.c +57 -0
@@ -756,6 +756,7 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {struct damon_sysfs_prep {struct kobject kobj; +enum damon_prep_action action; };static struct damon_sysfs_prep *damon_sysfs_prep_alloc (void )
@@ -765,9 +766,61 @@ static struct damon_sysfs_prep *damon_sysfs_prep_alloc(void) prep = kzalloc_obj(struct damon_sysfs_prep);if (!prep)return prep; + prep->action =DAMON_PREP_SET_PGIDLE ;return prep; } +struct damon_sysfs_prep_action_name { +const enum damon_prep_action action; +const char *name; +}; + +static const struct damon_sysfs_prep_action_name +damon_sysfs_prep_action_names[] = { + { + .action =DAMON_PREP_SET_PGIDLE , + .name ="set_pgidle" , + }, +}; + +static ssize_t prep_action_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +struct damon_sysfs_prep *prep =container_of (kobj, + struct damon_sysfs_prep, kobj); +int i; + +for (i =0 ; i <ARRAY_SIZE (damon_sysfs_prep_action_names); i++) { +const struct damon_sysfs_prep_action_name *action_name; + + action_name = &damon_sysfs_prep_action_names[i]; +if (action_name->action == prep->action) +return sysfs_emit (buf,"%s\n" , action_name->name); + } +return -EINVAL ; +} + +static ssize_t prep_action_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_prep *prep =container_of (kobj, + struct damon_sysfs_prep, kobj); +ssize_t ret = -EINVAL ; +int i; + +for (i =0 ; i <ARRAY_SIZE (damon_sysfs_prep_action_names); i++) { +const struct damon_sysfs_prep_action_name *action_name; + + action_name = &damon_sysfs_prep_action_names[i]; +if (sysfs_streq (buf, action_name->name)) { + prep->action = action_name->action; + ret = count; +break ; + } + } +return ret; +} +static void damon_sysfs_prep_release (struct kobject *kobj) { struct damon_sysfs_prep *prep = container_of(kobj,
@@ -776,7 +829,11 @@ static void damon_sysfs_prep_release(struct kobject *kobj)kfree (prep); } +static struct kobj_attribute damon_sysfs_prep_prep_action_attr = +__ATTR_RW_MODE (prep_action,0600 ); +static struct attribute *damon_sysfs_prep_attrs[] = { + &damon_sysfs_prep_prep_action_attr.attr,NULL , };ATTRIBUTE_GROUPS (damon_sysfs_prep);
Signature · 1 line
2.47.3
[email protected]
AI reviewRe: [RFC PATCH v2.2 12/17] mm/damon/sysfs: implement prep_action file
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The `prep_action` configuration is completely ignored and never applied to the DAMON core. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The prep_action configuration is completely ignored and never applied to the DAMON core. --
--- Patch [12]: [RFC PATCH v2.2 12/17] mm/damon/sysfs: implement prep_action file --- commit 5572380654e6a74889b64fc57510a982daf24d8e
Author: SJ Park <[email protected]>
mm/damon/sysfs: implement prep_action file
Add a file named prep_action under the prep directory. It represents the corresponding probe preparation action.
Quoted 12 lines
mm/damon/sysfs.c +1
-0@@ -756,6 +756,7 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {struct damon_sysfs_prep {struct kobject kobj; +enum damon_prep_action action; };static struct damon_sysfs_prep *damon_sysfs_prep_alloc (void )
[ ... ]
Quoted 4 lines
mm/damon/sysfs.c +4
-0+static ssize_t prep_action_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ + struct damon_sysfs_prep *prep = container_of(kobj,
mm/damon/sysfs.c static struct damon_sysfs_prep *damon_sysfs_prep_alloc(void) · line 816
Quoted 10 lines
mm/damon/sysfs.c +10
-0+ struct damon_sysfs_prep, kobj); +ssize_t ret = -EINVAL ; +int i; + +for (i =0 ; i <ARRAY_SIZE (damon_sysfs_prep_action_names); i++) { +const struct damon_sysfs_prep_action_name *action_name; + + action_name = &damon_sysfs_prep_action_names[i]; +if (sysfs_streq (buf, action_name->name)) { + prep->action = action_name->action;
[Severity: Medium]
Are we missing the logic to apply this configuration to the DAMON core?
Looking at damon_sysfs_set_probe(), it commits sysfs configurations to a probe by calling damon_sysfs_set_filters(), but it appears to skip the preps directory entirely:
static int damon_sysfs_set_probe(struct damon_probe *probe,
struct damon_sysfs_probe *sys_probe)
{
struct damon_sysfs_filters *sys_filters;
sys_filters = sys_probe->filters;
if (!sys_filters)
return 0;
return damon_sysfs_set_filters(probe, sys_filters);
}Does this mean the prep_action configuration is never applied when a user commits the context?
Quoted 6 lines
mm/damon/sysfs.c +6
-0+ ret = count; +break ; + } + } +return ret; +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
SJ Park
maintainerRe: [RFC PATCH v2.2 12/17] mm/damon/sysfs: implement prep_action file
Quoted 61 lines · On Tue, 28 Jul 2026 04:23:45 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Theprep_actionconfiguration is completely ignored and never applied to the DAMON core. ----- Patch [12]: [RFC PATCH v2.2 12/17]
mm/damon/sysfs: implementprep_actionfile --- commit5572380654e6a74889b64fc57510a982daf24d8e
Author: SJ Park <[email protected]>
mm/damon/sysfs: implementprep_actionfileAdd a file named
prep_actionunder the prep directory. It represents the corresponding probe preparation action.Quoted 12 lines
mm/damon/sysfs.c +1
-0@@ -756,6 +756,7 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {struct damon_sysfs_prep {struct kobject kobj; +enum damon_prep_action action; };static struct damon_sysfs_prep *damon_sysfs_prep_alloc (void )[ ... ]
Quoted 4 lines
mm/damon/sysfs.c +4
-0+static ssize_t prep_action_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ + struct damon_sysfs_prep *prep = container_of(kobj,mm/damon/sysfs.c static struct damon_sysfs_prep *damon_sysfs_prep_alloc(void) · line 816
Quoted 10 lines
mm/damon/sysfs.c +10
-0+ struct damon_sysfs_prep, kobj); +ssize_t ret = -EINVAL ; +int i; + +for (i =0 ; i <ARRAY_SIZE (damon_sysfs_prep_action_names); i++) { +const struct damon_sysfs_prep_action_name *action_name; + + action_name = &damon_sysfs_prep_action_names[i]; +if (sysfs_streq (buf, action_name->name)) { + prep->action = action_name->action;[Severity: Medium]
Are we missing the logic to apply this configuration to the DAMON core?Looking at
damon_sysfs_set_probe(), it commits sysfs configurations to a probe by callingdamon_sysfs_set_filters(), but it appears to skip the preps directory entirely:static int damon_sysfs_set_probe(struct
damon_probe*probe,
structdamon_sysfs_probe*sys_probe){ struct damon_sysfs_filters *sys_filters; sys_filters = sys_probe->filters; if (!sys_filters) return 0; return damon_sysfs_set_filters(probe, sys_filters); }
Quoted 2 lines
Does this mean the
prep_actionconfiguration is never applied when a user commits the context?
A later patch of this series does that.
Quoted 10 lines
Quoted 7 lines
mm/damon/sysfs.c +6
-0+ ret = count; +break ; + } + } +return ret; +}Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=12
Thanks,
SJ
SJ Park
maintainerRFC PATCH 13/17 mm/damon/sysfs: pass preps to DAMON core
In reply to SJ ParkDAMON sysfs interface provides the files for setting DAMON probe preps. But the underlying code is not really passing the user-set values to DAMON core. Pass those.
--- mm/damon/sysfs.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
mm/damon/sysfs.c +25 -0
@@ -2176,6 +2176,23 @@ static int damon_sysfs_set_attrs(struct damon_ctx *ctx,return damon_set_attrs (ctx, &attrs); } +static int damon_sysfs_set_preps (struct damon_probe *probe, +struct damon_sysfs_preps *sys_preps) +{ +int i; + +for (i =0 ; i < sys_preps->nr; i++) { +struct damon_sysfs_prep *sys_prep = sys_preps->preps_arr[i]; +struct damon_prep *prep; + + prep =damon_new_prep (sys_prep->action); +if (!prep) +return -ENOMEM ; +damon_add_prep (probe, prep); + } +return 0 ; +} +static int damon_sysfs_set_filters (struct damon_probe *probe,struct damon_sysfs_filters *sys_filters) {
@@ -2211,7 +2228,15 @@ static int damon_sysfs_set_probe(struct damon_probe *probe, struct damon_sysfs_probe *sys_probe) {struct damon_sysfs_filters *sys_filters; +struct damon_sysfs_preps *sys_preps; +int err; + sys_preps = sys_probe->preps; +if (sys_preps) { + err =damon_sysfs_set_preps (probe, sys_preps); +if (err) +return err; + } sys_filters = sys_probe->filters;if (!sys_filters)return 0 ;
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 14/17 selftests/damon/sysfs.sh: test probe prep sysfs files
In reply to SJ ParkAdd basic file operations test for newly introduced DAMON probe prep sysfs directories and files.
--- tools/testing/selftests/damon/sysfs.sh | 27 ++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
tools/testing/selftests/damon/sysfs.sh +27 -0
@@ -361,6 +361,32 @@ test_intervals() test_intervals_goal "$intervals_dir/intervals_goal" } +test_damon_prep() +{ + damon_prep_dir=$1 + ensure_file "$damon_prep_dir/prep_action" "exist" "600" + ensure_write_succ "$damon_prep_dir/prep_action" "set_pgidle" \ + "valid input" + ensure_write_fail "$damon_prep_dir/prep_action" "foo" "invalid input" +} + +test_damon_preps() +{ + preps_dir=$1 + ensure_dir "$preps_dir" "exist" + ensure_file "$preps_dir/nr_preps" "exist" "600" + ensure_write_succ "$preps_dir/nr_preps" "1" "valid input" + test_damon_prep "$preps_dir/0" + + ensure_write_succ "$preps_dir/nr_preps" "2" "valid input" + test_damon_prep "$preps_dir/0" + test_damon_prep "$preps_dir/1" + + ensure_write_succ "$preps_dir/nr_preps" "0" "valid input" + ensure_dir "$preps_dir/0" "not_exist" + ensure_dir "$preps_dir/1" "not_exist" +} + test_damon_filter() { damon_filter_dir=$1
@@ -392,6 +418,7 @@ test_probe() { probe_dir=$1 ensure_dir "$probe_dir" "exist" + test_damon_preps "$probe_dir/preps" test_damon_filters "$probe_dir/filters" }
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 15/17 Docs/mm/damon/design: document probe preps
In reply to SJ ParkUpdate DAMON design document for the newly added DAMON probe preps feature.
--- Documentation/mm/damon/design.rst | 7 +++++++ 1 file changed, 7 insertions(+)
Documentation/mm/damon/design.rst +7 -0
@@ -309,6 +309,13 @@ Users can therefore know how much of a given DAMON region has a specific data attribute by reading the per-region per-probe probe hits counter after each aggregation interval. +Users can optionally register probing preparation actions per probe. If such +actions are registered, DAMON applies the actions to each region's sampling +memory before starting the next sampling interval. Currently only one action, +``set_pgidle`` is supported. The action marks the page for the probing target +memory as access-idle. This can be useful to be used together with +``pgidle_unset`` probe filter. + This is a sampling based mechanism. Hence, it is lightweight but the output may include some measurement errors. The output should be used with good understanding of statistics.
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 16/17 Docs/admin-guide/mm/damon/usage: document probe preps sysfs files
In reply to SJ ParkUpdate DAMON usage document for the newly added DAMON probe preps sysfs files.
--- Documentation/admin-guide/mm/damon/usage.rst | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-)
Documentation/admin-guide/mm/damon/usage.rst +15 -3
@@ -74,6 +74,9 @@ comma (","). │ │ │ │ │ │ nr_regions/min,max │ │ │ │ │ │ :ref:`probes <damon_usage_sysfs_probes>`/nr_probes │ │ │ │ │ │ │ 0/weight + │ │ │ │ │ │ │ │ preps/nr_preps + │ │ │ │ │ │ │ │ │ 0/prep_action + │ │ │ │ │ │ │ │ │ ... │ │ │ │ │ │ │ │ filters/nr_filters │ │ │ │ │ │ │ │ │ 0/type,matching,allow,path │ │ │ │ │ │ │ │ │ ...
@@ -283,9 +286,18 @@ In the beginning, this directory has only one file, ``nr_probes``. Writing a number (``N``) to the file creates the number of child directories named ``0`` to ``N-1``. Each directory represents each monitoring probe. -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. +In each probe directory, two directories, ``preps`` and ``filters`` exist. The +directories contain files for installing probing preparation actions and +filters for the probe, that are used to determine the data attribute for the +probe. + +In the beginning, ``preps`` directory has only one file, ``nr_preps``. +Writing a number (``N``) to the file creates the number of child directories +named ``0`` to ``N-1``. Each directory represents each preparation action. +Each directory has one file, ``prep_action``. The preparation action can be +selected by writing the name of the action to the ``prep_action`` file. Refer +to the :ref:`design doc <damon_design_data_attrs_monitoring>` for the list of +supported actions. Each probe directory also contains ``weight`` file. Reading from and writing to the file gets and sets the :ref:`attributes-only monitoring
Signature · 1 line
2.47.3
SJ Park
maintainerRFC PATCH 17/17 Docs/ABI/damon: document probe prep sysfs files
In reply to SJ ParkUpdate DAMON ABI document for the newly added DAMON probe prep sysfs files.
--- Documentation/ABI/testing/sysfs-kernel-mm-damon | 13 +++++++++++++ 1 file changed, 13 insertions(+)
Documentation/ABI/testing/sysfs-kernel-mm-damon +13 -0
@@ -173,6 +173,19 @@ 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>/preps/nr_preps +Date: Jun 2026 +Contact: SJ Park <[email protected]> +Description: Writing a number 'N' to this file creates the number of + directories for each DAMON probing preparation action named '0' + to 'N-1' under the preps/ directory. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/monitoring_attrs/probes/<P>/preps/<R>/prep_action +Date: Jun 2026 +Contact: SJ Park <[email protected]> +Description: Writing to and reading from this file sets and gets the probing + preparation action. + 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