1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2013 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
4 *
5 * Selftests for a few posix timers interface.
6 *
7 * Kernel loop code stolen from Steven Rostedt <srostedt@redhat.com>
8 */
9
10 #include <sys/time.h>
11 #include <stdio.h>
12 #include <signal.h>
13 #include <unistd.h>
14 #include <time.h>
15 #include <pthread.h>
16
17 #include "../kselftest.h"
18
19 #define DELAY 2
20 #define USECS_PER_SEC 1000000
21
22 static volatile int done;
23
24 /* Busy loop in userspace to elapse ITIMER_VIRTUAL */
user_loop(void)25 static void user_loop(void)
26 {
27 while (!done);
28 }
29
30 /*
31 * Try to spend as much time as possible in kernelspace
32 * to elapse ITIMER_PROF.
33 */
kernel_loop(void)34 static void kernel_loop(void)
35 {
36 void *addr = sbrk(0);
37 int err = 0;
38
39 while (!done && !err) {
40 err = brk(addr + 4096);
41 err |= brk(addr);
42 }
43 }
44
45 /*
46 * Sleep until ITIMER_REAL expiration.
47 */
idle_loop(void)48 static void idle_loop(void)
49 {
50 pause();
51 }
52
sig_handler(int nr)53 static void sig_handler(int nr)
54 {
55 done = 1;
56 }
57
58 /*
59 * Check the expected timer expiration matches the GTOD elapsed delta since
60 * we armed the timer. Keep a 0.5 sec error margin due to various jitter.
61 */
check_diff(struct timeval start,struct timeval end)62 static int check_diff(struct timeval start, struct timeval end)
63 {
64 long long diff;
65
66 diff = end.tv_usec - start.tv_usec;
67 diff += (end.tv_sec - start.tv_sec) * USECS_PER_SEC;
68
69 if (abs(diff - DELAY * USECS_PER_SEC) > USECS_PER_SEC / 2) {
70 printf("Diff too high: %lld..", diff);
71 return -1;
72 }
73
74 return 0;
75 }
76
check_itimer(int which)77 static int check_itimer(int which)
78 {
79 int err;
80 struct timeval start, end;
81 struct itimerval val = {
82 .it_value.tv_sec = DELAY,
83 };
84
85 printf("Check itimer ");
86
87 if (which == ITIMER_VIRTUAL)
88 printf("virtual... ");
89 else if (which == ITIMER_PROF)
90 printf("prof... ");
91 else if (which == ITIMER_REAL)
92 printf("real... ");
93
94 fflush(stdout);
95
96 done = 0;
97
98 if (which == ITIMER_VIRTUAL)
99 signal(SIGVTALRM, sig_handler);
100 else if (which == ITIMER_PROF)
101 signal(SIGPROF, sig_handler);
102 else if (which == ITIMER_REAL)
103 signal(SIGALRM, sig_handler);
104
105 err = gettimeofday(&start, NULL);
106 if (err < 0) {
107 perror("Can't call gettimeofday()\n");
108 return -1;
109 }
110
111 err = setitimer(which, &val, NULL);
112 if (err < 0) {
113 perror("Can't set timer\n");
114 return -1;
115 }
116
117 if (which == ITIMER_VIRTUAL)
118 user_loop();
119 else if (which == ITIMER_PROF)
120 kernel_loop();
121 else if (which == ITIMER_REAL)
122 idle_loop();
123
124 err = gettimeofday(&end, NULL);
125 if (err < 0) {
126 perror("Can't call gettimeofday()\n");
127 return -1;
128 }
129
130 if (!check_diff(start, end))
131 printf("[OK]\n");
132 else
133 printf("[FAIL]\n");
134
135 return 0;
136 }
137
check_timer_create(int which)138 static int check_timer_create(int which)
139 {
140 int err;
141 timer_t id;
142 struct timeval start, end;
143 struct itimerspec val = {
144 .it_value.tv_sec = DELAY,
145 };
146
147 printf("Check timer_create() ");
148 if (which == CLOCK_THREAD_CPUTIME_ID) {
149 printf("per thread... ");
150 } else if (which == CLOCK_PROCESS_CPUTIME_ID) {
151 printf("per process... ");
152 }
153 fflush(stdout);
154
155 done = 0;
156 err = timer_create(which, NULL, &id);
157 if (err < 0) {
158 perror("Can't create timer\n");
159 return -1;
160 }
161 signal(SIGALRM, sig_handler);
162
163 err = gettimeofday(&start, NULL);
164 if (err < 0) {
165 perror("Can't call gettimeofday()\n");
166 return -1;
167 }
168
169 err = timer_settime(id, 0, &val, NULL);
170 if (err < 0) {
171 perror("Can't set timer\n");
172 return -1;
173 }
174
175 user_loop();
176
177 err = gettimeofday(&end, NULL);
178 if (err < 0) {
179 perror("Can't call gettimeofday()\n");
180 return -1;
181 }
182
183 if (!check_diff(start, end))
184 printf("[OK]\n");
185 else
186 printf("[FAIL]\n");
187
188 return 0;
189 }
190
main(int argc,char ** argv)191 int main(int argc, char **argv)
192 {
193 printf("Testing posix timers. False negative may happen on CPU execution \n");
194 printf("based timers if other threads run on the CPU...\n");
195
196 if (check_itimer(ITIMER_VIRTUAL) < 0)
197 return ksft_exit_fail();
198
199 if (check_itimer(ITIMER_PROF) < 0)
200 return ksft_exit_fail();
201
202 if (check_itimer(ITIMER_REAL) < 0)
203 return ksft_exit_fail();
204
205 if (check_timer_create(CLOCK_THREAD_CPUTIME_ID) < 0)
206 return ksft_exit_fail();
207
208 /*
209 * It's unfortunately hard to reliably test a timer expiration
210 * on parallel multithread cputime. We could arm it to expire
211 * on DELAY * nr_threads, with nr_threads busy looping, then wait
212 * the normal DELAY since the time is elapsing nr_threads faster.
213 * But for that we need to ensure we have real physical free CPUs
214 * to ensure true parallelism. So test only one thread until we
215 * find a better solution.
216 */
217 if (check_timer_create(CLOCK_PROCESS_CPUTIME_ID) < 0)
218 return ksft_exit_fail();
219
220 return ksft_exit_pass();
221 }
222