From nobody Mon May 25 04:33:42 2026 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 74B313382C7; Mon, 18 May 2026 23:41: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=1779147684; cv=none; b=Yx/0uYfUUmAsjTFhdrjmccVZ1hHcuQY4BLO3VsTUC16ANfmlIjfLd9LPt7oLoUCY0WAxQynu2Fce0pvssFeE/0oe0Ap1mGdrGAheB5Oo+zJ8ylJy0QGvGgi2X/K9/OMuxkkQC1ofNp+kP6rnYMPGChbY+ADU5olAc6wL2LRb6ig= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147684; c=relaxed/simple; bh=Kv/gTWHqRbjarAkUDYzqDqtowKyfqdWveUKMXCNryl4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=SItix55JbPdfP9sw9fYIPAV6VDwnFYjJgQ0/bGZbrHPDqnem/VbUwFhOjuSZb492jF+LK66eSXOe8nQ/O0jBKiXTvHji2r0qhD+j432kee15AGLBkmH5iIFj5EUxs41bGlu4B1Y/mTAZ07VqsF35uFhU56f7K1ujmLVL5fSbvyM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=OJ+RRDi6; 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="OJ+RRDi6" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 31F4CC2BCB8; Mon, 18 May 2026 23:41:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147684; bh=Kv/gTWHqRbjarAkUDYzqDqtowKyfqdWveUKMXCNryl4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=OJ+RRDi6YBmsa/4T6O0oOaztaI8BRoed5K2kxdEX9GjQoU0x/rODNv/eujhCdwa4S b2y59gcw76olyuSLgZ27kWlEJBODOr+CpyXHordESuJH84aCwzwDHNB6Cnjt2SFDJo j3Pk2ZqKMLZygNozt/DuGwFJDD+CtamF1mY4z2nZOf2RpvOihG95q22gjotx2zHbu5 YSEC/jarx5GJBNIIbHicVbilG/hmAkriybKNOBGUPEDg0JQIyElNWx34RrdPHnBqgq Md40eGcrwVGzVJgp3o+vozedcZC+jQIMOaZ01kT9BmHd3vfZwHqGL2tsv8jvwQ6fJX UCJN8PwdS5L4g== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 01/28] mm/damon/core: introduce struct damon_probe Date: Mon, 18 May 2026 16:40:49 -0700 Message-ID: <20260518234119.97569-2-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Introduce a data structure for data attribute probe. It is just a linked list header at this step. It will be extended in a way that it can determine if a given memory has a specific data attribute. Signed-off-by: SeongJae Park --- include/linux/damon.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 4d4f031bcb453..4794931fa2ea3 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -730,6 +730,15 @@ struct damon_intervals_goal { unsigned long max_sample_us; }; =20 +/** + * struct damon_probe - Data region attribute probe. + * + * @list: Siblings list. + */ +struct damon_probe { + struct list_head list; +}; + /** * struct damon_attrs - Monitoring attributes for accuracy/overhead contro= l. * --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 C569B33A039; Mon, 18 May 2026 23:41: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=1779147684; cv=none; b=t3gU067SjJ6Sofw5HAmbSMMS6G8zttgVpYLWefKosFzg0wzzberYzUVE9GGZ6FWvtJRc912/j46wGtpZ12utzPoJYgk5JynGjAEWqauIXiajZ/F9uEiJVI4hNhrndvBnVgwdcQRmqI43fIn8QWUXjqo+IxrdfTwMnp0ViiniKoU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147684; c=relaxed/simple; bh=94Qr9IFKkWG9Mojgz+bl9B4vZnOt7au8kRAVlKYdFQA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=bNC+fS9vl/gjLpxZMQzxe0dFKSSKJhnJ96h6z2At6WgarUogaju9s0jjfKJpH1NGyizM2eU3QLzjEOVjvMJWkugc1HjdcvqYw3STKtlD9rQI8aT0PGVKOKnTN8puSNgue+xkjZsAAPzlV3cpq/kcdztPbR0TcjmH2Qqz0Wrc2/E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bjMok+L/; 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="bjMok+L/" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 81597C2BCC7; Mon, 18 May 2026 23:41:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147684; bh=94Qr9IFKkWG9Mojgz+bl9B4vZnOt7au8kRAVlKYdFQA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bjMok+L/UpJK1v8J5IfXwSLOAwkOflKm3vr+Jrr+AC2hKG5kEuhbMy+5QW1dvkuwM 5wwIJ5iewvKVep/IpsYA4aIppO9GLKqH/ne77X6KuZX2ekF3H1FmwCApMD0U9Nuo7i KNKjuY6b8goJGXBvREVbWc2/yDPfodSenFLox4x8mPtUsEGPaMMH0E2+AnZNel9M8r cYPWVqJFcKOwSrwMIrWzAiT8aOSyQpd7AHfiR6m8FnnB6s1n/rE/AMZlJF35dgLuRX KOMV6h8vU/ULk+SeUqzdAlblFF5LVXL1+/dkn/VEI5AtrXi5SGMertHWs6sM0cCMkD XI8HGVOYdXcqQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 02/28] mm/damon/core: embed damon_probe objects in damon_ctx Date: Mon, 18 May 2026 16:40:50 -0700 Message-ID: <20260518234119.97569-3-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Let damon_probe objects be able to be installed on a given damon_ctx, by adding a linked list header for storing the objects. Add initialization and cleanup of the new field with helper functions, too. Signed-off-by: SeongJae Park --- include/linux/damon.h | 9 +++++++++ mm/damon/core.c | 38 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 4794931fa2ea3..43d71eb24ccb6 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -857,6 +857,7 @@ struct damon_ctx { =20 /* public: */ struct damon_operations ops; + struct list_head probes; unsigned long addr_unit; unsigned long min_region_sz; bool pause; @@ -909,6 +910,11 @@ static inline unsigned long damon_sz_region(struct dam= on_region *r) return r->ar.end - r->ar.start; } =20 +#define damon_for_each_probe(p, ctx) \ + list_for_each_entry(p, &(ctx)->probes, list) + +#define damon_for_each_probe_safe(p, next, ctx) \ + list_for_each_entry_safe(p, next, &(ctx)->probes, list) =20 #define damon_for_each_region(r, t) \ list_for_each_entry(r, &t->regions_list, list) @@ -951,6 +957,9 @@ static inline unsigned long damon_sz_region(struct damo= n_region *r) =20 #ifdef CONFIG_DAMON =20 +struct damon_probe *damon_new_probe(void); +void damon_add_probe(struct damon_ctx *ctx, struct damon_probe *probe); + struct damon_region *damon_new_region(unsigned long start, unsigned long e= nd); =20 /* diff --git a/mm/damon/core.c b/mm/damon/core.c index 59e51134d0ed0..6ce1b949efaa7 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -113,6 +113,38 @@ int damon_select_ops(struct damon_ctx *ctx, enum damon= _ops_id id) return err; } =20 +struct damon_probe *damon_new_probe(void) +{ + struct damon_probe *p; + + p =3D kmalloc_obj(*p); + if (!p) + return NULL; + INIT_LIST_HEAD(&p->list); + return p; +} + +void damon_add_probe(struct damon_ctx *ctx, struct damon_probe *probe) +{ + list_add_tail(&probe->list, &ctx->probes); +} + +static void damon_del_probe(struct damon_probe *p) +{ + list_del(&p->list); +} + +static void damon_free_probe(struct damon_probe *p) +{ + kfree(p); +} + +static void damon_destroy_probe(struct damon_probe *p) +{ + damon_del_probe(p); + damon_free_probe(p); +} + #ifdef CONFIG_DAMON_DEBUG_SANITY static void damon_verify_new_region(unsigned long start, unsigned long end) { @@ -605,6 +637,8 @@ struct damon_ctx *damon_new_ctx(void) ctx->attrs.min_nr_regions =3D 10; ctx->attrs.max_nr_regions =3D 1000; =20 + INIT_LIST_HEAD(&ctx->probes); + ctx->addr_unit =3D 1; ctx->min_region_sz =3D DAMON_MIN_REGION_SZ; =20 @@ -627,12 +661,16 @@ static void damon_destroy_targets(struct damon_ctx *c= tx) void damon_destroy_ctx(struct damon_ctx *ctx) { struct damos *s, *next_s; + struct damon_probe *p, *next_p; =20 damon_destroy_targets(ctx); =20 damon_for_each_scheme_safe(s, next_s, ctx) damon_destroy_scheme(s); =20 + damon_for_each_probe_safe(p, next_p, ctx) + damon_destroy_probe(p); + kfree(ctx); } =20 --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 2DD5E33A9F3; Mon, 18 May 2026 23:41:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147685; cv=none; b=huczkCrlMTqgVxc/zabq9BdM5neU1L1RYIyiDluXQG5ZzqQy4cJaeb6k7Lc1dX3/eEhKYybI52hZO+QgRqbmUJ7mXpMDRlENkcgTDNLuAAld00i7XT5fqwz6LXvX6EHMdVuI6vRD9WT+T7Ug/F9R5IXKO56uU/fKEwRT+bzMJB8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147685; c=relaxed/simple; bh=bf/w6G1Oz26zbX7WatE2cZ1YXPddmn7MtSESl1T9sTU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Rx2hHtUWr3Rr/qFKtZlwzmwLIQ9O7hwlnr6OSgXhUjVAs3JOATi51biuUFmGYSYqxN9Q/ZBL9R2wTuOW/6ZZkNd26d5aGRFKpRl77ZB9R+WMp5lC7SCD40KjCH8PSrhRkrWTOw3uwoXMhH/gbHtrnOaEjsTgca0o3Wuq5URw1io= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=qxLCnyTT; 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="qxLCnyTT" Received: by smtp.kernel.org (Postfix) with ESMTPSA id CFC1AC2BCF5; Mon, 18 May 2026 23:41:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147685; bh=bf/w6G1Oz26zbX7WatE2cZ1YXPddmn7MtSESl1T9sTU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=qxLCnyTT5UlEzwdnpnmd2/EeZJAcwhJjx/sgWGqm9JU+OvQA5SU8JTYEZBWjnQUy+ POQ7oGyTNhcIZZP3nKet9oC/IRADspR6c6pNoFC5/rkHQHMnjowDIELTYUMyhXO5IF MoeaIDKEVLkgOiPJHxuNgq8/wAEK+9XK54G8LmsCdqt5tfuVYIV27eykNBfiOl42nb 0a9lvnbRJMwOfqRvuyoejjOz+WpgUW6bHIadbYEMG98iQMBXwWK7aIufyXXJhMQTLT gmcK+Dab82FVsyC5Xx7tm8Q1uQApDxqqCfGEh6vXcjAVsGQS49c82xZ/Dxj9hVQEnc RqOTn1LGiyb0A== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 03/28] mm/damon/core: introduce damon_filter Date: Mon, 18 May 2026 16:40:51 -0700 Message-ID: <20260518234119.97569-4-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Define a data structure for constructing damon_probe's attributes check, namely damon_filter. It is very similar to damos_filter but works only for monitoring purposes. Also embed that into damon_probe, implement essential handling of the link, with fundamental helpers. Signed-off-by: SeongJae Park --- include/linux/damon.h | 36 ++++++++++++++++++++++++++++++++++++ mm/damon/core.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 43d71eb24ccb6..f8b679dd944d9 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -730,12 +730,38 @@ struct damon_intervals_goal { unsigned long max_sample_us; }; =20 +/** + * enum damon_filter_type - Type of &struct damon_filter + * + * @DAMON_FILTER_TYPE_ANON: Anonymous pages. + */ +enum damon_filter_type { + DAMON_FILTER_TYPE_ANON, +}; + +/** + * struct damon_filter - DAMON region filter for &struct damon_probe. + * + * @type: Type of the region. + * @matching: Whether this filter is for the type-matching ones. + * @allow: Whether the @type-@matching ones should pass this filter. + * @list: Siblings list. + */ +struct damon_filter { + enum damon_filter_type type; + bool matching; + bool allow; + struct list_head list; +}; + /** * struct damon_probe - Data region attribute probe. * + * @filters: Filters for assessing if a given region is for this probe. * @list: Siblings list. */ struct damon_probe { + struct list_head filters; struct list_head list; }; =20 @@ -910,6 +936,12 @@ static inline unsigned long damon_sz_region(struct dam= on_region *r) return r->ar.end - r->ar.start; } =20 +#define damon_for_each_filter(f, p) \ + list_for_each_entry(f, &(p)->filters, list) + +#define damon_for_each_filter_safe(f, next, p) \ + list_for_each_entry_safe(f, next, &(p)->filters, list) + #define damon_for_each_probe(p, ctx) \ list_for_each_entry(p, &(ctx)->probes, list) =20 @@ -957,6 +989,10 @@ static inline unsigned long damon_sz_region(struct dam= on_region *r) =20 #ifdef CONFIG_DAMON =20 +struct damon_filter *damon_new_filter(enum damon_filter_type type, + bool matching, bool allow); +void damon_add_filter(struct damon_probe *probe, struct damon_filter *f); + struct damon_probe *damon_new_probe(void); void damon_add_probe(struct damon_ctx *ctx, struct damon_probe *probe); =20 diff --git a/mm/damon/core.c b/mm/damon/core.c index 6ce1b949efaa7..516368fbf1de3 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -113,6 +113,31 @@ int damon_select_ops(struct damon_ctx *ctx, enum damon= _ops_id id) return err; } =20 +struct damon_filter *damon_new_filter(enum damon_filter_type type, + bool matching, bool allow) +{ + struct damon_filter *filter; + + filter =3D kmalloc_obj(*filter); + if (!filter) + return NULL; + filter->type =3D type; + filter->matching =3D matching; + filter->allow =3D allow; + INIT_LIST_HEAD(&filter->list); + return filter; +} + +void damon_add_filter(struct damon_probe *p, struct damon_filter *f) +{ + list_add_tail(&f->list, &p->filters); +} + +static void damon_free_filter(struct damon_filter *f) +{ + kfree(f); +} + struct damon_probe *damon_new_probe(void) { struct damon_probe *p; @@ -120,6 +145,7 @@ struct damon_probe *damon_new_probe(void) p =3D kmalloc_obj(*p); if (!p) return NULL; + INIT_LIST_HEAD(&p->filters); INIT_LIST_HEAD(&p->list); return p; } @@ -136,6 +162,10 @@ static void damon_del_probe(struct damon_probe *p) =20 static void damon_free_probe(struct damon_probe *p) { + struct damon_filter *f, *next; + + damon_for_each_filter_safe(f, next, p) + damon_free_filter(f); kfree(p); } =20 --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 6FF4033ADB0; Mon, 18 May 2026 23:41:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147685; cv=none; b=Iy0Sa+TmebknUaTw0kjLwbuvGyrfE4wFIlDe8KCvrw5El4uiUWn5GlTSI4VJoQJFn/mARUyjUEjkn65kuobXtTng3jxZQ8cU04U8Wt6e4ZpdFKazzWGM9hiAmF7yIYvlZ9CFX2ZvUPjeyRCio/qqlaeO2+wXCwgoINrAF6xHOlY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147685; c=relaxed/simple; bh=mIzkcH/5A3M6QuaehEH7P+cR7kb6K2TS5t1AbB4gd5k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=swJoDljmhkEVqEXR8jZfICwMmSX2CPwi9hYflWWG0zTfgow22dLnosIWmLZSZ5karfqfG3fb9wmzCN9uPJADJHNHRPu/i/0nUB0wulzcTLYiZZxHwPnZo9cV6JxK28nOfyppCCPPKd/MxAXQ9DQcmOd3rRI4wJcWohQik7Mjtk0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=os0gBHJH; 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="os0gBHJH" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2918BC2BCB7; Mon, 18 May 2026 23:41:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147685; bh=mIzkcH/5A3M6QuaehEH7P+cR7kb6K2TS5t1AbB4gd5k=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=os0gBHJHahHk/HMbnOsr8aOC6mf9fC0x+yISiRhTktEn1nluY6OaB82kZ2Y2HcTsp VoXK6LvyKbN5P4ymo+BdJUI/FKpJGfrTXeX7jRTcpl5FGLN1AWEqsMjSMi7LoYjlmX KaQRtevWPo0QgZPlK54LurK29YOMDPuSBxeqbH5iXLULy7CPK4Uh5W1wfca+16X1KP Hu86EpXtFQNWk/WCNLLRopq25OIHTeRlDpldzP7hVtTdcsqJRk/CHbetIBO0ecRSmK Cs32aLTLxmysA9hG+xbkX3/YCsYrBCd6Bejgyd6JAlLrgsgrFuvu3NVz1eDVMYQfPp 6s6S/rhp4LPhw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 04/28] mm/damon/core: commit probes Date: Mon, 18 May 2026 16:40:52 -0700 Message-ID: <20260518234119.97569-5-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Update damon_commit_ctx() to commit installed data probes, too. Signed-off-by: SeongJae Park --- mm/damon/core.c | 104 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index 516368fbf1de3..075d60a4749a3 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -133,11 +133,34 @@ void damon_add_filter(struct damon_probe *p, struct d= amon_filter *f) list_add_tail(&f->list, &p->filters); } =20 +static void damon_del_filter(struct damon_filter *f) +{ + list_del(&f->list); +} + static void damon_free_filter(struct damon_filter *f) { kfree(f); } =20 +static void damon_destroy_filter(struct damon_filter *f) +{ + damon_del_filter(f); + damon_free_filter(f); +} + +static struct damon_filter *damon_nth_filter(int n, struct damon_probe *p) +{ + struct damon_filter *f; + int i =3D 0; + + damon_for_each_filter(f, p) { + if (i++ =3D=3D n) + return f; + } + return NULL; +} + struct damon_probe *damon_new_probe(void) { struct damon_probe *p; @@ -175,6 +198,18 @@ static void damon_destroy_probe(struct damon_probe *p) damon_free_probe(p); } =20 +static struct damon_probe *damon_nth_probe(int n, struct damon_ctx *ctx) +{ + struct damon_probe *p; + int i =3D 0; + + damon_for_each_probe(p, ctx) { + if (i++ =3D=3D n) + return p; + } + return NULL; +} + #ifdef CONFIG_DAMON_DEBUG_SANITY static void damon_verify_new_region(unsigned long start, unsigned long end) { @@ -1389,6 +1424,72 @@ static int damon_commit_targets( return 0; } =20 +static void damon_commit_filter(struct damon_filter *dst, + struct damon_filter *src) +{ + dst->type =3D src->type; + dst->matching =3D src->matching; + dst->allow =3D src->allow; +} + +static int damon_commit_filters(struct damon_probe *dst, + struct damon_probe *src) +{ + struct damon_filter *dst_filter, *next, *src_filter, *new_filter; + int i =3D 0, j =3D 0; + + damon_for_each_filter_safe(dst_filter, next, dst) { + src_filter =3D damon_nth_filter(i++, src); + if (src_filter) + damon_commit_filter(dst_filter, src_filter); + else + damon_destroy_filter(dst_filter); + } + + damon_for_each_filter_safe(src_filter, next, src) { + if (j++ < i) + continue; + + new_filter =3D damon_new_filter(src_filter->type, + src_filter->matching, src_filter->allow); + if (!new_filter) + return -ENOMEM; + damon_add_filter(dst, new_filter); + } + return 0; +} + +static int damon_commit_probes(struct damon_ctx *dst, struct damon_ctx *sr= c) +{ + struct damon_probe *dst_probe, *next, *src_probe, *new_probe; + int i =3D 0, j =3D 0, err; + + damon_for_each_probe_safe(dst_probe, next, dst) { + src_probe =3D damon_nth_probe(i++, src); + if (src_probe) { + err =3D damon_commit_filters(dst_probe, src_probe); + if (err) + return err; + } else { + damon_destroy_probe(dst_probe); + } + } + + damon_for_each_probe_safe(src_probe, next, src) { + if (j++ < i) + continue; + + new_probe =3D damon_new_probe(); + if (!new_probe) + return -ENOMEM; + damon_add_probe(dst, new_probe); + err =3D damon_commit_filters(new_probe, src_probe); + if (err) + return err; + } + return 0; +} + /** * damon_commit_ctx() - Commit parameters of a DAMON context to another. * @dst: The commit destination DAMON context. @@ -1445,6 +1546,9 @@ int damon_commit_ctx(struct damon_ctx *dst, struct da= mon_ctx *src) } dst->pause =3D src->pause; dst->ops =3D src->ops; + err =3D damon_commit_probes(dst, src); + if (err) + return err; dst->addr_unit =3D src->addr_unit; dst->min_region_sz =3D src->min_region_sz; =20 --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 BE2AE33B6F6; Mon, 18 May 2026 23:41:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147685; cv=none; b=Rh82I7POqI1Kwju5wHzN9MGIC3GrMrPHBHF+OezSZKmsbfXcWIWpii2nWrjkdLKblmiyS2N4hz+K9y8swHh7fCfGppFKY4G8FzYaQmAry53PfpH8EILTVkCdmZ8j/lhwlJLhozVbCgNrmtpAEOP6mkxqBie2F4DaOL9nulB9GFQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147685; c=relaxed/simple; bh=IlAa+oqmEJU7Ymj9l5zZPzJiXY56Jh7uaI0GPCOUdHo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=i1j+B0IfDUae4JXGOhU7d9BwI2NPOCv7GFI9cMYHTLcwmQkgmZL0oEgpiUCQankTRn1E1aqNvt4pJtwdwHEuqYY2eOK+wmcOZh82zopOA6lzU2difp0FSzawyN7pQivGl5bRCrZSKkBVWk/Sdy7jVlEldXfEZ9koeUlwy3laX+c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=S0aaBZ+u; 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="S0aaBZ+u" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 75EEAC2BCC7; Mon, 18 May 2026 23:41:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147685; bh=IlAa+oqmEJU7Ymj9l5zZPzJiXY56Jh7uaI0GPCOUdHo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=S0aaBZ+unVDLD6djSWl/RinRsUhT4XjzyZT+8HeKoPgKZFTIU3hPnRzNfN0tRHS5e XM1/wiof5kJ4tPvwnaEKHbPjWBgIM0s/kVvxT0wwiLkePbg1ZAfloJ6vWZ2zWr5vwH TVRU7dgoR43P6zQvZzYlLU19c/8Jt70XTejnr3o28qQvbwVALZvvHWGBPGQo7gfyD9 EOgavJelUGc2RYXHMFbmcZBPDiG12ZxETMmqARfJ8k6eYE9idwqiF38DFWsPsvH79e EHfhcVcDfp4mFU8SSihbsBUU/rk/zDpiGxvFsoqZ80Cdr6WZpFESqm3s5GkpCvPdYO wkes1E00GUpVA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 05/28] mm/damon/core: introduce damon_region->probe_hits Date: Mon, 18 May 2026 16:40:53 -0700 Message-ID: <20260518234119.97569-6-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Add an array for the per-region per-probe positive samples count. For simple and efficient implementation, add a limit to the number of data probes and set the array to support only the limited number of counters. Signed-off-by: SeongJae Park --- include/linux/damon.h | 4 ++++ mm/damon/core.c | 10 ++++++++++ 2 files changed, 14 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index f8b679dd944d9..3a30af119ac6e 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -17,6 +17,8 @@ =20 /* Minimal region size. Every damon_region is aligned by this. */ #define DAMON_MIN_REGION_SZ PAGE_SIZE +/* Maximum number of monitoring probes. */ +#define DAMON_MAX_PROBES (4) /* Max priority score for DAMON-based operation schemes */ #define DAMOS_MAX_SCORE (99) =20 @@ -47,6 +49,7 @@ struct damon_size_range { * @nr_accesses: Access frequency of this region. * @nr_accesses_bp: @nr_accesses in basis point (0.01%) that updated for * each sampling interval. + * @probe_hits: Number of probe-positive region samples. * @list: List head for siblings. * @age: Age of this region. * @@ -75,6 +78,7 @@ struct damon_region { unsigned long sampling_addr; unsigned int nr_accesses; unsigned int nr_accesses_bp; + unsigned char probe_hits[DAMON_MAX_PROBES]; struct list_head list; =20 unsigned int age; diff --git a/mm/damon/core.c b/mm/damon/core.c index 075d60a4749a3..6dd1bce81ec2a 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -229,6 +229,7 @@ static void damon_verify_new_region(unsigned long start= , unsigned long end) struct damon_region *damon_new_region(unsigned long start, unsigned long e= nd) { struct damon_region *region; + int i; =20 damon_verify_new_region(start, end); region =3D kmem_cache_alloc(damon_region_cache, GFP_KERNEL); @@ -239,6 +240,8 @@ struct damon_region *damon_new_region(unsigned long sta= rt, unsigned long end) region->ar.end =3D end; region->nr_accesses =3D 0; region->nr_accesses_bp =3D 0; + for (i =3D 0; i < DAMON_MAX_PROBES; i++) + region->probe_hits[i] =3D 0; INIT_LIST_HEAD(®ion->list); =20 region->age =3D 0; @@ -2983,12 +2986,17 @@ static void damon_merge_two_regions(struct damon_ta= rget *t, struct damon_region *l, struct damon_region *r) { unsigned long sz_l =3D damon_sz_region(l), sz_r =3D damon_sz_region(r); + int i; =20 l->nr_accesses =3D (l->nr_accesses * sz_l + r->nr_accesses * sz_r) / (sz_l + sz_r); l->nr_accesses_bp =3D l->nr_accesses * 10000; l->age =3D (l->age * sz_l + r->age * sz_r) / (sz_l + sz_r); l->ar.end =3D r->ar.end; + /* todo: do this for only installed probes */ + for (i =3D 0; i < DAMON_MAX_PROBES; i++) + l->probe_hits[i] =3D (l->probe_hits[i] * sz_l + r->probe_hits[i] + * sz_r) / (sz_l + sz_r); damon_verify_merge_two_regions(l, r); damon_destroy_region(r, t); } @@ -3111,6 +3119,8 @@ static void damon_split_region_at(struct damon_target= *t, new->last_nr_accesses =3D r->last_nr_accesses; new->nr_accesses_bp =3D r->nr_accesses_bp; new->nr_accesses =3D r->nr_accesses; + /* todo: do this for only installed probes */ + memcpy(new->probe_hits, r->probe_hits, sizeof(r->probe_hits)); =20 damon_insert_region(new, r, damon_next_region(r), t); } --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 1576833C195; Mon, 18 May 2026 23:41:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147686; cv=none; b=GsP5XatX9gzmr/weCJ9M8rxEdfoMThZEr0QvmGqR62IGH0T19K+dfUVBJ4O48mu/H2oU9Amyi350yKiMJM+FfrTD+/pEE6zcYRAn9DxAClSeOjzHiL+dZW2c4Mwsu14rHZAzs6IBUacL7NAZr0WF6JtX3RIzXkryQIiVkDMRsmg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147686; c=relaxed/simple; bh=bFwyAkRlbSFnPcn2Zfz8Cw3kNquyafjVVoSte7BT/A8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ZncC3CEcN2xigSPtwfedN05V4920HV+MPEUHBoHJ0wg/cXM1RwGlAXrz18cz3eQJpkLnypWdv9zA2K6KDgezHByUfxDJAL+50P/WiJSyB8F8qhjIGLBEAEJPSBDGBZj+UOGsBYQT/emCOHQo8wBaw3+6R3ZnrwEqf5rQuxVFXJQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LzT2B5OG; 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="LzT2B5OG" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C6EEDC2BCB7; Mon, 18 May 2026 23:41:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147686; bh=bFwyAkRlbSFnPcn2Zfz8Cw3kNquyafjVVoSte7BT/A8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=LzT2B5OGWVhM6vAI/ZvXSIwb2csxeZ0L+L4eExWE8BlEiYxpultu72EMZcoLHfd6g te6ZppepUwfP+VkZrELQpy+niKvkH3KjJjkt4dw55AUPuOSLiNn/hoYK3hjl0gRYJP K1jvrYUASEWvFUOyCEg1keJE/akizF5DKo2bjW2SPClb/91IA9OGZ1SzHFFGAPYplb fj4OpGpGQkMSwpPLZhZBe097JRS/uFj5TbQ/uGOSPddNkOmYsRGACqEbCVjkKUpE+/ auWI5dwWoSyYPF3aphwlI/gwp9CemEpe8IpvcDe3de6MRbjl0gsSfN2znMFAzOcbmT yx4EbJItohhxg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 06/28] mm/damon/core: introduce damon_ops->apply_probes Date: Mon, 18 May 2026 16:40:54 -0700 Message-ID: <20260518234119.97569-7-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Extend damon_operations struct with a new callback, namely apply_probes. The callback will be invoked for data attributes monitoring. More specifically, the callback will apply damon_probe objects to each region and update the per-region per-probe counters for the number of encountered probe-positive samples. Signed-off-by: SeongJae Park --- include/linux/damon.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 3a30af119ac6e..1fb271a35e98f 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -630,6 +630,7 @@ 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. + * @apply_probes: Apply probes for each region. * @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. @@ -656,6 +657,8 @@ 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. + * @apply_probes should apply the data attribute probes to each region and + * accordingly update the probe hits counter of the region. * @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 @@ -673,6 +676,7 @@ 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 (*apply_probes)(struct damon_ctx *context); int (*get_scheme_score)(struct damon_ctx *context, struct damon_region *r, struct damos *scheme); unsigned long (*apply_scheme)(struct damon_ctx *context, --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 73D3433985A; Mon, 18 May 2026 23:41:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147686; cv=none; b=Un7c3lzFFaeO/6P9xJ5OCNR1lQ2f+SwDMr69AJghj6/1xbRnTSYdHnr10k0177DgoF3Dylaa0N4AXo+H+bWAKI6j/BnZMK96d06WyivCDIwQSALVO59LRMdqfKfVwtS9HyjDvnzL/6R3G2P5V8rcZ5XIjRQ2ZcORsVQqPbjBrjE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147686; c=relaxed/simple; bh=EOdiDLw/Fh1yhoztKW51lYed+pEAR0BsIW9TAh1kfRo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=jIIghuatINVcXedfBI51c0bN14FrI+yQlPETlUA5jpEN4Q+53o8Oz3azbqVRwZRFplLjN5NokCW+Sb5rCu+2SPr6+A34ZjD+SfT6aCQncr+Qn7a0Qq0VUT5j3NnZabEZ3snsFvRvqX2QS6LXc5C6SYb8nLBoPnS27CC3DgomrvE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=JNtF7sqb; 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="JNtF7sqb" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 22534C4AF0B; Mon, 18 May 2026 23:41:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147686; bh=EOdiDLw/Fh1yhoztKW51lYed+pEAR0BsIW9TAh1kfRo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=JNtF7sqbaWtRINKs/9wm8INSXN1Jw85y9a3gFeOXhJASFk2FC7+1/9zS4gFnJMnep Ijk9mRO0bujO7/WL+8XgRvnYe51tmd1qXYPDbsLqDaPCNJmPYmDtal4i1eOJUMYsmx hwktFvtinqKzdvsIAEojku/MdJhEKyOW5KLISSL8atvr35FyfBV4sp2F9QN0jxX4Th +VdbY8tsBKNCztZQnlFyDHma2nh9BVFShz29Ie48U83xGR3Sb78vRx7aGUG6Fbq5aN Y6KY5Dz1eVXmcfPPNxLikOmw56a3F5ZPVNHXI2JPS5co1BH/qO/Oro2J5K5nyVnJSx eF9sOSCkwLkPQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 07/28] mm/damon/core: do data attributes monitoring Date: Mon, 18 May 2026 16:40:55 -0700 Message-ID: <20260518234119.97569-8-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 the data attributes monitoring execution. Update kdamond to invoke the probes application callback, and reset the aggregated number of per-region per-probe positive samples for every aggregation interval. Signed-off-by: SeongJae Park --- mm/damon/core.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index 6dd1bce81ec2a..433da8781e255 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1913,10 +1913,14 @@ static void kdamond_reset_aggregated(struct damon_c= tx *c) struct damon_region *r; =20 damon_for_each_region(r, t) { + int i; + trace_damon_aggregated(ti, r, damon_nr_regions(t)); damon_warn_fix_nr_accesses_corruption(r); r->last_nr_accesses =3D r->nr_accesses; r->nr_accesses =3D 0; + for (i =3D 0; i < DAMON_MAX_PROBES; i++) + r->probe_hits[i] =3D 0; damon_verify_reset_aggregated(r, c); } ti++; @@ -3410,6 +3414,8 @@ static int kdamond_fn(void *data) =20 if (ctx->ops.check_accesses) max_nr_accesses =3D ctx->ops.check_accesses(ctx); + if (ctx->ops.apply_probes) + ctx->ops.apply_probes(ctx); =20 if (time_after_eq(ctx->passed_sample_intervals, next_aggregation_sis)) { --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 B666933A6E0; Mon, 18 May 2026 23:41:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147686; cv=none; b=CuKinXvD+A8WHz3BK3d1E8btvmXrgOscM0ZPcBV3MavJP8t4sp3UbAONOqxO33GdYExeYxzyo4GRNKhKQLJCbDnkWG/o+3zjhDtxE6pu2CRJvbAvXUqmfNTpL60J8NP3JeVjm4J6ZkUB1kum7+yX3X0GUNIFZTkbXb9yUh2y2Og= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147686; c=relaxed/simple; bh=68XCaizJWpb0cvYPnjOEqbd/hx47Dw30XZpPcOn5Ze4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=d+LUKK/ndAHdkCfr1eLX1o2OhbrK8VzVMunNY4hbdTlj18PKTMORd2slfsf6YotsBWDU63YKjlVRQ6wqzNdwQRLtUSZPxKPdxQaum7DYoF7JEtV5dalhowHtVVyzbMTvnNE72lTl41dZ9jhdL7TT1Cd/mVBUyY+snPI9l3ak0vI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=JTA9vo/O; 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="JTA9vo/O" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6FDB3C2BCB7; Mon, 18 May 2026 23:41:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147686; bh=68XCaizJWpb0cvYPnjOEqbd/hx47Dw30XZpPcOn5Ze4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=JTA9vo/O0Xr5kznzHrfK+9YrtR3JWfTICJHBHiwShjW6hCG/dT20uJsCq5m/tawNn iwMD6ihHE/CtmV7T11aplUeNxneg89abq9jdcoxRW0/ZfhxUIoY7DFjOQ810fYQ5NY 6OwxIRRH8U7bqrOyWa43q5JV3Rt5oqmZ9NHbysNdOoe3CI7fkpL07vjF81eq0NMcDH qCM8W0G6d9VoDRj41HICy3O/9GmMAKZYY7fx1V2IfKOuxexCiUiwViKkhFDbC3JhIk UmpKZxj2NWZ9Vnk1YLN4FVKXtVxaYIq3j0gVgqfeo/TGPbeQcZAOFWJL/OUr0I1wAD 0PLrySLWvYgXQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 08/28] mm/damon/paddr: support data attributes monitoring Date: Mon, 18 May 2026 16:40:56 -0700 Message-ID: <20260518234119.97569-9-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 and register damon_operations->apply_probes() callback to support data attributes monitoring. Signed-off-by: SeongJae Park --- mm/damon/paddr.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c index c4738cd5e221e..9997c5174ef1b 100644 --- a/mm/damon/paddr.c +++ b/mm/damon/paddr.c @@ -120,6 +120,67 @@ static unsigned int damon_pa_check_accesses(struct dam= on_ctx *ctx) return max_nr_accesses; } =20 +static bool damon_pa_filter_match(struct damon_filter *filter, + struct folio *folio) +{ + bool matched =3D false; + + switch (filter->type) { + case DAMON_FILTER_TYPE_ANON: + if (!folio) { + matched =3D false; + break; + } + matched =3D folio_test_anon(folio); + break; + default: + break; + } + return matched =3D=3D filter->matching; +} + +static bool damon_pa_filter_pass(phys_addr_t pa, struct folio *folio, + struct damon_probe *p) +{ + struct damon_filter *f; + bool pass =3D true; + + damon_for_each_filter(f, p) { + if (damon_pa_filter_match(f, folio)) { + pass =3D f->allow; + break; + } + pass =3D !f->allow; + } + return pass; +} + +static void damon_pa_apply_probes(struct damon_ctx *ctx) +{ + struct damon_target *t; + struct damon_region *r; + struct damon_probe *p; + + damon_for_each_target(t, ctx) { + damon_for_each_region(r, t) { + int i =3D 0; + phys_addr_t pa; + struct folio *folio; + + pa =3D damon_pa_phys_addr(r->sampling_addr, + ctx->addr_unit); + folio =3D damon_get_folio(PHYS_PFN(pa)); + damon_for_each_probe(p, ctx) { + if (damon_pa_filter_pass(pa, folio, p)) + r->probe_hits[i]++; + i++; + } + if (folio) + folio_put(folio); + } + } +} + /* * damos_pa_filter_out - Return true if the page should be filtered out. */ @@ -371,6 +432,7 @@ 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, + .apply_probes =3D damon_pa_apply_probes, .target_valid =3D NULL, .apply_scheme =3D damon_pa_apply_scheme, .get_scheme_score =3D damon_pa_scheme_score, --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 1003F33A9C4; Mon, 18 May 2026 23:41:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147687; cv=none; b=lgw+Y14k+L+RAcPnIzOEkxFeYp89t3Z353tRh1sU8H2vqzd/bhJbxoGEa2cuT6sePLIlUctgX1IXE775E9VOImsirbeDOXc5GnlMIbHJPKCQLUKtR2hJTkpuqJc7a11Gmfzy7Qe5o0PJ9zqNNU/+VNzFaa9A2bURY/xZHrpkDxQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147687; c=relaxed/simple; bh=MsWu2zyYAy4V2rgxAX8KgVIMloArlsZthg7SEALRXSU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Jlv825uuUGxWmPjigR8Jq/PP4OIy+4BtFdKuq7dwNzrU6Dxts+UvSAB0Ef/uS3wHR4JmJF7crRvxJtIiIk6weyrW6R3FA0NYzyKZOzgz7S6zImxkKobRCqiLMRjTpaG9L2RT3RukFypLKg4lc3jnDXZH0Xd/eb/k4/4yODe5WUE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=RuSV5quI; 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="RuSV5quI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BF8B4C2BCFD; Mon, 18 May 2026 23:41:26 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147686; bh=MsWu2zyYAy4V2rgxAX8KgVIMloArlsZthg7SEALRXSU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=RuSV5quIhV0b64AbZG5woewKGNkdF5ETDSlswFfsQrXoh8vBrZC/rS1nhl7rIA/4u dlPVOA6B5zZ1OCWtsWKXx6dmQAQW2ef27EJCzmKdq2IrxwZaOARkO1prRsk+fd12bp ARTVjTAhqcafa5P14ZMMo6Pt0trdOb7C4OnX8sIxtVCca8nQMDiOLk3oxZI0n/hS2L 6Hc9OBqWBMKvCnAU3FDJVXLIjpHg9Sz4s6woapDq/141bGs1Cne8Y8SaHNM61DF7Gi 2xi+VYTj4xyuYxlBapN/PhX12FOyQNDvk7rt82N8BeMxo02EZeoWjaAxQ32QcnB/A/ PMHCeB/zhxIMA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 09/28] mm/damon/sysfs: implement probes dir Date: Mon, 18 May 2026 16:40:57 -0700 Message-ID: <20260518234119.97569-10-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 sysfs directory that can be used by the users to install data probes. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index d5863cc33d230..ccd19fc062f31 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -747,6 +747,35 @@ static const struct kobj_type damon_sysfs_intervals_kt= ype =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * probes directory + */ + +struct damon_sysfs_probes { + struct kobject kobj; +}; + +static struct damon_sysfs_probes *damon_sysfs_probes_alloc(void) +{ + return kzalloc_obj(struct damon_sysfs_probes); +} + +static void damon_sysfs_probes_release(struct kobject *kobj) +{ + kfree(container_of(kobj, struct damon_sysfs_probes, kobj)); +} + +static struct attribute *damon_sysfs_probes_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_probes); + +static const struct kobj_type damon_sysfs_probes_ktype =3D { + .release =3D damon_sysfs_probes_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_probes_groups, +}; + /* * monitoring_attrs directory */ @@ -755,6 +784,7 @@ struct damon_sysfs_attrs { struct kobject kobj; struct damon_sysfs_intervals *intervals; struct damon_sysfs_ul_range *nr_regions_range; + struct damon_sysfs_probes *probes; }; =20 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void) @@ -771,6 +801,7 @@ static int damon_sysfs_attrs_add_dirs(struct damon_sysf= s_attrs *attrs) { struct damon_sysfs_intervals *intervals; struct damon_sysfs_ul_range *nr_regions_range; + struct damon_sysfs_probes *probes; int err; =20 intervals =3D damon_sysfs_intervals_alloc(5000, 100000, 60000000); @@ -799,8 +830,22 @@ static int damon_sysfs_attrs_add_dirs(struct damon_sys= fs_attrs *attrs) if (err) goto put_nr_regions_intervals_out; attrs->nr_regions_range =3D nr_regions_range; + + probes =3D damon_sysfs_probes_alloc(); + if (!probes) { + err =3D -ENOMEM; + goto put_nr_regions_intervals_out; + } + err =3D kobject_init_and_add(&probes->kobj, + &damon_sysfs_probes_ktype, &attrs->kobj, "probes"); + if (err) + goto put_probes_out; + attrs->probes =3D probes; return 0; =20 +put_probes_out: + kobject_put(&probes->kobj); + attrs->probes =3D NULL; put_nr_regions_intervals_out: kobject_put(&nr_regions_range->kobj); attrs->nr_regions_range =3D NULL; @@ -817,6 +862,7 @@ static void damon_sysfs_attrs_rm_dirs(struct damon_sysf= s_attrs *attrs) kobject_put(&attrs->nr_regions_range->kobj); damon_sysfs_intervals_rm_dirs(attrs->intervals); kobject_put(&attrs->intervals->kobj); + kobject_put(&attrs->probes->kobj); } =20 static void damon_sysfs_attrs_release(struct kobject *kobj) --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 7F66E33F5A2; Mon, 18 May 2026 23:41:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147687; cv=none; b=i59NbktXOKaHekw/2lmoMvIGOzrlM26SZYctYehIjyrAbkRODgB0JKbEETMkNw7hUM7dCRDLTjFRIwmi1SKziQPTQ/kA+knfdu58X62qn1rUsECG9vRYRqzDbDCaGIoNiPwooQiJVwLwVHcJRtVmuwLMbB/goIeooNN+QgdJsoM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147687; c=relaxed/simple; bh=k36/Xcej0i3WC6azEdy4/45wiJ+RQaA394vMsLmcu6g=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=AqrPd+JmLwCfr8vYhyeIyVO4M39TjuWC5bKiUZPpn13fXH3hZpvFZjzlpH5D1Rb3x9VI/29Mf4wDu3RhwlEZt6UfZlUeU8EIqKs+OpmFcyv11nC4GG8ksR1XN5e8Y4A9AaQJC7bQcpSieukackwHjDISdrNF4gVTRr7b/mPlnAM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=DEzq2doy; 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="DEzq2doy" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1B75AC2BCF6; Mon, 18 May 2026 23:41:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147687; bh=k36/Xcej0i3WC6azEdy4/45wiJ+RQaA394vMsLmcu6g=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=DEzq2doyKH3jz7AF117WqLyGUs7NJpLCgGzJ6BPBdAmNUm32uy2D+Gc3gQCiuCl9g eeWJjBZp8Vr1JVtFZq4eTYJ09Wn9H433ix+4OyOVyf6SpE6pG+WaqEjgICGhlXBcVF TqSOwYDd5hClHdnX/hGBn9nUrn0Y91xbDSxHmIcuc0LA3LzelvLRlPEoIy6Zg/6Pn7 8rJONbOySgYCBNMH6O9QbgUfzv+pBxGbihLghC19PaOXB8+wA2nxvpWa7KJATXtliM SKuySbALiuWH+e4wSRaqUoiz536aRTEZoiMcG4VEYFF44wiQDy9re63ho/rVm6LdfW iSlwNVCIZcu9g== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 10/28] mm/damon/sysfs: implement probe dir Date: Mon, 18 May 2026 16:40:58 -0700 Message-ID: <20260518234119.97569-11-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 sysfs directory for letting users install each data probe. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 119 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index ccd19fc062f31..6cef3eaa4431e 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -747,12 +747,43 @@ static const struct kobj_type damon_sysfs_intervals_k= type =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * probe directory + */ + +struct damon_sysfs_probe { + struct kobject kobj; +}; + +static struct damon_sysfs_probe *damon_sysfs_probe_alloc(void) +{ + return kzalloc_obj(struct damon_sysfs_probe); +} + +static void damon_sysfs_probe_release(struct kobject *kobj) +{ + kfree(container_of(kobj, struct damon_sysfs_probe, kobj)); +} + +static struct attribute *damon_sysfs_probe_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_probe); + +static const struct kobj_type damon_sysfs_probe_ktype =3D { + .release =3D damon_sysfs_probe_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_probe_groups, +}; + /* * probes directory */ =20 struct damon_sysfs_probes { struct kobject kobj; + struct damon_sysfs_probe **probes_arr; + int nr; }; =20 static struct damon_sysfs_probes *damon_sysfs_probes_alloc(void) @@ -760,12 +791,99 @@ static struct damon_sysfs_probes *damon_sysfs_probes_= alloc(void) return kzalloc_obj(struct damon_sysfs_probes); } =20 +static void damon_sysfs_probes_rm_dirs( + struct damon_sysfs_probes *probes) +{ + struct damon_sysfs_probe **probes_arr =3D probes->probes_arr; + int i; + + for (i =3D 0; i < probes->nr; i++) + kobject_put(&probes_arr[i]->kobj); + probes->nr =3D 0; + kfree(probes_arr); + probes->probes_arr =3D NULL; +} + +static int damon_sysfs_probes_add_dirs( + struct damon_sysfs_probes *probes, int nr_probes) +{ + struct damon_sysfs_probe **probes_arr, *probe; + int err, i; + + damon_sysfs_probes_rm_dirs(probes); + if (!nr_probes) + return 0; + + probes_arr =3D kmalloc_objs(*probes_arr, nr_probes, + GFP_KERNEL | __GFP_NOWARN); + if (!probes_arr) + return -ENOMEM; + probes->probes_arr =3D probes_arr; + + for (i =3D 0; i < nr_probes; i++) { + probe =3D damon_sysfs_probe_alloc(); + if (!probe) { + damon_sysfs_probes_rm_dirs(probes); + return -ENOMEM; + } + + err =3D kobject_init_and_add(&probe->kobj, + &damon_sysfs_probe_ktype, &probes->kobj, + "%d", i); + if (err) { + kobject_put(&probe->kobj); + damon_sysfs_probes_rm_dirs(probes); + return err; + } + + probes_arr[i] =3D probe; + probes->nr++; + } + return 0; +} + +static ssize_t nr_probes_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_probes *probes =3D container_of(kobj, + struct damon_sysfs_probes, kobj); + + return sysfs_emit(buf, "%d\n", probes->nr); +} + +static ssize_t nr_probes_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_probes *probes; + int nr, err =3D kstrtoint(buf, 0, &nr); + + if (err) + return err; + if (nr < 0 || nr > DAMON_MAX_PROBES) + return -EINVAL; + + probes =3D container_of(kobj, struct damon_sysfs_probes, kobj); + + if (!mutex_trylock(&damon_sysfs_lock)) + return -EBUSY; + err =3D damon_sysfs_probes_add_dirs(probes, nr); + mutex_unlock(&damon_sysfs_lock); + if (err) + return err; + + return count; +} + static void damon_sysfs_probes_release(struct kobject *kobj) { kfree(container_of(kobj, struct damon_sysfs_probes, kobj)); } =20 +static struct kobj_attribute damon_sysfs_probes_nr_probes =3D + __ATTR_RW_MODE(nr_probes, 0600); + static struct attribute *damon_sysfs_probes_attrs[] =3D { + &damon_sysfs_probes_nr_probes.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_probes); @@ -862,6 +980,7 @@ static void damon_sysfs_attrs_rm_dirs(struct damon_sysf= s_attrs *attrs) kobject_put(&attrs->nr_regions_range->kobj); damon_sysfs_intervals_rm_dirs(attrs->intervals); kobject_put(&attrs->intervals->kobj); + damon_sysfs_probes_rm_dirs(attrs->probes); kobject_put(&attrs->probes->kobj); } =20 --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 B9C2933F8C5; Mon, 18 May 2026 23:41:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147687; cv=none; b=tjduGtiAnthwDOFqZHF4lmRD7wlXgtkw+cYmvCEBKgSYt4kLwEWqAxFzb5kXmbrCzVPzSb6LYz3R6n+k7dUZ0uZzCCscJTAtABcwGDqDhtYHvadmqXUbMzs61aJYERCh0Rx7sB1xjVo5WAuC5L6kav8LqJC8brG/emZRurLoBpY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147687; c=relaxed/simple; bh=rmhr/Vph30m3uPvDxb7GClUtdzs7jhuiQ7mtlWz+jJo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Ev/WSdTTe6DIuy+KJrOCJWEoN4rJr0enRHQHvs+ELD3G0fMXum7KLzvLp+r+lNnr1M1FN/V05yBYLbAa4snVAt7xa3ofJbN9/5d/fMQAN0lnLuFY9usOrYkR8+tTJfDsFPFTmx2iYW5Si/fz1ZYAJV5l777gPMHhBVxtUehGHmI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=qyonSZK3; 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="qyonSZK3" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 69C8EC2BCFA; Mon, 18 May 2026 23:41:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147687; bh=rmhr/Vph30m3uPvDxb7GClUtdzs7jhuiQ7mtlWz+jJo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=qyonSZK3Sqo3vxcEuYFvvHUuU2LGTdr/Qq/X+Jxog9MN45lEOPuM4v11XQIP+ZCnR 8P1XjhPRdjPyyebInFoG8NJ5U5S9boE40lOzlWjnscbXl7F9pTuKghwSCcPDf9d1Q/ yhNmPKPJqrq95ptQuNHR0ORwPZD0gBYhHYv/4XS0Qg3AX3HVVu1eAfeJa0N75h+XOO xzkT4wxI/iu+yf6gE6U4xvF6VjviObSd2Jlt61BG1SrcHSii+yRmm0nw2wIojqJvxf /JG/SSJt+sQ4RcTMV+eAaYuDKjKy/HghbqKudd1/AUd1rdMga/ow5JTRrENztyZSsI xRTtUJMJx59JQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 11/28] mm/damon/sysfs: implement filters directory Date: Mon, 18 May 2026 16:40:59 -0700 Message-ID: <20260518234119.97569-12-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 a directory for letting users to install data probe filters. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 1 deletion(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 6cef3eaa4431e..dad4985a826db 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -747,12 +747,42 @@ static const struct kobj_type damon_sysfs_intervals_k= type =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * filters directory + */ + +struct damon_sysfs_filters { + struct kobject kobj; +}; + +static struct damon_sysfs_filters *damon_sysfs_filters_alloc(void) +{ + return kzalloc_obj(struct damon_sysfs_filters); +} + +static void damon_sysfs_filters_release(struct kobject *kobj) +{ + kfree(container_of(kobj, struct damon_sysfs_filters, kobj)); +} + +static struct attribute *damon_sysfs_filters_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_filters); + +static const struct kobj_type damon_sysfs_filters_ktype =3D { + .release =3D damon_sysfs_filters_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_filters_groups, +}; + /* * probe directory */ =20 struct damon_sysfs_probe { struct kobject kobj; + struct damon_sysfs_filters *filters; }; =20 static struct damon_sysfs_probe *damon_sysfs_probe_alloc(void) @@ -760,6 +790,30 @@ static struct damon_sysfs_probe *damon_sysfs_probe_all= oc(void) return kzalloc_obj(struct damon_sysfs_probe); } =20 +static int damon_sysfs_probe_add_dirs(struct damon_sysfs_probe *attr) +{ + struct damon_sysfs_filters *filters; + int err; + + filters =3D damon_sysfs_filters_alloc(); + if (!filters) + return -ENOMEM; + attr->filters =3D filters; + + err =3D kobject_init_and_add(&filters->kobj, &damon_sysfs_filters_ktype, + &attr->kobj, "filters"); + if (err) { + kobject_put(&filters->kobj); + attr->filters =3D NULL; + } + return err; +} + +static void damon_sysfs_probe_rm_dirs(struct damon_sysfs_probe *attr) +{ + kobject_put(&attr->filters->kobj); +} + static void damon_sysfs_probe_release(struct kobject *kobj) { kfree(container_of(kobj, struct damon_sysfs_probe, kobj)); @@ -797,8 +851,10 @@ static void damon_sysfs_probes_rm_dirs( struct damon_sysfs_probe **probes_arr =3D probes->probes_arr; int i; =20 - for (i =3D 0; i < probes->nr; i++) + for (i =3D 0; i < probes->nr; i++) { + damon_sysfs_probe_rm_dirs(probes_arr[i]); kobject_put(&probes_arr[i]->kobj); + } probes->nr =3D 0; kfree(probes_arr); probes->probes_arr =3D NULL; @@ -836,6 +892,13 @@ static int damon_sysfs_probes_add_dirs( return err; } =20 + err =3D damon_sysfs_probe_add_dirs(probe); + if (err) { + kobject_put(&probe->kobj); + damon_sysfs_probes_rm_dirs(probes); + return err; + } + probes_arr[i] =3D probe; probes->nr++; } --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 38261340A6B; Mon, 18 May 2026 23:41:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147688; cv=none; b=Bm36L8QG2NsL/osVn8wBcS8FJLNsqgcDu6almVs4KrveBjPSRVgXIf6mJ2shZb1rEZ68SYuD+ybo66n5o+Eq/A2zila1gKmbz3EwhlURaUQZUicYu4supvG4IwCfjBqjvf0UFzhA6HwsqXzSL03xdwBY9vL+CnBCN6izleVrLH0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147688; c=relaxed/simple; bh=wvd91ossHZGuFvsrtP96Nxm/U0YmccwrdIjw/ZrtSSU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=PKHNNE2u+jL+OTR9dDG41llfW4GGmSt9xhBnovAQ2NaDeByqj67L6RIAJwe2rKbXSvsCA5Cfp34Om046OEDBFxVU5j3l15gjdkaJu8dDavtzB5rx4E4UPHBHOd5EMitP9OuvqrgLb9+xLCr0xndiAwrNFL/DVeZkNDoWoigQ60k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=txaLbiZN; 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="txaLbiZN" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BD693C2BCB8; Mon, 18 May 2026 23:41:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147688; bh=wvd91ossHZGuFvsrtP96Nxm/U0YmccwrdIjw/ZrtSSU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=txaLbiZNBQJiq6Zd9QUOcVEvx9pJQt7EQtmx9ikkY4h0tGLsWWzXImChAw78wWLrg NvTvRL0ftQecPSWuh16J2Xk1ktWH9Ql9MXisPYuhd1eJBeayQ3HKz9NHWWYhKb6kr7 hhwSVI85zXdo/6ZBwLj7ov96QNCNtiPGv8XqtH61Njd0hhKRM1DmDBVAOxx3yZj5vD pIHEzFj74onFpR65qjZtKsmqkN2I88A1vVvOhVUtrCyET6/cQYhLEVojV0Y06E60Qx VFDiqndmcyNZRqWw8b042buVIOFn5GATfSwcp49QAkneZ5TG3xa1STVDUp8FGsb2Mm gmBmQo1FpotBA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 12/28] mm/damon/sysfs: implement filter dir Date: Mon, 18 May 2026 16:41:00 -0700 Message-ID: <20260518234119.97569-13-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 a sysfs directory for letting the users to configure each data probe filter. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 125 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 124 insertions(+), 1 deletion(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index dad4985a826db..2dc475ea0f0f7 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -747,12 +747,46 @@ static const struct kobj_type damon_sysfs_intervals_k= type =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * filter directory + */ + +struct damon_sysfs_filter { + struct kobject kobj; +}; + +static struct damon_sysfs_filter *damon_sysfs_filter_alloc(void) +{ + return kzalloc_obj(struct damon_sysfs_filter); +} + +static void damon_sysfs_filter_release(struct kobject *kobj) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + + kfree(filter); +} + +static struct attribute *damon_sysfs_filter_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_filter); + +static const struct kobj_type damon_sysfs_filter_ktype =3D { + .release =3D damon_sysfs_filter_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_filter_groups, +}; + /* * filters directory */ =20 struct damon_sysfs_filters { struct kobject kobj; + struct damon_sysfs_filter **filters_arr; + int nr; }; =20 static struct damon_sysfs_filters *damon_sysfs_filters_alloc(void) @@ -760,12 +794,98 @@ static struct damon_sysfs_filters *damon_sysfs_filter= s_alloc(void) return kzalloc_obj(struct damon_sysfs_filters); } =20 +static void damon_sysfs_filters_rm_dirs(struct damon_sysfs_filters *filter= s) +{ + struct damon_sysfs_filter **filters_arr =3D filters->filters_arr; + int i; + + for (i =3D 0; i < filters->nr; i++) + kobject_put(&filters_arr[i]->kobj); + filters->nr =3D 0; + kfree(filters_arr); + filters->filters_arr =3D NULL; +} + +static int damon_sysfs_filters_add_dirs( + struct damon_sysfs_filters *filters, int nr_filters) +{ + struct damon_sysfs_filter **filters_arr, *filter; + int err, i; + + damon_sysfs_filters_rm_dirs(filters); + if (!nr_filters) + return 0; + + filters_arr =3D kmalloc_objs(*filters_arr, nr_filters, + GFP_KERNEL | __GFP_NOWARN); + if (!filters_arr) + return -ENOMEM; + filters->filters_arr =3D filters_arr; + + for (i =3D 0; i < nr_filters; i++) { + filter =3D damon_sysfs_filter_alloc(); + if (!filter) { + damon_sysfs_filters_rm_dirs(filters); + return -ENOMEM; + } + + err =3D kobject_init_and_add(&filter->kobj, + &damon_sysfs_filter_ktype, &filters->kobj, + "%d", i); + if (err) { + kobject_put(&filter->kobj); + damon_sysfs_filters_rm_dirs(filters); + return err; + } + + filters_arr[i] =3D filter; + filters->nr++; + } + return 0; +} + +static ssize_t nr_filters_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_filters *filters =3D container_of(kobj, + struct damon_sysfs_filters, kobj); + + return sysfs_emit(buf, "%d\n", filters->nr); +} + +static ssize_t nr_filters_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_filters *filters; + int nr, err =3D kstrtoint(buf, 0, &nr); + + if (err) + return err; + if (nr < 0) + return -EINVAL; + + filters =3D container_of(kobj, struct damon_sysfs_filters, kobj); + + if (!mutex_trylock(&damon_sysfs_lock)) + return -EBUSY; + err =3D damon_sysfs_filters_add_dirs(filters, nr); + mutex_unlock(&damon_sysfs_lock); + if (err) + return err; + + return count; +} + static void damon_sysfs_filters_release(struct kobject *kobj) { kfree(container_of(kobj, struct damon_sysfs_filters, kobj)); } =20 +static struct kobj_attribute damon_sysfs_filters_nr_attr =3D + __ATTR_RW_MODE(nr_filters, 0600); + static struct attribute *damon_sysfs_filters_attrs[] =3D { + &damon_sysfs_filters_nr_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_filters); @@ -811,7 +931,10 @@ static int damon_sysfs_probe_add_dirs(struct damon_sys= fs_probe *attr) =20 static void damon_sysfs_probe_rm_dirs(struct damon_sysfs_probe *attr) { - kobject_put(&attr->filters->kobj); + if (attr->filters) { + damon_sysfs_filters_rm_dirs(attr->filters); + kobject_put(&attr->filters->kobj); + } } =20 static void damon_sysfs_probe_release(struct kobject *kobj) --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 61D5A343D86; Mon, 18 May 2026 23:41:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147688; cv=none; b=ggtYgb+QWVzrLNV2elNEXcwJ8nhanUMF9l85WMmRFZtS7PX+PB8qzWgTP7NwSFSFPxPvSR0wZzZ6hl5hp7O/aXQFwTgkyxxuQ7pCZZbpK2v8VhEYpGb8qtXRC2ZIm/jSAx+tEw+6cvqGM36JnkUR3xDpk8Nvj6gIa07C7QR096I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147688; c=relaxed/simple; bh=iQV6uszTSASR7SPrN3OuATode4ysgHHPU+n3qGy6r2A=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=IjwxpQuE/DivF4UdHdQDK/0FXmVlA0DBvi8y96O6q1btpnRIYQl2SctmRXdj07SQyj6/QR4SynPC23X+j3QZl5PZ9BlE86cxB4dwDNBxbMz2sYY0A7oUqj+eH9p8p5a5I/+Kaaz09w7Elm10R0LIXoYzS/h+IxkJg5ydk3dE5gE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hRdfq4b2; 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="hRdfq4b2" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1D4ABC2BCB7; Mon, 18 May 2026 23:41:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147688; bh=iQV6uszTSASR7SPrN3OuATode4ysgHHPU+n3qGy6r2A=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hRdfq4b2Z4RMt54O4rh/DHjSSfMRDWBJgbO2JPOqIO3JnLYnF59ElNO15mTckEh6/ rmdJs0hrf77dZBSubA5knpRrY92Pw7+7gJ03Tf0hlRwjxl6trKumdwMIw18h3TQJ0P I7z/n2kdhEHP1DCWD89OSgwpgjjrwioFLLn1VxF7ALLa0WLlv5H+H0aCLqNTzwya/2 ShQA9airxY5mc565VYqTITRVknU79aByJGmoZZsb/VVxo9ucDxwnjjkADN+dQY2L/i kDCMR1J+ATHvwqZGS0vTcT3A89Bknn61J5NgbIKDm8T0EZWVkgvpVqVLJxo+imDM7G aU4x+XAx2W5rw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 13/28] mm/damon/sysfs: implement filter dir files Date: Mon, 18 May 2026 16:41:01 -0700 Message-ID: <20260518234119.97569-14-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 sysfs files under the data probe filter directory for letting users to configure each filter. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 2dc475ea0f0f7..51a4f05c9275c 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -753,6 +753,9 @@ static const struct kobj_type damon_sysfs_intervals_kty= pe =3D { =20 struct damon_sysfs_filter { struct kobject kobj; + enum damon_filter_type type; + bool matching; + bool allow; }; =20 static struct damon_sysfs_filter *damon_sysfs_filter_alloc(void) @@ -760,6 +763,105 @@ static struct damon_sysfs_filter *damon_sysfs_filter_= alloc(void) return kzalloc_obj(struct damon_sysfs_filter); } =20 +struct damon_sysfs_filter_type_name { + enum damon_filter_type type; + char *name; +}; + +static const struct damon_sysfs_filter_type_name +damon_sysfs_filter_type_names[] =3D { + { + .type =3D DAMON_FILTER_TYPE_ANON, + .name =3D "anon", + }, +}; + +static ssize_t type_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + int i; + + for (i =3D 0; i < ARRAY_SIZE(damon_sysfs_filter_type_names); i++) { + const struct damon_sysfs_filter_type_name *type_name; + + type_name =3D &damon_sysfs_filter_type_names[i]; + if (type_name->type =3D=3D filter->type) + return sysfs_emit(buf, "%s\n", type_name->name); + } + return -EINVAL; +} + +static ssize_t type_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + ssize_t ret =3D -EINVAL; + int i; + + for (i =3D 0; i < ARRAY_SIZE(damon_sysfs_filter_type_names); i++) { + const struct damon_sysfs_filter_type_name *type_name; + + type_name =3D &damon_sysfs_filter_type_names[i]; + if (sysfs_streq(buf, type_name->name)) { + filter->type =3D type_name->type; + ret =3D count; + break; + } + } + return ret; +} + +static ssize_t matching_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + + return sysfs_emit(buf, "%c\n", filter->matching ? 'Y' : 'N'); +} + +static ssize_t matching_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + bool matching; + int err =3D kstrtobool(buf, &matching); + + if (err) + return err; + + filter->matching =3D matching; + return count; +} + +static ssize_t allow_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + + return sysfs_emit(buf, "%c\n", filter->allow ? 'Y' : 'N'); +} + +static ssize_t allow_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + bool allow; + int err =3D kstrtobool(buf, &allow); + + if (err) + return err; + + filter->allow =3D allow; + return count; +} + static void damon_sysfs_filter_release(struct kobject *kobj) { struct damon_sysfs_filter *filter =3D container_of(kobj, @@ -768,7 +870,19 @@ static void damon_sysfs_filter_release(struct kobject = *kobj) kfree(filter); } =20 +static struct kobj_attribute damon_sysfs_filter_type_attr =3D + __ATTR_RW_MODE(type, 0600); + +static struct kobj_attribute damon_sysfs_filter_matching_attr =3D + __ATTR_RW_MODE(matching, 0600); + +static struct kobj_attribute damon_sysfs_filter_allow_attr =3D + __ATTR_RW_MODE(allow, 0600); + static struct attribute *damon_sysfs_filter_attrs[] =3D { + &damon_sysfs_filter_type_attr.attr, + &damon_sysfs_filter_matching_attr.attr, + &damon_sysfs_filter_allow_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_filter); --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 BD635344D9D; Mon, 18 May 2026 23:41:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147688; cv=none; b=Mkfoh2RI+un3JdWvXtKfF7MjvOBcbOOgaKPrSj9CzCI+7ppRdZcp+BVcgJrhv82Ypvo8So7+JMnpcI/QDTksHy29XxHF5+4rvmFRgWvU+j7R0Rupp0ptSEJYAzCgDeouQqT80OD8IQOWALiWes8chW1Fnd+Yx3OkTsF4JgThGYU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147688; c=relaxed/simple; bh=foWtH36Q1RoAgy2NDpXfRZA2kQ9BRRcIQByE1JbM4RM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=JOuCXKRs5EyP1Kjt4Y7pyD38GCjnhIExTWsJ9xqWXjz4syVTayYmVeJ+yEvj4sglyYymNzlOqWvmiD8JIVvmwRT1sP6sda3vXT6IJ7/bE4GtlaaywkzfbngaL2bex/TVpTzQHC+8CjZefhMKAlwn43DtHioVrskxLp2aOJN2f7E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=OtqJ7PSm; 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="OtqJ7PSm" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6B1A7C2BCB8; Mon, 18 May 2026 23:41:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147688; bh=foWtH36Q1RoAgy2NDpXfRZA2kQ9BRRcIQByE1JbM4RM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=OtqJ7PSm6gqQlw+wraffFbAk4b2n9djCzxehALH8UETbcdW2RBd7zxyqfB/x7ca/4 m04k2OXrkOjnZwQbBD9P37fWEQRPS3d7NuztyzJawfgqE5BzJem5BQfjLpXjsdQlGZ ELS3ibL5Tcg56X5oVwP6FmddbGxLgrDLjvhFcu6Nzg9rd7toJvDd1dniqS+U9kMMMc dnVBXJqtYO9GzXd7oxJEep42QNklP5zBpyEstNJXBg9I8kDDgIEqjXHfpLL7zw3nbw +ghKd6OZ3dY6p3yIzBooc1TcDQaVNPHkGHvHxysgumly0hauXWuRVtxqgiIRMQqjs6 vbKX098uCoxAw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 14/28] mm/damon/sysfs: setup probes on DAMON core API parameters Date: Mon, 18 May 2026 16:41:02 -0700 Message-ID: <20260518234119.97569-15-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Add user-installed data probes to DAMON core API parameters, so that user inputs for data probes are passed to DAMON core. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 51a4f05c9275c..eeb7fdd030cf0 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1855,6 +1855,40 @@ static int damon_sysfs_set_attrs(struct damon_ctx *c= tx, return damon_set_attrs(ctx, &attrs); } =20 +static int damon_sysfs_set_probes(struct damon_ctx *ctx, + struct damon_sysfs_probes *sys_probes) +{ + int i; + + for (i =3D 0; i < sys_probes->nr; i++) { + struct damon_sysfs_filters *sys_filters =3D + sys_probes->probes_arr[i]->filters; + struct damon_probe *c; + int j; + + if (!sys_filters) + continue; + c =3D damon_new_probe(); + if (!c) + return -ENOMEM; + damon_add_probe(ctx, c); + + for (j =3D 0; j < sys_filters->nr; j++) { + struct damon_sysfs_filter *sys_filter =3D + sys_filters->filters_arr[j]; + struct damon_filter *filter; + + filter =3D damon_new_filter(sys_filter->type, + sys_filter->matching, + sys_filter->allow); + if (!filter) + return -ENOMEM; + damon_add_filter(c, filter); + } + } + return 0; +} + static int damon_sysfs_set_regions(struct damon_target *t, struct damon_sysfs_regions *sysfs_regions, unsigned long min_region_sz) @@ -1967,6 +2001,9 @@ static int damon_sysfs_apply_inputs(struct damon_ctx = *ctx, DAMON_MIN_REGION_SZ / sys_ctx->addr_unit, 1); ctx->pause =3D sys_ctx->pause; err =3D damon_sysfs_set_attrs(ctx, sys_ctx->attrs); + if (err) + return err; + err =3D damon_sysfs_set_probes(ctx, sys_ctx->attrs->probes); if (err) return err; err =3D damon_sysfs_add_targets(ctx, sys_ctx->targets); --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 0D5EA345CA3; Mon, 18 May 2026 23:41:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147689; cv=none; b=LC6jL3gNUYEm0GhA0vd1PlmKH2N7m61yhhtlfam5tcJ8DgBWFq6q4WeNTGQdhT38033G4yWP3j7t40miawa5rKfK/ALAxmhSQqyW13M2oAOMAckJ70g5x7OmJu+T1VnVN3ytBabplgyFrChTzkQTDxgsH69cWPdaXkpxNuCfFDs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147689; c=relaxed/simple; bh=KKZL2OHisyq4/jWatQDQLTgpqORuvrm8mIvvroFoPfQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=teb9STJbDHeeZrGErPv7RK+CZezbc7hxgPrxSk29C7E5iUBD3ByIYy8fBCU3KXiuZdvbmkRPr/MAA8u6aXzY/4yqx3jB3ca7eecI0yM/N0NuEeY953V1D/ocLlllsDydkcrbVuS5VdsCXUX89TSqtVtMRImaaLAjhO6sbZKeRiM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=eRj3FgSG; 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="eRj3FgSG" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BC5D7C2BD01; Mon, 18 May 2026 23:41:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147688; bh=KKZL2OHisyq4/jWatQDQLTgpqORuvrm8mIvvroFoPfQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=eRj3FgSGn0QTuJ4QtADEn6UIsfBkFbNKw1QGeKV170zq2UZZUtpuMFxtI7Bu6gB+j duhpkUPWlGHjjibjtIaZqpwvh8i8J0TGl0mcFno0V1HQNdTxh2xCGvPAAtGj1wl05Y pwYj14brGvx13Fikk2FvZ4uj2nw8lTXWm8+FukXlrqsKTvS7psYO1OY8gHvCebp0F9 um0MZTICJlSEovyZJ+0LicqDLejx0BGzLZjh0XXXEaFClDBSYFXD8BDA8WeZA0XnE3 fr9DNSYyITyMGpUIHh9LmyGnLnBIUkfOy1f99wZrsR12Eqr/qVpk2Sdej8Tb+EVvw8 EUbVDg4/KY1ww== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 15/28] mm/damon/sysfs-schemes: implement tried_regions//probes/ Date: Mon, 18 May 2026 16:41:03 -0700 Message-ID: <20260518234119.97569-16-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 a sysfs directory for showing the per-region probe hit counts. It is named 'probes/' and located under the DAMOS tried region directory. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 67 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 63 insertions(+), 4 deletions(-) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 0d3021db0b99b..3b66c3a757b2a 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -10,6 +10,32 @@ =20 #include "sysfs-common.h" =20 +/* + * probes directory + */ + +struct damos_sysfs_probes { + struct kobject kobj; +}; + +static struct damos_sysfs_probes *damos_sysfs_probes_alloc(void) +{ + return kzalloc_obj(struct damos_sysfs_probes); +} + +static void damos_sysfs_probes_release(struct kobject *kobj) +{ + struct damos_sysfs_probes *probes =3D container_of(kobj, + struct damos_sysfs_probes, kobj); + + kfree(probes); +} + +static const struct kobj_type damos_sysfs_probes_ktype =3D { + .release =3D damos_sysfs_probes_release, + .sysfs_ops =3D &kobj_sysfs_ops, +}; + /* * scheme region directory */ @@ -20,6 +46,7 @@ struct damon_sysfs_scheme_region { unsigned int nr_accesses; unsigned int age; unsigned long sz_filter_passed; + struct damos_sysfs_probes *probes; struct list_head list; }; =20 @@ -34,10 +61,36 @@ static struct damon_sysfs_scheme_region *damon_sysfs_sc= heme_region_alloc( sysfs_region->ar =3D region->ar; sysfs_region->nr_accesses =3D region->nr_accesses_bp / 10000; sysfs_region->age =3D region->age; + sysfs_region->probes =3D NULL; INIT_LIST_HEAD(&sysfs_region->list); return sysfs_region; } =20 +static int damos_sysfs_region_add_dirs( + struct damon_sysfs_scheme_region *region) +{ + struct damos_sysfs_probes *probes =3D damos_sysfs_probes_alloc(); + int err; + + if (!probes) + return -ENOMEM; + err =3D kobject_init_and_add(&probes->kobj, &damos_sysfs_probes_ktype, + ®ion->kobj, "probes"); + if (err) { + kobject_put(&probes->kobj); + return err; + } + + region->probes =3D probes; + return 0; +} + +static void damos_sysfs_region_rm_dirs( + struct damon_sysfs_scheme_region *region) +{ + kobject_put(®ion->probes->kobj); +} + static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *att= r, char *buf) { @@ -163,6 +216,7 @@ static void damon_sysfs_scheme_regions_rm_dirs( struct damon_sysfs_scheme_region *r, *next; =20 list_for_each_entry_safe(r, next, ®ions->regions_list, list) { + damos_sysfs_region_rm_dirs(r); list_del(&r->list); kobject_put(&r->kobj); regions->nr_regions--; @@ -2995,12 +3049,17 @@ void damos_sysfs_populate_region_dir(struct damon_s= ysfs_schemes *sysfs_schemes, if (kobject_init_and_add(®ion->kobj, &damon_sysfs_scheme_region_ktype, &sysfs_regions->kobj, "%d", - sysfs_regions->nr_regions)) { - kobject_put(®ion->kobj); - return; - } + sysfs_regions->nr_regions)) + goto out; + if (damos_sysfs_region_add_dirs(region)) + goto out; + list_add_tail(®ion->list, &sysfs_regions->regions_list); sysfs_regions->nr_regions++; + return; + +out: + kobject_put(®ion->kobj); } =20 int damon_sysfs_schemes_clear_regions( --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 5DD4E346FCA; Mon, 18 May 2026 23:41:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147689; cv=none; b=JX9yeUtlvmCZWMfVxSqJhtj3xrmbdFzy5RF4bxMYBtCfu9sMx8nqnoKGxYVnzhGWMlqGHVwW2+SIlIVhEBEkd1P/L3ZRzs909oC8YrSU8NGdEqitWrPy0jt4EppPIYFjvGxoeEGwrivUGgTLw2GpTiJJ6WibEThyfxc0pk9+ibI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147689; c=relaxed/simple; bh=BCYfbcH/9towdlHTij0N6UcZ7TWGSKJGOLSMnWOdmwM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=g99bqPTXIE5NRo/akxy9h18wwihPiLkQxgDfQCxOCw50rcn5XCwBhaXc6wdRfgdpW/WhaRqjtnGZ7Yy+vdPoCiNpSlaUevHfF7UPZSwtT8Lq8bXxb+MBjiH7SR25dE0KhNrH9v7MV7hDUYqTL5w2z+2SwGyGtJ2C2SXtoMTKPMo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=k4hbttl0; 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="k4hbttl0" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 175B5C2BCF7; Mon, 18 May 2026 23:41:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147689; bh=BCYfbcH/9towdlHTij0N6UcZ7TWGSKJGOLSMnWOdmwM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=k4hbttl01KlVHAccJUJlTI7Lx+yd5GzHlfIu5lkYfLn+PHZM0DDyYQQH2go4XlrfO WVXptW7kLGlJs6NdDHV4KEeDLrEjOoSDnP37W8FIyRvL8hWbazC55jgwSDBWS6gEWe EcvNRGyNgVYtfja1xn+S/z7zmNBH1HQUuTqFC4orI0H1L5zWYC4sqGEswBXYBchg1P J4cLJAqSHylRlg3ymLFateXna2+DA5ZWyB/jjdtw1tjy2G2Rbd8mu0dPh1IaHWWMfq eo6XdF5dk3vykg0/ORVvXuhBElUgudckLagVsPHWD+Q895/DQS8Tqav7D6eDNBq2QA HmhyniNte5EDQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 16/28] mm/damon/sysfs-schemes: implement probe dir Date: Mon, 18 May 2026 16:41:04 -0700 Message-ID: <20260518234119.97569-17-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 sysfs directory for showing per-probe hits count of each region. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 101 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 95 insertions(+), 6 deletions(-) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 3b66c3a757b2a..7e21e78d77512 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -10,12 +10,40 @@ =20 #include "sysfs-common.h" =20 +/* + * probe directory + */ + +struct damos_sysfs_probe { + struct kobject kobj; +}; + +static struct damos_sysfs_probe *damos_sysfs_probe_alloc(void) +{ + return kzalloc_obj(struct damos_sysfs_probe); +} + +static void damos_sysfs_probe_release(struct kobject *kobj) +{ + struct damos_sysfs_probe *probe =3D container_of(kobj, + struct damos_sysfs_probe, kobj); + + kfree(probe); +} + +static const struct kobj_type damos_sysfs_probe_ktype =3D { + .release =3D damos_sysfs_probe_release, + .sysfs_ops =3D &kobj_sysfs_ops, +}; + /* * probes directory */ =20 struct damos_sysfs_probes { struct kobject kobj; + struct damos_sysfs_probe **probes_arr; + int nr; }; =20 static struct damos_sysfs_probes *damos_sysfs_probes_alloc(void) @@ -23,6 +51,60 @@ static struct damos_sysfs_probes *damos_sysfs_probes_all= oc(void) return kzalloc_obj(struct damos_sysfs_probes); } =20 +static void damos_sysfs_probes_rm_dirs(struct damos_sysfs_probes *probes) +{ + struct damos_sysfs_probe **probes_arr =3D probes->probes_arr; + int i; + + for (i =3D 0; i < probes->nr; i++) + kobject_put(&probes_arr[i]->kobj); + probes->nr =3D 0; + kfree(probes_arr); + probes->probes_arr =3D NULL; +} + +static int damos_sysfs_probes_add_dirs(struct damos_sysfs_probes *probes, + struct damon_ctx *ctx) +{ + struct damon_probe *probe; + struct damos_sysfs_probe **probes_arr; + int i =3D 0; + + damon_for_each_probe(probe, ctx) + i++; + + if (!i) + return 0; + + probes_arr =3D kmalloc_objs(*probes_arr, i); + if (!probes_arr) + return -ENOMEM; + probes->probes_arr =3D probes_arr; + + i =3D 0; + damon_for_each_probe(probe, ctx) { + struct damos_sysfs_probe *sys_probe; + int err; + + sys_probe =3D damos_sysfs_probe_alloc(); + if (!sys_probe) { + damos_sysfs_probes_rm_dirs(probes); + return -ENOMEM; + } + err =3D kobject_init_and_add(&sys_probe->kobj, + &damos_sysfs_probe_ktype, &probes->kobj, "%d", + i); + if (err) { + kobject_put(&sys_probe->kobj); + damos_sysfs_probes_rm_dirs(probes); + return err; + } + probes_arr[i++] =3D sys_probe; + probes->nr++; + } + return 0; +} + static void damos_sysfs_probes_release(struct kobject *kobj) { struct damos_sysfs_probes *probes =3D container_of(kobj, @@ -67,7 +149,8 @@ static struct damon_sysfs_scheme_region *damon_sysfs_sch= eme_region_alloc( } =20 static int damos_sysfs_region_add_dirs( - struct damon_sysfs_scheme_region *region) + struct damon_sysfs_scheme_region *region, + struct damon_ctx *ctx) { struct damos_sysfs_probes *probes =3D damos_sysfs_probes_alloc(); int err; @@ -76,18 +159,24 @@ static int damos_sysfs_region_add_dirs( return -ENOMEM; err =3D kobject_init_and_add(&probes->kobj, &damos_sysfs_probes_ktype, ®ion->kobj, "probes"); - if (err) { - kobject_put(&probes->kobj); - return err; - } + if (err) + goto fail; + err =3D damos_sysfs_probes_add_dirs(probes, ctx); + if (err) + goto fail; =20 region->probes =3D probes; return 0; + +fail: + kobject_put(&probes->kobj); + return err; } =20 static void damos_sysfs_region_rm_dirs( struct damon_sysfs_scheme_region *region) { + damos_sysfs_probes_rm_dirs(region->probes); kobject_put(®ion->probes->kobj); } =20 @@ -3051,7 +3140,7 @@ void damos_sysfs_populate_region_dir(struct damon_sys= fs_schemes *sysfs_schemes, &sysfs_regions->kobj, "%d", sysfs_regions->nr_regions)) goto out; - if (damos_sysfs_region_add_dirs(region)) + if (damos_sysfs_region_add_dirs(region, ctx)) goto out; =20 list_add_tail(®ion->list, &sysfs_regions->regions_list); --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 BD49234BA5A; Mon, 18 May 2026 23:41:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147689; cv=none; b=irdy2z6nxPyaHctoIGrwlvkJS1t9+e3qwvOpLNxnrWYOImwK63E/5TgkSXHQG7v6ws76HyboB9I2S4v3M+CFjeTYwxfplWFmCnp/k9/036ZVAmBd8StxduqpcRGhfgHlyKck1M9SMkBs4oWseUTTDHjOvJ0Kdp3OXkrh+ekcTaM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147689; c=relaxed/simple; bh=n2uNzQcVMV3fWGsTPMWuHPA3jhhhlDZQTIQ6T7mMfXI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=dLkjiCzr2qfsD6Crz6E3BQI66SZY9KBYk7zHChR+5axT6WrE0fpgLyiSRQQH80jUAi2/njCfg8m9jm/keAJB/8UtQo7jdj5l8Longs9fL01OW9KQmjhNINfKTluwqCGrL1z6sO0/eUTzbpdrBextnX02+RUUXWkJk2Up7uBnzk8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=FjR/lpox; 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="FjR/lpox" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 68752C2BCB7; Mon, 18 May 2026 23:41:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147689; bh=n2uNzQcVMV3fWGsTPMWuHPA3jhhhlDZQTIQ6T7mMfXI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=FjR/lpoxix/85FF+0PAloLY57l8+Q19co9p89ktpyNPf+wpZhbsqlUmDHamtH1aMN kzcpPe+2Sfwk+ryGfm8N0axxC37D3K6DL/G3uEUeg0aXI6NwcKRlWxUYq1QiEyZu0M wzScwkrVtYfpmlPcjQG5U39FoWMWjDB9dMY7cG427SnloDZvTemSJyY9TP+0aFDKeM Cg2X7bqWqUMU7bdoIompn3sOdM0GDgUmCNBSQsVtv53htkHeScZjOme9DlYC5F3kZh eXz/+HYqVbQSEbvpQvi0W1nee0dH8/zbRHE5apH1dfj9nhqpjvfVoYxRRPIIDE65TK suRhmy7cERGIQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 17/28] mm/damon/sysfs-schemes: implement probe/hits file Date: Mon, 18 May 2026 16:41:05 -0700 Message-ID: <20260518234119.97569-18-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 sysfs file for showing the per-region per-probe hits count. Signed-off-by: SeongJae Park --- mm/damon/sysfs-schemes.c | 41 +++++++++++++++++++++++++++++++++------- 1 file changed, 34 insertions(+), 7 deletions(-) diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index 7e21e78d77512..e25f4824b72fd 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -16,11 +16,27 @@ =20 struct damos_sysfs_probe { struct kobject kobj; + unsigned char hits; }; =20 -static struct damos_sysfs_probe *damos_sysfs_probe_alloc(void) +static struct damos_sysfs_probe *damos_sysfs_probe_alloc(unsigned char hit= s) { - return kzalloc_obj(struct damos_sysfs_probe); + struct damos_sysfs_probe *probe; + + probe =3D kzalloc_obj(*probe); + if (!probe) + return NULL; + probe->hits =3D hits; + return probe; +} + +static ssize_t hits_show(struct kobject *kobj, struct kobj_attribute *attr, + char *buf) +{ + struct damos_sysfs_probe *probe =3D container_of(kobj, + struct damos_sysfs_probe, kobj); + + return sysfs_emit(buf, "%hhu\n", probe->hits); } =20 static void damos_sysfs_probe_release(struct kobject *kobj) @@ -31,9 +47,19 @@ static void damos_sysfs_probe_release(struct kobject *ko= bj) kfree(probe); } =20 +static struct kobj_attribute damos_sysfs_probe_hits_attr =3D + __ATTR_RO_MODE(hits, 0400); + +static struct attribute *damos_sysfs_probe_attrs[] =3D { + &damos_sysfs_probe_hits_attr.attr, + NULL, +}; +ATTRIBUTE_GROUPS(damos_sysfs_probe); + static const struct kobj_type damos_sysfs_probe_ktype =3D { .release =3D damos_sysfs_probe_release, .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damos_sysfs_probe_groups, }; =20 /* @@ -64,7 +90,7 @@ static void damos_sysfs_probes_rm_dirs(struct damos_sysfs= _probes *probes) } =20 static int damos_sysfs_probes_add_dirs(struct damos_sysfs_probes *probes, - struct damon_ctx *ctx) + struct damon_ctx *ctx, struct damon_region *region) { struct damon_probe *probe; struct damos_sysfs_probe **probes_arr; @@ -86,7 +112,7 @@ static int damos_sysfs_probes_add_dirs(struct damos_sysf= s_probes *probes, struct damos_sysfs_probe *sys_probe; int err; =20 - sys_probe =3D damos_sysfs_probe_alloc(); + sys_probe =3D damos_sysfs_probe_alloc(region->probe_hits[i]); if (!sys_probe) { damos_sysfs_probes_rm_dirs(probes); return -ENOMEM; @@ -150,7 +176,8 @@ static struct damon_sysfs_scheme_region *damon_sysfs_sc= heme_region_alloc( =20 static int damos_sysfs_region_add_dirs( struct damon_sysfs_scheme_region *region, - struct damon_ctx *ctx) + struct damon_ctx *ctx, + struct damon_region *dregion) { struct damos_sysfs_probes *probes =3D damos_sysfs_probes_alloc(); int err; @@ -161,7 +188,7 @@ static int damos_sysfs_region_add_dirs( ®ion->kobj, "probes"); if (err) goto fail; - err =3D damos_sysfs_probes_add_dirs(probes, ctx); + err =3D damos_sysfs_probes_add_dirs(probes, ctx, dregion); if (err) goto fail; =20 @@ -3140,7 +3167,7 @@ void damos_sysfs_populate_region_dir(struct damon_sys= fs_schemes *sysfs_schemes, &sysfs_regions->kobj, "%d", sysfs_regions->nr_regions)) goto out; - if (damos_sysfs_region_add_dirs(region, ctx)) + if (damos_sysfs_region_add_dirs(region, ctx, r)) goto out; =20 list_add_tail(®ion->list, &sysfs_regions->regions_list); --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 29A13351C0C; Mon, 18 May 2026 23:41:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147690; cv=none; b=nQOgqN0IpfxO4Lb8xdMVzWfDNGqTNw6jl/ypK72E1Cc8hvzsqfpOgzRH0kHwUCZaKicKImh0KO0cPoMdCdL/GBkEmT0r4IEB1cs+g0V9Zo6OD2JmO3p0ntS3vFl7qWhP5GtLEczTyRVtnZjdjhRa0MINqAtZlTZle561qQWUSbs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147690; c=relaxed/simple; bh=oi/JcE35e0BkzNgUR9uyr6y/BZqSFxdfd3cKlzhvFvg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=SbSCrInWZ/QpCeZTBv0IjOHhDy+E4hKpQnXt9v2vHVljgz3VAKFV563FCZ/tIVjq/X4Tud3zYWE2bI8z9lfmRctR1NdpF/O83ivyanE3JyjkOihA6n9VL+9vhEnB50ba9IQW4yDmzs/f8HD/QXSOE2PQ36hrUGDwc65x2EMthUU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=vPuKh+sf; 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="vPuKh+sf" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B7D0EC2BCF6; Mon, 18 May 2026 23:41:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147690; bh=oi/JcE35e0BkzNgUR9uyr6y/BZqSFxdfd3cKlzhvFvg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=vPuKh+sfRjGLW/nvTDitPAIw3lLZyXsSmvIzv4jkG6j5f2mhGzq50UVbZ8zELzgsI ydxwT4tUwTYrmkVtqAKm9VhqZxZjEq1fYn/pZi0UxjeY2y6XzT6BTft0sLxvHxhFZy Jk+qq8C9LAJ06MZ+WehePbeI/4xcRDffel7hdE4ZgLHi/e60FRqpQkvaKPZI0jSfPE eSpWwEHe0VWNjpJFkXUvgQddPfIBbVSML/9IiCgsRW3AVqSjFi0lvCDGnA5A9X//PP 8hewp/LLn1WxCQ4/2yBzmhr+Cj9U2yq1Pxyel1/Vq3MVqB4A+4b6YS5DG3Y6UKrsOt 6sn7E7PZgRiPQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , Masami Hiramatsu , Mathieu Desnoyers , Steven Rostedt , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH 18/28] mm/damon: trace probe_hits Date: Mon, 18 May 2026 16:41:06 -0700 Message-ID: <20260518234119.97569-19-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Introduce a new tracepoint for exposing the per-region per-probe positive sample count via tracefs. Signed-off-by: SeongJae Park --- include/trace/events/damon.h | 38 ++++++++++++++++++++++++++++++++++++ mm/damon/core.c | 9 +++++++++ 2 files changed, 47 insertions(+) diff --git a/include/trace/events/damon.h b/include/trace/events/damon.h index 7e25f4469b81b..78388538acf44 100644 --- a/include/trace/events/damon.h +++ b/include/trace/events/damon.h @@ -130,6 +130,44 @@ TRACE_EVENT(damon_monitor_intervals_tune, TP_printk("sample_us=3D%lu", __entry->sample_us) ); =20 +TRACE_EVENT_CONDITION(damon_region_aggregated, + + TP_PROTO(unsigned int target_id, struct damon_region *r, + unsigned int nr_regions, unsigned int nr_probes), + + TP_ARGS(target_id, r, nr_regions, nr_probes), + + TP_CONDITION(nr_probes > 0), + + TP_STRUCT__entry( + __field(unsigned long, target_id) + __field(unsigned long, start) + __field(unsigned long, end) + __field(unsigned int, nr_regions) + __field(unsigned int, nr_accesses) + __field(unsigned int, age) + __dynamic_array(unsigned char, probe_hits, nr_probes) + ), + + TP_fast_assign( + __entry->target_id =3D target_id; + __entry->start =3D r->ar.start; + __entry->end =3D r->ar.end; + __entry->nr_regions =3D nr_regions; + __entry->nr_accesses =3D r->nr_accesses; + __entry->age =3D r->age; + memcpy(__get_dynamic_array(probe_hits), r->probe_hits, + sizeof(*r->probe_hits) * nr_probes); + ), + + TP_printk("target_id=3D%lu nr_regions=3D%u %lu-%lu: %u %u probe_hits=3D%s= ", + __entry->target_id, __entry->nr_regions, + __entry->start, __entry->end, + __entry->nr_accesses, __entry->age, + __print_hex(__get_dynamic_array(probe_hits), + __get_dynamic_array_len(probe_hits))) +); + TRACE_EVENT(damon_aggregated, =20 TP_PROTO(unsigned int target_id, struct damon_region *r, diff --git a/mm/damon/core.c b/mm/damon/core.c index 433da8781e255..5ba7ad4df4351 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1908,6 +1908,13 @@ static void kdamond_reset_aggregated(struct damon_ct= x *c) { struct damon_target *t; unsigned int ti =3D 0; /* target's index */ + unsigned int nr_probes =3D 0; + struct damon_probe *probe; + + if (trace_damon_region_aggregated_enabled()) { + damon_for_each_probe(probe, c) + nr_probes++; + } =20 damon_for_each_target(t, c) { struct damon_region *r; @@ -1916,6 +1923,8 @@ static void kdamond_reset_aggregated(struct damon_ctx= *c) int i; =20 trace_damon_aggregated(ti, r, damon_nr_regions(t)); + trace_damon_region_aggregated(ti, r, + damon_nr_regions(t), nr_probes); damon_warn_fix_nr_accesses_corruption(r); r->last_nr_accesses =3D r->nr_accesses; r->nr_accesses =3D 0; --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 A5F6936EA9F; Mon, 18 May 2026 23:41:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147690; cv=none; b=D96w2WI8EQZgYNftrfNQM0cG8Ja93FNFKGaoZ6UKfL1UnuGr1bHnUxOT2nsO70U+kmxCAr8wJ/kM7h/J4vsPMXuMzTaWC5ZIatQ+EYA1dkWiKYuVP1rtPHSWEQqA9vZjMQ7ozJfG2u+2DNya8rE5d7uX+6b8TqJOqGghvABe8gw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147690; c=relaxed/simple; bh=EauBIBzKjl6rFCRlEGSo/s6NrgLL9HoVh8TIqUsq9vs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=EKo903l8Zaw9fUZlzaB/DiY7vffpY3YcB+BbXq7WjfHJSaiHxA+zS2BauglYE9RN5Mo+R4oE4jXEZ/opvrFgNjCXuGAci4iyFMYlbam9E9QkqZNt0p3ezlSlMdmdp1Zo7juuN23SPcyzVZZNMuLGs7KrUiT8DVkHpDpLNSj07oo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=GAqdjbTt; 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="GAqdjbTt" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 329DEC2BCB8; Mon, 18 May 2026 23:41:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147690; bh=EauBIBzKjl6rFCRlEGSo/s6NrgLL9HoVh8TIqUsq9vs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GAqdjbTtt4J592f5rknZPYg4bEy3S6qGxaMY2eqzUkrPLo7adPWZoZWmoR8Pj1lLX dombct2THm3bxFohjssz3OVixZpijTWCsHo0Dop1h6i1PZhUaA1TzQZ0ff5iRjIrhX jfLBNj/j42cmRh9tpjYPhzcC22bMIGsvou0C3AVJHeTDnRxJt/TSLaHJ+FqA5+PsBb s9oThTX8KBpju+wPm9Wah7BX/AbXifDKKPwmLocz+RbtIiSt7y6oC8wmHdP8Yy27Wn eGXde//yUTUzrXqnj02/C4I4OFtdSwIrX4qP/o6Sg+5rtr2sbSKwU60sD09zYXgdUJ PcOz4kGZCmYJA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , Shuah Khan , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 19/28] selftests/damon/sysfs.sh: test probes dir Date: Mon, 18 May 2026 16:41:07 -0700 Message-ID: <20260518234119.97569-20-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Add simple existence tests for data probes sysfs directories and files. Signed-off-by: SeongJae Park --- tools/testing/selftests/damon/sysfs.sh | 48 ++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/tools/testing/selftests/damon/sysfs.sh b/tools/testing/selftes= ts/damon/sysfs.sh index 83e3b7f63d81c..1ac3e2ce8e448 100755 --- a/tools/testing/selftests/damon/sysfs.sh +++ b/tools/testing/selftests/damon/sysfs.sh @@ -291,11 +291,59 @@ test_intervals() ensure_file "$intervals_dir/update_us" "exist" "600" } =20 +test_damon_filter() +{ + damon_filter_dir=3D$1 + ensure_file "$damon_filter_dir/type" "exist" "600" + ensure_write_succ "$damon_filter_dir/type" "anon" "valid input" + ensure_write_fail "$damon_filter_dir/type" "foo" "invalid input" + ensure_file "$damon_filter_dir/matching" "exist" "600" + ensure_file "$damon_filter_dir/allow" "exist" "600" +} + +test_damon_filters() +{ + filters_dir=3D$1 + ensure_dir "$filters_dir" "exist" + ensure_file "$filters_dir/nr_filters" "exist" "600" + ensure_write_succ "$filters_dir/nr_filters" "1" "valid input" + test_damon_filter "$filters_dir/0" + + ensure_write_succ "$filters_dir/nr_filters" "2" "valid input" + test_damon_filter "$filters_dir/0" + test_damon_filter "$filters_dir/1" + + ensure_write_succ "$filters_dir/nr_filters" "0" "valid input" + ensure_dir "$filters_dir/0" "not_exist" + ensure_dir "$filters_dir/1" "not_exist" +} + +test_probe() +{ + probe_dir=3D$1 + ensure_dir "$probe_dir" "exist" + test_damon_filters "$probe_dir/filters" +} + +test_probes() +{ + probes_dir=3D$1 + ensure_dir "$probes_dir" "exist" + ensure_file "$probes_dir/nr_probes" "exist" "600" + + ensure_write_succ "$probes_dir/nr_probes" "1" "valid input" + test_probe "$probes_dir/0" + + ensure_write_succ "$probes_dir/nr_probes" "0" "valid input" + ensure_dir "$probes_dir/0" "not_exist" +} + test_monitoring_attrs() { monitoring_attrs_dir=3D$1 ensure_dir "$monitoring_attrs_dir" "exist" test_intervals "$monitoring_attrs_dir/intervals" + test_probes "$monitoring_attrs_dir/probes" test_range "$monitoring_attrs_dir/nr_regions" } =20 --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 3F137380FC7; Mon, 18 May 2026 23:41:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147691; cv=none; b=RPrvboIPMs5LfI5zJB8ilj6go4rf5QjWrxM4SM1cfFfKzpeeBajihNLHkDa+if0Lxu22JT+0ZdPZ6xfIfFZi1SSTkv4PbysPVIHlXbUwfFFcGz9KGsKyHZ61Ho2Ocb46vQ2EB2tkPKd/SkBJcPfJuwTfHcuoHysVQPI2J7RAXnY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147691; c=relaxed/simple; bh=HNm5gFPN8L1pKPA5WaPz2373LNJLSB/ziwePPyhOuX0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=LDigNal+nJYETJWrCnm6hannj6EBmZawrMzsaZAmpRIGSwXgn+OIgPVfRrB+IyuGafotYJP14WF4cTLHfKQAuUXhMLIenRVRfiU8/nmvWN7dt+oqWqXhmOuTyliK0G1yXxJ0xO3So3LXG4Cwdh929IcYPtmh5t0aiY0OB0D4q88= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=I9+4AJ+2; 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="I9+4AJ+2" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 99FBBC2BCF5; Mon, 18 May 2026 23:41:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147691; bh=HNm5gFPN8L1pKPA5WaPz2373LNJLSB/ziwePPyhOuX0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=I9+4AJ+2XpHGhfvlIpE0FVIE828/xPDXuXC2l4CBlXz+S3sJcPiVNjgK8MUgFC7f5 /loBhwXTsjpsiTpcEAIMx2qenw+KXYigVPTwpVj7hKj16msneT7LLIyDci4sU08Nc4 E1YSpgcWxCF4y2KHOwxj3yaup7Xd2mCxxEunhFSPII6A5GzPZBL2LQSqkGA76IGU8R HOIg8OUH/Um701A46JC1GOdqvzak7u14vvnq3fX2JuT8+4x9sSP3DBCExpxAKMoG5+ sR0vuLYTqiu6ap8hgW1JA35l40Xr4UZYCfseDDcTM00WdH1Ivy2qxBX3Q6xDBmtrsK IoxXCF/rSLf2w== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , "Liam R. Howlett" , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Shuah Khan , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 20/28] Docs/mm/damon/design: document data attributes monitoring Date: Mon, 18 May 2026 16:41:08 -0700 Message-ID: <20260518234119.97569-21-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Update DAMON design document for newly added data attributes monitoring feature. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 37 +++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index faea09dc88d63..7fcb726263c1a 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -276,6 +276,43 @@ interval``, DAMON checks if the region's size and acce= ss frequency (``nr_accesses``) has significantly changed. If so, the counter is reset = to zero. Otherwise, the counter is increased. =20 +Data Attributes Monitoring +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Data access pattern is only one type of data attributes. In some use case= s, +users need to know more data attributes information. For example, users m= ay +need to know how much of a given hot or cold memory region is backed by +anonymous pages, or belong to a specific cgroup. For such use case, data +attributes monitoring feature is provided. + +Using the feature, users can register data attributes of their interest to= the +DAMON :ref:`context `. = The +registration is made by specifying a probe per attribute. Each of the pro= be +specifies a rule to determine if a given memory region has the related +attribute. The rule is constructed with multiple filters. The filters wo= rk +same to :ref:`DAMOS filters ` except the suppo= rted +filter types. Currently only ``anon`` filter type is supported for data +attributes monitoring. + +If such probes are registered, DAMON executes the probes for each region's +sampling memory when it does the access :ref:`sampling +`. The number of samples that identif= ied +as having the data attribute (hitting the probe) per :ref:`aggregation int= erval +` is accounted in a per-region per-probe counter. +Users can therefore know how much of a given DAMON region has a specific d= ata +attribute by reading the per-region per-probe probe hits counter after each +aggregation interval. + +This is a sampling based mechanism. Hence, it is lightweight but the outp= ut +may include some measurement errors. The output should be used with good +understanding of statistics. + +Another way to do this for higher accuracy is using :ref:`DAMOS filter +` with ``stat`` :ref:`action +` and ``sz_ops_filter_passed`` :ref:`stat +`. This approach provides the data attributes +information in page level. But, because it is operated in page level, the +overhead is proportional to the size of the memory. =20 Dynamic Target Space Updates Handling ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 E2CDE3955ED; Mon, 18 May 2026 23:41:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; cv=none; b=jZ4Wbbt91W9JF+5OCoFPYl/UmUQz2ewMP+Vp1qk0X7Iy2fN9Se6nX/QBu9TmJRjIt5hGNQHBEaw9PlZ/IixD/OLZdlsrkGYdf/E9DoIlX+DJoNCXXdubNQByvIcGO51r+SAijLiEGsGXMP5bNGgErUa5nIN7pOkFt0p8fjcQdtY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; c=relaxed/simple; bh=7jjwSTj0oWvjONIEU6hizSouOGWRpTuxqy3LQsj9UQc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=RWSN4v+nLEDau07cA5eI679oEMTSBCxUjpogXA7HyJFS5+gYiQuTQtg0N7SaLDCgRjlSnymFG8SAKcluzilHXKANOB2JrVeXK3iloonwdYWEb/CKDpQnYaLN6TmOfSwZtYNvfjMftV8SY/h5i20tPCq72rFmTR8GXr6wEJPQ2Ns= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=kYki/Wx0; 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="kYki/Wx0" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4BF72C2BCB8; Mon, 18 May 2026 23:41:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147691; bh=7jjwSTj0oWvjONIEU6hizSouOGWRpTuxqy3LQsj9UQc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=kYki/Wx0XXVJgKBiW6cFEviE1oaaTeAmamUswBb7Nj79oB4pX/QV4+bmAo8ErWIMF LQ7PR0kapL/4lP90Bkcu1srMFcPDP3GRpljYT+oafXfi4rBfXr145kGW9teb+RrNr7 5Qoh3qXYWOkWclcotzKkKarSeLE03ubHKXWFY1KyFXMXeKv21/ikR+IbsPrUaldnAG xsJxq/j62exPyjowPIXpvW33jm1KcLzqa1abnFFFhFEySpHtNNv3FaOMI1wIqG3oVt tmjjcDu9e+jj7WT4v6D7YLWL+eLzTtY9cKgagm4xTUHXw4eheLCI/Xk1wEPlL06Rvv RqWIOSgzqgMzA== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , "Liam R. Howlett" , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Shuah Khan , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 21/28] Docs/admin-guide/mm/damon/usage: document data attributes monitoring Date: Mon, 18 May 2026 16:41:09 -0700 Message-ID: <20260518234119.97569-22-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Update DAMON usage document for the newly added data attributes monitoring feature. Signed-off-by: SeongJae Park --- Documentation/admin-guide/mm/damon/usage.rst | 44 ++++++++++++++++++-- Documentation/mm/damon/design.rst | 2 + 2 files changed, 43 insertions(+), 3 deletions(-) diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/a= dmin-guide/mm/damon/usage.rst index c74dfa0ff3bfb..abd38385b3c23 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -72,6 +72,11 @@ comma (","). =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 intervals/= sample_us,aggr_us,update_us =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = intervals_goal/access_bp,aggrs,min_sample_us,max_sample_us =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 nr_regions= /min,max + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`prob= es `/nr_probes + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = 0/filters/nr_filters + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 0/type,matching,allow + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 ... + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = ... =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`targets `/nr_targets =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`0 `/pid_target,obsolete_target =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = :ref:`regions `/nr_regions @@ -98,6 +103,9 @@ comma (","). =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = :ref:`stats `/nr_tried,sz_tried,nr_applied,sz_applied,= sz_ops_filter_passed,qt_exceeds,nr_snapshots,max_nr_snapshots =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = :ref:`tried_regions `/total_bytes =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 0/start,end,nr_accesses,age,sz_filter_passed + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 =E2=94=82 probes + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 =E2=94=82 =E2=94=82 0/hits + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 =E2=94=82 =E2=94=82 ... =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 ... =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 ... =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 ... @@ -227,8 +235,8 @@ contexts//monitoring_attrs/ =20 Files for specifying attributes of the monitoring including required quali= ty and efficiency of the monitoring are in ``monitoring_attrs`` directory. -Specifically, two directories, ``intervals`` and ``nr_regions`` exist in t= his -directory. +Specifically, three directories, ``intervals``, ``nr_regions`` and ``probe= s`` +exist in this directory. =20 Under ``intervals`` directory, three files for DAMON's sampling interval (``sample_us``), aggregation interval (``aggr_us``), and update interval @@ -262,6 +270,27 @@ tuning-applied current values of the two intervals can= be read from the ``sample_us`` and ``aggr_us`` files after writing ``update_tuned_intervals= `` to the ``state`` file. =20 +.. _damon_usage_sysfs_probes: + +contexts//monitoring_attrs/probes/ +------------------------------------- + +A directory for registering :ref:`data attributes monitoring +` probes. + +In the beginning, this directory has only one file, ``nr_probes``. Writin= g a +number (``N``) to the file creates the number of child directories named `= `0`` +to ``N-1``. Each directory represents each monitoring probe. + +In each probe directory, one directory, ``filters`` exists. The directory +contains files for installing filters for the probe, that is used to deter= mine +the data attribute for the probe. + +In the beginning, ``filters`` directory has only one file, ``nr_filters``. +Writing a number (``N``) to the file creates the number of child directori= es +named ``0`` to ``N-1``. Each directory represents each filter and works i= n a +way similar to that for :ref:`DAMOS filter `. + .. _sysfs_targets: =20 contexts//targets/ @@ -615,10 +644,19 @@ tried_regions// ------------------ =20 In each region directory, you will find five files (``start``, ``end``, -``nr_accesses``, ``age``, and ``sz_filter_passed``). Reading the files wi= ll +``nr_accesses``, ``age`` and ``sz_filter_passed``). Reading the files will show the properties of the region that corresponding DAMON-based operation scheme ``action`` has tried to be applied. =20 +tried_regions//probes/ +------------------------- + +In each region directory, one directory (``probes``) also exists. In the +directory, subdirectories named ``0`` to ``N-1`` exists. ``N`` is the num= ber +of installed probes. In each number-named directory, a file (``hits``) ex= ist. +Reading the file shows the number of data attributes monitoring probe-hit +positive samples of the region. + Example ~~~~~~~ =20 diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index 7fcb726263c1a..937960d2b6d73 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -276,6 +276,8 @@ interval``, DAMON checks if the region's size and acces= s frequency (``nr_accesses``) has significantly changed. If so, the counter is reset = to zero. Otherwise, the counter is increased. =20 +.. _damon_design_data_attrs_monitoring: + Data Attributes Monitoring ~~~~~~~~~~~~~~~~~~~~~~~~~~ =20 --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 3F2CB399031; Mon, 18 May 2026 23:41:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; cv=none; b=kr3A8jlGRMmX3r5LQ55AIpsuIoERFUeyOu7vTSJsjKCvRKO1iHskWRGgeENB2NCe7hwT2dPYkiI0v45rc5JfZbOqnxgXNWxuZFj5kndNtiO1FmBKOssemkyGsKw9s1V7oShiLs1KLkFKXJjbMa+uSyfrG91eGI2fS52itPgUkOw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; c=relaxed/simple; bh=6FCGqtqPK1Y1yCXdyueYRDbO5bOOUBp7eJYagnQ/2uA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=jfFLetoC/ARJ0xW2wDpbhR9OYIMX6EExm/kakxPnYLrQDhjEj+D8oBex1/DU8N9erx1HCb2XzRfSUUGUT2GLnBZUPycoLuhU6nsJdWhuhC3L3JvD/ZW2IwVvgCKl5l26CZf7C0d8hYDIKzw+F8Wxl5xQfxcrYmzk+7CREehLTFg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Sv28qGD1; 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="Sv28qGD1" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EE061C2BCB7; Mon, 18 May 2026 23:41:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147692; bh=6FCGqtqPK1Y1yCXdyueYRDbO5bOOUBp7eJYagnQ/2uA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Sv28qGD1fBC1oWwlOv+NYk3ZPwvyCCq+0pmn0h12YcRr9a6RTz4X7Fuf7CrZVMx5M 1v7Qd/Zxj7SlJxxCeo1l35krA2BFOocZ2pHjLterqnyfw+8OCWwjGxJ0LI+XSAyoT8 Y7ynJDO/U8VSNu8e741JTrvfAOo+BDGxP/l1MThFLPl58R4PGgKebYDC+e13eUm5DU 89XBTH2i4eTFRKMApT+F/CaDzBd/t0jvvs0TgC4T+M+5Re1CvDCPR5cLiAJNeniBhC FzJup3NIpnrZAphhx7RoloYSOLXCacq904GFuApJ5zZbtIjpuGXGTy8UQ9sU+Ok5D1 Ip06a09ta9vWQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 22/28] mm/damon/core: introduce DAMON_FILTER_TYPE_MEMCG Date: Mon, 18 May 2026 16:41:10 -0700 Message-ID: <20260518234119.97569-23-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Belonging memory cgoup is another data attribute that can be useful to monitor. Introduce a new DAMON filter type, namely DAMON_FILTER_TYPE_MEMCG, for monitoring of this attribute. Signed-off-by: SeongJae Park --- include/linux/damon.h | 6 ++++++ mm/damon/core.c | 14 ++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 1fb271a35e98f..6a54c601889bd 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -742,9 +742,11 @@ struct damon_intervals_goal { * enum damon_filter_type - Type of &struct damon_filter * * @DAMON_FILTER_TYPE_ANON: Anonymous pages. + * @DAMON_FILTER_TYPE_MEMCG: Specific memcg's pages. */ enum damon_filter_type { DAMON_FILTER_TYPE_ANON, + DAMON_FILTER_TYPE_MEMCG, }; =20 /** @@ -753,12 +755,16 @@ enum damon_filter_type { * @type: Type of the region. * @matching: Whether this filter is for the type-matching ones. * @allow: Whether the @type-@matching ones should pass this filter. + * @memcg_id: Memcg id of the question if @type is DAMON_FILTER_MEMCG. * @list: Siblings list. */ struct damon_filter { enum damon_filter_type type; bool matching; bool allow; + union { + u64 memcg_id; + }; struct list_head list; }; =20 diff --git a/mm/damon/core.c b/mm/damon/core.c index 5ba7ad4df4351..4fc90b0bdac88 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1433,6 +1433,13 @@ static void damon_commit_filter(struct damon_filter = *dst, dst->type =3D src->type; dst->matching =3D src->matching; dst->allow =3D src->allow; + switch (dst->type) { + case DAMON_FILTER_TYPE_MEMCG: + dst->memcg_id =3D src->memcg_id; + break; + default: + break; + } } =20 static int damon_commit_filters(struct damon_probe *dst, @@ -1457,6 +1464,13 @@ static int damon_commit_filters(struct damon_probe *= dst, src_filter->matching, src_filter->allow); if (!new_filter) return -ENOMEM; + switch (src_filter->type) { + case DAMON_FILTER_TYPE_MEMCG: + new_filter->memcg_id =3D src_filter->memcg_id; + break; + default: + break; + } damon_add_filter(dst, new_filter); } return 0; --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 C60BE3A256C; Mon, 18 May 2026 23:41:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; cv=none; b=FXgNH8S+0nvZZHQHKKtYXqjbCHODGnLOpodJ1pwteDHhwL0JqUrkatWqaZZ9mHweySeXeTfh3jGSL4q5V8UoZGmIdjyI1p6dSIEIRUVjQx/bNsZgjbdXrtbtrd9ZhM289zchC5l4OVDm8RG4DwsYMSStBARJtWkIpdvkToziIB4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; c=relaxed/simple; bh=nQkVs1zWTxTfa8xwvc1gaYrxiOp7sl8ZruOo6hvwVAc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=HI7t0AIb2lbAScww1GFkibFHma+EOsDQiiCvBtrwhnKKGQzc4pyGAq4Z6AG5YPUabsqcBq0ii2GMKXYeaBNV0nx0Lh+EBnuKE28lscZHErpx09k9JAK0Oj2wySdp80BpTr/FmMNDg81zQqtTxQOb7eiUUjXjQ1cimtVl8DVb+fU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=pkfPHVX7; 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="pkfPHVX7" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 49151C2BCB8; Mon, 18 May 2026 23:41:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147692; bh=nQkVs1zWTxTfa8xwvc1gaYrxiOp7sl8ZruOo6hvwVAc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pkfPHVX7GX8aIMQ/kJ/GD5EiTwpxljO4R8nUKMySnXQ9Vb+lulnQBcBIW/nNx2C4m ClZoKjHJxKswAPf0joekMlk+8v0v/EcSa3o3mQKfLv3Ar52wfMDr8BD+yelnCCNxIE JK2PiqCCw47a0Gilz4unDa3f46dCO/7Od9kBIR3pK9I0AtPfwjlBKou8sro1cq+v4c WMwCJLs4ae4KK6G7lrM68CS8PIi17wGbjrlNK4m42Eep1f/ShmlBqddY3ucSqHquHX tgrLIMXbARD07N0DVWPGPDM7zK2GsKQjvV54K/Kp/onV0anElv6sHl8GwY0UFczpvU c+se8nMtaPYtw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 23/28] mm/damon/paddr: support DAMON_FILTER_TYPE_MEMCG Date: Mon, 18 May 2026 16:41:11 -0700 Message-ID: <20260518234119.97569-24-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 the support of DAMON_FILTER_TYPE_MEMCG on the DAMON operation set implementation for the physical address space. Signed-off-by: SeongJae Park --- mm/damon/paddr.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c index 9997c5174ef1b..d0598f5f26882 100644 --- a/mm/damon/paddr.c +++ b/mm/damon/paddr.c @@ -124,6 +124,7 @@ static bool damon_pa_filter_match(struct damon_filter *= filter, struct folio *folio) { bool matched =3D false; + struct mem_cgroup *memcg; =20 switch (filter->type) { case DAMON_FILTER_TYPE_ANON: @@ -133,6 +134,19 @@ static bool damon_pa_filter_match(struct damon_filter = *filter, } matched =3D folio_test_anon(folio); break; + case DAMON_FILTER_TYPE_MEMCG: + if (!folio) { + matched =3D false; + break; + } + rcu_read_lock(); + memcg =3D folio_memcg_check(folio); + if (!memcg) + matched =3D false; + else + matched =3D filter->memcg_id =3D=3D mem_cgroup_id(memcg); + rcu_read_unlock(); + break; default: break; } --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 DEEA43A3826; Mon, 18 May 2026 23:41:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; cv=none; b=Oml7wcsHOmotmqAwaQEim+ndtAqA00JxIigt/P6ir2Ta4gbQ4Orv6jfVl39mkENbMC0+v7tnUmUxn+10QkfauD1yfBOn2OJfGsOYpATuO7EHRq6s81edc8C4Kc/MmBackqwMAUW+3JSqUEbiHMBEgmusL+F0zt8q3dSreCl5bpc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147692; c=relaxed/simple; bh=AGpRYvO9ZCNPMYMckm0cAjHmLCwWdiWl6GwH6dhHuCw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=L87Aj2ZcXjtvM+nSf5QFpQ7reP2P4sFuKvOGVDJ2r/KTJC7/daZUKZy3xn6Ss9XwJu607UXXpLuXEHSNtDKpNZ9CMVP4sLzaw9lOaqSSHDpDKp7BKGyUL6KIQEwfFkVdmM1f+d4y8lso/j1yWRhLJ98LuwphQ/11FOHnUQ9UFFs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=t7sLBbkI; 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="t7sLBbkI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 97959C2BCB7; Mon, 18 May 2026 23:41:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147692; bh=AGpRYvO9ZCNPMYMckm0cAjHmLCwWdiWl6GwH6dhHuCw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=t7sLBbkIOm43qO3O7T09C0xNfgkehYwnbWLABepbu5er81+Uv0T6aeWgA7jvDoG22 xnmmPma69N0hJG/ABB7sZ9bDgoVFB0BH95HkfjudigdbF0FCMcKmbA66EiggkXzZ7/ Df8rXsPrHeWTBCh6E1AxZhsf2RyRXZKyxXF3p0PrE/VuAOhLd8Ukk+pWt3xdgWuj9P +/mi+D1mKP2jA4Y6ed2tAlXJiAIdxKJaKbfFMGQXTdGO+NeUNpW2mrXiS1iPr+SG7i +tVR1A5gWWw0xsquh2zJe5KiYi95zvnd6rPEscl0nIBGPhwh4gh35jXHCIS+pZFhru CVt8gTD4Ugzeg== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 24/28] mm/damon/sysfs: add filters//path file Date: Mon, 18 May 2026 16:41:12 -0700 Message-ID: <20260518234119.97569-25-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Introduce a new DAMON sysfs file for letting users setup the target memory cgroup of the belonging memory cgroup attribute monitoring. The file is named 'path', located under the probe filter directory. Users can set the target memory cgroup by writing the path to the memory cgroup from the cgroup mount point to the file. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index eeb7fdd030cf0..0f6379caf4816 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -756,6 +756,7 @@ struct damon_sysfs_filter { enum damon_filter_type type; bool matching; bool allow; + char *path; }; =20 static struct damon_sysfs_filter *damon_sysfs_filter_alloc(void) @@ -774,6 +775,10 @@ damon_sysfs_filter_type_names[] =3D { .type =3D DAMON_FILTER_TYPE_ANON, .name =3D "anon", }, + { + .type =3D DAMON_FILTER_TYPE_MEMCG, + .name =3D "memcg", + }, }; =20 static ssize_t type_show(struct kobject *kobj, @@ -862,11 +867,46 @@ static ssize_t allow_store(struct kobject *kobj, return count; } =20 +static ssize_t path_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + int len; + + if (!mutex_trylock(&damon_sysfs_lock)) + return -EBUSY; + len =3D sysfs_emit(buf, "%s\n", filter->path ? filter->path : ""); + mutex_unlock(&damon_sysfs_lock); + return len; +} + +static ssize_t path_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_filter *filter =3D container_of(kobj, + struct damon_sysfs_filter, kobj); + char *path =3D kmalloc_objs(*path, size_add(count, 1)); + + if (!path) + return -ENOMEM; + strscpy(path, buf, size_add(count, 1)); + if (!mutex_trylock(&damon_sysfs_lock)) { + kfree(path); + return -EBUSY; + } + kfree(filter->path); + filter->path =3D path; + mutex_unlock(&damon_sysfs_lock); + return count; +} + static void damon_sysfs_filter_release(struct kobject *kobj) { struct damon_sysfs_filter *filter =3D container_of(kobj, struct damon_sysfs_filter, kobj); =20 + kfree(filter->path); kfree(filter); } =20 @@ -879,10 +919,14 @@ static struct kobj_attribute damon_sysfs_filter_match= ing_attr =3D static struct kobj_attribute damon_sysfs_filter_allow_attr =3D __ATTR_RW_MODE(allow, 0600); =20 +static struct kobj_attribute damon_sysfs_filter_path_attr =3D + __ATTR_RW_MODE(path, 0600); + static struct attribute *damon_sysfs_filter_attrs[] =3D { &damon_sysfs_filter_type_attr.attr, &damon_sysfs_filter_matching_attr.attr, &damon_sysfs_filter_allow_attr.attr, + &damon_sysfs_filter_path_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_filter); --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 3F05F3AA4E2; Mon, 18 May 2026 23:41:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147693; cv=none; b=EWmct4XXDGhkvA9lJbLqNSu7tJdpnk7QS3XDTjE33k5N9MfGGsBuRf8MAaA+Zj8xCDzY3B5VuoyUQRrNsYhGAn1OhnvoZXTVwMZRxf0MaQ+tr8PVABcw0AD8dE4X3GjkfDaJpke9BgsfzRXLTwhwcRYzbdH78NhuGxtEVZq2NhM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147693; c=relaxed/simple; bh=3s3z69DVFkBSKLZyIG6U8q13xayntuiDZ22yXUYaX4Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=P1e5RIoGm4D4WW1y7eMGZttlmHjpddNjVXqiZhnE+cSPlMBg0Fg9M51gTx4LqxdRq9pt6f6AAMZYmj5PyHT8ZDpZ1sayf2dEFr6QjcM5RnIz4vGu827QCG5ZLgAMJQsU+UCBu4dAq8AobmLLqrK5/c66yyIU+6/DYabEuDt59nw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=o/Cy9yu6; 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="o/Cy9yu6" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EA329C2BCB8; Mon, 18 May 2026 23:41:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147693; bh=3s3z69DVFkBSKLZyIG6U8q13xayntuiDZ22yXUYaX4Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=o/Cy9yu6wDJmrd5LvgJQlhFZQKQMd+FYHdPtHHdwH8LcfwzNqCgCi7UvFFMBoh1J6 FBk/AYuGD4CtsTAx+LMzhNWYHGHl+499fKP4ZJFHY1oZ/mcVOZtJ+HW5Weo1T6ksyU hoCgRdPQuOHxzHx6H9dvxkjdnOBssO4xAUM6nk4hwkiLTSbS/AeYgzQdrJqpHs+JN9 1hE6NwrYoi2hw4/xGwp+CK93A88XaqglyB27Y1vsAtX6bWDphgIl4+J3p8UtrhYvhq qe+wFKoBU+tEuJVVBLhVjVkWrHVQThGD4k5SltvkxRAhcpqCaH5kh1wzs5Z8yBTID6 DfhKcR6rmaJhQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 25/28] mm/damon/sysfs-schemes: move memcg_path_to_id() to sysfs-common Date: Mon, 18 May 2026 16:41:13 -0700 Message-ID: <20260518234119.97569-26-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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 next commit will need to find the memcg id from the user-passed path to the memory cgroup, from sysfs.c. memcg_path_to_id() is doing that, but defined in sysfs-schemes.c as a static function. Move the function to sysfs-common.c and mark it as non-static, so that the next commit can reuse the function. Signed-off-by: SeongJae Park --- mm/damon/sysfs-common.c | 41 ++++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs-common.h | 2 ++ mm/damon/sysfs-schemes.c | 41 ---------------------------------------- 3 files changed, 43 insertions(+), 41 deletions(-) diff --git a/mm/damon/sysfs-common.c b/mm/damon/sysfs-common.c index 83e24a9b5a0db..bdc6ae2639e4f 100644 --- a/mm/damon/sysfs-common.c +++ b/mm/damon/sysfs-common.c @@ -104,3 +104,44 @@ const struct kobj_type damon_sysfs_ul_range_ktype =3D { .default_groups =3D damon_sysfs_ul_range_groups, }; =20 + +static bool damon_sysfs_memcg_path_eq(struct mem_cgroup *memcg, + char *memcg_path_buf, char *path) +{ +#ifdef CONFIG_MEMCG + cgroup_path(memcg->css.cgroup, memcg_path_buf, PATH_MAX); + if (sysfs_streq(memcg_path_buf, path)) + return true; +#endif /* CONFIG_MEMCG */ + return false; +} + +int damon_sysfs_memcg_path_to_id(char *memcg_path, u64 *id) +{ + struct mem_cgroup *memcg; + char *path; + bool found =3D false; + + if (!memcg_path) + return -EINVAL; + + path =3D kmalloc_array(PATH_MAX, sizeof(*path), GFP_KERNEL); + if (!path) + return -ENOMEM; + + for (memcg =3D mem_cgroup_iter(NULL, NULL, NULL); memcg; + memcg =3D mem_cgroup_iter(NULL, memcg, NULL)) { + /* skip offlined memcg */ + if (!mem_cgroup_online(memcg)) + continue; + if (damon_sysfs_memcg_path_eq(memcg, path, memcg_path)) { + *id =3D mem_cgroup_id(memcg); + found =3D true; + mem_cgroup_iter_break(NULL, memcg); + break; + } + } + + kfree(path); + return found ? 0 : -EINVAL; +} diff --git a/mm/damon/sysfs-common.h b/mm/damon/sysfs-common.h index 2099adee11d05..3079306966a91 100644 --- a/mm/damon/sysfs-common.h +++ b/mm/damon/sysfs-common.h @@ -59,3 +59,5 @@ int damos_sysfs_set_quota_scores(struct damon_sysfs_schem= es *sysfs_schemes, void damos_sysfs_update_effective_quotas( struct damon_sysfs_schemes *sysfs_schemes, struct damon_ctx *ctx); + +int damon_sysfs_memcg_path_to_id(char *memcg_path, u64 *id); diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c index e25f4824b72fd..329cfd0bbe9f3 100644 --- a/mm/damon/sysfs-schemes.c +++ b/mm/damon/sysfs-schemes.c @@ -2791,47 +2791,6 @@ const struct kobj_type damon_sysfs_schemes_ktype =3D= { .default_groups =3D damon_sysfs_schemes_groups, }; =20 -static bool damon_sysfs_memcg_path_eq(struct mem_cgroup *memcg, - char *memcg_path_buf, char *path) -{ -#ifdef CONFIG_MEMCG - cgroup_path(memcg->css.cgroup, memcg_path_buf, PATH_MAX); - if (sysfs_streq(memcg_path_buf, path)) - return true; -#endif /* CONFIG_MEMCG */ - return false; -} - -static int damon_sysfs_memcg_path_to_id(char *memcg_path, u64 *id) -{ - struct mem_cgroup *memcg; - char *path; - bool found =3D false; - - if (!memcg_path) - return -EINVAL; - - path =3D kmalloc_array(PATH_MAX, sizeof(*path), GFP_KERNEL); - if (!path) - return -ENOMEM; - - for (memcg =3D mem_cgroup_iter(NULL, NULL, NULL); memcg; - memcg =3D mem_cgroup_iter(NULL, memcg, NULL)) { - /* skip offlined memcg */ - if (!mem_cgroup_online(memcg)) - continue; - if (damon_sysfs_memcg_path_eq(memcg, path, memcg_path)) { - *id =3D mem_cgroup_id(memcg); - found =3D true; - mem_cgroup_iter_break(NULL, memcg); - break; - } - } - - kfree(path); - return found ? 0 : -EINVAL; -} - static int damon_sysfs_add_scheme_filters(struct damos *scheme, struct damon_sysfs_scheme_filters *sysfs_filters) { --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 8C5073AD50D; Mon, 18 May 2026 23:41:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147693; cv=none; b=uV/rm0lUsaBC5Xh7dqlxb7Xv165WQbi/gMCvNWEaxPS+GTDAmz4zTA2Xaa2nUbZEVRTbgJzKRbNVWo/dvVzXOWnLhRVVd0qpBI+NgVjMevnyXqFVVoj89eNFsr4wSfkSaBcOhGLv5FKKwUmYmxVAGTyIJABj7I+YBqufJQoZt+U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147693; c=relaxed/simple; bh=6WMqOvniCqDfChPfJlN5gPjmRV0oSVQC/3h1Awn27/8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=KwM1d18ejvRaEgi9/Nxc3s/hm/DRfRz2MQGlfHkYbWSfRn5kiOL5BZsFqMaTBHy7y3C+HH1zu1jrUc1cRP1L8qRu4esDO9ZSVI5fpkxKUAk4rbq0KZCJde+hLuIGeoFFrXG+rkrjYXoovbVZhyebAkP5wIC5Eo4lioc8tiQLZNA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=nx7Y6cJy; 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="nx7Y6cJy" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 47486C2BCC7; Mon, 18 May 2026 23:41:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147693; bh=6WMqOvniCqDfChPfJlN5gPjmRV0oSVQC/3h1Awn27/8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=nx7Y6cJyf/Z+FfDkjViLsnVZQjjR/x4a6hle29GtyefXQ8KOem/yZu9D84oeZkCow brJZMwLSkRV1s8PEP7ICJK8cV9yF++/3ijIGWnetTeohbFfslS94JTfBuFhXwrVxT/ Frb08HxyZLHkS6S3ta+POYFOs25hy0wZu0f5XGnF4zHqeOSI3E1UrNt9R1S1XLo5t+ i1wwT+vcb22AacRZzfhL51l1M/DMvkkOV6n0HZ52/UZn7K8U3rPpL5tyuxPI2Odffq 0h3YXuE7nU7USn9cHzsNr3Fhj1SyHj22LCAjZafvWPufwfP9V2+FHWXj54xXvBS7yl VR8Gq+H7tF8gw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 26/28] mm/damon/sysfs: setup damon_filter->memcg_id from path Date: Mon, 18 May 2026 16:41:14 -0700 Message-ID: <20260518234119.97569-27-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Find and set the memcg_id for damon_filter from the user-passed memory cgroup path when updating the DAMON input parameters. Signed-off-by: SeongJae Park --- include/linux/damon.h | 1 + mm/damon/core.c | 2 +- mm/damon/sysfs.c | 11 +++++++++++ 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 6a54c601889bd..4014fd0d463cb 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -1006,6 +1006,7 @@ static inline unsigned long damon_sz_region(struct da= mon_region *r) struct damon_filter *damon_new_filter(enum damon_filter_type type, bool matching, bool allow); void damon_add_filter(struct damon_probe *probe, struct damon_filter *f); +void damon_destroy_filter(struct damon_filter *f); =20 struct damon_probe *damon_new_probe(void); void damon_add_probe(struct damon_ctx *ctx, struct damon_probe *probe); diff --git a/mm/damon/core.c b/mm/damon/core.c index 4fc90b0bdac88..68b3b4bbc8fc9 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -143,7 +143,7 @@ static void damon_free_filter(struct damon_filter *f) kfree(f); } =20 -static void damon_destroy_filter(struct damon_filter *f) +void damon_destroy_filter(struct damon_filter *f) { damon_del_filter(f); damon_free_filter(f); diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 0f6379caf4816..2e95e3bac774d 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1927,6 +1927,17 @@ static int damon_sysfs_set_probes(struct damon_ctx *= ctx, sys_filter->allow); if (!filter) return -ENOMEM; + if (filter->type =3D=3D DAMON_FILTER_TYPE_MEMCG) { + int err; + + err =3D damon_sysfs_memcg_path_to_id( + sys_filter->path, + &filter->memcg_id); + if (err) { + damon_destroy_filter(filter); + return err; + } + } damon_add_filter(c, filter); } } --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 91B433B19D2; Mon, 18 May 2026 23:41:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147694; cv=none; b=g4RpWNO8dJFRfNwC2K8nvviJCHjn9PUeVZUbUD5xpHfcz88fE9tnEBW/GSVe+k/fRCSE1qdx06ZZvxtSSaWiWTdbb2QLNDM0bdgVf4/Uf21sn1rh6gny9d0RA597Ads5vLlU14mZOXr1Ohzo7LhQ3BEaZ9n18GAWNrMypAT3HPQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147694; c=relaxed/simple; bh=nrsABmJnRfG9DLDHrsalCtHOuyMv2VWZvo4tqHnGPDk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Sqp1ROxgs/SSZTutXTy5GCAFugtyLLS0PcPJuWHmp37o8DOjPd/MWlppdYu4y87NptK/6tp1sKxNvlsRA0n+tI9G6/D9kvB+jg/bVX5pUak36g9knJvJaht9cxOvuli5lLvUjtnV89rsjHLdXwx+jNeUSsZv4FNM22CzQDJaP+g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=d49e4zgQ; 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="d49e4zgQ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9A08CC2BCB7; Mon, 18 May 2026 23:41:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147694; bh=nrsABmJnRfG9DLDHrsalCtHOuyMv2VWZvo4tqHnGPDk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=d49e4zgQExuGINRxEf5AWO8nZAgQXWtelBWGpn1NMEWBzaksn2d3KfKUKieotlrpt h4cwaSTq82DQ78IKrFyL4vrwbAAANtYApc45EkAKHec0cCfWKSoAFVqTJz4C4phgOp JkGOcScHZ9Gbb6SN+oD6pCnmPxCPaUfZ6Wsh6K4QtqyLmUkqACBAXwsex97lntkS4c bWfBiQFPEMh+0qUofHh5TfyXJ2/h51vsZJHzlka6yPmYMiXnjbIfAFJeNC/VbotLjc uB7786B+psNCQx49QDu4fqK6gD0hKvud+C5xjEczoZ5CDUCU9mLwtLUD2t0GKJ22Af hKQ/cykC4X+HQ== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , "Liam R. Howlett" , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Shuah Khan , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 27/28] Docs/mm/damon/design: update for memcg damon filter Date: Mon, 18 May 2026 16:41:15 -0700 Message-ID: <20260518234119.97569-28-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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" Update DAMON design document for the newly added belonging memory cgroup attribute monitoring feature. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index 937960d2b6d73..2da7ca0d3d17a 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -293,8 +293,8 @@ registration is made by specifying a probe per attribut= e. Each of the probe specifies a rule to determine if a given memory region has the related attribute. The rule is constructed with multiple filters. The filters wo= rk same to :ref:`DAMOS filters ` except the suppo= rted -filter types. Currently only ``anon`` filter type is supported for data -attributes monitoring. +filter types. Currently only ``anon`` and ``memcg`` filter types are supp= orted +for data attributes monitoring. =20 If such probes are registered, DAMON executes the probes for each region's sampling memory when it does the access :ref:`sampling --=20 2.47.3 From nobody Mon May 25 04:33:42 2026 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 E46463B2FFF; Mon, 18 May 2026 23:41:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147695; cv=none; b=TdzB9ZYfXjlmu7kgzooQJICNMWRt0VR9XRVAa83rJ3q1pW6PWPHYs2QN2W4lHKAWqvWZsSl7RTKBt+YQsQ26kXjxGn8F5ii+NPpVcNDm05v09z7GsmUxZdMrtuuRwPxPPoT7w5EEZUV8S1NE3ojOLMG8n9qf8uYKyks8APUfleI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779147695; c=relaxed/simple; bh=pPitw4Kbtb0sQtr+JQ+YU1RPjhVWQVsWpAxRL8y/Q/0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=DR5ypAGdkEhnu0o38yUEsjZPSWB34hGrD2IUeJsbSJpjNn6uYDnxqa6PJkgtsIcu5N6ozswSIRDLCKOJRmCu0GpSfToapFfZccA9b+aWy1Bd7BQMmF2MYmpuJqNJArU344QZjnjVJyCa75FnXbrsc6rUm+ojOJcwZtrTtxwG148= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=jPC2DPoC; 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="jPC2DPoC" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 481A2C2BCF7; Mon, 18 May 2026 23:41:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1779147694; bh=pPitw4Kbtb0sQtr+JQ+YU1RPjhVWQVsWpAxRL8y/Q/0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=jPC2DPoCuKdsge2wTxodAU12wBvMRo1AgrdbhCSONiJMpayPYlEm5Xn4XTMdbVFlb vBK+Qp3OluA8LCpioHbE8gV7xiZn6f8Jne4k79sDdK84wz4VrBMexS0cXEMRe05FU5 3s7kqk+v1pzMy77OvWQ0PnmPitreSd1TLFW7RH5zDoPXJs3l++q9f8omk/2HW1o7Zm OkiQwxqBrU09EwG9LaxyeGmufRIXw+xJ5+lfht68rMSLz/jUmNO1napv9I4uhawXEq xWsurm5mbO81RbgqFULgX+iHy8ZruUoCNxNR+pPbUdcBtlGJKOsq4LjFwAk/dl3j+w KLaI3RwRN8aVw== From: SeongJae Park To: Andrew Morton Cc: SeongJae Park , "Liam R. Howlett" , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Shuah Khan , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [PATCH 28/28] Docs/admin-guide/mm/damon/usage: update for memcg damon filter Date: Mon, 18 May 2026 16:41:16 -0700 Message-ID: <20260518234119.97569-29-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20260518234119.97569-1-sj@kernel.org> References: <20260518234119.97569-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-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Update DAMON usage document for the newly added belonging memory cgroup attribute monitoring feature. Signed-off-by: SeongJae Park --- Documentation/admin-guide/mm/damon/usage.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/a= dmin-guide/mm/damon/usage.rst index abd38385b3c23..d46875e603d86 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -74,7 +74,7 @@ comma (","). =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 nr_regions= /min,max =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`prob= es `/nr_probes =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = 0/filters/nr_filters - =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 0/type,matching,allow + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 0/type,matching,allow,path =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = =E2=94=82 ... =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 = ... =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`targets `/nr_targets @@ -289,7 +289,9 @@ the data attribute for the probe. In the beginning, ``filters`` directory has only one file, ``nr_filters``. Writing a number (``N``) to the file creates the number of child directori= es named ``0`` to ``N-1``. Each directory represents each filter and works i= n a -way similar to that for :ref:`DAMOS filter `. +way similar to that for :ref:`DAMOS filter `. When the fil= ter +``type`` is ``memcg``, ``path`` file acts as ``memcg_path`` for :ref:`DAMOS +filter `. =20 .. _sysfs_targets: =20 --=20 2.47.3