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 #ifndef _QEMU_VIRTIO_SERIAL_H
  16 #define _QEMU_VIRTIO_SERIAL_H
  17
  18 #include "hw/qdev.h"
  19 #include "hw/virtio/virtio.h"
  20
  21 /* == Interface shared between the guest kernel and qemu == */
  22
  23 /* The Virtio ID for virtio console / serial ports */
  24 #define VIRTIO_ID_CONSOLE               3
  25
  26 /* Features supported */
  27 #define VIRTIO_CONSOLE_F_MULTIPORT      1
  28
  29 #define VIRTIO_CONSOLE_BAD_ID           (~(uint32_t)0)
  30
  31 struct virtio_console_config {
  32     /*
  33      * These two fields are used by VIRTIO_CONSOLE_F_SIZE which
  34      * isn't implemented here yet
  35      */
  36     uint16_t cols;
  37     uint16_t rows;
  38
  39     uint32_t max_nr_ports;
  40 } QEMU_PACKED;
  41
  42 struct virtio_console_control {
  43     uint32_t id;                /* Port number */
  44     uint16_t event;             /* The kind of control event (see below) */
  45     uint16_t value;             /* Extra information for the key */
  46 };
  47
  48 struct virtio_serial_conf {
  49     /* Max. number of ports we can have for a virtio-serial device */
  50     uint32_t max_virtserial_ports;
  51 };
  52
  53 /* Some events for the internal messages (control packets) */
  54 #define VIRTIO_CONSOLE_DEVICE_READY     0
  55 #define VIRTIO_CONSOLE_PORT_ADD         1
  56 #define VIRTIO_CONSOLE_PORT_REMOVE      2
  57 #define VIRTIO_CONSOLE_PORT_READY       3
  58 #define VIRTIO_CONSOLE_CONSOLE_PORT     4
  59 #define VIRTIO_CONSOLE_RESIZE           5
  60 #define VIRTIO_CONSOLE_PORT_OPEN        6
  61 #define VIRTIO_CONSOLE_PORT_NAME        7
  62
  63 /* == In-qemu interface == */
  64
  65 #define TYPE_VIRTIO_SERIAL_PORT "virtio-serial-port"
  66 #define VIRTIO_SERIAL_PORT(obj) \
  67      OBJECT_CHECK(VirtIOSerialPort, (obj), TYPE_VIRTIO_SERIAL_PORT)
  68 #define VIRTIO_SERIAL_PORT_CLASS(klass) \
  69      OBJECT_CLASS_CHECK(VirtIOSerialPortClass, (klass), TYPE_VIRTIO_SERIAL_PORT)
  70 #define VIRTIO_SERIAL_PORT_GET_CLASS(obj) \
  71      OBJECT_GET_CLASS(VirtIOSerialPortClass, (obj), TYPE_VIRTIO_SERIAL_PORT)
  72
  73 typedef struct VirtIOSerial VirtIOSerial;
  74 typedef struct VirtIOSerialBus VirtIOSerialBus;
  75 typedef struct VirtIOSerialPort VirtIOSerialPort;
  76
  77 typedef struct VirtIOSerialPortClass {
  78     DeviceClass parent_class;
  79
  80     /* Is this a device that binds with hvc in the guest? */
  81     bool is_console;
  82
  83     /*
  84      * The per-port (or per-app) realize function that's called when a
  85      * new device is found on the bus.
  86      */
  87     DeviceRealize realize;
  88     /*
  89      * Per-port unrealize function that's called when a port gets
  90      * hot-unplugged or removed.
  91      */
  92     DeviceUnrealize unrealize;
  93
  94     /* Callbacks for guest events */
  95         /* Guest opened/closed device. */
  96     void (*set_guest_connected)(VirtIOSerialPort *port, int guest_connected);
  97
  98         /* Guest is now ready to accept data (virtqueues set up). */
  99     void (*guest_ready)(VirtIOSerialPort *port);
 100
 101     /*
 102      * Guest wrote some data to the port. This data is handed over to
 103      * the app via this callback.  The app can return a size less than
 104      * 'len'.  In this case, throttling will be enabled for this port.
 105      */
 106     ssize_t (*have_data)(VirtIOSerialPort *port, const uint8_t *buf,
 107                          ssize_t len);
 108 } VirtIOSerialPortClass;
 109
 110 /*
 111  * This is the state that's shared between all the ports.  Some of the
 112  * state is configurable via command-line options. Some of it can be
 113  * set by individual devices in their initfn routines. Some of the
 114  * state is set by the generic qdev device init routine.
 115  */
 116 struct VirtIOSerialPort {
 117     DeviceState dev;
 118
 119     QTAILQ_ENTRY(VirtIOSerialPort) next;
 120
 121     /*
 122      * This field gives us the virtio device as well as the qdev bus
 123      * that we are associated with
 124      */
 125     VirtIOSerial *vser;
 126
 127     VirtQueue *ivq, *ovq;
 128
 129     /*
 130      * This name is sent to the guest and exported via sysfs.
 131      * The guest could create symlinks based on this information.
 132      * The name is in the reverse fqdn format, like org.qemu.console.0
 133      */
 134     char *name;
 135
 136     /*
 137      * This id helps identify ports between the guest and the host.
 138      * The guest sends a "header" with this id with each data packet
 139      * that it sends and the host can then find out which associated
 140      * device to send out this data to
 141      */
 142     uint32_t id;
 143
 144     /*
 145      * This is the elem that we pop from the virtqueue.  A slow
 146      * backend that consumes guest data (e.g. the file backend for
 147      * qemu chardevs) can cause the guest to block till all the output
 148      * is flushed.  This isn't desired, so we keep a note of the last
 149      * element popped and continue consuming it once the backend
 150      * becomes writable again.
 151      */
 152     VirtQueueElement elem;
 153
 154     /*
 155      * The index and the offset into the iov buffer that was popped in
 156      * elem above.
 157      */
 158     uint32_t iov_idx;
 159     uint64_t iov_offset;
 160
 161     /*
 162      * When unthrottling we use a bottom-half to call flush_queued_data.
 163      */
 164     QEMUBH *bh;
 165
 166     /* Is the corresponding guest device open? */
 167     bool guest_connected;
 168     /* Is this device open for IO on the host? */
 169     bool host_connected;
 170     /* Do apps not want to receive data? */
 171     bool throttled;
 172 };
 173
 174 /* The virtio-serial bus on top of which the ports will ride as devices */
 175 struct VirtIOSerialBus {
 176     BusState qbus;
 177
 178     /* This is the parent device that provides the bus for ports. */
 179     VirtIOSerial *vser;
 180
 181     /* The maximum number of ports that can ride on top of this bus */
 182     uint32_t max_nr_ports;
 183 };
 184
 185 typedef struct VirtIOSerialPostLoad {
 186     QEMUTimer *timer;
 187     uint32_t nr_active_ports;
 188     struct {
 189         VirtIOSerialPort *port;
 190         uint8_t host_connected;
 191     } *connected;
 192 } VirtIOSerialPostLoad;
 193
 194 struct VirtIOSerial {
 195     VirtIODevice parent_obj;
 196
 197     VirtQueue *c_ivq, *c_ovq;
 198     /* Arrays of ivqs and ovqs: one per port */
 199     VirtQueue **ivqs, **ovqs;
 200
 201     VirtIOSerialBus bus;
 202
 203     QTAILQ_HEAD(, VirtIOSerialPort) ports;
 204
 205     QLIST_ENTRY(VirtIOSerial) next;
 206
 207     /* bitmap for identifying active ports */
 208     uint32_t *ports_map;
 209
 210     struct VirtIOSerialPostLoad *post_load;
 211
 212     virtio_serial_conf serial;
 213 };
 214
 215 /* Interface to the virtio-serial bus */
 216
 217 /*
 218  * Open a connection to the port
 219  *   Returns 0 on success (always).
 220  */
 221 int virtio_serial_open(VirtIOSerialPort *port);
 222
 223 /*
 224  * Close the connection to the port
 225  *   Returns 0 on success (always).
 226  */
 227 int virtio_serial_close(VirtIOSerialPort *port);
 228
 229 /*
 230  * Send data to Guest
 231  */
 232 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
 233                             size_t size);
 234
 235 /*
 236  * Query whether a guest is ready to receive data.
 237  */
 238 size_t virtio_serial_guest_ready(VirtIOSerialPort *port);
 239
 240 /*
 241  * Flow control: Ports can signal to the virtio-serial core to stop
 242  * sending data or re-start sending data, depending on the 'throttle'
 243  * value here.
 244  */
 245 void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle);
 246
 247 #define TYPE_VIRTIO_SERIAL "virtio-serial-device"
 248 #define VIRTIO_SERIAL(obj) \
 249         OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL)
 250
 251 #define DEFINE_VIRTIO_SERIAL_PROPERTIES(_state, _field) \
 252         DEFINE_PROP_UINT32("max_ports", _state, _field.max_virtserial_ports, 31)
 253
 254 #endif