forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
244 lines
5.0 KiB
244 lines
5.0 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* vdso_full_test.c: Sample code to test all the timers. |
|
* Copyright (c) 2019 Arm Ltd. |
|
* |
|
* Compile with: |
|
* gcc -std=gnu99 vdso_full_test.c parse_vdso.c |
|
* |
|
*/ |
|
|
|
#include <stdint.h> |
|
#include <elf.h> |
|
#include <stdio.h> |
|
#include <time.h> |
|
#include <sys/auxv.h> |
|
#include <sys/time.h> |
|
#define _GNU_SOURCE |
|
#include <unistd.h> |
|
#include <sys/syscall.h> |
|
|
|
#include "../kselftest.h" |
|
#include "vdso_config.h" |
|
|
|
extern void *vdso_sym(const char *version, const char *name); |
|
extern void vdso_init_from_sysinfo_ehdr(uintptr_t base); |
|
extern void vdso_init_from_auxv(void *auxv); |
|
|
|
static const char *version; |
|
static const char **name; |
|
|
|
typedef long (*vdso_gettimeofday_t)(struct timeval *tv, struct timezone *tz); |
|
typedef long (*vdso_clock_gettime_t)(clockid_t clk_id, struct timespec *ts); |
|
typedef long (*vdso_clock_getres_t)(clockid_t clk_id, struct timespec *ts); |
|
typedef time_t (*vdso_time_t)(time_t *t); |
|
|
|
static int vdso_test_gettimeofday(void) |
|
{ |
|
/* Find gettimeofday. */ |
|
vdso_gettimeofday_t vdso_gettimeofday = |
|
(vdso_gettimeofday_t)vdso_sym(version, name[0]); |
|
|
|
if (!vdso_gettimeofday) { |
|
printf("Could not find %s\n", name[0]); |
|
return KSFT_SKIP; |
|
} |
|
|
|
struct timeval tv; |
|
long ret = vdso_gettimeofday(&tv, 0); |
|
|
|
if (ret == 0) { |
|
printf("The time is %lld.%06lld\n", |
|
(long long)tv.tv_sec, (long long)tv.tv_usec); |
|
} else { |
|
printf("%s failed\n", name[0]); |
|
return KSFT_FAIL; |
|
} |
|
|
|
return KSFT_PASS; |
|
} |
|
|
|
static int vdso_test_clock_gettime(clockid_t clk_id) |
|
{ |
|
/* Find clock_gettime. */ |
|
vdso_clock_gettime_t vdso_clock_gettime = |
|
(vdso_clock_gettime_t)vdso_sym(version, name[1]); |
|
|
|
if (!vdso_clock_gettime) { |
|
printf("Could not find %s\n", name[1]); |
|
return KSFT_SKIP; |
|
} |
|
|
|
struct timespec ts; |
|
long ret = vdso_clock_gettime(clk_id, &ts); |
|
|
|
if (ret == 0) { |
|
printf("The time is %lld.%06lld\n", |
|
(long long)ts.tv_sec, (long long)ts.tv_nsec); |
|
} else { |
|
printf("%s failed\n", name[1]); |
|
return KSFT_FAIL; |
|
} |
|
|
|
return KSFT_PASS; |
|
} |
|
|
|
static int vdso_test_time(void) |
|
{ |
|
/* Find time. */ |
|
vdso_time_t vdso_time = |
|
(vdso_time_t)vdso_sym(version, name[2]); |
|
|
|
if (!vdso_time) { |
|
printf("Could not find %s\n", name[2]); |
|
return KSFT_SKIP; |
|
} |
|
|
|
long ret = vdso_time(NULL); |
|
|
|
if (ret > 0) { |
|
printf("The time in hours since January 1, 1970 is %lld\n", |
|
(long long)(ret / 3600)); |
|
} else { |
|
printf("%s failed\n", name[2]); |
|
return KSFT_FAIL; |
|
} |
|
|
|
return KSFT_PASS; |
|
} |
|
|
|
static int vdso_test_clock_getres(clockid_t clk_id) |
|
{ |
|
/* Find clock_getres. */ |
|
vdso_clock_getres_t vdso_clock_getres = |
|
(vdso_clock_getres_t)vdso_sym(version, name[3]); |
|
|
|
if (!vdso_clock_getres) { |
|
printf("Could not find %s\n", name[3]); |
|
return KSFT_SKIP; |
|
} |
|
|
|
struct timespec ts, sys_ts; |
|
long ret = vdso_clock_getres(clk_id, &ts); |
|
|
|
if (ret == 0) { |
|
printf("The resolution is %lld %lld\n", |
|
(long long)ts.tv_sec, (long long)ts.tv_nsec); |
|
} else { |
|
printf("%s failed\n", name[3]); |
|
return KSFT_FAIL; |
|
} |
|
|
|
ret = syscall(SYS_clock_getres, clk_id, &sys_ts); |
|
|
|
if ((sys_ts.tv_sec != ts.tv_sec) || (sys_ts.tv_nsec != ts.tv_nsec)) { |
|
printf("%s failed\n", name[3]); |
|
return KSFT_FAIL; |
|
} |
|
|
|
return KSFT_PASS; |
|
} |
|
|
|
const char *vdso_clock_name[12] = { |
|
"CLOCK_REALTIME", |
|
"CLOCK_MONOTONIC", |
|
"CLOCK_PROCESS_CPUTIME_ID", |
|
"CLOCK_THREAD_CPUTIME_ID", |
|
"CLOCK_MONOTONIC_RAW", |
|
"CLOCK_REALTIME_COARSE", |
|
"CLOCK_MONOTONIC_COARSE", |
|
"CLOCK_BOOTTIME", |
|
"CLOCK_REALTIME_ALARM", |
|
"CLOCK_BOOTTIME_ALARM", |
|
"CLOCK_SGI_CYCLE", |
|
"CLOCK_TAI", |
|
}; |
|
|
|
/* |
|
* This function calls vdso_test_clock_gettime and vdso_test_clock_getres |
|
* with different values for clock_id. |
|
*/ |
|
static inline int vdso_test_clock(clockid_t clock_id) |
|
{ |
|
int ret0, ret1; |
|
|
|
ret0 = vdso_test_clock_gettime(clock_id); |
|
/* A skipped test is considered passed */ |
|
if (ret0 == KSFT_SKIP) |
|
ret0 = KSFT_PASS; |
|
|
|
ret1 = vdso_test_clock_getres(clock_id); |
|
/* A skipped test is considered passed */ |
|
if (ret1 == KSFT_SKIP) |
|
ret1 = KSFT_PASS; |
|
|
|
ret0 += ret1; |
|
|
|
printf("clock_id: %s", vdso_clock_name[clock_id]); |
|
|
|
if (ret0 > 0) |
|
printf(" [FAIL]\n"); |
|
else |
|
printf(" [PASS]\n"); |
|
|
|
return ret0; |
|
} |
|
|
|
int main(int argc, char **argv) |
|
{ |
|
unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR); |
|
int ret; |
|
|
|
if (!sysinfo_ehdr) { |
|
printf("AT_SYSINFO_EHDR is not present!\n"); |
|
return KSFT_SKIP; |
|
} |
|
|
|
version = versions[VDSO_VERSION]; |
|
name = (const char **)&names[VDSO_NAMES]; |
|
|
|
printf("[vDSO kselftest] VDSO_VERSION: %s\n", version); |
|
|
|
vdso_init_from_sysinfo_ehdr(getauxval(AT_SYSINFO_EHDR)); |
|
|
|
ret = vdso_test_gettimeofday(); |
|
|
|
#if _POSIX_TIMERS > 0 |
|
|
|
#ifdef CLOCK_REALTIME |
|
ret += vdso_test_clock(CLOCK_REALTIME); |
|
#endif |
|
|
|
#ifdef CLOCK_BOOTTIME |
|
ret += vdso_test_clock(CLOCK_BOOTTIME); |
|
#endif |
|
|
|
#ifdef CLOCK_TAI |
|
ret += vdso_test_clock(CLOCK_TAI); |
|
#endif |
|
|
|
#ifdef CLOCK_REALTIME_COARSE |
|
ret += vdso_test_clock(CLOCK_REALTIME_COARSE); |
|
#endif |
|
|
|
#ifdef CLOCK_MONOTONIC |
|
ret += vdso_test_clock(CLOCK_MONOTONIC); |
|
#endif |
|
|
|
#ifdef CLOCK_MONOTONIC_RAW |
|
ret += vdso_test_clock(CLOCK_MONOTONIC_RAW); |
|
#endif |
|
|
|
#ifdef CLOCK_MONOTONIC_COARSE |
|
ret += vdso_test_clock(CLOCK_MONOTONIC_COARSE); |
|
#endif |
|
|
|
#endif |
|
|
|
ret += vdso_test_time(); |
|
|
|
if (ret > 0) |
|
return KSFT_FAIL; |
|
|
|
return KSFT_PASS; |
|
}
|
|
|