From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F1448319615; Mon, 8 Dec 2025 06:29:50 +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=1765175391; cv=none; b=bB0+GnWVbQ+O2pHD8AAtRRuPpRPc0B24FGL9NMBjRRMFjkWbAC5ZUOgs8Ve68xR+wT0Epto+XdctTJkHXQs+ojcBeVpidk+a4Mo/0s1X/NShj88pBoNwUm4hFreT3JSdQCNeJj6QuIucReAFoVY5OeVlpLIGC4kdQk7EwqbxuMs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175391; c=relaxed/simple; bh=ZxPuOve16IrlwUTG5ESII4iH+1SrqZ6IkyUiguVkjLE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Q8hOmim2fDIy2pvBTejjOJ5u74yZq9pL6uwTTxv1nyRHX0CeW7WJeKG4dJlebk1CHxKe+tI9xTA9SRfqCTCcsP2wvRGJZiVp1Ep16Q68D6yW5KZDs3cNB1jsNGlAtdYyhUhlsmjKlaZ6i0z5oymOsddRcayKmC5nj05ErV67ms4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=rVfo/zWF; 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="rVfo/zWF" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8CD43C116B1; Mon, 8 Dec 2025 06:29:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175390; bh=ZxPuOve16IrlwUTG5ESII4iH+1SrqZ6IkyUiguVkjLE=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=rVfo/zWFzj33IhJkSn+EyozYUUTyO623/XtYnG369BniJsYKzB4HGum70XDruWtdN ojCFPbh0qcnhxVBagiY2tJE0oL4lrOLicZTXRC89eew0ch4PnE+j4YZYtK+ILS8/kQ CxBv2zBRlHx4FqOTslKi7vkvI+tx+h5jJRNg+BAukN/0A3kHAJzUsxYZNHXlTd85k6 W9xdhrHRmqTSD86en4WZMI/e8McaIUmwqpgXCxeJul/RB2DOzfi537YDBOQ4oawV++ mG8vVzKh1IMbPE1N6kj8UvVU+FbD2dyM7rGJxDRekmosWf58pUq16xKx/g+cQKUwaL cWkwZNoS/3WKA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 01/37] mm/damon/core: implement damon_report_access() Date: Sun, 7 Dec 2025 22:29:05 -0800 Message-ID: <20251208062943.68824-2-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" To report access information to DAMON, DAMON API callers should implement their DAMON operation set and register that to the DAMON core layer. It is a burden to do such implementation and registration, especially when existing kernel components want to simply report their observed access information. Add a new DAMON API function for simply reporting identified data accesses to DAMON, on the reporter' schedule. The function internally uses mutex, so reporting kernel code should be safe to sleep. This API was also discussed at LSFMMBPF'25: https://lwn.net/Articles/1016525/ Signed-off-by: SeongJae Park --- include/linux/damon.h | 24 ++++++++++++++++++++++++ mm/damon/core.c | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index a67292a2f09d..1bee6e7fed1d 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -110,6 +110,22 @@ struct damon_target { bool obsolete; }; =20 +/** + * struct damon_access_report - Represent single acces report information. + * @addr: The start address of the accessed address range. + * @size: The size of the accessed address range. + * + * Any DAMON API callers that notified access events can report the inform= ation + * to DAMON using damon_report_access(). This struct contains the reporti= ng + * infomration. Refer to damon_report_access() for more details. + */ +struct damon_access_report { + unsigned long addr; + unsigned long size; +/* private: */ + unsigned long report_jiffies; /* when this report is made */ +}; + /** * enum damos_action - Represents an action of a Data Access Monitoring-ba= sed * Operation Scheme. @@ -972,10 +988,18 @@ bool damon_is_running(struct damon_ctx *ctx); int damon_call(struct damon_ctx *ctx, struct damon_call_control *control); int damos_walk(struct damon_ctx *ctx, struct damos_walk_control *control); =20 +void damon_report_access(struct damon_access_report *report); + int damon_set_region_biggest_system_ram_default(struct damon_target *t, unsigned long *start, unsigned long *end, unsigned long min_sz_region); =20 +#else /* CONFIG_DAMON */ + +static inline void damon_report_access(struct damon_access_report *report) +{ +} + #endif /* CONFIG_DAMON */ =20 #endif /* _DAMON_H */ diff --git a/mm/damon/core.c b/mm/damon/core.c index cc15d8ec9dce..7abd8c550c60 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -20,6 +20,8 @@ #define CREATE_TRACE_POINTS #include =20 +#define DAMON_ACCESS_REPORTS_CAP 1000 + static DEFINE_MUTEX(damon_lock); static int nr_running_ctxs; static bool running_exclusive_ctxs; @@ -29,6 +31,11 @@ static struct damon_operations damon_registered_ops[NR_D= AMON_OPS]; =20 static struct kmem_cache *damon_region_cache __ro_after_init; =20 +static DEFINE_MUTEX(damon_access_reports_lock); +static struct damon_access_report damon_access_reports[ + DAMON_ACCESS_REPORTS_CAP]; +static int damon_access_reports_len; + /* Should be called under damon_ops_lock with id smaller than NR_DAMON_OPS= */ static bool __damon_is_registered_ops(enum damon_ops_id id) { @@ -1271,6 +1278,8 @@ int damon_commit_ctx(struct damon_ctx *dst, struct da= mon_ctx *src) return err; } dst->ops =3D src->ops; + if (err) + return err; dst->addr_unit =3D src->addr_unit; dst->min_sz_region =3D src->min_sz_region; =20 @@ -1521,6 +1530,34 @@ int damos_walk(struct damon_ctx *ctx, struct damos_w= alk_control *control) return 0; } =20 +/** + * damon_report_access() - Report identified access events to DAMON. + * @report: The reporting access information. + * + * Report access events to DAMON. + * + * Context: May sleep. + * + * NOTE: we may be able to implement this as a lockless queue, and allow a= ny + * context. As the overhead is unknown, and region-based DAMON logics wou= ld + * guarantee the reports would be not made that frequently, let's start wi= th + * this simple implementation. + */ +void damon_report_access(struct damon_access_report *report) +{ + struct damon_access_report *dst; + + /* silently fail for races */ + if (!mutex_trylock(&damon_access_reports_lock)) + return; + dst =3D &damon_access_reports[damon_access_reports_len++]; + if (damon_access_reports_len =3D=3D DAMON_ACCESS_REPORTS_CAP) + damon_access_reports_len =3D 0; + *dst =3D *report; + dst->report_jiffies =3D jiffies; + mutex_unlock(&damon_access_reports_lock); +} + /* * Warn and fix corrupted ->nr_accesses[_bp] for investigations and preven= ting * the problem being propagated. --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2A55E31A56C; Mon, 8 Dec 2025 06:29:51 +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=1765175392; cv=none; b=t8lSJWS3Jqp5IfOe2LOIZD8bBPSl2Yv7oqpWWqxK8tqwhhrJndbknhBG4x7o6EBI1WxxrxpjNynMbI1E28AnNjFJzrrWgHICHAaBAb+vkov+EXTJbJNNGrreznxmpPZeRMYaIFnpVyiriC39HvGCRQ7g2JIfStBsZSJrMwPdQxY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175392; c=relaxed/simple; bh=rQEjNspwX8hWrc2KTuqlN5FanQkO7AzzeHJdwmQvvNo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ctgYMTNXMZOmAWEsfm6+fL0FdbchLwbbcB5D1PYeNI0SseV1kzoJZ7ecLGs0+Ik9eNx44TiZUrNC76CPxbz8k4A8ec9YGl8Vz1frPbsNou8fdS8K+MO9NYS8Tt6oN8rGCC0LTutX65kJ2yoMXAcwlM8kMIylVwdhUH/JgGWQHpE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KWJkADCO; 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="KWJkADCO" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E1035C4CEF1; Mon, 8 Dec 2025 06:29:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175391; bh=rQEjNspwX8hWrc2KTuqlN5FanQkO7AzzeHJdwmQvvNo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KWJkADCOqjmtshNcqcdsfl9W/5939KuuwE2xNNVM99lQcloQ/Y4+rNRFo46AhWiSn B0t4CRnuVzxhJnf+RR8AzAJYe3g0S/4/7dW/7F6UbdtyvIfaCNilyUxbaSBA4HV/ez AH4s9HbPno59H1ha813qr5bA/da59GKO61xaGQcb+ulTBsranuFY6sGzAPx6M+rmGS f9YDz8YmUdoYeyIQDt5c4Kmgc0rNZhiOO4U/7exoW6pBmSCgUEyU4GSZXFsXRL12SO 1kjX9szQ10x2ZeH3A/RDddmTq1FDtQ7++SEXJB59PaOZA+1ezIRRzKw1nfrfKRnNzB P66fBYR26aDcA== From: SeongJae Park To: Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 02/37] mm/damon: define struct damon_sample_control Date: Sun, 7 Dec 2025 22:29:06 -0800 Message-ID: <20251208062943.68824-3-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" All existing DAMON operation sets are using page table Accessed bits as their access check sampling primitive. In following commits, the operation set for physical address space will be extended for multiple access sampling primitives, specifically page fault events. Define a new DAMON core layer API data structure for controlling which primitives the given operation set should use. Signed-off-by: SeongJae Park --- include/linux/damon.h | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 1bee6e7fed1d..b9359c76a6f1 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -765,6 +765,33 @@ struct damon_attrs { unsigned long aggr_samples; }; =20 +/** + * struct damon_primitives_enabled - Enablement of access sampling primiti= ves. + * + * @page_table: Page table Accessed bits scanning. + * @page_fault: Page faults monitoring. + * + * Read &struct damon_sample_control for more details. + */ +struct damon_primitives_enabled { + bool page_table; + bool page_fault; +}; + +/** + * struct damon_sample_control - Low level access check sampling rules. + * + * @primitives_enabled: Enablement of access check primitives. + * + * DAMON collect low level access information using sampling, and aggregate + * that to make higher access pattern picture. It can use multiple sampli= ng + * primitives including page table accessed bits and page fault events. T= his + * struct is for controlling what sampling primitives to use (enable). + */ +struct damon_sample_control { + struct damon_primitives_enabled primitives_enabled; +}; + /** * struct damon_ctx - Represents a context for each monitoring. This is t= he * main interface that allows users to set the attributes and get the resu= lts @@ -833,6 +860,7 @@ struct damon_ctx { struct mutex kdamond_lock; =20 struct damon_operations ops; + struct damon_sample_control sample_control; unsigned long addr_unit; unsigned long min_sz_region; =20 --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8469531A7FE; Mon, 8 Dec 2025 06:29:53 +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=1765175393; cv=none; b=t8NrTsxp3ir3TRRjH2rNii0CgsGWqAIIsTLonqZjThsbx7i2gzP6xCS+wYrmP4Cc5XZALHb3MUzGKtZTZ2XlMRTgZ2Hxx9bY/jhdI86qKP3xrQyH/v7naZ5vfLjJz0/lB+tsqxp3shhU29igjqsTz0hckA0jIL4TD5QEUfwzae0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175393; c=relaxed/simple; bh=j4VCJvAbCWiJF3GzXaegxyBFq9+F4EGOLszAHpMh12M=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=l6lJpwAwutXkN+jVECpfO0asb5bRicmNltJj7bhFsJtkPpA9pw/qE9h2mfD07r+d3YaKVDbxPrOn6Y/nMvzm4Uc9i0USAeV8wga0hPSXueDcoDjZGdOtIdFh9+o+dYlxlHLxBJmYVnR2AbKQqnJA0xBCvTgZb03aNcoFgDGPl38= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Gm/vBl8r; 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="Gm/vBl8r" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 21F2AC113D0; Mon, 8 Dec 2025 06:29:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175393; bh=j4VCJvAbCWiJF3GzXaegxyBFq9+F4EGOLszAHpMh12M=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Gm/vBl8ryD/sYQZKtcgb4nfb04AD2Tc1c7lyP0l4Nu/jnTmgwOeYH2cYgRSGJSjib M9h6V9GsqI1I/5HLfrYo7B5zjiZF4Xq9PQwwwbcYSChC3J1YdJLhPM3U8di0CQKlxR T0MJ7ooHrdBDEpMRDrL9Apg4NQq8hHiGXkdCoFXb8XYb+wCQKipI5TWxFys7CU4FG/ 3Hf6pJAzXORV9w84y3Gew1Tmsggpxce/DuHwn7iLtacKNq3ubWy2Kg8o8jMqsd5VlG PH88VLVnB304si86+tDirjCVtIvi8KEZ76LRsQi7gH466ZQcDTGxzRxBlHO0vwlv3V bCNZxUC5gKuvw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 03/37] mm/damon/core: commit damon_sample_control Date: Sun, 7 Dec 2025 22:29:07 -0800 Message-ID: <20251208062943.68824-4-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 parameters for sampling primitives usage control is not committed with damon_commit_ctx(). Hence it doesn't work with online parameters update. Implement the functionality. Signed-off-by: SeongJae Park --- mm/damon/core.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index 7abd8c550c60..89305d42e116 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -559,6 +559,8 @@ struct damon_ctx *damon_new_ctx(void) ctx->attrs.min_nr_regions =3D 10; ctx->attrs.max_nr_regions =3D 1000; =20 + ctx->sample_control.primitives_enabled.page_table =3D true; + ctx->addr_unit =3D 1; ctx->min_sz_region =3D DAMON_MIN_REGION; =20 @@ -1242,6 +1244,23 @@ static int damon_commit_targets( return 0; } =20 +static bool damon_primitives_enabled_invalid( + struct damon_primitives_enabled *config) +{ + return config->page_table =3D=3D config->page_fault; +} + +static int damon_commit_sample_control( + struct damon_sample_control *dst, + struct damon_sample_control *src) +{ + if (damon_primitives_enabled_invalid(&src->primitives_enabled)) + return -EINVAL; + + dst->primitives_enabled =3D src->primitives_enabled; + return 0; +} + /** * damon_commit_ctx() - Commit parameters of a DAMON context to another. * @dst: The commit destination DAMON context. @@ -1278,6 +1297,8 @@ int damon_commit_ctx(struct damon_ctx *dst, struct da= mon_ctx *src) return err; } dst->ops =3D src->ops; + err =3D damon_commit_sample_control(&dst->sample_control, + &src->sample_control); if (err) return err; dst->addr_unit =3D src->addr_unit; --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id ED72731A554; Mon, 8 Dec 2025 06:29:54 +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=1765175395; cv=none; b=AeA5TIaFiUT4lKser5kPYNew0bcglJRNeVclZ53OEp2qOcfTCJNglIwQk2TvkKaSNlXWxWaKIS6PysUj9p70xQhgDywgjDCMLiOSC7aP+TSCttQoOGV2f+LkUU0s1S+Y6HN5EG83gpV7kXx8xWlzop5OBwc9PW3AOjskGAzLMOM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175395; c=relaxed/simple; bh=kFi2QDyr9gKqWX13ZWpeGzoNVnWkjkenFzPE2s60nLM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=AmM0EeKNbc1KTbmwPkKZiTpBnSKqPf2xiQ7eWYIPZE6yETln8IIjZ7V5phI/m/UqTzOLsKm9+SflEwbc9nUM9GJdpt9Dp33sOFGq/ntBus5XSPCrQ31DFNjbyXf532XK6qJljZwkk7DKIJVXpcE9o1RgLuQ3aZEkn3dAC7xLnKE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hJbqzxQ3; 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="hJbqzxQ3" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 74180C19422; Mon, 8 Dec 2025 06:29:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175394; bh=kFi2QDyr9gKqWX13ZWpeGzoNVnWkjkenFzPE2s60nLM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hJbqzxQ3L/kD9luw3CSq8MIwgYAnTHw91s3JR6CQxPmXpWLZDk9ucr52+clZQuhB4 NPONyYD1/kreuAywtWnRDE8VgpdBCJWBg4QYHlRImB7iid3jVey8RsDS3PRnBgLSlE bBD8C6Y8uyKD5vA2xbaYihb9+wTBEPj7j5pc7Q6CJGSgO19ln82nPsM/qv0n0Dxbwq s9uHC4Kw17oKl1ssnFBk/gwkiCI5Fm7bvaxxebxjNleC1964qm3R9Iz6rcqIBp7VjF XxhxBmyInnw+Ud9km5Gp7nIosOoMDcLIbfDGy7sKPcU8CJ7jPpEvVRhIUEA1wvVFf9 M0sudPLy74hHg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 04/37] mm/damon/core: implement damon_report_page_fault() Date: Sun, 7 Dec 2025 22:29:08 -0800 Message-ID: <20251208062943.68824-5-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 DAMON core API for reporting page fault events to DAMON. It is a wrapper of damon_report_access(). This is a temporal hack. In future versions that will have no RFC tag, only damon_report_access() may be used. Signed-off-by: SeongJae Park --- include/linux/damon.h | 10 ++++++++++ mm/damon/core.c | 17 +++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index b9359c76a6f1..b8ebb2aa02c8 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -1017,6 +1017,13 @@ int damon_call(struct damon_ctx *ctx, struct damon_c= all_control *control); int damos_walk(struct damon_ctx *ctx, struct damos_walk_control *control); =20 void damon_report_access(struct damon_access_report *report); +#ifdef CONFIG_MMU +void damon_report_page_fault(struct vm_fault *vmf, bool huge_pmd); +#else +static inline void damon_report_page_fault(struct vm_fault *vmf, bool huge= _pmd) +{ +} +#endif =20 int damon_set_region_biggest_system_ram_default(struct damon_target *t, unsigned long *start, unsigned long *end, @@ -1027,6 +1034,9 @@ int damon_set_region_biggest_system_ram_default(struc= t damon_target *t, static inline void damon_report_access(struct damon_access_report *report) { } +static inline void damon_report_page_fault(struct vm_fault *vmf, bool huge= _pmd) +{ +} =20 #endif /* CONFIG_DAMON */ =20 diff --git a/mm/damon/core.c b/mm/damon/core.c index 89305d42e116..296117d5e7f7 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1579,6 +1579,23 @@ void damon_report_access(struct damon_access_report = *report) mutex_unlock(&damon_access_reports_lock); } =20 +#ifdef CONFIG_MMU +void damon_report_page_fault(struct vm_fault *vmf, bool huge_pmd) +{ + struct damon_access_report access_report =3D { + .size =3D 1, /* todo: set appripriately */ + }; + + if (huge_pmd) + access_report.addr =3D PFN_PHYS(pmd_pfn(vmf->orig_pmd)); + else + access_report.addr =3D PFN_PHYS(pte_pfn(vmf->orig_pte)); + /* todo: report vmf->address as virtual address */ + + damon_report_access(&access_report); +} +#endif + /* * Warn and fix corrupted ->nr_accesses[_bp] for investigations and preven= ting * the problem being propagated. --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 84A4C31A7FE for ; Mon, 8 Dec 2025 06:29:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175397; cv=none; b=bX9v85aZhXrzNoG0ZTwuyLmQwA9JrGLTsvFk6NyJ/g4CFOTCktV7uqSmRYsw0OV3GnavHd3IRbLyToo4EjHWiDselw9haGN7zSwTEf9pe5bOkbO3mHDR1dDmd2QIstoQ9Z7NwnjQa5A3tcydHdxCTcFxXyRqlBtnhiPCibVyS0A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175397; c=relaxed/simple; bh=IsAQBy+/F0THMv/6pxlb7dlCDTvmO/F43GY/84Lx7Qs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=MY6F7d9DVPDEbMl7kmg9UoEpKKLuD/EkNabv0w0QzViHB2iZ5j9mdVyB7gP5vVGRq6ovQUDbGgYf4W3qboCOQdUAzuaT4M8pW3LSerlMsQH0BSweUzHfwqIemIRbYnV0P13Du8hMf/BbrTaK25VG/LkmENbN3YgAn7Vl4vo9c08= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=rrkKJurf; 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="rrkKJurf" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C35AEC19424; Mon, 8 Dec 2025 06:29:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175396; bh=IsAQBy+/F0THMv/6pxlb7dlCDTvmO/F43GY/84Lx7Qs=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=rrkKJurf/ekHLTqr3oXC4YqVnKygVWt0HJT+83gq/Sz7EFTeS1jr0l3zZ3x3TwyZh uRswznSYSjtlgylkCypij/Ca+pKIB1LnH8V2t5o8RUaD+dlzdGd0OYo08Ek9z5f3dT R1HLsTu7RvLf2loccy9ldM0/g9rnq8W30RR2OV/3lg0Gq61og2650e77nJqi8EBgMK 04/1zCu7TbWB1cErBqV1C3ZFWqnYOt1J0upc/zfA0B53yngOk1KwXdH+pfIszva00f ETh14f5tGl6dakWTIosb3VkJlpnfEiXyFUSpK3CbHj87TKWd4cPyWgK/WjoT06T/2W UbEDolHGhNslg== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jann Horn , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Pedro Falcato , Suren Baghdasaryan , Vlastimil Babka , linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 05/37] mm/{mprotect,memory}: (no upstream-aimed hack) implement MM_CP_DAMON Date: Sun, 7 Dec 2025 22:29:09 -0800 Message-ID: <20251208062943.68824-6-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Note that this is not upstreamable as-is. This is only for helping discussion of other changes of its series. DAMON is using Accessed bits of page table entries as the major source of the access information. It lacks some additional information such as which CPU was making the access. Page faults could be another source of information for such additional information. Implement another change_protection() flag for such use cases, namely MM_CP_DAMON. DAMON will install PAGE_NONE protections using the flag. To avoid interfering with NUMA_BALANCING, which is also using PAGE_NON protection, pass the faults to DAMON only when NUMA_BALANCING is disabled. Again, this is not upstreamable as-is. There were comments about this on the previous version, and I was unable to take time on addressing those. As a result, this version is not addressing any of those previous comments. I'm sending this, though, to help discussions on patches of its series, except this one. Please forgive me adding this to your inbox without addressing your comments, and ignore. I will establish another discussion for this part later. Signed-off-by: SeongJae Park --- include/linux/mm.h | 1 + mm/memory.c | 60 ++++++++++++++++++++++++++++++++++++++++++++-- mm/mprotect.c | 5 ++++ 3 files changed, 64 insertions(+), 2 deletions(-) diff --git a/include/linux/mm.h b/include/linux/mm.h index 553cf9f438f1..2cba5a0196da 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2848,6 +2848,7 @@ int get_cmdline(struct task_struct *task, char *buffe= r, int buflen); #define MM_CP_UFFD_WP_RESOLVE (1UL << 3) /* Resolve wp */ #define MM_CP_UFFD_WP_ALL (MM_CP_UFFD_WP | \ MM_CP_UFFD_WP_RESOLVE) +#define MM_CP_DAMON (1UL << 4) =20 bool can_change_pte_writable(struct vm_area_struct *vma, unsigned long add= r, pte_t pte); diff --git a/mm/memory.c b/mm/memory.c index 6675e87eb7dd..5dc85adb1e59 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -78,6 +78,7 @@ #include #include #include +#include =20 #include =20 @@ -6172,6 +6173,54 @@ static vm_fault_t wp_huge_pud(struct vm_fault *vmf, = pud_t orig_pud) return VM_FAULT_FALLBACK; } =20 +/* + * NOTE: This is only poc purpose "hack" that will not be upstreamed as is. + * More discussions between all stakeholders including maintainers of MM c= ore, + * NUMA balancing, and DAMON should be made to make this upstreamable. + * (https://lore.kernel.org/20251128193947.80866-1-sj@kernel.org) + * + * This function is called from page fault handler, for page faults on + * P{TE,MD}-protected but vma-accessible pages. DAMON is making the fake + * protection for access sampling purpose. This function simply clear the + * protection and report this access to DAMON, by calling + * damon_report_page_fault(). + * + * The protection clear code is copied from NUMA fault handling code for P= TE. + * Again, this is only poc purpose "hack" to show what information DAMON w= ant + * from page fault events, rather than an upstream-aimed version. + */ +static vm_fault_t do_damon_page(struct vm_fault *vmf, bool huge_pmd) +{ + struct vm_area_struct *vma =3D vmf->vma; + struct folio *folio; + pte_t pte, old_pte; + bool writable =3D false, ignore_writable =3D false; + bool pte_write_upgrade =3D vma_wants_manual_pte_write_upgrade(vma); + + spin_lock(vmf->ptl); + old_pte =3D ptep_get(vmf->pte); + if (unlikely(!pte_same(old_pte, vmf->orig_pte))) { + pte_unmap_unlock(vmf->pte, vmf->ptl); + return 0; + } + pte =3D pte_modify(old_pte, vma->vm_page_prot); + writable =3D pte_write(pte); + if (!writable && pte_write_upgrade && + can_change_pte_writable(vma, vmf->address, pte)) + writable =3D true; + folio =3D vm_normal_folio(vma, vmf->address, pte); + if (folio && folio_test_large(folio)) + numa_rebuild_large_mapping(vmf, vma, folio, pte, + ignore_writable, pte_write_upgrade); + else + numa_rebuild_single_mapping(vmf, vma, vmf->address, vmf->pte, + writable); + pte_unmap_unlock(vmf->pte, vmf->ptl); + + damon_report_page_fault(vmf, huge_pmd); + return 0; +} + /* * These routines also need to handle stuff like marking pages dirty * and/or accessed for architectures that don't do it in hardware (most @@ -6236,8 +6285,11 @@ static vm_fault_t handle_pte_fault(struct vm_fault *= vmf) if (!pte_present(vmf->orig_pte)) return do_swap_page(vmf); =20 - if (pte_protnone(vmf->orig_pte) && vma_is_accessible(vmf->vma)) + if (pte_protnone(vmf->orig_pte) && vma_is_accessible(vmf->vma)) { + if (sysctl_numa_balancing_mode =3D=3D NUMA_BALANCING_DISABLED) + return do_damon_page(vmf, false); return do_numa_page(vmf); + } =20 spin_lock(vmf->ptl); entry =3D vmf->orig_pte; @@ -6363,8 +6415,12 @@ static vm_fault_t __handle_mm_fault(struct vm_area_s= truct *vma, return 0; } if (pmd_trans_huge(vmf.orig_pmd)) { - if (pmd_protnone(vmf.orig_pmd) && vma_is_accessible(vma)) + if (pmd_protnone(vmf.orig_pmd) && vma_is_accessible(vma)) { + if (sysctl_numa_balancing_mode =3D=3D + NUMA_BALANCING_DISABLED) + return do_damon_page(&vmf, true); return do_huge_pmd_numa_page(&vmf); + } =20 if ((flags & (FAULT_FLAG_WRITE|FAULT_FLAG_UNSHARE)) && !pmd_write(vmf.orig_pmd)) { diff --git a/mm/mprotect.c b/mm/mprotect.c index 5c330e817129..d2c14162f93d 100644 --- a/mm/mprotect.c +++ b/mm/mprotect.c @@ -651,6 +651,11 @@ long change_protection(struct mmu_gather *tlb, WARN_ON_ONCE(cp_flags & MM_CP_PROT_NUMA); #endif =20 +#ifdef CONFIG_ARCH_SUPPORTS_NUMA_BALANCING + if (cp_flags & MM_CP_DAMON) + newprot =3D PAGE_NONE; +#endif + if (is_vm_hugetlb_page(vma)) pages =3D hugetlb_change_protection(tlb, vma, start, end, newprot, cp_flags); --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 670F131A554; Mon, 8 Dec 2025 06:29:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175398; cv=none; b=bV/zLuT3JkSphXncvDUPh/5VjPCAoP60BZ9xKqJZ+YOBj7rEjVI66QZTBHcQIcmLNNm14o0K+mgZe+RXld+yl8xPSvccC6d8hVqi8x6kzhgdt8P52Fo1KVgs1zH5c8wjDhpEX7KZ0Mn2fvFI+I5xffRYogdfsmbi4Me8mlZ8sl8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175398; c=relaxed/simple; bh=FU7PUMIztU6bHn9o0PvCgnBq3cHVYIdbgyjQa5N1taw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=WqqLyyqmVMa04u32AKqn2KvrpfdATK7qzZzXQZkhdUZigFwa8bJrLu3D0M/3ZaJM6LKEDoKTUmdJIFdOYJ5i1fYtIPKNES1PrlX/MSqODYeYRJqWuNyG5M54SM7C57A8IUGKIJUR6Ex21LJ0VEzjKzW6l/6QrQZ0irs1SVn9qDQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ChdeafpH; 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="ChdeafpH" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 52020C4CEF1; Mon, 8 Dec 2025 06:29:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175398; bh=FU7PUMIztU6bHn9o0PvCgnBq3cHVYIdbgyjQa5N1taw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ChdeafpH4rH6YL3o1OKRhEuJQnPqQu9MWx0FDHaiJjG2zbJafy/3MUasBBnoQ6ERw 8+RMDYPSMQ+pQtclPsOp/r6aNzokcl/inkk19+vYiY8FJ7pA58bWrpi14lANsZukl7 v0z7oACIteOEGOzdjcln69EjPOT1UAQIgQ3UbdJWpvjhLq2yZZORheMgWQQGXMNk8L XuziggKbS2BuzHsZ8rl1O+5R28lNck8cQjOZFnftcgl0/ReiHNbauEqMjxBxb1zJbD 3Bcuc20nOgtGmJ68jLXrUEyi4yXMNKphfR5Ol8MsHs6c10Qp8xuwzX4+emNNQx3RfG gIuiMu3ys40mQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 06/37] mm/damon/paddr: support page fault access check primitive Date: Sun, 7 Dec 2025 22:29:10 -0800 Message-ID: <20251208062943.68824-7-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 operation set for the physical address space (paddr) to support page fault access check primitive. When DAMON core layer asks it to use page fault events as its access check primitive, paddr will install PROT_NONE protection to access sampling target pages, in a way similar to NUMA_HINT_FAULTS, using the non-upstreamable hack that was added by the previous commit. Signed-off-by: SeongJae Park --- mm/damon/paddr.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 65 insertions(+), 1 deletion(-) diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c index 07a8aead439e..698ca6b9dde6 100644 --- a/mm/damon/paddr.c +++ b/mm/damon/paddr.c @@ -14,6 +14,7 @@ #include #include #include +#include =20 #include "../internal.h" #include "ops-common.h" @@ -56,7 +57,8 @@ static void __damon_pa_prepare_access_check(struct damon_= region *r, damon_pa_mkold(damon_pa_phys_addr(r->sampling_addr, addr_unit)); } =20 -static void damon_pa_prepare_access_checks(struct damon_ctx *ctx) +/* Use page table accessed bits */ +static void damon_pa_prepare_access_checks_abit(struct damon_ctx *ctx) { struct damon_target *t; struct damon_region *r; @@ -67,6 +69,68 @@ static void damon_pa_prepare_access_checks(struct damon_= ctx *ctx) } } =20 +static bool damon_pa_change_protection_one(struct folio *folio, + struct vm_area_struct *vma, unsigned long addr, void *arg) +{ + /* todo: batch or remove tlb flushing */ + struct mmu_gather tlb; + + if (!vma_is_accessible(vma)) + return true; + + tlb_gather_mmu(&tlb, vma->vm_mm); + + change_protection(&tlb, vma, addr, addr + PAGE_SIZE, MM_CP_DAMON); + + tlb_finish_mmu(&tlb); + return true; +} + +static void damon_pa_change_protection(unsigned long paddr) +{ + struct folio *folio =3D damon_get_folio(PHYS_PFN(paddr)); + struct rmap_walk_control rwc =3D { + .rmap_one =3D damon_pa_change_protection_one, + .anon_lock =3D folio_lock_anon_vma_read, + }; + bool need_lock; + + if (!folio) + return; + if (!folio_mapped(folio) || !folio_raw_mapping(folio)) + return; + + need_lock =3D !folio_test_anon(folio) || folio_test_ksm(folio); + if (need_lock && !folio_trylock(folio)) + return; + + rmap_walk(folio, &rwc); + + if (need_lock) + folio_unlock(folio); +} + +static void damon_pa_prepare_access_checks_faults(struct damon_ctx *ctx) +{ + struct damon_target *t; + struct damon_region *r; + + damon_for_each_target(t, ctx) { + damon_for_each_region(r, t) { + r->sampling_addr =3D damon_rand(r->ar.start, r->ar.end); + damon_pa_change_protection(r->sampling_addr); + } + } +} + +static void damon_pa_prepare_access_checks(struct damon_ctx *ctx) +{ + if (ctx->sample_control.primitives_enabled.page_table) + damon_pa_prepare_access_checks_abit(ctx); + if (ctx->sample_control.primitives_enabled.page_fault) + damon_pa_prepare_access_checks_faults(ctx); +} + static bool damon_pa_young(phys_addr_t paddr, unsigned long *folio_sz) { struct folio *folio =3D damon_get_folio(PHYS_PFN(paddr)); --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EDB1931AAB3; Mon, 8 Dec 2025 06:29:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175400; cv=none; b=ORBuvpDLqi+UJG/ZBCNrZMRHBq0lHHKhEcQZq0u5alTPO+pySGtco7JElqxfu270gSCxXDHb2JBchIdGi3NAk1X4Dlll0TUhLB215tP2Ln2IpOf17gzeiEYPRhfl2ccps3Uh/1e8NSwJCSIVEI1YvPN/lnWVYargeEo2VtWdv1A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175400; c=relaxed/simple; bh=kw63posGt47cF3PzxW8YgBTIV3frYoxoD81lOplefX8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ab1+xVOkBVEAOyTd5srVdp//r4BbjDML7R42e+Tp91G/i1kJ9jOw9qstELZSXVRFoKqehYcIOyHM1iYB6PD5Bx45PuWHWtDCrt2ULjfMCFYFUnbu7woretLXsWLXrw0uiAnFRcGZc08NwitqYx/iWjC2AsJ2NBAp/D6A+3vL5eU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bBWtheks; 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="bBWtheks" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9E4B2C4CEF1; Mon, 8 Dec 2025 06:29:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175399; bh=kw63posGt47cF3PzxW8YgBTIV3frYoxoD81lOplefX8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bBWtheksOgHWBstZsj7GigQ1TcugWneeQURbZ71ey2h+Ojpj12DQybju+3H4WjIaO 8oXwugeidzsjW8kCg3bXXZVOPcB44WgQsLlE+TZbM9Fq9J934FBXgLEaTRgZzSW7BL 2kb3lbw5g+TzzRC9SFzPsEL9ndBuajBI52JFKMYAyk9uusLf1jOOfgrIO2xJXvJTEn r+IWVn9PyF/M5FJmGc2aMTqNu/ceeAxcMvgIU+YPnI1JDdG2MsCxXCz8Q1OeS94nSr JXnvBWRlMqGrzYj6/pAYNxdw4YFQEhmB0Z8eiWLJJrUG96ZIFmIZtYblqvFQ7KUXZm o5deaTstAHt7g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 07/37] mm/damon/core: apply access reports to high level snapshot Date: Sun, 7 Dec 2025 22:29:11 -0800 Message-ID: <20251208062943.68824-8-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Now any DAMON API callers can report their observed access information. The DAMON core layer is just ignoring those, though. Update the core to use the reported information at building the high level access pattern snapshot. Signed-off-by: SeongJae Park --- include/linux/damon.h | 1 + mm/damon/core.c | 68 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 68 insertions(+), 1 deletion(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index b8ebb2aa02c8..b04c2e36833a 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -83,6 +83,7 @@ struct damon_region { unsigned int age; /* private: Internal value for age calculation. */ unsigned int last_nr_accesses; + bool access_reported; }; =20 /** diff --git a/mm/damon/core.c b/mm/damon/core.c index 296117d5e7f7..a14754a47c7f 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -137,6 +137,7 @@ struct damon_region *damon_new_region(unsigned long sta= rt, unsigned long end) =20 region->age =3D 0; region->last_nr_accesses =3D 0; + region->access_reported =3D false; =20 return region; } @@ -2745,6 +2746,68 @@ static void kdamond_init_ctx(struct damon_ctx *ctx) } } =20 +static void kdamond_apply_access_report(struct damon_access_report *report, + struct damon_target *t, struct damon_ctx *ctx) +{ + struct damon_region *r; + + /* todo: make search faster, e.g., binary search? */ + damon_for_each_region(r, t) { + if (report->addr < r->ar.start) + continue; + if (r->ar.end < report->addr + report->size) + continue; + if (!r->access_reported) + damon_update_region_access_rate(r, true, &ctx->attrs); + r->access_reported =3D true; + } +} + +static unsigned int kdamond_apply_zero_access_report(struct damon_ctx *ctx) +{ + struct damon_target *t; + struct damon_region *r; + unsigned int max_nr_accesses =3D 0; + + damon_for_each_target(t, ctx) { + damon_for_each_region(r, t) { + if (r->access_reported) + r->access_reported =3D false; + else + damon_update_region_access_rate(r, false, + &ctx->attrs); + max_nr_accesses =3D max(max_nr_accesses, r->nr_accesses); + } + } + return max_nr_accesses; +} + +static unsigned int kdamond_check_reported_accesses(struct damon_ctx *ctx) +{ + int i; + struct damon_access_report *report; + struct damon_target *t; + + /* currently damon_access_report supports only physical address */ + if (damon_target_has_pid(ctx)) + return 0; + + mutex_lock(&damon_access_reports_lock); + for (i =3D 0; i < damon_access_reports_len; i++) { + report =3D &damon_access_reports[i]; + if (time_before(report->report_jiffies, + jiffies - + usecs_to_jiffies( + ctx->attrs.sample_interval))) + continue; + damon_for_each_target(t, ctx) + kdamond_apply_access_report(report, t, ctx); + } + mutex_unlock(&damon_access_reports_lock); + /* For nr_accesses_bp, absence of access should also be reported. */ + return kdamond_apply_zero_access_report(ctx); +} + /* * The monitoring daemon that runs as a kernel thread */ @@ -2790,7 +2853,10 @@ static int kdamond_fn(void *data) kdamond_usleep(sample_interval); ctx->passed_sample_intervals++; =20 - if (ctx->ops.check_accesses) + /* todo: make these non-exclusive */ + if (ctx->sample_control.primitives_enabled.page_fault) + max_nr_accesses =3D kdamond_check_reported_accesses(ctx); + else if (ctx->ops.check_accesses) max_nr_accesses =3D ctx->ops.check_accesses(ctx); =20 if (ctx->passed_sample_intervals >=3D next_aggregation_sis) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4A3D331984D; Mon, 8 Dec 2025 06:30:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175401; cv=none; b=KjN7UDslZ2nWLDGM32bJ8PfgnvEdv2o0e2zQg8G6D4ShjwXn6SKmq4f1WEPpqbEyYjR7GpsJZ8lWc34pY7Y9pkU0osDYHW0rlpNvRUfalAokFVYGivnmUKVxzOepbLRXKIkY02R791O46ceSbQ43GejT/yiao45QwRMboKBJdRQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175401; c=relaxed/simple; bh=PIidHNr/VkcFOE2gAHJhxadKF2Da7aKAwZ3oDyJGFRg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=WzQ2cS8Z0Zkpy7kk6CN8xqjBdmudBNH0T4/sjhiBbVGon9Mp6sZ01TXQ/VPZScJ9SywDoR5YnThTSK6V2cL5gC2sxlzQTWuxZei7dEK7A9u5dqytqO7PtLt3/O1UDY270Xt9RD2N1bu+BLhQt+zEmtmmC/KtlCWfRz2U9Kvek70= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=IuqerH5f; 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="IuqerH5f" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EF121C116B1; Mon, 8 Dec 2025 06:29:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175400; bh=PIidHNr/VkcFOE2gAHJhxadKF2Da7aKAwZ3oDyJGFRg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=IuqerH5fST4Q0MUSx48O3pCSTGmeM3CXG4UcARZdiFmwDCgxJavXxf9W6niH2Szya a8KPStk1sjhHmlrO0kQVZDKgYRHZunmYcAQWbHNDyJbQfm8/u19camQsfCvZ3afmI2 VrqZrkoV3ZACOyz6cJPSEsg5la75dOzdubY1oPlXdVew1BCuKgAdMScP21JtOPSr0N OxSlhXvLB/ArTSA2EzEKEsYmYQRCCWcgDb0CK4mGC75BdfG2LCR4irNdou/5NyIP1m jSj6M2gUsqa/dgoV7MF6rACA1e/d6T7wbVuf9GYDowCI9c56sNUNWf5U9yoZiW5/nV YNhgaPPwSUMwg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 08/37] mm/damon/sysfs: implement monitoring_attrs/sample/ dir Date: Sun, 7 Dec 2025 22:29:12 -0800 Message-ID: <20251208062943.68824-9-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 a sysfs directory for letting DAMON ABI users control what access sampling primitives to use, among page table Accessed bit and page fault events. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 53 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index e2bd2d7becdd..851e8c0dc989 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -749,6 +749,41 @@ static const struct kobj_type damon_sysfs_intervals_kt= ype =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * sample directory + */ + +struct damon_sysfs_sample { + struct kobject kobj; +}; + +static struct damon_sysfs_sample *damon_sysfs_sample_alloc(void) +{ + struct damon_sysfs_sample *sample =3D kmalloc( + sizeof(*sample), GFP_KERNEL); + + if (!sample) + return NULL; + sample->kobj =3D (struct kobject){}; + return sample; +} + +static void damon_sysfs_sample_release(struct kobject *kobj) +{ + kfree(container_of(kobj, struct damon_sysfs_sample, kobj)); +} + +static struct attribute *damon_sysfs_sample_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_sample); + +static const struct kobj_type damon_sysfs_sample_ktype =3D { + .release =3D damon_sysfs_sample_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_sample_groups, +}; + /* * monitoring_attrs directory */ @@ -757,6 +792,7 @@ struct damon_sysfs_attrs { struct kobject kobj; struct damon_sysfs_intervals *intervals; struct damon_sysfs_ul_range *nr_regions_range; + struct damon_sysfs_sample *sample; }; =20 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void) @@ -773,6 +809,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_sample *sample; int err; =20 intervals =3D damon_sysfs_intervals_alloc(5000, 100000, 60000000); @@ -801,8 +838,23 @@ 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; + + sample =3D damon_sysfs_sample_alloc(); + if (!sample) { + err =3D -ENOMEM; + goto put_nr_regions_intervals_out; + } + err =3D kobject_init_and_add(&sample->kobj, + &damon_sysfs_sample_ktype, &attrs->kobj, + "sample"); + if (err) + goto put_sample_out; + attrs->sample =3D sample; return 0; =20 +put_sample_out: + kobject_put(&sample->kobj); + attrs->sample =3D NULL; put_nr_regions_intervals_out: kobject_put(&nr_regions_range->kobj); attrs->nr_regions_range =3D NULL; @@ -817,6 +869,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->sample->kobj); } =20 static void damon_sysfs_attrs_release(struct kobject *kobj) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B3ACF31AA8D; Mon, 8 Dec 2025 06:30:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175402; cv=none; b=Vli6durf3/GgjnsvJzGEU8J0JYEp+Ce2YbnOKmFYo8E5oKjc1iujCSGw830mdDLE/XA2jzFvvfza4Ul8TotNm42Q3o7Umn6Q43DuP/SmSgON3kIyEbPeEUxny6XZVP/vVK/GCK0G1eU/6DJ7dLoyee3PwV16QfWdTpuW0Zrzb7Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175402; c=relaxed/simple; bh=yNKU0Z4igXUk3W3EuJXr4KHd7edg/Rmbwvdbsef5Gq4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=K+8dMqEL5Krf/GAYQYZ075lES9gyDiZ7Ii240iDnE0ysKc9ylWizpprs/9acPfMDmJCF5HUIN5SiYENXJdvEME5aUNE6h7Rcis5pMjCGvdYyVT/rseQGer5LaoqZo/1Lk/lrRs8sVUspkOj19wpzf8wdIzgLNKb7CvyoqCMFJ1g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=WrME62N/; 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="WrME62N/" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4FEA4C4CEF1; Mon, 8 Dec 2025 06:30:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175402; bh=yNKU0Z4igXUk3W3EuJXr4KHd7edg/Rmbwvdbsef5Gq4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=WrME62N/PIHC0ErSD9JgYLo9mp27uJj3fEFSvF32aAnvVB0Mc9jn/hxaAvgLXa3Zy HKLkMxqoIIIYF2fMInXLwCbzYMSF4F6isxZ5pkA+LWtHcntMpjy72AiBnmrtm3Fzsd Jl5Jxw6g3zU66UjAL+5M3P1ftZ0GstG2jEsL57AfRFuqmF49XAHTpKOKxmkjH865zp 39h3e/whDgUHJzw+ZhkCLPumPQv/WsrDdeAFrubui+vA69poFTnVqTMYpFmzMoRZeK 3xsr3NSLbACB/5uT0gEFuTjM1TxMdzEaXwg3H7qAWiuBrdhShHMvUyRvp6QSTAirD/ DJs0J+I5eOpjQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 09/37] mm/damon/sysfs: implement sample/primitives/ dir Date: Sun, 7 Dec 2025 22:29:13 -0800 Message-ID: <20251208062943.68824-10-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 a sysfs directory that will be used to let DAMON ABI users control what access sampling primitives to use, among page table Accessed bit, and page fault events. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 132 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 851e8c0dc989..14478fd79953 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -749,12 +749,111 @@ static const struct kobj_type damon_sysfs_intervals_= ktype =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * access check primitives directory + */ + +struct damon_sysfs_primitives { + struct kobject kobj; + bool page_table; + bool page_fault; +}; + +static struct damon_sysfs_primitives *damon_sysfs_primitives_alloc( + bool page_table, bool page_fault) +{ + struct damon_sysfs_primitives *primitives =3D kmalloc( + sizeof(*primitives), GFP_KERNEL); + + if (!primitives) + return NULL; + + primitives->kobj =3D (struct kobject){}; + primitives->page_table =3D page_table; + primitives->page_fault =3D page_fault; + return primitives; +} + +static ssize_t page_table_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_primitives *primitives =3D container_of(kobj, + struct damon_sysfs_primitives, kobj); + + return sysfs_emit(buf, "%c\n", primitives->page_table ? 'Y' : 'N'); +} + +static ssize_t page_table_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_primitives *primitives =3D container_of(kobj, + struct damon_sysfs_primitives, kobj); + bool enable; + int err =3D kstrtobool(buf, &enable); + + if (err) + return err; + primitives->page_table =3D enable; + return count; +} + +static ssize_t page_fault_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_primitives *primitives =3D container_of(kobj, + struct damon_sysfs_primitives, kobj); + + return sysfs_emit(buf, "%c\n", primitives->page_fault ? 'Y' : 'N'); +} + +static ssize_t page_fault_store(struct kobject *kobj, + struct kobj_attribute *attr, const char *buf, size_t count) +{ + struct damon_sysfs_primitives *primitives =3D container_of(kobj, + struct damon_sysfs_primitives, kobj); + bool enable; + int err =3D kstrtobool(buf, &enable); + + if (err) + return err; + primitives->page_fault =3D enable; + return count; +} + +static void damon_sysfs_primitives_release(struct kobject *kobj) +{ + struct damon_sysfs_primitives *primitives =3D container_of(kobj, + struct damon_sysfs_primitives, kobj); + + kfree(primitives); +} + +static struct kobj_attribute damon_sysfs_primitives_page_table_attr =3D + __ATTR_RW_MODE(page_table, 0600); + +static struct kobj_attribute damon_sysfs_primitives_page_fault_attr =3D + __ATTR_RW_MODE(page_fault, 0600); + +static struct attribute *damon_sysfs_primitives_attrs[] =3D { + &damon_sysfs_primitives_page_table_attr.attr, + &damon_sysfs_primitives_page_fault_attr.attr, + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_primitives); + +static const struct kobj_type damon_sysfs_primitives_ktype =3D { + .release =3D damon_sysfs_primitives_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_primitives_groups, +}; + /* * sample directory */ =20 struct damon_sysfs_sample { struct kobject kobj; + struct damon_sysfs_primitives *primitives; }; =20 static struct damon_sysfs_sample *damon_sysfs_sample_alloc(void) @@ -768,6 +867,35 @@ static struct damon_sysfs_sample *damon_sysfs_sample_a= lloc(void) return sample; } =20 +static int damon_sysfs_sample_add_dirs( + struct damon_sysfs_sample *sample) +{ + struct damon_sysfs_primitives *primitives; + int err; + + primitives =3D damon_sysfs_primitives_alloc(true, false); + if (!primitives) + return -ENOMEM; + err =3D kobject_init_and_add(&primitives->kobj, + &damon_sysfs_primitives_ktype, &sample->kobj, + "primitives"); + if (err) + goto put_primitives_out; + sample->primitives =3D primitives; + +put_primitives_out: + kobject_put(&primitives->kobj); + sample->primitives =3D NULL; + return err; +} + +static void damon_sysfs_sample_rm_dirs( + struct damon_sysfs_sample *sample) +{ + if (sample->primitives) + kobject_put(&sample->primitives->kobj); +} + static void damon_sysfs_sample_release(struct kobject *kobj) { kfree(container_of(kobj, struct damon_sysfs_sample, kobj)); @@ -847,6 +975,9 @@ static int damon_sysfs_attrs_add_dirs(struct damon_sysf= s_attrs *attrs) err =3D kobject_init_and_add(&sample->kobj, &damon_sysfs_sample_ktype, &attrs->kobj, "sample"); + if (err) + goto put_sample_out; + err =3D damon_sysfs_sample_add_dirs(sample); if (err) goto put_sample_out; attrs->sample =3D sample; @@ -869,6 +1000,7 @@ static void damon_sysfs_attrs_rm_dirs(struct damon_sys= fs_attrs *attrs) kobject_put(&attrs->nr_regions_range->kobj); damon_sysfs_intervals_rm_dirs(attrs->intervals); kobject_put(&attrs->intervals->kobj); + damon_sysfs_sample_rm_dirs(attrs->sample); kobject_put(&attrs->sample->kobj); } =20 --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 03B0A31B101; Mon, 8 Dec 2025 06:30:03 +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=1765175404; cv=none; b=XpuX5nsnsUXZ45dNO8V1KsRkLbZtxmrg8ncDnsJX/O7p4LMfRtdZbAVcMnbjXY1gzBvLS0VQofbr+DG/8InGnR98Ohl2Uo/RNbwA+u2AyoBghUqnqojp3dNxFEkyNo7gGGtsfXxSlvuaV//ovLtTB3Or0Zbh2+sifW3kvVujT1g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175404; c=relaxed/simple; bh=HqSr2dVJCwPH4hyJgJqnf3m06RGc89x094A8SJ4rv+U=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=HqMMoJEFuJfAE5HXKLN3KpqmgCRyNykIJJZiIPVhktjWr4CgQnJThEWBLH+et5jjWxIGBwVLr+BZ3/AFUbAMqfHW3aQQasvXY3lxzWd/ip8RuQerS0H7TZ9r7l5Zqb48pk5GwEiJ9KChdIpybnQZsM8vCZ1mc/o9P9UkbC5fPew= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=vIXLTVp7; 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="vIXLTVp7" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9F03BC113D0; Mon, 8 Dec 2025 06:30:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175403; bh=HqSr2dVJCwPH4hyJgJqnf3m06RGc89x094A8SJ4rv+U=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=vIXLTVp7/6bmfAS4G3mn84o+NgRZe3aM4W/0ATsBaPJzAgWfWNp65xQP4uEu1kdg0 eUpGG6eFBBMNmeW6wAd++++tZOEbSTTNVxLqwrcCzUz2kidF6/9WUWaaielwjVdNp+ Gro5lJ8x5IxhUltkdEspo/9xmJMmARN5eKNuJg5S7gzqrXqqyRgfyPrWQOcmDn3z9S EO5af6uaHfyA2E1iz6nDyGmklI35B/a+ZnsuEFhxUgcb2IJHmEEz7O/YtuNKHy75fI 3lCfVjr1NBlLNIXLR6AgKS+mlyr8jVC77Z96iJCPNPTSRALlrP2uIiv4ITYocQ5lVF p/+ec5asC+fsA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 10/37] mm/damon/sysfs: connect primitives directory with core Date: Sun, 7 Dec 2025 22:29:14 -0800 Message-ID: <20251208062943.68824-11-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 monitoring_attrs/sample/primitives/ directory is not connected with the core layer. Make the connection. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 14478fd79953..16d58cde03e8 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1640,6 +1640,17 @@ static inline bool damon_sysfs_kdamond_running( damon_is_running(kdamond->damon_ctx); } =20 +static int damon_sysfs_set_sample_control( + struct damon_sample_control *control, + struct damon_sysfs_sample *sysfs_sample) +{ + control->primitives_enabled.page_table =3D + sysfs_sample->primitives->page_table; + control->primitives_enabled.page_fault =3D + sysfs_sample->primitives->page_fault; + return 0; +} + static int damon_sysfs_apply_inputs(struct damon_ctx *ctx, struct damon_sysfs_context *sys_ctx) { @@ -1654,6 +1665,10 @@ static int damon_sysfs_apply_inputs(struct damon_ctx= *ctx, ctx->min_sz_region =3D max( DAMON_MIN_REGION / sys_ctx->addr_unit, 1); err =3D damon_sysfs_set_attrs(ctx, sys_ctx->attrs); + if (err) + return err; + err =3D damon_sysfs_set_sample_control(&ctx->sample_control, + sys_ctx->attrs->sample); if (err) return err; err =3D damon_sysfs_add_targets(ctx, sys_ctx->targets); --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8DE052DF145; Mon, 8 Dec 2025 06:30:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175406; cv=none; b=C8tUTqcAAEb+2ZtuHgitbsMolLoWPEpW3q4iN5BHIPCIA6x7IuSIGRqQSnAAzNLkKflnuqbjvVXZeH38OLFFilXkiTf9HmaHfp1apIju+NC5FZnHoQHga5sfRYKwfBc23ejP3biTc5I/6a1D7Unq83EzJTMItWktVR4u03cN8bM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175406; c=relaxed/simple; bh=kYp0neqPpPeaEbB6UDhepmoNhZxaB6USicxvRIelMVk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=mBJLY1XFAPgGtALrt0E/ik9fYrfrliF3SVYl1YRHX7tde9gJc+hxS5dNP1WNC4wi2NNT0w6ZYEawRjJbWQ4DsZT0BnbnHI7c2actAHJBdEYYKFbrePtyh+FvWvsAUPXxGWeRUQgKzU1YgJRR0GO7KCy6xBAWvSf5XZDOC5YyfDI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=nrQsyBz8; 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="nrQsyBz8" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EED04C19422; Mon, 8 Dec 2025 06:30:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175406; bh=kYp0neqPpPeaEbB6UDhepmoNhZxaB6USicxvRIelMVk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=nrQsyBz8XneqoGt7kXomZMNDszLsyaBphQqI9vhbG/YI16Pk0iW7d03rE3DlFfjcH /d2/T5SnePvleWqUN/ynQ6+MkGu1ux7qkdv56zSaWrorVThi7vccv2O7FOU2f30Pbj vWEH2ISNFqZfr0P/g8KhnZLwCw0HuI9E88kyjWBRvlz31dszh+xI/+7zKsh13toUEx Pxc/n6MUXc9E0Qfc5e/wPZiUcvMGqUqreRpJDsQXsBRAFWpf6f0Pb2XRLs4r/i9Pui 0Pp70UFcW8yzd9Qeq00aGp5n3F6E4a3Dz4PuEWlnM+QojTeDHRJ1ZaA8eZcXIvnIdR hAMpBTcrwmBgQ== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 11/37] Docs/mm/damon/design: document page fault sampling primitive Date: Sun, 7 Dec 2025 22:29:15 -0800 Message-ID: <20251208062943.68824-12-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 support of page fault events based access check sampling primitives. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 33 +++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index 7fd819b8bbf7..a21973b33bc3 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -117,6 +117,7 @@ to make a reasonable trade-off. Below shows this in de= tail:: =20 +.. _damon_design_pte_accessed_bit_access_check: =20 PTE Accessed-bit Based Access Check ----------------------------------- @@ -135,6 +136,23 @@ the interference is the responsibility of sysadmins. = However, it solves the conflict with the reclaim logic using ``PG_idle`` and ``PG_young`` page fl= ags, as Idle page tracking does. =20 +.. _damon_design_page_fault_access_check: + +Monitoring-purpose Page Faults Based Access Check +------------------------------------------------- + +The operation set implementation for the physical address space (``paddr``= ) can +do the access check using monitoring-purpose page fault events in a way si= milar +to NUMA balancing hinting faults. When it is being used, ``paddr`` instal= ls +the page protection in a way similar to that of NUMA balancing hinting fau= lts. +Then the page fault handler reports the faults happend by the installed pa= ge +protection to DAMON core layer. + +``paddr`` uses :ref:`accessed-bit based check +` by default, and users can ch= ange +it to use this page faults based one, using :ref:`access sampling primitiv= es +selection `. + .. _damon_design_addr_unit: =20 Address Unit @@ -244,6 +262,21 @@ maximum number of regions after the split. In this way, DAMON provides its best-effort quality and minimal overhead w= hile keeping the bounds users set for their trade-off. =20 +.. _damon_design_sampling_primitives_selection: + +Access Sampling Primitives Selection +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Some operations set implementations could utilize multiple access sampling +primitives. For example, the operations set implementation for physical +address space (``paddr``) support two promitives at the moment: 1) page ta= bles' +Accessed bits, and access monitoring-purpose page fault events. In future= , it +could be extended for more hardware features such as AMD IBS or CXL HMU, a= nd +support from the operations set implementation for virtual address spaces +(``vaddr``). DAMON API callers or ABI users can select what primitives to= use. + +At the moment, only exclusive use of the primitives is supported. + =20 .. _damon_design_age_tracking: =20 --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3D9BC31A041; Mon, 8 Dec 2025 06:30:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175409; cv=none; b=pSoS8r8t1aql6bkZ6UR+ueuOL5q8mXnQJDWwVBTioo9sU5oZzlI2HEx3TjdkKlNEwGSJuHtX2xtK4TrbJ7A8UtsLA3PYh4cWOX4orXHarVmWdbZtg8RNuDlsh1LOkBhcRb94nzZDmAA/KyVzaxIGjNVm2bMyMd04LjND4rs0F7o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175409; c=relaxed/simple; bh=BIoh7tGOQxVtDXmZY7UkJm8cloeuUXw++f1jh950BB0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=uIfRbH4kZdSPuSG9yW0T1QNVFZH20ZNy81OvBZFrJssrLIgcaNmJXHCwrWGJT495uqR+lfGdByckTOz/ON61PjeGy1Cex0YEGS0kqR4hZCdpuUDErU+yIn/VOcIdPVzgFI97L/8uQgY3MJ882uIbFnjUHYMoD8j92/aPgWGf41k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=RLiFBe5i; 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="RLiFBe5i" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 849C5C113D0; Mon, 8 Dec 2025 06:30:06 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175408; bh=BIoh7tGOQxVtDXmZY7UkJm8cloeuUXw++f1jh950BB0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=RLiFBe5iASWmPouudCyfwWsSiKUlu5UqEFg7KIkZQ/15AoC6ic71KPhH1QVqAemjA As92e7k+awmI3oMmflwuPiaCwOgOXfB750LFYek0Em9a1uC/cVSpPE3OW2RSaXxIns UMOV1bRFEhAyqm5pSNNbLO7on0TsM7STy06hTRilHUjQsWRaUyAMAeuyJBCC9Yk6Wq yqMU0lkBOT3CYS9cP38/onZptUSA9GxM8y/5OywZnlUl2U3y99wX5KeliufVc801xl WRbO8jkdXllfuVYJAgwRLrwFlQ3JeEKU1Pdc7BqduYfgJQ9sG8/Yg5KJUUTwxPHGeS 7m/a/Ud+zItLw== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 12/37] Docs/admin-guide/mm/damon/usage: document sample primitives dir Date: Sun, 7 Dec 2025 22:29:16 -0800 Message-ID: <20251208062943.68824-13-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 selective access sampling primitives activation, which is essential for using page fault events as the access check sampling primitive. Signed-off-by: SeongJae Park --- Documentation/admin-guide/mm/damon/usage.rst | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/a= dmin-guide/mm/damon/usage.rst index 7da4c002cb39..897a89950351 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -65,6 +65,7 @@ comma (","). =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 :ref:`monitoring_att= rs `/ =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 sample/pri= mitives/page_table,page_faults =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 :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 @@ -215,9 +216,9 @@ 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. +and efficiency of the monitoring, and types of accesses to monitor are in +``monitoring_attrs`` directory. Specifically, three directories, ``interv= als`` +, ``nr_regions`` and ``sample`` exist in this directory. =20 Under ``intervals`` directory, three files for DAMON's sampling interval (``sample_us``), aggregation interval (``aggr_us``), and update interval @@ -232,6 +233,18 @@ writing to and rading from the files. For more details about the intervals and monitoring regions range, please = refer to the Design document (:doc:`/mm/damon/design`). =20 +Under ``sample`` directory, a directory, ``primitives`` exists. + +contexts//monitoring_attrs/sample/primitives/ +------------------------------------------------ + +This directory is for the access sampling primitives :ref:`selection +`. Under ``primitives`` direc= tory, +two files, ``page_table`` and ``page_faults`` exist. By writing ``Y`` or = ``N`` +to these files, users can select whether to use the :ref:`page table acces= sed +bit ` and :ref:`page fault eve= nts +`, respectively. + .. _damon_usage_sysfs_monitoring_intervals_goal: =20 contexts//monitoring_attrs/intervals/intervals_goal/ --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 71A2731AF25; Mon, 8 Dec 2025 06:30:10 +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=1765175410; cv=none; b=SAqWz0B3naZGTFZR7ZaDt/XeLuy6FZlhfFAQ8a5CDPNtsLJhxGuOE/S+SuyqP1P1g7+FNTBeeRtuhL8I6gJTw1BbrjAImpVyt42bbbgQGp45Pfh+FD5oEtYvLh6zUYJtKWeoprP0oCapRLlW/6SgUCC0c8om6EFIxxqBcV9/Pjg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175410; c=relaxed/simple; bh=At5tPajQSPLt9hOlFCrxmrzWPKun1WpQ7z3727tgAL0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=txe6HiZRFlCstd3iL2xteJ8PPnPhU8f08hDKa5Wse32qLu1RUTi44MDSK0S3slUO0oY03xf+1amN0d/5XO8Ik5ivJEfS8+LQo90V0APNHlyxQvU89oolmTOx1Ocnv1fGqXQeJAbWQtX1wUHLvHFOcg4HHShkL2OBnLjL9KvZDsY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bWYxgDEw; 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="bWYxgDEw" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 23296C116B1; Mon, 8 Dec 2025 06:30:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175409; bh=At5tPajQSPLt9hOlFCrxmrzWPKun1WpQ7z3727tgAL0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bWYxgDEwewUI4Si1uvn2A7qlU6sI0b+yWp6SF/szJF2mbBBdXg0ZIAIekRW+ZOrrG 6TbmzOGczenZfeBVT1eGwM8skmQNCoC+T7rzUAg1s/D7qKk5krfv223sDy+Et7SKYV oKDb/jYUtQD9s5Sp7d1+s6HJyBRA78C9StrcOfWWsYip5AOF/H+pRJNQBU5+6oOv9w bB8o7cqHCaJ9YJ8Qk3M3o0RMOD2nKZPDQiL6V77bFV/BxTWnDPT447D3IS3ql5eu4y Hm319ClPVM1KMf1IeY6kU7NtDbSWg2Wq3lUwZjBk+UOcPyDyvcpSJnwXRSjLE7qQRx /YO2G1qXPqUiw== From: SeongJae Park To: Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 13/37] mm/damon: extend damon_access_report for origin CPU reporting Date: Sun, 7 Dec 2025 22:29:17 -0800 Message-ID: <20251208062943.68824-14-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 a field to damon_access_report that can be used to report which CPU has made the reporting access. Signed-off-by: SeongJae Park --- include/linux/damon.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index b04c2e36833a..e23a10ba7c92 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -115,6 +115,7 @@ struct damon_target { * struct damon_access_report - Represent single acces report information. * @addr: The start address of the accessed address range. * @size: The size of the accessed address range. + * @cpu: The id of the CPU that made the access. * * Any DAMON API callers that notified access events can report the inform= ation * to DAMON using damon_report_access(). This struct contains the reporti= ng @@ -123,6 +124,7 @@ struct damon_target { struct damon_access_report { unsigned long addr; unsigned long size; + unsigned int cpu; /* private: */ unsigned long report_jiffies; /* when this report is made */ }; --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 71E8B31A808; Mon, 8 Dec 2025 06:30:11 +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=1765175411; cv=none; b=cXZfYpyDhbwoHcRqrG3V8uDPiwsJlLmttBP3diNHG814JQBd8T0RKmax8UBLhbykhHre50bnVLyuf8/FabuL/XYcitdLu90OSaQTS81gmUNyEAV137xZHZy6QuAEZQXINPO1ZvKBnxSQ/6GMQeocWHFeH+hCN316Km4JyGexPH8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175411; c=relaxed/simple; bh=55qSAyG5lbRxWMFpgyshAGzR1uB1VLHtbYjVj1MXVYk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=IY2ivnbN8s4b1FNv4r/Dv90CDY4d7EUlhw33hat/rmeDysywttm9qTpzEOrFYanXn3eMzwQFrSJEb50O01i07ClSUEFskiY/vdS2eEIm1k+Xtuh5KCDTUb3Sf7MmYEzgMPzi+V0/FseLQOUo66C0Rx7kq2jBpVA0z4ddmXY9Qdw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=pATG9OqS; 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="pATG9OqS" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4DA33C113D0; Mon, 8 Dec 2025 06:30:10 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175411; bh=55qSAyG5lbRxWMFpgyshAGzR1uB1VLHtbYjVj1MXVYk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pATG9OqSqP99RXBWGY7fJfLyZtQHGWBxHulVCPM+ydODfXlD5TnhqK+S5lzerqbZp ekZhX9dMxDZRFfUaHT5/AvN0sqkS6YKZcSOE0NvI5G68DU6bsdO/BIMidyCJY5f5uD 7Vk+6Q1+zj24SDQCehMBMTSI5cwHPpdF896WJoTaJl0qTwmmI0QgVvTKPuzlG2xCn0 ziYlMA33EZHcUSw0rkmrwUQHl+DvAYvJdYA1LgqQtpp7+g2Bk8Z30yh6aCrZ5aB4dQ PxFDxYAGQxvIu08k+g0FHN14/31RkH8JClxSmy8if7CD2SAFIcNFLbMAxaYadwxx9A H0blcK8k17xZw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 14/37] mm/damon/core: report access origin cpu of page faults Date: Sun, 7 Dec 2025 22:29:18 -0800 Message-ID: <20251208062943.68824-15-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 CPU that executes the page fault event reporting function is the CPU that made the access. Report the origin CPU of the access. Signed-off-by: SeongJae Park --- mm/damon/core.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index a14754a47c7f..d2f842d8afd2 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1585,6 +1585,7 @@ void damon_report_page_fault(struct vm_fault *vmf, bo= ol huge_pmd) { struct damon_access_report access_report =3D { .size =3D 1, /* todo: set appripriately */ + .cpu =3D smp_processor_id(), }; =20 if (huge_pmd) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id EA39631B82B; Mon, 8 Dec 2025 06:30:12 +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=1765175413; cv=none; b=JQaesU8ZZTLlemqrYBmTpAj0bQMMFn5QiIYKaLLUX2a/qorYW77MBEvn6oALbhVPqwsO8jcxMtZazI1mhCR+CKEx54ZidUQs+ZhMFt4htXyvV4w1lQJv53u0kUau5v7Cgdnk1L0Oz218tD7XqCc29N9mMp2IEcJZWr/4vWykYJ4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175413; c=relaxed/simple; bh=DBAN6hkU/P5RDm6zU3vPLM0u0djvJ5SiKcRHSXDFMxg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=uhjyw1+Wy12YiVlzZUqGIPwaYOPTqx/i0V5RpW9SjSFpD+gb9fl9KiA91sKVXR/s/DbSmSJS9y1fICKRMgI+hItPzarA6+jaHTAwKtwMSf5vT0nupccElG0LbGkf7Y6rCc6mblnMvXlN1adUmKW4msny6SvX/Hb3asx1mJg6fuk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=u9bFz9IJ; 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="u9bFz9IJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A57FEC116B1; Mon, 8 Dec 2025 06:30:11 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175412; bh=DBAN6hkU/P5RDm6zU3vPLM0u0djvJ5SiKcRHSXDFMxg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=u9bFz9IJ0NFa6OquQ+K7h90ewPoaDRUvo5S3k4xHwsSXIP5d71Z+/NK6jSVU2a153 t5QmPH/kEcJc+2qIbDy5odH3l5EKXL7FFsJwYu2kAW+W84JlSl0CmuK2Sbnzc5c6Fk 7aiYMY3VS8WuHh06ZSNC4RuDS69q4heswKZttGoQzE3aaCiBaeGnXUAiwNagbPbnZE NsKjJv0/2StxSRaHStwFbxsKxgfxzA0mcfWBzlos2tgiw0INJuuJ+WjO3woN+xBGK+ S2WUoXQIIjs3lwquGnwmXicuRu4oOYkT9VGwdhy7MDGfvSoQgUsEd+aA3eY9POSAgY dIZbaAUzOsPwA== From: SeongJae Park To: Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 15/37] mm/damon: implement sample filter data structure for cpus-only monitoring Date: Sun, 7 Dec 2025 22:29:19 -0800 Message-ID: <20251208062943.68824-16-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Access information that is reported via damon_report_access() can inform DAMON not only whether there was an access, but also additional things such as the access-generated CPU. By filtering in/out specific types of the reported access based on such additional information, DAMON can support more fine-tuned monitoring, such as per-CPUs access monitoring. Implement a core API data structure for controlling such filtering. Signed-off-by: SeongJae Park --- include/linux/damon.h | 39 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index e23a10ba7c92..78be584ce5dd 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -781,18 +781,53 @@ struct damon_primitives_enabled { bool page_fault; }; =20 +/** + * enum damon_sample_filter_type - Type of &struct damon_sample_filter. + * + * @DAMON_FILTER_TYPE_CPUMASK: Filter by access-generated CPUs. + * + * Read &struct damon_sample_control for more details. + */ +enum damon_sample_filter_type { + DAMON_FILTER_TYPE_CPUMASK, +}; + +/** + * struct damon_sample_filter - &struct damon_access_report filter. + * + * @type: The type of this filter. + * @matching: Whether it is for condition-matching reports. + * @allow: Whether to include or excludie the @matching reports. + * @cpumask: Access-generated CPUs if @type is DAMON_FILTER_TYPE_CPUMASK. + * @list: List head for siblings. + * + * Read &struct damon_sample_control for more details. + */ +struct damon_sample_filter { + enum damon_sample_filter_type type; + bool matching; + bool allow; + cpumask_t cpumask; + struct list_head list; +}; + /** * struct damon_sample_control - Low level access check sampling rules. * * @primitives_enabled: Enablement of access check primitives. + * @sample_filters: List of access check sample filters. * * DAMON collect low level access information using sampling, and aggregate * that to make higher access pattern picture. It can use multiple sampli= ng - * primitives including page table accessed bits and page fault events. T= his - * struct is for controlling what sampling primitives to use (enable). + * primitives including page table accessed bits and page fault events. I= t can + * also filter in/out specific types of sampled access events to monitor + * accesses of specific types, such as access-generated CPUs. This struct= is + * for controlling what sampling primitives to use (enable), and what samp= led + * access events should be filtered in/out. */ struct damon_sample_control { struct damon_primitives_enabled primitives_enabled; + struct list_head sample_filters; }; =20 /** --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3A46531D366; Mon, 8 Dec 2025 06:30:13 +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=1765175414; cv=none; b=Hck9KG0fDUA0+BO38Tlg05NAFU5CLV6bANM60pesNJgFifhB0DFDXyDrNMv0FVom0bXsWi9I8SwC/zbEcpI2QZDeywCE543/6dTJeF7w6MNu94W8E0ISivC3JZhOsYrbzLhFSu5GB7l/blV7OIHI9btH3bJjEZMJC4RCCIKmIpw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175414; c=relaxed/simple; bh=YPnSi5M7u97aTRieMiHi7Bu1nhCZ+HHUKBFpBBpeqKc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=B7wwYgUPmPPBpRnL/kENzjyBvqLM/fCL44eCfgNuSYrPI9Z4kUioGEA8L9EF6ciFjgHQt5o03zxZPGKtv+F42SPPGfNOwDZRLccq0aMLip0WgZiVOwx+yDslzk1ebKJKftViUK7j0G1sL3Dem0VGKAc02f7xyA/quSLQboEGQ24= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bwtpk9Vd; 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="bwtpk9Vd" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D2673C113D0; Mon, 8 Dec 2025 06:30:12 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175413; bh=YPnSi5M7u97aTRieMiHi7Bu1nhCZ+HHUKBFpBBpeqKc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bwtpk9Vd4vrAjXdu+Ctd4td0gpjFcxyLgrazZzrenIIZvhJn+IUMrfbqM012cAkPK 4VyOKWJtp1gDHMdQ+i+MyhhJ9tz0oclTNl3ruANfwuKzTKbjbMp2uGqePbWHoHvztQ 9ghRHb7AHRZZAzH7iYKqlNrPAZuYtfgfBcdH2H3O6fZDYHfpA3bAQeGokqZ2OQ1dCs t9bkI/OOqV/F5+nKVCawY9qS0EMKXsyDlervg5viMH36AAOUy0zD54FEcU6VMZwRo4 Mv6ak+y8CjbpLzR5hpINFvZFct2LEgTwreIMdv27mspWLjTQY1JJM9FHFUlEmrMoGK TJgbSfE0dwdPw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 16/37] mm/damon/core: implement damon_sample_filter manipulations Date: Sun, 7 Dec 2025 22:29:20 -0800 Message-ID: <20251208062943.68824-17-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 basic manipulation helper functions for damon_sample_filter data structure. Signed-off-by: SeongJae Park --- include/linux/damon.h | 15 +++++++++++++++ mm/damon/core.c | 45 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 78be584ce5dd..aff34dce7c7c 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -947,6 +947,12 @@ static inline unsigned long damon_sz_region(struct dam= on_region *r) #define damon_for_each_target_safe(t, next, ctx) \ list_for_each_entry_safe(t, next, &(ctx)->adaptive_targets, list) =20 +#define damon_for_each_sample_filter(f, control) \ + list_for_each_entry(f, &(control)->sample_filters, list) + +#define damon_for_each_sample_filter_safe(f, next, control) \ + list_for_each_entry_safe(f, next, &(control)->sample_filters, list) + #define damon_for_each_scheme(s, ctx) \ list_for_each_entry(s, &(ctx)->schemes, list) =20 @@ -1022,6 +1028,15 @@ void damon_free_target(struct damon_target *t); void damon_destroy_target(struct damon_target *t, struct damon_ctx *ctx); unsigned int damon_nr_regions(struct damon_target *t); =20 +struct damon_sample_filter *damon_new_sample_filter( + enum damon_sample_filter_type filter_type, bool matching, + bool allow); +void damon_add_sample_filter(struct damon_sample_control *ctrl, + struct damon_sample_filter *filter); +void damon_free_sample_filter(struct damon_sample_filter *filter); +void damon_destroy_sample_filter(struct damon_sample_filter *filter, + struct damon_sample_control *ctrl); + struct damon_ctx *damon_new_ctx(void); void damon_destroy_ctx(struct damon_ctx *ctx); int damon_set_attrs(struct damon_ctx *ctx, struct damon_attrs *attrs); diff --git a/mm/damon/core.c b/mm/damon/core.c index d2f842d8afd2..4b98473eef84 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -533,6 +533,46 @@ unsigned int damon_nr_regions(struct damon_target *t) return t->nr_regions; } =20 +struct damon_sample_filter *damon_new_sample_filter( + enum damon_sample_filter_type filter_type, bool matching, + bool allow) +{ + struct damon_sample_filter *filter; + + filter =3D kmalloc(sizeof(*filter), GFP_KERNEL); + if (!filter) + return NULL; + filter->type =3D filter_type; + filter->matching =3D matching; + filter->allow =3D allow; + INIT_LIST_HEAD(&filter->list); + return filter; +} + +void damon_add_sample_filter(struct damon_sample_control *ctrl, + struct damon_sample_filter *filter) +{ + list_add_tail(&filter->list, &ctrl->sample_filters); +} + +static void damon_del_sample_filter(struct damon_sample_filter *f, + struct damon_sample_control *ctrl) +{ + list_del(&f->list); +} + +void damon_free_sample_filter(struct damon_sample_filter *f) +{ + kfree(f); +} + +void damon_destroy_sample_filter(struct damon_sample_filter *f, + struct damon_sample_control *ctrl) +{ + damon_del_sample_filter(f, ctrl); + damon_free_sample_filter(f); +} + struct damon_ctx *damon_new_ctx(void) { struct damon_ctx *ctx; @@ -561,6 +601,7 @@ struct damon_ctx *damon_new_ctx(void) ctx->attrs.max_nr_regions =3D 1000; =20 ctx->sample_control.primitives_enabled.page_table =3D true; + INIT_LIST_HEAD(&ctx->sample_control.sample_filters); =20 ctx->addr_unit =3D 1; ctx->min_sz_region =3D DAMON_MIN_REGION; @@ -582,12 +623,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_sample_filter *f, *next_f; =20 damon_destroy_targets(ctx); =20 damon_for_each_scheme_safe(s, next_s, ctx) damon_destroy_scheme(s); =20 + damon_for_each_sample_filter_safe(f, next_f, &ctx->sample_control) + damon_destroy_sample_filter(f, &ctx->sample_control); + kfree(ctx); } =20 --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3D8B331AF0A; Mon, 8 Dec 2025 06:30:15 +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=1765175415; cv=none; b=mQ4lsmYGwV02ZUbLe1FprrrOTpUFdJ+IFPp7eprko3Ck6RgqJykBzr/xizcAZ+L9bA2NQcMz9kFt1E9F7ttTuf1fheJh05IdyWWpBqQ6R7BHEvINdFYGBbbKd+n8tHYBVc773EUDz+MLnT80xUvbLlsTRGfjSF+Zy4Uo9tyTYWc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175415; c=relaxed/simple; bh=CBKpePU8YzS24DYStTop8saXN/aFoeKY8A1ZQfy6x5c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=utEWsi1lG7FLojZCkKH81bz5kcsMTjbbXwb0S+byZsiqo4yGwxYgn7LonVATwpJbfGNdIOZhCDcklnojSNZIWvD/+KXtq+mrFnqyJ5GI+vxuKLo7SD3szKt6BalDHB6IOv9HCBRPmgIZREmN2w+qDvMIPvYVbSvqAhHl+VCzfao= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=n1fWbwwd; 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="n1fWbwwd" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 297D2C19421; Mon, 8 Dec 2025 06:30:14 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175415; bh=CBKpePU8YzS24DYStTop8saXN/aFoeKY8A1ZQfy6x5c=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=n1fWbwwdL26H7CSpT1GiJ3AXdvHU2IoXrM7xZolVsqDyKPyOqF/8dNFIB3QywHqBy 4YIGrJZ1XhOsJiXFJ5xEvJ2qURr2ItUpG13MwlQ4tvtts08nLfjyFn4LlDzJRnrJS4 ApOrQasTN5tCXMWznZl364rhzFlGYVy8MdJqxyUjqQyyBK2OorUA6VEC07qdSIITgh 46i5xwRlJK+r9e/oj6UeoEjJQxu6Anm/BS+ZX7IXz/23Xcz2xocIbTZl6JqYCfzyxY j6+Kms2homn/pE2wPiIPeOcGFX0tZKx34/pbbECHjMI6wpFuRfDUSzXLSppPb98TGd zp1YsLwz1jrmA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 17/37] mm/damon/core: commit damon_sample_filters Date: Sun, 7 Dec 2025 22:29:21 -0800 Message-ID: <20251208062943.68824-18-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 data structure for access sample results filtering is not supported on the online parameters update function. Hence the feature cannot be used with the online parameters update. Add the support. Signed-off-by: SeongJae Park --- mm/damon/core.c | 76 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 75 insertions(+), 1 deletion(-) diff --git a/mm/damon/core.c b/mm/damon/core.c index 4b98473eef84..d952a833a05e 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -573,6 +573,19 @@ void damon_destroy_sample_filter(struct damon_sample_f= ilter *f, damon_free_sample_filter(f); } =20 +static struct damon_sample_filter *damon_nth_sample_filter(int n, + struct damon_sample_control *ctrl) +{ + struct damon_sample_filter *f; + int i =3D 0; + + damon_for_each_sample_filter(f, ctrl) { + if (i++ =3D=3D n) + return f; + } + return NULL; +} + struct damon_ctx *damon_new_ctx(void) { struct damon_ctx *ctx; @@ -1290,6 +1303,67 @@ static int damon_commit_targets( return 0; } =20 +static int damon_commit_sample_filter_arg(struct damon_sample_filter *dst, + struct damon_sample_filter *src) +{ + switch (src->type) { + case DAMON_FILTER_TYPE_CPUMASK: + dst->cpumask =3D src->cpumask; + break; + default: + break; + } + return 0; +} + +static int damon_commit_sample_filter(struct damon_sample_filter *dst, + struct damon_sample_filter *src) +{ + int err; + + err =3D damon_commit_sample_filter_arg(dst, src); + if (err) + return err; + dst->matching =3D src->matching; + dst->allow =3D src->allow; + return 0; +} + +static int damon_commit_sample_filters(struct damon_sample_control *dst, + struct damon_sample_control *src) +{ + struct damon_sample_filter *dst_filter, *next, *src_filter, *new_filter; + int i =3D 0, j =3D 0, err; + + damon_for_each_sample_filter_safe(dst_filter, next, dst) { + src_filter =3D damon_nth_sample_filter(i++, src); + if (src_filter) { + err =3D damon_commit_sample_filter(dst_filter, + src_filter); + if (err) + return err; + } else { + damon_destroy_sample_filter(dst_filter, dst); + } + } + + damon_for_each_sample_filter_safe(src_filter, next, src) { + if (j++ < i) + continue; + + new_filter =3D damon_new_sample_filter( + src_filter->type, src_filter->matching, + src_filter->allow); + if (!new_filter) + return -ENOMEM; + err =3D damon_commit_sample_filter_arg(new_filter, src_filter); + if (err) + return err; + damon_add_sample_filter(dst, new_filter); + } + return 0; +} + static bool damon_primitives_enabled_invalid( struct damon_primitives_enabled *config) { @@ -1304,7 +1378,7 @@ static int damon_commit_sample_control( return -EINVAL; =20 dst->primitives_enabled =3D src->primitives_enabled; - return 0; + return damon_commit_sample_filters(dst, src); } =20 /** --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6239B13790B; Mon, 8 Dec 2025 06:30:16 +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=1765175417; cv=none; b=jDa3Z0bx1CT1o+dfjFk5N4XAnoDfJU1HU0v25rl7yURiV2cGwjjcGdkJYzEJ8Vb88JlnyNmmrNABwSFxFAP3g3qb7JZfx5lMWejxVudMuDHai0tL6T0DEXzPoy1K5grWlYDPFyxcPptKjO5BX+BBSFAZVDYKWUJX7fNfXuk13xI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175417; c=relaxed/simple; bh=Fdrtqh4dKdLy2JHMv9GeJLVmZnlNDk6aLdhfIH2zS/Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=kKvmaxQq1DBS9d9u4g29ZtA1yZoH+7GkT2BcysZ/zGLR1OhBKcUyMy83xTCxDsSwghl3aewHYld7XfdGFT5VmTKrvbbfcZhsP0BHj8SjaRRtVsEARg+ffPehG4RB0ULgkl+TupipZWhsyAptAFee4Hevv2QIew7KlsV2XuJtzok= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hZn3EHdk; 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="hZn3EHdk" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7A998C116B1; Mon, 8 Dec 2025 06:30:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175416; bh=Fdrtqh4dKdLy2JHMv9GeJLVmZnlNDk6aLdhfIH2zS/Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hZn3EHdkDpxrRmJltAlArQeaA57+8Wo92tB0OhFhhDJ4QTwsfWMhHq3XoUr5ZNDpA GqBKwPf/5UC82CkIgWWTfyNVmJzrSmvqVvVn6Jt+UUQvfoDGHjye+RvrC7zuoZ20oG EgguVOwNeu6ve5Dtxrf5Bo3fzHPjtI9ZJu/dpVkNSjpWhHDSMYWoP23uhZH/xMjmka +qc4Zd9URYiVZRPV7ykkEm3gACny9AZ53ua1BElOi8w7XvPqBmls2ZWMllFgtiEnHr 1/qBFl51cnDBPbOi68h1fTJnvqk8NyIIJ/3VcoZIsOHqmHlKfkcMtZukfOSXuhJdbe sFtnr5Tv+8Jmg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 18/37] mm/damon/core: apply sample filter to access reports Date: Sun, 7 Dec 2025 22:29:22 -0800 Message-ID: <20251208062943.68824-19-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 data structure for access sample results filtering is not really being used on the core layer. Implement the support. Signed-off-by: SeongJae Park --- mm/damon/core.c | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index d952a833a05e..b627fc84161c 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -586,6 +586,13 @@ static struct damon_sample_filter *damon_nth_sample_fi= lter(int n, return NULL; } =20 +static struct damon_sample_filter *damon_last_sample_filter_or_null( + struct damon_sample_control *ctrl) +{ + return list_last_entry_or_null(&ctrl->sample_filters, + struct damon_sample_filter, list); +} + struct damon_ctx *damon_new_ctx(void) { struct damon_ctx *ctx; @@ -2866,11 +2873,45 @@ static void kdamond_init_ctx(struct damon_ctx *ctx) } } =20 +static bool damon_sample_filter_matching(struct damon_access_report *repor= t, + struct damon_sample_filter *filter) +{ + bool matched =3D false; + + switch (filter->type) { + case DAMON_FILTER_TYPE_CPUMASK: + matched =3D cpumask_test_cpu(report->cpu, &filter->cpumask); + break; + default: + break; + } + return matched =3D=3D filter->matching; +} + +static bool damon_sample_filter_out(struct damon_access_report *report, + struct damon_sample_control *ctrl) +{ + struct damon_sample_filter *filter; + + damon_for_each_sample_filter(filter, ctrl) { + if (damon_sample_filter_matching(report, filter) && + !filter->allow) + return true; + } + filter =3D damon_last_sample_filter_or_null(ctrl); + if (!filter) + return false; + return !filter->allow; +} + static void kdamond_apply_access_report(struct damon_access_report *report, struct damon_target *t, struct damon_ctx *ctx) { struct damon_region *r; =20 + if (damon_sample_filter_out(report, &ctx->sample_control)) + return; + /* todo: make search faster, e.g., binary search? */ damon_for_each_region(r, t) { if (report->addr < r->ar.start) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8E52131A808; Mon, 8 Dec 2025 06:30:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175418; cv=none; b=YXczHs09oC+bglNRCGBJigbybdsEOU68/4JWFISgKxsVvvSdxaNvS/RIj/ftp7v+btUTfo/SMLacxpv0jASoLdVJ0fwONFtZfdH4T1ZNVXBO8TbLXdso4q1F1job/WOe/nN5h0vHOD6e+DyR4yOHNANFG4PYH9NhyYMqNsZy5VI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175418; c=relaxed/simple; bh=R9m1eSl/V//tH4nv+68KXrctOAqXsKHuChO2fV0643Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=XElzzI6kah4QJkypF0f+UtlT48iIBUKok7v8owBWA5n2OJAOoKZQsmvrcAXFFxaBbt851CeyM2kmVjfNt7yK4Lf4C4VmmjiGCxjgAqZuolbnYuut+Uh1qaIv9k4WOzWiv67LTLFB4uVEByeMb4DjTm321/o/UxZpwN1UdUy2L64= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KBamaiLI; 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="KBamaiLI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id CB7B3C4CEF1; Mon, 8 Dec 2025 06:30:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175417; bh=R9m1eSl/V//tH4nv+68KXrctOAqXsKHuChO2fV0643Q=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KBamaiLINXILpgvGkgCQPbnTIHWtwp2rObqcA/i3cCRUkLuYOUTyDUBNU0lqHPqWJ gVbtbaaGI3dPObeMnBCW58NnnqLc707Oiqa7T8R3biwJ9nF94DTs0P6XVf6hOPpLQF l1+UpWH3GBSnC0/rp1YEGAABhen7ltyKK3nHuk42tlZDfVzhbzsIWfG1pTwjDTW3pK gmRChhrcxN7V406wIiciL5N7BlFleI+z6LkmuU00RUgoAr8vXhBFf6XLE0I6VadldR X+di5Q5FhDiFvn5zl+dLDLPKZDnzLSJRp0shJ6RhRJ02fowl7VGccZra1NDAEqaNg9 DCh5eL0wV/IPQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 19/37] mm/damon/sysfs: implement sample/filters/ directory Date: Sun, 7 Dec 2025 22:29:23 -0800 Message-ID: <20251208062943.68824-20-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 a directory for letting DAMON ABI users install and uninstall DAMON sample filters. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 16d58cde03e8..4208fed2b8df 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -749,6 +749,36 @@ static const struct kobj_type damon_sysfs_intervals_kt= ype =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * access check report filters directory + */ + +struct damon_sysfs_sample_filters { + struct kobject kobj; +}; + +static struct damon_sysfs_sample_filters * +damon_sysfs_sample_filters_alloc(void) +{ + return kzalloc(sizeof(struct damon_sysfs_sample_filters), GFP_KERNEL); +} + +static void damon_sysfs_sample_filters_release(struct kobject *kobj) +{ + kfree(container_of(kobj, struct damon_sysfs_sample_filters, kobj)); +} + +static struct attribute *damon_sysfs_sample_filters_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_sample_filters); + +static const struct kobj_type damon_sysfs_sample_filters_ktype =3D { + .release =3D damon_sysfs_sample_filters_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_sample_filters_groups, +}; + /* * access check primitives directory */ @@ -854,6 +884,7 @@ static const struct kobj_type damon_sysfs_primitives_kt= ype =3D { struct damon_sysfs_sample { struct kobject kobj; struct damon_sysfs_primitives *primitives; + struct damon_sysfs_sample_filters *filters; }; =20 static struct damon_sysfs_sample *damon_sysfs_sample_alloc(void) @@ -871,6 +902,7 @@ static int damon_sysfs_sample_add_dirs( struct damon_sysfs_sample *sample) { struct damon_sysfs_primitives *primitives; + struct damon_sysfs_sample_filters *filters; int err; =20 primitives =3D damon_sysfs_primitives_alloc(true, false); @@ -883,6 +915,19 @@ static int damon_sysfs_sample_add_dirs( goto put_primitives_out; sample->primitives =3D primitives; =20 + filters =3D damon_sysfs_sample_filters_alloc(); + if (!filters) + return -ENOMEM; + err =3D kobject_init_and_add(&filters->kobj, + &damon_sysfs_sample_filters_ktype, &sample->kobj, + "filters"); + if (err) + goto put_filters_out; + sample->filters =3D filters; + return 0; +put_filters_out: + kobject_put(&filters->kobj); + sample->filters =3D NULL; put_primitives_out: kobject_put(&primitives->kobj); sample->primitives =3D NULL; @@ -894,6 +939,9 @@ static void damon_sysfs_sample_rm_dirs( { if (sample->primitives) kobject_put(&sample->primitives->kobj); + if (sample->filters) { + kobject_put(&sample->filters->kobj); + } } =20 static void damon_sysfs_sample_release(struct kobject *kobj) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CE29C31AF17; Mon, 8 Dec 2025 06:30:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175419; cv=none; b=k8UdxgxDVunLXq8JewZKAMP2OS7UFatE7fuO2s3WRKQEPM8dEJNyEl/68kRpklxPFUznjo3l7+sodG+WE7aJievdI7MyOQRg0u0f1FIucEIUTiNPQ4jjiWWoLZYOdUDoHzOdgS0alb2KTGcfwKzB7bCXgxkjSs7K2TMLYr2CHWU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175419; c=relaxed/simple; bh=fqtI2Gnz07OVYPT/2oX+SDTbNLPGFodcuU+kQDn13Ek=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=F+A1iLvP9GcxjOfzmv7C7disTc2Z/MUg9Yy1ccm1OlP9hB0668xhSvgJHhhsdgly837Yw5ssSVJ1GgMg8GApdmH4RSZn7YCwhN9wZI5kUKxy9YIMu0DOaqxmd3XgRLJb1F8ihcJcF2Boiein9odO1RXG0uXll/85Fsp35b9RRO0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=diF8S5Xl; 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="diF8S5Xl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 29D0BC19421; Mon, 8 Dec 2025 06:30:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175419; bh=fqtI2Gnz07OVYPT/2oX+SDTbNLPGFodcuU+kQDn13Ek=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=diF8S5Xl62t4a4nrz6s9jCM+NbKUjbmQqLXN6ILr6Xw7ZT9FjwflJzMxaRNvwJ3xS 0qJlyuAKQSwruTpl/XCWLD27ziMxSuAnNrATHYkI6vMUm+Pts1Ap79LBGceoNAa04F RnjRiX+z4WCT5BINlgRz623mMcThFeb3xcqQGAcAdB112HUr40JjaHQkUj9NqBW8c9 R+OdqQeNs5DTvdLmzFmUorj1/3LKOz8wpb4tvhZ6JzJKvMm+O9ymy4c6YfcIM5cawr 3bdgx3SBR+sHWHr962QlfwlxxxUzZ5H2wAPSQhyJrBKurxOcZR/dWoQu3bBKB+cO1p IXPyl/gyERCXQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 20/37] mm/damon/sysfs: implement sample filter directory Date: Sun, 7 Dec 2025 22:29:24 -0800 Message-ID: <20251208062943.68824-21-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 setting individual DAMON sample filters. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 122 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 4208fed2b8df..ba0c76c1300c 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -749,12 +749,46 @@ static const struct kobj_type damon_sysfs_intervals_k= type =3D { .default_groups =3D damon_sysfs_intervals_groups, }; =20 +/* + * access check report filter directory + */ + +struct damon_sysfs_sample_filter { + struct kobject kobj; +}; + +static struct damon_sysfs_sample_filter *damon_sysfs_sample_filter_alloc(v= oid) +{ + return kzalloc(sizeof(struct damon_sysfs_sample_filter), GFP_KERNEL); +} + +static void damon_sysfs_sample_filter_release(struct kobject *kobj) +{ + struct damon_sysfs_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + + kfree(filter); +} + +static struct attribute *damon_sysfs_sample_filter_attrs[] =3D { + NULL, +}; +ATTRIBUTE_GROUPS(damon_sysfs_sample_filter); + +static const struct kobj_type damon_sysfs_sample_filter_ktype =3D { + .release =3D damon_sysfs_sample_filter_release, + .sysfs_ops =3D &kobj_sysfs_ops, + .default_groups =3D damon_sysfs_sample_filter_groups, +}; + /* * access check report filters directory */ =20 struct damon_sysfs_sample_filters { struct kobject kobj; + struct damon_sysfs_sample_filter **filters_arr; + int nr; }; =20 static struct damon_sysfs_sample_filters * @@ -763,12 +797,99 @@ damon_sysfs_sample_filters_alloc(void) return kzalloc(sizeof(struct damon_sysfs_sample_filters), GFP_KERNEL); } =20 +static void damon_sysfs_sample_filters_rm_dirs( + struct damon_sysfs_sample_filters *filters) +{ + struct damon_sysfs_sample_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_sample_filters_add_dirs( + struct damon_sysfs_sample_filters *filters, int nr_filters) +{ + struct damon_sysfs_sample_filter **filters_arr, *filter; + int err, i; + + damon_sysfs_sample_filters_rm_dirs(filters); + if (!nr_filters) + return 0; + + filters_arr =3D kmalloc_array(nr_filters, sizeof(*filters_arr), + 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_sample_filter_alloc(); + if (!filter) { + damon_sysfs_sample_filters_rm_dirs(filters); + return -ENOMEM; + } + + err =3D kobject_init_and_add(&filter->kobj, + &damon_sysfs_sample_filter_ktype, + &filters->kobj, "%d", i); + if (err) { + kobject_put(&filter->kobj); + damon_sysfs_sample_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_sample_filters *filters =3D container_of(kobj, + struct damon_sysfs_sample_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_sample_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_sample_filters, kobj); + + if (!mutex_trylock(&damon_sysfs_lock)) + return -EBUSY; + err =3D damon_sysfs_sample_filters_add_dirs(filters, nr); + mutex_unlock(&damon_sysfs_lock); + if (err) + return err; + + return count; +} + static void damon_sysfs_sample_filters_release(struct kobject *kobj) { kfree(container_of(kobj, struct damon_sysfs_sample_filters, kobj)); } =20 +static struct kobj_attribute damon_sysfs_sample_filters_nr_attr =3D + __ATTR_RW_MODE(nr_filters, 0600); + static struct attribute *damon_sysfs_sample_filters_attrs[] =3D { + &damon_sysfs_sample_filters_nr_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_sample_filters); @@ -940,6 +1061,7 @@ static void damon_sysfs_sample_rm_dirs( if (sample->primitives) kobject_put(&sample->primitives->kobj); if (sample->filters) { + damon_sysfs_sample_filters_rm_dirs(sample->filters); kobject_put(&sample->filters->kobj); } } --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0787D2BF006; Mon, 8 Dec 2025 06:30:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175422; cv=none; b=KpzTm+InPLzdXtYDD8h/OCKFIICKIXNMsCHg/nxtppTS/Ccm+DSyRLhbhwJNTGK6g2gYojkhLWU0gO72sKCHBvyiBCxi5O6RY+nELvpumBS6OG+tzRHI9vpKGZiZHjQmI995G+e+k82Zsr8fOrm+PSvD3yXUw8H2quHIZiKR23Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175422; c=relaxed/simple; bh=XR7TB9uLErl/OwhdiQ9KeniuUlLpDcU/pwQSdNEDmO0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=VzTYCMXey8tELWyCC4fmZ+CmdHQnjB4VQCaUEPG2ibcLqtNOvuCY9/Y0cKxEREYe2TvgeuvFvHhWG8yTZ0e2D606jwyJ9zDKeGo9jcIuQfWTj5ldIMhWOqgczR4oDIOU/pRGN8CjYMoPbs7f7c1qbMY83l4CrSCtF4pgejMckNU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=VmWOxnCr; 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="VmWOxnCr" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 79218C4CEF1; Mon, 8 Dec 2025 06:30:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175420; bh=XR7TB9uLErl/OwhdiQ9KeniuUlLpDcU/pwQSdNEDmO0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=VmWOxnCrqPZaZ0CQ3C+sAg9ZamAn3Pm5iZ8i2KGLyn4XeXa68XpbbzfhW3bCM8mMJ Ug4LgYGuooQouVyQ1sGTUaX4wjszQi0q9r9w4UjIKuVBcx994Al7dov0KBTeUwnLl4 LxIvF60thKzawCoVYOQvmoFycP9F6E74Zp2JBE7jF+v4CiFm8L0p/DKgH38Z3/2AHp fu1hJFMw+ziHHa2n9/vG/Eg+fQhRUQQrTma6+YK7lPntuRFeW/kyFxldT6aAhBH1cG e7Lb6m9G1PkcJgi8VGQuviQhGUvSUyMzgtN2zrPF9ZRrDVPes/GnZ5c0FjCqR26mD8 xgJjjcw2rE9Pw== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 21/37] mm/damon/sysfs: implement type, matching, allow files under sample filter dir Date: Sun, 7 Dec 2025 22:29:25 -0800 Message-ID: <20251208062943.68824-22-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 sample filter directory is not really having the file to set up for the properties of the representing DAMON sample filter. Implement files for setting the properties. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 101 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index ba0c76c1300c..74594e6e461c 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -755,6 +755,9 @@ static const struct kobj_type damon_sysfs_intervals_kty= pe =3D { =20 struct damon_sysfs_sample_filter { struct kobject kobj; + enum damon_sample_filter_type type; + bool matching; + bool allow; }; =20 static struct damon_sysfs_sample_filter *damon_sysfs_sample_filter_alloc(v= oid) @@ -762,6 +765,92 @@ static struct damon_sysfs_sample_filter *damon_sysfs_s= ample_filter_alloc(void) return kzalloc(sizeof(struct damon_sysfs_sample_filter), GFP_KERNEL); } =20 +static ssize_t type_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + struct damon_sysfs_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + int i =3D 0; + + for (; i < ARRAY_SIZE(damon_sysfs_sample_filter_type_names); i++) { + const struct damon_sysfs_sample_filter_type_name *type_name; + + type_name =3D &damon_sysfs_sample_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_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + ssize_t ret =3D -EINVAL; + int i =3D 0; + + for (; i < ARRAY_SIZE(damon_sysfs_sample_filter_type_names); i++) { + const struct damon_sysfs_sample_filter_type_name *type_name; + + type_name =3D &damon_sysfs_sample_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_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_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_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_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_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_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_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + bool allow; + int err =3D kstrtobool(buf, &allow); + + if (err) + return err; + + filter->allow =3D allow; + return count; +} + static void damon_sysfs_sample_filter_release(struct kobject *kobj) { struct damon_sysfs_sample_filter *filter =3D container_of(kobj, @@ -770,7 +859,19 @@ static void damon_sysfs_sample_filter_release(struct k= object *kobj) kfree(filter); } =20 +static struct kobj_attribute damon_sysfs_sample_filter_type_attr =3D + __ATTR_RW_MODE(type, 0600); + +static struct kobj_attribute damon_sysfs_sample_filter_matching_attr =3D + __ATTR_RW_MODE(matching, 0600); + +static struct kobj_attribute damon_sysfs_sample_filter_allow_attr =3D + __ATTR_RW_MODE(allow, 0600); + static struct attribute *damon_sysfs_sample_filter_attrs[] =3D { + &damon_sysfs_sample_filter_type_attr.attr, + &damon_sysfs_sample_filter_matching_attr.attr, + &damon_sysfs_sample_filter_allow_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_sample_filter); --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 557BF2D8764; Mon, 8 Dec 2025 06:30:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175423; cv=none; b=rcw8QUuK+2NJCtvGQHDlj4UMHOJIGyg1P4N8SFxOXKj5l2YqUBS0W/efrfbdBkc4x8posL0XZHWzI0i3VLVz8tPjtn00nU0A6tl+dWteOr0hLyHVhlqx6ACLVk3+DyvTLfkCLaMNlUs6Rw8XernJ62inWA3R3QBv3ofSLHS1vkc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175423; c=relaxed/simple; bh=WawtKcdhhI5OD3ibegWa6UMwH2uHq8mmOHPfQB4SyPw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=S3UwEKhUXTeaQLCa8UbeCtdhg5+SW3imYHl1Xm4FY/2lle5yYQ2BrfRw2NA6/yxrjT7CRAJrSYdcVnZp8IexiILRq4lKgvvP8C/SEMFobzaXNW3yHYd1v6yHolH7JA3PT67fVDIZJlZMVDHfbtufh3HHEOyQCh7QMQmW9AHJlsI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=aurXw1mb; 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="aurXw1mb" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D5D9BC19422; Mon, 8 Dec 2025 06:30:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175421; bh=WawtKcdhhI5OD3ibegWa6UMwH2uHq8mmOHPfQB4SyPw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=aurXw1mb7+DNtDpJv9c+X16hkpu7iLBKNTqx3ERbpveUEL1bLXLkCTPqiCj4TmA61 sdDkXckh9cBhOeKgjKPG5C4RW0kPzYzcIXKCJa8nnP5u5nOCXNSTx2QctBlb/swGvs /iBJ3qv2lXDDAh0vhogHIF4P3J5MvZlunpW88MFJAL6sZvdwvXN6tWNDAd2axqY46/ pFTzuRlkJPWy/c4Gp0QVSh/o00y7K78T05ZGpPs0yzpxZR/iB0gKVvh6/7yQ3EdtoF hdtWm4tjFlzkvelHHAY/sNDo0yA7mqnL6/KVEoqaAsA+3M+hUOKHlY7uJlI97L6nFA Stny1jirD/d9g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 22/37] mm/damon/sysfs: implement cpumask file under sample filter dir Date: Sun, 7 Dec 2025 22:29:26 -0800 Message-ID: <20251208062943.68824-23-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 DAON sample filter directory has files for only common properties. Add a file to further specify the CPUs to filter in or out. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 74594e6e461c..d6b0b6513fd1 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -758,6 +758,7 @@ struct damon_sysfs_sample_filter { enum damon_sample_filter_type type; bool matching; bool allow; + cpumask_t cpumask; }; =20 static struct damon_sysfs_sample_filter *damon_sysfs_sample_filter_alloc(v= oid) @@ -765,6 +766,19 @@ static struct damon_sysfs_sample_filter *damon_sysfs_s= ample_filter_alloc(void) return kzalloc(sizeof(struct damon_sysfs_sample_filter), GFP_KERNEL); } =20 +struct damon_sysfs_sample_filter_type_name { + enum damon_sample_filter_type type; + char *name; +}; + +static const struct damon_sysfs_sample_filter_type_name +damon_sysfs_sample_filter_type_names[] =3D { + { + .type =3D DAMON_FILTER_TYPE_CPUMASK, + .name =3D "cpumask", + }, +}; + static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { @@ -851,6 +865,29 @@ static ssize_t allow_store(struct kobject *kobj, return count; } =20 +static ssize_t cpumask_show(struct kobject *kobj, struct kobj_attribute *a= ttr, + char *buf) +{ + struct damon_sysfs_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + + return sysfs_emit(buf, "%*pbl\n", cpumask_pr_args(&filter->cpumask)); +} + +static ssize_t cpumask_store(struct kobject *kobj, struct kobj_attribute *= attr, + const char *buf, size_t count) +{ + struct damon_sysfs_sample_filter *filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + cpumask_t cpumask; + int err =3D cpulist_parse(buf, &cpumask); + + if (err) + return err; + filter->cpumask =3D cpumask; + return count; +} + static void damon_sysfs_sample_filter_release(struct kobject *kobj) { struct damon_sysfs_sample_filter *filter =3D container_of(kobj, @@ -868,10 +905,14 @@ static struct kobj_attribute damon_sysfs_sample_filte= r_matching_attr =3D static struct kobj_attribute damon_sysfs_sample_filter_allow_attr =3D __ATTR_RW_MODE(allow, 0600); =20 +static struct kobj_attribute damon_sysfs_sample_filter_cpumask_attr =3D + __ATTR_RW_MODE(cpumask, 0600); + static struct attribute *damon_sysfs_sample_filter_attrs[] =3D { &damon_sysfs_sample_filter_type_attr.attr, &damon_sysfs_sample_filter_matching_attr.attr, &damon_sysfs_sample_filter_allow_attr.attr, + &damon_sysfs_sample_filter_cpumask_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_sample_filter); --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4E3992D3A75; Mon, 8 Dec 2025 06:30:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175423; cv=none; b=u7yAeahZvoTTsytNgVv18W26gwLMxrWejSAFvmflsTEnz0L2iAuZleAkbYh3nACKtr2IFJ+eXtemoGg0S89QE6BPShT9Jl49dgbNgc35nahgkBkCnRbYHUpG6p49Ex+rOEPA0NrS73FXhqYzuthm2ejRHkBqRxJVWiWOYBUuiMc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175423; c=relaxed/simple; bh=QdvS7fwjEHTygGGbOIz6Ht6d55+sgZP4hFmu5IDrnVM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TK7eAVRzz1ASgTuVSPShQaplVuMxo8+dVbGuz40G9Ji/AY3RAbPhPwMWcunJi6Ypj16fN9TFsuD8teQ99Iv7uUBwPZEbJYLFRGPwxbCcVKTE9YNVMRJ7q2MS2pWs2ygYPRfJv1suC+yybxUIAW7OqSEe8yrxNcGxVAyYL+l981o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CNkul2iS; 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="CNkul2iS" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3EB73C4CEF1; Mon, 8 Dec 2025 06:30:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175423; bh=QdvS7fwjEHTygGGbOIz6Ht6d55+sgZP4hFmu5IDrnVM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=CNkul2iSXsQ14qVswyuoPgh7WhQlrFK6KDpfr49NKoT7+ekP7VI1kiUzeVKw/h8o5 e124ct7G+hZnLujpWYfVlVuivbilZbqhHwqW9M1CxxCFQglSa4MSmyW41DDg2xh5be BJ9RdcHt6Cx3Rkq0Sntjy0EJYIWb9j50EZ30Uz8KVHB4rN7XtcXaPeox7XYH06WWl0 YQ/porikMi9xZ29JGuupPckTOXxHaONboOpTuzcMVLMTCIr37ifXnpcxZc39K7I+Fi dfb+hqPYhzn7NLhLr5NU6dS0k7hRCFxepp0vfR7fQaHALUnedGPYL8BZMOEy0EjnNa wureveNDGsrVA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 23/37] mm/damon/sysfs: connect sample filters with core layer Date: Sun, 7 Dec 2025 22:29:27 -0800 Message-ID: <20251208062943.68824-24-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Only basic file operations are implemented for the DAMON sample filters sysfs directory. The user inputs are not really passed to the core layer. Make the connection. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index d6b0b6513fd1..3aac2aea6b0c 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -1952,6 +1952,35 @@ static inline bool damon_sysfs_kdamond_running( damon_is_running(kdamond->damon_ctx); } =20 +static int damon_sysfs_set_sample_filters( + struct damon_sample_control *control, + struct damon_sysfs_sample_filters *sysfs_filters) +{ + int i, err; + + for (i =3D 0; i < sysfs_filters->nr; i++) { + struct damon_sysfs_sample_filter *sysfs_filter =3D + sysfs_filters->filters_arr[i]; + struct damon_sample_filter *filter; + + filter =3D damon_new_sample_filter( + sysfs_filter->type, sysfs_filter->matching, + sysfs_filter->allow); + if (!filter) + return -ENOMEM; + switch (filter->type) { + case DAMON_FILTER_TYPE_CPUMASK: + filter->cpumask =3D sysfs_filter->cpumask; + break; + default: + break; + } + damon_add_sample_filter(control, filter); + } + return 0; +} + + static int damon_sysfs_set_sample_control( struct damon_sample_control *control, struct damon_sysfs_sample *sysfs_sample) @@ -1960,7 +1989,9 @@ static int damon_sysfs_set_sample_control( sysfs_sample->primitives->page_table; control->primitives_enabled.page_fault =3D sysfs_sample->primitives->page_fault; - return 0; + + return damon_sysfs_set_sample_filters(control, + sysfs_sample->filters); } =20 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx, --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D96B031ED88; Mon, 8 Dec 2025 06:30: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=1765175426; cv=none; b=sj3EJzxjFtDVrBRyc0pBpcYZ7cWn+vfnQo/EMBCCBxIE9pzRmuUJ1c/s+ggPmonQZp6kM3nAsHY3DC7Ihm0wFkQbbmOLtpiVL3e8IyCnGozLGAA6kYpmapAx1iOe0H3+hUahYp/p8gb7z4HAePltqZ+aMbFX00ZVZXNf4IiSMC8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175426; c=relaxed/simple; bh=Z3BU9CS2/j7n/yC26uZia3+mZzwDzeK0PuZdStu70eg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QxhqeHV5Lqt0APETJVCaTCv3JSA8DIjggSrVV41qSyWyjXaYIWnipnZMojT/0PPWtCukdMR/yD226M7UbrQeV9ku57OEnsjFgYuFqNXlxR6Xbe6y4i344saxd/ps+sgZWh2WXGu28TbW9CeSL3jW4fyZV20UM/5N5jEWpvDkQTc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=UGROWyCH; 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="UGROWyCH" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8A6D0C113D0; Mon, 8 Dec 2025 06:30:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175425; bh=Z3BU9CS2/j7n/yC26uZia3+mZzwDzeK0PuZdStu70eg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=UGROWyCHMiZMIYeqcr9kV7I8TYwKqYB9dRXryFVgu9qrdUCUTVwppf6+w9tTDAObP eXbFXGQWcLfv6mSZ1Kk4gbN2jUTUBgrh4UsshTLQl0M+QNcp8Va6gBCWilhMd7FMaZ 4DUcJ9l49nwkMViyr0l9E75gM7sUyXIDQ523NrpDHVq09jSfynaZnvsyNP7tyDC7sp OGof0rw1sVdJphQvqXV1bdF3WzW6jSzjaq5FeBZkl+tTFBq/iAzb4eTWgUtxvglXKU 3x/828CVdPgula6Cy67DeV3ihTijcTjCP1s2IJVmDO/LABJ+vgQ0meEHAxSsg1BHEY iEoXYUw9mJvpg== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 24/37] Docs/mm/damon/design: document sample filters Date: Sun, 7 Dec 2025 22:29:28 -0800 Message-ID: <20251208062943.68824-25-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 access sample results filtering. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 42 +++++++++++++++++++++++++++++-- 1 file changed, 40 insertions(+), 2 deletions(-) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index a21973b33bc3..9a4679de437f 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -146,12 +146,17 @@ do the access check using monitoring-purpose page fau= lt events in a way similar to NUMA balancing hinting faults. When it is being used, ``paddr`` instal= ls the page protection in a way similar to that of NUMA balancing hinting fau= lts. Then the page fault handler reports the faults happend by the installed pa= ge -protection to DAMON core layer. +protection to DAMON core layer. Compared to the accessed-bit based one, t= his +approach gives more information to DAMON, such as the access-generated +CPU. =20 ``paddr`` uses :ref:`accessed-bit based check ` by default, and users can ch= ange it to use this page faults based one, using :ref:`access sampling primitiv= es -selection `. +selection `. Also, the addtio= nal +information can be used for doing monitoring of only specific type accesse= s, +using :ref:`access sampling results filters +`. =20 .. _damon_design_addr_unit: =20 @@ -277,6 +282,39 @@ support from the operations set implementation for vir= tual address spaces =20 At the moment, only exclusive use of the primitives is supported. =20 +.. _damon_design_sampling_results_filters: + +Access Sampling Results Filter +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Depending on the access sampling primitives that used, the sampling results +could inform more than whether an access is made, such as the CPU or the t= hread +the sampled access was made from, and whether the sampled access was for +writing or reading. By filtering the results based on the additional +information, DAMON can perform for more detailed access monitoring, such as +per-CPUs/threads or read/write-only monitoring. + +For such special types of monitoring, DAMON provides a feature called "sam= pling +results filter". The feature allows users to set an arbitrary number of +filters for the sampling results. Each of the filters specifies + +- a type of the additional information (``type``), +- whether it is for the sampling results of the type or all except the type + (``matching``), and +- whether it is to allow (include) or reject (exclude) consuming of the ty= pe of + sampling results. + +Each filter is applied in the order of the installation. Only sampling re= sults +that allowed by previous filters are continue to be evaluated by the next +filters. If a sampling result is decided to be rejected by a filter, it is +just discarded and no later filter is applied. + +Below ``type`` of access sampling results filter are currently supported. + +- cpumask + - Whether the sampled access was generated by a cpu that included in a + given cpumask. + =20 .. _damon_design_age_tracking: =20 --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 855F53203A5; Mon, 8 Dec 2025 06:30: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=1765175428; cv=none; b=d8k+1NeS6smCWlX5YQi6a/OpYyEvRgadixl0ljUIE84bR1WqFq1NI6dWzImItvvbr03O2lfG2uInOFRMn/W+LmK16v/F2ygtAhkppbJBSeCxoE6x3BYTYIlJ/GLnZ/cOajru/2hL9AxJHsA2WzfJkYAUi11ByDEhW3eNWYy7mpI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175428; c=relaxed/simple; bh=MflKOa3kMKRZ5nzC/NEJe7cCxqAo99+D2pDObNtur7k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=nMbquzFb/t6pN2CurQq5g00P2qgrxjnuMojbMWsexMZJystAu9Cwvi2+91U02cww19TTbqcP4y+iCASE2dm48/6WwmAWpySkrsNIhEIkC6llzLtfDO6PV96nQxhOamiIVQMefpOfrs6dghJki3urmgrPNuLdA81fZ7yfrGsobXk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=q1Qe9zDT; 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="q1Qe9zDT" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 22CA8C4CEF1; Mon, 8 Dec 2025 06:30:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175428; bh=MflKOa3kMKRZ5nzC/NEJe7cCxqAo99+D2pDObNtur7k=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=q1Qe9zDTQODkH0a6LlN0LLWPF56eQxGRzEzYfMFdQWUh7byIaHBuE4XMnoV9G6fhB +cME28lPAyXBwZhM6UAEy9chg2ADqQhP99ZJd8Sc6fRu+JXcwxMuTckTYvg5FLyWd+ TKnJDcfq9YyYXiHBWQLV8OldynKIBRUgSw9K3qS4gqksQKLkrLaB33oxuKcZ/GCpAs NyAjkU5LejRDQlJvyIzJoIC/wp7yaH5ETycmwWyTKGm/z7W5BjBfyCg7kmNXxXEiqq UQYeR029RoU2S9MXdtbV4X+g7EMdij9R0ZRE5ILqnE4hykX7RTMMIcOTPRSTn973ny 6UTvSMDPJgySQ== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 25/37] Docs/admin-guide/mm/damon/usage: document sample filters dir Date: Sun, 7 Dec 2025 22:29:29 -0800 Message-ID: <20251208062943.68824-26-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 added DAMON sysfs files for installing and setting the access sample results filtering. Signed-off-by: SeongJae Park --- Documentation/admin-guide/mm/damon/usage.rst | 25 +++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/a= dmin-guide/mm/damon/usage.rst index 897a89950351..365a4548a5ba 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -66,6 +66,8 @@ 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 sample/pri= mitives/page_table,page_faults + =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 sample/fil= ters/nr_filters + =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,cpumask =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 :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 @@ -233,7 +235,8 @@ writing to and rading from the files. For more details about the intervals and monitoring regions range, please = refer to the Design document (:doc:`/mm/damon/design`). =20 -Under ``sample`` directory, a directory, ``primitives`` exists. +Under ``sample`` directory, two directories, ``primitives`` and ``filters`` +exist. =20 contexts//monitoring_attrs/sample/primitives/ ------------------------------------------------ @@ -245,6 +248,26 @@ to these files, users can select whether to use the :r= ef:`page table accessed bit ` and :ref:`page fault eve= nts `, respectively. =20 +contexts//monitoring_attrs/sample/filters/ +--------------------------------------------- + +This directory is for control of the :ref:`access sampling results filters +`. At the beginning, this director= y has +only one file, ``nr_filters``. Writing a positive integer ```` to the = file +generates directories of the number, named ``0`` to ````. The gene= rated +directories represent the sampling result filters to install to the DAMON +context, in the order of the directory names. Writing ``0`` to ``nr_filte= rs`` +removes the directories. + +Under the individual filter directory, five files, ``type``, ``matching``, +``allow``, and ``cpumask`` exist. The first three files are same to the +properties of the filter specified on the :ref:`design doc +`. + +Users can specify the cpumask of the filter by writing it to ``cpumask``. = The +format for ``cpumask`` input is same to that for other cpumask inputs like= that +for cgroup cpusets. + .. _damon_usage_sysfs_monitoring_intervals_goal: =20 contexts//monitoring_attrs/intervals/intervals_goal/ --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E3D4B320A10; Mon, 8 Dec 2025 06:30: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=1765175430; cv=none; b=uIMgHN/Pp/d2SUBliMPRmVc7s/kekjFSLB8dNgCHw/DJ8vbw+VDPWOTx5Uua1ajb1l4Zw5o8hP0ffGj6/xFPOfVOP8rsv74urlov6YQQAjgbDJTT/UbttE2RUk/CMe41suSy7UteXir3Z6TbAdS3tOamCBthptCr64wosULjBkE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175430; c=relaxed/simple; bh=JPE1XJEWPTQxQyA4KvTjuuct2aS89H1amzc/wDg9UWM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=nTSaYo6/guGRxC15b9vLhQmThDRklBQ9sgpGoecx/xCrtwiB7aw4JGN8pLJ0Jcs1w5T1ZuSpYTFwTeIBKaKmTHb1OJjScEkK0K7zQO7awtOFibtlisliUfLDBSDH1Ru5/wcXvo4eGB9aUvrEOTvUSiuMhReTZWaXGG6ekYzOaV4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=tJgREwbl; 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="tJgREwbl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B051BC19421; Mon, 8 Dec 2025 06:30:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175429; bh=JPE1XJEWPTQxQyA4KvTjuuct2aS89H1amzc/wDg9UWM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=tJgREwblfsPOxlzcswCmUBjL+skiE69803sMzc3gSdhETg2/YQKMTmiUTdKrSpIXk NOdj/igxZZbOXrL/JAkgCT3/YtMbkS8uSBPiL810CntJQ/tU7m05PHbrEEkZno5dnB WRjYU3mEpQ6zRE373T7OxkdT30znjkQ4N5WHpSyPbR63r/0upbHKttJQhRjI/p/WTF yOofkVwejRIAofsv5sqTF00LqmTd7DUrOd0bD9M08jltQoMdW6NXLtPz8u+VG/FUQ5 ZBE2ZhkelamznjhP0Cm7Y7YRfH7sDjVUVFLL7Vz5vaDereF7P85kB8UwEKDPAMdDrF 4HvoQZYRLZk6A== From: SeongJae Park To: Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 26/37] mm/damon: extend damon_access_report for access-origin thread info Date: Sun, 7 Dec 2025 22:29:30 -0800 Message-ID: <20251208062943.68824-27-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 access reporter might be able to know which thread has made the reporting access. Extend the report data structure for the information. Signed-off-by: SeongJae Park --- include/linux/damon.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index aff34dce7c7c..80332bb2b73c 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -116,6 +116,7 @@ struct damon_target { * @addr: The start address of the accessed address range. * @size: The size of the accessed address range. * @cpu: The id of the CPU that made the access. + * @tid: The task id of the task that made the access. * * Any DAMON API callers that notified access events can report the inform= ation * to DAMON using damon_report_access(). This struct contains the reporti= ng @@ -125,6 +126,7 @@ struct damon_access_report { unsigned long addr; unsigned long size; unsigned int cpu; + pid_t tid; /* private: */ unsigned long report_jiffies; /* when this report is made */ }; --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 54EC931A81C; Mon, 8 Dec 2025 06:30: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=1765175431; cv=none; b=LuRQuDs/yt7HwL/pq6Z+Dj0fm6DOFKCARNtveIFZP+6wDZqUbKmPgm7PFUOGGepT7w/AWAkMZ6EkEoH6sXjFdB0ETeAKTUqnoHfAUNUhhzW3GG+GfZJTpPwwZTuxcOsth8PZqKG9ALPTTBn7HMOFj1/xM6DVhKwZY/qQSU3rFmI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175431; c=relaxed/simple; bh=r7GPIONjiVkaUh4sMuF9LOredJ7nNRhajhKCAfUCZiU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=us68mNdJy/LADjyF5Jqv/V/6MKzed53+OugB/uJEMBbax20FHd4/841Y+AlEgMe6pmHXEgFwjcYMBsRWFnzaIEU2cWwfjFOpSsaTdTZrTUDDe4E/+AAjbtFJorkTxibXK55ej0dED7oDkWZzU08iodJRaCR6dLzYerCdj9WYWCs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LRoORpL2; 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="LRoORpL2" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D9AF1C116B1; Mon, 8 Dec 2025 06:30:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175430; bh=r7GPIONjiVkaUh4sMuF9LOredJ7nNRhajhKCAfUCZiU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=LRoORpL2ykkJNrHjZAbab6K5OR2TidIB5ylB9NIAUOm0kdPhMebK6wNPzQcvsUBzd GvhpiQIf/Ott8rwvoHP2Rew4ueO5b2lhpAKmZAxxmfXefloTY5pKmNETdULJIan6zj 0WyjrmAbH+cMJESAjRevzCXUnkJAlsajrXMgJsrSIX7feapX9ddTkp8h8hmKvdMsrq H3ztjraMeKsU6FZQNVtH0ZQLVRqjmpbXyWNVecz1565U2DMhBzzc+heIEkEnXwCO2J yMXlAmjOpkmY8Yo1vo3JrmEGpg/xkw9tOFTSiR822DpAJvN5kX8EhRqpRml+FCdhvb CPzbMFDn7trOg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 27/37] mm/damon/core: report access-generated thread id of the fault event Date: Sun, 7 Dec 2025 22:29:31 -0800 Message-ID: <20251208062943.68824-28-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Page fault event reporting function can know which thread is making the access. Add the information to the report. Signed-off-by: SeongJae Park --- mm/damon/core.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index b627fc84161c..4971647d4b5e 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1712,6 +1712,7 @@ void damon_report_page_fault(struct vm_fault *vmf, bo= ol huge_pmd) struct damon_access_report access_report =3D { .size =3D 1, /* todo: set appripriately */ .cpu =3D smp_processor_id(), + .tid =3D task_pid_vnr(current), }; =20 if (huge_pmd) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 30C63320CA8; Mon, 8 Dec 2025 06:30: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=1765175432; cv=none; b=Hq6FlVKPEk8tUipkOY0H1vaFWQJf7CMADaNL7DvqwBDfvMAAen7t73nm5V/NTbeqEofWI4B0X37PVIMmLCeic1NQMHaHmP/T4P92ER4iJv5Yyjwob0HK8u8ZWx4F0VnzAvhD2S9riXhgrR+vyWSW89JhrRMBOhOPK3obsWc/pvQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175432; c=relaxed/simple; bh=5bka80r89gRSONmAfQQwGshd2Lcq1UBCMlN2eimMurQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=NI6wBJs37+cjEznsuyzCNZ1TmsoZond9ZP3oL1kCbGho9Aa40fjTNSHb/MPd0GvT6EJMNAuhfHbKSrvJJDPHtZGe5Tjp5QspkcWCzorU0kPjj/o3KudBzQB0CCGo0c/Afr1dD1Ucfdnj/f2UOE+mR6n+7lFg8B6ajbrvd+PCoB4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=cdPmNLQb; 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="cdPmNLQb" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 38B08C4CEF1; Mon, 8 Dec 2025 06:30:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175432; bh=5bka80r89gRSONmAfQQwGshd2Lcq1UBCMlN2eimMurQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=cdPmNLQb0JS4kyN0C0aSoPXZcXcC7pKfrTP1MSY+OtHS9al9RJAd+Nbyj+Ik3k5BP IRERY4Z+6ATXkmOOoOJnf1rh8RWQCPK63AHKeazoV3/Q7WfHtEaNhC+9SrCa7dUDXg TZ5z2GaNy1bgSzGGz5vjrAXGDvGFGyDRohfks2I2k0Q8wGeB5db/DMSWpDr+FpLlM1 XE8atbc/zYtR+0xbpIBWXV4+W4FqTr/y/wqf8AzikmNXDYmFhRmkxDlL9xvVfNJow6 UGllFv5ETbtMBvDmJ7Dc8ECbu11DSX99uofXonsxVWsJySVQPlg9LGroBt1lua3RHV S6ZYQTE58i+Dw== From: SeongJae Park To: Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 28/37] mm/damon: extend damon_sample_filter for threads Date: Sun, 7 Dec 2025 22:29:32 -0800 Message-ID: <20251208062943.68824-29-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Now DAMON access reports could inform which thread was making the reporting access. By filtering the reports based on the threads, DAMON can do per-threads monitoring. Extend DAMON access sample filter to do such filtering. Signed-off-by: SeongJae Park --- include/linux/damon.h | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 80332bb2b73c..e3408280ea72 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -787,11 +787,13 @@ struct damon_primitives_enabled { * enum damon_sample_filter_type - Type of &struct damon_sample_filter. * * @DAMON_FILTER_TYPE_CPUMASK: Filter by access-generated CPUs. + * @DAMON_FILTER_TYPE_THREADS: Filter by access-generated threads. * * Read &struct damon_sample_control for more details. */ enum damon_sample_filter_type { DAMON_FILTER_TYPE_CPUMASK, + DAMON_FILTER_TYPE_THREADS, }; =20 /** @@ -801,6 +803,9 @@ enum damon_sample_filter_type { * @matching: Whether it is for condition-matching reports. * @allow: Whether to include or excludie the @matching reports. * @cpumask: Access-generated CPUs if @type is DAMON_FILTER_TYPE_CPUMASK. + * @tid_arr: Array of access-generated thread ids, if @type is + * DAMON_FILTER_TYPE_THREADS. + * @nr_tids: Size of @tid_arr, if @type is DAMON_FILTER_TYPE_THREADS. * @list: List head for siblings. * * Read &struct damon_sample_control for more details. @@ -809,7 +814,13 @@ struct damon_sample_filter { enum damon_sample_filter_type type; bool matching; bool allow; - cpumask_t cpumask; + union { + cpumask_t cpumask; + struct { + pid_t *tid_arr; + int nr_tids; + }; + }; struct list_head list; }; =20 @@ -823,9 +834,9 @@ struct damon_sample_filter { * that to make higher access pattern picture. It can use multiple sampli= ng * primitives including page table accessed bits and page fault events. I= t can * also filter in/out specific types of sampled access events to monitor - * accesses of specific types, such as access-generated CPUs. This struct= is - * for controlling what sampling primitives to use (enable), and what samp= led - * access events should be filtered in/out. + * accesses of specific types, such as access-generated CPUs and threads. = This + * struct is for controlling what sampling primitives to use (enable), and= what + * sampled access events should be filtered in/out. */ struct damon_sample_control { struct damon_primitives_enabled primitives_enabled; --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id ADE2A320CBF; Mon, 8 Dec 2025 06:30: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=1765175433; cv=none; b=gcJorvOBvj681L5dogvDF0cV5kdU4wqI05UwQn8bvHJUa3UrXkcescgX1ZrP+lB/RtT+Z2M8civAMdqCPekcOaHpFVJYsPqBdGV8PfTbdGmKJAk4L8VK0zoDvgViGrp5+DE1ClFUQZG7CCPrie2IHVcYP7J7gpAyCETD/NyRhG4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175433; c=relaxed/simple; bh=gwTxa0+Xw/5ku9fEShf6P61CX21upFsU6eEBzrxcpzU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=T79zt6GorIUIGPUZgFvy4R3zouM+v29Aec0Y40epqiDyx6/lh6UxlWgwFjBErQdJfNvJmdPjkZtAEXH60jX+bBWo7zh1Fg4m/AqNYUCzJlpF6Pnr+fOzP3wkPWYVPykVFfy/qX5LxLfddLwko5OjTFqeA9jycd6AKWN9Fe2Bcxs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=euXt4Rbs; 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="euXt4Rbs" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 66783C113D0; Mon, 8 Dec 2025 06:30:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175433; bh=gwTxa0+Xw/5ku9fEShf6P61CX21upFsU6eEBzrxcpzU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=euXt4RbsZvz/JVIq9rAtil0vOmQVNcrpPL1Nccoc9a4iX1XyV4b0MLoBdiEspWc+z UiF6XeIRapawls7mzSEnKfrTs+8j2R48XDy9BL07iOO35DWwo0HCY/ttxi/sHwUqxj gb3vJ+tisW6bhNcejx9VhjNpz0iDE+Bc79FP8xMm4LY7KHmPZtWEWb0QZkz0vmkT+5 Lrp6xQgaTcjaZSXbLKlCf2GegD8FvCsKyanGqvD7rw+ToXL9z6k6q5y+XYCrcCNFx5 uwCmOjS3uUc6QzBnBuEmvPqMxJKaASKq73+b2jQ9Zh1KFr6jZk+7YSM+C0+t+B04Ro 3na0LG6r+aL4g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 29/37] mm/damon/core: support threads type sample filter Date: Sun, 7 Dec 2025 22:29:33 -0800 Message-ID: <20251208062943.68824-30-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Access-generated threads based access sample filter type is not really being respected on the core layer. Implement the support for doing the filtering, and committing the information when doing the online parameters update. Signed-off-by: SeongJae Park --- mm/damon/core.c | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index 4971647d4b5e..782af39ef0c0 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -546,6 +546,10 @@ struct damon_sample_filter *damon_new_sample_filter( filter->matching =3D matching; filter->allow =3D allow; INIT_LIST_HEAD(&filter->list); + if (filter_type =3D=3D DAMON_FILTER_TYPE_THREADS) { + filter->tid_arr =3D NULL; + filter->nr_tids =3D 0; + } return filter; } =20 @@ -570,6 +574,10 @@ void damon_destroy_sample_filter(struct damon_sample_f= ilter *f, struct damon_sample_control *ctrl) { damon_del_sample_filter(f, ctrl); + if (f->type =3D=3D DAMON_FILTER_TYPE_THREADS) { + kfree(f->tid_arr); + f->nr_tids =3D 0; + } damon_free_sample_filter(f); } =20 @@ -1317,6 +1325,17 @@ static int damon_commit_sample_filter_arg(struct dam= on_sample_filter *dst, case DAMON_FILTER_TYPE_CPUMASK: dst->cpumask =3D src->cpumask; break; + case DAMON_FILTER_TYPE_THREADS: + if (dst->type =3D=3D DAMON_FILTER_TYPE_THREADS) + kfree(dst->tid_arr); + dst->tid_arr =3D kmalloc_array(src->nr_tids, + sizeof(*dst->tid_arr), GFP_KERNEL); + if (!dst->tid_arr) + return -ENOMEM; + memcpy(dst->tid_arr, src->tid_arr, sizeof(*dst->tid_arr) * + src->nr_tids); + dst->nr_tids =3D src->nr_tids; + break; default: break; } @@ -2878,11 +2897,20 @@ static bool damon_sample_filter_matching(struct dam= on_access_report *report, struct damon_sample_filter *filter) { bool matched =3D false; + int i; =20 switch (filter->type) { case DAMON_FILTER_TYPE_CPUMASK: matched =3D cpumask_test_cpu(report->cpu, &filter->cpumask); break; + case DAMON_FILTER_TYPE_THREADS: + for (i =3D 0; i < filter->nr_tids; i++) { + if (report->tid !=3D filter->tid_arr[i]) + continue; + matched =3D true; + break; + } + break; default: break; } --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C61C232143F; Mon, 8 Dec 2025 06:30: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=1765175434; cv=none; b=ifv/5PM6Dm8wN7mgNW0i0q7XehX3/yGunGk6EXFJOiSHaYhFjjknY1r2RQgZddFxMgQr58XskWDDasKlDkVTh2zPBhjHG2WSpEwTmzg688f8Nc5aVQux/VvKeVUqz79McBO0+eMWmWIG7gLoQkzM6TwJvCGZzbbzlfxtdAsf/rw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175434; c=relaxed/simple; bh=3JZCkxkL4i/kCYq9wc6IiaTGi5wDXb4PyYdbk+AUHf8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=b0xd4OPl/Kc7s8caZ9FQybG8wQ9QSw4ZKuqjbWRJszpqZSEDQWaJctvlXp905nGgKdcvzW2npqmyqgoireg0h6K/UaTpOLJBKZwtNmrrO8v9BKyxma0LtmXbe67fvHLcGKFuZIUH86ELUQkIYYNZflN1sEq9AKk9voy8fb95LJA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=lPzC8mFh; 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="lPzC8mFh" Received: by smtp.kernel.org (Postfix) with ESMTPSA id B0AD8C19421; Mon, 8 Dec 2025 06:30:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175434; bh=3JZCkxkL4i/kCYq9wc6IiaTGi5wDXb4PyYdbk+AUHf8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=lPzC8mFhApK44AZvUzvwj+vo6IrDlAMEE5iJ9ohs4vVx8YFqcfCPEy4nxJfKP1ppg 6ZznWeeXOhkl3NdXCkNyJU1vNhCTA3vjJmkw8vn4SnWbB44QcpBDsEVdjjP7SCY4c2 lRXZOJ1wVVY6hvlcor6fZLEeZcUdvZ2wqlRGMwZwcslxW8ohkFxNZpLvEqmJycs4UK jOLUzQfTZMD45lsKWkW7xE3U0OYt6sG0g5PiUjkz3WJyt1t79cpLPtFIhiGsF6AEwY eIzvmmkUmC1s8ca5DE672uyCZFaE0sPqSuNXj8g+1pzRf4AkUgqzCih/TEz5hTeYbk y7ENPFpbIzg9g== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 30/37] mm/damon/sysfs: support thread based access sample filtering Date: Sun, 7 Dec 2025 22:29:34 -0800 Message-ID: <20251208062943.68824-31-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 support of the threads based access sample filtering on DAMON sysfs interface. For this, add a new file for setting the threads of interest of the filter, and pass it to the core layer. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 75 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index 3aac2aea6b0c..b96df2d2d17e 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -759,6 +759,7 @@ struct damon_sysfs_sample_filter { bool matching; bool allow; cpumask_t cpumask; + int *tid_arr; /* first entry is the length of the array */ }; =20 static struct damon_sysfs_sample_filter *damon_sysfs_sample_filter_alloc(v= oid) @@ -777,6 +778,10 @@ damon_sysfs_sample_filter_type_names[] =3D { .type =3D DAMON_FILTER_TYPE_CPUMASK, .name =3D "cpumask", }, + { + .type =3D DAMON_FILTER_TYPE_THREADS, + .name =3D "threads", + }, }; =20 static ssize_t type_show(struct kobject *kobj, @@ -888,6 +893,47 @@ static ssize_t cpumask_store(struct kobject *kobj, str= uct kobj_attribute *attr, return count; } =20 +static ssize_t tid_arr_show(struct kobject *kobj, struct kobj_attribute *a= ttr, + char *buf) +{ + struct damon_sysfs_sample_filter *sample_filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + char *str; + int nr_tids, *tid_arr; + int i, ret; + + if (!sample_filter->tid_arr) + return sysfs_emit(buf, "\n"); + + str =3D kcalloc(2048, sizeof(*str), GFP_KERNEL); + if (!str) + return -ENOMEM; + nr_tids =3D sample_filter->tid_arr[0]; + tid_arr =3D &sample_filter->tid_arr[1]; + for (i =3D 0; i < nr_tids; i++) { + snprintf(&str[strlen(str)], 2048 - strlen(str), "%d", + tid_arr[i]); + if (i < nr_tids - 1) + snprintf(&str[strlen(str)], 2048 - strlen(str), ","); + } + ret =3D sysfs_emit(buf, "%s\n", str); + kfree(str); + return ret; +} + +static ssize_t tid_arr_store(struct kobject *kobj, struct kobj_attribute *= attr, + const char *buf, size_t count) +{ + struct damon_sysfs_sample_filter *sample_filter =3D container_of(kobj, + struct damon_sysfs_sample_filter, kobj); + int err; + + err =3D parse_int_array(buf, count, &sample_filter->tid_arr); + if (err) + return err; + return count; +} + static void damon_sysfs_sample_filter_release(struct kobject *kobj) { struct damon_sysfs_sample_filter *filter =3D container_of(kobj, @@ -908,11 +954,15 @@ static struct kobj_attribute damon_sysfs_sample_filte= r_allow_attr =3D static struct kobj_attribute damon_sysfs_sample_filter_cpumask_attr =3D __ATTR_RW_MODE(cpumask, 0600); =20 +static struct kobj_attribute damon_sysfs_sample_filter_tid_arr_attr =3D + __ATTR_RW_MODE(tid_arr, 0600); + static struct attribute *damon_sysfs_sample_filter_attrs[] =3D { &damon_sysfs_sample_filter_type_attr.attr, &damon_sysfs_sample_filter_matching_attr.attr, &damon_sysfs_sample_filter_allow_attr.attr, &damon_sysfs_sample_filter_cpumask_attr.attr, + &damon_sysfs_sample_filter_tid_arr_attr.attr, NULL, }; ATTRIBUTE_GROUPS(damon_sysfs_sample_filter); @@ -1952,6 +2002,25 @@ static inline bool damon_sysfs_kdamond_running( damon_is_running(kdamond->damon_ctx); } =20 +static int damon_sysfs_set_threads_filter(struct damon_sample_filter *filt= er, + int *sysfs_tid_arr) +{ + int nr_tids, i; + pid_t *tid_arr; + + if (!sysfs_tid_arr) + return -EINVAL; + nr_tids =3D sysfs_tid_arr[0]; + tid_arr =3D kmalloc_array(nr_tids, sizeof(*tid_arr), GFP_KERNEL); + if (!tid_arr) + return -ENOMEM; + for (i =3D 0; i < nr_tids; i++) + tid_arr[i] =3D sysfs_tid_arr[i + 1]; + filter->tid_arr =3D tid_arr; + filter->nr_tids =3D nr_tids; + return 0; +} + static int damon_sysfs_set_sample_filters( struct damon_sample_control *control, struct damon_sysfs_sample_filters *sysfs_filters) @@ -1972,6 +2041,12 @@ static int damon_sysfs_set_sample_filters( case DAMON_FILTER_TYPE_CPUMASK: filter->cpumask =3D sysfs_filter->cpumask; break; + case DAMON_FILTER_TYPE_THREADS: + err =3D damon_sysfs_set_threads_filter(filter, + sysfs_filter->tid_arr); + if (err) + damon_free_sample_filter(filter); + break; default: break; } --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A4610321F2A; Mon, 8 Dec 2025 06:30:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175437; cv=none; b=Z0dlq5M5OGqPrL57TYmvqd6kXFyTzOr7X63EbCuzuO3w1j0slGn/ZPqO9f9+Wt5i5ov3KXZ+ll3e+7esOfrWeGxSrDam0Pz9z/5jmqTZc+YNCJD9xwc8aUwXONtPMLdCU8Vu+84pvzuEVaCxmPgpCWOS2pwS+cJJzNNEvg3RNb8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175437; c=relaxed/simple; bh=WF46eHAg8BpA3rOP5vwAEQ9EqpTxFbiwB2Pt34pRHm0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=FyL5bb+FrgR9ZT+bw6viMPaKP6gZWbzuBmkhCZ2qTbpF7CN7huctAtPAYcJdWhg57g6p28WBA/bcaoYBuJbKCxI5HW5iy5+0OD8GQjnU/lZ9lmwxr0O9/aZnXvg+x9xmfKftSaYn7f0g0lkMxwe5FsumAI9GVQSbrhA0g/nKdvk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Jsk9EEcx; 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="Jsk9EEcx" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0D995C116B1; Mon, 8 Dec 2025 06:30:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175437; bh=WF46eHAg8BpA3rOP5vwAEQ9EqpTxFbiwB2Pt34pRHm0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Jsk9EEcx6sGR5L8QC3E5ZPFlTYVH7w3ajlnyRF2mk3nO70OXa5HGMeDiJOa8U7WKl pDeyuojSH9d/a7o02+VSAA1ssDTcxb5vDP/G+0kGZ4Imtc4uXqcHGkA2LCUn1RLXXK O+EQeptMA4tPgTn0TUp4I/IhVqa+WuFSiaDwYYMEqHVD/qiVSkmqteUAmsea+vTfPF XGVJYD79SAGRPkRl577nudDk15TT+WdhgNll1DtOmNCEjPbi6vgFE4uK1nxbYt8lPT UCrkhMX4EvzImtlCI202A8nCfdZnIJwUVfC6NGBwSEni/eBy1S52FZiOOkypPUEmxp QpbiymgYVVWVw== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 31/37] Docs/mm/damon/design: document threads type sample filter Date: Sun, 7 Dec 2025 22:29:35 -0800 Message-ID: <20251208062943.68824-32-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 threads type access sample results filtering. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index 9a4679de437f..4c6d83263a7b 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -148,7 +148,7 @@ the page protection in a way similar to that of NUMA ba= lancing hinting faults. Then the page fault handler reports the faults happend by the installed pa= ge protection to DAMON core layer. Compared to the accessed-bit based one, t= his approach gives more information to DAMON, such as the access-generated -CPU. +CPU/threads. =20 ``paddr`` uses :ref:`accessed-bit based check ` by default, and users can ch= ange @@ -314,6 +314,9 @@ Below ``type`` of access sampling results filter are cu= rrently supported. - cpumask - Whether the sampled access was generated by a cpu that included in a given cpumask. +- threads + - Whether the sampled access was generated by a thread that having a t= hread + (task) id that exist in a given array of ids. =20 =20 .. _damon_design_age_tracking: --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3483C322A2E; Mon, 8 Dec 2025 06:30:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175440; cv=none; b=fN/Uq8DLZXw95+Fy7n1JFBf25bKFNNpmZFSXArgOZ+VOFXFzU8njduvCTKk/KCgHNTl5C1GFmxME43XJrhA6Fljc4Z0XiFut7fN6x0ZGzvtqmyWnd50QARZB2SGvrOuzAitkTJhXB3KrAvi0vk9awvaw4lC/uvGjF2Ax7ghj4eY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175440; c=relaxed/simple; bh=P2SgdyCf2ZU0vqy/RDrIyCr5Bu1z5InvNin3lNvOuEg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=sJBWH6RIyErEZYVqMumR210GVIgLzbzTe9nrSRWbnUJGcXaChAglY730EyxU8UhPBhOvg1RwrTGInn2nPS4txuIoZAKH6Jbj6mLZlTMODUsFj/6BuNL316zXCcTT1fhFtTL6dkZBiLgZ2YrLSi6hZdAB3JfJUPQCYfcTmk3Q7as= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=StSBOZTR; 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="StSBOZTR" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9DB2EC19421; Mon, 8 Dec 2025 06:30:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175439; bh=P2SgdyCf2ZU0vqy/RDrIyCr5Bu1z5InvNin3lNvOuEg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=StSBOZTRBdXApkEJVKfwmFrboFQjqC8MYLknLXOmdgrtgFNEfFPug4wod06n0TzlM Y8QuzC0Gq3JOT8dUBFwR6Qx9y0F0KrPfAEY8XUYd5nDDcbx6V+3Q4fBnP74VG8Pr/F lYTrYA1aiL0qrEx8xfvE5IWHjMD99J/QzETrf9oANE9uBVsuWecK6XBCmzxXxAyFZt r8OCoBqkIhk+XAcaktUDsn9HHy7dF3X4pAW0aLtPYLd8QVy6OwbWaEAeCEKI4XkqiD n8qkFLT/O1CemZfo1ng1PzlIz8YzOFy6N78a4vhQhnO0in7P1mRNOhmEXqhg3laGLb EwcNqZHFCo6xQ== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 32/37] Docs/admin-guide/mm/damon/usage: document tids_arr file Date: Sun, 7 Dec 2025 22:29:36 -0800 Message-ID: <20251208062943.68824-33-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 threads based access sampling results filtering. Signed-off-by: SeongJae Park --- Documentation/admin-guide/mm/damon/usage.rst | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/Documentation/admin-guide/mm/damon/usage.rst b/Documentation/a= dmin-guide/mm/damon/usage.rst index 365a4548a5ba..d22d80710355 100644 --- a/Documentation/admin-guide/mm/damon/usage.rst +++ b/Documentation/admin-guide/mm/damon/usage.rst @@ -67,7 +67,7 @@ comma (","). =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 sample/pri= mitives/page_table,page_faults =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 =E2=94=82 sample/fil= ters/nr_filters - =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,cpumask + =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,cpumask,tid_arr =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 :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 @@ -260,13 +260,14 @@ context, in the order of the directory names. Writin= g ``0`` to ``nr_filters`` removes the directories. =20 Under the individual filter directory, five files, ``type``, ``matching``, -``allow``, and ``cpumask`` exist. The first three files are same to the -properties of the filter specified on the :ref:`design doc +``allow``, ``cpumask`` and ``tid_arr`` exist. The first three files are s= ame +to the properties of the filter specified on the :ref:`design doc `. =20 -Users can specify the cpumask of the filter by writing it to ``cpumask``. = The -format for ``cpumask`` input is same to that for other cpumask inputs like= that -for cgroup cpusets. +Users can specify the cpumask and thread id array of the filter by writing +those to ``cpumask`` and ``tid_arr``. The format for ``cpumask`` input is= same +to that for other cpumask inputs like that for cgroup cpusets. For +``tid_arr``, users can write array of the thread ids, separated by a comma. =20 .. _damon_usage_sysfs_monitoring_intervals_goal: =20 --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5B653322B6A; Mon, 8 Dec 2025 06:30:41 +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=1765175441; cv=none; b=jfXEa9u/YV8bNv8OgEbuxtwUGJFIZo0Kc8UZUIZ9fDr2W7eejx0mE2GEZ4XaDWjYwriALqbtHLi/6TSO2i93XTv9QSAFmEhJXIt0Z6tklpbIRj6QP9juF93uXfcLHnvmheSRt9seoR+rFQaZi8gx2Y4sLBEu4dSRV2MTTcDIBxA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175441; c=relaxed/simple; bh=RBgupw+0+IFAQYuywBDofV0MFSFxSZkVNemgNSqd6d8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Sa5OEovSuOfC66Mefg3uzuvtcKSmny/41+0hNSV7hkOaAQIT88e+ZMBT1amYGqiZr/aEGj+VM3P/uA3RozmxFOsnRvGJuJfEiSGKZVVavEEJMk+/KoG/H6bs9wvCaP/7+B2d+jGgZzmtdXNuE16HoEQSd+X9DTzprXMfQDysj6A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=QEs8xFy9; 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="QEs8xFy9" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 40E86C113D0; Mon, 8 Dec 2025 06:30:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175441; bh=RBgupw+0+IFAQYuywBDofV0MFSFxSZkVNemgNSqd6d8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=QEs8xFy9N/5t6MNK2CW9AAKR6gDNiwtRhj8gFt5ysY2bEKeVLIvwaRR/qG925Ypc2 64UnTu0Zd/Oyj/x+WezlY5QUBF6+gk0sNwB1wrGtSYiT2cIlajPMqNFriu35CaQYyW uJSfF5aQP7wPFdZ9SYEfJUgQeDjB2PQDtkF6fPWt5rNaxZJ90HRSuFIngFYB+itSdE 1hbpcmy4Uc1E1kMcpDAmlIuwDlWc2+f2UQz0kq8y8lYCUBoLfb2E5ecL3inu0dgdU/ TWH0+AzWqtrCn/xMZrNdLQMrt67rpb8tnfnF6nghvTQiDYEzVZ9qtjcAaUms3XANOw qqQzxtBHmf7Ng== From: SeongJae Park To: Cc: SeongJae Park , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 33/37] mm/damon: support reporting write access Date: Sun, 7 Dec 2025 22:29:37 -0800 Message-ID: <20251208062943.68824-34-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" damon_report_access() callers could know whether the reporting access was for reading or writing. The information can be used for fine-grained monitoring, such as monitoring only read-only accesses or write-only accesses. Extend the reporting data structure so that the caller can pass the information. Signed-off-by: SeongJae Park --- include/linux/damon.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index e3408280ea72..9299fc91ba27 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -117,6 +117,7 @@ struct damon_target { * @size: The size of the accessed address range. * @cpu: The id of the CPU that made the access. * @tid: The task id of the task that made the access. + * @is_write: Whether the access is write. * * Any DAMON API callers that notified access events can report the inform= ation * to DAMON using damon_report_access(). This struct contains the reporti= ng @@ -127,6 +128,7 @@ struct damon_access_report { unsigned long size; unsigned int cpu; pid_t tid; + bool is_write; /* private: */ unsigned long report_jiffies; /* when this report is made */ }; --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 49815322A27; Mon, 8 Dec 2025 06:30:42 +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=1765175443; cv=none; b=IIVILWxDA3VMOkAVFAYayomtPXMJTwEdiMsqHtEgMUIDUkAwNVliWRUGKzQqKVqQVWwSWkRFl3LOvjyWa5Mr9NTsKXFM3J8Rz8A6mGJpdFg050IYB85UFC15HHdbH2iL1qeVo+0Z9lkEq7WU5NcY4yjd2JtiiJWnQOqvLt1wArk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175443; c=relaxed/simple; bh=3vYcUeBmXr4garxcQHjJx07QLWWSN2yZSMq4StEXQLo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TWHldEvoIZM4W8vOckU4yQp0j96DE88HYVbA9WGtrNQzEaaZqXvdTmQ6gcQ1EjpvQwRbeH/4rMApOSnFT2MjteGywpZNos/saU0POOQtPJO8Gwbn0NR6JIY4SY0iahrRtTlSiTHb3SNtD+fh5Oib00tYWKKojecK9tM1hwtqjEU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=P0xtLSkF; 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="P0xtLSkF" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7AA08C4CEF1; Mon, 8 Dec 2025 06:30:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175442; bh=3vYcUeBmXr4garxcQHjJx07QLWWSN2yZSMq4StEXQLo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=P0xtLSkFs7pqEae043u1j3xnB95Eun6fs+QGZgZO9d81R7nVANe8WzFd7INUNaH5J G0cu5g13QicS+7SpfXLfFYjeCO7OZky97UtEnCU1Fg8vOIqL0guCnn+Met1AgHKg5M 5NTPXJXNgEVF4hk8vk1FGAsAu82jhb0v522m+QxbyOFfL7UlnXHN/ha84/c+mqS2eq 0qSRuP9CaCpfcNNAkk+LdrdatyCNz+99Jk1hlLUrlAc3UBxmBAqyPlfv8/yoebiFZt WeGrFytSTuFCntaqviHlHDTKBMaMONUSg6xP56TYbN2K/XjRoJDfgJDnBS6pPwmnAS 6VzqV0nDquVZQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 34/37] mm/damon/core: report whether the page fault was for writing Date: Sun, 7 Dec 2025 22:29:38 -0800 Message-ID: <20251208062943.68824-35-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 page fault event reporting function can know if the access was for writing or reading. Add the information to the report. Signed-off-by: SeongJae Park --- mm/damon/core.c | 1 + 1 file changed, 1 insertion(+) diff --git a/mm/damon/core.c b/mm/damon/core.c index 782af39ef0c0..e2fd17b83a92 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1732,6 +1732,7 @@ void damon_report_page_fault(struct vm_fault *vmf, bo= ol huge_pmd) .size =3D 1, /* todo: set appripriately */ .cpu =3D smp_processor_id(), .tid =3D task_pid_vnr(current), + .is_write =3D vmf->flags & FAULT_FLAG_WRITE, }; =20 if (huge_pmd) --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 089E5322B72; Mon, 8 Dec 2025 06:30:43 +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=1765175444; cv=none; b=ZUg457CF9Et13r2airguhK/dG8gn22hp7tJamHPrJfTWfE3U/LY+5H1YqMARkoLveIIeDiSJw48VAoldR/0uf2HzD4xbCSeEElnlS6CsG4Dk1qJGvmq8jNImB9qyfe2IyJJNs3dmYkLH2tY4hC8Sq4/l7tTxsLADMimGUQg2xuA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175444; c=relaxed/simple; bh=I2gSrUS/ytzkCO1hJUdsffUlWhdJJTl9/yHYyXuCFtM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=epV2KDdOqDs3Ja5jlWJkhu9J/XXnGb6DnuRhtdNPykNp2KtfYXHnM/MHQ6zArgpTV1OISzp31gU2xP182I05Dq4sWKz50sGp/AsrxQ30Zsld3+c4EyXGE+9ik+l0oY8GIXthi5pM4pdNUemTbheTo7HxTy8EQLCHNrDHqgVl+xk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Q3OgjpkR; 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="Q3OgjpkR" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D208FC116B1; Mon, 8 Dec 2025 06:30:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175443; bh=I2gSrUS/ytzkCO1hJUdsffUlWhdJJTl9/yHYyXuCFtM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Q3OgjpkR49zDj2QFoLmWOx92p1HIbZX2mIXn+c67LiZRVhV/qmtiAN6QAivmIiS4B acDRY6oMBC+L0ZilJc+sJkWCdFl6QnzirMYRi4xbUIHciCmy8M8pTK/m3wfxNoDxgB B9MAp6q8QV5L2+NgGWfBqAHMqeR2DF6/lspaRDe2lrRAZeEatsa23zcG4MdlpXXZHt YNw7GTz9W9bblfkR6tQBFR54YxALWklwnM4OokbXLsYUZrrsJGhz8bjoUeLVTwiFIc sanfNZ6mWEvnJObpLzN1GM1HOMrC7EMmHduLAzCsUvNasOziiHbeWwnizarubsYom7 RJ32Q0TBhwnew== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 35/37] mm/damon/core: support write access sample filter Date: Sun, 7 Dec 2025 22:29:39 -0800 Message-ID: <20251208062943.68824-36-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Now page fault events based access reports contain information about if the access was for a read or a write. Doing sampling results filtering based on the information can be useful. Introduce a new type of damon sample filter for that. Signed-off-by: SeongJae Park --- include/linux/damon.h | 9 ++++++--- mm/damon/core.c | 5 +++++ 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 9299fc91ba27..f9fd26f7eab8 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -790,12 +790,14 @@ struct damon_primitives_enabled { * * @DAMON_FILTER_TYPE_CPUMASK: Filter by access-generated CPUs. * @DAMON_FILTER_TYPE_THREADS: Filter by access-generated threads. + * @DAMON_FILTER_TYPE_WRITE: Filter by whether the access was for writing. * * Read &struct damon_sample_control for more details. */ enum damon_sample_filter_type { DAMON_FILTER_TYPE_CPUMASK, DAMON_FILTER_TYPE_THREADS, + DAMON_FILTER_TYPE_WRITE, }; =20 /** @@ -836,9 +838,10 @@ struct damon_sample_filter { * that to make higher access pattern picture. It can use multiple sampli= ng * primitives including page table accessed bits and page fault events. I= t can * also filter in/out specific types of sampled access events to monitor - * accesses of specific types, such as access-generated CPUs and threads. = This - * struct is for controlling what sampling primitives to use (enable), and= what - * sampled access events should be filtered in/out. + * accesses of specific types, such as access-generated CPUs, threads, and + * whether it was for read or writes. This struct is for controlling what + * sampling primitives to use (enable), and what sampled access events sho= uld + * be filtered in/out. */ struct damon_sample_control { struct damon_primitives_enabled primitives_enabled; diff --git a/mm/damon/core.c b/mm/damon/core.c index e2fd17b83a92..5f29e4dee267 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1336,6 +1336,8 @@ static int damon_commit_sample_filter_arg(struct damo= n_sample_filter *dst, src->nr_tids); dst->nr_tids =3D src->nr_tids; break; + case DAMON_FILTER_TYPE_WRITE: + break; default: break; } @@ -2912,6 +2914,9 @@ static bool damon_sample_filter_matching(struct damon= _access_report *report, break; } break; + case DAMON_FILTER_TYPE_WRITE: + matched =3D report->is_write; + break; default: break; } --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A119A31A800; Mon, 8 Dec 2025 06:30:45 +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=1765175445; cv=none; b=KDzDtgJihZPwdUWjcq7uByZs5CGBuCAhlZ2iCe9jxd3PH1PXzJD1wzxf+kkfiFYoH8VBYu25WIQkL5oFF//npQvuXpSOv+30Kci6Fh1ACv1tl28c9WnOh9YXDae2QLDepK3FUSyOUtqVf0w1oWC910uEqWadJA4sxmCGIbHHwU0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175445; c=relaxed/simple; bh=my96BzscRoG5OJJ+4DXHi+6nxWHst+CeituNuj8uGfI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=R0hqYaIYDcmiTy2IPHIejpBgW+zPRs6vCx3rzs742M8SQBLljLlPFhq0CES9kyXK3e66gptdyPRmmbOinkWU/UpMwXbhbMUJXDzubwkXMkr6PhCpEM32OYhA8cmeAK+C0GZWFDM1qhgzitW22H7li+3+KrUg0njc3XUSObzMUDk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=UQEDMWUt; 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="UQEDMWUt" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2FB2EC4CEF1; Mon, 8 Dec 2025 06:30:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175445; bh=my96BzscRoG5OJJ+4DXHi+6nxWHst+CeituNuj8uGfI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=UQEDMWUtVie4xcVROv00P1YKbtb+Gi24FUrk16/pvmtqaujQM4CTfk82pEL27xTj/ uQ4+24tBDGsoDWrertUrcW8EZmtJe4fcI5VaPxtiddAQKYIdsudknTIltccKXv/152 pasQqgRDZHC5BySXsw2btEm9VljjOGwpVzsgnvZPt92Q4rbWFEU5UfeSh55+6Fxxi0 d25dNjG+x4kKnRi/Zluf6E/Li0Q9b7/k0bOrYf35FnMYwRYC1+/0y2X4LJ6SXvg9PY /qNQDlDe9+rariOO1/7b/IB6MeSd38iCF7gtJrnZ+oVprVdY3uv6xqVHhcX4zhjjmz z7QJwjjugrOAg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 36/37] mm/damon/sysfs: support write-type access sample filter Date: Sun, 7 Dec 2025 22:29:40 -0800 Message-ID: <20251208062943.68824-37-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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" Allow users utilizing the write/read-only access sample results filtering, by adding a new supported input for specifying the filter is for that purpose. Signed-off-by: SeongJae Park --- mm/damon/sysfs.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/mm/damon/sysfs.c b/mm/damon/sysfs.c index b96df2d2d17e..d6f6a012a0e2 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -782,6 +782,10 @@ damon_sysfs_sample_filter_type_names[] =3D { .type =3D DAMON_FILTER_TYPE_THREADS, .name =3D "threads", }, + { + .type =3D DAMON_FILTER_TYPE_WRITE, + .name =3D "write", + }, }; =20 static ssize_t type_show(struct kobject *kobj, --=20 2.47.3 From nobody Fri Dec 19 11:52:31 2025 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AB626322B95; Mon, 8 Dec 2025 06:30:48 +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=1765175448; cv=none; b=QGKUpTht96s/RdxnA4wbywIulxBNgCGXFFuvwva7ie03/MTop2ODGaIQTR6hxVFJMVOPuRDjLV3Z+bE06rdSqJgppxqKAkOkU5F1/hNvbmUCLhY4na2e1IOpfzCFoAINoUQxwlJVxgbON0JuDAD79okCx36ql2zIHcq+95bIXy4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765175448; c=relaxed/simple; bh=7LPwC6Tdvp2/F8X1UVIxGeo9+bnDQ2Da295YW1KdEhA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Xgr/j0OxeOQpDi3v/q9Ys0Jt5B6AM9uhDOy9c6ph1SrEGVrbMXVEjCFPwzh9e43jmzea7h2ufdlYBJOAI8YrhxWVuxPJDsuhqNkwQUW0F0MIDrwS13QHaNMwNgRDwnjLcNBSk+sE1woX0NMr61Tc7ClgRMWVhA/nPTQQqvQrUNw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=MiIlJ+UI; 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="MiIlJ+UI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7F421C116B1; Mon, 8 Dec 2025 06:30:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1765175447; bh=7LPwC6Tdvp2/F8X1UVIxGeo9+bnDQ2Da295YW1KdEhA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=MiIlJ+UIhaWDtXpVtWGyfXhcGkfyDG2je19PMonZ1FJur8CzHYiCsCW7W+Xz/Cs7X f0ApIzkuEp6CBnrLykZlYX1TO6xtB0Q2qb02e8WQP+kCSn5RPcThXAWAriKYeu+VEM hnWYsawXlfplP9ofPhSyiuOVPeVEEwnWGWPe1Hg54CxxzOOAxTRsA56PE/AUlObxjI 30MyNHFDj3mBswCevCm36eEGQA7rmEDvN4GP28hORUJDMs9ltF+lvxGtPiDAVSPtq2 6Q+fMHbT1daCzHKPwvNtSOZTSeBHpyUEzIKZmpUh2wKwFU+IAW1LW4jwd1r9nLW9db rLZwHbnPPr+EA== From: SeongJae Park To: Cc: SeongJae Park , "Liam R. Howlett" , Andrew Morton , David Hildenbrand , Jonathan Corbet , Lorenzo Stoakes , Michal Hocko , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , damon@lists.linux.dev, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC PATCH v3 37/37] Docs/mm/damon/design: document write access sample filter type Date: Sun, 7 Dec 2025 22:29:41 -0800 Message-ID: <20251208062943.68824-38-sj@kernel.org> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251208062943.68824-1-sj@kernel.org> References: <20251208062943.68824-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 write access sample results filtering. Signed-off-by: SeongJae Park --- Documentation/mm/damon/design.rst | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Documentation/mm/damon/design.rst b/Documentation/mm/damon/des= ign.rst index 4c6d83263a7b..b194bf4a6519 100644 --- a/Documentation/mm/damon/design.rst +++ b/Documentation/mm/damon/design.rst @@ -148,7 +148,7 @@ the page protection in a way similar to that of NUMA ba= lancing hinting faults. Then the page fault handler reports the faults happend by the installed pa= ge protection to DAMON core layer. Compared to the accessed-bit based one, t= his approach gives more information to DAMON, such as the access-generated -CPU/threads. +CPU/threads and whether it was for writing or reading. =20 ``paddr`` uses :ref:`accessed-bit based check ` by default, and users can ch= ange @@ -317,6 +317,8 @@ Below ``type`` of access sampling results filter are cu= rrently supported. - threads - Whether the sampled access was generated by a thread that having a t= hread (task) id that exist in a given array of ids. +- write + - Whether the sampled access was for writing. =20 =20 .. _damon_design_age_tracking: --=20 2.47.3