diff --git a/glibc-RHEL-46733-1.patch b/glibc-RHEL-46733-1.patch new file mode 100644 index 0000000..acab115 --- /dev/null +++ b/glibc-RHEL-46733-1.patch @@ -0,0 +1,171 @@ +Partial backport (libio/Makefile, stdio-common/Makefile only) of: + +commit a7fe3e805d2ee128ac5f43b2a24201726d41cc04 +Author: Carlos O'Donell +Date: Wed Jun 19 11:48:05 2024 -0400 + + Fix conditionals on mtrace-based tests (bug 31892) + + The conditionals for several mtrace-based tests in catgets, elf, libio, + malloc, misc, nptl, posix, and stdio-common were incorrect leading to + test failures when bootstrapping glibc without perl. + + The correct conditional for mtrace-based tests requires three checks: + first checking for run-built-tests, then build-shared, and lastly that + PERL is not equal to "no" (missing perl). + Reviewed-by: Adhemerval Zanella + +Conflicts: + stdio-common/Makefile + (missing C2x tests tst-printf-binary, tst-printf-intn, + tst-printf-oct, missing test tst-vfprintf-width-i18n + in the downstream tree, but downstream backported + tst-ungetc-leak-mem earlier) + + +diff --git a/libio/Makefile b/libio/Makefile +index 418102c4c0d8c25a..2ef144268af98f34 100644 +--- a/libio/Makefile ++++ b/libio/Makefile +@@ -231,15 +231,28 @@ tst-bz22415-ENV = MALLOC_TRACE=$(objpfx)tst-bz22415.mtrace \ + tst-bz24228-ENV = MALLOC_TRACE=$(objpfx)tst-bz24228.mtrace \ + LD_PRELOAD=$(common-objpfx)/malloc/libc_malloc_debug.so + +-generated += test-fmemopen.mtrace test-fmemopen.check +-generated += tst-fdopen-seek-failure.mtrace tst-fdopen-seek-failure.check +-generated += tst-fopenloc.mtrace tst-fopenloc.check +-generated += tst-bz22415.mtrace tst-bz22415.check +- + aux := fileops genops stdfiles stdio strops + ++ifeq ($(run-built-tests),yes) ++ifeq ($(build-shared),yes) ++ifneq ($(PERL),no) ++generated += \ ++ test-fmemopen.check \ ++ test-fmemopen.mtrace \ ++ tst-bz22415.check \ ++ tst-bz22415.mtrace \ ++ tst-bz24228.check \ ++ tst-bz24228.mtrace \ ++ tst-fdopen-seek-failure.check \ ++ tst-fdopen-seek-failure.mtrace \ ++ tst-fopenloc.check \ ++ tst-fopenloc.mtrace \ ++ # generated ++endif ++endif ++endif ++ + ifeq ($(build-shared),yes) +-generated += tst-bz24228.mtrace tst-bz24228.check + aux += oldfileops oldstdfiles + endif + +@@ -250,16 +263,23 @@ shared-only-routines = oldiofopen oldiofdopen oldiofclose oldfileops \ + + ifeq ($(run-built-tests),yes) + tests-special += \ +- $(objpfx)test-fmemopen-mem.out \ + $(objpfx)test-freopen.out \ +- $(objpfx)tst-bz22415-mem.out \ +- $(objpfx)tst-fdopen-seek-failure-mem.out \ + # tests-special + ifeq (yes,$(build-shared)) + # Run tst-fopenloc-cmp.out and tst-openloc-mem.out only if shared + # library is enabled since they depend on tst-fopenloc.out. +-tests-special += $(objpfx)tst-fopenloc-cmp.out $(objpfx)tst-fopenloc-mem.out \ +- $(objpfx)tst-bz24228-mem.out ++tests-special += $(objpfx)tst-fopenloc-cmp.out ++ifeq ($(build-shared),yes) ++ifneq ($(PERL),no) ++tests-special += \ ++ $(objpfx)test-fmemopen-mem.out \ ++ $(objpfx)tst-bz22415-mem.out \ ++ $(objpfx)tst-bz24228-mem.out \ ++ $(objpfx)tst-fdopen-seek-failure-mem.out \ ++ $(objpfx)tst-fopenloc-mem.out \ ++ # tests-special ++endif ++endif + endif + + tests += \ +diff --git a/stdio-common/Makefile b/stdio-common/Makefile +index 1eaea991dd63e20c..bc314af0617e1647 100644 +--- a/stdio-common/Makefile ++++ b/stdio-common/Makefile +@@ -184,10 +184,6 @@ tests := \ + tst-perror \ + tst-popen \ + tst-popen2 \ +- tst-printf-bz18872 \ +- tst-printf-bz25691 \ +- tst-printf-fp-free \ +- tst-printf-fp-leak \ + tst-printf-round \ + tst-printfsz \ + tst-put-error \ +@@ -208,7 +204,6 @@ tests := \ + tst-unlockedio \ + tst-vfprintf-mbs-prec \ + tst-vfprintf-user-type \ +- tst-vfprintf-width-prec \ + tst-vfprintf-width-prec-alloc \ + tst-wc-printf \ + tstdiomisc \ +@@ -217,6 +212,20 @@ tests := \ + xbug \ + # tests + ++ifeq ($(run-built-tests),yes) ++ifeq (yes,$(build-shared)) ++ifneq ($(PERL),no) ++tests += \ ++ tst-printf-bz18872 \ ++ tst-printf-bz25691 \ ++ tst-printf-fp-free \ ++ tst-printf-fp-leak \ ++ tst-vfprintf-width-prec \ ++ # tests ++endif ++endif ++endif ++ + test-srcs = \ + tst-printf \ + tst-printfsz-islongdouble \ +@@ -225,15 +234,20 @@ test-srcs = \ + + ifeq ($(run-built-tests),yes) + tests-special += \ +- $(objpfx)tst-printf-bz18872-mem.out \ +- $(objpfx)tst-printf-bz25691-mem.out \ +- $(objpfx)tst-printf-fp-free-mem.out \ +- $(objpfx)tst-printf-fp-leak-mem.out \ + $(objpfx)tst-printf.out \ + $(objpfx)tst-printfsz-islongdouble.out \ + $(objpfx)tst-setvbuf1-cmp.out \ + $(objpfx)tst-unbputc.out \ + $(objpfx)tst-ungetc-leak-mem.out \ ++ # tests-special ++ ++ifeq (yes,$(build-shared)) ++ifneq ($(PERL),no) ++tests-special += \ ++ $(objpfx)tst-printf-bz18872-mem.out \ ++ $(objpfx)tst-printf-bz25691-mem.out \ ++ $(objpfx)tst-printf-fp-free-mem.out \ ++ $(objpfx)tst-printf-fp-leak-mem.out \ + $(objpfx)tst-vfprintf-width-prec-mem.out \ + # tests-special + +@@ -253,6 +267,8 @@ generated += \ + tst-vfprintf-width-prec-mem.out \ + tst-vfprintf-width-prec.mtrace \ + # generated ++endif ++endif + endif # $(run-built-tests) + + tests-special += $(objpfx)tst-errno-manual.out diff --git a/glibc-RHEL-46733-2.patch b/glibc-RHEL-46733-2.patch new file mode 100644 index 0000000..16a0bf4 --- /dev/null +++ b/glibc-RHEL-46733-2.patch @@ -0,0 +1,79 @@ +commit 3e4a01870ef9605ccf6475215a4b32aa86d5d206 +Author: Aaron Merey +Date: Thu Aug 29 12:02:25 2024 -0400 + + Test fclose on an unopened file. + + Add new file libio/tst-fclosed-unopened.c that tests whether fclose on + an unopened file returns EOF. + + Calling fclose on unopened files normally causes a use-after-free bug, + however the standard streams are an exception since they are not + deallocated by fclose. + + fclose returning EOF for unopened files is not part of the external + contract but there are dependancies on this behaviour. For example, + gnulib's close_stdout in lib/closeout.c. + + Tested for x86_64. + + Signed-off-by: Aaron Merey + +diff --git a/libio/Makefile b/libio/Makefile +index 2ef144268af98f34..f0ecb6b775a543af 100644 +--- a/libio/Makefile ++++ b/libio/Makefile +@@ -76,6 +76,7 @@ tests = \ + tst-eof \ + tst-ext \ + tst-ext2 \ ++ tst-fclose-unopened \ + tst-fdopen-seek-failure \ + tst-fgetc-after-eof \ + tst-fgetwc \ +diff --git a/libio/tst-fclose-unopened.c b/libio/tst-fclose-unopened.c +new file mode 100644 +index 0000000000000000..1f1cad042d8d72bf +--- /dev/null ++++ b/libio/tst-fclose-unopened.c +@@ -0,0 +1,40 @@ ++/* Test using fclose on an unopened file. ++ 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 ++ ++/* Verify that fclose on an unopened file returns EOF. This is not part ++ of the fclose external contract but there are dependancies on this ++ behaviour. */ ++ ++static int ++do_test (void) ++{ ++ TEST_COMPARE (fclose (stdin), 0); ++ ++ /* Attempt to close the unopened file and verify that EOF is returned. ++ Calling fclose on a file twice normally causes a use-after-free bug, ++ however the standard streams are an exception since they are not ++ deallocated by fclose. */ ++ TEST_COMPARE (fclose (stdin), EOF); ++ ++ return 0; ++} ++ ++#include diff --git a/glibc-RHEL-46733-3.patch b/glibc-RHEL-46733-3.patch new file mode 100644 index 0000000..753c87b --- /dev/null +++ b/glibc-RHEL-46733-3.patch @@ -0,0 +1,155 @@ +commit 35dc62de3d5d73a91d4ca8fa9799b510a34d170d +Author: Aaron Merey +Date: Thu Sep 19 09:53:23 2024 -0400 + + Add another test for fclose on an unopened file + + Add new file libio/tst-fclose-unopened2.c that tests whether fclose on an + unopened file returns EOF. + + This test differs from tst-fclose-unopened.c by ensuring the file's buffer + is allocated prior to double-fclose. A comment in tst-fclose-unopened.c + now clarifies that it is testing a file with an unallocated buffer. + + Calling fclose on unopened files normally causes a use-after-free bug, + however the standard streams are an exception since they are not + deallocated by fclose. + + Tested for x86_64. + + Reviewed-by: Carlos O'Donell + +diff --git a/libio/Makefile b/libio/Makefile +index f0ecb6b775a543af..8b2d8aaae563788b 100644 +--- a/libio/Makefile ++++ b/libio/Makefile +@@ -77,6 +77,7 @@ tests = \ + tst-ext \ + tst-ext2 \ + tst-fclose-unopened \ ++ tst-fclose-unopened2 \ + tst-fdopen-seek-failure \ + tst-fgetc-after-eof \ + tst-fgetwc \ +@@ -220,6 +221,9 @@ LDFLAGS-tst-bz24228 = -Wl,--version-script=tst-bz24228.map + + tst_wprintf2-ARGS = "Some Text" + ++tst-fclose-unopened2-ENV = \ ++ MALLOC_TRACE=$(objpfx)tst-fclose-unopened2.mtrace \ ++ LD_PRELOAD=$(common-objpfx)/malloc/libc_malloc_debug.so + test-fmemopen-ENV = MALLOC_TRACE=$(objpfx)test-fmemopen.mtrace \ + LD_PRELOAD=$(common-objpfx)/malloc/libc_malloc_debug.so + tst-fdopen-seek-failure-ENV = \ +@@ -244,6 +248,8 @@ generated += \ + tst-bz22415.mtrace \ + tst-bz24228.check \ + tst-bz24228.mtrace \ ++ tst-fclose-unopened2.check \ ++ tst-fclose-unopened2.mtrace \ + tst-fdopen-seek-failure.check \ + tst-fdopen-seek-failure.mtrace \ + tst-fopenloc.check \ +@@ -276,6 +282,7 @@ tests-special += \ + $(objpfx)test-fmemopen-mem.out \ + $(objpfx)tst-bz22415-mem.out \ + $(objpfx)tst-bz24228-mem.out \ ++ $(objpfx)tst-fclose-unopened2-mem.out \ + $(objpfx)tst-fdopen-seek-failure-mem.out \ + $(objpfx)tst-fopenloc-mem.out \ + # tests-special +@@ -363,6 +370,11 @@ $(objpfx)test-fmemopen-mem.out: $(objpfx)test-fmemopen.out + $(common-objpfx)malloc/mtrace $(objpfx)test-fmemopen.mtrace > $@; \ + $(evaluate-test) + ++$(objpfx)tst-fclose-unopened2-mem.out: $(objpfx)tst-fclose-unopened2.out ++ $(common-objpfx)malloc/mtrace \ ++ $(objpfx)tst-fclose-unopened2.mtrace > $@; \ ++ $(evaluate-test) ++ + $(objpfx)tst-fdopen-seek-failure-mem.out: $(objpfx)tst-fdopen-seek-failure.out + $(common-objpfx)malloc/mtrace \ + $(objpfx)tst-fdopen-seek-failure.mtrace > $@; \ +diff --git a/libio/tst-fclose-unopened.c b/libio/tst-fclose-unopened.c +index 1f1cad042d8d72bf..4fed2ffdfe8cf9b4 100644 +--- a/libio/tst-fclose-unopened.c ++++ b/libio/tst-fclose-unopened.c +@@ -19,9 +19,11 @@ + #include + #include + +-/* Verify that fclose on an unopened file returns EOF. This is not part +- of the fclose external contract but there are dependancies on this +- behaviour. */ ++/* Verify that fclose on an unopened file returns EOF. This test uses ++ a file with an unallocated buffer. ++ ++ This is not part of the fclose external contract but there are ++ dependencies on this behaviour. */ + + static int + do_test (void) +diff --git a/libio/tst-fclose-unopened2.c b/libio/tst-fclose-unopened2.c +new file mode 100644 +index 0000000000000000..1e99d9dc3d561b80 +--- /dev/null ++++ b/libio/tst-fclose-unopened2.c +@@ -0,0 +1,51 @@ ++/* Test using fclose on an unopened file. ++ 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 ++ ++/* Verify that fclose on an unopened file returns EOF. This test uses ++ a file with an allocated buffer. ++ ++ This is not part of the fclose external contract but there are ++ dependencies on this behaviour. */ ++ ++static int ++do_test (void) ++{ ++ mtrace (); ++ ++ /* Input file tst-fclose-unopened2.input has 6 bytes plus newline. */ ++ char buf[6]; ++ ++ /* Read from the file to ensure its internal buffer is allocated. */ ++ TEST_COMPARE (fread (buf, 1, sizeof (buf), stdin), sizeof (buf)); ++ ++ TEST_COMPARE (fclose (stdin), 0); ++ ++ /* Attempt to close the unopened file and verify that EOF is returned. ++ Calling fclose on a file twice normally causes a use-after-free bug, ++ however the standard streams are an exception since they are not ++ deallocated by fclose. */ ++ TEST_COMPARE (fclose (stdin), EOF); ++ ++ return 0; ++} ++ ++#include +diff --git a/libio/tst-fclose-unopened2.input b/libio/tst-fclose-unopened2.input +new file mode 100644 +index 0000000000000000..399f9ba41aff870b +--- /dev/null ++++ b/libio/tst-fclose-unopened2.input +@@ -0,0 +1 @@ ++fclose diff --git a/glibc.spec b/glibc.spec index e0cce6b..352b348 100644 --- a/glibc.spec +++ b/glibc.spec @@ -157,7 +157,7 @@ end \ Summary: The GNU libc libraries Name: glibc Version: %{glibcversion} -Release: 137%{?dist} +Release: 138%{?dist} # In general, GPLv2+ is used by programs, LGPLv2+ is used for # libraries. @@ -913,6 +913,9 @@ Patch674: glibc-RHEL-46724.patch Patch675: glibc-RHEL-66253-1.patch Patch676: glibc-RHEL-66253-2.patch Patch677: glibc-RHEL-66253-3.patch +Patch678: glibc-RHEL-46733-1.patch +Patch679: glibc-RHEL-46733-2.patch +Patch680: glibc-RHEL-46733-3.patch ############################################################################## # Continued list of core "glibc" package information: @@ -3072,6 +3075,9 @@ update_gconv_modules_cache () %endif %changelog +* Thu Nov 7 2024 Florian Weimer - 2.34-138 +- Add fclose testcases (RHEL-46733) + * Thu Nov 7 2024 Florian Weimer - 2.34-137 - Fix memory leak after fdopen seek failure (RHEL-66253)