upgrade to 2.23

Disable-hugepage-backed-malloc-if-__morecore-is-not-.patch

@@ -0,0 +1,261 @@
+From 959d74fd0fbbff310943096e15024a84e8f5cba4 Mon Sep 17 00:00:00 2001
+From: Matheus Castanho <msc@linux.ibm.com>
+Date: Thu, 12 Aug 2021 16:38:46 -0300
+Subject: [PATCH] Disable hugepage-backed malloc if __morecore is not available
+
+Starting with glibc 2.32, __morecore hook has been marked as deprecated, and was
+completely removed on glibc 2.34, which causes an undefined symbol error during
+the build of libhugetlbfs.
+
+Greater changes are needed in order to keep providing the same functionality
+with future versions of glibc (see issue #52). Meanwhile, we can disable
+hugepage-backed malloc setup if __morecore is not available so users can at
+least keep using the other features provided by the library.  Related tests are
+also conditionally disabled, and will show as SKIPPED if __morecore is not
+available.
+
+Tested on powerpc64le and x86_64 with glibc 2.34 and olders.
+
+Signed-off-by: Matheus Castanho <msc@linux.ibm.com>
+---
+ Makefile           |  6 +++++
+ morecore.c         |  8 ++++++
+ tests/run_tests.py | 67 +++++++++++++++++++++++++++++++++++++++-------
+ 3 files changed, 71 insertions(+), 10 deletions(-)
+
+diff --git a/Makefile b/Makefile
+index 8b73523..35e53e7 100644
+--- a/Makefile
++++ b/Makefile
+@@ -192,6 +192,12 @@ endif
+ endif
+ endif
+ 
++# glibc 2.34 removed __morecore, so it may not be available with recent versions
++HAS_MORECORE := $(shell /bin/echo -e '\#include <malloc.h>\nvoid * morecore_exists() { return &__morecore; }' | $(CC) -c -xc -o /dev/null - &> /dev/null && /bin/echo yes || /bin/echo no)
++ifeq ($(HAS_MORECORE),yes)
++CFLAGS += -DHAS_MORECORE
++endif
++
+ HEADERDIR = $(PREFIX)/include
+ LIBDIR32 = $(PREFIX)/$(LIB32)
+ LIBDIR64 = $(PREFIX)/$(LIB64)
+diff --git a/morecore.c b/morecore.c
+index 6563bbd..405c566 100644
+--- a/morecore.c
++++ b/morecore.c
+@@ -33,6 +33,13 @@
+ 
+ #include "libhugetlbfs_internal.h"
+ 
++#ifndef HAS_MORECORE
++void hugetlbfs_setup_morecore(void)
++{
++	INFO("Not setting up morecore because it's not available (see issue #52).\n");
++}
++#else
++
+ static int heap_fd;
+ 
+ static void *heapbase;
+@@ -381,3 +388,4 @@ void hugetlbfs_setup_morecore(void)
+ 	 * to mmap() if we run out of hugepages. */
+ 	mallopt(M_MMAP_MAX, 0);
+ }
++#endif /* HAS_MORECORE */
+diff --git a/tests/run_tests.py b/tests/run_tests.py
+index 018264d..871d04d 100755
+--- a/tests/run_tests.py
++++ b/tests/run_tests.py
+@@ -60,7 +60,7 @@ def snapshot_pool_state():
+         l.append((d, tuple(substate)))
+     return tuple(l)
+ 
+-def run_test_prog(bits, pagesize, cmd, **env):
++def run_test_prog(bits, pagesize, cmd, output='stdout', **env):
+     if paranoid_pool_check:
+         beforepool = snapshot_pool_state()
+         print("Pool state: %s" % str(beforepool))
+@@ -73,15 +73,17 @@ def run_test_prog(bits, pagesize, cmd, **env):
+         % (bits, bits, local_env.get("LD_LIBRARY_PATH", ""))
+     local_env["HUGETLB_DEFAULT_PAGE_SIZE"] = repr(pagesize)
+ 
++    popen_args = {'env' : local_env, output : subprocess.PIPE}
++
+     try:
+-        p = subprocess.Popen(cmd, env=local_env, stdout=subprocess.PIPE)
++        p = subprocess.Popen(cmd, **popen_args)
+         rc = p.wait()
+     except KeyboardInterrupt:
+         # Abort and mark this a strange test result
+         return (None, "")
+     except OSError as e:
+         return (-e.errno, "")
+-    out = p.stdout.read().decode().strip()
++    out = getattr(p, output).read().decode().strip()
+ 
+     if paranoid_pool_check:
+         afterpool = snapshot_pool_state()
+@@ -309,6 +311,33 @@ def check_linkhuge_tests():
+             okbits.add(bits)
+     return okbits
+ 
++def check_morecore_disabled():
++    """
++    Check if support for morecore is available.
++
++    Newer glibc versions (>= 2.34) removed the __morecore malloc hook, so tests
++    relying on that functionality will not work as expected, and should be
++    disabled.
++    """
++    global morecore_disabled, wordsizes, pagesizes
++
++    # Quick and dirty way to get a word and page size. Which one doesn't really
++    # matter in this case.
++    for wsz in wordsizes:
++        b = wsz
++        break
++    for psz in pagesizes:
++        p = psz
++        break
++
++    # Run an arbitrary program and check stderr for the "morecore disabled"
++    # message
++    (rc, out) = run_test_prog(b, p, "gethugepagesize", output='stderr',
++                              HUGETLB_MORECORE="yes",
++                              HUGETLB_VERBOSE="3")
++
++    morecore_disabled = "Not setting up morecore" in out
++
+ def print_cmd(pagesize, bits, cmd, env):
+     if env:
+         print(' '.join(['%s=%s' % (k, v) for k, v in env.items()]), end=" ")
+@@ -357,14 +386,17 @@ def skip_test(pagesize, bits, cmd, **env):
+     print_cmd(pagesize, bits, cmd, env)
+     print("SKIPPED")
+ 
+-def do_test(cmd, bits=None, **env):
++def do_test(cmd, bits=None, skip=False, **env):
+     """
+     Run a test case, testing each page size and each indicated word size.
+     """
+     if bits == None: bits = wordsizes
+     for p in pagesizes:
+         for b in (set(bits) & wordsizes_by_pagesize[p]):
+-            run_test(p, b, cmd, **env)
++            if skip:
++                skip_test(p, b, cmd, **env)
++            else:
++                run_test(p, b, cmd, **env)
+ 
+ def do_test_with_rlimit(rtype, limit, cmd, bits=None, **env):
+     """
+@@ -375,7 +407,7 @@ def do_test_with_rlimit(rtype, limit, cmd, bits=None, **env):
+     do_test(cmd, bits, **env)
+     resource.setrlimit(rtype, oldlimit)
+ 
+-def do_test_with_pagesize(pagesize, cmd, bits=None, **env):
++def do_test_with_pagesize(pagesize, cmd, bits=None, skip=False, **env):
+     """
+     Run a test case, testing with a specified huge page size and
+     each indicated word size.
+@@ -383,7 +415,10 @@ def do_test_with_pagesize(pagesize, cmd, bits=None, **env):
+     if bits == None:
+         bits = wordsizes
+     for b in (set(bits) & wordsizes_by_pagesize[pagesize]):
+-        run_test(pagesize, b, cmd, **env)
++        if skip:
++            skip_test(pagesize, b, cmd, **env)
++        else:
++            run_test(pagesize, b, cmd, **env)
+ 
+ def do_elflink_test(cmd, **env):
+     """
+@@ -533,7 +568,7 @@ def functional_tests():
+     """
+     Run the set of functional tests.
+     """
+-    global linkhuge_wordsizes
++    global linkhuge_wordsizes, morecore_disabled
+ 
+     # Kernel background tests not requiring hugepage support
+     do_test("zero_filesize_segment")
+@@ -598,19 +633,24 @@ def functional_tests():
+     do_test("fork-cow")
+     do_test("direct")
+     do_test_with_pagesize(system_default_hpage_size, "malloc")
++
+     do_test_with_pagesize(system_default_hpage_size, "malloc",
++                          skip=morecore_disabled,
+                           LD_PRELOAD="libhugetlbfs.so",
+                           HUGETLB_MORECORE="yes")
+     do_test_with_pagesize(system_default_hpage_size, "malloc",
++                          skip=morecore_disabled,
+                           LD_PRELOAD="libhugetlbfs.so",
+                           HUGETLB_MORECORE="yes",
+                           HUGETLB_RESTRICT_EXE="unknown:none")
+     do_test_with_pagesize(system_default_hpage_size, "malloc",
++                          skip=morecore_disabled,
+                           LD_PRELOAD="libhugetlbfs.so",
+                           HUGETLB_MORECORE="yes",
+                           HUGETLB_RESTRICT_EXE="unknown:malloc")
+     do_test_with_pagesize(system_default_hpage_size, "malloc_manysmall")
+     do_test_with_pagesize(system_default_hpage_size, "malloc_manysmall",
++                          skip=morecore_disabled,
+                           LD_PRELOAD="libhugetlbfs.so",
+                           HUGETLB_MORECORE="yes")
+ 
+@@ -630,26 +670,32 @@ def functional_tests():
+     do_test_with_pagesize(system_default_hpage_size, "heapshrink",
+                           GLIBC_TUNABLES="glibc.malloc.tcache_count=0",
+                           LD_PRELOAD="libheapshrink.so")
++
+     do_test_with_pagesize(system_default_hpage_size, "heapshrink",
++                          skip=morecore_disabled,
+                           GLIBC_TUNABLES="glibc.malloc.tcache_count=0",
+                           LD_PRELOAD="libhugetlbfs.so",
+                           HUGETLB_MORECORE="yes")
+     do_test_with_pagesize(system_default_hpage_size, "heapshrink",
++                          skip=morecore_disabled,
+                           GLIBC_TUNABLES="glibc.malloc.tcache_count=0",
+                           LD_PRELOAD="libhugetlbfs.so libheapshrink.so",
+                           HUGETLB_MORECORE="yes")
+     do_test_with_pagesize(system_default_hpage_size, "heapshrink",
++                          skip=morecore_disabled,
+                           GLIBC_TUNABLES="glibc.malloc.tcache_count=0",
+                           LD_PRELOAD="libheapshrink.so",
+                           HUGETLB_MORECORE="yes",
+                           HUGETLB_MORECORE_SHRINK="yes")
+     do_test_with_pagesize(system_default_hpage_size, "heapshrink",
++                          skip=morecore_disabled,
+                           GLIBC_TUNABLES="glibc.malloc.tcache_count=0",
+                           LD_PRELOAD="libhugetlbfs.so libheapshrink.so",
+                           HUGETLB_MORECORE="yes",
+                           HUGETLB_MORECORE_SHRINK="yes")
+ 
+-    do_test("heap-overflow", HUGETLB_VERBOSE="1", HUGETLB_MORECORE="yes")
++    do_test("heap-overflow", skip=morecore_disabled, HUGETLB_VERBOSE="1",
++            HUGETLB_MORECORE="yes")
+ 
+     # Run the remapping tests' up-front checks
+     linkhuge_wordsizes = check_linkhuge_tests()
+@@ -747,7 +793,7 @@ def print_help():
+ 
+ def main():
+     global wordsizes, pagesizes, dangerous, paranoid_pool_check, system_default_hpage_size
+-    global custom_ldscripts
++    global custom_ldscripts, morecore_disabled
+     testsets = set()
+     env_override = {"QUIET_TEST": "1", "HUGETLBFS_MOUNTS": "",
+                     "HUGETLB_ELFMAP": None, "HUGETLB_MORECORE": None}
+@@ -802,6 +848,7 @@ def main():
+         return 1
+ 
+     check_hugetlbfs_path()
++    check_morecore_disabled()
+ 
+     if "func" in testsets: functional_tests()
+     if "stress" in testsets: stress_tests()
+-- 
+2.23.0.windows.1
+

libhugetlbfs.spec

@@ -1,19 +1,20 @@
 %global ldscriptdir %{_datadir}/%{name}/ldscripts
 
 Name: 		libhugetlbfs
-Version: 	2.22
-Release: 	2
+Version: 	2.23
+Release: 	1
 Summary: 	A library which provides easy access to huge pages of memory
 License: 	LGPLv2+
 URL: 		https://github.com/libhugetlbfs/libhugetlbfs
 Source0: 	https://github.com/libhugetlbfs/libhugetlbfs/releases/download/%{version}/%{name}-%{version}.tar.gz
 
-Patch0000: 	0000-build_flags.patch
+Patch0:	0000-build_flags.patch
+Patch1: Disable-hugepage-backed-malloc-if-__morecore-is-not-.patch
 
-Patch9000:libhugetlbfs-2.16-remap_segments_with_MAP_SHARED.patch
-Patch9001:libhugetlbfs-2.16-remap_segments_with_MAP_SHARED-2.patch
+#Patch9000:libhugetlbfs-2.16-remap_segments_with_MAP_SHARED.patch
+#Patch9001:libhugetlbfs-2.16-remap_segments_with_MAP_SHARED-2.patch
 Patch9002:libhugetlbfs-make-cflags.patch
-Patch9003:libhugetlbfs-fix-max-segment-cannot-adopt-the-x86.patch
+#Patch9003:libhugetlbfs-fix-max-segment-cannot-adopt-the-x86.patch
 
 BuildRequires: 	gcc glibc-devel glibc-static
 
@@ -85,6 +86,9 @@ touch $RPM_BUILD_ROOT%{_sysconfdir}/security/limits.d/hugepages.conf
 
 
 %changelog
+* Tue Nov 16 2021 Qingqing Li <liqingqing3@huawei.com> - 2.23-1
+- upgrade to 2.23
+
 * Tue Dec 15 2020 wuxu<wuxu.wu@hotmail.com> - 2.22-2
 - Type:enhancement
 - ID:NA