int main(void)
{
timer_t tm1;
struct itimerspec its1, its2;
struct sigevent se;
struct sigaction act;
int signum = SIGRTMAX;
/* Set up signal handler: */
sigfillset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = sigalarm;
sigaction(signum, &act, NULL);
/* Set up timer: */
memset(&se, 0, sizeof(se));
se.sigev_notify = SIGEV_SIGNAL;
se.sigev_signo = signum;
se.sigev_value.sival_int = 0;
for (alarm_clock_id = CLOCK_REALTIME_ALARM;
alarm_clock_id <= CLOCK_BOOTTIME_ALARM;
alarm_clock_id++) {
alarmcount = 0;
if (timer_create(alarm_clock_id, &se, &tm1) == -1) {
printf("timer_create failed, %s unsupported?\n",
clockstring(alarm_clock_id));
break;
}
clock_gettime(alarm_clock_id, &start_time);
printf("Start time (%s): %ld:%ld\n", clockstring(alarm_clock_id),
start_time.tv_sec, start_time.tv_nsec);
printf("Setting alarm for every %i seconds\n", SUSPEND_SECS);
its1.it_value = start_time;
its1.it_value.tv_sec += SUSPEND_SECS;
its1.it_interval.tv_sec = SUSPEND_SECS;
its1.it_interval.tv_nsec = 0;
timer_settime(tm1, TIMER_ABSTIME, &its1, &its2);
while (alarmcount < 5)
sleep(1); /* First 5 alarms, do nothing */
printf("Starting suspend loops\n");
while (alarmcount < 10) {
int ret;
sleep(3);
ret = system("echo mem > /sys/power/state");
if (ret)
break;
}
timer_delete(tm1);
}
if (final_ret)
return ksft_exit_fail();
return ksft_exit_pass();
}
int main(int argc, char **argv)
{
long long length;
int clockid, ret;
for (clockid = CLOCK_REALTIME; clockid < NR_CLOCKIDS; clockid++) {
/* Skip cputime clockids since nanosleep won't increment cputime */
if (clockid == CLOCK_PROCESS_CPUTIME_ID ||
clockid == CLOCK_THREAD_CPUTIME_ID ||
clockid == CLOCK_HWSPECIFIC)
continue;
printf("Nanosleep %-31s ", clockstring(clockid));
length = 10;
while (length <= (NSEC_PER_SEC * 10)) {
ret = nanosleep_test(clockid, length);
if (ret == UNSUPPORTED) {
printf("[UNSUPPORTED]\n");
goto next;
}
if (ret < 0) {
printf("[FAILED]\n");
return ksft_exit_fail();
}
length *= 100;
}
printf("[OK]\n");
next:
ret = 0;
}
return ksft_exit_pass();
}
int main(int argc, char **argv)
{
double freq_base, freq_step;
int i, j, fails = 0;
init_test();
printf("Checking response to frequency step:\n");
printf(" Step 1st interval 2nd interval\n");
printf(" Freq Dev Max Freq Dev Max\n");
for (i = 2; i >= 0; i--) {
for (j = 0; j < 5; j++) {
freq_base = (rand() % (1 << 24) - (1 << 23)) / 65536e6;
freq_step = 10e-6 * (1 << (6 * i));
fails += run_test(0, freq_base, freq_step);
}
}
set_frequency(0.0);
if (fails)
ksft_exit_fail();
ksft_exit_pass();
}
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 argv, char **argc)
{
struct timespec mon, raw, start, end;
long long delta1, delta2, interval, eppm, ppm;
struct timex tx1, tx2;
setbuf(stdout, NULL);
if (clock_gettime(CLOCK_MONOTONIC_RAW, &raw)) {
printf("ERR: NO CLOCK_MONOTONIC_RAW\n");
return -1;
}
tx1.modes = 0;
adjtimex(&tx1);
get_monotonic_and_raw(&mon, &raw);
start = mon;
delta1 = diff_timespec(mon, raw);
if (tx1.offset)
printf("WARNING: ADJ_OFFSET in progress, this will cause inaccurate results\n");
printf("Estimating clock drift: ");
sleep(120);
get_monotonic_and_raw(&mon, &raw);
end = mon;
tx2.modes = 0;
adjtimex(&tx2);
delta2 = diff_timespec(mon, raw);
interval = diff_timespec(start, end);
/* calculate measured ppm between MONOTONIC and MONOTONIC_RAW */
eppm = ((delta2-delta1)*NSEC_PER_SEC)/interval;
eppm = -eppm;
printf("%lld.%i(est)", eppm/1000, abs((int)(eppm%1000)));
/* Avg the two actual freq samples adjtimex gave us */
ppm = (tx1.freq + tx2.freq) * 1000 / 2;
ppm = (long long)tx1.freq * 1000;
ppm = shift_right(ppm, 16);
printf(" %lld.%i(act)", ppm/1000, abs((int)(ppm%1000)));
if (llabs(eppm - ppm) > 1000) {
printf(" [FAILED]\n");
return ksft_exit_fail();
}
printf(" [OK]\n");
return ksft_exit_pass();
}
int main(int argc, char **argv)
{
int ret;
printf("Mqueue latency : ");
ret = mqueue_lat_test();
if (ret < 0) {
printf("[FAILED]\n");
return ksft_exit_fail();
}
printf("[OK]\n");
return ksft_exit_pass();
}
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)
{
switch (test_membarrier_query()) {
case TEST_MEMBARRIER_FAIL:
return ksft_exit_fail();
case TEST_MEMBARRIER_SKIP:
return ksft_exit_skip();
}
switch (test_membarrier()) {
case TEST_MEMBARRIER_FAIL:
return ksft_exit_fail();
case TEST_MEMBARRIER_SKIP:
return ksft_exit_skip();
}
printf("membarrier: tests done!\n");
return ksft_exit_pass();
}
int main(int argc, char **argv)
{
int i, ret;
ret = get_tai();
printf("tai offset started at %i\n", ret);
printf("Checking tai offsets can be properly set: ");
for (i = 1; i <= 60; i++) {
ret = set_tai(i);
ret = get_tai();
if (ret != i) {
printf("[FAILED] expected: %i got %i\n", i, ret);
return ksft_exit_fail();
}
}
printf("[OK]\n");
return ksft_exit_pass();
}
static int check_itimer(int which)
{
int err;
struct timeval start, end;
struct itimerval val = {
.it_value.tv_sec = DELAY,
};
printf("Check itimer ");
if (which == ITIMER_VIRTUAL)
printf("virtual... ");
else if (which == ITIMER_PROF)
printf("prof... ");
else if (which == ITIMER_REAL)
printf("real... ");
fflush(stdout);
done = 0;
if (which == ITIMER_VIRTUAL)
signal(SIGVTALRM, sig_handler);
else if (which == ITIMER_PROF)
signal(SIGPROF, sig_handler);
else if (which == ITIMER_REAL)
signal(SIGALRM, sig_handler);
err = gettimeofday(&start, NULL);
if (err < 0) {
perror("Can't call gettimeofday()\n");
return -1;
}
err = setitimer(which, &val, NULL);
if (err < 0) {
perror("Can't set timer\n");
return -1;
}
if (which == ITIMER_VIRTUAL)
user_loop();
else if (which == ITIMER_PROF)
kernel_loop();
else if (which == ITIMER_REAL)
idle_loop();
gettimeofday(&end, NULL);
if (err < 0) {
perror("Can't call gettimeofday()\n");
return -1;
}
if (!check_diff(start, end))
printf("[OK]\n");
else
printf("[FAIL]\n");
return 0;
}
static int check_timer_create(int which)
{
int err;
timer_t id;
struct timeval start, end;
struct itimerspec val = {
.it_value.tv_sec = DELAY,
};
printf("Check timer_create() ");
if (which == CLOCK_THREAD_CPUTIME_ID) {
printf("per thread... ");
} else if (which == CLOCK_PROCESS_CPUTIME_ID) {
printf("per process... ");
}
fflush(stdout);
done = 0;
err = timer_create(which, NULL, &id);
if (err < 0) {
perror("Can't create timer\n");
return -1;
}
signal(SIGALRM, sig_handler);
err = gettimeofday(&start, NULL);
if (err < 0) {
perror("Can't call gettimeofday()\n");
return -1;
}
err = timer_settime(id, 0, &val, NULL);
if (err < 0) {
perror("Can't set timer\n");
return -1;
}
user_loop();
gettimeofday(&end, NULL);
if (err < 0) {
perror("Can't call gettimeofday()\n");
return -1;
}
if (!check_diff(start, end))
printf("[OK]\n");
else
printf("[FAIL]\n");
return 0;
}
int main(int argc, char **argv)
{
printf("Testing posix timers. False negative may happen on CPU execution \n");
printf("based timers if other threads run on the CPU...\n");
if (check_itimer(ITIMER_VIRTUAL) < 0)
return ksft_exit_fail();
if (check_itimer(ITIMER_PROF) < 0)
return ksft_exit_fail();
if (check_itimer(ITIMER_REAL) < 0)
return ksft_exit_fail();
if (check_timer_create(CLOCK_THREAD_CPUTIME_ID) < 0)
return ksft_exit_fail();
/*
* It's unfortunately hard to reliably test a timer expiration
* on parallel multithread cputime. We could arm it to expire
* on DELAY * nr_threads, with nr_threads busy looping, then wait
* the normal DELAY since the time is elapsing nr_threads faster.
* But for that we need to ensure we have real physical free CPUs
* to ensure true parallelism. So test only one thread until we
* find a better solution.
*/
if (check_timer_create(CLOCK_PROCESS_CPUTIME_ID) < 0)
return ksft_exit_fail();
return ksft_exit_pass();
}
int main(int argc, char **argv)
{
int thread_count, i;
time_t start, now, runtime;
char buf[255];
pthread_t pth[MAX_THREADS];
int opt;
void *tret;
int ret = 0;
void *(*thread)(void *) = shared_thread;
thread_count = DEFAULT_THREAD_COUNT;
runtime = DEFAULT_RUNTIME;
/* Process arguments */
while ((opt = getopt(argc, argv, "t:n:i")) != -1) {
switch (opt) {
case 't':
runtime = atoi(optarg);
break;
case 'n':
thread_count = atoi(optarg);
break;
case 'i':
thread = independent_thread;
printf("using independent threads\n");
break;
default:
printf("Usage: %s [-t <secs>] [-n <numthreads>] [-i]\n", argv[0]);
printf(" -t: time to run\n");
printf(" -n: number of threads\n");
printf(" -i: use independent threads\n");
return -1;
}
}
if (thread_count > MAX_THREADS)
thread_count = MAX_THREADS;
setbuf(stdout, NULL);
start = time(0);
strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&start));
printf("%s\n", buf);
printf("Testing consistency with %i threads for %ld seconds: ", thread_count, runtime);
/* spawn */
for (i = 0; i < thread_count; i++)
pthread_create(&pth[i], 0, thread, 0);
while (time(&now) < start + runtime) {
sleep(1);
if (done) {
ret = 1;
strftime(buf, 255, "%a, %d %b %Y %T %z", localtime(&now));
printf("%s\n", buf);
goto out;
}
}
printf("[OK]\n");
done = 1;
out:
/* wait */
for (i = 0; i < thread_count; i++)
pthread_join(pth[i], &tret);
/* die */
if (ret)
ksft_exit_fail();
return ksft_exit_pass();
}
