mm/damon/core: move damon_set_targets() into dbgfs

damon_set_targets() function is defined in the core for general use cases,
but called from only dbgfs.  Also, because the function is for general use
cases, dbgfs does additional handling of pid type target id case.  To make
the situation simpler, this commit moves the function into dbgfs and makes
it to do the pid type case handling on its own.

Link: https://lkml.kernel.org/r/20211230100723.2238-4-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/damon.h b/include/linux/damon.h
index 5e1e3a128b77a9bac6452a7fa40c69e2c2cc456b..bd021af5db3d1706a51c21fe59dfdd36a384a531 100644 (file)
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -484,8 +484,6 @@ unsigned int damon_nr_regions(struct damon_target *t);
 
 struct damon_ctx *damon_new_ctx(void);
 void damon_destroy_ctx(struct damon_ctx *ctx);
-int damon_set_targets(struct damon_ctx *ctx,
-               unsigned long *ids, ssize_t nr_ids);
 int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int,
                unsigned long aggr_int, unsigned long primitive_upd_int,
                unsigned long min_nr_reg, unsigned long max_nr_reg);

diff --git a/mm/damon/core-test.h b/mm/damon/core-test.h
index 7008c3735e99f1d486109aeb8d9b3ccfbf68b6fb..4a6141ddd6fcfa3a6d420092cf57c5365e58b175 100644 (file)
--- a/mm/damon/core-test.h
+++ b/mm/damon/core-test.h
@@ -86,7 +86,10 @@ static void damon_test_aggregate(struct kunit *test)
        struct damon_region *r;
        int it, ir;
 
-       damon_set_targets(ctx, target_ids, 3);
+       for (it = 0; it < 3; it++) {
+               t = damon_new_target(target_ids[it]);
+               damon_add_target(ctx, t);
+       }
 
        it = 0;
        damon_for_each_target(t, ctx) {

diff --git a/mm/damon/core.c b/mm/damon/core.c
index 1dd153c31c9e2b8e5fd6bc7d608f830e768f9c1e..3fef5c667a31d752fcc86eaea0090edc36e9c27d 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -245,38 +245,6 @@ void damon_destroy_ctx(struct damon_ctx *ctx)
        kfree(ctx);
 }
 
-/**
- * damon_set_targets() - Set monitoring targets.
- * @ctx:       monitoring context
- * @ids:       array of target ids
- * @nr_ids:    number of entries in @ids
- *
- * This function should not be called while the kdamond is running.
- *
- * Return: 0 on success, negative error code otherwise.
- */
-int damon_set_targets(struct damon_ctx *ctx,
-                     unsigned long *ids, ssize_t nr_ids)
-{
-       ssize_t i;
-       struct damon_target *t, *next;
-
-       damon_destroy_targets(ctx);
-
-       for (i = 0; i < nr_ids; i++) {
-               t = damon_new_target(ids[i]);
-               if (!t) {
-                       /* The caller should do cleanup of the ids itself */
-                       damon_for_each_target_safe(t, next, ctx)
-                               damon_destroy_target(t);
-                       return -ENOMEM;
-               }
-               damon_add_target(ctx, t);
-       }
-
-       return 0;
-}
-
 /**
  * damon_set_attrs() - Set attributes for the monitoring.
  * @ctx:               monitoring context

diff --git a/mm/damon/dbgfs-test.h b/mm/damon/dbgfs-test.h
index 00bff058fe08fb8d1d1b60ae5c3d83a715221614..c1c988b607bc976d38aabb0ada2e49b042294e77 100644 (file)
--- a/mm/damon/dbgfs-test.h
+++ b/mm/damon/dbgfs-test.h
@@ -86,23 +86,23 @@ static void damon_dbgfs_test_set_targets(struct kunit *test)
        ctx->primitive.target_valid = NULL;
        ctx->primitive.cleanup = NULL;
 
-       damon_set_targets(ctx, ids, 3);
+       dbgfs_set_targets(ctx, ids, 3);
        sprint_target_ids(ctx, buf, 64);
        KUNIT_EXPECT_STREQ(test, (char *)buf, "1 2 3\n");
 
-       damon_set_targets(ctx, NULL, 0);
+       dbgfs_set_targets(ctx, NULL, 0);
        sprint_target_ids(ctx, buf, 64);
        KUNIT_EXPECT_STREQ(test, (char *)buf, "\n");
 
-       damon_set_targets(ctx, (unsigned long []){1, 2}, 2);
+       dbgfs_set_targets(ctx, (unsigned long []){1, 2}, 2);
        sprint_target_ids(ctx, buf, 64);
        KUNIT_EXPECT_STREQ(test, (char *)buf, "1 2\n");
 
-       damon_set_targets(ctx, (unsigned long []){2}, 1);
+       dbgfs_set_targets(ctx, (unsigned long []){2}, 1);
        sprint_target_ids(ctx, buf, 64);
        KUNIT_EXPECT_STREQ(test, (char *)buf, "2\n");
 
-       damon_set_targets(ctx, NULL, 0);
+       dbgfs_set_targets(ctx, NULL, 0);
        sprint_target_ids(ctx, buf, 64);
        KUNIT_EXPECT_STREQ(test, (char *)buf, "\n");
 
@@ -130,7 +130,7 @@ static void damon_dbgfs_test_set_init_regions(struct kunit *test)
        int i, rc;
        char buf[256];
 
-       damon_set_targets(ctx, ids, 3);
+       dbgfs_set_targets(ctx, ids, 3);
 
        /* Put valid inputs and check the results */
        for (i = 0; i < ARRAY_SIZE(valid_inputs); i++) {
@@ -158,7 +158,7 @@ static void damon_dbgfs_test_set_init_regions(struct kunit *test)
                KUNIT_EXPECT_STREQ(test, (char *)buf, "");
        }
 
-       damon_set_targets(ctx, NULL, 0);
+       dbgfs_set_targets(ctx, NULL, 0);
        damon_destroy_ctx(ctx);
 }
 

diff --git a/mm/damon/dbgfs.c b/mm/damon/dbgfs.c
index 3f65af04e4e6086c60cc78eac8515922e0541679..58867b96663503eb6260bc4cd72214298b0eeb3a 100644 (file)
--- a/mm/damon/dbgfs.c
+++ b/mm/damon/dbgfs.c
@@ -358,11 +358,48 @@ static void dbgfs_put_pids(unsigned long *ids, int nr_ids)
                put_pid((struct pid *)ids[i]);
 }
 
+/*
+ * dbgfs_set_targets() - Set monitoring targets.
+ * @ctx:       monitoring context
+ * @ids:       array of target ids
+ * @nr_ids:    number of entries in @ids
+ *
+ * This function should not be called while the kdamond is running.
+ *
+ * Return: 0 on success, negative error code otherwise.
+ */
+static int dbgfs_set_targets(struct damon_ctx *ctx,
+                     unsigned long *ids, ssize_t nr_ids)
+{
+       ssize_t i;
+       struct damon_target *t, *next;
+
+       damon_for_each_target_safe(t, next, ctx) {
+               if (targetid_is_pid(ctx))
+                       put_pid((struct pid *)t->id);
+               damon_destroy_target(t);
+       }
+
+       for (i = 0; i < nr_ids; i++) {
+               t = damon_new_target(ids[i]);
+               if (!t) {
+                       /* The caller should do cleanup of the ids itself */
+                       damon_for_each_target_safe(t, next, ctx)
+                               damon_destroy_target(t);
+                       if (targetid_is_pid(ctx))
+                               dbgfs_put_pids(ids, nr_ids);
+                       return -ENOMEM;
+               }
+               damon_add_target(ctx, t);
+       }
+
+       return 0;
+}
+
 static ssize_t dbgfs_target_ids_write(struct file *file,
                const char __user *buf, size_t count, loff_t *ppos)
 {
        struct damon_ctx *ctx = file->private_data;
-       struct damon_target *t, *next_t;
        bool id_is_pid = true;
        char *kbuf;
        unsigned long *targets;
@@ -407,11 +444,7 @@ static ssize_t dbgfs_target_ids_write(struct file *file,
        }
 
        /* remove previously set targets */
-       damon_for_each_target_safe(t, next_t, ctx) {
-               if (targetid_is_pid(ctx))
-                       put_pid((struct pid *)t->id);
-               damon_destroy_target(t);
-       }
+       dbgfs_set_targets(ctx, NULL, 0);
 
        /* Configure the context for the address space type */
        if (id_is_pid)
@@ -419,13 +452,9 @@ static ssize_t dbgfs_target_ids_write(struct file *file,
        else
                damon_pa_set_primitives(ctx);
 
-       ret = damon_set_targets(ctx, targets, nr_targets);
-       if (ret) {
-               if (id_is_pid)
-                       dbgfs_put_pids(targets, nr_targets);
-       } else {
+       ret = dbgfs_set_targets(ctx, targets, nr_targets);
+       if (!ret)
                ret = count;
-       }
 
 unlock_out:
        mutex_unlock(&ctx->kdamond_lock);