Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/* SPDX-License-Identifier: GPL-2.0+ */
2
3#ifndef __HID_BPF_H
4#define __HID_BPF_H
5
6#include <linux/bpf.h>
7#include <linux/mutex.h>
8#include <linux/srcu.h>
9#include <uapi/linux/hid.h>
10
11struct hid_device;
12
13/*
14 * The following is the user facing HID BPF API.
15 *
16 * Extra care should be taken when editing this part, as
17 * it might break existing out of the tree bpf programs.
18 */
19
20/**
21 * struct hid_bpf_ctx - User accessible data for all HID programs
22 *
23 * ``data`` is not directly accessible from the context. We need to issue
24 * a call to hid_bpf_get_data() in order to get a pointer to that field.
25 *
26 * @hid: the &struct hid_device representing the device itself
27 * @allocated_size: Allocated size of data.
28 *
29 * This is how much memory is available and can be requested
30 * by the HID program.
31 * Note that for ``HID_BPF_RDESC_FIXUP``, that memory is set to
32 * ``4096`` (4 KB)
33 * @size: Valid data in the data field.
34 *
35 * Programs can get the available valid size in data by fetching this field.
36 * Programs can also change this value by returning a positive number in the
37 * program.
38 * To discard the event, return a negative error code.
39 *
40 * ``size`` must always be less or equal than ``allocated_size`` (it is enforced
41 * once all BPF programs have been run).
42 * @retval: Return value of the previous program.
43 *
44 * ``hid`` and ``allocated_size`` are read-only, ``size`` and ``retval`` are read-write.
45 */
46struct hid_bpf_ctx {
47 struct hid_device *hid;
48 __u32 allocated_size;
49 union {
50 __s32 retval;
51 __s32 size;
52 };
53};
54
55/*
56 * Below is HID internal
57 */
58
59#define HID_BPF_MAX_PROGS_PER_DEV 64
60#define HID_BPF_FLAG_MASK (((HID_BPF_FLAG_MAX - 1) << 1) - 1)
61
62
63struct hid_report_enum;
64
65struct hid_ops {
66 struct hid_report *(*hid_get_report)(struct hid_report_enum *report_enum, const u8 *data);
67 int (*hid_hw_raw_request)(struct hid_device *hdev,
68 unsigned char reportnum, __u8 *buf,
69 size_t len, enum hid_report_type rtype,
70 enum hid_class_request reqtype,
71 u64 source, bool from_bpf);
72 int (*hid_hw_output_report)(struct hid_device *hdev, __u8 *buf, size_t len,
73 u64 source, bool from_bpf);
74 int (*hid_input_report)(struct hid_device *hid, enum hid_report_type type,
75 u8 *data, u32 size, int interrupt, u64 source, bool from_bpf,
76 bool lock_already_taken);
77 struct module *owner;
78 const struct bus_type *bus_type;
79};
80
81extern const struct hid_ops *hid_ops;
82
83/**
84 * struct hid_bpf_ops - A BPF struct_ops of callbacks allowing to attach HID-BPF
85 * programs to a HID device
86 * @hid_id: the HID uniq ID to attach to. This is writeable before ``load()``, and
87 * cannot be changed after
88 * @flags: flags used while attaching the struct_ops to the device. Currently only
89 * available value is %0 or ``BPF_F_BEFORE``.
90 * Writeable only before ``load()``
91 */
92struct hid_bpf_ops {
93 /* hid_id needs to stay first so we can easily change it
94 * from userspace.
95 */
96 int hid_id;
97 u32 flags;
98
99 /* private: do not show up in the docs */
100 struct list_head list;
101
102 /* public: rest should show up in the docs */
103
104 /**
105 * @hid_device_event: called whenever an event is coming in from the device
106 *
107 * It has the following arguments:
108 *
109 * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx
110 *
111 * Return: %0 on success and keep processing; a positive
112 * value to change the incoming size buffer; a negative
113 * error code to interrupt the processing of this event
114 *
115 * Context: Interrupt context.
116 */
117 int (*hid_device_event)(struct hid_bpf_ctx *ctx, enum hid_report_type report_type,
118 u64 source);
119
120 /**
121 * @hid_rdesc_fixup: called when the probe function parses the report descriptor
122 * of the HID device
123 *
124 * It has the following arguments:
125 *
126 * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx
127 *
128 * Return: %0 on success and keep processing; a positive
129 * value to change the incoming size buffer; a negative
130 * error code to interrupt the processing of this device
131 */
132 int (*hid_rdesc_fixup)(struct hid_bpf_ctx *ctx);
133
134 /**
135 * @hid_hw_request: called whenever a hid_hw_raw_request() call is emitted
136 * on the HID device
137 *
138 * It has the following arguments:
139 *
140 * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx
141 *
142 * ``reportnum``: the report number, as in hid_hw_raw_request()
143 *
144 * ``rtype``: the report type (``HID_INPUT_REPORT``, ``HID_FEATURE_REPORT``,
145 * ``HID_OUTPUT_REPORT``)
146 *
147 * ``reqtype``: the request
148 *
149 * ``source``: a u64 referring to a uniq but identifiable source. If %0, the
150 * kernel itself emitted that call. For hidraw, ``source`` is set
151 * to the associated ``struct file *``.
152 *
153 * Return: %0 to keep processing the request by hid-core; any other value
154 * stops hid-core from processing that event. A positive value should be
155 * returned with the number of bytes returned in the incoming buffer; a
156 * negative error code interrupts the processing of this call.
157 */
158 int (*hid_hw_request)(struct hid_bpf_ctx *ctx, unsigned char reportnum,
159 enum hid_report_type rtype, enum hid_class_request reqtype,
160 u64 source);
161
162 /**
163 * @hid_hw_output_report: called whenever a hid_hw_output_report() call is emitted
164 * on the HID device
165 *
166 * It has the following arguments:
167 *
168 * ``ctx``: The HID-BPF context as &struct hid_bpf_ctx
169 *
170 * ``source``: a u64 referring to a uniq but identifiable source. If %0, the
171 * kernel itself emitted that call. For hidraw, ``source`` is set
172 * to the associated ``struct file *``.
173 *
174 * Return: %0 to keep processing the request by hid-core; any other value
175 * stops hid-core from processing that event. A positive value should be
176 * returned with the number of bytes written to the device; a negative error
177 * code interrupts the processing of this call.
178 */
179 int (*hid_hw_output_report)(struct hid_bpf_ctx *ctx, u64 source);
180
181
182 /* private: do not show up in the docs */
183 struct hid_device *hdev;
184};
185
186/* stored in each device */
187struct hid_bpf {
188 u8 *device_data; /* allocated when a bpf program of type
189 * SEC(f.../hid_bpf_device_event) has been attached
190 * to this HID device
191 */
192 u32 allocated_data;
193 bool destroyed; /* prevents the assignment of any progs */
194
195 struct hid_bpf_ops *rdesc_ops;
196 struct list_head prog_list;
197 struct mutex prog_list_lock; /* protects prog_list update */
198 struct srcu_struct srcu; /* protects prog_list read-only access */
199};
200
201#ifdef CONFIG_HID_BPF
202u8 *dispatch_hid_bpf_device_event(struct hid_device *hid, enum hid_report_type type, u8 *data,
203 u32 *size, int interrupt, u64 source, bool from_bpf);
204int dispatch_hid_bpf_raw_requests(struct hid_device *hdev,
205 unsigned char reportnum, __u8 *buf,
206 u32 size, enum hid_report_type rtype,
207 enum hid_class_request reqtype,
208 u64 source, bool from_bpf);
209int dispatch_hid_bpf_output_report(struct hid_device *hdev, __u8 *buf, u32 size,
210 u64 source, bool from_bpf);
211int hid_bpf_connect_device(struct hid_device *hdev);
212void hid_bpf_disconnect_device(struct hid_device *hdev);
213void hid_bpf_destroy_device(struct hid_device *hid);
214int hid_bpf_device_init(struct hid_device *hid);
215const u8 *call_hid_bpf_rdesc_fixup(struct hid_device *hdev, const u8 *rdesc, unsigned int *size);
216#else /* CONFIG_HID_BPF */
217static inline u8 *dispatch_hid_bpf_device_event(struct hid_device *hid, enum hid_report_type type,
218 u8 *data, u32 *size, int interrupt,
219 u64 source, bool from_bpf) { return data; }
220static inline int dispatch_hid_bpf_raw_requests(struct hid_device *hdev,
221 unsigned char reportnum, u8 *buf,
222 u32 size, enum hid_report_type rtype,
223 enum hid_class_request reqtype,
224 u64 source, bool from_bpf) { return 0; }
225static inline int dispatch_hid_bpf_output_report(struct hid_device *hdev, __u8 *buf, u32 size,
226 u64 source, bool from_bpf) { return 0; }
227static inline int hid_bpf_connect_device(struct hid_device *hdev) { return 0; }
228static inline void hid_bpf_disconnect_device(struct hid_device *hdev) {}
229static inline void hid_bpf_destroy_device(struct hid_device *hid) {}
230static inline int hid_bpf_device_init(struct hid_device *hid) { return 0; }
231static inline const u8 *call_hid_bpf_rdesc_fixup(struct hid_device *hdev, const u8 *rdesc,
232 unsigned int *size) { return rdesc; }
233
234#endif /* CONFIG_HID_BPF */
235
236#endif /* __HID_BPF_H */