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 virtio_console_config config; 211 212 struct VirtIOSerialPostLoad *post_load; 213 214 virtio_serial_conf serial; 215 }; 216 217 /* Interface to the virtio-serial bus */ 218 219 /* 220 * Open a connection to the port 221 * Returns 0 on success (always). 222 */ 223 int virtio_serial_open(VirtIOSerialPort *port); 224 225 /* 226 * Close the connection to the port 227 * Returns 0 on success (always). 228 */ 229 int virtio_serial_close(VirtIOSerialPort *port); 230 231 /* 232 * Send data to Guest 233 */ 234 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf, 235 size_t size); 236 237 /* 238 * Query whether a guest is ready to receive data. 239 */ 240 size_t virtio_serial_guest_ready(VirtIOSerialPort *port); 241 242 /* 243 * Flow control: Ports can signal to the virtio-serial core to stop 244 * sending data or re-start sending data, depending on the 'throttle' 245 * value here. 246 */ 247 void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle); 248 249 #define TYPE_VIRTIO_SERIAL "virtio-serial-device" 250 #define VIRTIO_SERIAL(obj) \ 251 OBJECT_CHECK(VirtIOSerial, (obj), TYPE_VIRTIO_SERIAL) 252 253 #define DEFINE_VIRTIO_SERIAL_PROPERTIES(_state, _field) \ 254 DEFINE_PROP_UINT32("max_ports", _state, _field.max_virtserial_ports, 31) 255 256 #endif 257