From nobody Thu Dec 18 08:36:03 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 B313B15E5BC; Tue, 18 Jun 2024 18:18:17 +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=1718734697; cv=none; b=cnWBeuHxjZmkLOZ1FcNvoaKer5g0loQx5X3U6mqSA9+3LJEEBZnkt+Unwfd6jRHQ4xl6IQdgHN3xwVUBn19DXFb2lc24W71hisv7kFmVVAQDhC1he3NJZYl4i1gSsWSlDvUBhVzYeCFWCzqTNE7GnEF52JGMnm1npU4AoQ1IMa0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734697; c=relaxed/simple; bh=7hRdxjHOSIuwrdZCOKzvtYTSDa0l/gnw+9kuPa/0bZU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=EpKgAAPH73E5CPKCl4qkgBCuSo9rs9FleChmJJcx6xjfeJxlr4hlrHZbgTzRPwIugEy8UdqoDlpvlGtCTiFjM9UDimdeY422mD1WzN2QTV0P4Z6bssVC2Xzkpa9l0bfORYrWDOQNYxMGGzvG0nLMKegZ1Vjmbkf1XRN7QORbg58= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=rkohSxYo; 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="rkohSxYo" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D542BC4AF48; Tue, 18 Jun 2024 18:18:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734697; bh=7hRdxjHOSIuwrdZCOKzvtYTSDa0l/gnw+9kuPa/0bZU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=rkohSxYoVet+2VnInROCLHYvbmT/IcPl8P0ZgsPJ3X5uqKAAALvILpaMNTgGw2HL+ pA+wVpDtiRRJCmbVDvwOy8kIDC3Ybx/M7EllPDu5PiuRpxWxCTL1Q0o//xVXjeXAGc PyxuRULZuqMY6uvSC9/eijvV1adFiBJ7alMLDXzn7OXN4Zl0nxghlYw9X1AKmLb/8K rMXmH7ZDhYb7tpjfcBqUr0HQacYPAy6ttPJ76I2ENZCQwJaXxJVzD1oE9uKvrub2Wt 6v82xCBHrO/7cykYCj+gtLR88OKpLBk1gH6iTcPcMlSflBWhDl/2OVHuce76tLx/hu h+yFlMoGobSuQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 01/12] mm/damon/core: implement DAMOS quota goals online commit function Date: Tue, 18 Jun 2024 11:17:58 -0700 Message-Id: <20240618181809.82078-2-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 functions for supporting online DAMOS quota goals parameters update. The function receives two DAMOS quota structs. One is the struct that currently being used by a kdamond and therefore to be updated. The other one contains the parameters to be applied to the first one. The function applies the new parameters to the destination struct while keeping/updating the internal status. The function should be called from parameters-update safe place, like DAMON callbacks. Signed-off-by: SeongJae Park --- include/linux/damon.h | 1 + mm/damon/core.c | 59 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 3d62d98d6359..ce12c9f1b4e4 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -742,6 +742,7 @@ struct damos *damon_new_scheme(struct damos_access_patt= ern *pattern, int target_nid); void damon_add_scheme(struct damon_ctx *ctx, struct damos *s); void damon_destroy_scheme(struct damos *s); +int damos_commit_quota_goals(struct damos_quota *dst, struct damos_quota *= src); =20 struct damon_target *damon_new_target(void); void damon_add_target(struct damon_ctx *ctx, struct damon_target *t); diff --git a/mm/damon/core.c b/mm/damon/core.c index c0ec5be4f56e..b538a31fbd83 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -666,6 +666,65 @@ void damon_set_schemes(struct damon_ctx *ctx, struct d= amos **schemes, damon_add_scheme(ctx, schemes[i]); } =20 +static struct damos_quota_goal *damos_nth_quota_goal( + int n, struct damos_quota *q) +{ + struct damos_quota_goal *goal; + int i =3D 0; + + damos_for_each_quota_goal(goal, q) { + if (i++ =3D=3D n) + return goal; + } + return NULL; +} + +static void damos_commit_quota_goal( + struct damos_quota_goal *dst, struct damos_quota_goal *src) +{ + dst->metric =3D src->metric; + dst->target_value =3D src->target_value; + if (dst->metric =3D=3D DAMOS_QUOTA_USER_INPUT) + dst->current_value =3D src->current_value; + /* keep last_psi_total as is, since it will be updated in next cycle */ +} + +/** + * damos_commit_quota_goals() - Commit DAMOS quota goals to another quota. + * @dst: The commit destination DAMOS quota. + * @src: The commit source DAMOS quota. + * + * Copies user-specified parameters for quota goals from @src to @dst. Us= ers + * should use this function for quota goals-level parameters update of run= ning + * DAMON contexts, instead of manual in-place updates. + * + * This function should be called from parameters-update safe context, like + * DAMON callbacks. + */ +int damos_commit_quota_goals(struct damos_quota *dst, struct damos_quota *= src) +{ + struct damos_quota_goal *dst_goal, *next, *src_goal, *new_goal; + int i =3D 0, j =3D 0; + + damos_for_each_quota_goal_safe(dst_goal, next, dst) { + src_goal =3D damos_nth_quota_goal(i++, src); + if (src_goal) + damos_commit_quota_goal(dst_goal, src_goal); + else + damos_destroy_quota_goal(dst_goal); + } + damos_for_each_quota_goal_safe(src_goal, next, src) { + if (j++ < i) + continue; + new_goal =3D damos_new_quota_goal( + src_goal->metric, src_goal->target_value); + if (!new_goal) + return -ENOMEM; + damos_add_quota_goal(dst, new_goal); + } + return 0; +} + /** * damon_nr_running_ctxs() - Return number of currently running contexts. */ --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 1A83315E5CC; Tue, 18 Jun 2024 18:18:18 +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=1718734698; cv=none; b=kxPOmNCwfzVwT1FitCgOA1PCVlufFEYk6IUSxAnt2/zYKfbCB07WkZTN6pvgP8MTXRvRYP1XgOadSrCe5hz9Z78kh153ASYH/51apwQyLO8smf1eG8i2xYIBKV05zMDXxAU7Zc9X9JobA5fB4tUzLSJIZ8t4HfLp5EV9SCvxfGg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734698; c=relaxed/simple; bh=q0VgTmMSaytJbmDQpkmd078K1WOntRHHU6KIbNuTpyw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=aHRuB+AQE9nK0yaEGl0PfPRy8qS48/zTGrU7i89Hxp+ZlfofCSyTDqe+5SIGRAEZTKjHL4EHuB4PxNtvD/pr75zPpgTCZsLmqOTRF+VDoNX+3hujKoS5e1qLSUw3a0KQjmgvU42W5T67GLxSolB2/9nqHraz+o/z+zQqO/ofdOQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CkmS4eEK; 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="CkmS4eEK" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8474BC4AF4D; Tue, 18 Jun 2024 18:18:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734698; bh=q0VgTmMSaytJbmDQpkmd078K1WOntRHHU6KIbNuTpyw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=CkmS4eEK+RGfSEGakhprTqdICLAAHvNYxJWUiXjUbGGUa5c6g2ophuL2Wu8Lj0a1C cI9uAFIlIZxeUzwJuzK504OugxjO/3Ua7SB5qS1eWPxpLYzM+b31bBJlf48dwAJUno /Y5k6Mf1WepHXE6coENrRieznOFyab+/mDECE0L80avhvug04yb3GIYBOLReoLH64A QJ8ex2EB7T5XB9Vk0xWSgyVRRuou818fpVCzffjhpE3ITKdfNS6sl6kdzkMpaoJgy3 3La4c8cUV4YbnnKB/FkY7lwXSo7AfKK8M3YucH1dnjULop/2RDwwZjnHy278NioxT2 +JswtLTRyuriw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 02/12] mm/damon/core: implement DAMON context commit function Date: Tue, 18 Jun 2024 11:17:59 -0700 Message-Id: <20240618181809.82078-3-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 functions for supporting online DAMON context level parameters update. The function receives two DAMON context structs. One is the struct that currently being used by a kdamond and therefore to be updated. The other one contains the parameters to be applied to the first one. The function applies the new parameters to the destination struct while keeping/updating the internal status and operation results. The function should be called from DAMON context-update-safe place, like DAMON callbacks. Signed-off-by: SeongJae Park --- include/linux/damon.h | 1 + mm/damon/core.c | 274 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 275 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index ce12c9f1b4e4..27c546bfc6d4 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -756,6 +756,7 @@ void damon_destroy_ctx(struct damon_ctx *ctx); int damon_set_attrs(struct damon_ctx *ctx, struct damon_attrs *attrs); void damon_set_schemes(struct damon_ctx *ctx, struct damos **schemes, ssize_t nr_schemes); +int damon_commit_ctx(struct damon_ctx *old_ctx, struct damon_ctx *new_ctx); int damon_nr_running_ctxs(void); bool damon_is_registered_ops(enum damon_ops_id id); int damon_register_ops(struct damon_operations *ops); diff --git a/mm/damon/core.c b/mm/damon/core.c index b538a31fbd83..f69250b68bcc 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -725,6 +725,280 @@ int damos_commit_quota_goals(struct damos_quota *dst,= struct damos_quota *src) return 0; } =20 +static int damos_commit_quota(struct damos_quota *dst, struct damos_quota = *src) +{ + int err; + + dst->reset_interval =3D src->reset_interval; + dst->ms =3D src->ms; + dst->sz =3D src->sz; + err =3D damos_commit_quota_goals(dst, src); + if (err) + return err; + dst->weight_sz =3D src->weight_sz; + dst->weight_nr_accesses =3D src->weight_nr_accesses; + dst->weight_age =3D src->weight_age; + return 0; +} + +static struct damos_filter *damos_nth_filter(int n, struct damos *s) +{ + struct damos_filter *filter; + int i =3D 0; + + damos_for_each_filter(filter, s) { + if (i++ =3D=3D n) + return filter; + } + return NULL; +} + +static void damos_commit_filter_arg( + struct damos_filter *dst, struct damos_filter *src) +{ + switch (dst->type) { + case DAMOS_FILTER_TYPE_MEMCG: + dst->memcg_id =3D src->memcg_id; + break; + case DAMOS_FILTER_TYPE_ADDR: + dst->addr_range =3D src->addr_range; + break; + case DAMOS_FILTER_TYPE_TARGET: + dst->target_idx =3D src->target_idx; + break; + default: + break; + } +} + +static void damos_commit_filter( + struct damos_filter *dst, struct damos_filter *src) +{ + dst->type =3D src->type; + dst->matching =3D src->matching; + damos_commit_filter_arg(dst, src); +} + +static int damos_commit_filters(struct damos *dst, struct damos *src) +{ + struct damos_filter *dst_filter, *next, *src_filter, *new_filter; + int i =3D 0, j =3D 0; + + damos_for_each_filter_safe(dst_filter, next, dst) { + src_filter =3D damos_nth_filter(i++, src); + if (src_filter) + damos_commit_filter(dst_filter, src_filter); + else + damos_destroy_filter(dst_filter); + } + + damos_for_each_filter_safe(src_filter, next, src) { + if (j++ < i) + continue; + + new_filter =3D damos_new_filter( + src_filter->type, src_filter->matching); + if (!new_filter) + return -ENOMEM; + damos_commit_filter_arg(new_filter, src_filter); + damos_add_filter(dst, new_filter); + } + return 0; +} + +static struct damos *damon_nth_scheme(int n, struct damon_ctx *ctx) +{ + struct damos *s; + int i =3D 0; + + damon_for_each_scheme(s, ctx) { + if (i++ =3D=3D n) + return s; + } + return NULL; +} + +static int damos_commit(struct damos *dst, struct damos *src) +{ + int err; + + dst->pattern =3D src->pattern; + dst->action =3D src->action; + dst->apply_interval_us =3D src->apply_interval_us; + + err =3D damos_commit_quota(&dst->quota, &src->quota); + if (err) + return err; + + dst->wmarks =3D src->wmarks; + + err =3D damos_commit_filters(dst, src); + return err; +} + +static int damon_commit_schemes(struct damon_ctx *dst, struct damon_ctx *s= rc) +{ + struct damos *dst_scheme, *next, *src_scheme, *new_scheme; + int i =3D 0, j =3D 0, err; + + damon_for_each_scheme_safe(dst_scheme, next, dst) { + src_scheme =3D damon_nth_scheme(i++, src); + if (src_scheme) { + err =3D damos_commit(dst_scheme, src_scheme); + if (err) + return err; + } else { + damon_destroy_scheme(dst_scheme); + } + } + + damon_for_each_scheme_safe(src_scheme, next, src) { + if (j++ < i) + continue; + new_scheme =3D damon_new_scheme(&src_scheme->pattern, + src_scheme->action, + src_scheme->apply_interval_us, + &src_scheme->quota, &src_scheme->wmarks, + NUMA_NO_NODE); + if (!new_scheme) + return -ENOMEM; + damon_add_scheme(dst, new_scheme); + } + return 0; +} + +static struct damon_target *damon_nth_target(int n, struct damon_ctx *ctx) +{ + struct damon_target *t; + int i =3D 0; + + damon_for_each_target(t, ctx) { + if (i++ =3D=3D n) + return t; + } + return NULL; +} + +/* + * The caller should ensure the regions of @src are + * 1. valid (end >=3D src) and + * 2. sorted by starting address. + * + * If @src has no region, @dst keeps current regions. + */ +static int damon_commit_target_regions( + struct damon_target *dst, struct damon_target *src) +{ + struct damon_region *src_region; + struct damon_addr_range *ranges; + int i =3D 0, err; + + damon_for_each_region(src_region, src) + i++; + if (!i) + return 0; + + ranges =3D kmalloc_array(i, sizeof(*ranges), GFP_KERNEL | __GFP_NOWARN); + if (!ranges) + return -ENOMEM; + i =3D 0; + damon_for_each_region(src_region, src) + ranges[i++] =3D src_region->ar; + err =3D damon_set_regions(dst, ranges, i); + kfree(ranges); + return err; +} + +static int damon_commit_target( + struct damon_target *dst, bool dst_has_pid, + struct damon_target *src, bool src_has_pid) +{ + int err; + + err =3D damon_commit_target_regions(dst, src); + if (err) + return err; + if (dst_has_pid) + put_pid(dst->pid); + if (src_has_pid) + get_pid(src->pid); + dst->pid =3D src->pid; + return 0; +} + +static int damon_commit_targets( + struct damon_ctx *dst, struct damon_ctx *src) +{ + struct damon_target *dst_target, *next, *src_target, *new_target; + int i =3D 0, j =3D 0, err; + + damon_for_each_target_safe(dst_target, next, dst) { + src_target =3D damon_nth_target(i++, src); + if (src_target) { + err =3D damon_commit_target( + dst_target, damon_target_has_pid(dst), + src_target, damon_target_has_pid(src)); + if (err) + return err; + } else { + if (damon_target_has_pid(dst)) + put_pid(dst_target->pid); + damon_destroy_target(dst_target); + } + } + + damon_for_each_target_safe(src_target, next, src) { + if (j++ < i) + continue; + new_target =3D damon_new_target(); + if (!new_target) + return -ENOMEM; + err =3D damon_commit_target(new_target, false, + src_target, damon_target_has_pid(src)); + if (err) + return err; + } + return 0; +} + +/** + * damon_commit_ctx() - Commit parameters of a DAMON context to another. + * @dst: The commit destination DAMON context. + * @src: The commit source DAMON context. + * + * This function copies user-specified parameters from @src to @dst and up= date + * the internal status and results accordingly. Users should use this fun= ction + * for context-level parameters update of running context, instead of manu= al + * in-place updates. + * + * This function should be called from parameters-update safe context, like + * DAMON callbacks. + */ +int damon_commit_ctx(struct damon_ctx *dst, struct damon_ctx *src) +{ + int err; + + err =3D damon_commit_schemes(dst, src); + if (err) + return err; + err =3D damon_commit_targets(dst, src); + if (err) + return err; + /* + * schemes and targets should be updated first, since + * 1. damon_set_attrs() updates monitoring results of targets and + * next_apply_sis of schemes, and + * 2. ops update should be done after pid handling is done (target + * committing require putting pids). + */ + err =3D damon_set_attrs(dst, &src->attrs); + if (err) + return err; + dst->ops =3D src->ops; + + return 0; +} + /** * damon_nr_running_ctxs() - Return number of currently running contexts. */ --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 B6A8115ECD1; Tue, 18 Jun 2024 18:18:18 +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=1718734698; cv=none; b=Zv9M8lTRjfT5vBfr2eXEMuYgAhfvb/1rOUMGBdKb2YgA9FrVa0mqBWmcME3j2x2A2G70PihF6tdi69eWGrqRJRPRT1/gHelY9OS9GMzoJ/F2406RVhejMITPU6XBrFSxVMFzgqpbOEUcZabwLXmABiV2xwHLDYcfMNI+9mBLClc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734698; c=relaxed/simple; bh=iHi9F2LJwfRH7bQXO7MbPtxBZ9hQhqVO/mLP8mATsq0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=W1mMwAe/U2SVON/hEnLFracSqi7KU+rjwgsHrYHXIWoeconm0ftTuoOtPuQnXOcKVeONL1uKtPLHadEBIxGT9RnRZU7zJlFb+Ghm2yUXx2KMhdjU6BOuGuH20ps9dfJl4U5hFHCKJw7q5GgiCQ5/vDfu8HxWniyofgsV46uekDw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=aYOkhPAI; 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="aYOkhPAI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 31A89C4AF49; Tue, 18 Jun 2024 18:18:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734698; bh=iHi9F2LJwfRH7bQXO7MbPtxBZ9hQhqVO/mLP8mATsq0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=aYOkhPAIdBUFDJZuuOt/U3pLKRvSSX6WXYHpo+fIAycQr3OgTttGwtX284KPO+qPd hPVHPYRAtFozTVYqtkOhu2yi1QuxXf0q1fDgbkyNr9zb6YBKJdtc8u3LenvjZxZjhS ikrcX0GVUDeS6WeqszBOgeAe7eDR1c7gJhPc3iHVs8eDGvnMC0s8naVmIA6dH5+QGb ijPhu813BtP4jEPR18XhavPEc9pJ4IgbSuIqyrQRE/2Q5cv/Na8SAX8D4J9Hqo8ams YfHlm52WY2W/hyEXKQLccxzAtQlY4VNpvFvletIxoA/vcD4xKg3jgcWp8zqTeYdfTV BMtuWx94rR9Fg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 03/12] mm/damon/sysfs: use damon_commit_ctx() Date: Tue, 18 Jun 2024 11:18:00 -0700 Message-Id: <20240618181809.82078-4-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 manually manipulates DAMON context structs for online parameters update. Since the struct contains not only input parameters but also internal status and operation results, it is not that simple. Indeed, we found and fixed a few bugs in the code. Now DAMON core layer provides a function for the usage, namely damon_commit_ctx(). Replace the manual manipulation logic with the function. The core layer function could have its own bugs, but this change removes a source of bugs. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 6fee383bc0c5..0f9fe18beb40 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1345,6 +1345,9 @@ static int damon_sysfs_apply_inputs(struct damon_ctx = *ctx, return damon_sysfs_set_schemes(ctx, sys_ctx->schemes); } =20 +static struct damon_ctx *damon_sysfs_build_ctx( + struct damon_sysfs_context *sys_ctx); + /* * damon_sysfs_commit_input() - Commit user inputs to a running kdamond. * @kdamond: The kobject wrapper for the associated kdamond. @@ -1353,14 +1356,22 @@ static int damon_sysfs_apply_inputs(struct damon_ct= x *ctx, */ static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond) { + struct damon_ctx *param_ctx; + int err; + if (!damon_sysfs_kdamond_running(kdamond)) return -EINVAL; /* TODO: Support multiple contexts per kdamond */ if (kdamond->contexts->nr !=3D 1) return -EINVAL; =20 - return damon_sysfs_apply_inputs(kdamond->damon_ctx, - kdamond->contexts->contexts_arr[0]); + param_ctx =3D damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); + if (IS_ERR(param_ctx)) + return PTR_ERR(param_ctx); + err =3D damon_commit_ctx(kdamond->damon_ctx, param_ctx); + damon_sysfs_destroy_targets(param_ctx); + damon_destroy_ctx(param_ctx); + return err; } =20 static int damon_sysfs_commit_schemes_quota_goals( --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 5A7BF15ECEE; Tue, 18 Jun 2024 18:18:19 +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=1718734699; cv=none; b=uzqgdQw5WnATth9R1gLLuU8nz2yZSYnBb8SR7FeajNB10fT88XqZ9YPVKK6BplCfGv4LCc9fvDsuexsSRGgxlS59O1glylgtTfgH7YcEVp8NJenqGQt6nJ/vzatoZRPcRZQpWumut998JE9DJBSIOZTdj32/G+G+d5E65vj+8CE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734699; c=relaxed/simple; bh=vyu4uJ3nrBS9zXRgwSeDU7byk5QTt4EqJtkm+FLnKWk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Cp3o7IfxtHws5LMuy1MroaVYYQWgWf7bD+hFt8YfjF3VSFvuKyipO+4yVlbE3P9+ikQ7dXmRHBMnoxSyyxT8uAGMC/trAu2Tz4SBKmuPEiU3MSd+DLSXSlDjiTj8Su0JGYJzI9B8L1DaXCQnYLZEYunOC7VrPCgZ1alkhyRJQFc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=GhpVrpYn; 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="GhpVrpYn" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C8129C3277B; Tue, 18 Jun 2024 18:18:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734699; bh=vyu4uJ3nrBS9zXRgwSeDU7byk5QTt4EqJtkm+FLnKWk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GhpVrpYn44Wb3cl7ZfbnbyU1jS+5Zjc/B6MgPWl7lT9sv8IsCZd5lgVxQh9JhVPUM ZimB/lpOIiJ1meXbMj8oWQcrGfHLkFYxdRr12LhUnjQadgFAwdX2mZb68RhZSx5JGF 6qgA2za6SHEY5hjYVT2mbYaccCOKIIMRycGSPbfr7Qiw/0zO/RoukbVLXIndDCNve9 9ItQOg4Jk/OKE25fqQMBHMwUcLO/u7gBX9XxdVCe/Lw2HxsiHDQ+tAwlGimU4O2xpp 9wsEmirmXF7I2SOILuIxxo5jJOvRz759lWRp9yuOcSebyBz6qchrzF4SPgFUj4WtR1 MEjxIArfqSJqg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 04/12] mm/damon/sysfs-schemes: use damos_commit_quota_goals() Date: Tue, 18 Jun 2024 11:18:01 -0700 Message-Id: <20240618181809.82078-5-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 manually manipulates the DAMOS quota structs for online quotal goals parameter update. Since the struct contains not only input parameters but also internal status and operation results, it is not that simple. Now DAMON core layer provides a function for the usage, namely damon_commit_quota_goals(). Replace the manual manipulation logic with the function. The core layer function could have its own bugs, but this change removes a source of bugs. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 66fccfa776d7..1bccf2619e11 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -1983,10 +1983,13 @@ int damos_sysfs_set_quota_scores(struct damon_sysfs= _schemes *sysfs_schemes, struct damon_ctx *ctx) { struct damos *scheme; + struct damos_quota quota =3D {}; int i =3D 0; =20 + INIT_LIST_HEAD("a.goals); damon_for_each_scheme(scheme, ctx) { struct damon_sysfs_scheme *sysfs_scheme; + struct damos_quota_goal *g, *g_next; int err; =20 /* user could have removed the scheme sysfs dir */ @@ -1995,9 +1998,16 @@ int damos_sysfs_set_quota_scores(struct damon_sysfs_= schemes *sysfs_schemes, =20 sysfs_scheme =3D sysfs_schemes->schemes_arr[i]; err =3D damos_sysfs_set_quota_score(sysfs_scheme->quotas->goals, - &scheme->quota); + "a); + if (err) { + damos_for_each_quota_goal_safe(g, g_next, "a) + damos_destroy_quota_goal(g); + return err; + } + err =3D damos_commit_quota_goals(&scheme->quota, "a); + damos_for_each_quota_goal_safe(g, g_next, "a) + damos_destroy_quota_goal(g); if (err) - /* kdamond will clean up schemes and terminated */ return err; i++; } --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 EAEAE15EFAF; Tue, 18 Jun 2024 18:18:19 +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=1718734700; cv=none; b=VYbeqzwwJef5SF1IWwnOW7Z31zSnOrX9VDe665/uIaf1Rt0H4ko4US0si2rOyZe5wCGuelWN+o9+goFx4dDerZ+uDJMlrcIEqDgZ2GK44d0V7giznP983RRhY0MVSK2GCdB8aCWX9Li6iQwbRy8uInA2cHyop8GfnCztqafBb/8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734700; c=relaxed/simple; bh=kQhv3CeO5+UCw9SJSn7ZxV5sAw44NEd/krZ6l962Oqk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=CjKbRwOsNXubLGc4cvzNDYiKfhE05XplQn7BXu68RlveeLOWznxtjTKd962V10uk+prkYp05NBozhTkJpHY5acbAhMTMuTgl/6P7uLhaH+hAT/gs+PfQb+1L8lC7+tTW1F7cHVZoG/V+iGnuNvHPZbPcDKfairosDh5KQo95lOs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=gQ/CB4r0; 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="gQ/CB4r0" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 66037C4AF64; Tue, 18 Jun 2024 18:18:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734699; bh=kQhv3CeO5+UCw9SJSn7ZxV5sAw44NEd/krZ6l962Oqk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=gQ/CB4r01A0ClGT+QwDaT7ylpWMw3N+dob/wzVdm7wJD9HDuPo57XRBVku1+5BZZf k3KE4bLPtcIAsUXjZo670ljF89YMHona8451FMZ4mkRU0iCVHxswVKcO2vt6BEX98O /hnQh6TPCFAvWEHUNflOSLMe0hpR4jPahbJJKcHwmBVcWD3Lqa7WgKWlD/LKud4EYT sth87vbfVIsgkevcpxrNdwA7VVIsqeJWdAvvt+bPPmSN0Ap1KHOC9+DI3gJ/2T2LXL ymXCzvt+u91KmVkLalchFgH5miTU3BoCS9AXS1b0NVnnJCMM5fiTHaxV+BMjWJDZuq XbtAtMPFPO3kA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 05/12] mm/damon/sysfs: remove unnecessary online tuning handling code Date: Tue, 18 Jun 2024 11:18:02 -0700 Message-Id: <20240618181809.82078-6-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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.c contains code for handling of online DAMON parameters update edge cases. It is no more necessary since damon_commit_ctx() takes care of the cases. Remove the unnecessary code. Signed-off-by: SeongJae Park --- mm/damon/sysfs-test.h | 2 +- mm/damon/sysfs.c | 60 ++----------------------------------------- 2 files changed, 3 insertions(+), 59 deletions(-) diff --git a/mm/damon/sysfs-test.h b/mm/damon/sysfs-test.h index 73bdce2452c1..43a15156a7c3 100644 --- a/mm/damon/sysfs-test.h +++ b/mm/damon/sysfs-test.h @@ -62,7 +62,7 @@ static void damon_sysfs_test_set_targets(struct kunit *te= st) sysfs_target->pid =3D __damon_sysfs_test_get_any_pid( sysfs_target->pid + 1, 200); damon_sysfs_set_targets(ctx, sysfs_targets); - KUNIT_EXPECT_EQ(test, 1u, nr_damon_targets(ctx)); + KUNIT_EXPECT_EQ(test, 2u, nr_damon_targets(ctx)); =20 damon_destroy_ctx(ctx); kfree(sysfs_targets->targets_arr); diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 0f9fe18beb40..c729222797b8 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1162,72 +1162,16 @@ static int damon_sysfs_add_target(struct damon_sysf= s_target *sys_target, return err; } =20 -static int damon_sysfs_update_target_pid(struct damon_target *target, int = pid) -{ - struct pid *pid_new; - - pid_new =3D find_get_pid(pid); - if (!pid_new) - return -EINVAL; - - if (pid_new =3D=3D target->pid) { - put_pid(pid_new); - return 0; - } - - put_pid(target->pid); - target->pid =3D pid_new; - return 0; -} - -static int damon_sysfs_update_target(struct damon_target *target, - struct damon_ctx *ctx, - struct damon_sysfs_target *sys_target) -{ - int err =3D 0; - - if (damon_target_has_pid(ctx)) { - err =3D damon_sysfs_update_target_pid(target, sys_target->pid); - if (err) - return err; - } - - /* - * Do monitoring target region boundary update only if one or more - * regions are set by the user. This is for keeping current monitoring - * target results and range easier, especially for dynamic monitoring - * target regions update ops like 'vaddr'. - */ - if (sys_target->regions->nr) - err =3D damon_sysfs_set_regions(target, sys_target->regions); - return err; -} - static int damon_sysfs_set_targets(struct damon_ctx *ctx, struct damon_sysfs_targets *sysfs_targets) { - struct damon_target *t, *next; - int i =3D 0, err; + int i, err; =20 /* Multiple physical address space monitoring targets makes no sense */ if (ctx->ops.id =3D=3D DAMON_OPS_PADDR && sysfs_targets->nr > 1) return -EINVAL; =20 - damon_for_each_target_safe(t, next, ctx) { - if (i < sysfs_targets->nr) { - err =3D damon_sysfs_update_target(t, ctx, - sysfs_targets->targets_arr[i]); - if (err) - return err; - } else { - if (damon_target_has_pid(ctx)) - put_pid(t->pid); - damon_destroy_target(t); - } - i++; - } - - for (; i < sysfs_targets->nr; i++) { + for (i =3D 0; i < sysfs_targets->nr; i++) { struct damon_sysfs_target *st =3D sysfs_targets->targets_arr[i]; =20 err =3D damon_sysfs_add_target(st, ctx); --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 8B46315EFDA; Tue, 18 Jun 2024 18:18:20 +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=1718734700; cv=none; b=IADHHNZz26ooD6J/6timw8R7e+BdWqGxwkDQNGekX81v57gy7a2e2w7fBA/nmpKpIhPL4E9cGrpe0BIBQTFYT/wfKL9Pf6Oik8Bu85VRC29ZFopppAkoZebrdSy3stTc1F484Vxa4mGCI4cLVvoHQAE1X5YkRY+TbVVQptMBll4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734700; c=relaxed/simple; bh=EJciIpJkn54LApe2WvU8Qvem30aT3O4bHfII25VjoqE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=QEaMHTYboBHoMC5VJ+Huvv/CgDpw3Uqwq+1BfztCp0BQoGVQ5MUFHP2cQMpRnDA0JT/b8EMYvvHYsDNn2uNV5GVVloUcPF2PQNgoTaBExXHVngbfDT59om9OrcjW446Dg111MFAoGgcjLsVewU3wQKZcZbtxG8ndEmpbrsKuAlA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=PjoSmauB; 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="PjoSmauB" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 07F2AC4AF53; Tue, 18 Jun 2024 18:18:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734700; bh=EJciIpJkn54LApe2WvU8Qvem30aT3O4bHfII25VjoqE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=PjoSmauBnyzwWhhnbMqKVxNzt+ZsloVpP7l+vWj1e6DIaRfGZ3ecZyu3aYIrRHwYq gkYh0jfvuo91oJYjeFefoLFGuNHTWx/VQfwOUDYtq+WQfSeG4aHju3NPphSufmZDyM VWIyveow4XQMugCPdEuTG2g0AH3Tr4mbFNjFRDVLRLCqG4QoINhx0aID0+Fk7iua0e 0AkN3SLPSEwlx0oOoCZfq2l6hTpiZfVxH9zikTxB4s43cawJzfrIIf5NleDNwmsobB jwsAooNpgTPmqUC3y0o4YPvlJZ4SG6JvAfZiFK0AhcaQDvsd4HaeqkFXdWHxr4yTwL ze7fOUTGtpCXA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 06/12] mm/damon/sysfs: rename damon_sysfs_set_targets() to ...add_targets() Date: Tue, 18 Jun 2024 11:18:03 -0700 Message-Id: <20240618181809.82078-7-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 for updating DAMON structs that may or may not be partially populated. Hence it was not for only adding items, but also removing unnecessary items and updating items in-place. A previous commit has changed the function to assume the structs are not partially populated, and do only adding items. Make the function name better explain the behavior. Signed-off-by: SeongJae Park --- mm/damon/sysfs-test.h | 8 ++++---- mm/damon/sysfs.c | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/mm/damon/sysfs-test.h b/mm/damon/sysfs-test.h index 43a15156a7c3..1c9b596057a7 100644 --- a/mm/damon/sysfs-test.h +++ b/mm/damon/sysfs-test.h @@ -38,7 +38,7 @@ static int __damon_sysfs_test_get_any_pid(int min, int ma= x) return -1; } =20 -static void damon_sysfs_test_set_targets(struct kunit *test) +static void damon_sysfs_test_add_targets(struct kunit *test) { struct damon_sysfs_targets *sysfs_targets; struct damon_sysfs_target *sysfs_target; @@ -56,12 +56,12 @@ static void damon_sysfs_test_set_targets(struct kunit *= test) =20 ctx =3D damon_new_ctx(); =20 - damon_sysfs_set_targets(ctx, sysfs_targets); + damon_sysfs_add_targets(ctx, sysfs_targets); KUNIT_EXPECT_EQ(test, 1u, nr_damon_targets(ctx)); =20 sysfs_target->pid =3D __damon_sysfs_test_get_any_pid( sysfs_target->pid + 1, 200); - damon_sysfs_set_targets(ctx, sysfs_targets); + damon_sysfs_add_targets(ctx, sysfs_targets); KUNIT_EXPECT_EQ(test, 2u, nr_damon_targets(ctx)); =20 damon_destroy_ctx(ctx); @@ -71,7 +71,7 @@ static void damon_sysfs_test_set_targets(struct kunit *te= st) } =20 static struct kunit_case damon_sysfs_test_cases[] =3D { - KUNIT_CASE(damon_sysfs_test_set_targets), + KUNIT_CASE(damon_sysfs_test_add_targets), {}, }; =20 diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index c729222797b8..f83ea6a166c6 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1162,7 +1162,7 @@ static int damon_sysfs_add_target(struct damon_sysfs_= target *sys_target, return err; } =20 -static int damon_sysfs_set_targets(struct damon_ctx *ctx, +static int damon_sysfs_add_targets(struct damon_ctx *ctx, struct damon_sysfs_targets *sysfs_targets) { int i, err; @@ -1283,7 +1283,7 @@ static int damon_sysfs_apply_inputs(struct damon_ctx = *ctx, err =3D damon_sysfs_set_attrs(ctx, sys_ctx->attrs); if (err) return err; - err =3D damon_sysfs_set_targets(ctx, sys_ctx->targets); + err =3D damon_sysfs_add_targets(ctx, sys_ctx->targets); if (err) return err; return damon_sysfs_set_schemes(ctx, sys_ctx->schemes); --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 7033515FA77; Tue, 18 Jun 2024 18:18: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=1718734701; cv=none; b=QO+BkDTxocWzFTC3TLJuxjJS4d7Mkr2jaAjaAszAs0F8jCqB4b8SacIqExFvX6zjsxwBj0UO1V5s4MP7o/rPB09/lx52mqjk+n3vgKnNlMZby0Jz6eNzFt9mrFFKR/CwHRHoz0xik+r++5t1LxZzlHAkH4+9Ne91iEV7Ah7M680= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734701; c=relaxed/simple; bh=FhX0FlOnMgUOXgLd59wQh9U7osp32SgwH12eXj0ho8c=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=LAEaDzKI4TxgdTSNK32GcCAC3d0Jc/FH4XQoR1/ivsJkZ3KNTdCvEpQsVXol8IvsISnTVtE7v8ZLWKlvhRBNLfU4tfcx4JiAc82DdlZ6mlpwxxTmQW/R33eSdnUpDc54kOmJfe4GaUe0aNdxvvxDybsIqfcadkBhAVjckiQnI+k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=fu9AAeUW; 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="fu9AAeUW" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9E5D2C4AF49; Tue, 18 Jun 2024 18:18:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734701; bh=FhX0FlOnMgUOXgLd59wQh9U7osp32SgwH12eXj0ho8c=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=fu9AAeUWwTeRvtt2JM6jMIciTRKYP/+kxem/o9sGjge4tI6cDVL9JuDRmdkXWUjvO FE0m4jQ759sVN2rvKx3+TwR/0pBlT1i0cBvmuOsDRkaBljXk5rK6aORrGPyH/jRBwu w+tD6OmLtv0CxJZcBJEI8q23Hh0DzzfsAWJbYxHNGvdGD4cR/8fqCgVi18TGcmO7lM p7Cj3vOwXsVrCzzwVZ3ClXe840/Iw6Od1CEYAvLM3iO4n4hfaLUu2saw/99s43fa6K bQYGpdBDRJgSRCZZ4eW3VO1v6IlDmMlVhhUQwpkyuD1WEhld44789a3JPdjxezvpjL tiLJAL/I+k2wQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 07/12] mm/damon/sysfs-schemes: remove unnecessary online tuning handling code Date: Tue, 18 Jun 2024 11:18:04 -0700 Message-Id: <20240618181809.82078-8-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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-schemes.c contains code for handling of online DAMON parameters update edge cases. The logics are no more necessary since damon_commit_ctx() and damon_commit_quota_goals() takes care of the cases. Remove the unnecessary code. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 68 ++-------------------------------------- 1 file changed, 3 insertions(+), 65 deletions(-) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 1bccf2619e11..77c0265dff5c 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -1912,10 +1912,6 @@ static int damon_sysfs_set_scheme_filters(struct dam= os *scheme, struct damon_sysfs_scheme_filters *sysfs_filters) { int i; - struct damos_filter *filter, *next; - - damos_for_each_filter_safe(filter, next, scheme) - damos_destroy_filter(filter); =20 for (i =3D 0; i < sysfs_filters->nr; i++) { struct damon_sysfs_scheme_filter *sysfs_filter =3D @@ -1955,12 +1951,9 @@ static int damos_sysfs_set_quota_score( struct damos_sysfs_quota_goals *sysfs_goals, struct damos_quota *quota) { - struct damos_quota_goal *goal, *next; + struct damos_quota_goal *goal; int i; =20 - damos_for_each_quota_goal_safe(goal, next, quota) - damos_destroy_quota_goal(goal); - for (i =3D 0; i < sysfs_goals->nr; i++) { struct damos_sysfs_quota_goal *sysfs_goal =3D sysfs_goals->goals_arr[i]; @@ -2091,67 +2084,12 @@ static struct damos *damon_sysfs_mk_scheme( return scheme; } =20 -static void damon_sysfs_update_scheme(struct damos *scheme, - struct damon_sysfs_scheme *sysfs_scheme) -{ - struct damon_sysfs_access_pattern *access_pattern =3D - sysfs_scheme->access_pattern; - struct damon_sysfs_quotas *sysfs_quotas =3D sysfs_scheme->quotas; - struct damon_sysfs_weights *sysfs_weights =3D sysfs_quotas->weights; - struct damon_sysfs_watermarks *sysfs_wmarks =3D sysfs_scheme->watermarks; - int err; - - scheme->pattern.min_sz_region =3D access_pattern->sz->min; - scheme->pattern.max_sz_region =3D access_pattern->sz->max; - scheme->pattern.min_nr_accesses =3D access_pattern->nr_accesses->min; - scheme->pattern.max_nr_accesses =3D access_pattern->nr_accesses->max; - scheme->pattern.min_age_region =3D access_pattern->age->min; - scheme->pattern.max_age_region =3D access_pattern->age->max; - - scheme->action =3D sysfs_scheme->action; - scheme->apply_interval_us =3D sysfs_scheme->apply_interval_us; - scheme->target_nid =3D sysfs_scheme->target_nid; - - scheme->quota.ms =3D sysfs_quotas->ms; - scheme->quota.sz =3D sysfs_quotas->sz; - scheme->quota.reset_interval =3D sysfs_quotas->reset_interval_ms; - scheme->quota.weight_sz =3D sysfs_weights->sz; - scheme->quota.weight_nr_accesses =3D sysfs_weights->nr_accesses; - scheme->quota.weight_age =3D sysfs_weights->age; - - err =3D damos_sysfs_set_quota_score(sysfs_quotas->goals, &scheme->quota); - if (err) { - damon_destroy_scheme(scheme); - return; - } - - scheme->wmarks.metric =3D sysfs_wmarks->metric; - scheme->wmarks.interval =3D sysfs_wmarks->interval_us; - scheme->wmarks.high =3D sysfs_wmarks->high; - scheme->wmarks.mid =3D sysfs_wmarks->mid; - scheme->wmarks.low =3D sysfs_wmarks->low; - - err =3D damon_sysfs_set_scheme_filters(scheme, sysfs_scheme->filters); - if (err) - damon_destroy_scheme(scheme); -} - int damon_sysfs_set_schemes(struct damon_ctx *ctx, struct damon_sysfs_schemes *sysfs_schemes) { - struct damos *scheme, *next; - int i =3D 0; - - damon_for_each_scheme_safe(scheme, next, ctx) { - if (i < sysfs_schemes->nr) - damon_sysfs_update_scheme(scheme, - sysfs_schemes->schemes_arr[i]); - else - damon_destroy_scheme(scheme); - i++; - } + int i; =20 - for (; i < sysfs_schemes->nr; i++) { + for (i =3D 0; i < sysfs_schemes->nr; i++) { struct damos *scheme, *next; =20 scheme =3D damon_sysfs_mk_scheme(sysfs_schemes->schemes_arr[i]); --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 2254315FCFB; Tue, 18 Jun 2024 18:18: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=1718734702; cv=none; b=g2UuxahRCM22E2j41bhtkE/uxGFh0gUE6bB/JtE4cEwJA6Erj6iVXG33fpZ6iJyL+gRZibdvsdS4qRy+SEOQIlYTtKAAde5/EManfplA7FdgUb+bRwHWzuPix5yGfS4vm0FDyOonFCjRrEVj7erR4B8E2u7GLGalWXnRjpXEn70= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734702; c=relaxed/simple; bh=IvB9TY1BgcO/wE27+FMWRz+Cg1k/Z3ehFmcdbgTDhfw=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=PGWVTKZBEkJdwXqJSv14S5tN+1E6ceOfxV9Pag0SOtIJ4+I/3hIKS/GiILaZKFPBD7ifQJtX0pdacujfG1dm3J81t3kaFat5IS/C/YG92qoZllQvDtJTo9Z1e7p8nrJficrW/jMPSr4A4pfLmqjfwM8nmCXCg9HIqfppw9AzDp4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=W1QOFYNZ; 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="W1QOFYNZ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3FE3AC4AF50; Tue, 18 Jun 2024 18:18:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734701; bh=IvB9TY1BgcO/wE27+FMWRz+Cg1k/Z3ehFmcdbgTDhfw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=W1QOFYNZF8ejie0JzdmDiZs20qHP66bCShDkYs6kYuVfrgDXUx9RkIj2Vt689X0LL c5KGgHMaapOGrTmPZhmOjpu8mx7gR52gC1q2recUO41eCxmBKIcfIeDZhDC4F8wCDn pN5fhMg6QIdP2qketSZnuOJTmskmL1wvNkfaf8yOPiho89o7HCynwTtt0CyWbCWBVX uQ7NKuHV2FAqbxJsZ2v3dXdP5gNb0olBAmSaoys1f0Xr4P7Q9+dq1Ds0fNGgiav396 kTXFgqE4YzjkhgibHfbI2pv9Ia1icBbKh7YPt3PQBF9BLsTaVIlNJr3GF0FI8U9fCv 3jMgt+CtpQJAA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 08/12] mm/damon/sysfs-schemes: rename *_set_{schemes,scheme_filters,quota_score,schemes}() Date: Tue, 18 Jun 2024 11:18:05 -0700 Message-Id: <20240618181809.82078-9-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 functions were for updating DAMON structs that may or may not be partially populated. Hence it was not for only adding items, but also removing unnecessary items and updating items in-place. A previous commit has changed the functions to assume the structs are not partially populated, and do only adding items. Make the names better explain the behavior. Signed-off-by: SeongJae Park --- mm/damon/sysfs-common.h | 2 +- mm/damon/sysfs-schemes.c | 12 ++++++------ mm/damon/sysfs.c | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/mm/damon/sysfs-common.h b/mm/damon/sysfs-common.h index a63f51577cff..9a18f3c535d3 100644 --- a/mm/damon/sysfs-common.h +++ b/mm/damon/sysfs-common.h @@ -38,7 +38,7 @@ void damon_sysfs_schemes_rm_dirs(struct damon_sysfs_schem= es *schemes); =20 extern const struct kobj_type damon_sysfs_schemes_ktype; =20 -int damon_sysfs_set_schemes(struct damon_ctx *ctx, +int damon_sysfs_add_schemes(struct damon_ctx *ctx, struct damon_sysfs_schemes *sysfs_schemes); =20 void damon_sysfs_schemes_update_stats( diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 77c0265dff5c..b095457380b5 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -1908,7 +1908,7 @@ static int damon_sysfs_memcg_path_to_id(char *memcg_p= ath, unsigned short *id) return found ? 0 : -EINVAL; } =20 -static int damon_sysfs_set_scheme_filters(struct damos *scheme, +static int damon_sysfs_add_scheme_filters(struct damos *scheme, struct damon_sysfs_scheme_filters *sysfs_filters) { int i; @@ -1947,7 +1947,7 @@ static int damon_sysfs_set_scheme_filters(struct damo= s *scheme, return 0; } =20 -static int damos_sysfs_set_quota_score( +static int damos_sysfs_add_quota_score( struct damos_sysfs_quota_goals *sysfs_goals, struct damos_quota *quota) { @@ -1990,7 +1990,7 @@ int damos_sysfs_set_quota_scores(struct damon_sysfs_s= chemes *sysfs_schemes, break; =20 sysfs_scheme =3D sysfs_schemes->schemes_arr[i]; - err =3D damos_sysfs_set_quota_score(sysfs_scheme->quotas->goals, + err =3D damos_sysfs_add_quota_score(sysfs_scheme->quotas->goals, "a); if (err) { damos_for_each_quota_goal_safe(g, g_next, "a) @@ -2070,13 +2070,13 @@ static struct damos *damon_sysfs_mk_scheme( if (!scheme) return NULL; =20 - err =3D damos_sysfs_set_quota_score(sysfs_quotas->goals, &scheme->quota); + err =3D damos_sysfs_add_quota_score(sysfs_quotas->goals, &scheme->quota); if (err) { damon_destroy_scheme(scheme); return NULL; } =20 - err =3D damon_sysfs_set_scheme_filters(scheme, sysfs_filters); + err =3D damon_sysfs_add_scheme_filters(scheme, sysfs_filters); if (err) { damon_destroy_scheme(scheme); return NULL; @@ -2084,7 +2084,7 @@ static struct damos *damon_sysfs_mk_scheme( return scheme; } =20 -int damon_sysfs_set_schemes(struct damon_ctx *ctx, +int damon_sysfs_add_schemes(struct damon_ctx *ctx, struct damon_sysfs_schemes *sysfs_schemes) { int i; diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index f83ea6a166c6..cffc755e7775 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1286,7 +1286,7 @@ static int damon_sysfs_apply_inputs(struct damon_ctx = *ctx, err =3D damon_sysfs_add_targets(ctx, sys_ctx->targets); if (err) return err; - return damon_sysfs_set_schemes(ctx, sys_ctx->schemes); + return damon_sysfs_add_schemes(ctx, sys_ctx->schemes); } =20 static struct damon_ctx *damon_sysfs_build_ctx( --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 3BB0E160860; Tue, 18 Jun 2024 18:18: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=1718734703; cv=none; b=TAQk4hdo70GAhmdtL/cXZ+ltpaaq3ddkW5hT0/S3b5rqj02hutQliISn19cxaTGzmZTETCLudLy87PGDOpg/UcnoSvO6a6/DBmWSSlgqrYQg9PfPUL0P536eaSPaqZ6PALipxvPCVCsg0ovRhVQ2HxBCNcgbj9/Qg0IG/mw2y7k= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734703; c=relaxed/simple; bh=63ugfgzmyX4NmFqGz3i2C7qMQZ/sIyT4hK0C23YIhHI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=PUK51nNeGOqvAryRR+LDKKCnlJMMkjQPLVgfdMut4u8uiwSMZdqaqwmBeb0AengTILG/kZb2pQOgDQGmDNEzYt3GXrhidC22r5X7DiOxe/C10O/65AQBWiSIXpjUnx4bBIQdigmAh7FCQtAGKLS9XkX3/6vS+QvsMHwK/RoxENY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=oLvial6x; 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="oLvial6x" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D7D6DC4AF49; Tue, 18 Jun 2024 18:18:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734702; bh=63ugfgzmyX4NmFqGz3i2C7qMQZ/sIyT4hK0C23YIhHI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=oLvial6xmmuQ0yPDZAWQraZaKb6LAp115Mm79wORwQmYVnNAOzFEko+KxgpbPJLkz MRYok8GqL9vvB+Xng+vOPk6x2Ke23b0oGTXyeQGQo8z1inXgPxk4fopGgnRjedXhZy Eqrd1/iiBBe8JnYfDTnDFaiiUHu98i6oWKGJpphMMCb2CQJbEYesD+bDmm5pfzkviY 1KZ8YT+nbf6AUahFRFTMWuenMt9RgUl8U+0ZAhSKipyrrpCZoOyO8V25BsNViSxrCe XKrsvzOBk9oEyDrM0MCHujO98I7Z0YxrtalloMZJBeENxgdIECdr4zIzpyBHS4z3gP fY0Sy3b+SnQUQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 09/12] mm/damon/reclaim: use damon_commit_ctx() Date: Tue, 18 Jun 2024 11:18:06 -0700 Message-Id: <20240618181809.82078-10-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 manually manipulates the DAMON context struct for online parameters update. Since the struct contains not only input parameters but also internal status and operation results, it is not that simple. Indeed, we found and fixed a few bugs in the code. Now DAMON core layer provides a function for the usage, namely damon_commit_ctx(). Replace the manual manipulation logic with the function. The core layer function could have its own bugs, but this change removes a source of bugs. Signed-off-by: SeongJae Park --- mm/damon/reclaim.c | 43 ++++++++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 19 deletions(-) diff --git a/mm/damon/reclaim.c b/mm/damon/reclaim.c index a05ccb41749b..be7f04b00d0c 100644 --- a/mm/damon/reclaim.c +++ b/mm/damon/reclaim.c @@ -195,59 +195,64 @@ static void damon_reclaim_copy_quota_status(struct da= mos_quota *dst, =20 static int damon_reclaim_apply_parameters(void) { + struct damon_ctx *param_ctx; + struct damon_target *param_target; struct damos *scheme, *old_scheme; struct damos_quota_goal *goal; struct damos_filter *filter; - int err =3D 0; + int err; =20 - err =3D damon_set_attrs(ctx, &damon_reclaim_mon_attrs); + err =3D damon_modules_new_paddr_ctx_target(¶m_ctx, ¶m_target); if (err) return err; =20 - /* Will be freed by next 'damon_set_schemes()' below */ + err =3D damon_set_attrs(ctx, &damon_reclaim_mon_attrs); + if (err) + goto out; + + err =3D -ENOMEM; scheme =3D damon_reclaim_new_scheme(); if (!scheme) - return -ENOMEM; + goto out; if (!list_empty(&ctx->schemes)) { damon_for_each_scheme(old_scheme, ctx) damon_reclaim_copy_quota_status(&scheme->quota, &old_scheme->quota); } + damon_set_schemes(ctx, &scheme, 1); =20 if (quota_mem_pressure_us) { goal =3D damos_new_quota_goal(DAMOS_QUOTA_SOME_MEM_PSI_US, quota_mem_pressure_us); - if (!goal) { - damon_destroy_scheme(scheme); - return -ENOMEM; - } + if (!goal) + goto out; damos_add_quota_goal(&scheme->quota, goal); } =20 if (quota_autotune_feedback) { goal =3D damos_new_quota_goal(DAMOS_QUOTA_USER_INPUT, 10000); - if (!goal) { - damon_destroy_scheme(scheme); - return -ENOMEM; - } + if (!goal) + goto out; goal->current_value =3D quota_autotune_feedback; damos_add_quota_goal(&scheme->quota, goal); } =20 if (skip_anon) { filter =3D damos_new_filter(DAMOS_FILTER_TYPE_ANON, true); - if (!filter) { - /* Will be freed by next 'damon_set_schemes()' below */ - damon_destroy_scheme(scheme); - return -ENOMEM; - } + if (!filter) + goto out; damos_add_filter(scheme, filter); } - damon_set_schemes(ctx, &scheme, 1); =20 - return damon_set_region_biggest_system_ram_default(target, + err =3D damon_set_region_biggest_system_ram_default(param_target, &monitor_region_start, &monitor_region_end); + if (err) + goto out; + err =3D damon_commit_ctx(ctx, param_ctx); +out: + damon_destroy_ctx(param_ctx); + return err; } =20 static int damon_reclaim_turn(bool on) --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 3BADA1607BC; Tue, 18 Jun 2024 18:18: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=1718734703; cv=none; b=LQAo+IGOQGDFGLjctmX9K9zCo4BY7J8t3r9ALHWFYTkB2C9+ruYKWaYzHlMM5snU1GMJlCe69GBqbc9W0m3X2+S2L07IwLuOKVHOhSE8YRCWFYlEtq8/voyiYbdmT0sX7lQ+QofKD4+QnZJdqYvEQvwpGXlK5kvJtYRrtDTxPHY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734703; c=relaxed/simple; bh=50hBEP6CpX4UJy/Ydz/ykmHUVQkUp5qb7XdctlMxkUE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=baPcISIStSMUe6We3WLH8QiipZP/+OgRnt3AG9tfBmp+ERUyYEhiAoIpnmW4uKOuBAgRsYjLLJMt9xRLNx+kPU44qbiyARGxC2jeBbPtg7YxEKkRcM5UnEfzCzJvk/T/Ld75R1E6wUM3qJYs5AwKY4XoPVo3FSvdv0YLj0TuFG0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Bv3wHdx6; 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="Bv3wHdx6" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 78C6BC3277B; Tue, 18 Jun 2024 18:18:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734702; bh=50hBEP6CpX4UJy/Ydz/ykmHUVQkUp5qb7XdctlMxkUE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Bv3wHdx62BoXicPFD3PtWCmzu1QMbhv2f1y/yA6WIoKpljpHHt1SpeWSMp51QlqTh YRo9i5ZHlHsb8/rM5jZWPOZOJAdHlCUnI1ovNiJZyXBbcQCjvaa2bb40wetatKs/TA aw0ojXny1SKlwjKjhYhpd+0a5Hy6JFL5XOvQSKDN8mQ8Z5AiScjUsee6GCQXhbbpwD 8wT93MtFD7eBrhaeQvmcT7N1wSk+tll4x3u2s2Ku/osq8eZJffSqBJIkRbD9KyVIN2 yyYiJz4eJf2pWOUnSxMJ4EN7n2p7g9D2jtcyniabVB9N7eF3++GExlXmeU3iXTtaCZ 5BQVwFeCDY2Eg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 10/12] mm/damon/reclaim: remove unnecessary code for online tuning Date: Tue, 18 Jun 2024 11:18:07 -0700 Message-Id: <20240618181809.82078-11-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 contains code for handling of online DAMON parameters update edge cases. It is no more necessary since damon_commit_ctx() takes care of the cases. Remove the unnecessary code. Signed-off-by: SeongJae Park --- mm/damon/reclaim.c | 19 +------------------ 1 file changed, 1 insertion(+), 18 deletions(-) diff --git a/mm/damon/reclaim.c b/mm/damon/reclaim.c index be7f04b00d0c..9e0077a9404e 100644 --- a/mm/damon/reclaim.c +++ b/mm/damon/reclaim.c @@ -181,23 +181,11 @@ static struct damos *damon_reclaim_new_scheme(void) NUMA_NO_NODE); } =20 -static void damon_reclaim_copy_quota_status(struct damos_quota *dst, - struct damos_quota *src) -{ - dst->total_charged_sz =3D src->total_charged_sz; - dst->total_charged_ns =3D src->total_charged_ns; - dst->charged_sz =3D src->charged_sz; - dst->charged_from =3D src->charged_from; - dst->charge_target_from =3D src->charge_target_from; - dst->charge_addr_from =3D src->charge_addr_from; - dst->esz_bp =3D src->esz_bp; -} - static int damon_reclaim_apply_parameters(void) { struct damon_ctx *param_ctx; struct damon_target *param_target; - struct damos *scheme, *old_scheme; + struct damos *scheme; struct damos_quota_goal *goal; struct damos_filter *filter; int err; @@ -214,11 +202,6 @@ static int damon_reclaim_apply_parameters(void) scheme =3D damon_reclaim_new_scheme(); if (!scheme) goto out; - if (!list_empty(&ctx->schemes)) { - damon_for_each_scheme(old_scheme, ctx) - damon_reclaim_copy_quota_status(&scheme->quota, - &old_scheme->quota); - } damon_set_schemes(ctx, &scheme, 1); =20 if (quota_mem_pressure_us) { --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 AC943161906; Tue, 18 Jun 2024 18:18: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=1718734703; cv=none; b=Dq4pmE36CZQFNmacyQlE21vd5X9PnhokRT6fGEXgVEv0A82SUhsg2UgrK6js1kDMG5CJVe2PLNrM+ET55P3ECP9yKIxONVWTnKJtckiZk+Ac1WKQrNwDctu9MnQvtS01WXrR21fJJWlm6kGTbUCTTPq4WlBcAJqj1b1XYqpA5NE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734703; c=relaxed/simple; bh=Y0WL72ENjXuzcYBbbK9ft+KRSGtN7fHgxSV1OXgDM6s=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=rjSCI0lhTVbh04GfSyH1TEW7VxWQzspqc5b5jaylnwau61k7N1z+Uf+OoNw6mRhm9WGl6Mht7VHRNw/VRmiqXYWso6Faz+tq47KYNHHOQGSl3p2wZuuBKoHQXFqRcAoq7TpO4VqdiJjHCaQOGYqaisj8vAa6hrbkAd2kfWYQof0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=VwfqITNf; 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="VwfqITNf" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1BF79C4AF62; Tue, 18 Jun 2024 18:18:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734703; bh=Y0WL72ENjXuzcYBbbK9ft+KRSGtN7fHgxSV1OXgDM6s=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=VwfqITNfa3Gj1ma2qV/KzR8qnMeqp295ZGO60CRb4JZdppxB2/90KPDXFex+I8IS9 qE2LEd69le3pgiaIGSfyZY7/VMgIQMiVEqUnU99WRufDW3uEvBp/IrWj/wiHmY/wUm ridb+Gzi6oKnW4Rj2zaqD8u95VTwStfTtH1nakd76T3lZofQqJbQ89Gs5Rf0n9mxJB ZCKyZutBvmraNTr/twF/Qe0CHL7uda40NlCilWCFepZ9a4+P0/MaWYcfj9wIqDFWFB Ap88kFf1HArbbAbyQhpoFj+bDyRC22LC5jT3qnFdywRo5kaVmNKCZ4+z0+3Xizuwtt nxOJIHeqamhbg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 11/12] mm/damon/lru_sort: use damon_commit_ctx() Date: Tue, 18 Jun 2024 11:18:08 -0700 Message-Id: <20240618181809.82078-12-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 manually manipulates the DAMON context struct for online parameters update. Since the struct contains not only input parameters but also internal status and operation results, it is not that simple. Indeed, we found and fixed a few bugs in the code. Now DAMON core layer provides a function for the usage, namely damon_commit_ctx(). Replace the manual manipulation logic with the function. The core layer function could have its own bugs, but this change removes a source of bugs. Signed-off-by: SeongJae Park --- mm/damon/lru_sort.c | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/mm/damon/lru_sort.c b/mm/damon/lru_sort.c index 3775f0f2743d..f83542973946 100644 --- a/mm/damon/lru_sort.c +++ b/mm/damon/lru_sort.c @@ -199,15 +199,22 @@ static void damon_lru_sort_copy_quota_status(struct d= amos_quota *dst, =20 static int damon_lru_sort_apply_parameters(void) { + struct damon_ctx *param_ctx; + struct damon_target *param_target; struct damos *scheme, *hot_scheme, *cold_scheme; struct damos *old_hot_scheme =3D NULL, *old_cold_scheme =3D NULL; unsigned int hot_thres, cold_thres; - int err =3D 0; + int err; =20 - err =3D damon_set_attrs(ctx, &damon_lru_sort_mon_attrs); + err =3D damon_modules_new_paddr_ctx_target(¶m_ctx, ¶m_target); if (err) return err; =20 + err =3D damon_set_attrs(ctx, &damon_lru_sort_mon_attrs); + if (err) + goto out; + + err =3D -ENOMEM; damon_for_each_scheme(scheme, ctx) { if (!old_hot_scheme) { old_hot_scheme =3D scheme; @@ -220,7 +227,7 @@ static int damon_lru_sort_apply_parameters(void) hot_thres_access_freq / 1000; hot_scheme =3D damon_lru_sort_new_hot_scheme(hot_thres); if (!hot_scheme) - return -ENOMEM; + goto out; if (old_hot_scheme) damon_lru_sort_copy_quota_status(&hot_scheme->quota, &old_hot_scheme->quota); @@ -229,18 +236,24 @@ static int damon_lru_sort_apply_parameters(void) cold_scheme =3D damon_lru_sort_new_cold_scheme(cold_thres); if (!cold_scheme) { damon_destroy_scheme(hot_scheme); - return -ENOMEM; + goto out; } if (old_cold_scheme) damon_lru_sort_copy_quota_status(&cold_scheme->quota, &old_cold_scheme->quota); =20 - damon_set_schemes(ctx, &hot_scheme, 1); - damon_add_scheme(ctx, cold_scheme); + damon_set_schemes(param_ctx, &hot_scheme, 1); + damon_add_scheme(param_ctx, cold_scheme); =20 - return damon_set_region_biggest_system_ram_default(target, + err =3D damon_set_region_biggest_system_ram_default(param_target, &monitor_region_start, &monitor_region_end); + if (err) + goto out; + err =3D damon_commit_ctx(ctx, param_ctx); +out: + damon_destroy_ctx(param_ctx); + return err; } =20 static int damon_lru_sort_turn(bool on) --=20 2.39.2 From nobody Thu Dec 18 08:36:03 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 3DA0416630B; Tue, 18 Jun 2024 18:18:24 +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=1718734704; cv=none; b=pK9UAJiGPXHPfoKr9AJDyss3JOFOthiiONEsRRSlNzNG+F333BNC9MuMQREdcC2CAaFOgH4RhKRzNiMANgLopKR5suNOyC1656jQ3FgLOdIB7ouk6tFxcwajR3HqPT5d98ayM5dc3veXZOk9FZx04orqwEKUXO2qAZfyXWMRKbU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1718734704; c=relaxed/simple; bh=EHvHHvs3IdQ5P9rJaPK4ESC9R2II3qWxcAR6kWa1t4Q=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Thx5gemWxCHeFebJzz9LyuFriogJHRPVHaLnsPzfj3TkKpTjFIc7krSRjHN2Os3Mgs7DHY1rmJKtN1H//g3bzmxCovGY3pmT5eHKVU94Kfx0uGW+3U18S7vWg+pZ42OKWnf/9ibQDz//g8ZqeEtz5zOZRxnx/etvkMj7/TpiyBI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=b83Rt0oM; 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="b83Rt0oM" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B564AC4AF1C; Tue, 18 Jun 2024 18:18:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1718734704; bh=EHvHHvs3IdQ5P9rJaPK4ESC9R2II3qWxcAR6kWa1t4Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=b83Rt0oMqPtrzFHwkktThAbwt6RLmjgTiYcJl5Yy8yP9GJeb/W67nnfp5KZK0arUv AILftpGiE3WMsdcmNVeO06uiWCOP57jzQFLd1M8NPK1GdpHyeeBWFks1meqa/uR74z DWfr3k0KW/cwRj2FJZ4zBkjFtSID93TaQ4C7+cS9bb0DBl9MUr+I84JLe5+2BrtIRJ BUqf6UfT/EeGXEDHkhVbNrnNcvbOZNlJIgR/RwJHs/r28rZ1dBIEY6OkC+j0xFOk89 gykTKPRNkIWYUZK8UdpT7GsbE6qwRUCV9YHJ614stO3SWX0cnJ/oDWEJL45ZS2dn1m 2zQtXOPOaSZGg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH 12/12] mm/damon/lru_sort: remove unnecessary online tuning handling code Date: Tue, 18 Jun 2024 11:18:09 -0700 Message-Id: <20240618181809.82078-13-sj@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240618181809.82078-1-sj@kernel.org> References: <20240618181809.82078-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 contains code for handling of online DAMON parameters update edge cases. It is no more necessary since damon_commit_ctx() takes care of the cases. Remove the unnecessary code. Signed-off-by: SeongJae Park --- mm/damon/lru_sort.c | 28 +--------------------------- 1 file changed, 1 insertion(+), 27 deletions(-) diff --git a/mm/damon/lru_sort.c b/mm/damon/lru_sort.c index f83542973946..4af8fd4a390b 100644 --- a/mm/damon/lru_sort.c +++ b/mm/damon/lru_sort.c @@ -186,23 +186,11 @@ static struct damos *damon_lru_sort_new_cold_scheme(u= nsigned int cold_thres) return damon_lru_sort_new_scheme(&pattern, DAMOS_LRU_DEPRIO); } =20 -static void damon_lru_sort_copy_quota_status(struct damos_quota *dst, - struct damos_quota *src) -{ - dst->total_charged_sz =3D src->total_charged_sz; - dst->total_charged_ns =3D src->total_charged_ns; - dst->charged_sz =3D src->charged_sz; - dst->charged_from =3D src->charged_from; - dst->charge_target_from =3D src->charge_target_from; - dst->charge_addr_from =3D src->charge_addr_from; -} - static int damon_lru_sort_apply_parameters(void) { struct damon_ctx *param_ctx; struct damon_target *param_target; - struct damos *scheme, *hot_scheme, *cold_scheme; - struct damos *old_hot_scheme =3D NULL, *old_cold_scheme =3D NULL; + struct damos *hot_scheme, *cold_scheme; unsigned int hot_thres, cold_thres; int err; =20 @@ -215,22 +203,11 @@ static int damon_lru_sort_apply_parameters(void) goto out; =20 err =3D -ENOMEM; - damon_for_each_scheme(scheme, ctx) { - if (!old_hot_scheme) { - old_hot_scheme =3D scheme; - continue; - } - old_cold_scheme =3D scheme; - } - hot_thres =3D damon_max_nr_accesses(&damon_lru_sort_mon_attrs) * hot_thres_access_freq / 1000; hot_scheme =3D damon_lru_sort_new_hot_scheme(hot_thres); if (!hot_scheme) goto out; - if (old_hot_scheme) - damon_lru_sort_copy_quota_status(&hot_scheme->quota, - &old_hot_scheme->quota); =20 cold_thres =3D cold_min_age / damon_lru_sort_mon_attrs.aggr_interval; cold_scheme =3D damon_lru_sort_new_cold_scheme(cold_thres); @@ -238,9 +215,6 @@ static int damon_lru_sort_apply_parameters(void) damon_destroy_scheme(hot_scheme); goto out; } - if (old_cold_scheme) - damon_lru_sort_copy_quota_status(&cold_scheme->quota, - &old_cold_scheme->quota); =20 damon_set_schemes(param_ctx, &hot_scheme, 1); damon_add_scheme(param_ctx, cold_scheme); --=20 2.39.2