[COMMITTED 2.39 1/3] malloc/Makefile: Split and sort tests

[COMMITTED 2.39 1/3] malloc/Makefile: Split and sort tests

[Arjun Shankar]

From: "H.J. Lu" <hjl.tools@gmail.com>

Put each test on a separate line and sort tests.

Signed-off-by: H.J. Lu <hjl.tools@gmail.com>
Reviewed-by: Carlos O'Donell <carlos@redhat.com>
(cherry picked from commit d49cd6a1913da9744b9a0ffbefb3f7958322382e)
---
 malloc/Makefile | 166 +++++++++++++++++++++++++++++-------------------
 1 file changed, 102 insertions(+), 64 deletions(-)

diff --git a/malloc/Makefile b/malloc/Makefile
index c83ade5f10..77ba1a9109 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -24,60 +24,92 @@ include ../Makeconfig
 
 dist-headers := malloc.h
 headers := $(dist-headers) obstack.h mcheck.h
-tests := mallocbug tst-malloc tst-valloc tst-calloc tst-obstack \
-	 tst-malloc-check tst-mallocfork tst-trim1 \
-	 tst-malloc-usable tst-realloc tst-reallocarray tst-posix_memalign \
-	 tst-pvalloc tst-pvalloc-fortify tst-memalign tst-mallopt \
-	 tst-malloc-backtrace tst-malloc-thread-exit \
-	 tst-malloc-thread-fail tst-malloc-fork-deadlock \
-	 tst-mallocfork2 \
-	 tst-mallocfork3 \
-	 tst-interpose-nothread \
-	 tst-interpose-thread \
-	 tst-alloc_buffer \
-	 tst-free-errno \
-	 tst-malloc-tcache-leak \
-	 tst-malloc_info tst-mallinfo2 \
-	 tst-malloc-too-large \
-	 tst-malloc-stats-cancellation \
-	 tst-tcfree1 tst-tcfree2 tst-tcfree3 \
-	 tst-safe-linking \
-	 tst-mallocalign1 \
-	 tst-memalign-2 \
-	 tst-memalign-3 \
-	 tst-aligned-alloc
+tests := \
+  mallocbug \
+  tst-aligned-alloc \
+  tst-alloc_buffer \
+  tst-calloc \
+  tst-free-errno \
+  tst-interpose-nothread \
+  tst-interpose-thread \
+  tst-malloc \
+  tst-malloc-backtrace \
+  tst-malloc-check \
+  tst-malloc-fork-deadlock \
+  tst-malloc-stats-cancellation \
+  tst-malloc-tcache-leak \
+  tst-malloc-thread-exit \
+  tst-malloc-thread-fail \
+  tst-malloc-too-large \
+  tst-malloc-usable \
+  tst-malloc_info tst-mallinfo2 \
+  tst-mallocalign1 \
+  tst-mallocfork \
+  tst-mallocfork2 \
+  tst-mallocfork3 \
+  tst-mallopt \
+  tst-memalign \
+  tst-memalign-2 \
+  tst-memalign-3 \
+  tst-obstack \
+  tst-posix_memalign \
+  tst-pvalloc \
+  tst-pvalloc-fortify \
+  tst-realloc \
+  tst-reallocarray \
+  tst-safe-linking \
+  tst-tcfree1 tst-tcfree2 tst-tcfree3 \
+  tst-trim1 \
+  tst-valloc \
+# tests
 
 tests-static := \
-	 tst-interpose-static-nothread \
-	 tst-interpose-static-thread \
-	 tst-aligned-alloc-static
+  tst-aligned-alloc-static \
+  tst-interpose-static-nothread \
+  tst-interpose-static-thread \
+# tests-static
 
 # Test for the malloc_set_state symbol removed in glibc 2.25.
 ifeq ($(have-GLIBC_2.23)$(build-shared),yesyes)
-tests += tst-mallocstate tst-compathooks-off tst-compathooks-on
+tests += \
+  tst-compathooks-off \
+  tst-compathooks-on \
+  tst-mallocstate \
+# tests
 endif
 
 tests-internal := tst-scratch_buffer
 
 # The dynarray framework is only available inside glibc.
 tests-internal += \
-	 tst-dynarray \
-	 tst-dynarray-fail \
-	 tst-dynarray-at-fail \
+  tst-dynarray \
+  tst-dynarray-at-fail \
+  tst-dynarray-fail \
+# tests-internal
 
-tests += tst-malloc-usable-tunables tst-mxfast
+tests += \
+  tst-malloc-usable-tunables \
+  tst-mxfast \
+# tests
 
 tests += $(tests-static)
 test-srcs = tst-mtrace
 
 # These tests either are run with MALLOC_CHECK_=3 by default or do not work
 # with MALLOC_CHECK_=3 because they expect a specific failure.
-tests-exclude-malloc-check = tst-malloc-check tst-malloc-usable \
-	tst-mxfast tst-safe-linking \
-	tst-compathooks-off tst-compathooks-on tst-memalign-2 tst-memalign-3 \
-	tst-mallocfork2 \
-	tst-mallocfork3 \
-	tst-malloc-tcache-leak
+tests-exclude-malloc-check = \
+  tst-compathooks-off \
+  tst-compathooks-on \
+  tst-malloc-check \
+  tst-malloc-tcache-leak \
+  tst-malloc-usable \
+  tst-mallocfork2 \
+  tst-mallocfork3 \
+  tst-memalign-2 \
+  tst-memalign-3 \
+  tst-mxfast \
+  tst-safe-linking \
+# tests-exclude-malloc-check
 
 # Run all tests with MALLOC_CHECK_=3
 tests-malloc-check = $(filter-out $(tests-exclude-malloc-check) \
@@ -87,18 +119,19 @@ tests-malloc-check = $(filter-out $(tests-exclude-malloc-check) \
 # the Transparent Huge Pages support (1) or automatic huge page support (2).
 # We need exclude some tests that define the ENV vars.
 tests-exclude-hugetlb1 = \
-	tst-compathooks-off \
-	tst-compathooks-on \
-	tst-interpose-nothread \
-	tst-interpose-thread \
-	tst-interpose-static-nothread \
-	tst-interpose-static-thread \
-	tst-malloc-usable \
-	tst-malloc-usable-tunables \
-	tst-mallocstate \
-	tst-malloc-tcache-leak \
-	tst-mallocfork2 \
-	tst-mallocfork3
+  tst-compathooks-off \
+  tst-compathooks-on \
+  tst-interpose-nothread \
+  tst-interpose-static-nothread \
+  tst-interpose-static-thread \
+  tst-interpose-thread \
+  tst-malloc-tcache-leak \
+  tst-malloc-usable \
+  tst-malloc-usable-tunables \
+  tst-mallocfork2 \
+  tst-mallocfork3 \
+  tst-mallocstate \
+# tests-exclude-hugetlb1
 # The tst-free-errno relies on the used malloc page size to mmap an
 # overlapping region.
 tests-exclude-hugetlb2 = \
@@ -114,22 +147,25 @@ ifeq ($(have-GLIBC_2.23)$(build-shared),yesyes)
 # Tests that don't play well with mcheck.  They are either bugs in mcheck or
 # the tests expect specific internal behavior that is changed due to linking to
 # libmcheck.a.
-tests-exclude-mcheck = tst-mallocstate \
-	tst-safe-linking \
-	tst-malloc-backtrace \
-	tst-malloc-fork-deadlock \
-	tst-malloc-stats-cancellation \
-	tst-malloc-tcache-leak \
-	tst-malloc-thread-exit \
-	tst-malloc-thread-fail \
-	tst-malloc-usable-tunables \
-	tst-malloc_info \
-	tst-compathooks-off tst-compathooks-on \
-	tst-memalign-2 \
-	tst-memalign-3 \
-	tst-mxfast \
-	tst-mallocfork2 \
-	tst-mallocfork3
+tests-exclude-mcheck = \
+  tst-compathooks-off \
+  tst-compathooks-on \
+  tst-malloc-backtrace \
+  tst-malloc-fork-deadlock \
+  tst-malloc-stats-cancellation \
+  tst-malloc-tcache-leak \
+  tst-malloc-thread-exit \
+  tst-malloc-thread-fail \
+  tst-malloc-usable-tunables \
+  tst-malloc_info \
+  tst-mallocfork2 \
+  tst-mallocfork3 \
+  tst-mallocstate \
+  tst-memalign-2 \
+  tst-memalign-3 \
+  tst-mxfast \
+  tst-safe-linking \
+# tests-exclude-mcheck
 
 tests-mcheck = $(filter-out $(tests-exclude-mcheck) $(tests-static), $(tests))
 endif
@@ -159,10 +195,12 @@ extra-libs-others = $(extra-libs)
 extra-test-objs += \
   tst-interpose-aux-nothread.o \
   tst-interpose-aux-thread.o \
+# extra-test-objs
 
 test-extras = \
   tst-interpose-aux-nothread \
   tst-interpose-aux-thread \
+# test-extras
 
 libmemusage-routines = memusage
 libmemusage-inhibit-o = $(filter-out .os,$(object-suffixes))
-- 
2.45.0

[COMMITTED 2.39 2/3] malloc: Improve aligned_alloc and calloc test coverage.

[Arjun Shankar]

From: Joe Simmons-Talbott <josimmon@redhat.com>

Add a DSO (malloc/tst-aligned_alloc-lib.so) that can be used during
testing to interpose malloc with a call that randomly uses either
aligned_alloc, __libc_malloc, or __libc_calloc in the place of malloc.
Use LD_PRELOAD with the DSO to mirror malloc/tst-malloc.c testing as an
example in malloc/tst-malloc-random.c.  Add malloc/tst-aligned-alloc-random.c
as another example that does a number of malloc calls with randomly sized,
but limited to 0xffff, requests.

The intention is to be able to utilize existing malloc testing to ensure
that similar allocation APIs are also exposed to the same rigors.

Reviewed-by: DJ Delorie <dj@redhat.com>
(cherry picked from commit 3395157ff2b0657d70c36169156f67440205c8bf)
---
 malloc/Makefile                   | 12 ++++++
 malloc/tst-aligned-alloc-random.c | 43 ++++++++++++++++++
 malloc/tst-aligned_alloc-lib.c    | 72 +++++++++++++++++++++++++++++++
 malloc/tst-malloc-random.c        | 20 +++++++++
 malloc/tst-malloc.c               |  4 ++
 5 files changed, 151 insertions(+)
 create mode 100644 malloc/tst-aligned-alloc-random.c
 create mode 100644 malloc/tst-aligned_alloc-lib.c
 create mode 100644 malloc/tst-malloc-random.c

diff --git a/malloc/Makefile b/malloc/Makefile
index 77ba1a9109..c1a03f3cb0 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -27,6 +27,7 @@ headers := $(dist-headers) obstack.h mcheck.h
 tests := \
   mallocbug \
   tst-aligned-alloc \
+  tst-aligned-alloc-random \
   tst-alloc_buffer \
   tst-calloc \
   tst-free-errno \
@@ -36,6 +37,7 @@ tests := \
   tst-malloc-backtrace \
   tst-malloc-check \
   tst-malloc-fork-deadlock \
+  tst-malloc-random \
   tst-malloc-stats-cancellation \
   tst-malloc-tcache-leak \
   tst-malloc-thread-exit \
@@ -193,6 +195,7 @@ extra-libs-others = $(extra-libs)
 
 # Helper objects for some tests.
 extra-test-objs += \
+  tst-aligned_alloc-lib.so \
   tst-interpose-aux-nothread.o \
   tst-interpose-aux-thread.o \
 # extra-test-objs
@@ -202,6 +205,9 @@ test-extras = \
   tst-interpose-aux-thread \
 # test-extras
 
+modules-names = \
+  tst-aligned_alloc-lib
+
 libmemusage-routines = memusage
 libmemusage-inhibit-o = $(filter-out .os,$(object-suffixes))
 
@@ -408,3 +414,9 @@ tst-mallocstate-malloc-check-ENV = LD_PRELOAD=$(objpfx)libc_malloc_debug.so
 # libc_malloc_debug.so.
 $(objpfx)tst-mallocstate: $(objpfx)libc_malloc_debug.so
 $(objpfx)tst-mallocstate-malloc-check: $(objpfx)libc_malloc_debug.so
+
+$(objpfx)tst-aligned-alloc-random.out: $(objpfx)tst-aligned_alloc-lib.so
+$(objpfx)tst-malloc-random.out: $(objpfx)tst-aligned_alloc-lib.so
+
+tst-aligned-alloc-random-ENV = LD_PRELOAD=$(objpfx)tst-aligned_alloc-lib.so
+tst-malloc-random-ENV = LD_PRELOAD=$(objpfx)tst-aligned_alloc-lib.so
diff --git a/malloc/tst-aligned-alloc-random.c b/malloc/tst-aligned-alloc-random.c
new file mode 100644
index 0000000000..f2825ce38f
--- /dev/null
+++ b/malloc/tst-aligned-alloc-random.c
@@ -0,0 +1,43 @@
+/* Test for randomized malloc that calls aligned_alloc
+   Copyright (C) 2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <stdlib.h>
+#include <support/check.h>
+#include <time.h>
+
+static int
+do_test (void)
+{
+  void *p1;
+  int i;
+
+  srandom (time (NULL));
+
+  for (i = 0; i < 1024; i++)
+  {
+    size_t size = random () & 0xffff;
+
+    p1 = malloc (size);
+    TEST_VERIFY (p1 != NULL);
+  }
+
+  return 0;
+}
+
+
+#include <support/test-driver.c>
diff --git a/malloc/tst-aligned_alloc-lib.c b/malloc/tst-aligned_alloc-lib.c
new file mode 100644
index 0000000000..0205df5acf
--- /dev/null
+++ b/malloc/tst-aligned_alloc-lib.c
@@ -0,0 +1,72 @@
+/* Module used for improved aligned_alloc testing.
+   Copyright (C) 2024 Free Software Foundation, Inc.
+   Copyright The GNU Toolchain Authors.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If
+   not, see <https://www.gnu.org/licenses/>.  */
+
+#include <array_length.h>
+#include <libc-symbols.h>
+#include <stdlib.h>
+
+extern void *__libc_malloc (size_t size);
+extern void *__libc_calloc (size_t n, size_t size);
+
+int aligned_alloc_count = 0;
+int libc_malloc_count = 0;
+int libc_calloc_count = 0;
+
+/* Get a random alignment value.  Biased towards the smaller values.  Must be
+   a power of 2. */
+static size_t get_random_alignment (void)
+{
+  size_t aligns[] = {
+    1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384
+  };
+
+  return aligns[random () % array_length (aligns)];
+}
+
+static void *get_random_alloc (size_t size)
+{
+  void *retval;
+  size_t align;
+
+  switch (random() % 3)
+  {
+    case 1:
+      align = get_random_alignment ();
+      retval = aligned_alloc (align, size);
+      aligned_alloc_count++;
+      break;
+    case 2:
+      retval = __libc_calloc (1, size);
+      libc_calloc_count++;
+      break;
+    default:
+      retval = __libc_malloc (size);
+      libc_malloc_count++;
+      break;
+  }
+
+  return retval;
+}
+
+
+void * __random_malloc (size_t size)
+{
+  return get_random_alloc (size);
+}
+strong_alias (__random_malloc, malloc)
diff --git a/malloc/tst-malloc-random.c b/malloc/tst-malloc-random.c
new file mode 100644
index 0000000000..762b70c918
--- /dev/null
+++ b/malloc/tst-malloc-random.c
@@ -0,0 +1,20 @@
+/* Test malloc with random calls to aligned_alloc and calloc.
+
+   Copyright (C) 2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include "tst-malloc.c"
diff --git a/malloc/tst-malloc.c b/malloc/tst-malloc.c
index a7491d3d00..f7a6e4654c 100644
--- a/malloc/tst-malloc.c
+++ b/malloc/tst-malloc.c
@@ -18,7 +18,9 @@
 #include <errno.h>
 #include <malloc.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <libc-diag.h>
+#include <time.h>
 
 static int errors = 0;
 
@@ -35,6 +37,8 @@ do_test (void)
   void *p, *q;
   int save;
 
+  srandom (time (NULL));
+
   errno = 0;
 
   DIAG_PUSH_NEEDS_COMMENT;
-- 
2.45.0

[COMMITTED 2.39 3/3] malloc: New test to check malloc alternate path using memory obstruction

[Arjun Shankar]

From: sayan paul <saypaul@redhat.com>

The test aims to ensure that malloc uses the alternate path to
allocate memory when sbrk() or brk() fails.To achieve this,
the test first creates an obstruction at current program break,
tests that obstruction with a failing sbrk(), then checks if malloc
is still returning a valid ptr thus inferring that malloc() used
mmap() instead of brk() or sbrk() to allocate the memory.
Reviewed-by: Arjun Shankar <arjun@redhat.com>
Reviewed-by: Zack Weinberg <zack@owlfolio.org>

(cherry picked from commit 127fc56152347d73cb7c1c283e60e1cb1f15e9f9)
---
 malloc/Makefile                    |  1 +
 malloc/tst-malloc-alternate-path.c | 72 ++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 malloc/tst-malloc-alternate-path.c

diff --git a/malloc/Makefile b/malloc/Makefile
index c1a03f3cb0..cc14cf66c9 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -34,6 +34,7 @@ tests := \
   tst-interpose-nothread \
   tst-interpose-thread \
   tst-malloc \
+  tst-malloc-alternate-path \
   tst-malloc-backtrace \
   tst-malloc-check \
   tst-malloc-fork-deadlock \
diff --git a/malloc/tst-malloc-alternate-path.c b/malloc/tst-malloc-alternate-path.c
new file mode 100644
index 0000000000..43ae916815
--- /dev/null
+++ b/malloc/tst-malloc-alternate-path.c
@@ -0,0 +1,72 @@
+/* Test that malloc uses mmap when sbrk or brk fails.
+   Copyright (C) 2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* This test sets up an obstruction to ensure that brk/sbrk fails to
+   grow the heap, then verifies that malloc uses mmap for allocations
+   instead.  */
+
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <libc-pointer-arith.h>
+#include <support/check.h>
+#include <stddef.h>
+#include <stdalign.h>
+
+#define LARGE_SIZE (10 * (1 << 20)) // 10 MB
+static long page_size;
+
+static int
+do_test (void)
+{
+  /* Get current program break.  */
+  void *current_brk = sbrk (0);
+
+  page_size = sysconf (_SC_PAGESIZE);
+
+  /* Round up to the next page boundary.  */
+  void *next_page_boundary = PTR_ALIGN_UP (current_brk, page_size);
+
+  /* Place a mapping using mmap at the next page boundary.  */
+  void *obstruction_addr
+  = mmap (next_page_boundary, page_size, PROT_READ,
+    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+
+  /* Check if memory obstruction is set up correctly.  */
+  TEST_VERIFY_EXIT (obstruction_addr == next_page_boundary);
+
+  /* Try to extend the heap beyond the obstruction using sbrk */
+  int *ptr = sbrk (page_size);
+  TEST_VERIFY_EXIT (ptr == (void *) -1);
+
+  /* Attempt multiple small allocations using malloc.  */
+  for (size_t i = 0; i < page_size / alignof (max_align_t); i++)
+    {
+      TEST_VERIFY (malloc (alignof (max_align_t)));
+    }
+
+  /* Attempt to allocate a large block of memory using malloc.  */
+  TEST_VERIFY_EXIT (malloc (LARGE_SIZE) != NULL);
+
+  /* Check if malloc changed current program break.  */
+  TEST_VERIFY_EXIT (current_brk == sbrk (0));
+
+  return 0;
+}
+
+#include <support/test-driver.c>
-- 
2.45.0