mm/damon/core: remove damon_callback

	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().

 *

 * ``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;

	struct mutex kdamond_lock;

	struct damon_operations ops;

	struct damon_callback callback;

	struct list_head adaptive_targets;

	struct list_head schemes;

 * @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.

 *

 * 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)

{

 * 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)

{

		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);

	}

	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;

		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

			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);