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