1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * User Events FTrace Test Program
4 *
5 * Copyright (c) 2021 Beau Belgrave <beaub@linux.microsoft.com>
6 */
7
8 #include <errno.h>
9 #include <linux/user_events.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <fcntl.h>
13 #include <sys/ioctl.h>
14 #include <sys/stat.h>
15 #include <sys/uio.h>
16 #include <unistd.h>
17
18 #include "../kselftest_harness.h"
19 #include "user_events_selftests.h"
20
21 const char *data_file = "/sys/kernel/tracing/user_events_data";
22 const char *status_file = "/sys/kernel/tracing/user_events_status";
23 const char *enable_file = "/sys/kernel/tracing/events/user_events/__test_event/enable";
24 const char *trace_file = "/sys/kernel/tracing/trace";
25 const char *fmt_file = "/sys/kernel/tracing/events/user_events/__test_event/format";
26
trace_bytes(void)27 static int trace_bytes(void)
28 {
29 int fd = open(trace_file, O_RDONLY);
30 char buf[256];
31 int bytes = 0, got;
32
33 if (fd == -1)
34 return -1;
35
36 while (true) {
37 got = read(fd, buf, sizeof(buf));
38
39 if (got == -1)
40 return -1;
41
42 if (got == 0)
43 break;
44
45 bytes += got;
46 }
47
48 close(fd);
49
50 return bytes;
51 }
52
skip_until_empty_line(FILE * fp)53 static int skip_until_empty_line(FILE *fp)
54 {
55 int c, last = 0;
56
57 while (true) {
58 c = getc(fp);
59
60 if (c == EOF)
61 break;
62
63 if (last == '\n' && c == '\n')
64 return 0;
65
66 last = c;
67 }
68
69 return -1;
70 }
71
get_print_fmt(char * buffer,int len)72 static int get_print_fmt(char *buffer, int len)
73 {
74 FILE *fp = fopen(fmt_file, "r");
75 char *newline;
76
77 if (!fp)
78 return -1;
79
80 /* Read until empty line (Skip Common) */
81 if (skip_until_empty_line(fp) < 0)
82 goto err;
83
84 /* Read until empty line (Skip Properties) */
85 if (skip_until_empty_line(fp) < 0)
86 goto err;
87
88 /* Read in print_fmt: */
89 if (fgets(buffer, len, fp) == NULL)
90 goto err;
91
92 newline = strchr(buffer, '\n');
93
94 if (newline)
95 *newline = '\0';
96
97 fclose(fp);
98
99 return 0;
100 err:
101 fclose(fp);
102
103 return -1;
104 }
105
wait_for_delete(void)106 static bool wait_for_delete(void)
107 {
108 int i;
109
110 for (i = 0; i < 1000; ++i) {
111 int fd = open(enable_file, O_RDONLY);
112
113 if (fd == -1)
114 return true;
115
116 close(fd);
117 usleep(1000);
118 }
119
120 return false;
121 }
122
clear(int * check)123 static int clear(int *check)
124 {
125 struct user_unreg unreg = {0};
126 int fd;
127
128 unreg.size = sizeof(unreg);
129 unreg.disable_bit = 31;
130 unreg.disable_addr = (__u64)check;
131
132 fd = open(data_file, O_RDWR);
133
134 if (fd == -1)
135 return -1;
136
137 if (ioctl(fd, DIAG_IOCSUNREG, &unreg) == -1)
138 if (errno != ENOENT)
139 goto fail;
140
141 if (ioctl(fd, DIAG_IOCSDEL, "__test_event") == -1) {
142 if (errno == EBUSY) {
143 if (!wait_for_delete())
144 goto fail;
145 } else if (errno != ENOENT)
146 goto fail;
147 }
148
149 close(fd);
150
151 return 0;
152 fail:
153 close(fd);
154
155 return -1;
156 }
157
check_print_fmt(const char * event,const char * expected,int * check)158 static int check_print_fmt(const char *event, const char *expected, int *check)
159 {
160 struct user_reg reg = {0};
161 char print_fmt[256];
162 int ret;
163 int fd;
164
165 /* Ensure cleared */
166 ret = clear(check);
167
168 if (ret != 0)
169 return ret;
170
171 fd = open(data_file, O_RDWR);
172
173 if (fd == -1)
174 return fd;
175
176 reg.size = sizeof(reg);
177 reg.name_args = (__u64)event;
178 reg.enable_bit = 31;
179 reg.enable_addr = (__u64)check;
180 reg.enable_size = sizeof(*check);
181
182 /* Register should work */
183 ret = ioctl(fd, DIAG_IOCSREG, ®);
184
185 if (ret != 0) {
186 close(fd);
187 printf("Reg failed in fmt\n");
188 return ret;
189 }
190
191 /* Ensure correct print_fmt */
192 ret = get_print_fmt(print_fmt, sizeof(print_fmt));
193
194 close(fd);
195
196 if (ret != 0)
197 return ret;
198
199 return strcmp(print_fmt, expected);
200 }
201
FIXTURE(user)202 FIXTURE(user) {
203 int status_fd;
204 int data_fd;
205 int enable_fd;
206 int check;
207 bool umount;
208 };
209
FIXTURE_SETUP(user)210 FIXTURE_SETUP(user) {
211 USER_EVENT_FIXTURE_SETUP(return, self->umount);
212
213 self->status_fd = open(status_file, O_RDONLY);
214 ASSERT_NE(-1, self->status_fd);
215
216 self->data_fd = open(data_file, O_RDWR);
217 ASSERT_NE(-1, self->data_fd);
218
219 self->enable_fd = -1;
220 }
221
FIXTURE_TEARDOWN(user)222 FIXTURE_TEARDOWN(user) {
223 USER_EVENT_FIXTURE_TEARDOWN(self->umount);
224
225 close(self->status_fd);
226 close(self->data_fd);
227
228 if (self->enable_fd != -1) {
229 write(self->enable_fd, "0", sizeof("0"));
230 close(self->enable_fd);
231 }
232
233 if (clear(&self->check) != 0)
234 printf("WARNING: Clear didn't work!\n");
235 }
236
TEST_F(user,register_events)237 TEST_F(user, register_events) {
238 struct user_reg reg = {0};
239 struct user_unreg unreg = {0};
240
241 reg.size = sizeof(reg);
242 reg.name_args = (__u64)"__test_event u32 field1; u32 field2";
243 reg.enable_bit = 31;
244 reg.enable_addr = (__u64)&self->check;
245 reg.enable_size = sizeof(self->check);
246
247 unreg.size = sizeof(unreg);
248 unreg.disable_bit = 31;
249 unreg.disable_addr = (__u64)&self->check;
250
251 /* Register should work */
252 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
253 ASSERT_EQ(0, reg.write_index);
254
255 /* Multiple registers to the same addr + bit should fail */
256 ASSERT_EQ(-1, ioctl(self->data_fd, DIAG_IOCSREG, ®));
257 ASSERT_EQ(EADDRINUSE, errno);
258
259 /* Multiple registers to same name should result in same index */
260 reg.enable_bit = 30;
261 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
262 ASSERT_EQ(0, reg.write_index);
263
264 /* Register without separator spacing should still match */
265 reg.enable_bit = 29;
266 reg.name_args = (__u64)"__test_event u32 field1;u32 field2";
267 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
268 ASSERT_EQ(0, reg.write_index);
269
270 /* Multiple registers to same name but different args should fail */
271 reg.enable_bit = 29;
272 reg.name_args = (__u64)"__test_event u32 field1;";
273 ASSERT_EQ(-1, ioctl(self->data_fd, DIAG_IOCSREG, ®));
274 ASSERT_EQ(EADDRINUSE, errno);
275
276 /* Ensure disabled */
277 self->enable_fd = open(enable_file, O_RDWR);
278 ASSERT_NE(-1, self->enable_fd);
279 ASSERT_NE(-1, write(self->enable_fd, "0", sizeof("0")))
280
281 /* Enable event and ensure bits updated in status */
282 ASSERT_NE(-1, write(self->enable_fd, "1", sizeof("1")))
283 ASSERT_EQ(1 << reg.enable_bit, self->check);
284
285 /* Disable event and ensure bits updated in status */
286 ASSERT_NE(-1, write(self->enable_fd, "0", sizeof("0")))
287 ASSERT_EQ(0, self->check);
288
289 /* File still open should return -EBUSY for delete */
290 ASSERT_EQ(-1, ioctl(self->data_fd, DIAG_IOCSDEL, "__test_event"));
291 ASSERT_EQ(EBUSY, errno);
292
293 /* Unregister */
294 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSUNREG, &unreg));
295 unreg.disable_bit = 30;
296 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSUNREG, &unreg));
297 unreg.disable_bit = 29;
298 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSUNREG, &unreg));
299
300 /* Delete should have been auto-done after close and unregister */
301 close(self->data_fd);
302
303 ASSERT_EQ(true, wait_for_delete());
304 }
305
TEST_F(user,write_events)306 TEST_F(user, write_events) {
307 struct user_reg reg = {0};
308 struct iovec io[3];
309 __u32 field1, field2;
310 int before = 0, after = 0;
311
312 reg.size = sizeof(reg);
313 reg.name_args = (__u64)"__test_event u32 field1; u32 field2";
314 reg.enable_bit = 31;
315 reg.enable_addr = (__u64)&self->check;
316 reg.enable_size = sizeof(self->check);
317
318 field1 = 1;
319 field2 = 2;
320
321 io[0].iov_base = ®.write_index;
322 io[0].iov_len = sizeof(reg.write_index);
323 io[1].iov_base = &field1;
324 io[1].iov_len = sizeof(field1);
325 io[2].iov_base = &field2;
326 io[2].iov_len = sizeof(field2);
327
328 /* Register should work */
329 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
330 ASSERT_EQ(0, reg.write_index);
331 ASSERT_EQ(0, self->check);
332
333 /* Write should fail on invalid slot with ENOENT */
334 io[0].iov_base = &field2;
335 io[0].iov_len = sizeof(field2);
336 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
337 ASSERT_EQ(ENOENT, errno);
338 io[0].iov_base = ®.write_index;
339 io[0].iov_len = sizeof(reg.write_index);
340
341 /* Write should return -EBADF when event is not enabled */
342 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
343 ASSERT_EQ(EBADF, errno);
344
345 /* Enable event */
346 self->enable_fd = open(enable_file, O_RDWR);
347 ASSERT_NE(-1, write(self->enable_fd, "1", sizeof("1")))
348
349 /* Event should now be enabled */
350 ASSERT_NE(1 << reg.enable_bit, self->check);
351
352 /* Write should make it out to ftrace buffers */
353 before = trace_bytes();
354 ASSERT_NE(-1, writev(self->data_fd, (const struct iovec *)io, 3));
355 after = trace_bytes();
356 ASSERT_GT(after, before);
357
358 /* Negative index should fail with EINVAL */
359 reg.write_index = -1;
360 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
361 ASSERT_EQ(EINVAL, errno);
362 }
363
TEST_F(user,write_empty_events)364 TEST_F(user, write_empty_events) {
365 struct user_reg reg = {0};
366 struct iovec io[1];
367 int before = 0, after = 0;
368
369 reg.size = sizeof(reg);
370 reg.name_args = (__u64)"__test_event";
371 reg.enable_bit = 31;
372 reg.enable_addr = (__u64)&self->check;
373 reg.enable_size = sizeof(self->check);
374
375 io[0].iov_base = ®.write_index;
376 io[0].iov_len = sizeof(reg.write_index);
377
378 /* Register should work */
379 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
380 ASSERT_EQ(0, reg.write_index);
381 ASSERT_EQ(0, self->check);
382
383 /* Enable event */
384 self->enable_fd = open(enable_file, O_RDWR);
385 ASSERT_NE(-1, write(self->enable_fd, "1", sizeof("1")))
386
387 /* Event should now be enabled */
388 ASSERT_EQ(1 << reg.enable_bit, self->check);
389
390 /* Write should make it out to ftrace buffers */
391 before = trace_bytes();
392 ASSERT_NE(-1, writev(self->data_fd, (const struct iovec *)io, 1));
393 after = trace_bytes();
394 ASSERT_GT(after, before);
395 }
396
TEST_F(user,write_fault)397 TEST_F(user, write_fault) {
398 struct user_reg reg = {0};
399 struct iovec io[2];
400 int l = sizeof(__u64);
401 void *anon;
402
403 reg.size = sizeof(reg);
404 reg.name_args = (__u64)"__test_event u64 anon";
405 reg.enable_bit = 31;
406 reg.enable_addr = (__u64)&self->check;
407 reg.enable_size = sizeof(self->check);
408
409 anon = mmap(NULL, l, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
410 ASSERT_NE(MAP_FAILED, anon);
411
412 io[0].iov_base = ®.write_index;
413 io[0].iov_len = sizeof(reg.write_index);
414 io[1].iov_base = anon;
415 io[1].iov_len = l;
416
417 /* Register should work */
418 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
419 ASSERT_EQ(0, reg.write_index);
420
421 /* Enable event */
422 self->enable_fd = open(enable_file, O_RDWR);
423 ASSERT_NE(-1, write(self->enable_fd, "1", sizeof("1")))
424
425 /* Write should work normally */
426 ASSERT_NE(-1, writev(self->data_fd, (const struct iovec *)io, 2));
427
428 /* Faulted data should zero fill and work */
429 ASSERT_EQ(0, madvise(anon, l, MADV_DONTNEED));
430 ASSERT_NE(-1, writev(self->data_fd, (const struct iovec *)io, 2));
431 ASSERT_EQ(0, munmap(anon, l));
432 }
433
TEST_F(user,write_validator)434 TEST_F(user, write_validator) {
435 struct user_reg reg = {0};
436 struct iovec io[3];
437 int loc, bytes;
438 char data[8];
439 int before = 0, after = 0;
440
441 reg.size = sizeof(reg);
442 reg.name_args = (__u64)"__test_event __rel_loc char[] data";
443 reg.enable_bit = 31;
444 reg.enable_addr = (__u64)&self->check;
445 reg.enable_size = sizeof(self->check);
446
447 /* Register should work */
448 ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, ®));
449 ASSERT_EQ(0, reg.write_index);
450 ASSERT_EQ(0, self->check);
451
452 io[0].iov_base = ®.write_index;
453 io[0].iov_len = sizeof(reg.write_index);
454 io[1].iov_base = &loc;
455 io[1].iov_len = sizeof(loc);
456 io[2].iov_base = data;
457 bytes = snprintf(data, sizeof(data), "Test") + 1;
458 io[2].iov_len = bytes;
459
460 /* Undersized write should fail */
461 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 1));
462 ASSERT_EQ(EINVAL, errno);
463
464 /* Enable event */
465 self->enable_fd = open(enable_file, O_RDWR);
466 ASSERT_NE(-1, write(self->enable_fd, "1", sizeof("1")))
467
468 /* Event should now be enabled */
469 ASSERT_EQ(1 << reg.enable_bit, self->check);
470
471 /* Full in-bounds write should work */
472 before = trace_bytes();
473 loc = DYN_LOC(0, bytes);
474 ASSERT_NE(-1, writev(self->data_fd, (const struct iovec *)io, 3));
475 after = trace_bytes();
476 ASSERT_GT(after, before);
477
478 /* Out of bounds write should fault (offset way out) */
479 loc = DYN_LOC(1024, bytes);
480 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
481 ASSERT_EQ(EFAULT, errno);
482
483 /* Out of bounds write should fault (offset 1 byte out) */
484 loc = DYN_LOC(1, bytes);
485 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
486 ASSERT_EQ(EFAULT, errno);
487
488 /* Out of bounds write should fault (size way out) */
489 loc = DYN_LOC(0, bytes + 1024);
490 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
491 ASSERT_EQ(EFAULT, errno);
492
493 /* Out of bounds write should fault (size 1 byte out) */
494 loc = DYN_LOC(0, bytes + 1);
495 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
496 ASSERT_EQ(EFAULT, errno);
497
498 /* Non-Null should fault */
499 memset(data, 'A', sizeof(data));
500 loc = DYN_LOC(0, bytes);
501 ASSERT_EQ(-1, writev(self->data_fd, (const struct iovec *)io, 3));
502 ASSERT_EQ(EFAULT, errno);
503 }
504
TEST_F(user,print_fmt)505 TEST_F(user, print_fmt) {
506 int ret;
507
508 ret = check_print_fmt("__test_event __rel_loc char[] data",
509 "print fmt: \"data=%s\", __get_rel_str(data)",
510 &self->check);
511 ASSERT_EQ(0, ret);
512
513 ret = check_print_fmt("__test_event __data_loc char[] data",
514 "print fmt: \"data=%s\", __get_str(data)",
515 &self->check);
516 ASSERT_EQ(0, ret);
517
518 ret = check_print_fmt("__test_event s64 data",
519 "print fmt: \"data=%lld\", REC->data",
520 &self->check);
521 ASSERT_EQ(0, ret);
522
523 ret = check_print_fmt("__test_event u64 data",
524 "print fmt: \"data=%llu\", REC->data",
525 &self->check);
526 ASSERT_EQ(0, ret);
527
528 ret = check_print_fmt("__test_event s32 data",
529 "print fmt: \"data=%d\", REC->data",
530 &self->check);
531 ASSERT_EQ(0, ret);
532
533 ret = check_print_fmt("__test_event u32 data",
534 "print fmt: \"data=%u\", REC->data",
535 &self->check);
536 ASSERT_EQ(0, ret);
537
538 ret = check_print_fmt("__test_event int data",
539 "print fmt: \"data=%d\", REC->data",
540 &self->check);
541 ASSERT_EQ(0, ret);
542
543 ret = check_print_fmt("__test_event unsigned int data",
544 "print fmt: \"data=%u\", REC->data",
545 &self->check);
546 ASSERT_EQ(0, ret);
547
548 ret = check_print_fmt("__test_event s16 data",
549 "print fmt: \"data=%d\", REC->data",
550 &self->check);
551 ASSERT_EQ(0, ret);
552
553 ret = check_print_fmt("__test_event u16 data",
554 "print fmt: \"data=%u\", REC->data",
555 &self->check);
556 ASSERT_EQ(0, ret);
557
558 ret = check_print_fmt("__test_event short data",
559 "print fmt: \"data=%d\", REC->data",
560 &self->check);
561 ASSERT_EQ(0, ret);
562
563 ret = check_print_fmt("__test_event unsigned short data",
564 "print fmt: \"data=%u\", REC->data",
565 &self->check);
566 ASSERT_EQ(0, ret);
567
568 ret = check_print_fmt("__test_event s8 data",
569 "print fmt: \"data=%d\", REC->data",
570 &self->check);
571 ASSERT_EQ(0, ret);
572
573 ret = check_print_fmt("__test_event u8 data",
574 "print fmt: \"data=%u\", REC->data",
575 &self->check);
576 ASSERT_EQ(0, ret);
577
578 ret = check_print_fmt("__test_event char data",
579 "print fmt: \"data=%d\", REC->data",
580 &self->check);
581 ASSERT_EQ(0, ret);
582
583 ret = check_print_fmt("__test_event unsigned char data",
584 "print fmt: \"data=%u\", REC->data",
585 &self->check);
586 ASSERT_EQ(0, ret);
587
588 ret = check_print_fmt("__test_event char[4] data",
589 "print fmt: \"data=%s\", REC->data",
590 &self->check);
591 ASSERT_EQ(0, ret);
592 }
593
main(int argc,char ** argv)594 int main(int argc, char **argv)
595 {
596 return test_harness_run(argc, argv);
597 }
598