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