From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8274F2BCF41; Sun, 6 Jul 2025 20:00:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832026; cv=none; b=rIMtTg6eayOm3DIlqzNXoMrywz1LDcWIVn46WAyP3ncuCCm/J291BZ33rFCNMlDZ/yCL7sDkI0fQKEQKUX6dtDYpvkycsP4ARTWswI6r0ieWt3r0bn3sV50O/w2Tl4oDPXrpup6cNRUcZFZnQXbaslEi5k/RMHsbSNPINKLXj5c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832026; c=relaxed/simple; bh=xngwQdJg9SStMpbSeT2i8ZuPCcHFD5n4yxQZU8owQpo=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=lr5t0WtwHMQI4xQvewuYol0CArlJ7qfjFoam8hnLMPrV1+7C8TOd4519g8suM1n9AWT9mtQYR47gWGjvCs/WeA3aoCoEOF5wPqY22jjZGKhxcnpHyuTGUzASfdi6JV2SWbIiWmiyH5ipJeUV2tRUv6FbEw3Zg+5hsYiKNzGOj54= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Onb/X5Br; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Onb/X5Br" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E6CA4C4CEED; Sun, 6 Jul 2025 20:00:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832026; bh=xngwQdJg9SStMpbSeT2i8ZuPCcHFD5n4yxQZU8owQpo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Onb/X5BrLg4E4ya9P6ulS89sPP4Wf3LCW6Wvr0VaxdepBIEJ6oHsCTtcztCm87EjM irMxBSOse6pE15vyf1MZcQYCN6T2Xtvmsy1mng+bHPAd6yi9z+exFbFVufLywVrpR2 aIIaWYfG4Ch/cHncNLxLhynnGtyRVxQ0GiPxtmaL5Vxfb8PFTAUhjk73xln6imMnDR llK+1H9jIIuyRFbnvgEunMo+namHX+txHLpC/1/LVDaxaPtWwCTWSQyyJ8VJYLtsP0 Bz8Jsd9iDFItTMcviDCr4AhVTJOHFTp0cbpzTROESQmYCql3VU6bTZPTrD4pSwXffo Q+JWtYYMZzJ5w== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 01/14] mm/damon: accept parallel damon_call() requests Date: Sun, 6 Jul 2025 13:00:05 -0700 Message-Id: <20250706200018.42704-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Calling damon_call() while it is serving for another parallel thread immediately fails with -EBUSY. The caller should call it again, later. Each caller implementing such retry logic would be redundant. Accept parallel damon_call() requests and do the wait instead of the caller. Signed-off-by: SeongJae Park --- include/linux/damon.h | 7 +++++-- mm/damon/core.c | 49 ++++++++++++++++++++++--------------------- 2 files changed, 30 insertions(+), 26 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index accd45f203cd..9176a1c7d5a8 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -673,6 +673,8 @@ struct damon_call_control { struct completion completion; /* informs if the kdamond canceled @fn infocation */ bool canceled; + /* List head for siblings. */ + struct list_head list; }; =20 /** @@ -798,8 +800,9 @@ struct damon_ctx { /* for scheme quotas prioritization */ unsigned long *regions_score_histogram; =20 - struct damon_call_control *call_control; - struct mutex call_control_lock; + /* lists of &struct damon_call_control */ + struct list_head call_controls; + struct mutex call_controls_lock; =20 struct damos_walk_control *walk_control; struct mutex walk_control_lock; diff --git a/mm/damon/core.c b/mm/damon/core.c index 45c237ade8cf..01e62bdcdd67 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -533,7 +533,8 @@ struct damon_ctx *damon_new_ctx(void) ctx->next_ops_update_sis =3D 0; =20 mutex_init(&ctx->kdamond_lock); - mutex_init(&ctx->call_control_lock); + INIT_LIST_HEAD(&ctx->call_controls); + mutex_init(&ctx->call_controls_lock); mutex_init(&ctx->walk_control_lock); =20 ctx->attrs.min_nr_regions =3D 10; @@ -1353,14 +1354,11 @@ int damon_call(struct damon_ctx *ctx, struct damon_= call_control *control) { init_completion(&control->completion); control->canceled =3D false; + INIT_LIST_HEAD(&control->list); =20 - mutex_lock(&ctx->call_control_lock); - if (ctx->call_control) { - mutex_unlock(&ctx->call_control_lock); - return -EBUSY; - } - ctx->call_control =3D control; - mutex_unlock(&ctx->call_control_lock); + mutex_lock(&ctx->call_controls_lock); + list_add_tail(&ctx->call_controls, &control->list); + mutex_unlock(&ctx->call_controls_lock); if (!damon_is_running(ctx)) return -EINVAL; wait_for_completion(&control->completion); @@ -2379,11 +2377,11 @@ static void kdamond_usleep(unsigned long usecs) } =20 /* - * kdamond_call() - handle damon_call_control. + * kdamond_call() - handle damon_call_control objects. * @ctx: The &struct damon_ctx of the kdamond. * @cancel: Whether to cancel the invocation of the function. * - * If there is a &struct damon_call_control request that registered via + * If there are &struct damon_call_control requests that registered via * &damon_call() on @ctx, do or cancel the invocation of the function depe= nding * on @cancel. @cancel is set when the kdamond is already out of the main= loop * and therefore will be terminated. @@ -2393,21 +2391,24 @@ static void kdamond_call(struct damon_ctx *ctx, boo= l cancel) struct damon_call_control *control; int ret =3D 0; =20 - mutex_lock(&ctx->call_control_lock); - control =3D ctx->call_control; - mutex_unlock(&ctx->call_control_lock); - if (!control) - return; - if (cancel) { - control->canceled =3D true; - } else { - ret =3D control->fn(control->data); - control->return_code =3D ret; + while (true) { + mutex_lock(&ctx->call_controls_lock); + control =3D list_first_entry_or_null(&ctx->call_controls, + struct damon_call_control, list); + mutex_unlock(&ctx->call_controls_lock); + if (!control) + return; + if (cancel) { + control->canceled =3D true; + } else { + ret =3D control->fn(control->data); + control->return_code =3D ret; + } + mutex_lock(&ctx->call_controls_lock); + list_del(&control->list); + mutex_unlock(&ctx->call_controls_lock); + complete(&control->completion); } - complete(&control->completion); - mutex_lock(&ctx->call_control_lock); - ctx->call_control =3D NULL; - mutex_unlock(&ctx->call_control_lock); } =20 /* Returns negative error code if it's not activated but should return */ --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8A0E42BD01E; Sun, 6 Jul 2025 20:00:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832027; cv=none; b=B42E/K+5zV2umMr6y22iLHwgqHo8QNlWEglI1sgyNSW8qiW8nwfKe8NQ1jIXG7n7qw7yOxsEDNOxM7UDKLs+vxAL2mldgJI/F0ICQ/GAFje3yBHHDD++UXsDXr9BkG2UXt8S8Nnl6kRWvDxO5P/sEeUuSIdNzNeuYr5UF6IEf78= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832027; c=relaxed/simple; bh=5isUX/qdRWz6RuSCLUkT6PmSqq6/sjQX47PJKxk/1f4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=k4O0ypmZpTOKGUe25XCMKQP5EWfrrF2hmul9DmuGFT/noKZGJJcuNNklTztQwC/JdXOrPGnou4Ns88l7ua1QOlIu5Tk98rYHSrdwUPQkLo3aoHEcqxnLCSkzZrhsY7oFLf4ax0g8I0VklMQ4qUFx0jerzmY0i1y/HNT5Surh7g4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=lVFVqjHu; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lVFVqjHu" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0AA7DC4CEF3; Sun, 6 Jul 2025 20:00:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832027; bh=5isUX/qdRWz6RuSCLUkT6PmSqq6/sjQX47PJKxk/1f4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=lVFVqjHu6ZkO7yJPWtOZqMA6G9AjWhKGP0HBTOzvLejArhKM0PiTXlmvWo82MLve9 CbF7gJxWPPUB87pIZ+b2UU77a7LzhLY1eSKGrO9D+jjxliS630HbmFlbbbv/t8XVki feq7AUbvIxI7icwwZXFPFFNq8YICq8Zrvm6KBM5ZTmCDyKRw8LV+3omANvexbWHrMi p19qWsrp8EOE25923yMHww+e6dMStquIt4jAIGSX1NR7OLP1LuGI2lnJZKIrqH/5sq 8k7+fWo5ZXMYyODZvAfyt4gzf2rawoB9JYmPG7uluGBw6jykwwJ0Zdb3qXj1WS9IDY 12OmR6OqAzc+w== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 02/14] mm/damon/core: introduce repeat mode damon_call() Date: Sun, 6 Jul 2025 13:00:06 -0700 Message-Id: <20250706200018.42704-3-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" damon_call() can be useful for reading or writing DAMON internal data for one time. A common pattern of DAMON core usage from DAMON modules is doing such reads and writes repeatedly, for example, to periodically update the DAMOS stats. To do that with damon_call(), callers should call damon_call() repeatedly, with their own delay loop. Each caller doing that is repetitive. Introduce a repeat mode damon_call(). Callers can use the mode by setting a new field in damon_call_control. If the mode is turned on, damon_call() returns success immediately, and DAMON repeats invoking the callback function inside the kdamond main loop. Signed-off-by: SeongJae Park --- include/linux/damon.h | 2 ++ mm/damon/core.c | 23 +++++++++++++++++++---- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 9176a1c7d5a8..2d51b575d660 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -659,6 +659,7 @@ struct damon_callback { * * @fn: Function to be called back. * @data: Data that will be passed to @fn. + * @repeat: Repeat invocations. * @return_code: Return code from @fn invocation. * * Control damon_call(), which requests specific kdamond to invoke a given @@ -667,6 +668,7 @@ struct damon_callback { struct damon_call_control { int (*fn)(void *data); void *data; + bool repeat; int return_code; /* private: internal use only */ /* informs if the kdamond finished handling of the request */ diff --git a/mm/damon/core.c b/mm/damon/core.c index 01e62bdcdd67..7a4dc76dd023 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1339,8 +1339,9 @@ bool damon_is_running(struct damon_ctx *ctx) * * Ask DAMON worker thread (kdamond) of @ctx to call a function with an * argument data that respectively passed via &damon_call_control->fn and - * &damon_call_control->data of @control, and wait until the kdamond finis= hes - * handling of the request. + * &damon_call_control->data of @control. If &damon_call_control->repeat = of + * @control is set, further wait until the kdamond finishes handling of the + * request. Otherwise, return as soon as the request is made. * * The kdamond executes the function with the argument in the main loop, j= ust * after a sampling of the iteration is finished. The function can hence @@ -1352,7 +1353,8 @@ bool damon_is_running(struct damon_ctx *ctx) */ int damon_call(struct damon_ctx *ctx, struct damon_call_control *control) { - init_completion(&control->completion); + if (!control->repeat) + init_completion(&control->completion); control->canceled =3D false; INIT_LIST_HEAD(&control->list); =20 @@ -1361,6 +1363,8 @@ int damon_call(struct damon_ctx *ctx, struct damon_ca= ll_control *control) mutex_unlock(&ctx->call_controls_lock); if (!damon_is_running(ctx)) return -EINVAL; + if (control->repeat) + return 0; wait_for_completion(&control->completion); if (control->canceled) return -ECANCELED; @@ -2389,6 +2393,7 @@ static void kdamond_usleep(unsigned long usecs) static void kdamond_call(struct damon_ctx *ctx, bool cancel) { struct damon_call_control *control; + LIST_HEAD(repeat_controls); int ret =3D 0; =20 while (true) { @@ -2407,8 +2412,18 @@ static void kdamond_call(struct damon_ctx *ctx, bool= cancel) mutex_lock(&ctx->call_controls_lock); list_del(&control->list); mutex_unlock(&ctx->call_controls_lock); - complete(&control->completion); + if (!control->repeat) + complete(&control->completion); + else + list_add(&control->list, &repeat_controls); } + control =3D list_first_entry_or_null(&repeat_controls, + struct damon_call_control, list); + if (!control || cancel) + return; + mutex_lock(&ctx->call_controls_lock); + list_add_tail(&control->list, &ctx->call_controls); + mutex_unlock(&ctx->call_controls_lock); } =20 /* Returns negative error code if it's not activated but should return */ --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8A45E2BD5A1; Sun, 6 Jul 2025 20:00:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832028; cv=none; b=hFiIyjM+fQqeTGH3OdtWsMYv/zak2dAN8/pV6wTMgKzOZ/aGvITsYfz0JnY5WqM2NQckNOV116gwiTIcItzmLF1TjrtpuEwnM0+4sEGQd9EJqJ97i9Op6sg8Ac4GSrhwfpph4w5z+EECwmve+aLYli1C82nHypZJDbYQaLoDT3s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832028; c=relaxed/simple; bh=zg5wCAX53+Zaz9D4ii0pAZ1fdfy4NlBPdESVNdjo6HE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=KGE7TnDpzm2v3uFc+kzrAVwrmE3YcFZqJKZCCsDDz6d060BbfwSXYsXx3xgAg0yBSFaAJkGwXzvLR1OhP/duCseiOyx/qAhXNB6sEcllZm45+EM4aG6m+Saz1lYfenOyzaFwojWn0Y+HIMr8BwMSfKzq15l5jN9QfiBnAr9rGrw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=it7NQBAW; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="it7NQBAW" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0C53EC4CEF8; Sun, 6 Jul 2025 20:00:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832028; bh=zg5wCAX53+Zaz9D4ii0pAZ1fdfy4NlBPdESVNdjo6HE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=it7NQBAWoPO1aaM9WpLvrXffl0pPOFaII5ba1fwJtcuYoLlKgAlonWs98iz+wwdWP Do0DFn0jT1Q7jPqxaHWU7dhBY4eQ9lDPuA0Sf27Mt4qSANRkV1ub05pW1ZZ46k8Qa/ lzgm5fc314ixUmmp5kxMNPXkakT7xgOXHfeoEXQpuiKbw1Fkspm8hIQ9rqui0OZ45Z XWC8y3/54QuPlziwBdvE0S+wJG8UE8+ivDRG12LtaQiv7w5N8piHpaIQ7vkYK8cZum 1PSun8pa+xGy+MsOsLfA4HVbWmXFh9Kd13a2ZcJnYId61dynFyf32kpccGqo624mpx 21IpiqPIL4SSg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 03/14] mm/damon/stat: use damon_call() repeat mode instead of damon_callback Date: Sun, 6 Jul 2025 13:00:07 -0700 Message-Id: <20250706200018.42704-4-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DAMON_STAT uses damon_callback for periodically reading DAMON internal data. Use its alternative, damon_call() repeat mode. Signed-off-by: SeongJae Park --- mm/damon/stat.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/mm/damon/stat.c b/mm/damon/stat.c index b75af871627e..87bcd8866d4b 100644 --- a/mm/damon/stat.c +++ b/mm/damon/stat.c @@ -122,8 +122,9 @@ static void damon_stat_set_idletime_percentiles(struct = damon_ctx *c) kfree(sorted_regions); } =20 -static int damon_stat_after_aggregation(struct damon_ctx *c) +static int damon_stat_damon_call_fn(void *data) { + struct damon_ctx *c =3D data; static unsigned long last_refresh_jiffies; =20 /* avoid unnecessarily frequent stat update */ @@ -182,19 +183,29 @@ static struct damon_ctx *damon_stat_build_ctx(void) damon_add_target(ctx, target); if (damon_set_region_biggest_system_ram_default(target, &start, &end)) goto free_out; - ctx->callback.after_aggregation =3D damon_stat_after_aggregation; return ctx; free_out: damon_destroy_ctx(ctx); return NULL; } =20 +static struct damon_call_control call_control =3D { + .fn =3D damon_stat_damon_call_fn, + .repeat =3D true, +}; + static int damon_stat_start(void) { + int err; + damon_stat_context =3D damon_stat_build_ctx(); if (!damon_stat_context) return -ENOMEM; - return damon_start(&damon_stat_context, 1, true); + err =3D damon_start(&damon_stat_context, 1, true); + if (err) + return err; + call_control.data =3D damon_stat_context; + return damon_call(damon_stat_context, &call_control); } =20 static void damon_stat_stop(void) --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C4AC327453; Sun, 6 Jul 2025 20:00:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832029; cv=none; b=fRtd2xQVyDWFXsfONjxkk0nExJrmO0o6TfYEZZfI6AmTBB2E0ezafzTMmIzg3OHnH6bnIzkHxQb918C/JTwTjCJCVTodqN30wB4gePbW2qEI98vnKLiuCP7glaXLzH0OWbSsmjcPI90zcX1LOA2WgLYZu930IL+nurSsYjZ9MtY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832029; c=relaxed/simple; bh=fAIXtGREPARQvCC1/X313DQcYGh4YYVNrncF7IRNX5A=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=f/yHlFoy5pESgQyQuF/8zSNGR1frb5slyipReNPGB/+aIwra6oqdFcoxmxan0sZDx9aEHOlriHFBNjMnPl70pnCVViNgNPpJ+EYLkC8znhwhDVPoUdGaR+LzFnACC9yATa3A3TalyzUmzil6SHq5xv949brtmN8YABbpC/Bt3Dk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=UXdaIZkN; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="UXdaIZkN" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 23B73C4CEF1; Sun, 6 Jul 2025 20:00:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832029; bh=fAIXtGREPARQvCC1/X313DQcYGh4YYVNrncF7IRNX5A=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=UXdaIZkNlkgZ1r227EoMFkd/phUYdd18Gs4t6OMVdKw9jA/2XC8RQwJT54vFPN+3g pWlz8hbAcTv/weQ62NPfEDEzkE2tcZSP7QazS6zidY8eKdCjpFLDx951laieehu33L mMwPs9QOm4lZqmgOZwYajcCWfnYrHu1lDF7fAJAel86dZySEG+TQhZYhJHuSQnjI4I nh20kKvS6ahdi8AYjYEl2JfqxA/4eR7OFuWFwrZmJY5ciL+rxRAWu2x1BKzizPTcLb GOeLJf3RGLTlKxj9JX5+bgIq9S+7vJl83ILJ2ylz4MEjSESHwEwb18Y3+qZpi1RltU 6UKa6++4gD1+A== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 04/14] mm/damon/reclaim: use damon_call() repeat mode instead of damon_callback Date: Sun, 6 Jul 2025 13:00:08 -0700 Message-Id: <20250706200018.42704-5-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DAMON_RECLAIM uses damon_callback for periodically reading and writing DAMON internal data and parameters. Use its alternative, damon_call() repeat mode. Signed-off-by: SeongJae Park --- mm/damon/reclaim.c | 62 +++++++++++++++++++++++----------------------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/mm/damon/reclaim.c b/mm/damon/reclaim.c index 0fe8996328b8..3c71b4596676 100644 --- a/mm/damon/reclaim.c +++ b/mm/damon/reclaim.c @@ -238,6 +238,35 @@ static int damon_reclaim_apply_parameters(void) return err; } =20 +static int damon_reclaim_handle_commit_inputs(void) +{ + int err; + + if (!commit_inputs) + return 0; + + err =3D damon_reclaim_apply_parameters(); + commit_inputs =3D false; + return err; +} + +static int damon_reclaim_damon_call_fn(void *arg) +{ + struct damon_ctx *c =3D arg; + struct damos *s; + + /* update the stats parameter */ + damon_for_each_scheme(s, c) + damon_reclaim_stat =3D s->stat; + + return damon_reclaim_handle_commit_inputs(); +} + +static struct damon_call_control call_control =3D { + .fn =3D damon_reclaim_damon_call_fn, + .repeat =3D true, +}; + static int damon_reclaim_turn(bool on) { int err; @@ -257,7 +286,7 @@ static int damon_reclaim_turn(bool on) if (err) return err; kdamond_pid =3D ctx->kdamond->pid; - return 0; + return damon_call(ctx, &call_control); } =20 static int damon_reclaim_enabled_store(const char *val, @@ -296,34 +325,6 @@ module_param_cb(enabled, &enabled_param_ops, &enabled,= 0600); MODULE_PARM_DESC(enabled, "Enable or disable DAMON_RECLAIM (default: disabled)"); =20 -static int damon_reclaim_handle_commit_inputs(void) -{ - int err; - - if (!commit_inputs) - return 0; - - err =3D damon_reclaim_apply_parameters(); - commit_inputs =3D false; - return err; -} - -static int damon_reclaim_after_aggregation(struct damon_ctx *c) -{ - struct damos *s; - - /* update the stats parameter */ - damon_for_each_scheme(s, c) - damon_reclaim_stat =3D s->stat; - - return damon_reclaim_handle_commit_inputs(); -} - -static int damon_reclaim_after_wmarks_check(struct damon_ctx *c) -{ - return damon_reclaim_handle_commit_inputs(); -} - static int __init damon_reclaim_init(void) { int err =3D damon_modules_new_paddr_ctx_target(&ctx, &target); @@ -331,8 +332,7 @@ static int __init damon_reclaim_init(void) if (err) goto out; =20 - ctx->callback.after_wmarks_check =3D damon_reclaim_after_wmarks_check; - ctx->callback.after_aggregation =3D damon_reclaim_after_aggregation; + call_control.data =3D ctx; =20 /* 'enabled' has set before this function, probably via command line */ if (enabled) --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7F1F12BE025; Sun, 6 Jul 2025 20:00:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832030; cv=none; b=qzLVzsDB+WkJ/kZakO8SmBuGnHnPtqRR57YIGlnm91K1vAZwkRrrn/XURN6Z/1uPHO5ywOIIAjP/qkOv84edQ7V2SUsA4IddyufCJq53OTvcdknrqxT+74hgv9qCddLbWlriqH5C1OA27rBiDKxBHqal2z/FgKVrQq7GrdaLDUs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832030; c=relaxed/simple; bh=8BmJeyRI+t+rJLAQd+/Sf188h6vX4h9leuX/fdJu7n0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=KMyQzQHM+4xi7Lg148G5ZxS2Y0ureZYQTxG8/4Hgh3RPdr6tyHVaR+v5clFEu9UbhwVFDsE8YatrIZkdqkeyS/NROcpxI/pdnIllp3nJzLhF2HV+esKQw1V70E+LayuiKksa/AtOl3NkM0hwkXCFzCKRZqIHNaIdOnh35N045Wo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CNetGueO; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="CNetGueO" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 39236C4CEF1; Sun, 6 Jul 2025 20:00:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832030; bh=8BmJeyRI+t+rJLAQd+/Sf188h6vX4h9leuX/fdJu7n0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=CNetGueOoHKanG9mUzlnRfLDtfMrit02JswGEmbInvJ85dfZl/Wf0abkAi/EZmchO Y0GloZ2cQ8lw+lC6rUb+L0UTl3brkJGcAxee2uX2JFxCuAb11Vj1bM/LfDhD/Yf25v nB8Pf4OwaBI+INgAcsZJDg8eybijqPzrNuJ35jTzUD38DKfJJrSZLWP6cgEDn5EGOC psjnjL+pVz0uwuTkfCti6qM9L6ky69AccMZ66DTZfpCVEt4HPx4rJmo1IOyaKWvs96 GmDv8ptuqKDffYWUaNgUXI19BZyVRWq8G2WGboOV5EUOAEib02fuql9ZLX2yfGUjrj wrT7Tgi3ymv1g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 05/14] mm/damon/lru_sort: use damon_call() repeat mode instead of damon_callback Date: Sun, 6 Jul 2025 13:00:09 -0700 Message-Id: <20250706200018.42704-6-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DAMON_LRU_SORT uses damon_callback for periodically reading and writing DAMON internal data and parameters. Use its alternative, damon_call() repeat mode. Signed-off-by: SeongJae Park --- mm/damon/lru_sort.c | 70 ++++++++++++++++++++++----------------------- 1 file changed, 35 insertions(+), 35 deletions(-) diff --git a/mm/damon/lru_sort.c b/mm/damon/lru_sort.c index dcac775eaa11..621f19546596 100644 --- a/mm/damon/lru_sort.c +++ b/mm/damon/lru_sort.c @@ -230,6 +230,39 @@ static int damon_lru_sort_apply_parameters(void) return err; } =20 +static int damon_lru_sort_handle_commit_inputs(void) +{ + int err; + + if (!commit_inputs) + return 0; + + err =3D damon_lru_sort_apply_parameters(); + commit_inputs =3D false; + return err; +} + +static int damon_lru_sort_damon_call_fn(void *arg) +{ + struct damon_ctx *c =3D arg; + struct damos *s; + + /* update the stats parameter */ + damon_for_each_scheme(s, c) { + if (s->action =3D=3D DAMOS_LRU_PRIO) + damon_lru_sort_hot_stat =3D s->stat; + else if (s->action =3D=3D DAMOS_LRU_DEPRIO) + damon_lru_sort_cold_stat =3D s->stat; + } + + return damon_lru_sort_handle_commit_inputs(); +} + +static struct damon_call_control call_control =3D { + .fn =3D damon_lru_sort_damon_call_fn, + .repeat =3D true, +}; + static int damon_lru_sort_turn(bool on) { int err; @@ -249,7 +282,7 @@ static int damon_lru_sort_turn(bool on) if (err) return err; kdamond_pid =3D ctx->kdamond->pid; - return 0; + return damon_call(ctx, &call_control); } =20 static int damon_lru_sort_enabled_store(const char *val, @@ -288,38 +321,6 @@ module_param_cb(enabled, &enabled_param_ops, &enabled,= 0600); MODULE_PARM_DESC(enabled, "Enable or disable DAMON_LRU_SORT (default: disabled)"); =20 -static int damon_lru_sort_handle_commit_inputs(void) -{ - int err; - - if (!commit_inputs) - return 0; - - err =3D damon_lru_sort_apply_parameters(); - commit_inputs =3D false; - return err; -} - -static int damon_lru_sort_after_aggregation(struct damon_ctx *c) -{ - struct damos *s; - - /* update the stats parameter */ - damon_for_each_scheme(s, c) { - if (s->action =3D=3D DAMOS_LRU_PRIO) - damon_lru_sort_hot_stat =3D s->stat; - else if (s->action =3D=3D DAMOS_LRU_DEPRIO) - damon_lru_sort_cold_stat =3D s->stat; - } - - return damon_lru_sort_handle_commit_inputs(); -} - -static int damon_lru_sort_after_wmarks_check(struct damon_ctx *c) -{ - return damon_lru_sort_handle_commit_inputs(); -} - static int __init damon_lru_sort_init(void) { int err =3D damon_modules_new_paddr_ctx_target(&ctx, &target); @@ -327,8 +328,7 @@ static int __init damon_lru_sort_init(void) if (err) goto out; =20 - ctx->callback.after_wmarks_check =3D damon_lru_sort_after_wmarks_check; - ctx->callback.after_aggregation =3D damon_lru_sort_after_aggregation; + call_control.data =3D ctx; =20 /* 'enabled' has set before this function, probably via command line */ if (enabled) --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B4B6B2BE03F; Sun, 6 Jul 2025 20:00:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832031; cv=none; b=SUGpYWrvluh81GjISxZZvPSj4nt3j0r7ts9KWXCbw8LpN9UBjflY49jBRzAxamyVVaMg2YYe9TXUHksZtPn8pYhM6KTCsBwKjdA7DBtqX4M9wEtdyjA+JJJindU3yoeM7UVLjtNTTzborNbzd/U/t6asPnMnbP3sICPD3PFf6gA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832031; c=relaxed/simple; bh=4rlUnM41KWHBb9R2GQY7K2cpSu4qxxjH6BI9hmtiRvY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=E+3bl7rT8YE13FNnDsOmPlflhrM5ev/C5xc6uCPWAU7GKQILEsn6wCAaJHGCoij0Pseqp7h+dRXPNJcIo32Ha21ihPcyLfDHLnoSkS3ihL1XLC6QgaG9rOL4IAPzM2dBpfBfcXvWNnQcL6l7VLDbuGs1boXPbp7f7Qu4C0X2jZw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Hu3ELqqO; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Hu3ELqqO" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3E16CC4CEF4; Sun, 6 Jul 2025 20:00:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832031; bh=4rlUnM41KWHBb9R2GQY7K2cpSu4qxxjH6BI9hmtiRvY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Hu3ELqqOgQHEt+keoQhLPdyX8rut4DuHulVn/8mGyUWEU/HoEV6x7HOW6LB+FYDxV 5mBnMfXjCCSZvmMuV46mqNk836kS5ydl+Gm9Q/V6JwwrqTVZxa22zKsnQaoGo/Wi/W H1uGWeVHQL9LQUONWb8bQoLI3KwTW/qfwaV2RMQ45ZdeTQ2v+CmihTF1JJsAMlyBXx mWz0h35MWeAD7m6knzzPSJWx6J0VvPwy8TR7lH0JBgPwawURzjjeNkl9efYwGnM4aU +aX8gaCSCNOP2RQgVjjXYj53/6Z1U+euVEuQstT3bMIOy1d/fCpkBqMhTw3dNHsC3X lQbxy0NE8l+Qw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 06/14] samples/damon/prcl: use damon_call() repeat mode instead of damon_callback Date: Sun, 6 Jul 2025 13:00:10 -0700 Message-Id: <20250706200018.42704-7-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" prcl uses damon_callback for periodically reading DAMON internal data. Use its alternative, damon_call() repeat mode. Signed-off-by: SeongJae Park --- samples/damon/prcl.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/samples/damon/prcl.c b/samples/damon/prcl.c index d70f47924720..d3215699a5f4 100644 --- a/samples/damon/prcl.c +++ b/samples/damon/prcl.c @@ -34,8 +34,9 @@ MODULE_PARM_DESC(enable, "Enable of disable DAMON_SAMPLE_= WSSE"); static struct damon_ctx *ctx; static struct pid *target_pidp; =20 -static int damon_sample_prcl_after_aggregate(struct damon_ctx *c) +static int damon_sample_prcl_repeat_call_fn(void *data) { + struct damon_ctx *c =3D data; struct damon_target *t; =20 damon_for_each_target(t, c) { @@ -51,10 +52,16 @@ static int damon_sample_prcl_after_aggregate(struct dam= on_ctx *c) return 0; } =20 +static struct damon_call_control repeat_call_control =3D { + .fn =3D damon_sample_prcl_repeat_call_fn, + .repeat =3D true, +}; + static int damon_sample_prcl_start(void) { struct damon_target *target; struct damos *scheme; + int err; =20 pr_info("start\n"); =20 @@ -79,8 +86,6 @@ static int damon_sample_prcl_start(void) } target->pid =3D target_pidp; =20 - ctx->callback.after_aggregation =3D damon_sample_prcl_after_aggregate; - scheme =3D damon_new_scheme( &(struct damos_access_pattern) { .min_sz_region =3D PAGE_SIZE, @@ -100,7 +105,12 @@ static int damon_sample_prcl_start(void) } damon_set_schemes(ctx, &scheme, 1); =20 - return damon_start(&ctx, 1, true); + err =3D damon_start(&ctx, 1, true); + if (err) + return err; + + repeat_call_control.data =3D ctx; + return damon_call(ctx, &repeat_call_control); } =20 static void damon_sample_prcl_stop(void) --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9D2202BE056; Sun, 6 Jul 2025 20:00:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832032; cv=none; b=pO2otmobVfO8mdl29Sga55cx+t8S5EEtXSxCGJmdIApOFdo71N99szsrHgBKiTAocQnwH/xIh3c9AXKbVPU+Hsc1PEQgaK9BGANWC4g6fa+HsfkY0A+Rgw5HBkXpMJqYeHkNhwjUJxrv6Sb0+rL6qj4yed1lUnv7JMd0L3CZGH4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832032; c=relaxed/simple; bh=qgCCHgMjBSqd296NRY6BPJU6GpcbgCIFTrT62DjsH+o=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=MxYG50+8UU65p2C/bel/G+Nc4Lj8rpqd5DBRmpWbUbkHumSF0PDJDSbwa1z5VJUl9rEfGfHaWL0sltVsZDbUtahoZPUnorNzC1nrLv6bzHLuE7Qesqwb+aCL/TGPIcfdtuDsWLxDbkDISwYqpbMsTPqyio/cN8SSdsMlP7+lGik= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=H8WmWqp5; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="H8WmWqp5" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5A50DC4CEF2; Sun, 6 Jul 2025 20:00:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832032; bh=qgCCHgMjBSqd296NRY6BPJU6GpcbgCIFTrT62DjsH+o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=H8WmWqp5pOIN39aMPaQGFH+p5aZKw8AS/c6J3FPzO732FLWrX8np8QOplYlf99KmU iEHgPMCPLCFVQU5dkRKVNXmX5pVqGuQDgJQWE+9HNSfjA5K/5crGndLV4wspg2YJoU tVWAg5+0sCauY+ilkIvLzlVtDeKQLQLB0n48QpCVmJ8HqHGo/HNIZrPzDiwmm1EbWa LUYDAECjiJEoz5wW0N+N3DIx+Qcy4hSiLLjHjKgSUxvbdCmbMVdi4j75KITa2tIobL fJt1nuTboznH6bRjz9UYPMG4qyG84DSi/uZXkeKX9Hdv6WnTywHmOFsnYySygOJF+U ceUktNuq9G4rA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 07/14] samples/damon/wsse: use damon_call() repeat mode instead of damon_callback Date: Sun, 6 Jul 2025 13:00:11 -0700 Message-Id: <20250706200018.42704-8-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" wsse uses damon_callback for periodically reading DAMON internal data. Use its alternative, damon_call() repeat mode. Signed-off-by: SeongJae Park --- samples/damon/wsse.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/samples/damon/wsse.c b/samples/damon/wsse.c index 6037e5f8adf2..fb24190d2fc0 100644 --- a/samples/damon/wsse.c +++ b/samples/damon/wsse.c @@ -35,8 +35,9 @@ MODULE_PARM_DESC(enable, "Enable or disable DAMON_SAMPLE_= WSSE"); static struct damon_ctx *ctx; static struct pid *target_pidp; =20 -static int damon_sample_wsse_after_aggregate(struct damon_ctx *c) +static int damon_sample_wsse_repeat_call_fn(void *data) { + struct damon_ctx *c =3D data; struct damon_target *t; =20 damon_for_each_target(t, c) { @@ -52,9 +53,15 @@ static int damon_sample_wsse_after_aggregate(struct damo= n_ctx *c) return 0; } =20 +static struct damon_call_control repeat_call_control =3D { + .fn =3D damon_sample_wsse_repeat_call_fn, + .repeat =3D true, +}; + static int damon_sample_wsse_start(void) { struct damon_target *target; + int err; =20 pr_info("start\n"); =20 @@ -79,8 +86,11 @@ static int damon_sample_wsse_start(void) } target->pid =3D target_pidp; =20 - ctx->callback.after_aggregation =3D damon_sample_wsse_after_aggregate; - return damon_start(&ctx, 1, true); + err =3D damon_start(&ctx, 1, true); + if (err) + return err; + repeat_call_control.data =3D ctx; + return damon_call(ctx, &repeat_call_control); } =20 static void damon_sample_wsse_stop(void) --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AB92D2BE7AC; Sun, 6 Jul 2025 20:00:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832033; cv=none; b=jD12lFw0rXSDuAv0PpBzaPBCaEdXtF7LV4XiNG89V1ebYdglGJGbCo83eM751QyW6qC9Qvl5xySuX8SfE9DMbC3c6eWwSbmyYyaTK+F0N5D0giNeql+CLgGTQygfVoGimdYFk12Fa1iJ5WUktJ5VEyHVAkkYLZyXrg/7TT6D/Rw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832033; c=relaxed/simple; bh=kPaBWHAVnTpt3IhJpZpvKlwnOD5/goIRLdoHL+X/dnc=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Is9OU4ztptk5cJEd3qGTJ5NQs+mPAb2R2fKeravN65bjbuswNUNNqGXA6OdH45rRuXwxMkJZV+LT5N/gGbNZlP3ekqsBT0sSXnPa6TBz11ENIMwoc7NgqI2CWumVOmKiRgaRVTiKtrH0u4PIUrKvRx2RiMRbEqVJ1sLd/qn2TaA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hTQV/EBd; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="hTQV/EBd" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6602BC4CEF4; Sun, 6 Jul 2025 20:00:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832033; bh=kPaBWHAVnTpt3IhJpZpvKlwnOD5/goIRLdoHL+X/dnc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hTQV/EBdZ+FEb4l50CWDcbREHDhLh/y+oEWykVciIUzsu1JlCNLnsCdRI42AKrSaB 5AoQVzIj+ynaCVhdzqLkYtX+rllRieKnOtspV5kiuv3b0xyic544cjrjDDnSlh9ccu yBDGKU6s8nvy4J84g1sMnFKa8hyA9cuLp7zDdceDIlcZJiRGRNlJFyIgEyNa28Te8D aVEWLmBL9VTGimWrb4n3OSPxsTLf1nwdz86LKFZKttgKQlwGGzvOLcALKQpt/WT1Ez iV+5zPllFVf3HIuMpm+9Sqb4RMTrZ1RhAvi31afjOnq9zDudzblqruWEMALbd/dy58 vHmTGvQ/ZMP2g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 08/14] mm/damon/core: do not call ops.cleanup() when destroying targets Date: Sun, 6 Jul 2025 13:00:12 -0700 Message-Id: <20250706200018.42704-9-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" damon_operations.cleanup() is documented to be called for kdamond termination, but also being called for targets destruction, which is done for any damon_ctx destruction. Nobody is using the callback for now, though. Remove the cleanup() call under the destruction. Signed-off-by: SeongJae Park --- mm/damon/core.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/mm/damon/core.c b/mm/damon/core.c index 7a4dc76dd023..eaa2306ff324 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -550,11 +550,6 @@ static void damon_destroy_targets(struct damon_ctx *ct= x) { struct damon_target *t, *next_t; =20 - if (ctx->ops.cleanup) { - ctx->ops.cleanup(ctx); - return; - } - damon_for_each_target_safe(t, next_t, ctx) damon_destroy_target(t); } --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 30F962BCF7C; Sun, 6 Jul 2025 20:00:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832037; cv=none; b=tu/YV21ajyt8Dvm+d2uN4YFbc+gbXm3s6Xl80Bs4zzysBadyFUAZkWF+y2+GW7AgjEXrPgsA4nljVJzzpZcYHqxla96wZGkCGbfzmfVTy++0QcvCcJKviOJYRWLIdak5b4RmFoE06UKhkfljTIz10QJMfXrMM7TcRRNZ79ZPsNg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832037; c=relaxed/simple; bh=4kAaXCChET6SPUEFVOVLQUp7PQZ6yAFwNr2FE2D6vJA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=aZVcot+Cms1xR3TOdgkcRsuYeZhEURh9Wl4/XHZqOvw3uwF1RrT02au3iPdVdUOlgVdMhZgXFqu9RVj3BMFKh5OW5aC4uvoQjbDGl1S3nSV7eICRF8v3plFOsrIf0VML7B3hJREHWdqs2EEK/e07oAYItfct7pNk5uWxv4FG6s4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=sAqi3+RJ; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="sAqi3+RJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7C1B2C4CEF2; Sun, 6 Jul 2025 20:00:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832034; bh=4kAaXCChET6SPUEFVOVLQUp7PQZ6yAFwNr2FE2D6vJA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=sAqi3+RJgJAWDhlMgSPcliDtIJL40yZvJcgwtX5kaJs0AznUwEru+Z8DgE5ftQ3J7 arBc5jSCbrracd0a1Ug7Y7fCpiutotnskeue42bVVxSR0motuBS4+COHM7rmlYDkYa oy/aKiOrtgM/5YiktRpTfBeh1yk5aDktt5T7ws/aIDZOWaEoJv88MQ/7bR9wWlkpsE gevViW2N6C4H2TZLECWN9U4lyxUU3/swTSG0+v3QovQkVtvrpNH0kC6k5Xo0UOkarW GCMoY6Yc5vv0tIrjKOBQvs1xIrYBmdPxs826ekV4NQzfclkbcI11BzoHudP3WauSsn plpXkvAC7Ze7Q== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 09/14] mm/damon/core: add cleanup_target() ops callback Date: Sun, 6 Jul 2025 13:00:13 -0700 Message-Id: <20250706200018.42704-10-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Some DAMON operation sets may need additional cleanup per target. For example, [f]vaddr need to put pids of each target. Each user and core logic is doing that redundantly. Add another DAMON ops callback that will be used for doing such cleanups in operations set layer. Signed-off-by: SeongJae Park --- include/linux/damon.h | 4 +++- mm/damon/core.c | 12 ++++++++---- mm/damon/sysfs.c | 4 ++-- mm/damon/tests/core-kunit.h | 4 ++-- mm/damon/tests/vaddr-kunit.h | 2 +- 5 files changed, 16 insertions(+), 10 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 2d51b575d660..52b307db63de 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -608,6 +608,7 @@ enum damon_ops_id { * filters (&struct damos_filter) that handled by itself. * @target_valid should check whether the target is still valid for the * monitoring. + * @cleanup_target is called before the target will be deallocated. * @cleanup is called from @kdamond just before its termination. */ struct damon_operations { @@ -623,6 +624,7 @@ struct damon_operations { struct damon_target *t, struct damon_region *r, struct damos *scheme, unsigned long *sz_filter_passed); bool (*target_valid)(struct damon_target *t); + void (*cleanup_target)(struct damon_target *t); void (*cleanup)(struct damon_ctx *context); }; =20 @@ -933,7 +935,7 @@ struct damon_target *damon_new_target(void); void damon_add_target(struct damon_ctx *ctx, struct damon_target *t); bool damon_targets_empty(struct damon_ctx *ctx); void damon_free_target(struct damon_target *t); -void damon_destroy_target(struct damon_target *t); +void damon_destroy_target(struct damon_target *t, struct damon_ctx *ctx); unsigned int damon_nr_regions(struct damon_target *t); =20 struct damon_ctx *damon_new_ctx(void); diff --git a/mm/damon/core.c b/mm/damon/core.c index eaa2306ff324..ce1087b5436f 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -502,8 +502,12 @@ void damon_free_target(struct damon_target *t) kfree(t); } =20 -void damon_destroy_target(struct damon_target *t) +void damon_destroy_target(struct damon_target *t, struct damon_ctx *ctx) { + + if (ctx && ctx->ops.cleanup_target) + ctx->ops.cleanup_target(t); + damon_del_target(t); damon_free_target(t); } @@ -551,7 +555,7 @@ static void damon_destroy_targets(struct damon_ctx *ctx) struct damon_target *t, *next_t; =20 damon_for_each_target_safe(t, next_t, ctx) - damon_destroy_target(t); + damon_destroy_target(t, ctx); } =20 void damon_destroy_ctx(struct damon_ctx *ctx) @@ -1097,7 +1101,7 @@ static int damon_commit_targets( =20 if (damon_target_has_pid(dst)) put_pid(dst_target->pid); - damon_destroy_target(dst_target); + damon_destroy_target(dst_target, dst); damon_for_each_scheme(s, dst) { if (s->quota.charge_target_from =3D=3D dst_target) { s->quota.charge_target_from =3D NULL; @@ -1116,7 +1120,7 @@ static int damon_commit_targets( err =3D damon_commit_target(new_target, false, src_target, damon_target_has_pid(src)); if (err) { - damon_destroy_target(new_target); + damon_destroy_target(new_target, NULL); return err; } damon_add_target(dst, new_target); diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index c0193de6fb9a..f2f9f756f5a2 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1303,7 +1303,7 @@ static void damon_sysfs_destroy_targets(struct damon_= ctx *ctx) damon_for_each_target_safe(t, next, ctx) { if (has_pid) put_pid(t->pid); - damon_destroy_target(t); + damon_destroy_target(t, ctx); } } =20 @@ -1389,7 +1389,7 @@ static void damon_sysfs_before_terminate(struct damon= _ctx *ctx) =20 damon_for_each_target_safe(t, next, ctx) { put_pid(t->pid); - damon_destroy_target(t); + damon_destroy_target(t, ctx); } } =20 diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h index 298c67557fae..dfedfff19940 100644 --- a/mm/damon/tests/core-kunit.h +++ b/mm/damon/tests/core-kunit.h @@ -58,7 +58,7 @@ static void damon_test_target(struct kunit *test) damon_add_target(c, t); KUNIT_EXPECT_EQ(test, 1u, nr_damon_targets(c)); =20 - damon_destroy_target(t); + damon_destroy_target(t, c); KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c)); =20 damon_destroy_ctx(c); @@ -310,7 +310,7 @@ static void damon_test_set_regions(struct kunit *test) KUNIT_EXPECT_EQ(test, r->ar.start, expects[expect_idx++]); KUNIT_EXPECT_EQ(test, r->ar.end, expects[expect_idx++]); } - damon_destroy_target(t); + damon_destroy_target(t, NULL); } =20 static void damon_test_nr_accesses_to_accesses_bp(struct kunit *test) diff --git a/mm/damon/tests/vaddr-kunit.h b/mm/damon/tests/vaddr-kunit.h index 7cd944266a92..d2b37ccf2cc0 100644 --- a/mm/damon/tests/vaddr-kunit.h +++ b/mm/damon/tests/vaddr-kunit.h @@ -149,7 +149,7 @@ static void damon_do_test_apply_three_regions(struct ku= nit *test, KUNIT_EXPECT_EQ(test, r->ar.end, expected[i * 2 + 1]); } =20 - damon_destroy_target(t); + damon_destroy_target(t, NULL); } =20 /* --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 30F292BCF75; Sun, 6 Jul 2025 20:00:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832037; cv=none; b=T560T4Qoq4jm2O8R6dgdOoCl+cZ4qx5ojj3vW8NSHGI6d7U0d0Kw5qXhwudBPkj7DO9+Ohj5msTYp5oSDFuuBdNZyvJmu7Qwk2FVn3/8e3QpcRZ4OAYC3oey5FAlKeSzU5jsH7talhQReQXevaZvE9BrQ9s9qyMb9hLJr9A0N/I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832037; c=relaxed/simple; bh=arW9HamBDNLK1yN3sYPk8GcM8z+8LRLU5gO/RN527TA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=TgxvML/MLM95AYSEEppI+Ke+3jdOhTaa+iaBqeu0L9TCagqG+WfvVB0+C03V26yrzA7o35UTmjoxPe4XlTe2GpOLSdavqhrj8f7q7Db4smxo95XboIq72vZ6ls4L63r4Wotk/H5EnkiRBtQegMep32FhZgybP3SedL0Ftufr1WU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ToRJq6fY; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ToRJq6fY" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8EC5CC4CEF1; Sun, 6 Jul 2025 20:00:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832035; bh=arW9HamBDNLK1yN3sYPk8GcM8z+8LRLU5gO/RN527TA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ToRJq6fY2uHmmSXBV+y5yfAj4+RYgewQgtMYQI9cnh/YJJ35fO8AbtImb2cAiFPbq Y/8O+/vMt3ALjdNk7L3JbN2Qy4NPFrWv2JivT+LctVl+s9nf8LPH1BagIRI8OWz8fK p52tHZYlc4kzP+0S85hV1JtmzuS+PNciFusmjtPyjdCa95I4bVobY2qP0NOD+Mngp+ 01+SEHAufJrEGkFYSGJkQjRTuZr15O+myKC0FcE8ZQxgRX4N1KvAbi5Cdgf92dNTqx P1eD40XDQAWzN8JUv0G2a+GNbUxZLeOCZZDCqXq7rV5bGapONn6ke2Uq0c8Zbr5vkA Q3z+TavRLsyEQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 10/14] mm/damon/vaddr: put pid in cleanup_target() Date: Sun, 6 Jul 2025 13:00:14 -0700 Message-Id: <20250706200018.42704-11-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Implement cleanup_target() callback for [f]vaddr, which calls put_pid() for each target that will be destroyed. Also remove redundant put_pid() calls in core and sysfs, which was required to be done redundantly due to the lack of such self cleanup in vaddr. Signed-off-by: SeongJae Park --- mm/damon/core.c | 2 -- mm/damon/sysfs.c | 10 ++-------- mm/damon/vaddr.c | 6 ++++++ 3 files changed, 8 insertions(+), 10 deletions(-) diff --git a/mm/damon/core.c b/mm/damon/core.c index ce1087b5436f..6d526c5263d3 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1099,8 +1099,6 @@ static int damon_commit_targets( } else { struct damos *s; =20 - if (damon_target_has_pid(dst)) - put_pid(dst_target->pid); damon_destroy_target(dst_target, dst); damon_for_each_scheme(s, dst) { if (s->quota.charge_target_from =3D=3D dst_target) { diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index f2f9f756f5a2..5eba6ac53939 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1298,13 +1298,9 @@ static int damon_sysfs_set_attrs(struct damon_ctx *c= tx, static void damon_sysfs_destroy_targets(struct damon_ctx *ctx) { struct damon_target *t, *next; - bool has_pid =3D damon_target_has_pid(ctx); =20 - damon_for_each_target_safe(t, next, ctx) { - if (has_pid) - put_pid(t->pid); + damon_for_each_target_safe(t, next, ctx) damon_destroy_target(t, ctx); - } } =20 static int damon_sysfs_set_regions(struct damon_target *t, @@ -1387,10 +1383,8 @@ static void damon_sysfs_before_terminate(struct damo= n_ctx *ctx) if (!damon_target_has_pid(ctx)) return; =20 - damon_for_each_target_safe(t, next, ctx) { - put_pid(t->pid); + damon_for_each_target_safe(t, next, ctx) damon_destroy_target(t, ctx); - } } =20 /* diff --git a/mm/damon/vaddr.c b/mm/damon/vaddr.c index 46554e49a478..5c992317ee4c 100644 --- a/mm/damon/vaddr.c +++ b/mm/damon/vaddr.c @@ -627,6 +627,11 @@ static bool damon_va_target_valid(struct damon_target = *t) return false; } =20 +static void damon_va_cleanup_target(struct damon_target *t) +{ + put_pid(t->pid); +} + #ifndef CONFIG_ADVISE_SYSCALLS static unsigned long damos_madvise(struct damon_target *target, struct damon_region *r, int behavior) @@ -711,6 +716,7 @@ static int __init damon_va_initcall(void) .prepare_access_checks =3D damon_va_prepare_access_checks, .check_accesses =3D damon_va_check_accesses, .target_valid =3D damon_va_target_valid, + .cleanup_target =3D damon_va_cleanup_target, .cleanup =3D NULL, .apply_scheme =3D damon_va_apply_scheme, .get_scheme_score =3D damon_va_scheme_score, --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3101D2BE7AC; Sun, 6 Jul 2025 20:00:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832037; cv=none; b=OB1swLS/yiIHOeo+/tSo48Aeo8bHF7Rr5MSk9CDat7p5Vwy+Jjz4YWb36n5DnPDzmeZEfh+XW49ftY6RzjazMpBRCALxEoHY37N8CToqgqqxlG9mT82ryw9oHoJVUl1oAdTUtSSAbzsS4ELlA1FNftCiLQyZKT00CiaL5AyBR2o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832037; c=relaxed/simple; bh=dnbBIoiWMyEPhOBD2O+z/mHI1a/WsMzxyryGAQlSQsA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=U6cGhK/sElkxCaM5T1ntLMEZuEDlM4MpCvk6sRMzEOxU4eiZ60hxfDyEBpfHFE/BAnvwEs9tC8sCLpDODGJGX2zcu0U7qJiHj+LV6ah+m9YbpCf4e3m3v5So8Hiv2SuThOdZlkUo/d+svLEY0GUVly0TovELVYH4EABknQ8A5gU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Fck4arrF; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Fck4arrF" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9D54FC4CEF3; Sun, 6 Jul 2025 20:00:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832036; bh=dnbBIoiWMyEPhOBD2O+z/mHI1a/WsMzxyryGAQlSQsA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Fck4arrF4zOiEsMM2KixvP9bY4CrTLZdZmsGgyAw4WFOQ3EuBfiM5q7+fYkRi9jrc 2iSARDSXSgWCcG+Aok1uQ8KZJrFt+y8QVZADce3/aW4+tAw+djptIGH+zqNMhGL02i PtfhySHItgjb30S+G2+AKDAuGxUf6WgGoHzWfKhNRzAzWJFxizsOM+dFQFO2ChtILw Ec/Elo4Vt15QtAqaqI34j8F+LTXxpQCSkTx79mgOL9l8JhoL18bsO0JMiOqxHn3bT7 3emhbaSmmTKkY0GOeANGAU0cnsaX2d0Zf64Icv22zpPs3H90buLXg4F/3b6QOr4Iks BBbhFyVj+JDPg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 11/14] mm/damon/sysfs: remove damon_sysfs_destroy_targets() Date: Sun, 6 Jul 2025 13:00:15 -0700 Message-Id: <20250706200018.42704-12-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The function was introduced for putting pids and deallocating unnecessary targets. Hence it is called before damon_destroy_ctx(). Now vaddr puts pid for each target destruction (cleanup_target()). damon_destroy_ctx() deallocates the targets anyway. So damon_sysfs_destroy_targets() has no reason to exist. Remove it. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 23 +++-------------------- 1 file changed, 3 insertions(+), 20 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 5eba6ac53939..b0f7c60d655a 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1295,14 +1295,6 @@ static int damon_sysfs_set_attrs(struct damon_ctx *c= tx, return damon_set_attrs(ctx, &attrs); } =20 -static void damon_sysfs_destroy_targets(struct damon_ctx *ctx) -{ - struct damon_target *t, *next; - - damon_for_each_target_safe(t, next, ctx) - damon_destroy_target(t, ctx); -} - static int damon_sysfs_set_regions(struct damon_target *t, struct damon_sysfs_regions *sysfs_regions) { @@ -1337,7 +1329,6 @@ static int damon_sysfs_add_target(struct damon_sysfs_= target *sys_target, struct damon_ctx *ctx) { struct damon_target *t =3D damon_new_target(); - int err =3D -EINVAL; =20 if (!t) return -ENOMEM; @@ -1345,16 +1336,10 @@ static int damon_sysfs_add_target(struct damon_sysf= s_target *sys_target, if (damon_target_has_pid(ctx)) { t->pid =3D find_get_pid(sys_target->pid); if (!t->pid) - goto destroy_targets_out; + /* caller will destroy targets */ + return -EINVAL; } - err =3D damon_sysfs_set_regions(t, sys_target->regions); - if (err) - goto destroy_targets_out; - return 0; - -destroy_targets_out: - damon_sysfs_destroy_targets(ctx); - return err; + return damon_sysfs_set_regions(t, sys_target->regions); } =20 static int damon_sysfs_add_targets(struct damon_ctx *ctx, @@ -1458,13 +1443,11 @@ static int damon_sysfs_commit_input(void *data) test_ctx =3D damon_new_ctx(); err =3D damon_commit_ctx(test_ctx, param_ctx); if (err) { - damon_sysfs_destroy_targets(test_ctx); damon_destroy_ctx(test_ctx); goto out; } err =3D damon_commit_ctx(kdamond->damon_ctx, param_ctx); out: - damon_sysfs_destroy_targets(param_ctx); damon_destroy_ctx(param_ctx); return err; } --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E8FDD2BEFFD; Sun, 6 Jul 2025 20:00:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832038; cv=none; b=J9uvbUBS6+nItXFcbTJNgMGZCtNFc9Gp6mTaGEppF7WwfyK/ZrWVPCkdh1u/do/pjVVF6qFgTl9RaOqteKlKgUAqwdjdaV44DEHmAwsIgHb0CnV3lOpoVdrojSiV1+Y0Xr3WMe2YlVOLHkXibhPIoWaJp1ZSqoE1yl/yLjXULF4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832038; c=relaxed/simple; bh=kLOfiDb8Ht5Pc8uz232F1LSFeR+9kLoSLkkKWHCAI6o=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=CBArUQ3+fZX9E1PsRfyzIWrKML6HWpqITzFg6VvhD4LAxSpIElwqI6M2w4LXAtr2j/i3Ga2XQT9B2F0Er/J6dJ5JQ7wwt6cigAupwgAzsJ3v6iXp/1NGHcXAemSrEgnBCTj3ngOpHj4nxywJH/v60nWB/q6vUMVCDgp5R2u050M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ZRaIKFXz; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ZRaIKFXz" Received: by smtp.kernel.org (Postfix) with ESMTPSA id AC664C4CEF2; Sun, 6 Jul 2025 20:00:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832037; bh=kLOfiDb8Ht5Pc8uz232F1LSFeR+9kLoSLkkKWHCAI6o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ZRaIKFXzcU07eh1mdY2khZ0+YNhmNoYObMGqNWDba45n2BlbuEkeqD1PVAk4iK1WL jb2tkMYAZtZU25BgswhJ9W12rvJzuUrP4jBMfAaHFpmCulGeRS9QEquMuZK9ZPH1Bp NXLp7dVzMRyzpo3TX1nle9+UXSF+f4NrgJ8ujAf66PYOulrvzc8/aDdtPie5Fkmd1i +2LcHYO913Ruui3vWSlRy8KluXD2pA5KtDmA8aLQoAeWd5+OkUNXsEOM5FRbJJcuSe Ksel7wrXbzlVhK4HRdosao13Bm8SGEIzmwyGax3WEU/4ktM5Z5kpz9UsNFdAbT6tRx K85LQXeO7STcw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 12/14] mm/damon/core: destroy targets when kdamond_fn() finish Date: Sun, 6 Jul 2025 13:00:16 -0700 Message-Id: <20250706200018.42704-13-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" When kdamond_fn() completes, the targets are kept. Those are kept to let callers do additional cleanups if they need. There are no such additional cleanups though. DAMON sysfs interface deallocates those in before_terminate() callback, to reduce unnecessary memory usage, for [f]vaddr use case. Just destroy the targets for every case in the core layer. This saves more memory and simplifies the logic. Signed-off-by: SeongJae Park --- mm/damon/core.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index 6d526c5263d3..719373bcfaad 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -2617,6 +2617,7 @@ static int kdamond_fn(void *data) running_exclusive_ctxs =3D false; mutex_unlock(&damon_lock); =20 + damon_destroy_targets(ctx); return 0; } =20 --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 67DAC2C0313; Sun, 6 Jul 2025 20:00:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832039; cv=none; b=cerdTo9fg7rxh5JKnTeCviXUUsgJ+W3E5AC6yOpuOdlY9YR7O1lgkcDJfQNZxMZWa+T/p6QsDgnhrfwgqWFBPI8Gw58apvJ/tUBO2ZTnkTbl+kDojESq8EHl+tHS68RT7Z9B2ELttDFDXDZxKRrlW8q/Q823345CH2BhUPMF/ls= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832039; c=relaxed/simple; bh=WTjz/K1GFNo9usAZWWENvLqqlSxu80QiYvWGup6Il+g=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=kWXmURVnAmmdSwMMWESiMECaAc/s/2JbjTZ1z5hNSyjnlhV4QUms6JFpDDNHIXoVGTWvDKmkIGKIBbpkF0P76zZ/XsiVAnNJA6ArV9TwRdi5gdtmyzGe/Bo18/PM7M/OCwy33oTOp3dB6hXvzd4+cBCcbtvkhrugm77FoEMHG9Q= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=dQaNYsc6; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="dQaNYsc6" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B7282C4CEED; Sun, 6 Jul 2025 20:00:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832038; bh=WTjz/K1GFNo9usAZWWENvLqqlSxu80QiYvWGup6Il+g=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=dQaNYsc6fn3ngQRZ2jaLffrLZywSHmBXYS3OohecqNN3vWUf8ZKMZpqQ8coi89zmQ /GpY5J0YP8pIrQKow8qetlZdLd0tNhWKQr6bnFR3NqVQa+tfD7GZDGRpiAVTT6HNyd 8LSjoIGlIZl1Ktih9elHJEtYs2TaK7Si5AjVBMDfOZDXQPeuln8EczlBS3FFOQl+y3 ykPOJReVPPjm62z+0RVmN9xEdVmZgwh8SZ6lHVgV24J+EujHKnYeki+WyHewumYmVu H9W53690nPfXue1vVtr/0iiC0UHsBIuCd/lZVY/f5TdzRT9Inl1twtQWZ/NTCxgQv/ E0Laeu9dPzZBw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 13/14] mm/damon/sysfs: remove damon_sysfs_before_terminate() Date: Sun, 6 Jul 2025 13:00:17 -0700 Message-Id: <20250706200018.42704-14-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DAMON core layer does target cleanup on its own. Remove duplicated and unnecessarily selective cleanup attempts in DAMON sysfs interface. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index b0f7c60d655a..cce2c8a296e2 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1361,17 +1361,6 @@ static int damon_sysfs_add_targets(struct damon_ctx = *ctx, return 0; } =20 -static void damon_sysfs_before_terminate(struct damon_ctx *ctx) -{ - struct damon_target *t, *next; - - if (!damon_target_has_pid(ctx)) - return; - - damon_for_each_target_safe(t, next, ctx) - damon_destroy_target(t, ctx); -} - /* * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. * @data: The kobject wrapper that associated to the kdamond thread. @@ -1516,7 +1505,6 @@ static struct damon_ctx *damon_sysfs_build_ctx( return ERR_PTR(err); } =20 - ctx->callback.before_terminate =3D damon_sysfs_before_terminate; return ctx; } =20 --=20 2.39.5 From nobody Tue Oct 7 21:00:21 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7D45C2C08C5; Sun, 6 Jul 2025 20:00:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832040; cv=none; b=huJkqEryuTjHIwxs5UHbElHVWoH594NIslkNBZSHMI8tpZ8dQq9rOzKGrcUaY5/aO2BDUvPmaabZnw1msKCaGM3m25zQHQOCD3N5Iy6U8xH+7zuPzKqCBhMH3NAhyQPXEuk62LCOQtN1T7yB0rQiDiMqdQSGgsWLijB2DP7DAyQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1751832040; c=relaxed/simple; bh=UY8idiDxx1z6VY897USN60G0+UWHNTZfcQ9JenDI6ok=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=koX5fa+Kma7pfBtz5yGEKdq6MCG01rFMSZ2V9CUY81OGIW5lofpyCTBCe6M4wnkczWWlQkSCWo/w6iDxWxns2scoaTTbNi6KxxumGqOfnVxwueb1m3DV76mDKBcq7Eqp7zsQCjCQaTcLqcVlatKVP0mZ4MsPbfAM0f4Ubk13z9E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=HUKnQNA1; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="HUKnQNA1" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D4271C4CEED; Sun, 6 Jul 2025 20:00:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1751832040; bh=UY8idiDxx1z6VY897USN60G0+UWHNTZfcQ9JenDI6ok=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HUKnQNA15EstRNmSOh/lfXnqionSWBjs/fTP4t7hUoev5c8hq4F8mFMi7xh5Ieopx RQCOssCOkluQz/JD3vSkmQRnjIzettO5FOhFk7ojmODcJ243GO6R7kf0B1l6IgUGjs FkVVJnhAPAt9n5LhRjaeiMDFQ20wHC8odD4p/pAAT+8qKCKqB7n9GAoEQoNhuVpYYz g/rFh/3XJ8ftoGa4gB/nmmyD1Bp1uST+0vOWYzsLl6txc2eXxsx92z+5FKf6b1cdsv kIoFJD6l7LyFzWuLy3j+8PjVOA1d6HpLDi8TJO6JFXz/uo/QNS3zThRu7SzCZxmk8I hI1L8tqJj9vHw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH 14/14] mm/damon/core: remove damon_callback Date: Sun, 6 Jul 2025 13:00:18 -0700 Message-Id: <20250706200018.42704-15-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250706200018.42704-1-sj@kernel.org> References: <20250706200018.42704-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" All damon_callback usages are replicated by damon_call() and damos_walk(). Remove damon_callback. Signed-off-by: SeongJae Park --- include/linux/damon.h | 31 +------------------------------ mm/damon/core.c | 26 +++++++------------------- 2 files changed, 8 insertions(+), 49 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 52b307db63de..5e5cabbf8190 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -628,34 +628,6 @@ struct damon_operations { void (*cleanup)(struct damon_ctx *context); }; =20 -/** - * 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 aggregat= ion - * intervals. Therefore, users can safely access the monitoring results - * without additional protection. For the reason, users are recommended t= o 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(). * @@ -726,7 +698,7 @@ struct damon_intervals_goal { * ``mmap()`` calls from the application, in case of virtual memory monito= ring) * and applies the changes for each @ops_update_interval. All time interv= als * are in micro-seconds. Please refer to &struct damon_operations and &st= ruct - * 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; =20 struct damon_operations ops; - struct damon_callback callback; =20 struct list_head adaptive_targets; struct list_head schemes; diff --git a/mm/damon/core.c b/mm/damon/core.c index 719373bcfaad..ebf483fc0b76 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -680,9 +680,7 @@ static bool damon_valid_intervals_goal(struct damon_att= rs *attrs) * @attrs: monitoring attributes * * This function should be called while the kdamond is not running, an acc= ess - * 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) { @@ -1137,7 +1135,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) { @@ -2444,9 +2442,6 @@ static int kdamond_wait_activation(struct damon_ctx *= ctx) =20 kdamond_usleep(min_wait_time); =20 - if (ctx->callback.after_wmarks_check && - ctx->callback.after_wmarks_check(ctx)) - break; kdamond_call(ctx, false); damos_walk_cancel(ctx); } @@ -2503,10 +2498,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 =3D ctx->next_aggregation_sis; unsigned long next_ops_update_sis =3D ctx->next_ops_update_sis; @@ -2524,14 +2518,10 @@ static int kdamond_fn(void *data) if (ctx->ops.check_accesses) max_nr_accesses =3D ctx->ops.check_accesses(ctx); =20 - if (ctx->passed_sample_intervals >=3D next_aggregation_sis) { + if (ctx->passed_sample_intervals >=3D next_aggregation_sis) kdamond_merge_regions(ctx, max_nr_accesses / 10, sz_limit); - if (ctx->callback.after_aggregation && - ctx->callback.after_aggregation(ctx)) - break; - } =20 /* * do kdamond_call() and kdamond_apply_schemes() after @@ -2597,8 +2587,6 @@ static int kdamond_fn(void *data) damon_destroy_region(r, t); } =20 - if (ctx->callback.before_terminate) - ctx->callback.before_terminate(ctx); if (ctx->ops.cleanup) ctx->ops.cleanup(ctx); kfree(ctx->regions_score_histogram); --=20 2.39.5