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