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 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 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 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 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 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 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 202 FIXTURE(user) { 203 int status_fd; 204 int data_fd; 205 int enable_fd; 206 int check; 207 bool umount; 208 }; 209 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 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 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 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 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 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 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 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 594 int main(int argc, char **argv) 595 { 596 return test_harness_run(argc, argv); 597 } 598