1 #include "qemu/osdep.h" 2 #include "sysemu/sysemu.h" 3 #include "qemu/error-report.h" 4 #include "qmp-commands.h" 5 #include "trace.h" 6 #include "ui/input.h" 7 #include "ui/console.h" 8 #include "sysemu/replay.h" 9 10 struct QemuInputHandlerState { 11 DeviceState *dev; 12 QemuInputHandler *handler; 13 int id; 14 int events; 15 QemuConsole *con; 16 QTAILQ_ENTRY(QemuInputHandlerState) node; 17 }; 18 19 typedef struct QemuInputEventQueue QemuInputEventQueue; 20 struct QemuInputEventQueue { 21 enum { 22 QEMU_INPUT_QUEUE_DELAY = 1, 23 QEMU_INPUT_QUEUE_EVENT, 24 QEMU_INPUT_QUEUE_SYNC, 25 } type; 26 QEMUTimer *timer; 27 uint32_t delay_ms; 28 QemuConsole *src; 29 InputEvent *evt; 30 QTAILQ_ENTRY(QemuInputEventQueue) node; 31 }; 32 33 static QTAILQ_HEAD(, QemuInputHandlerState) handlers = 34 QTAILQ_HEAD_INITIALIZER(handlers); 35 static NotifierList mouse_mode_notifiers = 36 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers); 37 38 static QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue) kbd_queue = 39 QTAILQ_HEAD_INITIALIZER(kbd_queue); 40 static QEMUTimer *kbd_timer; 41 static uint32_t kbd_default_delay_ms = 10; 42 static uint32_t queue_count; 43 static uint32_t queue_limit = 1024; 44 45 QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev, 46 QemuInputHandler *handler) 47 { 48 QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1); 49 static int id = 1; 50 51 s->dev = dev; 52 s->handler = handler; 53 s->id = id++; 54 QTAILQ_INSERT_TAIL(&handlers, s, node); 55 56 qemu_input_check_mode_change(); 57 return s; 58 } 59 60 void qemu_input_handler_activate(QemuInputHandlerState *s) 61 { 62 QTAILQ_REMOVE(&handlers, s, node); 63 QTAILQ_INSERT_HEAD(&handlers, s, node); 64 qemu_input_check_mode_change(); 65 } 66 67 void qemu_input_handler_deactivate(QemuInputHandlerState *s) 68 { 69 QTAILQ_REMOVE(&handlers, s, node); 70 QTAILQ_INSERT_TAIL(&handlers, s, node); 71 qemu_input_check_mode_change(); 72 } 73 74 void qemu_input_handler_unregister(QemuInputHandlerState *s) 75 { 76 QTAILQ_REMOVE(&handlers, s, node); 77 g_free(s); 78 qemu_input_check_mode_change(); 79 } 80 81 void qemu_input_handler_bind(QemuInputHandlerState *s, 82 const char *device_id, int head, 83 Error **errp) 84 { 85 QemuConsole *con; 86 Error *err = NULL; 87 88 con = qemu_console_lookup_by_device_name(device_id, head, &err); 89 if (err) { 90 error_propagate(errp, err); 91 return; 92 } 93 94 s->con = con; 95 } 96 97 static QemuInputHandlerState* 98 qemu_input_find_handler(uint32_t mask, QemuConsole *con) 99 { 100 QemuInputHandlerState *s; 101 102 QTAILQ_FOREACH(s, &handlers, node) { 103 if (s->con == NULL || s->con != con) { 104 continue; 105 } 106 if (mask & s->handler->mask) { 107 return s; 108 } 109 } 110 111 QTAILQ_FOREACH(s, &handlers, node) { 112 if (s->con != NULL) { 113 continue; 114 } 115 if (mask & s->handler->mask) { 116 return s; 117 } 118 } 119 return NULL; 120 } 121 122 void qmp_input_send_event(bool has_device, const char *device, 123 bool has_head, int64_t head, 124 InputEventList *events, Error **errp) 125 { 126 InputEventList *e; 127 QemuConsole *con; 128 Error *err = NULL; 129 130 con = NULL; 131 if (has_device) { 132 if (!has_head) { 133 head = 0; 134 } 135 con = qemu_console_lookup_by_device_name(device, head, &err); 136 if (err) { 137 error_propagate(errp, err); 138 return; 139 } 140 } 141 142 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 143 error_setg(errp, "VM not running"); 144 return; 145 } 146 147 for (e = events; e != NULL; e = e->next) { 148 InputEvent *event = e->value; 149 150 if (!qemu_input_find_handler(1 << event->type, con)) { 151 error_setg(errp, "Input handler not found for " 152 "event type %s", 153 InputEventKind_str(event->type)); 154 return; 155 } 156 } 157 158 for (e = events; e != NULL; e = e->next) { 159 InputEvent *evt = e->value; 160 161 if (evt->type == INPUT_EVENT_KIND_KEY && 162 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER) { 163 KeyValue *key = evt->u.key.data->key; 164 QKeyCode code = qemu_input_key_number_to_qcode(key->u.number.data); 165 qemu_input_event_send_key_qcode(con, code, evt->u.key.data->down); 166 } else { 167 qemu_input_event_send(con, evt); 168 } 169 } 170 171 qemu_input_event_sync(); 172 } 173 174 static int qemu_input_transform_invert_abs_value(int value) 175 { 176 return (int64_t)INPUT_EVENT_ABS_MAX - value + INPUT_EVENT_ABS_MIN; 177 } 178 179 static void qemu_input_transform_abs_rotate(InputEvent *evt) 180 { 181 InputMoveEvent *move = evt->u.abs.data; 182 switch (graphic_rotate) { 183 case 90: 184 if (move->axis == INPUT_AXIS_X) { 185 move->axis = INPUT_AXIS_Y; 186 } else if (move->axis == INPUT_AXIS_Y) { 187 move->axis = INPUT_AXIS_X; 188 move->value = qemu_input_transform_invert_abs_value(move->value); 189 } 190 break; 191 case 180: 192 move->value = qemu_input_transform_invert_abs_value(move->value); 193 break; 194 case 270: 195 if (move->axis == INPUT_AXIS_X) { 196 move->axis = INPUT_AXIS_Y; 197 move->value = qemu_input_transform_invert_abs_value(move->value); 198 } else if (move->axis == INPUT_AXIS_Y) { 199 move->axis = INPUT_AXIS_X; 200 } 201 break; 202 } 203 } 204 205 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt) 206 { 207 const char *name; 208 int qcode, idx = -1; 209 InputKeyEvent *key; 210 InputBtnEvent *btn; 211 InputMoveEvent *move; 212 213 if (src) { 214 idx = qemu_console_get_index(src); 215 } 216 switch (evt->type) { 217 case INPUT_EVENT_KIND_KEY: 218 key = evt->u.key.data; 219 switch (key->key->type) { 220 case KEY_VALUE_KIND_NUMBER: 221 qcode = qemu_input_key_number_to_qcode(key->key->u.number.data); 222 name = QKeyCode_str(qcode); 223 trace_input_event_key_number(idx, key->key->u.number.data, 224 name, key->down); 225 break; 226 case KEY_VALUE_KIND_QCODE: 227 name = QKeyCode_str(key->key->u.qcode.data); 228 trace_input_event_key_qcode(idx, name, key->down); 229 break; 230 case KEY_VALUE_KIND__MAX: 231 /* keep gcc happy */ 232 break; 233 } 234 break; 235 case INPUT_EVENT_KIND_BTN: 236 btn = evt->u.btn.data; 237 name = InputButton_str(btn->button); 238 trace_input_event_btn(idx, name, btn->down); 239 break; 240 case INPUT_EVENT_KIND_REL: 241 move = evt->u.rel.data; 242 name = InputAxis_str(move->axis); 243 trace_input_event_rel(idx, name, move->value); 244 break; 245 case INPUT_EVENT_KIND_ABS: 246 move = evt->u.abs.data; 247 name = InputAxis_str(move->axis); 248 trace_input_event_abs(idx, name, move->value); 249 break; 250 case INPUT_EVENT_KIND__MAX: 251 /* keep gcc happy */ 252 break; 253 } 254 } 255 256 static void qemu_input_queue_process(void *opaque) 257 { 258 struct QemuInputEventQueueHead *queue = opaque; 259 QemuInputEventQueue *item; 260 261 g_assert(!QTAILQ_EMPTY(queue)); 262 item = QTAILQ_FIRST(queue); 263 g_assert(item->type == QEMU_INPUT_QUEUE_DELAY); 264 QTAILQ_REMOVE(queue, item, node); 265 queue_count--; 266 g_free(item); 267 268 while (!QTAILQ_EMPTY(queue)) { 269 item = QTAILQ_FIRST(queue); 270 switch (item->type) { 271 case QEMU_INPUT_QUEUE_DELAY: 272 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) 273 + item->delay_ms); 274 return; 275 case QEMU_INPUT_QUEUE_EVENT: 276 qemu_input_event_send(item->src, item->evt); 277 qapi_free_InputEvent(item->evt); 278 break; 279 case QEMU_INPUT_QUEUE_SYNC: 280 qemu_input_event_sync(); 281 break; 282 } 283 QTAILQ_REMOVE(queue, item, node); 284 queue_count--; 285 g_free(item); 286 } 287 } 288 289 static void qemu_input_queue_delay(struct QemuInputEventQueueHead *queue, 290 QEMUTimer *timer, uint32_t delay_ms) 291 { 292 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1); 293 bool start_timer = QTAILQ_EMPTY(queue); 294 295 item->type = QEMU_INPUT_QUEUE_DELAY; 296 item->delay_ms = delay_ms; 297 item->timer = timer; 298 QTAILQ_INSERT_TAIL(queue, item, node); 299 queue_count++; 300 301 if (start_timer) { 302 timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) 303 + item->delay_ms); 304 } 305 } 306 307 static void qemu_input_queue_event(struct QemuInputEventQueueHead *queue, 308 QemuConsole *src, InputEvent *evt) 309 { 310 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1); 311 312 item->type = QEMU_INPUT_QUEUE_EVENT; 313 item->src = src; 314 item->evt = evt; 315 QTAILQ_INSERT_TAIL(queue, item, node); 316 queue_count++; 317 } 318 319 static void qemu_input_queue_sync(struct QemuInputEventQueueHead *queue) 320 { 321 QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1); 322 323 item->type = QEMU_INPUT_QUEUE_SYNC; 324 QTAILQ_INSERT_TAIL(queue, item, node); 325 queue_count++; 326 } 327 328 void qemu_input_event_send_impl(QemuConsole *src, InputEvent *evt) 329 { 330 QemuInputHandlerState *s; 331 332 qemu_input_event_trace(src, evt); 333 334 /* pre processing */ 335 if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) { 336 qemu_input_transform_abs_rotate(evt); 337 } 338 339 /* send event */ 340 s = qemu_input_find_handler(1 << evt->type, src); 341 if (!s) { 342 return; 343 } 344 s->handler->event(s->dev, src, evt); 345 s->events++; 346 } 347 348 void qemu_input_event_send(QemuConsole *src, InputEvent *evt) 349 { 350 /* Expect all parts of QEMU to send events with QCodes exclusively. 351 * Key numbers are only supported as end-user input via QMP */ 352 assert(!(evt->type == INPUT_EVENT_KIND_KEY && 353 evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER)); 354 355 356 /* 357 * 'sysrq' was mistakenly added to hack around the fact that 358 * the ps2 driver was not generating correct scancodes sequences 359 * when 'alt+print' was pressed. This flaw is now fixed and the 360 * 'sysrq' key serves no further purpose. We normalize it to 361 * 'print', so that downstream receivers of the event don't 362 * neeed to deal with this mistake 363 */ 364 if (evt->type == INPUT_EVENT_KIND_KEY && 365 evt->u.key.data->key->u.qcode.data == Q_KEY_CODE_SYSRQ) { 366 evt->u.key.data->key->u.qcode.data = Q_KEY_CODE_PRINT; 367 } 368 369 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 370 return; 371 } 372 373 replay_input_event(src, evt); 374 } 375 376 void qemu_input_event_sync_impl(void) 377 { 378 QemuInputHandlerState *s; 379 380 trace_input_event_sync(); 381 382 QTAILQ_FOREACH(s, &handlers, node) { 383 if (!s->events) { 384 continue; 385 } 386 if (s->handler->sync) { 387 s->handler->sync(s->dev); 388 } 389 s->events = 0; 390 } 391 } 392 393 void qemu_input_event_sync(void) 394 { 395 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 396 return; 397 } 398 399 replay_input_sync_event(); 400 } 401 402 static InputEvent *qemu_input_event_new_key(KeyValue *key, bool down) 403 { 404 InputEvent *evt = g_new0(InputEvent, 1); 405 evt->u.key.data = g_new0(InputKeyEvent, 1); 406 evt->type = INPUT_EVENT_KIND_KEY; 407 evt->u.key.data->key = key; 408 evt->u.key.data->down = down; 409 return evt; 410 } 411 412 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down) 413 { 414 InputEvent *evt; 415 evt = qemu_input_event_new_key(key, down); 416 if (QTAILQ_EMPTY(&kbd_queue)) { 417 qemu_input_event_send(src, evt); 418 qemu_input_event_sync(); 419 qapi_free_InputEvent(evt); 420 } else if (queue_count < queue_limit) { 421 qemu_input_queue_event(&kbd_queue, src, evt); 422 qemu_input_queue_sync(&kbd_queue); 423 } else { 424 qapi_free_InputEvent(evt); 425 } 426 } 427 428 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down) 429 { 430 QKeyCode code = qemu_input_key_number_to_qcode(num); 431 qemu_input_event_send_key_qcode(src, code, down); 432 } 433 434 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down) 435 { 436 KeyValue *key = g_new0(KeyValue, 1); 437 key->type = KEY_VALUE_KIND_QCODE; 438 key->u.qcode.data = q; 439 qemu_input_event_send_key(src, key, down); 440 } 441 442 void qemu_input_event_send_key_delay(uint32_t delay_ms) 443 { 444 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { 445 return; 446 } 447 448 if (!kbd_timer) { 449 kbd_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, qemu_input_queue_process, 450 &kbd_queue); 451 } 452 if (queue_count < queue_limit) { 453 qemu_input_queue_delay(&kbd_queue, kbd_timer, 454 delay_ms ? delay_ms : kbd_default_delay_ms); 455 } 456 } 457 458 InputEvent *qemu_input_event_new_btn(InputButton btn, bool down) 459 { 460 InputEvent *evt = g_new0(InputEvent, 1); 461 evt->u.btn.data = g_new0(InputBtnEvent, 1); 462 evt->type = INPUT_EVENT_KIND_BTN; 463 evt->u.btn.data->button = btn; 464 evt->u.btn.data->down = down; 465 return evt; 466 } 467 468 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down) 469 { 470 InputEvent *evt; 471 evt = qemu_input_event_new_btn(btn, down); 472 qemu_input_event_send(src, evt); 473 qapi_free_InputEvent(evt); 474 } 475 476 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map, 477 uint32_t button_old, uint32_t button_new) 478 { 479 InputButton btn; 480 uint32_t mask; 481 482 for (btn = 0; btn < INPUT_BUTTON__MAX; btn++) { 483 mask = button_map[btn]; 484 if ((button_old & mask) == (button_new & mask)) { 485 continue; 486 } 487 qemu_input_queue_btn(src, btn, button_new & mask); 488 } 489 } 490 491 bool qemu_input_is_absolute(void) 492 { 493 QemuInputHandlerState *s; 494 495 s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS, 496 NULL); 497 return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS); 498 } 499 500 int qemu_input_scale_axis(int value, 501 int min_in, int max_in, 502 int min_out, int max_out) 503 { 504 int64_t range_in = (int64_t)max_in - min_in; 505 int64_t range_out = (int64_t)max_out - min_out; 506 507 if (range_in < 1) { 508 return min_out + range_out / 2; 509 } 510 return ((int64_t)value - min_in) * range_out / range_in + min_out; 511 } 512 513 InputEvent *qemu_input_event_new_move(InputEventKind kind, 514 InputAxis axis, int value) 515 { 516 InputEvent *evt = g_new0(InputEvent, 1); 517 InputMoveEvent *move = g_new0(InputMoveEvent, 1); 518 519 evt->type = kind; 520 evt->u.rel.data = move; /* evt->u.rel is the same as evt->u.abs */ 521 move->axis = axis; 522 move->value = value; 523 return evt; 524 } 525 526 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value) 527 { 528 InputEvent *evt; 529 evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value); 530 qemu_input_event_send(src, evt); 531 qapi_free_InputEvent(evt); 532 } 533 534 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, 535 int min_in, int max_in) 536 { 537 InputEvent *evt; 538 int scaled = qemu_input_scale_axis(value, min_in, max_in, 539 INPUT_EVENT_ABS_MIN, 540 INPUT_EVENT_ABS_MAX); 541 evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled); 542 qemu_input_event_send(src, evt); 543 qapi_free_InputEvent(evt); 544 } 545 546 void qemu_input_check_mode_change(void) 547 { 548 static int current_is_absolute; 549 int is_absolute; 550 551 is_absolute = qemu_input_is_absolute(); 552 553 if (is_absolute != current_is_absolute) { 554 trace_input_mouse_mode(is_absolute); 555 notifier_list_notify(&mouse_mode_notifiers, NULL); 556 } 557 558 current_is_absolute = is_absolute; 559 } 560 561 void qemu_add_mouse_mode_change_notifier(Notifier *notify) 562 { 563 notifier_list_add(&mouse_mode_notifiers, notify); 564 } 565 566 void qemu_remove_mouse_mode_change_notifier(Notifier *notify) 567 { 568 notifier_remove(notify); 569 } 570 571 MouseInfoList *qmp_query_mice(Error **errp) 572 { 573 MouseInfoList *mice_list = NULL; 574 MouseInfoList *info; 575 QemuInputHandlerState *s; 576 bool current = true; 577 578 QTAILQ_FOREACH(s, &handlers, node) { 579 if (!(s->handler->mask & 580 (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) { 581 continue; 582 } 583 584 info = g_new0(MouseInfoList, 1); 585 info->value = g_new0(MouseInfo, 1); 586 info->value->index = s->id; 587 info->value->name = g_strdup(s->handler->name); 588 info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS; 589 info->value->current = current; 590 591 current = false; 592 info->next = mice_list; 593 mice_list = info; 594 } 595 596 return mice_list; 597 } 598 599 void hmp_mouse_set(Monitor *mon, const QDict *qdict) 600 { 601 QemuInputHandlerState *s; 602 int index = qdict_get_int(qdict, "index"); 603 int found = 0; 604 605 QTAILQ_FOREACH(s, &handlers, node) { 606 if (s->id != index) { 607 continue; 608 } 609 if (!(s->handler->mask & (INPUT_EVENT_MASK_REL | 610 INPUT_EVENT_MASK_ABS))) { 611 error_report("Input device '%s' is not a mouse", s->handler->name); 612 return; 613 } 614 found = 1; 615 qemu_input_handler_activate(s); 616 break; 617 } 618 619 if (!found) { 620 error_report("Mouse at index '%d' not found", index); 621 } 622 623 qemu_input_check_mode_change(); 624 } 625