]>
Commit | Line | Data |
---|---|---|
98b19252 AS |
1 | /* |
2 | * A bus for connecting virtio serial and console ports | |
3 | * | |
71c092e9 | 4 | * Copyright (C) 2009, 2010 Red Hat, Inc. |
98b19252 AS |
5 | * |
6 | * Author(s): | |
7 | * Amit Shah <amit.shah@redhat.com> | |
8 | * | |
9 | * Some earlier parts are: | |
10 | * Copyright IBM, Corp. 2008 | |
11 | * authored by | |
12 | * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com> | |
13 | * | |
14 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
15 | * the COPYING file in the top-level directory. | |
16 | */ | |
17 | ||
e4d5639d | 18 | #include "iov.h" |
98b19252 AS |
19 | #include "monitor.h" |
20 | #include "qemu-queue.h" | |
21 | #include "sysbus.h" | |
22 | #include "virtio-serial.h" | |
23 | ||
24 | /* The virtio-serial bus on top of which the ports will ride as devices */ | |
25 | struct VirtIOSerialBus { | |
26 | BusState qbus; | |
27 | ||
28 | /* This is the parent device that provides the bus for ports. */ | |
29 | VirtIOSerial *vser; | |
30 | ||
31 | /* The maximum number of ports that can ride on top of this bus */ | |
32 | uint32_t max_nr_ports; | |
33 | }; | |
34 | ||
35 | struct VirtIOSerial { | |
36 | VirtIODevice vdev; | |
37 | ||
38 | VirtQueue *c_ivq, *c_ovq; | |
39 | /* Arrays of ivqs and ovqs: one per port */ | |
40 | VirtQueue **ivqs, **ovqs; | |
41 | ||
42 | VirtIOSerialBus *bus; | |
43 | ||
8b53a865 AS |
44 | DeviceState *qdev; |
45 | ||
98b19252 | 46 | QTAILQ_HEAD(, VirtIOSerialPort) ports; |
055b889f AS |
47 | |
48 | /* bitmap for identifying active ports */ | |
49 | uint32_t *ports_map; | |
50 | ||
98b19252 AS |
51 | struct virtio_console_config config; |
52 | }; | |
53 | ||
54 | static VirtIOSerialPort *find_port_by_id(VirtIOSerial *vser, uint32_t id) | |
55 | { | |
56 | VirtIOSerialPort *port; | |
57 | ||
055b889f AS |
58 | if (id == VIRTIO_CONSOLE_BAD_ID) { |
59 | return NULL; | |
60 | } | |
61 | ||
98b19252 AS |
62 | QTAILQ_FOREACH(port, &vser->ports, next) { |
63 | if (port->id == id) | |
64 | return port; | |
65 | } | |
66 | return NULL; | |
67 | } | |
68 | ||
69 | static VirtIOSerialPort *find_port_by_vq(VirtIOSerial *vser, VirtQueue *vq) | |
70 | { | |
71 | VirtIOSerialPort *port; | |
72 | ||
73 | QTAILQ_FOREACH(port, &vser->ports, next) { | |
74 | if (port->ivq == vq || port->ovq == vq) | |
75 | return port; | |
76 | } | |
77 | return NULL; | |
78 | } | |
79 | ||
6663a195 AS |
80 | static bool use_multiport(VirtIOSerial *vser) |
81 | { | |
82 | return vser->vdev.guest_features & (1 << VIRTIO_CONSOLE_F_MULTIPORT); | |
83 | } | |
84 | ||
98b19252 AS |
85 | static size_t write_to_port(VirtIOSerialPort *port, |
86 | const uint8_t *buf, size_t size) | |
87 | { | |
88 | VirtQueueElement elem; | |
89 | VirtQueue *vq; | |
e4d5639d | 90 | size_t offset; |
98b19252 AS |
91 | |
92 | vq = port->ivq; | |
93 | if (!virtio_queue_ready(vq)) { | |
94 | return 0; | |
95 | } | |
98b19252 | 96 | |
e4d5639d | 97 | offset = 0; |
98b19252 | 98 | while (offset < size) { |
e4d5639d | 99 | size_t len; |
98b19252 AS |
100 | |
101 | if (!virtqueue_pop(vq, &elem)) { | |
102 | break; | |
103 | } | |
104 | ||
e4d5639d AS |
105 | len = iov_from_buf(elem.in_sg, elem.in_num, |
106 | buf + offset, size - offset); | |
107 | offset += len; | |
98b19252 | 108 | |
98b19252 AS |
109 | virtqueue_push(vq, &elem, len); |
110 | } | |
111 | ||
112 | virtio_notify(&port->vser->vdev, vq); | |
113 | return offset; | |
114 | } | |
115 | ||
6bff8656 | 116 | static void discard_vq_data(VirtQueue *vq, VirtIODevice *vdev) |
a69c7600 AS |
117 | { |
118 | VirtQueueElement elem; | |
119 | ||
7185f931 AS |
120 | if (!virtio_queue_ready(vq)) { |
121 | return; | |
122 | } | |
6bff8656 AS |
123 | while (virtqueue_pop(vq, &elem)) { |
124 | virtqueue_push(vq, &elem, 0); | |
125 | } | |
126 | virtio_notify(vdev, vq); | |
127 | } | |
128 | ||
9ed7b059 | 129 | static void do_flush_queued_data(VirtIOSerialPort *port, VirtQueue *vq, |
6bff8656 | 130 | VirtIODevice *vdev) |
a69c7600 | 131 | { |
6bff8656 | 132 | assert(port); |
fd11a78b | 133 | assert(virtio_queue_ready(vq)); |
a69c7600 | 134 | |
f1925dff | 135 | while (!port->throttled) { |
471344db | 136 | unsigned int i; |
a69c7600 | 137 | |
f1925dff AS |
138 | /* Pop an elem only if we haven't left off a previous one mid-way */ |
139 | if (!port->elem.out_num) { | |
140 | if (!virtqueue_pop(vq, &port->elem)) { | |
141 | break; | |
142 | } | |
143 | port->iov_idx = 0; | |
144 | port->iov_offset = 0; | |
145 | } | |
a69c7600 | 146 | |
f1925dff AS |
147 | for (i = port->iov_idx; i < port->elem.out_num; i++) { |
148 | size_t buf_size; | |
149 | ssize_t ret; | |
150 | ||
151 | buf_size = port->elem.out_sg[i].iov_len - port->iov_offset; | |
152 | ret = port->info->have_data(port, | |
153 | port->elem.out_sg[i].iov_base | |
154 | + port->iov_offset, | |
155 | buf_size); | |
156 | if (ret < 0 && ret != -EAGAIN) { | |
157 | /* We don't handle any other type of errors here */ | |
158 | abort(); | |
159 | } | |
160 | if (ret == -EAGAIN || (ret >= 0 && ret < buf_size)) { | |
161 | virtio_serial_throttle_port(port, true); | |
162 | port->iov_idx = i; | |
163 | if (ret > 0) { | |
164 | port->iov_offset += ret; | |
165 | } | |
166 | break; | |
167 | } | |
168 | port->iov_offset = 0; | |
a69c7600 | 169 | } |
f1925dff AS |
170 | if (port->throttled) { |
171 | break; | |
172 | } | |
173 | virtqueue_push(vq, &port->elem, 0); | |
174 | port->elem.out_num = 0; | |
a69c7600 AS |
175 | } |
176 | virtio_notify(vdev, vq); | |
177 | } | |
178 | ||
6bff8656 | 179 | static void flush_queued_data(VirtIOSerialPort *port) |
9ed7b059 | 180 | { |
a1c59752 | 181 | assert(port); |
9ed7b059 | 182 | |
6b611d3a AS |
183 | if (!virtio_queue_ready(port->ovq)) { |
184 | return; | |
185 | } | |
6bff8656 | 186 | do_flush_queued_data(port, port->ovq, &port->vser->vdev); |
9ed7b059 AS |
187 | } |
188 | ||
98b19252 AS |
189 | static size_t send_control_msg(VirtIOSerialPort *port, void *buf, size_t len) |
190 | { | |
191 | VirtQueueElement elem; | |
192 | VirtQueue *vq; | |
193 | struct virtio_console_control *cpkt; | |
194 | ||
195 | vq = port->vser->c_ivq; | |
196 | if (!virtio_queue_ready(vq)) { | |
197 | return 0; | |
198 | } | |
199 | if (!virtqueue_pop(vq, &elem)) { | |
200 | return 0; | |
201 | } | |
202 | ||
203 | cpkt = (struct virtio_console_control *)buf; | |
204 | stl_p(&cpkt->id, port->id); | |
205 | memcpy(elem.in_sg[0].iov_base, buf, len); | |
206 | ||
207 | virtqueue_push(vq, &elem, len); | |
208 | virtio_notify(&port->vser->vdev, vq); | |
209 | return len; | |
210 | } | |
211 | ||
212 | static size_t send_control_event(VirtIOSerialPort *port, uint16_t event, | |
213 | uint16_t value) | |
214 | { | |
215 | struct virtio_console_control cpkt; | |
216 | ||
217 | stw_p(&cpkt.event, event); | |
218 | stw_p(&cpkt.value, value); | |
219 | ||
220 | return send_control_msg(port, &cpkt, sizeof(cpkt)); | |
221 | } | |
222 | ||
223 | /* Functions for use inside qemu to open and read from/write to ports */ | |
224 | int virtio_serial_open(VirtIOSerialPort *port) | |
225 | { | |
6663a195 AS |
226 | /* Don't allow opening an already-open port */ |
227 | if (port->host_connected) { | |
228 | return 0; | |
229 | } | |
230 | /* Send port open notification to the guest */ | |
231 | port->host_connected = true; | |
232 | send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1); | |
233 | ||
98b19252 AS |
234 | return 0; |
235 | } | |
236 | ||
237 | int virtio_serial_close(VirtIOSerialPort *port) | |
238 | { | |
6663a195 | 239 | port->host_connected = false; |
9ed7b059 AS |
240 | /* |
241 | * If there's any data the guest sent which the app didn't | |
242 | * consume, reset the throttling flag and discard the data. | |
243 | */ | |
244 | port->throttled = false; | |
6bff8656 | 245 | discard_vq_data(port->ovq, &port->vser->vdev); |
9ed7b059 | 246 | |
6663a195 AS |
247 | send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, 0); |
248 | ||
98b19252 AS |
249 | return 0; |
250 | } | |
251 | ||
252 | /* Individual ports/apps call this function to write to the guest. */ | |
253 | ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf, | |
254 | size_t size) | |
255 | { | |
6663a195 AS |
256 | if (!port || !port->host_connected || !port->guest_connected) { |
257 | return 0; | |
258 | } | |
98b19252 AS |
259 | return write_to_port(port, buf, size); |
260 | } | |
261 | ||
262 | /* | |
263 | * Readiness of the guest to accept data on a port. | |
264 | * Returns max. data the guest can receive | |
265 | */ | |
266 | size_t virtio_serial_guest_ready(VirtIOSerialPort *port) | |
267 | { | |
268 | VirtQueue *vq = port->ivq; | |
269 | ||
270 | if (!virtio_queue_ready(vq) || | |
271 | !(port->vser->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) || | |
272 | virtio_queue_empty(vq)) { | |
273 | return 0; | |
274 | } | |
6663a195 AS |
275 | if (use_multiport(port->vser) && !port->guest_connected) { |
276 | return 0; | |
277 | } | |
98b19252 AS |
278 | |
279 | if (virtqueue_avail_bytes(vq, 4096, 0)) { | |
280 | return 4096; | |
281 | } | |
282 | if (virtqueue_avail_bytes(vq, 1, 0)) { | |
283 | return 1; | |
284 | } | |
285 | return 0; | |
286 | } | |
287 | ||
9ed7b059 AS |
288 | void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle) |
289 | { | |
290 | if (!port) { | |
291 | return; | |
292 | } | |
293 | ||
294 | port->throttled = throttle; | |
295 | if (throttle) { | |
296 | return; | |
297 | } | |
298 | ||
6bff8656 | 299 | flush_queued_data(port); |
9ed7b059 AS |
300 | } |
301 | ||
98b19252 | 302 | /* Guest wants to notify us of some event */ |
e61da14d | 303 | static void handle_control_message(VirtIOSerial *vser, void *buf, size_t len) |
98b19252 AS |
304 | { |
305 | struct VirtIOSerialPort *port; | |
306 | struct virtio_console_control cpkt, *gcpkt; | |
160600fd AS |
307 | uint8_t *buffer; |
308 | size_t buffer_len; | |
98b19252 AS |
309 | |
310 | gcpkt = buf; | |
98b19252 | 311 | |
e61da14d AS |
312 | if (len < sizeof(cpkt)) { |
313 | /* The guest sent an invalid control packet */ | |
314 | return; | |
315 | } | |
316 | ||
98b19252 AS |
317 | cpkt.event = lduw_p(&gcpkt->event); |
318 | cpkt.value = lduw_p(&gcpkt->value); | |
319 | ||
055b889f AS |
320 | port = find_port_by_id(vser, ldl_p(&gcpkt->id)); |
321 | if (!port && cpkt.event != VIRTIO_CONSOLE_DEVICE_READY) | |
322 | return; | |
323 | ||
98b19252 | 324 | switch(cpkt.event) { |
055b889f | 325 | case VIRTIO_CONSOLE_DEVICE_READY: |
4048c7c3 AS |
326 | if (!cpkt.value) { |
327 | error_report("virtio-serial-bus: Guest failure in adding device %s\n", | |
328 | vser->bus->qbus.name); | |
329 | break; | |
330 | } | |
055b889f AS |
331 | /* |
332 | * The device is up, we can now tell the device about all the | |
333 | * ports we have here. | |
334 | */ | |
335 | QTAILQ_FOREACH(port, &vser->ports, next) { | |
336 | send_control_event(port, VIRTIO_CONSOLE_PORT_ADD, 1); | |
337 | } | |
338 | break; | |
339 | ||
98b19252 | 340 | case VIRTIO_CONSOLE_PORT_READY: |
4048c7c3 AS |
341 | if (!cpkt.value) { |
342 | error_report("virtio-serial-bus: Guest failure in adding port %u for device %s\n", | |
343 | port->id, vser->bus->qbus.name); | |
344 | break; | |
345 | } | |
98b19252 AS |
346 | /* |
347 | * Now that we know the guest asked for the port name, we're | |
348 | * sure the guest has initialised whatever state is necessary | |
349 | * for this port. Now's a good time to let the guest know if | |
350 | * this port is a console port so that the guest can hook it | |
351 | * up to hvc. | |
352 | */ | |
353 | if (port->is_console) { | |
354 | send_control_event(port, VIRTIO_CONSOLE_CONSOLE_PORT, 1); | |
355 | } | |
6663a195 | 356 | |
160600fd AS |
357 | if (port->name) { |
358 | stw_p(&cpkt.event, VIRTIO_CONSOLE_PORT_NAME); | |
359 | stw_p(&cpkt.value, 1); | |
360 | ||
361 | buffer_len = sizeof(cpkt) + strlen(port->name) + 1; | |
362 | buffer = qemu_malloc(buffer_len); | |
363 | ||
364 | memcpy(buffer, &cpkt, sizeof(cpkt)); | |
365 | memcpy(buffer + sizeof(cpkt), port->name, strlen(port->name)); | |
366 | buffer[buffer_len - 1] = 0; | |
367 | ||
368 | send_control_msg(port, buffer, buffer_len); | |
369 | qemu_free(buffer); | |
370 | } | |
371 | ||
6663a195 AS |
372 | if (port->host_connected) { |
373 | send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1); | |
374 | } | |
375 | ||
98b19252 AS |
376 | /* |
377 | * When the guest has asked us for this information it means | |
378 | * the guest is all setup and has its virtqueues | |
379 | * initialised. If some app is interested in knowing about | |
380 | * this event, let it know. | |
381 | */ | |
382 | if (port->info->guest_ready) { | |
383 | port->info->guest_ready(port); | |
384 | } | |
385 | break; | |
6663a195 AS |
386 | |
387 | case VIRTIO_CONSOLE_PORT_OPEN: | |
388 | port->guest_connected = cpkt.value; | |
389 | if (cpkt.value && port->info->guest_open) { | |
390 | /* Send the guest opened notification if an app is interested */ | |
391 | port->info->guest_open(port); | |
392 | } | |
393 | ||
394 | if (!cpkt.value && port->info->guest_close) { | |
395 | /* Send the guest closed notification if an app is interested */ | |
396 | port->info->guest_close(port); | |
397 | } | |
398 | break; | |
98b19252 AS |
399 | } |
400 | } | |
401 | ||
402 | static void control_in(VirtIODevice *vdev, VirtQueue *vq) | |
403 | { | |
404 | } | |
405 | ||
406 | static void control_out(VirtIODevice *vdev, VirtQueue *vq) | |
407 | { | |
408 | VirtQueueElement elem; | |
409 | VirtIOSerial *vser; | |
e61da14d AS |
410 | uint8_t *buf; |
411 | size_t len; | |
98b19252 AS |
412 | |
413 | vser = DO_UPCAST(VirtIOSerial, vdev, vdev); | |
414 | ||
e61da14d AS |
415 | len = 0; |
416 | buf = NULL; | |
98b19252 | 417 | while (virtqueue_pop(vq, &elem)) { |
e61da14d AS |
418 | size_t cur_len, copied; |
419 | ||
420 | cur_len = iov_size(elem.out_sg, elem.out_num); | |
421 | /* | |
422 | * Allocate a new buf only if we didn't have one previously or | |
423 | * if the size of the buf differs | |
424 | */ | |
425 | if (cur_len > len) { | |
426 | qemu_free(buf); | |
427 | ||
428 | buf = qemu_malloc(cur_len); | |
429 | len = cur_len; | |
430 | } | |
431 | copied = iov_to_buf(elem.out_sg, elem.out_num, buf, 0, len); | |
432 | ||
433 | handle_control_message(vser, buf, copied); | |
1e4476aa | 434 | virtqueue_push(vq, &elem, 0); |
98b19252 | 435 | } |
e61da14d | 436 | qemu_free(buf); |
98b19252 AS |
437 | virtio_notify(vdev, vq); |
438 | } | |
439 | ||
440 | /* Guest wrote something to some port. */ | |
441 | static void handle_output(VirtIODevice *vdev, VirtQueue *vq) | |
442 | { | |
443 | VirtIOSerial *vser; | |
a69c7600 AS |
444 | VirtIOSerialPort *port; |
445 | bool discard; | |
98b19252 AS |
446 | |
447 | vser = DO_UPCAST(VirtIOSerial, vdev, vdev); | |
a69c7600 | 448 | port = find_port_by_vq(vser, vq); |
98b19252 | 449 | |
a69c7600 AS |
450 | discard = false; |
451 | if (!port || !port->host_connected || !port->info->have_data) { | |
452 | discard = true; | |
98b19252 | 453 | } |
a69c7600 | 454 | |
6bff8656 AS |
455 | if (discard) { |
456 | discard_vq_data(vq, vdev); | |
457 | return; | |
458 | } | |
459 | if (port->throttled) { | |
9ed7b059 AS |
460 | return; |
461 | } | |
462 | ||
6bff8656 | 463 | do_flush_queued_data(port, vq, vdev); |
98b19252 AS |
464 | } |
465 | ||
466 | static void handle_input(VirtIODevice *vdev, VirtQueue *vq) | |
467 | { | |
468 | } | |
469 | ||
470 | static uint32_t get_features(VirtIODevice *vdev, uint32_t features) | |
471 | { | |
306eb457 AS |
472 | VirtIOSerial *vser; |
473 | ||
474 | vser = DO_UPCAST(VirtIOSerial, vdev, vdev); | |
475 | ||
ee4d45be MT |
476 | if (vser->bus->max_nr_ports > 1) { |
477 | features |= (1 << VIRTIO_CONSOLE_F_MULTIPORT); | |
478 | } | |
98b19252 AS |
479 | return features; |
480 | } | |
481 | ||
482 | /* Guest requested config info */ | |
483 | static void get_config(VirtIODevice *vdev, uint8_t *config_data) | |
484 | { | |
485 | VirtIOSerial *vser; | |
486 | ||
487 | vser = DO_UPCAST(VirtIOSerial, vdev, vdev); | |
488 | memcpy(config_data, &vser->config, sizeof(struct virtio_console_config)); | |
489 | } | |
490 | ||
491 | static void set_config(VirtIODevice *vdev, const uint8_t *config_data) | |
492 | { | |
493 | struct virtio_console_config config; | |
494 | ||
495 | memcpy(&config, config_data, sizeof(config)); | |
496 | } | |
497 | ||
498 | static void virtio_serial_save(QEMUFile *f, void *opaque) | |
499 | { | |
500 | VirtIOSerial *s = opaque; | |
6663a195 AS |
501 | VirtIOSerialPort *port; |
502 | uint32_t nr_active_ports; | |
055b889f | 503 | unsigned int i; |
98b19252 AS |
504 | |
505 | /* The virtio device */ | |
506 | virtio_save(&s->vdev, f); | |
507 | ||
508 | /* The config space */ | |
509 | qemu_put_be16s(f, &s->config.cols); | |
510 | qemu_put_be16s(f, &s->config.rows); | |
6663a195 | 511 | |
055b889f AS |
512 | qemu_put_be32s(f, &s->config.max_nr_ports); |
513 | ||
514 | /* The ports map */ | |
515 | ||
516 | for (i = 0; i < (s->config.max_nr_ports + 31) / 32; i++) { | |
517 | qemu_put_be32s(f, &s->ports_map[i]); | |
518 | } | |
6663a195 | 519 | |
055b889f | 520 | /* Ports */ |
e245795b | 521 | |
6663a195 | 522 | nr_active_ports = 0; |
e245795b | 523 | QTAILQ_FOREACH(port, &s->ports, next) { |
6663a195 | 524 | nr_active_ports++; |
e245795b | 525 | } |
6663a195 AS |
526 | |
527 | qemu_put_be32s(f, &nr_active_ports); | |
528 | ||
529 | /* | |
530 | * Items in struct VirtIOSerialPort. | |
531 | */ | |
532 | QTAILQ_FOREACH(port, &s->ports, next) { | |
37f95bf3 AS |
533 | uint32_t elem_popped; |
534 | ||
6663a195 AS |
535 | qemu_put_be32s(f, &port->id); |
536 | qemu_put_byte(f, port->guest_connected); | |
31abe21f | 537 | qemu_put_byte(f, port->host_connected); |
37f95bf3 AS |
538 | |
539 | elem_popped = 0; | |
540 | if (port->elem.out_num) { | |
541 | elem_popped = 1; | |
542 | } | |
543 | qemu_put_be32s(f, &elem_popped); | |
544 | if (elem_popped) { | |
545 | qemu_put_be32s(f, &port->iov_idx); | |
546 | qemu_put_be64s(f, &port->iov_offset); | |
547 | ||
548 | qemu_put_buffer(f, (unsigned char *)&port->elem, | |
549 | sizeof(port->elem)); | |
550 | } | |
6663a195 | 551 | } |
98b19252 AS |
552 | } |
553 | ||
554 | static int virtio_serial_load(QEMUFile *f, void *opaque, int version_id) | |
555 | { | |
556 | VirtIOSerial *s = opaque; | |
6663a195 | 557 | VirtIOSerialPort *port; |
f83ccb3e | 558 | uint32_t max_nr_ports, nr_active_ports, ports_map; |
6663a195 | 559 | unsigned int i; |
98b19252 | 560 | |
37f95bf3 | 561 | if (version_id > 3) { |
98b19252 AS |
562 | return -EINVAL; |
563 | } | |
6663a195 | 564 | |
98b19252 AS |
565 | /* The virtio device */ |
566 | virtio_load(&s->vdev, f); | |
567 | ||
568 | if (version_id < 2) { | |
569 | return 0; | |
570 | } | |
571 | ||
572 | /* The config space */ | |
573 | qemu_get_be16s(f, &s->config.cols); | |
574 | qemu_get_be16s(f, &s->config.rows); | |
295587f7 | 575 | |
055b889f AS |
576 | qemu_get_be32s(f, &max_nr_ports); |
577 | if (max_nr_ports > s->config.max_nr_ports) { | |
578 | /* Source could have had more ports than us. Fail migration. */ | |
295587f7 AS |
579 | return -EINVAL; |
580 | } | |
98b19252 | 581 | |
055b889f | 582 | for (i = 0; i < (max_nr_ports + 31) / 32; i++) { |
f83ccb3e | 583 | qemu_get_be32s(f, &ports_map); |
055b889f | 584 | |
f83ccb3e | 585 | if (ports_map != s->ports_map[i]) { |
055b889f AS |
586 | /* |
587 | * Ports active on source and destination don't | |
588 | * match. Fail migration. | |
589 | */ | |
055b889f AS |
590 | return -EINVAL; |
591 | } | |
e245795b AS |
592 | } |
593 | ||
6663a195 AS |
594 | qemu_get_be32s(f, &nr_active_ports); |
595 | ||
596 | /* Items in struct VirtIOSerialPort */ | |
597 | for (i = 0; i < nr_active_ports; i++) { | |
598 | uint32_t id; | |
31abe21f | 599 | bool host_connected; |
6663a195 AS |
600 | |
601 | id = qemu_get_be32(f); | |
602 | port = find_port_by_id(s, id); | |
603 | ||
604 | port->guest_connected = qemu_get_byte(f); | |
31abe21f AS |
605 | host_connected = qemu_get_byte(f); |
606 | if (host_connected != port->host_connected) { | |
607 | /* | |
608 | * We have to let the guest know of the host connection | |
609 | * status change | |
610 | */ | |
611 | send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, | |
612 | port->host_connected); | |
613 | } | |
37f95bf3 AS |
614 | |
615 | if (version_id > 2) { | |
616 | uint32_t elem_popped; | |
617 | ||
618 | qemu_get_be32s(f, &elem_popped); | |
619 | if (elem_popped) { | |
620 | qemu_get_be32s(f, &port->iov_idx); | |
621 | qemu_get_be64s(f, &port->iov_offset); | |
622 | ||
623 | qemu_get_buffer(f, (unsigned char *)&port->elem, | |
624 | sizeof(port->elem)); | |
625 | virtqueue_map_sg(port->elem.in_sg, port->elem.in_addr, | |
626 | port->elem.in_num, 1); | |
627 | virtqueue_map_sg(port->elem.out_sg, port->elem.out_addr, | |
628 | port->elem.out_num, 1); | |
629 | ||
630 | /* | |
631 | * Port was throttled on source machine. Let's | |
632 | * unthrottle it here so data starts flowing again. | |
633 | */ | |
634 | virtio_serial_throttle_port(port, false); | |
635 | } | |
636 | } | |
6663a195 | 637 | } |
98b19252 AS |
638 | return 0; |
639 | } | |
640 | ||
641 | static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent); | |
642 | ||
643 | static struct BusInfo virtser_bus_info = { | |
644 | .name = "virtio-serial-bus", | |
645 | .size = sizeof(VirtIOSerialBus), | |
646 | .print_dev = virtser_bus_dev_print, | |
647 | }; | |
648 | ||
649 | static VirtIOSerialBus *virtser_bus_new(DeviceState *dev) | |
650 | { | |
651 | VirtIOSerialBus *bus; | |
652 | ||
9ae84f0a | 653 | bus = FROM_QBUS(VirtIOSerialBus, qbus_create(&virtser_bus_info, dev, NULL)); |
98b19252 AS |
654 | bus->qbus.allow_hotplug = 1; |
655 | ||
656 | return bus; | |
657 | } | |
658 | ||
659 | static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent) | |
660 | { | |
661 | VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev); | |
662 | VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev); | |
663 | ||
664 | monitor_printf(mon, "%*s dev-prop-int: id: %u\n", | |
665 | indent, "", port->id); | |
6663a195 AS |
666 | monitor_printf(mon, "%*s dev-prop-int: guest_connected: %d\n", |
667 | indent, "", port->guest_connected); | |
668 | monitor_printf(mon, "%*s dev-prop-int: host_connected: %d\n", | |
669 | indent, "", port->host_connected); | |
9ed7b059 AS |
670 | monitor_printf(mon, "%*s dev-prop-int: throttled: %d\n", |
671 | indent, "", port->throttled); | |
98b19252 AS |
672 | } |
673 | ||
055b889f AS |
674 | /* This function is only used if a port id is not provided by the user */ |
675 | static uint32_t find_free_port_id(VirtIOSerial *vser) | |
676 | { | |
677 | unsigned int i; | |
678 | ||
679 | for (i = 0; i < (vser->config.max_nr_ports + 31) / 32; i++) { | |
680 | uint32_t map, bit; | |
681 | ||
682 | map = vser->ports_map[i]; | |
683 | bit = ffs(~map); | |
684 | if (bit) { | |
685 | return (bit - 1) + i * 32; | |
686 | } | |
687 | } | |
688 | return VIRTIO_CONSOLE_BAD_ID; | |
689 | } | |
690 | ||
691 | static void mark_port_added(VirtIOSerial *vser, uint32_t port_id) | |
692 | { | |
693 | unsigned int i; | |
694 | ||
695 | i = port_id / 32; | |
696 | vser->ports_map[i] |= 1U << (port_id % 32); | |
697 | } | |
698 | ||
699 | static void add_port(VirtIOSerial *vser, uint32_t port_id) | |
700 | { | |
701 | mark_port_added(vser, port_id); | |
702 | ||
703 | send_control_event(find_port_by_id(vser, port_id), | |
704 | VIRTIO_CONSOLE_PORT_ADD, 1); | |
705 | } | |
706 | ||
707 | static void remove_port(VirtIOSerial *vser, uint32_t port_id) | |
708 | { | |
9ed7b059 | 709 | VirtIOSerialPort *port; |
055b889f AS |
710 | unsigned int i; |
711 | ||
712 | i = port_id / 32; | |
713 | vser->ports_map[i] &= ~(1U << (port_id % 32)); | |
714 | ||
9ed7b059 AS |
715 | port = find_port_by_id(vser, port_id); |
716 | /* Flush out any unconsumed buffers first */ | |
6bff8656 | 717 | discard_vq_data(port->ovq, &port->vser->vdev); |
9ed7b059 AS |
718 | |
719 | send_control_event(port, VIRTIO_CONSOLE_PORT_REMOVE, 1); | |
055b889f AS |
720 | } |
721 | ||
98b19252 AS |
722 | static int virtser_port_qdev_init(DeviceState *qdev, DeviceInfo *base) |
723 | { | |
724 | VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev); | |
725 | VirtIOSerialPortInfo *info = DO_UPCAST(VirtIOSerialPortInfo, qdev, base); | |
726 | VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev); | |
727 | VirtIOSerialBus *bus = DO_UPCAST(VirtIOSerialBus, qbus, qdev->parent_bus); | |
728 | int ret; | |
729 | bool plugging_port0; | |
730 | ||
731 | port->vser = bus->vser; | |
732 | ||
733 | /* | |
734 | * Is the first console port we're seeing? If so, put it up at | |
735 | * location 0. This is done for backward compatibility (old | |
736 | * kernel, new qemu). | |
737 | */ | |
738 | plugging_port0 = port->is_console && !find_port_by_id(port->vser, 0); | |
739 | ||
055b889f AS |
740 | if (find_port_by_id(port->vser, port->id)) { |
741 | error_report("virtio-serial-bus: A port already exists at id %u\n", | |
742 | port->id); | |
98b19252 AS |
743 | return -1; |
744 | } | |
98b19252 | 745 | |
055b889f AS |
746 | if (port->id == VIRTIO_CONSOLE_BAD_ID) { |
747 | if (plugging_port0) { | |
748 | port->id = 0; | |
749 | } else { | |
750 | port->id = find_free_port_id(port->vser); | |
751 | if (port->id == VIRTIO_CONSOLE_BAD_ID) { | |
752 | error_report("virtio-serial-bus: Maximum port limit for this device reached\n"); | |
753 | return -1; | |
754 | } | |
755 | } | |
756 | } | |
757 | ||
758 | if (port->id >= port->vser->config.max_nr_ports) { | |
759 | error_report("virtio-serial-bus: Out-of-range port id specified, max. allowed: %u\n", | |
760 | port->vser->config.max_nr_ports - 1); | |
761 | return -1; | |
762 | } | |
763 | ||
764 | dev->info = info; | |
98b19252 AS |
765 | ret = info->init(dev); |
766 | if (ret) { | |
767 | return ret; | |
768 | } | |
769 | ||
6663a195 AS |
770 | if (!use_multiport(port->vser)) { |
771 | /* | |
772 | * Allow writes to guest in this case; we have no way of | |
773 | * knowing if a guest port is connected. | |
774 | */ | |
775 | port->guest_connected = true; | |
776 | } | |
777 | ||
f1925dff AS |
778 | port->elem.out_num = 0; |
779 | ||
98b19252 AS |
780 | QTAILQ_INSERT_TAIL(&port->vser->ports, port, next); |
781 | port->ivq = port->vser->ivqs[port->id]; | |
782 | port->ovq = port->vser->ovqs[port->id]; | |
783 | ||
055b889f AS |
784 | add_port(port->vser, port->id); |
785 | ||
98b19252 AS |
786 | /* Send an update to the guest about this new port added */ |
787 | virtio_notify_config(&port->vser->vdev); | |
788 | ||
789 | return ret; | |
790 | } | |
791 | ||
792 | static int virtser_port_qdev_exit(DeviceState *qdev) | |
793 | { | |
794 | VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev); | |
795 | VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev); | |
796 | VirtIOSerial *vser = port->vser; | |
797 | ||
055b889f | 798 | remove_port(port->vser, port->id); |
f146ec9a | 799 | |
98b19252 AS |
800 | QTAILQ_REMOVE(&vser->ports, port, next); |
801 | ||
802 | if (port->info->exit) | |
803 | port->info->exit(dev); | |
804 | ||
805 | return 0; | |
806 | } | |
807 | ||
808 | void virtio_serial_port_qdev_register(VirtIOSerialPortInfo *info) | |
809 | { | |
810 | info->qdev.init = virtser_port_qdev_init; | |
811 | info->qdev.bus_info = &virtser_bus_info; | |
812 | info->qdev.exit = virtser_port_qdev_exit; | |
813 | info->qdev.unplug = qdev_simple_unplug_cb; | |
814 | qdev_register(&info->qdev); | |
815 | } | |
816 | ||
817 | VirtIODevice *virtio_serial_init(DeviceState *dev, uint32_t max_nr_ports) | |
818 | { | |
819 | VirtIOSerial *vser; | |
820 | VirtIODevice *vdev; | |
5ab4bb59 | 821 | uint32_t i, max_supported_ports; |
98b19252 AS |
822 | |
823 | if (!max_nr_ports) | |
824 | return NULL; | |
825 | ||
5ab4bb59 AS |
826 | /* Each port takes 2 queues, and one pair is for the control queue */ |
827 | max_supported_ports = VIRTIO_PCI_QUEUE_MAX / 2 - 1; | |
828 | ||
829 | if (max_nr_ports > max_supported_ports) { | |
830 | error_report("maximum ports supported: %u", max_supported_ports); | |
831 | return NULL; | |
832 | } | |
833 | ||
98b19252 AS |
834 | vdev = virtio_common_init("virtio-serial", VIRTIO_ID_CONSOLE, |
835 | sizeof(struct virtio_console_config), | |
836 | sizeof(VirtIOSerial)); | |
837 | ||
838 | vser = DO_UPCAST(VirtIOSerial, vdev, vdev); | |
839 | ||
840 | /* Spawn a new virtio-serial bus on which the ports will ride as devices */ | |
841 | vser->bus = virtser_bus_new(dev); | |
842 | vser->bus->vser = vser; | |
843 | QTAILQ_INIT(&vser->ports); | |
844 | ||
845 | vser->bus->max_nr_ports = max_nr_ports; | |
846 | vser->ivqs = qemu_malloc(max_nr_ports * sizeof(VirtQueue *)); | |
847 | vser->ovqs = qemu_malloc(max_nr_ports * sizeof(VirtQueue *)); | |
848 | ||
849 | /* Add a queue for host to guest transfers for port 0 (backward compat) */ | |
850 | vser->ivqs[0] = virtio_add_queue(vdev, 128, handle_input); | |
851 | /* Add a queue for guest to host transfers for port 0 (backward compat) */ | |
852 | vser->ovqs[0] = virtio_add_queue(vdev, 128, handle_output); | |
853 | ||
a01a9cb8 AS |
854 | /* TODO: host to guest notifications can get dropped |
855 | * if the queue fills up. Implement queueing in host, | |
856 | * this might also make it possible to reduce the control | |
857 | * queue size: as guest preposts buffers there, | |
858 | * this will save 4Kbyte of guest memory per entry. */ | |
859 | ||
98b19252 | 860 | /* control queue: host to guest */ |
a01a9cb8 | 861 | vser->c_ivq = virtio_add_queue(vdev, 32, control_in); |
98b19252 | 862 | /* control queue: guest to host */ |
a01a9cb8 | 863 | vser->c_ovq = virtio_add_queue(vdev, 32, control_out); |
98b19252 AS |
864 | |
865 | for (i = 1; i < vser->bus->max_nr_ports; i++) { | |
866 | /* Add a per-port queue for host to guest transfers */ | |
867 | vser->ivqs[i] = virtio_add_queue(vdev, 128, handle_input); | |
868 | /* Add a per-per queue for guest to host transfers */ | |
869 | vser->ovqs[i] = virtio_add_queue(vdev, 128, handle_output); | |
870 | } | |
871 | ||
872 | vser->config.max_nr_ports = max_nr_ports; | |
a132a679 AL |
873 | vser->ports_map = qemu_mallocz(((max_nr_ports + 31) / 32) |
874 | * sizeof(vser->ports_map[0])); | |
98b19252 AS |
875 | /* |
876 | * Reserve location 0 for a console port for backward compat | |
877 | * (old kernel, new qemu) | |
878 | */ | |
055b889f | 879 | mark_port_added(vser, 0); |
98b19252 AS |
880 | |
881 | vser->vdev.get_features = get_features; | |
882 | vser->vdev.get_config = get_config; | |
883 | vser->vdev.set_config = set_config; | |
884 | ||
8b53a865 AS |
885 | vser->qdev = dev; |
886 | ||
98b19252 AS |
887 | /* |
888 | * Register for the savevm section with the virtio-console name | |
889 | * to preserve backward compat | |
890 | */ | |
37f95bf3 | 891 | register_savevm(dev, "virtio-console", -1, 3, virtio_serial_save, |
98b19252 AS |
892 | virtio_serial_load, vser); |
893 | ||
894 | return vdev; | |
895 | } | |
8b53a865 AS |
896 | |
897 | void virtio_serial_exit(VirtIODevice *vdev) | |
898 | { | |
899 | VirtIOSerial *vser = DO_UPCAST(VirtIOSerial, vdev, vdev); | |
900 | ||
901 | unregister_savevm(vser->qdev, "virtio-console", vser); | |
902 | ||
903 | qemu_free(vser->ivqs); | |
904 | qemu_free(vser->ovqs); | |
905 | qemu_free(vser->ports_map); | |
906 | ||
907 | virtio_cleanup(vdev); | |
908 | } |