1
2
3
4
5
6
7
8
9
10
11
12
13#include "sysemu/char.h"
14#include "qemu/error-report.h"
15#include "trace.h"
16#include "hw/virtio/virtio-serial.h"
17#include "qapi-event.h"
18
19#define TYPE_VIRTIO_CONSOLE_SERIAL_PORT "virtserialport"
20#define VIRTIO_CONSOLE(obj) \
21 OBJECT_CHECK(VirtConsole, (obj), TYPE_VIRTIO_CONSOLE_SERIAL_PORT)
22
23typedef struct VirtConsole {
24 VirtIOSerialPort parent_obj;
25
26 CharDriverState *chr;
27 guint watch;
28} VirtConsole;
29
30
31
32
33
34static gboolean chr_write_unblocked(GIOChannel *chan, GIOCondition cond,
35 void *opaque)
36{
37 VirtConsole *vcon = opaque;
38
39 vcon->watch = 0;
40 virtio_serial_throttle_port(VIRTIO_SERIAL_PORT(vcon), false);
41 return FALSE;
42}
43
44
45static ssize_t flush_buf(VirtIOSerialPort *port,
46 const uint8_t *buf, ssize_t len)
47{
48 VirtConsole *vcon = VIRTIO_CONSOLE(port);
49 ssize_t ret;
50
51 if (!vcon->chr) {
52
53 return len;
54 }
55
56 ret = qemu_chr_fe_write(vcon->chr, buf, len);
57 trace_virtio_console_flush_buf(port->id, len, ret);
58
59 if (ret < len) {
60 VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_GET_CLASS(port);
61
62
63
64
65
66
67
68 if (ret < 0)
69 ret = 0;
70 if (!k->is_console) {
71 virtio_serial_throttle_port(port, true);
72 if (!vcon->watch) {
73 vcon->watch = qemu_chr_fe_add_watch(vcon->chr,
74 G_IO_OUT|G_IO_HUP,
75 chr_write_unblocked, vcon);
76 }
77 }
78 }
79 return ret;
80}
81
82
83static void set_guest_connected(VirtIOSerialPort *port, int guest_connected)
84{
85 VirtConsole *vcon = VIRTIO_CONSOLE(port);
86 DeviceState *dev = DEVICE(port);
87
88 if (vcon->chr) {
89 qemu_chr_fe_set_open(vcon->chr, guest_connected);
90 }
91
92 if (dev->id) {
93 qapi_event_send_vserport_change(dev->id, guest_connected,
94 &error_abort);
95 }
96}
97
98static void guest_writable(VirtIOSerialPort *port)
99{
100 VirtConsole *vcon = VIRTIO_CONSOLE(port);
101
102 if (vcon->chr) {
103 qemu_chr_accept_input(vcon->chr);
104 }
105}
106
107
108static int chr_can_read(void *opaque)
109{
110 VirtConsole *vcon = opaque;
111
112 return virtio_serial_guest_ready(VIRTIO_SERIAL_PORT(vcon));
113}
114
115
116static void chr_read(void *opaque, const uint8_t *buf, int size)
117{
118 VirtConsole *vcon = opaque;
119 VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(vcon);
120
121 trace_virtio_console_chr_read(port->id, size);
122 virtio_serial_write(port, buf, size);
123}
124
125static void chr_event(void *opaque, int event)
126{
127 VirtConsole *vcon = opaque;
128 VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(vcon);
129
130 trace_virtio_console_chr_event(port->id, event);
131 switch (event) {
132 case CHR_EVENT_OPENED:
133 virtio_serial_open(port);
134 break;
135 case CHR_EVENT_CLOSED:
136 if (vcon->watch) {
137 g_source_remove(vcon->watch);
138 vcon->watch = 0;
139 }
140 virtio_serial_close(port);
141 break;
142 }
143}
144
145static void virtconsole_realize(DeviceState *dev, Error **errp)
146{
147 VirtIOSerialPort *port = VIRTIO_SERIAL_PORT(dev);
148 VirtConsole *vcon = VIRTIO_CONSOLE(dev);
149 VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_GET_CLASS(dev);
150
151 if (port->id == 0 && !k->is_console) {
152 error_setg(errp, "Port number 0 on virtio-serial devices reserved "
153 "for virtconsole devices for backward compatibility.");
154 return;
155 }
156
157 if (vcon->chr) {
158 vcon->chr->explicit_fe_open = 1;
159 qemu_chr_add_handlers(vcon->chr, chr_can_read, chr_read, chr_event,
160 vcon);
161 }
162}
163
164static void virtconsole_unrealize(DeviceState *dev, Error **errp)
165{
166 VirtConsole *vcon = VIRTIO_CONSOLE(dev);
167
168 if (vcon->watch) {
169 g_source_remove(vcon->watch);
170 }
171}
172
173static void virtconsole_class_init(ObjectClass *klass, void *data)
174{
175 VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_CLASS(klass);
176
177 k->is_console = true;
178}
179
180static const TypeInfo virtconsole_info = {
181 .name = "virtconsole",
182 .parent = TYPE_VIRTIO_CONSOLE_SERIAL_PORT,
183 .class_init = virtconsole_class_init,
184};
185
186static Property virtserialport_properties[] = {
187 DEFINE_PROP_CHR("chardev", VirtConsole, chr),
188 DEFINE_PROP_END_OF_LIST(),
189};
190
191static void virtserialport_class_init(ObjectClass *klass, void *data)
192{
193 DeviceClass *dc = DEVICE_CLASS(klass);
194 VirtIOSerialPortClass *k = VIRTIO_SERIAL_PORT_CLASS(klass);
195
196 k->realize = virtconsole_realize;
197 k->unrealize = virtconsole_unrealize;
198 k->have_data = flush_buf;
199 k->set_guest_connected = set_guest_connected;
200 k->guest_writable = guest_writable;
201 dc->props = virtserialport_properties;
202}
203
204static const TypeInfo virtserialport_info = {
205 .name = TYPE_VIRTIO_CONSOLE_SERIAL_PORT,
206 .parent = TYPE_VIRTIO_SERIAL_PORT,
207 .instance_size = sizeof(VirtConsole),
208 .class_init = virtserialport_class_init,
209};
210
211static void virtconsole_register_types(void)
212{
213 type_register_static(&virtserialport_info);
214 type_register_static(&virtconsole_info);
215}
216
217type_init(virtconsole_register_types)
218