The GNU C Library manual has details on integration of Restartable
Sequences.
+* The GNU C Library now provides the header file <sys/single_threaded.h>
+ which declares the variable __libc_single_threaded. Applications are
+ encouraged to use this variable for single-thread optimizations,
+ instead of weak references to symbols historically defined in
+ libpthread.
+
Deprecated and removed features, and other changes affecting compatibility:
* The deprecated <sys/sysctl.h> header and the sysctl function have been
tests-static-normal := tst-leaks1-static tst-array1-static tst-array5-static \
tst-dl-iter-static \
tst-tlsalign-static tst-tlsalign-extern-static \
- tst-linkall-static tst-env-setuid tst-env-setuid-tunables
+ tst-linkall-static tst-env-setuid tst-env-setuid-tunables \
+ tst-single_threaded-static tst-single_threaded-pthread-static
+
tests-static-internal := tst-tls1-static tst-tls2-static \
tst-ptrguard1-static tst-stackguard1-static \
tst-tls1-static-non-pie tst-libc_dlvsym-static
tests-static := $(tests-static-normal) $(tests-static-internal)
ifeq (yes,$(build-shared))
-tests-static += tst-tls9-static
-tst-tls9-static-ENV = \
- LD_LIBRARY_PATH=$(objpfx):$(common-objpfx):$(common-objpfx)dlfcn
+tests-static += tst-tls9-static tst-single_threaded-static-dlopen
+static-dlopen-environment = \
+ LD_LIBRARY_PATH=$(objpfx):$(common-objpfx):$(common-objpfx)dlfcn
+tst-tls9-static-ENV = $(static-dlopen-environment)
+tst-single_threaded-static-dlopen-ENV = $(static-dlopen-environment)
tests += restest1 preloadtest loadfail multiload origtest resolvfail \
constload1 order noload filter \
tst-dlopen-self tst-auditmany tst-initfinilazyfail tst-dlopenfail \
tst-dlopenfail-2 \
tst-filterobj tst-filterobj-dlopen tst-auxobj tst-auxobj-dlopen \
- tst-audit14 tst-audit15 tst-audit16
+ tst-audit14 tst-audit15 tst-audit16 \
+ tst-single_threaded tst-single_threaded-pthread
# reldep9
tests-internal += loadtest unload unload2 circleload1 \
neededtest neededtest2 neededtest3 neededtest4 \
tst-dlopenfailmod1 tst-dlopenfaillinkmod tst-dlopenfailmod2 \
tst-dlopenfailmod3 tst-ldconfig-ld-mod \
tst-filterobj-flt tst-filterobj-aux tst-filterobj-filtee \
- tst-auditlogmod-1 tst-auditlogmod-2 tst-auditlogmod-3
+ tst-auditlogmod-1 tst-auditlogmod-2 tst-auditlogmod-3 \
+ tst-single_threaded-mod1 tst-single_threaded-mod2 \
+ tst-single_threaded-mod3 tst-single_threaded-mod4
# Most modules build with _ISOMAC defined, but those filtered out
# depend on internal headers.
modules-names-tests = $(filter-out ifuncmod% tst-libc_dlvsym-dso tst-tlsmod%,\
$(objpfx)tst-auxobj-dlopen: $(libdl)
$(objpfx)tst-auxobj.out: $(objpfx)tst-filterobj-filtee.so
$(objpfx)tst-auxobj-dlopen.out: $(objpfx)tst-filterobj-filtee.so
+
+$(objpfx)tst-single_threaded: $(objpfx)tst-single_threaded-mod1.so $(libdl)
+$(objpfx)tst-single_threaded.out: \
+ $(objpfx)tst-single_threaded-mod2.so $(objpfx)tst-single_threaded-mod3.so
+$(objpfx)tst-single_threaded-static-dlopen: \
+ $(objpfx)tst-single_threaded-mod1.o $(common-objpfx)dlfcn/libdl.a
+$(objpfx)tst-single_threaded-static-dlopen.out: \
+ $(objpfx)tst-single_threaded-mod2.so
+$(objpfx)tst-single_threaded-pthread: \
+ $(objpfx)tst-single_threaded-mod1.so $(libdl) $(shared-thread-library)
+$(objpfx)tst-single_threaded-pthread.out: \
+ $(objpfx)tst-single_threaded-mod2.so $(objpfx)tst-single_threaded-mod3.so \
+ $(objpfx)tst-single_threaded-mod4.so
+$(objpfx)tst-single_threaded-pthread-static: $(static-thread-library)
#include <ctype.h>
#include <libc-early-init.h>
#include <rseq-internal.h>
+#include <sys/single_threaded.h>
void
__libc_early_init (_Bool initial)
{
/* Initialize ctype data. */
__ctype_init ();
+
/* Register rseq ABI to the kernel for the main program's libc. */
if (initial)
rseq_register_current_thread ();
+
+ /* Only the outer namespace is marked as single-threaded. */
+ __libc_single_threaded = initial;
}
--- /dev/null
+/* Test support for single-thread optimizations. Shared object 1.
+ Copyright (C) 2020 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 <sys/single_threaded.h>
+
+_Bool
+single_threaded_1 (void)
+{
+ return __libc_single_threaded;
+}
--- /dev/null
+/* Test support for single-thread optimizations. Shared object 2.
+ Copyright (C) 2020 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 <sys/single_threaded.h>
+
+_Bool
+single_threaded_2 (void)
+{
+ return __libc_single_threaded;
+}
--- /dev/null
+/* Test support for single-thread optimizations. Shared object 3.
+ Copyright (C) 2020 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 <sys/single_threaded.h>
+
+_Bool
+single_threaded_3 (void)
+{
+ return __libc_single_threaded;
+}
--- /dev/null
+/* Test support for single-thread optimizations. Shared object 4.
+ Copyright (C) 2020 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 <sys/single_threaded.h>
+
+_Bool
+single_threaded_4 (void)
+{
+ return __libc_single_threaded;
+}
--- /dev/null
+/* Test support for single-thread optimizations. With threads, static version.
+ Copyright (C) 2020 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+/* This test is a stripped-down version of
+ tst-single_threaded-pthread.c, without any loading of dynamic
+ objects. */
+
+#include <stdio.h>
+#include <support/check.h>
+#include <support/xthread.h>
+#include <sys/single_threaded.h>
+
+/* First barrier synchronizes main thread, thread 1, thread 2. */
+static pthread_barrier_t barrier1;
+
+/* Second barrier synchronizes main thread, thread 2. */
+static pthread_barrier_t barrier2;
+
+static void *
+threadfunc (void *closure)
+{
+ TEST_VERIFY (!__libc_single_threaded);
+
+ /* Wait for the main thread and the other thread. */
+ xpthread_barrier_wait (&barrier1);
+ TEST_VERIFY (!__libc_single_threaded);
+
+ /* Second thread waits on second barrier, too. */
+ if (closure != NULL)
+ xpthread_barrier_wait (&barrier2);
+ TEST_VERIFY (!__libc_single_threaded);
+
+ return NULL;
+}
+
+static int
+do_test (void)
+{
+ TEST_VERIFY (__libc_single_threaded);
+
+ /* Two threads plus main thread. */
+ xpthread_barrier_init (&barrier1, NULL, 3);
+
+ /* Main thread and second thread. */
+ xpthread_barrier_init (&barrier2, NULL, 2);
+
+ pthread_t thr1 = xpthread_create (NULL, threadfunc, NULL);
+ TEST_VERIFY (!__libc_single_threaded);
+
+ pthread_t thr2 = xpthread_create (NULL, threadfunc, &thr2);
+ TEST_VERIFY (!__libc_single_threaded);
+
+ xpthread_barrier_wait (&barrier1);
+ TEST_VERIFY (!__libc_single_threaded);
+
+ /* Join first thread. This should not bring us back into
+ single-threaded mode. */
+ xpthread_join (thr1);
+ TEST_VERIFY (!__libc_single_threaded);
+
+ /* We may be back in single-threaded mode after joining both
+ threads, but this is not guaranteed. */
+ xpthread_barrier_wait (&barrier2);
+ xpthread_join (thr2);
+ printf ("info: __libc_single_threaded after joining all threads: %d\n",
+ __libc_single_threaded);
+
+ return 0;
+}
+
+#include <support/test-driver.c>
--- /dev/null
+/* Test support for single-thread optimizations. With threads.
+ Copyright (C) 2020 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 <stddef.h>
+#include <stdio.h>
+#include <support/check.h>
+#include <support/namespace.h>
+#include <support/xdlfcn.h>
+#include <support/xthread.h>
+#include <sys/single_threaded.h>
+
+/* First barrier synchronizes main thread, thread 1, thread 2. */
+static pthread_barrier_t barrier1;
+
+/* Second barrier synchronizes main thread, thread 2. */
+static pthread_barrier_t barrier2;
+
+/* Defined in tst-single-threaded-mod1.so. */
+_Bool single_threaded_1 (void);
+
+/* Initialized via dlsym. */
+static _Bool (*single_threaded_2) (void);
+static _Bool (*single_threaded_3) (void);
+static _Bool (*single_threaded_4) (void);
+
+static void *
+threadfunc (void *closure)
+{
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+
+ /* Wait until the main thread loads more functions. */
+ xpthread_barrier_wait (&barrier1);
+
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ TEST_VERIFY (!single_threaded_3 ());
+ TEST_VERIFY (!single_threaded_4 ());
+
+ /* Second thread waits on second barrier, too. */
+ if (closure != NULL)
+ xpthread_barrier_wait (&barrier2);
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ TEST_VERIFY (!single_threaded_3 ());
+ TEST_VERIFY (!single_threaded_4 ());
+
+ return NULL;
+}
+
+/* Used for closure arguments to the subprocess function. */
+static char expected_false = 0;
+static char expected_true = 1;
+
+/* A subprocess inherits currently inherits the single-threaded state
+ of the parent process. */
+static void
+subprocess (void *closure)
+{
+ const char *expected = closure;
+ TEST_COMPARE (__libc_single_threaded, *expected);
+ TEST_COMPARE (single_threaded_1 (), *expected);
+ if (single_threaded_2 != NULL)
+ TEST_COMPARE (single_threaded_2 (), *expected);
+ if (single_threaded_3 != NULL)
+ TEST_COMPARE (single_threaded_3 (), *expected);
+ if (single_threaded_4 != NULL)
+ TEST_VERIFY (!single_threaded_4 ());
+}
+
+static int
+do_test (void)
+{
+ printf ("info: main __libc_single_threaded address: %p\n",
+ &__libc_single_threaded);
+ TEST_VERIFY (__libc_single_threaded);
+ TEST_VERIFY (single_threaded_1 ());
+ support_isolate_in_subprocess (subprocess, &expected_true);
+
+ void *handle_mod2 = xdlopen ("tst-single_threaded-mod2.so", RTLD_LAZY);
+ single_threaded_2 = xdlsym (handle_mod2, "single_threaded_2");
+ TEST_VERIFY (single_threaded_2 ());
+
+ /* Two threads plus main thread. */
+ xpthread_barrier_init (&barrier1, NULL, 3);
+
+ /* Main thread and second thread. */
+ xpthread_barrier_init (&barrier2, NULL, 2);
+
+ pthread_t thr1 = xpthread_create (NULL, threadfunc, NULL);
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ support_isolate_in_subprocess (subprocess, &expected_false);
+
+ pthread_t thr2 = xpthread_create (NULL, threadfunc, &thr2);
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ support_isolate_in_subprocess (subprocess, &expected_false);
+
+ /* Delayed library load, while already multi-threaded. */
+ void *handle_mod3 = xdlopen ("tst-single_threaded-mod3.so", RTLD_LAZY);
+ single_threaded_3 = xdlsym (handle_mod3, "single_threaded_3");
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ TEST_VERIFY (!single_threaded_3 ());
+ support_isolate_in_subprocess (subprocess, &expected_false);
+
+ /* Same with dlmopen. */
+ void *handle_mod4 = dlmopen (LM_ID_NEWLM, "tst-single_threaded-mod4.so",
+ RTLD_LAZY);
+ single_threaded_4 = xdlsym (handle_mod4, "single_threaded_4");
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ TEST_VERIFY (!single_threaded_3 ());
+ TEST_VERIFY (!single_threaded_4 ());
+ support_isolate_in_subprocess (subprocess, &expected_false);
+
+ /* Run the newly loaded functions from the other threads as
+ well. */
+ xpthread_barrier_wait (&barrier1);
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ TEST_VERIFY (!single_threaded_3 ());
+ TEST_VERIFY (!single_threaded_4 ());
+ support_isolate_in_subprocess (subprocess, &expected_false);
+
+ /* Join first thread. This should not bring us back into
+ single-threaded mode. */
+ xpthread_join (thr1);
+ TEST_VERIFY (!__libc_single_threaded);
+ TEST_VERIFY (!single_threaded_1 ());
+ TEST_VERIFY (!single_threaded_2 ());
+ TEST_VERIFY (!single_threaded_3 ());
+ TEST_VERIFY (!single_threaded_4 ());
+ support_isolate_in_subprocess (subprocess, &expected_false);
+
+ /* We may be back in single-threaded mode after joining both
+ threads, but this is not guaranteed. */
+ xpthread_barrier_wait (&barrier2);
+ xpthread_join (thr2);
+ printf ("info: __libc_single_threaded after joining all threads: %d\n",
+ __libc_single_threaded);
+
+ xdlclose (handle_mod4);
+ xdlclose (handle_mod3);
+ xdlclose (handle_mod2);
+
+ return 0;
+}
+
+#include <support/test-driver.c>
--- /dev/null
+/* Test support for single-thread optimizations. No threads, static dlopen.
+ Copyright (C) 2020 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/>. */
+
+/* In a static dlopen scenario, the single-threaded optimization is
+ not possible because their is no globally shared dynamic linker
+ across all namespaces. */
+
+#include <stddef.h>
+#include <support/check.h>
+#include <support/xdlfcn.h>
+#include <sys/single_threaded.h>
+
+static int
+do_test (void)
+{
+ TEST_VERIFY (__libc_single_threaded);
+
+ /* Defined in tst-single-threaded-mod1.o. */
+ extern _Bool single_threaded_1 (void);
+ TEST_VERIFY (single_threaded_1 ());
+
+ /* A failed dlopen does not change the multi-threaded status. */
+ TEST_VERIFY (dlopen ("tst-single_threaded-does-not-exist.so", RTLD_LAZY)
+ == NULL);
+ TEST_VERIFY (__libc_single_threaded);
+ TEST_VERIFY (single_threaded_1 ());
+
+ /* And neither does a successful dlopen for outer (static) libc. */
+ void *handle_mod2 = xdlopen ("tst-single_threaded-mod2.so", RTLD_LAZY);
+ _Bool (*single_threaded_2) (void)
+ = xdlsym (handle_mod2, "single_threaded_2");
+ TEST_VERIFY (__libc_single_threaded);
+ TEST_VERIFY (single_threaded_1 ());
+ /* The inner libc always assumes multi-threaded use. */
+ TEST_VERIFY (!single_threaded_2 ());
+
+ xdlclose (handle_mod2);
+
+ return 0;
+}
+
+#include <support/test-driver.c>
--- /dev/null
+/* Test support for single-thread optimizations. Static, no threads.
+ Copyright (C) 2020 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 <support/check.h>
+#include <sys/single_threaded.h>
+
+static int
+do_test (void)
+{
+ TEST_VERIFY (__libc_single_threaded);
+ return 0;
+}
+
+#include <support/test-driver.c>
--- /dev/null
+/* Test support for single-thread optimizations. No threads.
+ Copyright (C) 2020 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 <stddef.h>
+#include <stdio.h>
+#include <support/check.h>
+#include <support/namespace.h>
+#include <support/xdlfcn.h>
+#include <sys/single_threaded.h>
+
+/* Defined in tst-single-threaded-mod1.so. */
+extern _Bool single_threaded_1 (void);
+
+/* Initialized via dlsym. */
+_Bool (*single_threaded_2) (void);
+_Bool (*single_threaded_3) (void);
+
+static void
+subprocess (void *closure)
+{
+ TEST_VERIFY (__libc_single_threaded);
+ TEST_VERIFY (single_threaded_1 ());
+ if (single_threaded_2 != NULL)
+ TEST_VERIFY (single_threaded_2 ());
+ if (single_threaded_3 != NULL)
+ TEST_VERIFY (!single_threaded_3 ());
+}
+
+static int
+do_test (void)
+{
+ TEST_VERIFY (__libc_single_threaded);
+ TEST_VERIFY (single_threaded_1 ());
+ support_isolate_in_subprocess (subprocess, NULL);
+
+ void *handle_mod2 = xdlopen ("tst-single_threaded-mod2.so", RTLD_LAZY);
+ single_threaded_2 = xdlsym (handle_mod2, "single_threaded_2");
+ TEST_VERIFY (single_threaded_2 ());
+ support_isolate_in_subprocess (subprocess, NULL);
+
+ /* The current implementation treats the inner namespace as
+ multi-threaded. */
+ void *handle_mod3 = dlmopen (LM_ID_NEWLM, "tst-single_threaded-mod3.so",
+ RTLD_LAZY);
+ single_threaded_3 = xdlsym (handle_mod3, "single_threaded_3");
+ TEST_VERIFY (!single_threaded_3 ());
+ support_isolate_in_subprocess (subprocess, NULL);
+
+ xdlclose (handle_mod3);
+ xdlclose (handle_mod2);
+
+ return 0;
+}
+
+#include <support/test-driver.c>
#include <atomic.h>
#include <hurd/resource.h>
+#include <sys/single_threaded.h>
#include <pt-internal.h>
#include <pthreadP.h>
sigset_t sigset;
size_t stacksize;
+ /* Avoid a data race in the multi-threaded case. */
+ if (__libc_single_threaded)
+ __libc_single_threaded = 0;
+
/* Allocate a new thread structure. */
err = __pthread_alloc (&pthread);
if (err)
--- /dev/null
+#include <misc/sys/single_threaded.h>
bits/syslog.h bits/syslog-ldbl.h bits/syslog-path.h bits/error.h \
bits/select2.h bits/hwcap.h sys/auxv.h \
sys/sysmacros.h bits/sysmacros.h bits/types/struct_iovec.h \
- bits/err-ldbl.h bits/error-ldbl.h
+ bits/err-ldbl.h bits/error-ldbl.h \
+ sys/single_threaded.h
routines := brk sbrk sstk ioctl \
readv writev preadv preadv64 pwritev pwritev64 \
fgetxattr flistxattr fremovexattr fsetxattr getxattr \
listxattr lgetxattr llistxattr lremovexattr lsetxattr \
removexattr setxattr getauxval ifunc-impl-list makedev \
- allocate_once fd_to_filename
+ allocate_once fd_to_filename single_threaded
generated += tst-error1.mtrace tst-error1-mem.out \
tst-allocate_once.mtrace tst-allocate_once-mem.out
GLIBC_2.30 {
twalk_r;
}
+ GLIBC_2.32 {
+ __libc_single_threaded;
+ }
GLIBC_PRIVATE {
__madvise;
__mktemp;
--- /dev/null
+/* Support for single-thread optimizations. Statically linked version.
+ Copyright (C) 2020 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 <sys/single_threaded.h>
+
+/* In dynamically linked programs, this variable is initialized in
+ __libc_early_init (as false for inner libcs). */
+#ifdef SHARED
+char __libc_single_threaded;
+#else
+char __libc_single_threaded = 1;
+#endif
--- /dev/null
+/* Support for single-thread optimizations.
+ Copyright (C) 2020 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/>. */
+
+#ifndef _SYS_SINGLE_THREADED_H
+#define _SYS_SINGLE_THREADED_H
+
+#include <features.h>
+
+__BEGIN_DECLS
+
+/* If this variable is non-zero, then the current thread is the only
+ thread in the process image. If it is zero, the process might be
+ multi-threaded. */
+extern char __libc_single_threaded;
+
+__END_DECLS
+
+#endif /* _SYS_SINGLE_THREADED_H */
#include <tls-setup.h>
#include <rseq-internal.h>
#include "libioP.h"
+#include <sys/single_threaded.h>
#include <shlib-compat.h>
{
STACK_VARIABLES;
+ /* Avoid a data race in the multi-threaded case. */
+ if (__libc_single_threaded)
+ __libc_single_threaded = 0;
+
const struct pthread_attr *iattr = (struct pthread_attr *) attr;
union pthread_attr_transparent default_attr;
bool destroy_default_attr = false;
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.3.4 xdr_quad_t F
GLIBC_2.3.4 xdr_u_quad_t F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 mach_print F
GLIBC_2.32 mremap F
GLIBC_2.32 thrd_current F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.31 msgctl F
GLIBC_2.31 semctl F
GLIBC_2.31 shmctl F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.31 msgctl F
GLIBC_2.31 semctl F
GLIBC_2.31 shmctl F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.31 msgctl F
GLIBC_2.31 semctl F
GLIBC_2.31 shmctl F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.31 msgctl F
GLIBC_2.31 semctl F
GLIBC_2.31 shmctl F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.32 __isoc99_vswscanfieee128 F
GLIBC_2.32 __isoc99_vwscanfieee128 F
GLIBC_2.32 __isoc99_wscanfieee128 F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __obstack_printf_chkieee128 F
GLIBC_2.32 __obstack_printfieee128 F
GLIBC_2.32 __obstack_vprintf_chkieee128 F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.31 msgctl F
GLIBC_2.31 semctl F
GLIBC_2.31 shmctl F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.31 msgctl F
GLIBC_2.31 semctl F
GLIBC_2.31 shmctl F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
GLIBC_2.30 gettid F
GLIBC_2.30 tgkill F
GLIBC_2.30 twalk_r F
+GLIBC_2.32 __libc_single_threaded D 0x1
GLIBC_2.32 __rseq_abi T 0x20
GLIBC_2.32 pthread_attr_getsigmask_np F
GLIBC_2.32 pthread_attr_setaffinity_np F
projects / platform / upstream / glibc.git / commitdiff