[RFC PATCH v2 00/17] mm/damon: introduce data access-as-a-data attribute

[RFC PATCH v2 00/17] mm/damon: introduce data access-as-a-data attribute

[SJ Park]

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/20260725210225.129944-1-sj@kernel.org
- 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
-- 
2.47.3

[RFC PATCH v2 01/17] mm/damon/core: introduce DAMON_FILTER_TYPE_PGIDLE_UNSET

[SJ Park]

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.

Signed-off-by: SJ Park <sj@kernel.org>
---
 include/linux/damon.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/linux/damon.h b/include/linux/damon.h
index 8ad6ef2e063de..cee4b74761081 100644
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -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,
 };
 
 /**
-- 
2.47.3

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

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/paddr.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c
index 5a6a78054784a..199de1463fa06 100644
--- a/mm/damon/paddr.c
+++ b/mm/damon/paddr.c
@@ -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;
 	}
-- 
2.47.3

[RFC PATCH v2 03/17] mm/damon/sysfs: support pgidle_unset probe filter type

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/sysfs.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index 053ba2e53b969..376c6ecbd4bf3 100644
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -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,
-- 
2.47.3

[RFC PATCH v2 04/17] Docs/mm/damon/design: document pgidle_unset probe filter type

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 Documentation/mm/damon/design.rst | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/design.rst
index a8c163475ef2b..c4830bd09498d 100644
--- a/Documentation/mm/damon/design.rst
+++ b/Documentation/mm/damon/design.rst
@@ -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
-- 
2.47.3

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

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 include/linux/damon.h | 32 ++++++++++++++++++++++++++++++++
 mm/damon/core.c       | 26 ++++++++++++++++++++++++++
 2 files changed, 58 insertions(+)

diff --git a/include/linux/damon.h b/include/linux/damon.h
index cee4b74761081..255b20e44287f 100644
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -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);
diff --git a/mm/damon/core.c b/mm/damon/core.c
index 5eb0400d5ce16..bda61f9ec0266 100644
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -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);
-- 
2.47.3

[RFC PATCH v2 06/17] mm/damon/core: commit preps

[SJ Park]

damon_commit_probes() is ignoring damon_prep.  Commit the prep actions,
too.

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/core.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/mm/damon/core.c b/mm/damon/core.c
index bda61f9ec0266..c74dee56efee8 100644
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -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;
-- 
2.47.3

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

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 include/linux/damon.h |  4 ++++
 mm/damon/core.c       | 18 +++++++++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/include/linux/damon.h b/include/linux/damon.h
index 255b20e44287f..f5b0f16305b30 100644
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -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,
diff --git a/mm/damon/core.c b/mm/damon/core.c
index c74dee56efee8..bd2dc702a9811 100644
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -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;
 		}
-- 
2.47.3

[RFC PATCH v2 08/17] mm/damon/paddr: support damon_prep

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/paddr.c | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c
index 199de1463fa06..8d8fcd1369e56 100644
--- a/mm/damon/paddr.c
+++ b/mm/damon/paddr.c
@@ -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,
-- 
2.47.3

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

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/sysfs.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index 376c6ecbd4bf3..0e4d7a50545e1 100644
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -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
  */
-- 
2.47.3

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

[SJ Park]

Create probe preps directory when the probe directory is generated.

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/sysfs.c | 50 +++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 43 insertions(+), 7 deletions(-)

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index 0e4d7a50545e1..6d3ed80fb2eb1 100644
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -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);
-- 
2.47.3

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

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/sysfs.c | 83 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index 6d3ed80fb2eb1..e348c1feed1ad 100644
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -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
  */
-- 
2.47.3

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

[SJ Park]

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/sysfs.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 54 insertions(+), 2 deletions(-)

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index e348c1feed1ad..f275a6f73eee1 100644
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -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;
 }
 
-- 
2.47.3

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

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 mm/damon/sysfs.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index f275a6f73eee1..d7a2b62322841 100644
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -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;
-- 
2.47.3

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

[SJ Park]

Add basic file operations test for newly introduced DAMON probe prep
sysfs directories and files.

Signed-off-by: SJ Park <sj@kernel.org>
---
 tools/testing/selftests/damon/sysfs.sh | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tools/testing/selftests/damon/sysfs.sh b/tools/testing/selftests/damon/sysfs.sh
index f7fb94b84e716..ddebde6edabe4 100755
--- a/tools/testing/selftests/damon/sysfs.sh
+++ b/tools/testing/selftests/damon/sysfs.sh
@@ -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"
 }
 
-- 
2.47.3

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

[SJ Park]

Update DAMON design document for the newly added DAMON probe preps
feature.

Signed-off-by: SJ Park <sj@kernel.org>
---
 Documentation/mm/damon/design.rst | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/design.rst
index c4830bd09498d..7f983e0c39b80 100644
--- a/Documentation/mm/damon/design.rst
+++ b/Documentation/mm/damon/design.rst
@@ -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.
-- 
2.47.3

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

[SJ Park]

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

Signed-off-by: SJ Park <sj@kernel.org>
---
 Documentation/admin-guide/mm/damon/usage.rst | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/admin-guide/mm/damon/usage.rst
index da5f9afd08aef..e4fdec3fa5059 100644
--- a/Documentation/admin-guide/mm/damon/usage.rst
+++ b/Documentation/admin-guide/mm/damon/usage.rst
@@ -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
-- 
2.47.3

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

[SJ Park]

Update DAMON ABI document for the newly added DAMON probe prep sysfs
files.

Signed-off-by: SJ Park <sj@kernel.org>
---
 Documentation/ABI/testing/sysfs-kernel-mm-damon | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/Documentation/ABI/testing/sysfs-kernel-mm-damon b/Documentation/ABI/testing/sysfs-kernel-mm-damon
index e9488bb48d23c..339b7c4177ab7 100644
--- a/Documentation/ABI/testing/sysfs-kernel-mm-damon
+++ b/Documentation/ABI/testing/sysfs-kernel-mm-damon
@@ -173,6 +173,19 @@ Contact:	SJ Park <sj@kernel.org>
 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 <sj@kernel.org>
+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 <sj@kernel.org>
+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 <sj@kernel.org>
-- 
2.47.3

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

[sashiko-bot]

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 <sj@kernel.org>

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.

> diff --git a/Documentation/ABI/testing/sysfs-kernel-mm-damon b/Documentation/ABI/testing/sysfs-kernel-mm-damon
> index e675a57145e36..f913f4eee4b4d 100644
> --- a/Documentation/ABI/testing/sysfs-kernel-mm-damon
> +++ b/Documentation/ABI/testing/sysfs-kernel-mm-damon
[ ... ]
> +What:		/sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/monitoring_attrs/probes/<P>/preps/nr_preps
> +Date:		Jun 2026
> +Contact:	SJ Park <sj@kernel.org>
> +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?

> +Date:		Jun 2026
> +Contact:	SJ Park <sj@kernel.org>
> +Description:	Writing to and reading from this file sets and gets the probing
> +		preparation action.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=17

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

[sashiko-bot]

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 <sj@kernel.org>

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

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

> diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/admin-guide/mm/damon/usage.rst
> index da5f9afd08aef..e4fdec3fa5059 100644
> --- a/Documentation/admin-guide/mm/damon/usage.rst
> +++ b/Documentation/admin-guide/mm/damon/usage.rst

[ ... ]

> @@ -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"?

> +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")?

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=16

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

[sashiko-bot]

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 <sj@kernel.org>

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.

> diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
> index 50ff1c172d746..bf65e87fcb521 100644
> --- a/mm/damon/sysfs.c
> +++ b/mm/damon/sysfs.c

[ ... ]

> @@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
>  	.default_groups = damon_sysfs_intervals_groups,
>  };
>  

[ ... ]

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

> +	.release = damon_sysfs_preps_release,
> +	.sysfs_ops = &kobj_sysfs_ops,
> +	.default_groups = damon_sysfs_preps_groups,
> +};
> +
>  /*
>   * filter directory
>   */

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=9

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

[sashiko-bot]

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 <sj@kernel.org>

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.

> diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
> index 38affef08d0fb..a33423d997f59 100644
> --- a/mm/damon/sysfs.c
> +++ b/mm/damon/sysfs.c
> @@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {

[ ... ]

> +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".

> +};
> +
> +static const struct damon_sysfs_prep_action_name
> +damon_sysfs_prep_action_names[] = {
> +	{
> +		.action = DAMON_PREP_SET_PGIDLE,
> +		.name = "set_pgidle",
> +	},
> +};

[ ... ]

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

> +	.release = damon_sysfs_prep_release,
> +	.sysfs_ops = &kobj_sysfs_ops,
> +	.default_groups = damon_sysfs_prep_groups,
> +};

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=11

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

[sashiko-bot]

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 <sj@kernel.org>

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.

> diff --git a/include/linux/damon.h b/include/linux/damon.h
> index a8bb9ee6979e3..24b362fcf53b1 100644
> --- a/include/linux/damon.h
> +++ b/include/linux/damon.h

[ ... ]

> @@ -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;
}

[ ... ]

> @@ -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?

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=5

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

[sashiko-bot]

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 <sj@kernel.org>

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.

> diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c
> index 5a6a78054784a..199de1463fa06 100644
> --- a/mm/damon/paddr.c
> +++ b/mm/damon/paddr.c
> @@ -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?

> +		if (!folio)
> +			matched = false;
> +		else
> +			matched = damon_folio_young(folio);
> +		break;
>  	default:
>  		break;
>  	}

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=2

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

[sashiko-bot]

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 <sj@kernel.org>

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.

> diff --git a/include/linux/damon.h b/include/linux/damon.h
> index 24b362fcf53b1..fe2c6b56d1d53 100644
> --- a/include/linux/damon.h
> +++ b/include/linux/damon.h
[ ... ]
> @@ -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.

>   * @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.
[ ... ]
> diff --git a/mm/damon/core.c b/mm/damon/core.c
> index 127d3a7c27280..7ea42983d1276 100644
> --- a/mm/damon/core.c
> +++ b/mm/damon/core.c
[ ... ]
> @@ -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.

> +		if (do_prep)
> +			ctx->ops.prep_probes(ctx, access_check_disabled);
>  
>  		kdamond_usleep(sample_interval);
>  		ctx->passed_sample_intervals++;

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=7

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

[SJ Park]

On Sun, 26 Jul 2026 17:53:33 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> 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.
> 
> > diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c
> > index 5a6a78054784a..199de1463fa06 100644
> > --- a/mm/damon/paddr.c
> > +++ b/mm/damon/paddr.c
> > @@ -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?

A later patch of this series does that.

> 
> > +		if (!folio)
> > +			matched = false;
> > +		else
> > +			matched = damon_folio_young(folio);
> > +		break;
> >  	default:
> >  		break;
> >  	}
> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=2


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 17:52:27 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> 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.
> 
> > diff --git a/include/linux/damon.h b/include/linux/damon.h
> > index a8bb9ee6979e3..24b362fcf53b1 100644
> > --- a/include/linux/damon.h
> > +++ b/include/linux/damon.h
> 
> [ ... ]
> 
> > @@ -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;
> }

A later patch of this series does that.

> 
> [ ... ]
> 
> > @@ -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?

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

'''
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -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)
'''

> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=5


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 17:57:00 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> 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.
> 
> > diff --git a/include/linux/damon.h b/include/linux/damon.h
> > index 24b362fcf53b1..fe2c6b56d1d53 100644
> > --- a/include/linux/damon.h
> > +++ b/include/linux/damon.h
> [ ... ]
> > @@ -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.

Nice suggestion, I will do, like below.

'''
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -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.
'''

> 
> >   * @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.
> [ ... ]
> > diff --git a/mm/damon/core.c b/mm/damon/core.c
> > index 127d3a7c27280..7ea42983d1276 100644
> > --- a/mm/damon/core.c
> > +++ b/mm/damon/core.c
> [ ... ]
> > @@ -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(...).

Good finding!  I will move do_prep setup to be done after
kdamond_wait_activation().
> 
> [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.

That's the intended behavior.

> 
> > +		if (do_prep)
> > +			ctx->ops.prep_probes(ctx, access_check_disabled);
> >  
> >  		kdamond_usleep(sample_interval);
> >  		ctx->passed_sample_intervals++;
> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=7


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 17:46:08 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> 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.
> 
> > diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
> > index 50ff1c172d746..bf65e87fcb521 100644
> > --- a/mm/damon/sysfs.c
> > +++ b/mm/damon/sysfs.c
> 
> [ ... ]
> 
> > @@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
> >  	.default_groups = damon_sysfs_intervals_groups,
> >  };
> >  
> 
> [ ... ]
> 
> > +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.

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

> 
> > +	.release = damon_sysfs_preps_release,
> > +	.sysfs_ops = &kobj_sysfs_ops,
> > +	.default_groups = damon_sysfs_preps_groups,
> > +};
> > +
> >  /*
> >   * filter directory
> >   */
> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=9


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 17:47:43 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> 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.
> 
> > diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
> > index 38affef08d0fb..a33423d997f59 100644
> > --- a/mm/damon/sysfs.c
> > +++ b/mm/damon/sysfs.c
> > @@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
> 
> [ ... ]
> 
> > +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.

> 
> > +};
> > +
> > +static const struct damon_sysfs_prep_action_name
> > +damon_sysfs_prep_action_names[] = {
> > +	{
> > +		.action = DAMON_PREP_SET_PGIDLE,
> > +		.name = "set_pgidle",
> > +	},
> > +};
> 
> [ ... ]
> 
> > +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...

> 
> > +	.release = damon_sysfs_prep_release,
> > +	.sysfs_ops = &kobj_sysfs_ops,
> > +	.default_groups = damon_sysfs_prep_groups,
> > +};
> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=11


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 17:45:47 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> Docs/admin-guide/mm/damon/usage: document probe preps sysfs files
> 
> Update DAMON usage document for the newly added DAMON probe preps sysfs files.
> 
> > diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/admin-guide/mm/damon/usage.rst
> > index da5f9afd08aef..e4fdec3fa5059 100644
> > --- a/Documentation/admin-guide/mm/damon/usage.rst
> > +++ b/Documentation/admin-guide/mm/damon/usage.rst
> 
> [ ... ]
> 
> > @@ -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"?

Good finding, will fix.

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

> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=16


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 17:45:46 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> 
> 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.
> 
> > diff --git a/Documentation/ABI/testing/sysfs-kernel-mm-damon b/Documentation/ABI/testing/sysfs-kernel-mm-damon
> > index e675a57145e36..f913f4eee4b4d 100644
> > --- a/Documentation/ABI/testing/sysfs-kernel-mm-damon
> > +++ b/Documentation/ABI/testing/sysfs-kernel-mm-damon
> [ ... ]
> > +What:		/sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/monitoring_attrs/probes/<P>/preps/nr_preps
> > +Date:		Jun 2026
> > +Contact:	SJ Park <sj@kernel.org>
> > +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?

Good catch.  Will fix.

> 
> > +Date:		Jun 2026
> > +Contact:	SJ Park <sj@kernel.org>
> > +Description:	Writing to and reading from this file sets and gets the probing
> > +		preparation action.
> 
> -- 
> Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=17


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 11:54:32 -0700 SJ Park <sj@kernel.org> wrote:

> On Sun, 26 Jul 2026 17:46:08 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> > 
> > 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.
> > 
> > > diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
> > > index 50ff1c172d746..bf65e87fcb521 100644
> > > --- a/mm/damon/sysfs.c
> > > +++ b/mm/damon/sysfs.c
> > 
> > [ ... ]
> > 
> > > @@ -750,6 +750,74 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
> > >  	.default_groups = damon_sysfs_intervals_groups,
> > >  };
> > >  
> > 
> > [ ... ]
> > 
> > > +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.
> 
> This is an intended thing, for not causing build warning, while splitting
> change in reviewable size.

I will fix this.

> 
> > 
> > > +	.release = damon_sysfs_preps_release,
> > > +	.sysfs_ops = &kobj_sysfs_ops,
> > > +	.default_groups = damon_sysfs_preps_groups,
> > > +};
> > > +
> > >  /*
> > >   * filter directory
> > >   */
> > 
> > -- 
> > Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=9
> 
> 
> Thanks,
> SJ
> 


Thanks,
SJ

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

[SJ Park]

On Sun, 26 Jul 2026 11:57:15 -0700 SJ Park <sj@kernel.org> wrote:

> On Sun, 26 Jul 2026 17:47:43 +0000 sashiko-bot@kernel.org 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 <sj@kernel.org>
> > 
> > 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.
> > 
> > > diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
> > > index 38affef08d0fb..a33423d997f59 100644
> > > --- a/mm/damon/sysfs.c
> > > +++ b/mm/damon/sysfs.c
> > > @@ -750,6 +750,89 @@ static const struct kobj_type damon_sysfs_intervals_ktype = {
> > 
> > [ ... ]
> > 
> > > +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.
> 
> > 
> > > +};
> > > +
> > > +static const struct damon_sysfs_prep_action_name
> > > +damon_sysfs_prep_action_names[] = {
> > > +	{
> > > +		.action = DAMON_PREP_SET_PGIDLE,
> > > +		.name = "set_pgidle",
> > > +	},
> > > +};
> > 
> > [ ... ]
> > 
> > > +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...

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

> 
> > 
> > > +	.release = damon_sysfs_prep_release,
> > > +	.sysfs_ops = &kobj_sysfs_ops,
> > > +	.default_groups = damon_sysfs_prep_groups,
> > > +};
> > 
> > -- 
> > Sashiko AI review · https://sashiko.dev/#/patchset/20260726173935.94046-1-sj@kernel.org?part=11
> 
> 
> Thanks,
> SJ
> 


Thanks,
SJ