From nobody Thu Dec 18 19:04:26 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 8EF3F25B678; Wed, 26 Feb 2025 06:36:56 +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=1740551816; cv=none; b=gvyr1++Ms8dp4xo+seSU7G3OjJhOnxj+CC65OeFhQH9ly2jZDtlPfClF8HSTi9U8afWyoekAe+hpt+mUyF3FzCYFzMa2CmiiPL6LPj47AkBQkQEuVCwmZU5eT9r8PcDshz7K+0SNjCJnx+5olxhKZNa//BPiM9U2nvVvFgCE/Bw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551816; c=relaxed/simple; bh=5n9xRLBBKD40DxaNJxpmX5CbdO8tnA9vHZtFNqo0gek=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=cu8YwEYv/7D4pEelQBVVrx7grLLJOWFaqH0RrhZrdSIUS6bgdr1fZ4BujMjsOrxU9TgBwg9sRdvUXL94FGO5yIU8ZE90JN8OQqur/wznb/mfhfOh7E2csNJ9VVKcDx4DSzWrV2/06Bekc875hecMqz3/72UJwFF64wQMxJYAnMQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=JNjpdu0n; 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="JNjpdu0n" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EE5C5C4CEE2; Wed, 26 Feb 2025 06:36:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551816; bh=5n9xRLBBKD40DxaNJxpmX5CbdO8tnA9vHZtFNqo0gek=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=JNjpdu0naIeVD/lEw6HDtDk+7/Wad7TrQhcHR/+50Bj4hoe+y6aNGrXqIPF90UhX3 CAnGFDEcAhmNDIxn88JGEMRBGoudUaSX1NKQm0FkOSuDs4JRdCbeWv9hBjD8RTZW2T zX69CheuLIzZ05UaOf95ACvkggJVfNhwABo1lFEvgGuIkuSaQAIMrQXxFm5i/Al1uH tjGjfTNdOXeAmXEv7ouuwwFqyyTs2zuGY+USl8gVaBdkqXtugtuXtprfoyai76z29b HKE4HYcVWyDaCKJnEBczKxPQpf3QrO9z32HKGAEsFMHouBXLW2Lr3ZnlOfa7uRonEm ZbDqtOQl08BpA== 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/13] mm/damon/sysfs: validate user inputs from damon_sysfs_commit_input() Date: Tue, 25 Feb 2025 22:36:39 -0800 Message-Id: <20250226063651.513178-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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" Online DAMON parameters commit via DAMON sysfs interface can make kdamond stop. This behavior was made because it can make the implementation simpler. The implementation simply tries committing the parameter without validation. If it finds something wrong, it returns error without reverting partially committed parameters back. It is safe though, since it breaks kdamond main loop in the case of the error return. Users can make the wrong parameters by mistake, though. Validating the input parameters first and returning the error when some parameters wrong, while letting kdamond continues running with the old parameters would be the better behavior. This behavior can also make damon_call() carrying the online commit instead of the damon_callback hook in future easier, because damon_call() cannot directly break kdamond main loop. Implement the better behavior. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index ccd435d234b9..87e4c6e3614e 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1449,11 +1449,11 @@ static struct damon_ctx *damon_sysfs_build_ctx( * damon_sysfs_commit_input() - Commit user inputs to a running kdamond. * @kdamond: The kobject wrapper for the associated kdamond. * - * If the sysfs input is wrong, the kdamond will be terminated. + * Returns error if the sysfs input is wrong. */ static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond) { - struct damon_ctx *param_ctx; + struct damon_ctx *param_ctx, *test_ctx; int err; =20 if (!damon_sysfs_kdamond_running(kdamond)) @@ -1465,7 +1465,15 @@ static int damon_sysfs_commit_input(struct damon_sys= fs_kdamond *kdamond) param_ctx =3D damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); if (IS_ERR(param_ctx)) return PTR_ERR(param_ctx); + 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 Thu Dec 18 19:04:26 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 6584B269AE6; Wed, 26 Feb 2025 06:36:57 +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=1740551817; cv=none; b=eNX04hJlQF+Ak1WaxevHLAwSYnnRA9kagrGSme/qXDFTZSyjiSLoovlQv+7/HSVmAY8Z8o2m9m47o/vHi09w+S/sehasYgDqeFo6BJxdDsgWzQnQRmGc7A3ltyia/RNHej+w10p9MC8Nmi0CE1Qn96phQ1ZRBl2tXd/s8C+fV8s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551817; c=relaxed/simple; bh=9LkGnu4V55DcG0gnLZ1nxdIsaaPuWfP3P63Al4SXqQY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Cr4StymugGlyPWPdCrR7HrESQgXyQ0xe7amRt2anur/U2/ykdEWoMx9Y0Dpfh37BvJT//gYM4Y1LgGo+55Fnf647DgY+NHFsHZ8/h/9e0QoXZV0baF+CcSWhgQ4xl5byeglZIJCJcQgJhJls7l875GnPhT5LT6k6+iVBCTByzQc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=QEaBgAC4; 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="QEaBgAC4" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 167AAC4CEEF; Wed, 26 Feb 2025 06:36:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551817; bh=9LkGnu4V55DcG0gnLZ1nxdIsaaPuWfP3P63Al4SXqQY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=QEaBgAC47cbxN/RRjljj/8roAg+KCPL71T4UAk25EG2gYQZU01C8ZZm/pZhxdCMTr dnWU8VqhwLdVhdEQEP3yxWTYhNkXhzjyJrljzSasWAWf6ljh/fl564jMepEjub7hpL 9dYuHOFrQOSMxGUm+FtWJy3FnzLHIwNMdfxmGgOEK/XsK/+SK7KRL/17jiWAhJBafP iiGwutL6uv8Vd8FM+8kaYmFpuDyGAtDtHm3UOwJe98w6gR71px8mwiTAJmsbDEOsgl ntMIFzIJsMEROJQvm0jvpJ0s8G/jqL4Tesq5PXZL6jGcgAvAzr0YpCry7BWySPVx9P bNZaVK+RBMpCw== 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/13] mm/damon/core: invoke kdamond_call() after merging is done if possible Date: Tue, 25 Feb 2025 22:36:40 -0800 Message-Id: <20250226063651.513178-3-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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" kdamond_call() callers may iterate the regions, so better to call it when the number of regions is as small as possible. It is when kdamond_merge_regions() is finished. Invoke it on the point. This change is also for making future change for carrying online parameters commit with damon_call() easier. The commit work should be able to make sequence between other aggregation interval based operations including regioins merging and aggregation reset. Placing damon_call() invocation after the regions merging makes the sequence handling simpler. Signed-off-by: SeongJae Park --- mm/damon/core.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mm/damon/core.c b/mm/damon/core.c index 310cdc87d5f4..0578e89dff13 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -2412,7 +2412,6 @@ static int kdamond_fn(void *data) if (ctx->callback.after_sampling && ctx->callback.after_sampling(ctx)) break; - kdamond_call(ctx, false); =20 kdamond_usleep(sample_interval); ctx->passed_sample_intervals++; @@ -2430,9 +2429,10 @@ static int kdamond_fn(void *data) } =20 /* - * do kdamond_apply_schemes() after kdamond_merge_regions() if - * possible, to reduce overhead + * do kdamond_call() and kdamond_apply_schemes() after + * kdamond_merge_regions() if possible, to reduce overhead */ + kdamond_call(ctx, false); if (!list_empty(&ctx->schemes)) kdamond_apply_schemes(ctx); else --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 D424D26A1B6; Wed, 26 Feb 2025 06:36:58 +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=1740551818; cv=none; b=Z9KBaZgNot2VgN0keT2tGWs2dJcBDsbVumpBKDRTiBbOu5SXBYEgTeBg1UUUpHZlgsOqsl/gidm5ELbkguLSz+18thnP/oPNMbm/PPAN3iGUmw9vZvSgcf0o7gHTJK3GKt6aXlvPIyI1ydbvvki2yfcJkrYDqNjACe9ZoYdvzgo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551818; c=relaxed/simple; bh=43qAgqvlrGuT5QCdJ6rPL+omeoO3HK7C7mVfbHXX3rQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=AAaFXp8Pyt2s5J8eIZ/ML8GnrzV1IdtxE8b8yNwpXiWlTpy1NyAJAMgd33rzo9+iHCA0q71IcoGcwbNgOFu32bhZsyNTmkXa6bp4KYX83Z+eK6HZovd8d4AtvWu9NqEYrL1lEyNGLk3tdV1g07aEB9Krg/9c+3PQW7GyWGyOt20= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=c4OrK71w; 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="c4OrK71w" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 23684C4CEEA; Wed, 26 Feb 2025 06:36:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551818; bh=43qAgqvlrGuT5QCdJ6rPL+omeoO3HK7C7mVfbHXX3rQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=c4OrK71wA49aXqNHD0dgxHKUbfmC0RMtGyCLCaB6W3Eyv4rKbWxPGCoR1QCw0SNg9 hjHvjPnTQAqPS3kKuYHaXiKVTPYlH1ij1VFFgXXiSPsfrzOJ2suCfPduH0d6nzK20g hBBC+6wchQZVwWHdiszEe/DQwIcEXs/YKGslXcd0k2jL3BXRBtBC8LPDS778Vr6lvY kazGYDDVN7rsJKJ6BEtfvgINPlqmFKOoMkaq3G+lbsyOlwAlRx1jE4kS66PMnFypWU Xm9TfZgjYCUQ4B+nYySeAzTOQb3myWea8idoUNYg+f77E66mcHOWHMf7O+H2UXCwO+ EVNsmFbEdpE4A== 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/13] mm/damon/core: make damon_set_attrs() be safe to be called from damon_call() Date: Tue, 25 Feb 2025 22:36:41 -0800 Message-Id: <20250226063651.513178-4-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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" Currently all DAMON kernel API callers do online DAMON parameters commit from damon_callback->after_aggregation because only those are safe place to call the DAMON monitoring attributes update function, namely damon_set_attrs(). Because damon_callback hooks provides no synchronization, the callers works in asynchronous ways or implement their own inefficient and complicated synchronization mechanisms. It also means online DAMON parameters commit can take up to one aggregation interval. On large systems having long aggregation intervals, that can be too slow. The synchronization can be done in more efficient and simple way while removing the latency constraint if it can be done using damon_call(). The fact that damon_call() can be executed in the middle of the aggregation makes damon_set_attrs() unsafe to be called from it, though. Two real problems can occur in the case. First, converting the not yet completely aggregated nr_accesses for new user-set intervals can arguably degrade the accuracy or at least make the logic complicated. Second, kdamond_reset_aggregated() will not be called after the monitoring results update, so next aggregation starts from unclean state. This can result in inconsistent and unexpected nr_accesses. Make it safe as follows. Catch the middle-of-the-aggregation case from damon_set_attrs() and pass the information to nr_accesses conversion logic. The logic works as before if this is not the case (called after the current aggregation is completed). If not, it drops the nr_accesses information that so far aggregated, and make the status same to the beginning of this aggregation, but as if the last aggregation was ran with the updated sampling/aggregation intervals. Signed-off-by: SeongJae Park --- mm/damon/core.c | 38 ++++++++++++++++++++++++++----------- mm/damon/tests/core-kunit.h | 6 +++--- 2 files changed, 30 insertions(+), 14 deletions(-) diff --git a/mm/damon/core.c b/mm/damon/core.c index 0578e89dff13..5b807caaec95 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -602,11 +602,25 @@ static unsigned int damon_nr_accesses_for_new_attrs(u= nsigned int nr_accesses, } =20 static void damon_update_monitoring_result(struct damon_region *r, - struct damon_attrs *old_attrs, struct damon_attrs *new_attrs) + struct damon_attrs *old_attrs, struct damon_attrs *new_attrs, + bool aggregating) { - r->nr_accesses =3D damon_nr_accesses_for_new_attrs(r->nr_accesses, - old_attrs, new_attrs); - r->nr_accesses_bp =3D r->nr_accesses * 10000; + if (!aggregating) { + r->nr_accesses =3D damon_nr_accesses_for_new_attrs( + r->nr_accesses, old_attrs, new_attrs); + r->nr_accesses_bp =3D r->nr_accesses * 10000; + } else { + /* + * if this is called in the middle of the aggregation, reset + * the aggregations we made so far for this aggregation + * interval. In other words, make the status like + * kdamond_reset_aggregated() is called. + */ + r->last_nr_accesses =3D damon_nr_accesses_for_new_attrs( + r->last_nr_accesses, old_attrs, new_attrs); + r->nr_accesses_bp =3D r->last_nr_accesses * 10000; + r->nr_accesses =3D 0; + } r->age =3D damon_age_for_new_attrs(r->age, old_attrs, new_attrs); } =20 @@ -619,7 +633,7 @@ static void damon_update_monitoring_result(struct damon= _region *r, * ->nr_accesses and ->age of given damon_ctx's regions for new damon_attr= s. */ static void damon_update_monitoring_results(struct damon_ctx *ctx, - struct damon_attrs *new_attrs) + struct damon_attrs *new_attrs, bool aggregating) { struct damon_attrs *old_attrs =3D &ctx->attrs; struct damon_target *t; @@ -634,7 +648,7 @@ static void damon_update_monitoring_results(struct damo= n_ctx *ctx, damon_for_each_target(t, ctx) damon_for_each_region(r, t) damon_update_monitoring_result( - r, old_attrs, new_attrs); + r, old_attrs, new_attrs, aggregating); } =20 /* @@ -661,10 +675,10 @@ static bool damon_valid_intervals_goal(struct damon_a= ttrs *attrs) * @ctx: monitoring context * @attrs: monitoring attributes * - * This function should be called while the kdamond is not running, or an - * access check results aggregation is not ongoing (e.g., from - * &struct damon_callback->after_aggregation or - * &struct damon_callback->after_wmarks_check callbacks). + * 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(). * * Every time interval is in micro-seconds. * @@ -675,6 +689,8 @@ int damon_set_attrs(struct damon_ctx *ctx, struct damon= _attrs *attrs) unsigned long sample_interval =3D attrs->sample_interval ? attrs->sample_interval : 1; struct damos *s; + bool aggregating =3D ctx->passed_sample_intervals < + ctx->next_aggregation_sis; =20 if (!damon_valid_intervals_goal(attrs)) return -EINVAL; @@ -695,7 +711,7 @@ int damon_set_attrs(struct damon_ctx *ctx, struct damon= _attrs *attrs) ctx->next_ops_update_sis =3D ctx->passed_sample_intervals + attrs->ops_update_interval / sample_interval; =20 - damon_update_monitoring_results(ctx, attrs); + damon_update_monitoring_results(ctx, attrs, aggregating); ctx->attrs =3D *attrs; =20 damon_for_each_scheme(s, ctx) diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h index 532c6a6f21f9..be0fea9ee5fc 100644 --- a/mm/damon/tests/core-kunit.h +++ b/mm/damon/tests/core-kunit.h @@ -348,19 +348,19 @@ static void damon_test_update_monitoring_result(struc= t kunit *test) =20 new_attrs =3D (struct damon_attrs){ .sample_interval =3D 100, .aggr_interval =3D 10000,}; - damon_update_monitoring_result(r, &old_attrs, &new_attrs); + damon_update_monitoring_result(r, &old_attrs, &new_attrs, false); KUNIT_EXPECT_EQ(test, r->nr_accesses, 15); KUNIT_EXPECT_EQ(test, r->age, 2); =20 new_attrs =3D (struct damon_attrs){ .sample_interval =3D 1, .aggr_interval =3D 1000}; - damon_update_monitoring_result(r, &old_attrs, &new_attrs); + damon_update_monitoring_result(r, &old_attrs, &new_attrs, false); KUNIT_EXPECT_EQ(test, r->nr_accesses, 150); KUNIT_EXPECT_EQ(test, r->age, 2); =20 new_attrs =3D (struct damon_attrs){ .sample_interval =3D 1, .aggr_interval =3D 100}; - damon_update_monitoring_result(r, &old_attrs, &new_attrs); + damon_update_monitoring_result(r, &old_attrs, &new_attrs, false); KUNIT_EXPECT_EQ(test, r->nr_accesses, 150); KUNIT_EXPECT_EQ(test, r->age, 20); =20 --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 9A49426B09C; Wed, 26 Feb 2025 06:36:59 +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=1740551819; cv=none; b=VVTjyn9zUjc2KWJMgdr5e2ETlZrrdYhJzuAIxBUh1z2CntjakdnvQT7U8MtfbFWRqD52Egigihvaz+tna455h82yLBYCkUAhlMrzRrPNh/yDBqXKM3ueDvUuPG3E4fKkCQHoAKYnsd7WaSZ3N2y13fEl2yq19U+sUrf1IleRrpw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551819; c=relaxed/simple; bh=A9kUtW/vUg0eJWtZD6pmVLozHOg4c74YXKaYzr3PmRI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=WTX/dPtePM9hhavuTGIsn2jXBu4F4Xoh22udt1ObvUwQcnBsU5u7yFs7MXiehRrX42qo6NgIB0pHvkcrlT+npI3iekJkugqDO5eYBWFHjt6IM0mEVZRB2bINolbGWP7Pw1mgTFNXtQouizepLXyhYudJlmZfrpStBiQFJD0znd4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=u1VUa9Tl; 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="u1VUa9Tl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4FECBC4CEEA; Wed, 26 Feb 2025 06:36:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551819; bh=A9kUtW/vUg0eJWtZD6pmVLozHOg4c74YXKaYzr3PmRI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=u1VUa9TlCpJ6kmtrlPET5GNYjsXSI2WrULZys0ykm4efcjqil6Y+mFt2nGwzo5eLJ ePQC78kT9F7g3yy7DGEm5r21ku2OpNLSV+S2mK1272WKYfBQ1gPZpBScgWneMkbcI+ Owd5vUURIHYkBFHqIdvDRGsIYYzJV1mIl9O18ksRlWIHEqAKwMRVx/KznMkjhNYaLE optqYDTULzCapSsFFGZmxXuzJblRowlcC51/Pgr6KI/ZjyB/y92QCkzcdFm0oSDRLA upDbHHpdf0v+5OHZRPE79eKaxcLeYRV6/xkJyvlpqfJDBECuo3MpOfXBk49BRU0Sy0 w3AwyPHF3QPFw== 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/13] mm/damon/sysfs: handle commit command using damon_call() Date: Tue, 25 Feb 2025 22:36:42 -0800 Message-Id: <20250226063651.513178-5-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 sysfs interface is using damon_callback->after_aggregation hook with its self-implemented synchronization mechanism for the hook. It is inefficient, complicated, and take up to one aggregation interval to complete, which can be long on some configs. Instead use damon_call(). It provides a synchronization mechanism that built inside DAMON's core layer, so more efficient than DAMON sysfs interface's own one. Also it isolates the implementation inside the core layer, and hence makes it easier to be maintained. Finally, it takes up to one sampling interval, which is much shorter than the aggregation interval in common setups. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 87e4c6e3614e..c55a2cee4b74 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1451,8 +1451,9 @@ static struct damon_ctx *damon_sysfs_build_ctx( * * Returns error if the sysfs input is wrong. */ -static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond) +static int damon_sysfs_commit_input(void *data) { + struct damon_sysfs_kdamond *kdamond =3D data; struct damon_ctx *param_ctx, *test_ctx; int err; =20 @@ -1550,11 +1551,6 @@ static int damon_sysfs_cmd_request_callback(struct d= amon_ctx *c, bool active, if (!kdamond || kdamond->damon_ctx !=3D c) goto out; switch (damon_sysfs_cmd_request.cmd) { - case DAMON_SYSFS_CMD_COMMIT: - if (!after_aggregation) - goto out; - err =3D damon_sysfs_commit_input(kdamond); - break; default: break; } @@ -1712,11 +1708,7 @@ static int damon_sysfs_update_schemes_tried_regions( * @cmd: The command to handle. * @kdamond: The kobject wrapper for the associated kdamond. * - * This function handles a DAMON sysfs command for a kdamond. For commands - * that need to access running DAMON context-internal data, it requests - * handling of the command to the DAMON callback - * (@damon_sysfs_cmd_request_callback()) and wait until it is properly han= dled, - * or the context is completed. + * This function handles a DAMON sysfs command for a kdamond. * * Return: 0 on success, negative error code otherwise. */ @@ -1730,6 +1722,9 @@ static int damon_sysfs_handle_cmd(enum damon_sysfs_cm= d cmd, return damon_sysfs_turn_damon_on(kdamond); case DAMON_SYSFS_CMD_OFF: return damon_sysfs_turn_damon_off(kdamond); + case DAMON_SYSFS_CMD_COMMIT: + return damon_sysfs_damon_call( + damon_sysfs_commit_input, kdamond); case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: return damon_sysfs_damon_call( damon_sysfs_commit_schemes_quota_goals, --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 17D8A26BDA4; Wed, 26 Feb 2025 06:37:00 +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=1740551821; cv=none; b=qpy1f/hLWx4xqmIAJppOXJzH6PvsbnILYClz9N55TI9MOZcOR8Vn9iw3Xktz5q6HImkj/LDoPEXsOrCoZrCzSxHNxOlSBBkM7OJauYrROgm0RgStn+1b4wP2vbvpmj7v7nhGn1RYcDFk9fkpfT2k7XM8A2DVRx/qBS4t6MbDm7k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551821; c=relaxed/simple; bh=ZDADvW0oQPUgZeNcgv9P9GJF3heQ3/Xecw6OVh3xMI4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=jzGb/9rDRTiMrNrHsc/myC0KlW6bUxHfUogj+vQvNY+GdpaWnwyNW18F2QI4n74Orw0Kh0WXobXJrNx887ZPlvXxYcD+5QqO96I4Ie/YvtiJoQL9VFazLi97V8eIjp6Y9XNAJ/hA0LL85f25xQSdyygDQBYjsk+ska+wS6csuIY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=P+NvSuYV; 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="P+NvSuYV" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 72AE7C4CEE9; Wed, 26 Feb 2025 06:37:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551820; bh=ZDADvW0oQPUgZeNcgv9P9GJF3heQ3/Xecw6OVh3xMI4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=P+NvSuYVCbP0zamxR9Q/T6/f9oqao4fhYmC9FmNd8WnmGQmavl/+yCP8sFp2JJ0x0 wsdh8ZTOVYIAhsfdq8IUCe8m4JKlWrpDNkAawiTNWgTv/DeA3X9QD6QzsQAbZXxNVe VlutXHzq9Cai0AjDj1uiQI0L+7cCB+wBaQLFWxoFlfGHWJlS1nneI197sqWE/pFpUa 1tM/iMs5d5Dc1ose5/SFQDJGVVoyMralJztkIL26RLL48jyNrfZbew7bCdkgHBaqrl OagseUL313dWU+fHsgFcJ5Lztx1xk34sj/HVXOfwOWcZcbUGzvAv+qz+3NB+F5wnmV i827EwrB5itOA== 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/13] mm/damon/sysfs: remove damon_sysfs_cmd_request code from damon_sysfs_handle_cmd() Date: Tue, 25 Feb 2025 22:36:43 -0800 Message-Id: <20250226063651.513178-6-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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_sysfs_handle_cmd() handles user requests that it can directly handle on its own. For requests that need to be handled from damon_callback hooks, it uses DAMON sysfs interface's own synchronous damon_callback hooks management mechanism, namely damon_sysfs_cmd_request. Now all user requests are handled without damon_callback hooks, so damon_sysfs_cmd_request use code in damon_sysfs_andle_cmd() does nothing in real. Remove the unnecessary code. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 32 -------------------------------- 1 file changed, 32 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index c55a2cee4b74..166161f12c26 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1715,8 +1715,6 @@ static int damon_sysfs_update_schemes_tried_regions( static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd, struct damon_sysfs_kdamond *kdamond) { - bool need_wait =3D true; - switch (cmd) { case DAMON_SYSFS_CMD_ON: return damon_sysfs_turn_damon_on(kdamond); @@ -1747,38 +1745,8 @@ static int damon_sysfs_handle_cmd(enum damon_sysfs_c= md cmd, return damon_sysfs_damon_call( damon_sysfs_upd_tuned_intervals, kdamond); default: - break; - } - - /* Pass the command to DAMON callback for safe DAMON context access */ - if (damon_sysfs_cmd_request.kdamond) - return -EBUSY; - if (!damon_sysfs_kdamond_running(kdamond)) return -EINVAL; - damon_sysfs_cmd_request.cmd =3D cmd; - damon_sysfs_cmd_request.kdamond =3D kdamond; - - /* - * wait until damon_sysfs_cmd_request_callback() handles the request - * from kdamond context - */ - mutex_unlock(&damon_sysfs_lock); - while (need_wait) { - schedule_timeout_idle(msecs_to_jiffies(100)); - if (!mutex_trylock(&damon_sysfs_lock)) - continue; - if (!damon_sysfs_cmd_request.kdamond) { - /* damon_sysfs_cmd_request_callback() handled */ - need_wait =3D false; - } else if (!damon_sysfs_kdamond_running(kdamond)) { - /* kdamond has already finished */ - need_wait =3D false; - damon_sysfs_cmd_request.kdamond =3D NULL; - } - mutex_unlock(&damon_sysfs_lock); } - mutex_lock(&damon_sysfs_lock); - return 0; } =20 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *at= tr, --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 4390526E149; Wed, 26 Feb 2025 06:37:01 +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=1740551822; cv=none; b=FRVMePdHteG9swH9MTLCcCBHPvehaJ9RJflLb9rWSfq71A7sCWr29CivCF6oonWv14GwdgCxxlp/2t+8B+cKVwQ3VO2QkVkdunz32ssheR5x1nleefDw0idBJZuaHgi58vrQa9OPBL9WfyVsW2qxwwOZV7laRl7VDCjrddfTnTM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551822; c=relaxed/simple; bh=T05PHV/b/RY6SE79bGJVruG1lJQyvBwcsDSu/WYUE0U=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=PqVStpBd8nRfKX1IC2cQZIu981BBo+zln3nY6scZshDGFQXC8Eb2GiBSgH7EfTPADdc1BSVHC5MnZjyHE/GgksnX6beZe2TkOL+CZw71BuxhZ4QrfyYX3UwEwnBBP+ujCi5w/5c6kSN4aaF9f4asldnboDBu6XGcJGEZVbHR0QI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ou4Jlw/h; 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="ou4Jlw/h" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9491DC4CEEC; Wed, 26 Feb 2025 06:37:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551821; bh=T05PHV/b/RY6SE79bGJVruG1lJQyvBwcsDSu/WYUE0U=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ou4Jlw/h7uxzaJKHZrhqjlV2IAvmkNPu9L3ZopdDLUbEKqsSKUFC4oNZcwIN974nz NOwvefrT1a5l7zV4szTYyn7Zz8Fg9RoYksLLzP+Gjjrf5oCH5MP88bgQhyPyubwqwJ Itxtyz0qHmVmtj5hHo+bcvquT6H0jg1mOO//L6+Qz12uSC5u1ktkLRoENnpxDtLLoq WYAOzzgdsSCZkd3SLqTaNCvfSMQ2RyRWGxD+tqkDFlsFYCZ3LQptMkp34co2a/3q8F FIMek3ClqcJbhIexLUjLeW5TtbhKsNCcZuLbbItCEh6RELG9wYPT2UZ0svKOt5wDYa 2DNmGdrkiut6Q== 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/13] mm/damon/sysfs: remove damon_sysfs_cmd_request_callback() and its callers Date: Tue, 25 Feb 2025 22:36:44 -0800 Message-Id: <20250226063651.513178-7-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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_sysfs_cmd_request_callback() is the damon_callback hook functions that were used to handle user requests that need to read and/or write DAMON internal data. All the usages are now updated to use damon_call() or damos_walk(), though. Remove it and its callers. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 62 ------------------------------------------------ 1 file changed, 62 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 166161f12c26..e5bcf019086f 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1529,65 +1529,6 @@ static int damon_sysfs_upd_tuned_intervals(void *dat= a) return 0; } =20 -/* - * damon_sysfs_cmd_request_callback() - DAMON callback for handling reques= ts. - * @c: The DAMON context of the callback. - * @active: Whether @c is not deactivated due to watermarks. - * @after_aggr: Whether this is called from after_aggregation() callback. - * - * This function is periodically called back from the kdamond thread for @= c. - * Then, it checks if there is a waiting DAMON sysfs request and handles i= t. - */ -static int damon_sysfs_cmd_request_callback(struct damon_ctx *c, bool acti= ve, - bool after_aggregation) -{ - struct damon_sysfs_kdamond *kdamond; - int err =3D 0; - - /* avoid deadlock due to concurrent state_store('off') */ - if (!mutex_trylock(&damon_sysfs_lock)) - return 0; - kdamond =3D damon_sysfs_cmd_request.kdamond; - if (!kdamond || kdamond->damon_ctx !=3D c) - goto out; - switch (damon_sysfs_cmd_request.cmd) { - default: - break; - } - /* Mark the request as invalid now. */ - damon_sysfs_cmd_request.kdamond =3D NULL; -out: - mutex_unlock(&damon_sysfs_lock); - return err; -} - -static int damon_sysfs_after_wmarks_check(struct damon_ctx *c) -{ - /* - * after_wmarks_check() is called back while the context is deactivated - * by watermarks. - */ - return damon_sysfs_cmd_request_callback(c, false, false); -} - -static int damon_sysfs_after_sampling(struct damon_ctx *c) -{ - /* - * after_sampling() is called back only while the context is not - * deactivated by watermarks. - */ - return damon_sysfs_cmd_request_callback(c, true, false); -} - -static int damon_sysfs_after_aggregation(struct damon_ctx *c) -{ - /* - * after_aggregation() is called back only while the context is not - * deactivated by watermarks. - */ - return damon_sysfs_cmd_request_callback(c, true, true); -} - static struct damon_ctx *damon_sysfs_build_ctx( struct damon_sysfs_context *sys_ctx) { @@ -1603,9 +1544,6 @@ static struct damon_ctx *damon_sysfs_build_ctx( return ERR_PTR(err); } =20 - ctx->callback.after_wmarks_check =3D damon_sysfs_after_wmarks_check; - ctx->callback.after_sampling =3D damon_sysfs_after_sampling; - ctx->callback.after_aggregation =3D damon_sysfs_after_aggregation; ctx->callback.before_terminate =3D damon_sysfs_before_terminate; return ctx; } --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 52F0426E62F; Wed, 26 Feb 2025 06:37:02 +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=1740551823; cv=none; b=NfSljTLGzQR1G+F/UZDx8SXFe5yGSURC4G6tDUPDcDS4xxtq3Nc2IxUYpgNb7iNnbM1cyn/S0PvaKgxcOQVqLobEBr+QHuK3+C3cNDyxPLc/Nj81uHO+1l3ZCEUxnoGioz/n/UF+G+5cuU967kmxrla7Bo6GIFPaB/oAB3X2V08= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551823; c=relaxed/simple; bh=4J5vWHiHbtHqjwMC+hRbiipl4h9liEs0+TfNTGi8OuM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=WUh9AMjqt9hnVtNuW8/ajGbKpZr7lyyrfOqUzovzFK5OncCYdrzUaxe7i8oinJK5FXh+132fH4irp/RtCOs51pShlCJWgpNouWhOIS//QXc7xadwN4YW+mGf4/azcZPWB92r+ZhfZTQWEC7992JD8+XjzobrQj1k+sxqXm6VjmY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=IY35+2jS; 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="IY35+2jS" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A40BBC4CEEA; Wed, 26 Feb 2025 06:37:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551822; bh=4J5vWHiHbtHqjwMC+hRbiipl4h9liEs0+TfNTGi8OuM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=IY35+2jSTR0fwPWqE0pDaF10P37LWFVbjA8i0aglA/xKkrkdRBuW0AFLyuSa9KeHM pL7QeBCioMTspDME/Oi5tgLtMj3Ww5A1LPrqqmL+8dn/I3P/H+2ATvr7HkujdVpKi+ kHsu0DgCV4rIYvS/nH7GWwA5/FyIk/sNfWnIPacPHqL0MUoFtHZ4yCGO0syynawauK o6NDT1eHtNQSJhVYcRQ8EP8uA+lKkSVaQWO6RUtD4CnGHJnBTN6fPLTNtOzqrfcU3k V9DFeIAiANVX3zwg0kvelgpgrf764O4s+SgKVbqY4L3lCILw+abR5640X7UDPvdUnp MicgMxBby5e1g== 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/13] mm/damon/sysfs: remove damon_sysfs_cmd_request and its readers Date: Tue, 25 Feb 2025 22:36:45 -0800 Message-Id: <20250226063651.513178-8-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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_sysfs_cmd_request is DAMON sysfs interface's own synchronization mechanism for accessing DAMON internal data via damon_callback hooks. All the users are now migrated to damon_call() and damos_walk(), so nobody really uses it. No one writes to the data structure but reading code is remained. Remove the reading code and the entire data structure. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 24 +----------------------- 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index e5bcf019086f..1af6aff35d84 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1238,25 +1238,6 @@ static const char * const damon_sysfs_cmd_strs[] =3D= { "update_tuned_intervals", }; =20 -/* - * struct damon_sysfs_cmd_request - A request to the DAMON callback. - * @cmd: The command that needs to be handled by the callback. - * @kdamond: The kobject wrapper that associated to the kdamond thread. - * - * This structure represents a sysfs command request that need to access s= ome - * DAMON context-internal data. Because DAMON context-internal data can be - * safely accessed from DAMON callbacks without additional synchronization= , the - * request will be handled by the DAMON callback. None-``NULL`` @kdamond = means - * the request is valid. - */ -struct damon_sysfs_cmd_request { - enum damon_sysfs_cmd cmd; - struct damon_sysfs_kdamond *kdamond; -}; - -/* Current DAMON callback request. Protected by damon_sysfs_lock. */ -static struct damon_sysfs_cmd_request damon_sysfs_cmd_request; - static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *att= r, char *buf) { @@ -1555,8 +1536,6 @@ static int damon_sysfs_turn_damon_on(struct damon_sys= fs_kdamond *kdamond) =20 if (damon_sysfs_kdamond_running(kdamond)) return -EBUSY; - if (damon_sysfs_cmd_request.kdamond =3D=3D kdamond) - return -EBUSY; /* TODO: support multiple contexts per kdamond */ if (kdamond->contexts->nr !=3D 1) return -EINVAL; @@ -1796,8 +1775,7 @@ static bool damon_sysfs_kdamonds_busy(struct damon_sy= sfs_kdamond **kdamonds, int i; =20 for (i =3D 0; i < nr_kdamonds; i++) { - if (damon_sysfs_kdamond_running(kdamonds[i]) || - damon_sysfs_cmd_request.kdamond =3D=3D kdamonds[i]) + if (damon_sysfs_kdamond_running(kdamonds[i])) return true; } =20 --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 67B5F26F462; Wed, 26 Feb 2025 06:37:04 +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=1740551824; cv=none; b=HcEbITuIeDoWPwt9bJYISnhmnC0wbhdV6rFkQIvPHQJsYKBEkoBymjFsOzIlr8hPiVa3WY5nOK/ZqXL+QlnJdPBDLKycOinCZQuCiGRfbvWBhZoOQgzlohUDmfAgbiwFFj6+S3PTlckEcqdCrYaeRoxhIytpiU5FGjjgt2A9/Gk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551824; c=relaxed/simple; bh=CtrMG3b7XVPdT3oTv/pTE3ihT4fR44kaP9KWdR8X7yY=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=fv6QFyrN/yFmbJUdcbGoJlRkz2jvoauVJqSdZ1G1XOGuAONosRsZa2IziQGorHM2+BFwAeSdmHG+2tzFvsZ7YJIKeeTCzXcahwAvT5BVdOxB1hXZwyB3+vTsmhH04zgxAInUeQliCSQ+F5eOVS8BtBFG7mlQk0LB+pQo2qigsXk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Rgk7xIYf; 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="Rgk7xIYf" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B6576C4CEEC; Wed, 26 Feb 2025 06:37:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551823; bh=CtrMG3b7XVPdT3oTv/pTE3ihT4fR44kaP9KWdR8X7yY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Rgk7xIYf3uct/Bru8Ihtd41lN4L529TO1m3KX1Dc8PXuXuthMn4rHZrRsk/mmkrnK Apxx/MqDzsD8GMC1087yex2BQnHxNoWJ+CyVuVR24lv2CO89Xusu2gCF3x+XsQdBRt 5XRq7mSJ3gZHpjRAJDgs71Frh6f0C4UH+rEgIebK4gEzfYdsiujh8LgrbGSayJm14v 8XKrOppXa45/2KvwpVC3rjn6marRIl5Di23tF9Kcp3hEZaeMP+Q+AH9YHZCJxgF9uR SHm6TU42cy3/Do4NvwpVF3b4YZF2Ugvsty/3yxwagOLGXHKQBPOQByXTGSyx4RN8Js wH2Vb89PCJhwQ== 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/13] mm/damon/sysfs-schemes: remove obsolete comment for damon_sysfs_schemes_clear_regions() Date: Tue, 25 Feb 2025 22:36:46 -0800 Message-Id: <20250226063651.513178-9-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 comment on damon_sysfs_schemes_clear_regions() function is obsolete, since it has updated to directly called from DAMON sysfs interface code. Remove the outdated comment. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 1 - 1 file changed, 1 deletion(-) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index ed834622df2a..d50f37ef4eb8 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -2341,7 +2341,6 @@ void damos_sysfs_populate_region_dir(struct damon_sys= fs_schemes *sysfs_schemes, } } =20 -/* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */ int damon_sysfs_schemes_clear_regions( struct damon_sysfs_schemes *sysfs_schemes) { --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 3182F26FA6B; Wed, 26 Feb 2025 06:37:05 +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=1740551825; cv=none; b=UcXiQMSsMbsFGXokB5ydXrUAdxPzlUpGN0wMQpH8tMewQ5U60lFyplBbX/PqaAHFHplZfC7wOzQvIfFcA8JeGCFwhT2qkM/TQW8RGLLjPnf7BY9u7jqhz8En9F988F+Go73DHRfNPdiKn8BM9dWZXVlhs0XsIbFomnLW8ABz19I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551825; c=relaxed/simple; bh=7J5ghi8H2WMjQQb1EvkfdSEY5M+51vnK26msM4ePujs=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=kiNT1oH/T4usFTagJsVKycHR/IOTpyw6WTlMnuxBRNmR1CZYFtOx4vIkCOBxc5jTCbOlP1eQo41lS0arZ/rtU3MlxJwFQVRfoZGZZ9cnw1xLe0h4ocy5dVM8y1w/Qo+sRt3B5rIWWGKwFgwpDVgarPRgT+aUYZP3+ecoewgTgMQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=MK4TDoVk; 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="MK4TDoVk" Received: by smtp.kernel.org (Postfix) with ESMTPSA id DD050C4CEEF; Wed, 26 Feb 2025 06:37:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551825; bh=7J5ghi8H2WMjQQb1EvkfdSEY5M+51vnK26msM4ePujs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=MK4TDoVkFXgj08qkJ+EcQXH+mw3NjLfnViyo0n3e55anSepeTY5jXsyN7Yt5mkqxV Lulnr/k/dX1l+iDioETho9Vd/iKLfxVPHn2tQEzbbbwJrdKMR6gNJs8nBLXVw8xSUz YPbvl7K0LN+3bPsbgZjXPdB5R0g+QcqPj5cxEPJteD/+HCZDOha6Wm+W5Ob7gXHQvZ LoZbADvdbvVZ0Rx1FwPCGaQsb0JC3ykTliyJA3LCvbxDHkF6R3/ctpcvkmzPLTQ/tK WHARxzqIRfK2FN06WamKGPZYWdgzffwMQ0MFOfdZDm6KjryghaYUT4LtsfGA1Y2aGO OI7eQC+5MP2rw== 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/13] mm/damon: remove damon_callback->private Date: Tue, 25 Feb 2025 22:36:47 -0800 Message-Id: <20250226063651.513178-10-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 field was added to let users keep their personal data to use inside of the callbacks. However, no one is actively using that now. Remove it. Signed-off-by: SeongJae Park --- include/linux/damon.h | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 636dcdc49b22..2b783c91cbb5 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -604,12 +604,10 @@ struct damon_operations { * @after_aggregation: Called after each aggregation. * @before_damos_apply: Called before applying DAMOS action. * @before_terminate: Called before terminating the monitoring. - * @private: User private data. * * The monitoring thread (&damon_ctx.kdamond) calls @before_start and * @before_terminate just before starting and finishing the monitoring, - * respectively. Therefore, those are good places for installing and clea= ning - * @private. + * respectively. * * The monitoring thread calls @after_wmarks_check after each DAMON-based * operation schemes' watermarks check. If users need to make changes to = the @@ -625,8 +623,6 @@ struct damon_operations { * If any callback returns non-zero, monitoring stops. */ struct damon_callback { - void *private; - int (*before_start)(struct damon_ctx *context); int (*after_wmarks_check)(struct damon_ctx *context); int (*after_sampling)(struct damon_ctx *context); --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 A442B271260; Wed, 26 Feb 2025 06:37:06 +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=1740551827; cv=none; b=uhyc/+okMwF2HNkQnXlS55U3n3LBLftjyxKMSev11BAvdCD37aq6bsS/RSVN70bEEXoBi7DCTKxBNQb3FroydgoCF6jEn0xpIcVPQ9U8bdNILQpz4QuDtPCWrmol6FuW2CcKQXCPVTUQ6RQPAzXLFCyzGdq0BFED//cc7kHATgQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551827; c=relaxed/simple; bh=e9BbdG+2vB4mTDRNMra/h/Oi4AJ4RbVhMKgF5wEM9pw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=IpvoInswMcYRIuaXLcebljHZXNQ9Gqf29Uxyn76TajvIhtI386pRIAWC53kjGnu1MqOWXYtYFHrw0duvxJd6TUQLie2/UStvRz50UR6EQnIB0Q9kSP6AZyBUoBjTqHxrBDt/Yu5GbESR9m5vSMZRl4UuijoCY2NLiZGb0RE3jVI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Qo/zDMIb; 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="Qo/zDMIb" Received: by smtp.kernel.org (Postfix) with ESMTPSA id F3D24C4AF0D; Wed, 26 Feb 2025 06:37:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551826; bh=e9BbdG+2vB4mTDRNMra/h/Oi4AJ4RbVhMKgF5wEM9pw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Qo/zDMIbXIg4iDVJoez5QmSFrcvso/zTS3AF0lBT5xEKV2so/jqAzecIE/MA1ci1d 8bJb/oeaUeW3UiowG/ACpPzXs+xbCwGERjCC8K12Wb5Yjrh6aHbiosCR3ftS36DTGz ylF/G3Mc532XIVh45Jeoc1Pa5aX88EZZGRQi6YELDM+8AzhT38Pu7TOcS0V2yBZtXW MhCiqCSnls5757YCrjBjTAIWH5o944ZHS/9jHu2fPjSQPpYOaAknFb79Blcc2QtASs RE44cR4n5JTU52dRgQbINPnxtCHGXPdV7oqysRLLjtMUTUcnnHsy9DqCzeOko4MaVC npq+r7YNR8bdA== 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/13] mm/damon: remove ->before_start of damon_callback Date: Tue, 25 Feb 2025 22:36:48 -0800 Message-Id: <20250226063651.513178-11-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 pointer field was added to be used as a place to do some initialization works just before DAMON starts working. However, nobody is using it now. Remove it. Signed-off-by: SeongJae Park --- include/linux/damon.h | 7 ++----- mm/damon/core.c | 2 -- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 2b783c91cbb5..11cd916b41fb 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -598,16 +598,14 @@ struct damon_operations { /** * struct damon_callback - Monitoring events notification callbacks. * - * @before_start: Called before starting the monitoring. * @after_wmarks_check: Called after each schemes' watermarks check. * @after_sampling: Called after each sampling. * @after_aggregation: Called after each aggregation. * @before_damos_apply: Called before applying DAMOS action. * @before_terminate: Called before terminating the monitoring. * - * The monitoring thread (&damon_ctx.kdamond) calls @before_start and - * @before_terminate just before starting and finishing the monitoring, - * respectively. + * 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 @@ -623,7 +621,6 @@ struct damon_operations { * If any callback returns non-zero, monitoring stops. */ struct damon_callback { - int (*before_start)(struct damon_ctx *context); int (*after_wmarks_check)(struct damon_ctx *context); int (*after_sampling)(struct damon_ctx *context); int (*after_aggregation)(struct damon_ctx *context); diff --git a/mm/damon/core.c b/mm/damon/core.c index 5b807caaec95..8efb249be855 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -2399,8 +2399,6 @@ static int kdamond_fn(void *data) =20 if (ctx->ops.init) ctx->ops.init(ctx); - if (ctx->callback.before_start && ctx->callback.before_start(ctx)) - goto done; ctx->regions_score_histogram =3D kmalloc_array(DAMOS_MAX_SCORE + 1, sizeof(*ctx->regions_score_histogram), GFP_KERNEL); if (!ctx->regions_score_histogram) --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 A445A271261; Wed, 26 Feb 2025 06:37:07 +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=1740551827; cv=none; b=FbpeW9nNGoTRe1w7N5N+TbFLiiAQtKrt4gUo4mocEnF12foMVkSGg3vyQPRSh2dd2lgAynDH/75+l6beRV9x40skpGKws760I1q5rz2oR7zSwGJiFFAWNeu/Yh4dn2nKtOG7ea43pTAasdYmbygPFU52iHNFwqtY2RhdpI1fWBc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551827; c=relaxed/simple; bh=PfFmM0ne7oeiliHHlhMvk+NOJkvWZ9fZ49v2P+Pn3V8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=qX8Sd/YpkRN3WF1x46DOuMTd42PpM6osPLG2P5VmHy197/13SmET8qWv4384u1gtPTIJIy3ycbv1AKU5c6WEPU8Mm+wlSZ5Q6rxvhf/vZMm4kOZeq0zcgdEJQ0tSDlMsL3anWhgD74GH3/xMv6qfcw4/QDlhRzqygAhzUcyyM2I= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=s+hMAQS9; 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="s+hMAQS9" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1517EC4CEE2; Wed, 26 Feb 2025 06:37:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551827; bh=PfFmM0ne7oeiliHHlhMvk+NOJkvWZ9fZ49v2P+Pn3V8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=s+hMAQS9IZUUNzjcxBCFzvAu6e86w60J/OsSVl7SoXFMus4d9TQBOdA38tv76FXlk kw4INrISe/ou+9pU8qcv+As2O2REveghPG5mSAeSfhWK/XEBcT0GOfP41fI9bvGI// 0vleAx8Tzorcq/SKPmmTDV73koXV1J64xp9SscUbgZnF3SEeE8DyIPfrbe58dVmfHK tPq7bxuvwuPcFGbCp0Vx7nzHO2i/PLFG3jekRQBzPT/2ZyATYY/uwYiBhO8cULjONS vnM+w+IIDAQADnGOeVdKin+e3vO+nf8/h4sWAsmLsJblwz9RC+x0Gv3wpX8dIGQNaL rMtg4tSW/IJEQ== 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/13] mm/damon: remove damon_callback->after_sampling Date: Tue, 25 Feb 2025 22:36:49 -0800 Message-Id: <20250226063651.513178-12-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 callback was used by DAMON sysfs interface for reading DAMON internal data. But it is no more being used, and damon_call() can do similar works in a better way. Remove it. Signed-off-by: SeongJae Park --- include/linux/damon.h | 11 ++++------- mm/damon/core.c | 3 --- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 11cd916b41fb..c9abacf16d88 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -599,7 +599,6 @@ struct damon_operations { * struct damon_callback - Monitoring events notification callbacks. * * @after_wmarks_check: Called after each schemes' watermarks check. - * @after_sampling: Called after each sampling. * @after_aggregation: Called after each aggregation. * @before_damos_apply: Called before applying DAMOS action. * @before_terminate: Called before terminating the monitoring. @@ -612,17 +611,15 @@ struct damon_operations { * 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_sampling and @after_aggregation for = each - * of the sampling intervals and aggregation intervals, respectively. - * Therefore, users can safely access the monitoring results without addit= ional - * protection. For the reason, users are recommended to use these callbac= k for - * the accesses to the results. + * 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_sampling)(struct damon_ctx *context); int (*after_aggregation)(struct damon_ctx *context); int (*before_damos_apply)(struct damon_ctx *context, struct damon_target *target, diff --git a/mm/damon/core.c b/mm/damon/core.c index 8efb249be855..14e4122464a1 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -2423,9 +2423,6 @@ static int kdamond_fn(void *data) =20 if (ctx->ops.prepare_access_checks) ctx->ops.prepare_access_checks(ctx); - if (ctx->callback.after_sampling && - ctx->callback.after_sampling(ctx)) - break; =20 kdamond_usleep(sample_interval); ctx->passed_sample_intervals++; --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 6E274271282; Wed, 26 Feb 2025 06:37:08 +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=1740551828; cv=none; b=BZrRC1AXhAQCL4qG9KrzFiC597ZFmv/U9dJAEZ5ovSxcy3gmZkACW4doueGm/bdrVyIlvGS8IbOFIjnp2RAi08km+MTKyIcP9HBh+8tKl9mTRZc+A4iXgPIeHTXGZ5CWGObVwX3pkNaj+UnE9n0OG5ZRuJl2rBgtP2aOakjKZ3w= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551828; c=relaxed/simple; bh=0JELExNnHyeZjbeP5ZoxjubmzZrKIkH6IvMexJsNwbs=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=gyOiPsCVPWDnIq73RUN4X9lE2L34k84Z4jvBLg6w4qb750QZrb0Ycvkb02/VanQZmru2AWelssM3Ko8vQay/ci7etsb/x7iWPEnHKm4rXniCuh/SjrY6FoExTb/T9Db1KIV4GPAk7ZNMd12QgUlQM2k78WXTtrGEAg0Bj1JyR3g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=pG7uDphF; 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="pG7uDphF" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 29484C4CED6; Wed, 26 Feb 2025 06:37:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551828; bh=0JELExNnHyeZjbeP5ZoxjubmzZrKIkH6IvMexJsNwbs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pG7uDphFQhxUNLwpk3/l2bizP+t02fv/8iSWqdIx3jv5WH+6lNDCOI7SFur64oCT8 J74ndxyjuJMt7aHCM4EyDV3q0OwVWBneiXZQkCfslrPhaqeVCkFu/1WAMRxkMiHOOM SQChpQWk/q96/Fu+jSgqmBINCXbmOKuQYvAUM2fWwirYqQmZY5cJWRpAa7sDK4Ios7 2RIt1aw29LGdueGRMwQRPSuo741vZsF8C1QCw3tJbhzVA7U2n+ACJNOgSTd7V8Ctl+ q9YQpLx8CUfcQ2+O2B4lMv88KXkZkBiXwvFz0OieBicaTO7zO0JYI+vT8MxAMsIi/P nO/Kos09Tn5lQ== 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/13] mm/damon: remove damon_callback->before_damos_apply Date: Tue, 25 Feb 2025 22:36:50 -0800 Message-Id: <20250226063651.513178-13-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 hook was introduced to let DAMON kernel API users access DAMOS schemes-eligible regions in a safe way. Now it is no more used by anyone, and the functionality is provided in a better way by damos_walk(). Remove it. Signed-off-by: SeongJae Park --- include/linux/damon.h | 5 ----- mm/damon/core.c | 13 ++++--------- 2 files changed, 4 insertions(+), 14 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index c9abacf16d88..2808ea07e1cc 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -600,7 +600,6 @@ struct damon_operations { * * @after_wmarks_check: Called after each schemes' watermarks check. * @after_aggregation: Called after each aggregation. - * @before_damos_apply: Called before applying DAMOS action. * @before_terminate: Called before terminating the monitoring. * * The monitoring thread (&damon_ctx.kdamond) calls @before_terminate just @@ -621,10 +620,6 @@ struct damon_operations { struct damon_callback { int (*after_wmarks_check)(struct damon_ctx *context); int (*after_aggregation)(struct damon_ctx *context); - int (*before_damos_apply)(struct damon_ctx *context, - struct damon_target *target, - struct damon_region *region, - struct damos *scheme); void (*before_terminate)(struct damon_ctx *context); }; =20 diff --git a/mm/damon/core.c b/mm/damon/core.c index 14e4122464a1..22f90666fe16 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1723,7 +1723,6 @@ static void damos_apply_scheme(struct damon_ctx *c, s= truct damon_target *t, struct timespec64 begin, end; unsigned long sz_applied =3D 0; unsigned long sz_ops_filter_passed =3D 0; - int err =3D 0; /* * We plan to support multiple context per kdamond, as DAMON sysfs * implies with 'nr_contexts' file. Nevertheless, only single context @@ -1763,14 +1762,10 @@ static void damos_apply_scheme(struct damon_ctx *c,= struct damon_target *t, if (damos_filter_out(c, t, r, s)) return; ktime_get_coarse_ts64(&begin); - if (c->callback.before_damos_apply) - err =3D c->callback.before_damos_apply(c, t, r, s); - if (!err) { - trace_damos_before_apply(cidx, sidx, tidx, r, - damon_nr_regions(t), do_trace); - sz_applied =3D c->ops.apply_scheme(c, t, r, s, - &sz_ops_filter_passed); - } + trace_damos_before_apply(cidx, sidx, tidx, r, + damon_nr_regions(t), do_trace); + sz_applied =3D c->ops.apply_scheme(c, t, r, s, + &sz_ops_filter_passed); damos_walk_call_walk(c, t, r, s, sz_ops_filter_passed); ktime_get_coarse_ts64(&end); quota->total_charged_ns +=3D timespec64_to_ns(&end) - --=20 2.39.5 From nobody Thu Dec 18 19:04:26 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 8295C271816; Wed, 26 Feb 2025 06:37:09 +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=1740551829; cv=none; b=oOokVmsrldH42XI1vZYfy3j3x9MFBWFbRkWnJtqEm9FwW48GOugCzessHFQX705tagpS0kT9fjHaaYiv/wLBJ4VpXdDbCDNfpu44ln+W8eVImKsIR2ShNfjqa8Z1C31d6BG3/u+ljeGfTwzFDFufEHoYaF7hIEnu5B/3qkqXnTI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1740551829; c=relaxed/simple; bh=tR7XrAvAqL9tgp0wezUMza5484QErgFfXZf5Rw+Zt88=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=XMqtNqsMSoXcSFOaLPK5hIeOWNH1dd7ZGIb4AwUsHG4KseVzn0usiDIGVunHNWnDOt1vGUh+P+0eWtQW726wGgn7H4WlSxIZUPc9ELG4aJROxTpYtKNfQJtRsleuRCh6s/vrdbxaYk4kqXUmi6Hz/fBRh5iXMsV2S3VyYq78uMc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=NkC3trE4; 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="NkC3trE4" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3C407C4CEE2; Wed, 26 Feb 2025 06:37:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1740551829; bh=tR7XrAvAqL9tgp0wezUMza5484QErgFfXZf5Rw+Zt88=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NkC3trE48rYxCFFDy66tykiWPjoMbZBsb/HBH52ZAkninFLJ0O7MByribphGwbMXz KLyVk3wtX2t/4Y0G1+C3lCFJJtVUbu69r17GBdwwItO1VXWf3YcRODWw7dXkn0AuAE phXZP9tRtyKsqQZ0MbG+9Qfyf7IP+CPFby3/BLT18JYgoBHCuZks1Cw+zk79o+PzpW uSl6vMNooIM3pr8B6TzmOWAUwvxvYIavDbJQouMkMxLaR7GHAXpqTFmi/H1u6KuAFm zTkjponpdS4dehkyARKICzrcYji2/gmUJN+SIFQgkB1I12AaeUXdMzH/18G3MFPeHx 9yDRcptpIKLMg== 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/13] mm/damon: remove damon_operations->reset_aggregated Date: Tue, 25 Feb 2025 22:36:51 -0800 Message-Id: <20250226063651.513178-14-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250226063651.513178-1-sj@kernel.org> References: <20250226063651.513178-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 operations layer hook was introduced to let operations set do any aggregation data reset if needed. But it is not really be used now. Remove it. Signed-off-by: SeongJae Park --- include/linux/damon.h | 7 +------ mm/damon/core.c | 2 -- mm/damon/paddr.c | 1 - mm/damon/vaddr.c | 1 - 4 files changed, 1 insertion(+), 10 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 2808ea07e1cc..957c7f3af80f 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -537,7 +537,6 @@ enum damon_ops_id { * @update: Update operations-related data structures. * @prepare_access_checks: Prepare next access check of target regions. * @check_accesses: Check the accesses to target regions. - * @reset_aggregated: Reset aggregated accesses monitoring results. * @get_scheme_score: Get the score of a region for a scheme. * @apply_scheme: Apply a DAMON-based operation scheme. * @target_valid: Determine if the target is valid. @@ -549,8 +548,7 @@ enum damon_ops_id { * (&damon_ctx.kdamond) calls @init and @prepare_access_checks before star= ting * the monitoring, @update after each &damon_attrs.ops_update_interval, and * @check_accesses, @target_valid and @prepare_access_checks after each - * &damon_attrs.sample_interval. Finally, @reset_aggregated is called aft= er - * each &damon_attrs.aggr_interval. + * &damon_attrs.sample_interval. * * Each &struct damon_operations instance having valid @id can be register= ed * via damon_register_ops() and selected by damon_select_ops() later. @@ -565,8 +563,6 @@ enum damon_ops_id { * last preparation and update the number of observed accesses of each reg= ion. * It should also return max number of observed accesses that made as a re= sult * of its update. The value will be used for regions adjustment threshold. - * @reset_aggregated should reset the access monitoring results that aggre= gated - * by @check_accesses. * @get_scheme_score should return the priority score of a region for a sc= heme * as an integer in [0, &DAMOS_MAX_SCORE]. * @apply_scheme is called from @kdamond when a region for user provided @@ -584,7 +580,6 @@ struct damon_operations { void (*update)(struct damon_ctx *context); void (*prepare_access_checks)(struct damon_ctx *context); unsigned int (*check_accesses)(struct damon_ctx *context); - void (*reset_aggregated)(struct damon_ctx *context); int (*get_scheme_score)(struct damon_ctx *context, struct damon_target *t, struct damon_region *r, struct damos *scheme); diff --git a/mm/damon/core.c b/mm/damon/core.c index 22f90666fe16..6f821a579257 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -2463,8 +2463,6 @@ static int kdamond_fn(void *data) =20 kdamond_reset_aggregated(ctx); kdamond_split_regions(ctx); - if (ctx->ops.reset_aggregated) - ctx->ops.reset_aggregated(ctx); } =20 if (ctx->passed_sample_intervals >=3D next_ops_update_sis) { diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c index fee66a3cc82b..e5b532340102 100644 --- a/mm/damon/paddr.c +++ b/mm/damon/paddr.c @@ -618,7 +618,6 @@ static int __init damon_pa_initcall(void) .update =3D NULL, .prepare_access_checks =3D damon_pa_prepare_access_checks, .check_accesses =3D damon_pa_check_accesses, - .reset_aggregated =3D NULL, .target_valid =3D NULL, .cleanup =3D NULL, .apply_scheme =3D damon_pa_apply_scheme, diff --git a/mm/damon/vaddr.c b/mm/damon/vaddr.c index a6174f725bd7..e6d99106a7f9 100644 --- a/mm/damon/vaddr.c +++ b/mm/damon/vaddr.c @@ -710,7 +710,6 @@ static int __init damon_va_initcall(void) .update =3D damon_va_update, .prepare_access_checks =3D damon_va_prepare_access_checks, .check_accesses =3D damon_va_check_accesses, - .reset_aggregated =3D NULL, .target_valid =3D damon_va_target_valid, .cleanup =3D NULL, .apply_scheme =3D damon_va_apply_scheme, --=20 2.39.5