mm/damon/core: commit probes

Update damon_commit_ctx() to commit installed data probes, too.

Link: https://lore.kernel.org/20260518234119.97569-5-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Cc: David Hildenbrand <david@kernel.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Liam R. Howlett <liam@infradead.org>
Cc: Lorenzo Stoakes <ljs@kernel.org>
Cc: "Masami Hiramatsu (Google)" <mhiramat@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/damon/core.c b/mm/damon/core.c
index d01417955a3b4130c61483023b657b0f7cd2be1d..240cae1420c12b6aeaad745f723141fe8a126adb 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -133,11 +133,34 @@ void damon_add_filter(struct damon_probe *p, struct damon_filter *f)
        list_add_tail(&f->list, &p->filters);
 }
 
+static void damon_del_filter(struct damon_filter *f)
+{
+       list_del(&f->list);
+}
+
 static void damon_free_filter(struct damon_filter *f)
 {
        kfree(f);
 }
 
+static void damon_destroy_filter(struct damon_filter *f)
+{
+       damon_del_filter(f);
+       damon_free_filter(f);
+}
+
+static struct damon_filter *damon_nth_filter(int n, struct damon_probe *p)
+{
+       struct damon_filter *f;
+       int i = 0;
+
+       damon_for_each_filter(f, p) {
+               if (i++ == n)
+                       return f;
+       }
+       return NULL;
+}
+
 struct damon_probe *damon_new_probe(void)
 {
        struct damon_probe *p;
@@ -175,6 +198,18 @@ static void damon_destroy_probe(struct damon_probe *p)
        damon_free_probe(p);
 }
 
+static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx)
+{
+       struct damon_probe *p;
+       int i = 0;
+
+       damon_for_each_probe(p, ctx) {
+               if (i++ == n)
+                       return p;
+       }
+       return NULL;
+}
+
 #ifdef CONFIG_DAMON_DEBUG_SANITY
 static void damon_verify_new_region(unsigned long start, unsigned long end)
 {
@@ -1386,6 +1421,72 @@ static int damon_commit_targets(
        return 0;
 }
 
+static void damon_commit_filter(struct damon_filter *dst,
+               struct damon_filter *src)
+{
+       dst->type = src->type;
+       dst->matching = src->matching;
+       dst->allow = src->allow;
+}
+
+static int damon_commit_filters(struct damon_probe *dst,
+               struct damon_probe *src)
+{
+       struct damon_filter *dst_filter, *next, *src_filter, *new_filter;
+       int i = 0, j = 0;
+
+       damon_for_each_filter_safe(dst_filter, next, dst) {
+               src_filter = damon_nth_filter(i++, src);
+               if (src_filter)
+                       damon_commit_filter(dst_filter, src_filter);
+               else
+                       damon_destroy_filter(dst_filter);
+       }
+
+       damon_for_each_filter_safe(src_filter, next, src) {
+               if (j++ < i)
+                       continue;
+
+               new_filter = damon_new_filter(src_filter->type,
+                               src_filter->matching, src_filter->allow);
+               if (!new_filter)
+                       return -ENOMEM;
+               damon_add_filter(dst, new_filter);
+       }
+       return 0;
+}
+
+static int damon_commit_probes(struct damon_ctx *dst, struct damon_ctx *src)
+{
+       struct damon_probe *dst_probe, *next, *src_probe, *new_probe;
+       int i = 0, j = 0, err;
+
+       damon_for_each_probe_safe(dst_probe, next, dst) {
+               src_probe = damon_nth_probe(i++, src);
+               if (src_probe) {
+                       err = damon_commit_filters(dst_probe, src_probe);
+                       if (err)
+                               return err;
+               } else {
+                       damon_destroy_probe(dst_probe);
+               }
+       }
+
+       damon_for_each_probe_safe(src_probe, next, src) {
+               if (j++ < i)
+                       continue;
+
+               new_probe = damon_new_probe();
+               if (!new_probe)
+                       return -ENOMEM;
+               damon_add_probe(dst, new_probe);
+               err = damon_commit_filters(new_probe, src_probe);
+               if (err)
+                       return err;
+       }
+       return 0;
+}
+
 /**
  * damon_commit_ctx() - Commit parameters of a DAMON context to another.
  * @dst:       The commit destination DAMON context.
@@ -1442,6 +1543,9 @@ int damon_commit_ctx(struct damon_ctx *dst, struct damon_ctx *src)
        }
        dst->pause = src->pause;
        dst->ops = src->ops;
+       err = damon_commit_probes(dst, src);
+       if (err)
+               return err;
        dst->addr_unit = src->addr_unit;
        dst->min_region_sz = src->min_region_sz;