FILE
hid_bpf.c
File preview with syntax highlighting.
linux-6.19.14/tools/testing/selftests/hid/hid_bpf.c
1// SPDX-License-Identifier: GPL-2.0 2/* Copyright (c) 2022-2024 Red Hat */ 3#include "hid.skel.h" 4#include "hid_common.h" 5#include <bpf/bpf.h> 6 7struct hid_hw_request_syscall_args { 8 __u8 data[10]; 9 unsigned int hid; 10 int retval; 11 size_t size; 12 enum hid_report_type type; 13 __u8 request_type; 14}; 15 16FIXTURE(hid_bpf) { 17 struct uhid_device hid; 18 int hidraw_fd; 19 struct hid *skel; 20 struct bpf_link *hid_links[3]; /* max number of programs loaded in a single test */ 21}; 22static void detach_bpf(FIXTURE_DATA(hid_bpf) * self) 23{ 24 int i; 25 26 if (self->hidraw_fd) 27 close(self->hidraw_fd); 28 self->hidraw_fd = 0; 29 30 if (!self->skel) 31 return; 32 33 hid__detach(self->skel); 34 35 for (i = 0; i < ARRAY_SIZE(self->hid_links); i++) { 36 if (self->hid_links[i]) 37 bpf_link__destroy(self->hid_links[i]); 38 } 39 40 hid__destroy(self->skel); 41 self->skel = NULL; 42} 43 44FIXTURE_TEARDOWN(hid_bpf) { 45 void *uhid_err; 46 47 uhid_destroy(_metadata, &self->hid); 48 49 detach_bpf(self); 50 pthread_join(self->hid.tid, &uhid_err); 51} 52#define TEARDOWN_LOG(fmt, ...) do { \ 53 TH_LOG(fmt, ##__VA_ARGS__); \ 54 hid_bpf_teardown(_metadata, self, variant); \ 55} while (0) 56 57FIXTURE_SETUP(hid_bpf) 58{ 59 int err; 60 61 err = setup_uhid(_metadata, &self->hid, BUS_USB, 0x0001, 0x0a36, rdesc, sizeof(rdesc)); 62 ASSERT_OK(err); 63} 64 65struct test_program { 66 const char *name; 67 int insert_head; 68}; 69#define LOAD_PROGRAMS(progs) \ 70 load_programs(progs, ARRAY_SIZE(progs), _metadata, self, variant) 71#define LOAD_BPF \ 72 load_programs(NULL, 0, _metadata, self, variant) 73static void load_programs(const struct test_program programs[], 74 const size_t progs_count, 75 struct __test_metadata *_metadata, 76 FIXTURE_DATA(hid_bpf) * self, 77 const FIXTURE_VARIANT(hid_bpf) * variant) 78{ 79 struct bpf_map *iter_map; 80 int err = -EINVAL; 81 82 ASSERT_LE(progs_count, ARRAY_SIZE(self->hid_links)) 83 TH_LOG("too many programs are to be loaded"); 84 85 /* open the bpf file */ 86 self->skel = hid__open(); 87 ASSERT_OK_PTR(self->skel) TEARDOWN_LOG("Error while calling hid__open"); 88 89 for (int i = 0; i < progs_count; i++) { 90 struct bpf_program *prog; 91 struct bpf_map *map; 92 int *ops_hid_id; 93 94 prog = bpf_object__find_program_by_name(*self->skel->skeleton->obj, 95 programs[i].name); 96 ASSERT_OK_PTR(prog) TH_LOG("can not find program by name '%s'", programs[i].name); 97 98 bpf_program__set_autoload(prog, true); 99 100 map = bpf_object__find_map_by_name(*self->skel->skeleton->obj, 101 programs[i].name + 4); 102 ASSERT_OK_PTR(map) TH_LOG("can not find struct_ops by name '%s'", 103 programs[i].name + 4); 104 105 /* hid_id is the first field of struct hid_bpf_ops */ 106 ops_hid_id = bpf_map__initial_value(map, NULL); 107 ASSERT_OK_PTR(ops_hid_id) TH_LOG("unable to retrieve struct_ops data"); 108 109 *ops_hid_id = self->hid.hid_id; 110 } 111 112 /* we disable the auto-attach feature of all maps because we 113 * only want the tested one to be manually attached in the next 114 * call to bpf_map__attach_struct_ops() 115 */ 116 bpf_object__for_each_map(iter_map, *self->skel->skeleton->obj) 117 bpf_map__set_autoattach(iter_map, false); 118 119 err = hid__load(self->skel); 120 ASSERT_OK(err) TH_LOG("hid_skel_load failed: %d", err); 121 122 for (int i = 0; i < progs_count; i++) { 123 struct bpf_map *map; 124 125 map = bpf_object__find_map_by_name(*self->skel->skeleton->obj, 126 programs[i].name + 4); 127 ASSERT_OK_PTR(map) TH_LOG("can not find struct_ops by name '%s'", 128 programs[i].name + 4); 129 130 self->hid_links[i] = bpf_map__attach_struct_ops(map); 131 ASSERT_OK_PTR(self->hid_links[i]) TH_LOG("failed to attach struct ops '%s'", 132 programs[i].name + 4); 133 } 134 135 hid__attach(self->skel); 136 137 self->hidraw_fd = open_hidraw(&self->hid); 138 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 139} 140 141/* 142 * A simple test to see if the fixture is working fine. 143 * If this fails, none of the other tests will pass. 144 */ 145TEST_F(hid_bpf, test_create_uhid) 146{ 147} 148 149/* 150 * Attach hid_first_event to the given uhid device, 151 * retrieve and open the matching hidraw node, 152 * inject one event in the uhid device, 153 * check that the program sees it and can change the data 154 */ 155TEST_F(hid_bpf, raw_event) 156{ 157 const struct test_program progs[] = { 158 { .name = "hid_first_event" }, 159 }; 160 __u8 buf[10] = {0}; 161 int err; 162 163 LOAD_PROGRAMS(progs); 164 165 /* check that the program is correctly loaded */ 166 ASSERT_EQ(self->skel->data->callback_check, 52) TH_LOG("callback_check1"); 167 ASSERT_EQ(self->skel->data->callback2_check, 52) TH_LOG("callback2_check1"); 168 169 /* inject one event */ 170 buf[0] = 1; 171 buf[1] = 42; 172 uhid_send_event(_metadata, &self->hid, buf, 6); 173 174 /* check that hid_first_event() was executed */ 175 ASSERT_EQ(self->skel->data->callback_check, 42) TH_LOG("callback_check1"); 176 177 /* read the data from hidraw */ 178 memset(buf, 0, sizeof(buf)); 179 err = read(self->hidraw_fd, buf, sizeof(buf)); 180 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 181 ASSERT_EQ(buf[0], 1); 182 ASSERT_EQ(buf[2], 47); 183 184 /* inject another event */ 185 memset(buf, 0, sizeof(buf)); 186 buf[0] = 1; 187 buf[1] = 47; 188 uhid_send_event(_metadata, &self->hid, buf, 6); 189 190 /* check that hid_first_event() was executed */ 191 ASSERT_EQ(self->skel->data->callback_check, 47) TH_LOG("callback_check1"); 192 193 /* read the data from hidraw */ 194 memset(buf, 0, sizeof(buf)); 195 err = read(self->hidraw_fd, buf, sizeof(buf)); 196 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 197 ASSERT_EQ(buf[2], 52); 198} 199 200/* 201 * Attach hid_first_event to the given uhid device, 202 * retrieve and open the matching hidraw node, 203 * inject one event in the uhid device, 204 * check that the program sees it and can change the data 205 */ 206TEST_F(hid_bpf, subprog_raw_event) 207{ 208 const struct test_program progs[] = { 209 { .name = "hid_subprog_first_event" }, 210 }; 211 __u8 buf[10] = {0}; 212 int err; 213 214 LOAD_PROGRAMS(progs); 215 216 /* inject one event */ 217 buf[0] = 1; 218 buf[1] = 42; 219 uhid_send_event(_metadata, &self->hid, buf, 6); 220 221 /* read the data from hidraw */ 222 memset(buf, 0, sizeof(buf)); 223 err = read(self->hidraw_fd, buf, sizeof(buf)); 224 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 225 ASSERT_EQ(buf[0], 1); 226 ASSERT_EQ(buf[2], 47); 227 228 /* inject another event */ 229 memset(buf, 0, sizeof(buf)); 230 buf[0] = 1; 231 buf[1] = 47; 232 uhid_send_event(_metadata, &self->hid, buf, 6); 233 234 /* read the data from hidraw */ 235 memset(buf, 0, sizeof(buf)); 236 err = read(self->hidraw_fd, buf, sizeof(buf)); 237 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 238 ASSERT_EQ(buf[2], 52); 239} 240 241/* 242 * Attach hid_first_event to the given uhid device, 243 * attempt at re-attaching it, we should not lock and 244 * return an invalid struct bpf_link 245 */ 246TEST_F(hid_bpf, multiple_attach) 247{ 248 const struct test_program progs[] = { 249 { .name = "hid_first_event" }, 250 }; 251 struct bpf_link *link; 252 253 LOAD_PROGRAMS(progs); 254 255 link = bpf_map__attach_struct_ops(self->skel->maps.first_event); 256 ASSERT_NULL(link) TH_LOG("unexpected return value when re-attaching the struct_ops"); 257} 258 259/* 260 * Ensures that we can attach/detach programs 261 */ 262TEST_F(hid_bpf, test_attach_detach) 263{ 264 const struct test_program progs[] = { 265 { .name = "hid_first_event" }, 266 { .name = "hid_second_event" }, 267 }; 268 struct bpf_link *link; 269 __u8 buf[10] = {0}; 270 int err, link_fd; 271 272 LOAD_PROGRAMS(progs); 273 274 link = self->hid_links[0]; 275 ASSERT_OK_PTR(link) TH_LOG("HID-BPF link not created"); 276 277 link_fd = bpf_link__fd(link); 278 ASSERT_GE(link_fd, 0) TH_LOG("HID-BPF link FD not valid"); 279 280 /* inject one event */ 281 buf[0] = 1; 282 buf[1] = 42; 283 uhid_send_event(_metadata, &self->hid, buf, 6); 284 285 /* read the data from hidraw */ 286 memset(buf, 0, sizeof(buf)); 287 err = read(self->hidraw_fd, buf, sizeof(buf)); 288 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 289 ASSERT_EQ(buf[0], 1); 290 ASSERT_EQ(buf[2], 47); 291 292 /* make sure both programs are run */ 293 ASSERT_EQ(buf[3], 52); 294 295 /* pin the first program and immediately unpin it */ 296#define PIN_PATH "/sys/fs/bpf/hid_first_event" 297 err = bpf_obj_pin(link_fd, PIN_PATH); 298 ASSERT_OK(err) TH_LOG("error while calling bpf_obj_pin"); 299 remove(PIN_PATH); 300#undef PIN_PATH 301 usleep(100000); 302 303 /* detach the program */ 304 detach_bpf(self); 305 306 self->hidraw_fd = open_hidraw(&self->hid); 307 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 308 309 /* inject another event */ 310 memset(buf, 0, sizeof(buf)); 311 buf[0] = 1; 312 buf[1] = 47; 313 uhid_send_event(_metadata, &self->hid, buf, 6); 314 315 /* read the data from hidraw */ 316 memset(buf, 0, sizeof(buf)); 317 err = read(self->hidraw_fd, buf, sizeof(buf)); 318 ASSERT_EQ(err, 6) TH_LOG("read_hidraw_no_bpf"); 319 ASSERT_EQ(buf[0], 1); 320 ASSERT_EQ(buf[1], 47); 321 ASSERT_EQ(buf[2], 0); 322 ASSERT_EQ(buf[3], 0); 323 324 /* re-attach our program */ 325 326 LOAD_PROGRAMS(progs); 327 328 /* inject one event */ 329 memset(buf, 0, sizeof(buf)); 330 buf[0] = 1; 331 buf[1] = 42; 332 uhid_send_event(_metadata, &self->hid, buf, 6); 333 334 /* read the data from hidraw */ 335 memset(buf, 0, sizeof(buf)); 336 err = read(self->hidraw_fd, buf, sizeof(buf)); 337 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 338 ASSERT_EQ(buf[0], 1); 339 ASSERT_EQ(buf[2], 47); 340 ASSERT_EQ(buf[3], 52); 341} 342 343/* 344 * Attach hid_change_report_id to the given uhid device, 345 * retrieve and open the matching hidraw node, 346 * inject one event in the uhid device, 347 * check that the program sees it and can change the data 348 */ 349TEST_F(hid_bpf, test_hid_change_report) 350{ 351 const struct test_program progs[] = { 352 { .name = "hid_change_report_id" }, 353 }; 354 __u8 buf[10] = {0}; 355 int err; 356 357 LOAD_PROGRAMS(progs); 358 359 /* inject one event */ 360 buf[0] = 1; 361 buf[1] = 42; 362 uhid_send_event(_metadata, &self->hid, buf, 6); 363 364 /* read the data from hidraw */ 365 memset(buf, 0, sizeof(buf)); 366 err = read(self->hidraw_fd, buf, sizeof(buf)); 367 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 368 ASSERT_EQ(buf[0], 2); 369 ASSERT_EQ(buf[1], 42); 370 ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test"); 371} 372 373/* 374 * Call hid_bpf_input_report against the given uhid device, 375 * check that the program is called and does the expected. 376 */ 377TEST_F(hid_bpf, test_hid_user_input_report_call) 378{ 379 struct hid_hw_request_syscall_args args = { 380 .retval = -1, 381 .size = 10, 382 }; 383 DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattrs, 384 .ctx_in = &args, 385 .ctx_size_in = sizeof(args), 386 ); 387 __u8 buf[10] = {0}; 388 int err, prog_fd; 389 390 LOAD_BPF; 391 392 args.hid = self->hid.hid_id; 393 args.data[0] = 1; /* report ID */ 394 args.data[1] = 2; /* report ID */ 395 args.data[2] = 42; /* report ID */ 396 397 prog_fd = bpf_program__fd(self->skel->progs.hid_user_input_report); 398 399 /* check that there is no data to read from hidraw */ 400 memset(buf, 0, sizeof(buf)); 401 err = read(self->hidraw_fd, buf, sizeof(buf)); 402 ASSERT_EQ(err, -1) TH_LOG("read_hidraw"); 403 404 err = bpf_prog_test_run_opts(prog_fd, &tattrs); 405 406 ASSERT_OK(err) TH_LOG("error while calling bpf_prog_test_run_opts"); 407 408 ASSERT_EQ(args.retval, 0); 409 410 /* read the data from hidraw */ 411 memset(buf, 0, sizeof(buf)); 412 err = read(self->hidraw_fd, buf, sizeof(buf)); 413 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 414 ASSERT_EQ(buf[0], 1); 415 ASSERT_EQ(buf[1], 2); 416 ASSERT_EQ(buf[2], 42); 417} 418 419/* 420 * Call hid_bpf_hw_output_report against the given uhid device, 421 * check that the program is called and does the expected. 422 */ 423TEST_F(hid_bpf, test_hid_user_output_report_call) 424{ 425 struct hid_hw_request_syscall_args args = { 426 .retval = -1, 427 .size = 10, 428 }; 429 DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattrs, 430 .ctx_in = &args, 431 .ctx_size_in = sizeof(args), 432 ); 433 int err, cond_err, prog_fd; 434 struct timespec time_to_wait; 435 436 LOAD_BPF; 437 438 args.hid = self->hid.hid_id; 439 args.data[0] = 1; /* report ID */ 440 args.data[1] = 2; /* report ID */ 441 args.data[2] = 42; /* report ID */ 442 443 prog_fd = bpf_program__fd(self->skel->progs.hid_user_output_report); 444 445 pthread_mutex_lock(&uhid_output_mtx); 446 447 memset(output_report, 0, sizeof(output_report)); 448 clock_gettime(CLOCK_REALTIME, &time_to_wait); 449 time_to_wait.tv_sec += 2; 450 451 err = bpf_prog_test_run_opts(prog_fd, &tattrs); 452 cond_err = pthread_cond_timedwait(&uhid_output_cond, &uhid_output_mtx, &time_to_wait); 453 454 ASSERT_OK(err) TH_LOG("error while calling bpf_prog_test_run_opts"); 455 ASSERT_OK(cond_err) TH_LOG("error while calling waiting for the condition"); 456 457 ASSERT_EQ(args.retval, 3); 458 459 ASSERT_EQ(output_report[0], 1); 460 ASSERT_EQ(output_report[1], 2); 461 ASSERT_EQ(output_report[2], 42); 462 463 pthread_mutex_unlock(&uhid_output_mtx); 464} 465 466/* 467 * Call hid_hw_raw_request against the given uhid device, 468 * check that the program is called and does the expected. 469 */ 470TEST_F(hid_bpf, test_hid_user_raw_request_call) 471{ 472 struct hid_hw_request_syscall_args args = { 473 .retval = -1, 474 .type = HID_FEATURE_REPORT, 475 .request_type = HID_REQ_GET_REPORT, 476 .size = 10, 477 }; 478 DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattrs, 479 .ctx_in = &args, 480 .ctx_size_in = sizeof(args), 481 ); 482 int err, prog_fd; 483 484 LOAD_BPF; 485 486 args.hid = self->hid.hid_id; 487 args.data[0] = 1; /* report ID */ 488 489 prog_fd = bpf_program__fd(self->skel->progs.hid_user_raw_request); 490 491 err = bpf_prog_test_run_opts(prog_fd, &tattrs); 492 ASSERT_OK(err) TH_LOG("error while calling bpf_prog_test_run_opts"); 493 494 ASSERT_EQ(args.retval, 2); 495 496 ASSERT_EQ(args.data[1], 2); 497} 498 499/* 500 * Call hid_hw_raw_request against the given uhid device, 501 * check that the program is called and prevents the 502 * call to uhid. 503 */ 504TEST_F(hid_bpf, test_hid_filter_raw_request_call) 505{ 506 const struct test_program progs[] = { 507 { .name = "hid_test_filter_raw_request" }, 508 }; 509 __u8 buf[10] = {0}; 510 int err; 511 512 LOAD_PROGRAMS(progs); 513 514 /* first check that we did not attach to device_event */ 515 516 /* inject one event */ 517 buf[0] = 1; 518 buf[1] = 42; 519 uhid_send_event(_metadata, &self->hid, buf, 6); 520 521 /* read the data from hidraw */ 522 memset(buf, 0, sizeof(buf)); 523 err = read(self->hidraw_fd, buf, sizeof(buf)); 524 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 525 ASSERT_EQ(buf[0], 1); 526 ASSERT_EQ(buf[1], 42); 527 ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test"); 528 529 /* now check that our program is preventing hid_hw_raw_request() */ 530 531 /* emit hid_hw_raw_request from hidraw */ 532 /* Get Feature */ 533 memset(buf, 0, sizeof(buf)); 534 buf[0] = 0x1; /* Report Number */ 535 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 536 ASSERT_LT(err, 0) TH_LOG("unexpected success while reading HIDIOCGFEATURE: %d", err); 537 ASSERT_EQ(errno, 20) TH_LOG("unexpected error code while reading HIDIOCGFEATURE: %d", 538 errno); 539 540 /* remove our bpf program and check that we can now emit commands */ 541 542 /* detach the program */ 543 detach_bpf(self); 544 545 self->hidraw_fd = open_hidraw(&self->hid); 546 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 547 548 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 549 ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGFEATURE: %d", err); 550} 551 552/* 553 * Call hid_hw_raw_request against the given uhid device, 554 * check that the program is called and can issue the call 555 * to uhid and transform the answer. 556 */ 557TEST_F(hid_bpf, test_hid_change_raw_request_call) 558{ 559 const struct test_program progs[] = { 560 { .name = "hid_test_hidraw_raw_request" }, 561 }; 562 __u8 buf[10] = {0}; 563 int err; 564 565 LOAD_PROGRAMS(progs); 566 567 /* emit hid_hw_raw_request from hidraw */ 568 /* Get Feature */ 569 memset(buf, 0, sizeof(buf)); 570 buf[0] = 0x1; /* Report Number */ 571 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 572 ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err); 573 574 ASSERT_EQ(buf[0], 2); 575 ASSERT_EQ(buf[1], 3); 576 ASSERT_EQ(buf[2], 4); 577} 578 579/* 580 * Call hid_hw_raw_request against the given uhid device, 581 * check that the program is not making infinite loops. 582 */ 583TEST_F(hid_bpf, test_hid_infinite_loop_raw_request_call) 584{ 585 const struct test_program progs[] = { 586 { .name = "hid_test_infinite_loop_raw_request" }, 587 }; 588 __u8 buf[10] = {0}; 589 int err; 590 591 LOAD_PROGRAMS(progs); 592 593 /* emit hid_hw_raw_request from hidraw */ 594 /* Get Feature */ 595 memset(buf, 0, sizeof(buf)); 596 buf[0] = 0x1; /* Report Number */ 597 err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf); 598 ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err); 599} 600 601/* 602 * Call hid_hw_output_report against the given uhid device, 603 * check that the program is called and prevents the 604 * call to uhid. 605 */ 606TEST_F(hid_bpf, test_hid_filter_output_report_call) 607{ 608 const struct test_program progs[] = { 609 { .name = "hid_test_filter_output_report" }, 610 }; 611 __u8 buf[10] = {0}; 612 int err; 613 614 LOAD_PROGRAMS(progs); 615 616 /* first check that we did not attach to device_event */ 617 618 /* inject one event */ 619 buf[0] = 1; 620 buf[1] = 42; 621 uhid_send_event(_metadata, &self->hid, buf, 6); 622 623 /* read the data from hidraw */ 624 memset(buf, 0, sizeof(buf)); 625 err = read(self->hidraw_fd, buf, sizeof(buf)); 626 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 627 ASSERT_EQ(buf[0], 1); 628 ASSERT_EQ(buf[1], 42); 629 ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test"); 630 631 /* now check that our program is preventing hid_hw_output_report() */ 632 633 buf[0] = 1; /* report ID */ 634 buf[1] = 2; 635 buf[2] = 42; 636 637 err = write(self->hidraw_fd, buf, 3); 638 ASSERT_LT(err, 0) TH_LOG("unexpected success while sending hid_hw_output_report: %d", err); 639 ASSERT_EQ(errno, 25) TH_LOG("unexpected error code while sending hid_hw_output_report: %d", 640 errno); 641 642 /* remove our bpf program and check that we can now emit commands */ 643 644 /* detach the program */ 645 detach_bpf(self); 646 647 self->hidraw_fd = open_hidraw(&self->hid); 648 ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw"); 649 650 err = write(self->hidraw_fd, buf, 3); 651 ASSERT_GE(err, 0) TH_LOG("error while sending hid_hw_output_report: %d", err); 652} 653 654/* 655 * Call hid_hw_output_report against the given uhid device, 656 * check that the program is called and can issue the call 657 * to uhid and transform the answer. 658 */ 659TEST_F(hid_bpf, test_hid_change_output_report_call) 660{ 661 const struct test_program progs[] = { 662 { .name = "hid_test_hidraw_output_report" }, 663 }; 664 __u8 buf[10] = {0}; 665 int err; 666 667 LOAD_PROGRAMS(progs); 668 669 /* emit hid_hw_output_report from hidraw */ 670 buf[0] = 1; /* report ID */ 671 buf[1] = 2; 672 buf[2] = 42; 673 674 err = write(self->hidraw_fd, buf, 10); 675 ASSERT_EQ(err, 2) TH_LOG("unexpected returned size while sending hid_hw_output_report: %d", 676 err); 677} 678 679/* 680 * Call hid_hw_output_report against the given uhid device, 681 * check that the program is not making infinite loops. 682 */ 683TEST_F(hid_bpf, test_hid_infinite_loop_output_report_call) 684{ 685 const struct test_program progs[] = { 686 { .name = "hid_test_infinite_loop_output_report" }, 687 }; 688 __u8 buf[10] = {0}; 689 int err; 690 691 LOAD_PROGRAMS(progs); 692 693 /* emit hid_hw_output_report from hidraw */ 694 buf[0] = 1; /* report ID */ 695 buf[1] = 2; 696 buf[2] = 42; 697 698 err = write(self->hidraw_fd, buf, 8); 699 ASSERT_EQ(err, 2) TH_LOG("unexpected returned size while sending hid_hw_output_report: %d", 700 err); 701} 702 703/* 704 * Attach hid_multiply_event_wq to the given uhid device, 705 * retrieve and open the matching hidraw node, 706 * inject one event in the uhid device, 707 * check that the program sees it and can add extra data 708 */ 709TEST_F(hid_bpf, test_multiply_events_wq) 710{ 711 const struct test_program progs[] = { 712 { .name = "hid_test_multiply_events_wq" }, 713 }; 714 __u8 buf[10] = {0}; 715 int err; 716 717 LOAD_PROGRAMS(progs); 718 719 /* inject one event */ 720 buf[0] = 1; 721 buf[1] = 42; 722 uhid_send_event(_metadata, &self->hid, buf, 6); 723 724 /* read the data from hidraw */ 725 memset(buf, 0, sizeof(buf)); 726 err = read(self->hidraw_fd, buf, sizeof(buf)); 727 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 728 ASSERT_EQ(buf[0], 1); 729 ASSERT_EQ(buf[1], 47); 730 731 usleep(100000); 732 733 /* read the data from hidraw */ 734 memset(buf, 0, sizeof(buf)); 735 err = read(self->hidraw_fd, buf, sizeof(buf)); 736 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 737 ASSERT_EQ(buf[0], 2); 738 ASSERT_EQ(buf[1], 3); 739} 740 741/* 742 * Attach hid_multiply_event to the given uhid device, 743 * retrieve and open the matching hidraw node, 744 * inject one event in the uhid device, 745 * check that the program sees it and can add extra data 746 */ 747TEST_F(hid_bpf, test_multiply_events) 748{ 749 const struct test_program progs[] = { 750 { .name = "hid_test_multiply_events" }, 751 }; 752 __u8 buf[10] = {0}; 753 int err; 754 755 LOAD_PROGRAMS(progs); 756 757 /* inject one event */ 758 buf[0] = 1; 759 buf[1] = 42; 760 uhid_send_event(_metadata, &self->hid, buf, 6); 761 762 /* read the data from hidraw */ 763 memset(buf, 0, sizeof(buf)); 764 err = read(self->hidraw_fd, buf, sizeof(buf)); 765 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 766 ASSERT_EQ(buf[0], 2); 767 ASSERT_EQ(buf[1], 47); 768 769 /* read the data from hidraw */ 770 memset(buf, 0, sizeof(buf)); 771 err = read(self->hidraw_fd, buf, sizeof(buf)); 772 ASSERT_EQ(err, 9) TH_LOG("read_hidraw"); 773 ASSERT_EQ(buf[0], 2); 774 ASSERT_EQ(buf[1], 52); 775} 776 777/* 778 * Call hid_bpf_input_report against the given uhid device, 779 * check that the program is not making infinite loops. 780 */ 781TEST_F(hid_bpf, test_hid_infinite_loop_input_report_call) 782{ 783 const struct test_program progs[] = { 784 { .name = "hid_test_infinite_loop_input_report" }, 785 }; 786 __u8 buf[10] = {0}; 787 int err; 788 789 LOAD_PROGRAMS(progs); 790 791 /* emit hid_hw_output_report from hidraw */ 792 buf[0] = 1; /* report ID */ 793 buf[1] = 2; 794 buf[2] = 42; 795 796 uhid_send_event(_metadata, &self->hid, buf, 6); 797 798 /* read the data from hidraw */ 799 memset(buf, 0, sizeof(buf)); 800 err = read(self->hidraw_fd, buf, sizeof(buf)); 801 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 802 ASSERT_EQ(buf[0], 1); 803 ASSERT_EQ(buf[1], 3); 804 805 /* read the data from hidraw: hid_bpf_try_input_report should work exactly one time */ 806 memset(buf, 0, sizeof(buf)); 807 err = read(self->hidraw_fd, buf, sizeof(buf)); 808 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 809 ASSERT_EQ(buf[0], 1); 810 ASSERT_EQ(buf[1], 4); 811 812 /* read the data from hidraw: there should be none */ 813 memset(buf, 0, sizeof(buf)); 814 err = read(self->hidraw_fd, buf, sizeof(buf)); 815 ASSERT_EQ(err, -1) TH_LOG("read_hidraw"); 816} 817 818/* 819 * Attach hid_insert{0,1,2} to the given uhid device, 820 * retrieve and open the matching hidraw node, 821 * inject one event in the uhid device, 822 * check that the programs have been inserted in the correct order. 823 */ 824TEST_F(hid_bpf, test_hid_attach_flags) 825{ 826 const struct test_program progs[] = { 827 { 828 .name = "hid_test_insert2", 829 .insert_head = 0, 830 }, 831 { 832 .name = "hid_test_insert1", 833 .insert_head = 1, 834 }, 835 { 836 .name = "hid_test_insert3", 837 .insert_head = 0, 838 }, 839 }; 840 __u8 buf[10] = {0}; 841 int err; 842 843 LOAD_PROGRAMS(progs); 844 845 /* inject one event */ 846 buf[0] = 1; 847 uhid_send_event(_metadata, &self->hid, buf, 6); 848 849 /* read the data from hidraw */ 850 memset(buf, 0, sizeof(buf)); 851 err = read(self->hidraw_fd, buf, sizeof(buf)); 852 ASSERT_EQ(err, 6) TH_LOG("read_hidraw"); 853 ASSERT_EQ(buf[1], 1); 854 ASSERT_EQ(buf[2], 2); 855 ASSERT_EQ(buf[3], 3); 856} 857 858/* 859 * Attach hid_rdesc_fixup to the given uhid device, 860 * retrieve and open the matching hidraw node, 861 * check that the hidraw report descriptor has been updated. 862 */ 863TEST_F(hid_bpf, test_rdesc_fixup) 864{ 865 struct hidraw_report_descriptor rpt_desc = {0}; 866 const struct test_program progs[] = { 867 { .name = "hid_rdesc_fixup" }, 868 }; 869 int err, desc_size; 870 871 LOAD_PROGRAMS(progs); 872 873 /* check that hid_rdesc_fixup() was executed */ 874 ASSERT_EQ(self->skel->data->callback2_check, 0x21); 875 876 /* read the exposed report descriptor from hidraw */ 877 err = ioctl(self->hidraw_fd, HIDIOCGRDESCSIZE, &desc_size); 878 ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGRDESCSIZE: %d", err); 879 880 /* ensure the new size of the rdesc is bigger than the old one */ 881 ASSERT_GT(desc_size, sizeof(rdesc)); 882 883 rpt_desc.size = desc_size; 884 err = ioctl(self->hidraw_fd, HIDIOCGRDESC, &rpt_desc); 885 ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGRDESC: %d", err); 886 887 ASSERT_EQ(rpt_desc.value[4], 0x42); 888} 889 890static int libbpf_print_fn(enum libbpf_print_level level, 891 const char *format, va_list args) 892{ 893 char buf[1024]; 894 895 if (level == LIBBPF_DEBUG) 896 return 0; 897 898 snprintf(buf, sizeof(buf), "# %s", format); 899 900 vfprintf(stdout, buf, args); 901 return 0; 902} 903 904int main(int argc, char **argv) 905{ 906 /* Use libbpf 1.0 API mode */ 907 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 908 libbpf_set_print(libbpf_print_fn); 909 910 return test_harness_run(argc, argv); 911}
~/
Read-only file preview.