1/* Test support for single-thread optimizations. With threads.
2 Copyright (C) 2020-2022 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19#include <stddef.h>
20#include <stdio.h>
21#include <support/check.h>
22#include <support/namespace.h>
23#include <support/xdlfcn.h>
24#include <support/xthread.h>
25#include <sys/single_threaded.h>
26
27/* First barrier synchronizes main thread, thread 1, thread 2. */
28static pthread_barrier_t barrier1;
29
30/* Second barrier synchronizes main thread, thread 2. */
31static pthread_barrier_t barrier2;
32
33/* Defined in tst-single-threaded-mod1.so. */
34_Bool single_threaded_1 (void);
35
36/* Initialized via dlsym. */
37static _Bool (*single_threaded_2) (void);
38static _Bool (*single_threaded_3) (void);
39static _Bool (*single_threaded_4) (void);
40
41static void *
42threadfunc (void *closure)
43{
44 TEST_VERIFY (!__libc_single_threaded);
45 TEST_VERIFY (!single_threaded_1 ());
46 TEST_VERIFY (!single_threaded_2 ());
47
48 /* Wait until the main thread loads more functions. */
49 xpthread_barrier_wait (barrier: &barrier1);
50
51 TEST_VERIFY (!__libc_single_threaded);
52 TEST_VERIFY (!single_threaded_1 ());
53 TEST_VERIFY (!single_threaded_2 ());
54 TEST_VERIFY (!single_threaded_3 ());
55 TEST_VERIFY (!single_threaded_4 ());
56
57 /* Second thread waits on second barrier, too. */
58 if (closure != NULL)
59 xpthread_barrier_wait (barrier: &barrier2);
60 TEST_VERIFY (!__libc_single_threaded);
61 TEST_VERIFY (!single_threaded_1 ());
62 TEST_VERIFY (!single_threaded_2 ());
63 TEST_VERIFY (!single_threaded_3 ());
64 TEST_VERIFY (!single_threaded_4 ());
65
66 return NULL;
67}
68
69/* Used for closure arguments to the subprocess function. */
70static char expected_false = 0;
71static char expected_true = 1;
72
73/* A subprocess inherits currently inherits the single-threaded state
74 of the parent process. */
75static void
76subprocess (void *closure)
77{
78 const char *expected = closure;
79 TEST_COMPARE (__libc_single_threaded, *expected);
80 TEST_COMPARE (single_threaded_1 (), *expected);
81 if (single_threaded_2 != NULL)
82 TEST_COMPARE (single_threaded_2 (), *expected);
83 if (single_threaded_3 != NULL)
84 TEST_COMPARE (single_threaded_3 (), *expected);
85 if (single_threaded_4 != NULL)
86 TEST_VERIFY (!single_threaded_4 ());
87}
88
89static int
90do_test (void)
91{
92 printf (format: "info: main __libc_single_threaded address: %p\n",
93 &__libc_single_threaded);
94 TEST_VERIFY (__libc_single_threaded);
95 TEST_VERIFY (single_threaded_1 ());
96 support_isolate_in_subprocess (callback: subprocess, closure: &expected_true);
97
98 void *handle_mod2 = xdlopen (filename: "tst-single_threaded-mod2.so", RTLD_LAZY);
99 single_threaded_2 = xdlsym (handle: handle_mod2, symbol: "single_threaded_2");
100 TEST_VERIFY (single_threaded_2 ());
101
102 /* Two threads plus main thread. */
103 xpthread_barrier_init (barrier: &barrier1, NULL, count: 3);
104
105 /* Main thread and second thread. */
106 xpthread_barrier_init (barrier: &barrier2, NULL, count: 2);
107
108 pthread_t thr1 = xpthread_create (NULL, thread_func: threadfunc, NULL);
109 TEST_VERIFY (!__libc_single_threaded);
110 TEST_VERIFY (!single_threaded_1 ());
111 TEST_VERIFY (!single_threaded_2 ());
112 support_isolate_in_subprocess (callback: subprocess, closure: &expected_false);
113
114 pthread_t thr2 = xpthread_create (NULL, thread_func: threadfunc, closure: &thr2);
115 TEST_VERIFY (!__libc_single_threaded);
116 TEST_VERIFY (!single_threaded_1 ());
117 TEST_VERIFY (!single_threaded_2 ());
118 support_isolate_in_subprocess (callback: subprocess, closure: &expected_false);
119
120 /* Delayed library load, while already multi-threaded. */
121 void *handle_mod3 = xdlopen (filename: "tst-single_threaded-mod3.so", RTLD_LAZY);
122 single_threaded_3 = xdlsym (handle: handle_mod3, symbol: "single_threaded_3");
123 TEST_VERIFY (!__libc_single_threaded);
124 TEST_VERIFY (!single_threaded_1 ());
125 TEST_VERIFY (!single_threaded_2 ());
126 TEST_VERIFY (!single_threaded_3 ());
127 support_isolate_in_subprocess (callback: subprocess, closure: &expected_false);
128
129 /* Same with dlmopen. */
130 void *handle_mod4 = dlmopen (LM_ID_NEWLM, file: "tst-single_threaded-mod4.so",
131 RTLD_LAZY);
132 single_threaded_4 = xdlsym (handle: handle_mod4, symbol: "single_threaded_4");
133 TEST_VERIFY (!__libc_single_threaded);
134 TEST_VERIFY (!single_threaded_1 ());
135 TEST_VERIFY (!single_threaded_2 ());
136 TEST_VERIFY (!single_threaded_3 ());
137 TEST_VERIFY (!single_threaded_4 ());
138 support_isolate_in_subprocess (callback: subprocess, closure: &expected_false);
139
140 /* Run the newly loaded functions from the other threads as
141 well. */
142 xpthread_barrier_wait (barrier: &barrier1);
143 TEST_VERIFY (!__libc_single_threaded);
144 TEST_VERIFY (!single_threaded_1 ());
145 TEST_VERIFY (!single_threaded_2 ());
146 TEST_VERIFY (!single_threaded_3 ());
147 TEST_VERIFY (!single_threaded_4 ());
148 support_isolate_in_subprocess (callback: subprocess, closure: &expected_false);
149
150 /* Join first thread. This should not bring us back into
151 single-threaded mode. */
152 xpthread_join (thr: thr1);
153 TEST_VERIFY (!__libc_single_threaded);
154 TEST_VERIFY (!single_threaded_1 ());
155 TEST_VERIFY (!single_threaded_2 ());
156 TEST_VERIFY (!single_threaded_3 ());
157 TEST_VERIFY (!single_threaded_4 ());
158 support_isolate_in_subprocess (callback: subprocess, closure: &expected_false);
159
160 /* We may be back in single-threaded mode after joining both
161 threads, but this is not guaranteed. */
162 xpthread_barrier_wait (barrier: &barrier2);
163 xpthread_join (thr: thr2);
164 printf (format: "info: __libc_single_threaded after joining all threads: %d\n",
165 __libc_single_threaded);
166
167 xdlclose (handle: handle_mod4);
168 xdlclose (handle: handle_mod3);
169 xdlclose (handle: handle_mod2);
170
171 return 0;
172}
173
174#include <support/test-driver.c>
175

source code of glibc/elf/tst-single_threaded-pthread.c