From patchwork Thu Feb 6 23:11:03 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 13964081 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4FBB1C02194 for ; Thu, 6 Feb 2025 23:11:22 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id CD259280003; Thu, 6 Feb 2025 18:11:21 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id C82DB280002; Thu, 6 Feb 2025 18:11:21 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id B4B09280003; Thu, 6 Feb 2025 18:11:21 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id 944E9280002 for ; Thu, 6 Feb 2025 18:11:21 -0500 (EST) Received: from smtpin10.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id E641F1215D3 for ; Thu, 6 Feb 2025 23:11:20 +0000 (UTC) X-FDA: 83091067920.10.7751D27 Received: from nyc.source.kernel.org (nyc.source.kernel.org [147.75.193.91]) by imf19.hostedemail.com (Postfix) with ESMTP id 51DCA1A000A for ; Thu, 6 Feb 2025 23:11:19 +0000 (UTC) Authentication-Results: imf19.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=cPa3J4Xv; spf=pass (imf19.hostedemail.com: domain of sj@kernel.org designates 147.75.193.91 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738883479; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:references:dkim-signature; bh=C8BulwWR576wybI6j5452jEk+v96SVFrRX0fNs1iXzk=; b=TGSMu2Yf6qHT43QrFuGNXxaxUDjgK31zUh5Kzr8cEk/trY+PFxsPnN3iHzqpv8tS0TMAvT J51IQ1H8v32rcQZSSbKBuJoB5/eWD4Yc70lZxnTmhErP2xp5PhhyA//P+qbTIxcHQwmnq6 +Zr8PPCt4WyP8B7s94EaEB/u20pMeYA= ARC-Authentication-Results: i=1; imf19.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=cPa3J4Xv; spf=pass (imf19.hostedemail.com: domain of sj@kernel.org designates 147.75.193.91 as permitted sender) smtp.mailfrom=sj@kernel.org; dmarc=pass (policy=quarantine) header.from=kernel.org ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738883479; a=rsa-sha256; cv=none; b=hrNjyu2AvB7skPKlIkQLEf+6b0hyQurGdA9gOnYcob4O3tcWNL5uDvBVmgPjRyx2mDV+Gv nizFGHFyp6rIW88khOpcp3siBf43C5p+ibFG5SBJ0zOmhxQKVdax68wAr+nUOTWNAVQjIS yndfQ/rxClDqRZdI6Am1MLU/pdJJDKs= Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by nyc.source.kernel.org (Postfix) with ESMTP id 95503A42146; Thu, 6 Feb 2025 23:09:32 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id DBD7CC4CEDD; Thu, 6 Feb 2025 23:11:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1738883478; bh=1l9ScDXKqIkJS8f8Hq8dlrjRQ1aDQXSzobIfw4wm6Og=; h=From:To:Cc:Subject:Date:From; b=cPa3J4Xv775+ISWQBF7AiaN42OhdjeFkz3e0JvwuRs0mkmiRcKN7ZZvavAyh1cx6J vHzcGtlGYMRfx4M2uJDcutFTKQ09iEYA8iyEg/RykWTeaEb9EjOcehM2D0wlcsDLOz DFTQ1/SNfTtxRRAyssdXKp5Oefw4U6S1yXoXysMuqtSECSy3HLV3vtYiTjSMiCwrgN SPqYKriZckG9EfDpz2UqEPSU10chbQDCHCdoaujbDA92EE/gPPGNbb+uDEW08Vtrv9 4YsC+K95mj+UAVf7gm2WMV1wyuqy+IURH2xwCvESV0bECHhjDPoMo9oHaJGPtc1qQf 5ev469ctkmQyg== 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, Usama Arif Subject: [RFC PATCH] mm/damon: avoid applying DAMOS action to same entity multiple times Date: Thu, 6 Feb 2025 15:11:03 -0800 Message-Id: <20250206231103.38298-1-sj@kernel.org> X-Mailer: git-send-email 2.39.5 MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam09 X-Rspamd-Queue-Id: 51DCA1A000A X-Stat-Signature: if8hce7xq33qnmi1xmybaoasm7faj1jw X-HE-Tag: 1738883479-511168 X-HE-Meta: U2FsdGVkX1++fXnFpOpRzLTbgOLsbtMO0UtdjBHphf8IR+wWSNnsfnOkPcjJJtgcw0xIEq/1Zr5STgCfBeRDoiIy+RJo44J2MLsYUpEpgZuJBoAxKanM8iqjw4DNsZmxFo6r8DxaqofJx3OknJK/UnLZAbN24/IFn0pwZU8I7iNvDJig9D8QA4KvIHQDM+ZE/wwy6J5UPQeT928kkgrMQAEuLmBbk5/lT4HTydvKrXGLDQIeP2zPITRrIO7tJCkJ7WXOBpYpbgPfNbJgK5HpMu/i33Zs/tP7hX/rgb6CdUZVnc/zJ+BWArHcjXN40wya30RcwKWVaM/puorCST0ryGg0GY+DFQJ3wYoDpZugl3mcHiKFLtOZVOKK/CNXaPzS47C+tsGnfapx6TDPURHBq+eNRHwEYdBG9Imu5CuTiIrT8Wel3LcqCAuYaVPMtxNKnzLvC4AK5lwFP7iT2SDrzgptmYv6eVmJqPnMOFiPyWEZDznspYTCubLUgxiOjonytVMmoFEM6rckUNIV2ErmBJ4zw7K+pUT7fH3C1zYDmzghjDbtw7ASC0q7h/5ZiGfa9MSX6fBzGOdYf0tp+wOFWptpfQUa0R24MnVkhciuJS+ObI3r4FEwK+a3RxrCLVwJje46BzhbLRQ56z8iCsQRuSLUQwNIM2wLoXEV7Bpbdd1wDy6f0K+4xQo37mPHfPnfFE7bCW1MZhEwgLu1njXE40azGPeNx5bP+B4CAkp88XboDh6lFBpmyLWX13ZNvUy7obNCJwkMIuZBhtaemI1nGfKfSedr5e9mtHgtDSutV88KCULoaJ85VpokthPO1yCtirRtD46uK/VSkFhK/CnA7fkN5+a45cKoKZzwRAbo4TWBdqstzaRicp0TXcEc01GH6XWeDuxaGj+YLHVPFf7YfshHr8PF5R4sIaBFLhuJC/QP0hrG5wK03HvJNOburKLtU+gj9HeMD3DOtdQtzBe Xw0s37zi h5cj30Tt47mpeX4oyPYsG3Ncq1EAAVTRwO3wdLJmeBu+w+yZXJD6WG8F2aIrnmKHAepJEb+F0rPUO4RoQLUyNfFKb7U9KP0LGIzizcXtt8iKKGvADx3yzF0CgKDXXYt3hCbRWCWgmS4aRKKNP0cGwfYF59E+pBqsJcQbtdrQiDa+1t/BTbbvER2fWWVxxGlkH6jlIh0JhLIVmwBeC6Xb/nVWo7RcqfiEyRHHVX3B1iq4EO6cnPf+Rwi7k6zACtOg8h0ow X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: 'paddr' DAMON operations set can apply a DAMOS scheme's action to a large folio multiple times in single DAMOS-regions-walk if the folio is laid on multiple DAMON regions. Add a field for DAMOS scheme object that can be used by the underlying ops to know what was the last entity that the scheme's action has applied. The core layer unsets the field when each DAMOS-regions-walk is done for the given scheme. And update 'paddr' ops to use the infrastructure to avoid the problem. Reported-by: Usama Arif Closes: https://lore.kernel.org/20250203225604.44742-3-usamaarif642@gmail.com Signed-off-by: SeongJae Park --- include/linux/damon.h | 11 +++++++++++ mm/damon/core.c | 1 + mm/damon/paddr.c | 39 +++++++++++++++++++++++++++------------ 3 files changed, 39 insertions(+), 12 deletions(-) base-commit: a0aaf0b2cacaf69162a3d20685ff8c7c84b15a41 diff --git a/include/linux/damon.h b/include/linux/damon.h index af525252b853..a390af84cf0f 100644 --- a/include/linux/damon.h +++ b/include/linux/damon.h @@ -432,6 +432,7 @@ struct damos_access_pattern { * @wmarks: Watermarks for automated (in)activation of this scheme. * @target_nid: Destination node if @action is "migrate_{hot,cold}". * @filters: Additional set of &struct damos_filter for &action. + * @last_applied: Last @action applied ops-managing entity. * @stat: Statistics of this scheme. * @list: List head for siblings. * @@ -454,6 +455,15 @@ struct damos_access_pattern { * implementation could check pages of the region and skip &action to respect * &filters * + * The minimum entity that @action can be applied depends on the underlying + * &struct damon_operations. Since it may not be aligned with the core layer + * abstract, namely &struct damon_region, &struct damon_operations could apply + * @action to same entity multiple times. Large folios that underlying on + * multiple &struct damon region objects could be such examples. The &struct + * damon_operations can use @last_applied to avoid that. DAMOS core logic + * unsets @last_applied when each regions walking for applying the scheme is + * finished. + * * After applying the &action to each region, &stat_count and &stat_sz is * updated to reflect the number of regions and total size of regions that the * &action is applied. @@ -477,6 +487,7 @@ struct damos { int target_nid; }; struct list_head filters; + void *last_applied; struct damos_stat stat; struct list_head list; }; diff --git a/mm/damon/core.c b/mm/damon/core.c index c7b981308862..1a4dd644949b 100644 --- a/mm/damon/core.c +++ b/mm/damon/core.c @@ -1851,6 +1851,7 @@ static void kdamond_apply_schemes(struct damon_ctx *c) s->next_apply_sis = c->passed_sample_intervals + (s->apply_interval_us ? s->apply_interval_us : c->attrs.aggr_interval) / sample_interval; + s->last_applied = NULL; } } diff --git a/mm/damon/paddr.c b/mm/damon/paddr.c index 0fb61f6ddb8d..d64c6fe28667 100644 --- a/mm/damon/paddr.c +++ b/mm/damon/paddr.c @@ -243,6 +243,17 @@ static bool damos_pa_filter_out(struct damos *scheme, struct folio *folio) return false; } +static bool damon_pa_invalid_damos_folio(struct folio *folio, struct damos *s) +{ + if (!folio) + return true; + if (folio == s->last_applied) { + folio_put(folio); + return true; + } + return false; +} + static unsigned long damon_pa_pageout(struct damon_region *r, struct damos *s, unsigned long *sz_filter_passed) { @@ -250,6 +261,7 @@ static unsigned long damon_pa_pageout(struct damon_region *r, struct damos *s, LIST_HEAD(folio_list); bool install_young_filter = true; struct damos_filter *filter; + struct folio *folio; /* check access in page level again by default */ damos_for_each_filter(filter, s) { @@ -268,9 +280,8 @@ static unsigned long damon_pa_pageout(struct damon_region *r, struct damos *s, addr = r->ar.start; while (addr < r->ar.end) { - struct folio *folio = damon_get_folio(PHYS_PFN(addr)); - - if (!folio) { + folio = damon_get_folio(PHYS_PFN(addr)); + if (damon_pa_invalid_damos_folio(folio, s)) { addr += PAGE_SIZE; continue; } @@ -296,6 +307,7 @@ static unsigned long damon_pa_pageout(struct damon_region *r, struct damos *s, damos_destroy_filter(filter); applied = reclaim_pages(&folio_list); cond_resched(); + s->last_applied = folio; return applied * PAGE_SIZE; } @@ -304,12 +316,12 @@ static inline unsigned long damon_pa_mark_accessed_or_deactivate( unsigned long *sz_filter_passed) { unsigned long addr, applied = 0; + struct folio *folio; addr = r->ar.start; while (addr < r->ar.end) { - struct folio *folio = damon_get_folio(PHYS_PFN(addr)); - - if (!folio) { + folio = damon_get_folio(PHYS_PFN(addr)); + if (damon_pa_invalid_damos_folio(folio, s)) { addr += PAGE_SIZE; continue; } @@ -328,6 +340,7 @@ static inline unsigned long damon_pa_mark_accessed_or_deactivate( addr += folio_size(folio); folio_put(folio); } + s->last_applied = folio; return applied * PAGE_SIZE; } @@ -471,12 +484,12 @@ static unsigned long damon_pa_migrate(struct damon_region *r, struct damos *s, { unsigned long addr, applied; LIST_HEAD(folio_list); + struct folio *folio; addr = r->ar.start; while (addr < r->ar.end) { - struct folio *folio = damon_get_folio(PHYS_PFN(addr)); - - if (!folio) { + folio = damon_get_folio(PHYS_PFN(addr)); + if (damon_pa_invalid_damos_folio(folio, s)) { addr += PAGE_SIZE; continue; } @@ -495,6 +508,7 @@ static unsigned long damon_pa_migrate(struct damon_region *r, struct damos *s, } applied = damon_pa_migrate_pages(&folio_list, s->target_nid); cond_resched(); + s->last_applied = folio; return applied * PAGE_SIZE; } @@ -512,15 +526,15 @@ static unsigned long damon_pa_stat(struct damon_region *r, struct damos *s, { unsigned long addr; LIST_HEAD(folio_list); + struct folio *folio; if (!damon_pa_scheme_has_filter(s)) return 0; addr = r->ar.start; while (addr < r->ar.end) { - struct folio *folio = damon_get_folio(PHYS_PFN(addr)); - - if (!folio) { + folio = damon_get_folio(PHYS_PFN(addr)); + if (damon_pa_invalid_damos_folio(folio, s)) { addr += PAGE_SIZE; continue; } @@ -530,6 +544,7 @@ static unsigned long damon_pa_stat(struct damon_region *r, struct damos *s, addr += folio_size(folio); folio_put(folio); } + s->last_applied = folio; return 0; }