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