diff --git a/glibc-RHEL-50101-1.patch b/glibc-RHEL-50101-1.patch new file mode 100644 index 0000000..eb722e3 --- /dev/null +++ b/glibc-RHEL-50101-1.patch @@ -0,0 +1,240 @@ +commit 3395157ff2b0657d70c36169156f67440205c8bf +Author: Joe Simmons-Talbott +Date: Tue May 14 14:36:50 2024 +0000 + + malloc: Improve aligned_alloc and calloc test coverage. + + 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 + +Conflicts: + malloc/Makefile + (usual tests conflict) + +diff --git a/malloc/Makefile b/malloc/Makefile +index cb4e027d28b179f0..e0fb433a15bad2c2 100644 +--- a/malloc/Makefile ++++ b/malloc/Makefile +@@ -44,6 +44,8 @@ tests := mallocbug tst-malloc tst-valloc tst-calloc tst-obstack \ + tst-safe-linking \ + tst-mallocalign1 \ + tst-malloc-alternate-path \ ++ tst-aligned-alloc-random \ ++ tst-malloc-random \ + + tests-static := \ + tst-interpose-static-nothread \ +@@ -123,6 +125,7 @@ extra-libs-others = $(extra-libs) + + # Helper objects for some tests. + extra-tests-objs += \ ++ tst-aligned_alloc-lib.so \ + tst-interpose-aux-nothread.o \ + tst-interpose-aux-thread.o \ + +@@ -130,6 +133,9 @@ test-extras = \ + tst-interpose-aux-nothread \ + tst-interpose-aux-thread \ + ++modules-names = \ ++ tst-aligned_alloc-lib ++ + libmemusage-routines = memusage + libmemusage-inhibit-o = $(filter-out .os,$(object-suffixes)) + +@@ -328,3 +334,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 0000000000000000..f2825ce38f04e04e +--- /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 ++ . */ ++ ++#include ++#include ++#include ++ ++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 +diff --git a/malloc/tst-aligned_alloc-lib.c b/malloc/tst-aligned_alloc-lib.c +new file mode 100644 +index 0000000000000000..0205df5acf6297a5 +--- /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 . */ ++ ++#include ++#include ++#include ++ ++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 0000000000000000..762b70c918cc6004 +--- /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 ++ . */ ++ ++#include "tst-malloc.c" +diff --git a/malloc/tst-malloc.c b/malloc/tst-malloc.c +index a587cbded66039fb..98be3ee254d75d4e 100644 +--- a/malloc/tst-malloc.c ++++ b/malloc/tst-malloc.c +@@ -19,7 +19,9 @@ + #include + #include + #include ++#include + #include ++#include + + static int errors = 0; + +@@ -36,6 +38,8 @@ do_test (void) + void *p, *q; + int save; + ++ srandom (time (NULL)); ++ + errno = 0; + + DIAG_PUSH_NEEDS_COMMENT; diff --git a/glibc-RHEL-50101-2.patch b/glibc-RHEL-50101-2.patch new file mode 100644 index 0000000..318a037 --- /dev/null +++ b/glibc-RHEL-50101-2.patch @@ -0,0 +1,86 @@ +commit 9a27b566b2048f599048f2f4afe1cce06c4ef43d +Author: Miguel Martín +Date: Tue Jul 16 17:14:56 2024 +0200 + + malloc: avoid global locks in tst-aligned_alloc-lib.c + + Make sure the DSO used by aligned_alloc/calloc/malloc tests does not get + a global lock on multithreaded tests. + Reviewed-by: Arjun Shankar + +diff --git a/malloc/tst-aligned_alloc-lib.c b/malloc/tst-aligned_alloc-lib.c +index 0205df5acf6297a5..9ef1f839c101a6ae 100644 +--- a/malloc/tst-aligned_alloc-lib.c ++++ b/malloc/tst-aligned_alloc-lib.c +@@ -17,37 +17,38 @@ + License along with the GNU C Library; see the file COPYING.LIB. If + not, see . */ + +-#include + #include + #include ++#include + + extern void *__libc_malloc (size_t size); + extern void *__libc_calloc (size_t n, size_t size); + ++__thread unsigned int seed = 0; ++ + 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) ++static void * ++get_random_alloc (size_t size) + { + void *retval; + size_t align; ++ struct timespec tp; ++ ++ if (seed == 0) ++ { ++ clock_gettime (CLOCK_REALTIME, &tp); ++ seed = tp.tv_nsec; ++ } + +- switch (random() % 3) +- { ++ switch (rand_r (&seed) % 3) ++ { + case 1: +- align = get_random_alignment (); ++ /* Get a random alignment value. Biased towards the smaller ++ * values up to 16384. Must be a power of 2. */ ++ align = 1 << rand_r (&seed) % 15; + retval = aligned_alloc (align, size); + aligned_alloc_count++; + break; +@@ -59,13 +60,13 @@ static void *get_random_alloc (size_t size) + retval = __libc_malloc (size); + libc_malloc_count++; + break; +- } ++ } + + return retval; + } + +- +-void * __random_malloc (size_t size) ++void * ++__random_malloc (size_t size) + { + return get_random_alloc (size); + } diff --git a/glibc-RHEL-50101-3.patch b/glibc-RHEL-50101-3.patch new file mode 100644 index 0000000..49c6e28 --- /dev/null +++ b/glibc-RHEL-50101-3.patch @@ -0,0 +1,251 @@ +commit b0fbcb7d0051a68baf26b2aed51a8a31c34d68e5 +Author: Miguel Martín +Date: Tue Jul 16 17:14:57 2024 +0200 + + malloc: add multi-threaded tests for aligned_alloc/calloc/malloc + + Improve aligned_alloc/calloc/malloc test coverage by adding + multi-threaded tests with random memory allocations and with/without + cross-thread memory deallocations. + + Perform a number of memory allocation calls with random sizes limited + to 0xffff. + + Use the existing DSO ('malloc/tst-aligned_alloc-lib.c') to randomize + allocator selection. + + The multi-threaded allocation/deallocation is staged as described below: + + - Stage 1: Half of the threads will be allocating memory and the + other half will be waiting for them to finish the allocation. + - Stage 2: Half of the threads will be allocating memory and the + other half will be deallocating memory. + - Stage 3: Half of the threads will be deallocating memory and the + second half waiting on them to finish. + + Add 'malloc/tst-aligned-alloc-random-thread.c' where each thread will + deallocate only the memory that was previously allocated by itself. + + Add 'malloc/tst-aligned-alloc-random-thread-cross.c' where each thread + will deallocate memory that was previously allocated by another thread. + + 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: Arjun Shankar + +Conflicts: + malloc/Makefile + (usual tests conflict) + +diff --git a/malloc/Makefile b/malloc/Makefile +index e0fb433a15bad2c2..9dc068f6b3a69caa 100644 +--- a/malloc/Makefile ++++ b/malloc/Makefile +@@ -46,6 +46,8 @@ tests := mallocbug tst-malloc tst-valloc tst-calloc tst-obstack \ + tst-malloc-alternate-path \ + tst-aligned-alloc-random \ + tst-malloc-random \ ++ tst-aligned-alloc-random-thread \ ++ tst-aligned-alloc-random-thread-cross \ + + tests-static := \ + tst-interpose-static-nothread \ +@@ -96,7 +98,9 @@ tests-exclude-mcheck = tst-mallocstate \ + tst-malloc-thread-fail \ + tst-malloc-usable-tunables \ + tst-malloc_info \ +- tst-compathooks-off tst-compathooks-on ++ tst-compathooks-off tst-compathooks-on \ ++ tst-aligned-alloc-random-thread \ ++ tst-aligned-alloc-random-thread-cross \ + + tests-mcheck = $(filter-out $(tests-exclude-mcheck) $(tests-static), $(tests)) + endif +@@ -336,7 +340,11 @@ $(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-aligned-alloc-random-thread.out: $(objpfx)tst-aligned_alloc-lib.so ++$(objpfx)tst-aligned-alloc-random-thread-cross.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-aligned-alloc-random-thread-ENV = LD_PRELOAD=$(objpfx)tst-aligned_alloc-lib.so ++tst-aligned-alloc-random-thread-cross-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-thread-cross.c b/malloc/tst-aligned-alloc-random-thread-cross.c +new file mode 100644 +index 0000000000000000..360ecc56ee7c8c06 +--- /dev/null ++++ b/malloc/tst-aligned-alloc-random-thread-cross.c +@@ -0,0 +1,19 @@ ++/* multi-threaded memory allocation and cross-thread deallocation test. ++ 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; see the file COPYING.LIB. If ++ not, see . */ ++#define CROSS_THREAD_DEALLOC ++#include "tst-aligned-alloc-random-thread.c" +diff --git a/malloc/tst-aligned-alloc-random-thread.c b/malloc/tst-aligned-alloc-random-thread.c +new file mode 100644 +index 0000000000000000..e95f79250abec85e +--- /dev/null ++++ b/malloc/tst-aligned-alloc-random-thread.c +@@ -0,0 +1,145 @@ ++/* multi-threaded memory allocation/deallocation test. ++ 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; see the file COPYING.LIB. If ++ not, see . */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#ifndef ITERATIONS ++# define ITERATIONS 16 ++#endif ++ ++#ifndef NUM_THREADS ++# define NUM_THREADS 8 ++#endif ++ ++#ifndef NUM_ALLOCATIONS ++# define NUM_ALLOCATIONS 2048 ++#endif ++ ++static pthread_barrier_t barrier; ++ ++__thread unsigned int seed; ++ ++typedef struct ++{ ++ int id; ++ pthread_t thread; ++} thread; ++ ++thread threads[NUM_THREADS]; ++ ++void *allocations[NUM_THREADS][NUM_ALLOCATIONS]; ++ ++void ++run_thread_dealloc (int id) ++{ ++ for (int i = 0; i < NUM_ALLOCATIONS; i++) ++ { ++ free (allocations[id][i]); ++ allocations[id][i] = NULL; ++ } ++} ++ ++void ++run_thread_alloc (int id) ++{ ++ size_t msb, size; ++ for (int i = 0; i < NUM_ALLOCATIONS; i++) ++ { ++ msb = 1 << rand_r (&seed) % 16; ++ size = msb + rand_r (&seed) % msb; ++ allocations[id][i] = malloc (size); ++ TEST_VERIFY_EXIT (allocations[id][i] != NULL); ++ } ++} ++ ++void * ++run_allocations (void *arg) ++{ ++ int id = *((int *) arg); ++ seed = time (NULL) + id; ++ ++ /* Stage 1: First half o the threads allocating memory and the second ++ * half waiting for them to finish ++ */ ++ if (id < NUM_THREADS / 2) ++ run_thread_alloc (id); ++ ++ xpthread_barrier_wait (&barrier); ++ ++ /* Stage 2: Half of the threads allocationg memory and the other ++ * half deallocating: ++ * - In the non cross-thread dealloc scenario the first half will be ++ * deallocating the memory allocated by themselves in stage 1 and the ++ * second half will be allocating memory. ++ * - In the cross-thread dealloc scenario the first half will continue ++ * to allocate memory and the second half will deallocate the memory ++ * allocated by the first half in stage 1. ++ */ ++ if (id < NUM_THREADS / 2) ++#ifndef CROSS_THREAD_DEALLOC ++ run_thread_dealloc (id); ++#else ++ run_thread_alloc (id + NUM_THREADS / 2); ++#endif ++ else ++#ifndef CROSS_THREAD_DEALLOC ++ run_thread_alloc (id); ++#else ++ run_thread_dealloc (id - NUM_THREADS / 2); ++#endif ++ ++ xpthread_barrier_wait (&barrier); ++ ++ // Stage 3: Second half of the threads deallocating and the first half ++ // waiting for them to finish. ++ if (id >= NUM_THREADS / 2) ++ run_thread_dealloc (id); ++ ++ return NULL; ++} ++ ++static int ++do_test (void) ++{ ++ xpthread_barrier_init (&barrier, NULL, NUM_THREADS); ++ ++ for (int i = 0; i < ITERATIONS; i++) ++ { ++ for (int t = 0; t < NUM_THREADS; t++) ++ { ++ threads[t].id = t; ++ threads[t].thread ++ = xpthread_create (NULL, run_allocations, &threads[t].id); ++ } ++ ++ for (int t = 0; t < NUM_THREADS; t++) ++ xpthread_join (threads[t].thread); ++ } ++ ++ return 0; ++} ++ ++#include diff --git a/glibc.spec b/glibc.spec index 2a7a74f..58c1232 100644 --- a/glibc.spec +++ b/glibc.spec @@ -157,7 +157,7 @@ end \ Summary: The GNU libc libraries Name: glibc Version: %{glibcversion} -Release: 118%{?dist} +Release: 119%{?dist} # In general, GPLv2+ is used by programs, LGPLv2+ is used for # libraries. @@ -844,6 +844,9 @@ Patch605: glibc-RHEL-25257-1.patch Patch606: glibc-RHEL-25257-2.patch Patch607: glibc-RHEL-46741-1.patch Patch608: glibc-RHEL-46741-2.patch +Patch609: glibc-RHEL-50101-1.patch +Patch610: glibc-RHEL-50101-2.patch +Patch611: glibc-RHEL-50101-3.patch ############################################################################## # Continued list of core "glibc" package information: @@ -3003,6 +3006,9 @@ update_gconv_modules_cache () %endif %changelog +* Tue Aug 06 2024 Arjun Shankar - 2.34-119 +- Add new tests for aligned_alloc (RHEL-50101) + * Tue Aug 06 2024 Arjun Shankar - 2.34-118 - manual: Improve documentation of putc, putwc, getc, and getwc (RHEL-46741)