From nobody Mon Oct 6 01:21:10 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 AD5709463; Sun, 27 Jul 2025 20:18:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647499; cv=none; b=LHjuhLsBwYuBwwo0Lnbgc8djUD3mJwhqENENw7cCV0TbaY3UF3Pv09Ug8Hwus+2hJHCrDASZaAxuyFdL17UAa8OC5gQL6KLSmShoPX7EwdD19Oii6DKAtO+uPsq6fXTjyFD6z9p/rPXIfJuGGxWNSTGHU4XZ6bSbkQadctKAlw8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647499; c=relaxed/simple; bh=HqUvAgrhD+ZVNsGThR4W3V9E1/zbZYx/FHOFDYmdj58=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=bTCzK5bym6qPE5ww20itBVZc7D/HTupBW50lIDYByTropJsGNoVfsri0iOtXRBCmDd1P5sVf9ThudfYt2BKPQYG8zDrtfimodx2qbymje9IAX1wcfu4xh500gZFCMGZZn06Y85ruKyK/aDc4hhx6i1hKuQMU1fVe7GiAx17VQkw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KQijjcRc; 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="KQijjcRc" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2F3A1C4CEEF; Sun, 27 Jul 2025 20:18:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647499; bh=HqUvAgrhD+ZVNsGThR4W3V9E1/zbZYx/FHOFDYmdj58=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KQijjcRc2uGNxF3ZV2oGZ3kGwkNsro6aw8jQX9xkOJFU36vTddqeevRmebA1/jTpa mAg48nqTRpMUIqSR1FNP2zE7og5SkioWdmv8ZP4C0OGAz/h06AtOs3amG//Q1ZbEIq Aj2khGAnzV7oJIdWgvoQS+H4/AJtm5o2xElqvP6dYAC/dZZDeZE+9xZ9RbwfHufvYd JkyUcUX0fHJB5O9Ur39tgOmbJnU2mIP2Y166eRMV42C/fyGPVqnIjL2rL/GAFgiVA5 HQIu7zzcdGn/zrP2SDqhru2E3C6upMrE1/9xcRDVnIPQsvTI32rey5qyM+CmFtESGb BtXrwFiIcbPVA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 1/7] mm/damon/core: introduce damon_report_access() Date: Sun, 27 Jul 2025 13:18:07 -0700 Message-Id: <20250727201813.53858-2-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-1-sj@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DAMON core layer asks operations set layer about past access information, on core layer's schedule. In other words, core layer "pulls" the information from the operations set layer. This is problematic for a case where the operations set layer has no time and space to save the information until the core layer queries. Add a new DAMON API function for reporting identified data accesses to DAMON, on the identifiers' schedule. In other words, it lets the operations set layer to "push" the information to the core layer. The function internally uses mutex, so reporting kernel code should be safe to sleep. This API was also discussed at LSFMM'25: https://lwn.net/Articles/1016525/ Signed-off-by: SeongJae Park --- include/linux/damon.h | 25 +++++++++++++++++++++++++ mm/damon/core.c | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 479ee52b79e1..1f7592147d92 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -104,6 +104,23 @@ struct damon_target { struct list_head list; }; =20 +/** + * struct damon_access_report - Represent single acces report information. + * @pid: The PID of the virtual address space of the address. + * NULL if it is of the physical address. + * @addr: The start address of the reporting region. + * @size: The size of the reporting region. + * + * @pid could be stale, and hence shouldn't be de-referenced. + */ +struct damon_access_report { + struct pid *pid; + 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. @@ -941,9 +958,17 @@ 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); =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 64e59d15043a..4e25fe100b56 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -24,6 +24,8 @@ #define DAMON_MIN_REGION 1 #endif =20 +#define DAMON_ACCESS_REPORTS_CAP 1000 + static DEFINE_MUTEX(damon_lock); static int nr_running_ctxs; static bool running_exclusive_ctxs; @@ -33,6 +35,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) { @@ -1461,6 +1468,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.39.5 From nobody Mon Oct 6 01:21:10 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 D331A230981; Sun, 27 Jul 2025 20:18:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647501; cv=none; b=KOxkTxzuZjoEIdoBRvBjUOmKl9zUwjlPGLEKMHeNc7ORZz/lLKAqcuRYUQP9JW3ZXyair1aF95bR3BuCILazZkvOULhR88vSgFSsmaYpZUb3VCcNrCsXHtDJW5MWTZE8oZcFk1nNkuxBHD6Dr5/xXTKDeYPsSmY5u1WeorgKDok= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647501; c=relaxed/simple; bh=tkPbh1vYlIwSvC/vF2tZ2YQvmhDcZ/BAu1gsu6yocrM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=CREV8UQvdXyL5wJEhdHmqHJQ0ni+UTmLRslce0IhHCAUwbcECq9eXuN5SzftDdmxmadzhmO6fEU40YsNJUocgYxwmcmVDo5XLY9J16VIruoCd/rAZ4iOBdZra9jxWnQOnhw7Pu063zmd8XdEw3VeHJG0zJCbSPiDiWoqr4sk2qw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TdoXJDbI; 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="TdoXJDbI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3E560C4CEF8; Sun, 27 Jul 2025 20:18:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647500; bh=tkPbh1vYlIwSvC/vF2tZ2YQvmhDcZ/BAu1gsu6yocrM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=TdoXJDbIX7Og9uiSKRdjVQhbxJm2D0VZc+QHNI4fHO9garcj1BMAA0j6RLls46a1D /Zs78wbmn2dXP3gDf/ZM2syok3kNJ02+AwBzdtP/BqsOve9qrIdKrnpf5VK/yJLvYF n8eA19tzgNoxBptNdEKBL+2xxjgXU7KhSQWkYpxm3xhFCTsIbStnDQMV40RxQQpK8D POHIG4dJOn14pZmkFmfiVrKGjS5zqOZCNb3RIpJwBnsQAEkgIwGu5RI92b+DDbAjKy Oh+PROfob69zYN+CD/INvzqHFaS6MEczh0mckk1TbVRgCfLk83zasSeicW0XQDGrIc M9rX3/yfAFG2A== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 2/7] mm/damon/core: add eligible_report() ops callback Date: Sun, 27 Jul 2025 13:18:08 -0700 Message-Id: <20250727201813.53858-3-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-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" Not every reported access information will be eligible for all DAMON ops and targets. For example, virtual address access reports will not be eligible for 'padr' ops, or monitoring targets for a process that is different from the process for the report. If it is for monitoring accesses from specific CPUs or write, reports from other CPUs or reads should be ignored. Add operations set callback for this report eligibility checking. Signed-off-by: SeongJae Park --- include/linux/damon.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index 1f7592147d92..f3e5c585b5f1 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -590,6 +590,7 @@ enum damon_ops_id { * @update: Update operations-related data structures. * @prepare_access_checks: Prepare next access check of target regions. * @check_accesses: Check the accesses to target regions. + * @eligible_report: Verify an access report for a target. * @get_scheme_score: Get the score of a region for a scheme. * @apply_scheme: Apply a DAMON-based operation scheme. * @target_valid: Determine if the target is valid. @@ -617,6 +618,8 @@ enum damon_ops_id { * last preparation and update the number of observed accesses of each reg= ion. * It should also return max number of observed accesses that made as a re= sult * of its update. The value will be used for regions adjustment threshold. + * @eligible_report should check if the given access report is eligible to= be + * used by this operations set for the given target. * @get_scheme_score should return the priority score of a region for a sc= heme * as an integer in [0, &DAMOS_MAX_SCORE]. * @apply_scheme is called from @kdamond when a region for user provided @@ -635,6 +638,8 @@ struct damon_operations { void (*update)(struct damon_ctx *context); void (*prepare_access_checks)(struct damon_ctx *context); unsigned int (*check_accesses)(struct damon_ctx *context); + bool (*eligible_report)(struct damon_access_report *report, + struct damon_target *t); int (*get_scheme_score)(struct damon_ctx *context, struct damon_target *t, struct damon_region *r, struct damos *scheme); --=20 2.39.5 From nobody Mon Oct 6 01:21:10 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 8A5CF22F74B; Sun, 27 Jul 2025 20:18:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647501; cv=none; b=sJDokf59H8GVTy7oHQVz7nNTJX9yGWc9alLvT3B/dPmrN1P+vSsYKx7LpapVkrEVq4spZOISsYnI/1V9A6qcxUnTe3f4a0UxS8l2dRB0sKfQ2mDitzElvtMLaUmSnKM30w+mH/BAlz9GknllILlcYDJFt8qzhbGV+YtzhoifWYU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647501; c=relaxed/simple; bh=NkOlFUXA+qPHhiPIn4M4gJxZzGyprOZBn0h+Dwp+Qx4=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=tAEmjvFwbtSkPYhHUYH5hzCDnsr/J4i/6fvYcYjbAktsdIEuM4YgSzu9TfcXlemZj3wwN9z7Ji6Mt7/XD/Kmg2cMEsmqUD0AlQ6vNZHhrP5W8UXs3RLmDtGtvbWwNOieyIg0Xf+pjzssL7TJCyZ7W+uqY6+y2njv8hgHAxz9uW0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=F4IztOny; 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="F4IztOny" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4808DC4CEEF; Sun, 27 Jul 2025 20:18:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647501; bh=NkOlFUXA+qPHhiPIn4M4gJxZzGyprOZBn0h+Dwp+Qx4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=F4IztOny+fn1C3EUh1pj9ARTeeD8TOf9NgKIVCaojvSByCCvki3xxfOrbkuouJxzl XHorGjFUUMs/o71G7GUlAEm2M1DAVPpg47dNVSiMLBvoZNU/5D1aBZtxVxILIm30kB 5mAThhUy+RjFprJ7rcR3XH/j2lUKwiNc9Fvn3mxf2Qi0uRLk5qpUtTW9Bam32otJ0r eqG2XxZNmvzLwnGxKLy0duXGxLU3zCk2EGkMjsb/kZwT3r9lHeKNC4Ezv/pYILS/2s rtdicMP3GtNeB02eOtUwNVKWbe2oh8Zubeuv7GaB57bD2fiUPqysv2doZ8UZlkcVfs k5A1f6ES8eVlQ== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 3/7] mm/damon/vaddr: implement eligible_report() Date: Sun, 27 Jul 2025 13:18:09 -0700 Message-Id: <20250727201813.53858-4-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-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 eligible_report() operation for vaddr operation set. It checks the eligibility of the report based on the pid of the report and the current monitoring target. Signed-off-by: SeongJae Park --- mm/damon/vaddr.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mm/damon/vaddr.c b/mm/damon/vaddr.c index 87e825349bdf..a80cd34e5232 100644 --- a/mm/damon/vaddr.c +++ b/mm/damon/vaddr.c @@ -792,6 +792,12 @@ static int damos_va_migrate_pte_entry(pte_t *pte, unsi= gned long addr, return 0; } =20 +static bool damon_va_eligible_report(struct damon_access_report *report, + struct damon_target *t) +{ + return report->pid =3D=3D t->pid; +} + /* * Functions for the target validity check and cleanup */ @@ -954,6 +960,7 @@ static int __init damon_va_initcall(void) .update =3D damon_va_update, .prepare_access_checks =3D damon_va_prepare_access_checks, .check_accesses =3D damon_va_check_accesses, + .eligible_report =3D damon_va_eligible_report, .target_valid =3D damon_va_target_valid, .cleanup_target =3D damon_va_cleanup_target, .cleanup =3D NULL, --=20 2.39.5 From nobody Mon Oct 6 01:21:10 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 BB1CE2356C0; Sun, 27 Jul 2025 20:18:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647502; cv=none; b=VfXD3FEKPkElhjjgW99yG8eE2M6/glh+lSZsFDeVR+NBRrukzhQelc/f6dhS0nnAUWkkiEfnmltHfhcGbX7AZzLmnfClYaKMn6AuxXZjyTsDAz8CrtzRmycXbtpTTwNLVE3CENhtklncbDy1N8IXGewiUuYBxNgpXsmhBulc97A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647502; c=relaxed/simple; bh=3yxuU0XQzbUfmqOxngAFD/wzk8Fov7BuHvufkENc1Gc=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=PKnibw7G+w4gW7Oge+GROE/j1n6rP6yL7P76PKOepyQy6nsdVyMryMKbBtZ0PooLZUwvsy9ZCsEQTQOjr9/mL99VNg6muNsxcR9We2JjVujbAAaY/zzqDPSX+DGPBG3mUVphQ/I8xXeGfUW0BzJ/RhBQeYMD6LuR33lWRe6VU4E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bb43SF+4; 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="bb43SF+4" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6F0BDC4CEF7; Sun, 27 Jul 2025 20:18:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647502; bh=3yxuU0XQzbUfmqOxngAFD/wzk8Fov7BuHvufkENc1Gc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=bb43SF+4/x6PxpUFYRnY7Va/Dus59O6I/kDuN5DbBrKHFG6Dpo4/TOdUmPY4GEtMd tWGacLr/fxtnXvK8Lyry7QnrR7qp6bYDT+gGfa1Qgl2rTrAkTNwTcTFyI+p34hjpSR GJUeVDZ2U/JN2ED6Qgi9JUg1KJgCrKxFz2p7TtJtmR18eN8KTs6nCTk3OeusD6cJ9X QdoY3JqwGct1q99PIlZtLVIMX7L0lhVZqwAxnaFhwdqGwX8zLGr1yQh7oLDB+p3KRj uf4bODK9O0BUK1L6t0tshazTj6xjuHCyCbjhOgl+b/jKipBip4Es2B5YQLN8cVS8vL oPFcUvAYYaIJA== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 4/7] mm/damon/core: read received access reports Date: Sun, 27 Jul 2025 13:18:10 -0700 Message-Id: <20250727201813.53858-5-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-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" Reported access information is only saved in the core layer's internal data structure. Those are not really being used for final monitoring results. Update core layer access information (DAMON regions) using the reported access information. Signed-off-by: SeongJae Park --- include/linux/damon.h | 1 + mm/damon/core.c | 66 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+) diff --git a/include/linux/damon.h b/include/linux/damon.h index f3e5c585b5f1..8ec49beac573 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 4e25fe100b56..428ac1b83118 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -141,6 +141,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; } @@ -2560,6 +2561,69 @@ 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; + + if (ctx->ops.eligible_report && !ctx->ops.eligible_report(report, t)) + return; + + /* 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; + + 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; + if (report->pid && !damon_target_has_pid(ctx)) + 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 */ @@ -2607,6 +2671,8 @@ static int kdamond_fn(void *data) =20 if (ctx->ops.check_accesses) max_nr_accesses =3D ctx->ops.check_accesses(ctx); + else + max_nr_accesses =3D kdamond_check_reported_accesses(ctx); =20 if (ctx->passed_sample_intervals >=3D next_aggregation_sis) kdamond_merge_regions(ctx, --=20 2.39.5 From nobody Mon Oct 6 01:21:10 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 2192E23A98D; Sun, 27 Jul 2025 20:18:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647504; cv=none; b=c6jureDmvispNvDTYKiHbyc33VLCCdOTr3YLDoYgqYDsuswPhl2Jbe2bdciGmKA9kU+x7fwWx13PDDrG3TVxwx2t3tZJdWFHIoMzkRI8cmDDbnXVrUeLZXToBGPruwHvePlkwVhjh9zTLHBgu+NJ86cs+7sPlIhr4Lj8x/owRtU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647504; c=relaxed/simple; bh=WGQcM9UnLZgKBQqcVI81lbDDPjMMbRc1qGpPElDOEoM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=m6tvDtD2gfdwQNFoy4QqO35mqZjpisX/MwzQg1wGHp/J0OLk6qhunNv8OC3EGcUIdHWdadynAkrOxBJtH5wPZcKQX1KaETjXFmluK+nVPAmMzHeGgJnmED9Qo5Y4qjE5HABvMkIbzd4JHbq81EKlwM6B7crUgRbPt4s7pzpAcL0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Pwk10txZ; 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="Pwk10txZ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 76AEDC4CEEF; Sun, 27 Jul 2025 20:18:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647503; bh=WGQcM9UnLZgKBQqcVI81lbDDPjMMbRc1qGpPElDOEoM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Pwk10txZDLZxjPwQc1qT4zeUjOU9Po7GZs0gkYhI9apYTp89LeOs+ML2c2IstQ5oz 2oJxTDKqVp9sz5jghf6QByvyejV8Xt+Z3bGx2snEozm5e6JwbcsLsgEQrR6VUnAAgv 2UzrHdggs5IlMth+PJsPs5B9DKF3xHu5yj3PXxb8z+RnJvzPOAtBEarANZEJztZnPV jL2UWDQ7NQuED2XQWMSzxZc/ERzdNYvafbVpQDyZgcy7r1pnHsXAf9OZz1QQmyAb4s GnuxF99fxHci/Dh4AyWaio8GSn1u0150UlDt9NvZ/feTj/7XeQUPlyD975a2jXPdd1 7WWY3/E1wR5EA== 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 , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 5/7] mm/memory: implement MM_CP_DAMON Date: Sun, 27 Jul 2025 13:18:11 -0700 Message-Id: <20250727201813.53858-6-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-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 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 case, 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. Signed-off-by: SeongJae Park --- include/linux/mm.h | 1 + mm/memory.c | 53 ++++++++++++++++++++++++++++++++++++++++++++-- mm/mprotect.c | 5 +++++ 3 files changed, 57 insertions(+), 2 deletions(-) diff --git a/include/linux/mm.h b/include/linux/mm.h index 21270f1664a4..ad92b77bf782 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2567,6 +2567,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 92fd18a5d8d1..656e610867b0 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -75,6 +75,7 @@ #include #include #include +#include =20 #include =20 @@ -5972,6 +5973,47 @@ static vm_fault_t wp_huge_pud(struct vm_fault *vmf, = pud_t orig_pud) return VM_FAULT_FALLBACK; } =20 +static vm_fault_t do_damon_page(struct vm_fault *vmf, bool huge_pmd) +{ + struct damon_access_report access_report =3D { + .addr =3D vmf->address, + .size =3D 1, + }; + 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); + + 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)); + + 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_access(&access_report); + 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 @@ -6036,8 +6078,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; @@ -6159,8 +6204,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 78bded7acf79..e8a76114e4f9 100644 --- a/mm/mprotect.c +++ b/mm/mprotect.c @@ -714,6 +714,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(vma, start, end, newprot, cp_flags); --=20 2.39.5 From nobody Mon Oct 6 01:21:10 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 30E9F23C51D; Sun, 27 Jul 2025 20:18:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647505; cv=none; b=sGIxeFKCWlZzu3VJQVpPaHlt19X4mWmwKeu+D23Wa56pqX5T4WnHpNU1H9iEBLw9Pnjebys9MumOiBY44FBlDv0cSWRKd1FBMavbAc3O7/187u/uBJpx2tNWPUbW7CxCKHkWSuUP/6XicdhJK8Hw1k/0sjqjidma5nit7v/ApIg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647505; c=relaxed/simple; bh=7vfSMEb8duHJazLWTg6Sxiv7QWIEANLC0eGbGwST1R8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=r1riQz9OdyiI4lnlf8mR7drI0Fha0PEv2rW5PY4jDEeGADo4pl/OFtRBNejrU8wN+ohxG1xrUB946kYwcLUbSf01X5BU78UgthMKGzXK094wQlclJ9e2OYKPE158+j5uYyUFA3EkHlL26Ym42dIPRX5jqEOw68OesP81JBALQ/c= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=aT6BXn3T; 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="aT6BXn3T" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 825EFC4CEEF; Sun, 27 Jul 2025 20:18:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647504; bh=7vfSMEb8duHJazLWTg6Sxiv7QWIEANLC0eGbGwST1R8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=aT6BXn3T2PxJzZMoAqtXevwqwvD0Gyq31K8qSyDJpYsJ/9k045auIsH81m+Pq3I0T mGDqfFVI8xSzlY1lokpeUO5BQNWc9vO+D1ePRLAw+YRQMZS+Gryv0WDUhsMLM1ZXJ1 Fj3/cF6XKn2aVnVameShRV0FG8QojWhHIWn93EWjpmBcWs0w+ndHpcsainsJsai+OS 306+GMjumFB/NtmIfSt2NL6fWtMaus7wszDlQeCzUc20CXMiufGzwpF+4GcO/ZSCX6 hQ7VvcqfHOg3+VaL1C/J4QiEgG+P3EKoB/OMPNQyST4hu3eK0US4L1lEi/9aJ7BoR/ tTmaJkiTB9ugg== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 6/7] mm/damon: implement paddr_fault operations set Date: Sun, 27 Jul 2025 13:18:12 -0700 Message-Id: <20250727201813.53858-7-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-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 an example damon_report_access() based DAMON operations set, paddr_fault. It monitors the physical address space accesses, same to paddr. Only one difference is that it uses page faults as its access information source, using damon_report_access() and MM_CP_DAMON based mechanisms. This is not to be merged into the mainline as-is, but only for giving an example of how damon_report_access() based operation sets can be implemented and extended. Signed-off-by: SeongJae Park --- include/linux/damon.h | 3 ++ mm/damon/paddr.c | 77 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 79 insertions(+), 1 deletion(-) diff --git a/include/linux/damon.h b/include/linux/damon.h index 8ec49beac573..c35ed89371d0 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -574,12 +574,15 @@ struct damos { * @DAMON_OPS_FVADDR: Monitoring operations for only fixed ranges of virtu= al * address spaces * @DAMON_OPS_PADDR: Monitoring operations for the physical address space + * @DAMON_OPS_PADDR_FULAT: Monitoring operations for the physical address + * space, using page faults as the source * @NR_DAMON_OPS: Number of monitoring operations implementations */ enum damon_ops_id { DAMON_OPS_VADDR, DAMON_OPS_FVADDR, DAMON_OPS_PADDR, + DAMON_OPS_PADDR_FAULT, NR_DAMON_OPS, }; =20 diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c index 53a55c5114fb..68c309ad1aa4 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" @@ -97,6 +98,65 @@ static unsigned int damon_pa_check_accesses(struct damon= _ctx *ctx) return max_nr_accesses; } =20 +static bool damon_pa_fault_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_fault_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_fault_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_fault_prepare_access_check(struct damon_region *r) +{ + r->sampling_addr =3D damon_rand(r->ar.start, r->ar.end); + + damon_pa_fault_change_protection(r->sampling_addr); +} + +static void damon_pa_fault_prepare_access_checks(struct damon_ctx *ctx) +{ + struct damon_target *t; + struct damon_region *r; + + damon_for_each_target(t, ctx) { + damon_for_each_region(r, t) + __damon_pa_fault_prepare_access_check(r); + } +} + /* * damos_pa_filter_out - Return true if the page should be filtered out. */ @@ -355,8 +415,23 @@ static int __init damon_pa_initcall(void) .apply_scheme =3D damon_pa_apply_scheme, .get_scheme_score =3D damon_pa_scheme_score, }; + struct damon_operations fault_ops =3D { + .id =3D DAMON_OPS_PADDR_FAULT, + .init =3D NULL, + .update =3D NULL, + .prepare_access_checks =3D damon_pa_fault_prepare_access_checks, + .check_accesses =3D NULL, + .target_valid =3D NULL, + .cleanup =3D NULL, + .apply_scheme =3D damon_pa_apply_scheme, + .get_scheme_score =3D damon_pa_scheme_score, + }; + int err; =20 - return damon_register_ops(&ops); + err =3D damon_register_ops(&ops); + if (err) + return err; + return damon_register_ops(&fault_ops); }; =20 subsys_initcall(damon_pa_initcall); --=20 2.39.5 From nobody Mon Oct 6 01:21:10 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 EDE8F23F429; Sun, 27 Jul 2025 20:18: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=1753647506; cv=none; b=A8ODzyXzaetIjarsmS6oN/Zvj0uWQKEr/6UbU1kC2WwPig9YAFZlQ8FyRoV3A0JDQ82pqmPnWM0vaA/L0cQNKgduAgQYcCArnrIet7tBngKq2BT77TE5Jwq/LEzSFNI7YoJjutIBxaCTT0+kQPL63PJiZFGbxZQEPu4QatoXZX4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1753647506; c=relaxed/simple; bh=lIN23oNIZq4gvn+3V74kVsfgrx2Y6wNkq7FOywUP7e8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=CR4fsuT5lsNHpR86EJXFC089f8RQmV9VXevcVfVmp7zNam+KcVPRr1QHE/yOm580kEVEaMLUD11K7EU71/HHmEdyV+fuXaxKwNuHSiilk8MHFwKqPoQfc/R68MywIRBCs8rJVy+DNn9l8/nyuR35mvui1D7CeK2PCU3cIWE3Zes= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=SnVyd1ia; 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="SnVyd1ia" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A97EFC4CEFA; Sun, 27 Jul 2025 20:18:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1753647505; bh=lIN23oNIZq4gvn+3V74kVsfgrx2Y6wNkq7FOywUP7e8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=SnVyd1iaZ6FIKe2TiI2z0l2MSfELTCCZol2515DoHHFYOTm0vguEMRVfekcMdFrp4 MNz8vg9AOMJ7/Xqirrg14z4v2WJN2K65r4ZAFP5hbx9xAGDq2ATFA0cAnMX6IfPOVw mlc0Qs1JzsL/QIC79ERmWTZXEV1h3DwFk0Ey2tXFExsnhZfRxdz7IbWqD3x0kH9JD1 9BdqkLbs2YX56yNk/wnj4ajUI5nDWfujZUyUnbmu4a8p+HDkMFS2rCxHuU3I+ZSuWO UHg/beRd0Lky+HxbcqIqt1JAVD2VyTiZpFGVweSJzFmIYKmLCz8NZywx+vcQIjThj3 U3avO1s/Otxag== From: SeongJae Park To: Cc: SeongJae Park , Andrew Morton , damon@lists.linux.dev, kernel-team@meta.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [RFC v2 7/7] mm/damon/sysfs: support paddr_fault Date: Sun, 27 Jul 2025 13:18:13 -0700 Message-Id: <20250727201813.53858-8-sj@kernel.org> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20250727201813.53858-1-sj@kernel.org> References: <20250727201813.53858-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 sysfs interface to support the page faults based physical address space access monitoring. Users can use it by writing paddr_fault to the ops file. For simple testing, the DAMON user-space tool can be used as below, after applying below hack. $ git diff --- a/src/_damon_sysfs.py +++ b/src/_damon_sysfs.py @@ -548,7 +548,7 @@ def write_monitoring_attrs_dir(dir_path, context): def write_context_dir(dir_path, context): err =3D _damo_fs.write_file(os.path.join(dir_path, 'operations'), - context.ops) + 'paddr_fault') if err is not None: return err $ sudo ./damo start $ sudo ./damo report access 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 6d2b0dab50cb..b1bf43972491 100644 --- a/mm/damon/sysfs.c +++ b/mm/damon/sysfs.c @@ -829,6 +829,10 @@ static const struct damon_sysfs_ops_name damon_sysfs_o= ps_names[] =3D { .ops_id =3D DAMON_OPS_PADDR, .name =3D "paddr", }, + { + .ops_id =3D DAMON_OPS_PADDR_FAULT, + .name =3D "paddr_fault", + }, }; =20 struct damon_sysfs_context { --=20 2.39.5