mm/damon/core: simplify the kdamond stop mechanism by removing 'done'

When the 'kdamond_wait_activation()' function or 'after_sampling()' or
'after_aggregation()' DAMON callbacks return an error, it is unnecessary
to use bool 'done' to check if kdamond should be finished.  This commit
simplifies the kdamond stop mechanism by removing 'done' and break the
while loop directly in the cases.

Link: https://lkml.kernel.org/r/1663060287-30201-4-git-send-email-kaixuxia@tencent.com
Signed-off-by: Kaixu Xia <kaixuxia@tencent.com>
Reviewed-by: SeongJae Park <sj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/damon/core.c b/mm/damon/core.c
index 29635a82cb691747b3b0f54abf4e104bbd06aa0b..a843673c11cfc5a252fd2f6683af4ee5a03efaec 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -1152,30 +1152,25 @@ static int kdamond_fn(void *data)
        struct damon_region *r, *next;
        unsigned int max_nr_accesses = 0;
        unsigned long sz_limit = 0;
-       bool done = false;
 
        pr_debug("kdamond (%d) starts\n", current->pid);
 
        if (ctx->ops.init)
                ctx->ops.init(ctx);
        if (ctx->callback.before_start && ctx->callback.before_start(ctx))
-               done = true;
+               goto done;
 
        sz_limit = damon_region_sz_limit(ctx);
 
-       while (!kdamond_need_stop(ctx) && !done) {
-               if (kdamond_wait_activation(ctx)) {
-                       done = true;
-                       continue;
-               }
+       while (!kdamond_need_stop(ctx)) {
+               if (kdamond_wait_activation(ctx))
+                       break;
 
                if (ctx->ops.prepare_access_checks)
                        ctx->ops.prepare_access_checks(ctx);
                if (ctx->callback.after_sampling &&
-                               ctx->callback.after_sampling(ctx)) {
-                       done = true;
-                       continue;
-               }
+                               ctx->callback.after_sampling(ctx))
+                       break;
 
                kdamond_usleep(ctx->attrs.sample_interval);
 
@@ -1187,10 +1182,8 @@ static int kdamond_fn(void *data)
                                        max_nr_accesses / 10,
                                        sz_limit);
                        if (ctx->callback.after_aggregation &&
-                                       ctx->callback.after_aggregation(ctx)) {
-                               done = true;
-                               continue;
-                       }
+                                       ctx->callback.after_aggregation(ctx))
+                               break;
                        kdamond_apply_schemes(ctx);
                        kdamond_reset_aggregated(ctx);
                        kdamond_split_regions(ctx);
@@ -1204,6 +1197,7 @@ static int kdamond_fn(void *data)
                        sz_limit = damon_region_sz_limit(ctx);
                }
        }
+done:
        damon_for_each_target(t, ctx) {
                damon_for_each_region_safe(r, next, t)
                        damon_destroy_region(r, t);