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 struct __test_metadata *_metadata; 47 long id; 48 struct timespec *timeout; 49 int lock; 50 int ret; 51 }; 52 #define THREAD_ARG_INITIALIZER { NULL, 0, NULL, 0, 0 } 53 54 FIXTURE(args) 55 { 56 }; 57 58 FIXTURE_SETUP(args) 59 { 60 }; 61 62 FIXTURE_TEARDOWN(args) 63 { 64 }; 65 66 FIXTURE_VARIANT(args) 67 { 68 long timeout_ns; 69 bool broadcast; 70 bool owner; 71 bool locked; 72 }; 73 74 /* 75 * For a given timeout value, this macro creates a test input with all the 76 * possible combinations of valid arguments 77 */ 78 #define FIXTURE_VARIANT_ADD_TIMEOUT(timeout) \ 79 \ 80 FIXTURE_VARIANT_ADD(args, t_##timeout) \ 81 { \ 82 .timeout_ns = timeout, \ 83 }; \ 84 \ 85 FIXTURE_VARIANT_ADD(args, t_##timeout##_broadcast) \ 86 { \ 87 .timeout_ns = timeout, \ 88 .broadcast = true, \ 89 }; \ 90 \ 91 FIXTURE_VARIANT_ADD(args, t_##timeout##_broadcast_locked) \ 92 { \ 93 .timeout_ns = timeout, \ 94 .broadcast = true, \ 95 .locked = true, \ 96 }; \ 97 \ 98 FIXTURE_VARIANT_ADD(args, t_##timeout##_broadcast_owner) \ 99 { \ 100 .timeout_ns = timeout, \ 101 .broadcast = true, \ 102 .owner = true, \ 103 }; \ 104 \ 105 FIXTURE_VARIANT_ADD(args, t_##timeout##_locked) \ 106 { \ 107 .timeout_ns = timeout, \ 108 .locked = true, \ 109 }; \ 110 \ 111 FIXTURE_VARIANT_ADD(args, t_##timeout##_owner) \ 112 { \ 113 .timeout_ns = timeout, \ 114 .owner = true, \ 115 }; \ 116 117 FIXTURE_VARIANT_ADD_TIMEOUT(0); 118 FIXTURE_VARIANT_ADD_TIMEOUT(5000); 119 FIXTURE_VARIANT_ADD_TIMEOUT(500000); 120 FIXTURE_VARIANT_ADD_TIMEOUT(2000000000); 121 122 int create_rt_thread(struct __test_metadata *_metadata, pthread_t *pth, void*(*func)(void *), void *arg, 123 int policy, int prio) 124 { 125 int ret; 126 struct sched_param schedp; 127 pthread_attr_t attr; 128 129 pthread_attr_init(&attr); 130 memset(&schedp, 0, sizeof(schedp)); 131 132 ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); 133 ASSERT_EQ(ret, 0) 134 TH_LOG("pthread_attr_setinheritsched failed"); 135 136 ret = pthread_attr_setschedpolicy(&attr, policy); 137 ASSERT_EQ(ret, 0) 138 TH_LOG("pthread_attr_setschedpolicy failed"); 139 140 schedp.sched_priority = prio; 141 ret = pthread_attr_setschedparam(&attr, &schedp); 142 ASSERT_EQ(ret, 0) 143 TH_LOG("pthread_attr_setschedparam failed"); 144 145 ret = pthread_create(pth, &attr, func, arg); 146 ASSERT_EQ(ret, 0) 147 TH_LOG("pthread_create failed"); 148 149 return 0; 150 } 151 152 153 void *waiterfn(void *arg) 154 { 155 struct thread_arg *args = (struct thread_arg *)arg; 156 struct __test_metadata *_metadata = args->_metadata; 157 futex_t old_val; 158 159 TH_LOG("Waiter %ld: running", args->id); 160 /* Each thread sleeps for a different amount of time 161 * This is to avoid races, because we don't lock the 162 * external mutex here 163 */ 164 usleep(1000 * (long)args->id); 165 166 old_val = f1; 167 atomic_inc(&waiters_blocked); 168 TH_LOG("Calling futex_wait_requeue_pi: %p (%u) -> %p", &f1, f1, &f2); 169 args->ret = futex_wait_requeue_pi(&f1, old_val, &f2, args->timeout, 170 FUTEX_PRIVATE_FLAG); 171 172 TH_LOG("waiter %ld woke with %d %s", args->id, args->ret, 173 args->ret < 0 ? strerror(errno) : ""); 174 atomic_inc(&waiters_woken); 175 if (args->ret < 0) { 176 if (args->timeout && errno == ETIMEDOUT) { 177 args->ret = 0; 178 } else { 179 ASSERT_EQ(args->ret, 0) 180 TH_LOG("futex_wait_requeue_pi failed: %s", strerror(errno)); 181 } 182 futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG); 183 } 184 futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG); 185 186 TH_LOG("Waiter %ld: exiting with %d", args->id, args->ret); 187 pthread_exit((void *)&args->ret); 188 } 189 190 void *broadcast_wakerfn(void *arg) 191 { 192 struct thread_arg *args = (struct thread_arg *)arg; 193 struct __test_metadata *_metadata = args->_metadata; 194 int nr_requeue = INT_MAX; 195 int task_count = 0; 196 futex_t old_val; 197 int nr_wake = 1; 198 int i = 0; 199 200 TH_LOG("Waker: waiting for waiters to block"); 201 while (waiters_blocked.val < THREAD_MAX) 202 usleep(1000); 203 usleep(1000); 204 205 TH_LOG("Waker: Calling broadcast"); 206 if (args->lock) { 207 TH_LOG("Calling FUTEX_LOCK_PI on mutex=%x @ %p", f2, &f2); 208 futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG); 209 } 210 continue_requeue: 211 old_val = f1; 212 args->ret = futex_cmp_requeue_pi(&f1, old_val, &f2, nr_wake, nr_requeue, 213 FUTEX_PRIVATE_FLAG); 214 if (args->ret < 0) { 215 ASSERT_GE(args->ret, 0) 216 TH_LOG("FUTEX_CMP_REQUEUE_PI failed: %s", strerror(errno)); 217 } else if (++i < MAX_WAKE_ITERS) { 218 task_count += args->ret; 219 if (task_count < THREAD_MAX - waiters_woken.val) 220 goto continue_requeue; 221 } else { 222 ASSERT_TRUE(0) { 223 TH_LOG("max broadcast iterations (%d) reached with %d/%d tasks woken or requeued", 224 MAX_WAKE_ITERS, task_count, THREAD_MAX); 225 } 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 TH_LOG("Waker: exiting with %d", args->ret); 237 pthread_exit((void *)&args->ret); 238 } 239 240 void *signal_wakerfn(void *arg) 241 { 242 struct thread_arg *args = (struct thread_arg *)arg; 243 struct __test_metadata *_metadata = args->_metadata; 244 unsigned int old_val; 245 int nr_requeue = 0; 246 int task_count = 0; 247 int nr_wake = 1; 248 int i = 0; 249 250 TH_LOG("Waker: waiting for waiters to block"); 251 while (waiters_blocked.val < THREAD_MAX) 252 usleep(1000); 253 usleep(1000); 254 255 while (task_count < THREAD_MAX && waiters_woken.val < THREAD_MAX) { 256 TH_LOG("task_count: %d, waiters_woken: %d", 257 task_count, waiters_woken.val); 258 if (args->lock) { 259 TH_LOG("Calling FUTEX_LOCK_PI on mutex=%x @ %p", f2, &f2); 260 futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG); 261 } 262 TH_LOG("Waker: Calling signal"); 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 TH_LOG("futex: %x", f2); 271 if (args->lock) { 272 TH_LOG("Calling FUTEX_UNLOCK_PI on mutex=%x @ %p", 273 f2, &f2); 274 futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG); 275 } 276 TH_LOG("futex: %x", f2); 277 if (args->ret < 0) { 278 ASSERT_GE(args->ret, 0) 279 TH_LOG("FUTEX_CMP_REQUEUE_PI failed: %s", strerror(-args->ret)); 280 } 281 282 task_count += args->ret; 283 usleep(SIGNAL_PERIOD_US); 284 i++; 285 /* we have to loop at least THREAD_MAX times */ 286 if (i > MAX_WAKE_ITERS + THREAD_MAX) { 287 ASSERT_TRUE(0) { 288 TH_LOG("max signaling iterations (%d) reached, giving up on pending waiters.", 289 MAX_WAKE_ITERS + THREAD_MAX); 290 } 291 } 292 } 293 294 futex_wake(&wake_complete, 1, FUTEX_PRIVATE_FLAG); 295 296 if (args->ret >= 0) 297 args->ret = task_count; 298 299 TH_LOG("Waker: exiting with %d", args->ret); 300 TH_LOG("Waker: waiters_woken: %d", waiters_woken.val); 301 pthread_exit((void *)&args->ret); 302 } 303 304 void *third_party_blocker(void *arg) 305 { 306 struct thread_arg *args = (struct thread_arg *)arg; 307 struct __test_metadata *_metadata = args->_metadata; 308 int ret2 = 0; 309 310 args->ret = futex_lock_pi(&f2, NULL, 0, FUTEX_PRIVATE_FLAG); 311 if (args->ret) 312 goto out; 313 args->ret = futex_wait(&wake_complete, wake_complete, NULL, 314 FUTEX_PRIVATE_FLAG); 315 ret2 = futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG); 316 317 out: 318 if (args->ret || ret2) { 319 ASSERT_TRUE(0) 320 TH_LOG("%s() futex error", __func__); 321 } 322 323 pthread_exit((void *)&args->ret); 324 } 325 326 TEST_F(args, futex_requeue_pi) 327 { 328 struct thread_arg blocker_arg = THREAD_ARG_INITIALIZER; 329 struct thread_arg waker_arg = THREAD_ARG_INITIALIZER; 330 pthread_t waiter[THREAD_MAX], waker, blocker; 331 void *(*wakerfn)(void *) = signal_wakerfn; 332 bool third_party_owner = variant->owner; 333 long timeout_ns = variant->timeout_ns; 334 bool broadcast = variant->broadcast; 335 struct thread_arg args[THREAD_MAX]; 336 struct timespec ts, *tsp = NULL; 337 bool lock = variant->locked; 338 int *waiter_ret, i, ret = 0; 339 340 TH_LOG("Arguments: broadcast=%d locked=%d owner=%d timeout=%ldns", 341 broadcast, lock, third_party_owner, timeout_ns); 342 343 if (timeout_ns) { 344 time_t secs; 345 346 TH_LOG("timeout_ns = %ld", timeout_ns); 347 ret = clock_gettime(CLOCK_MONOTONIC, &ts); 348 secs = (ts.tv_nsec + timeout_ns) / 1000000000; 349 ts.tv_nsec = ((int64_t)ts.tv_nsec + timeout_ns) % 1000000000; 350 ts.tv_sec += secs; 351 TH_LOG("ts.tv_sec = %ld", ts.tv_sec); 352 TH_LOG("ts.tv_nsec = %ld", ts.tv_nsec); 353 tsp = &ts; 354 } 355 356 if (broadcast) 357 wakerfn = broadcast_wakerfn; 358 359 if (third_party_owner) { 360 blocker_arg._metadata = _metadata; 361 create_rt_thread(_metadata, &blocker, third_party_blocker, 362 (void *)&blocker_arg, SCHED_FIFO, 1); 363 } 364 365 atomic_set(&waiters_woken, 0); 366 for (i = 0; i < THREAD_MAX; i++) { 367 args[i]._metadata = _metadata; 368 args[i].id = i; 369 args[i].timeout = tsp; 370 TH_LOG("Starting thread %d", i); 371 create_rt_thread(_metadata, &waiter[i], waiterfn, (void *)&args[i], 372 SCHED_FIFO, 1); 373 } 374 waker_arg._metadata = _metadata; 375 waker_arg.lock = lock; 376 create_rt_thread(_metadata, &waker, wakerfn, (void *)&waker_arg, SCHED_FIFO, 1); 377 378 /* Wait for threads to finish */ 379 /* Store the first error or failure encountered in waiter_ret */ 380 waiter_ret = &args[0].ret; 381 for (i = 0; i < THREAD_MAX; i++) 382 pthread_join(waiter[i], *waiter_ret ? NULL : (void **)&waiter_ret); 383 384 if (third_party_owner) 385 pthread_join(blocker, NULL); 386 pthread_join(waker, NULL); 387 388 if (!ret) { 389 if (*waiter_ret) 390 ret = *waiter_ret; 391 else if (waker_arg.ret < 0) 392 ret = waker_arg.ret; 393 else if (blocker_arg.ret) 394 ret = blocker_arg.ret; 395 } 396 397 EXPECT_EQ(ret, 0) 398 TH_LOG("Test failed with error code: %d", ret); 399 } 400 401 TEST_HARNESS_MAIN 402