1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /******************************************************************************
3 *
4 * Copyright © International Business Machines Corp., 2006-2008
5 *
6 * DESCRIPTION
7 * This test excercises the futex syscall op codes needed for requeuing
8 * priority inheritance aware POSIX condition variables and mutexes.
9 *
10 * AUTHORS
11 * Sripathi Kodi <sripathik@in.ibm.com>
12 * Darren Hart <dvhart@linux.intel.com>
13 *
14 * HISTORY
15 * 2008-Jan-13: Initial version by Sripathi Kodi <sripathik@in.ibm.com>
16 * 2009-Nov-6: futex test adaptation by Darren Hart <dvhart@linux.intel.com>
17 *
18 *****************************************************************************/
19
20 #define _GNU_SOURCE
21
22 #include <errno.h>
23 #include <limits.h>
24 #include <pthread.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <signal.h>
28 #include <string.h>
29
30 #include "atomic.h"
31 #include "futextest.h"
32 #include "../../kselftest_harness.h"
33
34 #define MAX_WAKE_ITERS 1000
35 #define THREAD_MAX 10
36 #define SIGNAL_PERIOD_US 100
37
38 atomic_t waiters_blocked = ATOMIC_INITIALIZER;
39 atomic_t waiters_woken = ATOMIC_INITIALIZER;
40
41 futex_t f1 = FUTEX_INITIALIZER;
42 futex_t f2 = FUTEX_INITIALIZER;
43 futex_t wake_complete = FUTEX_INITIALIZER;
44
45 struct thread_arg {
46 long id;
47 struct timespec *timeout;
48 int lock;
49 int ret;
50 };
51 #define THREAD_ARG_INITIALIZER { 0, NULL, 0, 0 }
52
FIXTURE(args)53 FIXTURE(args)
54 {
55 };
56
FIXTURE_SETUP(args)57 FIXTURE_SETUP(args)
58 {
59 };
60
FIXTURE_TEARDOWN(args)61 FIXTURE_TEARDOWN(args)
62 {
63 };
64
FIXTURE_VARIANT(args)65 FIXTURE_VARIANT(args)
66 {
67 long timeout_ns;
68 bool broadcast;
69 bool owner;
70 bool locked;
71 };
72
73 /*
74 * For a given timeout value, this macro creates a test input with all the
75 * possible combinations of valid arguments
76 */
77 #define FIXTURE_VARIANT_ADD_TIMEOUT(timeout) \
78 \
79 FIXTURE_VARIANT_ADD(args, t_##timeout) \
80 { \
81 .timeout_ns = timeout, \
82 }; \
83 \
84 FIXTURE_VARIANT_ADD(args, t_##timeout##_broadcast) \
85 { \
86 .timeout_ns = timeout, \
87 .broadcast = true, \
88 }; \
89 \
90 FIXTURE_VARIANT_ADD(args, t_##timeout##_broadcast_locked) \
91 { \
92 .timeout_ns = timeout, \
93 .broadcast = true, \
94 .locked = true, \
95 }; \
96 \
97 FIXTURE_VARIANT_ADD(args, t_##timeout##_broadcast_owner) \
98 { \
99 .timeout_ns = timeout, \
100 .broadcast = true, \
101 .owner = true, \
102 }; \
103 \
104 FIXTURE_VARIANT_ADD(args, t_##timeout##_locked) \
105 { \
106 .timeout_ns = timeout, \
107 .locked = true, \
108 }; \
109 \
110 FIXTURE_VARIANT_ADD(args, t_##timeout##_owner) \
111 { \
112 .timeout_ns = timeout, \
113 .owner = true, \
114 }; \
115
116 FIXTURE_VARIANT_ADD_TIMEOUT(0);
117 FIXTURE_VARIANT_ADD_TIMEOUT(5000);
118 FIXTURE_VARIANT_ADD_TIMEOUT(500000);
119 FIXTURE_VARIANT_ADD_TIMEOUT(2000000000);
120
create_rt_thread(pthread_t * pth,void * (* func)(void *),void * arg,int policy,int prio)121 int create_rt_thread(pthread_t *pth, void*(*func)(void *), void *arg,
122 int policy, int prio)
123 {
124 int ret;
125 struct sched_param schedp;
126 pthread_attr_t attr;
127
128 pthread_attr_init(&attr);
129 memset(&schedp, 0, sizeof(schedp));
130
131 ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
132 if (ret) {
133 ksft_exit_fail_msg("pthread_attr_setinheritsched\n");
134 return -1;
135 }
136
137 ret = pthread_attr_setschedpolicy(&attr, policy);
138 if (ret) {
139 ksft_exit_fail_msg("pthread_attr_setschedpolicy\n");
140 return -1;
141 }
142
143 schedp.sched_priority = prio;
144 ret = pthread_attr_setschedparam(&attr, &schedp);
145 if (ret) {
146 ksft_exit_fail_msg("pthread_attr_setschedparam\n");
147 return -1;
148 }
149
150 ret = pthread_create(pth, &attr, func, arg);
151 if (ret) {
152 ksft_exit_fail_msg("pthread_create\n");
153 return -1;
154 }
155 return 0;
156 }
157
158
waiterfn(void * arg)159 void *waiterfn(void *arg)
160 {
161 struct thread_arg *args = (struct thread_arg *)arg;
162 futex_t old_val;
163
164 ksft_print_dbg_msg("Waiter %ld: running\n", args->id);
165 /* Each thread sleeps for a different amount of time
166 * This is to avoid races, because we don't lock the
167 * external mutex here */
168 usleep(1000 * (long)args->id);
169
170 old_val = f1;
171 atomic_inc(&waiters_blocked);
172 ksft_print_dbg_msg("Calling futex_wait_requeue_pi: %p (%u) -> %p\n",
173 &f1, f1, &f2);
174 args->ret = futex_wait_requeue_pi(&f1, old_val, &f2, args->timeout,
175 FUTEX_PRIVATE_FLAG);
176
177 ksft_print_dbg_msg("waiter %ld woke with %d %s\n", args->id, args->ret,
178 args->ret < 0 ? strerror(errno) : "");
179 atomic_inc(&waiters_woken);
180 if (args->ret < 0) {
181 if (args->timeout && errno == ETIMEDOUT)
182 args->ret = 0;
183 else {
184 ksft_exit_fail_msg("futex_wait_requeue_pi\n");
185 }
186 futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG);
187 }
188 futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG);
189
190 ksft_print_dbg_msg("Waiter %ld: exiting with %d\n", args->id, args->ret);
191 pthread_exit((void *)&args->ret);
192 }
193
broadcast_wakerfn(void * arg)194 void *broadcast_wakerfn(void *arg)
195 {
196 struct thread_arg *args = (struct thread_arg *)arg;
197 int nr_requeue = INT_MAX;
198 int task_count = 0;
199 futex_t old_val;
200 int nr_wake = 1;
201 int i = 0;
202
203 ksft_print_dbg_msg("Waker: waiting for waiters to block\n");
204 while (waiters_blocked.val < THREAD_MAX)
205 usleep(1000);
206 usleep(1000);
207
208 ksft_print_dbg_msg("Waker: Calling broadcast\n");
209 if (args->lock) {
210 ksft_print_dbg_msg("Calling FUTEX_LOCK_PI on mutex=%x @ %p\n", f2, &f2);
211 futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG);
212 }
213 continue_requeue:
214 old_val = f1;
215 args->ret = futex_cmp_requeue_pi(&f1, old_val, &f2, nr_wake, nr_requeue,
216 FUTEX_PRIVATE_FLAG);
217 if (args->ret < 0) {
218 ksft_exit_fail_msg("FUTEX_CMP_REQUEUE_PI failed\n");
219 } else if (++i < MAX_WAKE_ITERS) {
220 task_count += args->ret;
221 if (task_count < THREAD_MAX - waiters_woken.val)
222 goto continue_requeue;
223 } else {
224 ksft_exit_fail_msg("max broadcast iterations (%d) reached with %d/%d tasks woken or requeued\n",
225 MAX_WAKE_ITERS, task_count, THREAD_MAX);
226 }
227
228 futex_wake(&wake_complete, 1, FUTEX_PRIVATE_FLAG);
229
230 if (args->lock)
231 futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG);
232
233 if (args->ret > 0)
234 args->ret = task_count;
235
236 ksft_print_dbg_msg("Waker: exiting with %d\n", args->ret);
237 pthread_exit((void *)&args->ret);
238 }
239
signal_wakerfn(void * arg)240 void *signal_wakerfn(void *arg)
241 {
242 struct thread_arg *args = (struct thread_arg *)arg;
243 unsigned int old_val;
244 int nr_requeue = 0;
245 int task_count = 0;
246 int nr_wake = 1;
247 int i = 0;
248
249 ksft_print_dbg_msg("Waker: waiting for waiters to block\n");
250 while (waiters_blocked.val < THREAD_MAX)
251 usleep(1000);
252 usleep(1000);
253
254 while (task_count < THREAD_MAX && waiters_woken.val < THREAD_MAX) {
255 ksft_print_dbg_msg("task_count: %d, waiters_woken: %d\n",
256 task_count, waiters_woken.val);
257 if (args->lock) {
258 ksft_print_dbg_msg("Calling FUTEX_LOCK_PI on mutex=%x @ %p\n",
259 f2, &f2);
260 futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG);
261 }
262 ksft_print_dbg_msg("Waker: Calling signal\n");
263 /* cond_signal */
264 old_val = f1;
265 args->ret = futex_cmp_requeue_pi(&f1, old_val, &f2,
266 nr_wake, nr_requeue,
267 FUTEX_PRIVATE_FLAG);
268 if (args->ret < 0)
269 args->ret = -errno;
270 ksft_print_dbg_msg("futex: %x\n", f2);
271 if (args->lock) {
272 ksft_print_dbg_msg("Calling FUTEX_UNLOCK_PI on mutex=%x @ %p\n",
273 f2, &f2);
274 futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG);
275 }
276 ksft_print_dbg_msg("futex: %x\n", f2);
277 if (args->ret < 0)
278 ksft_exit_fail_msg("FUTEX_CMP_REQUEUE_PI failed\n");
279
280 task_count += args->ret;
281 usleep(SIGNAL_PERIOD_US);
282 i++;
283 /* we have to loop at least THREAD_MAX times */
284 if (i > MAX_WAKE_ITERS + THREAD_MAX) {
285 ksft_exit_fail_msg("max signaling iterations (%d) reached, giving up on pending waiters.\n",
286 MAX_WAKE_ITERS + THREAD_MAX);
287 }
288 }
289
290 futex_wake(&wake_complete, 1, FUTEX_PRIVATE_FLAG);
291
292 if (args->ret >= 0)
293 args->ret = task_count;
294
295 ksft_print_dbg_msg("Waker: exiting with %d\n", args->ret);
296 ksft_print_dbg_msg("Waker: waiters_woken: %d\n", waiters_woken.val);
297 pthread_exit((void *)&args->ret);
298 }
299
third_party_blocker(void * arg)300 void *third_party_blocker(void *arg)
301 {
302 struct thread_arg *args = (struct thread_arg *)arg;
303 int ret2 = 0;
304
305 args->ret = futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG);
306 if (args->ret)
307 goto out;
308 args->ret = futex_wait(&wake_complete, wake_complete, NULL,
309 FUTEX_PRIVATE_FLAG);
310 ret2 = futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG);
311
312 out:
313 if (args->ret || ret2)
314 ksft_exit_fail_msg("third_party_blocker() futex error");
315
316 pthread_exit((void *)&args->ret);
317 }
318
TEST_F(args,futex_requeue_pi)319 TEST_F(args, futex_requeue_pi)
320 {
321 struct thread_arg blocker_arg = THREAD_ARG_INITIALIZER;
322 struct thread_arg waker_arg = THREAD_ARG_INITIALIZER;
323 pthread_t waiter[THREAD_MAX], waker, blocker;
324 void *(*wakerfn)(void *) = signal_wakerfn;
325 bool third_party_owner = variant->owner;
326 long timeout_ns = variant->timeout_ns;
327 bool broadcast = variant->broadcast;
328 struct thread_arg args[THREAD_MAX];
329 struct timespec ts, *tsp = NULL;
330 bool lock = variant->locked;
331 int *waiter_ret, i, ret = 0;
332
333 ksft_print_msg(
334 "\tArguments: broadcast=%d locked=%d owner=%d timeout=%ldns\n",
335 broadcast, lock, third_party_owner, timeout_ns);
336
337 if (timeout_ns) {
338 time_t secs;
339
340 ksft_print_dbg_msg("timeout_ns = %ld\n", timeout_ns);
341 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
342 secs = (ts.tv_nsec + timeout_ns) / 1000000000;
343 ts.tv_nsec = ((int64_t)ts.tv_nsec + timeout_ns) % 1000000000;
344 ts.tv_sec += secs;
345 ksft_print_dbg_msg("ts.tv_sec = %ld\n", ts.tv_sec);
346 ksft_print_dbg_msg("ts.tv_nsec = %ld\n", ts.tv_nsec);
347 tsp = &ts;
348 }
349
350 if (broadcast)
351 wakerfn = broadcast_wakerfn;
352
353 if (third_party_owner) {
354 if (create_rt_thread(&blocker, third_party_blocker,
355 (void *)&blocker_arg, SCHED_FIFO, 1)) {
356 ksft_exit_fail_msg("Creating third party blocker thread failed\n");
357 }
358 }
359
360 atomic_set(&waiters_woken, 0);
361 for (i = 0; i < THREAD_MAX; i++) {
362 args[i].id = i;
363 args[i].timeout = tsp;
364 ksft_print_dbg_msg("Starting thread %d\n", i);
365 if (create_rt_thread(&waiter[i], waiterfn, (void *)&args[i],
366 SCHED_FIFO, 1)) {
367 ksft_exit_fail_msg("Creating waiting thread failed\n");
368 }
369 }
370 waker_arg.lock = lock;
371 if (create_rt_thread(&waker, wakerfn, (void *)&waker_arg,
372 SCHED_FIFO, 1)) {
373 ksft_exit_fail_msg("Creating waker thread failed\n");
374 }
375
376 /* Wait for threads to finish */
377 /* Store the first error or failure encountered in waiter_ret */
378 waiter_ret = &args[0].ret;
379 for (i = 0; i < THREAD_MAX; i++)
380 pthread_join(waiter[i],
381 *waiter_ret ? NULL : (void **)&waiter_ret);
382
383 if (third_party_owner)
384 pthread_join(blocker, NULL);
385 pthread_join(waker, NULL);
386
387 if (!ret) {
388 if (*waiter_ret)
389 ret = *waiter_ret;
390 else if (waker_arg.ret < 0)
391 ret = waker_arg.ret;
392 else if (blocker_arg.ret)
393 ret = blocker_arg.ret;
394 }
395
396 if (ret)
397 ksft_test_result_fail("fail");
398 }
399
400 TEST_HARNESS_MAIN
401