diff options
49 files changed, 1601 insertions, 265 deletions
@@ -488,31 +488,14 @@ build the GNU C Library: As of release time, GNU 'make' 4.4.1 is the newest verified to work to build the GNU C Library. - * GCC 6.2 or newer + * GCC 12.1 or newer - GCC 6.2 or higher is required. In general it is recommended to use - the newest version of the compiler that is known to work for + GCC 12.1 or higher is required. In general it is recommended to + use the newest version of the compiler that is known to work for building the GNU C Library, as newer compilers usually produce better code. As of release time, GCC 14.2.1 is the newest compiler verified to work to build the GNU C Library. - For PowerPC 64-bits little-endian (powerpc64le), a GCC version with - support for '-mno-gnu-attribute', '-mabi=ieeelongdouble', and - '-mabi=ibmlongdouble' is required. Likewise, the compiler must - also support passing '-mlong-double-128' with the preceding - options. As of release, this implies GCC 7.4 and newer (excepting - GCC 7.5.0, see GCC PR94200). These additional features are - required for building the GNU C Library with support for IEEE long - double. - - For ARC architecture builds, GCC 8.3 or higher is needed. - - For s390x architecture builds, GCC 7.1 or higher is needed (See gcc - Bug 98269). - - For AArch64 architecture builds with mathvec enabled, GCC 10 or - higher is needed due to dependency on arm_sve.h. - For multi-arch support it is recommended to use a GCC which has been built with support for GNU indirect functions. This ensures that correct debugging information is generated for functions @@ -5764,6 +5764,7 @@ if test $ac_verc_fail = yes; then fi +# Require GCC 12.1 to build. { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC is sufficient to build libc" >&5 printf %s "checking if $CC is sufficient to build libc... " >&6; } if test ${libc_cv_compiler_ok+y} @@ -5778,7 +5779,7 @@ int main (void) { -#if !defined __GNUC__ || __GNUC__ < 6 || (__GNUC__ == 6 && __GNUC_MINOR__ < 2) +#if !defined __GNUC__ || __GNUC__ < 12 || (__GNUC__ == 12 && __GNUC_MINOR__ < 1) #error insufficient compiler #endif ; diff --git a/configure.ac b/configure.ac index d068bb5..0b0d887 100644 --- a/configure.ac +++ b/configure.ac @@ -573,9 +573,10 @@ AC_CHECK_PROG_VER(BISON, bison, --version, [bison (GNU Bison) \([0-9]*\.[0-9.]*\)], [2.7*|[3-9].*|[1-9][0-9]*], critic_missing="$critic_missing bison") +# Require GCC 12.1 to build. AC_CACHE_CHECK([if $CC is sufficient to build libc], libc_cv_compiler_ok, [ AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[]], [[ -#if !defined __GNUC__ || __GNUC__ < 6 || (__GNUC__ == 6 && __GNUC_MINOR__ < 2) +#if !defined __GNUC__ || __GNUC__ < 12 || (__GNUC__ == 12 && __GNUC_MINOR__ < 1) #error insufficient compiler #endif]])], [libc_cv_compiler_ok=yes], diff --git a/elf/Makefile b/elf/Makefile index 1282a5b..250348c 100644 --- a/elf/Makefile +++ b/elf/Makefile @@ -3453,7 +3453,8 @@ $(objpfx)tst-dlopen-constructor-null-mod2.so: \ CFLAGS-tst-origin.c += $(no-stack-protector) CFLAGS-liborigin-mod.c += $(no-stack-protector) # Link tst-origin with liborigin-mod.so, but without a full path. -LDFLAGS-tst-origin += -Wl,-rpath,\$$ORIGIN -L$(subst :, -L,$(rpath-link)) -lorigin-mod +LDFLAGS-tst-origin += -Wl,-rpath,\$$ORIGIN -L$(subst :, -L,$(rpath-link)) +LDLIBS-tst-origin += -lorigin-mod $(objpfx)tst-origin: +nolink-deps += $(objpfx)liborigin-mod.so $(objpfx)tst-origin: $(objpfx)liborigin-mod.so $(objpfx)tst-origin.out: tst-origin.sh $(objpfx)tst-origin diff --git a/malloc/malloc.c b/malloc/malloc.c index 7e4c139..a0bc733 100644 --- a/malloc/malloc.c +++ b/malloc/malloc.c @@ -1325,6 +1325,9 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ static __always_inline size_t checked_request2size (size_t req) __nonnull (1) { + _Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2, + "PTRDIFF_MAX is not more than half of SIZE_MAX"); + if (__glibc_unlikely (req > PTRDIFF_MAX)) return 0; @@ -3380,26 +3383,17 @@ tcache_thread_shutdown (void) #endif /* !USE_TCACHE */ #if IS_IN (libc) -void * -__libc_malloc (size_t bytes) + +static void * __attribute_noinline__ +__libc_malloc2 (size_t bytes) { mstate ar_ptr; void *victim; - _Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2, - "PTRDIFF_MAX is not more than half of SIZE_MAX"); - if (!__malloc_initialized) ptmalloc_init (); -#if USE_TCACHE - bool err = tcache_try_malloc (bytes, &victim); - - if (err) - return NULL; - if (victim) - return tag_new_usable (victim); -#endif + MAYBE_INIT_TCACHE (); if (SINGLE_THREAD_P) { @@ -3430,6 +3424,19 @@ __libc_malloc (size_t bytes) ar_ptr == arena_for_chunk (mem2chunk (victim))); return victim; } + +void * +__libc_malloc (size_t bytes) +{ +#if USE_TCACHE + size_t tc_idx = csize2tidx (checked_request2size (bytes)); + + if (tcache_available (tc_idx)) + return tag_new_usable (tcache_get (tc_idx)); +#endif + + return __libc_malloc2 (bytes); +} libc_hidden_def (__libc_malloc) void diff --git a/manual/examples/longopt.c b/manual/examples/longopt.c index c679cd2..bf3857b 100644 --- a/manual/examples/longopt.c +++ b/manual/examples/longopt.c @@ -66,23 +66,23 @@ main (int argc, char **argv) break; case 'a': - puts ("option -a\n"); + puts ("option -a"); break; case 'b': - puts ("option -b\n"); + puts ("option -b"); break; case 'c': - printf ("option -c with value `%s'\n", optarg); + printf ("option -c with value '%s'\n", optarg); break; case 'd': - printf ("option -d with value `%s'\n", optarg); + printf ("option -d with value '%s'\n", optarg); break; case 'f': - printf ("option -f with value `%s'\n", optarg); + printf ("option -f with value '%s'\n", optarg); break; case '?': diff --git a/manual/install.texi b/manual/install.texi index d001e82..7fcdda9 100644 --- a/manual/install.texi +++ b/manual/install.texi @@ -530,32 +530,14 @@ As of release time, GNU @code{make} 4.4.1 is the newest verified to work to build @theglibc{}. @item -GCC 6.2 or newer +GCC 12.1 or newer -GCC 6.2 or higher is required. In general it is recommended to use +GCC 12.1 or higher is required. In general it is recommended to use the newest version of the compiler that is known to work for building @theglibc{}, as newer compilers usually produce better code. As of release time, GCC 14.2.1 is the newest compiler verified to work to build @theglibc{}. -For PowerPC 64-bits little-endian (powerpc64le), a GCC version with support -for @option{-mno-gnu-attribute}, @option{-mabi=ieeelongdouble}, and -@option{-mabi=ibmlongdouble} is required. Likewise, the compiler must also -support passing @option{-mlong-double-128} with the preceding options. As -of release, this implies GCC 7.4 and newer (excepting GCC 7.5.0, see GCC -PR94200). These additional features are required for building the GNU C -Library with support for IEEE long double. - -@c powerpc64le performs an autoconf test to verify the compiler compiles with -@c commands like "$CC -c foo.c -mabi=ibmlongdouble -mlong-double-128". - -For ARC architecture builds, GCC 8.3 or higher is needed. - -For s390x architecture builds, GCC 7.1 or higher is needed (See gcc Bug 98269). - -For AArch64 architecture builds with mathvec enabled, GCC 10 or higher is needed -due to dependency on arm_sve.h. - For multi-arch support it is recommended to use a GCC which has been built with support for GNU indirect functions. This ensures that correct debugging information is generated for functions selected by IFUNC resolvers. This diff --git a/manual/llio.texi b/manual/llio.texi index b6bc7f2..7b5f77b 100644 --- a/manual/llio.texi +++ b/manual/llio.texi @@ -1693,6 +1693,8 @@ existing map is unmapped. @c Which is which? @item MAP_ANONYMOUS @itemx MAP_ANON +@standards{POSIX.1-2024, sys/mman.h} +@standardsx{MAP_ANON, POSIX.1-2024, sys/mman.h} This flag tells the system to create an anonymous mapping, not connected to a file. @var{filedes} and @var{offset} are ignored, and the region is initialized with zeros. @@ -3639,11 +3641,14 @@ duplicate of @var{old}. @end deftypefun @deftypefun int dup3 (int @var{old}, int @var{new}, int @var{flags}) -@standards{Linux, unistd.h} +@standards{POSIX.1-2024, unistd.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This function is the same as @code{dup2} but creates the new descriptor as if it had been opened with flags @var{flags}. The only allowed flag is @code{O_CLOEXEC}. + +This function was originally a Linux extension, but was added in +POSIX.1-2024. @end deftypefun @deftypevr Macro int F_DUPFD diff --git a/manual/memory.texi b/manual/memory.texi index dc4621e..9a29c7d 100644 --- a/manual/memory.texi +++ b/manual/memory.texi @@ -842,8 +842,8 @@ is left undisturbed. @end deftypefun @deftypefun {void *} reallocarray (void *@var{ptr}, size_t @var{nmemb}, size_t @var{size}) -@standards{BSD, malloc.h} -@standards{BSD, stdlib.h} +@standards{POSIX.1-2024, malloc.h} +@standards{POSIX.1-2024, stdlib.h} @safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{} @acsfd{} @acsmem{}}} The @code{reallocarray} function changes the size of the block whose address @@ -856,8 +856,8 @@ returning a null pointer, and leaving the original block unchanged. @code{reallocarray} should be used instead of @code{realloc} when the new size of the allocated block is the result of a multiplication that might overflow. -@strong{Portability Note:} This function is not part of any standard. It was -first introduced in OpenBSD 5.6. +This function was originally derived from OpenBSD 5.6, but was added in +POSIX.1-2024. @end deftypefun Like @code{malloc}, @code{realloc} and @code{reallocarray} may return a null diff --git a/manual/message.texi b/manual/message.texi index ef68693..71b56e6 100644 --- a/manual/message.texi +++ b/manual/message.texi @@ -18,11 +18,11 @@ in separate files which are loaded at runtime depending on the language selection of the user. @Theglibc{} provides two different sets of functions to support -message translation. The problem is that neither of the interfaces is -officially defined by the POSIX standard. The @code{catgets} family of -functions is defined in the X/Open standard but this is derived from -industry decisions and therefore not necessarily based on reasonable -decisions. +message translation. The @code{catgets} family of functions were +previously the only family defined in the X/Open standard but they were +derived from industry decisions and therefore not necessarily based on +reasonable decisions. However, the preferable @code{gettext} family of +functions was standardized in POSIX-1.2024. As mentioned above, the message catalog handling provides easy extendability by using external data files which contain the message @@ -830,7 +830,7 @@ not part of the C library they can be found in a separate library named @file{libintl.a} (or accordingly different for shared libraries). @deftypefun {char *} gettext (const char *@var{msgid}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@asunsafe{@asucorrupt{} @ascuheap{} @asulock{} @ascudlopen{}}@acunsafe{@acucorrupt{} @aculock{} @acsfd{} @acsmem{}}} @c Wrapper for dcgettext. The @code{gettext} function searches the currently selected message @@ -878,7 +878,7 @@ currently selected default message catalog it must specify all ambiguous information. @deftypefun {char *} dgettext (const char *@var{domainname}, const char *@var{msgid}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@asunsafe{@asucorrupt{} @ascuheap{} @asulock{} @ascudlopen{}}@acunsafe{@acucorrupt{} @aculock{} @acsfd{} @acsmem{}}} @c Wrapper for dcgettext. The @code{dgettext} function acts just like the @code{gettext} @@ -893,7 +893,7 @@ anachronism. The returned string must never be modified. @end deftypefun @deftypefun {char *} dcgettext (const char *@var{domainname}, const char *@var{msgid}, int @var{category}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@asunsafe{@asucorrupt{} @ascuheap{} @asulock{} @ascudlopen{}}@acunsafe{@acucorrupt{} @aculock{} @acsfd{} @acsmem{}}} @c dcgettext @mtsenv @asucorrupt @ascuheap @asulock @ascudlopen @acucorrupt @aculock @acsfd @acsmem @c dcigettext @mtsenv @asucorrupt @ascuheap @asulock @ascudlopen @acucorrupt @aculock @acsfd @acsmem @@ -1112,7 +1112,7 @@ exactly one domain is active. This is controlled with the following function. @deftypefun {char *} textdomain (const char *@var{domainname}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{}@asunsafe{@asulock{} @ascuheap{}}@acunsafe{@aculock{} @acsmem{}}} @c textdomain @asulock @ascuheap @aculock @acsmem @c libc_rwlock_wrlock @asulock @aculock @@ -1149,7 +1149,7 @@ really never should be used. @end deftypefun @deftypefun {char *} bindtextdomain (const char *@var{domainname}, const char *@var{dirname}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{}@asunsafe{@ascuheap{}}@acunsafe{@acsmem{}}} @c bindtextdomain @ascuheap @acsmem @c set_binding_values @ascuheap @acsmem @@ -1271,7 +1271,7 @@ to be written in English, this solution nevertheless fulfills its purpose. @deftypefun {char *} ngettext (const char *@var{msgid1}, const char *@var{msgid2}, unsigned long int @var{n}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@asunsafe{@asucorrupt{} @ascuheap{} @asulock{} @ascudlopen{}}@acunsafe{@acucorrupt{} @aculock{} @acsfd{} @acsmem{}}} @c Wrapper for dcngettext. The @code{ngettext} function is similar to the @code{gettext} function @@ -1295,7 +1295,7 @@ Please note that the numeric value @var{n} has to be passed to the @end deftypefun @deftypefun {char *} dngettext (const char *@var{domain}, const char *@var{msgid1}, const char *@var{msgid2}, unsigned long int @var{n}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@asunsafe{@asucorrupt{} @ascuheap{} @asulock{} @ascudlopen{}}@acunsafe{@acucorrupt{} @aculock{} @acsfd{} @acsmem{}}} @c Wrapper for dcngettext. The @code{dngettext} is similar to the @code{dgettext} function in the @@ -1305,7 +1305,7 @@ parameters are handled in the same way @code{ngettext} handles them. @end deftypefun @deftypefun {char *} dcngettext (const char *@var{domain}, const char *@var{msgid1}, const char *@var{msgid2}, unsigned long int @var{n}, int @var{category}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@asunsafe{@asucorrupt{} @ascuheap{} @asulock{} @ascudlopen{}}@acunsafe{@acucorrupt{} @aculock{} @acsfd{} @acsmem{}}} @c Wrapper for dcigettext. The @code{dcngettext} is similar to the @code{dcgettext} function in the @@ -1562,7 +1562,7 @@ independently of the current output character set. It is therefore recommended that all @var{msgid}s be US-ASCII strings. @deftypefun {char *} bind_textdomain_codeset (const char *@var{domainname}, const char *@var{codeset}) -@standards{GNU, libintl.h} +@standards{POSIX-1.2024, libintl.h} @safety{@prelim{}@mtsafe{}@asunsafe{@ascuheap{}}@acunsafe{@acsmem{}}} @c bind_textdomain_codeset @ascuheap @acsmem @c set_binding_values dup @ascuheap @acsmem diff --git a/manual/pattern.texi b/manual/pattern.texi index 250fa1e..f2e8353 100644 --- a/manual/pattern.texi +++ b/manual/pattern.texi @@ -119,9 +119,12 @@ If this flag is set, either @samp{foo*} or @samp{foobar} as a pattern would match the string @samp{foobar/frobozz}. @item FNM_CASEFOLD -@standards{GNU, fnmatch.h} +@standards{POSIX.1-2024, fnmatch.h} Ignore case in comparing @var{string} to @var{pattern}. +This macro was originally a GNU extension, but was added in +POSIX.1-2024. + @item FNM_EXTMATCH @standards{GNU, fnmatch.h} @cindex Korn Shell diff --git a/manual/process.texi b/manual/process.texi index a8f37e5..609c78a 100644 --- a/manual/process.texi +++ b/manual/process.texi @@ -338,7 +338,7 @@ signals and signal actions from the parent process.) @end itemize @deftypefun pid_t _Fork (void) -@standards{GNU, unistd.h} +@standards{POSIX.1-2024, unistd.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} The @code{_Fork} function is similar to @code{fork}, but it does not invoke any callbacks registered with @code{pthread_atfork}, nor does it reset @@ -347,8 +347,9 @@ new subprocess, only async-signal-safe functions may be called, such as @code{dup2} or @code{execve}. The @code{_Fork} function is an async-signal-safe replacement of @code{fork}. -It is a GNU extension. +This function was originally a GNU extension, but was added in +POSIX.1-2024. @end deftypefun @deftypefun pid_t vfork (void) @@ -835,10 +836,13 @@ signal number of the signal that terminated the child process. @end deftypefn @deftypefn Macro int WCOREDUMP (int @var{status}) -@standards{BSD, sys/wait.h} +@standards{POSIX.1-2024, sys/wait.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This macro returns a nonzero value if the child process terminated and produced a core dump. + +This macro was originally a BSD extension, but was added in +POSIX.1-2024. @end deftypefn @deftypefn Macro int WIFSTOPPED (int @var{status}) diff --git a/manual/signal.texi b/manual/signal.texi index 842b4e4..7e21a93 100644 --- a/manual/signal.texi +++ b/manual/signal.texi @@ -803,7 +803,7 @@ The default action is to terminate the process. @end deftypevr @deftypevr Macro int SIGWINCH -@standards{BSD, signal.h} +@standards{POSIX.1-2024, signal.h} Window size change. This is generated on some systems (including GNU) when the terminal driver's record of the number of rows and columns on the screen is changed. The default action is to ignore it. @@ -811,6 +811,9 @@ the screen is changed. The default action is to ignore it. If a program does full-screen display, it should handle @code{SIGWINCH}. When the signal arrives, it should fetch the new screen size and reformat its display accordingly. + +This macro was originally a BSD extension, but was added in +POSIX.1-2024. @end deftypevr @deftypevr Macro int SIGINFO diff --git a/manual/startup.texi b/manual/startup.texi index 95b0ed8..6f29ddd 100644 --- a/manual/startup.texi +++ b/manual/startup.texi @@ -337,7 +337,7 @@ pointer. @end deftypefun @deftypefun {char *} secure_getenv (const char *@var{name}) -@standards{GNU, stdlib.h} +@standards{POSIX.1-2024, stdlib.h} @safety{@prelim{}@mtsafe{@mtsenv{}}@assafe{}@acsafe{}} @c Calls getenv unless secure mode is enabled. This function is similar to @code{getenv}, but it returns a null @@ -346,7 +346,8 @@ program file has SUID or SGID bits set. General-purpose libraries should always prefer this function over @code{getenv} to avoid vulnerabilities if the library is referenced from a SUID/SGID program. -This function is a GNU extension. +This function was originally a GNU extension, but was added in +POSIX.1-2024. @end deftypefun diff --git a/manual/string.texi b/manual/string.texi index 0b667bd..feba0b7 100644 --- a/manual/string.texi +++ b/manual/string.texi @@ -1081,7 +1081,7 @@ issues. @xref{Concatenating Strings}. @end deftypefun @deftypefun size_t strlcpy (char *restrict @var{to}, const char *restrict @var{from}, size_t @var{size}) -@standards{BSD, string.h} +@standards{POSIX-1.2024, string.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This function copies the string @var{from} to the destination array @var{to}, limiting the result's size (including the null terminator) @@ -1114,21 +1114,23 @@ processing strings. Also, this function has a performance issue, as its time cost is proportional to the length of @var{from} even when @var{size} is small. -This function is derived from OpenBSD 2.4. +This function was originally derived from OpenBSD 2.4, but was added in +POSIX.1-2024. @end deftypefun @deftypefun size_t wcslcpy (wchar_t *restrict @var{to}, const wchar_t *restrict @var{from}, size_t @var{size}) -@standards{BSD, string.h} +@standards{POSIX.1-2024, string.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This function is a variant of @code{strlcpy} for wide strings. The @var{size} argument counts the length of the destination buffer in wide characters (and not bytes). -This function is derived from BSD. +This function was originally a BSD extension, but was added in +POSIX.1-2024. @end deftypefun @deftypefun size_t strlcat (char *restrict @var{to}, const char *restrict @var{from}, size_t @var{size}) -@standards{BSD, string.h} +@standards{POSIX-1.2024, string.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This function appends the string @var{from} to the string @var{to}, limiting the result's total size (including the null @@ -1156,17 +1158,19 @@ As noted below, this function is generally a poor choice for processing strings. Also, this function has significant performance issues. @xref{Concatenating Strings}. -This function is derived from OpenBSD 2.4. +This function was originally derived from OpenBSD 2.4, but was added in +POSIX.1-2024. @end deftypefun @deftypefun size_t wcslcat (wchar_t *restrict @var{to}, const wchar_t *restrict @var{from}, size_t @var{size}) -@standards{BSD, string.h} +@standards{POSIX.1-2024, string.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This function is a variant of @code{strlcat} for wide strings. The @var{size} argument counts the length of the destination buffer in wide characters (and not bytes). -This function is derived from BSD. +This function was originally a BSD extension, but was added in +POSIX.1-2024. @end deftypefun Because these functions can abruptly truncate strings or wide strings, @@ -2008,14 +2012,15 @@ strcasestr ("hello, World", "wo") @deftypefun {void *} memmem (const void *@var{haystack}, size_t @var{haystack-len},@*const void *@var{needle}, size_t @var{needle-len}) -@standards{GNU, string.h} +@standards{POSIX.1-2024, string.h} @safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}} This is like @code{strstr}, but @var{needle} and @var{haystack} are byte arrays rather than strings. @var{needle-len} is the length of @var{needle} and @var{haystack-len} is the length of @var{haystack}. -This function is a GNU extension. +This function was originally a GNU extension, but was added in +POSIX.1-2024. @end deftypefun @deftypefun size_t strspn (const char *@var{string}, const char *@var{skipset}) diff --git a/manual/terminal.texi b/manual/terminal.texi index bdaee56..b437cb5 100644 --- a/manual/terminal.texi +++ b/manual/terminal.texi @@ -2107,7 +2107,7 @@ might be overwritten by subsequent calls to @code{ptsname}. @end deftypefun @deftypefun int ptsname_r (int @var{filedes}, char *@var{buf}, size_t @var{len}) -@standards{GNU, stdlib.h} +@standards{POSIX.1-2024, stdlib.h} @safety{@prelim{}@mtsafe{}@asunsafe{@ascuheap{/bsd}}@acunsafe{@acsmem{} @acsfd{}}} @c ptsname_r @ascuheap/bsd @acsmem @acsfd @c /hurd @@ -2143,7 +2143,8 @@ The @code{ptsname_r} function is similar to the @code{ptsname} function except that it places its result into the user-specified buffer starting at @var{buf} with length @var{len}. -This function is a GNU extension. +This function was originally a GNU extension, but was added in +POSIX.1-2024. @end deftypefun Typical usage of these functions is illustrated by the following example: diff --git a/manual/threads.texi b/manual/threads.texi index 7b9c796..67955e1 100644 --- a/manual/threads.texi +++ b/manual/threads.texi @@ -554,6 +554,8 @@ This section describes the @glibcadj{} POSIX Threads implementation. @menu * Thread-specific Data:: Support for creating and managing thread-specific data +* Waiting with Explicit Clocks:: Functions for waiting with an + explicit clock specification. * POSIX Semaphores:: Support for process and thread synchronization using semaphores * Non-POSIX Extensions:: Additional functions to extend @@ -617,6 +619,55 @@ Associate the thread-specific @var{value} with @var{key} in the calling thread. @end deftypefun +@node Waiting with Explicit Clocks +@subsection Functions for Waiting According to a Specific Clock + +@Theglibc{} provides several waiting functions that expect an explicit +@code{clockid_t} argument. These functions were all adopted by +POSIX.1-2024. + +@comment pthread.h +@deftypefun int pthread_cond_clockwait (pthread_cond_t *@var{cond}, pthread_mutex_t *@var{mutex}, clockid_t @var{clockid}, const struct timespec *@var{abstime}) +@standards{POSIX-1.2024, pthread.h} +@safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{}}} +@c If exactly the same function with arguments is called from a signal +@c handler that interrupts between the mutex unlock and sleep then it +@c will unlock the mutex twice resulting in undefined behaviour. Keep +@c in mind that the unlock and sleep are only atomic with respect to other +@c threads (really a happens-after relationship for pthread_cond_broadcast +@c and pthread_cond_signal). +@c In the AC case we would cancel the thread and the mutex would remain +@c locked and we can't recover from that. +Behaves like @code{pthread_cond_timedwait} except the time @var{abstime} is +measured against the clock specified by @var{clockid} rather than the clock +specified or defaulted when @code{pthread_cond_init} was called. Currently, +@var{clockid} must be either @code{CLOCK_MONOTONIC} or +@code{CLOCK_REALTIME}. +@end deftypefun + +@comment pthread.h +@deftypefun int pthread_rwlock_clockrdlock (pthread_rwlock_t *@var{rwlock}, clockid_t @var{clockid}, const struct timespec *@var{abstime}) +@standards{POSIX-1.2024, pthread.h} +@safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{}}} +Behaves like @code{pthread_rwlock_timedrdlock} except the time +@var{abstime} is measured against the clock specified by @var{clockid} +rather than @code{CLOCK_REALTIME}. Currently, @var{clockid} must be either +@code{CLOCK_MONOTONIC} or @code{CLOCK_REALTIME}, otherwise @code{EINVAL} is +returned. +@end deftypefun + +@comment pthread.h +@deftypefun int pthread_rwlock_clockwrlock (pthread_rwlock_t *@var{rwlock}, clockid_t @var{clockid}, const struct timespec *@var{abstime}) +@standards{POSIX-1.2024, pthread.h} +@safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{}}} +Behaves like @code{pthread_rwlock_timedwrlock} except the time +@var{abstime} is measured against the clock specified by @var{clockid} +rather than @code{CLOCK_REALTIME}. Currently, @var{clockid} must be either +@code{CLOCK_MONOTONIC} or @code{CLOCK_REALTIME}, otherwise @code{EINVAL} is +returned. +@end deftypefun + + @node POSIX Semaphores @subsection POSIX Semaphores @@ -729,8 +780,7 @@ the standard. * Default Thread Attributes:: Setting default attributes for threads in a process. * Initial Thread Signal Mask:: Setting the initial mask of threads. -* Waiting with Explicit Clocks:: Functions for waiting with an - explicit clock specification. +* Joining Threads:: Wait for a thread to terminate. * Single-Threaded:: Detecting single-threaded execution. * Restartable Sequences:: Linux-specific restartable sequences integration. @@ -849,52 +899,11 @@ signal mask and use @code{pthread_sigmask} to apply it to the thread. If the signal mask was copied to a heap allocation, the copy should be freed. -@node Waiting with Explicit Clocks -@subsubsection Functions for Waiting According to a Specific Clock - -@Theglibc{} provides several waiting functions that expect an explicit -@code{clockid_t} argument. +@node Joining Threads +@subsubsection Wait for a thread to terminate -@comment pthread.h -@comment POSIX-proposed -@deftypefun int pthread_cond_clockwait (pthread_cond_t *@var{cond}, pthread_mutex_t *@var{mutex}, clockid_t @var{clockid}, const struct timespec *@var{abstime}) -@safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{}}} -@c If exactly the same function with arguments is called from a signal -@c handler that interrupts between the mutex unlock and sleep then it -@c will unlock the mutex twice resulting in undefined behaviour. Keep -@c in mind that the unlock and sleep are only atomic with respect to other -@c threads (really a happens-after relationship for pthread_cond_broadcast -@c and pthread_cond_signal). -@c In the AC case we would cancel the thread and the mutex would remain -@c locked and we can't recover from that. -Behaves like @code{pthread_cond_timedwait} except the time @var{abstime} is -measured against the clock specified by @var{clockid} rather than the clock -specified or defaulted when @code{pthread_cond_init} was called. Currently, -@var{clockid} must be either @code{CLOCK_MONOTONIC} or -@code{CLOCK_REALTIME}. -@end deftypefun - -@comment pthread.h -@comment POSIX-proposed -@deftypefun int pthread_rwlock_clockrdlock (pthread_rwlock_t *@var{rwlock}, clockid_t @var{clockid}, const struct timespec *@var{abstime}) -@safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{}}} -Behaves like @code{pthread_rwlock_timedrdlock} except the time -@var{abstime} is measured against the clock specified by @var{clockid} -rather than @code{CLOCK_REALTIME}. Currently, @var{clockid} must be either -@code{CLOCK_MONOTONIC} or @code{CLOCK_REALTIME}, otherwise @code{EINVAL} is -returned. -@end deftypefun - -@comment pthread.h -@comment POSIX-proposed -@deftypefun int pthread_rwlock_clockwrlock (pthread_rwlock_t *@var{rwlock}, clockid_t @var{clockid}, const struct timespec *@var{abstime}) -@safety{@prelim{}@mtsafe{}@asunsafe{@asulock{}}@acunsafe{@aculock{}}} -Behaves like @code{pthread_rwlock_timedwrlock} except the time -@var{abstime} is measured against the clock specified by @var{clockid} -rather than @code{CLOCK_REALTIME}. Currently, @var{clockid} must be either -@code{CLOCK_MONOTONIC} or @code{CLOCK_REALTIME}, otherwise @code{EINVAL} is -returned. -@end deftypefun +@Theglibc{} provides several extensions to the @code{pthread_join} +function. @comment pthread.h @comment GNU extension diff --git a/stdio-common/Makefile b/stdio-common/Makefile index 31f40cf..3709222 100644 --- a/stdio-common/Makefile +++ b/stdio-common/Makefile @@ -378,7 +378,9 @@ endif endif tests-container += \ - tst-popen3 + tst-popen3 \ + tst-setvbuf2 \ + tst-setvbuf2-ind # tests-container generated += \ @@ -390,6 +392,8 @@ generated += \ tests-internal = \ tst-grouping_iterator \ + tst-setvbuf2 \ + tst-setvbuf2-ind \ # tests-internal test-srcs = \ @@ -762,6 +766,11 @@ $(objpfx)tst-setvbuf1-cmp.out: tst-setvbuf1.expect $(objpfx)tst-setvbuf1.out cmp $^ > $@; \ $(evaluate-test) +CFLAGS-tst-setvbuf2.c += -DIND_PROC=\"$(objpfx)tst-setvbuf2-ind\" +$(objpfx)tst-setvbuf2-ind : $(objpfx)tst-setvbuf2-ind.o $(shared-thread-library) +$(objpfx)tst-setvbuf2.out: $(objpfx)tst-setvbuf2-ind +$(objpfx)tst-setvbuf2 : $(shared-thread-library) + $(objpfx)tst-printf-round: $(libm) $(objpfx)tst-scanf-round: $(libm) diff --git a/stdio-common/tst-setvbuf2-ind.c b/stdio-common/tst-setvbuf2-ind.c new file mode 100644 index 0000000..fda2942 --- /dev/null +++ b/stdio-common/tst-setvbuf2-ind.c @@ -0,0 +1,2 @@ +#define INDEPENDENT_PART 1 +#include "tst-setvbuf2.c" diff --git a/stdio-common/tst-setvbuf2.c b/stdio-common/tst-setvbuf2.c new file mode 100644 index 0000000..6cc8335 --- /dev/null +++ b/stdio-common/tst-setvbuf2.c @@ -0,0 +1,1030 @@ +/* Test setvbuf under various conditions. + Copyright (C) 2025 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 file is used twice, once as the test itself (where do_test + is defined) and once as a subprocess we spawn to test stdin et all + (where main is defined). INDEPENDENT_PART is defined for the + latter. + + Note also that the purpose of this test is to test setvbuf, not the + underlying buffering code. */ + +#include <stdbool.h> +#include <stdio.h> +#include <stdio_ext.h> +#include <stdlib.h> +#include <unistd.h> +#include <fcntl.h> +#include <string.h> +#include <errno.h> +#include <signal.h> +#include <libio.h> +#include <termios.h> + +#include <support/support.h> +#include <support/check.h> +#include <support/temp_file.h> +#include <support/xstdio.h> +#include <support/xunistd.h> +#include <support/xthread.h> +#include <support/tty.h> + +/* Dear future developer: If you are reading this, you are likely + trying to change or understand this test. In that case, these + debug/dump macros will be helpful. */ +#if 0 +# define debug printf ("\033[3%dm%s:%d\033[0m\n", \ + (__LINE__ % 6) + 1, __FUNCTION__, __LINE__); + +static void +dumpfp (FILE *fp) +{ + char f[10], *p=f; + + if (fp->_flags & _IO_UNBUFFERED) + *p++ = 'N'; + if (fp->_flags & _IO_LINE_BUF) + *p++ = 'L'; + if (p == f) + *p++ = 'B'; + *p = 0; + + printf ("FILE %p flags %s" + " read %p \033[%dm%+ld \033[%dm%+ld\033[0m" + " write %p \033[%dm%+ld \033[%dm%+ld\033[0m %ld" + " buf %p \033[%dm%+ld\033[0m sz %ld pend %ld\n", + fp, f, + + fp->_IO_read_base, + fp->_IO_read_ptr == fp->_IO_read_base ? 33 : 32, + fp->_IO_read_ptr - fp->_IO_read_base, + fp->_IO_read_end == fp->_IO_read_base ? 33 : 36, + fp->_IO_read_end - fp->_IO_read_base, + + fp->_IO_write_base, + fp->_IO_write_ptr == fp->_IO_write_base ? 33 : 32, + fp->_IO_write_ptr - fp->_IO_write_base, + fp->_IO_write_end == fp->_IO_write_base ? 33 : 36, + fp->_IO_write_end - fp->_IO_write_base, + fp->_IO_write_end - fp->_IO_write_base, + + fp->_IO_buf_base, + fp->_IO_buf_end == fp->_IO_buf_base ? 33 : 35, + fp->_IO_buf_end - fp->_IO_buf_base, + __fbufsize (fp), __fpending (fp) + ); +} +#else +# define debug +# define dumpfp(FP) +#endif + +#ifndef INDEPENDENT_PART +/* st_blksize value for that file, or BUFSIZ if out of range. */ +static int blksize = BUFSIZ; +#endif + +/* Our test buffer. */ +#define TEST_BUFSIZE 42 +static int bufsize = TEST_BUFSIZE < BUFSIZ ? TEST_BUFSIZE : BUFSIZ; +static char *buffer; + +/* Test data, both written to that file and used as an in-memory + stream. */ +char test_data[2 * BUFSIZ]; + +#define TEST_STRING "abcdef\n" + +enum test_source_case + { + test_source_file, + test_source_pipe, + test_source_fifo, + test_source_pseudo_terminal, + test_source_dev_null, + test_source_count, + }; + +static const char *const test_source_name[test_source_count] = + { + "regular file", + "pipe", + "fifo", + "pseudo_terminal", + "dev_null" + }; + +enum test_stream_case + { + test_stream_stdin, + test_stream_stdout, + test_stream_stderr, + test_stream_fopen_r, + test_stream_fdopen_r, + test_stream_fopen_w, + test_stream_fdopen_w, + test_stream_count + }; + +static bool test_stream_reads[test_stream_count] = + { + true, + false, + false, + true, + true, + false, + false + }; + +static const char *const test_stream_name[test_stream_count] = + { + "stdin", + "stdout", + "stderr", + "fopen (read)", + "fdopen (read)", + "fopen (write)", + "fdopen (write)" + }; + +enum test_config_case + { + test_config_none, + test_config_unbuffered, + test_config_line, + test_config_fully, + test_config_count + }; + +static const char *const test_config_name[test_config_count] = + { + "no change", + "unbuffered", + "line buffered", + "fully buffered" + }; + +FILE *test_stream; + +char *test_file_name = NULL; +int pty_fd; +char *test_pipe_name = NULL; +int test_pipe[2]; + +/* This is either -1 or represents a pre-opened file descriptor for + the test as returned by prepare_test_file. */ +int test_fd; + +/*------------------------------------------------------------*/ + +/* Note that throughout this test we reopen, remove, and change + to/from a fifo, the test file. This would normally cause a race + condition, except that we're in a test container. No other process + can run in the test container simultaneously. */ + +void +prepare_test_data (void) +{ + buffer = (char *) xmalloc (bufsize); + +#ifndef INDEPENDENT_PART + /* Both file and pipe need this. */ + if (test_file_name == NULL) + { + debug; + int fd = create_temp_file ("tst-setvbuf2", &test_file_name); + TEST_VERIFY_EXIT (fd != -1); + struct stat64 st; + xfstat64 (fd, &st); + if (st.st_blksize > 0 && st.st_blksize < BUFSIZ) + blksize = st.st_blksize; + xclose (fd); + } +#endif + + for (size_t i = 0; i < 2 * BUFSIZ; i++) + { + unsigned char c = TEST_STRING[i % strlen (TEST_STRING)]; + test_data[i] = c; + } +} + +#ifndef INDEPENDENT_PART + +/* These functions provide a source/sink for the "other" side of any + pipe-style descriptor we're using for test. */ + +static pthread_t writer_thread_tid = 0; +static pthread_t reader_thread_tid = 0; + +typedef struct { + int fd; + const char *fname; +} ThreadData; +/* It's OK if this is static, we only run one at a time. */ +ThreadData thread_data; + +static void * +writer_thread_proc (void *closure) +{ + ThreadData *td = (ThreadData *) closure; + int fd; + int i; + ssize_t wn; + debug; + + if (td->fname) + td->fd = xopen (td->fname, O_WRONLY, 0777); + fd = td->fd; + + while (1) + { + i = 0; + while (i < BUFSIZ) + { + wn = write (fd, test_data + i, BUFSIZ - i); + if (wn <= 0) + break; + i += wn; + } + } + return NULL; +} + +static void * +reader_thread_proc (void *closure) +{ + ThreadData *td = (ThreadData *) closure; + int fd; + ssize_t rn; + int n = 0; + debug; + + if (td->fname) + td->fd = xopen (td->fname, O_RDONLY, 0777); + fd = td->fd; + + while (1) + { + char buf[BUFSIZ]; + rn = read (fd, buf, BUFSIZ); + if (rn <= 0) + break; + TEST_COMPARE_BLOB (buf, rn, test_data+n, rn); + n += rn; + } + return NULL; +} + +static void +start_writer_thread (int fd) +{ + debug; + thread_data.fd = fd; + thread_data.fname = NULL; + writer_thread_tid = xpthread_create (NULL, writer_thread_proc, + (void *)&thread_data); +} + +static void +start_writer_thread_n (const char *fname) +{ + debug; + thread_data.fd = 0; + thread_data.fname = fname; + writer_thread_tid = xpthread_create (NULL, writer_thread_proc, + (void *)&thread_data); +} + +static void +end_writer_thread (void) +{ + debug; + if (writer_thread_tid) + { + pthread_cancel (writer_thread_tid); + xpthread_join (writer_thread_tid); + xclose (thread_data.fd); + writer_thread_tid = 0; + } +} + +static void +start_reader_thread (int fd) +{ + debug; + thread_data.fd = fd; + thread_data.fname = NULL; + reader_thread_tid = xpthread_create (NULL, reader_thread_proc, + (void *)&thread_data); +} + +static void +start_reader_thread_n (const char *fname) +{ + debug; + thread_data.fd = 0; + thread_data.fname = fname; + reader_thread_tid = xpthread_create (NULL, reader_thread_proc, + (void *)&thread_data); +} + +static void +end_reader_thread (void) +{ + debug; + if (reader_thread_tid) + { + pthread_cancel (reader_thread_tid); + xpthread_join (reader_thread_tid); + xclose (thread_data.fd); + reader_thread_tid = 0; + } +} + +/*------------------------------------------------------------*/ + +/* These two functions are reponsible for choosing a file to be tested + against, typically by returning a filename but in a few cases also + providing a file descriptor (i.e. for fdopen). */ + +static const char * +prepare_test_file (enum test_source_case f, enum test_stream_case s) +{ + debug; + + test_fd = -1; + + switch (f) + { + case test_source_file: + { + if (test_stream_reads[f]) + { + debug; + FILE *fp = xfopen (test_file_name, "w"); + TEST_VERIFY_EXIT (fwrite (test_data, 1, 2 * BUFSIZ, fp) + == 2 * BUFSIZ); + xfclose (fp); + } + debug; + return test_file_name; + } + + case test_source_pipe: + { + debug; + xpipe (test_pipe); + if (test_stream_reads[s]) + { + start_writer_thread (test_pipe[1]); + test_fd = test_pipe[0]; + } + else + { + start_reader_thread (test_pipe[0]); + test_fd = test_pipe[1]; + } + test_pipe_name = xasprintf ("/proc/self/fd/%d", test_fd); + debug; + return test_pipe_name; + } + + case test_source_fifo: + { + /* We do not want to fail/exit if the file doesn't exist. */ + unlink (test_file_name); + xmkfifo (test_file_name, 0600); + debug; + if (test_stream_reads[s]) + start_writer_thread_n (test_file_name); + else + start_reader_thread_n (test_file_name); + debug; + return test_file_name; + } + + case test_source_pseudo_terminal: + { + support_openpty (&pty_fd, &test_fd, &test_pipe_name, NULL, NULL); + + debug; + if (test_stream_reads[s]) + start_writer_thread (pty_fd); + else + start_reader_thread (pty_fd); + + debug; + return test_pipe_name; + } + + case test_source_dev_null: + debug; + return "/dev/null"; + + default: + abort (); + } +} + +static void +unprepare_test_file (FILE *fp, + enum test_source_case f, + enum test_stream_case s) +{ + debug; + switch (f) + { + case test_source_file: + break; + + case test_source_pipe: + free (test_pipe_name); + if (test_stream_reads[s]) + end_writer_thread (); + else + end_reader_thread (); + break; + + case test_source_fifo: + if (test_stream_reads[s]) + end_writer_thread (); + else + end_reader_thread (); + unlink (test_file_name); + break; + + case test_source_pseudo_terminal: + free (test_pipe_name); + if (test_stream_reads[s]) + end_writer_thread (); + else + end_reader_thread (); + break; + + case test_source_dev_null: + break; + + default: + abort (); + } + debug; +} + +/*------------------------------------------------------------*/ + +/* This function takes a filename and returns a file descriptor, + opened according to the method requested. */ + +static FILE * +open_test_stream (enum test_source_case f, enum test_stream_case s) +{ + int fd; + FILE *fp; + const char *fname; + + debug; + fname = prepare_test_file (f, s); + if (fname == NULL) + return NULL; + + switch (s) + { + case test_stream_stdin: + fp = xfopen (fname, "r"); + break; + + case test_stream_stdout: + fp = xfopen (fname, "w"); + break; + + case test_stream_stderr: + fp = xfopen (fname, "w"); + break; + + case test_stream_fopen_r: + fp = xfopen (fname, "r"); + break; + + case test_stream_fdopen_r: + if (test_fd == -1) + fd = xopen (fname, O_RDONLY, 0); + else + fd = test_fd; + fp = fdopen (fd, "r"); + break; + + case test_stream_fopen_w: + fp = xfopen (fname, "w"); + break; + + case test_stream_fdopen_w: + fd = xopen (fname, O_WRONLY|O_CREAT|O_TRUNC, 0777); + fp = fdopen (fd, "w"); + break; + + default: + abort (); + } + TEST_VERIFY_EXIT (fp != NULL); + + if (f == test_source_pseudo_terminal) + { + struct termios t; + /* We disable the NL to CR-LF conversion so that we can compare + data without having to remove the extra CRs. */ + if (tcgetattr (fileno (fp), &t) < 0) + FAIL_EXIT1 ("tcgetattr failed: %m"); + t.c_oflag &= ~ONLCR; + if (tcsetattr (fileno (fp), TCSANOW, &t) < 0) + FAIL_EXIT1 ("tcsetattr failed: %m"); + } + + debug; + printf ("source %s stream %s file %s fd %d\n", + test_source_name[f], + test_stream_name[s], fname, fileno (fp)); + return fp; +} + +#endif + +/*------------------------------------------------------------*/ + +/* These functions do the actual testing - setting various buffering + options and verifying that they buffer as expected. */ + +static void +test_put_string (FILE *fp, const char *s, int count) +{ + while (*s && count--) + { + fputc (*s++, fp); + TEST_VERIFY_EXIT (!ferror (fp)); + } +} + +int +verify_fully_buffered (FILE *fp, + enum test_source_case f, + enum test_stream_case s, + enum test_config_case c) +{ + debug; + if (test_stream_reads[s]) + { + char buf[10]; + dumpfp (fp); + size_t fc = fread (buf, 1, 10 - 1, fp); + dumpfp (fp); + + ssize_t count = fp->_IO_read_ptr - fp->_IO_read_base; + + TEST_VERIFY (fp->_IO_read_base != NULL); + if (f == test_source_dev_null) + { + TEST_VERIFY (fc == 0); + TEST_VERIFY (count == 0); + } + else if (f == test_source_pseudo_terminal) + { + TEST_VERIFY (fc == 9); + TEST_VERIFY (count == 3 || count == 10); + } + else + { + TEST_VERIFY (fc == 9); + TEST_VERIFY (count == 10); + } + + /* We already checked for the first character being 'a'. */ + if (count > 1) + { + TEST_COMPARE_BLOB (buf, count - 1, test_data + 1, count - 1); + TEST_COMPARE_BLOB (fp->_IO_read_base, count, test_data, count); + } + } + else + { + dumpfp (fp); + test_put_string (fp, test_data + 1, 10 - 1); + dumpfp (fp); + TEST_COMPARE (fp->_IO_write_ptr - fp->_IO_write_base, 10); + TEST_COMPARE_BLOB (fp->_IO_write_base, 10, test_data, 10); + } + + TEST_COMPARE ((fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)), 0); + if (c != test_config_none) + TEST_COMPARE (__fbufsize (fp), bufsize); + return 0; +} + +int +verify_line_buffered (FILE *fp, + enum test_source_case f, + enum test_stream_case s, + enum test_config_case c) +{ + debug; + /* "line buffered" for inputs is not really defined; what you really + want here is to control the device providing input. For GLIBC a + line-buffered input is treated as fully buffered. */ + if (test_stream_reads[s]) + { + char buf[10]; + dumpfp (fp); + size_t fc = fread (buf, 1, 10 - 1, fp); + dumpfp (fp); + + ssize_t count = fp->_IO_read_ptr - fp->_IO_read_base; + + TEST_VERIFY (fp->_IO_read_base != NULL); + if (f == test_source_dev_null) + { + TEST_VERIFY (fc == 0); + TEST_VERIFY (count == 0); + } + else if (f == test_source_pseudo_terminal) + { + TEST_VERIFY (fc == 9); + TEST_VERIFY (count == 3 || count == 10); + } + else + { + TEST_VERIFY (fc == 9); + TEST_VERIFY (count == 10); + } + + /* We already checked for the first character being 'a'. */ + if (count > 1) + { + TEST_COMPARE_BLOB (buf, count - 1, test_data + 1, count - 1); + TEST_COMPARE_BLOB (fp->_IO_read_base, count, test_data, count); + } + } + else + { + dumpfp (fp); + test_put_string (fp, test_data + 1, 10 - 1); + dumpfp (fp); + TEST_COMPARE (fp->_IO_write_ptr - fp->_IO_write_base, 3); + /* The first "abcdef\n" got flushed, leaving "abc". */ + TEST_COMPARE_BLOB (fp->_IO_write_base, 3, test_data + 7, 3); + } + + TEST_COMPARE ((fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)), _IO_LINE_BUF); + if (c != test_config_none) + TEST_COMPARE (__fbufsize (fp), bufsize); + return 0; +} + +int +verify_unbuffered (FILE *fp, + enum test_source_case f, + enum test_stream_case s, + enum test_config_case c) +{ + debug; + if (test_stream_reads[s]) + { + /* We've already read one byte. */ + dumpfp (fp); + TEST_VERIFY (fp->_IO_read_base != NULL); + if (f == test_source_dev_null) + TEST_COMPARE (fp->_IO_read_ptr - fp->_IO_read_base, 0); + else + { + TEST_COMPARE (fp->_IO_read_ptr - fp->_IO_read_base, 1); + TEST_COMPARE (fp->_IO_read_base[0], test_data[0]); + TEST_VERIFY (fp->_IO_read_ptr == fp->_IO_read_end); + } + } + else + { + dumpfp (fp); + fputc (test_data[1], fp); + dumpfp (fp); + TEST_COMPARE (fp->_IO_write_ptr - fp->_IO_write_base, 0); + TEST_COMPARE (fp->_IO_write_base[0], test_data[1]); + TEST_VERIFY (fp->_IO_write_end == fp->_IO_write_base); + } + TEST_COMPARE ((fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)), + _IO_UNBUFFERED); + TEST_COMPARE (__fbufsize (fp), 1); + return 0; +} + +static int +do_setvbuf (FILE *fp, void *buf, int flags, int size, + enum test_stream_case s) +{ + if (s != test_stream_stdout) + printf ("SETVBUF %p %p %s %d\n", + fp, buf, + flags == _IONBF ? "_IONBF" + : flags == _IOLBF ? "_IOLBF" + : flags == _IOFBF ? "_IOFBF" + : "???", size); + if (setvbuf (fp, buf, flags, size)) + { + perror ("setvbuf"); + return 1; + } + return 0; +} + +int +do_second_part (FILE *fp, + enum test_source_case f, + enum test_stream_case s, + enum test_config_case c) +{ + /* At this point, FP is the stream to test according to the other + parameters. */ + + int rv = 0; + int flags_before; + int flags_after; + + debug; + + flags_before = fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF); + + /* This is where we do the thing we're testing for. */ + switch (c) + { + case test_config_none: + /* Buffering is unchanged. */ + break; + + case test_config_unbuffered: + do_setvbuf (fp, NULL, _IONBF, 0, s); + break; + + case test_config_line: + do_setvbuf (fp, buffer, _IOLBF, bufsize, s); + break; + + case test_config_fully: + do_setvbuf (fp, buffer, _IOFBF, bufsize, s); + break; + + default: + abort (); + } + + flags_after = fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF); + + /* Check the buffer mode after we touch it, if we touched it. */ + switch (c) + { + case test_config_none: + /* Buffering is unchanged, but may change on the first read/write. */ + TEST_COMPARE (flags_after, flags_before); + break; + + case test_config_unbuffered: + TEST_COMPARE (flags_after, _IO_UNBUFFERED); + break; + + case test_config_line: + TEST_COMPARE (flags_after, _IO_LINE_BUF); + break; + + case test_config_fully: + TEST_COMPARE (flags_after, 0); + break; + + default: + abort (); + } + + /* Glibc defers calculating the appropriate buffering mechanism + until it reads from or writes to the device. So we read one + character here, and account for that in the tests. */ + if (test_stream_reads[s]) + { + dumpfp (fp); + int c = fgetc (fp); + if (c != TEST_STRING[0] && f != test_source_dev_null) + FAIL ("first char read is %c not %c", c, TEST_STRING[0]); + dumpfp (fp); + } + else + { + dumpfp (fp); + fputc (TEST_STRING[0], fp); + dumpfp (fp); + } + + switch (fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)) + { + case _IO_LINE_BUF: + rv += verify_line_buffered (fp, f, s, c); + break; + + case _IO_UNBUFFERED: + rv += verify_unbuffered (fp, f, s, c); + break; + + case 0: /* Fully buffered. */ + rv += verify_fully_buffered (fp, f, s, c); + break; + + default: + abort (); + } + + + fclose (fp); + return rv; +} + +/*------------------------------------------------------------*/ + +#ifdef INDEPENDENT_PART +/* This part is the independent sub-process we call to test stdin et + al. */ + +int +main (int argc, char **argv) +{ + /* This is one of the subprocesses we created to test stdin et + al. */ + FILE *fp; + + /* If we're called as a regular test, instead of as a sub-process, + don't complain. */ + if (argc == 1) + return 0; + + if (argc != 4) + { + int i; + for (i = 0; i <= argc; i ++) + printf ("argv[%d] = `%s'\n", i, argv[i] ?: "(null)"); + FAIL_EXIT1 ("sub-process called wrong"); + } + + prepare_test_data (); + + enum test_source_case f = atoi (argv[1]); + enum test_stream_case s = atoi (argv[2]); + enum test_config_case c = atoi (argv[3]); + + if (s != test_stream_stdout) + printf ("\n\033[41mRunning test %s : %s : %s\033[0m\n", + test_source_name[f], + test_stream_name[s], + test_config_name[c]); + + switch (s) + { + case test_stream_stdin: + fp = stdin; + break; + case test_stream_stdout: + fp = stdout; + break; + case test_stream_stderr: + fp = stderr; + break; + default: + abort (); + } + + return do_second_part (fp, f, s, c); +} + +#else +/* This part is the standard test process. */ + +/* Spawn an independent sub-process with std* redirected. */ +int +recurse (FILE *fp, + enum test_source_case f, + enum test_stream_case s, + enum test_config_case c) +{ + /* We need to test stdin, stdout, or stderr, which means creating a + subprocess with one of those redirected from FP. */ + debug; + + pid_t pid; + int status; + + pid = fork (); + + switch (pid) + { + case -1: /* error */ + perror ("fork"); + return 1; + break; + + default: /* parent */ + fclose (fp); + xwaitpid (pid, &status, 0); + if (WIFEXITED (status) + && WEXITSTATUS (status) == 0) + return 0; + return 1; + + case 0: /* child */ + switch (s) + { + case test_stream_stdin: + xclose (0); + dup2 (fileno (fp), 0); + break; + case test_stream_stdout: + xclose (1); + dup2 (fileno (fp), 1); + break; + case test_stream_stderr: + xclose (2); + dup2 (fileno (fp), 2); + break; + default: + abort (); + } + fclose (fp); + + /* At this point, we have to run a program... which is tricky to + properly support for remote targets or crosses, because of + glibc versions etc. Hence we run in a test-container. */ + + char fs[10], ss[10], cs[10]; + sprintf (fs, "%d", f); + sprintf (ss, "%d", s); + sprintf (cs, "%d", c); + execl (IND_PROC, IND_PROC, fs, ss, cs, NULL); + if (s == test_stream_stdout) + fprintf (stderr, "execl (%s) failed, ", IND_PROC); + else + printf ("execl (%s) failed, ", IND_PROC); + perror ("The error was"); + exit (1); + break; + } + + return 0; +} + +int +do_test (void) +{ + int rv = 0; + + signal (SIGPIPE, SIG_IGN); + + prepare_test_data (); + + for (enum test_source_case f = 0; f < test_source_count; ++f) + for (enum test_stream_case s = 0; s < test_stream_count; ++s) + for (enum test_config_case c = 0; c < test_config_count; ++c) + { + printf ("\n\033[43mRunning test %s : %s : %s\033[0m\n", + test_source_name[f], + test_stream_name[s], + test_config_name[c]); + + FILE *fp = open_test_stream (f, s); + + if (fp) + { + + if (s <= test_stream_stderr) + rv += recurse (fp, f, s, c); + else + rv += do_second_part (fp, f, s, c); + + unprepare_test_file (fp, f, s); + } + } + + free (buffer); + + printf ("return %d\n", rv); + return rv; +} + +# include <support/test-driver.c> +#endif + diff --git a/stdlib/Makefile b/stdlib/Makefile index c9c8f70..513445b 100644 --- a/stdlib/Makefile +++ b/stdlib/Makefile @@ -300,6 +300,8 @@ tests := \ tst-qsort2 \ tst-qsort3 \ tst-qsort6 \ + tst-qsort7 \ + tst-qsortx7 \ tst-quick_exit \ tst-rand-sequence \ tst-rand48 \ @@ -553,7 +555,19 @@ tests-special += $(objpfx)isomac.out ifeq ($(run-built-tests),yes) tests-special += $(objpfx)tst-fmtmsg.out -endif +ifeq ($(build-shared),yes) +ifneq ($(PERL),no) +generated += \ + tst-qsort7.mtrace \ + tst-qsortx7.mtrace \ + # generated +tests-special += \ + $(objpfx)tst-qsort7-mem.out \ + $(objpfx)tst-qsortx7-mem.out \ + # tests-special +endif # $(build-shared) == yes +endif # $(PERL) == yes +endif # $(run-built-tests) == yes include ../Rules @@ -647,3 +661,19 @@ $(objpfx)tst-getrandom2: $(shared-thread-library) $(objpfx)tst-getenv-signal: $(shared-thread-library) $(objpfx)tst-getenv-thread: $(shared-thread-library) $(objpfx)tst-getenv-unsetenv: $(shared-thread-library) + +CFLAGS-tst-qsort7.c += -fno-exceptions -fno-asynchronous-unwind-tables +LDLIBS-tst-qsort7 = $(shared-thread-library) +tst-qsort7-ENV = MALLOC_TRACE=$(objpfx)tst-qsort7.mtrace \ + LD_PRELOAD=$(common-objpfx)/malloc/libc_malloc_debug.so +$(objpfx)tst-qsort7-mem.out: $(objpfx)tst-qsort7.out + $(common-objpfx)malloc/mtrace $(objpfx)tst-qsort7.mtrace > $@; \ + $(evaluate-test) + +CFLAGS-tst-qsortx7.c += -fexceptions +LDLIBS-tst-qsortx7 = $(shared-thread-library) +tst-qsortx7-ENV = MALLOC_TRACE=$(objpfx)tst-qsortx7.mtrace \ + LD_PRELOAD=$(common-objpfx)/malloc/libc_malloc_debug.so +$(objpfx)tst-qsortx7-mem.out: $(objpfx)tst-qsortx7.out + $(common-objpfx)malloc/mtrace $(objpfx)tst-qsortx7.mtrace > $@; \ + $(evaluate-test) diff --git a/stdlib/qsort.c b/stdlib/qsort.c index 08fdb84..0b1e0e9 100644 --- a/stdlib/qsort.c +++ b/stdlib/qsort.c @@ -25,6 +25,7 @@ #include <stdlib.h> #include <string.h> #include <stdbool.h> +#include "pthreadP.h" /* Swap SIZE bytes between addresses A and B. These helpers are provided along the generic one as an optimization. */ @@ -338,36 +339,10 @@ indirect_msort_with_tmp (const struct msort_param *p, void *b, size_t n, } } -void -__qsort_r (void *const pbase, size_t total_elems, size_t size, - __compar_d_fn_t cmp, void *arg) +static void +qsort_r_mergesort (void *const pbase, size_t total_elems, size_t size, + __compar_d_fn_t cmp, void *arg, void *buf) { - if (total_elems <= 1) - return; - - /* Align to the maximum size used by the swap optimization. */ - _Alignas (uint64_t) char tmp[QSORT_STACK_SIZE]; - size_t total_size = total_elems * size; - char *buf; - - if (size > INDIRECT_SORT_SIZE_THRES) - total_size = 2 * total_elems * sizeof (void *) + size; - - if (total_size <= sizeof tmp) - buf = tmp; - else - { - int save = errno; - buf = malloc (total_size); - __set_errno (save); - if (buf == NULL) - { - /* Fallback to heapsort in case of memory failure. */ - heapsort_r (pbase, total_elems - 1, size, cmp, arg); - return; - } - } - if (size > INDIRECT_SORT_SIZE_THRES) { const struct msort_param msort_param = @@ -392,9 +367,53 @@ __qsort_r (void *const pbase, size_t total_elems, size_t size, }; msort_with_tmp (&msort_param, pbase, total_elems); } +} + +static bool +qsort_r_malloc (void *const pbase, size_t total_elems, size_t size, + __compar_d_fn_t cmp, void *arg, size_t total_size) +{ + int save = errno; + char *buf = malloc (total_size); + __set_errno (save); + if (buf == NULL) + return false; - if (buf != tmp) - free (buf); + /* Deallocate the auxiliary buffer if the callback function throws + or if the thread is cancelled. */ + pthread_cleanup_combined_push (free, buf); + qsort_r_mergesort (pbase, total_elems, size, cmp, arg, buf); + pthread_cleanup_combined_pop (0); + + free (buf); + + return true; +} + +void +__qsort_r (void *const pbase, size_t total_elems, size_t size, + __compar_d_fn_t cmp, void *arg) +{ + if (total_elems <= 1) + return; + + /* Align to the maximum size used by the swap optimization. */ + size_t total_size = total_elems * size; + + if (size > INDIRECT_SORT_SIZE_THRES) + total_size = 2 * total_elems * sizeof (void *) + size; + + if (total_size <= QSORT_STACK_SIZE) + { + _Alignas (uint64_t) char tmp[QSORT_STACK_SIZE]; + qsort_r_mergesort (pbase, total_elems, size, cmp, arg, tmp); + } + else + { + if (!qsort_r_malloc (pbase, total_elems, size, cmp, arg, total_size)) + /* Fallback to heapsort in case of memory failure. */ + heapsort_r (pbase, total_elems - 1, size, cmp, arg); + } } libc_hidden_def (__qsort_r) weak_alias (__qsort_r, qsort_r) diff --git a/stdlib/tst-qsort4.c b/stdlib/tst-qsort4.c index 2875d40..a36e66a 100644 --- a/stdlib/tst-qsort4.c +++ b/stdlib/tst-qsort4.c @@ -16,6 +16,10 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ +#undef pthread_cleanup_combined_push +#define pthread_cleanup_combined_push(routine, arg) +#undef pthread_cleanup_combined_pop +#define pthread_cleanup_combined_pop(execute) #include "qsort.c" #include <stdio.h> diff --git a/stdlib/tst-qsort7.c b/stdlib/tst-qsort7.c new file mode 100644 index 0000000..0d62630 --- /dev/null +++ b/stdlib/tst-qsort7.c @@ -0,0 +1,80 @@ +/* Check exception handling from qsort (BZ 32058). + 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 + <http://www.gnu.org/licenses/>. */ + +#include <array_length.h> +#include <mcheck.h> +#include <stdlib.h> +#include <support/check.h> +#include <support/xthread.h> +#include <unistd.h> + +static pthread_barrier_t b; + +static void +cl (void *arg) +{ +} + +static int +compar_func (const void *a1, const void *a2) +{ + xpthread_barrier_wait (&b); + + pthread_cleanup_push (cl, NULL); + + pause (); + + pthread_cleanup_pop (0); + + support_record_failure (); + + return 0; +} + +static void * +tf (void *tf) +{ + /* An array larger than QSORT_STACK_SIZE to force memory allocation. */ + int input[1024] = { 0 }; + qsort (input, array_length (input), sizeof input[0], compar_func); + + return NULL; +} + +static int +do_test (void) +{ + mtrace (); + + xpthread_barrier_init (&b, NULL, 2); + + pthread_t thr = xpthread_create (NULL, tf, NULL); + + xpthread_barrier_wait (&b); + + xpthread_cancel (thr); + + { + void *r = xpthread_join (thr); + TEST_VERIFY (r == PTHREAD_CANCELED); + } + + return 0; +} + +#include <support/test-driver.c> diff --git a/stdlib/tst-qsortx7.c b/stdlib/tst-qsortx7.c new file mode 100644 index 0000000..ab61523 --- /dev/null +++ b/stdlib/tst-qsortx7.c @@ -0,0 +1 @@ +#include "tst-qsort7.c" diff --git a/support/Makefile b/support/Makefile index dfe8e54..d41278e 100644 --- a/support/Makefile +++ b/support/Makefile @@ -330,6 +330,7 @@ tests = \ README-testing \ tst-support-namespace \ tst-support-open-dev-null-range \ + tst-support-openpty \ tst-support-process_state \ tst-support_blob_repeat \ tst-support_capture_subprocess \ @@ -351,6 +352,10 @@ tests = \ tst-xsigstack \ # tests +tests-container = \ + tst-support-openpty-c \ + # tests-container + ifeq ($(run-built-tests),yes) tests-special = \ $(objpfx)tst-support_record_failure-2.out diff --git a/support/test-container.c b/support/test-container.c index 79d3189..a641250 100644 --- a/support/test-container.c +++ b/support/test-container.c @@ -1151,6 +1151,9 @@ main (int argc, char **argv) devmount (new_root_path, "null"); devmount (new_root_path, "zero"); devmount (new_root_path, "urandom"); +#ifdef __linux__ + devmount (new_root_path, "ptmx"); +#endif /* We're done with the "old" root, switch to the new one. */ if (chroot (new_root_path) < 0) @@ -1217,6 +1220,14 @@ main (int argc, char **argv) maybe_xmkdir ("/tmp", 0755); +#ifdef __linux__ + maybe_xmkdir ("/dev/pts", 0777); + if (mount ("/dev/pts", "/dev/pts", "devpts", 0, "newinstance,ptmxmode=0666,mode=0666") < 0) + FAIL_EXIT1 ("can't mount /dev/pts: %m\n"); + if (mount ("/dev/pts/ptmx", "/dev/ptmx", "", MS_BIND | MS_REC, NULL) < 0) + FAIL_EXIT1 ("can't mount /dev/ptmx\n"); +#endif + if (require_pidns) { /* Now that we're pid 1 (effectively "root") we can mount /proc */ diff --git a/support/tst-support-openpty-c.c b/support/tst-support-openpty-c.c new file mode 100644 index 0000000..0a6a428 --- /dev/null +++ b/support/tst-support-openpty-c.c @@ -0,0 +1,2 @@ +/* Same test, but in a test-container. */ +#include "tst-support-openpty.c" diff --git a/support/tst-support-openpty.c b/support/tst-support-openpty.c new file mode 100644 index 0000000..1222d70 --- /dev/null +++ b/support/tst-support-openpty.c @@ -0,0 +1,49 @@ +/* Basic test for support_openpty support in test-container. + Copyright (C) 2025 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 <termios.h> +#include <unistd.h> +#include <sys/ioctl.h> + +#include <support/tty.h> +#include <support/check.h> +#include <support/support.h> + +/* Note: the purpose of this test isn't to test if ptys function + correctly, but only to verify that test-container's support for + them is correct. The many checks in support_openpty.c are + sufficient for this. */ + +int +do_test (void) +{ + int outer, inner; + char *name; + struct termios term; + struct winsize win; + + cfmakeraw (&term); + win.ws_row = 24; + win.ws_col = 80; + + support_openpty (&outer, &inner, &name, &term, &win); + + return 0; +} + +#include <support/test-driver.c> diff --git a/sysdeps/aarch64/dl-tlsdesc.S b/sysdeps/aarch64/dl-tlsdesc.S index 68afc44..fc40d66 100644 --- a/sysdeps/aarch64/dl-tlsdesc.S +++ b/sysdeps/aarch64/dl-tlsdesc.S @@ -119,20 +119,19 @@ _dl_tlsdesc_undefweak: object referenced by the argument. ptrdiff_t - __attribute__ ((__regparm__ (1))) _dl_tlsdesc_dynamic (struct tlsdesc *tdp) { struct tlsdesc_dynamic_arg *td = tdp->arg; - dtv_t *dtv = *(dtv_t **)((char *)__thread_pointer + TCBHEAD_DTV); + dtv_t *dtv = *(dtv_t **)((char *)__thread_pointer() + TCBHEAD_DTV); if (__builtin_expect (td->gen_count <= dtv[0].counter && (dtv[td->tlsinfo.ti_module].pointer.val != TLS_DTV_UNALLOCATED), 1)) return dtv[td->tlsinfo.ti_module].pointer.val + td->tlsinfo.ti_offset - - __thread_pointer; + - __thread_pointer(); - return ___tls_get_addr (&td->tlsinfo) - __thread_pointer; + return __tls_get_addr (&td->tlsinfo) - __thread_pointer(); } */ @@ -142,7 +141,12 @@ _dl_tlsdesc_undefweak: cfi_startproc .align 2 _dl_tlsdesc_dynamic: +# if HAVE_AARCH64_PAC_RET + PACIASP + cfi_window_save +# else BTI_C +# endif /* Save just enough registers to support fast path, if we fall into slow path we will save additional registers. */ @@ -173,6 +177,10 @@ _dl_tlsdesc_dynamic: 1: ldp x3, x4, [sp, #16] ldp x1, x2, [sp], #32 +# if HAVE_AARCH64_PAC_RET + AUTIASP + cfi_window_save +# endif cfi_adjust_cfa_offset (-32) RET 2: @@ -182,10 +190,6 @@ _dl_tlsdesc_dynamic: /* Save the remaining registers that we must treat as caller save. */ cfi_restore_state -# if HAVE_AARCH64_PAC_RET - PACIASP - cfi_window_save -# endif # define NSAVEXREGPAIRS 8 stp x29, x30, [sp,#-16*NSAVEXREGPAIRS]! cfi_adjust_cfa_offset (16*NSAVEXREGPAIRS) @@ -236,10 +240,6 @@ _dl_tlsdesc_dynamic: cfi_adjust_cfa_offset (-16*NSAVEXREGPAIRS) cfi_restore (x29) cfi_restore (x30) -# if HAVE_AARCH64_PAC_RET - AUTIASP - cfi_window_save -# endif b 1b cfi_endproc .size _dl_tlsdesc_dynamic, .-_dl_tlsdesc_dynamic diff --git a/sysdeps/htl/pthreadP.h b/sysdeps/htl/pthreadP.h index 78ef4e7..535deeb 100644 --- a/sysdeps/htl/pthreadP.h +++ b/sysdeps/htl/pthreadP.h @@ -23,6 +23,7 @@ #include <pthread.h> #include <link.h> +#include <bits/cancelation.h> /* Attribute to indicate thread creation was issued from C11 thrd_create. */ #define ATTR_C11_THREAD ((void*)(uintptr_t)-1) @@ -233,4 +234,18 @@ weak_extern (__pthread_exit) _Static_assert (sizeof (type) == size, \ "sizeof (" #type ") != " #size) + /* Special cleanup macros which register cleanup both using + __pthread_cleanup_{push,pop} and using cleanup attribute. This is needed + for qsort, so that it supports both throwing exceptions from the caller + sort function callback (only cleanup attribute works there) and + cancellation of the thread running the callback if the callback or some + routines it calls don't have unwind information. + TODO: add support for cleanup routines. */ +#ifndef pthread_cleanup_combined_push +# define pthread_cleanup_combined_push __pthread_cleanup_push +#endif +#ifndef pthread_cleanup_combined_pop +# define pthread_cleanup_combined_pop __pthread_cleanup_pop +#endif + #endif /* pthreadP.h */ diff --git a/sysdeps/loongarch/cpu-tunables.c b/sysdeps/loongarch/cpu-tunables.c index 8b87e58..cad2e26 100644 --- a/sysdeps/loongarch/cpu-tunables.c +++ b/sysdeps/loongarch/cpu-tunables.c @@ -50,7 +50,7 @@ TUNABLE_CALLBACK (set_hwcaps) (tunable_val_t *valp) GLIBC_TUNABLES=glibc.cpu.hwcaps=-xxx,yyy,-zzz,.... can be used to enable CPU/ARCH feature yyy, disable CPU/ARCH feature - yyy and zzz, where the feature name is case-sensitive and has to + xxx and zzz, where the feature name is case-sensitive and has to match the ones in cpu-features.h. It can be used by glibc developers to tune for a new processor or override the IFUNC selection to improve performance for a particular workload. diff --git a/sysdeps/mach/hurd/Makefile b/sysdeps/mach/hurd/Makefile index 4b69b40..994de00 100644 --- a/sysdeps/mach/hurd/Makefile +++ b/sysdeps/mach/hurd/Makefile @@ -337,6 +337,9 @@ tests-unsupported += tst-vfprintf-width-prec-alloc endif ifeq ($(subdir),stdlib) tests-unsupported += test-bz22786 tst-strtod-overflow +# pthread_cleanup_combined_push/pthread_cleanup_combined_pop requires cleanup +# support (BZ 32058). +test-xfail-tst-qsortx7 = yes endif ifeq ($(subdir),timezone) tests-unsupported += tst-tzset diff --git a/sysdeps/nptl/pthreadP.h b/sysdeps/nptl/pthreadP.h index 2d620ed..8f25696 100644 --- a/sysdeps/nptl/pthreadP.h +++ b/sysdeps/nptl/pthreadP.h @@ -588,10 +588,10 @@ struct __pthread_cleanup_combined_frame /* Special cleanup macros which register cleanup both using __pthread_cleanup_{push,pop} and using cleanup attribute. This is needed - for pthread_once, so that it supports both throwing exceptions from the - pthread_once callback (only cleanup attribute works there) and cancellation - of the thread running the callback if the callback or some routines it - calls don't have unwind information. */ + for pthread_once and qsort, so that it supports both throwing exceptions + from the pthread_once or caller sort function callback (only cleanup + attribute works there) and cancellation of the thread running the callback + if the callback or some routines it calls don't have unwind information. */ static __always_inline void __pthread_cleanup_combined_routine (struct __pthread_cleanup_combined_frame diff --git a/sysdeps/s390/configure b/sysdeps/s390/configure index 67c3755..97f5252 100644 --- a/sysdeps/s390/configure +++ b/sysdeps/s390/configure @@ -309,46 +309,6 @@ then fi - - -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC is sufficient to build libc on s390x" >&5 -printf %s "checking if $CC is sufficient to build libc on s390x... " >&6; } -if test ${libc_cv_compiler_ok_on_s390x+y} -then : - printf %s "(cached) " >&6 -else case e in #( - e) -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main (void) -{ - -#if !defined __GNUC__ || __GNUC__ < 7 || (__GNUC__ == 7 && __GNUC_MINOR__ < 1) -#error insufficient compiler for building on s390x -#endif - - ; - return 0; -} -_ACEOF -if ac_fn_c_try_cpp "$LINENO" -then : - libc_cv_compiler_ok_on_s390x=yes -else case e in #( - e) libc_cv_compiler_ok_on_s390x=no ;; -esac -fi -rm -f conftest.err conftest.i conftest.$ac_ext ;; -esac -fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $libc_cv_compiler_ok_on_s390x" >&5 -printf "%s\n" "$libc_cv_compiler_ok_on_s390x" >&6; } -if test "$libc_cv_compiler_ok_on_s390x" != yes; then - critic_missing="$critic_missing On s390x, GCC >= 7.1.0 is required." -fi - test -n "$critic_missing" && as_fn_error $? " *** $critic_missing" "$LINENO" 5 diff --git a/sysdeps/s390/configure.ac b/sysdeps/s390/configure.ac index 89c3e5b..496866b 100644 --- a/sysdeps/s390/configure.ac +++ b/sysdeps/s390/configure.ac @@ -161,23 +161,5 @@ then AC_DEFINE(HAVE_S390_MIN_ARCH13_ZARCH_ASM_SUPPORT) fi - -dnl test if GCC is new enough. See gcc "Bug 98269 - gcc 6.5.0 -dnl __builtin_add_overflow() with small uint32_t values incorrectly detects -dnl overflow -dnl (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98269) -AC_CACHE_CHECK([if $CC is sufficient to build libc on s390x], -libc_cv_compiler_ok_on_s390x, [ -AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[]], [[ -#if !defined __GNUC__ || __GNUC__ < 7 || (__GNUC__ == 7 && __GNUC_MINOR__ < 1) -#error insufficient compiler for building on s390x -#endif -]])], - [libc_cv_compiler_ok_on_s390x=yes], - [libc_cv_compiler_ok_on_s390x=no])]) -if test "$libc_cv_compiler_ok_on_s390x" != yes; then - critic_missing="$critic_missing On s390x, GCC >= 7.1.0 is required." -fi - test -n "$critic_missing" && AC_MSG_ERROR([ *** $critic_missing]) diff --git a/sysdeps/unix/sysv/linux/aarch64/Makefile b/sysdeps/unix/sysv/linux/aarch64/Makefile index 0839f0b..15a2b44 100644 --- a/sysdeps/unix/sysv/linux/aarch64/Makefile +++ b/sysdeps/unix/sysv/linux/aarch64/Makefile @@ -1,3 +1,16 @@ +ifeq ($(subdir),elf) +tests += \ + tst-tlsdesc-pac \ + # tests +modules-names += \ + tst-tlsdesc-pac-mod \ + # modules-names + +LDFLAGS-tst-tlsdesc-pac = -rdynamic + +$(objpfx)tst-tlsdesc-pac.out: $(objpfx)tst-tlsdesc-pac-mod.so +endif + ifeq ($(subdir),misc) sysdep_headers += sys/elf.h tests += \ diff --git a/sysdeps/unix/sysv/linux/aarch64/tst-tlsdesc-pac-mod.c b/sysdeps/unix/sysv/linux/aarch64/tst-tlsdesc-pac-mod.c new file mode 100644 index 0000000..d34c8be --- /dev/null +++ b/sysdeps/unix/sysv/linux/aarch64/tst-tlsdesc-pac-mod.c @@ -0,0 +1,27 @@ +/* AArch64 tests for unwinding TLSDESC (BZ 32612) + Copyright (C) 2025 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/>. */ + +_Thread_local int foo; +/* Make the TLS segment large enough to trigger _dl_tlsdesc_dynamic. */ +_Thread_local int foobar[1000]; + +void +bar (void) +{ + foo = 1; +} diff --git a/sysdeps/unix/sysv/linux/aarch64/tst-tlsdesc-pac.c b/sysdeps/unix/sysv/linux/aarch64/tst-tlsdesc-pac.c new file mode 100644 index 0000000..24d656a --- /dev/null +++ b/sysdeps/unix/sysv/linux/aarch64/tst-tlsdesc-pac.c @@ -0,0 +1,48 @@ +/* AArch64 tests for unwinding TLSDESC (BZ 32612) + Copyright (C) 2025 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 <unwind.h> +#include <support/xdlfcn.h> + +static _Unwind_Reason_Code +unwind_callback (struct _Unwind_Context* context, void* closure) +{ + return _URC_NO_REASON; +} + +/* Assume that TLS variable from tst-tlsdesc-pac-mod.so will trigger + the slow-path that allocates the required memory with malloc. */ +void * +malloc (size_t s) +{ + _Unwind_Backtrace (unwind_callback, NULL); + return calloc (1, s); +} + +static int +do_test (void) +{ + void *h = xdlopen ("tst-tlsdesc-pac-mod.so", RTLD_LAZY); + void (*func)(void) = xdlsym (h, "bar"); + func (); + + return 0; +} + +#include <support/test-driver.c> diff --git a/sysdeps/unix/sysv/linux/syscall-names.list b/sysdeps/unix/sysv/linux/syscall-names.list index daffa08..6f3351a 100644 --- a/sysdeps/unix/sysv/linux/syscall-names.list +++ b/sysdeps/unix/sysv/linux/syscall-names.list @@ -21,8 +21,8 @@ # This file can list all potential system calls. The names are only # used if the installed kernel headers also provide them. -# The list of system calls is current as of Linux 6.13. -kernel 6.13 +# The list of system calls is current as of Linux 6.14. +kernel 6.14 FAST_atomic_update FAST_cmpxchg diff --git a/sysdeps/x86/Makefile b/sysdeps/x86/Makefile index 5311b59..01b0192 100644 --- a/sysdeps/x86/Makefile +++ b/sysdeps/x86/Makefile @@ -21,6 +21,9 @@ tests += \ tst-cpu-features-supports-static \ tst-get-cpu-features \ tst-get-cpu-features-static \ + tst-gnu2-tls2-x86-noxsave \ + tst-gnu2-tls2-x86-noxsavec \ + tst-gnu2-tls2-x86-noxsavexsavec \ tst-hwcap-tunables \ # tests tests-static += \ @@ -91,6 +94,25 @@ CFLAGS-tst-gnu2-tls2.c += -msse CFLAGS-tst-gnu2-tls2mod0.c += -msse2 -mtune=haswell CFLAGS-tst-gnu2-tls2mod1.c += -msse2 -mtune=haswell CFLAGS-tst-gnu2-tls2mod2.c += -msse2 -mtune=haswell + +LDFLAGS-tst-gnu2-tls2-x86-noxsave += -Wl,-z,lazy +LDFLAGS-tst-gnu2-tls2-x86-noxsavec += -Wl,-z,lazy +LDFLAGS-tst-gnu2-tls2-x86-noxsavexsavec += -Wl,-z,lazy + +# Test for bug 32810: incorrect XSAVE state size if XSAVEC is disabled +# via tunable. +tst-gnu2-tls2-x86-noxsave-ENV = GLIBC_TUNABLES=glibc.cpu.hwcaps=-XSAVE +tst-gnu2-tls2-x86-noxsavec-ENV = GLIBC_TUNABLES=glibc.cpu.hwcaps=-XSAVEC +tst-gnu2-tls2-x86-noxsavexsavec-ENV = GLIBC_TUNABLES=glibc.cpu.hwcaps=-XSAVE,-XSAVEC +$(objpfx)tst-gnu2-tls2-x86-noxsave: $(shared-thread-library) +$(objpfx)tst-gnu2-tls2-x86-noxsavec: $(shared-thread-library) +$(objpfx)tst-gnu2-tls2-x86-noxsavexsavec: $(shared-thread-library) +$(objpfx)tst-gnu2-tls2-x86-noxsave.out \ +$(objpfx)tst-gnu2-tls2-x86-noxsavec.out \ +$(objpfx)tst-gnu2-tls2-x86-noxsavexsavec.out: \ + $(objpfx)tst-gnu2-tls2mod0.so \ + $(objpfx)tst-gnu2-tls2mod1.so \ + $(objpfx)tst-gnu2-tls2mod2.so endif ifeq ($(subdir),math) diff --git a/sysdeps/x86/cpu-features.c b/sysdeps/x86/cpu-features.c index 27abaca..6cf7e4c 100644 --- a/sysdeps/x86/cpu-features.c +++ b/sysdeps/x86/cpu-features.c @@ -24,6 +24,7 @@ #include <dl-cacheinfo.h> #include <dl-minsigstacksize.h> #include <dl-hwcap2.h> +#include <gcc-macros.h> extern void TUNABLE_CALLBACK (set_hwcaps) (tunable_val_t *) attribute_hidden; @@ -83,6 +84,8 @@ extern void TUNABLE_CALLBACK (set_x86_shstk) (tunable_val_t *) # include <dl-cet.h> #endif +unsigned long int _dl_x86_features_tlsdesc_state_size; + static void update_active (struct cpu_features *cpu_features) { @@ -317,6 +320,7 @@ update_active (struct cpu_features *cpu_features) = xsave_state_full_size; cpu_features->xsave_state_full_size = xsave_state_full_size; + _dl_x86_features_tlsdesc_state_size = xsave_state_full_size; /* Check if XSAVEC is available. */ if (CPU_FEATURES_CPU_P (cpu_features, XSAVEC)) @@ -405,11 +409,9 @@ update_active (struct cpu_features *cpu_features) = ALIGN_UP ((amx_size + TLSDESC_CALL_REGISTER_SAVE_AREA), 64); - /* Set xsave_state_full_size to the compact AMX - state size for XSAVEC. NB: xsave_state_full_size - is only used in _dl_tlsdesc_dynamic_xsave and - _dl_tlsdesc_dynamic_xsavec. */ - cpu_features->xsave_state_full_size = amx_size; + /* Set TLSDESC state size to the compact AMX + state size for XSAVEC. */ + _dl_x86_features_tlsdesc_state_size = amx_size; #endif cpu_features->xsave_state_size = ALIGN_UP (size + TLSDESC_CALL_REGISTER_SAVE_AREA, @@ -1159,6 +1161,9 @@ no_cpuid: TUNABLE_CALLBACK (set_prefer_map_32bit_exec)); #endif + /* Do not add the logic to disable XSAVE/XSAVEC if this glibc build + requires AVX and therefore XSAVE or XSAVEC support. */ +#ifndef GCCMACRO__AVX__ bool disable_xsave_features = false; if (!CPU_FEATURE_USABLE_P (cpu_features, OSXSAVE)) @@ -1212,6 +1217,7 @@ no_cpuid: CPU_FEATURE_UNSET (cpu_features, FMA4); } +#endif #ifdef __x86_64__ GLRO(dl_hwcap) = HWCAP_X86_64; diff --git a/sysdeps/x86/cpu-tunables.c b/sysdeps/x86/cpu-tunables.c index 3423176..74cd5b9 100644 --- a/sysdeps/x86/cpu-tunables.c +++ b/sysdeps/x86/cpu-tunables.c @@ -96,7 +96,7 @@ TUNABLE_CALLBACK (set_hwcaps) (tunable_val_t *valp) GLIBC_TUNABLES=glibc.cpu.hwcaps=-xxx,yyy,-zzz,.... can be used to enable CPU/ARCH feature yyy, disable CPU/ARCH feature - yyy and zzz, where the feature name is case-sensitive and has to + xxx and zzz, where the feature name is case-sensitive and has to match the ones in cpu-features.h. It can be used by glibc developers to tune for a new processor or override the IFUNC selection to improve performance for a particular workload. @@ -164,6 +164,8 @@ TUNABLE_CALLBACK (set_hwcaps) (tunable_val_t *valp) /* Update xsave_state_size to XSAVE state size. */ cpu_features->xsave_state_size = cpu_features->xsave_state_full_size; + _dl_x86_features_tlsdesc_state_size + = cpu_features->xsave_state_full_size; CPU_FEATURE_UNSET (cpu_features, XSAVEC); } } diff --git a/sysdeps/x86/dl-diagnostics-cpu.c b/sysdeps/x86/dl-diagnostics-cpu.c index 7d03736..870b126 100644 --- a/sysdeps/x86/dl-diagnostics-cpu.c +++ b/sysdeps/x86/dl-diagnostics-cpu.c @@ -89,6 +89,8 @@ _dl_diagnostics_cpu (void) cpu_features->xsave_state_size); print_cpu_features_value ("xsave_state_full_size", cpu_features->xsave_state_full_size); + print_cpu_features_value ("tlsdesc_state_full_size", + _dl_x86_features_tlsdesc_state_size); print_cpu_features_value ("data_cache_size", cpu_features->data_cache_size); print_cpu_features_value ("shared_cache_size", cpu_features->shared_cache_size); diff --git a/sysdeps/x86/include/cpu-features.h b/sysdeps/x86/include/cpu-features.h index 9c485d3..fbf1b89 100644 --- a/sysdeps/x86/include/cpu-features.h +++ b/sysdeps/x86/include/cpu-features.h @@ -935,8 +935,6 @@ struct cpu_features /* The full state size for XSAVE when XSAVEC is disabled by GLIBC_TUNABLES=glibc.cpu.hwcaps=-XSAVEC - - and the AMX state size when XSAVEC is available. */ unsigned int xsave_state_full_size; /* Data cache size for use in memory and string routines, typically @@ -990,6 +988,13 @@ extern const struct cpu_features *_dl_x86_get_cpu_features (void) #define __get_cpu_features() _dl_x86_get_cpu_features() +#if IS_IN (rtld) || IS_IN (libc) +/* XSAVE/XSAVEC state size used by TLS descriptors. Compared to + xsave_state_size from struct cpu_features, this includes additional + registers. */ +extern unsigned long int _dl_x86_features_tlsdesc_state_size attribute_hidden; +#endif + #if defined (_LIBC) && !IS_IN (nonlib) /* Unused for x86. */ # define INIT_ARCH() diff --git a/sysdeps/x86/tst-gnu2-tls2-x86-noxsave.c b/sysdeps/x86/tst-gnu2-tls2-x86-noxsave.c new file mode 100644 index 0000000..f0024c1 --- /dev/null +++ b/sysdeps/x86/tst-gnu2-tls2-x86-noxsave.c @@ -0,0 +1 @@ +#include <elf/tst-gnu2-tls2.c> diff --git a/sysdeps/x86/tst-gnu2-tls2-x86-noxsavec.c b/sysdeps/x86/tst-gnu2-tls2-x86-noxsavec.c new file mode 100644 index 0000000..f0024c1 --- /dev/null +++ b/sysdeps/x86/tst-gnu2-tls2-x86-noxsavec.c @@ -0,0 +1 @@ +#include <elf/tst-gnu2-tls2.c> diff --git a/sysdeps/x86/tst-gnu2-tls2-x86-noxsavexsavec.c b/sysdeps/x86/tst-gnu2-tls2-x86-noxsavexsavec.c new file mode 100644 index 0000000..f0024c1 --- /dev/null +++ b/sysdeps/x86/tst-gnu2-tls2-x86-noxsavexsavec.c @@ -0,0 +1 @@ +#include <elf/tst-gnu2-tls2.c> diff --git a/sysdeps/x86_64/dl-tlsdesc-dynamic.h b/sysdeps/x86_64/dl-tlsdesc-dynamic.h index 9965ddd..4f496de 100644 --- a/sysdeps/x86_64/dl-tlsdesc-dynamic.h +++ b/sysdeps/x86_64/dl-tlsdesc-dynamic.h @@ -99,7 +99,7 @@ _dl_tlsdesc_dynamic: # endif #else /* Allocate stack space of the required size to save the state. */ - sub _rtld_local_ro+RTLD_GLOBAL_RO_DL_X86_CPU_FEATURES_OFFSET+XSAVE_STATE_FULL_SIZE_OFFSET(%rip), %RSP_LP + sub _dl_x86_features_tlsdesc_state_size(%rip), %RSP_LP #endif /* Besides rdi and rsi, saved above, save rcx, rdx, r8, r9, r10 and r11. */ |