virtio-serial: save/load: Ensure target has enough ports
[qemu.git] / hw / virtio-serial-bus.c
blob9a7f0c139908bae4b33f7d05b4d30019f30473f9
1 /*
2 * A bus for connecting virtio serial and console ports
4 * Copyright (C) 2009 Red Hat, Inc.
6 * Author(s):
7 * Amit Shah <amit.shah@redhat.com>
9 * Some earlier parts are:
10 * Copyright IBM, Corp. 2008
11 * authored by
12 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
14 * This work is licensed under the terms of the GNU GPL, version 2. See
15 * the COPYING file in the top-level directory.
18 #include "monitor.h"
19 #include "qemu-queue.h"
20 #include "sysbus.h"
21 #include "virtio-serial.h"
23 /* The virtio-serial bus on top of which the ports will ride as devices */
24 struct VirtIOSerialBus {
25 BusState qbus;
27 /* This is the parent device that provides the bus for ports. */
28 VirtIOSerial *vser;
30 /* The maximum number of ports that can ride on top of this bus */
31 uint32_t max_nr_ports;
34 struct VirtIOSerial {
35 VirtIODevice vdev;
37 VirtQueue *c_ivq, *c_ovq;
38 /* Arrays of ivqs and ovqs: one per port */
39 VirtQueue **ivqs, **ovqs;
41 VirtIOSerialBus *bus;
43 QTAILQ_HEAD(, VirtIOSerialPort) ports;
44 struct virtio_console_config config;
47 static VirtIOSerialPort *find_port_by_id(VirtIOSerial *vser, uint32_t id)
49 VirtIOSerialPort *port;
51 QTAILQ_FOREACH(port, &vser->ports, next) {
52 if (port->id == id)
53 return port;
55 return NULL;
58 static VirtIOSerialPort *find_port_by_vq(VirtIOSerial *vser, VirtQueue *vq)
60 VirtIOSerialPort *port;
62 QTAILQ_FOREACH(port, &vser->ports, next) {
63 if (port->ivq == vq || port->ovq == vq)
64 return port;
66 return NULL;
69 static bool use_multiport(VirtIOSerial *vser)
71 return vser->vdev.guest_features & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
74 static size_t write_to_port(VirtIOSerialPort *port,
75 const uint8_t *buf, size_t size)
77 VirtQueueElement elem;
78 VirtQueue *vq;
79 size_t offset = 0;
80 size_t len = 0;
82 vq = port->ivq;
83 if (!virtio_queue_ready(vq)) {
84 return 0;
86 if (!size) {
87 return 0;
90 while (offset < size) {
91 int i;
93 if (!virtqueue_pop(vq, &elem)) {
94 break;
97 for (i = 0; offset < size && i < elem.in_num; i++) {
98 len = MIN(elem.in_sg[i].iov_len, size - offset);
100 memcpy(elem.in_sg[i].iov_base, buf + offset, len);
101 offset += len;
103 virtqueue_push(vq, &elem, len);
106 virtio_notify(&port->vser->vdev, vq);
107 return offset;
110 static size_t send_control_msg(VirtIOSerialPort *port, void *buf, size_t len)
112 VirtQueueElement elem;
113 VirtQueue *vq;
114 struct virtio_console_control *cpkt;
116 vq = port->vser->c_ivq;
117 if (!virtio_queue_ready(vq)) {
118 return 0;
120 if (!virtqueue_pop(vq, &elem)) {
121 return 0;
124 cpkt = (struct virtio_console_control *)buf;
125 stl_p(&cpkt->id, port->id);
126 memcpy(elem.in_sg[0].iov_base, buf, len);
128 virtqueue_push(vq, &elem, len);
129 virtio_notify(&port->vser->vdev, vq);
130 return len;
133 static size_t send_control_event(VirtIOSerialPort *port, uint16_t event,
134 uint16_t value)
136 struct virtio_console_control cpkt;
138 stw_p(&cpkt.event, event);
139 stw_p(&cpkt.value, value);
141 return send_control_msg(port, &cpkt, sizeof(cpkt));
144 /* Functions for use inside qemu to open and read from/write to ports */
145 int virtio_serial_open(VirtIOSerialPort *port)
147 /* Don't allow opening an already-open port */
148 if (port->host_connected) {
149 return 0;
151 /* Send port open notification to the guest */
152 port->host_connected = true;
153 send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
155 return 0;
158 int virtio_serial_close(VirtIOSerialPort *port)
160 port->host_connected = false;
161 send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
163 return 0;
166 /* Individual ports/apps call this function to write to the guest. */
167 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
168 size_t size)
170 if (!port || !port->host_connected || !port->guest_connected) {
171 return 0;
173 return write_to_port(port, buf, size);
177 * Readiness of the guest to accept data on a port.
178 * Returns max. data the guest can receive
180 size_t virtio_serial_guest_ready(VirtIOSerialPort *port)
182 VirtQueue *vq = port->ivq;
184 if (!virtio_queue_ready(vq) ||
185 !(port->vser->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) ||
186 virtio_queue_empty(vq)) {
187 return 0;
189 if (use_multiport(port->vser) && !port->guest_connected) {
190 return 0;
193 if (virtqueue_avail_bytes(vq, 4096, 0)) {
194 return 4096;
196 if (virtqueue_avail_bytes(vq, 1, 0)) {
197 return 1;
199 return 0;
202 /* Guest wants to notify us of some event */
203 static void handle_control_message(VirtIOSerial *vser, void *buf)
205 struct VirtIOSerialPort *port;
206 struct virtio_console_control cpkt, *gcpkt;
207 uint8_t *buffer;
208 size_t buffer_len;
210 gcpkt = buf;
211 port = find_port_by_id(vser, ldl_p(&gcpkt->id));
212 if (!port)
213 return;
215 cpkt.event = lduw_p(&gcpkt->event);
216 cpkt.value = lduw_p(&gcpkt->value);
218 switch(cpkt.event) {
219 case VIRTIO_CONSOLE_PORT_READY:
221 * Now that we know the guest asked for the port name, we're
222 * sure the guest has initialised whatever state is necessary
223 * for this port. Now's a good time to let the guest know if
224 * this port is a console port so that the guest can hook it
225 * up to hvc.
227 if (port->is_console) {
228 send_control_event(port, VIRTIO_CONSOLE_CONSOLE_PORT, 1);
231 if (port->name) {
232 stw_p(&cpkt.event, VIRTIO_CONSOLE_PORT_NAME);
233 stw_p(&cpkt.value, 1);
235 buffer_len = sizeof(cpkt) + strlen(port->name) + 1;
236 buffer = qemu_malloc(buffer_len);
238 memcpy(buffer, &cpkt, sizeof(cpkt));
239 memcpy(buffer + sizeof(cpkt), port->name, strlen(port->name));
240 buffer[buffer_len - 1] = 0;
242 send_control_msg(port, buffer, buffer_len);
243 qemu_free(buffer);
246 if (port->host_connected) {
247 send_control_event(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
251 * When the guest has asked us for this information it means
252 * the guest is all setup and has its virtqueues
253 * initialised. If some app is interested in knowing about
254 * this event, let it know.
256 if (port->info->guest_ready) {
257 port->info->guest_ready(port);
259 break;
261 case VIRTIO_CONSOLE_PORT_OPEN:
262 port->guest_connected = cpkt.value;
263 if (cpkt.value && port->info->guest_open) {
264 /* Send the guest opened notification if an app is interested */
265 port->info->guest_open(port);
268 if (!cpkt.value && port->info->guest_close) {
269 /* Send the guest closed notification if an app is interested */
270 port->info->guest_close(port);
272 break;
276 static void control_in(VirtIODevice *vdev, VirtQueue *vq)
280 static void control_out(VirtIODevice *vdev, VirtQueue *vq)
282 VirtQueueElement elem;
283 VirtIOSerial *vser;
285 vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
287 while (virtqueue_pop(vq, &elem)) {
288 handle_control_message(vser, elem.out_sg[0].iov_base);
289 virtqueue_push(vq, &elem, elem.out_sg[0].iov_len);
291 virtio_notify(vdev, vq);
294 /* Guest wrote something to some port. */
295 static void handle_output(VirtIODevice *vdev, VirtQueue *vq)
297 VirtIOSerial *vser;
298 VirtQueueElement elem;
300 vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
302 while (virtqueue_pop(vq, &elem)) {
303 VirtIOSerialPort *port;
304 size_t ret;
306 port = find_port_by_vq(vser, vq);
307 if (!port) {
308 ret = 0;
309 goto next_buf;
313 * A port may not have any handler registered for consuming the
314 * data that the guest sends or it may not have a chardev associated
315 * with it. Just ignore the data in that case.
317 if (!port->info->have_data) {
318 ret = 0;
319 goto next_buf;
322 /* The guest always sends only one sg */
323 ret = port->info->have_data(port, elem.out_sg[0].iov_base,
324 elem.out_sg[0].iov_len);
326 next_buf:
327 virtqueue_push(vq, &elem, ret);
329 virtio_notify(vdev, vq);
332 static void handle_input(VirtIODevice *vdev, VirtQueue *vq)
336 static uint32_t get_features(VirtIODevice *vdev, uint32_t features)
338 VirtIOSerial *vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
339 if (vser->bus->max_nr_ports > 1) {
340 features |= (1 << VIRTIO_CONSOLE_F_MULTIPORT);
342 return features;
345 /* Guest requested config info */
346 static void get_config(VirtIODevice *vdev, uint8_t *config_data)
348 VirtIOSerial *vser;
350 vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
351 memcpy(config_data, &vser->config, sizeof(struct virtio_console_config));
354 static void set_config(VirtIODevice *vdev, const uint8_t *config_data)
356 struct virtio_console_config config;
358 memcpy(&config, config_data, sizeof(config));
361 static void virtio_serial_save(QEMUFile *f, void *opaque)
363 VirtIOSerial *s = opaque;
364 VirtIOSerialPort *port;
365 uint32_t nr_active_ports;
367 /* The virtio device */
368 virtio_save(&s->vdev, f);
370 /* The config space */
371 qemu_put_be16s(f, &s->config.cols);
372 qemu_put_be16s(f, &s->config.rows);
373 qemu_put_be32s(f, &s->config.nr_ports);
375 /* Items in struct VirtIOSerial */
377 qemu_put_be32s(f, &s->bus->max_nr_ports);
379 /* Do this because we might have hot-unplugged some ports */
380 nr_active_ports = 0;
381 QTAILQ_FOREACH(port, &s->ports, next) {
382 nr_active_ports++;
385 qemu_put_be32s(f, &nr_active_ports);
388 * Items in struct VirtIOSerialPort.
390 QTAILQ_FOREACH(port, &s->ports, next) {
392 * We put the port number because we may not have an active
393 * port at id 0 that's reserved for a console port, or in case
394 * of ports that might have gotten unplugged
396 qemu_put_be32s(f, &port->id);
397 qemu_put_byte(f, port->guest_connected);
401 static int virtio_serial_load(QEMUFile *f, void *opaque, int version_id)
403 VirtIOSerial *s = opaque;
404 VirtIOSerialPort *port;
405 uint32_t max_nr_ports, nr_active_ports;
406 unsigned int i;
408 if (version_id > 2) {
409 return -EINVAL;
412 /* The virtio device */
413 virtio_load(&s->vdev, f);
415 if (version_id < 2) {
416 return 0;
419 /* The config space */
420 qemu_get_be16s(f, &s->config.cols);
421 qemu_get_be16s(f, &s->config.rows);
422 s->config.nr_ports = qemu_get_be32(f);
424 /* Items in struct VirtIOSerial */
426 qemu_get_be32s(f, &max_nr_ports);
427 if (max_nr_ports > s->bus->max_nr_ports) {
428 /* Source could have more ports than us. Fail migration. */
429 return -EINVAL;
432 qemu_get_be32s(f, &nr_active_ports);
434 /* Items in struct VirtIOSerialPort */
435 for (i = 0; i < nr_active_ports; i++) {
436 uint32_t id;
438 id = qemu_get_be32(f);
439 port = find_port_by_id(s, id);
441 port->guest_connected = qemu_get_byte(f);
444 return 0;
447 static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
449 static struct BusInfo virtser_bus_info = {
450 .name = "virtio-serial-bus",
451 .size = sizeof(VirtIOSerialBus),
452 .print_dev = virtser_bus_dev_print,
455 static VirtIOSerialBus *virtser_bus_new(DeviceState *dev)
457 VirtIOSerialBus *bus;
459 bus = FROM_QBUS(VirtIOSerialBus, qbus_create(&virtser_bus_info, dev, NULL));
460 bus->qbus.allow_hotplug = 1;
462 return bus;
465 static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
467 VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev);
468 VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);
470 monitor_printf(mon, "%*s dev-prop-int: id: %u\n",
471 indent, "", port->id);
472 monitor_printf(mon, "%*s dev-prop-int: guest_connected: %d\n",
473 indent, "", port->guest_connected);
474 monitor_printf(mon, "%*s dev-prop-int: host_connected: %d\n",
475 indent, "", port->host_connected);
478 static int virtser_port_qdev_init(DeviceState *qdev, DeviceInfo *base)
480 VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev);
481 VirtIOSerialPortInfo *info = DO_UPCAST(VirtIOSerialPortInfo, qdev, base);
482 VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);
483 VirtIOSerialBus *bus = DO_UPCAST(VirtIOSerialBus, qbus, qdev->parent_bus);
484 int ret;
485 bool plugging_port0;
487 port->vser = bus->vser;
490 * Is the first console port we're seeing? If so, put it up at
491 * location 0. This is done for backward compatibility (old
492 * kernel, new qemu).
494 plugging_port0 = port->is_console && !find_port_by_id(port->vser, 0);
496 if (port->vser->config.nr_ports == bus->max_nr_ports && !plugging_port0) {
497 error_report("virtio-serial-bus: Maximum device limit reached");
498 return -1;
500 dev->info = info;
502 ret = info->init(dev);
503 if (ret) {
504 return ret;
507 port->id = plugging_port0 ? 0 : port->vser->config.nr_ports++;
509 if (!use_multiport(port->vser)) {
511 * Allow writes to guest in this case; we have no way of
512 * knowing if a guest port is connected.
514 port->guest_connected = true;
517 QTAILQ_INSERT_TAIL(&port->vser->ports, port, next);
518 port->ivq = port->vser->ivqs[port->id];
519 port->ovq = port->vser->ovqs[port->id];
521 /* Send an update to the guest about this new port added */
522 virtio_notify_config(&port->vser->vdev);
524 return ret;
527 static int virtser_port_qdev_exit(DeviceState *qdev)
529 VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev);
530 VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);
531 VirtIOSerial *vser = port->vser;
533 send_control_event(port, VIRTIO_CONSOLE_PORT_REMOVE, 1);
536 * Don't decrement nr_ports here; thus we keep a linearly
537 * increasing port id. Not utilising an id again saves us a couple
538 * of complications:
540 * - Not having to bother about sending the port id to the guest
541 * kernel on hotplug or on addition of new ports; the guest can
542 * also linearly increment the port number. This is preferable
543 * because the config space won't have the need to store a
544 * ports_map.
546 * - Extra state to be stored for all the "holes" that got created
547 * so that we keep filling in the ids from the least available
548 * index.
550 * When such a functionality is desired, a control message to add
551 * a port can be introduced.
553 QTAILQ_REMOVE(&vser->ports, port, next);
555 if (port->info->exit)
556 port->info->exit(dev);
558 return 0;
561 void virtio_serial_port_qdev_register(VirtIOSerialPortInfo *info)
563 info->qdev.init = virtser_port_qdev_init;
564 info->qdev.bus_info = &virtser_bus_info;
565 info->qdev.exit = virtser_port_qdev_exit;
566 info->qdev.unplug = qdev_simple_unplug_cb;
567 qdev_register(&info->qdev);
570 VirtIODevice *virtio_serial_init(DeviceState *dev, uint32_t max_nr_ports)
572 VirtIOSerial *vser;
573 VirtIODevice *vdev;
574 uint32_t i;
576 if (!max_nr_ports)
577 return NULL;
579 vdev = virtio_common_init("virtio-serial", VIRTIO_ID_CONSOLE,
580 sizeof(struct virtio_console_config),
581 sizeof(VirtIOSerial));
583 vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
585 /* Spawn a new virtio-serial bus on which the ports will ride as devices */
586 vser->bus = virtser_bus_new(dev);
587 vser->bus->vser = vser;
588 QTAILQ_INIT(&vser->ports);
590 vser->bus->max_nr_ports = max_nr_ports;
591 vser->ivqs = qemu_malloc(max_nr_ports * sizeof(VirtQueue *));
592 vser->ovqs = qemu_malloc(max_nr_ports * sizeof(VirtQueue *));
594 /* Add a queue for host to guest transfers for port 0 (backward compat) */
595 vser->ivqs[0] = virtio_add_queue(vdev, 128, handle_input);
596 /* Add a queue for guest to host transfers for port 0 (backward compat) */
597 vser->ovqs[0] = virtio_add_queue(vdev, 128, handle_output);
599 /* control queue: host to guest */
600 vser->c_ivq = virtio_add_queue(vdev, 16, control_in);
601 /* control queue: guest to host */
602 vser->c_ovq = virtio_add_queue(vdev, 16, control_out);
604 for (i = 1; i < vser->bus->max_nr_ports; i++) {
605 /* Add a per-port queue for host to guest transfers */
606 vser->ivqs[i] = virtio_add_queue(vdev, 128, handle_input);
607 /* Add a per-per queue for guest to host transfers */
608 vser->ovqs[i] = virtio_add_queue(vdev, 128, handle_output);
611 vser->config.max_nr_ports = max_nr_ports;
613 * Reserve location 0 for a console port for backward compat
614 * (old kernel, new qemu)
616 vser->config.nr_ports = 1;
618 vser->vdev.get_features = get_features;
619 vser->vdev.get_config = get_config;
620 vser->vdev.set_config = set_config;
623 * Register for the savevm section with the virtio-console name
624 * to preserve backward compat
626 register_savevm("virtio-console", -1, 2, virtio_serial_save,
627 virtio_serial_load, vser);
629 return vdev;