syscalls/clock_gettime: Add support for time64 tests
v3 cover syscalls/clock_gettime: Add support for time64 tests
Hello,
Here is the third version which looks very different from the previous one again :)
V2->V3:
- Define an enum for timespec type create struct tst_timespec and update all generic helpers to handle them.
- Update clock_gettime tests to use them.
Viresh Kumar (2):
tst_timer: Add support for kernel's 64 bit timespec syscalls/clock_gettime: Add support for time64 tests
include/tst_timer.h | 549 +++++++++++++++++---- .../syscalls/clock_gettime/clock_gettime01.c | 116 ++--- .../syscalls/clock_gettime/clock_gettime02.c | 72 +-- .../syscalls/clock_gettime/clock_gettime03.c | 55 ++- 4 files changed, 602 insertions(+), 190 deletions(-)
Signature · 1 line
2.7.4
PATCH v3 1/2 tst_timer: Add support for kernel's 64 bit timespec
The Linux kernel defined a new 64bit timespec some time back and this patch makes necessary changes to tst_timer.h in order to prepare for supporting changes in syscalls testcases.
A new enum is introduced to keep a list of all timespec variants we need to support and all the timespec routines are updated to support the listed variants.
In order to not do unnecessary changes to other syscall tests, the name of the earlier routines are kept as is (with help of some macros that eventually call the new helpers).
The LTP testsuite is build tested with this patch and nothing fails to compile.
--- include/tst_timer.h | 508 ++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 411 insertions(+), 97 deletions(-)
include/tst_timer.h +411 -97
@@ -14,27 +14,45 @@#include <sys/time.h> #include <time.h> - -static inline long long tst_timespec_to_ns (struct timespec t) -{ -return t.tv_sec *1000000000 + t.tv_nsec; -} - -/* -* Converts timespec to microseconds. -*/ -static inline long long tst_timespec_to_us (struct timespec t) -{ -return t.tv_sec *1000000 + (t.tv_nsec +500 ) /1000 ; -} - -/* -* Converts timespec to milliseconds. -*/ -static inline long long tst_timespec_to_ms (struct timespec t) -{ -return t.tv_sec *1000 + (t.tv_nsec +500000 ) /1000000 ; -} +#include "tst_test.h" + +#ifndef __kernel_timespec + +#if defined(__x86_64__) && defined(__ILP32__) +typedef long long __kernel_long_t ; +#else +typedef long __kernel_long_t ; +#endif + +typedef __kernel_long_t __kernel_old_time_t ; + +struct __kernel_old_timespec { +__kernel_old_time_t tv_sec;/* seconds */ +__kernel_old_time_t tv_nsec;/* nanoseconds */ +}; + +typedef long long __kernel_time64_t ; + +struct __kernel_timespec { +__kernel_time64_t tv_sec;/* seconds */ +long long tv_nsec;/* nanoseconds */ +}; +#endif + +enum tst_timespec_type { +TST_LIBC_TIMESPEC , +TST_KERN_OLD_TIMESPEC , +TST_KERN_TIMESPEC +}; + +struct tst_timespec { +enum tst_timespec_type type; +union { +struct timespec libc_ts; +struct __kernel_old_timespec kern_old_ts; +struct __kernel_timespec kern_ts; + }; +};/* * Converts timeval to microseconds.
@@ -78,134 +96,427 @@ static inline struct timeval tst_us_to_timeval(long long us)return ret; } +#define TST_TIMESPEC_SINGLE_TS_TO (_name) \ +static inline long long _name(struct timespec t) \ +{ \ + struct tst_timespec tst_t = { \ + .type = TST_LIBC_TIMESPEC, \ + .libc_ts = t, \ + }; \ + \ + return tst_##_name(tst_t); \ +} + +static inline long long tst_tst_timespec_to_ns (struct tst_timespec t) +{ +switch (t.type) { +case TST_LIBC_TIMESPEC : +return t.libc_ts.tv_sec *1000000000 + t.libc_ts.tv_nsec; +case TST_KERN_OLD_TIMESPEC : +return t.kern_old_ts.tv_sec *1000000000 + t.kern_old_ts.tv_nsec; +case TST_KERN_TIMESPEC : +return t.kern_ts.tv_sec *1000000000 + t.kern_ts.tv_nsec; +default : +tst_brk (TBROK ,"Invalid type: %d" , t.type); +return -1 ; + } +} +TST_TIMESPEC_SINGLE_TS_TO (tst_timespec_to_ns); +/* -* Converts ms to struct timespec +* Converts timespec to microseconds. */ -static inline struct timespec tst_ms_to_timespec (long long ms) +static inline long long tst_tst_timespec_to_us (struct tst_timespec t) { -struct timespec ret; - - ret.tv_sec = ms /1000 ; - ret.tv_nsec = (ms %1000 ) *1000000 ; - -return ret; +switch (t.type) { +case TST_LIBC_TIMESPEC : +return t.libc_ts.tv_sec *1000000 + (t.libc_ts.tv_nsec +500 ) /1000 ; +case TST_KERN_OLD_TIMESPEC : +return t.kern_old_ts.tv_sec *1000000 + (t.kern_old_ts.tv_nsec +500 ) /1000 ; +case TST_KERN_TIMESPEC : +return t.kern_ts.tv_sec *1000000 + (t.kern_ts.tv_nsec +500 ) /1000 ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t.type); +return -1 ; + } } +TST_TIMESPEC_SINGLE_TS_TO (tst_timespec_to_us);/* -* Converts us to struct timespec +* Converts timespec to milliseconds. */ -static inline struct timespec tst_us_to_timespec (long long us) +static inline long long tst_tst_timespec_to_ms (struct tst_timespec t) { -struct timespec ret; +switch (t.type) { +case TST_LIBC_TIMESPEC : +return t.libc_ts.tv_sec *1000 + (t.libc_ts.tv_nsec +500000 ) /1000000 ; +case TST_KERN_OLD_TIMESPEC : +return t.kern_old_ts.tv_sec *1000 + (t.kern_old_ts.tv_nsec +500000 ) /1000000 ; +case TST_KERN_TIMESPEC : +return t.kern_ts.tv_sec *1000 + (t.kern_ts.tv_nsec +500000 ) /1000000 ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t.type); +return -1 ; + } +} +TST_TIMESPEC_SINGLE_TS_TO (tst_timespec_to_ms); + +#define TST_TIMESPEC_SINGLE_TO_TS (_name) \ +static inline struct timespec _name##_timespec(long long time) \ +{ \ + struct tst_timespec tst_t; \ + \ + tst_t = _name##_tst_timespec(TST_LIBC_TIMESPEC, time); \ + return tst_t.libc_ts; \ +} - ret.tv_sec = us /1000000 ; - ret.tv_nsec = (us %1000000 ) *1000 ; +/* +* Converts ms to struct tst_timespec +*/ +static inline struct tst_timespec tst_ms_to_tst_timespec (enum tst_timespec_type type,long long ms) +{ +struct tst_timespec ret = {.type = type}; + +switch (type) { +case TST_LIBC_TIMESPEC : + ret.libc_ts.tv_sec = ms /1000 ; + ret.libc_ts.tv_nsec = (ms %1000 ) *1000000 ; +break ; +case TST_KERN_OLD_TIMESPEC : + ret.kern_old_ts.tv_sec = ms /1000 ; + ret.kern_old_ts.tv_nsec = (ms %1000 ) *1000000 ; +break ; +case TST_KERN_TIMESPEC : + ret.kern_ts.tv_sec = ms /1000 ; + ret.kern_ts.tv_nsec = (ms %1000 ) *1000000 ; +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , type); + }return ret; } +TST_TIMESPEC_SINGLE_TO_TS (tst_ms_to);/* -* Comparsions +* Converts us to struct tst_timespec */ -static inline int tst_timespec_lt (struct timespec t1,struct timespec t2) +static inline struct tst_timespec +tst_us_to_tst_timespec (enum tst_timespec_type type,long long us) { -if (t1.tv_sec == t2.tv_sec) -return t1.tv_nsec < t2.tv_nsec; +struct tst_timespec ret = {.type = type}; + +switch (type) { +case TST_LIBC_TIMESPEC : + ret.libc_ts.tv_sec = us /1000000 ; + ret.libc_ts.tv_nsec = (us %1000000 ) *1000 ; +break ; +case TST_KERN_OLD_TIMESPEC : + ret.kern_old_ts.tv_sec = us /1000000 ; + ret.kern_old_ts.tv_nsec = (us %1000000 ) *1000 ; +break ; +case TST_KERN_TIMESPEC : + ret.kern_ts.tv_sec = us /1000000 ; + ret.kern_ts.tv_nsec = (us %1000000 ) *1000 ; +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , type); + } -return t1.tv_sec < t2.tv_sec; +return ret; +} +TST_TIMESPEC_SINGLE_TO_TS (tst_us_to); + +#define TST_TIMESPEC_MULT_TS_TO (_name, _ret_type) \ +static inline _ret_type _name(struct timespec t1, struct timespec t2) \ +{ \ + struct tst_timespec tst_t1 = { \ + .type = TST_LIBC_TIMESPEC, \ + .libc_ts = t1, \ + }; \ + \ + struct tst_timespec tst_t2 = { \ + .type = TST_LIBC_TIMESPEC, \ + .libc_ts = t2, \ + }; \ + \ + return tst_##_name(tst_t1, tst_t2); \ } -static inline struct timespec tst_timespec_normalize (struct timespec t) +/* +* Comparsions +*/ +static inline int tst_tst_timespec_lt (struct tst_timespec t1,struct tst_timespec t2) { -if (t.tv_nsec >=1000000000 ) { - t.tv_sec++; - t.tv_nsec -=1000000000 ; +if (t1.type != t2.type) +tst_brk (TBROK ,"Incompatible timespec type (%d:%d)" , t1.type, t2.type); + +switch (t1.type) { +case TST_LIBC_TIMESPEC : +if (t1.libc_ts.tv_sec == t2.libc_ts.tv_sec) +return t1.libc_ts.tv_nsec < t2.libc_ts.tv_nsec; + +return t1.libc_ts.tv_sec < t2.libc_ts.tv_sec; +case TST_KERN_OLD_TIMESPEC : +if (t1.kern_old_ts.tv_sec == t2.kern_old_ts.tv_sec) +return t1.kern_old_ts.tv_nsec < t2.kern_old_ts.tv_nsec; + +return t1.kern_old_ts.tv_sec < t2.kern_old_ts.tv_sec; +break ; +case TST_KERN_TIMESPEC : +if (t1.kern_ts.tv_sec == t2.kern_ts.tv_sec) +return t1.kern_ts.tv_nsec < t2.kern_ts.tv_nsec; + +return t1.kern_ts.tv_sec < t2.kern_ts.tv_sec; +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t1.type); +return -1 ; } +} +TST_TIMESPEC_MULT_TS_TO (tst_timespec_lt, int); -if (t.tv_nsec <0 ) { - t.tv_sec--; - t.tv_nsec +=1000000000 ; +static inline struct tst_timespec tst_timespec_normalize (struct tst_timespec t) +{ +switch (t.type) { +case TST_LIBC_TIMESPEC : +if (t.libc_ts.tv_nsec >=1000000000 ) { + t.libc_ts.tv_sec++; + t.libc_ts.tv_nsec -=1000000000 ; + } + +if (t.libc_ts.tv_nsec <0 ) { + t.libc_ts.tv_sec--; + t.libc_ts.tv_nsec +=1000000000 ; + } +break ; +case TST_KERN_OLD_TIMESPEC : +if (t.kern_old_ts.tv_nsec >=1000000000 ) { + t.kern_old_ts.tv_sec++; + t.kern_old_ts.tv_nsec -=1000000000 ; + } + +if (t.kern_old_ts.tv_nsec <0 ) { + t.kern_old_ts.tv_sec--; + t.kern_old_ts.tv_nsec +=1000000000 ; + } +break ; +case TST_KERN_TIMESPEC : +if (t.kern_ts.tv_nsec >=1000000000 ) { + t.kern_ts.tv_sec++; + t.kern_ts.tv_nsec -=1000000000 ; + } + +if (t.kern_ts.tv_nsec <0 ) { + t.kern_ts.tv_sec--; + t.kern_ts.tv_nsec +=1000000000 ; + } +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t.type); }return t; } +#define TST_TIMESPEC_SINGLE_TS_TO_TS (_name) \ +static inline struct timespec _name(struct timespec t, long long time) \ +{ \ + struct tst_timespec ret, tst_t = { \ + .type = TST_LIBC_TIMESPEC, \ + .libc_ts = t, \ + }; \ + \ + ret = tst_##_name(tst_t, time); \ + return ret.libc_ts; \ +} +/* * Adds us microseconds to t. */ -static inline struct timespec tst_timespec_add_us (struct timespec t, -long long us) +static inline struct tst_timespec tst_tst_timespec_add_us (struct tst_timespec t, +long long us) { - t.tv_sec += us /1000000 ; - t.tv_nsec += (us %1000000 ) *1000 ; - +switch (t.type) { +case TST_LIBC_TIMESPEC : + t.libc_ts.tv_sec += us /1000000 ; + t.libc_ts.tv_nsec += (us %1000000 ) *1000 ; +break ; +case TST_KERN_OLD_TIMESPEC : + t.kern_old_ts.tv_sec += us /1000000 ; + t.kern_old_ts.tv_nsec += (us %1000000 ) *1000 ; +break ; +case TST_KERN_TIMESPEC : + t.kern_ts.tv_sec += us /1000000 ; + t.kern_ts.tv_nsec += (us %1000000 ) *1000 ; +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t.type); + }return tst_timespec_normalize (t); } +TST_TIMESPEC_SINGLE_TS_TO_TS (tst_timespec_add_us);/* -* Adds two timespec structures. +* Subtracts us microseconds from t. */ -static inline struct timespec tst_timespec_add (struct timespec t1, -struct timespec t2) +static inline struct tst_timespec tst_tst_timespec_sub_us (struct tst_timespec t, +long long us) { -struct timespec res; - - res.tv_sec = t1.tv_sec + t2.tv_sec; - res.tv_nsec = t1.tv_nsec + t2.tv_nsec; +switch (t.type) { +case TST_LIBC_TIMESPEC : + t.libc_ts.tv_sec -= us /1000000 ; + t.libc_ts.tv_nsec -= (us %1000000 ) *1000 ; +break ; +case TST_KERN_OLD_TIMESPEC : + t.kern_old_ts.tv_sec -= us /1000000 ; + t.kern_old_ts.tv_nsec -= (us %1000000 ) *1000 ; +break ; +case TST_KERN_TIMESPEC : + t.kern_ts.tv_sec -= us /1000000 ; + t.kern_ts.tv_nsec -= (us %1000000 ) *1000 ; +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t.type); + } -return tst_timespec_normalize (res); +return tst_timespec_normalize (t); +} +TST_TIMESPEC_SINGLE_TS_TO_TS (tst_timespec_sub_us); + +#define TST_TIMESPEC_MULT_TS_TO_TS (_name) \ +static inline struct timespec _name(struct timespec t1, struct timespec t2) \ +{ \ + struct tst_timespec ret, tst_t1 = { \ + .type = TST_LIBC_TIMESPEC, \ + .libc_ts = t1, \ + }; \ + \ + struct tst_timespec tst_t2 = { \ + .type = TST_LIBC_TIMESPEC, \ + .libc_ts = t2, \ + }; \ + \ + ret = tst_##_name(tst_t1, tst_t2); \ + return ret.libc_ts; \ }/* -* Subtracts us microseconds from t. +* Adds two tst_timespec structures. */ -static inline struct timespec tst_timespec_sub_us (struct timespec t, -long long us) +static inline struct tst_timespec tst_tst_timespec_add (struct tst_timespec t1, +struct tst_timespec t2) { - t.tv_sec -= us /1000000 ; - t.tv_nsec -= (us %1000000 ) *1000 ; +struct tst_timespec res = {.type = t1.type}; + +if (t1.type != t2.type) +tst_brk (TBROK ,"Incompatible timespec type (%d:%d)" , t1.type, t2.type); + +switch (t2.type) { +case TST_LIBC_TIMESPEC : + res.libc_ts.tv_sec = t1.libc_ts.tv_sec + t2.libc_ts.tv_sec; + res.libc_ts.tv_nsec = t1.libc_ts.tv_nsec + t2.libc_ts.tv_nsec; +break ; +case TST_KERN_OLD_TIMESPEC : + res.kern_old_ts.tv_sec = t1.kern_old_ts.tv_sec + t2.kern_old_ts.tv_sec; + res.kern_old_ts.tv_nsec = t1.kern_old_ts.tv_nsec + t2.kern_old_ts.tv_nsec; +break ; +case TST_KERN_TIMESPEC : + res.kern_ts.tv_sec = t1.kern_ts.tv_sec + t2.kern_ts.tv_sec; + res.kern_ts.tv_nsec = t1.kern_ts.tv_nsec + t2.kern_ts.tv_nsec; +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t1.type); + } -return tst_timespec_normalize (t); +return tst_timespec_normalize (res); } +TST_TIMESPEC_MULT_TS_TO_TS (tst_timespec_add);/* -* Returns difference between two timespec structures. +* Returns difference between two tst_timespec structures. */ -static inline struct timespec tst_timespec_diff (struct timespec t1, -struct timespec t2) +static inline struct tst_timespec tst_tst_timespec_diff (struct tst_timespec t1, +struct tst_timespec t2) { -struct timespec res; - - res.tv_sec = t1.tv_sec - t2.tv_sec; - -if (t1.tv_nsec < t2.tv_nsec) { - res.tv_sec--; - res.tv_nsec =1000000000 - (t2.tv_nsec - t1.tv_nsec); - }else { - res.tv_nsec = t1.tv_nsec - t2.tv_nsec; +struct tst_timespec res = {.type = t1.type}; + +if (t1.type != t2.type) +tst_brk (TBROK ,"Incompatible timespec type (%d:%d)" , t1.type, t2.type); + +switch (t1.type) { +case TST_LIBC_TIMESPEC : + res.libc_ts.tv_sec = t1.libc_ts.tv_sec - t2.libc_ts.tv_sec; + +if (t1.libc_ts.tv_nsec < t2.libc_ts.tv_nsec) { + res.libc_ts.tv_sec--; + res.libc_ts.tv_nsec =1000000000 - (t2.libc_ts.tv_nsec - t1.libc_ts.tv_nsec); + }else { + res.libc_ts.tv_nsec = t1.libc_ts.tv_nsec - t2.libc_ts.tv_nsec; + } +break ; +case TST_KERN_OLD_TIMESPEC : + res.kern_old_ts.tv_sec = t1.kern_old_ts.tv_sec - t2.kern_old_ts.tv_sec; + +if (t1.kern_old_ts.tv_nsec < t2.kern_old_ts.tv_nsec) { + res.kern_old_ts.tv_sec--; + res.kern_old_ts.tv_nsec =1000000000 - (t2.kern_old_ts.tv_nsec - t1.kern_old_ts.tv_nsec); + }else { + res.kern_old_ts.tv_nsec = t1.kern_old_ts.tv_nsec - t2.kern_old_ts.tv_nsec; + } +break ; +case TST_KERN_TIMESPEC : + res.kern_ts.tv_sec = t1.kern_ts.tv_sec - t2.kern_ts.tv_sec; + +if (t1.kern_ts.tv_nsec < t2.kern_ts.tv_nsec) { + res.kern_ts.tv_sec--; + res.kern_ts.tv_nsec =1000000000 - (t2.kern_ts.tv_nsec - t1.kern_ts.tv_nsec); + }else { + res.kern_ts.tv_nsec = t1.kern_ts.tv_nsec - t2.kern_ts.tv_nsec; + } +break ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t1.type); }return res; } +TST_TIMESPEC_MULT_TS_TO_TS (tst_timespec_diff); -static inline long long tst_timespec_diff_ns (struct timespec t1, -struct timespec t2) +static inline long long tst_tst_timespec_diff_ns (struct tst_timespec t1, +struct tst_timespec t2) { -return t1.tv_nsec - t2.tv_nsec +1000000000LL * (t1.tv_sec - t2.tv_sec); +if (t1.type != t2.type) +tst_brk (TBROK ,"Incompatible timespec type (%d:%d)" , t1.type, t2.type); + +switch (t1.type) { +case TST_LIBC_TIMESPEC : +return t1.libc_ts.tv_nsec - t2.libc_ts.tv_nsec +1000000000LL * (t1.libc_ts.tv_sec - t2.libc_ts.tv_sec); +case TST_KERN_OLD_TIMESPEC : +return t1.kern_old_ts.tv_nsec - t2.kern_old_ts.tv_nsec +1000000000LL * (t1.kern_old_ts.tv_sec - t2.kern_old_ts.tv_sec); +case TST_KERN_TIMESPEC : +return t1.kern_ts.tv_nsec - t2.kern_ts.tv_nsec +1000000000LL * (t1.kern_ts.tv_sec - t2.kern_ts.tv_sec); +default : +tst_brk (TBROK ,"Invalid type: %d" , t1.type); +return -1 ; + } } +TST_TIMESPEC_MULT_TS_TO(tst_timespec_diff_ns, long long); -static inline long long tst_timespec_diff_us (struct timespec t1, -struct timespec t2) +static inline long long tst_tst_timespec_diff_us (struct tst_timespec t1, +struct tst_timespec t2) { -return tst_timespec_to_us (tst_timespec_diff (t1, t2)); +return tst_tst_timespec_to_us (tst_tst_timespec_diff (t1, t2)); } +TST_TIMESPEC_MULT_TS_TO(tst_timespec_diff_us, long long); -static inline long long tst_timespec_diff_ms (struct timespec t1, -struct timespec t2) +static inline long long tst_tst_timespec_diff_ms (struct tst_timespec t1, +struct tst_timespec t2) { -return tst_timespec_to_ms (tst_timespec_diff (t1, t2)); +return tst_tst_timespec_to_ms (tst_tst_timespec_diff (t1, t2)); } +TST_TIMESPEC_MULT_TS_TO(tst_timespec_diff_ms, long long);/* * Returns difference between two timeval structures.
@@ -242,26 +553,29 @@ static inline long long tst_timeval_diff_ms(struct timeval t1,/* * Returns absolute value of difference between two timespec structures. */ -static inline struct timespec tst_timespec_abs_diff (struct timespec t1, -struct timespec t2) +static inline struct tst_timespec +tst_tst_timespec_abs_diff (struct tst_timespec t1,struct tst_timespec t2) { -if (tst_timespec_lt (t1, t2)) -return tst_timespec_diff (t2, t1); +if (tst_tst_timespec_lt (t1, t2)) +return tst_tst_timespec_diff (t2, t1);else -return tst_timespec_diff (t1, t2); +return tst_tst_timespec_diff (t1, t2); } +TST_TIMESPEC_MULT_TS_TO_TS (tst_timespec_abs_diff); -static inline long long tst_timespec_abs_diff_us (struct timespec t1, -struct timespec t2) +static inline long long tst_tst_timespec_abs_diff_us (struct tst_timespec t1, +struct tst_timespec t2) { -return tst_timespec_to_us (tst_timespec_abs_diff (t1, t2)); +return tst_tst_timespec_to_us (tst_tst_timespec_abs_diff (t1, t2)); } +TST_TIMESPEC_MULT_TS_TO(tst_timespec_abs_diff_us, long long); -static inline long long tst_timespec_abs_diff_ms (struct timespec t1, -struct timespec t2) +static inline long long tst_tst_timespec_abs_diff_ms (struct tst_timespec t1, +struct tst_timespec t2) { -return tst_timespec_to_ms (tst_timespec_abs_diff (t1, t2)); +return tst_tst_timespec_to_ms (tst_tst_timespec_abs_diff (t1, t2)); } +TST_TIMESPEC_MULT_TS_TO(tst_timespec_abs_diff_ms, long long);/* * Exits the test with TCONF if particular timer is not supported. This is
Signature · 1 line
2.7.4
PATCH v3 1/2 tst_timer: Add support for kernel's 64 bit timespec
Hi!
I've cleaned up and simplified these changes + wrote a simple test and pushed the result, thanks a lot for your effors.
Can you please rebase the test changes on the top of these changes? It should be merely cosmetical, function names have changes etc.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v3 1/2 tst_timer: Add support for kernel's 64 bit timespec
Quoted 6 lines · Cyril Hrubis
Hi!
I've cleaned up and simplified these changes + wrote a simple test and pushed the result, thanks a lot for your effors.Can you please rebase the test changes on the top of these changes? It should be merely cosmetical, function names have changes etc.
Thanks for the changes, they look much better now :)
Signature · 1 line
viresh
PATCH v3 1/2 tst_timer: Add support for kernel's 64 bit timespec
In reply to Cyril HrubisHi,
Quoted 5 lines
I've cleaned up and simplified these changes + wrote a simple test and pushed the result, thanks a lot for your effors.
Can you please rebase the test changes on the top of these changes? It should be merely cosmetical, function names have changes etc.
include/tst_timer.h is broken on gcc 4, which we have in Travis (CentOS 6). I don't know how to fix this, but maybe fix is trivial.
Or is it time to finally drop this oldest distro? If it's easy to fix, I'd postpone dropping CentOS 6 after release (some embedded distros/projects might still use old compilers).
gcc -g -O2 -g -O2 -fno-strict-aliasing -pipe -Wall -W -Wold-style-definition -W -Wall -D_FORTIFY_SOURCE=2 -I../../include -I../../include -I../../include/old/ -L../../lib test_timer.c -lltp -o test_timer
In file included from test_timer.c:11:../../include/tst_timer.h: In function ?tst_ts_from_timespec?:../../include/tst_timer.h:214: error: unknown field ?libc_ts? specified in initializer ../../include/tst_timer.h:214: warning: missing braces around initializer ../../include/tst_timer.h:214: warning: (near initialization for ?t.<anonymous>?) ../../include/tst_timer.h:215: warning: missing initializer ../../include/tst_timer.h:215: warning: (near initialization for ?t.<anonymous>.libc_ts.tv_nsec?) ../../include/tst_timer.h:215: error: unknown field ?libc_ts? specified in initializer ../../include/tst_timer.h:215: warning: excess elements in struct initializer ../../include/tst_timer.h:215: warning: (near initialization for ?t?)
make: *** [test_timer] Error 1
$ gcc --version gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-18)
Kind regards,
Petr
PATCH v3 1/2 tst_timer: Add support for kernel's 64 bit timespec
Hi!
Quoted 19 lines
include/tst_timer.his broken on gcc 4, which we have in Travis (CentOS 6). I don't know how to fix this, but maybe fix is trivial.
Or is it time to finally drop this oldest distro? If it's easy to fix, I'd postpone dropping CentOS 6 after release (some embedded distros/projects might still use old compilers).gcc -g -O2 -g -O2 -fno-strict-aliasing -pipe -Wall -W -Wold-style-definition -W -Wall -D_FORTIFY_SOURCE=2 -I../../include -I../../include -I../../include/old/ -L../../lib
test_timer.c-lltp -otest_timer
In file included from test_timer.c:11:../../include/tst_timer.h: In function ???tst_ts_from_timespec???:../../include/tst_timer.h:214: error: unknown field ???libc_ts??? specified in initializer../../include/tst_timer.h:214: warning: missing braces around initializer../../include/tst_timer.h:214: warning: (near initialization for ???t.<anonymous>???)../../include/tst_timer.h:215: warning: missing initializer../../include/tst_timer.h:215: warning: (near initialization for ???t.<anonymous>.libc_ts.tv_nsec???)../../include/tst_timer.h:215: error: unknown field ???libc_ts??? specified in initializer../../include/tst_timer.h:215: warning: excess elements in struct initializer../../include/tst_timer.h:215: warning: (near initialization for ???t???)
make: *** [test_timer] Error 1
Quoted 2 lines
$ gcc --version gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-18)
Looks like there are some problems with the anonymouns unions, probably gcc 4.4 does not support these. I will have a look later on.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v3 1/2 tst_timer: Add support for kernel's 64 bit timespec
Hi!
Quoted 5 lines
Quoted 2 lines
$ gcc --version gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-18)Looks like there are some problems with the anonymouns unions, probably gcc 4.4 does not support these. I will have a look later on.
Looking into the issue, anonymous unions are part of c11 standard so it looks like gcc 4.4 is too old to support that. I have tested 4.4.5 which definitelly lacks the support.
So I guess I will have to change the code so that the union has a name, its not a big deal since we aren't touching the fields directly but only in a few get/set functions.
Signature · 2 lines
Cyril Hrubis [email protected]
PATCH v3 2/2 syscalls/clock_gettime: Add support for time64 tests
In reply to Viresh KumarThis adds support for time64 tests to the existing clock_gettime() syscall tests.
--- include/tst_timer.h | 65 +++++++++++- .../syscalls/clock_gettime/clock_gettime01.c | 116 +++++++++------------ .../syscalls/clock_gettime/clock_gettime02.c | 72 +++++++------ .../syscalls/clock_gettime/clock_gettime03.c | 55 ++++++++-- 4 files changed, 203 insertions(+), 105 deletions(-)
include/tst_timer.h +64 -1
@@ -15,6 +15,7 @@#include <sys/time.h> #include <time.h> #include "tst_test.h" +#include "lapi/syscalls.h" #ifndef __kernel_timespec
@@ -42,7 +43,9 @@ struct __kernel_timespec {enum tst_timespec_type {TST_LIBC_TIMESPEC ,TST_KERN_OLD_TIMESPEC , -TST_KERN_TIMESPEC +TST_KERN_TIMESPEC , +/* Used for indicating failure test with bad address */ +TST_KERN_BAD_ADDR };struct tst_timespec {
@@ -54,6 +57,66 @@ struct tst_timespec { }; }; +static inline void *tst_get_timespec (struct tst_timespec *t) +{ +switch (t->type) { +case TST_LIBC_TIMESPEC : +return &t->libc_ts; +case TST_KERN_OLD_TIMESPEC : +return &t->kern_old_ts; +case TST_KERN_TIMESPEC : +return &t->kern_ts; +case TST_KERN_BAD_ADDR : +return tst_get_bad_addr (NULL ); +default : +tst_brk (TBROK ,"Invalid type: %d" , t->type); +return NULL ; + } +} + +static inline int libc_clock_gettime (clockid_t clk_id,struct tst_timespec *t) +{ +return clock_gettime (clk_id,tst_get_timespec (t)); +} + +static inline int sys_clock_gettime (clockid_t clk_id,struct tst_timespec *t) +{ +return tst_syscall (__NR_clock_gettime, clk_id,tst_get_timespec (t)); +} + +static inline int sys_clock_gettime64 (clockid_t clk_id,struct tst_timespec *t) +{ +return tst_syscall (__NR_clock_gettime64, clk_id,tst_get_timespec (t)); +} + +/* +* tst_timespec_nonzero return: +* 0: On success, i.e. timespec updated correctly. +* -1: Error, timespec not updated. +* -2: Error, tv_nsec is corrupted. +*/ +static inline int tst_timespec_nonzero (struct tst_timespec *t) +{ +switch (t->type) { +case TST_LIBC_TIMESPEC : +return (t->libc_ts.tv_nsec ==0 && t->libc_ts.tv_sec ==0 ) ?-1 :0 ; +case TST_KERN_OLD_TIMESPEC : +return (t->kern_old_ts.tv_nsec ==0 && t->kern_old_ts.tv_sec ==0 ) ?-1 :0 ; +case TST_KERN_TIMESPEC : +if (t->kern_ts.tv_nsec ==0 && t->kern_ts.tv_sec ==0 ) +return -1 ; + +/* Upper 32 bits of tv_nsec should be cleared */ +if (t->kern_ts.tv_nsec >>32 ) +return -2 ; +else +return 0 ; +default : +tst_brk (TBROK ,"Invalid type: %d" , t->type); +return -1 ; + } +} +/* * Converts timeval to microseconds. */
testcases/kernel/syscalls/clock_gettime/clock_gettime01.c +52 -64
150 lines not on this page · raw message
testcases/kernel/syscalls/clock_gettime/clock_gettime02.c +43 -29
112 lines not on this page · raw message
testcases/kernel/syscalls/clock_gettime/clock_gettime03.c +44 -11
106 lines not on this page · raw message
Signature · 1 line
2.7.4