From patchwork Sun Apr 5 03:53:17 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: WANG Rui X-Patchwork-Id: 132702 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from vm01.sourceware.org (localhost [127.0.0.1]) by sourceware.org (Postfix) with ESMTP id 4011E4BA2E2F for ; Sun, 5 Apr 2026 03:55:36 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 4011E4BA2E2F X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail.loongson.cn (mail.loongson.cn [114.242.206.163]) by sourceware.org (Postfix) with ESMTP id 7E5314BA2E24 for ; Sun, 5 Apr 2026 03:54:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 7E5314BA2E24 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=loongson.cn Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=loongson.cn ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 7E5314BA2E24 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=114.242.206.163 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1775361248; cv=none; b=FyE2957nWd4qBw3ucXBcy1GsPUaL3dJXB8F0DzWoXCNFO2qpDwWY7Um58hOIfZ19YppBwioyf/lxJBOWmWvJgWuVIw/l52bJvuH2YkGDxF9ZvYRfUeHTmQDG1pDTw3lcog4u0z0Qq6Q1MfC7BqLb/Iu4Uem8NJ+ukGJqAxh7guw= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1775361248; c=relaxed/simple; bh=2QoRue9+GOUrEgPoMFpUKF9s+pYaEgpPicbdeiPK72k=; h=From:To:Subject:Date:Message-ID:MIME-Version; b=gy18FoLj3JLJmiJ5eOFeY5/lEQspAjvNfG9VX1jhjAasuMUjr3hDfNrlU4i2jAuO+4qcJ+rOM7EtNyk0dq8kgODuPmRPyUniH3fAqgWFzkknKOCUtE0kStxFDciu+gGwOMCBnBQs1Ia7Vgz9WLkdoNcSfJycoAyeYedxBAOXGCA= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7E5314BA2E24 Received: from loongson.cn (unknown [223.64.120.66]) by gateway (Coremail) with SMTP id _____8BxVcHc3NFphBgiAA--.48242S3; Sun, 05 Apr 2026 11:54:04 +0800 (CST) Received: from localhost (unknown [223.64.120.66]) by front1 (Coremail) with SMTP id qMiowJBxDOHK3NFpP1JlAA--.44692S3; Sun, 05 Apr 2026 11:53:58 +0800 (CST) From: WANG Rui To: libc-alpha@sourceware.org Cc: Adhemerval Zanella , Dev Jain , Florian Weimer , Wilco Dijkstra , Xi Ruoyao , WANG Xuerui , caiyinyu , mengqinggang , Huacai Chen , hjl.tools@gmail.com, WANG Rui Subject: [PATCH v8 1/6] hugepages: Move THP helpers to generic hugepages abstraction Date: Sun, 5 Apr 2026 11:53:17 +0800 Message-ID: <20260405035323.558335-2-wangrui@loongson.cn> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260405035323.558335-1-wangrui@loongson.cn> References: <20260405035323.558335-1-wangrui@loongson.cn> MIME-Version: 1.0 X-CM-TRANSID: qMiowJBxDOHK3NFpP1JlAA--.44692S3 X-CM-SenderInfo: pzdqw2txl6z05rqj20fqof0/ X-Coremail-Antispam: 1Uk129KBj9fXoWfJFWxuFykWw1rtF48Aw4DJrc_yoW8JF4kGo WfGFWrJF4rXrn8ZrWxCa90qa1jk34kuw4rJFnxZrZxWayjqr1rAr40ka95Wr9xGF45KFyx JFyrK3W5tF18tr95l-sFpf9Il3svdjkaLaAFLSUrUUUU8b8apTn2vfkv8UJUUUU8wcxFpf 9Il3svdxBIdaVrn0xqx4xG64xvF2IEw4CE5I8CrVC2j2Jv73VFW2AGmfu7bjvjm3AaLaJ3 UjIYCTnIWjp_UUUYX7kC6x804xWl14x267AKxVWUJVW8JwAFc2x0x2IEx4CE42xK8VAvwI 8IcIk0rVWrJVCq3wAFIxvE14AKwVWUAVWUZwA2ocxC64kIII0Yj41l84x0c7CEw4AK67xG Y2AK021l84ACjcxK6xIIjxv20xvE14v26r4j6ryUM28EF7xvwVC0I7IYx2IY6xkF7I0E14 v26r4j6F4UM28EF7xvwVC2z280aVAFwI0_Gr0_Cr1l84ACjcxK6I8E87Iv6xkF7I0E14v2 6r4j6r4UJwAaw2AFwI0_Jrv_JF1le2I262IYc4CY6c8Ij28IcVAaY2xG8wAqjxCEc2xF0c Ia020Ex4CE44I27wAqx4xG64xvF2IEw4CE5I8CrVC2j2WlYx0E2Ix0cI8IcVAFwI0_Jw0_ WrylYx0Ex4A2jsIE14v26r4j6F4UMcvjeVCFs4IE7xkEbVWUJVW8JwACjcxG0xvY0x0EwI xGrwCY1x0262kKe7AKxVWUAVWUtwCF04k20xvY0x0EwIxGrwCFx2IqxVCFs4IE7xkEbVWU JVW8JwCFI7km07C267AKxVWUXVWUAwC20s026c02F40E14v26r1j6r18MI8I3I0E7480Y4 vE14v26r106r1rMI8E67AF67kF1VAFwI0_Jw0_GFylIxkGc2Ij64vIr41lIxAIcVC0I7IY x2IY67AKxVW8JVW5JwCI42IY6xIIjxv20xvEc7CjxVAFwI0_Gr0_Cr1lIxAIcVCF04k26c xKx2IYs7xG6r1j6r1xMIIF0xvEx4A2jsIE14v26r4j6F4UMIIF0xvEx4A2jsIEc7CjxVAF wI0_Gr0_Gr1UYxBIdaVFxhVjvjDU0xZFpf9x07jzc_-UUUUU= X-Spam-Status: No, score=-11.5 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_SHORT, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libc-alpha-bounces~patchwork=sourceware.org@sourceware.org The helpers for determining the default transparent huge page size and THP mode are currently implemented in malloc-hugepages. However, these interfaces are not malloc-specific and are also needed by other subsystems (e.g. the dynamic loader for segment alignment). Introduce a new generic hugepages abstraction and move the THP mode detection, default THP page size probing, and hugepage configuration helpers there. The malloc code now calls into the generic helpers instead of duplicating the sysfs parsing. There is no functional change. This is a pure refactoring to make the THP detection reusable outside of malloc. Reviewed-by: Wilco Dijkstra Signed-off-by: WANG Rui --- elf/dl-tunables.c | 7 ++-- malloc/malloc-internal.h | 2 +- malloc/malloc.c | 27 ++++++++------- sysdeps/generic/Makefile | 4 +-- .../{malloc-hugepages.c => hugepages.c} | 13 ++++---- .../{malloc-hugepages.h => hugepages.h} | 32 ++++++++++-------- .../{malloc-hugepages.h => hugepages.h} | 4 +-- .../linux/{malloc-hugepages.c => hugepages.c} | 33 ++++++++++--------- 8 files changed, 63 insertions(+), 59 deletions(-) rename sysdeps/generic/{malloc-hugepages.c => hugepages.c} (76%) rename sysdeps/generic/{malloc-hugepages.h => hugepages.h} (68%) rename sysdeps/unix/sysv/linux/aarch64/{malloc-hugepages.h => hugepages.h} (91%) rename sysdeps/unix/sysv/linux/{malloc-hugepages.c => hugepages.c} (89%) diff --git a/elf/dl-tunables.c b/elf/dl-tunables.c index 1440d3fa6a5..5c65e8b4583 100644 --- a/elf/dl-tunables.c +++ b/elf/dl-tunables.c @@ -33,7 +33,7 @@ #include #include #include -#include +#include #define TUNABLES_INTERNAL 1 #include "dl-tunables.h" @@ -297,8 +297,9 @@ __tunables_init (char **envp) char *envval = NULL; char **prev_envp = envp; - /* Default to glibc.malloc.hugetlb=1 if DEFAULT_THP_PAGESIZE is non-zero. */ - if (DEFAULT_THP_PAGESIZE > 0) + /* Default to glibc.malloc.hugetlb=1 if MALLOC_DEFAULT_THP_PAGESIZE + is non-zero. */ + if (MALLOC_DEFAULT_THP_PAGESIZE > 0) TUNABLE_SET (glibc, malloc, hugetlb, 1); /* Ignore tunables for AT_SECURE programs. */ diff --git a/malloc/malloc-internal.h b/malloc/malloc-internal.h index dd326af1ea0..a6340bfd888 100644 --- a/malloc/malloc-internal.h +++ b/malloc/malloc-internal.h @@ -22,7 +22,7 @@ #include #include #include -#include +#include #include /* Called in the parent process before a fork. */ diff --git a/malloc/malloc.c b/malloc/malloc.c index 6a888b0eb7d..febd7b516f4 100644 --- a/malloc/malloc.c +++ b/malloc/malloc.c @@ -1759,7 +1759,7 @@ struct malloc_par INTERNAL_SIZE_T arena_max; /* Transparent Large Page support. */ - enum malloc_thp_mode_t thp_mode; + enum thp_mode_t thp_mode; INTERNAL_SIZE_T thp_pagesize; /* A value different than 0 means to align mmap allocation to hp_pagesize add hp_flags on flags. */ @@ -1814,7 +1814,7 @@ static struct malloc_par mp_ = .trim_threshold = DEFAULT_TRIM_THRESHOLD, #define NARENAS_FROM_NCORES(n) ((n) * (sizeof (long) == 4 ? 2 : 8)) .arena_test = NARENAS_FROM_NCORES (1), - .thp_mode = malloc_thp_mode_not_supported + .thp_mode = thp_mode_not_supported #if USE_TCACHE , .tcache_count = TCACHE_FILL_COUNT, @@ -1896,7 +1896,7 @@ madvise_thp (void *p, INTERNAL_SIZE_T size) /* Only use __madvise if the system is using 'madvise' mode and the size is at least a huge page, otherwise the call is wasteful. */ - if (mp_.thp_mode != malloc_thp_mode_madvise || size < mp_.thp_pagesize) + if (mp_.thp_mode != thp_mode_madvise || size < mp_.thp_pagesize) return; /* Linux requires the input address to be page-aligned, and unaligned @@ -5017,33 +5017,32 @@ do_set_mxfast (size_t value) static __always_inline int do_set_hugetlb (size_t value) { - /* Enable THP if DEFAULT_THP_PAGESIZE is non-zero. */ - if (DEFAULT_THP_PAGESIZE > 0) + /* Enable THP if MALLOC_DEFAULT_THP_PAGESIZE is non-zero. */ + if (MALLOC_DEFAULT_THP_PAGESIZE > 0) { - mp_.thp_mode = malloc_thp_mode_madvise; - mp_.thp_pagesize = DEFAULT_THP_PAGESIZE; + mp_.thp_mode = thp_mode_madvise; + mp_.thp_pagesize = MALLOC_DEFAULT_THP_PAGESIZE; } if (value == 0) { /* Turn off THP support completely. */ - mp_.thp_mode = malloc_thp_mode_never; + mp_.thp_mode = thp_mode_never; mp_.thp_pagesize = 0; } else if (value == 1) { /* Avoid querying the THP page size/mode since accessing /sys/kernel/mm is relatively slow and might not be accessible in containers. */ - if (DEFAULT_THP_PAGESIZE > 0) + if (MALLOC_DEFAULT_THP_PAGESIZE > 0) return 0; - mp_.thp_mode = __malloc_thp_mode (); - if (mp_.thp_mode == malloc_thp_mode_madvise - || mp_.thp_mode == malloc_thp_mode_always) - mp_.thp_pagesize = __malloc_default_thp_pagesize (); + mp_.thp_mode = __get_thp_mode (); + if (mp_.thp_mode == thp_mode_madvise || mp_.thp_mode == thp_mode_always) + mp_.thp_pagesize = __get_thp_size (); } else if (value >= 2) - __malloc_hugepage_config (value == 2 ? 0 : value, &mp_.hp_pagesize, + __get_hugepage_config (value == 2 ? 0 : value, &mp_.hp_pagesize, &mp_.hp_flags); return 0; } diff --git a/sysdeps/generic/Makefile b/sysdeps/generic/Makefile index 0c25592f35b..53c4efa63e5 100644 --- a/sysdeps/generic/Makefile +++ b/sysdeps/generic/Makefile @@ -32,9 +32,9 @@ endif endif ifeq ($(subdir),malloc) -sysdep_malloc_debug_routines += malloc-hugepages +sysdep_malloc_debug_routines += hugepages endif ifeq ($(subdir),misc) -sysdep_routines += malloc-hugepages +sysdep_routines += hugepages endif diff --git a/sysdeps/generic/malloc-hugepages.c b/sysdeps/generic/hugepages.c similarity index 76% rename from sysdeps/generic/malloc-hugepages.c rename to sysdeps/generic/hugepages.c index 57b82a2438d..28bab662b13 100644 --- a/sysdeps/generic/malloc-hugepages.c +++ b/sysdeps/generic/hugepages.c @@ -16,23 +16,22 @@ License along with the GNU C Library; see the file COPYING.LIB. If not, see . */ -#include +#include unsigned long int -__malloc_default_thp_pagesize (void) +__get_thp_size (void) { return 0; } -enum malloc_thp_mode_t -__malloc_thp_mode (void) +enum thp_mode_t +__get_thp_mode (void) { - return malloc_thp_mode_not_supported; + return thp_mode_not_supported; } -/* Return the default transparent huge page size. */ void -__malloc_hugepage_config (size_t requested, size_t *pagesize, int *flags) +__get_hugepage_config (size_t requested, size_t *pagesize, int *flags) { *pagesize = 0; *flags = 0; diff --git a/sysdeps/generic/malloc-hugepages.h b/sysdeps/generic/hugepages.h similarity index 68% rename from sysdeps/generic/malloc-hugepages.h rename to sysdeps/generic/hugepages.h index ab2690f7b8a..5fc9b5c8dea 100644 --- a/sysdeps/generic/malloc-hugepages.h +++ b/sysdeps/generic/hugepages.h @@ -1,4 +1,4 @@ -/* Malloc huge page support. Generic implementation. +/* Huge page support. Generic implementation. Copyright (C) 2021-2026 Free Software Foundation, Inc. This file is part of the GNU C Library. @@ -16,33 +16,37 @@ License along with the GNU C Library; see the file COPYING.LIB. If not, see . */ -#ifndef _MALLOC_HUGEPAGES_H -#define _MALLOC_HUGEPAGES_H +#ifndef _HUGEPAGES_H +#define _HUGEPAGES_H #include /* Return the default transparent huge page size. */ -unsigned long int __malloc_default_thp_pagesize (void) attribute_hidden; +unsigned long int __get_thp_size (void) attribute_hidden; -enum malloc_thp_mode_t +enum thp_mode_t { - malloc_thp_mode_always, - malloc_thp_mode_madvise, - malloc_thp_mode_never, - malloc_thp_mode_not_supported + thp_mode_always, + thp_mode_madvise, + thp_mode_never, + thp_mode_not_supported }; -enum malloc_thp_mode_t __malloc_thp_mode (void) attribute_hidden; +enum thp_mode_t __get_thp_mode (void) attribute_hidden; /* Return the supported huge page size from the REQUESTED sizes on PAGESIZE along with the required extra mmap flags on FLAGS, Requesting the value of 0 returns the default huge page size, otherwise the value will be matched against the sizes supported by the system. */ -void __malloc_hugepage_config (size_t requested, size_t *pagesize, int *flags) +void __get_hugepage_config (size_t requested, size_t *pagesize, int *flags) attribute_hidden; -#ifndef DEFAULT_THP_PAGESIZE -# define DEFAULT_THP_PAGESIZE 0 +#ifndef MALLOC_DEFAULT_THP_PAGESIZE +# define MALLOC_DEFAULT_THP_PAGESIZE 0 #endif -#endif /* _MALLOC_HUGEPAGES_H */ +#ifndef MAX_THP_PAGESIZE +# define MAX_THP_PAGESIZE (32 * 1024 * 1024) +#endif + +#endif /* _HUGEPAGES_H */ diff --git a/sysdeps/unix/sysv/linux/aarch64/malloc-hugepages.h b/sysdeps/unix/sysv/linux/aarch64/hugepages.h similarity index 91% rename from sysdeps/unix/sysv/linux/aarch64/malloc-hugepages.h rename to sysdeps/unix/sysv/linux/aarch64/hugepages.h index 2204112e4e5..4f9de8a3949 100644 --- a/sysdeps/unix/sysv/linux/aarch64/malloc-hugepages.h +++ b/sysdeps/unix/sysv/linux/aarch64/hugepages.h @@ -16,6 +16,6 @@ License along with the GNU C Library; see the file COPYING.LIB. If not, see . */ -#define DEFAULT_THP_PAGESIZE (1UL << 21) +#define MALLOC_DEFAULT_THP_PAGESIZE (1UL << 21) -#include_next +#include_next diff --git a/sysdeps/unix/sysv/linux/malloc-hugepages.c b/sysdeps/unix/sysv/linux/hugepages.c similarity index 89% rename from sysdeps/unix/sysv/linux/malloc-hugepages.c rename to sysdeps/unix/sysv/linux/hugepages.c index 77b49374e60..707a75c2a29 100644 --- a/sysdeps/unix/sysv/linux/malloc-hugepages.c +++ b/sysdeps/unix/sysv/linux/hugepages.c @@ -18,16 +18,13 @@ #include #include -#include +#include #include #include unsigned long int -__malloc_default_thp_pagesize (void) +__get_thp_size (void) { - if (DEFAULT_THP_PAGESIZE != 0) - return DEFAULT_THP_PAGESIZE; - int fd = __open64_nocancel ( "/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", O_RDONLY); if (fd == -1) @@ -50,13 +47,13 @@ __malloc_default_thp_pagesize (void) return r; } -enum malloc_thp_mode_t -__malloc_thp_mode (void) +enum thp_mode_t +__get_thp_mode (void) { int fd = __open64_nocancel ("/sys/kernel/mm/transparent_hugepage/enabled", O_RDONLY); if (fd == -1) - return malloc_thp_mode_not_supported; + return thp_mode_not_supported; static const char mode_always[] = "[always] madvise never\n"; static const char mode_madvise[] = "always [madvise] never\n"; @@ -65,24 +62,26 @@ __malloc_thp_mode (void) char str[sizeof(mode_always)]; ssize_t s = __read_nocancel (fd, str, sizeof (str)); if (s >= sizeof str || s < 0) - return malloc_thp_mode_not_supported; + return thp_mode_not_supported; str[s] = '\0'; __close_nocancel (fd); if (s == sizeof (mode_always) - 1) { if (strcmp (str, mode_always) == 0) - return malloc_thp_mode_always; + return thp_mode_always; else if (strcmp (str, mode_madvise) == 0) - return malloc_thp_mode_madvise; + return thp_mode_madvise; else if (strcmp (str, mode_never) == 0) - return malloc_thp_mode_never; + return thp_mode_never; } - return malloc_thp_mode_not_supported; + return thp_mode_not_supported; } +#if !IS_IN (rtld) + static size_t -malloc_default_hugepage_size (void) +get_default_hugepage_size (void) { int fd = __open64_nocancel ("/proc/meminfo", O_RDONLY); if (fd == -1) @@ -136,14 +135,14 @@ hugepage_flags (size_t pagesize) } void -__malloc_hugepage_config (size_t requested, size_t *pagesize, int *flags) +__get_hugepage_config (size_t requested, size_t *pagesize, int *flags) { *pagesize = 0; *flags = 0; if (requested == 0) { - *pagesize = malloc_default_hugepage_size (); + *pagesize = get_default_hugepage_size (); if (*pagesize != 0) *flags = hugepage_flags (*pagesize); return; @@ -205,3 +204,5 @@ __malloc_hugepage_config (size_t requested, size_t *pagesize, int *flags) __close_nocancel (dirfd); } + +#endif /* !IS_IN(rtld) */