qapi2texi: Fix up output around #optional
[qemu.git] / chardev / char.c
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu/osdep.h"
25 #include "qemu-common.h"
26 #include "qemu/cutils.h"
27 #include "monitor/monitor.h"
28 #include "sysemu/sysemu.h"
29 #include "qemu/config-file.h"
30 #include "qemu/error-report.h"
31 #include "sysemu/char.h"
32 #include "qmp-commands.h"
33 #include "qapi-visit.h"
34 #include "sysemu/replay.h"
35 #include "qemu/help_option.h"
36
37 #include "char-mux.h"
38 #include "char-io.h"
39 #include "char-parallel.h"
40 #include "char-serial.h"
41
42 /***********************************************************/
43 /* character device */
44
45 static QTAILQ_HEAD(ChardevHead, Chardev) chardevs =
46 QTAILQ_HEAD_INITIALIZER(chardevs);
47
48 void qemu_chr_be_event(Chardev *s, int event)
49 {
50 CharBackend *be = s->be;
51
52 /* Keep track if the char device is open */
53 switch (event) {
54 case CHR_EVENT_OPENED:
55 s->be_open = 1;
56 break;
57 case CHR_EVENT_CLOSED:
58 s->be_open = 0;
59 break;
60 }
61
62 if (!be || !be->chr_event) {
63 return;
64 }
65
66 be->chr_event(be->opaque, event);
67 }
68
69 void qemu_chr_be_generic_open(Chardev *s)
70 {
71 qemu_chr_be_event(s, CHR_EVENT_OPENED);
72 }
73
74
75 /* Not reporting errors from writing to logfile, as logs are
76 * defined to be "best effort" only */
77 static void qemu_chr_fe_write_log(Chardev *s,
78 const uint8_t *buf, size_t len)
79 {
80 size_t done = 0;
81 ssize_t ret;
82
83 if (s->logfd < 0) {
84 return;
85 }
86
87 while (done < len) {
88 retry:
89 ret = write(s->logfd, buf + done, len - done);
90 if (ret == -1 && errno == EAGAIN) {
91 g_usleep(100);
92 goto retry;
93 }
94
95 if (ret <= 0) {
96 return;
97 }
98 done += ret;
99 }
100 }
101
102 static int qemu_chr_fe_write_buffer(Chardev *s,
103 const uint8_t *buf, int len, int *offset)
104 {
105 ChardevClass *cc = CHARDEV_GET_CLASS(s);
106 int res = 0;
107 *offset = 0;
108
109 qemu_mutex_lock(&s->chr_write_lock);
110 while (*offset < len) {
111 retry:
112 res = cc->chr_write(s, buf + *offset, len - *offset);
113 if (res < 0 && errno == EAGAIN) {
114 g_usleep(100);
115 goto retry;
116 }
117
118 if (res <= 0) {
119 break;
120 }
121
122 *offset += res;
123 }
124 if (*offset > 0) {
125 qemu_chr_fe_write_log(s, buf, *offset);
126 }
127 qemu_mutex_unlock(&s->chr_write_lock);
128
129 return res;
130 }
131
132 static bool qemu_chr_replay(Chardev *chr)
133 {
134 return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
135 }
136
137 int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
138 {
139 Chardev *s = be->chr;
140 ChardevClass *cc;
141 int ret;
142
143 if (!s) {
144 return 0;
145 }
146
147 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
148 int offset;
149 replay_char_write_event_load(&ret, &offset);
150 assert(offset <= len);
151 qemu_chr_fe_write_buffer(s, buf, offset, &offset);
152 return ret;
153 }
154
155 cc = CHARDEV_GET_CLASS(s);
156 qemu_mutex_lock(&s->chr_write_lock);
157 ret = cc->chr_write(s, buf, len);
158
159 if (ret > 0) {
160 qemu_chr_fe_write_log(s, buf, ret);
161 }
162
163 qemu_mutex_unlock(&s->chr_write_lock);
164
165 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
166 replay_char_write_event_save(ret, ret < 0 ? 0 : ret);
167 }
168
169 return ret;
170 }
171
172 int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len)
173 {
174 int offset;
175 int res;
176
177 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
178 replay_char_write_event_load(&res, &offset);
179 assert(offset <= len);
180 qemu_chr_fe_write_buffer(s, buf, offset, &offset);
181 return res;
182 }
183
184 res = qemu_chr_fe_write_buffer(s, buf, len, &offset);
185
186 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
187 replay_char_write_event_save(res, offset);
188 }
189
190 if (res < 0) {
191 return res;
192 }
193 return offset;
194 }
195
196 int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
197 {
198 Chardev *s = be->chr;
199
200 if (!s) {
201 return 0;
202 }
203
204 return qemu_chr_write_all(s, buf, len);
205 }
206
207 int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
208 {
209 Chardev *s = be->chr;
210 int offset = 0, counter = 10;
211 int res;
212
213 if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) {
214 return 0;
215 }
216
217 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
218 return replay_char_read_all_load(buf);
219 }
220
221 while (offset < len) {
222 retry:
223 res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
224 len - offset);
225 if (res == -1 && errno == EAGAIN) {
226 g_usleep(100);
227 goto retry;
228 }
229
230 if (res == 0) {
231 break;
232 }
233
234 if (res < 0) {
235 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
236 replay_char_read_all_save_error(res);
237 }
238 return res;
239 }
240
241 offset += res;
242
243 if (!counter--) {
244 break;
245 }
246 }
247
248 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
249 replay_char_read_all_save_buf(buf, offset);
250 }
251 return offset;
252 }
253
254 int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
255 {
256 Chardev *s = be->chr;
257 int res;
258
259 if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
260 res = -ENOTSUP;
261 } else {
262 res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
263 }
264
265 return res;
266 }
267
268 int qemu_chr_be_can_write(Chardev *s)
269 {
270 CharBackend *be = s->be;
271
272 if (!be || !be->chr_can_read) {
273 return 0;
274 }
275
276 return be->chr_can_read(be->opaque);
277 }
278
279 void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len)
280 {
281 CharBackend *be = s->be;
282
283 if (be && be->chr_read) {
284 be->chr_read(be->opaque, buf, len);
285 }
286 }
287
288 void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len)
289 {
290 if (qemu_chr_replay(s)) {
291 if (replay_mode == REPLAY_MODE_PLAY) {
292 return;
293 }
294 replay_chr_be_write(s, buf, len);
295 } else {
296 qemu_chr_be_write_impl(s, buf, len);
297 }
298 }
299
300 int qemu_chr_fe_get_msgfd(CharBackend *be)
301 {
302 Chardev *s = be->chr;
303 int fd;
304 int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
305 if (s && qemu_chr_replay(s)) {
306 error_report("Replay: get msgfd is not supported "
307 "for serial devices yet");
308 exit(1);
309 }
310 return res;
311 }
312
313 int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
314 {
315 Chardev *s = be->chr;
316
317 if (!s) {
318 return -1;
319 }
320
321 return CHARDEV_GET_CLASS(s)->get_msgfds ?
322 CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
323 }
324
325 int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
326 {
327 Chardev *s = be->chr;
328
329 if (!s) {
330 return -1;
331 }
332
333 return CHARDEV_GET_CLASS(s)->set_msgfds ?
334 CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
335 }
336
337 int qemu_chr_add_client(Chardev *s, int fd)
338 {
339 return CHARDEV_GET_CLASS(s)->chr_add_client ?
340 CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
341 }
342
343 void qemu_chr_fe_accept_input(CharBackend *be)
344 {
345 Chardev *s = be->chr;
346
347 if (!s) {
348 return;
349 }
350
351 if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
352 CHARDEV_GET_CLASS(s)->chr_accept_input(s);
353 }
354 qemu_notify_event();
355 }
356
357 void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
358 {
359 char buf[CHR_READ_BUF_LEN];
360 va_list ap;
361 va_start(ap, fmt);
362 vsnprintf(buf, sizeof(buf), fmt, ap);
363 /* XXX this blocks entire thread. Rewrite to use
364 * qemu_chr_fe_write and background I/O callbacks */
365 qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
366 va_end(ap);
367 }
368
369 static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
370 bool *be_opened, Error **errp)
371 {
372 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
373 /* Any ChardevCommon member would work */
374 ChardevCommon *common = backend ? backend->u.null.data : NULL;
375
376 if (common && common->has_logfile) {
377 int flags = O_WRONLY | O_CREAT;
378 if (common->has_logappend &&
379 common->logappend) {
380 flags |= O_APPEND;
381 } else {
382 flags |= O_TRUNC;
383 }
384 chr->logfd = qemu_open(common->logfile, flags, 0666);
385 if (chr->logfd < 0) {
386 error_setg_errno(errp, errno,
387 "Unable to open logfile %s",
388 common->logfile);
389 return;
390 }
391 }
392
393 if (cc->open) {
394 cc->open(chr, backend, be_opened, errp);
395 }
396 }
397
398 static void char_init(Object *obj)
399 {
400 Chardev *chr = CHARDEV(obj);
401
402 chr->logfd = -1;
403 qemu_mutex_init(&chr->chr_write_lock);
404 }
405
406 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len)
407 {
408 return len;
409 }
410
411 static void char_class_init(ObjectClass *oc, void *data)
412 {
413 ChardevClass *cc = CHARDEV_CLASS(oc);
414
415 cc->chr_write = null_chr_write;
416 }
417
418 static void char_finalize(Object *obj)
419 {
420 Chardev *chr = CHARDEV(obj);
421
422 if (chr->be) {
423 chr->be->chr = NULL;
424 }
425 g_free(chr->filename);
426 g_free(chr->label);
427 if (chr->logfd != -1) {
428 close(chr->logfd);
429 }
430 qemu_mutex_destroy(&chr->chr_write_lock);
431 }
432
433 static const TypeInfo char_type_info = {
434 .name = TYPE_CHARDEV,
435 .parent = TYPE_OBJECT,
436 .instance_size = sizeof(Chardev),
437 .instance_init = char_init,
438 .instance_finalize = char_finalize,
439 .abstract = true,
440 .class_size = sizeof(ChardevClass),
441 .class_init = char_class_init,
442 };
443
444 /**
445 * Called after processing of default and command-line-specified
446 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
447 * to a mux chardev. This is done here to ensure that
448 * output/prompts/banners are only displayed for the FE that has
449 * focus when initial command-line processing/machine init is
450 * completed.
451 *
452 * After this point, any new FE attached to any new or existing
453 * mux will receive CHR_EVENT_OPENED notifications for the BE
454 * immediately.
455 */
456 static void muxes_realize_done(Notifier *notifier, void *unused)
457 {
458 Chardev *chr;
459
460 QTAILQ_FOREACH(chr, &chardevs, next) {
461 if (CHARDEV_IS_MUX(chr)) {
462 MuxChardev *d = MUX_CHARDEV(chr);
463 int i;
464
465 /* send OPENED to all already-attached FEs */
466 for (i = 0; i < d->mux_cnt; i++) {
467 mux_chr_send_event(d, i, CHR_EVENT_OPENED);
468 }
469 /* mark mux as OPENED so any new FEs will immediately receive
470 * OPENED event
471 */
472 qemu_chr_be_generic_open(chr);
473 }
474 }
475 muxes_realized = true;
476 }
477
478 static Notifier muxes_realize_notify = {
479 .notify = muxes_realize_done,
480 };
481
482 Chardev *qemu_chr_fe_get_driver(CharBackend *be)
483 {
484 return be->chr;
485 }
486
487 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
488 {
489 int tag = 0;
490
491 if (CHARDEV_IS_MUX(s)) {
492 MuxChardev *d = MUX_CHARDEV(s);
493
494 if (d->mux_cnt >= MAX_MUX) {
495 goto unavailable;
496 }
497
498 d->backends[d->mux_cnt] = b;
499 tag = d->mux_cnt++;
500 } else if (s->be) {
501 goto unavailable;
502 } else {
503 s->be = b;
504 }
505
506 b->fe_open = false;
507 b->tag = tag;
508 b->chr = s;
509 return true;
510
511 unavailable:
512 error_setg(errp, QERR_DEVICE_IN_USE, s->label);
513 return false;
514 }
515
516 static bool qemu_chr_is_busy(Chardev *s)
517 {
518 if (CHARDEV_IS_MUX(s)) {
519 MuxChardev *d = MUX_CHARDEV(s);
520 return d->mux_cnt >= 0;
521 } else {
522 return s->be != NULL;
523 }
524 }
525
526 void qemu_chr_fe_deinit(CharBackend *b)
527 {
528 assert(b);
529
530 if (b->chr) {
531 qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);
532 if (b->chr->be == b) {
533 b->chr->be = NULL;
534 }
535 if (CHARDEV_IS_MUX(b->chr)) {
536 MuxChardev *d = MUX_CHARDEV(b->chr);
537 d->backends[b->tag] = NULL;
538 }
539 b->chr = NULL;
540 }
541 }
542
543 void qemu_chr_fe_set_handlers(CharBackend *b,
544 IOCanReadHandler *fd_can_read,
545 IOReadHandler *fd_read,
546 IOEventHandler *fd_event,
547 void *opaque,
548 GMainContext *context,
549 bool set_open)
550 {
551 Chardev *s;
552 ChardevClass *cc;
553 int fe_open;
554
555 s = b->chr;
556 if (!s) {
557 return;
558 }
559
560 cc = CHARDEV_GET_CLASS(s);
561 if (!opaque && !fd_can_read && !fd_read && !fd_event) {
562 fe_open = 0;
563 remove_fd_in_watch(s, context);
564 } else {
565 fe_open = 1;
566 }
567 b->chr_can_read = fd_can_read;
568 b->chr_read = fd_read;
569 b->chr_event = fd_event;
570 b->opaque = opaque;
571 if (cc->chr_update_read_handler) {
572 cc->chr_update_read_handler(s, context);
573 }
574
575 if (set_open) {
576 qemu_chr_fe_set_open(b, fe_open);
577 }
578
579 if (fe_open) {
580 qemu_chr_fe_take_focus(b);
581 /* We're connecting to an already opened device, so let's make sure we
582 also get the open event */
583 if (s->be_open) {
584 qemu_chr_be_generic_open(s);
585 }
586 }
587
588 if (CHARDEV_IS_MUX(s)) {
589 mux_chr_set_handlers(s, context);
590 }
591 }
592
593 void qemu_chr_fe_take_focus(CharBackend *b)
594 {
595 if (!b->chr) {
596 return;
597 }
598
599 if (CHARDEV_IS_MUX(b->chr)) {
600 mux_set_focus(b->chr, b->tag);
601 }
602 }
603
604 int qemu_chr_wait_connected(Chardev *chr, Error **errp)
605 {
606 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
607
608 if (cc->chr_wait_connected) {
609 return cc->chr_wait_connected(chr, errp);
610 }
611
612 return 0;
613 }
614
615 int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
616 {
617 if (!be->chr) {
618 error_setg(errp, "missing associated backend");
619 return -1;
620 }
621
622 return qemu_chr_wait_connected(be->chr, errp);
623 }
624
625 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
626 {
627 char host[65], port[33], width[8], height[8];
628 int pos;
629 const char *p;
630 QemuOpts *opts;
631 Error *local_err = NULL;
632
633 opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
634 if (local_err) {
635 error_report_err(local_err);
636 return NULL;
637 }
638
639 if (strstart(filename, "mon:", &p)) {
640 filename = p;
641 qemu_opt_set(opts, "mux", "on", &error_abort);
642 if (strcmp(filename, "stdio") == 0) {
643 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
644 * but pass it to the guest. Handle this only for compat syntax,
645 * for -chardev syntax we have special option for this.
646 * This is what -nographic did, redirecting+muxing serial+monitor
647 * to stdio causing Ctrl+C to be passed to guest. */
648 qemu_opt_set(opts, "signal", "off", &error_abort);
649 }
650 }
651
652 if (strcmp(filename, "null") == 0 ||
653 strcmp(filename, "pty") == 0 ||
654 strcmp(filename, "msmouse") == 0 ||
655 strcmp(filename, "wctablet") == 0 ||
656 strcmp(filename, "braille") == 0 ||
657 strcmp(filename, "testdev") == 0 ||
658 strcmp(filename, "stdio") == 0) {
659 qemu_opt_set(opts, "backend", filename, &error_abort);
660 return opts;
661 }
662 if (strstart(filename, "vc", &p)) {
663 qemu_opt_set(opts, "backend", "vc", &error_abort);
664 if (*p == ':') {
665 if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
666 /* pixels */
667 qemu_opt_set(opts, "width", width, &error_abort);
668 qemu_opt_set(opts, "height", height, &error_abort);
669 } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
670 /* chars */
671 qemu_opt_set(opts, "cols", width, &error_abort);
672 qemu_opt_set(opts, "rows", height, &error_abort);
673 } else {
674 goto fail;
675 }
676 }
677 return opts;
678 }
679 if (strcmp(filename, "con:") == 0) {
680 qemu_opt_set(opts, "backend", "console", &error_abort);
681 return opts;
682 }
683 if (strstart(filename, "COM", NULL)) {
684 qemu_opt_set(opts, "backend", "serial", &error_abort);
685 qemu_opt_set(opts, "path", filename, &error_abort);
686 return opts;
687 }
688 if (strstart(filename, "file:", &p)) {
689 qemu_opt_set(opts, "backend", "file", &error_abort);
690 qemu_opt_set(opts, "path", p, &error_abort);
691 return opts;
692 }
693 if (strstart(filename, "pipe:", &p)) {
694 qemu_opt_set(opts, "backend", "pipe", &error_abort);
695 qemu_opt_set(opts, "path", p, &error_abort);
696 return opts;
697 }
698 if (strstart(filename, "tcp:", &p) ||
699 strstart(filename, "telnet:", &p)) {
700 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
701 host[0] = 0;
702 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
703 goto fail;
704 }
705 qemu_opt_set(opts, "backend", "socket", &error_abort);
706 qemu_opt_set(opts, "host", host, &error_abort);
707 qemu_opt_set(opts, "port", port, &error_abort);
708 if (p[pos] == ',') {
709 qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
710 if (local_err) {
711 error_report_err(local_err);
712 goto fail;
713 }
714 }
715 if (strstart(filename, "telnet:", &p))
716 qemu_opt_set(opts, "telnet", "on", &error_abort);
717 return opts;
718 }
719 if (strstart(filename, "udp:", &p)) {
720 qemu_opt_set(opts, "backend", "udp", &error_abort);
721 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
722 host[0] = 0;
723 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
724 goto fail;
725 }
726 }
727 qemu_opt_set(opts, "host", host, &error_abort);
728 qemu_opt_set(opts, "port", port, &error_abort);
729 if (p[pos] == '@') {
730 p += pos + 1;
731 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
732 host[0] = 0;
733 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
734 goto fail;
735 }
736 }
737 qemu_opt_set(opts, "localaddr", host, &error_abort);
738 qemu_opt_set(opts, "localport", port, &error_abort);
739 }
740 return opts;
741 }
742 if (strstart(filename, "unix:", &p)) {
743 qemu_opt_set(opts, "backend", "socket", &error_abort);
744 qemu_opts_do_parse(opts, p, "path", &local_err);
745 if (local_err) {
746 error_report_err(local_err);
747 goto fail;
748 }
749 return opts;
750 }
751 if (strstart(filename, "/dev/parport", NULL) ||
752 strstart(filename, "/dev/ppi", NULL)) {
753 qemu_opt_set(opts, "backend", "parport", &error_abort);
754 qemu_opt_set(opts, "path", filename, &error_abort);
755 return opts;
756 }
757 if (strstart(filename, "/dev/", NULL)) {
758 qemu_opt_set(opts, "backend", "tty", &error_abort);
759 qemu_opt_set(opts, "path", filename, &error_abort);
760 return opts;
761 }
762
763 fail:
764 qemu_opts_del(opts);
765 return NULL;
766 }
767
768 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
769 {
770 const char *logfile = qemu_opt_get(opts, "logfile");
771
772 backend->has_logfile = logfile != NULL;
773 backend->logfile = logfile ? g_strdup(logfile) : NULL;
774
775 backend->has_logappend = true;
776 backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
777 }
778
779 static const ChardevClass *char_get_class(const char *driver, Error **errp)
780 {
781 ObjectClass *oc;
782 const ChardevClass *cc;
783 char *typename = g_strdup_printf("chardev-%s", driver);
784
785 oc = object_class_by_name(typename);
786 g_free(typename);
787
788 if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
789 error_setg(errp, "'%s' is not a valid char driver name", driver);
790 return NULL;
791 }
792
793 if (object_class_is_abstract(oc)) {
794 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
795 "abstract device type");
796 return NULL;
797 }
798
799 cc = CHARDEV_CLASS(oc);
800 if (cc->internal) {
801 error_setg(errp, "'%s' is not a valid char driver name", driver);
802 return NULL;
803 }
804
805 return cc;
806 }
807
808 static Chardev *qemu_chardev_add(const char *id, const char *typename,
809 ChardevBackend *backend, Error **errp)
810 {
811 Chardev *chr;
812
813 chr = qemu_chr_find(id);
814 if (chr) {
815 error_setg(errp, "Chardev '%s' already exists", id);
816 return NULL;
817 }
818
819 chr = qemu_chardev_new(id, typename, backend, errp);
820 if (!chr) {
821 return NULL;
822 }
823
824 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
825 return chr;
826 }
827
828 static const struct ChardevAlias {
829 const char *typename;
830 const char *alias;
831 } chardev_alias_table[] = {
832 #ifdef HAVE_CHARDEV_PARPORT
833 { "parallel", "parport" },
834 #endif
835 #ifdef HAVE_CHARDEV_SERIAL
836 { "serial", "tty" },
837 #endif
838 };
839
840 typedef struct ChadevClassFE {
841 void (*fn)(const char *name, void *opaque);
842 void *opaque;
843 } ChadevClassFE;
844
845 static void
846 chardev_class_foreach(ObjectClass *klass, void *opaque)
847 {
848 ChadevClassFE *fe = opaque;
849
850 assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
851 if (CHARDEV_CLASS(klass)->internal) {
852 return;
853 }
854
855 fe->fn(object_class_get_name(klass) + 8, fe->opaque);
856 }
857
858 static void
859 chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque)
860 {
861 ChadevClassFE fe = { .fn = fn, .opaque = opaque };
862 int i;
863
864 object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
865
866 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
867 fn(chardev_alias_table[i].alias, opaque);
868 }
869 }
870
871 static void
872 help_string_append(const char *name, void *opaque)
873 {
874 GString *str = opaque;
875
876 g_string_append_printf(str, "\n%s", name);
877 }
878
879 Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
880 Error **errp)
881 {
882 Error *local_err = NULL;
883 const ChardevClass *cc;
884 Chardev *chr;
885 int i;
886 ChardevBackend *backend = NULL;
887 const char *name = qemu_opt_get(opts, "backend");
888 const char *id = qemu_opts_id(opts);
889 char *bid = NULL;
890
891 if (name == NULL) {
892 error_setg(errp, "chardev: \"%s\" missing backend",
893 qemu_opts_id(opts));
894 return NULL;
895 }
896
897 if (is_help_option(name)) {
898 GString *str = g_string_new("");
899
900 chardev_name_foreach(help_string_append, str);
901
902 error_report("Available chardev backend types: %s", str->str);
903 g_string_free(str, true);
904 exit(0);
905 }
906
907 if (id == NULL) {
908 error_setg(errp, "chardev: no id specified");
909 return NULL;
910 }
911
912 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
913 if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
914 name = chardev_alias_table[i].typename;
915 break;
916 }
917 }
918
919 cc = char_get_class(name, errp);
920 if (cc == NULL) {
921 return NULL;
922 }
923
924 backend = g_new0(ChardevBackend, 1);
925 backend->type = CHARDEV_BACKEND_KIND_NULL;
926
927 if (qemu_opt_get_bool(opts, "mux", 0)) {
928 bid = g_strdup_printf("%s-base", id);
929 }
930
931 chr = NULL;
932 if (cc->parse) {
933 cc->parse(opts, backend, &local_err);
934 if (local_err) {
935 error_propagate(errp, local_err);
936 goto out;
937 }
938 } else {
939 ChardevCommon *ccom = g_new0(ChardevCommon, 1);
940 qemu_chr_parse_common(opts, ccom);
941 backend->u.null.data = ccom; /* Any ChardevCommon member would work */
942 }
943
944 chr = qemu_chardev_add(bid ? bid : id,
945 object_class_get_name(OBJECT_CLASS(cc)),
946 backend, errp);
947 if (chr == NULL) {
948 goto out;
949 }
950
951 if (bid) {
952 Chardev *mux;
953 qapi_free_ChardevBackend(backend);
954 backend = g_new0(ChardevBackend, 1);
955 backend->type = CHARDEV_BACKEND_KIND_MUX;
956 backend->u.mux.data = g_new0(ChardevMux, 1);
957 backend->u.mux.data->chardev = g_strdup(bid);
958 mux = qemu_chardev_add(id, TYPE_CHARDEV_MUX, backend, errp);
959 if (mux == NULL) {
960 qemu_chr_delete(chr);
961 chr = NULL;
962 goto out;
963 }
964 chr = mux;
965 }
966
967 out:
968 qapi_free_ChardevBackend(backend);
969 g_free(bid);
970 return chr;
971 }
972
973 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename)
974 {
975 const char *p;
976 Chardev *chr;
977 QemuOpts *opts;
978 Error *err = NULL;
979
980 if (strstart(filename, "chardev:", &p)) {
981 return qemu_chr_find(p);
982 }
983
984 opts = qemu_chr_parse_compat(label, filename);
985 if (!opts)
986 return NULL;
987
988 chr = qemu_chr_new_from_opts(opts, &err);
989 if (err) {
990 error_report_err(err);
991 }
992 if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
993 monitor_init(chr, MONITOR_USE_READLINE);
994 }
995 qemu_opts_del(opts);
996 return chr;
997 }
998
999 Chardev *qemu_chr_new(const char *label, const char *filename)
1000 {
1001 Chardev *chr;
1002 chr = qemu_chr_new_noreplay(label, filename);
1003 if (chr) {
1004 if (replay_mode != REPLAY_MODE_NONE) {
1005 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
1006 }
1007 if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
1008 error_report("Replay: ioctl is not supported "
1009 "for serial devices yet");
1010 }
1011 replay_register_char_driver(chr);
1012 }
1013 return chr;
1014 }
1015
1016 void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
1017 {
1018 Chardev *chr = be->chr;
1019
1020 if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
1021 CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
1022 }
1023 }
1024
1025 void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
1026 {
1027 Chardev *chr = be->chr;
1028
1029 if (!chr) {
1030 return;
1031 }
1032
1033 if (be->fe_open == fe_open) {
1034 return;
1035 }
1036 be->fe_open = fe_open;
1037 if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
1038 CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
1039 }
1040 }
1041
1042 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
1043 GIOFunc func, void *user_data)
1044 {
1045 Chardev *s = be->chr;
1046 GSource *src;
1047 guint tag;
1048
1049 if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
1050 return 0;
1051 }
1052
1053 src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
1054 if (!src) {
1055 return 0;
1056 }
1057
1058 g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
1059 tag = g_source_attach(src, NULL);
1060 g_source_unref(src);
1061
1062 return tag;
1063 }
1064
1065 void qemu_chr_fe_disconnect(CharBackend *be)
1066 {
1067 Chardev *chr = be->chr;
1068
1069 if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
1070 CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
1071 }
1072 }
1073
1074 void qemu_chr_delete(Chardev *chr)
1075 {
1076 QTAILQ_REMOVE(&chardevs, chr, next);
1077 object_unref(OBJECT(chr));
1078 }
1079
1080 ChardevInfoList *qmp_query_chardev(Error **errp)
1081 {
1082 ChardevInfoList *chr_list = NULL;
1083 Chardev *chr;
1084
1085 QTAILQ_FOREACH(chr, &chardevs, next) {
1086 ChardevInfoList *info = g_malloc0(sizeof(*info));
1087 info->value = g_malloc0(sizeof(*info->value));
1088 info->value->label = g_strdup(chr->label);
1089 info->value->filename = g_strdup(chr->filename);
1090 info->value->frontend_open = chr->be && chr->be->fe_open;
1091
1092 info->next = chr_list;
1093 chr_list = info;
1094 }
1095
1096 return chr_list;
1097 }
1098
1099 static void
1100 qmp_prepend_backend(const char *name, void *opaque)
1101 {
1102 ChardevBackendInfoList **list = opaque;
1103 ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
1104
1105 info->value = g_malloc0(sizeof(*info->value));
1106 info->value->name = g_strdup(name);
1107 info->next = *list;
1108 *list = info;
1109 }
1110
1111 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
1112 {
1113 ChardevBackendInfoList *backend_list = NULL;
1114
1115 chardev_name_foreach(qmp_prepend_backend, &backend_list);
1116
1117 return backend_list;
1118 }
1119
1120 Chardev *qemu_chr_find(const char *name)
1121 {
1122 Chardev *chr;
1123
1124 QTAILQ_FOREACH(chr, &chardevs, next) {
1125 if (strcmp(chr->label, name) != 0)
1126 continue;
1127 return chr;
1128 }
1129 return NULL;
1130 }
1131
1132 QemuOptsList qemu_chardev_opts = {
1133 .name = "chardev",
1134 .implied_opt_name = "backend",
1135 .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
1136 .desc = {
1137 {
1138 .name = "backend",
1139 .type = QEMU_OPT_STRING,
1140 },{
1141 .name = "path",
1142 .type = QEMU_OPT_STRING,
1143 },{
1144 .name = "host",
1145 .type = QEMU_OPT_STRING,
1146 },{
1147 .name = "port",
1148 .type = QEMU_OPT_STRING,
1149 },{
1150 .name = "localaddr",
1151 .type = QEMU_OPT_STRING,
1152 },{
1153 .name = "localport",
1154 .type = QEMU_OPT_STRING,
1155 },{
1156 .name = "to",
1157 .type = QEMU_OPT_NUMBER,
1158 },{
1159 .name = "ipv4",
1160 .type = QEMU_OPT_BOOL,
1161 },{
1162 .name = "ipv6",
1163 .type = QEMU_OPT_BOOL,
1164 },{
1165 .name = "wait",
1166 .type = QEMU_OPT_BOOL,
1167 },{
1168 .name = "server",
1169 .type = QEMU_OPT_BOOL,
1170 },{
1171 .name = "delay",
1172 .type = QEMU_OPT_BOOL,
1173 },{
1174 .name = "reconnect",
1175 .type = QEMU_OPT_NUMBER,
1176 },{
1177 .name = "telnet",
1178 .type = QEMU_OPT_BOOL,
1179 },{
1180 .name = "tls-creds",
1181 .type = QEMU_OPT_STRING,
1182 },{
1183 .name = "width",
1184 .type = QEMU_OPT_NUMBER,
1185 },{
1186 .name = "height",
1187 .type = QEMU_OPT_NUMBER,
1188 },{
1189 .name = "cols",
1190 .type = QEMU_OPT_NUMBER,
1191 },{
1192 .name = "rows",
1193 .type = QEMU_OPT_NUMBER,
1194 },{
1195 .name = "mux",
1196 .type = QEMU_OPT_BOOL,
1197 },{
1198 .name = "signal",
1199 .type = QEMU_OPT_BOOL,
1200 },{
1201 .name = "name",
1202 .type = QEMU_OPT_STRING,
1203 },{
1204 .name = "debug",
1205 .type = QEMU_OPT_NUMBER,
1206 },{
1207 .name = "size",
1208 .type = QEMU_OPT_SIZE,
1209 },{
1210 .name = "chardev",
1211 .type = QEMU_OPT_STRING,
1212 },{
1213 .name = "append",
1214 .type = QEMU_OPT_BOOL,
1215 },{
1216 .name = "logfile",
1217 .type = QEMU_OPT_STRING,
1218 },{
1219 .name = "logappend",
1220 .type = QEMU_OPT_BOOL,
1221 },
1222 { /* end of list */ }
1223 },
1224 };
1225
1226 bool qemu_chr_has_feature(Chardev *chr,
1227 ChardevFeature feature)
1228 {
1229 return test_bit(feature, chr->features);
1230 }
1231
1232 void qemu_chr_set_feature(Chardev *chr,
1233 ChardevFeature feature)
1234 {
1235 return set_bit(feature, chr->features);
1236 }
1237
1238 Chardev *qemu_chardev_new(const char *id, const char *typename,
1239 ChardevBackend *backend, Error **errp)
1240 {
1241 Chardev *chr = NULL;
1242 Error *local_err = NULL;
1243 bool be_opened = true;
1244
1245 assert(g_str_has_prefix(typename, "chardev-"));
1246
1247 chr = CHARDEV(object_new(typename));
1248 chr->label = g_strdup(id);
1249
1250 qemu_char_open(chr, backend, &be_opened, &local_err);
1251 if (local_err) {
1252 error_propagate(errp, local_err);
1253 object_unref(OBJECT(chr));
1254 return NULL;
1255 }
1256
1257 if (!chr->filename) {
1258 chr->filename = g_strdup(typename + 8);
1259 }
1260 if (be_opened) {
1261 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
1262 }
1263
1264 return chr;
1265 }
1266
1267 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
1268 Error **errp)
1269 {
1270 const ChardevClass *cc;
1271 ChardevReturn *ret;
1272 Chardev *chr;
1273
1274 cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp);
1275 if (!cc) {
1276 return NULL;
1277 }
1278
1279 chr = qemu_chardev_add(id, object_class_get_name(OBJECT_CLASS(cc)),
1280 backend, errp);
1281 if (!chr) {
1282 return NULL;
1283 }
1284
1285 ret = g_new0(ChardevReturn, 1);
1286 if (CHARDEV_IS_PTY(chr)) {
1287 ret->pty = g_strdup(chr->filename + 4);
1288 ret->has_pty = true;
1289 }
1290
1291 return ret;
1292 }
1293
1294 void qmp_chardev_remove(const char *id, Error **errp)
1295 {
1296 Chardev *chr;
1297
1298 chr = qemu_chr_find(id);
1299 if (chr == NULL) {
1300 error_setg(errp, "Chardev '%s' not found", id);
1301 return;
1302 }
1303 if (qemu_chr_is_busy(chr)) {
1304 error_setg(errp, "Chardev '%s' is busy", id);
1305 return;
1306 }
1307 if (qemu_chr_replay(chr)) {
1308 error_setg(errp,
1309 "Chardev '%s' cannot be unplugged in record/replay mode", id);
1310 return;
1311 }
1312 qemu_chr_delete(chr);
1313 }
1314
1315 void qemu_chr_cleanup(void)
1316 {
1317 Chardev *chr, *tmp;
1318
1319 QTAILQ_FOREACH_SAFE(chr, &chardevs, next, tmp) {
1320 qemu_chr_delete(chr);
1321 }
1322 }
1323
1324 static void register_types(void)
1325 {
1326 type_register_static(&char_type_info);
1327
1328 /* this must be done after machine init, since we register FEs with muxes
1329 * as part of realize functions like serial_isa_realizefn when -nographic
1330 * is specified
1331 */
1332 qemu_add_machine_init_done_notifier(&muxes_realize_notify);
1333 }
1334
1335 type_init(register_types);