HID: bpf: fix gcc warning and unify __u64 into u64

I've got multiple reports of:
error: cast from pointer to integer of different size
[-Werror=pointer-to-int-cast].

Let's use the same trick than kernel/bpf/helpers.c to shut up that warning.

Even if we were on an architecture with addresses on more than 64 bits,
this isn't much of an issue as the address is not used as a pointer,
but as an hash and the caller is not supposed to go back to the kernel
address ever.

And while we change those, make sure we use u64 instead of __u64 for
consistency

Reported-by: Stephen Rothwell <sfr@canb.auug.org.au>
Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202406280633.OPB5uIFj-lkp@intel.com/
Closes: https://lore.kernel.org/oe-kbuild-all/202406282304.UydSVncq-lkp@intel.com/
Closes: https://lore.kernel.org/oe-kbuild-all/202406282242.Fk738zzy-lkp@intel.com/
Reported-by: Mirsad Todorovac <mtodorovac69@gmail.com>
Fixes: 67eccf151d76 ("HID: add source argument to HID low level functions")
Link: https://patch.msgid.link/20240701-fix-cki-v2-2-20564e2e1393@kernel.org
Signed-off-by: Benjamin Tissoires <bentiss@kernel.org>

diff --git a/drivers/hid/bpf/hid_bpf_dispatch.c b/drivers/hid/bpf/hid_bpf_dispatch.c
index 23daf94510bb2761482d09797434fda663fecb2c..a36e680399fea8460850daeded22540f9fc0a556 100644 (file)
--- a/drivers/hid/bpf/hid_bpf_dispatch.c
+++ b/drivers/hid/bpf/hid_bpf_dispatch.c
@@ -440,7 +440,7 @@ hid_bpf_hw_request(struct hid_bpf_ctx *ctx, __u8 *buf, size_t buf__sz,
                                              size,
                                              rtype,
                                              reqtype,
-                                             (__u64)ctx,
+                                             (u64)(long)ctx,
                                              true); /* prevent infinite recursions */
 
        if (ret > 0)
@@ -483,7 +483,7 @@ hid_bpf_hw_output_report(struct hid_bpf_ctx *ctx, __u8 *buf, size_t buf__sz)
        if (!dma_data)
                return -ENOMEM;
 
-       ret = hid_ops->hid_hw_output_report(hdev, dma_data, size, (__u64)ctx, true);
+       ret = hid_ops->hid_hw_output_report(hdev, dma_data, size, (u64)(long)ctx, true);
 
        kfree(dma_data);
        return ret;
@@ -505,7 +505,7 @@ __hid_bpf_input_report(struct hid_bpf_ctx *ctx, enum hid_report_type type, u8 *b
        if (ret)
                return ret;
 
-       return hid_ops->hid_input_report(ctx->hid, type, buf, size, 0, (__u64)ctx, true,
+       return hid_ops->hid_input_report(ctx->hid, type, buf, size, 0, (u64)(long)ctx, true,
                                         lock_already_taken);
 }
 

diff --git a/drivers/hid/bpf/hid_bpf_struct_ops.c b/drivers/hid/bpf/hid_bpf_struct_ops.c
index 37d2f8e2413a91630aa8acdddb925b265e7a614a..b03b44ad3458fe4a63ba3f8540128ea9cda490cf 100644 (file)
--- a/drivers/hid/bpf/hid_bpf_struct_ops.c
+++ b/drivers/hid/bpf/hid_bpf_struct_ops.c
@@ -261,7 +261,7 @@ static void hid_bpf_unreg(void *kdata)
        hid_put_device(hdev);
 }
 
-static int __hid_bpf_device_event(struct hid_bpf_ctx *ctx, enum hid_report_type type, __u64 source)
+static int __hid_bpf_device_event(struct hid_bpf_ctx *ctx, enum hid_report_type type, u64 source)
 {
        return 0;
 }

diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 52a75afe3e7d6a5e9b61b280dbd26316e026f2a2..0f797dab975b9af131b470b659c9792ec2013237 100644 (file)
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -2412,7 +2412,7 @@ int __hid_hw_raw_request(struct hid_device *hdev,
                         unsigned char reportnum, __u8 *buf,
                         size_t len, enum hid_report_type rtype,
                         enum hid_class_request reqtype,
-                        __u64 source, bool from_bpf)
+                        u64 source, bool from_bpf)
 {
        unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE;
        int ret;
@@ -2454,7 +2454,7 @@ int hid_hw_raw_request(struct hid_device *hdev,
 }
 EXPORT_SYMBOL_GPL(hid_hw_raw_request);
 
-int __hid_hw_output_report(struct hid_device *hdev, __u8 *buf, size_t len, __u64 source,
+int __hid_hw_output_report(struct hid_device *hdev, __u8 *buf, size_t len, u64 source,
                           bool from_bpf)
 {
        unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE;

diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index c2396916cdaa7ee3fc59818b87b53ea7e21e015b..716294e40e8ac4a581dc7da71f65b7b9f789fd23 100644 (file)
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -140,7 +140,7 @@ static ssize_t hidraw_send_report(struct file *file, const char __user *buffer,
 
        if ((report_type == HID_OUTPUT_REPORT) &&
            !(dev->quirks & HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP)) {
-               ret = __hid_hw_output_report(dev, buf, count, (__u64)file, false);
+               ret = __hid_hw_output_report(dev, buf, count, (u64)(long)file, false);
                /*
                 * compatibility with old implementation of USB-HID and I2C-HID:
                 * if the device does not support receiving output reports,
@@ -151,7 +151,7 @@ static ssize_t hidraw_send_report(struct file *file, const char __user *buffer,
        }
 
        ret = __hid_hw_raw_request(dev, buf[0], buf, count, report_type,
-                                  HID_REQ_SET_REPORT, (__u64)file, false);
+                                  HID_REQ_SET_REPORT, (u64)(long)file, false);
 
 out_free:
        kfree(buf);
@@ -228,7 +228,7 @@ static ssize_t hidraw_get_report(struct file *file, char __user *buffer, size_t
        }
 
        ret = __hid_hw_raw_request(dev, report_number, buf, count, report_type,
-                                  HID_REQ_GET_REPORT, (__u64)file, false);
+                                  HID_REQ_GET_REPORT, (u64)(long)file, false);
 
        if (ret < 0)
                goto out_free;

diff --git a/include/linux/hid_bpf.h b/include/linux/hid_bpf.h
index 93546ee7677a3c2f84bdea8dead85ff684d20c60..3f6584014311a4a47c3998e718083fbcf5fb6ca8 100644 (file)
--- a/include/linux/hid_bpf.h
+++ b/include/linux/hid_bpf.h
@@ -68,9 +68,9 @@ struct hid_ops {
                                  unsigned char reportnum, __u8 *buf,
                                  size_t len, enum hid_report_type rtype,
                                  enum hid_class_request reqtype,
-                                 __u64 source, bool from_bpf);
+                                 u64 source, bool from_bpf);
        int (*hid_hw_output_report)(struct hid_device *hdev, __u8 *buf, size_t len,
-                                   __u64 source, bool from_bpf);
+                                   u64 source, bool from_bpf);
        int (*hid_input_report)(struct hid_device *hid, enum hid_report_type type,
                                u8 *data, u32 size, int interrupt, u64 source, bool from_bpf,
                                bool lock_already_taken);
@@ -115,7 +115,7 @@ struct hid_bpf_ops {
         * Context: Interrupt context.
         */
        int (*hid_device_event)(struct hid_bpf_ctx *ctx, enum hid_report_type report_type,
-                               __u64 source);
+                               u64 source);
 
        /**
         * @hid_rdesc_fixup: called when the probe function parses the report descriptor