console: add kbd_put_keysym_console

So you can send keysyms to a specific (text terminal) console. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
console: rework text terminal cursor logic
2014-05-26 08:41:02 +02:00 · 2014-05-26 08:41:02 +02:00 · 2014-05-26 08:41:02 +02:00 · 2014-05-26 08:41:02 +02:00 · 2014-05-26 08:41:02 +02:00
6 changed files with 141 additions and 358 deletions
--- a/hw/usb/dev-mtp.c
+++ b/hw/usb/dev-mtp.c
@@ -46,7 +46,6 @@ enum mtp_code {

    /* response codes */
    RES_OK                         = 0x2001,
-    RES_GENERAL_ERROR              = 0x2002,
    RES_SESSION_NOT_OPEN           = 0x2003,
    RES_INVALID_TRANSACTION_ID     = 0x2004,
    RES_OPERATION_NOT_SUPPORTED    = 0x2005,
@@ -110,8 +109,7 @@ struct MTPObject {
    struct stat  stat;
    MTPObject    *parent;
    MTPObject    **children;
-    uint32_t     nchildren;
-    bool         have_children;
+    int32_t      nchildren;
    QTAILQ_ENTRY(MTPObject) next;
 };

@@ -275,6 +273,7 @@ static MTPObject *usb_mtp_object_alloc(MTPState *s, uint32_t handle,
    o->handle = handle;
    o->parent = parent;
    o->name = g_strdup(name);
+    o->nchildren = -1;
    if (parent == NULL) {
        o->path = g_strdup(name);
    } else {
@@ -341,11 +340,7 @@ static void usb_mtp_object_readdir(MTPState *s, MTPObject *o)
    struct dirent *entry;
    DIR *dir;

-    if (o->have_children) {
-        return;
-    }
-    o->have_children = true;
-
+    o->nchildren = 0;
    dir = opendir(o->path);
    if (!dir) {
        return;
@@ -703,10 +698,7 @@ static MTPData *usb_mtp_get_partial_object(MTPState *s, MTPControl *c,
    if (offset > o->stat.st_size) {
        offset = o->stat.st_size;
    }
-    if (lseek(d->fd, offset, SEEK_SET) < 0) {
-        usb_mtp_data_free(d);
-        return NULL;
-    }
+    lseek(d->fd, offset, SEEK_SET);

    d->length = c->argv[2];
    if (d->length > o->stat.st_size - offset) {
@@ -797,7 +789,9 @@ static void usb_mtp_command(MTPState *s, MTPControl *c)
                                 c->trans, 0, 0, 0);
            return;
        }
-        usb_mtp_object_readdir(s, o);
+        if (o->nchildren == -1) {
+            usb_mtp_object_readdir(s, o);
+        }
        if (c->code == CMD_GET_NUM_OBJECTS) {
            trace_usb_mtp_op_get_num_objects(s->dev.addr, o->handle, o->path);
            nres = 1;
@@ -829,9 +823,7 @@ static void usb_mtp_command(MTPState *s, MTPControl *c)
        }
        data_in = usb_mtp_get_object(s, c, o);
        if (NULL == data_in) {
-            usb_mtp_queue_result(s, RES_GENERAL_ERROR,
-                                 c->trans, 0, 0, 0);
-            return;
+            fprintf(stderr, "%s: TODO: handle error\n", __func__);
        }
        break;
    case CMD_GET_PARTIAL_OBJECT:
@@ -848,9 +840,7 @@ static void usb_mtp_command(MTPState *s, MTPControl *c)
        }
        data_in = usb_mtp_get_partial_object(s, c, o);
        if (NULL == data_in) {
-            usb_mtp_queue_result(s, RES_GENERAL_ERROR,
-                                 c->trans, 0, 0, 0);
-            return;
+            fprintf(stderr, "%s: TODO: handle error\n", __func__);
        }
        nres = 1;
        res0 = data_in->length;
--- a/hw/usb/hcd-xhci.c
+++ b/hw/usb/hcd-xhci.c
@@ -621,11 +621,6 @@ static const char *ep_state_name(uint32_t state)
                       ARRAY_SIZE(ep_state_names));
 }

-static bool xhci_get_flag(XHCIState *xhci, enum xhci_flags bit)
-{
-    return xhci->flags & (1 << bit);
-}
-
 static uint64_t xhci_mfindex_get(XHCIState *xhci)
 {
    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
@@ -3440,7 +3435,7 @@ static void xhci_child_detach(USBPort *uport, USBDevice *child)
    USBBus *bus = usb_bus_from_device(child);
    XHCIState *xhci = container_of(bus, XHCIState, bus);

-    xhci_detach_slot(xhci, child->port);
+    xhci_detach_slot(xhci, uport);
 }

 static USBPortOps xhci_uport_ops = {
@@ -3599,15 +3594,13 @@ static int usb_xhci_initfn(struct PCIDevice *dev)
                     PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64,
                     &xhci->mem);

-    if (pci_bus_is_express(dev->bus)) {
-        ret = pcie_endpoint_cap_init(dev, 0xa0);
-        assert(ret >= 0);
-    }
+    ret = pcie_endpoint_cap_init(dev, 0xa0);
+    assert(ret >= 0);

-    if (xhci_get_flag(xhci, XHCI_FLAG_USE_MSI)) {
+    if (xhci->flags & (1 << XHCI_FLAG_USE_MSI)) {
        msi_init(dev, 0x70, xhci->numintrs, true, false);
    }
-    if (xhci_get_flag(xhci, XHCI_FLAG_USE_MSI_X)) {
+    if (xhci->flags & (1 << XHCI_FLAG_USE_MSI_X)) {
        msix_init(dev, xhci->numintrs,
                  &xhci->mem, 0, OFF_MSIX_TABLE,
                  &xhci->mem, 0, OFF_MSIX_PBA,
--- a/hw/usb/host-libusb.c
+++ b/hw/usb/host-libusb.c
@@ -720,9 +720,6 @@ static void usb_host_ep_update(USBHostDevice *s)
    struct libusb_config_descriptor *conf;
    const struct libusb_interface_descriptor *intf;
    const struct libusb_endpoint_descriptor *endp;
-#if LIBUSBX_API_VERSION >= 0x01000103
-    struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
-#endif
    uint8_t devep, type;
    int pid, ep;
    int rc, i, e;
@@ -768,15 +765,6 @@ static void usb_host_ep_update(USBHostDevice *s)
            usb_ep_set_type(udev, pid, ep, type);
            usb_ep_set_ifnum(udev, pid, ep, i);
            usb_ep_set_halted(udev, pid, ep, 0);
-#if LIBUSBX_API_VERSION >= 0x01000103
-            if (type == LIBUSB_TRANSFER_TYPE_BULK &&
-                    libusb_get_ss_endpoint_companion_descriptor(ctx, endp,
-                        &endp_ss_comp) == LIBUSB_SUCCESS) {
-                usb_ep_set_max_streams(udev, pid, ep,
-                                       endp_ss_comp->bmAttributes);
-                libusb_free_ss_endpoint_companion_descriptor(endp_ss_comp);
-            }
-#endif
        }
    }

@@ -1214,23 +1202,10 @@ static void usb_host_handle_data(USBDevice *udev, USBPacket *p)
            usb_packet_copy(p, r->buffer, size);
        }
        ep = p->ep->nr | (r->in ? USB_DIR_IN : 0);
-        if (p->stream) {
-#if LIBUSBX_API_VERSION >= 0x01000103
-            libusb_fill_bulk_stream_transfer(r->xfer, s->dh, ep, p->stream,
-                                             r->buffer, size,
-                                             usb_host_req_complete_data, r,
-                                             BULK_TIMEOUT);
-#else
-            usb_host_req_free(r);
-            p->status = USB_RET_STALL;
-            return;
-#endif
-        } else {
-            libusb_fill_bulk_transfer(r->xfer, s->dh, ep,
-                                      r->buffer, size,
-                                      usb_host_req_complete_data, r,
-                                      BULK_TIMEOUT);
-        }
+        libusb_fill_bulk_transfer(r->xfer, s->dh, ep,
+                                  r->buffer, size,
+                                  usb_host_req_complete_data, r,
+                                  BULK_TIMEOUT);
        break;
    case USB_ENDPOINT_XFER_INT:
        r = usb_host_req_alloc(s, p, p->pid == USB_TOKEN_IN, p->iov.size);
@@ -1293,54 +1268,6 @@ static void usb_host_handle_reset(USBDevice *udev)
    }
 }

-static int usb_host_alloc_streams(USBDevice *udev, USBEndpoint **eps,
-                                  int nr_eps, int streams)
-{
-#if LIBUSBX_API_VERSION >= 0x01000103
-    USBHostDevice *s = USB_HOST_DEVICE(udev);
-    unsigned char endpoints[30];
-    int i, rc;
-
-    for (i = 0; i < nr_eps; i++) {
-        endpoints[i] = eps[i]->nr;
-        if (eps[i]->pid == USB_TOKEN_IN) {
-            endpoints[i] |= 0x80;
-        }
-    }
-    rc = libusb_alloc_streams(s->dh, streams, endpoints, nr_eps);
-    if (rc < 0) {
-        usb_host_libusb_error("libusb_alloc_streams", rc);
-    } else if (rc != streams) {
-        fprintf(stderr,
-            "libusb_alloc_streams: got less streams then requested %d < %d\n",
-            rc, streams);
-    }
-
-    return (rc == streams) ? 0 : -1;
-#else
-    fprintf(stderr, "libusb_alloc_streams: error not implemented\n");
-    return -1;
-#endif
-}
-
-static void usb_host_free_streams(USBDevice *udev, USBEndpoint **eps,
-                                  int nr_eps)
-{
-#if LIBUSBX_API_VERSION >= 0x01000103
-    USBHostDevice *s = USB_HOST_DEVICE(udev);
-    unsigned char endpoints[30];
-    int i;
-
-    for (i = 0; i < nr_eps; i++) {
-        endpoints[i] = eps[i]->nr;
-        if (eps[i]->pid == USB_TOKEN_IN) {
-            endpoints[i] |= 0x80;
-        }
-    }
-    libusb_free_streams(s->dh, endpoints, nr_eps);
-#endif
-}
-
 /*
 * This is *NOT* about restoring state.  We have absolutely no idea
 * what state the host device is in at the moment and whenever it is
@@ -1422,8 +1349,6 @@ static void usb_host_class_initfn(ObjectClass *klass, void *data)
    uc->handle_reset   = usb_host_handle_reset;
    uc->handle_destroy = usb_host_handle_destroy;
    uc->flush_ep_queue = usb_host_flush_ep_queue;
-    uc->alloc_streams  = usb_host_alloc_streams;
-    uc->free_streams   = usb_host_free_streams;
    dc->vmsd = &vmstate_usb_host;
    dc->props = usb_host_dev_properties;
    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
--- a/hw/usb/redirect.c
+++ b/hw/usb/redirect.c
@@ -50,10 +50,6 @@
                       ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \
                       (i) & 0x0f))

-#ifndef USBREDIR_VERSION /* This is not defined in older usbredir versions */
-#define USBREDIR_VERSION 0
-#endif
-
 typedef struct USBRedirDevice USBRedirDevice;

 /* Struct to hold buffered packets */
@@ -72,7 +68,6 @@ struct endp_data {
    uint8_t interval;
    uint8_t interface; /* bInterfaceNumber this ep belongs to */
    uint16_t max_packet_size; /* In bytes, not wMaxPacketSize format !! */
-    uint32_t max_streams;
    uint8_t iso_started;
    uint8_t iso_error; /* For reporting iso errors to the HC */
    uint8_t interrupt_started;
@@ -111,9 +106,8 @@ struct USBRedirDevice {
    int read_buf_size;
    /* Active chardev-watch-tag */
    guint watch;
-    /* For async handling of close / reject */
+    /* For async handling of close */
    QEMUBH *chardev_close_bh;
-    QEMUBH *device_reject_bh;
    /* To delay the usb attach in case of quick chardev close + open */
    QEMUTimer *attach_timer;
    int64_t next_attach_time;
@@ -786,12 +780,11 @@ static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p,
        dev->endpoint[EP2I(ep)].bulk_receiving_enabled = 0;
    }

-    DPRINTF("bulk-out ep %02X stream %u len %zd id %"PRIu64"\n",
-            ep, p->stream, size, p->id);
+    DPRINTF("bulk-out ep %02X len %zd id %"PRIu64"\n", ep, size, p->id);

    bulk_packet.endpoint  = ep;
    bulk_packet.length    = size;
-    bulk_packet.stream_id = p->stream;
+    bulk_packet.stream_id = 0;
    bulk_packet.length_high = size >> 16;
    assert(bulk_packet.length_high == 0 ||
           usbredirparser_peer_has_cap(dev->parser,
@@ -1098,66 +1091,6 @@ static void usbredir_handle_control(USBDevice *udev, USBPacket *p,
    p->status = USB_RET_ASYNC;
 }

-static int usbredir_alloc_streams(USBDevice *udev, USBEndpoint **eps,
-                                  int nr_eps, int streams)
-{
-    USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
-#if USBREDIR_VERSION >= 0x000700
-    struct usb_redir_alloc_bulk_streams_header alloc_streams;
-    int i;
-
-    if (!usbredirparser_peer_has_cap(dev->parser,
-                                     usb_redir_cap_bulk_streams)) {
-        ERROR("peer does not support streams\n");
-        goto reject;
-    }
-
-    if (streams == 0) {
-        ERROR("request to allocate 0 streams\n");
-        return -1;
-    }
-
-    alloc_streams.no_streams = streams;
-    alloc_streams.endpoints = 0;
-    for (i = 0; i < nr_eps; i++) {
-        alloc_streams.endpoints |= 1 << USBEP2I(eps[i]);
-    }
-    usbredirparser_send_alloc_bulk_streams(dev->parser, 0, &alloc_streams);
-    usbredirparser_do_write(dev->parser);
-
-    return 0;
-#else
-    ERROR("usbredir_alloc_streams not implemented\n");
-    goto reject;
-#endif
-reject:
-    ERROR("streams are not available, disconnecting\n");
-    qemu_bh_schedule(dev->device_reject_bh);
-    return -1;
-}
-
-static void usbredir_free_streams(USBDevice *udev, USBEndpoint **eps,
-                                  int nr_eps)
-{
-#if USBREDIR_VERSION >= 0x000700
-    USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
-    struct usb_redir_free_bulk_streams_header free_streams;
-    int i;
-
-    if (!usbredirparser_peer_has_cap(dev->parser,
-                                     usb_redir_cap_bulk_streams)) {
-        return;
-    }
-
-    free_streams.endpoints = 0;
-    for (i = 0; i < nr_eps; i++) {
-        free_streams.endpoints |= 1 << USBEP2I(eps[i]);
-    }
-    usbredirparser_send_free_bulk_streams(dev->parser, 0, &free_streams);
-    usbredirparser_do_write(dev->parser);
-#endif
-}
-
 /*
 * Close events can be triggered by usbredirparser_do_write which gets called
 * from within the USBDevice data / control packet callbacks and doing a
@@ -1169,7 +1102,6 @@ static void usbredir_chardev_close_bh(void *opaque)
 {
    USBRedirDevice *dev = opaque;

-    qemu_bh_cancel(dev->device_reject_bh);
    usbredir_device_disconnect(dev);

    if (dev->parser) {
@@ -1221,9 +1153,6 @@ static void usbredir_create_parser(USBRedirDevice *dev)
    usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids);
    usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length);
    usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_receiving);
-#if USBREDIR_VERSION >= 0x000700
-    usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_streams);
-#endif

    if (runstate_check(RUN_STATE_INMIGRATE)) {
        flags |= usbredirparser_fl_no_hello;
@@ -1242,17 +1171,6 @@ static void usbredir_reject_device(USBRedirDevice *dev)
    }
 }

-/*
- * We may need to reject the device when the hcd calls alloc_streams, doing
- * an usb_detach from within a hcd call is not a good idea, hence this bh.
- */
-static void usbredir_device_reject_bh(void *opaque)
-{
-    USBRedirDevice *dev = opaque;
-
-    usbredir_reject_device(dev);
-}
-
 static void usbredir_do_attach(void *opaque)
 {
    USBRedirDevice *dev = opaque;
@@ -1379,7 +1297,6 @@ static int usbredir_initfn(USBDevice *udev)
    }

    dev->chardev_close_bh = qemu_bh_new(usbredir_chardev_close_bh, dev);
-    dev->device_reject_bh = qemu_bh_new(usbredir_device_reject_bh, dev);
    dev->attach_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, usbredir_do_attach, dev);

    packet_id_queue_init(&dev->cancelled, dev, "cancelled");
@@ -1420,7 +1337,6 @@ static void usbredir_handle_destroy(USBDevice *udev)
    dev->cs = NULL;
    /* Note must be done after qemu_chr_close, as that causes a close event */
    qemu_bh_delete(dev->chardev_close_bh);
-    qemu_bh_delete(dev->device_reject_bh);

    timer_del(dev->attach_timer);
    timer_free(dev->attach_timer);
@@ -1712,7 +1628,6 @@ static void usbredir_setup_usb_eps(USBRedirDevice *dev)
        usb_ep->type = dev->endpoint[i].type;
        usb_ep->ifnum = dev->endpoint[i].interface;
        usb_ep->max_packet_size = dev->endpoint[i].max_packet_size;
-        usb_ep->max_streams = dev->endpoint[i].max_streams;
        usbredir_set_pipeline(dev, usb_ep);
    }
 }
@@ -1731,12 +1646,6 @@ static void usbredir_ep_info(void *priv,
                                     usb_redir_cap_ep_info_max_packet_size)) {
            dev->endpoint[i].max_packet_size = ep_info->max_packet_size[i];
        }
-#if USBREDIR_VERSION >= 0x000700
-        if (usbredirparser_peer_has_cap(dev->parser,
-                                        usb_redir_cap_bulk_streams)) {
-            dev->endpoint[i].max_streams = ep_info->max_streams[i];
-        }
-#endif
        switch (dev->endpoint[i].type) {
        case usb_redir_type_invalid:
            break;
@@ -1870,20 +1779,6 @@ static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
 static void usbredir_bulk_streams_status(void *priv, uint64_t id,
    struct usb_redir_bulk_streams_status_header *bulk_streams_status)
 {
-#if USBREDIR_VERSION >= 0x000700
-    USBRedirDevice *dev = priv;
-
-    if (bulk_streams_status->status == usb_redir_success) {
-        DPRINTF("bulk streams status %d eps %08x\n",
-                bulk_streams_status->status, bulk_streams_status->endpoints);
-    } else {
-        ERROR("bulk streams %s failed status %d eps %08x\n",
-              (bulk_streams_status->no_streams == 0) ? "free" : "alloc",
-              bulk_streams_status->status, bulk_streams_status->endpoints);
-        ERROR("usb-redir-host does not provide streams, disconnecting\n");
-        usbredir_reject_device(dev);
-    }
-#endif
 }

 static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
@@ -1955,8 +1850,8 @@ static void usbredir_bulk_packet(void *priv, uint64_t id,
    int len = (bulk_packet->length_high << 16) | bulk_packet->length;
    USBPacket *p;

-    DPRINTF("bulk-in status %d ep %02X stream %u len %d id %"PRIu64"\n",
-            bulk_packet->status, ep, bulk_packet->stream_id, len, id);
+    DPRINTF("bulk-in status %d ep %02X len %d id %"PRIu64"\n",
+            bulk_packet->status, ep, len, id);

    p = usbredir_find_packet_by_id(dev, ep, id);
    if (p) {
@@ -2270,23 +2165,6 @@ static bool usbredir_bulk_receiving_needed(void *priv)
    return endp->bulk_receiving_started;
 }

-static const VMStateDescription usbredir_stream_vmstate = {
-    .name = "usb-redir-ep/stream-state",
-    .version_id = 1,
-    .minimum_version_id = 1,
-    .fields = (VMStateField[]) {
-        VMSTATE_UINT32(max_streams, struct endp_data),
-        VMSTATE_END_OF_LIST()
-    }
-};
-
-static bool usbredir_stream_needed(void *priv)
-{
-    struct endp_data *endp = priv;
-
-    return endp->max_streams;
-}
-
 static const VMStateDescription usbredir_ep_vmstate = {
    .name = "usb-redir-ep",
    .version_id = 1,
@@ -2318,9 +2196,6 @@ static const VMStateDescription usbredir_ep_vmstate = {
        {
            .vmsd = &usbredir_bulk_receiving_vmstate,
            .needed = usbredir_bulk_receiving_needed,
-        }, {
-            .vmsd = &usbredir_stream_vmstate,
-            .needed = usbredir_stream_needed,
        }, {
            /* empty */
        }
@@ -2486,8 +2361,6 @@ static void usbredir_class_initfn(ObjectClass *klass, void *data)
    uc->handle_control = usbredir_handle_control;
    uc->flush_ep_queue = usbredir_flush_ep_queue;
    uc->ep_stopped     = usbredir_ep_stopped;
-    uc->alloc_streams  = usbredir_alloc_streams;
-    uc->free_streams   = usbredir_free_streams;
    dc->vmsd           = &usbredir_vmstate;
    dc->props          = usbredir_properties;
    set_bit(DEVICE_CATEGORY_MISC, dc->categories);
--- a/include/ui/console.h
+++ b/include/ui/console.h
@@ -81,6 +81,7 @@ void do_mouse_set(Monitor *mon, const QDict *qdict);
 #define QEMU_KEY_CTRL_PAGEUP     0xe406
 #define QEMU_KEY_CTRL_PAGEDOWN   0xe407

+void kbd_put_keysym_console(QemuConsole *s, int keysym);
 void kbd_put_keysym(int keysym);

 /* consoles */
--- a/ui/console.c
+++ b/ui/console.c
@@ -143,8 +143,6 @@ struct QemuConsole {
    TextCell *cells;
    int text_x[2], text_y[2], cursor_invalidate;
    int echo;
-    bool cursor_visible_phase;
-    QEMUTimer *cursor_timer;

    int update_x0;
    int update_y0;
@@ -177,10 +175,14 @@ static DisplayState *display_state;
 static QemuConsole *active_console;
 static QemuConsole *consoles[MAX_CONSOLES];
 static int nb_consoles = 0;
+static bool cursor_visible_phase;
+static QEMUTimer *cursor_timer;

 static void text_console_do_init(CharDriverState *chr, DisplayState *ds);
 static void dpy_refresh(DisplayState *s);
 static DisplayState *get_alloc_displaystate(void);
+static void text_console_update_cursor_timer(void);
+static void text_console_update_cursor(void *opaque);

 static void gui_update(void *opaque)
 {
@@ -475,6 +477,9 @@ static inline void text_update_xy(QemuConsole *s, int x, int y)

 static void invalidate_xy(QemuConsole *s, int x, int y)
 {
+    if (!qemu_console_is_visible(s)) {
+        return;
+    }
    if (s->update_x0 > x * FONT_WIDTH)
        s->update_x0 = x * FONT_WIDTH;
    if (s->update_y0 > y * FONT_HEIGHT)
@@ -490,25 +495,20 @@ static void update_xy(QemuConsole *s, int x, int y)
    TextCell *c;
    int y1, y2;

-    if (!qemu_console_is_visible(s)) {
-        return;
-    }
-
    if (s->ds->have_text) {
        text_update_xy(s, x, y);
    }

-    if (s->ds->have_gfx) {
-        y1 = (s->y_base + y) % s->total_height;
-        y2 = y1 - s->y_displayed;
-        if (y2 < 0)
-            y2 += s->total_height;
-        if (y2 < s->height) {
-            c = &s->cells[y1 * s->width + x];
-            vga_putcharxy(s, x, y2, c->ch,
-                          &(c->t_attrib));
-            invalidate_xy(s, x, y2);
-        }
+    y1 = (s->y_base + y) % s->total_height;
+    y2 = y1 - s->y_displayed;
+    if (y2 < 0) {
+        y2 += s->total_height;
+    }
+    if (y2 < s->height) {
+        c = &s->cells[y1 * s->width + x];
+        vga_putcharxy(s, x, y2, c->ch,
+                      &(c->t_attrib));
+        invalidate_xy(s, x, y2);
    }
 }

@@ -518,33 +518,28 @@ static void console_show_cursor(QemuConsole *s, int show)
    int y, y1;
    int x = s->x;

-    if (!qemu_console_is_visible(s)) {
-        return;
-    }
-
    if (s->ds->have_text) {
        s->cursor_invalidate = 1;
    }

-    if (s->ds->have_gfx) {
-        if (x >= s->width) {
-            x = s->width - 1;
-        }
-        y1 = (s->y_base + s->y) % s->total_height;
-        y = y1 - s->y_displayed;
-        if (y < 0)
-            y += s->total_height;
-        if (y < s->height) {
-            c = &s->cells[y1 * s->width + x];
-            if (show && s->cursor_visible_phase) {
-                TextAttributes t_attrib = s->t_attrib_default;
-                t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
-                vga_putcharxy(s, x, y, c->ch, &t_attrib);
-            } else {
-                vga_putcharxy(s, x, y, c->ch, &(c->t_attrib));
-            }
-            invalidate_xy(s, x, y);
+    if (x >= s->width) {
+        x = s->width - 1;
+    }
+    y1 = (s->y_base + s->y) % s->total_height;
+    y = y1 - s->y_displayed;
+    if (y < 0) {
+        y += s->total_height;
+    }
+    if (y < s->height) {
+        c = &s->cells[y1 * s->width + x];
+        if (show && cursor_visible_phase) {
+            TextAttributes t_attrib = s->t_attrib_default;
+            t_attrib.invers = !(t_attrib.invers); /* invert fg and bg */
+            vga_putcharxy(s, x, y, c->ch, &t_attrib);
+        } else {
+            vga_putcharxy(s, x, y, c->ch, &(c->t_attrib));
        }
+        invalidate_xy(s, x, y);
    }
 }

@@ -554,10 +549,6 @@ static void console_refresh(QemuConsole *s)
    TextCell *c;
    int x, y, y1;

-    if (!qemu_console_is_visible(s)) {
-        return;
-    }
-
    if (s->ds->have_text) {
        s->text_x[0] = 0;
        s->text_y[0] = 0;
@@ -566,25 +557,23 @@ static void console_refresh(QemuConsole *s)
        s->cursor_invalidate = 1;
    }

-    if (s->ds->have_gfx) {
-        vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface),
-                      color_table_rgb[0][COLOR_BLACK]);
-        y1 = s->y_displayed;
-        for (y = 0; y < s->height; y++) {
-            c = s->cells + y1 * s->width;
-            for (x = 0; x < s->width; x++) {
-                vga_putcharxy(s, x, y, c->ch,
-                              &(c->t_attrib));
-                c++;
-            }
-            if (++y1 == s->total_height) {
-                y1 = 0;
-            }
+    vga_fill_rect(s, 0, 0, surface_width(surface), surface_height(surface),
+                  color_table_rgb[0][COLOR_BLACK]);
+    y1 = s->y_displayed;
+    for (y = 0; y < s->height; y++) {
+        c = s->cells + y1 * s->width;
+        for (x = 0; x < s->width; x++) {
+            vga_putcharxy(s, x, y, c->ch,
+                          &(c->t_attrib));
+            c++;
+        }
+        if (++y1 == s->total_height) {
+            y1 = 0;
        }
-        console_show_cursor(s, 1);
-        dpy_gfx_update(s, 0, 0,
-                       surface_width(surface), surface_height(surface));
    }
+    console_show_cursor(s, 1);
+    dpy_gfx_update(s, 0, 0,
+                   surface_width(surface), surface_height(surface));
 }

 static void console_scroll(QemuConsole *s, int ydelta)
@@ -640,7 +629,7 @@ static void console_put_lf(QemuConsole *s)
            c->t_attrib = s->t_attrib_default;
            c++;
        }
-        if (qemu_console_is_visible(s) && s->y_displayed == s->y_base) {
+        if (s->y_displayed == s->y_base) {
            if (s->ds->have_text) {
                s->text_x[0] = 0;
                s->text_y[0] = 0;
@@ -648,18 +637,16 @@ static void console_put_lf(QemuConsole *s)
                s->text_y[1] = s->height - 1;
            }

-            if (s->ds->have_gfx) {
-                vga_bitblt(s, 0, FONT_HEIGHT, 0, 0,
-                           s->width * FONT_WIDTH,
-                           (s->height - 1) * FONT_HEIGHT);
-                vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT,
-                              s->width * FONT_WIDTH, FONT_HEIGHT,
-                              color_table_rgb[0][s->t_attrib_default.bgcol]);
-                s->update_x0 = 0;
-                s->update_y0 = 0;
-                s->update_x1 = s->width * FONT_WIDTH;
-                s->update_y1 = s->height * FONT_HEIGHT;
-            }
+            vga_bitblt(s, 0, FONT_HEIGHT, 0, 0,
+                       s->width * FONT_WIDTH,
+                       (s->height - 1) * FONT_HEIGHT);
+            vga_fill_rect(s, 0, (s->height - 1) * FONT_HEIGHT,
+                          s->width * FONT_WIDTH, FONT_HEIGHT,
+                          color_table_rgb[0][s->t_attrib_default.bgcol]);
+            s->update_x0 = 0;
+            s->update_y0 = 0;
+            s->update_x1 = s->width * FONT_WIDTH;
+            s->update_y1 = s->height * FONT_HEIGHT;
        }
    }
 }
@@ -1004,9 +991,6 @@ void console_select(unsigned int index)
    if (s) {
        DisplayState *ds = s->ds;

-        if (active_console && active_console->cursor_timer) {
-            timer_del(active_console->cursor_timer);
-        }
        active_console = s;
        if (ds->have_gfx) {
            QLIST_FOREACH(dcl, &ds->listeners, next) {
@@ -1023,10 +1007,7 @@ void console_select(unsigned int index)
        if (ds->have_text) {
            dpy_text_resize(s, s->width, s->height);
        }
-        if (s->cursor_timer) {
-            timer_mod(s->cursor_timer,
-                   qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2);
-        }
+        text_console_update_cursor(NULL);
    }
 }

@@ -1075,13 +1056,11 @@ static void kbd_send_chars(void *opaque)
 }

 /* called when an ascii key is pressed */
-void kbd_put_keysym(int keysym)
+void kbd_put_keysym_console(QemuConsole *s, int keysym)
 {
-    QemuConsole *s;
    uint8_t buf[16], *q;
    int c;

-    s = active_console;
    if (!s || (s->console_type == GRAPHIC_CONSOLE))
        return;

@@ -1130,6 +1109,11 @@ void kbd_put_keysym(int keysym)
    }
 }

+void kbd_put_keysym(int keysym)
+{
+    kbd_put_keysym_console(active_console, keysym);
+}
+
 static void text_console_invalidate(void *opaque)
 {
    QemuConsole *s = (QemuConsole *) opaque;
@@ -1167,9 +1151,9 @@ static void text_console_update(void *opaque, console_ch_t *chardata)
    }
 }

-static QemuConsole *new_console(DisplayState *ds, console_type_t console_type)
+static QemuConsole *new_console(DisplayState *ds, console_type_t console_type,
+                                uint32_t head)
 {
-    Error *local_err = NULL;
    Object *obj;
    QemuConsole *s;
    int i;
@@ -1179,13 +1163,14 @@ static QemuConsole *new_console(DisplayState *ds, console_type_t console_type)

    obj = object_new(TYPE_QEMU_CONSOLE);
    s = QEMU_CONSOLE(obj);
+    s->head = head;
    object_property_add_link(obj, "device", TYPE_DEVICE,
                             (Object **)&s->device,
                             object_property_allow_set_link,
                             OBJ_PROP_LINK_UNREF_ON_RELEASE,
-                             &local_err);
+                             &error_abort);
    object_property_add_uint32_ptr(obj, "head",
-                                   &s->head, &local_err);
+                                   &s->head, &error_abort);

    if (!active_console || ((active_console->console_type != GRAPHIC_CONSOLE) &&
        (console_type == GRAPHIC_CONSOLE))) {
@@ -1270,19 +1255,18 @@ DisplaySurface *qemu_create_displaysurface_from(int width, int height, int bpp,
    return surface;
 }

-static DisplaySurface *qemu_create_dummy_surface(void)
+static DisplaySurface *qemu_create_message_surface(int w, int h,
+                                                   const char *msg)
 {
-    static const char msg[] =
-        "This VM has no graphic display device.";
-    DisplaySurface *surface = qemu_create_displaysurface(640, 480);
+    DisplaySurface *surface = qemu_create_displaysurface(w, h);
    pixman_color_t bg = color_table_rgb[0][COLOR_BLACK];
    pixman_color_t fg = color_table_rgb[0][COLOR_WHITE];
    pixman_image_t *glyph;
    int len, x, y, i;

    len = strlen(msg);
-    x = (640/FONT_WIDTH  - len) / 2;
-    y = (480/FONT_HEIGHT - 1)   / 2;
+    x = (w / FONT_WIDTH  - len) / 2;
+    y = (h / FONT_HEIGHT - 1)   / 2;
    for (i = 0; i < len; i++) {
        glyph = qemu_pixman_glyph_from_vgafont(FONT_HEIGHT, vgafont16, msg[i]);
        qemu_pixman_glyph_render(glyph, surface->image, &fg, &bg,
@@ -1304,6 +1288,8 @@ void qemu_free_displaysurface(DisplaySurface *surface)

 void register_displaychangelistener(DisplayChangeListener *dcl)
 {
+    static const char nodev[] =
+        "This VM has no graphic display device.";
    static DisplaySurface *dummy;
    QemuConsole *con;

@@ -1322,11 +1308,12 @@ void register_displaychangelistener(DisplayChangeListener *dcl)
            dcl->ops->dpy_gfx_switch(dcl, con->surface);
        } else {
            if (!dummy) {
-                dummy = qemu_create_dummy_surface();
+                dummy = qemu_create_message_surface(640, 480, nodev);
            }
            dcl->ops->dpy_gfx_switch(dcl, dummy);
        }
    }
+    text_console_update_cursor(NULL);
 }

 void update_displaychangelistener(DisplayChangeListener *dcl,
@@ -1550,6 +1537,8 @@ static DisplayState *get_alloc_displaystate(void)
 {
    if (!display_state) {
        display_state = g_new0(DisplayState, 1);
+        cursor_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
+                                    text_console_update_cursor, NULL);
    }
    return display_state;
 }
@@ -1560,7 +1549,6 @@ static DisplayState *get_alloc_displaystate(void)
 */
 DisplayState *init_displaystate(void)
 {
-    Error *local_err = NULL;
    gchar *name;
    int i;

@@ -1579,7 +1567,7 @@ DisplayState *init_displaystate(void)
         * doesn't change any more */
        name = g_strdup_printf("console[%d]", i);
        object_property_add_child(container_get(object_get_root(), "/backend"),
-                                  name, OBJECT(consoles[i]), &local_err);
+                                  name, OBJECT(consoles[i]), &error_abort);
        g_free(name);
    }

@@ -1590,7 +1578,8 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
                                  const GraphicHwOps *hw_ops,
                                  void *opaque)
 {
-    Error *local_err = NULL;
+    static const char noinit[] =
+        "Guest has not initialized the display (yet).";
    int width = 640;
    int height = 480;
    QemuConsole *s;
@@ -1598,17 +1587,15 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,

    ds = get_alloc_displaystate();
    trace_console_gfx_new();
-    s = new_console(ds, GRAPHIC_CONSOLE);
+    s = new_console(ds, GRAPHIC_CONSOLE, head);
    s->hw_ops = hw_ops;
    s->hw = opaque;
    if (dev) {
-        object_property_set_link(OBJECT(s), OBJECT(dev),
-                                 "device", &local_err);
-        object_property_set_int(OBJECT(s), head,
-                                "head", &local_err);
+        object_property_set_link(OBJECT(s), OBJECT(dev), "device",
+                                 &error_abort);
    }

-    s->surface = qemu_create_displaysurface(width, height);
+    s->surface = qemu_create_message_surface(width, height, noinit);
    return s;
 }

@@ -1622,7 +1609,6 @@ QemuConsole *qemu_console_lookup_by_index(unsigned int index)

 QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
 {
-    Error *local_err = NULL;
    Object *obj;
    uint32_t h;
    int i;
@@ -1632,12 +1618,12 @@ QemuConsole *qemu_console_lookup_by_device(DeviceState *dev, uint32_t head)
            continue;
        }
        obj = object_property_get_link(OBJECT(consoles[i]),
-                                       "device", &local_err);
+                                       "device", &error_abort);
        if (DEVICE(obj) != dev) {
            continue;
        }
        h = object_property_get_int(OBJECT(consoles[i]),
-                                    "head", &local_err);
+                                    "head", &error_abort);
        if (h != head) {
            continue;
        }
@@ -1712,14 +1698,32 @@ static void text_console_set_echo(CharDriverState *chr, bool echo)
    s->echo = echo;
 }

+static void text_console_update_cursor_timer(void)
+{
+    timer_mod(cursor_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
+              + CONSOLE_CURSOR_PERIOD / 2);
+}
+
 static void text_console_update_cursor(void *opaque)
 {
-    QemuConsole *s = opaque;
+    QemuConsole *s;
+    int i, count = 0;

-    s->cursor_visible_phase = !s->cursor_visible_phase;
-    graphic_hw_invalidate(s);
-    timer_mod(s->cursor_timer,
-                   qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + CONSOLE_CURSOR_PERIOD / 2);
+    cursor_visible_phase = !cursor_visible_phase;
+
+    for (i = 0; i < nb_consoles; i++) {
+        s = consoles[i];
+        if (qemu_console_is_graphic(s) ||
+            !qemu_console_is_visible(s)) {
+            continue;
+        }
+        count++;
+        graphic_hw_invalidate(s);
+    }
+
+    if (count) {
+        text_console_update_cursor_timer();
+    }
 }

 static const GraphicHwOps text_console_ops = {
@@ -1755,9 +1759,6 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
        s->surface = qemu_create_displaysurface(g_width, g_height);
    }

-    s->cursor_timer =
-        timer_new_ms(QEMU_CLOCK_REALTIME, text_console_update_cursor, s);
-
    s->hw_ops = &text_console_ops;
    s->hw = s;

@@ -1811,9 +1812,9 @@ static CharDriverState *text_console_init(ChardevVC *vc)

    trace_console_txt_new(width, height);
    if (width == 0 || height == 0) {
-        s = new_console(NULL, TEXT_CONSOLE);
+        s = new_console(NULL, TEXT_CONSOLE, 0);
    } else {
-        s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE);
+        s = new_console(NULL, TEXT_CONSOLE_FIXED_SIZE, 0);
        s->surface = qemu_create_displaysurface(width, height);
    }
Author	SHA1	Message	Date
Gerd Hoffmann	3f9a6e852e	console: add kbd_put_keysym_console So you can send keysyms to a specific (text terminal) console. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:02 +02:00
Gerd Hoffmann	aea7947c74	console: rework text terminal cursor logic Have a global timer. Update all visible terminal windows syncronously. Right now this can be the active_console only, but that will change soon. The global timer will disable itself if not needed, so we only have to care start it if needed. Which might be at console switch time or when a new displaychangelistener is registered. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:02 +02:00
Gerd Hoffmann	b35e3ba01a	console: update text terminal surface unconditionally These days each QemuConsole has its own private DisplaySurface, so we can simply render updates all the time. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:02 +02:00
Gerd Hoffmann	521a580d23	console: nicer initial screen Now that we have a function to create a fancy DisplaySurface with a message for the user, to handle non-existing graphics hardware, we can make it more generic and use it for other things too. This patch adds a text line to the in initial DisplaySurface, notifying the user that the display isn't initialized yet by the guest. You can see this in action when starting qemu with '-S'. Also when booting ovmf in qemu (which needs a few moments to initialize itself before it initializes the vga). Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:02 +02:00
Kirill Batuzov	afff2b15e8	console: Abort on property access errors All defined properties of QemuConsole are mandatory and no access to them should fail. Nevertheless not checking returned errors is bad because in case of unexpected failure it will hide the bug and cause a memory leak. Abort in case of unexpected property access errors. This change exposed a bug where an attempt was made to write to a read-only property "head". Set "head" property's value at creation time and do not attempt to change it later. This fixes the bug mentioned above. Signed-off-by: Kirill Batuzov <batuzovk@ispras.ru> Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>	2014-05-26 08:41:02 +02:00