1 /* 2 * This work is licensed under the terms of the GNU GPL, version 2 or 3 * (at your option) any later version. See the COPYING file in the 4 * top-level directory. 5 */ 6 7 #include "qemu/osdep.h" 8 #include "qapi/error.h" 9 #include "qemu/config-file.h" 10 #include "qemu/main-loop.h" 11 #include "qemu/module.h" 12 #include "qemu/sockets.h" 13 #include "ui/input.h" 14 #include "qom/object_interfaces.h" 15 #include "sysemu/iothread.h" 16 #include "block/aio.h" 17 18 #include <sys/ioctl.h> 19 #include "standard-headers/linux/input.h" 20 21 static bool linux_is_button(unsigned int lnx) 22 { 23 if (lnx < 0x100) { 24 return false; 25 } 26 if (lnx >= 0x160 && lnx < 0x2c0) { 27 return false; 28 } 29 return true; 30 } 31 32 #define TYPE_INPUT_LINUX "input-linux" 33 #define INPUT_LINUX(obj) \ 34 OBJECT_CHECK(InputLinux, (obj), TYPE_INPUT_LINUX) 35 #define INPUT_LINUX_GET_CLASS(obj) \ 36 OBJECT_GET_CLASS(InputLinuxClass, (obj), TYPE_INPUT_LINUX) 37 #define INPUT_LINUX_CLASS(klass) \ 38 OBJECT_CLASS_CHECK(InputLinuxClass, (klass), TYPE_INPUT_LINUX) 39 40 typedef struct InputLinux InputLinux; 41 typedef struct InputLinuxClass InputLinuxClass; 42 43 struct InputLinux { 44 Object parent; 45 46 char *evdev; 47 int fd; 48 bool repeat; 49 bool grab_request; 50 bool grab_active; 51 bool grab_all; 52 bool keydown[KEY_CNT]; 53 int keycount; 54 int wheel; 55 bool initialized; 56 57 bool has_rel_x; 58 bool has_abs_x; 59 int num_keys; 60 int num_btns; 61 int abs_x_min; 62 int abs_x_max; 63 int abs_y_min; 64 int abs_y_max; 65 struct input_event event; 66 int read_offset; 67 68 enum GrabToggleKeys grab_toggle; 69 70 QTAILQ_ENTRY(InputLinux) next; 71 }; 72 73 struct InputLinuxClass { 74 ObjectClass parent_class; 75 }; 76 77 static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs); 78 79 static void input_linux_toggle_grab(InputLinux *il) 80 { 81 intptr_t request = !il->grab_active; 82 InputLinux *item; 83 int rc; 84 85 rc = ioctl(il->fd, EVIOCGRAB, request); 86 if (rc < 0) { 87 return; 88 } 89 il->grab_active = !il->grab_active; 90 91 if (!il->grab_all) { 92 return; 93 } 94 QTAILQ_FOREACH(item, &inputs, next) { 95 if (item == il || item->grab_all) { 96 /* avoid endless loops */ 97 continue; 98 } 99 if (item->grab_active != il->grab_active) { 100 input_linux_toggle_grab(item); 101 } 102 } 103 } 104 105 static bool input_linux_check_toggle(InputLinux *il) 106 { 107 switch (il->grab_toggle) { 108 case GRAB_TOGGLE_KEYS_CTRL_CTRL: 109 return il->keydown[KEY_LEFTCTRL] && 110 il->keydown[KEY_RIGHTCTRL]; 111 112 case GRAB_TOGGLE_KEYS_ALT_ALT: 113 return il->keydown[KEY_LEFTALT] && 114 il->keydown[KEY_RIGHTALT]; 115 116 case GRAB_TOGGLE_KEYS_SHIFT_SHIFT: 117 return il->keydown[KEY_LEFTSHIFT] && 118 il->keydown[KEY_RIGHTSHIFT]; 119 120 case GRAB_TOGGLE_KEYS_META_META: 121 return il->keydown[KEY_LEFTMETA] && 122 il->keydown[KEY_RIGHTMETA]; 123 124 case GRAB_TOGGLE_KEYS_SCROLLLOCK: 125 return il->keydown[KEY_SCROLLLOCK]; 126 127 case GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK: 128 return (il->keydown[KEY_LEFTCTRL] || 129 il->keydown[KEY_RIGHTCTRL]) && 130 il->keydown[KEY_SCROLLLOCK]; 131 132 case GRAB_TOGGLE_KEYS__MAX: 133 /* avoid gcc error */ 134 break; 135 } 136 return false; 137 } 138 139 static bool input_linux_should_skip(InputLinux *il, 140 struct input_event *event) 141 { 142 return (il->grab_toggle == GRAB_TOGGLE_KEYS_SCROLLLOCK || 143 il->grab_toggle == GRAB_TOGGLE_KEYS_CTRL_SCROLLLOCK) && 144 event->code == KEY_SCROLLLOCK; 145 } 146 147 static void input_linux_handle_keyboard(InputLinux *il, 148 struct input_event *event) 149 { 150 if (event->type == EV_KEY) { 151 if (event->value > 2 || (event->value > 1 && !il->repeat)) { 152 /* 153 * ignore autorepeat + unknown key events 154 * 0 == up, 1 == down, 2 == autorepeat, other == undefined 155 */ 156 return; 157 } 158 if (event->code >= KEY_CNT) { 159 /* 160 * Should not happen. But better safe than sorry, 161 * and we make Coverity happy too. 162 */ 163 return; 164 } 165 166 /* keep track of key state */ 167 if (!il->keydown[event->code] && event->value) { 168 il->keydown[event->code] = true; 169 il->keycount++; 170 } 171 if (il->keydown[event->code] && !event->value) { 172 il->keydown[event->code] = false; 173 il->keycount--; 174 } 175 176 /* send event to guest when grab is active */ 177 if (il->grab_active && !input_linux_should_skip(il, event)) { 178 int qcode = qemu_input_linux_to_qcode(event->code); 179 qemu_input_event_send_key_qcode(NULL, qcode, event->value); 180 } 181 182 /* hotkey -> record switch request ... */ 183 if (input_linux_check_toggle(il)) { 184 il->grab_request = true; 185 } 186 187 /* 188 * ... and do the switch when all keys are lifted, so we 189 * confuse neither guest nor host with keys which seem to 190 * be stuck due to missing key-up events. 191 */ 192 if (il->grab_request && !il->keycount) { 193 il->grab_request = false; 194 input_linux_toggle_grab(il); 195 } 196 } 197 } 198 199 static void input_linux_event_mouse_button(int button) 200 { 201 qemu_input_queue_btn(NULL, button, true); 202 qemu_input_event_sync(); 203 qemu_input_queue_btn(NULL, button, false); 204 qemu_input_event_sync(); 205 } 206 207 static void input_linux_handle_mouse(InputLinux *il, struct input_event *event) 208 { 209 if (!il->grab_active) { 210 return; 211 } 212 213 switch (event->type) { 214 case EV_KEY: 215 switch (event->code) { 216 case BTN_LEFT: 217 qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event->value); 218 break; 219 case BTN_RIGHT: 220 qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event->value); 221 break; 222 case BTN_MIDDLE: 223 qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event->value); 224 break; 225 case BTN_GEAR_UP: 226 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event->value); 227 break; 228 case BTN_GEAR_DOWN: 229 qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN, 230 event->value); 231 break; 232 case BTN_SIDE: 233 qemu_input_queue_btn(NULL, INPUT_BUTTON_SIDE, event->value); 234 break; 235 case BTN_EXTRA: 236 qemu_input_queue_btn(NULL, INPUT_BUTTON_EXTRA, event->value); 237 break; 238 }; 239 break; 240 case EV_REL: 241 switch (event->code) { 242 case REL_X: 243 qemu_input_queue_rel(NULL, INPUT_AXIS_X, event->value); 244 break; 245 case REL_Y: 246 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event->value); 247 break; 248 case REL_WHEEL: 249 il->wheel = event->value; 250 break; 251 } 252 break; 253 case EV_ABS: 254 switch (event->code) { 255 case ABS_X: 256 qemu_input_queue_abs(NULL, INPUT_AXIS_X, event->value, 257 il->abs_x_min, il->abs_x_max); 258 break; 259 case ABS_Y: 260 qemu_input_queue_abs(NULL, INPUT_AXIS_Y, event->value, 261 il->abs_y_min, il->abs_y_max); 262 break; 263 } 264 break; 265 case EV_SYN: 266 qemu_input_event_sync(); 267 if (il->wheel != 0) { 268 input_linux_event_mouse_button((il->wheel > 0) 269 ? INPUT_BUTTON_WHEEL_UP 270 : INPUT_BUTTON_WHEEL_DOWN); 271 il->wheel = 0; 272 } 273 break; 274 } 275 } 276 277 static void input_linux_event(void *opaque) 278 { 279 InputLinux *il = opaque; 280 int rc; 281 int read_size; 282 uint8_t *p = (uint8_t *)&il->event; 283 284 for (;;) { 285 read_size = sizeof(il->event) - il->read_offset; 286 rc = read(il->fd, &p[il->read_offset], read_size); 287 if (rc != read_size) { 288 if (rc < 0 && errno != EAGAIN) { 289 fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno)); 290 qemu_set_fd_handler(il->fd, NULL, NULL, NULL); 291 close(il->fd); 292 } else if (rc > 0) { 293 il->read_offset += rc; 294 } 295 break; 296 } 297 il->read_offset = 0; 298 299 if (il->num_keys) { 300 input_linux_handle_keyboard(il, &il->event); 301 } 302 if ((il->has_rel_x || il->has_abs_x) && il->num_btns) { 303 input_linux_handle_mouse(il, &il->event); 304 } 305 } 306 } 307 308 static void input_linux_complete(UserCreatable *uc, Error **errp) 309 { 310 InputLinux *il = INPUT_LINUX(uc); 311 uint8_t evtmap, relmap, absmap; 312 uint8_t keymap[KEY_CNT / 8], keystate[KEY_CNT / 8]; 313 unsigned int i; 314 int rc, ver; 315 struct input_absinfo absinfo; 316 317 if (!il->evdev) { 318 error_setg(errp, "no input device specified"); 319 return; 320 } 321 322 il->fd = open(il->evdev, O_RDWR); 323 if (il->fd < 0) { 324 error_setg_file_open(errp, errno, il->evdev); 325 return; 326 } 327 qemu_set_nonblock(il->fd); 328 329 rc = ioctl(il->fd, EVIOCGVERSION, &ver); 330 if (rc < 0) { 331 error_setg(errp, "%s: is not an evdev device", il->evdev); 332 goto err_close; 333 } 334 335 rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap); 336 if (rc < 0) { 337 error_setg(errp, "%s: failed to read event bits", il->evdev); 338 goto err_close; 339 } 340 341 if (evtmap & (1 << EV_REL)) { 342 relmap = 0; 343 rc = ioctl(il->fd, EVIOCGBIT(EV_REL, sizeof(relmap)), &relmap); 344 if (relmap & (1 << REL_X)) { 345 il->has_rel_x = true; 346 } 347 } 348 349 if (evtmap & (1 << EV_ABS)) { 350 absmap = 0; 351 rc = ioctl(il->fd, EVIOCGBIT(EV_ABS, sizeof(absmap)), &absmap); 352 if (absmap & (1 << ABS_X)) { 353 il->has_abs_x = true; 354 rc = ioctl(il->fd, EVIOCGABS(ABS_X), &absinfo); 355 il->abs_x_min = absinfo.minimum; 356 il->abs_x_max = absinfo.maximum; 357 rc = ioctl(il->fd, EVIOCGABS(ABS_Y), &absinfo); 358 il->abs_y_min = absinfo.minimum; 359 il->abs_y_max = absinfo.maximum; 360 } 361 } 362 363 if (evtmap & (1 << EV_KEY)) { 364 memset(keymap, 0, sizeof(keymap)); 365 rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap); 366 rc = ioctl(il->fd, EVIOCGKEY(sizeof(keystate)), keystate); 367 for (i = 0; i < KEY_CNT; i++) { 368 if (keymap[i / 8] & (1 << (i % 8))) { 369 if (linux_is_button(i)) { 370 il->num_btns++; 371 } else { 372 il->num_keys++; 373 } 374 if (keystate[i / 8] & (1 << (i % 8))) { 375 il->keydown[i] = true; 376 il->keycount++; 377 } 378 } 379 } 380 } 381 382 qemu_set_fd_handler(il->fd, input_linux_event, NULL, il); 383 if (il->keycount) { 384 /* delay grab until all keys are released */ 385 il->grab_request = true; 386 } else { 387 input_linux_toggle_grab(il); 388 } 389 QTAILQ_INSERT_TAIL(&inputs, il, next); 390 il->initialized = true; 391 return; 392 393 err_close: 394 close(il->fd); 395 return; 396 } 397 398 static void input_linux_instance_finalize(Object *obj) 399 { 400 InputLinux *il = INPUT_LINUX(obj); 401 402 if (il->initialized) { 403 QTAILQ_REMOVE(&inputs, il, next); 404 close(il->fd); 405 } 406 g_free(il->evdev); 407 } 408 409 static char *input_linux_get_evdev(Object *obj, Error **errp) 410 { 411 InputLinux *il = INPUT_LINUX(obj); 412 413 return g_strdup(il->evdev); 414 } 415 416 static void input_linux_set_evdev(Object *obj, const char *value, 417 Error **errp) 418 { 419 InputLinux *il = INPUT_LINUX(obj); 420 421 if (il->evdev) { 422 error_setg(errp, "evdev property already set"); 423 return; 424 } 425 il->evdev = g_strdup(value); 426 } 427 428 static bool input_linux_get_grab_all(Object *obj, Error **errp) 429 { 430 InputLinux *il = INPUT_LINUX(obj); 431 432 return il->grab_all; 433 } 434 435 static void input_linux_set_grab_all(Object *obj, bool value, 436 Error **errp) 437 { 438 InputLinux *il = INPUT_LINUX(obj); 439 440 il->grab_all = value; 441 } 442 443 static bool input_linux_get_repeat(Object *obj, Error **errp) 444 { 445 InputLinux *il = INPUT_LINUX(obj); 446 447 return il->repeat; 448 } 449 450 static void input_linux_set_repeat(Object *obj, bool value, 451 Error **errp) 452 { 453 InputLinux *il = INPUT_LINUX(obj); 454 455 il->repeat = value; 456 } 457 458 static int input_linux_get_grab_toggle(Object *obj, Error **errp) 459 { 460 InputLinux *il = INPUT_LINUX(obj); 461 462 return il->grab_toggle; 463 } 464 465 static void input_linux_set_grab_toggle(Object *obj, int value, 466 Error **errp) 467 { 468 InputLinux *il = INPUT_LINUX(obj); 469 470 il->grab_toggle = value; 471 } 472 473 static void input_linux_instance_init(Object *obj) 474 { 475 object_property_add_str(obj, "evdev", 476 input_linux_get_evdev, 477 input_linux_set_evdev, NULL); 478 object_property_add_bool(obj, "grab_all", 479 input_linux_get_grab_all, 480 input_linux_set_grab_all, NULL); 481 object_property_add_bool(obj, "repeat", 482 input_linux_get_repeat, 483 input_linux_set_repeat, NULL); 484 object_property_add_enum(obj, "grab-toggle", "GrabToggleKeys", 485 &GrabToggleKeys_lookup, 486 input_linux_get_grab_toggle, 487 input_linux_set_grab_toggle, NULL); 488 } 489 490 static void input_linux_class_init(ObjectClass *oc, void *data) 491 { 492 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc); 493 494 ucc->complete = input_linux_complete; 495 } 496 497 static const TypeInfo input_linux_info = { 498 .name = TYPE_INPUT_LINUX, 499 .parent = TYPE_OBJECT, 500 .class_size = sizeof(InputLinuxClass), 501 .class_init = input_linux_class_init, 502 .instance_size = sizeof(InputLinux), 503 .instance_init = input_linux_instance_init, 504 .instance_finalize = input_linux_instance_finalize, 505 .interfaces = (InterfaceInfo[]) { 506 { TYPE_USER_CREATABLE }, 507 { } 508 } 509 }; 510 511 static void register_types(void) 512 { 513 type_register_static(&input_linux_info); 514 } 515 516 type_init(register_types); 517