From patchwork Thu Feb 6 18:51:00 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Frank van der Linden X-Patchwork-Id: 13963567 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 3C783C0219B for ; Thu, 6 Feb 2025 18:52:10 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 26495280013; Thu, 6 Feb 2025 13:51:52 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 1EC1F280002; Thu, 6 Feb 2025 13:51:52 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id F31CF280013; Thu, 6 Feb 2025 13:51:51 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id D1C9C280002 for ; Thu, 6 Feb 2025 13:51:51 -0500 (EST) Received: from smtpin11.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay01.hostedemail.com (Postfix) with ESMTP id 949581C917F for ; Thu, 6 Feb 2025 18:51:51 +0000 (UTC) X-FDA: 83090414022.11.BB646CA Received: from mail-pj1-f74.google.com (mail-pj1-f74.google.com [209.85.216.74]) by imf28.hostedemail.com (Postfix) with ESMTP id C4A36C0007 for ; Thu, 6 Feb 2025 18:51:49 +0000 (UTC) Authentication-Results: imf28.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=Xd978mEs; spf=pass (imf28.hostedemail.com: domain of 3xASlZwQKCKUKaIQLTTLQJ.HTRQNSZc-RRPaFHP.TWL@flex--fvdl.bounces.google.com designates 209.85.216.74 as permitted sender) smtp.mailfrom=3xASlZwQKCKUKaIQLTTLQJ.HTRQNSZc-RRPaFHP.TWL@flex--fvdl.bounces.google.com; dmarc=pass (policy=reject) header.from=google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738867909; 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-type:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=41QLNtbtqhWSGZ/oObOknHg0NviKslOOeQUP783wlTM=; b=0ordxWKAMODxxG/YTGUwQPFldYUCzF5ly2sCHGhcvgRlmyXlePZrlz3u2aFEJD/8+RupUw mPLBpJOKHegveq7/dRTjEkGFo42NzRYsFGiNkEmoP6JJZOmzpBKS6JNOFSG5IVXb3opBlI d8a3TkqcFbnxqa0efrv6a5uhpwYCU3Q= ARC-Authentication-Results: i=1; imf28.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=Xd978mEs; spf=pass (imf28.hostedemail.com: domain of 3xASlZwQKCKUKaIQLTTLQJ.HTRQNSZc-RRPaFHP.TWL@flex--fvdl.bounces.google.com designates 209.85.216.74 as permitted sender) smtp.mailfrom=3xASlZwQKCKUKaIQLTTLQJ.HTRQNSZc-RRPaFHP.TWL@flex--fvdl.bounces.google.com; dmarc=pass (policy=reject) header.from=google.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738867909; a=rsa-sha256; cv=none; b=ydz+PvIw/oFvN8J6qwlcjDiHneqTyA1Vj1h5R159R72qIJI4XhpGcf7btE8rCn6vMRxhBa +vssvYAhiQIy7qUof31n/ykWqfEyXuwuoOJPVkcYYPctuyY9/OkEXH2dnfsx3iqlkR5yjx KYAEaVDO+dnGnyrLsbaYi1X9Sh2m1Kw= Received: by mail-pj1-f74.google.com with SMTP id 98e67ed59e1d1-2f9c02f54f2so2486921a91.3 for ; Thu, 06 Feb 2025 10:51:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1738867909; x=1739472709; darn=kvack.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=41QLNtbtqhWSGZ/oObOknHg0NviKslOOeQUP783wlTM=; b=Xd978mEsfuej7zGvJH2cei0SbQmidlk15mYmyN/DkKTijkTlxN1gVF6sg3bm/OQQFf 3q4GUJJaFK1PFgUYMETEe06djKM8JagGZ/Wn6XR/LY1LBkyz1U2HUm5LF0YpLEhQGTRL G3vWwhTYqtmrtUGdw0fGo59ErnEHK0GUNBUyyQkjOr4I+t8zj+z7zAPEnYQ6kVMVll6T BEdG8Q6NaUwCTsDkp0PkkvHfbMRBFSSJjV3uhaq9p8Hisy4/W6ZmJKs6TSwzFlX0zotk Ku/Unt5W+/STQbgurujHLA5ylbVYJXKxiyPV2F0/ii94vrzDDXzXywieFEW4NxKAXI5W bBZw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738867909; x=1739472709; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=41QLNtbtqhWSGZ/oObOknHg0NviKslOOeQUP783wlTM=; b=s0sBL+V304nXjYped2TlJe7I0P1/Jdt4O5XM3Hc/r4SuV8gls5aX9xbXcZe/ekwfQb wLo7IpgG18d4FacWPa0kmtz7ovzIRTtd+81SHjxO0t4ntJtuaW4klR7gFQgeJJmMCCbI Oci7DyEonkfjcqKqSPptHOxNa1URt+i3QIIBQadSJIFmLIEtxAFz18vm1kRwZqcvxLD4 wqf8DNhAMvIhGvok71rXPQOqGVvDgDmrKyrHNq/CQ/lo7HsS9vTi1WCPfpUpEJAdRoFA d46If4GiFqcEWS9Ixk6lzFNFquWCf7pivb8hPiN+hDT632vKq/dhFr5bIRVdDf1aEu2g XoRA== X-Forwarded-Encrypted: i=1; AJvYcCWC4+TZvzoDkZULpyXfy2152gkJKI9Lvoy9QQkHyLvXDBBckdU0MS2SKsC2sz74Rvtf8tL8Gl6UeA==@kvack.org X-Gm-Message-State: AOJu0YyyvT1epvX3+gRi3FA9aWVe3YOguCAMo4BuF8mbNC4H7BD25OOQ dTLJYCOp1DtRDYjbJSu59D5Jy3A2VZguu3ljSJhT+TE3BTVUZNZGPPCbx4yUbB9d+UsYVg== X-Google-Smtp-Source: AGHT+IGVxYFLO6PMMj5YOBtKJIkBsk+UPteT4nuImFK20RZLySxCL3GaHTYjR4JwUAp1YZGI3vapG7Y+ X-Received: from pfbhd4.prod.google.com ([2002:a05:6a00:6584:b0:72f:8e60:adb8]) (user=fvdl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:2e9c:b0:725:e405:6df7 with SMTP id d2e1a72fcca58-7305d46f7bemr390731b3a.10.1738867908791; Thu, 06 Feb 2025 10:51:48 -0800 (PST) Date: Thu, 6 Feb 2025 18:51:00 +0000 In-Reply-To: <20250206185109.1210657-1-fvdl@google.com> Mime-Version: 1.0 References: <20250206185109.1210657-1-fvdl@google.com> X-Mailer: git-send-email 2.48.1.502.g6dc24dfdaf-goog Message-ID: <20250206185109.1210657-21-fvdl@google.com> Subject: [PATCH v3 20/28] mm/hugetlb: do pre-HVO for bootmem allocated pages From: Frank van der Linden To: akpm@linux-foundation.org, muchun.song@linux.dev, linux-mm@kvack.org, linux-kernel@vger.kernel.org Cc: yuzhao@google.com, usamaarif642@gmail.com, joao.m.martins@oracle.com, roman.gushchin@linux.dev, Frank van der Linden X-Rspamd-Queue-Id: C4A36C0007 X-Stat-Signature: yudxww566cns4jezte1ye4oxtx1w3npj X-Rspam-User: X-Rspamd-Server: rspam01 X-HE-Tag: 1738867909-410919 X-HE-Meta: U2FsdGVkX1+W14e334cup0TtVnGLIcZIwq9CKFqAMFsOML0HMWoGhK0ZxuEa6v5T08TnILIPbuky/CXMmGx4PNnepjfCUOnRZzmyGE+RvslwYk2eh04XOeYkKx8uT3r5W4ZaXsn3IvXhD+42cpuJcqJpeyrDHGlYQiK0QwJaw2pbB8g1cVJJV65rxiEVNcSQB/rmpJN+R6zjvfRFGAtpioWB1o7MpY5MAOT9HKEJ9F5rJn0KiVHtpWNEkjycf72YJzyB9XsmadtIDWtHwi9UGucgLkVW+ttcK1ECWrzSUnvopl9J7ZOvhgExkjXCabzfTKzqWU6KQknwvO+226H/SGhlawpiytXgBNr15M+fjbgyg6hJ+B32+6Mu9zlwsnyIMGQ5uMcq61rVFQwz9uZCjRrozidjdhwxN2q6h+oOpc5eLRznsuCEmPk0pWGCpaqDo0aks/oScBDWDiRv+hBQssjDi2hAAl8PfMdzycVK+8ZAcpmb8tRfhDAyFi3cYSy2oJCuXvLiIdtm4+CNAOi+0cd8HqwlzukXO5GURGcC2FCGRqSPS8beuULCo/YmxM/VkrnBHZK8aci2kznXTsTxU5UykGjdScogZj4UkOjzwX5XppvvtxBT1yCSKvsODEz3lauH7lWIaSBoOZnWklG5Oi/bzPoO6XtXPZKqSl1II51ahE6HGpV9NsmTClVnSrcsaPsK0NZm+exzeNdfBUXv7m973kpW1zwWCM8jvGht13g6itKC4GREtMlfM1O/Y120swWBW3oLohBuucgr6XSw7N/ZmsghT2ikcYWzwSuNR6V9L4UEEmwYeFM8UkpC08SvM8gocdkDn624S1MQMlS+Bkg/S945Hg7XRWLRJT2gphTgJwvcwLFvsQwcu09NSP3FZ27K/CDleRuDCyzaDTIRmsXInkYjLSompjFFiiCFCuip+4wlyRtfxFH0hg+ISChO+Ofqp1CZdqZ5rTDkQ6e f2kjzGWM DxSbL591FuN9rPdvLYz245WPxLAPRE9Y5fj/OHwtUCdHvYSvqR//ziGG/LbN2W5NpjJdUlRXjDzaevlWo+9kNrLSFNLbFFrhCN0JFsOlszrVfRonSuISvx5tZeZp8QhrrXRXqNeHwfsgs+chD9fLxEOy9WbtGI44xKbdpojjZhJQAbBBshpvYkJbv0DB8MDyf17jkH84fp/K8GhwicFmt4z6Jt2KYE8voRlG4JI2bEq+jpeeYuwiyi4EzQyrFYWS6I+eHNGy+JegevteMOYl5DxHcOPUX4LY1yGTOTTXW98xsg9zXr6+S2ZeW4sYbblcms2uDvaD8tOLrn4r1yHx0ZxRY9KsKjgwB3mt659RmsInpSalt+aihskUj7NTxDOURG1Qy/OJk8mUM3ikbFq8JF5jKlxjxYENwblErr/RvjkJsPD8UqDiOqNN8gWn+DNXZ/tbfTjjbNs8voZ5unfOdo54r3M6mAEyxyoWnJjKQLSyBPcrwgClKp3GmIofFK7mc5E+lsC6SZaSUfSNkqQqninN9yg== 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: For large systems, the overhead of vmemmap pages for hugetlb is substantial. It's about 1.5% of memory, which is about 45G for a 3T system. If you want to configure most of that system for hugetlb (e.g. to use as backing memory for VMs), there is a chance of running out of memory on boot, even though you know that the 45G will become available later. To avoid this scenario, and since it's a waste to first allocate and then free that 45G during boot, do pre-HVO for hugetlb bootmem allocated pages ('gigantic' pages). pre-HVO is done by adding functions that are called from sparse_init_nid_early and sparse_init_nid_late. The first is called before memmap allocation, so it takes care of allocating memmap HVO-style. The second verifies that all bootmem pages look good, specifically it checks that they do not intersect with multiple zones. This can only be done from sparse_init_nid_late path, when zones have been initialized. The hugetlb page size must be aligned to the section size, and aligned to the size of memory described by the number of page structures contained in one PMD (since pre-HVO is not prepared to split PMDs). This should be true for most 'gigantic' pages, it is for 1G pages on x86, where both of these alignment requirements are 128M. This will only have an effect if hugetlb_bootmem_alloc was called early in boot. If not, it won't do anything, and HVO for bootmem hugetlb pages works as before. Signed-off-by: Frank van der Linden --- include/linux/hugetlb.h | 2 + mm/hugetlb.c | 4 +- mm/hugetlb_vmemmap.c | 143 ++++++++++++++++++++++++++++++++++++++++ mm/hugetlb_vmemmap.h | 6 ++ mm/sparse-vmemmap.c | 4 ++ 5 files changed, 157 insertions(+), 2 deletions(-) diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h index 10a7ce2b95e1..2512463bca49 100644 --- a/include/linux/hugetlb.h +++ b/include/linux/hugetlb.h @@ -687,6 +687,8 @@ struct huge_bootmem_page { #define HUGE_BOOTMEM_HVO 0x0001 #define HUGE_BOOTMEM_ZONES_VALID 0x0002 +bool hugetlb_bootmem_page_zones_valid(int nid, struct huge_bootmem_page *m); + int isolate_or_dissolve_huge_page(struct page *page, struct list_head *list); int replace_free_hugepage_folios(unsigned long start_pfn, unsigned long end_pfn); struct folio *alloc_hugetlb_folio(struct vm_area_struct *vma, diff --git a/mm/hugetlb.c b/mm/hugetlb.c index 7e0810c217ce..29b3a6e70a53 100644 --- a/mm/hugetlb.c +++ b/mm/hugetlb.c @@ -3310,8 +3310,8 @@ static void __init prep_and_add_bootmem_folios(struct hstate *h, } } -static bool __init hugetlb_bootmem_page_zones_valid(int nid, - struct huge_bootmem_page *m) +bool __init hugetlb_bootmem_page_zones_valid(int nid, + struct huge_bootmem_page *m) { unsigned long start_pfn; bool valid; diff --git a/mm/hugetlb_vmemmap.c b/mm/hugetlb_vmemmap.c index be6b33ecbc8e..9a99dfa3c495 100644 --- a/mm/hugetlb_vmemmap.c +++ b/mm/hugetlb_vmemmap.c @@ -743,6 +743,149 @@ void hugetlb_vmemmap_optimize_bootmem_folios(struct hstate *h, struct list_head __hugetlb_vmemmap_optimize_folios(h, folio_list, true); } +#ifdef CONFIG_SPARSEMEM_VMEMMAP_PREINIT + +/* Return true of a bootmem allocated HugeTLB page should be pre-HVO-ed */ +static bool vmemmap_should_optimize_bootmem_page(struct huge_bootmem_page *m) +{ + unsigned long section_size, psize, pmd_vmemmap_size; + phys_addr_t paddr; + + if (!READ_ONCE(vmemmap_optimize_enabled)) + return false; + + if (!hugetlb_vmemmap_optimizable(m->hstate)) + return false; + + psize = huge_page_size(m->hstate); + paddr = virt_to_phys(m); + + /* + * Pre-HVO only works if the bootmem huge page + * is aligned to the section size. + */ + section_size = (1UL << PA_SECTION_SHIFT); + if (!IS_ALIGNED(paddr, section_size) || + !IS_ALIGNED(psize, section_size)) + return false; + + /* + * The pre-HVO code does not deal with splitting PMDS, + * so the bootmem page must be aligned to the number + * of base pages that can be mapped with one vmemmap PMD. + */ + pmd_vmemmap_size = (PMD_SIZE / (sizeof(struct page))) << PAGE_SHIFT; + if (!IS_ALIGNED(paddr, pmd_vmemmap_size) || + !IS_ALIGNED(psize, pmd_vmemmap_size)) + return false; + + return true; +} + +/* + * Initialize memmap section for a gigantic page, HVO-style. + */ +void __init hugetlb_vmemmap_init_early(int nid) +{ + unsigned long psize, paddr, section_size; + unsigned long ns, i, pnum, pfn, nr_pages; + unsigned long start, end; + struct huge_bootmem_page *m = NULL; + void *map; + + /* + * Noting to do if bootmem pages were not allocated + * early in boot, or if HVO wasn't enabled in the + * first place. + */ + if (!hugetlb_bootmem_allocated()) + return; + + if (!READ_ONCE(vmemmap_optimize_enabled)) + return; + + section_size = (1UL << PA_SECTION_SHIFT); + + list_for_each_entry(m, &huge_boot_pages[nid], list) { + if (!vmemmap_should_optimize_bootmem_page(m)) + continue; + + nr_pages = pages_per_huge_page(m->hstate); + psize = nr_pages << PAGE_SHIFT; + paddr = virt_to_phys(m); + pfn = PHYS_PFN(paddr); + map = pfn_to_page(pfn); + start = (unsigned long)map; + end = start + nr_pages * sizeof(struct page); + + if (vmemmap_populate_hvo(start, end, nid, + HUGETLB_VMEMMAP_RESERVE_SIZE) < 0) + continue; + + memmap_boot_pages_add(HUGETLB_VMEMMAP_RESERVE_SIZE / PAGE_SIZE); + + pnum = pfn_to_section_nr(pfn); + ns = psize / section_size; + + for (i = 0; i < ns; i++) { + sparse_init_early_section(nid, map, pnum, + SECTION_IS_VMEMMAP_PREINIT); + map += section_map_size(); + pnum++; + } + + m->flags |= HUGE_BOOTMEM_HVO; + } +} + +void __init hugetlb_vmemmap_init_late(int nid) +{ + struct huge_bootmem_page *m, *tm; + unsigned long phys, nr_pages, start, end; + unsigned long pfn, nr_mmap; + struct hstate *h; + void *map; + + if (!hugetlb_bootmem_allocated()) + return; + + if (!READ_ONCE(vmemmap_optimize_enabled)) + return; + + list_for_each_entry_safe(m, tm, &huge_boot_pages[nid], list) { + if (!(m->flags & HUGE_BOOTMEM_HVO)) + continue; + + phys = virt_to_phys(m); + h = m->hstate; + pfn = PHYS_PFN(phys); + nr_pages = pages_per_huge_page(h); + + if (!hugetlb_bootmem_page_zones_valid(nid, m)) { + /* + * Oops, the hugetlb page spans multiple zones. + * Remove it from the list, and undo HVO. + */ + list_del(&m->list); + + map = pfn_to_page(pfn); + + start = (unsigned long)map; + end = start + nr_pages * sizeof(struct page); + + vmemmap_undo_hvo(start, end, nid, + HUGETLB_VMEMMAP_RESERVE_SIZE); + nr_mmap = end - start - HUGETLB_VMEMMAP_RESERVE_SIZE; + memmap_boot_pages_add(DIV_ROUND_UP(nr_mmap, PAGE_SIZE)); + + memblock_phys_free(phys, huge_page_size(h)); + continue; + } else + m->flags |= HUGE_BOOTMEM_ZONES_VALID; + } +} +#endif + static const struct ctl_table hugetlb_vmemmap_sysctls[] = { { .procname = "hugetlb_optimize_vmemmap", diff --git a/mm/hugetlb_vmemmap.h b/mm/hugetlb_vmemmap.h index 926b8b27b5cb..0031e49b12f7 100644 --- a/mm/hugetlb_vmemmap.h +++ b/mm/hugetlb_vmemmap.h @@ -9,6 +9,8 @@ #ifndef _LINUX_HUGETLB_VMEMMAP_H #define _LINUX_HUGETLB_VMEMMAP_H #include +#include +#include /* * Reserve one vmemmap page, all vmemmap addresses are mapped to it. See @@ -25,6 +27,10 @@ long hugetlb_vmemmap_restore_folios(const struct hstate *h, void hugetlb_vmemmap_optimize_folio(const struct hstate *h, struct folio *folio); void hugetlb_vmemmap_optimize_folios(struct hstate *h, struct list_head *folio_list); void hugetlb_vmemmap_optimize_bootmem_folios(struct hstate *h, struct list_head *folio_list); +#ifdef CONFIG_SPARSEMEM_VMEMMAP_PREINIT +void hugetlb_vmemmap_init_early(int nid); +void hugetlb_vmemmap_init_late(int nid); +#endif static inline unsigned int hugetlb_vmemmap_size(const struct hstate *h) diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c index 8cc848c4b17c..fd2ab5118e13 100644 --- a/mm/sparse-vmemmap.c +++ b/mm/sparse-vmemmap.c @@ -32,6 +32,8 @@ #include #include +#include "hugetlb_vmemmap.h" + /* * Flags for vmemmap_populate_range and friends. */ @@ -594,6 +596,7 @@ struct page * __meminit __populate_section_memmap(unsigned long pfn, */ void __init sparse_vmemmap_init_nid_early(int nid) { + hugetlb_vmemmap_init_early(nid); } /* @@ -604,5 +607,6 @@ void __init sparse_vmemmap_init_nid_early(int nid) */ void __init sparse_vmemmap_init_nid_late(int nid) { + hugetlb_vmemmap_init_late(nid); } #endif