hw/net: fix mcf_fec driver receiver
[qemu.git] / spice-qemu-char.c
1 #include "config-host.h"
2 #include "trace.h"
3 #include "ui/qemu-spice.h"
4 #include "sysemu/char.h"
5 #include <spice.h>
6 #include <spice/protocol.h>
7
8 #include "qemu/osdep.h"
9
10 typedef struct SpiceCharDriver {
11 CharDriverState* chr;
12 SpiceCharDeviceInstance sin;
13 bool active;
14 bool blocked;
15 const uint8_t *datapos;
16 int datalen;
17 QLIST_ENTRY(SpiceCharDriver) next;
18 } SpiceCharDriver;
19
20 typedef struct SpiceCharSource {
21 GSource source;
22 SpiceCharDriver *scd;
23 } SpiceCharSource;
24
25 static QLIST_HEAD(, SpiceCharDriver) spice_chars =
26 QLIST_HEAD_INITIALIZER(spice_chars);
27
28 static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len)
29 {
30 SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
31 ssize_t out = 0;
32 ssize_t last_out;
33 uint8_t* p = (uint8_t*)buf;
34
35 while (len > 0) {
36 int can_write = qemu_chr_be_can_write(scd->chr);
37 last_out = MIN(len, can_write);
38 if (last_out <= 0) {
39 break;
40 }
41 qemu_chr_be_write(scd->chr, p, last_out);
42 out += last_out;
43 len -= last_out;
44 p += last_out;
45 }
46
47 trace_spice_vmc_write(out, len + out);
48 return out;
49 }
50
51 static int vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len)
52 {
53 SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
54 int bytes = MIN(len, scd->datalen);
55
56 if (bytes > 0) {
57 memcpy(buf, scd->datapos, bytes);
58 scd->datapos += bytes;
59 scd->datalen -= bytes;
60 assert(scd->datalen >= 0);
61 }
62 if (scd->datalen == 0) {
63 scd->datapos = 0;
64 scd->blocked = false;
65 }
66 trace_spice_vmc_read(bytes, len);
67 return bytes;
68 }
69
70 #if SPICE_SERVER_VERSION >= 0x000c02
71 static void vmc_event(SpiceCharDeviceInstance *sin, uint8_t event)
72 {
73 SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
74 int chr_event;
75
76 switch (event) {
77 case SPICE_PORT_EVENT_BREAK:
78 chr_event = CHR_EVENT_BREAK;
79 break;
80 default:
81 return;
82 }
83
84 trace_spice_vmc_event(chr_event);
85 qemu_chr_be_event(scd->chr, chr_event);
86 }
87 #endif
88
89 static void vmc_state(SpiceCharDeviceInstance *sin, int connected)
90 {
91 SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
92
93 if ((scd->chr->be_open && connected) ||
94 (!scd->chr->be_open && !connected)) {
95 return;
96 }
97
98 qemu_chr_be_event(scd->chr,
99 connected ? CHR_EVENT_OPENED : CHR_EVENT_CLOSED);
100 }
101
102 static SpiceCharDeviceInterface vmc_interface = {
103 .base.type = SPICE_INTERFACE_CHAR_DEVICE,
104 .base.description = "spice virtual channel char device",
105 .base.major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
106 .base.minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
107 .state = vmc_state,
108 .write = vmc_write,
109 .read = vmc_read,
110 #if SPICE_SERVER_VERSION >= 0x000c02
111 .event = vmc_event,
112 #endif
113 #if SPICE_SERVER_VERSION >= 0x000c06
114 .flags = SPICE_CHAR_DEVICE_NOTIFY_WRITABLE,
115 #endif
116 };
117
118
119 static void vmc_register_interface(SpiceCharDriver *scd)
120 {
121 if (scd->active) {
122 return;
123 }
124 scd->sin.base.sif = &vmc_interface.base;
125 qemu_spice_add_interface(&scd->sin.base);
126 scd->active = true;
127 trace_spice_vmc_register_interface(scd);
128 }
129
130 static void vmc_unregister_interface(SpiceCharDriver *scd)
131 {
132 if (!scd->active) {
133 return;
134 }
135 spice_server_remove_interface(&scd->sin.base);
136 scd->active = false;
137 trace_spice_vmc_unregister_interface(scd);
138 }
139
140 static gboolean spice_char_source_prepare(GSource *source, gint *timeout)
141 {
142 SpiceCharSource *src = (SpiceCharSource *)source;
143
144 *timeout = -1;
145
146 return !src->scd->blocked;
147 }
148
149 static gboolean spice_char_source_check(GSource *source)
150 {
151 SpiceCharSource *src = (SpiceCharSource *)source;
152
153 return !src->scd->blocked;
154 }
155
156 static gboolean spice_char_source_dispatch(GSource *source,
157 GSourceFunc callback, gpointer user_data)
158 {
159 GIOFunc func = (GIOFunc)callback;
160
161 return func(NULL, G_IO_OUT, user_data);
162 }
163
164 static GSourceFuncs SpiceCharSourceFuncs = {
165 .prepare = spice_char_source_prepare,
166 .check = spice_char_source_check,
167 .dispatch = spice_char_source_dispatch,
168 };
169
170 static GSource *spice_chr_add_watch(CharDriverState *chr, GIOCondition cond)
171 {
172 SpiceCharDriver *scd = chr->opaque;
173 SpiceCharSource *src;
174
175 assert(cond & G_IO_OUT);
176
177 src = (SpiceCharSource *)g_source_new(&SpiceCharSourceFuncs,
178 sizeof(SpiceCharSource));
179 src->scd = scd;
180
181 return (GSource *)src;
182 }
183
184 static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
185 {
186 SpiceCharDriver *s = chr->opaque;
187 int read_bytes;
188
189 assert(s->datalen == 0);
190 s->datapos = buf;
191 s->datalen = len;
192 spice_server_char_device_wakeup(&s->sin);
193 read_bytes = len - s->datalen;
194 if (read_bytes != len) {
195 /* We'll get passed in the unconsumed data with the next call */
196 s->datalen = 0;
197 s->datapos = NULL;
198 s->blocked = true;
199 }
200 return read_bytes;
201 }
202
203 static void spice_chr_close(struct CharDriverState *chr)
204 {
205 SpiceCharDriver *s = chr->opaque;
206
207 vmc_unregister_interface(s);
208 QLIST_REMOVE(s, next);
209
210 g_free((char *)s->sin.subtype);
211 #if SPICE_SERVER_VERSION >= 0x000c02
212 g_free((char *)s->sin.portname);
213 #endif
214 g_free(s);
215 }
216
217 static void spice_vmc_set_fe_open(struct CharDriverState *chr, int fe_open)
218 {
219 SpiceCharDriver *s = chr->opaque;
220 if (fe_open) {
221 vmc_register_interface(s);
222 } else {
223 vmc_unregister_interface(s);
224 }
225 }
226
227 static void spice_port_set_fe_open(struct CharDriverState *chr, int fe_open)
228 {
229 #if SPICE_SERVER_VERSION >= 0x000c02
230 SpiceCharDriver *s = chr->opaque;
231
232 if (fe_open) {
233 spice_server_port_event(&s->sin, SPICE_PORT_EVENT_OPENED);
234 } else {
235 spice_server_port_event(&s->sin, SPICE_PORT_EVENT_CLOSED);
236 }
237 #endif
238 }
239
240 static void spice_chr_fe_event(struct CharDriverState *chr, int event)
241 {
242 #if SPICE_SERVER_VERSION >= 0x000c02
243 SpiceCharDriver *s = chr->opaque;
244
245 spice_server_port_event(&s->sin, event);
246 #endif
247 }
248
249 static void print_allowed_subtypes(void)
250 {
251 const char** psubtype;
252 int i;
253
254 fprintf(stderr, "allowed names: ");
255 for(i=0, psubtype = spice_server_char_device_recognized_subtypes();
256 *psubtype != NULL; ++psubtype, ++i) {
257 if (i == 0) {
258 fprintf(stderr, "%s", *psubtype);
259 } else {
260 fprintf(stderr, ", %s", *psubtype);
261 }
262 }
263 fprintf(stderr, "\n");
264 }
265
266 static void spice_chr_accept_input(struct CharDriverState *chr)
267 {
268 SpiceCharDriver *s = chr->opaque;
269
270 spice_server_char_device_wakeup(&s->sin);
271 }
272
273 static CharDriverState *chr_open(const char *subtype,
274 void (*set_fe_open)(struct CharDriverState *, int))
275
276 {
277 CharDriverState *chr;
278 SpiceCharDriver *s;
279
280 chr = qemu_chr_alloc();
281 s = g_malloc0(sizeof(SpiceCharDriver));
282 s->chr = chr;
283 s->active = false;
284 s->sin.subtype = g_strdup(subtype);
285 chr->opaque = s;
286 chr->chr_write = spice_chr_write;
287 chr->chr_add_watch = spice_chr_add_watch;
288 chr->chr_close = spice_chr_close;
289 chr->chr_set_fe_open = set_fe_open;
290 chr->explicit_be_open = true;
291 chr->chr_fe_event = spice_chr_fe_event;
292 chr->chr_accept_input = spice_chr_accept_input;
293
294 QLIST_INSERT_HEAD(&spice_chars, s, next);
295
296 return chr;
297 }
298
299 CharDriverState *qemu_chr_open_spice_vmc(const char *type)
300 {
301 const char **psubtype = spice_server_char_device_recognized_subtypes();
302
303 if (type == NULL) {
304 fprintf(stderr, "spice-qemu-char: missing name parameter\n");
305 print_allowed_subtypes();
306 return NULL;
307 }
308 for (; *psubtype != NULL; ++psubtype) {
309 if (strcmp(type, *psubtype) == 0) {
310 break;
311 }
312 }
313 if (*psubtype == NULL) {
314 fprintf(stderr, "spice-qemu-char: unsupported type: %s\n", type);
315 print_allowed_subtypes();
316 return NULL;
317 }
318
319 return chr_open(type, spice_vmc_set_fe_open);
320 }
321
322 #if SPICE_SERVER_VERSION >= 0x000c02
323 CharDriverState *qemu_chr_open_spice_port(const char *name)
324 {
325 CharDriverState *chr;
326 SpiceCharDriver *s;
327
328 if (name == NULL) {
329 fprintf(stderr, "spice-qemu-char: missing name parameter\n");
330 return NULL;
331 }
332
333 chr = chr_open("port", spice_port_set_fe_open);
334 s = chr->opaque;
335 s->sin.portname = g_strdup(name);
336
337 return chr;
338 }
339
340 void qemu_spice_register_ports(void)
341 {
342 SpiceCharDriver *s;
343
344 QLIST_FOREACH(s, &spice_chars, next) {
345 if (s->sin.portname == NULL) {
346 continue;
347 }
348 vmc_register_interface(s);
349 }
350 }
351 #endif
352
353 static void qemu_chr_parse_spice_vmc(QemuOpts *opts, ChardevBackend *backend,
354 Error **errp)
355 {
356 const char *name = qemu_opt_get(opts, "name");
357
358 if (name == NULL) {
359 error_setg(errp, "chardev: spice channel: no name given");
360 return;
361 }
362 backend->spicevmc = g_new0(ChardevSpiceChannel, 1);
363 backend->spicevmc->type = g_strdup(name);
364 }
365
366 static void qemu_chr_parse_spice_port(QemuOpts *opts, ChardevBackend *backend,
367 Error **errp)
368 {
369 const char *name = qemu_opt_get(opts, "name");
370
371 if (name == NULL) {
372 error_setg(errp, "chardev: spice port: no name given");
373 return;
374 }
375 backend->spiceport = g_new0(ChardevSpicePort, 1);
376 backend->spiceport->fqdn = g_strdup(name);
377 }
378
379 static void register_types(void)
380 {
381 register_char_driver("spicevmc", CHARDEV_BACKEND_KIND_SPICEVMC,
382 qemu_chr_parse_spice_vmc);
383 register_char_driver("spiceport", CHARDEV_BACKEND_KIND_SPICEPORT,
384 qemu_chr_parse_spice_port);
385 }
386
387 type_init(register_types);