1 /*
2 * Copyright (c) 2015 Etienne Gemsa <etienne.gemsa@lse.epita.fr>
3 * Copyright (c) 2015-2016 Dmitry V. Levin <ldv@strace.io>
4 * Copyright (c) 2015-2021 The strace developers.
5 * All rights reserved.
6 *
7 * SPDX-License-Identifier: LGPL-2.1-or-later
8 */
9
10 #include "defs.h"
11 #include <linux/ioctl.h>
12 #include <linux/input.h>
13 #include "xlat/evdev_abs.h"
14 #include "xlat/evdev_ev.h"
15 #include "xlat/evdev_autorepeat.h"
16 #include "xlat/evdev_ff_status.h"
17 #include "xlat/evdev_ff_types.h"
18 #include "xlat/evdev_keycode.h"
19 #include "xlat/evdev_leds.h"
20 #include "xlat/evdev_misc.h"
21 #include "xlat/evdev_mtslots.h"
22 #include "xlat/evdev_prop.h"
23 #include "xlat/evdev_relative_axes.h"
24 #include "xlat/evdev_snd.h"
25 #include "xlat/evdev_switch.h"
26
27 static int
28 abs_ioctl(struct tcb *const tcp, const unsigned int code,
29 const kernel_ulong_t arg)
30 {
31 static const size_t orig_sz = offsetofend(struct input_absinfo, flat);
32 static const size_t res_sz = offsetofend(struct input_absinfo,
33 resolution);
34
35 struct input_absinfo absinfo;
36 size_t sz = _IOC_SIZE(code);
37 size_t read_sz = MIN(sz, sizeof(absinfo));
38
39 if (sz < orig_sz) {
40 printaddr(arg);
41 return RVAL_IOCTL_DECODED;
42 }
43
44 if (umoven_or_printaddr(tcp, arg, read_sz, &absinfo))
45 return RVAL_IOCTL_DECODED;
46
47 tprint_struct_begin();
48 PRINT_FIELD_U(absinfo, value);
49 tprint_struct_next();
50 PRINT_FIELD_U(absinfo, minimum);
51
52 if (!abbrev(tcp)) {
53 tprint_struct_next();
54 PRINT_FIELD_U(absinfo, maximum);
55 tprint_struct_next();
56 PRINT_FIELD_U(absinfo, fuzz);
57 tprint_struct_next();
58 PRINT_FIELD_U(absinfo, flat);
59 if (sz > orig_sz) {
60 if (sz >= res_sz) {
61 tprint_struct_next();
62 PRINT_FIELD_U(absinfo, resolution);
63 }
64 if (sz != res_sz) {
65 tprint_struct_next();
66 tprint_more_data_follows();
67 }
68 }
69 } else {
70 tprint_struct_next();
71 tprint_more_data_follows();
72 }
73
74 tprint_struct_end();
75
76 return RVAL_IOCTL_DECODED;
77 }
78
79 static int
80 keycode_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
81 {
82 unsigned int keycode[2];
83
84 if (!umove_or_printaddr(tcp, arg, &keycode)) {
85 tprint_array_begin();
86 PRINT_VAL_U(keycode[0]);
87 tprint_array_next();
88
89 printxval(evdev_keycode, keycode[1], "KEY_???");
90 tprint_array_end();
91 }
92
93 return RVAL_IOCTL_DECODED;
94 }
95
96 static int
97 keycode_V2_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
98 {
99 struct input_keymap_entry ike;
100
101 if (umove_or_printaddr(tcp, arg, &ike))
102 return RVAL_IOCTL_DECODED;
103
104 tprint_struct_begin();
105 PRINT_FIELD_U(ike, flags);
106 tprint_struct_next();
107 PRINT_FIELD_U(ike, len);
108
109 if (!abbrev(tcp)) {
110 tprint_struct_next();
111 PRINT_FIELD_U(ike, index);
112 tprint_struct_next();
113 PRINT_FIELD_XVAL(ike, keycode, evdev_keycode, "KEY_???");
114 tprint_struct_next();
115 PRINT_FIELD_X_ARRAY(ike, scancode);
116 } else {
117 tprint_struct_next();
118 tprint_more_data_follows();
119 }
120
121 tprint_struct_end();
122
123 return RVAL_IOCTL_DECODED;
124 }
125
126 static int
127 getid_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
128 {
129 struct input_id id;
130
131 if (!umove_or_printaddr(tcp, arg, &id)) {
132 tprint_struct_begin();
133 PRINT_FIELD_U(id, bustype);
134 tprint_struct_next();
135 PRINT_FIELD_U(id, vendor);
136 tprint_struct_next();
137 PRINT_FIELD_U(id, product);
138 tprint_struct_next();
139 PRINT_FIELD_U(id, version);
140 tprint_struct_end();
141 }
142
143 return RVAL_IOCTL_DECODED;
144 }
145
146 static int
147 decode_bitset(struct tcb *const tcp, const kernel_ulong_t arg,
148 const struct xlat *decode_nr, const unsigned int max_nr,
149 const char *const dflt)
150 {
151 unsigned int size;
152 unsigned int size_bits;
153
154 if ((kernel_ulong_t) tcp->u_rval > max_nr / 8)
155 size_bits = max_nr;
156 else
157 size_bits = tcp->u_rval * 8;
158
159 size = ROUNDUP(ROUNDUP_DIV(size_bits, 8), current_wordsize);
160
161 if (syserror(tcp) || !size) {
162 printaddr(arg);
163
164 return RVAL_IOCTL_DECODED;
165 }
166
167 char decoded_arg[size];
168
169 if (umove_or_printaddr(tcp, arg, &decoded_arg))
170 return RVAL_IOCTL_DECODED;
171
172 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_RAW) {
173 tprint_bitset_begin();
174
175 int bit_displayed = 0;
176 int i = next_set_bit(decoded_arg, 0, size_bits);
177 if (i >= 0) {
178 printxval(decode_nr, i, dflt);
179
180 while ((i = next_set_bit(decoded_arg, i + 1,
181 size_bits)) > 0) {
182 if (abbrev(tcp) && bit_displayed >= 3) {
183 tprint_bitset_next();
184 tprint_more_data_follows();
185 break;
186 }
187 tprint_bitset_next();
188 printxval(decode_nr, i, dflt);
189 bit_displayed++;
190 }
191 }
192
193 tprint_bitset_end();
194 }
195
196 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
197 tprint_comment_begin();
198
199 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_ABBREV) {
200 print_local_array_ex(tcp, decoded_arg, size / current_wordsize,
201 current_wordsize, print_xint_array_member,
202 NULL, 0, NULL, NULL);
203 }
204
205 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
206 tprint_comment_end();
207
208 return RVAL_IOCTL_DECODED;
209 }
210
211 static int
212 mtslots_ioctl(struct tcb *const tcp, const unsigned int code,
213 const kernel_ulong_t arg)
214 {
215 const size_t size = _IOC_SIZE(code) / sizeof(int);
216 if (!size) {
217 printaddr(arg);
218 return RVAL_IOCTL_DECODED;
219 }
220
221 struct {
222 unsigned int code;
223 int values[0];
224 } mt;
225 if (umove_or_printaddr(tcp, arg, &mt))
226 return RVAL_IOCTL_DECODED;
227
228 tprint_struct_begin();
229
230 PRINT_FIELD_XVAL(mt, code, evdev_mtslots, "ABS_MT_???");
231 tprint_struct_next();
232
233 tprints_field_name("values");
234 int val;
235 print_array(tcp, arg + sizeof(val), size - 1, &val, sizeof(val),
236 tfetch_mem, print_int_array_member, NULL);
237
238 tprint_struct_end();
239
240 return RVAL_IOCTL_DECODED;
241 }
242
243 static int
244 repeat_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
245 {
246 printpair_int(tcp, arg, "%u");
247 return RVAL_IOCTL_DECODED;
248 }
249
250 static int
251 bit_ioctl(struct tcb *const tcp, const unsigned int ev_nr,
252 const kernel_ulong_t arg)
253 {
254 switch (ev_nr) {
255 case 0:
256 return decode_bitset(tcp, arg, evdev_ev,
257 EV_MAX, "EV_???");
258 case EV_KEY:
259 return decode_bitset(tcp, arg, evdev_keycode,
260 KEY_MAX, "KEY_???");
261 case EV_REL:
262 return decode_bitset(tcp, arg, evdev_relative_axes,
263 REL_MAX, "REL_???");
264 case EV_ABS:
265 return decode_bitset(tcp, arg, evdev_abs,
266 ABS_MAX, "ABS_???");
267 case EV_MSC:
268 return decode_bitset(tcp, arg, evdev_misc,
269 MSC_MAX, "MSC_???");
270 case EV_SW:
271 return decode_bitset(tcp, arg, evdev_switch,
272 SW_MAX, "SW_???");
273 case EV_LED:
274 return decode_bitset(tcp, arg, evdev_leds,
275 LED_MAX, "LED_???");
276 case EV_SND:
277 return decode_bitset(tcp, arg, evdev_snd,
278 SND_MAX, "SND_???");
279 case EV_REP:
280 return decode_bitset(tcp, arg, evdev_autorepeat,
281 REP_MAX, "REP_???");
282 case EV_FF:
283 return decode_bitset(tcp, arg, evdev_ff_types,
284 FF_MAX, "FF_???");
285 case EV_PWR:
286 printnum_int(tcp, arg, "%d");
287 return RVAL_IOCTL_DECODED;
288 case EV_FF_STATUS:
289 return decode_bitset(tcp, arg, evdev_ff_status,
290 FF_STATUS_MAX, "FF_STATUS_???");
291 default:
292 printaddr(arg);
293 return RVAL_IOCTL_DECODED;
294 }
295 }
296
297 static int
298 evdev_read_ioctl(struct tcb *const tcp, const unsigned int code,
299 const kernel_ulong_t arg)
300 {
301 /* fixed-number fixed-length commands */
302 switch (code) {
303 case EVIOCGVERSION:
304 printnum_int(tcp, arg, "%#x");
305 return RVAL_IOCTL_DECODED;
306 case EVIOCGEFFECTS:
307 printnum_int(tcp, arg, "%u");
308 return RVAL_IOCTL_DECODED;
309 case EVIOCGID:
310 return getid_ioctl(tcp, arg);
311 case EVIOCGREP:
312 return repeat_ioctl(tcp, arg);
313 case EVIOCGKEYCODE:
314 return keycode_ioctl(tcp, arg);
315 case EVIOCGKEYCODE_V2:
316 return keycode_V2_ioctl(tcp, arg);
317 }
318
319 /* fixed-number variable-length commands */
320 switch (_IOC_NR(code)) {
321 case _IOC_NR(EVIOCGMTSLOTS(0)):
322 return mtslots_ioctl(tcp, code, arg);
323 case _IOC_NR(EVIOCGNAME(0)):
324 case _IOC_NR(EVIOCGPHYS(0)):
325 case _IOC_NR(EVIOCGUNIQ(0)):
326 if (syserror(tcp))
327 printaddr(arg);
328 else
329 printstrn(tcp, arg, tcp->u_rval);
330 return RVAL_IOCTL_DECODED;
331 case _IOC_NR(EVIOCGPROP(0)):
332 return decode_bitset(tcp, arg, evdev_prop,
333 INPUT_PROP_MAX, "PROP_???");
334 case _IOC_NR(EVIOCGSND(0)):
335 return decode_bitset(tcp, arg, evdev_snd,
336 SND_MAX, "SND_???");
337 case _IOC_NR(EVIOCGSW(0)):
338 return decode_bitset(tcp, arg, evdev_switch,
339 SW_MAX, "SW_???");
340 case _IOC_NR(EVIOCGKEY(0)):
341 return decode_bitset(tcp, arg, evdev_keycode,
342 KEY_MAX, "KEY_???");
343 case _IOC_NR(EVIOCGLED(0)):
344 return decode_bitset(tcp, arg, evdev_leds,
345 LED_MAX, "LED_???");
346 }
347
348 /* multi-number fixed-length commands */
349 if ((_IOC_NR(code) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0)))
350 return abs_ioctl(tcp, code, arg);
351
352 /* multi-number variable-length commands */
353 if ((_IOC_NR(code) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
354 return bit_ioctl(tcp, _IOC_NR(code) & EV_MAX, arg);
355
356 printaddr(arg);
357 return RVAL_IOCTL_DECODED;
358 }
359
360 static int
361 evdev_write_ioctl(struct tcb *const tcp, const unsigned int code,
362 const kernel_ulong_t arg)
363 {
364 /* fixed-number fixed-length commands */
365 switch (code) {
366 case EVIOCSREP:
367 return repeat_ioctl(tcp, arg);
368 case EVIOCSKEYCODE:
369 return keycode_ioctl(tcp, arg);
370 case EVIOCSKEYCODE_V2:
371 return keycode_V2_ioctl(tcp, arg);
372 case EVIOCRMFF:
373 PRINT_VAL_D((int) arg);
374 return RVAL_IOCTL_DECODED;
375 case EVIOCGRAB:
376 case EVIOCREVOKE:
377 PRINT_VAL_U(arg);
378 return RVAL_IOCTL_DECODED;
379 case EVIOCSCLOCKID:
380 printnum_int(tcp, arg, "%u");
381 return RVAL_IOCTL_DECODED;
382 }
383
384 int rc = evdev_write_ioctl_mpers(tcp, code, arg);
385
386 if (rc != RVAL_DECODED)
387 return rc;
388
389 /* multi-number fixed-length commands */
390 if ((_IOC_NR(code) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0)))
391 return abs_ioctl(tcp, code, arg);
392
393 printaddr(arg);
394 return RVAL_IOCTL_DECODED;
395 }
396
397 void
398 print_evdev_ff_type(const kernel_ulong_t val)
399 {
400 printxval(evdev_ff_types, val, "FF_???");
401 }
402
403 int
404 evdev_ioctl(struct tcb *const tcp,
405 const unsigned int code, const kernel_ulong_t arg)
406 {
407 switch (_IOC_DIR(code)) {
408 case _IOC_READ:
409 if (entering(tcp))
410 return 0;
411 tprint_arg_next();
412 return evdev_read_ioctl(tcp, code, arg);
413 case _IOC_WRITE:
414 tprint_arg_next();
415 return evdev_write_ioctl(tcp, code, arg) | RVAL_DECODED;
416 default:
417 return RVAL_DECODED;
418 }
419 }