Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241/* 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 { struct hid_device *hid; __u32 allocated_size; union { __s32 retval; __s32 size; };};
/* * Below is HID internal */
#define HID_BPF_MAX_PROGS_PER_DEV 64#define HID_BPF_FLAG_MASK (((HID_BPF_FLAG_MAX - 1) << 1) - 1)
struct hid_report_enum;
struct hid_ops { struct hid_report *(*hid_get_report)(struct hid_report_enum *report_enum, const u8 *data); 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); int (*hid_hw_output_report)(struct hid_device *hdev, __u8 *buf, size_t len, u64 source, bool from_bpf); int (*hid_input_report)(struct hid_device *hid, enum hid_report_type type, u8 *data, size_t bufsize, u32 size, int interrupt, u64 source, bool from_bpf, bool lock_already_taken); struct module *owner; const struct bus_type *bus_type;};
extern const 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 { /* hid_id needs to stay first so we can easily change it * from userspace. */ int hid_id; u32 flags;
/* private: do not show up in the docs */ struct list_head list;
/* public: rest should show up in the docs */
/** * @hid_device_event: called whenever an event is coming in from the device * * It has the following arguments: * * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx * * Return: %0 on success and keep processing; a positive * value to change the incoming size buffer; a negative * error code to interrupt the processing of this event * * Context: Interrupt context. */ int (*hid_device_event)(struct hid_bpf_ctx *ctx, enum hid_report_type report_type, u64 source);
/** * @hid_rdesc_fixup: called when the probe function parses the report descriptor * of the HID device * * It has the following arguments: * * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx * * Return: %0 on success and keep processing; a positive * value to change the incoming size buffer; a negative * error code to interrupt the processing of this device */ int (*hid_rdesc_fixup)(struct hid_bpf_ctx *ctx);
/** * @hid_hw_request: called whenever a hid_hw_raw_request() call is emitted * on the HID device * * It has the following arguments: * * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx * * ``reportnum``: the report number, as in hid_hw_raw_request() * * ``rtype``: the report type (``HID_INPUT_REPORT``, ``HID_FEATURE_REPORT``, * ``HID_OUTPUT_REPORT``) * * ``reqtype``: the request * * ``source``: a u64 referring to a uniq but identifiable source. If %0, the * kernel itself emitted that call. For hidraw, ``source`` is set * to the associated ``struct file *``. * * Return: %0 to keep processing the request by hid-core; any other value * stops hid-core from processing that event. A positive value should be * returned with the number of bytes returned in the incoming buffer; a * negative error code interrupts the processing of this call. */ int (*hid_hw_request)(struct hid_bpf_ctx *ctx, unsigned char reportnum, enum hid_report_type rtype, enum hid_class_request reqtype, u64 source);
/** * @hid_hw_output_report: called whenever a hid_hw_output_report() call is emitted * on the HID device * * It has the following arguments: * * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx * * ``source``: a u64 referring to a uniq but identifiable source. If %0, the * kernel itself emitted that call. For hidraw, ``source`` is set * to the associated ``struct file *``. * * Return: %0 to keep processing the request by hid-core; any other value * stops hid-core from processing that event. A positive value should be * returned with the number of bytes written to the device; a negative error * code interrupts the processing of this call. */ int (*hid_hw_output_report)(struct hid_bpf_ctx *ctx, u64 source);
/* private: do not show up in the docs */ struct hid_device *hdev;};
/* stored in each device */struct hid_bpf { u8 *device_data; /* allocated when a bpf program of type * SEC(f.../hid_bpf_device_event) has been attached * to this HID device */ u32 allocated_data; bool destroyed; /* prevents the assignment of any progs */
struct hid_bpf_ops *rdesc_ops; struct list_head prog_list; struct mutex prog_list_lock; /* protects prog_list update */ struct srcu_struct srcu; /* protects prog_list read-only access */};
#ifdef CONFIG_HID_BPFu8 *dispatch_hid_bpf_device_event(struct hid_device *hid, enum hid_report_type type, u8 *data, size_t *buf_size, 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);const 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, size_t *buf_size, 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; }static inline const u8 *call_hid_bpf_rdesc_fixup(struct hid_device *hdev, const u8 *rdesc, unsigned int *size) { return rdesc; }
#endif /* CONFIG_HID_BPF */
#endif /* __HID_BPF_H */