2 * Virtio Console and Generic Serial Port Devices
4 * Copyright Red Hat, Inc. 2009, 2010
7 * Amit Shah <amit.shah@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "chardev/char-fe.h"
15 #include "qemu/error-report.h"
17 #include "hw/virtio/virtio-serial.h"
18 #include "qapi-event.h"
20 #define TYPE_VIRTIO_CONSOLE_SERIAL_PORT "virtserialport"
21 #define VIRTIO_CONSOLE(obj) \
22 OBJECT_CHECK(VirtConsole, (obj), TYPE_VIRTIO_CONSOLE_SERIAL_PORT)
24 typedef struct VirtConsole
{
25 VirtIOSerialPort parent_obj
;
32 * Callback function that's called from chardevs when backend becomes
35 static gboolean
chr_write_unblocked(GIOChannel
*chan
, GIOCondition cond
,
38 VirtConsole
*vcon
= opaque
;
41 virtio_serial_throttle_port(VIRTIO_SERIAL_PORT(vcon
), false);
45 /* Callback function that's called when the guest sends us data */
46 static ssize_t
flush_buf(VirtIOSerialPort
*port
,
47 const uint8_t *buf
, ssize_t len
)
49 VirtConsole
*vcon
= VIRTIO_CONSOLE(port
);
52 if (!qemu_chr_fe_backend_connected(&vcon
->chr
)) {
53 /* If there's no backend, we can just say we consumed all data. */
57 ret
= qemu_chr_fe_write(&vcon
->chr
, buf
, len
);
58 trace_virtio_console_flush_buf(port
->id
, len
, ret
);
61 VirtIOSerialPortClass
*k
= VIRTIO_SERIAL_PORT_GET_CLASS(port
);
64 * Ideally we'd get a better error code than just -1, but
65 * that's what the chardev interface gives us right now. If
66 * we had a finer-grained message, like -EPIPE, we could close
72 /* XXX we should be queuing data to send later for the
73 * console devices too rather than silently dropping
74 * console data on EAGAIN. The Linux virtio-console
75 * hvc driver though does sends with spinlocks held,
76 * so if we enable throttling that'll stall the entire
77 * guest kernel, not merely the process writing to the
80 * While we could queue data for later write without
81 * enabling throttling, this would result in the guest
82 * being able to trigger arbitrary memory usage in QEMU
83 * buffering data for later writes.
85 * So fixing this problem likely requires fixing the
86 * Linux virtio-console hvc driver to not hold spinlocks
87 * while writing, and instead merely block the process
88 * that's writing. QEMU would then need some way to detect
89 * if the guest had the fixed driver too, before we can
90 * use throttling on host side.
93 virtio_serial_throttle_port(port
, true);
95 vcon
->watch
= qemu_chr_fe_add_watch(&vcon
->chr
,
97 chr_write_unblocked
, vcon
);
104 /* Callback function that's called when the guest opens/closes the port */
105 static void set_guest_connected(VirtIOSerialPort
*port
, int guest_connected
)
107 VirtConsole
*vcon
= VIRTIO_CONSOLE(port
);
108 DeviceState
*dev
= DEVICE(port
);
109 VirtIOSerialPortClass
*k
= VIRTIO_SERIAL_PORT_GET_CLASS(port
);
111 if (!k
->is_console
) {
112 qemu_chr_fe_set_open(&vcon
->chr
, guest_connected
);
116 qapi_event_send_vserport_change(dev
->id
, guest_connected
,
121 static void guest_writable(VirtIOSerialPort
*port
)
123 VirtConsole
*vcon
= VIRTIO_CONSOLE(port
);
125 qemu_chr_fe_accept_input(&vcon
->chr
);
128 /* Readiness of the guest to accept data on a port */
129 static int chr_can_read(void *opaque
)
131 VirtConsole
*vcon
= opaque
;
133 return virtio_serial_guest_ready(VIRTIO_SERIAL_PORT(vcon
));
136 /* Send data from a char device over to the guest */
137 static void chr_read(void *opaque
, const uint8_t *buf
, int size
)
139 VirtConsole
*vcon
= opaque
;
140 VirtIOSerialPort
*port
= VIRTIO_SERIAL_PORT(vcon
);
142 trace_virtio_console_chr_read(port
->id
, size
);
143 virtio_serial_write(port
, buf
, size
);
146 static void chr_event(void *opaque
, int event
)
148 VirtConsole
*vcon
= opaque
;
149 VirtIOSerialPort
*port
= VIRTIO_SERIAL_PORT(vcon
);
151 trace_virtio_console_chr_event(port
->id
, event
);
153 case CHR_EVENT_OPENED
:
154 virtio_serial_open(port
);
156 case CHR_EVENT_CLOSED
:
158 g_source_remove(vcon
->watch
);
161 virtio_serial_close(port
);
166 static int chr_be_change(void *opaque
)
168 VirtConsole
*vcon
= opaque
;
169 VirtIOSerialPort
*port
= VIRTIO_SERIAL_PORT(vcon
);
170 VirtIOSerialPortClass
*k
= VIRTIO_SERIAL_PORT_GET_CLASS(port
);
173 qemu_chr_fe_set_handlers(&vcon
->chr
, chr_can_read
, chr_read
,
174 NULL
, chr_be_change
, vcon
, NULL
, true);
176 qemu_chr_fe_set_handlers(&vcon
->chr
, chr_can_read
, chr_read
,
177 chr_event
, chr_be_change
, vcon
, NULL
, false);
181 g_source_remove(vcon
->watch
);
182 vcon
->watch
= qemu_chr_fe_add_watch(&vcon
->chr
,
184 chr_write_unblocked
, vcon
);
190 static void virtconsole_realize(DeviceState
*dev
, Error
**errp
)
192 VirtIOSerialPort
*port
= VIRTIO_SERIAL_PORT(dev
);
193 VirtConsole
*vcon
= VIRTIO_CONSOLE(dev
);
194 VirtIOSerialPortClass
*k
= VIRTIO_SERIAL_PORT_GET_CLASS(dev
);
196 if (port
->id
== 0 && !k
->is_console
) {
197 error_setg(errp
, "Port number 0 on virtio-serial devices reserved "
198 "for virtconsole devices for backward compatibility.");
202 if (qemu_chr_fe_backend_connected(&vcon
->chr
)) {
204 * For consoles we don't block guest data transfer just
205 * because nothing is connected - we'll just let it go
206 * whetherever the chardev wants - /dev/null probably.
208 * For serial ports we need 100% reliable data transfer
209 * so we use the opened/closed signals from chardev to
210 * trigger open/close of the device
213 qemu_chr_fe_set_handlers(&vcon
->chr
, chr_can_read
, chr_read
,
216 virtio_serial_open(port
);
218 qemu_chr_fe_set_handlers(&vcon
->chr
, chr_can_read
, chr_read
,
219 chr_event
, chr_be_change
,
225 static void virtconsole_unrealize(DeviceState
*dev
, Error
**errp
)
227 VirtConsole
*vcon
= VIRTIO_CONSOLE(dev
);
230 g_source_remove(vcon
->watch
);
234 static void virtconsole_class_init(ObjectClass
*klass
, void *data
)
236 VirtIOSerialPortClass
*k
= VIRTIO_SERIAL_PORT_CLASS(klass
);
238 k
->is_console
= true;
241 static const TypeInfo virtconsole_info
= {
242 .name
= "virtconsole",
243 .parent
= TYPE_VIRTIO_CONSOLE_SERIAL_PORT
,
244 .class_init
= virtconsole_class_init
,
247 static Property virtserialport_properties
[] = {
248 DEFINE_PROP_CHR("chardev", VirtConsole
, chr
),
249 DEFINE_PROP_END_OF_LIST(),
252 static void virtserialport_class_init(ObjectClass
*klass
, void *data
)
254 DeviceClass
*dc
= DEVICE_CLASS(klass
);
255 VirtIOSerialPortClass
*k
= VIRTIO_SERIAL_PORT_CLASS(klass
);
257 k
->realize
= virtconsole_realize
;
258 k
->unrealize
= virtconsole_unrealize
;
259 k
->have_data
= flush_buf
;
260 k
->set_guest_connected
= set_guest_connected
;
261 k
->guest_writable
= guest_writable
;
262 dc
->props
= virtserialport_properties
;
265 static const TypeInfo virtserialport_info
= {
266 .name
= TYPE_VIRTIO_CONSOLE_SERIAL_PORT
,
267 .parent
= TYPE_VIRTIO_SERIAL_PORT
,
268 .instance_size
= sizeof(VirtConsole
),
269 .class_init
= virtserialport_class_init
,
272 static void virtconsole_register_types(void)
274 type_register_static(&virtserialport_info
);
275 type_register_static(&virtconsole_info
);
278 type_init(virtconsole_register_types
)