GIT update of https://sourceware.org/git/glibc.git/release/2.37/master from glibc-2.37
GIT update of https://sourceware.org/git/glibc.git/release/2.37/master from glibc-2.37
Gbp-Pq: Name git-updates.diff
Please send GNU C library bug reports via <https://sourceware.org/bugzilla/>
using `glibc' in the "product" field.
\f
+Version 2.37.1
+
+Security related changes:
+
+ CVE-2023-25139: When the printf family of functions is called with a
+ format specifier that uses an <apostrophe> (enable grouping) and a
+ minimum width specifier, the resulting output could be larger than
+ reasonably expected by a caller that computed a tight bound on the
+ buffer size. The resulting larger than expected output could result
+ in a buffer overflow in the printf family of functions.
+
+The following bugs are resolved with this release:
+
+ [20975] Deferred cancellation triggers in __check_pf and looses lock leading to deadlock
+ [27576] gmon: improve mcount overflow handling
+ [29444] gmon: Fix allocated buffer overflow (bug 29444)
+ [30053] time: strftime %s returns -1 after 2038 on 32 bits systems
+ [30101] gmon: fix memory corruption issues
+ [30125] dynamic-link: [regression, bisected] glibc-2.37 creates new
+ symlink for libraries without soname
+ [30151] gshadow: Matching sgetsgent, sgetsgent_r ERANGE handling
+ [30163] posix: Fix system blocks SIGCHLD erroneously
+ [30305] x86_64: Fix asm constraints in feraiseexcept
+ [30477] libc: [RISCV]: time64 does not work on riscv32
+ [30515] _dl_find_object incorrectly returns 1 during early startup
+\f
Version 2.37
Major new features:
coincides with offset change
[30039] stdio: __vsprintf_internal does not handle unspecified buffer
length in fortify mode
+ [30804] F_GETLK, F_SETLK, and F_SETLKW value change for powerpc64 with
+ -D_FILE_OFFSET_BITS=64
\f
Version 2.36
tests-special += \
$(objpfx)noload-mem.out \
$(objpfx)tst-ldconfig-X.out \
+ $(objpfx)tst-ldconfig-p.out \
+ $(objpfx)tst-ldconfig-soname.out \
$(objpfx)tst-leaks1-mem.out \
$(objpfx)tst-rtld-help.out \
# tests-special
tst-initorderb2 \
tst-latepthreadmod \
tst-ldconfig-ld-mod \
+ tst-ldconfig-soname-lib-with-soname \
+ tst-ldconfig-soname-lib-without-soname \
tst-main1mod \
tst-nodelete2mod \
tst-nodelete-dlclose-dso \
'$(run-program-env)' > $@; \
$(evaluate-test)
+$(objpfx)tst-ldconfig-p.out : tst-ldconfig-p.sh $(objpfx)ldconfig
+ $(SHELL) $< '$(common-objpfx)' '$(test-wrapper-env)' \
+ '$(run-program-env)' > $@; \
+ $(evaluate-test)
+
+LDFLAGS-tst-ldconfig-soname-lib-with-soname.so = \
+ -Wl,-soname,libtst-ldconfig-soname-lib-with-soname.so.1
+
+$(objpfx)tst-ldconfig-soname.out : tst-ldconfig-soname.sh \
+ $(objpfx)ldconfig \
+ $(objpfx)tst-ldconfig-soname-lib-with-soname.so \
+ $(objpfx)tst-ldconfig-soname-lib-without-soname.so
+ $(SHELL) $< '$(common-objpfx)' '$(test-wrapper-env)' \
+ '$(run-program-env)' > $@; \
+ $(evaluate-test)
+
# Test static linking of all the libraries we can possibly link
# together. Note that in some configurations this may be less than the
# complete list of libraries we build but we try to maxmimize this list.
void
_dl_audit_symbind (struct link_map *l, struct reloc_result *reloc_result,
- const ElfW(Sym) *defsym, DL_FIXUP_VALUE_TYPE *value,
- lookup_t result)
+ const void *reloc, const ElfW(Sym) *defsym,
+ DL_FIXUP_VALUE_TYPE *value, lookup_t result, bool lazy)
{
bool for_jmp_slot = reloc_result == NULL;
}
if (flags & LA_SYMB_ALTVALUE)
- DL_FIXUP_BINDNOW_RELOC (value, new_value, sym.st_value);
+ DL_FIXUP_BINDNOW_RELOC (l, reloc, value, new_value, sym.st_value, lazy);
}
void
struct dl_find_object_internal internal;
_dl_find_object_from_map (l, &internal);
_dl_find_object_to_external (&internal, result);
- return 1;
+ return 0;
}
/* Object not found. */
unsigned int init = atomic_load_acquire (&reloc_result->init);
if (init == 0)
{
- _dl_audit_symbind (l, reloc_result, sym, &value, result);
+ _dl_audit_symbind (l, reloc_result, reloc, sym, &value, result, true);
/* Store the result for later runs. */
if (__glibc_likely (! GLRO(dl_bind_not)))
auditing libraries the possibility to change the value and
tell us whether further auditing is wanted. */
if (defsym != NULL && GLRO(dl_naudit) > 0)
- _dl_audit_symbind (l, reloc_result, defsym, &value, result);
+ _dl_audit_symbind (l, reloc_result, reloc, defsym, &value, result,
+ true);
#endif
/* Store the result for later runs. */
default: 2
}
}
+
+ gmon {
+ minarcs {
+ type: INT_32
+ minval: 50
+ default: 50
+ }
+ maxarcs {
+ type: INT_32
+ minval: 50
+ default: 1048576
+ }
+ }
}
= RESOLVE_MAP (map, scope, &sym, rversion,
ELF_MACHINE_JMP_SLOT);
if (sym != NULL)
- _dl_audit_symbind (map, NULL, sym, r_addr_arg, sym_map);
+ _dl_audit_symbind (map, NULL, r, sym, r_addr_arg, sym_map,
+ false);
}
#endif
}
(struct r_found_version *) NULL,
ELF_MACHINE_JMP_SLOT);
if (sym != NULL)
- _dl_audit_symbind (map, NULL , sym,r_addr_arg, sym_map);
+ _dl_audit_symbind (map, NULL, r, sym,r_addr_arg, sym_map,
+ false);
}
# endif
}
#define R_LARCH_GNU_VTINHERIT 57
#define R_LARCH_GNU_VTENTRY 58
+/* reserved 59-63 */
+
+#define R_LARCH_B16 64
+#define R_LARCH_B21 65
+#define R_LARCH_B26 66
+#define R_LARCH_ABS_HI20 67
+#define R_LARCH_ABS_LO12 68
+#define R_LARCH_ABS64_LO20 69
+#define R_LARCH_ABS64_HI12 70
+#define R_LARCH_PCALA_HI20 71
+#define R_LARCH_PCALA_LO12 72
+#define R_LARCH_PCALA64_LO20 73
+#define R_LARCH_PCALA64_HI12 74
+#define R_LARCH_GOT_PC_HI20 75
+#define R_LARCH_GOT_PC_LO12 76
+#define R_LARCH_GOT64_PC_LO20 77
+#define R_LARCH_GOT64_PC_HI12 78
+#define R_LARCH_GOT_HI20 79
+#define R_LARCH_GOT_LO12 80
+#define R_LARCH_GOT64_LO20 81
+#define R_LARCH_GOT64_HI12 82
+#define R_LARCH_TLS_LE_HI20 83
+#define R_LARCH_TLS_LE_LO12 84
+#define R_LARCH_TLS_LE64_LO20 85
+#define R_LARCH_TLS_LE64_HI12 86
+#define R_LARCH_TLS_IE_PC_HI20 87
+#define R_LARCH_TLS_IE_PC_LO12 88
+#define R_LARCH_TLS_IE64_PC_LO20 89
+#define R_LARCH_TLS_IE64_PC_HI12 90
+#define R_LARCH_TLS_IE_HI20 91
+#define R_LARCH_TLS_IE_LO12 92
+#define R_LARCH_TLS_IE64_LO20 93
+#define R_LARCH_TLS_IE64_HI12 94
+#define R_LARCH_TLS_LD_PC_HI20 95
+#define R_LARCH_TLS_LD_HI20 96
+#define R_LARCH_TLS_GD_PC_HI20 97
+#define R_LARCH_TLS_GD_HI20 98
+#define R_LARCH_32_PCREL 99
+#define R_LARCH_RELAX 100
+
/* ARC specific declarations. */
/* Processor specific flags for the Ehdr e_flags field. */
goto out;
}
if (soname == NULL)
- soname = implicit_soname (libname, flag);
+ soname = xstrdup (libname);
create_links (real_path, path, libname, soname);
free (soname);
out:
}
if (soname == NULL)
- soname = implicit_soname (direntry->d_name, flag);
+ soname = xstrdup (direntry->d_name);
/* A link may just point to itself. */
if (is_link)
return ret;
}
-/* Returns made up soname if lib doesn't have explicit DT_SONAME. */
-
-char *
-implicit_soname (const char *lib, int flag)
-{
- char *soname = xstrdup (lib);
-
- /* Aout files don't have a soname, just return the name
- including the major number. */
- char *major = strstr (soname, ".so.");
- if (major)
- {
- char *dot = strstr (major + 4, ".");
- if (dot)
- *dot = '\0';
- }
- return soname;
-}
-
/* Get architecture specific version of process_elf_file. */
#include <readelflib.c>
TEST_VERIFY (dladdr1 (&_exit, &info, &extra_info, RTLD_DL_LINKMAP) != 0);
TEST_VERIFY (extra_info == handle);
+ /* Check _dl_find_object. */
+ struct dl_find_object dlfo;
+ TEST_COMPARE (_dl_find_object (__builtin_return_address (0), &dlfo), 0);
+ /* "ld.so" is seen with --enable-hardcoded-path-in-tests. */
+ if (strcmp (basename (dlfo.dlfo_link_map->l_name), "ld.so") != 0)
+ TEST_COMPARE_STRING (basename (dlfo.dlfo_link_map->l_name), LD_SO);
+ TEST_COMPARE (_dl_find_object (dlsym (handle, "environ"), &dlfo), 0);
+ TEST_COMPARE_STRING (basename (dlfo.dlfo_link_map->l_name), LIBC_SO);
+ TEST_COMPARE (_dl_find_object ((void *) 1, &dlfo), -1);
+ TEST_COMPARE (_dl_find_object ((void *) -1, &dlfo), -1);
+
/* Verify that dlmopen creates a new namespace. */
void *dlmopen_handle = xdlmopen (LM_ID_NEWLM, LIBC_SO, RTLD_NOW);
TEST_VERIFY (dlmopen_handle != handle);
--- /dev/null
+#!/bin/sh
+# Test that ldconfig -p prints something useful.
+# Copyright (C) 2023 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/>.
+
+# Check that the newly built ldconfig -p can dump the system
+# /etc/ld.so.cache file. This should always work even if the ABIs are
+# not compatible, except in a cross-endian build (that presumably
+# involves emulation when running ldconfig).
+
+common_objpfx=$1
+test_wrapper_env=$2
+run_program_env=$3
+
+if ! test -r /etc/ld.so.cache; then
+ echo "warning: /etc/ld.so.cache does not exist, test skipped"
+ exit 77
+fi
+
+testout="${common_objpfx}elf/tst-ldconfig-p.out"
+# Truncate file.
+: > "$testout"
+
+${test_wrapper_env} \
+${run_program_env} \
+${common_objpfx}elf/ldconfig -p \
+ $testroot/lib >>"$testout" 2>>"$testout"
+status=$?
+echo "info: ldconfig exit status: $status" >>"$testout"
+
+errors=0
+case $status in
+ (0)
+ if head -n 1 "$testout" | \
+ grep -q "libs found in cache \`/etc/ld.so.cache'\$" ; then
+ echo "info: initial string found" >>"$testout"
+ else
+ echo "error: initial string not found" >>"$testout"
+ errors=1
+ fi
+ if grep -q "^ libc\.so\..* => " "$testout"; then
+ echo "info: libc.so.* string found" >>"$testout"
+ else
+ echo "error: libc.so.* string not found" >>"$testout"
+ errors=1
+ fi
+ ;;
+ (1)
+ if head -n 1 "$testout" | \
+ grep -q ": Cache file has wrong endianness\.$" ; then
+ echo "info: cache file has wrong endianess" >> "$testout"
+ else
+ echo "error: unexpected ldconfig error message" >> "$testout"
+ errors=1
+ fi
+ ;;
+ (*)
+ echo "error: unexpected exit status" >> "$testout"
+ errors=1
+ ;;
+esac
+
+exit $errors
--- /dev/null
+/* This file intentionally left blank */
--- /dev/null
+/* This file intentionally left blank */
--- /dev/null
+#!/bin/sh
+# Test that ldconfig creates symlinks according to the library's soname
+# (and in particular, does not create symlinks for libraries without a soname)
+# Copyright (C) 2000-2023 Free Software Foundation, Inc.
+# Copyright The GNU Toolchain Authors.
+# This file is part of the GNU C Library.
+
+# The GNU C Library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+# The GNU C Library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+
+# You should have received a copy of the GNU Lesser General Public
+# License along with the GNU C Library; if not, see
+# <https://www.gnu.org/licenses/>.
+
+set -ex
+
+common_objpfx=$1
+test_wrapper_env=$2
+run_program_env=$3
+
+testroot="${common_objpfx}elf/bug30125-test-directory"
+cleanup () {
+ rm -rf "$testroot"
+}
+trap cleanup 0
+
+rm -rf "$testroot"
+mkdir -p $testroot/lib
+cp "${common_objpfx}elf/tst-ldconfig-soname-lib-with-soname.so" \
+ $testroot/lib/libtst-ldconfig-soname-lib-with-soname.so.1.2.3
+cp "${common_objpfx}elf/tst-ldconfig-soname-lib-without-soname.so" \
+ $testroot/lib/libtst-ldconfig-soname-lib-without-soname.so.1.2.3
+
+${test_wrapper_env} \
+${run_program_env} \
+${common_objpfx}elf/ldconfig -vn $testroot/lib
+
+LINKS=$(cd $testroot/lib && find . -type l)
+if [ "$LINKS" != "./libtst-ldconfig-soname-lib-with-soname.so.1" ]; then
+ echo "error: $0 - extra symlinks found"
+ exit 1
+fi
# Copyright (C) 1995-2023 Free Software Foundation, Inc.
+# Copyright The GNU Toolchain Authors.
# This file is part of the GNU C Library.
# The GNU C Library is free software; you can redistribute it and/or
headers := sys/gmon.h sys/gmon_out.h sys/profil.h
routines := gmon mcount profil sprofil prof-freq
-tests = tst-sprofil tst-gmon
+tests = tst-sprofil tst-gmon tst-mcleanup
ifeq ($(build-profile),yes)
tests += tst-profile-static
tests-static += tst-profile-static
tests-special += $(objpfx)tst-gmon-gprof.out
endif
+CFLAGS-tst-mcleanup.c := -fno-omit-frame-pointer -pg
+tst-mcleanup-no-pie = yes
+CRT-tst-mcleanup := $(csu-objpfx)g$(start-installed-name)
+tst-mcleanup-ENV := GMON_OUT_PREFIX=$(objpfx)tst-mcleanup.data
+ifeq ($(run-built-tests),yes)
+tests-special += $(objpfx)tst-mcleanup.out
+endif
+
CFLAGS-tst-gmon-static.c := $(PIE-ccflag) -fno-omit-frame-pointer -pg
CRT-tst-gmon-static := $(csu-objpfx)g$(static-start-installed-name)
tst-gmon-static-no-pie = yes
clean-tst-gmon-data:
rm -f $(objpfx)tst-gmon.data.*
+$(objpfx)tst-mcount-overflow.o: clean-tst-mcount-overflow-data
+clean-tst-mcount-overflow-data:
+ rm -f $(objpfx)tst-mcount-overflow.data.*
+
+$(objpfx)tst-mcount-overflow-check.out: tst-mcount-overflow-check.sh $(objpfx)tst-mcount-overflow.out
+ $(SHELL) $< $(objpfx)tst-mcount-overflow > $@; \
+ $(evaluate-test)
+
+$(objpfx)tst-mcleanup.out: clean-tst-mcleanup-data
+clean-tst-mcleanup-data:
+ rm -f $(objpfx)tst-mcleanup.data.*
+
$(objpfx)tst-gmon-gprof.out: tst-gmon-gprof.sh $(objpfx)tst-gmon.out
$(SHELL) $< $(GPROF) $(objpfx)tst-gmon $(objpfx)tst-gmon.data.* > $@; \
$(evaluate-test)
{
struct gmonparam *p = &_gmonparam;
- /* Don't change the state if we ran into an error. */
- if (p->state == GMON_PROF_ERROR)
- return;
-
- if (mode)
+ /* Treat start request as stop if error or gmon not initialized. */
+ if (mode && p->state != GMON_PROF_ERROR && p->tos != NULL)
{
/* start */
__profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale);
{
/* stop */
__profil(NULL, 0, 0, 0);
- p->state = GMON_PROF_OFF;
+ /* Don't change the state if we ran into an error. */
+ if (p->state != GMON_PROF_ERROR)
+ p->state = GMON_PROF_OFF;
}
}
libc_hidden_def (__moncontrol)
int o;
char *cp;
struct gmonparam *p = &_gmonparam;
+ long int minarcs, maxarcs;
+
+ /* No tunables, we use hardcoded defaults */
+ minarcs = MINARCS;
+ maxarcs = MAXARCS;
+
+ /*
+ * If we are incorrectly called twice in a row (without an
+ * intervening call to _mcleanup), ignore the second call to
+ * prevent leaking memory.
+ */
+ if (p->tos != NULL)
+ return;
/*
* round lowpc and highpc to multiples of the density we're using
p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER));
p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER));
p->textsize = p->highpc - p->lowpc;
+ /* This looks like a typo, but it's here to align the p->froms
+ section. */
p->kcountsize = ROUNDUP(p->textsize / HISTFRACTION, sizeof(*p->froms));
p->hashfraction = HASHFRACTION;
p->log_hashfraction = -1;
instead of integer division. Precompute shift amount. */
p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1;
}
- p->fromssize = p->textsize / HASHFRACTION;
+ p->fromssize = ROUNDUP(p->textsize / HASHFRACTION, sizeof(*p->froms));
p->tolimit = p->textsize * ARCDENSITY / 100;
- if (p->tolimit < MINARCS)
- p->tolimit = MINARCS;
- else if (p->tolimit > MAXARCS)
- p->tolimit = MAXARCS;
+ if (p->tolimit < minarcs)
+ p->tolimit = minarcs;
+ else if (p->tolimit > maxarcs)
+ p->tolimit = maxarcs;
p->tossize = p->tolimit * sizeof(struct tostruct);
cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1);
{
__moncontrol (0);
- if (_gmonparam.state != GMON_PROF_ERROR)
+ if (_gmonparam.state != GMON_PROF_ERROR && _gmonparam.tos != NULL)
write_gmon ();
/* free the memory. */
free (_gmonparam.tos);
+
+ /* reset buffer to initial state for safety */
+ memset(&_gmonparam, 0, sizeof _gmonparam);
+ /* somewhat confusingly, ON=0, OFF=3 */
+ _gmonparam.state = GMON_PROF_OFF;
}
#include <atomic.h>
+#include <not-cancel.h>
+#include <unistd.h>
+#define ERR(s) __write_nocancel (STDERR_FILENO, s, sizeof (s) - 1)
+
/*
* mcount is called on entry to each function compiled with the profiling
* switch set. _mcount(), which is declared in a machine-dependent way
return;
overflow:
p->state = GMON_PROF_ERROR;
+ ERR("mcount: call graph buffer size limit exceeded, gmon.out will not be generated\n");
return;
}
* Always allocate at least this many tostructs. This
* hides the inadequacy of the ARCDENSITY heuristic, at least
* for small programs.
+ *
+ * Value can be overridden at runtime by glibc.gmon.minarcs tunable.
*/
#define MINARCS 50
* Used to be max representable value of ARCINDEX minus 2, but now
* that ARCINDEX is a long, that's too large; we don't really want
* to allow a 48 gigabyte table.
- * The old value of 1<<16 wasn't high enough in practice for large C++
- * programs; will 1<<20 be adequate for long? FIXME
+ *
+ * Value can be overridden at runtime by glibc.gmon.maxarcs tunable.
*/
#define MAXARCS (1 << 20)
--- /dev/null
+/* Test program for repeated invocation of _mcleanup
+ Copyright The GNU Toolchain Authors.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+/* Intentionally calls _mcleanup() twice: once manually, it will be
+ called again as an atexit handler. This is incorrect use of the API,
+ but the point of the test is to make sure we don't crash when the
+ API is misused in this way. */
+
+#include <sys/gmon.h>
+
+int
+main (void)
+{
+ _mcleanup();
+ return 0;
+}
--- /dev/null
+#!/bin/sh
+# Test expected messages generated when mcount overflows
+# Copyright (C) 2017-2023 Free Software Foundation, Inc.
+# Copyright The GNU Toolchain Authors.
+# This file is part of the GNU C Library.
+
+# The GNU C Library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+# The GNU C Library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+
+# You should have received a copy of the GNU Lesser General Public
+# License along with the GNU C Library; if not, see
+# <https://www.gnu.org/licenses/>.
+
+LC_ALL=C
+export LC_ALL
+set -e
+exec 2>&1
+
+program="$1"
+
+check_msg() {
+ if ! grep -q "$1" "$program.out"; then
+ echo "FAIL: expected message not in output: $1"
+ exit 1
+ fi
+}
+
+check_msg 'monstartup: maxarcs < minarcs, setting maxarcs = minarcs'
+check_msg 'mcount: call graph buffer size limit exceeded, gmon.out will not be generated'
+
+for data_file in $1.data.*; do
+ if [ -f "$data_file" ]; then
+ echo "FAIL: expected no data files, but found $data_file"
+ exit 1
+ fi
+done
+
+echo PASS
--- /dev/null
+/* Test program to trigger mcount overflow in profiling collection.
+ Copyright (C) 2017-2023 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/>. */
+
+/* Program with sufficiently complex, yet pointless, call graph
+ that it will trigger an mcount overflow, when you set the
+ minarcs/maxarcs tunables to very low values. */
+
+#define PREVENT_TAIL_CALL asm volatile ("")
+
+/* Calls REP(n) macro 16 times, for n=0..15.
+ * You need to define REP(n) before using this.
+ */
+#define REPS \
+ REP(0) REP(1) REP(2) REP(3) REP(4) REP(5) REP(6) REP(7) \
+ REP(8) REP(9) REP(10) REP(11) REP(12) REP(13) REP(14) REP(15)
+
+/* Defines 16 leaf functions named f1_0 to f1_15 */
+#define REP(n) \
+ __attribute__ ((noinline, noclone, weak)) void f1_##n (void) {};
+REPS
+#undef REP
+
+/* Calls all 16 leaf functions f1_* in succession */
+__attribute__ ((noinline, noclone, weak)) void
+f2 (void)
+{
+# define REP(n) f1_##n();
+ REPS
+# undef REP
+ PREVENT_TAIL_CALL;
+}
+
+/* Defines 16 functions named f2_0 to f2_15, which all just call f2 */
+#define REP(n) \
+ __attribute__ ((noinline, noclone, weak)) void \
+ f2_##n (void) { f2(); PREVENT_TAIL_CALL; };
+REPS
+#undef REP
+
+__attribute__ ((noinline, noclone, weak)) void
+f3 (int count)
+{
+ for (int i = 0; i < count; ++i)
+ {
+ /* Calls f1_0(), f2_0(), f1_1(), f2_1(), f3_0(), etc */
+# define REP(n) f1_##n(); f2_##n();
+ REPS
+# undef REP
+ }
+}
+
+int
+main (void)
+{
+ f3 (1000);
+ return 0;
+}
routines = getsgent getsgnam sgetsgent fgetsgent putsgent \
getsgent_r getsgnam_r sgetsgent_r fgetsgent_r
-tests = tst-gshadow tst-putsgent tst-fgetsgent_r
+tests = tst-gshadow tst-putsgent tst-fgetsgent_r tst-sgetsgent
CFLAGS-getsgent_r.c += -fexceptions
CFLAGS-getsgent.c += -fexceptions
buffer[buflen - 1] = '\0';
sp = strncpy (buffer, string, buflen);
if (buffer[buflen - 1] != '\0')
- return ERANGE;
+ {
+ __set_errno (ERANGE);
+ return ERANGE;
+ }
}
else
sp = (char *) string;
--- /dev/null
+/* Test large input for sgetsgent (bug 30151).
+ Copyright (C) 2023 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 <gshadow.h>
+#include <stddef.h>
+#include <support/check.h>
+#include <support/support.h>
+#include <support/xmemstream.h>
+#include <stdlib.h>
+
+static int
+do_test (void)
+{
+ /* Create a shadow group with 1000 members. */
+ struct xmemstream mem;
+ xopen_memstream (&mem);
+ const char *passwd = "k+zD0nucwfxAo3sw1NXUj6K5vt5M16+X0TVGdE1uFvq5R8V7efJ";
+ fprintf (mem.out, "group-name:%s::m0", passwd);
+ for (int i = 1; i < 1000; ++i)
+ fprintf (mem.out, ",m%d", i);
+ xfclose_memstream (&mem);
+
+ /* Call sgetsgent. */
+ char *input = mem.buffer;
+ struct sgrp *e = sgetsgent (input);
+ TEST_VERIFY_EXIT (e != NULL);
+ TEST_COMPARE_STRING (e->sg_namp, "group-name");
+ TEST_COMPARE_STRING (e->sg_passwd, passwd);
+ /* No administrators. */
+ TEST_COMPARE_STRING (e->sg_adm[0], NULL);
+ /* Check the members list. */
+ for (int i = 0; i < 1000; ++i)
+ {
+ char *member = xasprintf ("m%d", i);
+ TEST_COMPARE_STRING (e->sg_mem[i], member);
+ free (member);
+ }
+ TEST_COMPARE_STRING (e->sg_mem[1000], NULL);
+
+ /* Check that putsgent brings back the input string. */
+ xopen_memstream (&mem);
+ TEST_COMPARE (putsgent (e, mem.out), 0);
+ xfclose_memstream (&mem);
+ /* Compare without the trailing '\n' that putsgent added. */
+ TEST_COMPARE (mem.buffer[mem.length - 1], '\n');
+ mem.buffer[mem.length - 1] = '\0';
+ TEST_COMPARE_STRING (mem.buffer, input);
+
+ free (mem.buffer);
+ free (input);
+ return 0;
+}
+
+#include <support/test-driver.c>
mach_msg_type_number_t codeCnt
#else /* Vanilla Mach 3.0 interface. */
integer_t exception,
- integer_t code, integer_t subcode
+ integer_t code, long_integer_t subcode
#endif
)
{
struct hurd_signal_detail
{
/* Codes from origination Mach exception_raise message. */
- integer_t exc, exc_code, exc_subcode;
+ integer_t exc, exc_code;
+ long_integer_t exc_subcode;
/* Sigcode as passed or computed from exception codes. */
- integer_t code;
+ long_integer_t code;
/* Error code as passed or extracted from exception codes. */
error_t error;
};
mach_msg_type_number_t codeCnt
#else /* Vanilla Mach 3.0 interface. */
integer_t exception,
- integer_t code, integer_t subcode
+ integer_t code, long_integer_t subcode
#endif
)
{
ftw64-time64 \
closefrom close_range
+
others := pwd
test-srcs := ftwtest ftwtest-time64
tests := test-utime test-stat test-stat2 test-lfs tst-getcwd \
tst-utimensat \
tst-closefrom \
tst-close_range \
- tst-ftw-bz28126
+ tst-ftw-bz28126 \
+ tst-fcntl-lock \
+ tst-fcntl-lock-lfs
tests-time64 := \
tst-fcntl-time64 \
--- /dev/null
+#define _FILE_OFFSET_BITS 64
+#include <io/tst-fcntl-lock.c>
--- /dev/null
+/* Test for advisory record locking.
+ Copyright (C) 2023 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program 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 General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+
+/* This is essentially the POSIX lockf. */
+
+static int
+fcntl_lockf (int fd, int cmd, off_t len)
+{
+ struct flock fl = {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_CUR,
+ .l_len = len
+ };
+
+ switch (cmd)
+ {
+ case F_TEST:
+ fl.l_type = F_RDLCK;
+ if (fcntl (fd, F_GETLK, &fl) < 0)
+ return -1;
+ if (fl.l_type == F_UNLCK || fl.l_pid == getpid ())
+ return 0;
+ errno = EACCES;
+ return -1;
+
+ case F_ULOCK:
+ fl.l_type = F_UNLCK;
+ return fcntl (fd, F_SETLK, &fl);
+
+ case F_LOCK:
+ return fcntl (fd, F_SETLKW, &fl);
+
+ case F_TLOCK:
+ return fcntl (fd, F_SETLK, &fl);
+ }
+
+ errno = EINVAL;
+ return -1;
+}
+
+static int
+fcntl64_lockf (int fd, int cmd, off64_t len64)
+ {
+ struct flock64 fl64 = {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_CUR,
+ .l_len = len64
+ };
+
+ switch (cmd)
+ {
+ case F_TEST:
+ fl64.l_type = F_RDLCK;
+ if (fcntl64 (fd, F_GETLK64, &fl64) < 0)
+ return -1;
+ if (fl64.l_type == F_UNLCK || fl64.l_pid == getpid ())
+ return 0;
+ errno = EACCES;
+ return -1;
+
+ case F_ULOCK:
+ fl64.l_type = F_UNLCK;
+ return fcntl64 (fd, F_SETLK64, &fl64);
+
+ case F_LOCK:
+ return fcntl64 (fd, F_SETLKW64, &fl64);
+
+ case F_TLOCK:
+ return fcntl64 (fd, F_SETLK64, &fl64);
+ }
+
+ errno = EINVAL;
+ return -1;
+}
+
+#define TST_LOCKFD "tst-fcntl-lock."
+#define LOCKF fcntl_lockf
+#define LOCKF64 fcntl64_lockf
+#include "tst-lockf.c"
#include <support/capture_subprocess.h>
#include <support/check.h>
+#ifndef TST_LOCKFD
+# define TST_LOCKFD "tst-lockfd."
+#endif
+#ifndef LOCKF
+# define LOCKF lockf
+#endif
+#ifndef LOCKF64
+# define LOCKF64 lockf64
+#endif
+
static char *temp_filename;
static int temp_fd;
static void
do_prepare (int argc, char **argv)
{
- temp_fd = create_temp_file ("tst-lockfd.", &temp_filename);
+ temp_fd = create_temp_file (TST_LOCKFD, &temp_filename);
TEST_VERIFY_EXIT (temp_fd != -1);
}
#define PREPARE do_prepare
{
/* Check if parent has [0, 1024) locked. */
TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0);
- TEST_COMPARE (lockf (temp_fd, F_TLOCK, 1024), -1);
+ TEST_COMPARE (LOCKF (temp_fd, F_TLOCK, 1024), -1);
TEST_COMPARE (errno, EAGAIN);
- TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1);
+ TEST_COMPARE (LOCKF (temp_fd, F_TEST, 1024), -1);
TEST_COMPARE (errno, EACCES);
/* Also Check if parent has last 1024 bytes locked. */
TEST_COMPARE (lseek (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024);
- TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), -1);
+ TEST_COMPARE (LOCKF (temp_fd, F_TEST, 1024), -1);
/* And try to lock [1024, 2048). */
TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024);
- TEST_COMPARE (lockf (temp_fd, F_LOCK, 1024), 0);
+ TEST_COMPARE (LOCKF (temp_fd, F_LOCK, 1024), 0);
/* Check if non-LFS interface cap access to 32-bif off_t. */
TEST_COMPARE (lseek64 (temp_fd, (off64_t)INT32_MAX, SEEK_SET),
(off64_t)INT32_MAX);
- TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), 0);
}
static void
{
/* Check if parent has [0, 1024) locked. */
TEST_COMPARE (lseek64 (temp_fd, 0, SEEK_SET), 0);
- TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), -1);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TLOCK, 1024), -1);
TEST_COMPARE (errno, EAGAIN);
- TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
TEST_COMPARE (errno, EACCES);
/* Also Check if parent has last 1024 bytes locked. */
TEST_COMPARE (lseek64 (temp_fd, INT32_MAX-1024, SEEK_SET), INT32_MAX-1024);
- TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
/* And try to lock [1024, 2048). */
TEST_COMPARE (lseek64 (temp_fd, 1024, SEEK_SET), 1024);
- TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
/* And also [INT32_MAX, INT32_MAX+1024). */
{
off64_t off = (off64_t)INT32_MAX;
TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off);
- TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
}
/* Check if [INT32_MAX+1024, INT64_MAX) is locked. */
{
off64_t off = (off64_t)INT32_MAX+1024;
TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off);
- TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), -1);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TLOCK, 1024), -1);
TEST_COMPARE (errno, EAGAIN);
- TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), -1);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), -1);
TEST_COMPARE (errno, EACCES);
}
}
do_test (void)
{
/* Basic tests to check if a lock can be obtained and checked. */
- TEST_COMPARE (lockf (temp_fd, F_LOCK, 1024), 0);
- TEST_COMPARE (lockf (temp_fd, F_LOCK, INT32_MAX), 0);
- TEST_COMPARE (lockf (temp_fd, F_TLOCK, 1024), 0);
- TEST_COMPARE (lockf (temp_fd, F_TEST, 1024), 0);
+ TEST_COMPARE (LOCKF (temp_fd, F_LOCK, 1024), 0);
+ TEST_COMPARE (LOCKF (temp_fd, F_LOCK, INT32_MAX), 0);
+ TEST_COMPARE (LOCKF (temp_fd, F_TLOCK, 1024), 0);
+ TEST_COMPARE (LOCKF (temp_fd, F_TEST, 1024), 0);
TEST_COMPARE (lseek (temp_fd, 1024, SEEK_SET), 1024);
- TEST_COMPARE (lockf (temp_fd, F_ULOCK, 1024), 0);
+ TEST_COMPARE (LOCKF (temp_fd, F_ULOCK, 1024), 0);
/* Parent process should have ([0, 1024), [2048, INT32_MAX)) ranges locked. */
{
struct support_capture_subprocess result;
result = support_capture_subprocess (do_test_child_lockf, NULL);
- support_capture_subprocess_check (&result, "lockf", 0, sc_allow_none);
+ support_capture_subprocess_check (&result, "LOCKF", 0, sc_allow_none);
}
if (sizeof (off_t) != sizeof (off64_t))
{
/* Check if previously locked regions with LFS symbol. */
TEST_COMPARE (lseek (temp_fd, 0, SEEK_SET), 0);
- TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0);
- TEST_COMPARE (lockf64 (temp_fd, F_TLOCK, 1024), 0);
- TEST_COMPARE (lockf64 (temp_fd, F_TEST, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TLOCK, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_TEST, 1024), 0);
/* Lock region [INT32_MAX+1024, INT64_MAX). */
off64_t off = (off64_t)INT32_MAX + 1024;
TEST_COMPARE (lseek64 (temp_fd, off, SEEK_SET), off);
- TEST_COMPARE (lockf64 (temp_fd, F_LOCK, 1024), 0);
+ TEST_COMPARE (LOCKF64 (temp_fd, F_LOCK, 1024), 0);
/* Parent process should have ([0, 1024), [2048, INT32_MAX),
[INT32_MAX+1024, INT64_MAX)) ranges locked. */
{
struct support_capture_subprocess result;
result = support_capture_subprocess (do_test_child_lockf64, NULL);
- support_capture_subprocess_check (&result, "lockf", 0, sc_allow_none);
+ support_capture_subprocess_check (&result, "LOCKF", 0, sc_allow_none);
}
}
if (__glibc_unlikely (mtag_enabled))
*(volatile char*) oldmem;
- /* Return the chunk as is whenever possible, i.e. there's enough usable space
- but not so much that we end up fragmenting the block. We use the trim
- threshold as the heuristic to decide the latter. */
- size_t usable = musable (oldmem);
- if (bytes <= usable
- && (unsigned long) (usable - bytes) <= mp_.trim_threshold)
- return oldmem;
-
/* chunk corresponding to oldmem */
const mchunkptr oldp = mem2chunk (oldmem);
+
+ /* Return the chunk as is if the request grows within usable bytes, typically
+ into the alignment padding. We want to avoid reusing the block for
+ shrinkages because it ends up unnecessarily fragmenting the address space.
+ This is also why the heuristic misses alignment padding for THP for
+ now. */
+ size_t usable = musable (oldmem);
+ if (bytes <= usable)
+ {
+ size_t difference = usable - bytes;
+ if ((unsigned long) difference < 2 * sizeof (INTERNAL_SIZE_T)
+ || (chunk_is_mmapped (oldp) && difference <= GLRO (dl_pagesize)))
+ return oldmem;
+ }
+
/* its size */
const INTERNAL_SIZE_T oldsize = chunksize (oldp);
# define __glibc_objsize(__o) __bos (__o)
#endif
+#if __USE_FORTIFY_LEVEL > 0
/* Compile time conditions to choose between the regular, _chk and _chk_warn
variants. These conditions should get evaluated to constant and optimized
away. */
? __ ## f ## _alias (__VA_ARGS__) \
: (__glibc_unsafe_len (__l, __s, __osz) \
? __ ## f ## _chk_warn (__VA_ARGS__, __osz) \
- : __ ## f ## _chk (__VA_ARGS__, __osz))) \
+ : __ ## f ## _chk (__VA_ARGS__, __osz)))
/* Fortify function f, where object size argument passed to f is the number of
elements and not total size. */
? __ ## f ## _alias (__VA_ARGS__) \
: (__glibc_unsafe_len (__l, __s, __osz) \
? __ ## f ## _chk_warn (__VA_ARGS__, (__osz) / (__s)) \
- : __ ## f ## _chk (__VA_ARGS__, (__osz) / (__s)))) \
+ : __ ## f ## _chk (__VA_ARGS__, (__osz) / (__s))))
+#endif
#if __GNUC_PREREQ (4,3)
# define __warnattr(msg) __attribute__((__warning__ (msg)))
tst-gets \
tst-grouping \
tst-grouping2 \
+ tst-grouping3 \
tst-long-dbl-fphex \
tst-memstream-string \
tst-obprintf \
$(objpfx)tst-swprintf.out: $(gen-locales)
$(objpfx)tst-vfprintf-mbs-prec.out: $(gen-locales)
$(objpfx)tst-vfprintf-width-i18n.out: $(gen-locales)
+$(objpfx)tst-grouping3.out: $(gen-locales)
endif
tst-printf-bz18872-ENV = MALLOC_TRACE=$(objpfx)tst-printf-bz18872.mtrace \
# BZ #11319 was first fixed for regular vdprintf, then reopened because
# the fortified version had the same bug.
-CFLAGS-tst-bz11319-fortify2.c += -D_FORTIFY_SOURCE=2
+CFLAGS-tst-bz11319-fortify2.c += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2
CFLAGS-tst-memstream-string.c += -fno-builtin-fprintf
--- /dev/null
+/* Test printf with grouping and padding (bug 30068)
+ Copyright (C) 2023 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 <locale.h>
+#include <stdio.h>
+#include <support/check.h>
+#include <support/support.h>
+
+static int
+do_test (void)
+{
+ char buf[80];
+
+ xsetlocale (LC_NUMERIC, "de_DE.UTF-8");
+
+ /* The format string has the following conversion specifier:
+ ' - Use thousands grouping.
+ + - The result of a signed conversion shall begin with a sign.
+ - - Left justified.
+ 13 - Minimum 13 bytes of width.
+ 9 - Minimum 9 digits of precision.
+
+ In bug 30068 the grouping characters were not accounted for in
+ the width, and were added after the fact resulting in a 15-byte
+ output instead of a 13-byte output. The two additional bytes
+ come from the locale-specific thousands separator. This increase
+ in size could result in a buffer overflow if a reasonable caller
+ calculated the size of the expected buffer using nl_langinfo to
+ determine the sie of THOUSEP in bytes.
+
+ This bug is distinct from bug 23432 which has to do with the
+ minimum precision calculation (digit based). */
+ sprintf (buf, "%+-'13.9d", 1234567);
+ TEST_COMPARE_STRING (buf, "+001.234.567 ");
+
+ return 0;
+}
+
+#include <support/test-driver.c>
bool octal_marker = (prec <= number_length && number.word != 0
&& alt && base == 8);
- prec = MAX (0, prec - (workend - string));
+ /* At this point prec_inc is the additional bytes required for the
+ specificed precision. It is 0 if the precision would not have
+ required additional bytes i.e. the number of input digits is more
+ than the precision. It is greater than zero if the precision is
+ more than the number of digits without grouping (precision only
+ considers digits). */
+ unsigned int prec_inc = MAX (0, prec - (workend - string));
if (!left)
{
- width -= number_length + prec;
+ width -= number_length + prec_inc;
if (number.word != 0 && alt && (base == 16 || base == 2))
/* Account for 0X, 0x, 0B or 0b hex or binary marker. */
Xprintf_buffer_putc (buf, spec);
}
- width += prec;
+ width += prec_inc;
Xprintf_buffer_pad (buf, L_('0'), width);
if (octal_marker)
}
else
{
+ /* Perform left justification adjustments. */
+
if (is_negative)
{
Xprintf_buffer_putc (buf, L_('-'));
if (octal_marker)
--width;
- width -= workend - string + prec;
+ /* Adjust the width by subtracting the number of bytes
+ required to represent the number with grouping characters
+ (NUMBER_LENGTH) and any additional bytes required for
+ precision. */
+ width -= number_length + prec_inc;
- Xprintf_buffer_pad (buf, L_('0'), prec);
+ Xprintf_buffer_pad (buf, L_('0'), prec_inc);
if (octal_marker)
Xprintf_buffer_putc (buf, L_('0'));
test-a64l \
test-at_quick_exit-race \
test-atexit-race \
+ test-atexit-recursive \
test-bz22786 \
test-canon \
test-canon2 \
exit (). */
while (true)
{
- struct exit_function_list *cur = *listp;
+ struct exit_function_list *cur;
+
+ restart:
+ cur = *listp;
if (cur == NULL)
{
if (__glibc_unlikely (new_exitfn_called != __new_exitfn_called))
/* The last exit function, or another thread, has registered
more exit functions. Start the loop over. */
- continue;
+ goto restart;
}
*listp = cur->next;
--- /dev/null
+/* Support file for atexit/exit, etc. race tests (BZ #27749).
+ Copyright (C) 2023 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/>. */
+
+/* Check that atexit handler registed from another handler still called. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <support/check.h>
+#include <support/xunistd.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static void
+atexit_cb (void)
+{
+}
+
+static void
+atexit_last (void)
+{
+ _exit (1);
+}
+
+static void
+atexit_recursive (void)
+{
+ atexit (&atexit_cb);
+ atexit (&atexit_last);
+}
+
+_Noreturn static void
+test_and_exit (int count)
+{
+ for (int i = 0; i < count; ++i)
+ atexit (&atexit_cb);
+ atexit (&atexit_recursive);
+ exit (0);
+}
+
+static int
+do_test (void)
+{
+ for (int i = 0; i < 100; ++i)
+ if (xfork () == 0)
+ test_and_exit (i);
+
+ for (int i = 0; i < 100; ++i)
+ {
+ int status;
+ xwaitpid (0, &status, 0);
+ if (!WIFEXITED (status))
+ FAIL_EXIT1 ("Failed iterations %d", i);
+ TEST_COMPARE (WEXITSTATUS (status), 1);
+ }
+
+ return 0;
+}
+
+#define TEST_FUNCTION do_test
+#include <support/test-driver.c>
#include <support/check.h>
#include <support/temp_file.h>
#include <support/support.h>
+#include <support/xthread.h>
#include <support/xunistd.h>
static char *tmpdir;
}
}
+static void *
+sleep_and_check_sigchld (void *closure)
+{
+ double *seconds = (double *) closure;
+ char cmd[namemax];
+ sprintf (cmd, "sleep %lf" , *seconds);
+ TEST_COMPARE (system (cmd), 0);
+
+ sigset_t blocked = {0};
+ TEST_COMPARE (sigprocmask (SIG_BLOCK, NULL, &blocked), 0);
+ TEST_COMPARE (sigismember (&blocked, SIGCHLD), 0);
+ return NULL;
+}
+
static int
do_test (void)
{
xchmod (_PATH_BSHELL, st.st_mode);
}
+ {
+ pthread_t long_sleep_thread = xpthread_create (NULL,
+ sleep_and_check_sigchld,
+ &(double) { 0.2 });
+ pthread_t short_sleep_thread = xpthread_create (NULL,
+ sleep_and_check_sigchld,
+ &(double) { 0.1 });
+ xpthread_join (short_sleep_thread);
+ xpthread_join (long_sleep_thread);
+ }
+
TEST_COMPARE (system (""), 0);
return 0;
check_hostent \
check_netent \
delayed_exit \
+ dtotimespec \
+ dtotimespec-time64 \
ignore_stderr \
next_to_fault \
oom_error \
--- /dev/null
+/* Convert double to timespec. 64-bit time support.
+ Copyright (C) 2011-2023 Free Software Foundation, Inc.
+ This file is part of the GNU C Library and is also part of gnulib.
+ Patches to this file should be submitted to both projects.
+
+ 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 <time.h>
+
+#if __TIMESIZE != 64
+# define timespec __timespec64
+# define time_t __time64_t
+# define dtotimespec dtotimespec_time64
+# include "dtotimespec.c"
+#endif
--- /dev/null
+/* Convert double to timespec.
+ Copyright (C) 2011-2023 Free Software Foundation, Inc.
+ This file is part of the GNU C Library and is also part of gnulib.
+ Patches to this file should be submitted to both projects.
+
+ 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/>. */
+
+/* Convert the double value SEC to a struct timespec. Round toward
+ positive infinity. On overflow, return an extremal value. */
+
+#include <support/timespec.h>
+#include <intprops.h>
+
+struct timespec
+dtotimespec (double sec)
+{
+ if (sec <= TYPE_MINIMUM (time_t))
+ return make_timespec (TYPE_MINIMUM (time_t), 0);
+ else if (sec >= 1.0 + TYPE_MAXIMUM (time_t))
+ return make_timespec (TYPE_MAXIMUM (time_t), TIMESPEC_HZ - 1);
+ else
+ {
+ time_t s = sec;
+ double frac = TIMESPEC_HZ * (sec - s);
+ long ns = frac;
+ ns += ns < frac;
+ s += ns / TIMESPEC_HZ;
+ ns %= TIMESPEC_HZ;
+
+ if (ns < 0)
+ {
+ s--;
+ ns += TIMESPEC_HZ;
+ }
+
+ return make_timespec (s, ns);
+ }
+}
#include <error.h>
#include <support/support.h>
+#include <support/timespec.h>
/* Design considerations
return 0;
}
+/* Emulate the "/bin/sleep" command. No suffix support. Options are
+ ignored. */
+static int
+sleep_func (char **argv)
+{
+ if (argv[0] == NULL)
+ {
+ fprintf (stderr, "sleep: missing operand\n");
+ return 1;
+ }
+ char *endptr = NULL;
+ double sec = strtod (argv[0], &endptr);
+ if (endptr == argv[0] || errno == ERANGE || sec < 0)
+ {
+ fprintf (stderr, "sleep: invalid time interval '%s'\n", argv[0]);
+ return 1;
+ }
+ struct timespec ts = dtotimespec (sec);
+ if (nanosleep (&ts, NULL) < 0)
+ {
+ fprintf (stderr, "sleep: failed to nanosleep: %s\n", strerror (errno));
+ return 1;
+ }
+ return 0;
+}
+
/* This is a list of all the built-in commands we understand. */
static struct {
const char *name;
{ "cp", copy_func },
{ "exit", exit_func },
{ "kill", kill_func },
+ { "sleep", sleep_func },
{ NULL, NULL }
};
struct timespec observed,
double lower_bound, double upper_bound);
+struct timespec dtotimespec (double sec) __attribute__((const));
+
#else
struct timespec __REDIRECT (timespec_add, (struct timespec, struct timespec),
timespec_add_time64);
double lower_bound,
double upper_bound),
support_timespec_check_in_range_time64);
+
+struct timespec __REDIRECT (dtotimespec, (double sec), dtotimespec_time64);
#endif
/* Check that the timespec on the left represents a time before the
#define DL_FIXUP_VALUE_ADDR(value) (value)
#define DL_FIXUP_ADDR_VALUE(addr) (addr)
#define DL_FIXUP_BINDNOW_ADDR_VALUE(addr) (addr)
-#define DL_FIXUP_BINDNOW_RELOC(value, new_value, st_value) \
+#define DL_FIXUP_BINDNOW_RELOC(l, reloc, value, new_value, st_value, lazy) \
(*value) = st_value;
const char *lib, int *flag, unsigned int *isa_level,
char **soname, int is_link, struct stat *stat_buf);
-extern char *implicit_soname (const char *lib, int flag);
-
/* Declared in readelflib.c. */
extern int process_elf_file (const char *file_name, const char *lib,
int *flag, unsigned int *isa_level, char **soname,
the flags with LA_SYMB_NOPLTENTER | LA_SYMB_NOPLTEXIT prior calling
la_symbind{32,64}. */
void _dl_audit_symbind (struct link_map *l, struct reloc_result *reloc_result,
- const ElfW(Sym) *defsym, DL_FIXUP_VALUE_TYPE *value,
- lookup_t result)
+ const void *reloc, const ElfW(Sym) *defsym,
+ DL_FIXUP_VALUE_TYPE *value, lookup_t result, bool lazy)
attribute_hidden;
/* Same as _dl_audit_symbind, but also sets LA_SYMB_DLSYM flag. */
void _dl_audit_symbind_alt (struct link_map *l, const ElfW(Sym) *ref,
#define DL_FIXUP_ADDR_VALUE(addr) \
(*(DL_FIXUP_VALUE_TYPE *) ((uintptr_t) (addr) & ~2))
#define DL_FIXUP_BINDNOW_ADDR_VALUE(addr) (addr)
-#define DL_FIXUP_BINDNOW_RELOC(value, new_value, st_value) \
+#define DL_FIXUP_BINDNOW_RELOC(l, reloc, value, new_value, st_value, lazy) \
*(value) = *(DL_FIXUP_VALUE_TYPE *) ((uintptr_t) (new_value) & ~2)
#define DL_FIXUP_VALUE_ADDR(value) ((uintptr_t) &(value))
#define DL_FIXUP_ADDR_VALUE(addr) (*(struct fdesc *) (addr))
#define DL_FIXUP_BINDNOW_ADDR_VALUE(addr) (addr)
-#define DL_FIXUP_BINDNOW_RELOC(value, new_value, st_value) \
+#define DL_FIXUP_BINDNOW_RELOC(l, reloc, value, new_value, st_value, lazy) \
(*value) = *(struct fdesc *) (st_value)
as if the shell had terminated using _exit(127). */
status = W_EXITCODE (127, 0);
+ /* sigaction can not fail with SIGINT/SIGQUIT used with old
+ disposition. Same applies for sigprocmask. */
DO_LOCK ();
if (SUB_REF () == 0)
{
- /* sigaction can not fail with SIGINT/SIGQUIT used with old
- disposition. Same applies for sigprocmask. */
__sigaction (SIGINT, &intr, NULL);
__sigaction (SIGQUIT, &quit, NULL);
- __sigprocmask (SIG_SETMASK, &omask, NULL);
}
DO_UNLOCK ();
+ __sigprocmask (SIG_SETMASK, &omask, NULL);
if (ret != 0)
__set_errno (ret);
/* We need to correctly set the audit modules value for bind-now. */
# define DL_FIXUP_BINDNOW_ADDR_VALUE(addr) \
(((Elf64_FuncDesc *)(addr))->fd_func)
-# define DL_FIXUP_BINDNOW_RELOC(value, new_value, st_value) \
+# define DL_FIXUP_BINDNOW_RELOC(l, reloc, value, new_value, st_value, lazy) \
({ \
Elf64_FuncDesc *opd = (Elf64_FuncDesc *) (value); \
opd->fd_func = (st_value); \
})
#else
# define DL_FIXUP_BINDNOW_ADDR_VALUE(addr) (addr)
-# define DL_FIXUP_BINDNOW_RELOC(value, new_value, st_value) \
+# define DL_FIXUP_BINDNOW_RELOC(l, reloc, value, new_value, st_value, lazy) \
(*value) = st_value;
#endif
/* Wait indefinitely for cancellation, which only works if asynchronous
cancellation is enabled. */
-#ifdef SYS_pause
- syscall (SYS_pause);
-#elif defined SYS_ppoll || defined SYS_ppoll_time64
+#if defined SYS_ppoll || defined SYS_ppoll_time64
# ifndef SYS_ppoll_time64
# define SYS_ppoll_time64 SYS_ppoll
# endif
--- /dev/null
+/* Configuration of lookup functions. SPARC64 version.
+ Copyright (C) 2023 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/>. */
+
+/* The type of the return value of fixup/profile_fixup. */
+#define DL_FIXUP_VALUE_TYPE ElfW(Addr)
+/* Construct a value of type DL_FIXUP_VALUE_TYPE from a code address
+ and a link map. */
+#define DL_FIXUP_MAKE_VALUE(map, addr) (addr)
+/* Extract the code address from a value of type DL_FIXUP_MAKE_VALUE.
+ */
+#define DL_FIXUP_VALUE_CODE_ADDR(value) (value)
+#define DL_FIXUP_VALUE_ADDR(value) (value)
+#define DL_FIXUP_ADDR_VALUE(addr) (addr)
+#define DL_FIXUP_BINDNOW_ADDR_VALUE(addr) (addr)
+/* For bindnow, _dl_audit_symbind will be responsible to setup the final value
+ while for lazy binding _dl_fixup/_dl_profile_fixup will call the audit
+ callbacks and tail cail elf_machine_fixup_plt. */
+#ifdef __arch64__
+# define DL_SPARC_FIXUP(l, r, value, new_value) \
+ sparc64_fixup_plt (l, r, value, new_value, (r)->r_addend, 0)
+#else
+# define DL_SPARC_FIXUP(l, r, value, new_value) \
+ sparc_fixup_plt (r, value, new_value, 0, 1)
+#endif
+#define DL_FIXUP_BINDNOW_RELOC(l, reloc, value, new_value, st_value, lazy) \
+ ({ \
+ if (lazy) \
+ (*value) = st_value; \
+ else \
+ { \
+ const PLTREL *__r = (reloc); \
+ DL_SPARC_FIXUP (l, __r, value, new_value); \
+ } \
+ })
netrom/netrom.h netpacket/packet.h netrose/rose.h \
neteconet/ec.h netiucv/iucv.h
sysdep_routines += netlink_assert_response
+
+CFLAGS-check_pf.c += -fexceptions
endif
# Don't compile the ctype glue code, since there is no old non-GNU C library.
#endif
#ifndef F_GETLK
-# ifndef __USE_FILE_OFFSET64
+# if !defined __USE_FILE_OFFSET64 && __TIMESIZE != 64
# define F_GETLK 5 /* Get record locking info. */
# define F_SETLK 6 /* Set record locking info (non-blocking). */
# define F_SETLKW 7 /* Set record locking info (blocking). */
return NULL;
}
+#ifdef __EXCEPTIONS
+static void
+cancel_handler (void *arg __attribute__((unused)))
+{
+ /* Release the lock. */
+ __libc_lock_unlock (lock);
+}
+#endif
void
attribute_hidden
struct cached_data *olddata = NULL;
struct cached_data *data = NULL;
+#ifdef __EXCEPTIONS
+ /* Make sure that lock is released when the thread is cancelled. */
+ __libc_cleanup_push (cancel_handler, NULL);
+#endif
__libc_lock_lock (lock);
if (cache_valid_p ())
}
}
+#ifdef __EXCEPTIONS
+ __libc_cleanup_pop (0);
+#endif
__libc_lock_unlock (lock);
if (data != NULL)
test-xfail-check-wx-segment = *
endif # $(subdir) == elf
+
+ifeq ($(subdir),debug)
+test-xfail-tst-ssp-1 = $(have-ssp)
+endif # $(subdir) == debug
# define __O_LARGEFILE 0200000
#endif
+#if __WORDSIZE == 64 && !defined __USE_FILE_OFFSET64
+# define F_GETLK 5
+# define F_SETLK 6
+# define F_SETLKW 7
+#endif
+
struct flock
{
short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */
# MAP_ANON alias for MAP_ANONYMOUS. MAP_RENAME, MAP_AUTOGROW,
# MAP_LOCAL and MAP_AUTORSRV are in the kernel header for
# MIPS, marked as "not used by linux"; SPARC has MAP_INHERIT
- # in the kernel header, but does not use it.
+ # in the kernel header, but does not use it. The kernel
+ # header for HPPA removed a define of MAP_VARIABLE to 0 in
+ # Linux 6.2.
'MAP_HUGE_[0-9].*|MAP_UNINITIALIZED|MAP_FAILED|MAP_ANON'
- '|MAP_RENAME|MAP_AUTOGROW|MAP_LOCAL|MAP_AUTORSRV|MAP_INHERIT',
+ '|MAP_RENAME|MAP_AUTOGROW|MAP_LOCAL|MAP_AUTORSRV|MAP_INHERIT'
+ '|MAP_VARIABLE',
linux_version_glibc > linux_version_headers,
linux_version_headers > linux_version_glibc))
}
static void
-get_common_cache_info (long int *shared_ptr, unsigned int *threads_ptr,
+get_common_cache_info (long int *shared_ptr, long int * shared_per_thread_ptr, unsigned int *threads_ptr,
long int core)
{
unsigned int eax;
unsigned int family = cpu_features->basic.family;
unsigned int model = cpu_features->basic.model;
long int shared = *shared_ptr;
+ long int shared_per_thread = *shared_per_thread_ptr;
unsigned int threads = *threads_ptr;
bool inclusive_cache = true;
bool support_count_mask = true;
/* Try L2 otherwise. */
level = 2;
shared = core;
+ shared_per_thread = core;
threads_l2 = 0;
threads_l3 = -1;
}
}
else
{
-intel_bug_no_cache_info:
- /* Assume that all logical threads share the highest cache
- level. */
- threads
- = ((cpu_features->features[CPUID_INDEX_1].cpuid.ebx >> 16)
- & 0xff);
- }
-
- /* Cap usage of highest cache level to the number of supported
- threads. */
- if (shared > 0 && threads > 0)
- shared /= threads;
+ intel_bug_no_cache_info:
+ /* Assume that all logical threads share the highest cache
+ level. */
+ threads = ((cpu_features->features[CPUID_INDEX_1].cpuid.ebx >> 16)
+ & 0xff);
+ }
+ /* Get per-thread size of highest level cache. */
+ if (shared_per_thread > 0 && threads > 0)
+ shared_per_thread /= threads;
}
/* Account for non-inclusive L2 and L3 caches. */
if (!inclusive_cache)
{
- if (threads_l2 > 0)
- core /= threads_l2;
+ long int core_per_thread = threads_l2 > 0 ? (core / threads_l2) : core;
+ shared_per_thread += core_per_thread;
shared += core;
}
*shared_ptr = shared;
+ *shared_per_thread_ptr = shared_per_thread;
*threads_ptr = threads;
}
/* Find out what brand of processor. */
long int data = -1;
long int shared = -1;
+ long int shared_per_thread = -1;
long int core = -1;
unsigned int threads = 0;
unsigned long int level1_icache_size = -1;
data = handle_intel (_SC_LEVEL1_DCACHE_SIZE, cpu_features);
core = handle_intel (_SC_LEVEL2_CACHE_SIZE, cpu_features);
shared = handle_intel (_SC_LEVEL3_CACHE_SIZE, cpu_features);
+ shared_per_thread = shared;
level1_icache_size
= handle_intel (_SC_LEVEL1_ICACHE_SIZE, cpu_features);
level4_cache_size
= handle_intel (_SC_LEVEL4_CACHE_SIZE, cpu_features);
- get_common_cache_info (&shared, &threads, core);
+ get_common_cache_info (&shared, &shared_per_thread, &threads, core);
}
else if (cpu_features->basic.kind == arch_kind_zhaoxin)
{
data = handle_zhaoxin (_SC_LEVEL1_DCACHE_SIZE);
core = handle_zhaoxin (_SC_LEVEL2_CACHE_SIZE);
shared = handle_zhaoxin (_SC_LEVEL3_CACHE_SIZE);
+ shared_per_thread = shared;
level1_icache_size = handle_zhaoxin (_SC_LEVEL1_ICACHE_SIZE);
level1_icache_linesize = handle_zhaoxin (_SC_LEVEL1_ICACHE_LINESIZE);
level3_cache_assoc = handle_zhaoxin (_SC_LEVEL3_CACHE_ASSOC);
level3_cache_linesize = handle_zhaoxin (_SC_LEVEL3_CACHE_LINESIZE);
- get_common_cache_info (&shared, &threads, core);
+ get_common_cache_info (&shared, &shared_per_thread, &threads, core);
}
else if (cpu_features->basic.kind == arch_kind_amd)
{
data = handle_amd (_SC_LEVEL1_DCACHE_SIZE, cpu_features);
core = handle_amd (_SC_LEVEL2_CACHE_SIZE, cpu_features);
shared = handle_amd (_SC_LEVEL3_CACHE_SIZE, cpu_features);
+ shared_per_thread = shared;
level1_icache_size = handle_amd (_SC_LEVEL1_ICACHE_SIZE, cpu_features);
level1_icache_linesize
if (shared <= 0)
/* No shared L3 cache. All we have is the L2 cache. */
- shared = core;
+ shared = core;
+
+ if (shared_per_thread <= 0)
+ shared_per_thread = shared;
}
cpu_features->level1_icache_size = level1_icache_size;
cpu_features->level3_cache_linesize = level3_cache_linesize;
cpu_features->level4_cache_size = level4_cache_size;
- /* The default setting for the non_temporal threshold is 3/4 of one
- thread's share of the chip's cache. For most Intel and AMD processors
- with an initial release date between 2017 and 2020, a thread's typical
- share of the cache is from 500 KBytes to 2 MBytes. Using the 3/4
- threshold leaves 125 KBytes to 500 KBytes of the thread's data
- in cache after a maximum temporal copy, which will maintain
- in cache a reasonable portion of the thread's stack and other
- active data. If the threshold is set higher than one thread's
- share of the cache, it has a substantial risk of negatively
- impacting the performance of other threads running on the chip. */
- unsigned long int non_temporal_threshold = shared * 3 / 4;
+ /* The default setting for the non_temporal threshold is 1/4 of size
+ of the chip's cache. For most Intel and AMD processors with an
+ initial release date between 2017 and 2023, a thread's typical
+ share of the cache is from 18-64MB. Using the 1/4 L3 is meant to
+ estimate the point where non-temporal stores begin out-competing
+ REP MOVSB. As well the point where the fact that non-temporal
+ stores are forced back to main memory would already occurred to the
+ majority of the lines in the copy. Note, concerns about the
+ entire L3 cache being evicted by the copy are mostly alleviated
+ by the fact that modern HW detects streaming patterns and
+ provides proper LRU hints so that the maximum thrashing
+ capped at 1/associativity. */
+ unsigned long int non_temporal_threshold = shared / 4;
+
+ /* If the computed non_temporal_threshold <= 3/4 * per-thread L3, we most
+ likely have incorrect/incomplete cache info in which case, default to
+ 3/4 * per-thread L3 to avoid regressions. */
+ unsigned long int non_temporal_threshold_lowbound
+ = shared_per_thread * 3 / 4;
+ if (non_temporal_threshold < non_temporal_threshold_lowbound)
+ non_temporal_threshold = non_temporal_threshold_lowbound;
+
+ /* If no ERMS, we use the per-thread L3 chunking. Normal cacheable stores run
+ a higher risk of actually thrashing the cache as they don't have a HW LRU
+ hint. As well, their performance in highly parallel situations is
+ noticeably worse. */
+ if (!CPU_FEATURE_USABLE_P (cpu_features, ERMS))
+ non_temporal_threshold = non_temporal_threshold_lowbound;
/* SIZE_MAX >> 4 because memmove-vec-unaligned-erms right-shifts the value of
'x86_non_temporal_threshold' by `LOG_4X_MEMCPY_THRESH` (4) and it is best
if that operation cannot overflow. Minimum of 0x4040 (16448) because the
/* One example of an invalid operation is 0.0 / 0.0. */
float f = 0.0;
- __asm__ __volatile__ ("divss %0, %0 " : : "x" (f));
+ __asm__ __volatile__ ("divss %0, %0 " : "+x" (f));
(void) &f;
}
float f = 1.0;
float g = 0.0;
- __asm__ __volatile__ ("divss %1, %0" : : "x" (f), "x" (g));
+ __asm__ __volatile__ ("divss %1, %0" : "+x" (f) : "x" (g));
(void) &f;
}
tst-clock tst-clock2 tst-clock_nanosleep tst-cpuclock1 \
tst-adjtime tst-ctime tst-difftime tst-mktime4 tst-clock_settime \
tst-settimeofday tst-itimer tst-gmtime tst-timegm \
- tst-timespec_get tst-timespec_getres
+ tst-timespec_get tst-timespec_getres tst-strftime4
tests-time64 := \
tst-adjtime-time64 \
tst-itimer-time64 \
tst-mktime4-time64 \
tst-settimeofday-time64 \
+ tst-strftime4-time64 \
tst-timegm-time64 \
tst-timespec_get-time64 \
tst-timespec_getres-time64 \
#ifdef _LIBC
# define tzname __tzname
# define tzset __tzset
+
+# define time_t __time64_t
+# define __gmtime_r(t, tp) __gmtime64_r (t, tp)
+# define mktime(tp) __mktime64 (tp)
#endif
#if !HAVE_TM_GMTOFF
#ifdef _LIBC
# define HAVE_LOCALTIME_R 0
# include "../locale/localeinfo.h"
-#endif
+# define time_t __time64_t
+# define __localtime_r(t, tp) __localtime64_r (t, tp)
+#endif
#if ! HAVE_LOCALTIME_R && ! defined localtime_r
# ifdef _LIBC
--- /dev/null
+#include "tst-strftime4.c"
--- /dev/null
+/* Test strftime and strptime after 2038-01-19 03:14:07 UTC (bug 30053).
+ Copyright (C) 2023 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 <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <support/check.h>
+
+static int
+do_test (void)
+{
+ TEST_VERIFY_EXIT (setenv ("TZ", "UTC0", 1) == 0);
+ tzset ();
+ if (sizeof (time_t) > 4)
+ {
+ time_t wrap = (time_t) 2147483648LL;
+ char buf[80];
+ struct tm *tm = gmtime (&wrap);
+ TEST_VERIFY_EXIT (tm != NULL);
+ TEST_VERIFY_EXIT (strftime (buf, sizeof buf, "%s", tm) > 0);
+ puts (buf);
+ TEST_VERIFY (strcmp (buf, "2147483648") == 0);
+
+ struct tm tm2;
+ char *p = strptime (buf, "%s", &tm2);
+ TEST_VERIFY_EXIT (p != NULL && *p == '\0');
+ time_t t = mktime (&tm2);
+ printf ("%lld\n", (long long) t);
+ TEST_VERIFY (t == wrap);
+ }
+ else
+ FAIL_UNSUPPORTED ("32-bit time_t");
+ return 0;
+}
+
+#include <support/test-driver.c>
projects / glibc.git / commitdiff