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