1 /* SPDX-License-Identifier: GPL-2.0+ */ 1
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
11 struct hid_device;
12
13 /*
14 * The following is the user facing HID BPF AP
15 *
16 * Extra care should be taken when editing thi
17 * it might break existing out of the tree bpf
18 */
19
20 /**
21 * struct hid_bpf_ctx - User accessible data f
22 *
23 * ``data`` is not directly accessible from th
24 * a call to hid_bpf_get_data() in order to ge
25 *
26 * @hid: the &struct hid_device representing t
27 * @allocated_size: Allocated size of data.
28 *
29 * This is how much memory is
30 * by the HID program.
31 * Note that for ``HID_BPF_RD
32 * ``4096`` (4 KB)
33 * @size: Valid data in the data field.
34 *
35 * Programs can get the available valid
36 * Programs can also change this value
37 * program.
38 * To discard the event, return a negat
39 *
40 * ``size`` must always be less or equa
41 * once all BPF programs have been run)
42 * @retval: Return value of the previous progr
43 *
44 * ``hid`` and ``allocated_size`` are read-onl
45 */
46 struct 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
61
62
63 struct hid_report_enum;
64
65 struct hid_ops {
66 struct hid_report *(*hid_get_report)(s
67 int (*hid_hw_raw_request)(struct hid_d
68 unsigned cha
69 size_t len,
70 enum hid_cla
71 u64 source,
72 int (*hid_hw_output_report)(struct hid
73 u64 source
74 int (*hid_input_report)(struct hid_dev
75 u8 *data, u32
76 bool lock_alre
77 struct module *owner;
78 const struct bus_type *bus_type;
79 };
80
81 extern struct hid_ops *hid_ops;
82
83 /**
84 * struct hid_bpf_ops - A BPF struct_ops of ca
85 * programs to a HID devi
86 * @hid_id: the HID uniq ID to attach to. This
87 * cannot be changed after
88 * @flags: flags used while attaching the stru
89 * available value is %0 or ``BPF_F_BE
90 * Writeable only before ``load()``
91 */
92 struct hid_bpf_ops {
93 /* hid_id needs to stay first so we ca
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
103
104 /**
105 * @hid_device_event: called whenever
106 *
107 * It has the following arguments:
108 *
109 * ``ctx``: The HID-BPF context as &st
110 *
111 * Return: %0 on success and keep proc
112 * value to change the incoming size b
113 * error code to interrupt the process
114 *
115 * Context: Interrupt context.
116 */
117 int (*hid_device_event)(struct hid_bpf
118 u64 source);
119
120 /**
121 * @hid_rdesc_fixup: called when the p
122 * of the HID device
123 *
124 * It has the following arguments:
125 *
126 * ``ctx``: The HID-BPF context as &st
127 *
128 * Return: %0 on success and keep proc
129 * value to change the incoming size b
130 * error code to interrupt the process
131 */
132 int (*hid_rdesc_fixup)(struct hid_bpf_
133
134 /**
135 * @hid_hw_request: called whenever a
136 * on the HID device
137 *
138 * It has the following arguments:
139 *
140 * ``ctx``: The HID-BPF context as &st
141 *
142 * ``reportnum``: the report number, a
143 *
144 * ``rtype``: the report type (``HID_I
145 * ``HID_OUTPUT_REPORT``)
146 *
147 * ``reqtype``: the request
148 *
149 * ``source``: a u64 referring to a un
150 * kernel itself emitted that call. Fo
151 * to the associated ``struct file *``
152 *
153 * Return: %0 to keep processing the r
154 * stops hid-core from processing that
155 * returned with the number of bytes r
156 * negative error code interrupts the
157 */
158 int (*hid_hw_request)(struct hid_bpf_c
159 enum hid_report
160 u64 source);
161
162 /**
163 * @hid_hw_output_report: called whene
164 * on the HID device
165 *
166 * It has the following arguments:
167 *
168 * ``ctx``: The HID-BPF context as &st
169 *
170 * ``source``: a u64 referring to a un
171 * kernel itself emitted that call. Fo
172 * to the associated ``struct file *``
173 *
174 * Return: %0 to keep processing the r
175 * stops hid-core from processing that
176 * returned with the number of bytes w
177 * code interrupts the processing of t
178 */
179 int (*hid_hw_output_report)(struct hid
180
181
182 /* private: do not show up in the docs
183 struct hid_device *hdev;
184 };
185
186 /* stored in each device */
187 struct hid_bpf {
188 u8 *device_data; /* all
189 * SEC
190 * to
191 */
192 u32 allocated_data;
193 bool destroyed; /* pre
194
195 struct hid_bpf_ops *rdesc_ops;
196 struct list_head prog_list;
197 struct mutex prog_list_lock; /* pro
198 struct srcu_struct srcu; /* pro
199 };
200
201 #ifdef CONFIG_HID_BPF
202 u8 *dispatch_hid_bpf_device_event(struct hid_d
203 u32 *size, i
204 int dispatch_hid_bpf_raw_requests(struct hid_d
205 unsigned cha
206 u32 size, en
207 enum hid_cla
208 u64 source,
209 int dispatch_hid_bpf_output_report(struct hid_
210 u64 source,
211 int hid_bpf_connect_device(struct hid_device *
212 void hid_bpf_disconnect_device(struct hid_devi
213 void hid_bpf_destroy_device(struct hid_device
214 int hid_bpf_device_init(struct hid_device *hid
215 u8 *call_hid_bpf_rdesc_fixup(struct hid_device
216 #else /* CONFIG_HID_BPF */
217 static inline u8 *dispatch_hid_bpf_device_even
218
219
220 static inline int dispatch_hid_bpf_raw_request
221
222
223
224
225 static inline int dispatch_hid_bpf_output_repo
226
227 static inline int hid_bpf_connect_device(struc
228 static inline void hid_bpf_disconnect_device(s
229 static inline void hid_bpf_destroy_device(stru
230 static inline int hid_bpf_device_init(struct h
231 /*
232 * This specialized allocator has to be a macr
233 * accounted separately (to have a separate al
234 * intentional to enforce typesafety.
235 */
236 #define call_hid_bpf_rdesc_fixup(_hdev, _rdesc
237 ((u8 *)kmemdup(_rdesc, *(_size
238
239 #endif /* CONFIG_HID_BPF */
240
241 #endif /* __HID_BPF_H */
242
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.