1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2022 Red Hat */ 3 #include "hid.skel.h" 4 5 #include "../kselftest_harness.h" 6 7 #include <bpf/bpf.h> 8 #include <fcntl.h> 9 #include <fnmatch.h> 10 #include <dirent.h> 11 #include <poll.h> 12 #include <pthread.h> 13 #include <stdbool.h> 14 #include <linux/hidraw.h> 15 #include <linux/uhid.h> 16 17 #define SHOW_UHID_DEBUG 0 18 19 #define min(a, b) \ 20 ({ __typeof__(a) _a = (a); \ 21 __typeof__(b) _b = (b); \ 22 _a < _b ? _a : _b; }) 23 24 static unsigned char rdesc[] = { 25 0x06, 0x00, 0xff, /* Usage Page (Vendor Defined Page 1) */ 26 0x09, 0x21, /* Usage (Vendor Usage 0x21) */ 27 0xa1, 0x01, /* COLLECTION (Application) */ 28 0x09, 0x01, /* Usage (Vendor Usage 0x01) */ 29 0xa1, 0x00, /* COLLECTION (Physical) */ 30 0x85, 0x02, /* REPORT_ID (2) */ 31 0x19, 0x01, /* USAGE_MINIMUM (1) */ 32 0x29, 0x08, /* USAGE_MAXIMUM (3) */ 33 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ 34 0x25, 0xff, /* LOGICAL_MAXIMUM (255) */ 35 0x95, 0x08, /* REPORT_COUNT (8) */ 36 0x75, 0x08, /* REPORT_SIZE (8) */ 37 0x81, 0x02, /* INPUT (Data,Var,Abs) */ 38 0xc0, /* END_COLLECTION */ 39 0x09, 0x01, /* Usage (Vendor Usage 0x01) */ 40 0xa1, 0x00, /* COLLECTION (Physical) */ 41 0x85, 0x01, /* REPORT_ID (1) */ 42 0x06, 0x00, 0xff, /* Usage Page (Vendor Defined Page 1) */ 43 0x19, 0x01, /* USAGE_MINIMUM (1) */ 44 0x29, 0x03, /* USAGE_MAXIMUM (3) */ 45 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ 46 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */ 47 0x95, 0x03, /* REPORT_COUNT (3) */ 48 0x75, 0x01, /* REPORT_SIZE (1) */ 49 0x81, 0x02, /* INPUT (Data,Var,Abs) */ 50 0x95, 0x01, /* REPORT_COUNT (1) */ 51 0x75, 0x05, /* REPORT_SIZE (5) */ 52 0x81, 0x01, /* INPUT (Cnst,Var,Abs) */ 53 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */ 54 0x09, 0x30, /* USAGE (X) */ 55 0x09, 0x31, /* USAGE (Y) */ 56 0x15, 0x81, /* LOGICAL_MINIMUM (-127) */ 57 0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */ 58 0x75, 0x10, /* REPORT_SIZE (16) */ 59 0x95, 0x02, /* REPORT_COUNT (2) */ 60 0x81, 0x06, /* INPUT (Data,Var,Rel) */ 61 62 0x06, 0x00, 0xff, /* Usage Page (Vendor Defined Page 1) */ 63 0x19, 0x01, /* USAGE_MINIMUM (1) */ 64 0x29, 0x03, /* USAGE_MAXIMUM (3) */ 65 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ 66 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */ 67 0x95, 0x03, /* REPORT_COUNT (3) */ 68 0x75, 0x01, /* REPORT_SIZE (1) */ 69 0x91, 0x02, /* Output (Data,Var,Abs) */ 70 0x95, 0x01, /* REPORT_COUNT (1) */ 71 0x75, 0x05, /* REPORT_SIZE (5) */ 72 0x91, 0x01, /* Output (Cnst,Var,Abs) */ 73 74 0x06, 0x00, 0xff, /* Usage Page (Vendor Defined Page 1) */ 75 0x19, 0x06, /* USAGE_MINIMUM (6) */ 76 0x29, 0x08, /* USAGE_MAXIMUM (8) */ 77 0x15, 0x00, /* LOGICAL_MINIMUM (0) */ 78 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */ 79 0x95, 0x03, /* REPORT_COUNT (3) */ 80 0x75, 0x01, /* REPORT_SIZE (1) */ 81 0xb1, 0x02, /* Feature (Data,Var,Abs) */ 82 0x95, 0x01, /* REPORT_COUNT (1) */ 83 0x75, 0x05, /* REPORT_SIZE (5) */ 84 0x91, 0x01, /* Output (Cnst,Var,Abs) */ 85 86 0xc0, /* END_COLLECTION */ 87 0xc0, /* END_COLLECTION */ 88 }; 89 90 static __u8 feature_data[] = { 1, 2 }; 91 92 struct attach_prog_args { 93 int prog_fd; 94 unsigned int hid; 95 int retval; 96 int insert_head; 97 }; 98 99 struct hid_hw_request_syscall_args { 100 __u8 data[10]; 101 unsigned int hid; 102 int retval; 103 size_t size; 104 enum hid_report_type type; 105 __u8 request_type; 106 }; 107 108 #define ASSERT_OK(data) ASSERT_FALSE(data) 109 #define ASSERT_OK_PTR(ptr) ASSERT_NE(NULL, ptr) 110 111 #define UHID_LOG(fmt, ...) do { \ 112 if (SHOW_UHID_DEBUG) \ 113 TH_LOG(fmt, ##__VA_ARGS__); \ 114 } while (0) 115 116 static pthread_mutex_t uhid_started_mtx = PTHREAD_MUTEX_INITIALIZER; 117 static pthread_cond_t uhid_started = PTHREAD_COND_INITIALIZER; 118 119 static pthread_mutex_t uhid_output_mtx = PTHREAD_MUTEX_INITIALIZER; 120 static pthread_cond_t uhid_output_cond = PTHREAD_COND_INITIALIZER; 121 static unsigned char output_report[10]; 122 123 /* no need to protect uhid_stopped, only one thread accesses it */ 124 static bool uhid_stopped; 125 126 static int uhid_write(struct __test_metadata *_metadata, int fd, const struct uhid_event *ev) 127 { 128 ssize_t ret; 129 130 ret = write(fd, ev, sizeof(*ev)); 131 if (ret < 0) { 132 TH_LOG("Cannot write to uhid: %m"); 133 return -errno; 134 } else if (ret != sizeof(*ev)) { 135 TH_LOG("Wrong size written to uhid: %zd != %zu", 136 ret, sizeof(ev)); 137 return -EFAULT; 138 } else { 139 return 0; 140 } 141 } 142 143 static int uhid_create(struct __test_metadata *_metadata, int fd, int rand_nb) 144 { 145 struct uhid_event ev; 146 char buf[25]; 147 148 sprintf(buf, "test-uhid-device-%d", rand_nb); 149 150 memset(&ev, 0, sizeof(ev)); 151 ev.type = UHID_CREATE; 152 strcpy((char *)ev.u.create.name, buf); 153 ev.u.create.rd_data = rdesc; 154 ev.u.create.rd_size = sizeof(rdesc); 155 ev.u.create.bus = BUS_USB; 156 ev.u.create.vendor = 0x0001; 157 ev.u.create.product = 0x0a37; 158 ev.u.create.version = 0; 159 ev.u.create.country = 0; 160 161 sprintf(buf, "%d", rand_nb); 162 strcpy((char *)ev.u.create.phys, buf); 163 164 return uhid_write(_metadata, fd, &ev); 165 } 166 167 static void uhid_destroy(struct __test_metadata *_metadata, int fd) 168 { 169 struct uhid_event ev; 170 171 memset(&ev, 0, sizeof(ev)); 172 ev.type = UHID_DESTROY; 173 174 uhid_write(_metadata, fd, &ev); 175 } 176 177 static int uhid_event(struct __test_metadata *_metadata, int fd) 178 { 179 struct uhid_event ev, answer; 180 ssize_t ret; 181 182 memset(&ev, 0, sizeof(ev)); 183 ret = read(fd, &ev, sizeof(ev)); 184 if (ret == 0) { 185 UHID_LOG("Read HUP on uhid-cdev"); 186 return -EFAULT; 187 } else if (ret < 0) { 188 UHID_LOG("Cannot read uhid-cdev: %m"); 189 return -errno; 190 } else if (ret != sizeof(ev)) { 191 UHID_LOG("Invalid size read from uhid-dev: %zd != %zu", 192 ret, sizeof(ev)); 193 return -EFAULT; 194 } 195 196 switch (ev.type) { 197 case UHID_START: 198 pthread_mutex_lock(&uhid_started_mtx); 199 pthread_cond_signal(&uhid_started); 200 pthread_mutex_unlock(&uhid_started_mtx); 201 202 UHID_LOG("UHID_START from uhid-dev"); 203 break; 204 case UHID_STOP: 205 uhid_stopped = true; 206 207 UHID_LOG("UHID_STOP from uhid-dev"); 208 break; 209 case UHID_OPEN: 210 UHID_LOG("UHID_OPEN from uhid-dev"); 211 break; 212 case UHID_CLOSE: 213 UHID_LOG("UHID_CLOSE from uhid-dev"); 214 break; 215 case UHID_OUTPUT: 216 UHID_LOG("UHID_OUTPUT from uhid-dev"); 217 218 pthread_mutex_lock(&uhid_output_mtx); 219 memcpy(output_report, 220 ev.u.output.data, 221 min(ev.u.output.size, sizeof(output_report))); 222 pthread_cond_signal(&uhid_output_cond); 223 pthread_mutex_unlock(&uhid_output_mtx); 224 break; 225 case UHID_GET_REPORT: 226 UHID_LOG("UHID_GET_REPORT from uhid-dev"); 227 228 answer.type = UHID_GET_REPORT_REPLY; 229 answer.u.get_report_reply.id = ev.u.get_report.id; 230 answer.u.get_report_reply.err = ev.u.get_report.rnum == 1 ? 0 : -EIO; 231 answer.u.get_report_reply.size = sizeof(feature_data); 232 memcpy(answer.u.get_report_reply.data, feature_data, sizeof(feature_data)); 233 234 uhid_write(_metadata, fd, &answer); 235 236 break; 237 case UHID_SET_REPORT: 238 UHID_LOG("UHID_SET_REPORT from uhid-dev"); 239 break; 240 default: 241 TH_LOG("Invalid event from uhid-dev: %u", ev.type); 242 } 243 244 return 0; 245 } 246 247 struct uhid_thread_args { 248 int fd; 249 struct __test_metadata *_metadata; 250 }; 251 static void *uhid_read_events_thread(void *arg) 252 { 253 struct uhid_thread_args *args = (struct uhid_thread_args *)arg; 254 struct __test_metadata *_metadata = args->_metadata; 255 struct pollfd pfds[1]; 256 int fd = args->fd; 257 int ret = 0; 258 259 pfds[0].fd = fd; 260 pfds[0].events = POLLIN; 261 262 uhid_stopped = false; 263 264 while (!uhid_stopped) { 265 ret = poll(pfds, 1, 100); 266 if (ret < 0) { 267 TH_LOG("Cannot poll for fds: %m"); 268 break; 269 } 270 if (pfds[0].revents & POLLIN) { 271 ret = uhid_event(_metadata, fd); 272 if (ret) 273 break; 274 } 275 } 276 277 return (void *)(long)ret; 278 } 279 280 static int uhid_start_listener(struct __test_metadata *_metadata, pthread_t *tid, int uhid_fd) 281 { 282 struct uhid_thread_args args = { 283 .fd = uhid_fd, 284 ._metadata = _metadata, 285 }; 286 int err; 287 288 pthread_mutex_lock(&uhid_started_mtx); 289 err = pthread_create(tid, NULL, uhid_read_events_thread, (void *)&args); 290 ASSERT_EQ(0, err) { 291 TH_LOG("Could not start the uhid thread: %d", err); 292 pthread_mutex_unlock(&uhid_started_mtx); 293 close(uhid_fd); 294 return -EIO; 295 } 296 pthread_cond_wait(&uhid_started, &uhid_started_mtx); 297 pthread_mutex_unlock(&uhid_started_mtx); 298 299 return 0; 300 } 301 302 static int uhid_send_event(struct __test_metadata *_metadata, int fd, __u8 *buf, size_t size) 303 { 304 struct uhid_event ev; 305 306 if (size > sizeof(ev.u.input.data)) 307 return -E2BIG; 308 309 memset(&ev, 0, sizeof(ev)); 310 ev.type = UHID_INPUT2; 311 ev.u.input2.size = size; 312 313 memcpy(ev.u.input2.data, buf, size); 314 315 return uhid_write(_metadata, fd, &ev); 316 } 317 318 static int setup_uhid(struct __test_metadata *_metadata, int rand_nb) 319 { 320 int fd; 321 const char *path = "/dev/uhid"; 322 int ret; 323 324 fd = open(path, O_RDWR | O_CLOEXEC); 325 ASSERT_GE(fd, 0) TH_LOG("open uhid-cdev failed; %d", fd); 326 327 ret = uhid_create(_metadata, fd, rand_nb); 328 ASSERT_EQ(0, ret) { 329 TH_LOG("create uhid device failed: %d", ret); 330 close(fd); 331 } 332 333 return fd; 334 } 335 336 static bool match_sysfs_device(int dev_id, const char *workdir, struct dirent *dir) 337 { 338 const char *target = "0003:0001:0A37.*"; 339 char phys[512]; 340 char uevent[1024]; 341 char temp[512]; 342 int fd, nread; 343 bool found = false; 344 345 if (fnmatch(target, dir->d_name, 0)) 346 return false; 347 348 /* we found the correct VID/PID, now check for phys */ 349 sprintf(uevent, "%s/%s/uevent", workdir, dir->d_name); 350 351 fd = open(uevent, O_RDONLY | O_NONBLOCK); 352 if (fd < 0) 353 return false; 354 355 sprintf(phys, "PHYS=%d", dev_id); 356 357 nread = read(fd, temp, ARRAY_SIZE(temp)); 358 if (nread > 0 && (strstr(temp, phys)) != NULL) 359 found = true; 360 361 close(fd); 362 363 return found; 364 } 365 366 static int get_hid_id(int dev_id) 367 { 368 const char *workdir = "/sys/devices/virtual/misc/uhid"; 369 const char *str_id; 370 DIR *d; 371 struct dirent *dir; 372 int found = -1, attempts = 3; 373 374 /* it would be nice to be able to use nftw, but the no_alu32 target doesn't support it */ 375 376 while (found < 0 && attempts > 0) { 377 attempts--; 378 d = opendir(workdir); 379 if (d) { 380 while ((dir = readdir(d)) != NULL) { 381 if (!match_sysfs_device(dev_id, workdir, dir)) 382 continue; 383 384 str_id = dir->d_name + sizeof("0003:0001:0A37."); 385 found = (int)strtol(str_id, NULL, 16); 386 387 break; 388 } 389 closedir(d); 390 } 391 if (found < 0) 392 usleep(100000); 393 } 394 395 return found; 396 } 397 398 static int get_hidraw(int dev_id) 399 { 400 const char *workdir = "/sys/devices/virtual/misc/uhid"; 401 char sysfs[1024]; 402 DIR *d, *subd; 403 struct dirent *dir, *subdir; 404 int i, found = -1; 405 406 /* retry 5 times in case the system is loaded */ 407 for (i = 5; i > 0; i--) { 408 usleep(10); 409 d = opendir(workdir); 410 411 if (!d) 412 continue; 413 414 while ((dir = readdir(d)) != NULL) { 415 if (!match_sysfs_device(dev_id, workdir, dir)) 416 continue; 417 418 sprintf(sysfs, "%s/%s/hidraw", workdir, dir->d_name); 419 420 subd = opendir(sysfs); 421 if (!subd) 422 continue; 423 424 while ((subdir = readdir(subd)) != NULL) { 425 if (fnmatch("hidraw*", subdir->d_name, 0)) 426 continue; 427 428 found = atoi(subdir->d_name + strlen("hidraw")); 429 } 430 431 closedir(subd); 432 433 if (found > 0) 434 break; 435 } 436 closedir(d); 437 } 438 439 return found; 440 } 441 442 static int open_hidraw(int dev_id) 443 { 444 int hidraw_number; 445 char hidraw_path[64] = { 0 }; 446 447 hidraw_number = get_hidraw(dev_id); 448 if (hidraw_number < 0) 449 return hidraw_number; 450 451 /* open hidraw node to check the other side of the pipe */ 452 sprintf(hidraw_path, "/dev/hidraw%d", hidraw_number); 453 return open(hidraw_path, O_RDWR | O_NONBLOCK); 454 } 455 456 FIXTURE(hid_bpf) { 457 int dev_id; 458 int uhid_fd; 459 int hidraw_fd; 460 int hid_id; 461 pthread_t tid; 462 struct hid *skel; 463 struct bpf_link *hid_links[3]; /* max number of programs loaded in a single test */ 464 }; 465 static void detach_bpf(FIXTURE_DATA(hid_bpf) * self) 466 { 467 int i; 468 469 if (self->hidraw_fd) 470 close(self->hidraw_fd); 471 self->hidraw_fd = 0; 472 473 if (!self->skel) 474 return; 475 476 hid__detach(self->skel); 477 478 for (i = 0; i < ARRAY_SIZE(self->hid_links); i++) { 479 if (self->hid_links[i]) 480 bpf_link__destroy(self->hid_links[i]); 481 } 482 483 hid__destroy(self->skel); 484 self->skel = NULL; 485 } 486 487 FIXTURE_TEARDOWN(hid_bpf) { 488 void *uhid_err; 489 490 uhid_destroy(_metadata, self->uhid_fd); 491 492 detach_bpf(self); 493 pthread_join(self->tid, &uhid_err); 494 } 495 #define TEARDOWN_LOG(fmt, ...) do { \ 496 TH_LOG(fmt, ##__VA_ARGS__); \ 497 hid_bpf_teardown(_metadata, self, variant); \ 498 } while (0) 499 500 FIXTURE_SETUP(hid_bpf) 501 { 502 time_t t; 503 int err; 504 505 /* initialize random number generator */ 506 srand((unsigned int)time(&t)); 507 508 self->dev_id = rand() % 1024; 509 510 self->uhid_fd = setup_uhid(_metadata, self->dev_id); 511 512 /* locate the uev, self, variant);ent file of the created device */ 513 self->hid_id = get_hid_id(self->dev_id); 514 ASSERT_GT(self->hid_id, 0) 515 TEARDOWN_LOG("Could not locate uhid device id: %d", self->hid_id); 516 517 err = uhid_start_listener(_metadata, &self->tid, self->uhid_fd); 518 ASSERT_EQ(0, err) TEARDOWN_LOG("could not start udev listener: %d", err); 519 } 520 521 struct test_program { 522 const char *name; 523 int insert_head; 524 }; 525 #define LOAD_PROGRAMS(progs) \ 526 load_programs(progs, ARRAY_SIZE(progs), _metadata, self, variant) 527 #define LOAD_BPF \ 528 load_programs(NULL, 0, _metadata, self, variant) 529 static void load_programs(const struct test_program programs[], 530 const size_t progs_count, 531 struct __test_metadata *_metadata, 532 FIXTURE_DATA(hid_bpf) * self, 533 const FIXTURE_VARIANT(hid_bpf) * variant) 534 { 535 struct bpf_map *iter_map; 536 int err = -EINVAL; 537 538 ASSERT_LE(progs_count, ARRAY_SIZE(self->hid_links)) 539 TH_LOG("too many programs are to be loaded"); 540 541 /* open the bpf file */ 542 self->skel = hid__open(); 543 ASSERT_OK_PTR(self->skel) TEARDOWN_LOG("Error while calling hid__open"); 544 545 for (int i = 0; i < progs_count; i++) { 546 struct bpf_program *prog; 547 struct bpf_map *map; 548 int *ops_hid_id; 549 550 prog = bpf_object__find_program_by_name(*self->skel->skeleton->obj, 551 programs[i].name); 552 ASSERT_OK_PTR(prog) TH_LOG("can not find program by name '%s'", programs[i].name); 553 554 bpf_program__set_autoload(prog, true); 555 556 map = bpf_object__find_map_by_name(*self->skel->skeleton->obj, 557 programs[i].name + 4); 558 ASSERT_OK_PTR(map) TH_LOG("can not find struct_ops by name '%s'", 559 programs[i].name + 4); 560 561 /* hid_id is the first field of struct hid_bpf_ops */ 562 ops_hid_id = bpf_map__initial_value(map, NULL); 563 ASSERT_OK_PTR(ops_hid_id) TH_LOG("unable to retrieve struct_ops data"); 564 565 *ops_hid_id = self->hid_id; 566 } 567 568 /* we disable the auto-attach feature of all maps because we 569 * only want the tested one to be manually attached in the next 570 * call to bpf_map__attach_struct_ops() 571 */ 572 bpf_object__for_each_map(iter_map, *self->skel->skeleton->obj) 573 bpf_map__set_autoattach(iter_map, false); 574 575 err = hid__load(self->skel); 576 ASSERT_OK(err) TH_LOG("hid_skel_load failed: %d", err); 577 578 for (int i = 0; i < progs_count; i++) { 579 struct bpf_map *map; 580 581 map = bpf_object__find_map_by_name(*self->skel->skeleton->obj, 582 programs[i].name + 4); 583 ASSERT_OK_PTR(map) TH_LOG("can not find struct_ops by name '%s'", 584 programs[i].name + 4); 585 586 self->hid_links[i] = bpf_map__attach_struct_ops(map); 587 ASSERT_OK_PTR(self->hid_links[i]) TH_LOG("failed to attach struct ops '%s'", 588 programs[i].name + 4); 589 } 590 591 hid__attach(self->skel); 592 593 self->hidraw_fd = open_hidraw(self->dev_id); 594 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 595 } 596 597 /* 598 * A simple test to see if the fixture is working fine. 599 * If this fails, none of the other tests will pass. 600 */ 601 TEST_F(hid_bpf, test_create_uhid) 602 { 603 } 604 605 /* 606 * Attach hid_first_event to the given uhid device, 607 * retrieve and open the matching hidraw node, 608 * inject one event in the uhid device, 609 * check that the program sees it and can change the data 610 */ 611 TEST_F(hid_bpf, raw_event) 612 { 613 const struct test_program progs[] = { 614 { .name = "hid_first_event" }, 615 }; 616 __u8 buf[10] = {0}; 617 int err; 618 619 LOAD_PROGRAMS(progs); 620 621 /* check that the program is correctly loaded */ 622 ASSERT_EQ(self->skel->data->callback_check, 52) TH_LOG("callback_check1"); 623 ASSERT_EQ(self->skel->data->callback2_check, 52) TH_LOG("callback2_check1"); 624 625 /* inject one event */ 626 buf[0] = 1; 627 buf[1] = 42; 628 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 629 630 /* check that hid_first_event() was executed */ 631 ASSERT_EQ(self->skel->data->callback_check, 42) TH_LOG("callback_check1"); 632 633 /* read the data from hidraw */ 634 memset(buf, 0, sizeof(buf)); 635 err = read(self->hidraw_fd, buf, sizeof(buf)); 636 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 637 ASSERT_EQ(buf[0], 1); 638 ASSERT_EQ(buf[2], 47); 639 640 /* inject another event */ 641 memset(buf, 0, sizeof(buf)); 642 buf[0] = 1; 643 buf[1] = 47; 644 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 645 646 /* check that hid_first_event() was executed */ 647 ASSERT_EQ(self->skel->data->callback_check, 47) TH_LOG("callback_check1"); 648 649 /* read the data from hidraw */ 650 memset(buf, 0, sizeof(buf)); 651 err = read(self->hidraw_fd, buf, sizeof(buf)); 652 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 653 ASSERT_EQ(buf[2], 52); 654 } 655 656 /* 657 * Attach hid_first_event to the given uhid device, 658 * retrieve and open the matching hidraw node, 659 * inject one event in the uhid device, 660 * check that the program sees it and can change the data 661 */ 662 TEST_F(hid_bpf, subprog_raw_event) 663 { 664 const struct test_program progs[] = { 665 { .name = "hid_subprog_first_event" }, 666 }; 667 __u8 buf[10] = {0}; 668 int err; 669 670 LOAD_PROGRAMS(progs); 671 672 /* inject one event */ 673 buf[0] = 1; 674 buf[1] = 42; 675 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 676 677 /* read the data from hidraw */ 678 memset(buf, 0, sizeof(buf)); 679 err = read(self->hidraw_fd, buf, sizeof(buf)); 680 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 681 ASSERT_EQ(buf[0], 1); 682 ASSERT_EQ(buf[2], 47); 683 684 /* inject another event */ 685 memset(buf, 0, sizeof(buf)); 686 buf[0] = 1; 687 buf[1] = 47; 688 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 689 690 /* read the data from hidraw */ 691 memset(buf, 0, sizeof(buf)); 692 err = read(self->hidraw_fd, buf, sizeof(buf)); 693 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 694 ASSERT_EQ(buf[2], 52); 695 } 696 697 /* 698 * Attach hid_first_event to the given uhid device, 699 * attempt at re-attaching it, we should not lock and 700 * return an invalid struct bpf_link 701 */ 702 TEST_F(hid_bpf, multiple_attach) 703 { 704 const struct test_program progs[] = { 705 { .name = "hid_first_event" }, 706 }; 707 struct bpf_link *link; 708 709 LOAD_PROGRAMS(progs); 710 711 link = bpf_map__attach_struct_ops(self->skel->maps.first_event); 712 ASSERT_NULL(link) TH_LOG("unexpected return value when re-attaching the struct_ops"); 713 } 714 715 /* 716 * Ensures that we can attach/detach programs 717 */ 718 TEST_F(hid_bpf, test_attach_detach) 719 { 720 const struct test_program progs[] = { 721 { .name = "hid_first_event" }, 722 { .name = "hid_second_event" }, 723 }; 724 struct bpf_link *link; 725 __u8 buf[10] = {0}; 726 int err, link_fd; 727 728 LOAD_PROGRAMS(progs); 729 730 link = self->hid_links[0]; 731 ASSERT_OK_PTR(link) TH_LOG("HID-BPF link not created"); 732 733 link_fd = bpf_link__fd(link); 734 ASSERT_GE(link_fd, 0) TH_LOG("HID-BPF link FD not valid"); 735 736 /* inject one event */ 737 buf[0] = 1; 738 buf[1] = 42; 739 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 740 741 /* read the data from hidraw */ 742 memset(buf, 0, sizeof(buf)); 743 err = read(self->hidraw_fd, buf, sizeof(buf)); 744 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 745 ASSERT_EQ(buf[0], 1); 746 ASSERT_EQ(buf[2], 47); 747 748 /* make sure both programs are run */ 749 ASSERT_EQ(buf[3], 52); 750 751 /* pin the first program and immediately unpin it */ 752 #define PIN_PATH "/sys/fs/bpf/hid_first_event" 753 err = bpf_obj_pin(link_fd, PIN_PATH); 754 ASSERT_OK(err) TH_LOG("error while calling bpf_obj_pin"); 755 remove(PIN_PATH); 756 #undef PIN_PATH 757 usleep(100000); 758 759 /* detach the program */ 760 detach_bpf(self); 761 762 self->hidraw_fd = open_hidraw(self->dev_id); 763 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 764 765 /* inject another event */ 766 memset(buf, 0, sizeof(buf)); 767 buf[0] = 1; 768 buf[1] = 47; 769 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 770 771 /* read the data from hidraw */ 772 memset(buf, 0, sizeof(buf)); 773 err = read(self->hidraw_fd, buf, sizeof(buf)); 774 ASSERT_EQ(err, 6) TH_LOG("read_hidraw_no_bpf"); 775 ASSERT_EQ(buf[0], 1); 776 ASSERT_EQ(buf[1], 47); 777 ASSERT_EQ(buf[2], 0); 778 ASSERT_EQ(buf[3], 0); 779 780 /* re-attach our program */ 781 782 LOAD_PROGRAMS(progs); 783 784 /* inject one event */ 785 memset(buf, 0, sizeof(buf)); 786 buf[0] = 1; 787 buf[1] = 42; 788 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 789 790 /* read the data from hidraw */ 791 memset(buf, 0, sizeof(buf)); 792 err = read(self->hidraw_fd, buf, sizeof(buf)); 793 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 794 ASSERT_EQ(buf[0], 1); 795 ASSERT_EQ(buf[2], 47); 796 ASSERT_EQ(buf[3], 52); 797 } 798 799 /* 800 * Attach hid_change_report_id to the given uhid device, 801 * retrieve and open the matching hidraw node, 802 * inject one event in the uhid device, 803 * check that the program sees it and can change the data 804 */ 805 TEST_F(hid_bpf, test_hid_change_report) 806 { 807 const struct test_program progs[] = { 808 { .name = "hid_change_report_id" }, 809 }; 810 __u8 buf[10] = {0}; 811 int err; 812 813 LOAD_PROGRAMS(progs); 814 815 /* inject one event */ 816 buf[0] = 1; 817 buf[1] = 42; 818 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 819 820 /* read the data from hidraw */ 821 memset(buf, 0, sizeof(buf)); 822 err = read(self->hidraw_fd, buf, sizeof(buf)); 823 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 824 ASSERT_EQ(buf[0], 2); 825 ASSERT_EQ(buf[1], 42); 826 ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test"); 827 } 828 829 /* 830 * Call hid_bpf_input_report against the given uhid device, 831 * check that the program is called and does the expected. 832 */ 833 TEST_F(hid_bpf, test_hid_user_input_report_call) 834 { 835 struct hid_hw_request_syscall_args args = { 836 .retval = -1, 837 .size = 10, 838 }; 839 DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattrs, 840 .ctx_in = &args, 841 .ctx_size_in = sizeof(args), 842 ); 843 __u8 buf[10] = {0}; 844 int err, prog_fd; 845 846 LOAD_BPF; 847 848 args.hid = self->hid_id; 849 args.data[0] = 1; /* report ID */ 850 args.data[1] = 2; /* report ID */ 851 args.data[2] = 42; /* report ID */ 852 853 prog_fd = bpf_program__fd(self->skel->progs.hid_user_input_report); 854 855 /* check that there is no data to read from hidraw */ 856 memset(buf, 0, sizeof(buf)); 857 err = read(self->hidraw_fd, buf, sizeof(buf)); 858 ASSERT_EQ(err, -1) TH_LOG("read_hidraw"); 859 860 err = bpf_prog_test_run_opts(prog_fd, &tattrs); 861 862 ASSERT_OK(err) TH_LOG("error while calling bpf_prog_test_run_opts"); 863 864 ASSERT_EQ(args.retval, 0); 865 866 /* read the data from hidraw */ 867 memset(buf, 0, sizeof(buf)); 868 err = read(self->hidraw_fd, buf, sizeof(buf)); 869 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 870 ASSERT_EQ(buf[0], 1); 871 ASSERT_EQ(buf[1], 2); 872 ASSERT_EQ(buf[2], 42); 873 } 874 875 /* 876 * Call hid_bpf_hw_output_report against the given uhid device, 877 * check that the program is called and does the expected. 878 */ 879 TEST_F(hid_bpf, test_hid_user_output_report_call) 880 { 881 struct hid_hw_request_syscall_args args = { 882 .retval = -1, 883 .size = 10, 884 }; 885 DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattrs, 886 .ctx_in = &args, 887 .ctx_size_in = sizeof(args), 888 ); 889 int err, cond_err, prog_fd; 890 struct timespec time_to_wait; 891 892 LOAD_BPF; 893 894 args.hid = self->hid_id; 895 args.data[0] = 1; /* report ID */ 896 args.data[1] = 2; /* report ID */ 897 args.data[2] = 42; /* report ID */ 898 899 prog_fd = bpf_program__fd(self->skel->progs.hid_user_output_report); 900 901 pthread_mutex_lock(&uhid_output_mtx); 902 903 memset(output_report, 0, sizeof(output_report)); 904 clock_gettime(CLOCK_REALTIME, &time_to_wait); 905 time_to_wait.tv_sec += 2; 906 907 err = bpf_prog_test_run_opts(prog_fd, &tattrs); 908 cond_err = pthread_cond_timedwait(&uhid_output_cond, &uhid_output_mtx, &time_to_wait); 909 910 ASSERT_OK(err) TH_LOG("error while calling bpf_prog_test_run_opts"); 911 ASSERT_OK(cond_err) TH_LOG("error while calling waiting for the condition"); 912 913 ASSERT_EQ(args.retval, 3); 914 915 ASSERT_EQ(output_report[0], 1); 916 ASSERT_EQ(output_report[1], 2); 917 ASSERT_EQ(output_report[2], 42); 918 919 pthread_mutex_unlock(&uhid_output_mtx); 920 } 921 922 /* 923 * Call hid_hw_raw_request against the given uhid device, 924 * check that the program is called and does the expected. 925 */ 926 TEST_F(hid_bpf, test_hid_user_raw_request_call) 927 { 928 struct hid_hw_request_syscall_args args = { 929 .retval = -1, 930 .type = HID_FEATURE_REPORT, 931 .request_type = HID_REQ_GET_REPORT, 932 .size = 10, 933 }; 934 DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattrs, 935 .ctx_in = &args, 936 .ctx_size_in = sizeof(args), 937 ); 938 int err, prog_fd; 939 940 LOAD_BPF; 941 942 args.hid = self->hid_id; 943 args.data[0] = 1; /* report ID */ 944 945 prog_fd = bpf_program__fd(self->skel->progs.hid_user_raw_request); 946 947 err = bpf_prog_test_run_opts(prog_fd, &tattrs); 948 ASSERT_OK(err) TH_LOG("error while calling bpf_prog_test_run_opts"); 949 950 ASSERT_EQ(args.retval, 2); 951 952 ASSERT_EQ(args.data[1], 2); 953 } 954 955 /* 956 * Call hid_hw_raw_request against the given uhid device, 957 * check that the program is called and prevents the 958 * call to uhid. 959 */ 960 TEST_F(hid_bpf, test_hid_filter_raw_request_call) 961 { 962 const struct test_program progs[] = { 963 { .name = "hid_test_filter_raw_request" }, 964 }; 965 __u8 buf[10] = {0}; 966 int err; 967 968 LOAD_PROGRAMS(progs); 969 970 /* first check that we did not attach to device_event */ 971 972 /* inject one event */ 973 buf[0] = 1; 974 buf[1] = 42; 975 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 976 977 /* read the data from hidraw */ 978 memset(buf, 0, sizeof(buf)); 979 err = read(self->hidraw_fd, buf, sizeof(buf)); 980 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 981 ASSERT_EQ(buf[0], 1); 982 ASSERT_EQ(buf[1], 42); 983 ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test"); 984 985 /* now check that our program is preventing hid_hw_raw_request() */ 986 987 /* emit hid_hw_raw_request from hidraw */ 988 /* Get Feature */ 989 memset(buf, 0, sizeof(buf)); 990 buf[0] = 0x1; /* Report Number */ 991 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 992 ASSERT_LT(err, 0) TH_LOG("unexpected success while reading HIDIOCGFEATURE: %d", err); 993 ASSERT_EQ(errno, 20) TH_LOG("unexpected error code while reading HIDIOCGFEATURE: %d", 994 errno); 995 996 /* remove our bpf program and check that we can now emit commands */ 997 998 /* detach the program */ 999 detach_bpf(self); 1000 1001 self->hidraw_fd = open_hidraw(self->dev_id); 1002 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 1003 1004 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 1005 ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGFEATURE: %d", err); 1006 } 1007 1008 /* 1009 * Call hid_hw_raw_request against the given uhid device, 1010 * check that the program is called and can issue the call 1011 * to uhid and transform the answer. 1012 */ 1013 TEST_F(hid_bpf, test_hid_change_raw_request_call) 1014 { 1015 const struct test_program progs[] = { 1016 { .name = "hid_test_hidraw_raw_request" }, 1017 }; 1018 __u8 buf[10] = {0}; 1019 int err; 1020 1021 LOAD_PROGRAMS(progs); 1022 1023 /* emit hid_hw_raw_request from hidraw */ 1024 /* Get Feature */ 1025 memset(buf, 0, sizeof(buf)); 1026 buf[0] = 0x1; /* Report Number */ 1027 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 1028 ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err); 1029 1030 ASSERT_EQ(buf[0], 2); 1031 ASSERT_EQ(buf[1], 3); 1032 ASSERT_EQ(buf[2], 4); 1033 } 1034 1035 /* 1036 * Call hid_hw_raw_request against the given uhid device, 1037 * check that the program is not making infinite loops. 1038 */ 1039 TEST_F(hid_bpf, test_hid_infinite_loop_raw_request_call) 1040 { 1041 const struct test_program progs[] = { 1042 { .name = "hid_test_infinite_loop_raw_request" }, 1043 }; 1044 __u8 buf[10] = {0}; 1045 int err; 1046 1047 LOAD_PROGRAMS(progs); 1048 1049 /* emit hid_hw_raw_request from hidraw */ 1050 /* Get Feature */ 1051 memset(buf, 0, sizeof(buf)); 1052 buf[0] = 0x1; /* Report Number */ 1053 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 1054 ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err); 1055 } 1056 1057 /* 1058 * Call hid_hw_output_report against the given uhid device, 1059 * check that the program is called and prevents the 1060 * call to uhid. 1061 */ 1062 TEST_F(hid_bpf, test_hid_filter_output_report_call) 1063 { 1064 const struct test_program progs[] = { 1065 { .name = "hid_test_filter_output_report" }, 1066 }; 1067 __u8 buf[10] = {0}; 1068 int err; 1069 1070 LOAD_PROGRAMS(progs); 1071 1072 /* first check that we did not attach to device_event */ 1073 1074 /* inject one event */ 1075 buf[0] = 1; 1076 buf[1] = 42; 1077 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 1078 1079 /* read the data from hidraw */ 1080 memset(buf, 0, sizeof(buf)); 1081 err = read(self->hidraw_fd, buf, sizeof(buf)); 1082 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 1083 ASSERT_EQ(buf[0], 1); 1084 ASSERT_EQ(buf[1], 42); 1085 ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test"); 1086 1087 /* now check that our program is preventing hid_hw_output_report() */ 1088 1089 buf[0] = 1; /* report ID */ 1090 buf[1] = 2; 1091 buf[2] = 42; 1092 1093 err = write(self->hidraw_fd, buf, 3); 1094 ASSERT_LT(err, 0) TH_LOG("unexpected success while sending hid_hw_output_report: %d", err); 1095 ASSERT_EQ(errno, 25) TH_LOG("unexpected error code while sending hid_hw_output_report: %d", 1096 errno); 1097 1098 /* remove our bpf program and check that we can now emit commands */ 1099 1100 /* detach the program */ 1101 detach_bpf(self); 1102 1103 self->hidraw_fd = open_hidraw(self->dev_id); 1104 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 1105 1106 err = write(self->hidraw_fd, buf, 3); 1107 ASSERT_GE(err, 0) TH_LOG("error while sending hid_hw_output_report: %d", err); 1108 } 1109 1110 /* 1111 * Call hid_hw_output_report against the given uhid device, 1112 * check that the program is called and can issue the call 1113 * to uhid and transform the answer. 1114 */ 1115 TEST_F(hid_bpf, test_hid_change_output_report_call) 1116 { 1117 const struct test_program progs[] = { 1118 { .name = "hid_test_hidraw_output_report" }, 1119 }; 1120 __u8 buf[10] = {0}; 1121 int err; 1122 1123 LOAD_PROGRAMS(progs); 1124 1125 /* emit hid_hw_output_report from hidraw */ 1126 buf[0] = 1; /* report ID */ 1127 buf[1] = 2; 1128 buf[2] = 42; 1129 1130 err = write(self->hidraw_fd, buf, 10); 1131 ASSERT_EQ(err, 2) TH_LOG("unexpected returned size while sending hid_hw_output_report: %d", 1132 err); 1133 } 1134 1135 /* 1136 * Call hid_hw_output_report against the given uhid device, 1137 * check that the program is not making infinite loops. 1138 */ 1139 TEST_F(hid_bpf, test_hid_infinite_loop_output_report_call) 1140 { 1141 const struct test_program progs[] = { 1142 { .name = "hid_test_infinite_loop_output_report" }, 1143 }; 1144 __u8 buf[10] = {0}; 1145 int err; 1146 1147 LOAD_PROGRAMS(progs); 1148 1149 /* emit hid_hw_output_report from hidraw */ 1150 buf[0] = 1; /* report ID */ 1151 buf[1] = 2; 1152 buf[2] = 42; 1153 1154 err = write(self->hidraw_fd, buf, 8); 1155 ASSERT_EQ(err, 2) TH_LOG("unexpected returned size while sending hid_hw_output_report: %d", 1156 err); 1157 } 1158 1159 /* 1160 * Attach hid_multiply_event_wq to the given uhid device, 1161 * retrieve and open the matching hidraw node, 1162 * inject one event in the uhid device, 1163 * check that the program sees it and can add extra data 1164 */ 1165 TEST_F(hid_bpf, test_multiply_events_wq) 1166 { 1167 const struct test_program progs[] = { 1168 { .name = "hid_test_multiply_events_wq" }, 1169 }; 1170 __u8 buf[10] = {0}; 1171 int err; 1172 1173 LOAD_PROGRAMS(progs); 1174 1175 /* inject one event */ 1176 buf[0] = 1; 1177 buf[1] = 42; 1178 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 1179 1180 /* read the data from hidraw */ 1181 memset(buf, 0, sizeof(buf)); 1182 err = read(self->hidraw_fd, buf, sizeof(buf)); 1183 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 1184 ASSERT_EQ(buf[0], 1); 1185 ASSERT_EQ(buf[1], 47); 1186 1187 usleep(100000); 1188 1189 /* read the data from hidraw */ 1190 memset(buf, 0, sizeof(buf)); 1191 err = read(self->hidraw_fd, buf, sizeof(buf)); 1192 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 1193 ASSERT_EQ(buf[0], 2); 1194 ASSERT_EQ(buf[1], 3); 1195 } 1196 1197 /* 1198 * Attach hid_multiply_event to the given uhid device, 1199 * retrieve and open the matching hidraw node, 1200 * inject one event in the uhid device, 1201 * check that the program sees it and can add extra data 1202 */ 1203 TEST_F(hid_bpf, test_multiply_events) 1204 { 1205 const struct test_program progs[] = { 1206 { .name = "hid_test_multiply_events" }, 1207 }; 1208 __u8 buf[10] = {0}; 1209 int err; 1210 1211 LOAD_PROGRAMS(progs); 1212 1213 /* inject one event */ 1214 buf[0] = 1; 1215 buf[1] = 42; 1216 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 1217 1218 /* read the data from hidraw */ 1219 memset(buf, 0, sizeof(buf)); 1220 err = read(self->hidraw_fd, buf, sizeof(buf)); 1221 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 1222 ASSERT_EQ(buf[0], 2); 1223 ASSERT_EQ(buf[1], 47); 1224 1225 /* read the data from hidraw */ 1226 memset(buf, 0, sizeof(buf)); 1227 err = read(self->hidraw_fd, buf, sizeof(buf)); 1228 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 1229 ASSERT_EQ(buf[0], 2); 1230 ASSERT_EQ(buf[1], 52); 1231 } 1232 1233 /* 1234 * Call hid_bpf_input_report against the given uhid device, 1235 * check that the program is not making infinite loops. 1236 */ 1237 TEST_F(hid_bpf, test_hid_infinite_loop_input_report_call) 1238 { 1239 const struct test_program progs[] = { 1240 { .name = "hid_test_infinite_loop_input_report" }, 1241 }; 1242 __u8 buf[10] = {0}; 1243 int err; 1244 1245 LOAD_PROGRAMS(progs); 1246 1247 /* emit hid_hw_output_report from hidraw */ 1248 buf[0] = 1; /* report ID */ 1249 buf[1] = 2; 1250 buf[2] = 42; 1251 1252 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 1253 1254 /* read the data from hidraw */ 1255 memset(buf, 0, sizeof(buf)); 1256 err = read(self->hidraw_fd, buf, sizeof(buf)); 1257 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 1258 ASSERT_EQ(buf[0], 1); 1259 ASSERT_EQ(buf[1], 3); 1260 1261 /* read the data from hidraw: hid_bpf_try_input_report should work exactly one time */ 1262 memset(buf, 0, sizeof(buf)); 1263 err = read(self->hidraw_fd, buf, sizeof(buf)); 1264 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 1265 ASSERT_EQ(buf[0], 1); 1266 ASSERT_EQ(buf[1], 4); 1267 1268 /* read the data from hidraw: there should be none */ 1269 memset(buf, 0, sizeof(buf)); 1270 err = read(self->hidraw_fd, buf, sizeof(buf)); 1271 ASSERT_EQ(err, -1) TH_LOG("read_hidraw"); 1272 } 1273 1274 /* 1275 * Attach hid_insert{0,1,2} to the given uhid device, 1276 * retrieve and open the matching hidraw node, 1277 * inject one event in the uhid device, 1278 * check that the programs have been inserted in the correct order. 1279 */ 1280 TEST_F(hid_bpf, test_hid_attach_flags) 1281 { 1282 const struct test_program progs[] = { 1283 { 1284 .name = "hid_test_insert2", 1285 .insert_head = 0, 1286 }, 1287 { 1288 .name = "hid_test_insert1", 1289 .insert_head = 1, 1290 }, 1291 { 1292 .name = "hid_test_insert3", 1293 .insert_head = 0, 1294 }, 1295 }; 1296 __u8 buf[10] = {0}; 1297 int err; 1298 1299 LOAD_PROGRAMS(progs); 1300 1301 /* inject one event */ 1302 buf[0] = 1; 1303 uhid_send_event(_metadata, self->uhid_fd, buf, 6); 1304 1305 /* read the data from hidraw */ 1306 memset(buf, 0, sizeof(buf)); 1307 err = read(self->hidraw_fd, buf, sizeof(buf)); 1308 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 1309 ASSERT_EQ(buf[1], 1); 1310 ASSERT_EQ(buf[2], 2); 1311 ASSERT_EQ(buf[3], 3); 1312 } 1313 1314 /* 1315 * Attach hid_rdesc_fixup to the given uhid device, 1316 * retrieve and open the matching hidraw node, 1317 * check that the hidraw report descriptor has been updated. 1318 */ 1319 TEST_F(hid_bpf, test_rdesc_fixup) 1320 { 1321 struct hidraw_report_descriptor rpt_desc = {0}; 1322 const struct test_program progs[] = { 1323 { .name = "hid_rdesc_fixup" }, 1324 }; 1325 int err, desc_size; 1326 1327 LOAD_PROGRAMS(progs); 1328 1329 /* check that hid_rdesc_fixup() was executed */ 1330 ASSERT_EQ(self->skel->data->callback2_check, 0x21); 1331 1332 /* read the exposed report descriptor from hidraw */ 1333 err = ioctl(self->hidraw_fd, HIDIOCGRDESCSIZE, &desc_size); 1334 ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGRDESCSIZE: %d", err); 1335 1336 /* ensure the new size of the rdesc is bigger than the old one */ 1337 ASSERT_GT(desc_size, sizeof(rdesc)); 1338 1339 rpt_desc.size = desc_size; 1340 err = ioctl(self->hidraw_fd, HIDIOCGRDESC, &rpt_desc); 1341 ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGRDESC: %d", err); 1342 1343 ASSERT_EQ(rpt_desc.value[4], 0x42); 1344 } 1345 1346 static int libbpf_print_fn(enum libbpf_print_level level, 1347 const char *format, va_list args) 1348 { 1349 char buf[1024]; 1350 1351 if (level == LIBBPF_DEBUG) 1352 return 0; 1353 1354 snprintf(buf, sizeof(buf), "# %s", format); 1355 1356 vfprintf(stdout, buf, args); 1357 return 0; 1358 } 1359 1360 static void __attribute__((constructor)) __constructor_order_last(void) 1361 { 1362 if (!__constructor_order) 1363 __constructor_order = _CONSTRUCTOR_ORDER_BACKWARD; 1364 } 1365 1366 int main(int argc, char **argv) 1367 { 1368 /* Use libbpf 1.0 API mode */ 1369 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 1370 libbpf_set_print(libbpf_print_fn); 1371 1372 return test_harness_run(argc, argv); 1373 } 1374