clock_nanosleep.c

  1// SPDX-License-Identifier: GPL-2.0
  2#define _GNU_SOURCE
  3#include <sched.h>
  4
  5#include <sys/timerfd.h>
  6#include <sys/syscall.h>
  7#include <time.h>
  8#include <unistd.h>
  9#include <stdlib.h>
 10#include <stdio.h>
 11#include <stdint.h>
 12#include <pthread.h>
 13#include <signal.h>
 14#include <string.h>
 15
 16#include "log.h"
 17#include "timens.h"
 18
 19void test_sig(int sig)
 20{
 21	if (sig == SIGUSR2)
 22		pthread_exit(NULL);
 23}
 24
 25struct thread_args {
 26	struct timespec *now, *rem;
 27	pthread_mutex_t *lock;
 28	int clockid;
 29	int abs;
 30};
 31
 32void *call_nanosleep(void *_args)
 33{
 34	struct thread_args *args = _args;
 35
 36	clock_nanosleep(args->clockid, args->abs ? TIMER_ABSTIME : 0, args->now, args->rem);
 37	pthread_mutex_unlock(args->lock);
 38	return NULL;
 39}
 40
 41static int run_test(int clockid, int abs)
 42{
 43	struct timespec now = {}, rem;
 44	struct thread_args args = { .now = &now, .rem = &rem, .clockid = clockid};
 45	struct timespec start;
 46	pthread_mutex_t lock;
 47	pthread_t thread;
 48	int j, ok, ret;
 49
 50	signal(SIGUSR1, test_sig);
 51	signal(SIGUSR2, test_sig);
 52
 53	pthread_mutex_init(&lock, NULL);
 54	pthread_mutex_lock(&lock);
 55
 56	if (clock_gettime(clockid, &start) == -1) {
 57		if (errno == EINVAL && check_skip(clockid))
 58			return 0;
 59		return pr_perror("clock_gettime");
 60	}
 61
 62
 63	if (abs) {
 64		now.tv_sec = start.tv_sec;
 65		now.tv_nsec = start.tv_nsec;
 66	}
 67
 68	now.tv_sec += 3600;
 69	args.abs = abs;
 70	args.lock = &lock;
 71	ret = pthread_create(&thread, NULL, call_nanosleep, &args);
 72	if (ret != 0) {
 73		pr_err("Unable to create a thread: %s", strerror(ret));
 74		return 1;
 75	}
 76
 77	/* Wait when the thread will call clock_nanosleep(). */
 78	ok = 0;
 79	for (j = 0; j < 8; j++) {
 80		/* The maximum timeout is about 5 seconds. */
 81		usleep(10000 << j);
 82
 83		/* Try to interrupt clock_nanosleep(). */
 84		pthread_kill(thread, SIGUSR1);
 85
 86		usleep(10000 << j);
 87		/* Check whether clock_nanosleep() has been interrupted or not. */
 88		if (pthread_mutex_trylock(&lock) == 0) {
 89			/**/
 90			ok = 1;
 91			break;
 92		}
 93	}
 94	if (!ok)
 95		pthread_kill(thread, SIGUSR2);
 96	pthread_join(thread, NULL);
 97	pthread_mutex_destroy(&lock);
 98
 99	if (!ok) {
100		ksft_test_result_pass("clockid: %d abs:%d timeout\n", clockid, abs);
101		return 1;
102	}
103
104	if (rem.tv_sec < 3300 || rem.tv_sec > 3900) {
105		pr_fail("clockid: %d abs: %d remain: %ld\n",
106			clockid, abs, rem.tv_sec);
107		return 1;
108	}
109	ksft_test_result_pass("clockid: %d abs:%d\n", clockid, abs);
110
111	return 0;
112}
113
114int main(int argc, char *argv[])
115{
116	int ret, nsfd;
117
118	ksft_print_header();
119
120	nscheck();
121
122	ksft_set_plan(4);
123
124	check_supported_timers();
125
126	if (unshare_timens())
127		return 1;
128
129	if (_settime(CLOCK_MONOTONIC, 7 * 24 * 3600))
130		return 1;
131	if (_settime(CLOCK_BOOTTIME, 9 * 24 * 3600))
132		return 1;
133
134	nsfd = open("/proc/self/ns/time_for_children", O_RDONLY);
135	if (nsfd < 0)
136		return pr_perror("Unable to open timens_for_children");
137
138	if (setns(nsfd, CLONE_NEWTIME))
139		return pr_perror("Unable to set timens");
140
141	ret = 0;
142	ret |= run_test(CLOCK_MONOTONIC, 0);
143	ret |= run_test(CLOCK_MONOTONIC, 1);
144	ret |= run_test(CLOCK_BOOTTIME_ALARM, 0);
145	ret |= run_test(CLOCK_BOOTTIME_ALARM, 1);
146
147	if (ret)
148		ksft_exit_fail();
149	ksft_exit_pass();
150	return ret;
151}