include/hw/virtio/virtio-serial.h

   1 /*
   2  * Virtio Serial / Console Support
   3  *
   4  * Copyright IBM, Corp. 2008
   5  * Copyright Red Hat, Inc. 2009, 2010
   6  *
   7  * Authors:
   8  *  Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
   9  *  Amit Shah <amit.shah@redhat.com>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2.  See
  12  * the COPYING file in the top-level directory.
  13  *
  14  */
  15
  16 #ifndef QEMU_VIRTIO_SERIAL_H
  17 #define QEMU_VIRTIO_SERIAL_H
  18
  19 #include "standard-headers/linux/virtio_console.h"
  20 #include "hw/qdev.h"
  21 #include "hw/virtio/virtio.h"
  22
  23 struct virtio_serial_conf {
  24     /* Max. number of ports we can have for a virtio-serial device */
  25     uint32_t max_virtserial_ports;
  26 };
  27
  28 #define TYPE_VIRTIO_SERIAL_PORT "virtio-serial-port"
  29 #define VIRTIO_SERIAL_PORT(obj) \
  30      OBJECT_CHECK(VirtIOSerialPort, (obj), TYPE_VIRTIO_SERIAL_PORT)
  31 #define VIRTIO_SERIAL_PORT_CLASS(klass) \
  32      OBJECT_CLASS_CHECK(VirtIOSerialPortClass, (klass), TYPE_VIRTIO_SERIAL_PORT)
  33 #define VIRTIO_SERIAL_PORT_GET_CLASS(obj) \
  34      OBJECT_GET_CLASS(VirtIOSerialPortClass, (obj), TYPE_VIRTIO_SERIAL_PORT)
  35
  36 typedef struct VirtIOSerial VirtIOSerial;
  37 typedef struct VirtIOSerialBus VirtIOSerialBus;
  38 typedef struct VirtIOSerialPort VirtIOSerialPort;
  39
  40 typedef struct VirtIOSerialPortClass {
  41     DeviceClass parent_class;
  42
  43     /* Is this a device that binds with hvc in the guest? */
  44     bool is_console;
  45
  46     /*
  47      * The per-port (or per-app) realize function that's called when a
  48      * new device is found on the bus.
  49      */
  50     DeviceRealize realize;
  51     /*
  52      * Per-port unrealize function that's called when a port gets
  53      * hot-unplugged or removed.
  54      */
  55     DeviceUnrealize unrealize;
  56
  57     /* Callbacks for guest events */
  58         /* Guest opened/closed device. */
  59     void (*set_guest_connected)(VirtIOSerialPort *port, int guest_connected);
  60
  61         /* Guest is now ready to accept data (virtqueues set up). */
  62     void (*guest_ready)(VirtIOSerialPort *port);
  63
  64         /*
  65          * Guest has enqueued a buffer for the host to write into.
  66          * Called each time a buffer is enqueued by the guest;
  67          * irrespective of whether there already were free buffers the
  68          * host could have consumed.
  69          *
  70          * This is dependent on both the guest and host end being
  71          * connected.
  72          */
  73     void (*guest_writable)(VirtIOSerialPort *port);
  74
  75     /*
  76      * Guest wrote some data to the port. This data is handed over to
  77      * the app via this callback.  The app can return a size less than
  78      * 'len'.  In this case, throttling will be enabled for this port.
  79      */
  80     ssize_t (*have_data)(VirtIOSerialPort *port, const uint8_t *buf,
  81                          ssize_t len);
  82 } VirtIOSerialPortClass;
  83
  84 /*
  85  * This is the state that's shared between all the ports.  Some of the
  86  * state is configurable via command-line options. Some of it can be
  87  * set by individual devices in their initfn routines. Some of the
  88  * state is set by the generic qdev device init routine.
  89  */
  90 struct VirtIOSerialPort {
  91     DeviceState dev;
  92
  93     QTAILQ_ENTRY(VirtIOSerialPort) next;
  94
  95     /*
  96      * This field gives us the virtio device as well as the qdev bus
  97      * that we are associated with
  98      */
  99     VirtIOSerial *vser;
 100
 101     VirtQueue *ivq, *ovq;
 102
 103     /*
 104      * This name is sent to the guest and exported via sysfs.
 105      * The guest could create symlinks based on this information.
 106      * The name is in the reverse fqdn format, like org.qemu.console.0
 107      */
 108     char *name;
 109
 110     /*
 111      * This id helps identify ports between the guest and the host.
 112      * The guest sends a "header" with this id with each data packet
 113      * that it sends and the host can then find out which associated
 114      * device to send out this data to
 115      */
 116     uint32_t id;
 117
 118     /*
 119      * This is the elem that we pop from the virtqueue.  A slow
 120      * backend that consumes guest data (e.g. the file backend for
 121      * qemu chardevs) can cause the guest to block till all the output
 122      * is flushed.  This isn't desired, so we keep a note of the last
 123      * element popped and continue consuming it once the backend
 124      * becomes writable again.
 125      */
 126     VirtQueueElement *elem;
 127
 128     /*
 129      * The index and the offset into the iov buffer that was popped in
 130      * elem above.
 131      */
 132     uint32_t iov_idx;
 133     uint64_t iov_offset;
 134
 135     /*
 136      * When unthrottling we use a bottom-half to call flush_queued_data.
 137      */
 138     QEMUBH *bh;
 139
 140     /* Is the corresponding guest device open? */
 141     bool guest_connected;
 142     /* Is this device open for IO on the host? */
 143     bool host_connected;
 144     /* Do apps not want to receive data? */
 145     bool throttled;
 146 };
 147
 148 /* The virtio-serial bus on top of which the ports will ride as devices */
 149 struct VirtIOSerialBus {
 150     BusState qbus;
 151
 152     /* This is the parent device that provides the bus for ports. */
 153     VirtIOSerial *vser;
 154
 155     /* The maximum number of ports that can ride on top of this bus */
 156     uint32_t max_nr_ports;
 157 };
 158
 159 typedef struct VirtIOSerialPostLoad {
 160     QEMUTimer *timer;
 161     uint32_t nr_active_ports;
 162     struct {
 163         VirtIOSerialPort *port;
 164         uint8_t host_connected;
 165     } *connected;
 166 } VirtIOSerialPostLoad;
 167
 168 struct VirtIOSerial {
 169     VirtIODevice parent_obj;
 170
 171     VirtQueue *c_ivq, *c_ovq;
 172     /* Arrays of ivqs and ovqs: one per port */
 173     VirtQueue **ivqs, **ovqs;
 174
 175     VirtIOSerialBus bus;
 176
 177     QTAILQ_HEAD(, VirtIOSerialPort) ports;
 178
 179     QLIST_ENTRY(VirtIOSerial) next;
 180
 181     /* bitmap for identifying active ports */
 182     uint32_t *ports_map;
 183
 184     struct VirtIOSerialPostLoad *post_load;
 185
 186     virtio_serial_conf serial;
 187
 188     uint64_t host_features;
 189 };
 190
 191 /* Interface to the virtio-serial bus */
 192
 193 /*
 194  * Open a connection to the port
 195  *   Returns 0 on success (always).
 196  */
 197 int virtio_serial_open(VirtIOSerialPort *port);
 198
 199 /*
 200  * Close the connection to the port
 201  *   Returns 0 on success (always).
 202  */
 203 int virtio_serial_close(VirtIOSerialPort *port);
 204
 205 /*
 206  * Send data to Guest
 207  */
 208 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
 209                             size_t size);
 210
 211 /*
 212  * Query whether a guest is ready to receive data.
 213  */
 214 size_t virtio_serial_guest_ready(VirtIOSerialPort *port);
 215
 216 /*
 217  * Flow control: Ports can signal to the virtio-serial core to stop
 218  * sending data or re-start sending data, depending on the 'throttle'
 219  * value here.
 220  */
 221 void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle);
 222
 223 #define TYPE_VIRTIO_SERIAL "virtio-serial-device"
 224 #define VIRTIO_SERIAL(obj) \
 225         OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL)
 226
 227 #endif