1063 lines
24 KiB
C
1063 lines
24 KiB
C
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
* Copyright (C) 2015-2020 Cyril Hrubis <chrubis@suse.cz>
|
|
*/
|
|
|
|
/*
|
|
|
|
Timer - struct timespec conversion runtimes and easy to use functions to
|
|
measure elapsed time.
|
|
|
|
*/
|
|
|
|
#ifndef TST_TIMER
|
|
#define TST_TIMER
|
|
|
|
#include <linux/time_types.h>
|
|
#include <linux/types.h>
|
|
#include <sched.h>
|
|
#include <sys/time.h>
|
|
#include <mqueue.h>
|
|
#include <time.h>
|
|
#include "tst_test.h"
|
|
#include "lapi/common_timers.h"
|
|
#include "lapi/posix_types.h"
|
|
#include "lapi/syscalls.h"
|
|
|
|
/*
|
|
* Converts timeval to microseconds.
|
|
*/
|
|
static inline long long tst_timeval_to_us(struct timeval t)
|
|
{
|
|
return ((long long)t.tv_sec) * 1000000 + t.tv_usec;
|
|
}
|
|
|
|
/*
|
|
* Converts timeval to milliseconds.
|
|
*/
|
|
static inline long long tst_timeval_to_ms(struct timeval t)
|
|
{
|
|
return ((long long)t.tv_sec) * 1000 + (t.tv_usec + 500) / 1000;
|
|
}
|
|
|
|
/*
|
|
* Converts milliseconds to struct timeval
|
|
*/
|
|
static inline struct timeval tst_ms_to_timeval(long long ms)
|
|
{
|
|
struct timeval ret;
|
|
|
|
ret.tv_sec = ms / 1000;
|
|
ret.tv_usec = (ms % 1000) * 1000;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Converts microseconds to struct timeval
|
|
*/
|
|
static inline struct timeval tst_us_to_timeval(long long us)
|
|
{
|
|
struct timeval ret;
|
|
|
|
ret.tv_sec = us / 1000000;
|
|
ret.tv_usec = us % 1000000;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Returns difference between two timeval structures.
|
|
*/
|
|
static inline struct timeval tst_timeval_diff(struct timeval t1,
|
|
struct timeval t2)
|
|
{
|
|
struct timeval res;
|
|
|
|
res.tv_sec = t1.tv_sec - t2.tv_sec;
|
|
|
|
if (t1.tv_usec < t2.tv_usec) {
|
|
res.tv_sec--;
|
|
res.tv_usec = 1000000 - (t2.tv_usec - t1.tv_usec);
|
|
} else {
|
|
res.tv_usec = t1.tv_usec - t2.tv_usec;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static inline long long tst_timeval_diff_us(struct timeval t1,
|
|
struct timeval t2)
|
|
{
|
|
return tst_timeval_to_us(tst_timeval_diff(t1, t2));
|
|
}
|
|
|
|
static inline long long tst_timeval_diff_ms(struct timeval t1,
|
|
struct timeval t2)
|
|
{
|
|
return tst_timeval_to_ms(tst_timeval_diff(t1, t2));
|
|
}
|
|
|
|
typedef __kernel_long_t __kernel_old_time_t;
|
|
|
|
#ifndef HAVE_STRUCT___KERNEL_OLD_TIMEVAL
|
|
struct __kernel_old_timeval {
|
|
__kernel_old_time_t tv_sec; /* seconds */
|
|
__kernel_suseconds_t tv_usec; /* microseconds */
|
|
};
|
|
#endif
|
|
|
|
#ifndef HAVE_STRUCT___KERNEL_OLD_TIMESPEC
|
|
struct __kernel_old_timespec {
|
|
__kernel_old_time_t tv_sec; /* seconds */
|
|
__kernel_old_time_t tv_nsec; /* nanoseconds */
|
|
};
|
|
#endif
|
|
|
|
typedef long long __kernel_time64_t;
|
|
|
|
#ifndef HAVE_STRUCT___KERNEL_TIMESPEC
|
|
struct __kernel_timespec {
|
|
__kernel_time64_t tv_sec; /* seconds */
|
|
long long tv_nsec; /* nanoseconds */
|
|
};
|
|
#endif
|
|
|
|
struct __kernel_old_itimerspec {
|
|
struct __kernel_old_timespec it_interval; /* timer period */
|
|
struct __kernel_old_timespec it_value; /* timer expiration */
|
|
};
|
|
|
|
#ifndef HAVE_STRUCT___KERNEL_ITIMERSPEC
|
|
struct __kernel_itimerspec {
|
|
struct __kernel_timespec it_interval; /* timer period */
|
|
struct __kernel_timespec it_value; /* timer expiration */
|
|
};
|
|
#endif
|
|
|
|
enum tst_ts_type {
|
|
TST_LIBC_TIMESPEC,
|
|
TST_KERN_OLD_TIMESPEC,
|
|
TST_KERN_TIMESPEC
|
|
};
|
|
|
|
struct tst_ts {
|
|
enum tst_ts_type type;
|
|
union ts {
|
|
struct timespec libc_ts;
|
|
struct __kernel_old_timespec kern_old_ts;
|
|
struct __kernel_timespec kern_ts;
|
|
} ts;
|
|
};
|
|
|
|
struct tst_its {
|
|
enum tst_ts_type type;
|
|
union {
|
|
struct __kernel_old_itimerspec kern_old_its;
|
|
struct __kernel_itimerspec kern_its;
|
|
} ts;
|
|
};
|
|
|
|
static inline void *tst_ts_get(struct tst_ts *t)
|
|
{
|
|
if (!t)
|
|
return NULL;
|
|
|
|
switch (t->type) {
|
|
case TST_LIBC_TIMESPEC:
|
|
return &t->ts.libc_ts;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return &t->ts.kern_old_ts;
|
|
case TST_KERN_TIMESPEC:
|
|
return &t->ts.kern_ts;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", t->type);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static inline void *tst_its_get(struct tst_its *t)
|
|
{
|
|
if (!t)
|
|
return NULL;
|
|
|
|
switch (t->type) {
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return &t->ts.kern_old_its;
|
|
case TST_KERN_TIMESPEC:
|
|
return &t->ts.kern_its;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", t->type);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static inline int libc_clock_getres(clockid_t clk_id, void *ts)
|
|
{
|
|
return clock_getres(clk_id, ts);
|
|
}
|
|
|
|
static inline int sys_clock_getres(clockid_t clk_id, void *ts)
|
|
{
|
|
return tst_syscall(__NR_clock_getres, clk_id, ts);
|
|
}
|
|
|
|
static inline int sys_clock_getres64(clockid_t clk_id, void *ts)
|
|
{
|
|
return tst_syscall(__NR_clock_getres_time64, clk_id, ts);
|
|
}
|
|
|
|
static inline int libc_clock_gettime(clockid_t clk_id, void *ts)
|
|
{
|
|
return clock_gettime(clk_id, ts);
|
|
}
|
|
|
|
static inline int sys_clock_gettime(clockid_t clk_id, void *ts)
|
|
{
|
|
return tst_syscall(__NR_clock_gettime, clk_id, ts);
|
|
}
|
|
|
|
static inline int sys_clock_gettime64(clockid_t clk_id, void *ts)
|
|
{
|
|
return tst_syscall(__NR_clock_gettime64, clk_id, ts);
|
|
}
|
|
|
|
static inline int libc_clock_settime(clockid_t clk_id, void *ts)
|
|
{
|
|
return clock_settime(clk_id, ts);
|
|
}
|
|
|
|
static inline int sys_clock_settime(clockid_t clk_id, void *ts)
|
|
{
|
|
return tst_syscall(__NR_clock_settime, clk_id, ts);
|
|
}
|
|
|
|
static inline int sys_clock_settime64(clockid_t clk_id, void *ts)
|
|
{
|
|
return tst_syscall(__NR_clock_settime64, clk_id, ts);
|
|
}
|
|
|
|
static inline int libc_clock_nanosleep(clockid_t clk_id, int flags,
|
|
void *request, void *remain)
|
|
{
|
|
return clock_nanosleep(clk_id, flags, request, remain);
|
|
}
|
|
|
|
static inline int sys_clock_nanosleep(clockid_t clk_id, int flags,
|
|
void *request, void *remain)
|
|
{
|
|
return tst_syscall(__NR_clock_nanosleep, clk_id, flags,
|
|
request, remain);
|
|
}
|
|
|
|
static inline int sys_clock_nanosleep64(clockid_t clk_id, int flags,
|
|
void *request, void *remain)
|
|
{
|
|
return tst_syscall(__NR_clock_nanosleep_time64, clk_id, flags,
|
|
request, remain);
|
|
}
|
|
|
|
static inline int sys_futex(int *uaddr, int futex_op, int val, void *to,
|
|
int *uaddr2, int val3)
|
|
{
|
|
return tst_syscall(__NR_futex, uaddr, futex_op, val, to, uaddr2, val3);
|
|
}
|
|
|
|
static inline int sys_futex_time64(int *uaddr, int futex_op, int val, void *to,
|
|
int *uaddr2, int val3)
|
|
{
|
|
return tst_syscall(__NR_futex_time64, uaddr, futex_op, val, to, uaddr2, val3);
|
|
}
|
|
|
|
static inline int libc_mq_timedsend(mqd_t mqdes, const char *msg_ptr,
|
|
size_t msg_len, unsigned int msg_prio, void *abs_timeout)
|
|
{
|
|
return mq_timedsend(mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
|
|
}
|
|
|
|
static inline int sys_mq_timedsend(mqd_t mqdes, const char *msg_ptr,
|
|
size_t msg_len, unsigned int msg_prio, void *abs_timeout)
|
|
{
|
|
return tst_syscall(__NR_mq_timedsend, mqdes, msg_ptr, msg_len, msg_prio,
|
|
abs_timeout);
|
|
}
|
|
|
|
static inline int sys_mq_timedsend64(mqd_t mqdes, const char *msg_ptr,
|
|
size_t msg_len, unsigned int msg_prio, void *abs_timeout)
|
|
{
|
|
return tst_syscall(__NR_mq_timedsend_time64, mqdes, msg_ptr, msg_len,
|
|
msg_prio, abs_timeout);
|
|
}
|
|
|
|
static inline ssize_t libc_mq_timedreceive(mqd_t mqdes, char *msg_ptr,
|
|
size_t msg_len, unsigned int *msg_prio, void *abs_timeout)
|
|
{
|
|
return mq_timedreceive(mqdes, msg_ptr, msg_len, msg_prio, abs_timeout);
|
|
}
|
|
|
|
static inline ssize_t sys_mq_timedreceive(mqd_t mqdes, char *msg_ptr,
|
|
size_t msg_len, unsigned int *msg_prio, void *abs_timeout)
|
|
{
|
|
return tst_syscall(__NR_mq_timedreceive, mqdes, msg_ptr, msg_len,
|
|
msg_prio, abs_timeout);
|
|
}
|
|
|
|
static inline ssize_t sys_mq_timedreceive64(mqd_t mqdes, char *msg_ptr,
|
|
size_t msg_len, unsigned int *msg_prio, void *abs_timeout)
|
|
{
|
|
return tst_syscall(__NR_mq_timedreceive_time64, mqdes, msg_ptr, msg_len,
|
|
msg_prio, abs_timeout);
|
|
}
|
|
|
|
static inline int libc_sched_rr_get_interval(pid_t pid, void *ts)
|
|
{
|
|
return sched_rr_get_interval(pid, ts);
|
|
}
|
|
|
|
static inline int sys_sched_rr_get_interval(pid_t pid, void *ts)
|
|
{
|
|
return tst_syscall(__NR_sched_rr_get_interval, pid, ts);
|
|
}
|
|
|
|
static inline int sys_sched_rr_get_interval64(pid_t pid, void *ts)
|
|
{
|
|
return tst_syscall(__NR_sched_rr_get_interval_time64, pid, ts);
|
|
}
|
|
|
|
static inline int sys_timer_gettime(kernel_timer_t timerid, void *its)
|
|
{
|
|
return tst_syscall(__NR_timer_gettime, timerid, its);
|
|
}
|
|
|
|
static inline int sys_timer_gettime64(kernel_timer_t timerid, void *its)
|
|
{
|
|
return tst_syscall(__NR_timer_gettime64, timerid, its);
|
|
}
|
|
|
|
static inline int sys_timer_settime(kernel_timer_t timerid, int flags, void *its,
|
|
void *old_its)
|
|
{
|
|
return tst_syscall(__NR_timer_settime, timerid, flags, its, old_its);
|
|
}
|
|
|
|
static inline int sys_timer_settime64(kernel_timer_t timerid, int flags, void *its,
|
|
void *old_its)
|
|
{
|
|
return tst_syscall(__NR_timer_settime64, timerid, flags, its, old_its);
|
|
}
|
|
|
|
static inline int sys_timerfd_gettime(int fd, void *its)
|
|
{
|
|
return tst_syscall(__NR_timerfd_gettime, fd, its);
|
|
}
|
|
|
|
static inline int sys_timerfd_gettime64(int fd, void *its)
|
|
{
|
|
return tst_syscall(__NR_timerfd_gettime64, fd, its);
|
|
}
|
|
|
|
static inline int sys_timerfd_settime(int fd, int flags, void *its,
|
|
void *old_its)
|
|
{
|
|
return tst_syscall(__NR_timerfd_settime, fd, flags, its, old_its);
|
|
}
|
|
|
|
static inline int sys_timerfd_settime64(int fd, int flags, void *its,
|
|
void *old_its)
|
|
{
|
|
return tst_syscall(__NR_timerfd_settime64, fd, flags, its, old_its);
|
|
}
|
|
|
|
/*
|
|
* Returns tst_ts seconds.
|
|
*/
|
|
static inline long long tst_ts_get_sec(struct tst_ts ts)
|
|
{
|
|
switch (ts.type) {
|
|
case TST_LIBC_TIMESPEC:
|
|
return ts.ts.libc_ts.tv_sec;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return ts.ts.kern_old_ts.tv_sec;
|
|
case TST_KERN_TIMESPEC:
|
|
return ts.ts.kern_ts.tv_sec;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", ts.type);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns tst_ts nanoseconds.
|
|
*/
|
|
static inline long long tst_ts_get_nsec(struct tst_ts ts)
|
|
{
|
|
switch (ts.type) {
|
|
case TST_LIBC_TIMESPEC:
|
|
return ts.ts.libc_ts.tv_nsec;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return ts.ts.kern_old_ts.tv_nsec;
|
|
case TST_KERN_TIMESPEC:
|
|
return ts.ts.kern_ts.tv_nsec;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", ts.type);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets tst_ts seconds.
|
|
*/
|
|
static inline void tst_ts_set_sec(struct tst_ts *ts, long long sec)
|
|
{
|
|
switch (ts->type) {
|
|
case TST_LIBC_TIMESPEC:
|
|
ts->ts.libc_ts.tv_sec = sec;
|
|
break;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
ts->ts.kern_old_ts.tv_sec = sec;
|
|
break;
|
|
case TST_KERN_TIMESPEC:
|
|
ts->ts.kern_ts.tv_sec = sec;
|
|
break;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", ts->type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets tst_ts nanoseconds.
|
|
*/
|
|
static inline void tst_ts_set_nsec(struct tst_ts *ts, long long nsec)
|
|
{
|
|
switch (ts->type) {
|
|
case TST_LIBC_TIMESPEC:
|
|
ts->ts.libc_ts.tv_nsec = nsec;
|
|
break;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
ts->ts.kern_old_ts.tv_nsec = nsec;
|
|
break;
|
|
case TST_KERN_TIMESPEC:
|
|
ts->ts.kern_ts.tv_nsec = nsec;
|
|
break;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", ts->type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns tst_its it_interval seconds.
|
|
*/
|
|
static inline long long tst_its_get_interval_sec(struct tst_its its)
|
|
{
|
|
switch (its.type) {
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return its.ts.kern_old_its.it_interval.tv_sec;
|
|
case TST_KERN_TIMESPEC:
|
|
return its.ts.kern_its.it_interval.tv_sec;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its.type);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns tst_its it_interval nanoseconds.
|
|
*/
|
|
static inline long long tst_its_get_interval_nsec(struct tst_its its)
|
|
{
|
|
switch (its.type) {
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return its.ts.kern_old_its.it_interval.tv_nsec;
|
|
case TST_KERN_TIMESPEC:
|
|
return its.ts.kern_its.it_interval.tv_nsec;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its.type);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_interval seconds.
|
|
*/
|
|
static inline void tst_its_set_interval_sec(struct tst_its *its, long long sec)
|
|
{
|
|
switch (its->type) {
|
|
break;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
its->ts.kern_old_its.it_interval.tv_sec = sec;
|
|
break;
|
|
case TST_KERN_TIMESPEC:
|
|
its->ts.kern_its.it_interval.tv_sec = sec;
|
|
break;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its->type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_interval nanoseconds.
|
|
*/
|
|
static inline void tst_its_set_interval_nsec(struct tst_its *its, long long nsec)
|
|
{
|
|
switch (its->type) {
|
|
break;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
its->ts.kern_old_its.it_interval.tv_nsec = nsec;
|
|
break;
|
|
case TST_KERN_TIMESPEC:
|
|
its->ts.kern_its.it_interval.tv_nsec = nsec;
|
|
break;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its->type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns tst_its it_value seconds.
|
|
*/
|
|
static inline long long tst_its_get_value_sec(struct tst_its its)
|
|
{
|
|
switch (its.type) {
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return its.ts.kern_old_its.it_value.tv_sec;
|
|
case TST_KERN_TIMESPEC:
|
|
return its.ts.kern_its.it_value.tv_sec;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its.type);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns tst_its it_value nanoseconds.
|
|
*/
|
|
static inline long long tst_its_get_value_nsec(struct tst_its its)
|
|
{
|
|
switch (its.type) {
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
return its.ts.kern_old_its.it_value.tv_nsec;
|
|
case TST_KERN_TIMESPEC:
|
|
return its.ts.kern_its.it_value.tv_nsec;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its.type);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_value seconds.
|
|
*/
|
|
static inline void tst_its_set_value_sec(struct tst_its *its, long long sec)
|
|
{
|
|
switch (its->type) {
|
|
break;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
its->ts.kern_old_its.it_value.tv_sec = sec;
|
|
break;
|
|
case TST_KERN_TIMESPEC:
|
|
its->ts.kern_its.it_value.tv_sec = sec;
|
|
break;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its->type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_value nanoseconds.
|
|
*/
|
|
static inline void tst_its_set_value_nsec(struct tst_its *its, long long nsec)
|
|
{
|
|
switch (its->type) {
|
|
break;
|
|
case TST_KERN_OLD_TIMESPEC:
|
|
its->ts.kern_old_its.it_value.tv_nsec = nsec;
|
|
break;
|
|
case TST_KERN_TIMESPEC:
|
|
its->ts.kern_its.it_value.tv_nsec = nsec;
|
|
break;
|
|
default:
|
|
tst_brk(TBROK, "Invalid type: %d", its->type);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Checks that timespec is valid, i.e. that the timestamp is not zero and that
|
|
* the nanoseconds are normalized i.e. in <0, 1s) interval.
|
|
*
|
|
* 0: On success, i.e. timespec updated correctly.
|
|
* -1: Error, timespec not updated.
|
|
* -2: Error, tv_nsec is corrupted.
|
|
*/
|
|
static inline int tst_ts_valid(struct tst_ts *t)
|
|
{
|
|
long long nsec = tst_ts_get_nsec(*t);
|
|
|
|
if (nsec < 0 || nsec >= 1000000000)
|
|
return -2;
|
|
|
|
if (tst_ts_get_sec(*t) == 0 && tst_ts_get_nsec(*t) == 0)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Converts timespec to tst_ts.
|
|
*/
|
|
static inline struct tst_ts tst_ts_from_timespec(struct timespec ts)
|
|
{
|
|
struct tst_ts t = {
|
|
.type = TST_LIBC_TIMESPEC,
|
|
.ts.libc_ts.tv_sec = ts.tv_sec,
|
|
.ts.libc_ts.tv_nsec = ts.tv_nsec,
|
|
};
|
|
|
|
return t;
|
|
}
|
|
|
|
/*
|
|
* Converst tst_ts into timespec.
|
|
*/
|
|
static inline struct timespec tst_ts_to_timespec(struct tst_ts t)
|
|
{
|
|
return t.ts.libc_ts;
|
|
}
|
|
|
|
/*
|
|
* Converts tst_ts to nanoseconds.
|
|
*/
|
|
static inline long long tst_ts_to_ns(struct tst_ts t)
|
|
{
|
|
return tst_ts_get_sec(t) * 1000000000 + tst_ts_get_nsec(t);
|
|
}
|
|
|
|
/*
|
|
* Converts tst_ts to microseconds and rounds the value.
|
|
*/
|
|
static inline long long tst_ts_to_us(struct tst_ts t)
|
|
{
|
|
return tst_ts_get_sec(t) * 1000000 +
|
|
(tst_ts_get_nsec(t) + 500) / 1000;
|
|
}
|
|
|
|
/*
|
|
* Converts timespec to microseconds and rounds the value.
|
|
*/
|
|
static inline long long tst_timespec_to_us(struct timespec ts)
|
|
{
|
|
return tst_ts_to_us(tst_ts_from_timespec(ts));
|
|
}
|
|
|
|
/*
|
|
* Converts tst_ts to milliseconds and rounds the value.
|
|
*/
|
|
static inline long long tst_ts_to_ms(struct tst_ts t)
|
|
{
|
|
return tst_ts_get_sec(t) * 1000 +
|
|
(tst_ts_get_nsec(t) + 500000) / 1000000;
|
|
}
|
|
|
|
/*
|
|
* Converts timespec to milliseconds and rounds the value.
|
|
*/
|
|
static inline long long tst_timespec_to_ms(struct timespec ts)
|
|
{
|
|
return tst_ts_to_ms(tst_ts_from_timespec(ts));
|
|
}
|
|
|
|
/*
|
|
* Converts nanoseconds to tst_ts
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_from_ns(enum tst_ts_type type, long long ns)
|
|
{
|
|
struct tst_ts ret = {.type = type};
|
|
|
|
tst_ts_set_sec(&ret, ns / 1000000000);
|
|
tst_ts_set_nsec(&ret, ns % 1000000000);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Converts microseconds to tst_ts
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_from_us(enum tst_ts_type type, long long us)
|
|
{
|
|
struct tst_ts ret = {.type = type};
|
|
|
|
tst_ts_set_sec(&ret, us / 1000000);
|
|
tst_ts_set_nsec(&ret, (us % 1000000) * 1000);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Converts microseconds to timespec
|
|
*/
|
|
static inline struct timespec
|
|
tst_timespec_from_us(long long us)
|
|
{
|
|
return tst_ts_to_timespec(tst_ts_from_us(TST_LIBC_TIMESPEC, us));
|
|
}
|
|
|
|
/*
|
|
* Converts miliseconds to tst_ts
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_from_ms(enum tst_ts_type type, long long ms)
|
|
{
|
|
struct tst_ts ret = {.type = type};
|
|
|
|
tst_ts_set_sec(&ret, ms / 1000);
|
|
tst_ts_set_nsec(&ret, (ms % 1000) * 1000000);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Converts miliseconds to timespec
|
|
*/
|
|
static inline struct timespec
|
|
tst_timespec_from_ms(long long ms)
|
|
{
|
|
return tst_ts_to_timespec(tst_ts_from_ms(TST_LIBC_TIMESPEC, ms));
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_value from microseconds.
|
|
*/
|
|
static inline void tst_its_set_interval_from_us(struct tst_its *its, long long usec)
|
|
{
|
|
struct timespec tp = tst_timespec_from_us(usec);
|
|
|
|
tst_its_set_interval_sec(its, tp.tv_sec);
|
|
tst_its_set_interval_nsec(its, tp.tv_nsec);
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_value from microseconds.
|
|
*/
|
|
static inline void tst_its_set_value_from_us(struct tst_its *its, long long usec)
|
|
{
|
|
struct timespec tp = tst_timespec_from_us(usec);
|
|
|
|
tst_its_set_value_sec(its, tp.tv_sec);
|
|
tst_its_set_value_nsec(its, tp.tv_nsec);
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_interval from tst_ts.
|
|
*/
|
|
static inline void tst_its_set_interval_from_ts(struct tst_its *its, struct tst_ts ts)
|
|
{
|
|
tst_its_set_interval_sec(its, tst_ts_get_sec(ts));
|
|
tst_its_set_interval_nsec(its, tst_ts_get_nsec(ts));
|
|
}
|
|
|
|
/*
|
|
* Sets tst_its it_value from tst_ts.
|
|
*/
|
|
static inline void tst_its_set_value_from_ts(struct tst_its *its, struct tst_ts ts)
|
|
{
|
|
tst_its_set_value_sec(its, tst_ts_get_sec(ts));
|
|
tst_its_set_value_nsec(its, tst_ts_get_nsec(ts));
|
|
}
|
|
|
|
/*
|
|
* Returns if t1 less than t2. Both t1 and t2 must be normalized.
|
|
*/
|
|
static inline int tst_ts_lt(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
if (tst_ts_get_sec(t1) == tst_ts_get_sec(t2))
|
|
return tst_ts_get_nsec(t1) < tst_ts_get_nsec(t2);
|
|
|
|
return tst_ts_get_sec(t1) < tst_ts_get_sec(t2);
|
|
}
|
|
|
|
/*
|
|
* Returns if ts1 less than ts2. Both ts1 and ts2 must be normalized.
|
|
*/
|
|
static inline int tst_timespec_lt(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
return tst_ts_lt(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
}
|
|
|
|
/*
|
|
* Returns normalized tst_ts, i.e. 0 <= nsec < 1000000000.
|
|
*/
|
|
static inline struct tst_ts tst_ts_normalize(struct tst_ts t)
|
|
{
|
|
long long sec = tst_ts_get_sec(t);
|
|
long long nsec = tst_ts_get_nsec(t);
|
|
|
|
if (nsec >= 1000000000) {
|
|
tst_ts_set_sec(&t, sec + 1);
|
|
tst_ts_set_nsec(&t, nsec - 1000000000);
|
|
}
|
|
|
|
if (nsec < 0) {
|
|
tst_ts_set_sec(&t, sec - 1);
|
|
tst_ts_set_nsec(&t, nsec + 1000000000);
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
/*
|
|
* Adds us microseconds to tst_ts.
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_add_us(struct tst_ts t, long long us)
|
|
{
|
|
struct tst_ts res = {.type = t.type};
|
|
|
|
tst_ts_set_sec(&res, tst_ts_get_sec(t) + us / 1000000);
|
|
tst_ts_set_nsec(&res, tst_ts_get_nsec(t) + (us % 1000000) * 1000);
|
|
|
|
return tst_ts_normalize(res);
|
|
}
|
|
|
|
/*
|
|
* Adds us microseconds to struct timespec.
|
|
*/
|
|
static inline struct timespec
|
|
tst_timespec_add_us(struct timespec ts, long long us)
|
|
{
|
|
struct tst_ts res;
|
|
|
|
res = tst_ts_add_us(tst_ts_from_timespec(ts), us);
|
|
|
|
return tst_ts_to_timespec(res);
|
|
}
|
|
|
|
/*
|
|
* Substracts us microseconds from tst_ts.
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_sub_us(struct tst_ts t, long long us)
|
|
{
|
|
struct tst_ts res = {.type = t.type};
|
|
|
|
tst_ts_set_sec(&res, tst_ts_get_sec(t) - us / 1000000);
|
|
tst_ts_set_nsec(&res, tst_ts_get_nsec(t) - (us % 1000000) * 1000);
|
|
|
|
return tst_ts_normalize(res);
|
|
}
|
|
|
|
/*
|
|
* Substracts us microseconds from timespec.
|
|
*/
|
|
static inline struct timespec
|
|
tst_timespec_sub_us(struct timespec ts, long long us)
|
|
{
|
|
struct tst_ts res;
|
|
|
|
res = tst_ts_sub_us(tst_ts_from_timespec(ts), us);
|
|
|
|
return tst_ts_to_timespec(res);
|
|
}
|
|
|
|
/*
|
|
* Adds two tst_ts structures.
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_add(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
struct tst_ts res = {.type = t1.type};
|
|
|
|
tst_ts_set_sec(&res, tst_ts_get_sec(t1) + tst_ts_get_sec(t2));
|
|
tst_ts_set_nsec(&res, tst_ts_get_nsec(t1) + tst_ts_get_nsec(t2));
|
|
|
|
return tst_ts_normalize(res);
|
|
}
|
|
|
|
/*
|
|
* Adds two timespec structures.
|
|
*/
|
|
static inline struct timespec
|
|
tst_timespec_add(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
struct tst_ts res;
|
|
|
|
res = tst_ts_add(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
|
|
return tst_ts_to_timespec(res);
|
|
}
|
|
|
|
/*
|
|
* Substract two tst_ts structures.
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_diff(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
struct tst_ts res = {.type = t1.type};
|
|
|
|
tst_ts_set_sec(&res, tst_ts_get_sec(t1) - tst_ts_get_sec(t2));
|
|
tst_ts_set_nsec(&res, tst_ts_get_nsec(t1) - tst_ts_get_nsec(t2));
|
|
|
|
return tst_ts_normalize(res);
|
|
}
|
|
|
|
/*
|
|
* Substract two timespec structures.
|
|
*/
|
|
static inline struct timespec
|
|
tst_timespec_diff(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
struct tst_ts res;
|
|
|
|
res = tst_ts_diff(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
|
|
return tst_ts_to_timespec(res);
|
|
}
|
|
|
|
/*
|
|
* Substract two tst_ts structures returns number of nanoseconds.
|
|
*/
|
|
static inline long long
|
|
tst_ts_diff_ns(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
return tst_ts_to_ns(tst_ts_diff(t1, t2));
|
|
}
|
|
|
|
/*
|
|
* Substract two timespec structures returns number of nanoseconds.
|
|
*/
|
|
static inline long long
|
|
tst_timespec_diff_ns(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
return tst_ts_diff_ns(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
}
|
|
|
|
/*
|
|
* Substract two tst_ts structures returns number of microseconds.
|
|
*/
|
|
static inline long long
|
|
tst_ts_diff_us(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
return tst_ts_to_us(tst_ts_diff(t1, t2));
|
|
}
|
|
|
|
/*
|
|
* Substract two timespec structures returns number of microseconds.
|
|
*/
|
|
static inline long long
|
|
tst_timespec_diff_us(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
return tst_ts_diff_us(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
}
|
|
|
|
/*
|
|
* Substract two tst_ts structures returns number of milliseconds.
|
|
*/
|
|
static inline long long
|
|
tst_ts_diff_ms(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
return tst_ts_to_ms(tst_ts_diff(t1, t2));
|
|
}
|
|
|
|
/*
|
|
* Substract two timespec structures returns number of milliseconds.
|
|
*/
|
|
static inline long long
|
|
tst_timespec_diff_ms(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
return tst_ts_diff_ms(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
}
|
|
|
|
/*
|
|
* Returns absolute value of difference between two timespec structures.
|
|
*/
|
|
static inline struct tst_ts
|
|
tst_ts_abs_diff(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
if (tst_ts_lt(t1, t2))
|
|
return tst_ts_diff(t2, t1);
|
|
else
|
|
return tst_ts_diff(t1, t2);
|
|
}
|
|
|
|
/*
|
|
* Returns absolute value of difference between two tst_ts structures in
|
|
* microseconds.
|
|
*/
|
|
static inline long long
|
|
tst_ts_abs_diff_us(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
return tst_ts_to_us(tst_ts_abs_diff(t1, t2));
|
|
}
|
|
|
|
/*
|
|
* Returns absolute value of difference between two timespec structures in
|
|
* microseconds.
|
|
*/
|
|
static inline long long
|
|
tst_timespec_abs_diff_us(struct timespec ts1, struct timespec ts2)
|
|
{
|
|
return tst_ts_abs_diff_us(tst_ts_from_timespec(ts1), tst_ts_from_timespec(ts2));
|
|
}
|
|
|
|
/*
|
|
* Returns absolute value of difference between two timespec structures in
|
|
* milliseconds.
|
|
*/
|
|
static inline long long
|
|
tst_ts_abs_diff_ms(struct tst_ts t1, struct tst_ts t2)
|
|
{
|
|
return tst_ts_to_ms(tst_ts_abs_diff(t1, t2));
|
|
}
|
|
|
|
/*
|
|
* Exits the test with TCONF if particular timer is not supported. This is
|
|
* intended to be used in test setup. There is no cleanup callback parameter as
|
|
* you are expected to call it before initializing any resources that has to be
|
|
* cleaned up later.
|
|
*
|
|
* @clk_id: Posix clock to use.
|
|
*/
|
|
void tst_timer_check(clockid_t clk_id);
|
|
|
|
/*
|
|
* Marks a start time for given clock type.
|
|
*
|
|
* @clk_id: Posix clock to use.
|
|
*/
|
|
void tst_timer_start(clockid_t clk_id);
|
|
|
|
/*
|
|
* Returns true if timer started by tst_timer_start() has been running for
|
|
* longer than ms seconds.
|
|
*
|
|
* @ms: Time interval in milliseconds.
|
|
*/
|
|
int tst_timer_expired_ms(long long ms);
|
|
|
|
/*
|
|
* Marks timer end time.
|
|
*/
|
|
void tst_timer_stop(void);
|
|
|
|
/*
|
|
* Retuns elapsed time in struct timespec.
|
|
*/
|
|
struct timespec tst_timer_elapsed(void);
|
|
|
|
/*
|
|
* Returns elapsed time in milliseconds.
|
|
*/
|
|
static inline long long tst_timer_elapsed_ms(void)
|
|
{
|
|
return tst_timespec_to_ms(tst_timer_elapsed());
|
|
}
|
|
|
|
/*
|
|
* Returns elapsed time in microseconds.
|
|
*/
|
|
static inline long long tst_timer_elapsed_us(void)
|
|
{
|
|
return tst_timespec_to_us(tst_timer_elapsed());
|
|
}
|
|
|
|
#endif /* TST_TIMER */
|