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