File:  [Qemu by Fabrice Bellard] / qemu / hw / virtio-console.c
Revision 1.1.1.3 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 17:39:45 2018 UTC (2 years, 2 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu0125, qemu0124, qemu0123, qemu0122, qemu0121, qemu0120, HEAD
qemu 0.12.0

    1: /*
    2:  * Virtio Console Device
    3:  *
    4:  * Copyright IBM, Corp. 2008
    5:  *
    6:  * Authors:
    7:  *  Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
    8:  *
    9:  * This work is licensed under the terms of the GNU GPL, version 2.  See
   10:  * the COPYING file in the top-level directory.
   11:  *
   12:  */
   13: 
   14: #include "hw.h"
   15: #include "qemu-char.h"
   16: #include "virtio.h"
   17: #include "virtio-console.h"
   18: 
   19: 
   20: typedef struct VirtIOConsole
   21: {
   22:     VirtIODevice vdev;
   23:     VirtQueue *ivq, *ovq;
   24:     CharDriverState *chr;
   25: } VirtIOConsole;
   26: 
   27: static VirtIOConsole *to_virtio_console(VirtIODevice *vdev)
   28: {
   29:     return (VirtIOConsole *)vdev;
   30: }
   31: 
   32: static void virtio_console_handle_output(VirtIODevice *vdev, VirtQueue *vq)
   33: {
   34:     VirtIOConsole *s = to_virtio_console(vdev);
   35:     VirtQueueElement elem;
   36: 
   37:     while (virtqueue_pop(vq, &elem)) {
   38:         ssize_t len = 0;
   39:         int d;
   40: 
   41:         for (d = 0; d < elem.out_num; d++) {
   42:             len += qemu_chr_write(s->chr, (uint8_t *)elem.out_sg[d].iov_base,
   43:                                   elem.out_sg[d].iov_len);
   44:         }
   45:         virtqueue_push(vq, &elem, len);
   46:         virtio_notify(vdev, vq);
   47:     }
   48: }
   49: 
   50: static void virtio_console_handle_input(VirtIODevice *vdev, VirtQueue *vq)
   51: {
   52: }
   53: 
   54: static uint32_t virtio_console_get_features(VirtIODevice *vdev)
   55: {
   56:     return 0;
   57: }
   58: 
   59: static int vcon_can_read(void *opaque)
   60: {
   61:     VirtIOConsole *s = (VirtIOConsole *) opaque;
   62: 
   63:     if (!virtio_queue_ready(s->ivq) ||
   64:         !(s->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) ||
   65:         virtio_queue_empty(s->ivq))
   66:         return 0;
   67: 
   68:     /* current implementations have a page sized buffer.
   69:      * We fall back to a one byte per read if there is not enough room.
   70:      * It would be cool to have a function that returns the available byte
   71:      * instead of checking for a limit */
   72:     if (virtqueue_avail_bytes(s->ivq, TARGET_PAGE_SIZE, 0))
   73:         return TARGET_PAGE_SIZE;
   74:     if (virtqueue_avail_bytes(s->ivq, 1, 0))
   75:         return 1;
   76:     return 0;
   77: }
   78: 
   79: static void vcon_read(void *opaque, const uint8_t *buf, int size)
   80: {
   81:     VirtIOConsole *s = (VirtIOConsole *) opaque;
   82:     VirtQueueElement elem;
   83:     int offset = 0;
   84: 
   85:     /* The current kernel implementation has only one outstanding input
   86:      * buffer of PAGE_SIZE. Nevertheless, this function is prepared to
   87:      * handle multiple buffers with multiple sg element for input */
   88:     while (offset < size) {
   89:         int i = 0;
   90:         if (!virtqueue_pop(s->ivq, &elem))
   91:                 break;
   92:         while (offset < size && i < elem.in_num) {
   93:             int len = MIN(elem.in_sg[i].iov_len, size - offset);
   94:             memcpy(elem.in_sg[i].iov_base, buf + offset, len);
   95:             offset += len;
   96:             i++;
   97:         }
   98:         virtqueue_push(s->ivq, &elem, size);
   99:     }
  100:     virtio_notify(&s->vdev, s->ivq);
  101: }
  102: 
  103: static void vcon_event(void *opaque, int event)
  104: {
  105:     /* we will ignore any event for the time being */
  106: }
  107: 
  108: static void virtio_console_save(QEMUFile *f, void *opaque)
  109: {
  110:     VirtIOConsole *s = opaque;
  111: 
  112:     virtio_save(&s->vdev, f);
  113: }
  114: 
  115: static int virtio_console_load(QEMUFile *f, void *opaque, int version_id)
  116: {
  117:     VirtIOConsole *s = opaque;
  118: 
  119:     if (version_id != 1)
  120:         return -EINVAL;
  121: 
  122:     virtio_load(&s->vdev, f);
  123:     return 0;
  124: }
  125: 
  126: VirtIODevice *virtio_console_init(DeviceState *dev)
  127: {
  128:     VirtIOConsole *s;
  129:     s = (VirtIOConsole *)virtio_common_init("virtio-console",
  130:                                             VIRTIO_ID_CONSOLE,
  131:                                             0, sizeof(VirtIOConsole));
  132:     s->vdev.get_features = virtio_console_get_features;
  133: 
  134:     s->ivq = virtio_add_queue(&s->vdev, 128, virtio_console_handle_input);
  135:     s->ovq = virtio_add_queue(&s->vdev, 128, virtio_console_handle_output);
  136: 
  137:     s->chr = qdev_init_chardev(dev);
  138:     qemu_chr_add_handlers(s->chr, vcon_can_read, vcon_read, vcon_event, s);
  139: 
  140:     register_savevm("virtio-console", -1, 1, virtio_console_save, virtio_console_load, s);
  141: 
  142:     return &s->vdev;
  143: }

unix.superglobalmegacorp.com