From nobody Tue Oct 7 07:00:18 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 D56A028D8F2; Sat, 12 Jul 2025 19:50:21 +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=1752349822; cv=none; b=G/6x6uxV1Zjfc7vwMOGeDfoSg9xXGDlEPN42xEWTYOrs+FWaYiIGDx+/iMCgzlmfxcIZ+KaP9zs5xo5CIPbJJZTFT3FMPN5wW/ULIiOc6/BgTvYj5TuH4eZ1LYgh+I335+in6SoWW3CKFGMSYf4647gTFVxzV0yhFj0dHDJrmEw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349822; c=relaxed/simple; bh=JQzHUCo6E86SNxkHiwVE3u7TqJ48m1u5XQT+KNsWP+Y=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=BQtF4BNV62rzehQa3uSdNWQHfLvZQpYDWnuLE3wEONu3abNnUvihzt4N2JtHJS03ldahlKSMBgIW/qphviz1h4U3wbe9bLcRFfoMdsW/xTAwl1XEi32Ko9l12IIYmaCvtX4AUcshjxahXeHp4tcqvD0VSWBHvWxDdT1u6Moej6o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Q0tX2vnZ; 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="Q0tX2vnZ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3772BC4CEEF; Sat, 12 Jul 2025 19:50:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349821; bh=JQzHUCo6E86SNxkHiwVE3u7TqJ48m1u5XQT+KNsWP+Y=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Q0tX2vnZvDL78oHqrWl4XfFPryieDDWOCjoRhH6amuntAiXHntNr8T0qLl8KNKmi/ JTE1i/Lp9CTrR7iv4tibfJF/5dyCcTIRWZ2p0BP/AgJzsQmkHwU4FPA5ZoRkR6ZRwp VPYju7t0X3AakzFacunJto2cws3sivEGWD4KXlaVbkpz8OHdEHnuYb1sJb+ILv7Scm HqLKG9rsF92ztUSnC5Ec/0jm6vwSbHjuEUa5f7o0kf/ApI5ARfc9zhZhxWy1g+c1mJ Lkn9/LGNRGzjyCG1FQ7V7NucTYJG35NVq00e43Ge62zFvc4w69UJ2cgt77krVUYjiA Ud0TMwFlW2aXA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 01/14] mm/damon: accept parallel damon_call() requests Date: Sat, 12 Jul 2025 12:50:03 -0700 Message-Id: <20250712195016.151108-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 1f425d830bb9..562c7876ba88 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 2714a7a023db..b0a0b98f6889 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; @@ -1393,14 +1394,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); @@ -2419,11 +2417,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. @@ -2433,21 +2431,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 07:00:18 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 D712928DF50; Sat, 12 Jul 2025 19:50:22 +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=1752349822; cv=none; b=B+iuvLNH7rRFzA4ydVylXD3xdT4GOtefbjEHVnjGzFYHOl52jBCIaDD8qLkVLqkBqZlMMpfq3RQQrQlkC/gLhwMrlcSCWw4rDiR5IjTmqI6PopK6PPx8/rfu5ibjpDhwt+titY2HmBg71s96Y1Y2g5+aWPCctcFPPPeFLgx5rHQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349822; c=relaxed/simple; bh=OtU+NRyCIh0C5uwTmklBNfReGv9IlgGR+JKEfON4Vh4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Z/EJNmmxB5/7tP0b26ZbF3Ku4m7ig3GedLhl/hWN4Kv8t+hUK2v0Ewyv4jWOWZl8xGU9vWObxGuXRbE4R5c35xn6urVnpsjwTTuXMY2awHLwh01diTEXw+D+q3cKizdIuJoh3+P+zbJ20YIZkfmspXu3O3KpoPSPa9hj6AdYUfk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=evOAGIJS; 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="evOAGIJS" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 46295C4CEEF; Sat, 12 Jul 2025 19:50:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349822; bh=OtU+NRyCIh0C5uwTmklBNfReGv9IlgGR+JKEfON4Vh4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=evOAGIJSbKOfOxDLbqgOJsH3hGip86AqldafX8BSdrC5/Knp7Y1ygDTUGjExVRe8G ZAB3SrqhBChhKnYkASVe6TFRB06jtG1JpvNu4nB8FXLl77hFOqV96oKGZno+fSsC5H zCLa7V0y4yWVNT21+/kVlYbhOnAJmxaPfolF/XAwk6LPMyESEoVLsKEHstH72pAh8C hlsakP6Df8On06CAh9p8hZ7W67q0hK+TaBH+7mVLoKH3xdn0j0K/Afm2/9qf3MHw6+ SpeLDPTBxZxdeogCyKebfYwTvxbONKQC0oFx1dzSzDiJE2YJshbERtlu7d9GIXe1HT xDMWYWQU8v31A== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 02/14] mm/damon/core: introduce repeat mode damon_call() Date: Sat, 12 Jul 2025 12:50:04 -0700 Message-Id: <20250712195016.151108-3-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 | 25 ++++++++++++++++++++----- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 562c7876ba88..b83987275ff9 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 b0a0b98f6889..ffb87497dbb5 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1379,8 +1379,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 @@ -1392,7 +1393,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 @@ -1401,6 +1403,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; @@ -2429,6 +2433,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) { @@ -2437,7 +2442,7 @@ static void kdamond_call(struct damon_ctx *ctx, bool = cancel) struct damon_call_control, list); mutex_unlock(&ctx->call_controls_lock); if (!control) - return; + break; if (cancel) { control->canceled =3D true; } else { @@ -2447,8 +2452,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 07:00:18 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 A09A628ECE0; Sat, 12 Jul 2025 19:50:23 +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=1752349823; cv=none; b=jKbPUBsn04BovRELrbJEyalkXI/oFqPcQcsqeNMi2fwPH8LiOavvbBQXx7VkOrDJkwTmPeaLxaEY5lrOWUzC1pCxNekxUp3UtVi4UxER+A0gZEWtpPZG7lMJddVSFaOb4qQVg+0hx/dTCf4TnUjyQPyT3AuQKlYC/i1LkafWGcY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349823; c=relaxed/simple; bh=zg5wCAX53+Zaz9D4ii0pAZ1fdfy4NlBPdESVNdjo6HE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=rNlblZ41uBGPTOtVNImm2s3oNC40sKq+mw2+vjx41fp/Q1rkBeg8FooymWohsgfGrVyYkZD4nsBN3V4+oKRc2bbx+r+PkMRcP3QiC1birVnkksdExKVaeyyKmJHV0OjgUuGyYbFdSu0YRlfbZS15z93lk3WK2BNDN+LfKfMBNT8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=dZhCx5mB; 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="dZhCx5mB" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5A2D4C4CEF5; Sat, 12 Jul 2025 19:50:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349823; bh=zg5wCAX53+Zaz9D4ii0pAZ1fdfy4NlBPdESVNdjo6HE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=dZhCx5mBp1+DmVO9gPRsFOjjrVDd0+M7Ain/KZjwWiIFaBhl1BKhE8j6sB2AtTXxR PexvP3cWaiJTTCJjphxyMs9xoWE/ppkV8kFIGVPzXhxA4u3yc+WcORyNFtvCdlDuEo /bN3XYWiqcOscvlPbfVvtAXJPwfeK10ZeSlFaaY7rNxoZaS5q8RXDvR9WUG1+zlCiK ku925kWoJlzXlxbA/lp10XKYE+knsMG1nEjJQZhTqe3wNPWv3MooACCzisIpaN5zIY Cf6PUwW1mQRP4ixjBYA8P+xCd7toRYAU+L0Xly+rcSmwZIE/rw+znYZANQmk2J96e0 Td15cpGo/q+RQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 03/14] mm/damon/stat: use damon_call() repeat mode instead of damon_callback Date: Sat, 12 Jul 2025 12:50:05 -0700 Message-Id: <20250712195016.151108-4-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 07:00:18 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 0B1D3291C1A; Sat, 12 Jul 2025 19:50:25 +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=1752349826; cv=none; b=h3FTTmPaGHcw5ixA+63Rtw/N9L/lAJx6q5VQ21d30kNuYsiB5OhiNyKNdH/e15nH35srNb13IwwSfguEnSHq9s2pG5VtAWi7BPXLfjTVSOL+uY/Sk8rG9iIpjUyW75xlL+Ow5TXRcnDh3EVoUISgbfXkjX0Nen8TkI7VeXX6R6I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349826; c=relaxed/simple; bh=fAIXtGREPARQvCC1/X313DQcYGh4YYVNrncF7IRNX5A=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=cKLn+1VIw7WsCQNCXG11QQMJlLgcwCaSbf4gFFlP9Cgk/Z5KOsgPRiMJ2ilNaGKsGhFQHCkASVaaPoLQ7We+1Zsyc3jX3DU0l5xpNr1Rq5gXXvUhIf4Zg8L+uzCbjktR7ehWtct7H0jy/ml+Ua6PngKLHQlXDoahMzJ19XVlh4A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=SnBXbj9J; 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="SnBXbj9J" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 68F0CC4CEF5; Sat, 12 Jul 2025 19:50:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349825; bh=fAIXtGREPARQvCC1/X313DQcYGh4YYVNrncF7IRNX5A=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=SnBXbj9JLQ/68/CzvkH51wlCIhPyiwg8gTXIEr4W7DaJ8ASkufZ3vJ3yZBm2RI+9E +GyAELXBJre+9ftd1CCJU53fepM+WY1a0WDjQVRPvvVecuRWJvFwc6blCwn1IjyiXN /SSnQpWYVxbVqYJi6iS9cdvvXXgCkOs7LWpn00YpARWLYhlzmW3TH9FC6k9WqqM1KV 95ZFzjgtQBENj88W2DdFytayi5LoJb38TaT3cw/dsU/VyuTwIcdY9gZImUzV6n/jfw J854wJCjwLUf66wJl0v/6I61VTSml4gfmx57e6M5HRP3P9K9LrHH3qbEIPVm98W73/ VJRlj62cabWpw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 04/14] mm/damon/reclaim: use damon_call() repeat mode instead of damon_callback Date: Sat, 12 Jul 2025 12:50:06 -0700 Message-Id: <20250712195016.151108-5-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 07:00:18 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 20853291C36; Sat, 12 Jul 2025 19:50: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=1752349827; cv=none; b=TzU63yaLuTmVpNNP71hZJ+UVTo11/sZ/bKHd4a7K+5eyzBTTEdaLlJpkC+qZ+QE42qYWvFZCMRcEFB3Cv51621oF1CUWyJhgyWoXKmhmvPIeRmrUOwmJtKRU/tLHc0GsaVOS3oEKggftk27lQSytOB7pLriAIX+oP8QqKKbLhFo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349827; c=relaxed/simple; bh=8BmJeyRI+t+rJLAQd+/Sf188h6vX4h9leuX/fdJu7n0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Dy2u0NQ3LpSbCV+FSKTODoznLES/iCdG5fPJj12mZ31hiI/uzBxplGBj9L2dCUXCEL+bPbtdJq3m2xOKHYzShCCpcYjzboHyM6HXWUc70Cotmu0PwV3AdqvDOCaglAfsBPjEHClB/jrM3dx7/NC1bG9VQtOOyaDZevvxxMqQKK0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=nlT5K1qi; 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="nlT5K1qi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7D780C4CEF7; Sat, 12 Jul 2025 19:50:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349826; bh=8BmJeyRI+t+rJLAQd+/Sf188h6vX4h9leuX/fdJu7n0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=nlT5K1qiBV0RHGAA/07WZGIywH1FpMj7f3h2LS1ztccSE95zqwui6wMnVj+hjadWa wmYVhMJ8J9fR7w6RwmDd3u2AIzufI7gimqcKwQlW/PNTfcIibHTFaicSG2bMMIb8IJ VIuXlbisNF8xHh5Yxa+cLuJU8U9s5TZfLbxmHLPmH4Y213HfYQVOdYIc6o8BG99Z4Y MfuixWL+Ds2olswgaCRAZobNECvnX4xrqFhOLLrBBHjfex6gldDrrJL7tcdmMHWjD1 8p/h7cn0NXMAzK310FxmhpTl9VUQc+SD65u7+oG8QPOFO0CH6Oig+MDeCDfMeFzx26 EAm7Dm8lIj/fg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 05/14] mm/damon/lru_sort: use damon_call() repeat mode instead of damon_callback Date: Sat, 12 Jul 2025 12:50:07 -0700 Message-Id: <20250712195016.151108-6-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 07:00:18 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 DB3FD292933; Sat, 12 Jul 2025 19:50: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=1752349828; cv=none; b=D/w7SUsacKv+0QEqC/zyQv4dbQb59Z+Ge0sCWeuGWpHQkOLlMDrM8Y5HzcfWVt2cPaPVnYWLQM6Eqsf/35BkLAJaO2OlzRNTIhxEIOg0u/gXTigPHSVZU5WygylBc81shjFV2TjrjyiiON06Ax83V5+nlgot+T0CloC13FEbDw0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349828; c=relaxed/simple; bh=OcwCWpW+gdDxIZHIlmwdIcrtDzrp/aZZNpUe+KYMNyw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=mZh6SMaMFOSmZgqTz+zYJsTZFynljBNN+myIxBaqnDd1owGQP0Z5SyMWoGywUYfOqmUOBOU6YFvAQrxIkFzZlfTZTzwQdU1tyHpWTe9KF2Ch583eR7ebuvljpsz3PC42U8jZCDrsJnkwIOrgMsDNFGsmpFSSoMcr0Jun4eD0tK8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=uoHT9o7n; 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="uoHT9o7n" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9420EC4CEF7; Sat, 12 Jul 2025 19:50:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349827; bh=OcwCWpW+gdDxIZHIlmwdIcrtDzrp/aZZNpUe+KYMNyw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=uoHT9o7neTDGCfTetH92f6SPSSQQ4gZ83vz4dRrQm7cPm00O2608YsjoNdxSCb1tw lekOjYFQQngnDAaSVPYl8R4ZeTmp7RA46ZFwRfACQsQJgrLIoP2hkr/89WpQ4CM2pb XdwFWc1rtMQpAFNM9KRCD0R1mKyxndDzJO1iA5GPx/LKho6AIM7PHhJVNOyOeT5a+t YLKnKUZc4PbERRpJ+tKccu9JEzhBvLHkQ/CyG8U1seatzpVS/NvmbxnzpRUZ4rLpzw ygbhVTty2PtzYFabUfFcCQLFlIoWXpJUi4IMTHb5IoYlKEgTBcyT9cp09wa51600UB d4GOFX4fSjuHA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 06/14] samples/damon/prcl: use damon_call() repeat mode instead of damon_callback Date: Sat, 12 Jul 2025 12:50:08 -0700 Message-Id: <20250712195016.151108-7-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 8a312dba7691..25a751a67b2d 100644 --- a/samples/damon/prcl.c +++ b/samples/damon/prcl.c @@ -34,8 +34,9 @@ MODULE_PARM_DESC(enabled, "Enable or disable DAMON_SAMPLE= _PRCL"); 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 07:00:18 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 52080293C61; Sat, 12 Jul 2025 19:50: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=1752349829; cv=none; b=l0HGVOM/F1qRizc1fwYcahZ/u7k0FXptXN3u8SvQZlityRhbXqYp/O389KB7xm+iEG7H9qGcNKrhZhFzyfoD7FOVIRcdZRHNeTjEYSGDCJEs37xb3lxHmmT+GVhNmlEyiW2HhDj/jF9tFAauvGbVIy7UWlwxfJBw8AISw4YJ8YI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349829; c=relaxed/simple; bh=ikK+Sa8v3BhJZJAUTG8MzTN6GxVcuKS7QD6jsmPU43w=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=EvRcin1/TqvbfWRp+P0tn/uS7q69p/9a5/w50RSsUINxtc0LCosD+9FPbp/S25GudxibUtN1X0SiirgwKDjDcT/THoM+figZzBnYsuJWm2hSju1VDBvB0y3lNmePpFDHfTBa6uYYWjfvvGrX0LtOdBS0UJc7r7mEjdVxE/lXz3g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KqyvPtNi; 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="KqyvPtNi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A645FC4CEF1; Sat, 12 Jul 2025 19:50:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349828; bh=ikK+Sa8v3BhJZJAUTG8MzTN6GxVcuKS7QD6jsmPU43w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KqyvPtNiCmv3jSG8kU4DMI35E9lVuUa2RCtxo2cW4xZCDn8TvFbUPdd0G7WIOHEFD vlnR+7mf5beW+zcxzghbfPMMeVcvKz8ZtDEbxHTu+2Z2e9HS6Mi1mHjEPNj8AUUWkY heQRhGZbUv9vVGyUmsqORwvlH6P0Qq6dNwp4TojVbyV10u4u6QTZVOKG+iflteQJzf yCChGBkEu9KpV0O45jrr/pJkvNJ3LAk1PxgPXpMJb+x0kEd7yLaiQ607ql6cuy4SLm i4gVdmUb+aybB//Nc8R7g8Ay6QYGWIn7VXpp5bVWK8oYQQ+YU1TgkpTz8TqGM4bm7A U6NwqD8A+vBIA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 07/14] samples/damon/wsse: use damon_call() repeat mode instead of damon_callback Date: Sat, 12 Jul 2025 12:50:09 -0700 Message-Id: <20250712195016.151108-8-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 d87b3b0801d2..a250e86b24a5 100644 --- a/samples/damon/wsse.c +++ b/samples/damon/wsse.c @@ -35,8 +35,9 @@ MODULE_PARM_DESC(enabled, "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 07:00:18 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 48A24295D96; Sat, 12 Jul 2025 19:50: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=1752349830; cv=none; b=aC8SvnUy/1QH2FVqkqD3uceMkYVWQjiRbinM0uVGm65U7keTT9w4/zNUqQa2cPErTeE9oDWm2oz7Xw1TFQq6hh7Vkv8+osIVQIJWkyGenwrayiFaOHEOcjE/WnSBnXBVE+VDidcAQb2aWquFL19t2FreCfvAtVYaypugzla6uSQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349830; c=relaxed/simple; bh=WnNs9PvTSxpuHsXeKNYiQH21hri+QkB7YdUTcuWeAPQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=j96cfvylEWz8VJvfMCAEHSRhf+qjuYChVrqLVeZ5FPfmoYW0oXkUP4qVIFMkp2y/nGYlGNmf5PTcYd8/JDVOHOM688YNZA8GP8MUdd3xlJeEaYrhdsonHLZiNptVvWYLeuHG1x0wUSFrt0tJ5zkJB6m63bqP3NiUemgqujgXQfU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Ws49IYGo; 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="Ws49IYGo" Received: by smtp.kernel.org (Postfix) with ESMTPSA id AE51EC4CEF1; Sat, 12 Jul 2025 19:50:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349829; bh=WnNs9PvTSxpuHsXeKNYiQH21hri+QkB7YdUTcuWeAPQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Ws49IYGooENIMBShzHJS2qwqqhXkR7Zuz+BYP6ebuoiAlWZok6MczK6dDFt4tZLYS Y6U4IgrFCbB2vTEUk6NaY0ePC6vQYJ34XmLTvTqiMCOqvYewtNjc0+tPLs4YU5gwOR E9cmJgucjSpKYHiRfWK6fwK5r3ACw4p4Z4MNHNgJRMfSya/gf2iX3BL4bYvWQ49j8p woppfYoiQ3NGrRRZNE8D/FzxoKGpiLBTQNtu5pLdw2Q+pEG12y4wnhPbzEdrTRWxS3 wuWHNvhPK2iY6JLGT5O3+sae63zLkrnRoKc10gNlqmn/qIj732q6KXxPnCrj7b1B5V utIrRfUt1N4gw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 08/14] mm/damon/core: do not call ops.cleanup() when destroying targets Date: Sat, 12 Jul 2025 12:50:10 -0700 Message-Id: <20250712195016.151108-9-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 ffb87497dbb5..b82a838b5a0e 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 07:00:18 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 1B6F32980D4; Sat, 12 Jul 2025 19:50: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=1752349831; cv=none; b=RJvoT1ZVv95nlNLTlAt0WwCCmvqX5dUWnzKZqhA/sjzJKEZZ+YvI/TPcBPHRyisUrvqBKwlAG4QWO1mmcLRPw5D+Sl1uYaRLE4cuFH2TjZ8pD4B/nw7Tat2JBEGxkvMp46QF7Sn+5HToVewfz9qGni2KpwtlcCWxQFnu26YCOGs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349831; c=relaxed/simple; bh=fckFdBccHNMeF+WTVksjus+tZiKmAgrc4GdBEfhl2Po=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=f60sopzdv0LnrJZsR3xS92e2AWduxwI8Kp19ihvtwpl0VP62dqzKLZVrMG4csE1Dq/GTAStNvSpcYJdj8tUp01or3E8GGiNx8MCQY4os12T30EwB/UFI7nTzpgpfxgQ0Lm2ggmJZSWqDWrkuNM+GouQo3EaTM3KAa/XepkTnVnQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=OtrVhYwe; 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="OtrVhYwe" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B96C9C4CEEF; Sat, 12 Jul 2025 19:50:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349830; bh=fckFdBccHNMeF+WTVksjus+tZiKmAgrc4GdBEfhl2Po=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=OtrVhYweZizfT32E7ls+t1kchwrgFxHUjb9c1BbmL95Qfm01XXrbctAVIj/9mpm26 XkmAmqA0yHJ9mowqc6gc/ANfsas9iKQdViE+R/wDMws+3RzEVLgigA2LH426inpdYt HVyYCPpKmvRU1L/bbD3Uh7i5h6fgTZIk8Ihx2NbTd6BcciXIdEL4WwegqdbZV1uBNV 2Oo9qxoZitDEOt5ZU0u8z27lKspWUVUU0DXEhvumCUfAfURynO77TeMe7vt7+YY2YG 3D023D8dBh9nYvl5ieMIK+4jpYk4i7NCz3n+cqaVGxc7JowoxIc1UJ5KdyzgJ/c7B6 ew3ThgVFJl+4w== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 09/14] mm/damon/core: add cleanup_target() ops callback Date: Sat, 12 Jul 2025 12:50:11 -0700 Message-Id: <20250712195016.151108-10-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 b83987275ff9..27305d39f600 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 b82a838b5a0e..678c9b4e038c 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) @@ -1137,7 +1141,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; @@ -1156,7 +1160,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 07:00:18 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 6E399298CB7; Sat, 12 Jul 2025 19:50: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=1752349832; cv=none; b=SJkOmvQheqTrvCwKJT6eVkRhr/bO92war8w4k4M7cwPuKit6Dzij7z5c7Yz4C0BS0b5byD6Dn92m7E06wRvqjsfaLPV0qEG8tmqfA5h+1nArk+9MZOZTUrdLCw7YCkv8yldT09j0y3z10152ZSJ5QYD8atXh6BYJ2cSs9zLZduU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349832; c=relaxed/simple; bh=fsU2gZbsgWMkSYRpc0h/oL/Vi1gtpWY17PNH7wEfRqI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=KfJ09M24Izfii0D5PwdF8hY8z22otAHXCAIhUMnObsIJLsayGBP2zYaYr60BxzR/XJ87HPPIF7rQux2SrqvgIjnIECPoAy76GRPdV8pncaKjNjDcH7QCtfhn25UvD3z/V4C9hHJ8FNOL0ClYH7wVnhvMR6lCrelChUqfsUCW0aY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=fZjsH8Lu; 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="fZjsH8Lu" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C7960C4CEEF; Sat, 12 Jul 2025 19:50:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349832; bh=fsU2gZbsgWMkSYRpc0h/oL/Vi1gtpWY17PNH7wEfRqI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=fZjsH8LuWln/avbZ2fC2i7o0sVDMaEqh0lYKe4Uob3y8Q3/oxuTt3XvV20Q0Mkdqb fq5CjUPRamAzYp7UTe2jacxA1AaVazjjdF7uyNAWnL63n+tzWlj78NxwrutMU1I8Q+ /JRoCCwpdeZ8Ekl4sPoK5ORG3Z4JSgHN2Eq8LNa+EzFkj0SUFjJbgx7I5vhM3N0eC7 6amk7B1drrGlPxjjoC9Ehlrs7xtC6StO42TxD3xj/Y++HKpZcdOFub7ZlzKfgzNW4M UBEQiqHNK+1piDXfEls6y6JcMYiD7+CgtLP3uZ+aoNqQibzQn7t1nh/P4sGEnehOhD kplNSl9iKhd9A== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 10/14] mm/damon/vaddr: put pid in cleanup_target() Date: Sat, 12 Jul 2025 12:50:12 -0700 Message-Id: <20250712195016.151108-11-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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, sysfs and sample modules, which were 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 ++++++ samples/damon/prcl.c | 2 -- samples/damon/wsse.c | 2 -- 5 files changed, 8 insertions(+), 14 deletions(-) diff --git a/mm/damon/core.c b/mm/damon/core.c index 678c9b4e038c..9554743dc992 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1139,8 +1139,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 7f5dc9c221a0..94af19c4dfed 100644 --- a/mm/damon/vaddr.c +++ b/mm/damon/vaddr.c @@ -805,6 +805,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) @@ -946,6 +951,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, diff --git a/samples/damon/prcl.c b/samples/damon/prcl.c index 25a751a67b2d..1b839c06a612 100644 --- a/samples/damon/prcl.c +++ b/samples/damon/prcl.c @@ -120,8 +120,6 @@ static void damon_sample_prcl_stop(void) damon_stop(&ctx, 1); damon_destroy_ctx(ctx); } - if (target_pidp) - put_pid(target_pidp); } =20 static bool init_called; diff --git a/samples/damon/wsse.c b/samples/damon/wsse.c index a250e86b24a5..da052023b099 100644 --- a/samples/damon/wsse.c +++ b/samples/damon/wsse.c @@ -100,8 +100,6 @@ static void damon_sample_wsse_stop(void) damon_stop(&ctx, 1); damon_destroy_ctx(ctx); } - if (target_pidp) - put_pid(target_pidp); } =20 static bool init_called; --=20 2.39.5 From nobody Tue Oct 7 07:00:18 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 AD30029A307; Sat, 12 Jul 2025 19:50: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=1752349833; cv=none; b=tBTfVYLZQ/zM9eJHyDd7RJ8iOz8NjWgrjX7rdat8PWMMQqpBLzCByZmJaKmKOuiGnwUfp8tHHrA4iY8BXM5hhJ7Ptm1L3PNhyXbUYbVPBUxpVDIq2IopMBeKVb8ktqrmrrbZ7YHHTadoKAV0s7LXgMhd5s5PD1ZbzcavBdRVXns= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349833; c=relaxed/simple; bh=dnbBIoiWMyEPhOBD2O+z/mHI1a/WsMzxyryGAQlSQsA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=a0V3eH4r1V16ORSLd35xYS6uA+WwLRCgbwCDKXjlZ+YgqtwCNyBp1WjyxMgxPDiPEOlXGen4iqHMWgQMfEm1DC6red7DffRYvaYf5WfyqtXDgFt17e5111zybNbve7ssXf9wRmnz8zunmgMz4E/wm029l/4j3jeKNhsnYO+hM1U= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Q8v/haOo; 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="Q8v/haOo" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E031AC4CEF1; Sat, 12 Jul 2025 19:50:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349833; bh=dnbBIoiWMyEPhOBD2O+z/mHI1a/WsMzxyryGAQlSQsA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Q8v/haOo/sr/cW7UzHViSG7jG2NDvn3mEJydrAguNE2pADocNYFn9UqCJKcBwyNYc DbW+E8jFph9RJ+xwhaS81tMh6GfFXF55QN6vdbha+7vsoZX+DS5kOoPLaaUozcMFV/ MZSzvKvyYQPgQY7n6P/yF6e92QddeSAtXzkz/nafa/wMYIWiaPHCHixhlF0KUuJskG nLFSRJGHlqd4L5oNz27q0Lm3ZiQjVJbVBas7v4qyvQJhdwmjGelSqcaCqRCvBSJyOd mxK+DZHpBCZ9fBsWXkUbl7PEqAqDNZCDMRSXUFtcu6nkbkf/YOZ7JViK7FQ/MbUZaJ 6tnFruKRpNN9w== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 11/14] mm/damon/sysfs: remove damon_sysfs_destroy_targets() Date: Sat, 12 Jul 2025 12:50:13 -0700 Message-Id: <20250712195016.151108-12-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 07:00:18 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 46C6A29AAF5; Sat, 12 Jul 2025 19:50: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=1752349834; cv=none; b=l8/UBCBybkInXMSO7B8btHhufXAgK97FJ3m7Vp3+7Fas2THphBSvZbgJjnS/FLTVsPGbZ2rKCdZuivYNx78LKIYDLnZJOtwH24g1qCN8bBNWVPY0OHYuBbVs9RU54iemDaUc6burmeTI5RnZfBp+7dn5TttqdQ8ebwmmqNjr5dc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349834; c=relaxed/simple; bh=oQhsnF1/u67JFZnBKsT/L2sSUWnwWM0joMv6k3f9o4Q=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=q6pC3gMXjKdmJUB27B3vamLR7FNeR2giIbaOBAoIYMWgdMQy6BXZm3+jSZGRJ96pNLQUUo25YaNcgZzzcLMjkPcHLE0Goti6eokd2y5yf3OJCsaUSk0kTBO8JIaaaJAhy7ZnrBYmUpTZtd+ekJdvMj/cOs/BY4BAwnTrnlXa39s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=tXZ9YU2D; 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="tXZ9YU2D" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EBFD0C4CEEF; Sat, 12 Jul 2025 19:50:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349834; bh=oQhsnF1/u67JFZnBKsT/L2sSUWnwWM0joMv6k3f9o4Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=tXZ9YU2DWWzvtng2+sg7GFjLnmbS3mxfQjEl4vscmm05pc3l7IP27dr9sMFGayXBd TUqTgeHrJdji1bQn9Q2WuwgFVWYzn5opGRJ872u9Id35NgjjUV+gONygjKnKYQV9Tu GQDq+bbWbTP95qVDYCnqSE09LSbNtzGFPjLXBfSDyCnCS6U3D3YGdH8sM5mRnXIppU ipzUtLCJJi/f+mdobrr5PQOpXwfi31SpM0tNgmhJw2ww8CZnUVdqszQ7sb1hOC/TA1 8BR8rNh8JK+K+SnKNebCrfBSFOwTmW06Wpom401omBXN/ciP/FbuAg0LHNtXuPxKyj kehZm5p4/8LEQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 12/14] mm/damon/core: destroy targets when kdamond_fn() finish Date: Sat, 12 Jul 2025 12:50:14 -0700 Message-Id: <20250712195016.151108-13-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 9554743dc992..ffd1a061c2cb 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -2657,6 +2657,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 07:00:18 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 4C1B029B8C3; Sat, 12 Jul 2025 19:50: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=1752349835; cv=none; b=RVm4pDoPBru/mDujx5ig5xVRLXHS1p9jvQA5z9UxTggoU3kwmo2zH2UjJdJlOkoJyaWxmwqU6KN4GOubqSyM9xup1UyQGf1GoRSgCzmrEjciLoMIIZx1vn1PefAdeLnbZt2Xu9w3d+nWE7KeBsQzO2ocmP2rYK34YSvBr3ziybg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349835; c=relaxed/simple; bh=WTjz/K1GFNo9usAZWWENvLqqlSxu80QiYvWGup6Il+g=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Ey9no4Bgfzt5OORDuwBH6ln2r2t8Yx5oENxNYJyzhmDskTLqi2O6NbRrBio5mUoZVVjPmMsxoKBOzLKQ7g7kmHxJhIVsY9e6UuibWBIlJbOUqQEaUKLMvmlWWLVwMxvMnA9IZ8SE2xr8qT0WPdFARniivQa1KOXW+fJHEqAXt7A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=HWkGXT/Y; 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="HWkGXT/Y" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0301FC4CEEF; Sat, 12 Jul 2025 19:50:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349835; bh=WTjz/K1GFNo9usAZWWENvLqqlSxu80QiYvWGup6Il+g=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HWkGXT/YIsfyj9wuHfO1zUCsFKK6RTYxF4bWGCR9fEN/SuCmIoCK8vk1DTnWz9EQt Iv5ZftO212rgxYD9gKmFXC332PjovWtSume4z5zwzI7vcYIBs+9upIGAh5fmFEUZ9C HbjgaFCQZxNTfwyT6lFlsDhvjcbDfqVhvMfsYD2CWGvCCUdbQKyFJHSC2DAypx/Br5 MZcgRpkBnTt4ZIuqI2oGFArJv/UTohteUsB4dJfZumkkyHzH8wBEfctUdMZhfKB3fi WZ8InS7s1bsZDwO/uSKfAYWSd3q/QkhqS9ondBRKk/YZTv7Z+S6CsrD2HZUjywyf5S 59Kpe/mRt/LTw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 13/14] mm/damon/sysfs: remove damon_sysfs_before_terminate() Date: Sat, 12 Jul 2025 12:50:15 -0700 Message-Id: <20250712195016.151108-14-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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 07:00:18 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 C3B4729DB8F; Sat, 12 Jul 2025 19:50: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=1752349836; cv=none; b=jdQSKdbvc21Qz/RTIUw5H1rv5rSV9faIkfA724MPiJhm75FXhgLlsyHVZ+Bqa3iqCI6tz7xrus7O4VQFa0QtqPBz2T1BN49id9qjmxtRB0irvF6fDicunhbLUYrsSN0mgg15bg+YyEVyALrBuDeNMG9Jv0J8amokYT4grTgYp0U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1752349836; c=relaxed/simple; bh=N6UgM+GaU7C25cINsCnFK+jRBTnhXf4uYeOYOmlqYds=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=aBQQplNgTYcJmFWyC7NlO9HzyzMHvhuazUanGkT6t2ZshltuD4PtWpETaLTNg5B2ltruqmf+u+8KLRdYQWq9KqitNXTJ/+KwaGfejhmuWhdjpf/eUTZ002usjcM7TD7o9j1hscOoLB2QvT0CV3E4MJmhD3CV/zs3QQkQjl5Hk7Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=jI3qg08J; 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="jI3qg08J" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 23DA8C4CEF1; Sat, 12 Jul 2025 19:50:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1752349836; bh=N6UgM+GaU7C25cINsCnFK+jRBTnhXf4uYeOYOmlqYds=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=jI3qg08JH6ttnI0W7A3bfseSky7pZofrGzwYc23N1TYIhYlE50n3BH3z0aleDvYIL kVvS56Apd0e1nEiBhzPjcLz5g2vQPEdiIBivrjAU61AAWaPDBgbQt6iivdKxQvQAS3 agMj7LmG+f+kKCQPh9IgGiWrBdpHy1Izu248+N8QXR+7eV4FQb2ALB3fVlKTeZtHuy 7zbGBW5g82RZtaTtfczGkMs6L2ReRL5a94IIJWpjna/XZtPBBbMcV3KcFIcZfuNlGM d9K3EPVqvl6T0H2/DqgmKTg36JYgkcgOPSi3RtxuXyIEi55drBeAYkhpsV6m/TYFrL 2bGhRqQG30ZsA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 14/14] mm/damon/core: remove damon_callback Date: Sat, 12 Jul 2025 12:50:16 -0700 Message-Id: <20250712195016.151108-15-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250712195016.151108-1-sj@kernel.org> References: <20250712195016.151108-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(). Time to say goodbye. 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 27305d39f600..34fc5407f98e 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 ffd1a061c2cb..f3ec3bd736ec 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) { @@ -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) =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); } @@ -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 =3D ctx->next_aggregation_sis; unsigned long next_ops_update_sis =3D ctx->next_ops_update_sis; @@ -2564,14 +2558,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 @@ -2637,8 +2627,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