int main(int argc, char **argv) { pthread_t thr; int ret = RET_PASS; int res; int c; while ((c = getopt(argc, argv, "chv:")) != -1) { switch (c) { case 'c': log_color(1); break; case 'h': usage(basename(argv[0])); exit(0); case 'v': log_verbosity(atoi(optarg)); break; default: usage(basename(argv[0])); exit(1); } } ksft_print_header(); ksft_set_plan(1); ksft_print_msg( "%s: Test the futex value of private file mappings in FUTEX_WAIT\n", basename(argv[0])); ret = pthread_create(&thr, NULL, thr_futex_wait, NULL); if (ret < 0) { fprintf(stderr, "pthread_create error\n"); ret = RET_ERROR; goto out; } info("wait a while\n"); usleep(WAKE_WAIT_US); val = 2; res = futex_wake(&val, 1, 0); info("futex_wake %d\n", res); if (res != 1) { fail("FUTEX_WAKE didn't find the waiting thread.\n"); ret = RET_FAIL; } info("join\n"); pthread_join(thr, NULL); out: print_result(TEST_NAME, ret); return ret; }
int main(int argc, char **argv) { ksft_print_header(); ksft_set_plan(4); test_pidfd_send_signal_syscall_support(); test_pidfd_send_signal_simple_success(); test_pidfd_send_signal_exited_fail(); test_pidfd_send_signal_recycled_pid_fail(); return ksft_exit_pass(); }
int main(int argc, char *argv[]) { int c, ret; while ((c = getopt(argc, argv, "bchlot:v:")) != -1) { switch (c) { case 'b': broadcast = 1; break; case 'c': log_color(1); break; case 'h': usage(basename(argv[0])); exit(0); case 'l': locked = 1; break; case 'o': owner = 1; locked = 0; break; case 't': timeout_ns = atoi(optarg); break; case 'v': log_verbosity(atoi(optarg)); break; default: usage(basename(argv[0])); exit(1); } } ksft_print_header(); ksft_print_msg("%s: Test requeue functionality\n", basename(argv[0])); ksft_print_msg( "\tArguments: broadcast=%d locked=%d owner=%d timeout=%ldns\n", broadcast, locked, owner, timeout_ns); /* * FIXME: unit_test is obsolete now that we parse options and the * various style of runs are done by run.sh - simplify the code and move * unit_test into main() */ ret = unit_test(broadcast, locked, owner, timeout_ns); print_result(TEST_NAME, ret); return ret; }
int main(int argc, char **argv) { int opt; bool do_suspend = true; bool succeeded = true; cpu_set_t available_cpus; int err; int cpu; ksft_print_header(); while ((opt = getopt(argc, argv, "n")) != -1) { switch (opt) { case 'n': do_suspend = false; break; default: printf("Usage: %s [-n]\n", argv[0]); printf(" -n: do not trigger a suspend/resume cycle before the test\n"); return -1; } } if (do_suspend) suspend(); err = sched_getaffinity(0, sizeof(available_cpus), &available_cpus); if (err < 0) ksft_exit_fail_msg("sched_getaffinity() failed\n"); for (cpu = 0; cpu < CPU_SETSIZE; cpu++) { bool test_success; if (!CPU_ISSET(cpu, &available_cpus)) continue; test_success = run_test(cpu); if (test_success) { ksft_test_result_pass("CPU %d\n", cpu); } else { ksft_test_result_fail("CPU %d\n", cpu); succeeded = false; } } if (succeeded) ksft_exit_pass(); else ksft_exit_fail(); }
int main(int argc, char *argv[]) { unsigned int old_val; struct sigaction sa; pthread_t waiter; int c, res, ret = RET_PASS; while ((c = getopt(argc, argv, "chv:")) != -1) { switch (c) { case 'c': log_color(1); break; case 'h': usage(basename(argv[0])); exit(0); case 'v': log_verbosity(atoi(optarg)); break; default: usage(basename(argv[0])); exit(1); } } ksft_print_header(); ksft_set_plan(1); ksft_print_msg("%s: Test signal handling during requeue_pi\n", basename(argv[0])); ksft_print_msg("\tArguments: <none>\n"); sa.sa_handler = handle_signal; sigemptyset(&sa.sa_mask); sa.sa_flags = 0; if (sigaction(SIGUSR1, &sa, NULL)) { error("sigaction\n", errno); exit(1); } info("m1:f2: %x\n", f2); info("Creating waiter\n"); res = create_rt_thread(&waiter, waiterfn, NULL, SCHED_FIFO, 1); if (res) { error("Creating waiting thread failed", res); ret = RET_ERROR; goto out; } info("Calling FUTEX_LOCK_PI on f2=%x @ %p\n", f2, &f2); info("m2:f2: %x\n", f2); futex_lock_pi(&f2, 0, 0, FUTEX_PRIVATE_FLAG); info("m3:f2: %x\n", f2); while (1) { /* * signal the waiter before requeue, waiter should automatically * restart futex_wait_requeue_pi() in the kernel. Wait for the * waiter to block on f1 again. */ info("Issuing SIGUSR1 to waiter\n"); pthread_kill(waiter, SIGUSR1); usleep(DELAY_US); info("Requeueing waiter via FUTEX_CMP_REQUEUE_PI\n"); old_val = f1; res = futex_cmp_requeue_pi(&f1, old_val, &(f2), 1, 0, FUTEX_PRIVATE_FLAG); /* * If res is non-zero, we either requeued the waiter or hit an * error, break out and handle it. If it is zero, then the * signal may have hit before the the waiter was blocked on f1. * Try again. */ if (res > 0) { atomic_set(&requeued, 1); break; } else if (res < 0) { error("FUTEX_CMP_REQUEUE_PI failed\n", errno); ret = RET_ERROR; break; } } info("m4:f2: %x\n", f2); /* * Signal the waiter after requeue, waiter should return from * futex_wait_requeue_pi() with EWOULDBLOCK. Join the thread here so the * futex_unlock_pi() can't happen before the signal wakeup is detected * in the kernel. */ info("Issuing SIGUSR1 to waiter\n"); pthread_kill(waiter, SIGUSR1); info("Waiting for waiter to return\n"); pthread_join(waiter, NULL); info("Calling FUTEX_UNLOCK_PI on mutex=%x @ %p\n", f2, &f2); futex_unlock_pi(&f2, FUTEX_PRIVATE_FLAG); info("m5:f2: %x\n", f2); out: if (ret == RET_PASS && waiter_ret) ret = waiter_ret; print_result(TEST_NAME, ret); return ret; }