1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <stdio.h>
24#include <unistd.h>
25#include <time.h>
26#include <string.h>
27#include <signal.h>
28#include <stdlib.h>
29#include <pthread.h>
30#ifdef KTEST
31#include "../kselftest.h"
32#else
33static inline int ksft_exit_pass(void)
34{
35 exit(0);
36}
37static inline int ksft_exit_fail(void)
38{
39 exit(1);
40}
41#endif
42
43#define CLOCK_REALTIME 0
44#define CLOCK_MONOTONIC 1
45#define CLOCK_PROCESS_CPUTIME_ID 2
46#define CLOCK_THREAD_CPUTIME_ID 3
47#define CLOCK_MONOTONIC_RAW 4
48#define CLOCK_REALTIME_COARSE 5
49#define CLOCK_MONOTONIC_COARSE 6
50#define CLOCK_BOOTTIME 7
51#define CLOCK_REALTIME_ALARM 8
52#define CLOCK_BOOTTIME_ALARM 9
53#define CLOCK_HWSPECIFIC 10
54#define CLOCK_TAI 11
55#define NR_CLOCKIDS 12
56
57
58#define NSEC_PER_SEC 1000000000ULL
59#define UNRESONABLE_LATENCY 40000000
60
61#define TIMER_SECS 1
62int alarmcount;
63int clock_id;
64struct timespec start_time;
65long long max_latency_ns;
66
67char *clockstring(int clockid)
68{
69 switch (clockid) {
70 case CLOCK_REALTIME:
71 return "CLOCK_REALTIME";
72 case CLOCK_MONOTONIC:
73 return "CLOCK_MONOTONIC";
74 case CLOCK_PROCESS_CPUTIME_ID:
75 return "CLOCK_PROCESS_CPUTIME_ID";
76 case CLOCK_THREAD_CPUTIME_ID:
77 return "CLOCK_THREAD_CPUTIME_ID";
78 case CLOCK_MONOTONIC_RAW:
79 return "CLOCK_MONOTONIC_RAW";
80 case CLOCK_REALTIME_COARSE:
81 return "CLOCK_REALTIME_COARSE";
82 case CLOCK_MONOTONIC_COARSE:
83 return "CLOCK_MONOTONIC_COARSE";
84 case CLOCK_BOOTTIME:
85 return "CLOCK_BOOTTIME";
86 case CLOCK_REALTIME_ALARM:
87 return "CLOCK_REALTIME_ALARM";
88 case CLOCK_BOOTTIME_ALARM:
89 return "CLOCK_BOOTTIME_ALARM";
90 case CLOCK_TAI:
91 return "CLOCK_TAI";
92 };
93 return "UNKNOWN_CLOCKID";
94}
95
96
97long long timespec_sub(struct timespec a, struct timespec b)
98{
99 long long ret = NSEC_PER_SEC * b.tv_sec + b.tv_nsec;
100
101 ret -= NSEC_PER_SEC * a.tv_sec + a.tv_nsec;
102 return ret;
103}
104
105
106void sigalarm(int signo)
107{
108 long long delta_ns;
109 struct timespec ts;
110
111 clock_gettime(clock_id, &ts);
112 alarmcount++;
113
114 delta_ns = timespec_sub(start_time, ts);
115 delta_ns -= NSEC_PER_SEC * TIMER_SECS * alarmcount;
116
117 if (delta_ns < 0)
118 printf("%s timer fired early: FAIL\n", clockstring(clock_id));
119
120 if (delta_ns > max_latency_ns)
121 max_latency_ns = delta_ns;
122}
123
124int do_timer(int clock_id, int flags)
125{
126 struct sigevent se;
127 timer_t tm1;
128 struct itimerspec its1, its2;
129 int err;
130
131
132 memset(&se, 0, sizeof(se));
133 se.sigev_notify = SIGEV_SIGNAL;
134 se.sigev_signo = SIGRTMAX;
135 se.sigev_value.sival_int = 0;
136
137 max_latency_ns = 0;
138 alarmcount = 0;
139
140 err = timer_create(clock_id, &se, &tm1);
141 if (err) {
142 if ((clock_id == CLOCK_REALTIME_ALARM) ||
143 (clock_id == CLOCK_BOOTTIME_ALARM)) {
144 printf("%-22s %s missing CAP_WAKE_ALARM? : [UNSUPPORTED]\n",
145 clockstring(clock_id),
146 flags ? "ABSTIME":"RELTIME");
147 return 0;
148 }
149 printf("%s - timer_create() failed\n", clockstring(clock_id));
150 return -1;
151 }
152
153 clock_gettime(clock_id, &start_time);
154 if (flags) {
155 its1.it_value = start_time;
156 its1.it_value.tv_sec += TIMER_SECS;
157 } else {
158 its1.it_value.tv_sec = TIMER_SECS;
159 its1.it_value.tv_nsec = 0;
160 }
161 its1.it_interval.tv_sec = TIMER_SECS;
162 its1.it_interval.tv_nsec = 0;
163
164 err = timer_settime(tm1, flags, &its1, &its2);
165 if (err) {
166 printf("%s - timer_settime() failed\n", clockstring(clock_id));
167 return -1;
168 }
169
170 while (alarmcount < 5)
171 sleep(1);
172
173 printf("%-22s %s max latency: %10lld ns : ",
174 clockstring(clock_id),
175 flags ? "ABSTIME":"RELTIME",
176 max_latency_ns);
177
178 timer_delete(tm1);
179 if (max_latency_ns < UNRESONABLE_LATENCY) {
180 printf("[OK]\n");
181 return 0;
182 }
183 printf("[FAILED]\n");
184 return -1;
185}
186
187int main(void)
188{
189 struct sigaction act;
190 int signum = SIGRTMAX;
191 int ret = 0;
192
193
194 sigfillset(&act.sa_mask);
195 act.sa_flags = 0;
196 act.sa_handler = sigalarm;
197 sigaction(signum, &act, NULL);
198
199 printf("Setting timers for every %i seconds\n", TIMER_SECS);
200 for (clock_id = 0; clock_id < NR_CLOCKIDS; clock_id++) {
201
202 if ((clock_id == CLOCK_PROCESS_CPUTIME_ID) ||
203 (clock_id == CLOCK_THREAD_CPUTIME_ID) ||
204 (clock_id == CLOCK_MONOTONIC_RAW) ||
205 (clock_id == CLOCK_REALTIME_COARSE) ||
206 (clock_id == CLOCK_MONOTONIC_COARSE) ||
207 (clock_id == CLOCK_HWSPECIFIC))
208 continue;
209
210 ret |= do_timer(clock_id, TIMER_ABSTIME);
211 ret |= do_timer(clock_id, 0);
212 }
213 if (ret)
214 return ksft_exit_fail();
215 return ksft_exit_pass();
216}
217
