1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * ldt_gdt.c - Test cases for LDT and GDT access
4 * Copyright (c) 2011-2015 Andrew Lutomirski
5 */
6
7 #define _GNU_SOURCE
8
9 #include <stdio.h>
10 #include <sys/time.h>
11 #include <time.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14 #include <sys/syscall.h>
15 #include <dlfcn.h>
16 #include <string.h>
17 #include <errno.h>
18 #include <sched.h>
19 #include <stdbool.h>
20 #include <limits.h>
21
22 #include "vdso_config.h"
23 #include "vdso_call.h"
24 #include "../kselftest.h"
25
26 static const char **name;
27
28 #ifndef SYS_getcpu
29 # ifdef __x86_64__
30 # define SYS_getcpu 309
31 # else
32 # define SYS_getcpu 318
33 # endif
34 #endif
35
36 #ifndef __NR_clock_gettime64
37 #define __NR_clock_gettime64 403
38 #endif
39
40 #ifndef __kernel_timespec
41 struct __kernel_timespec {
42 long long tv_sec;
43 long long tv_nsec;
44 };
45 #endif
46
47 /* max length of lines in /proc/self/maps - anything longer is skipped here */
48 #define MAPS_LINE_LEN 128
49
50 int nerrs = 0;
51
52 typedef int (*vgettime_t)(clockid_t, struct timespec *);
53
54 vgettime_t vdso_clock_gettime;
55
56 typedef int (*vgettime64_t)(clockid_t, struct __kernel_timespec *);
57
58 vgettime64_t vdso_clock_gettime64;
59
60 typedef long (*vgtod_t)(struct timeval *tv, struct timezone *tz);
61
62 vgtod_t vdso_gettimeofday;
63
64 typedef long (*getcpu_t)(unsigned *, unsigned *, void *);
65
66 getcpu_t vgetcpu;
67 getcpu_t vdso_getcpu;
68
vsyscall_getcpu(void)69 static void *vsyscall_getcpu(void)
70 {
71 #ifdef __x86_64__
72 FILE *maps;
73 char line[MAPS_LINE_LEN];
74 bool found = false;
75
76 maps = fopen("/proc/self/maps", "r");
77 if (!maps) /* might still be present, but ignore it here, as we test vDSO not vsyscall */
78 return NULL;
79
80 while (fgets(line, MAPS_LINE_LEN, maps)) {
81 char r, x;
82 void *start, *end;
83 char name[MAPS_LINE_LEN];
84
85 /* sscanf() is safe here as strlen(name) >= strlen(line) */
86 if (sscanf(line, "%p-%p %c-%cp %*x %*x:%*x %*u %s",
87 &start, &end, &r, &x, name) != 5)
88 continue;
89
90 if (strcmp(name, "[vsyscall]"))
91 continue;
92
93 /* assume entries are OK, as we test vDSO here not vsyscall */
94 found = true;
95 break;
96 }
97
98 fclose(maps);
99
100 if (!found) {
101 printf("Warning: failed to find vsyscall getcpu\n");
102 return NULL;
103 }
104 return (void *) (0xffffffffff600800);
105 #else
106 return NULL;
107 #endif
108 }
109
110
fill_function_pointers()111 static void fill_function_pointers()
112 {
113 void *vdso = dlopen("linux-vdso.so.1",
114 RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
115 if (!vdso)
116 vdso = dlopen("linux-gate.so.1",
117 RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
118 if (!vdso)
119 vdso = dlopen("linux-vdso32.so.1",
120 RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
121 if (!vdso)
122 vdso = dlopen("linux-vdso64.so.1",
123 RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
124 if (!vdso) {
125 printf("[WARN]\tfailed to find vDSO\n");
126 return;
127 }
128
129 vdso_getcpu = (getcpu_t)dlsym(vdso, name[4]);
130 if (!vdso_getcpu)
131 printf("Warning: failed to find getcpu in vDSO\n");
132
133 vgetcpu = (getcpu_t) vsyscall_getcpu();
134
135 vdso_clock_gettime = (vgettime_t)dlsym(vdso, name[1]);
136 if (!vdso_clock_gettime)
137 printf("Warning: failed to find clock_gettime in vDSO\n");
138
139 #if defined(VDSO_32BIT)
140 vdso_clock_gettime64 = (vgettime64_t)dlsym(vdso, name[5]);
141 if (!vdso_clock_gettime64)
142 printf("Warning: failed to find clock_gettime64 in vDSO\n");
143 #endif
144
145 vdso_gettimeofday = (vgtod_t)dlsym(vdso, name[0]);
146 if (!vdso_gettimeofday)
147 printf("Warning: failed to find gettimeofday in vDSO\n");
148
149 }
150
sys_getcpu(unsigned * cpu,unsigned * node,void * cache)151 static long sys_getcpu(unsigned * cpu, unsigned * node,
152 void* cache)
153 {
154 return syscall(__NR_getcpu, cpu, node, cache);
155 }
156
sys_clock_gettime(clockid_t id,struct timespec * ts)157 static inline int sys_clock_gettime(clockid_t id, struct timespec *ts)
158 {
159 return syscall(__NR_clock_gettime, id, ts);
160 }
161
sys_clock_gettime64(clockid_t id,struct __kernel_timespec * ts)162 static inline int sys_clock_gettime64(clockid_t id, struct __kernel_timespec *ts)
163 {
164 return syscall(__NR_clock_gettime64, id, ts);
165 }
166
sys_gettimeofday(struct timeval * tv,struct timezone * tz)167 static inline int sys_gettimeofday(struct timeval *tv, struct timezone *tz)
168 {
169 return syscall(__NR_gettimeofday, tv, tz);
170 }
171
test_getcpu(void)172 static void test_getcpu(void)
173 {
174 printf("[RUN]\tTesting getcpu...\n");
175
176 for (int cpu = 0; ; cpu++) {
177 cpu_set_t cpuset;
178 CPU_ZERO(&cpuset);
179 CPU_SET(cpu, &cpuset);
180 if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0)
181 return;
182
183 unsigned cpu_sys, cpu_vdso, cpu_vsys,
184 node_sys, node_vdso, node_vsys;
185 long ret_sys, ret_vdso = 1, ret_vsys = 1;
186 unsigned node;
187
188 ret_sys = sys_getcpu(&cpu_sys, &node_sys, 0);
189 if (vdso_getcpu)
190 ret_vdso = VDSO_CALL(vdso_getcpu, 3, &cpu_vdso, &node_vdso, 0);
191 if (vgetcpu)
192 ret_vsys = vgetcpu(&cpu_vsys, &node_vsys, 0);
193
194 if (!ret_sys)
195 node = node_sys;
196 else if (!ret_vdso)
197 node = node_vdso;
198 else if (!ret_vsys)
199 node = node_vsys;
200
201 bool ok = true;
202 if (!ret_sys && (cpu_sys != cpu || node_sys != node))
203 ok = false;
204 if (!ret_vdso && (cpu_vdso != cpu || node_vdso != node))
205 ok = false;
206 if (!ret_vsys && (cpu_vsys != cpu || node_vsys != node))
207 ok = false;
208
209 printf("[%s]\tCPU %u:", ok ? "OK" : "FAIL", cpu);
210 if (!ret_sys)
211 printf(" syscall: cpu %u, node %u", cpu_sys, node_sys);
212 if (!ret_vdso)
213 printf(" vdso: cpu %u, node %u", cpu_vdso, node_vdso);
214 if (!ret_vsys)
215 printf(" vsyscall: cpu %u, node %u", cpu_vsys,
216 node_vsys);
217 printf("\n");
218
219 if (!ok)
220 nerrs++;
221 }
222 }
223
ts_leq(const struct timespec * a,const struct timespec * b)224 static bool ts_leq(const struct timespec *a, const struct timespec *b)
225 {
226 if (a->tv_sec != b->tv_sec)
227 return a->tv_sec < b->tv_sec;
228 else
229 return a->tv_nsec <= b->tv_nsec;
230 }
231
ts64_leq(const struct __kernel_timespec * a,const struct __kernel_timespec * b)232 static bool ts64_leq(const struct __kernel_timespec *a,
233 const struct __kernel_timespec *b)
234 {
235 if (a->tv_sec != b->tv_sec)
236 return a->tv_sec < b->tv_sec;
237 else
238 return a->tv_nsec <= b->tv_nsec;
239 }
240
tv_leq(const struct timeval * a,const struct timeval * b)241 static bool tv_leq(const struct timeval *a, const struct timeval *b)
242 {
243 if (a->tv_sec != b->tv_sec)
244 return a->tv_sec < b->tv_sec;
245 else
246 return a->tv_usec <= b->tv_usec;
247 }
248
249 static char const * const clocknames[] = {
250 [0] = "CLOCK_REALTIME",
251 [1] = "CLOCK_MONOTONIC",
252 [2] = "CLOCK_PROCESS_CPUTIME_ID",
253 [3] = "CLOCK_THREAD_CPUTIME_ID",
254 [4] = "CLOCK_MONOTONIC_RAW",
255 [5] = "CLOCK_REALTIME_COARSE",
256 [6] = "CLOCK_MONOTONIC_COARSE",
257 [7] = "CLOCK_BOOTTIME",
258 [8] = "CLOCK_REALTIME_ALARM",
259 [9] = "CLOCK_BOOTTIME_ALARM",
260 [10] = "CLOCK_SGI_CYCLE",
261 [11] = "CLOCK_TAI",
262 };
263
test_one_clock_gettime(int clock,const char * name)264 static void test_one_clock_gettime(int clock, const char *name)
265 {
266 struct timespec start, vdso, end;
267 int vdso_ret, end_ret;
268
269 printf("[RUN]\tTesting clock_gettime for clock %s (%d)...\n", name, clock);
270
271 if (sys_clock_gettime(clock, &start) < 0) {
272 if (errno == EINVAL) {
273 vdso_ret = VDSO_CALL(vdso_clock_gettime, 2, clock, &vdso);
274 if (vdso_ret == -EINVAL) {
275 printf("[OK]\tNo such clock.\n");
276 } else {
277 printf("[FAIL]\tNo such clock, but __vdso_clock_gettime returned %d\n", vdso_ret);
278 nerrs++;
279 }
280 } else {
281 printf("[WARN]\t clock_gettime(%d) syscall returned error %d\n", clock, errno);
282 }
283 return;
284 }
285
286 vdso_ret = VDSO_CALL(vdso_clock_gettime, 2, clock, &vdso);
287 end_ret = sys_clock_gettime(clock, &end);
288
289 if (vdso_ret != 0 || end_ret != 0) {
290 printf("[FAIL]\tvDSO returned %d, syscall errno=%d\n",
291 vdso_ret, errno);
292 nerrs++;
293 return;
294 }
295
296 printf("\t%llu.%09ld %llu.%09ld %llu.%09ld\n",
297 (unsigned long long)start.tv_sec, start.tv_nsec,
298 (unsigned long long)vdso.tv_sec, vdso.tv_nsec,
299 (unsigned long long)end.tv_sec, end.tv_nsec);
300
301 if (!ts_leq(&start, &vdso) || !ts_leq(&vdso, &end)) {
302 printf("[FAIL]\tTimes are out of sequence\n");
303 nerrs++;
304 return;
305 }
306
307 printf("[OK]\tTest Passed.\n");
308 }
309
test_clock_gettime(void)310 static void test_clock_gettime(void)
311 {
312 if (!vdso_clock_gettime) {
313 printf("[SKIP]\tNo vDSO, so skipping clock_gettime() tests\n");
314 return;
315 }
316
317 for (int clock = 0; clock < ARRAY_SIZE(clocknames); clock++)
318 test_one_clock_gettime(clock, clocknames[clock]);
319
320 /* Also test some invalid clock ids */
321 test_one_clock_gettime(-1, "invalid");
322 test_one_clock_gettime(INT_MIN, "invalid");
323 test_one_clock_gettime(INT_MAX, "invalid");
324 }
325
test_one_clock_gettime64(int clock,const char * name)326 static void test_one_clock_gettime64(int clock, const char *name)
327 {
328 struct __kernel_timespec start, vdso, end;
329 int vdso_ret, end_ret;
330
331 printf("[RUN]\tTesting clock_gettime64 for clock %s (%d)...\n", name, clock);
332
333 if (sys_clock_gettime64(clock, &start) < 0) {
334 if (errno == EINVAL) {
335 vdso_ret = VDSO_CALL(vdso_clock_gettime64, 2, clock, &vdso);
336 if (vdso_ret == -EINVAL) {
337 printf("[OK]\tNo such clock.\n");
338 } else {
339 printf("[FAIL]\tNo such clock, but __vdso_clock_gettime64 returned %d\n", vdso_ret);
340 nerrs++;
341 }
342 } else {
343 printf("[WARN]\t clock_gettime64(%d) syscall returned error %d\n", clock, errno);
344 }
345 return;
346 }
347
348 vdso_ret = VDSO_CALL(vdso_clock_gettime64, 2, clock, &vdso);
349 end_ret = sys_clock_gettime64(clock, &end);
350
351 if (vdso_ret != 0 || end_ret != 0) {
352 printf("[FAIL]\tvDSO returned %d, syscall errno=%d\n",
353 vdso_ret, errno);
354 nerrs++;
355 return;
356 }
357
358 printf("\t%llu.%09lld %llu.%09lld %llu.%09lld\n",
359 (unsigned long long)start.tv_sec, start.tv_nsec,
360 (unsigned long long)vdso.tv_sec, vdso.tv_nsec,
361 (unsigned long long)end.tv_sec, end.tv_nsec);
362
363 if (!ts64_leq(&start, &vdso) || !ts64_leq(&vdso, &end)) {
364 printf("[FAIL]\tTimes are out of sequence\n");
365 nerrs++;
366 return;
367 }
368
369 printf("[OK]\tTest Passed.\n");
370 }
371
test_clock_gettime64(void)372 static void test_clock_gettime64(void)
373 {
374 if (!vdso_clock_gettime64) {
375 printf("[SKIP]\tNo vDSO, so skipping clock_gettime64() tests\n");
376 return;
377 }
378
379 for (int clock = 0; clock < ARRAY_SIZE(clocknames); clock++)
380 test_one_clock_gettime64(clock, clocknames[clock]);
381
382 /* Also test some invalid clock ids */
383 test_one_clock_gettime64(-1, "invalid");
384 test_one_clock_gettime64(INT_MIN, "invalid");
385 test_one_clock_gettime64(INT_MAX, "invalid");
386 }
387
test_gettimeofday(void)388 static void test_gettimeofday(void)
389 {
390 struct timeval start, vdso, end;
391 struct timezone sys_tz, vdso_tz;
392 int vdso_ret, end_ret;
393
394 if (!vdso_gettimeofday)
395 return;
396
397 printf("[RUN]\tTesting gettimeofday...\n");
398
399 if (sys_gettimeofday(&start, &sys_tz) < 0) {
400 printf("[FAIL]\tsys_gettimeofday failed (%d)\n", errno);
401 nerrs++;
402 return;
403 }
404
405 vdso_ret = VDSO_CALL(vdso_gettimeofday, 2, &vdso, &vdso_tz);
406 end_ret = sys_gettimeofday(&end, NULL);
407
408 if (vdso_ret != 0 || end_ret != 0) {
409 printf("[FAIL]\tvDSO returned %d, syscall errno=%d\n",
410 vdso_ret, errno);
411 nerrs++;
412 return;
413 }
414
415 printf("\t%llu.%06ld %llu.%06ld %llu.%06ld\n",
416 (unsigned long long)start.tv_sec, start.tv_usec,
417 (unsigned long long)vdso.tv_sec, vdso.tv_usec,
418 (unsigned long long)end.tv_sec, end.tv_usec);
419
420 if (!tv_leq(&start, &vdso) || !tv_leq(&vdso, &end)) {
421 printf("[FAIL]\tTimes are out of sequence\n");
422 nerrs++;
423 }
424
425 if (sys_tz.tz_minuteswest == vdso_tz.tz_minuteswest &&
426 sys_tz.tz_dsttime == vdso_tz.tz_dsttime) {
427 printf("[OK]\ttimezones match: minuteswest=%d, dsttime=%d\n",
428 sys_tz.tz_minuteswest, sys_tz.tz_dsttime);
429 } else {
430 printf("[FAIL]\ttimezones do not match\n");
431 nerrs++;
432 }
433
434 /* And make sure that passing NULL for tz doesn't crash. */
435 VDSO_CALL(vdso_gettimeofday, 2, &vdso, NULL);
436 }
437
main(int argc,char ** argv)438 int main(int argc, char **argv)
439 {
440 name = (const char **)&names[VDSO_NAMES];
441
442 fill_function_pointers();
443
444 test_clock_gettime();
445 test_clock_gettime64();
446 test_gettimeofday();
447
448 /*
449 * Test getcpu() last so that, if something goes wrong setting affinity,
450 * we still run the other tests.
451 */
452 test_getcpu();
453
454 return nerrs ? 1 : 0;
455 }
456