virtio-serial: avoid crash when port has no name
[qemu.git] / hw / char / virtio-serial-bus.c
1 /*
2 * A bus for connecting virtio serial and console ports
3 *
4 * Copyright (C) 2009, 2010 Red Hat, Inc.
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 * Contributions after 2012-01-13 are licensed under the terms of the
18 * GNU GPL, version 2 or (at your option) any later version.
19 */
20
21 #include "qemu/iov.h"
22 #include "monitor/monitor.h"
23 #include "qemu/queue.h"
24 #include "hw/sysbus.h"
25 #include "trace.h"
26 #include "hw/virtio/virtio-serial.h"
27 #include "hw/virtio/virtio-access.h"
28
29 struct VirtIOSerialDevices {
30 QLIST_HEAD(, VirtIOSerial) devices;
31 } vserdevices;
32
33 static VirtIOSerialPort *find_port_by_id(VirtIOSerial *vser, uint32_t id)
34 {
35 VirtIOSerialPort *port;
36
37 if (id == VIRTIO_CONSOLE_BAD_ID) {
38 return NULL;
39 }
40
41 QTAILQ_FOREACH(port, &vser->ports, next) {
42 if (port->id == id)
43 return port;
44 }
45 return NULL;
46 }
47
48 static VirtIOSerialPort *find_port_by_vq(VirtIOSerial *vser, VirtQueue *vq)
49 {
50 VirtIOSerialPort *port;
51
52 QTAILQ_FOREACH(port, &vser->ports, next) {
53 if (port->ivq == vq || port->ovq == vq)
54 return port;
55 }
56 return NULL;
57 }
58
59 static VirtIOSerialPort *find_port_by_name(char *name)
60 {
61 VirtIOSerial *vser;
62
63 QLIST_FOREACH(vser, &vserdevices.devices, next) {
64 VirtIOSerialPort *port;
65
66 QTAILQ_FOREACH(port, &vser->ports, next) {
67 if (!strcmp(port->name, name)) {
68 return port;
69 }
70 }
71 }
72 return NULL;
73 }
74
75 static bool use_multiport(VirtIOSerial *vser)
76 {
77 VirtIODevice *vdev = VIRTIO_DEVICE(vser);
78 return vdev->guest_features & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
79 }
80
81 static size_t write_to_port(VirtIOSerialPort *port,
82 const uint8_t *buf, size_t size)
83 {
84 VirtQueueElement elem;
85 VirtQueue *vq;
86 size_t offset;
87
88 vq = port->ivq;
89 if (!virtio_queue_ready(vq)) {
90 return 0;
91 }
92
93 offset = 0;
94 while (offset < size) {
95 size_t len;
96
97 if (!virtqueue_pop(vq, &elem)) {
98 break;
99 }
100
101 len = iov_from_buf(elem.in_sg, elem.in_num, 0,
102 buf + offset, size - offset);
103 offset += len;
104
105 virtqueue_push(vq, &elem, len);
106 }
107
108 virtio_notify(VIRTIO_DEVICE(port->vser), vq);
109 return offset;
110 }
111
112 static void discard_vq_data(VirtQueue *vq, VirtIODevice *vdev)
113 {
114 VirtQueueElement elem;
115
116 if (!virtio_queue_ready(vq)) {
117 return;
118 }
119 while (virtqueue_pop(vq, &elem)) {
120 virtqueue_push(vq, &elem, 0);
121 }
122 virtio_notify(vdev, vq);
123 }
124
125 static void do_flush_queued_data(VirtIOSerialPort *port, VirtQueue *vq,
126 VirtIODevice *vdev)
127 {
128 VirtIOSerialPortClass *vsc;
129
130 assert(port);
131 assert(virtio_queue_ready(vq));
132
133 vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);
134
135 while (!port->throttled) {
136 unsigned int i;
137
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 }
146
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 = vsc->have_data(port,
153 port->elem.out_sg[i].iov_base
154 + port->iov_offset,
155 buf_size);
156 if (port->throttled) {
157 port->iov_idx = i;
158 if (ret > 0) {
159 port->iov_offset += ret;
160 }
161 break;
162 }
163 port->iov_offset = 0;
164 }
165 if (port->throttled) {
166 break;
167 }
168 virtqueue_push(vq, &port->elem, 0);
169 port->elem.out_num = 0;
170 }
171 virtio_notify(vdev, vq);
172 }
173
174 static void flush_queued_data(VirtIOSerialPort *port)
175 {
176 assert(port);
177
178 if (!virtio_queue_ready(port->ovq)) {
179 return;
180 }
181 do_flush_queued_data(port, port->ovq, VIRTIO_DEVICE(port->vser));
182 }
183
184 static size_t send_control_msg(VirtIOSerial *vser, void *buf, size_t len)
185 {
186 VirtQueueElement elem;
187 VirtQueue *vq;
188
189 vq = vser->c_ivq;
190 if (!virtio_queue_ready(vq)) {
191 return 0;
192 }
193 if (!virtqueue_pop(vq, &elem)) {
194 return 0;
195 }
196
197 memcpy(elem.in_sg[0].iov_base, buf, len);
198
199 virtqueue_push(vq, &elem, len);
200 virtio_notify(VIRTIO_DEVICE(vser), vq);
201 return len;
202 }
203
204 static size_t send_control_event(VirtIOSerial *vser, uint32_t port_id,
205 uint16_t event, uint16_t value)
206 {
207 VirtIODevice *vdev = VIRTIO_DEVICE(vser);
208 struct virtio_console_control cpkt;
209
210 virtio_stl_p(vdev, &cpkt.id, port_id);
211 virtio_stw_p(vdev, &cpkt.event, event);
212 virtio_stw_p(vdev, &cpkt.value, value);
213
214 trace_virtio_serial_send_control_event(port_id, event, value);
215 return send_control_msg(vser, &cpkt, sizeof(cpkt));
216 }
217
218 /* Functions for use inside qemu to open and read from/write to ports */
219 int virtio_serial_open(VirtIOSerialPort *port)
220 {
221 /* Don't allow opening an already-open port */
222 if (port->host_connected) {
223 return 0;
224 }
225 /* Send port open notification to the guest */
226 port->host_connected = true;
227 send_control_event(port->vser, port->id, VIRTIO_CONSOLE_PORT_OPEN, 1);
228
229 return 0;
230 }
231
232 int virtio_serial_close(VirtIOSerialPort *port)
233 {
234 port->host_connected = false;
235 /*
236 * If there's any data the guest sent which the app didn't
237 * consume, reset the throttling flag and discard the data.
238 */
239 port->throttled = false;
240 discard_vq_data(port->ovq, VIRTIO_DEVICE(port->vser));
241
242 send_control_event(port->vser, port->id, VIRTIO_CONSOLE_PORT_OPEN, 0);
243
244 return 0;
245 }
246
247 /* Individual ports/apps call this function to write to the guest. */
248 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
249 size_t size)
250 {
251 if (!port || !port->host_connected || !port->guest_connected) {
252 return 0;
253 }
254 return write_to_port(port, buf, size);
255 }
256
257 /*
258 * Readiness of the guest to accept data on a port.
259 * Returns max. data the guest can receive
260 */
261 size_t virtio_serial_guest_ready(VirtIOSerialPort *port)
262 {
263 VirtIODevice *vdev = VIRTIO_DEVICE(port->vser);
264 VirtQueue *vq = port->ivq;
265 unsigned int bytes;
266
267 if (!virtio_queue_ready(vq) ||
268 !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK) ||
269 virtio_queue_empty(vq)) {
270 return 0;
271 }
272 if (use_multiport(port->vser) && !port->guest_connected) {
273 return 0;
274 }
275 virtqueue_get_avail_bytes(vq, &bytes, NULL, 4096, 0);
276 return bytes;
277 }
278
279 static void flush_queued_data_bh(void *opaque)
280 {
281 VirtIOSerialPort *port = opaque;
282
283 flush_queued_data(port);
284 }
285
286 void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle)
287 {
288 if (!port) {
289 return;
290 }
291
292 trace_virtio_serial_throttle_port(port->id, throttle);
293 port->throttled = throttle;
294 if (throttle) {
295 return;
296 }
297 qemu_bh_schedule(port->bh);
298 }
299
300 /* Guest wants to notify us of some event */
301 static void handle_control_message(VirtIOSerial *vser, void *buf, size_t len)
302 {
303 VirtIODevice *vdev = VIRTIO_DEVICE(vser);
304 struct VirtIOSerialPort *port;
305 VirtIOSerialPortClass *vsc;
306 struct virtio_console_control cpkt, *gcpkt;
307 uint8_t *buffer;
308 size_t buffer_len;
309
310 gcpkt = buf;
311
312 if (len < sizeof(cpkt)) {
313 /* The guest sent an invalid control packet */
314 return;
315 }
316
317 cpkt.event = virtio_lduw_p(vdev, &gcpkt->event);
318 cpkt.value = virtio_lduw_p(vdev, &gcpkt->value);
319
320 trace_virtio_serial_handle_control_message(cpkt.event, cpkt.value);
321
322 if (cpkt.event == VIRTIO_CONSOLE_DEVICE_READY) {
323 if (!cpkt.value) {
324 error_report("virtio-serial-bus: Guest failure in adding device %s",
325 vser->bus.qbus.name);
326 return;
327 }
328 /*
329 * The device is up, we can now tell the device about all the
330 * ports we have here.
331 */
332 QTAILQ_FOREACH(port, &vser->ports, next) {
333 send_control_event(vser, port->id, VIRTIO_CONSOLE_PORT_ADD, 1);
334 }
335 return;
336 }
337
338 port = find_port_by_id(vser, virtio_ldl_p(vdev, &gcpkt->id));
339 if (!port) {
340 error_report("virtio-serial-bus: Unexpected port id %u for device %s",
341 virtio_ldl_p(vdev, &gcpkt->id), vser->bus.qbus.name);
342 return;
343 }
344
345 trace_virtio_serial_handle_control_message_port(port->id);
346
347 vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);
348
349 switch(cpkt.event) {
350 case VIRTIO_CONSOLE_PORT_READY:
351 if (!cpkt.value) {
352 error_report("virtio-serial-bus: Guest failure in adding port %u for device %s",
353 port->id, vser->bus.qbus.name);
354 break;
355 }
356 /*
357 * Now that we know the guest asked for the port name, we're
358 * sure the guest has initialised whatever state is necessary
359 * for this port. Now's a good time to let the guest know if
360 * this port is a console port so that the guest can hook it
361 * up to hvc.
362 */
363 if (vsc->is_console) {
364 send_control_event(vser, port->id, VIRTIO_CONSOLE_CONSOLE_PORT, 1);
365 }
366
367 if (port->name) {
368 virtio_stl_p(vdev, &cpkt.id, port->id);
369 virtio_stw_p(vdev, &cpkt.event, VIRTIO_CONSOLE_PORT_NAME);
370 virtio_stw_p(vdev, &cpkt.value, 1);
371
372 buffer_len = sizeof(cpkt) + strlen(port->name) + 1;
373 buffer = g_malloc(buffer_len);
374
375 memcpy(buffer, &cpkt, sizeof(cpkt));
376 memcpy(buffer + sizeof(cpkt), port->name, strlen(port->name));
377 buffer[buffer_len - 1] = 0;
378
379 send_control_msg(vser, buffer, buffer_len);
380 g_free(buffer);
381 }
382
383 if (port->host_connected) {
384 send_control_event(vser, port->id, VIRTIO_CONSOLE_PORT_OPEN, 1);
385 }
386
387 /*
388 * When the guest has asked us for this information it means
389 * the guest is all setup and has its virtqueues
390 * initialised. If some app is interested in knowing about
391 * this event, let it know.
392 */
393 if (vsc->guest_ready) {
394 vsc->guest_ready(port);
395 }
396 break;
397
398 case VIRTIO_CONSOLE_PORT_OPEN:
399 port->guest_connected = cpkt.value;
400 if (vsc->set_guest_connected) {
401 /* Send the guest opened notification if an app is interested */
402 vsc->set_guest_connected(port, cpkt.value);
403 }
404 break;
405 }
406 }
407
408 static void control_in(VirtIODevice *vdev, VirtQueue *vq)
409 {
410 }
411
412 static void control_out(VirtIODevice *vdev, VirtQueue *vq)
413 {
414 VirtQueueElement elem;
415 VirtIOSerial *vser;
416 uint8_t *buf;
417 size_t len;
418
419 vser = VIRTIO_SERIAL(vdev);
420
421 len = 0;
422 buf = NULL;
423 while (virtqueue_pop(vq, &elem)) {
424 size_t cur_len;
425
426 cur_len = iov_size(elem.out_sg, elem.out_num);
427 /*
428 * Allocate a new buf only if we didn't have one previously or
429 * if the size of the buf differs
430 */
431 if (cur_len > len) {
432 g_free(buf);
433
434 buf = g_malloc(cur_len);
435 len = cur_len;
436 }
437 iov_to_buf(elem.out_sg, elem.out_num, 0, buf, cur_len);
438
439 handle_control_message(vser, buf, cur_len);
440 virtqueue_push(vq, &elem, 0);
441 }
442 g_free(buf);
443 virtio_notify(vdev, vq);
444 }
445
446 /* Guest wrote something to some port. */
447 static void handle_output(VirtIODevice *vdev, VirtQueue *vq)
448 {
449 VirtIOSerial *vser;
450 VirtIOSerialPort *port;
451
452 vser = VIRTIO_SERIAL(vdev);
453 port = find_port_by_vq(vser, vq);
454
455 if (!port || !port->host_connected) {
456 discard_vq_data(vq, vdev);
457 return;
458 }
459
460 if (!port->throttled) {
461 do_flush_queued_data(port, vq, vdev);
462 return;
463 }
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 {
472 VirtIOSerial *vser;
473
474 vser = VIRTIO_SERIAL(vdev);
475
476 if (vser->bus.max_nr_ports > 1) {
477 features |= (1 << VIRTIO_CONSOLE_F_MULTIPORT);
478 }
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 = VIRTIO_SERIAL(vdev);
488 memcpy(config_data, &vser->config, sizeof(struct virtio_console_config));
489 }
490
491 static void guest_reset(VirtIOSerial *vser)
492 {
493 VirtIOSerialPort *port;
494 VirtIOSerialPortClass *vsc;
495
496 QTAILQ_FOREACH(port, &vser->ports, next) {
497 vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);
498 if (port->guest_connected) {
499 port->guest_connected = false;
500 if (vsc->set_guest_connected) {
501 vsc->set_guest_connected(port, false);
502 }
503 }
504 }
505 }
506
507 static void set_status(VirtIODevice *vdev, uint8_t status)
508 {
509 VirtIOSerial *vser;
510 VirtIOSerialPort *port;
511
512 vser = VIRTIO_SERIAL(vdev);
513 port = find_port_by_id(vser, 0);
514
515 if (port && !use_multiport(port->vser)
516 && (status & VIRTIO_CONFIG_S_DRIVER_OK)) {
517 /*
518 * Non-multiport guests won't be able to tell us guest
519 * open/close status. Such guests can only have a port at id
520 * 0, so set guest_connected for such ports as soon as guest
521 * is up.
522 */
523 port->guest_connected = true;
524 }
525 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
526 guest_reset(vser);
527 }
528 }
529
530 static void vser_reset(VirtIODevice *vdev)
531 {
532 VirtIOSerial *vser;
533
534 vser = VIRTIO_SERIAL(vdev);
535 guest_reset(vser);
536
537 /* In case we have switched endianness */
538 vser->config.max_nr_ports =
539 virtio_tswap32(vdev, vser->serial.max_virtserial_ports);
540 }
541
542 static void virtio_serial_save(QEMUFile *f, void *opaque)
543 {
544 /* The virtio device */
545 virtio_save(VIRTIO_DEVICE(opaque), f);
546 }
547
548 static void virtio_serial_save_device(VirtIODevice *vdev, QEMUFile *f)
549 {
550 VirtIOSerial *s = VIRTIO_SERIAL(vdev);
551 VirtIOSerialPort *port;
552 uint32_t nr_active_ports;
553 unsigned int i, max_nr_ports;
554
555 /* The config space */
556 qemu_put_be16s(f, &s->config.cols);
557 qemu_put_be16s(f, &s->config.rows);
558
559 qemu_put_be32s(f, &s->config.max_nr_ports);
560
561 /* The ports map */
562 max_nr_ports = virtio_tswap32(vdev, s->config.max_nr_ports);
563 for (i = 0; i < (max_nr_ports + 31) / 32; i++) {
564 qemu_put_be32s(f, &s->ports_map[i]);
565 }
566
567 /* Ports */
568
569 nr_active_ports = 0;
570 QTAILQ_FOREACH(port, &s->ports, next) {
571 nr_active_ports++;
572 }
573
574 qemu_put_be32s(f, &nr_active_ports);
575
576 /*
577 * Items in struct VirtIOSerialPort.
578 */
579 QTAILQ_FOREACH(port, &s->ports, next) {
580 uint32_t elem_popped;
581
582 qemu_put_be32s(f, &port->id);
583 qemu_put_byte(f, port->guest_connected);
584 qemu_put_byte(f, port->host_connected);
585
586 elem_popped = 0;
587 if (port->elem.out_num) {
588 elem_popped = 1;
589 }
590 qemu_put_be32s(f, &elem_popped);
591 if (elem_popped) {
592 qemu_put_be32s(f, &port->iov_idx);
593 qemu_put_be64s(f, &port->iov_offset);
594
595 qemu_put_buffer(f, (unsigned char *)&port->elem,
596 sizeof(port->elem));
597 }
598 }
599 }
600
601 static void virtio_serial_post_load_timer_cb(void *opaque)
602 {
603 uint32_t i;
604 VirtIOSerial *s = VIRTIO_SERIAL(opaque);
605 VirtIOSerialPort *port;
606 uint8_t host_connected;
607 VirtIOSerialPortClass *vsc;
608
609 if (!s->post_load) {
610 return;
611 }
612 for (i = 0 ; i < s->post_load->nr_active_ports; ++i) {
613 port = s->post_load->connected[i].port;
614 host_connected = s->post_load->connected[i].host_connected;
615 if (host_connected != port->host_connected) {
616 /*
617 * We have to let the guest know of the host connection
618 * status change
619 */
620 send_control_event(s, port->id, VIRTIO_CONSOLE_PORT_OPEN,
621 port->host_connected);
622 }
623 vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);
624 if (vsc->set_guest_connected) {
625 vsc->set_guest_connected(port, port->guest_connected);
626 }
627 }
628 g_free(s->post_load->connected);
629 timer_free(s->post_load->timer);
630 g_free(s->post_load);
631 s->post_load = NULL;
632 }
633
634 static int fetch_active_ports_list(QEMUFile *f, int version_id,
635 VirtIOSerial *s, uint32_t nr_active_ports)
636 {
637 uint32_t i;
638
639 s->post_load = g_malloc0(sizeof(*s->post_load));
640 s->post_load->nr_active_ports = nr_active_ports;
641 s->post_load->connected =
642 g_malloc0(sizeof(*s->post_load->connected) * nr_active_ports);
643
644 s->post_load->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
645 virtio_serial_post_load_timer_cb,
646 s);
647
648 /* Items in struct VirtIOSerialPort */
649 for (i = 0; i < nr_active_ports; i++) {
650 VirtIOSerialPort *port;
651 uint32_t id;
652
653 id = qemu_get_be32(f);
654 port = find_port_by_id(s, id);
655 if (!port) {
656 return -EINVAL;
657 }
658
659 port->guest_connected = qemu_get_byte(f);
660 s->post_load->connected[i].port = port;
661 s->post_load->connected[i].host_connected = qemu_get_byte(f);
662
663 if (version_id > 2) {
664 uint32_t elem_popped;
665
666 qemu_get_be32s(f, &elem_popped);
667 if (elem_popped) {
668 qemu_get_be32s(f, &port->iov_idx);
669 qemu_get_be64s(f, &port->iov_offset);
670
671 qemu_get_buffer(f, (unsigned char *)&port->elem,
672 sizeof(port->elem));
673 virtqueue_map_sg(port->elem.in_sg, port->elem.in_addr,
674 port->elem.in_num, 1);
675 virtqueue_map_sg(port->elem.out_sg, port->elem.out_addr,
676 port->elem.out_num, 1);
677
678 /*
679 * Port was throttled on source machine. Let's
680 * unthrottle it here so data starts flowing again.
681 */
682 virtio_serial_throttle_port(port, false);
683 }
684 }
685 }
686 timer_mod(s->post_load->timer, 1);
687 return 0;
688 }
689
690 static int virtio_serial_load(QEMUFile *f, void *opaque, int version_id)
691 {
692 if (version_id > 3) {
693 return -EINVAL;
694 }
695
696 /* The virtio device */
697 return virtio_load(VIRTIO_DEVICE(opaque), f, version_id);
698 }
699
700 static int virtio_serial_load_device(VirtIODevice *vdev, QEMUFile *f,
701 int version_id)
702 {
703 VirtIOSerial *s = VIRTIO_SERIAL(vdev);
704 uint32_t max_nr_ports, nr_active_ports, ports_map;
705 unsigned int i;
706 int ret;
707 uint32_t tmp;
708
709 if (version_id < 2) {
710 return 0;
711 }
712
713 /* Unused */
714 qemu_get_be16s(f, (uint16_t *) &tmp);
715 qemu_get_be16s(f, (uint16_t *) &tmp);
716 qemu_get_be32s(f, &tmp);
717
718 /* Note: this is the only location where we use tswap32() instead of
719 * virtio_tswap32() because:
720 * - virtio_tswap32() only makes sense when the device is fully restored
721 * - the target endianness that was used to populate s->config is
722 * necessarly the default one
723 */
724 max_nr_ports = tswap32(s->config.max_nr_ports);
725 for (i = 0; i < (max_nr_ports + 31) / 32; i++) {
726 qemu_get_be32s(f, &ports_map);
727
728 if (ports_map != s->ports_map[i]) {
729 /*
730 * Ports active on source and destination don't
731 * match. Fail migration.
732 */
733 return -EINVAL;
734 }
735 }
736
737 qemu_get_be32s(f, &nr_active_ports);
738
739 if (nr_active_ports) {
740 ret = fetch_active_ports_list(f, version_id, s, nr_active_ports);
741 if (ret) {
742 return ret;
743 }
744 }
745 return 0;
746 }
747
748 static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
749
750 static Property virtser_props[] = {
751 DEFINE_PROP_UINT32("nr", VirtIOSerialPort, id, VIRTIO_CONSOLE_BAD_ID),
752 DEFINE_PROP_STRING("name", VirtIOSerialPort, name),
753 DEFINE_PROP_END_OF_LIST()
754 };
755
756 #define TYPE_VIRTIO_SERIAL_BUS "virtio-serial-bus"
757 #define VIRTIO_SERIAL_BUS(obj) \
758 OBJECT_CHECK(VirtIOSerialBus, (obj), TYPE_VIRTIO_SERIAL_BUS)
759
760 static void virtser_bus_class_init(ObjectClass *klass, void *data)
761 {
762 BusClass *k = BUS_CLASS(klass);
763 k->print_dev = virtser_bus_dev_print;
764 }
765
766 static const TypeInfo virtser_bus_info = {
767 .name = TYPE_VIRTIO_SERIAL_BUS,
768 .parent = TYPE_BUS,
769 .instance_size = sizeof(VirtIOSerialBus),
770 .class_init = virtser_bus_class_init,
771 };
772
773 static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
774 {
775 VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, qdev);
776
777 monitor_printf(mon, "%*sport %d, guest %s, host %s, throttle %s\n",
778 indent, "", port->id,
779 port->guest_connected ? "on" : "off",
780 port->host_connected ? "on" : "off",
781 port->throttled ? "on" : "off");
782 }
783
784 /* This function is only used if a port id is not provided by the user */
785 static uint32_t find_free_port_id(VirtIOSerial *vser)
786 {
787 VirtIODevice *vdev = VIRTIO_DEVICE(vser);
788 unsigned int i, max_nr_ports;
789
790 max_nr_ports = virtio_tswap32(vdev, vser->config.max_nr_ports);
791 for (i = 0; i < (max_nr_ports + 31) / 32; i++) {
792 uint32_t map, bit;
793
794 map = vser->ports_map[i];
795 bit = ffs(~map);
796 if (bit) {
797 return (bit - 1) + i * 32;
798 }
799 }
800 return VIRTIO_CONSOLE_BAD_ID;
801 }
802
803 static void mark_port_added(VirtIOSerial *vser, uint32_t port_id)
804 {
805 unsigned int i;
806
807 i = port_id / 32;
808 vser->ports_map[i] |= 1U << (port_id % 32);
809 }
810
811 static void add_port(VirtIOSerial *vser, uint32_t port_id)
812 {
813 mark_port_added(vser, port_id);
814 send_control_event(vser, port_id, VIRTIO_CONSOLE_PORT_ADD, 1);
815 }
816
817 static void remove_port(VirtIOSerial *vser, uint32_t port_id)
818 {
819 VirtIOSerialPort *port;
820
821 /*
822 * Don't mark port 0 removed -- we explicitly reserve it for
823 * backward compat with older guests, ensure a virtconsole device
824 * unplug retains the reservation.
825 */
826 if (port_id) {
827 unsigned int i;
828
829 i = port_id / 32;
830 vser->ports_map[i] &= ~(1U << (port_id % 32));
831 }
832
833 port = find_port_by_id(vser, port_id);
834 /*
835 * This function is only called from qdev's unplug callback; if we
836 * get a NULL port here, we're in trouble.
837 */
838 assert(port);
839
840 /* Flush out any unconsumed buffers first */
841 discard_vq_data(port->ovq, VIRTIO_DEVICE(port->vser));
842
843 send_control_event(vser, port->id, VIRTIO_CONSOLE_PORT_REMOVE, 1);
844 }
845
846 static void virtser_port_device_realize(DeviceState *dev, Error **errp)
847 {
848 VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(dev);
849 VirtIOSerialPortClass *vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);
850 VirtIOSerialBus *bus = VIRTIO_SERIAL_BUS(qdev_get_parent_bus(dev));
851 VirtIODevice *vdev = VIRTIO_DEVICE(bus->vser);
852 int max_nr_ports;
853 bool plugging_port0;
854 Error *err = NULL;
855
856 port->vser = bus->vser;
857 port->bh = qemu_bh_new(flush_queued_data_bh, port);
858
859 assert(vsc->have_data);
860
861 /*
862 * Is the first console port we're seeing? If so, put it up at
863 * location 0. This is done for backward compatibility (old
864 * kernel, new qemu).
865 */
866 plugging_port0 = vsc->is_console && !find_port_by_id(port->vser, 0);
867
868 if (find_port_by_id(port->vser, port->id)) {
869 error_setg(errp, "virtio-serial-bus: A port already exists at id %u",
870 port->id);
871 return;
872 }
873
874 if (port->name != NULL && find_port_by_name(port->name)) {
875 error_setg(errp, "virtio-serial-bus: A port already exists by name %s",
876 port->name);
877 return;
878 }
879
880 if (port->id == VIRTIO_CONSOLE_BAD_ID) {
881 if (plugging_port0) {
882 port->id = 0;
883 } else {
884 port->id = find_free_port_id(port->vser);
885 if (port->id == VIRTIO_CONSOLE_BAD_ID) {
886 error_setg(errp, "virtio-serial-bus: Maximum port limit for "
887 "this device reached");
888 return;
889 }
890 }
891 }
892
893 max_nr_ports = virtio_tswap32(vdev, port->vser->config.max_nr_ports);
894 if (port->id >= max_nr_ports) {
895 error_setg(errp, "virtio-serial-bus: Out-of-range port id specified, "
896 "max. allowed: %u", max_nr_ports - 1);
897 return;
898 }
899
900 vsc->realize(dev, &err);
901 if (err != NULL) {
902 error_propagate(errp, err);
903 return;
904 }
905
906 port->elem.out_num = 0;
907 }
908
909 static void virtser_port_device_plug(HotplugHandler *hotplug_dev,
910 DeviceState *dev, Error **errp)
911 {
912 VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(dev);
913
914 QTAILQ_INSERT_TAIL(&port->vser->ports, port, next);
915 port->ivq = port->vser->ivqs[port->id];
916 port->ovq = port->vser->ovqs[port->id];
917
918 add_port(port->vser, port->id);
919
920 /* Send an update to the guest about this new port added */
921 virtio_notify_config(VIRTIO_DEVICE(hotplug_dev));
922 }
923
924 static void virtser_port_device_unrealize(DeviceState *dev, Error **errp)
925 {
926 VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(dev);
927 VirtIOSerialPortClass *vsc = VIRTIO_SERIAL_PORT_GET_CLASS(dev);
928 VirtIOSerial *vser = port->vser;
929
930 qemu_bh_delete(port->bh);
931 remove_port(port->vser, port->id);
932
933 QTAILQ_REMOVE(&vser->ports, port, next);
934
935 if (vsc->unrealize) {
936 vsc->unrealize(dev, errp);
937 }
938 }
939
940 static void virtio_serial_device_realize(DeviceState *dev, Error **errp)
941 {
942 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
943 VirtIOSerial *vser = VIRTIO_SERIAL(dev);
944 uint32_t i, max_supported_ports;
945
946 if (!vser->serial.max_virtserial_ports) {
947 error_setg(errp, "Maximum number of serial ports not specified");
948 return;
949 }
950
951 /* Each port takes 2 queues, and one pair is for the control queue */
952 max_supported_ports = VIRTIO_PCI_QUEUE_MAX / 2 - 1;
953
954 if (vser->serial.max_virtserial_ports > max_supported_ports) {
955 error_setg(errp, "maximum ports supported: %u", max_supported_ports);
956 return;
957 }
958
959 virtio_init(vdev, "virtio-serial", VIRTIO_ID_CONSOLE,
960 sizeof(struct virtio_console_config));
961
962 /* Spawn a new virtio-serial bus on which the ports will ride as devices */
963 qbus_create_inplace(&vser->bus, sizeof(vser->bus), TYPE_VIRTIO_SERIAL_BUS,
964 dev, vdev->bus_name);
965 qbus_set_hotplug_handler(BUS(&vser->bus), DEVICE(vser), errp);
966 vser->bus.vser = vser;
967 QTAILQ_INIT(&vser->ports);
968
969 vser->bus.max_nr_ports = vser->serial.max_virtserial_ports;
970 vser->ivqs = g_malloc(vser->serial.max_virtserial_ports
971 * sizeof(VirtQueue *));
972 vser->ovqs = g_malloc(vser->serial.max_virtserial_ports
973 * sizeof(VirtQueue *));
974
975 /* Add a queue for host to guest transfers for port 0 (backward compat) */
976 vser->ivqs[0] = virtio_add_queue(vdev, 128, handle_input);
977 /* Add a queue for guest to host transfers for port 0 (backward compat) */
978 vser->ovqs[0] = virtio_add_queue(vdev, 128, handle_output);
979
980 /* TODO: host to guest notifications can get dropped
981 * if the queue fills up. Implement queueing in host,
982 * this might also make it possible to reduce the control
983 * queue size: as guest preposts buffers there,
984 * this will save 4Kbyte of guest memory per entry. */
985
986 /* control queue: host to guest */
987 vser->c_ivq = virtio_add_queue(vdev, 32, control_in);
988 /* control queue: guest to host */
989 vser->c_ovq = virtio_add_queue(vdev, 32, control_out);
990
991 for (i = 1; i < vser->bus.max_nr_ports; i++) {
992 /* Add a per-port queue for host to guest transfers */
993 vser->ivqs[i] = virtio_add_queue(vdev, 128, handle_input);
994 /* Add a per-per queue for guest to host transfers */
995 vser->ovqs[i] = virtio_add_queue(vdev, 128, handle_output);
996 }
997
998 vser->config.max_nr_ports =
999 virtio_tswap32(vdev, vser->serial.max_virtserial_ports);
1000 vser->ports_map = g_malloc0(((vser->serial.max_virtserial_ports + 31) / 32)
1001 * sizeof(vser->ports_map[0]));
1002 /*
1003 * Reserve location 0 for a console port for backward compat
1004 * (old kernel, new qemu)
1005 */
1006 mark_port_added(vser, 0);
1007
1008 vser->post_load = NULL;
1009
1010 /*
1011 * Register for the savevm section with the virtio-console name
1012 * to preserve backward compat
1013 */
1014 register_savevm(dev, "virtio-console", -1, 3, virtio_serial_save,
1015 virtio_serial_load, vser);
1016
1017 QLIST_INSERT_HEAD(&vserdevices.devices, vser, next);
1018 }
1019
1020 static void virtio_serial_port_class_init(ObjectClass *klass, void *data)
1021 {
1022 DeviceClass *k = DEVICE_CLASS(klass);
1023
1024 set_bit(DEVICE_CATEGORY_INPUT, k->categories);
1025 k->bus_type = TYPE_VIRTIO_SERIAL_BUS;
1026 k->realize = virtser_port_device_realize;
1027 k->unrealize = virtser_port_device_unrealize;
1028 k->props = virtser_props;
1029 }
1030
1031 static const TypeInfo virtio_serial_port_type_info = {
1032 .name = TYPE_VIRTIO_SERIAL_PORT,
1033 .parent = TYPE_DEVICE,
1034 .instance_size = sizeof(VirtIOSerialPort),
1035 .abstract = true,
1036 .class_size = sizeof(VirtIOSerialPortClass),
1037 .class_init = virtio_serial_port_class_init,
1038 };
1039
1040 static void virtio_serial_device_unrealize(DeviceState *dev, Error **errp)
1041 {
1042 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1043 VirtIOSerial *vser = VIRTIO_SERIAL(dev);
1044
1045 QLIST_REMOVE(vser, next);
1046
1047 unregister_savevm(dev, "virtio-console", vser);
1048
1049 g_free(vser->ivqs);
1050 g_free(vser->ovqs);
1051 g_free(vser->ports_map);
1052 if (vser->post_load) {
1053 g_free(vser->post_load->connected);
1054 timer_del(vser->post_load->timer);
1055 timer_free(vser->post_load->timer);
1056 g_free(vser->post_load);
1057 }
1058 virtio_cleanup(vdev);
1059 }
1060
1061 static Property virtio_serial_properties[] = {
1062 DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtIOSerial, serial),
1063 DEFINE_PROP_END_OF_LIST(),
1064 };
1065
1066 static void virtio_serial_class_init(ObjectClass *klass, void *data)
1067 {
1068 DeviceClass *dc = DEVICE_CLASS(klass);
1069 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
1070 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
1071
1072 QLIST_INIT(&vserdevices.devices);
1073
1074 dc->props = virtio_serial_properties;
1075 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
1076 vdc->realize = virtio_serial_device_realize;
1077 vdc->unrealize = virtio_serial_device_unrealize;
1078 vdc->get_features = get_features;
1079 vdc->get_config = get_config;
1080 vdc->set_status = set_status;
1081 vdc->reset = vser_reset;
1082 vdc->save = virtio_serial_save_device;
1083 vdc->load = virtio_serial_load_device;
1084 hc->plug = virtser_port_device_plug;
1085 hc->unplug = qdev_simple_device_unplug_cb;
1086 }
1087
1088 static const TypeInfo virtio_device_info = {
1089 .name = TYPE_VIRTIO_SERIAL,
1090 .parent = TYPE_VIRTIO_DEVICE,
1091 .instance_size = sizeof(VirtIOSerial),
1092 .class_init = virtio_serial_class_init,
1093 .interfaces = (InterfaceInfo[]) {
1094 { TYPE_HOTPLUG_HANDLER },
1095 { }
1096 }
1097 };
1098
1099 static void virtio_serial_register_types(void)
1100 {
1101 type_register_static(&virtser_bus_info);
1102 type_register_static(&virtio_serial_port_type_info);
1103 type_register_static(&virtio_device_info);
1104 }
1105
1106 type_init(virtio_serial_register_types)