cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

clock_nanosleep.c (3033B)

      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
     41int 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	nscheck();
    119
    120	ksft_set_plan(4);
    121
    122	check_supported_timers();
    123
    124	if (unshare_timens())
    125		return 1;
    126
    127	if (_settime(CLOCK_MONOTONIC, 7 * 24 * 3600))
    128		return 1;
    129	if (_settime(CLOCK_BOOTTIME, 9 * 24 * 3600))
    130		return 1;
    131
    132	nsfd = open("/proc/self/ns/time_for_children", O_RDONLY);
    133	if (nsfd < 0)
    134		return pr_perror("Unable to open timens_for_children");
    135
    136	if (setns(nsfd, CLONE_NEWTIME))
    137		return pr_perror("Unable to set timens");
    138
    139	ret = 0;
    140	ret |= run_test(CLOCK_MONOTONIC, 0);
    141	ret |= run_test(CLOCK_MONOTONIC, 1);
    142	ret |= run_test(CLOCK_BOOTTIME_ALARM, 0);
    143	ret |= run_test(CLOCK_BOOTTIME_ALARM, 1);
    144
    145	if (ret)
    146		ksft_exit_fail();
    147	ksft_exit_pass();
    148	return ret;
    149}