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