/* SPDX-License-Identifier: GPL-2.0+ */ #ifndef __HID_BPF_H #define __HID_BPF_H #include <linux/bpf.h> #include <linux/mutex.h> #include <linux/srcu.h> #include <uapi/linux/hid.h> struct hid_device; /* * The following is the user facing HID BPF API. * * Extra care should be taken when editing this part, as * it might break existing out of the tree bpf programs. */ /** * struct hid_bpf_ctx - User accessible data for all HID programs * * ``data`` is not directly accessible from the context. We need to issue * a call to hid_bpf_get_data() in order to get a pointer to that field. * * @hid: the &struct hid_device representing the device itself * @allocated_size: Allocated size of data. * * This is how much memory is available and can be requested * by the HID program. * Note that for ``HID_BPF_RDESC_FIXUP``, that memory is set to * ``4096`` (4 KB) * @size: Valid data in the data field. * * Programs can get the available valid size in data by fetching this field. * Programs can also change this value by returning a positive number in the * program. * To discard the event, return a negative error code. * * ``size`` must always be less or equal than ``allocated_size`` (it is enforced * once all BPF programs have been run). * @retval: Return value of the previous program. * * ``hid`` and ``allocated_size`` are read-only, ``size`` and ``retval`` are read-write. */ struct hid_bpf_ctx { … }; /* * Below is HID internal */ #define HID_BPF_MAX_PROGS_PER_DEV … #define HID_BPF_FLAG_MASK … struct hid_report_enum; struct hid_ops { … }; extern struct hid_ops *hid_ops; /** * struct hid_bpf_ops - A BPF struct_ops of callbacks allowing to attach HID-BPF * programs to a HID device * @hid_id: the HID uniq ID to attach to. This is writeable before ``load()``, and * cannot be changed after * @flags: flags used while attaching the struct_ops to the device. Currently only * available value is %0 or ``BPF_F_BEFORE``. * Writeable only before ``load()`` */ struct hid_bpf_ops { … }; /* stored in each device */ struct hid_bpf { … }; #ifdef CONFIG_HID_BPF u8 *dispatch_hid_bpf_device_event(struct hid_device *hid, enum hid_report_type type, u8 *data, u32 *size, int interrupt, u64 source, bool from_bpf); int dispatch_hid_bpf_raw_requests(struct hid_device *hdev, unsigned char reportnum, __u8 *buf, u32 size, enum hid_report_type rtype, enum hid_class_request reqtype, u64 source, bool from_bpf); int dispatch_hid_bpf_output_report(struct hid_device *hdev, __u8 *buf, u32 size, u64 source, bool from_bpf); int hid_bpf_connect_device(struct hid_device *hdev); void hid_bpf_disconnect_device(struct hid_device *hdev); void hid_bpf_destroy_device(struct hid_device *hid); int hid_bpf_device_init(struct hid_device *hid); u8 *call_hid_bpf_rdesc_fixup(struct hid_device *hdev, const u8 *rdesc, unsigned int *size); #else /* CONFIG_HID_BPF */ static inline u8 *dispatch_hid_bpf_device_event(struct hid_device *hid, enum hid_report_type type, u8 *data, u32 *size, int interrupt, u64 source, bool from_bpf) { return data; } static inline int dispatch_hid_bpf_raw_requests(struct hid_device *hdev, unsigned char reportnum, u8 *buf, u32 size, enum hid_report_type rtype, enum hid_class_request reqtype, u64 source, bool from_bpf) { return 0; } static inline int dispatch_hid_bpf_output_report(struct hid_device *hdev, __u8 *buf, u32 size, u64 source, bool from_bpf) { return 0; } static inline int hid_bpf_connect_device(struct hid_device *hdev) { return 0; } static inline void hid_bpf_disconnect_device(struct hid_device *hdev) {} static inline void hid_bpf_destroy_device(struct hid_device *hid) {} static inline int hid_bpf_device_init(struct hid_device *hid) { return 0; } /* * This specialized allocator has to be a macro for its allocations to be * accounted separately (to have a separate alloc_tag). The typecast is * intentional to enforce typesafety. */ #define call_hid_bpf_rdesc_fixup … #endif /* CONFIG_HID_BPF */ #endif /* __HID_BPF_H */
Codebase Browser
linux