Skip to contentSkip to conversation

mm/damon: introduce data access-as-a-data attribute

RFC PATCH In review SJ Park 2 participants 34 messages Jul 26

Subsystems (5)
lore
Share & tools
lore

SJ Park

author maintainer
#0 lore raw

v2 cover 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 ms

Start 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 ms

After 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 ms

Start 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 ms

Patches 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 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 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: create probe preps directory mm/damon/sysfs: implement probe prep directory mm/damon/sysfs: create probe prep files for preps/nr file write 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                         |  42 ++-
 mm/damon/core.c                               | 103 ++++++-
 mm/damon/paddr.c                              |  41 +++
 mm/damon/sysfs.c                              | 280 +++++++++++++++++-
 tools/testing/selftests/damon/sysfs.sh        |  27 ++
 8 files changed, 525 insertions(+), 14 deletions(-)

base-commit: 4737efca4039cb5fe50569ea3ffb18c389483810

Signature · 1 line
2.47.3
author maintainer
#1 lore raw

RFC PATCH v2 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
index 8ad6ef2e063de..cee4b74761081 100644
@@ -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
author maintainer
#2 lore raw

RFC PATCH v2 2/17 mm/damon/paddr: support PGIDLE_UNSET probe filter type

In reply to SJ Park

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 | 6 ++++++
 1 file changed, 6 insertions(+)
mm/damon/paddr.c +6 -0
index 5a6a78054784a..199de1463fa06 100644
@@ -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
#3 lore raw

Re: [RFC PATCH v2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The newly introduced DAMON_FILTER_TYPE_PGIDLE_UNSET probe filter type is completely inaccessible…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The newly introduced DAMON_FILTER_TYPE_PGIDLE_UNSET probe filter type is completely inaccessible from userspace because it was omitted from the sysfs string mappings. --

--- Patch [2]: [RFC PATCH v2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type --- commit 28cc087ac53ca1eb5ea0ff45e8fd4a6108a12c9f
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
index 5a6a78054784a..199de1463fa06 100644
@@ -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: Medium]
Will this new filter type be inaccessible from userspace?

The DAMON_FILTER_TYPE_PGIDLE_UNSET filter type appears to be missing from the damon_sysfs_filter_type_names array in mm/damon/sysfs.c:

static const struct damon_sysfs_filter_type_name

damon_sysfs_filter_type_names[] = {
	{
		.type = DAMON_FILTER_TYPE_ANON,
		.name = "anon",
	},
	{
		.type = DAMON_FILTER_TYPE_MEMCG,
		.name = "memcg",
	},
};

Without adding it here (for example, as "pgidle_unset"), won't userspace attempts to configure this filter via sysfs be rejected with -EINVAL, effectively making it unusable?

Quoted 8 lines
mm/damon/paddr.c +5 -0
+		if (!folio)
+			matched = false;
+		else
+			matched = damon_folio_young(folio);
+		break;
 	default:
 		break;
 	}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
author maintainer
#4 lore raw

Re: [RFC PATCH v2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type

Quoted 42 lines · On Sun, 26 Jul 2026 17:53:33 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The newly introduced DAMON_FILTER_TYPE_PGIDLE_UNSET probe filter type is completely inaccessible from userspace because it was omitted from the sysfs string mappings. --

--- Patch [2]: [RFC PATCH v2 02/17] mm/damon/paddr: support PGIDLE_UNSET probe filter type --- commit 28cc087ac53ca1eb5ea0ff45e8fd4a6108a12c9f
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
index 5a6a78054784a..199de1463fa06 100644
@@ -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: Medium]
Will this new filter type be inaccessible from userspace?

The DAMON_FILTER_TYPE_PGIDLE_UNSET filter type appears to be missing from the damon_sysfs_filter_type_names array in mm/damon/sysfs.c:

static const struct damon_sysfs_filter_type_name

damon_sysfs_filter_type_names[] = {
	{
		.type = DAMON_FILTER_TYPE_ANON,
		.name = "anon",
	},
	{
		.type = DAMON_FILTER_TYPE_MEMCG,
		.name = "memcg",
	},
};
Quoted 3 lines

Without adding it here (for example, as "pgidle_unset"), won't userspace attempts to configure this filter via sysfs be rejected with -EINVAL, effectively making it unusable?

A later patch of this series does that.

Quoted 12 lines
Quoted 9 lines
mm/damon/paddr.c +5 -0
+		if (!folio)
+			matched = false;
+		else
+			matched = damon_folio_young(folio);
+		break;
 	default:
 		break;
 	}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2

Thanks,
SJ

author maintainer
#5 lore raw

RFC PATCH v2 3/17 mm/damon/sysfs: support pgidle_unset probe filter type

In reply to SJ Park

Extend 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
index 053ba2e53b969..376c6ecbd4bf3 100644
@@ -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
author maintainer
#6 lore raw

RFC PATCH v2 4/17 Docs/mm/damon/design: document pgidle_unset probe filter type

In reply to SJ Park

Update 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
index a8c163475ef2b..c4830bd09498d 100644
@@ -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
author maintainer
#7 lore raw

RFC PATCH v2 5/17 mm/damon/core: introduce damon_prep struct

In reply to SJ Park

Some 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
index cee4b74761081..255b20e44287f 100644
@@ -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, prep) \
+	list_for_each_entry(p, &(prep)->preps, list)
+
+#define damon_for_each_prep_safe(p, next, prep) \
+	list_for_each_entry_safe(p, next, &(prep)->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
index 5eb0400d5ce16..bda61f9ec0266 100644
@@ -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
#8 lore raw

Re: [RFC PATCH v2 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] Missing synchronization of the `preps` list during DAMON context commit operations. - [Low] The…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] Missing synchronization of the preps list during DAMON context commit operations.
- [Low] The parameter names in damon_for_each_prep and damon_for_each_prep_safe are reversed compared to their semantic meaning. --

--- Patch [5]: [RFC PATCH v2 05/17] mm/damon/core: introduce damon_prep struct --- commit 9f7bafc6bbe2ee2b7391d751512d413fcf3bdf98
Author: SJ Park <[email protected]>

mm/damon/core: introduce damon_prep struct

This commit introduces a new data type damon_prep to specify preparation actions for DAMON probes. It adds lists and iteration macros for these actions, as well as an initial action DAMON_PREP_SET_PGIDLE.

Quoted 4 lines
include/linux/damon.h +0 -0
index a8bb9ee6979e3..24b362fcf53b1 100644

[ ... ]

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]
Since this patch introduces the preps list to struct damon_probe, should damon_commit_probes() in mm/damon/core.c be updated to synchronize this new list?

Currently, damon_commit_probes() copies probe parameters and filters, but it appears to omit the preps list. If a context is updated via damon_commit_ctx(), wouldn't any configured preparation actions be silently dropped for new probes, and existing probes fail to update their preps lists?

For example:

mm/damon/core.c:damon_commit_probes() {
    ...
    damon_for_each_probe_safe(dst_probe, next, dst) {
        ...
        err = damon_commit_filters(dst_probe, src_probe);
        ...
    }

    damon_for_each_probe_safe(src_probe, next, src) {
        ...
        new_probe = damon_new_probe();
        ...
        err = damon_commit_filters(new_probe, src_probe);
    }
    return 0;
}

[ ... ]

include/linux/damon.h static inline unsigned long damon_sz_region(struct damon_region *r) · line 990

Quoted 10 lines
include/linux/damon.h +6 -0
@@ -959,6 +982,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, prep) \
+	list_for_each_entry(p, &(prep)->preps, list)
+
+#define damon_for_each_prep_safe(p, next, prep) \
+	list_for_each_entry_safe(p, next, &(prep)->preps, list)
+

[Severity: Low]
Are the macro parameter names here reversed compared to their semantic meaning?

The parameter 'p' is used as the list iterator (which represents a prep), and 'prep' is used as the parent structure (which represents a probe). This differs from the convention used in damon_for_each_filter(f, p).

Will this force usage like damon_for_each_prep_safe(prep, prep_next, p), which could be confusing to callers?

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

Re: [RFC PATCH v2 05/17] mm/damon/core: introduce damon_prep struct

Quoted 44 lines · On Sun, 26 Jul 2026 17:52:27 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] Missing synchronization of the preps list during DAMON context commit operations.
- [Low] The parameter names in damon_for_each_prep and damon_for_each_prep_safe are reversed compared to their semantic meaning. --

--- Patch [5]: [RFC PATCH v2 05/17] mm/damon/core: introduce damon_prep struct --- commit 9f7bafc6bbe2ee2b7391d751512d413fcf3bdf98
Author: SJ Park <[email protected]>

mm/damon/core: introduce damon_prep struct

This commit introduces a new data type damon_prep to specify preparation actions for DAMON probes. It adds lists and iteration macros for these actions, as well as an initial action DAMON_PREP_SET_PGIDLE.

Quoted 4 lines
include/linux/damon.h +0 -0
index a8bb9ee6979e3..24b362fcf53b1 100644

[ ... ]

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]
Since this patch introduces the preps list to struct damon_probe, should damon_commit_probes() in mm/damon/core.c be updated to synchronize this new list?

Currently, damon_commit_probes() copies probe parameters and filters, but it appears to omit the preps list. If a context is updated via damon_commit_ctx(), wouldn't any configured preparation actions be silently dropped for new probes, and existing probes fail to update their preps lists?

For example:

Quoted 16 lines
mm/damon/core.c:damon_commit_probes() {
    ...
    damon_for_each_probe_safe(dst_probe, next, dst) {
        ...
        err = damon_commit_filters(dst_probe, src_probe);
        ...
    }

    damon_for_each_probe_safe(src_probe, next, src) {
        ...
        new_probe = damon_new_probe();
        ...
        err = damon_commit_filters(new_probe, src_probe);
    }
    return 0;
}

A later patch of this series does that.

Quoted 17 lines

[ ... ]

include/linux/damon.h static inline unsigned long damon_sz_region(struct damon_region *r) · line 990

Quoted 10 lines
include/linux/damon.h +6 -0
@@ -959,6 +982,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, prep) \
+	list_for_each_entry(p, &(prep)->preps, list)
+
+#define damon_for_each_prep_safe(p, next, prep) \
+	list_for_each_entry_safe(p, next, &(prep)->preps, list)
+

[Severity: Low]
Are the macro parameter names here reversed compared to their semantic meaning?

Quoted 6 lines

The parameter 'p' is used as the list iterator (which represents a prep), and 'prep' is used as the parent structure (which represents a probe). This differs from the convention used in damon_for_each_filter(f, p).

Will this force usage like damon_for_each_prep_safe(prep, prep_next, p), which could be confusing to callers?

Good catch! I will s/prep/probe/ like below.

'''

include/linux/damon.h +4 -4
@@ -1123,11 +1123,11 @@ static inline unsigned long damon_sz_region(struct damon_region *r)
        return r->ar.end - r->ar.start;
 }
 
-#define damon_for_each_prep(p, prep) \
-       list_for_each_entry(p, &(prep)->preps, list)
+#define damon_for_each_prep(p, probe) \
+       list_for_each_entry(p, &(probe)->preps, list)
 
-#define damon_for_each_prep_safe(p, next, prep) \
-       list_for_each_entry_safe(p, next, &(prep)->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)

'''

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

Thanks,
SJ

author maintainer
#10 lore raw

RFC PATCH v2 6/17 mm/damon/core: commit preps

In reply to SJ Park

damon_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
index bda61f9ec0266..c74dee56efee8 100644
@@ -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)
 {
@@ -1694,6 +1717,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)
 {
@@ -1752,6 +1805,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;
@@ -1769,6 +1825,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
author maintainer
#11 lore raw

RFC PATCH v2 7/17 mm/damon/core: introduce damon_operations->prep_probes()

In reply to SJ Park

damon_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 |  4 ++++
 mm/damon/core.c       | 18 +++++++++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)
include/linux/damon.h +4 -0
index 255b20e44287f..f5b0f16305b30 100644
@@ -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,8 @@ 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.
  * @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 +681,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 +17 -1
index c74dee56efee8..bd2dc702a9811 100644
@@ -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)
 {
@@ -3868,6 +3880,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);
+		bool do_prep = damon_has_prep(ctx) && ctx->ops.prep_probes;
 		unsigned int max_merge_score = 0, max_wsum;
 		bool get_max_wsum;
 
@@ -3876,6 +3889,8 @@ static int kdamond_fn(void *data)
 
 		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++;
@@ -3890,7 +3905,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
#12 lore raw

Re: [RFC PATCH v2 07/17] mm/damon/core: introduce damon_operations->prep_probes()

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] TOCTOU race in `kdamond_fn` across blocking wait leads to NULL pointer dereference of…

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] TOCTOU race in kdamond_fn across blocking wait leads to NULL pointer dereference of ctx->ops.prep_probes.
- [Medium] Silent bypass of preparation actions when unsupported by operations set.
- [Low] API Contract Omission: prep_probes documentation fails to specify the requirement to set sampling_addr. --

--- Patch [7]: [RFC PATCH v2 07/17] mm/damon/core: introduce damon_operations->prep_probes() --- commit f3f60f13684ba2645da0754240dfe010fa41b859
Author: SJ Park <[email protected]>

mm/damon/core: introduce damon_operations->prep_probes()

damon_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.

Quoted 4 lines
include/linux/damon.h +0 -0
index 24b362fcf53b1..fe2c6b56d1d53 100644

[ ... ]

include/linux/damon.h enum damon_ops_id { · line 659

Quoted 6 lines
include/linux/damon.h +2 -0
@@ -654,6 +655,8 @@ 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.

[Severity: Low]
Does this documentation need to specify that @prep_probes is responsible for setting the sampling_addr?

Looking at kdamond_fn(), when do_prep and access_check_disabled are both true, apply_probes() receives false for its set_samples parameter:

kdamond_fn() {
...

        if (do_prep)
                ctx->ops.prep_probes(ctx, access_check_disabled);
...
                max_wsum = ctx->ops.apply_probes(ctx,
                                access_check_disabled && !do_prep,
                                get_max_wsum);

...
}

This seems to leave prep_probes as the only callback receiving true for set_samples, making it solely responsible for setting sampling_addr.

Quoted 3 lines
include/linux/damon.h +0 -0
  * @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.

[ ... ]

Quoted 4 lines
mm/damon/core.c +0 -0
index 127d3a7c27280..7ea42983d1276 100644

[ ... ]

mm/damon/core.c static int kdamond_fn(void *data) · line 3893

Quoted 4 lines
mm/damon/core.c +0 -0
@@ -3878,6 +3891,8 @@ static int kdamond_fn(void *data)
 
 		if (!access_check_disabled && ctx->ops.prepare_access_checks)
 			ctx->ops.prepare_access_checks(ctx);

[Severity: High]
Could the context's operations set change during kdamond_wait_activation() (called just before this), resulting in a NULL pointer dereference here?

The do_prep flag is cached before calling kdamond_wait_activation().

If the wait blocks, a user could update the context's operations to one that does not implement prep_probes (via kdamond_call() from a sysfs commit), making ctx->ops.prep_probes NULL.

When execution resumes, it would use the stale do_prep = true value and attempt to call the now-NULL ctx->ops.prep_probes(...).

[Severity: Medium]
Also, does this silently ignore user-configured preparation actions?

If a user configures a probe with preparation actions, but the current operations set doesn't implement prep_probes, do_prep evaluates to false.

It appears the preparation actions are silently bypassed during execution without returning an error during context commit, such as in __damon_commit_ctx().

This could leave the user unaware that their configured actions are not being applied.

Quoted 5 lines
mm/damon/core.c +2 -0
+		if (do_prep)
+			ctx->ops.prep_probes(ctx, access_check_disabled);
 
 		kdamond_usleep(sample_interval);
 		ctx->passed_sample_intervals++;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
author maintainer
#13 lore raw

Re: [RFC PATCH v2 07/17] mm/damon/core: introduce damon_operations->prep_probes()

Quoted 44 lines · On Sun, 26 Jul 2026 17:57:00 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] TOCTOU race in kdamond_fn across blocking wait leads to NULL pointer dereference of ctx->ops.prep_probes.
- [Medium] Silent bypass of preparation actions when unsupported by operations set.
- [Low] API Contract Omission: prep_probes documentation fails to specify the requirement to set sampling_addr. --

--- Patch [7]: [RFC PATCH v2 07/17] mm/damon/core: introduce damon_operations->prep_probes() --- commit f3f60f13684ba2645da0754240dfe010fa41b859
Author: SJ Park <[email protected]>

mm/damon/core: introduce damon_operations->prep_probes()

damon_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.

Quoted 4 lines
include/linux/damon.h +0 -0
index 24b362fcf53b1..fe2c6b56d1d53 100644

[ ... ]

include/linux/damon.h enum damon_ops_id { · line 659

Quoted 6 lines
include/linux/damon.h +2 -0
@@ -654,6 +655,8 @@ 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.

[Severity: Low]
Does this documentation need to specify that @prep_probes is responsible for setting the sampling_addr?

Looking at kdamond_fn(), when do_prep and access_check_disabled are both true, apply_probes() receives false for its set_samples parameter:

kdamond_fn() {
...

        if (do_prep)
                ctx->ops.prep_probes(ctx, access_check_disabled);
...
                max_wsum = ctx->ops.apply_probes(ctx,
                                access_check_disabled && !do_prep,
                                get_max_wsum);
Quoted 5 lines

...
}

This seems to leave prep_probes as the only callback receiving true for set_samples, making it solely responsible for setting sampling_addr.

Nice suggestion, I will do, like below.

'''

include/linux/damon.h +2 -1
@@ -714,7 +714,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.
  * @prep_probes should execute required &struct damon_prep for next &struct
- * damon_probe applications to each region.
+ * 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.

'''

Quoted 19 lines
Quoted 4 lines
include/linux/damon.h +0 -0
  * @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.

[ ... ]

Quoted 4 lines
mm/damon/core.c +0 -0
index 127d3a7c27280..7ea42983d1276 100644

[ ... ]

mm/damon/core.c static int kdamond_fn(void *data) · line 3893

Quoted 4 lines
mm/damon/core.c +0 -0
@@ -3878,6 +3891,8 @@ static int kdamond_fn(void *data)
 
 		if (!access_check_disabled && ctx->ops.prepare_access_checks)
 			ctx->ops.prepare_access_checks(ctx);

[Severity: High]
Could the context's operations set change during kdamond_wait_activation() (called just before this), resulting in a NULL pointer dereference here?

Quoted 8 lines

The do_prep flag is cached before calling kdamond_wait_activation().

If the wait blocks, a user could update the context's operations to one that does not implement prep_probes (via kdamond_call() from a sysfs commit), making ctx->ops.prep_probes NULL.

When execution resumes, it would use the stale do_prep = true value and attempt to call the now-NULL ctx->ops.prep_probes(...).

Good finding! I will move do_prep setup to be done after kdamond_wait_activation().

Quoted 7 lines

[Severity: Medium]
Also, does this silently ignore user-configured preparation actions?

If a user configures a probe with preparation actions, but the current operations set doesn't implement prep_probes, do_prep evaluates to false.

Quoted 6 lines

It appears the preparation actions are silently bypassed during execution without returning an error during context commit, such as in __damon_commit_ctx().

This could leave the user unaware that their configured actions are not being applied.

That's the intended behavior.

Quoted 9 lines
Quoted 6 lines
mm/damon/core.c +2 -0
+		if (do_prep)
+			ctx->ops.prep_probes(ctx, access_check_disabled);
 
 		kdamond_usleep(sample_interval);
 		ctx->passed_sample_intervals++;
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7

Thanks,
SJ

author maintainer
#14 lore raw

RFC PATCH v2 8/17 mm/damon/paddr: support damon_prep

In reply to SJ Park

Implement 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
index 199de1463fa06..8d8fcd1369e56 100644
@@ -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)
 {
@@ -446,6 +480,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
author maintainer
#15 lore raw

RFC PATCH v2 9/17 mm/damon/sysfs: implement preps directory

In reply to SJ Park

Implement a sysfs directory and a file under the directory that will be used for setting DAMON probe preps. Implement only preparatory data structures and functions. The code is not really generating the directories at the moment.

---
 mm/damon/sysfs.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
mm/damon/sysfs.c +68 -0
index 376c6ecbd4bf3..0e4d7a50545e1 100644
@@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
 	.default_groups = damon_sysfs_intervals_groups,
 };
 
+/*
+ * preps directory
+ */
+
+struct damon_sysfs_preps {
+	struct kobject kobj;
+	int nr;
+};
+
+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);
+
+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
  */
Signature · 1 line
2.47.3
#16 lore raw

Re: [RFC PATCH v2 09/17] mm/damon/sysfs: implement preps directory

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The kobj_type structure `damon_sysfs_preps_ktype` is missing the `static` keyword. --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The kobj_type structure damon_sysfs_preps_ktype is missing the static keyword. --

--- Patch [9]: [RFC PATCH v2 09/17] mm/damon/sysfs: implement preps directory --- commit 8155aac7530c47520c4a221fb588dbd6e53e3875
Author: SJ Park <[email protected]>

mm/damon/sysfs: implement preps directory

This commit implements a sysfs directory and a file for setting DAMON probe preps. It introduces the preparatory data structures and functions without actually generating the directories yet.

Quoted 4 lines
mm/damon/sysfs.c +0 -0
index 50ff1c172d746..bf65e87fcb521 100644

[ ... ]

Quoted 4 lines
mm/damon/sysfs.c +0 -0
@@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
 	.default_groups = damon_sysfs_intervals_groups,
 };
 

[ ... ]

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 815

Quoted 7 lines
mm/damon/sysfs.c +7 -0
+static struct attribute *damon_sysfs_preps_attrs[] = {
+	&damon_sysfs_preps_nr_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(damon_sysfs_preps);
+
+const struct kobj_type damon_sysfs_preps_ktype = {

[Severity: Low]
Does this inadvertently expose damon_sysfs_preps_ktype to the global namespace?

It looks like the static keyword is missing on the definition of damon_sysfs_preps_ktype, which will cause it to be globally visible and may trigger static analysis warnings.

Quoted 8 lines
mm/damon/sysfs.c +5 -0
+	.release = damon_sysfs_preps_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = damon_sysfs_preps_groups,
+};
+
 /*
  * filter directory
  */
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
author maintainer
#17 lore raw

Re: [RFC PATCH v2 09/17] mm/damon/sysfs: implement preps directory

Quoted 39 lines · On Sun, 26 Jul 2026 17:46:08 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The kobj_type structure damon_sysfs_preps_ktype is missing the static keyword. --

--- Patch [9]: [RFC PATCH v2 09/17] mm/damon/sysfs: implement preps directory --- commit 8155aac7530c47520c4a221fb588dbd6e53e3875
Author: SJ Park <[email protected]>

mm/damon/sysfs: implement preps directory

This commit implements a sysfs directory and a file for setting DAMON probe preps. It introduces the preparatory data structures and functions without actually generating the directories yet.

Quoted 4 lines
mm/damon/sysfs.c +0 -0
index 50ff1c172d746..bf65e87fcb521 100644

[ ... ]

Quoted 4 lines
mm/damon/sysfs.c +0 -0
@@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
 	.default_groups = damon_sysfs_intervals_groups,
 };
 

[ ... ]

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 815

Quoted 7 lines
mm/damon/sysfs.c +7 -0
+static struct attribute *damon_sysfs_preps_attrs[] = {
+	&damon_sysfs_preps_nr_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(damon_sysfs_preps);
+
+const struct kobj_type damon_sysfs_preps_ktype = {

[Severity: Low]
Does this inadvertently expose damon_sysfs_preps_ktype to the global namespace?

Quoted 3 lines

It looks like the static keyword is missing on the definition of damon_sysfs_preps_ktype, which will cause it to be globally visible and may trigger static analysis warnings.

This is an intended thing, for not causing build warning, while splitting change in reviewable size.

Quoted 12 lines
Quoted 9 lines
mm/damon/sysfs.c +5 -0
+	.release = damon_sysfs_preps_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = damon_sysfs_preps_groups,
+};
+
 /*
  * filter directory
  */
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9

Thanks,
SJ

author maintainer
#18 lore raw

Re: [RFC PATCH v2 09/17] mm/damon/sysfs: implement preps directory

Quoted 41 lines · On Sun, 26 Jul 2026 11:54:32 -0700 SJ Park <[email protected]> wrote:
Quoted 39 lines · On Sun, 26 Jul 2026 17:46:08 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The kobj_type structure damon_sysfs_preps_ktype is missing the static keyword. --

--- Patch [9]: [RFC PATCH v2 09/17] mm/damon/sysfs: implement preps directory --- commit 8155aac7530c47520c4a221fb588dbd6e53e3875
Author: SJ Park <[email protected]>

mm/damon/sysfs: implement preps directory

This commit implements a sysfs directory and a file for setting DAMON probe preps. It introduces the preparatory data structures and functions without actually generating the directories yet.

Quoted 4 lines
mm/damon/sysfs.c +0 -0
index 50ff1c172d746..bf65e87fcb521 100644

[ ... ]

Quoted 4 lines
mm/damon/sysfs.c +0 -0
@@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
 	.default_groups = damon_sysfs_intervals_groups,
 };
 

[ ... ]

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 815

Quoted 7 lines
mm/damon/sysfs.c +7 -0
+static struct attribute *damon_sysfs_preps_attrs[] = {
+	&damon_sysfs_preps_nr_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(damon_sysfs_preps);
+
+const struct kobj_type damon_sysfs_preps_ktype = {

[Severity: Low]
Does this inadvertently expose damon_sysfs_preps_ktype to the global namespace?

Quoted 6 lines
Quoted 3 lines

It looks like the static keyword is missing on the definition of damon_sysfs_preps_ktype, which will cause it to be globally visible and may trigger static analysis warnings.

This is an intended thing, for not causing build warning, while splitting change in reviewable size.

I will fix this.

Quoted 15 lines
Quoted 13 lines
Quoted 10 lines
mm/damon/sysfs.c +5 -0
+	.release = damon_sysfs_preps_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = damon_sysfs_preps_groups,
+};
+
 /*
  * filter directory
  */
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
Quoted 3 lines

Thanks,
SJ

Thanks,
SJ

author maintainer
#19 lore raw

RFC PATCH v2 10/17 mm/damon/sysfs: create probe preps directory

In reply to SJ Park

Create probe preps directory when the probe directory is generated.

---
 mm/damon/sysfs.c | 50 +++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 43 insertions(+), 7 deletions(-)
mm/damon/sysfs.c +43 -7
index 0e4d7a50545e1..6d3ed80fb2eb1 100644
@@ -759,6 +759,16 @@ struct damon_sysfs_preps {
 	int nr;
 };
 
+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)
 {
@@ -812,7 +822,7 @@ static struct attribute *damon_sysfs_preps_attrs[] = {
 };
 ATTRIBUTE_GROUPS(damon_sysfs_preps);
 
-const struct kobj_type damon_sysfs_preps_ktype = {
+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,
@@ -1138,6 +1148,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;
 };
 
@@ -1148,25 +1159,50 @@ 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) {
+		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
author maintainer
#20 lore raw

RFC PATCH v2 11/17 mm/damon/sysfs: implement probe prep directory

In reply to SJ Park

Implement DAMON sysfs directory and files for specifying each probe prep action. Introduce only preparatory data structure and functions. The files are not really being created under the sysfs.

---
 mm/damon/sysfs.c | 83 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)
mm/damon/sysfs.c +83 -0
index 6d3ed80fb2eb1..e348c1feed1ad 100644
@@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
 	.default_groups = damon_sysfs_intervals_groups,
 };
 
+/*
+ * prep directory
+ */
+
+struct damon_sysfs_prep {
+	struct kobject kobj;
+	enum damon_prep_action action;
+};
+
+struct damon_sysfs_prep_action_name {
+	enum damon_prep_action action;
+	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,
+			struct damon_sysfs_prep, 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);
+
+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
  */
Signature · 1 line
2.47.3
#21 lore raw

Re: [RFC PATCH v2 11/17] mm/damon/sysfs: implement probe prep directory

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Low] Missing `static` qualifier for `damon_sysfs_prep_ktype`. - [Low] The `name` field in `struct…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Low] Missing static qualifier for damon_sysfs_prep_ktype.
- [Low] The name field in struct damon_sysfs_prep_action_name is declared as a non-const char * but initialized with read-only string literals. --

--- Patch [11]: [RFC PATCH v2 11/17] mm/damon/sysfs: implement probe prep directory --- commit ec46e0d8618f958d1edbf7e0edacd883d4e30bde
Author: SJ Park <[email protected]>

mm/damon/sysfs: implement probe prep directory

This commit implements the DAMON sysfs directory and files for specifying each probe prep action. It introduces the preparatory data structures and functions, though the files are not yet created under sysfs.

Quoted 5 lines
mm/damon/sysfs.c +0 -0
index 38affef08d0fb..a33423d997f59 100644
@@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {

[ ... ]

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 764

Quoted 3 lines
mm/damon/sysfs.c +3 -0
+struct damon_sysfs_prep_action_name {
+	enum damon_prep_action action;
+	char *name;

[Severity: Low]
This isn't a bug, but should this field be a const char * instead of char *? The damon_sysfs_prep_action_names array initializes it with read-only string literals like "set_pgidle".

Quoted 9 lines
mm/damon/sysfs.c +9 -0
+};
+
+static const struct damon_sysfs_prep_action_name
+damon_sysfs_prep_action_names[] = {
+	{
+		.action = DAMON_PREP_SET_PGIDLE,
+		.name = "set_pgidle",
+	},
+};

[ ... ]

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 830

Quoted 7 lines
mm/damon/sysfs.c +7 -0
+static struct attribute *damon_sysfs_prep_attrs[] = {
+	&damon_sysfs_prep_prep_action_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(damon_sysfs_prep);
+
+const struct kobj_type damon_sysfs_prep_ktype = {

[Severity: Low]
This isn't a bug, but is the static qualifier missing here? Without it, damon_sysfs_prep_ktype is exported globally which might trigger build warnings like -Wmissing-prototypes when compiling with W=1.

Quoted 4 lines
mm/damon/sysfs.c +4 -0
+	.release = damon_sysfs_prep_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = damon_sysfs_prep_groups,
+};
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
author maintainer
#22 lore raw

Re: [RFC PATCH v2 11/17] mm/damon/sysfs: implement probe prep directory

Quoted 23 lines · On Sun, 26 Jul 2026 17:47:43 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Low] Missing static qualifier for damon_sysfs_prep_ktype.
- [Low] The name field in struct damon_sysfs_prep_action_name is declared as a non-const char * but initialized with read-only string literals. --

--- Patch [11]: [RFC PATCH v2 11/17] mm/damon/sysfs: implement probe prep directory --- commit ec46e0d8618f958d1edbf7e0edacd883d4e30bde
Author: SJ Park <[email protected]>

mm/damon/sysfs: implement probe prep directory

This commit implements the DAMON sysfs directory and files for specifying each probe prep action. It introduces the preparatory data structures and functions, though the files are not yet created under sysfs.

Quoted 5 lines
mm/damon/sysfs.c +0 -0
index 38affef08d0fb..a33423d997f59 100644
@@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {

[ ... ]

Quoted 8 lines

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 764

Quoted 3 lines
mm/damon/sysfs.c +3 -0
+struct damon_sysfs_prep_action_name {
+	enum damon_prep_action action;
+	char *name;

[Severity: Low]
This isn't a bug, but should this field be a const char * instead of char *? The damon_sysfs_prep_action_names array initializes it with read-only string literals like "set_pgidle".

Good suggestion. I will constify both fields.

Quoted 13 lines
Quoted 10 lines
mm/damon/sysfs.c +9 -0
+};
+
+static const struct damon_sysfs_prep_action_name
+damon_sysfs_prep_action_names[] = {
+	{
+		.action = DAMON_PREP_SET_PGIDLE,
+		.name = "set_pgidle",
+	},
+};

[ ... ]

Quoted 12 lines

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 830

Quoted 7 lines
mm/damon/sysfs.c +7 -0
+static struct attribute *damon_sysfs_prep_attrs[] = {
+	&damon_sysfs_prep_prep_action_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(damon_sysfs_prep);
+
+const struct kobj_type damon_sysfs_prep_ktype = {

[Severity: Low]
This isn't a bug, but is the static qualifier missing here? Without it, damon_sysfs_prep_ktype is exported globally which might trigger build warnings like -Wmissing-prototypes when compiling with W=1.

It didn't warn on my setup. Let me think more...

Quoted 8 lines
Quoted 5 lines
mm/damon/sysfs.c +4 -0
+	.release = damon_sysfs_prep_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = damon_sysfs_prep_groups,
+};
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11

Thanks,
SJ

author maintainer
#23 lore raw

Re: [RFC PATCH v2 11/17] mm/damon/sysfs: implement probe prep directory

Quoted 62 lines · On Sun, 26 Jul 2026 11:57:15 -0700 SJ Park <[email protected]> wrote:
Quoted 23 lines · On Sun, 26 Jul 2026 17:47:43 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Low] Missing static qualifier for damon_sysfs_prep_ktype.
- [Low] The name field in struct damon_sysfs_prep_action_name is declared as a non-const char * but initialized with read-only string literals. --

--- Patch [11]: [RFC PATCH v2 11/17] mm/damon/sysfs: implement probe prep directory --- commit ec46e0d8618f958d1edbf7e0edacd883d4e30bde
Author: SJ Park <[email protected]>

mm/damon/sysfs: implement probe prep directory

This commit implements the DAMON sysfs directory and files for specifying each probe prep action. It introduces the preparatory data structures and functions, though the files are not yet created under sysfs.

Quoted 5 lines
mm/damon/sysfs.c +0 -0
index 38affef08d0fb..a33423d997f59 100644
@@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {

[ ... ]

Quoted 8 lines

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 764

Quoted 3 lines
mm/damon/sysfs.c +3 -0
+struct damon_sysfs_prep_action_name {
+	enum damon_prep_action action;
+	char *name;

[Severity: Low]
This isn't a bug, but should this field be a const char * instead of char *? The damon_sysfs_prep_action_names array initializes it with read-only string literals like "set_pgidle".

Good suggestion. I will constify both fields.

Quoted 13 lines
Quoted 10 lines
mm/damon/sysfs.c +9 -0
+};
+
+static const struct damon_sysfs_prep_action_name
+damon_sysfs_prep_action_names[] = {
+	{
+		.action = DAMON_PREP_SET_PGIDLE,
+		.name = "set_pgidle",
+	},
+};

[ ... ]

Quoted 12 lines

mm/damon/sysfs.c static const struct kobj_type damon_sysfs_intervals_ktype = { · line 830

Quoted 7 lines
mm/damon/sysfs.c +7 -0
+static struct attribute *damon_sysfs_prep_attrs[] = {
+	&damon_sysfs_prep_prep_action_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(damon_sysfs_prep);
+
+const struct kobj_type damon_sysfs_prep_ktype = {

[Severity: Low]
This isn't a bug, but is the static qualifier missing here? Without it, damon_sysfs_prep_ktype is exported globally which might trigger build warnings like -Wmissing-prototypes when compiling with W=1.

Quoted 1 line

It didn't warn on my setup. Let me think more...

I still cannot make the warning on my setup. But the theory makes sense. I will fix this by changing the patch sequence.

Quoted 11 lines
Quoted 9 lines
Quoted 6 lines
mm/damon/sysfs.c +4 -0
+	.release = damon_sysfs_prep_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = damon_sysfs_prep_groups,
+};
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=11
Quoted 3 lines

Thanks,
SJ

Thanks,
SJ

author maintainer
#24 lore raw

RFC PATCH v2 12/17 mm/damon/sysfs: create probe prep files for preps/nr file write

In reply to SJ Park

Implement preps/nr file write operation to really create the probe prep directories and their files.

---
 mm/damon/sysfs.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 54 insertions(+), 2 deletions(-)
mm/damon/sysfs.c +54 -2
index e348c1feed1ad..f275a6f73eee1 100644
@@ -759,6 +759,17 @@ struct damon_sysfs_prep {
 	enum damon_prep_action action;
 };
 
+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;
+	prep->action = DAMON_PREP_SET_PGIDLE;
+	return prep;
+}
+
 struct damon_sysfs_prep_action_name {
 	enum damon_prep_action action;
 	char *name;
@@ -827,7 +838,7 @@ static struct attribute *damon_sysfs_prep_attrs[] = {
 };
 ATTRIBUTE_GROUPS(damon_sysfs_prep);
 
-const struct kobj_type damon_sysfs_prep_ktype = {
+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,
@@ -839,6 +850,7 @@ const struct kobj_type damon_sysfs_prep_ktype = {
 
 struct damon_sysfs_preps {
 	struct kobject kobj;
+	struct damon_sysfs_prep **preps_arr;
 	int nr;
 };
 
@@ -849,13 +861,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
author maintainer
#25 lore raw

RFC PATCH v2 13/17 mm/damon/sysfs: pass preps to DAMON core

In reply to SJ Park

DAMON 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
index f275a6f73eee1..d7a2b62322841 100644
@@ -2174,6 +2174,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)
 {
@@ -2209,7 +2226,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
author maintainer
#26 lore raw

RFC PATCH v2 14/17 selftests/damon/sysfs.sh: test probe prep sysfs files

In reply to SJ Park

Add 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
index f7fb94b84e716..ddebde6edabe4 100755
@@ -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
author maintainer
#27 lore raw

RFC PATCH v2 15/17 Docs/mm/damon/design: document probe preps

In reply to SJ Park

Update 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
index c4830bd09498d..7f983e0c39b80 100644
@@ -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
author maintainer
#28 lore raw

RFC PATCH v2 16/17 Docs/admin-guide/mm/damon/usage: document probe preps sysfs files

In reply to SJ Park

Update 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
index da5f9afd08aef..e4fdec3fa5059 100644
@@ -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 is 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
+names ``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
#29 lore raw

Re: [RFC PATCH v2 16/17] Docs/admin-guide/mm/damon/usage: document probe preps sysfs files

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Low] Typo in documentation: 'names' used instead of 'named'. - [Low] Subject-verb agreement error in…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Low] Typo in documentation: 'names' used instead of 'named'.
- [Low] Subject-verb agreement error in updated documentation sentence.
--

--- Patch [16]: [RFC PATCH v2 16/17] Docs/admin-guide/mm/damon/usage: document probe preps sysfs files --- commit a784c34ebf2a666ab86343b9b4f5290f8391e1b3
Author: SJ Park <[email protected]>

Docs/admin-guide/mm/damon/usage: document probe preps sysfs files

Update DAMON usage document for the newly added DAMON probe preps sysfs files.

Quoted 4 lines
Documentation/admin-guide/mm/damon/usage.rst +0 -0
index da5f9afd08aef..e4fdec3fa5059 100644

[ ... ]

Documentation/admin-guide/mm/damon/usage.rst In the beginning, this directory has only one file, ``nr_probes``. Writing a · line 291

Quoted 10 lines
Documentation/admin-guide/mm/damon/usage.rst +3 -3
@@ -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 is used to determine the data attribute for the
                              ^^^^^^^

[Severity: Low]
This isn't a bug, but since the sentence refers to plural subjects ("preparation actions and filters" or "files"), should "that is used" be updated to "that are used"?

Documentation/admin-guide/mm/damon/usage.rst In the beginning, this directory has only one file, ``nr_probes``. Writing a · line 296

Quoted 5 lines
Documentation/admin-guide/mm/damon/usage.rst +5 -0
+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
+names ``0`` to ``N-1``.  Each directory represents each preparation action.

^^^^^

[Severity: Low]
This isn't a bug, but there appears to be a typo. Should "names" be "named" to match the intended meaning ("child directories named 0 to N-1")?

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

Re: [RFC PATCH v2 16/17] Docs/admin-guide/mm/damon/usage: document probe preps sysfs files

Quoted 32 lines · On Sun, 26 Jul 2026 17:45:47 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Low] Typo in documentation: 'names' used instead of 'named'.
- [Low] Subject-verb agreement error in updated documentation sentence.
--

--- Patch [16]: [RFC PATCH v2 16/17] Docs/admin-guide/mm/damon/usage: document probe preps sysfs files --- commit a784c34ebf2a666ab86343b9b4f5290f8391e1b3
Author: SJ Park <[email protected]>

Docs/admin-guide/mm/damon/usage: document probe preps sysfs files

Update DAMON usage document for the newly added DAMON probe preps sysfs files.

Quoted 4 lines
Documentation/admin-guide/mm/damon/usage.rst +0 -0
index da5f9afd08aef..e4fdec3fa5059 100644

[ ... ]

Documentation/admin-guide/mm/damon/usage.rst In the beginning, this directory has only one file, ``nr_probes``. Writing a · line 291

Quoted 10 lines
Documentation/admin-guide/mm/damon/usage.rst +3 -3
@@ -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 is used to determine the data attribute for the
                              ^^^^^^^
Quoted 4 lines

[Severity: Low]
This isn't a bug, but since the sentence refers to plural subjects ("preparation actions and filters" or "files"), should "that is used" be updated to "that are used"?

Good finding, will fix.

Quoted 11 lines

Documentation/admin-guide/mm/damon/usage.rst In the beginning, this directory has only one file, ``nr_probes``. Writing a · line 296

Quoted 6 lines
Documentation/admin-guide/mm/damon/usage.rst +5 -0
+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
+names ``0`` to ``N-1``.  Each directory represents each preparation action.

^^^^^

[Severity: Low]
This isn't a bug, but there appears to be a typo. Should "names" be "named" to match the intended meaning ("child directories named 0 to N-1")?

Good finding, will fix.

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

Thanks,
SJ

author maintainer
#31 lore raw

RFC PATCH v2 17/17 Docs/ABI/damon: document probe prep sysfs files

In reply to SJ Park

Update 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
index e9488bb48d23c..339b7c4177ab7 100644
@@ -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>/prep/<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
#32 lore raw

Re: [RFC PATCH v2 17/17] Docs/ABI/damon: document probe prep sysfs files

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] The sysfs path for the `prep_action` file is documented incorrectly as `prep/<R>/prep_action`…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The sysfs path for the prep_action file is documented incorrectly as prep/<R>/prep_action instead of preps/<R>/prep_action. --

--- Patch [17]: [RFC PATCH v2 17/17] Docs/ABI/damon: document probe prep sysfs files --- commit c668115a6c46349a2601c78b7bdb1229021f721a
Author: SJ Park <[email protected]>

Docs/ABI/damon: document probe prep sysfs files

This commit updates the DAMON ABI documentation to include the newly added DAMON probe prep sysfs files.

Quoted 4 lines
Documentation/ABI/testing/sysfs-kernel-mm-damon +0 -0
index e675a57145e36..f913f4eee4b4d 100644

[ ... ]

Documentation/ABI/testing/sysfs-kernel-mm-damon Contact: SJ Park <[email protected]> · line 183

Quoted 8 lines
Documentation/ABI/testing/sysfs-kernel-mm-damon +8 -0
+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>/prep/<R>/prep_action

[Severity: Low]
Is this path missing an 's'?

The description above states the directories are created under the preps/ directory, but this sysfs path uses prep/ instead of preps/. Should this be documented as preps/<R>/prep_action to match the actual sysfs directory name?

Quoted 4 lines
Documentation/ABI/testing/sysfs-kernel-mm-damon +4 -0
+Date:		Jun 2026
+Contact:	SJ Park <[email protected]>
+Description:	Writing to and reading from this file sets and gets the probing
+		preparation action.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=17
author maintainer
#33 lore raw

Re: [RFC PATCH v2 17/17] Docs/ABI/damon: document probe prep sysfs files

Quoted 30 lines · On Sun, 26 Jul 2026 17:45:46 +0000 [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] The sysfs path for the prep_action file is documented incorrectly as prep/<R>/prep_action instead of preps/<R>/prep_action. --

--- Patch [17]: [RFC PATCH v2 17/17] Docs/ABI/damon: document probe prep sysfs files --- commit c668115a6c46349a2601c78b7bdb1229021f721a
Author: SJ Park <[email protected]>

Docs/ABI/damon: document probe prep sysfs files

This commit updates the DAMON ABI documentation to include the newly added DAMON probe prep sysfs files.

Quoted 4 lines
Documentation/ABI/testing/sysfs-kernel-mm-damon +0 -0
index e675a57145e36..f913f4eee4b4d 100644

[ ... ]

Documentation/ABI/testing/sysfs-kernel-mm-damon Contact: SJ Park <[email protected]> · line 183

Quoted 8 lines
Documentation/ABI/testing/sysfs-kernel-mm-damon +8 -0
+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>/prep/<R>/prep_action

[Severity: Low]
Is this path missing an 's'?

Quoted 4 lines

The description above states the directories are created under the preps/ directory, but this sysfs path uses prep/ instead of preps/. Should this be documented as preps/<R>/prep_action to match the actual sysfs directory name?

Good catch. Will fix.

Quoted 8 lines
Quoted 5 lines
Documentation/ABI/testing/sysfs-kernel-mm-damon +4 -0
+Date:		Jun 2026
+Contact:	SJ Park <[email protected]>
+Description:	Writing to and reading from this file sets and gets the probing
+		preparation action.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=17

Thanks,
SJ