mm/damon/core: remove damon_callback

All damon_callback usages are replicated by damon_call() and damos_walk().
Time to say goodbye.  Remove damon_callback.

Link: https://lkml.kernel.org/r/20250712195016.151108-15-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/damon.h b/include/linux/damon.h
index 8c765e36623aa7ca872a3e93dfa6e0fe32f27371..f13664c62ddda5b74ab2b4a961ae61d0c510b315 100644 (file)
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -629,34 +629,6 @@ struct damon_operations {
        void (*cleanup)(struct damon_ctx *context);
 };
 
-/**
- * struct damon_callback - Monitoring events notification callbacks.
- *
- * @after_wmarks_check:        Called after each schemes' watermarks check.
- * @after_aggregation: Called after each aggregation.
- * @before_terminate:  Called before terminating the monitoring.
- *
- * The monitoring thread (&damon_ctx.kdamond) calls @before_terminate just
- * before finishing the monitoring.
- *
- * The monitoring thread calls @after_wmarks_check after each DAMON-based
- * operation schemes' watermarks check.  If users need to make changes to the
- * attributes of the monitoring context while it's deactivated due to the
- * watermarks, this is the good place to do.
- *
- * The monitoring thread calls @after_aggregation for each of the aggregation
- * intervals.  Therefore, users can safely access the monitoring results
- * without additional protection.  For the reason, users are recommended to use
- * these callback for the accesses to the results.
- *
- * If any callback returns non-zero, monitoring stops.
- */
-struct damon_callback {
-       int (*after_wmarks_check)(struct damon_ctx *context);
-       int (*after_aggregation)(struct damon_ctx *context);
-       void (*before_terminate)(struct damon_ctx *context);
-};
-
 /*
  * struct damon_call_control - Control damon_call().
  *
@@ -727,7 +699,7 @@ struct damon_intervals_goal {
  * ``mmap()`` calls from the application, in case of virtual memory monitoring)
  * and applies the changes for each @ops_update_interval.  All time intervals
  * are in micro-seconds.  Please refer to &struct damon_operations and &struct
- * damon_callback for more detail.
+ * damon_call_control for more detail.
  */
 struct damon_attrs {
        unsigned long sample_interval;
@@ -816,7 +788,6 @@ struct damon_ctx {
        struct mutex kdamond_lock;
 
        struct damon_operations ops;
-       struct damon_callback callback;
 
        struct list_head adaptive_targets;
        struct list_head schemes;

diff --git a/mm/damon/core.c b/mm/damon/core.c
index ffd1a061c2cbe66494ef9265873467f3969cb7ae..f3ec3bd736eca97501adddd91307ed74cda81f46 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -680,9 +680,7 @@ static bool damon_valid_intervals_goal(struct damon_attrs *attrs)
  * @attrs:             monitoring attributes
  *
  * This function should be called while the kdamond is not running, an access
- * check results aggregation is not ongoing (e.g., from &struct
- * damon_callback->after_aggregation or &struct
- * damon_callback->after_wmarks_check callbacks), or from damon_call().
+ * check results aggregation is not ongoing (e.g., from damon_call().
  *
  * Every time interval is in micro-seconds.
  *
@@ -778,7 +776,7 @@ static void damos_commit_quota_goal(
  * DAMON contexts, instead of manual in-place updates.
  *
  * This function should be called from parameters-update safe context, like
- * DAMON callbacks.
+ * damon_call().
  */
 int damos_commit_quota_goals(struct damos_quota *dst, struct damos_quota *src)
 {
@@ -1177,7 +1175,7 @@ static int damon_commit_targets(
  * in-place updates.
  *
  * This function should be called from parameters-update safe context, like
- * DAMON callbacks.
+ * damon_call().
  */
 int damon_commit_ctx(struct damon_ctx *dst, struct damon_ctx *src)
 {
@@ -2484,9 +2482,6 @@ static int kdamond_wait_activation(struct damon_ctx *ctx)
 
                kdamond_usleep(min_wait_time);
 
-               if (ctx->callback.after_wmarks_check &&
-                               ctx->callback.after_wmarks_check(ctx))
-                       break;
                kdamond_call(ctx, false);
                damos_walk_cancel(ctx);
        }
@@ -2543,10 +2538,9 @@ static int kdamond_fn(void *data)
        while (!kdamond_need_stop(ctx)) {
                /*
                 * ctx->attrs and ctx->next_{aggregation,ops_update}_sis could
-                * be changed from after_wmarks_check() or after_aggregation()
-                * callbacks.  Read the values here, and use those for this
-                * iteration.  That is, damon_set_attrs() updated new values
-                * are respected from next iteration.
+                * be changed from kdamond_call().  Read the values here, and
+                * use those for this iteration.  That is, damon_set_attrs()
+                * updated new values are respected from next iteration.
                 */
                unsigned long next_aggregation_sis = ctx->next_aggregation_sis;
                unsigned long next_ops_update_sis = ctx->next_ops_update_sis;
@@ -2564,14 +2558,10 @@ static int kdamond_fn(void *data)
                if (ctx->ops.check_accesses)
                        max_nr_accesses = ctx->ops.check_accesses(ctx);
 
-               if (ctx->passed_sample_intervals >= next_aggregation_sis) {
+               if (ctx->passed_sample_intervals >= next_aggregation_sis)
                        kdamond_merge_regions(ctx,
                                        max_nr_accesses / 10,
                                        sz_limit);
-                       if (ctx->callback.after_aggregation &&
-                                       ctx->callback.after_aggregation(ctx))
-                               break;
-               }
 
                /*
                 * do kdamond_call() and kdamond_apply_schemes() after
@@ -2637,8 +2627,6 @@ done:
                        damon_destroy_region(r, t);
        }
 
-       if (ctx->callback.before_terminate)
-               ctx->callback.before_terminate(ctx);
        if (ctx->ops.cleanup)
                ctx->ops.cleanup(ctx);
        kfree(ctx->regions_score_histogram);