mm/damon/core: add a callback for scheme target regions check

Patch series "efficiently expose damos action tried regions information".

DAMON users can retrieve the monitoring results via 'after_aggregation'
callbacks if the user is using the kernel API, or 'damon_aggregated'
tracepoint if the user is in the user space.  Those are useful if full
monitoring results are necessary.  However, if the user has interest in
only a snapshot of the results for some regions having specific access
pattern, the interfaces could be inefficient.  For example, some users
only want to know which memory regions are not accessed for more than a
specific time at the moment.

Also, some DAMOS users would want to know exactly to what memory regions
the schemes' actions tried to be applied, for a debugging or a tuning.  As
DAMOS has its internal mechanism for quota and regions prioritization, the
users would need to simulate DAMOS' mechanism against the monitoring
results.  That's unnecessarily complex.

This patchset implements DAMON kernel API callbacks and sysfs directory
for efficient exposure of the information for the use cases.  The new
callback will be called for each region when a DAMOS action is gonna tried
to be applied to it.  The sysfs directory will be called 'tried_regions'
and placed under each scheme sysfs directory.  Users can write a special
keyworkd, 'update_schemes_regions', to the 'state' file of a kdamond sysfs
directory.  Then, DAMON sysfs interface will fill the directory with the
information of regions that corresponding scheme action was tried to be
applied for next one aggregation interval.

Patches Sequence
----------------

The first one (patch 1) implements the callback for the kernel space
users.  Following two patches (patches 2 and 3) implements sysfs
directories for the information and its sub directories.  Two patches
(patches 4 and 5) for implementing the special keywords for filling the
data to and cleaning up the directories follow.  Patch 6 adds a selftest
for the new sysfs directory.  Finally, two patches (patches 7 and 8)
document the new feature in the administrator guide and the ABI document.

This patch (of 8):

Getting DAMON monitoring results of only specific access pattern (e.g.,
getting address ranges of memory that not accessed at all for two minutes)
can be useful for efficient monitoring of the system.  The information can
also be helpful for deep level investigation of DAMON-based operation
schemes.

For that, users need to record (in case of the user space users) or
iterate (in case of the kernel space users) full monitoring results and
filter it out for the specific access pattern.  In case of the DAMOS
investigation, users will even need to simulate DAMOS' quota and
prioritization mechanisms.  It's inefficient and complex.

Add a new DAMON callback that will be called before each scheme is applied
to each region.  DAMON kernel API users will be able to do the query-like
monitoring results collection, or DAMOS investigation in an efficient and
simple way using it.

Commits for providing the capability to the user space users will follow.

Link: https://lkml.kernel.org/r/20221101220328.95765-1-sj@kernel.org
Link: https://lkml.kernel.org/r/20221101220328.95765-2-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <shuah@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/damon.h b/include/linux/damon.h
index 620ada0..3563063 100644 (file)
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -357,6 +357,7 @@ struct damon_operations {
  * @after_wmarks_check:        Called after each schemes' watermarks check.
  * @after_sampling:    Called after each sampling.
  * @after_aggregation: Called after each aggregation.
+ * @before_damos_apply:        Called before applying DAMOS action.
  * @before_terminate:  Called before terminating the monitoring.
  * @private:           User private data.
  *
@@ -385,6 +386,10 @@ struct damon_callback {
        int (*after_wmarks_check)(struct damon_ctx *context);
        int (*after_sampling)(struct damon_ctx *context);
        int (*after_aggregation)(struct damon_ctx *context);
+       int (*before_damos_apply)(struct damon_ctx *context,
+                       struct damon_target *target,
+                       struct damon_region *region,
+                       struct damos *scheme);
        void (*before_terminate)(struct damon_ctx *context);
 };
 

diff --git a/mm/damon/core.c b/mm/damon/core.c
index 80d5937..ceec75b 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -772,6 +772,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,
        unsigned long sz = damon_sz_region(r);
        struct timespec64 begin, end;
        unsigned long sz_applied = 0;
+       int err = 0;
 
        if (c->ops.apply_scheme) {
                if (quota->esz && quota->charged_sz + sz > quota->esz) {
@@ -782,7 +783,10 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,
                        damon_split_region_at(t, r, sz);
                }
                ktime_get_coarse_ts64(&begin);
-               sz_applied = c->ops.apply_scheme(c, t, r, s);
+               if (c->callback.before_damos_apply)
+                       err = c->callback.before_damos_apply(c, t, r, s);
+               if (!err)
+                       sz_applied = c->ops.apply_scheme(c, t, r, s);
                ktime_get_coarse_ts64(&end);
                quota->total_charged_ns += timespec64_to_ns(&end) -
                        timespec64_to_ns(&begin);