selftests/hid: add tests for hid_hw_raw_request HID-BPF hooks

We add 3 new tests:
- first, we make sure we can prevent the raw_request to happen
- second, we make sure that we can detect that a given hidraw client
  was actually doing the request, and for that client only, call ourself
  hid_bpf_hw_request(), returning a custom value
- last, we ensure that we can not loop between hooks for
  hid_hw_raw_request() and manual calls to hid_bpf_hw_request() from that
  hook

Link: https://patch.msgid.link/20240626-hid_hw_req_bpf-v2-6-cfd60fb6c79f@kernel.org
Acked-by: Jiri Kosina <jkosina@suse.com>
Signed-off-by: Benjamin Tissoires <bentiss@kernel.org>

diff --git a/tools/testing/selftests/hid/hid_bpf.c b/tools/testing/selftests/hid/hid_bpf.c
index 45e173db35bdd71b846a07739ba66e2e089eff11..f97d56337d8a7855da4f332320837073361c8648 100644 (file)
--- a/tools/testing/selftests/hid/hid_bpf.c
+++ b/tools/testing/selftests/hid/hid_bpf.c
@@ -470,6 +470,11 @@ static void detach_bpf(FIXTURE_DATA(hid_bpf) * self)
                close(self->hidraw_fd);
        self->hidraw_fd = 0;
 
+       if (!self->skel)
+               return;
+
+       hid__detach(self->skel);
+
        for (i = 0; i < ARRAY_SIZE(self->hid_links); i++) {
                if (self->hid_links[i])
                        bpf_link__destroy(self->hid_links[i]);
@@ -575,6 +580,8 @@ static void load_programs(const struct test_program programs[],
                                                         programs[i].name + 4);
        }
 
+       hid__attach(self->skel);
+
        self->hidraw_fd = open_hidraw(self->dev_id);
        ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw");
 }
@@ -919,6 +926,108 @@ TEST_F(hid_bpf, test_hid_user_raw_request_call)
        ASSERT_EQ(args.data[1], 2);
 }
 
+/*
+ * Call hid_hw_raw_request against the given uhid device,
+ * check that the program is called and prevents the
+ * call to uhid.
+ */
+TEST_F(hid_bpf, test_hid_filter_raw_request_call)
+{
+       const struct test_program progs[] = {
+               { .name = "hid_test_filter_raw_request" },
+       };
+       __u8 buf[10] = {0};
+       int err;
+
+       LOAD_PROGRAMS(progs);
+
+       /* first check that we did not attach to device_event */
+
+       /* inject one event */
+       buf[0] = 1;
+       buf[1] = 42;
+       uhid_send_event(_metadata, self->uhid_fd, buf, 6);
+
+       /* read the data from hidraw */
+       memset(buf, 0, sizeof(buf));
+       err = read(self->hidraw_fd, buf, sizeof(buf));
+       ASSERT_EQ(err, 6) TH_LOG("read_hidraw");
+       ASSERT_EQ(buf[0], 1);
+       ASSERT_EQ(buf[1], 42);
+       ASSERT_EQ(buf[2], 0) TH_LOG("leftovers_from_previous_test");
+
+       /* now check that our program is preventing hid_hw_raw_request() */
+
+       /* emit hid_hw_raw_request from hidraw */
+       /* Get Feature */
+       memset(buf, 0, sizeof(buf));
+       buf[0] = 0x1; /* Report Number */
+       err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);
+       ASSERT_LT(err, 0) TH_LOG("unexpected success while reading HIDIOCGFEATURE: %d", err);
+       ASSERT_EQ(errno, 20) TH_LOG("unexpected error code while reading HIDIOCGFEATURE: %d",
+                                   errno);
+
+       /* remove our bpf program and check that we can now emit commands */
+
+       /* detach the program */
+       detach_bpf(self);
+
+       self->hidraw_fd = open_hidraw(self->dev_id);
+       ASSERT_GE(self->hidraw_fd, 0) TH_LOG("open_hidraw");
+
+       err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);
+       ASSERT_GE(err, 0) TH_LOG("error while reading HIDIOCGFEATURE: %d", err);
+}
+
+/*
+ * Call hid_hw_raw_request against the given uhid device,
+ * check that the program is called and can issue the call
+ * to uhid and transform the answer.
+ */
+TEST_F(hid_bpf, test_hid_change_raw_request_call)
+{
+       const struct test_program progs[] = {
+               { .name = "hid_test_hidraw_raw_request" },
+       };
+       __u8 buf[10] = {0};
+       int err;
+
+       LOAD_PROGRAMS(progs);
+
+       /* emit hid_hw_raw_request from hidraw */
+       /* Get Feature */
+       memset(buf, 0, sizeof(buf));
+       buf[0] = 0x1; /* Report Number */
+       err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);
+       ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err);
+
+       ASSERT_EQ(buf[0], 2);
+       ASSERT_EQ(buf[1], 3);
+       ASSERT_EQ(buf[2], 4);
+}
+
+/*
+ * Call hid_hw_raw_request against the given uhid device,
+ * check that the program is not making infinite loops.
+ */
+TEST_F(hid_bpf, test_hid_infinite_loop_raw_request_call)
+{
+       const struct test_program progs[] = {
+               { .name = "hid_test_infinite_loop_raw_request" },
+       };
+       __u8 buf[10] = {0};
+       int err;
+
+       LOAD_PROGRAMS(progs);
+
+       /* emit hid_hw_raw_request from hidraw */
+       /* Get Feature */
+       memset(buf, 0, sizeof(buf));
+       buf[0] = 0x1; /* Report Number */
+       err = ioctl(self->hidraw_fd, HIDIOCGFEATURE(sizeof(buf)), buf);
+       ASSERT_EQ(err, 3) TH_LOG("unexpected returned size while reading HIDIOCGFEATURE: %d", err);
+}
+
 /*
  * Attach hid_insert{0,1,2} to the given uhid device,
  * retrieve and open the matching hidraw node,

diff --git a/tools/testing/selftests/hid/progs/hid.c b/tools/testing/selftests/hid/progs/hid.c
index 2e7e5a736dc6de278059df5a84597e1a18222d07..0ad452fcca58532830e2b06b0d24c3ba76190ee9 100644 (file)
--- a/tools/testing/selftests/hid/progs/hid.c
+++ b/tools/testing/selftests/hid/progs/hid.c
@@ -306,3 +306,82 @@ SEC(".struct_ops.link")
 struct hid_bpf_ops test_insert3 = {
        .hid_device_event = (void *)hid_test_insert3,
 };
+
+SEC("?struct_ops/hid_hw_request")
+int BPF_PROG(hid_test_filter_raw_request, struct hid_bpf_ctx *hctx, unsigned char reportnum,
+            enum hid_report_type rtype, enum hid_class_request reqtype, __u64 source)
+{
+       return -20;
+}
+
+SEC(".struct_ops.link")
+struct hid_bpf_ops test_filter_raw_request = {
+       .hid_hw_request = (void *)hid_test_filter_raw_request,
+};
+
+static struct file *current_file;
+
+SEC("fentry/hidraw_open")
+int BPF_PROG(hidraw_open, struct inode *inode, struct file *file)
+{
+       current_file = file;
+       return 0;
+}
+
+SEC("?struct_ops.s/hid_hw_request")
+int BPF_PROG(hid_test_hidraw_raw_request, struct hid_bpf_ctx *hctx, unsigned char reportnum,
+            enum hid_report_type rtype, enum hid_class_request reqtype, __u64 source)
+{
+       __u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 3 /* size */);
+       int ret;
+
+       if (!data)
+               return 0; /* EPERM check */
+
+       /* check if the incoming request comes from our hidraw operation */
+       if (source == (__u64)current_file) {
+               data[0] = reportnum;
+
+               ret = hid_bpf_hw_request(hctx, data, 2, rtype, reqtype);
+               if (ret != 2)
+                       return -1;
+               data[0] = reportnum + 1;
+               data[1] = reportnum + 2;
+               data[2] = reportnum + 3;
+               return 3;
+       }
+
+       return 0;
+}
+
+SEC(".struct_ops.link")
+struct hid_bpf_ops test_hidraw_raw_request = {
+       .hid_hw_request = (void *)hid_test_hidraw_raw_request,
+};
+
+SEC("?struct_ops.s/hid_hw_request")
+int BPF_PROG(hid_test_infinite_loop_raw_request, struct hid_bpf_ctx *hctx, unsigned char reportnum,
+            enum hid_report_type rtype, enum hid_class_request reqtype, __u64 source)
+{
+       __u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 3 /* size */);
+       int ret;
+
+       if (!data)
+               return 0; /* EPERM check */
+
+       /* always forward the request as-is to the device, hid-bpf should prevent
+        * infinite loops.
+        */
+       data[0] = reportnum;
+
+       ret = hid_bpf_hw_request(hctx, data, 2, rtype, reqtype);
+       if (ret == 2)
+               return 3;
+
+       return 0;
+}
+
+SEC(".struct_ops.link")
+struct hid_bpf_ops test_infinite_loop_raw_request = {
+       .hid_hw_request = (void *)hid_test_infinite_loop_raw_request,
+};