mm/damon/sysfs: implement DAMOS tried regions update command

Implement the code for filling the data of 'tried_regions' DAMON sysfs
directory.  With this commit, DAMON sysfs interface users can write a
special keyword, 'update_schemes_tried_regions' to the corresponding
'state' file of the kdamond.  Then, DAMON sysfs interface will collect the
tried regions information using the 'before_damos_apply()' callback for
one aggregation interval and populate scheme region directories with the
values.

[sj@kernel.org: skip tried regions update if the scheme directory was removed]
Link: https://lkml.kernel.org/r/20221114182954.4745-2-sj@kernel.org
Link: https://lkml.kernel.org/r/20221101220328.95765-5-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/mm/damon/sysfs-common.h b/mm/damon/sysfs-common.h
index 4626b27..634a6e7 100644 (file)
--- a/mm/damon/sysfs-common.h
+++ b/mm/damon/sysfs-common.h
@@ -44,3 +44,9 @@ int damon_sysfs_set_schemes(struct damon_ctx *ctx,
 void damon_sysfs_schemes_update_stats(
                struct damon_sysfs_schemes *sysfs_schemes,
                struct damon_ctx *ctx);
+
+int damon_sysfs_schemes_update_regions_start(
+               struct damon_sysfs_schemes *sysfs_schemes,
+               struct damon_ctx *ctx);
+
+int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx);

diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c
index f0b5ad7..5f14f18 100644 (file)
--- a/mm/damon/sysfs-schemes.c
+++ b/mm/damon/sysfs-schemes.c
@@ -1244,3 +1244,83 @@ void damon_sysfs_schemes_update_stats(
                sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds;
        }
 }
+
+/*
+ * damon_sysfs_schemes that need to update its schemes regions dir.  Protected
+ * by damon_sysfs_lock
+ */
+static struct damon_sysfs_schemes *damon_sysfs_schemes_for_damos_callback;
+static int damon_sysfs_schemes_region_idx;
+
+/*
+ * DAMON callback that called before damos apply.  While this callback is
+ * registered, damon_sysfs_lock should be held to ensure the regions
+ * directories exist.
+ */
+static int damon_sysfs_before_damos_apply(struct damon_ctx *ctx,
+               struct damon_target *t, struct damon_region *r,
+               struct damos *s)
+{
+       struct damos *scheme;
+       struct damon_sysfs_scheme_regions *sysfs_regions;
+       struct damon_sysfs_scheme_region *region;
+       struct damon_sysfs_schemes *sysfs_schemes =
+               damon_sysfs_schemes_for_damos_callback;
+       int schemes_idx = 0;
+
+       damon_for_each_scheme(scheme, ctx) {
+               if (scheme == s)
+                       break;
+               schemes_idx++;
+       }
+
+       /* user could have removed the scheme sysfs dir */
+       if (schemes_idx >= sysfs_schemes->nr)
+               return 0;
+
+       sysfs_regions = sysfs_schemes->schemes_arr[schemes_idx]->tried_regions;
+       region = damon_sysfs_scheme_region_alloc(r);
+       list_add_tail(&region->list, &sysfs_regions->regions_list);
+       sysfs_regions->nr_regions++;
+       if (kobject_init_and_add(&region->kobj,
+                               &damon_sysfs_scheme_region_ktype,
+                               &sysfs_regions->kobj, "%d",
+                               damon_sysfs_schemes_region_idx++)) {
+               kobject_put(&region->kobj);
+       }
+       return 0;
+}
+
+/* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */
+int damon_sysfs_schemes_update_regions_start(
+               struct damon_sysfs_schemes *sysfs_schemes,
+               struct damon_ctx *ctx)
+{
+       struct damos *scheme;
+       int schemes_idx = 0;
+
+       damon_for_each_scheme(scheme, ctx) {
+               struct damon_sysfs_scheme *sysfs_scheme;
+
+               sysfs_scheme = sysfs_schemes->schemes_arr[schemes_idx++];
+               damon_sysfs_scheme_regions_rm_dirs(
+                               sysfs_scheme->tried_regions);
+       }
+
+       damon_sysfs_schemes_for_damos_callback = sysfs_schemes;
+       ctx->callback.before_damos_apply = damon_sysfs_before_damos_apply;
+       return 0;
+}
+
+/*
+ * Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock.  Caller
+ * should unlock damon_sysfs_lock which held before
+ * damon_sysfs_schemes_update_regions_start()
+ */
+int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx)
+{
+       damon_sysfs_schemes_for_damos_callback = NULL;
+       ctx->callback.before_damos_apply = NULL;
+       damon_sysfs_schemes_region_idx = 0;
+       return 0;
+}

diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c
index 284daf2..ffb5a84 100644 (file)
--- a/mm/damon/sysfs.c
+++ b/mm/damon/sysfs.c
@@ -1000,6 +1000,11 @@ enum damon_sysfs_cmd {
         */
        DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS,
        /*
+        * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried
+        * regions
+        */
+       DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS,
+       /*
         * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands.
         */
        NR_DAMON_SYSFS_CMDS,
@@ -1011,6 +1016,7 @@ static const char * const damon_sysfs_cmd_strs[] = {
        "off",
        "commit",
        "update_schemes_stats",
+       "update_schemes_tried_regions",
 };
 
 /*
@@ -1193,6 +1199,16 @@ static int damon_sysfs_set_targets(struct damon_ctx *ctx,
 static void damon_sysfs_before_terminate(struct damon_ctx *ctx)
 {
        struct damon_target *t, *next;
+       struct damon_sysfs_kdamond *kdamond;
+
+       /* damon_sysfs_schemes_update_regions_stop() might not yet called */
+       kdamond = damon_sysfs_cmd_request.kdamond;
+       if (kdamond && damon_sysfs_cmd_request.cmd ==
+                       DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS &&
+                       ctx == kdamond->damon_ctx) {
+               damon_sysfs_schemes_update_regions_stop(ctx);
+               mutex_unlock(&damon_sysfs_lock);
+       }
 
        if (!damon_target_has_pid(ctx))
                return;
@@ -1225,6 +1241,27 @@ static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond)
        return 0;
 }
 
+static int damon_sysfs_upd_schemes_regions_start(
+               struct damon_sysfs_kdamond *kdamond)
+{
+       struct damon_ctx *ctx = kdamond->damon_ctx;
+
+       if (!ctx)
+               return -EINVAL;
+       return damon_sysfs_schemes_update_regions_start(
+                       kdamond->contexts->contexts_arr[0]->schemes, ctx);
+}
+
+static int damon_sysfs_upd_schemes_regions_stop(
+               struct damon_sysfs_kdamond *kdamond)
+{
+       struct damon_ctx *ctx = kdamond->damon_ctx;
+
+       if (!ctx)
+               return -EINVAL;
+       return damon_sysfs_schemes_update_regions_stop(ctx);
+}
+
 static inline bool damon_sysfs_kdamond_running(
                struct damon_sysfs_kdamond *kdamond)
 {
@@ -1277,10 +1314,12 @@ static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond)
 static int damon_sysfs_cmd_request_callback(struct damon_ctx *c)
 {
        struct damon_sysfs_kdamond *kdamond;
+       static bool damon_sysfs_schemes_regions_updating;
        int err = 0;
 
        /* avoid deadlock due to concurrent state_store('off') */
-       if (!mutex_trylock(&damon_sysfs_lock))
+       if (!damon_sysfs_schemes_regions_updating &&
+                       !mutex_trylock(&damon_sysfs_lock))
                return 0;
        kdamond = damon_sysfs_cmd_request.kdamond;
        if (!kdamond || kdamond->damon_ctx != c)
@@ -1292,13 +1331,27 @@ static int damon_sysfs_cmd_request_callback(struct damon_ctx *c)
        case DAMON_SYSFS_CMD_COMMIT:
                err = damon_sysfs_commit_input(kdamond);
                break;
+       case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS:
+               if (!damon_sysfs_schemes_regions_updating) {
+                       err = damon_sysfs_upd_schemes_regions_start(kdamond);
+                       if (!err) {
+                               damon_sysfs_schemes_regions_updating = true;
+                               goto keep_lock_out;
+                       }
+               } else {
+                       err = damon_sysfs_upd_schemes_regions_stop(kdamond);
+                       damon_sysfs_schemes_regions_updating = false;
+               }
+               break;
        default:
                break;
        }
        /* Mark the request as invalid now. */
        damon_sysfs_cmd_request.kdamond = NULL;
 out:
-       mutex_unlock(&damon_sysfs_lock);
+       if (!damon_sysfs_schemes_regions_updating)
+               mutex_unlock(&damon_sysfs_lock);
+keep_lock_out:
        return err;
 }