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