1 /* Copyright (C) 2005-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #include <errno.h>
19 #include <pthread.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22
23
24 static pthread_mutex_t m1;
25 static pthread_mutex_t m2;
26 static pthread_barrier_t b;
27
28
29 #ifndef LOCK
30 # define LOCK(m) pthread_mutex_lock (m)
31 #endif
32
33
34 static void *
35 tf (void *arg)
36 {
37 long int round = (long int) arg;
38
39 if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL) != 0)
40 {
41 printf ("%ld: setcancelstate failed\n", round);
42 exit (1);
43 }
44
45 int e = LOCK (&m1);
46 if (e != 0)
47 {
48 printf ("%ld: child: mutex_lock m1 failed with error %d\n", round, e);
49 exit (1);
50 }
51
52 e = LOCK (&m2);
53 if (e != 0)
54 {
55 printf ("%ld: child: mutex_lock m2 failed with error %d\n", round, e);
56 exit (1);
57 }
58
59 e = pthread_barrier_wait (&b);
60 if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
61 {
62 printf ("%ld: child: 1st barrier_wait failed\n", round);
63 exit (1);
64 }
65
66 e = pthread_barrier_wait (&b);
67 if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
68 {
69 printf ("%ld: child: 2nd barrier_wait failed\n", round);
70 exit (1);
71 }
72
73 pthread_testcancel ();
74
75 printf ("%ld: testcancel returned\n", round);
76 exit (1);
77 }
78
79
80 static int
81 do_test (void)
82 {
83 #ifdef PREPARE_TMO
84 PREPARE_TMO;
85 #endif
86
87 pthread_mutexattr_t a;
88 if (pthread_mutexattr_init (&a) != 0)
89 {
90 puts ("mutexattr_init failed");
91 return 1;
92 }
93 if (pthread_mutexattr_setrobust (&a, PTHREAD_MUTEX_ROBUST_NP) != 0)
94 {
95 puts ("mutexattr_setrobust failed");
96 return 1;
97 }
98
99 #ifdef ENABLE_PI
100 if (pthread_mutexattr_setprotocol (&a, PTHREAD_PRIO_INHERIT) != 0)
101 {
102 puts ("pthread_mutexattr_setprotocol failed");
103 return 1;
104 }
105 else
106 {
107 int e = pthread_mutex_init (&m1, &a);
108 if (e == ENOTSUP)
109 {
110 puts ("PI robust mutexes not supported");
111 return 0;
112 }
113 else if (e != 0)
114 {
115 puts ("mutex_init m1 failed");
116 return 1;
117 }
118 pthread_mutex_destroy (&m1);
119 }
120 #endif
121
122 #ifndef NOT_CONSISTENT
123 if (pthread_mutex_init (&m1, &a) != 0)
124 {
125 puts ("mutex_init m1 failed");
126 return 1;
127 }
128
129 if (pthread_mutex_init (&m2, &a) != 0)
130 {
131 puts ("mutex_init m2 failed");
132 return 1;
133 }
134 #endif
135
136 if (pthread_barrier_init (&b, NULL, 2) != 0)
137 {
138 puts ("barrier_init failed");
139 return 1;
140 }
141
142 for (long int round = 1; round < 5; ++round)
143 {
144 #ifdef NOT_CONSISTENT
145 if (pthread_mutex_init (&m1 , &a) != 0)
146 {
147 puts ("mutex_init m1 failed");
148 return 1;
149 }
150 if (pthread_mutex_init (&m2 , &a) != 0)
151 {
152 puts ("mutex_init m2 failed");
153 return 1;
154 }
155 #endif
156
157 pthread_t th;
158 if (pthread_create (&th, NULL, tf, (void *) round) != 0)
159 {
160 printf ("%ld: create failed\n", round);
161 return 1;
162 }
163
164 int e = pthread_barrier_wait (&b);
165 if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
166 {
167 printf ("%ld: parent: 1st barrier_wait failed\n", round);
168 return 1;
169 }
170
171 if (pthread_cancel (th) != 0)
172 {
173 printf ("%ld: cancel failed\n", round);
174 return 1;
175 }
176
177 e = pthread_barrier_wait (&b);
178 if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
179 {
180 printf ("%ld: parent: 2nd barrier_wait failed\n", round);
181 return 1;
182 }
183
184 #ifndef AFTER_JOIN
185 if (round & 1)
186 #endif
187 {
188 void *res;
189 if (pthread_join (th, &res) != 0)
190 {
191 printf ("%ld: join failed\n", round);
192 return 1;
193 }
194 if (res != PTHREAD_CANCELED)
195 {
196 printf ("%ld: thread not canceled\n", round);
197 return 1;
198 }
199 }
200
201 e = LOCK (&m1);
202 if (e == 0)
203 {
204 printf ("%ld: parent: mutex_lock m1 succeeded\n", round);
205 return 1;
206 }
207 if (e != EOWNERDEAD)
208 {
209 printf ("%ld: parent: mutex_lock m1 returned wrong code\n", round);
210 return 1;
211 }
212
213 e = LOCK (&m2);
214 if (e == 0)
215 {
216 printf ("%ld: parent: mutex_lock m2 succeeded\n", round);
217 return 1;
218 }
219 if (e != EOWNERDEAD)
220 {
221 printf ("%ld: parent: mutex_lock m2 returned wrong code\n", round);
222 return 1;
223 }
224
225 #ifndef AFTER_JOIN
226 if ((round & 1) == 0)
227 {
228 void *res;
229 if (pthread_join (th, &res) != 0)
230 {
231 printf ("%ld: join failed\n", round);
232 return 1;
233 }
234 if (res != PTHREAD_CANCELED)
235 {
236 printf ("%ld: thread not canceled\n", round);
237 return 1;
238 }
239 }
240 #endif
241
242 #ifndef NOT_CONSISTENT
243 e = pthread_mutex_consistent (&m1);
244 if (e != 0)
245 {
246 printf ("%ld: mutex_consistent m1 failed with error %d\n", round, e);
247 return 1;
248 }
249
250 e = pthread_mutex_consistent (&m2);
251 if (e != 0)
252 {
253 printf ("%ld: mutex_consistent m2 failed with error %d\n", round, e);
254 return 1;
255 }
256 #endif
257
258 e = pthread_mutex_unlock (&m1);
259 if (e != 0)
260 {
261 printf ("%ld: mutex_unlock m1 failed with %d\n", round, e);
262 return 1;
263 }
264
265 e = pthread_mutex_unlock (&m2);
266 if (e != 0)
267 {
268 printf ("%ld: mutex_unlock m2 failed with %d\n", round, e);
269 return 1;
270 }
271
272 #ifdef NOT_CONSISTENT
273 e = LOCK (&m1);
274 if (e == 0)
275 {
276 printf ("%ld: locking inconsistent mutex m1 succeeded\n", round);
277 return 1;
278 }
279 if (e != ENOTRECOVERABLE)
280 {
281 printf ("%ld: locking inconsistent mutex m1 failed with error %d\n",
282 round, e);
283 return 1;
284 }
285
286 if (pthread_mutex_destroy (&m1) != 0)
287 {
288 puts ("mutex_destroy m1 failed");
289 return 1;
290 }
291
292 e = LOCK (&m2);
293 if (e == 0)
294 {
295 printf ("%ld: locking inconsistent mutex m2 succeeded\n", round);
296 return 1;
297 }
298 if (e != ENOTRECOVERABLE)
299 {
300 printf ("%ld: locking inconsistent mutex m2 failed with error %d\n",
301 round, e);
302 return 1;
303 }
304
305 if (pthread_mutex_destroy (&m2) != 0)
306 {
307 puts ("mutex_destroy m2 failed");
308 return 1;
309 }
310 #endif
311 }
312
313 #ifndef NOT_CONSISTENT
314 if (pthread_mutex_destroy (&m1) != 0)
315 {
316 puts ("mutex_destroy m1 failed");
317 return 1;
318 }
319
320 if (pthread_mutex_destroy (&m2) != 0)
321 {
322 puts ("mutex_destroy m2 failed");
323 return 1;
324 }
325 #endif
326
327 if (pthread_mutexattr_destroy (&a) != 0)
328 {
329 puts ("mutexattr_destroy failed");
330 return 1;
331 }
332
333 return 0;
334 }
335
336 #define TEST_FUNCTION do_test ()
337 #include "../test-skeleton.c"