]> git.proxmox.com Git - mirror_qemu.git/blob - chardev/char.c
Merge remote-tracking branch 'remotes/elmarco/tags/chr-split-pull-request' into staging
[mirror_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);
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, "braille") == 0 ||
656 strcmp(filename, "testdev") == 0 ||
657 strcmp(filename, "stdio") == 0) {
658 qemu_opt_set(opts, "backend", filename, &error_abort);
659 return opts;
660 }
661 if (strstart(filename, "vc", &p)) {
662 qemu_opt_set(opts, "backend", "vc", &error_abort);
663 if (*p == ':') {
664 if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
665 /* pixels */
666 qemu_opt_set(opts, "width", width, &error_abort);
667 qemu_opt_set(opts, "height", height, &error_abort);
668 } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
669 /* chars */
670 qemu_opt_set(opts, "cols", width, &error_abort);
671 qemu_opt_set(opts, "rows", height, &error_abort);
672 } else {
673 goto fail;
674 }
675 }
676 return opts;
677 }
678 if (strcmp(filename, "con:") == 0) {
679 qemu_opt_set(opts, "backend", "console", &error_abort);
680 return opts;
681 }
682 if (strstart(filename, "COM", NULL)) {
683 qemu_opt_set(opts, "backend", "serial", &error_abort);
684 qemu_opt_set(opts, "path", filename, &error_abort);
685 return opts;
686 }
687 if (strstart(filename, "file:", &p)) {
688 qemu_opt_set(opts, "backend", "file", &error_abort);
689 qemu_opt_set(opts, "path", p, &error_abort);
690 return opts;
691 }
692 if (strstart(filename, "pipe:", &p)) {
693 qemu_opt_set(opts, "backend", "pipe", &error_abort);
694 qemu_opt_set(opts, "path", p, &error_abort);
695 return opts;
696 }
697 if (strstart(filename, "tcp:", &p) ||
698 strstart(filename, "telnet:", &p)) {
699 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
700 host[0] = 0;
701 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
702 goto fail;
703 }
704 qemu_opt_set(opts, "backend", "socket", &error_abort);
705 qemu_opt_set(opts, "host", host, &error_abort);
706 qemu_opt_set(opts, "port", port, &error_abort);
707 if (p[pos] == ',') {
708 qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
709 if (local_err) {
710 error_report_err(local_err);
711 goto fail;
712 }
713 }
714 if (strstart(filename, "telnet:", &p))
715 qemu_opt_set(opts, "telnet", "on", &error_abort);
716 return opts;
717 }
718 if (strstart(filename, "udp:", &p)) {
719 qemu_opt_set(opts, "backend", "udp", &error_abort);
720 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
721 host[0] = 0;
722 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
723 goto fail;
724 }
725 }
726 qemu_opt_set(opts, "host", host, &error_abort);
727 qemu_opt_set(opts, "port", port, &error_abort);
728 if (p[pos] == '@') {
729 p += pos + 1;
730 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
731 host[0] = 0;
732 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
733 goto fail;
734 }
735 }
736 qemu_opt_set(opts, "localaddr", host, &error_abort);
737 qemu_opt_set(opts, "localport", port, &error_abort);
738 }
739 return opts;
740 }
741 if (strstart(filename, "unix:", &p)) {
742 qemu_opt_set(opts, "backend", "socket", &error_abort);
743 qemu_opts_do_parse(opts, p, "path", &local_err);
744 if (local_err) {
745 error_report_err(local_err);
746 goto fail;
747 }
748 return opts;
749 }
750 if (strstart(filename, "/dev/parport", NULL) ||
751 strstart(filename, "/dev/ppi", NULL)) {
752 qemu_opt_set(opts, "backend", "parport", &error_abort);
753 qemu_opt_set(opts, "path", filename, &error_abort);
754 return opts;
755 }
756 if (strstart(filename, "/dev/", NULL)) {
757 qemu_opt_set(opts, "backend", "tty", &error_abort);
758 qemu_opt_set(opts, "path", filename, &error_abort);
759 return opts;
760 }
761
762 fail:
763 qemu_opts_del(opts);
764 return NULL;
765 }
766
767 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
768 {
769 const char *logfile = qemu_opt_get(opts, "logfile");
770
771 backend->has_logfile = logfile != NULL;
772 backend->logfile = logfile ? g_strdup(logfile) : NULL;
773
774 backend->has_logappend = true;
775 backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
776 }
777
778 static const ChardevClass *char_get_class(const char *driver, Error **errp)
779 {
780 ObjectClass *oc;
781 const ChardevClass *cc;
782 char *typename = g_strdup_printf("chardev-%s", driver);
783
784 oc = object_class_by_name(typename);
785 g_free(typename);
786
787 if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
788 error_setg(errp, "'%s' is not a valid char driver name", driver);
789 return NULL;
790 }
791
792 if (object_class_is_abstract(oc)) {
793 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
794 "abstract device type");
795 return NULL;
796 }
797
798 cc = CHARDEV_CLASS(oc);
799 if (cc->internal) {
800 error_setg(errp, "'%s' is not a valid char driver name", driver);
801 return NULL;
802 }
803
804 return cc;
805 }
806
807 static Chardev *qemu_chardev_add(const char *id, const char *typename,
808 ChardevBackend *backend, Error **errp)
809 {
810 Chardev *chr;
811
812 chr = qemu_chr_find(id);
813 if (chr) {
814 error_setg(errp, "Chardev '%s' already exists", id);
815 return NULL;
816 }
817
818 chr = qemu_chardev_new(id, typename, backend, errp);
819 if (!chr) {
820 return NULL;
821 }
822
823 QTAILQ_INSERT_TAIL(&chardevs, chr, next);
824 return chr;
825 }
826
827 static const struct ChardevAlias {
828 const char *typename;
829 const char *alias;
830 } chardev_alias_table[] = {
831 #ifdef HAVE_CHARDEV_PARPORT
832 { "parallel", "parport" },
833 #endif
834 #ifdef HAVE_CHARDEV_SERIAL
835 { "serial", "tty" },
836 #endif
837 };
838
839 typedef struct ChadevClassFE {
840 void (*fn)(const char *name, void *opaque);
841 void *opaque;
842 } ChadevClassFE;
843
844 static void
845 chardev_class_foreach(ObjectClass *klass, void *opaque)
846 {
847 ChadevClassFE *fe = opaque;
848
849 assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
850 if (CHARDEV_CLASS(klass)->internal) {
851 return;
852 }
853
854 fe->fn(object_class_get_name(klass) + 8, fe->opaque);
855 }
856
857 static void
858 chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque)
859 {
860 ChadevClassFE fe = { .fn = fn, .opaque = opaque };
861 int i;
862
863 object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
864
865 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
866 fn(chardev_alias_table[i].alias, opaque);
867 }
868 }
869
870 static void
871 help_string_append(const char *name, void *opaque)
872 {
873 GString *str = opaque;
874
875 g_string_append_printf(str, "\n%s", name);
876 }
877
878 Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
879 Error **errp)
880 {
881 Error *local_err = NULL;
882 const ChardevClass *cc;
883 Chardev *chr;
884 int i;
885 ChardevBackend *backend = NULL;
886 const char *name = qemu_opt_get(opts, "backend");
887 const char *id = qemu_opts_id(opts);
888 char *bid = NULL;
889
890 if (name == NULL) {
891 error_setg(errp, "chardev: \"%s\" missing backend",
892 qemu_opts_id(opts));
893 return NULL;
894 }
895
896 if (is_help_option(name)) {
897 GString *str = g_string_new("");
898
899 chardev_name_foreach(help_string_append, str);
900
901 error_report("Available chardev backend types: %s", str->str);
902 g_string_free(str, true);
903 exit(0);
904 }
905
906 if (id == NULL) {
907 error_setg(errp, "chardev: no id specified");
908 return NULL;
909 }
910
911 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
912 if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
913 name = chardev_alias_table[i].typename;
914 break;
915 }
916 }
917
918 cc = char_get_class(name, errp);
919 if (cc == NULL) {
920 return NULL;
921 }
922
923 backend = g_new0(ChardevBackend, 1);
924 backend->type = CHARDEV_BACKEND_KIND_NULL;
925
926 if (qemu_opt_get_bool(opts, "mux", 0)) {
927 bid = g_strdup_printf("%s-base", id);
928 }
929
930 chr = NULL;
931 if (cc->parse) {
932 cc->parse(opts, backend, &local_err);
933 if (local_err) {
934 error_propagate(errp, local_err);
935 goto out;
936 }
937 } else {
938 ChardevCommon *ccom = g_new0(ChardevCommon, 1);
939 qemu_chr_parse_common(opts, ccom);
940 backend->u.null.data = ccom; /* Any ChardevCommon member would work */
941 }
942
943 chr = qemu_chardev_add(bid ? bid : id,
944 object_class_get_name(OBJECT_CLASS(cc)),
945 backend, errp);
946 if (chr == NULL) {
947 goto out;
948 }
949
950 if (bid) {
951 Chardev *mux;
952 qapi_free_ChardevBackend(backend);
953 backend = g_new0(ChardevBackend, 1);
954 backend->type = CHARDEV_BACKEND_KIND_MUX;
955 backend->u.mux.data = g_new0(ChardevMux, 1);
956 backend->u.mux.data->chardev = g_strdup(bid);
957 mux = qemu_chardev_add(id, TYPE_CHARDEV_MUX, backend, errp);
958 if (mux == NULL) {
959 qemu_chr_delete(chr);
960 chr = NULL;
961 goto out;
962 }
963 chr = mux;
964 }
965
966 out:
967 qapi_free_ChardevBackend(backend);
968 g_free(bid);
969 return chr;
970 }
971
972 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename)
973 {
974 const char *p;
975 Chardev *chr;
976 QemuOpts *opts;
977 Error *err = NULL;
978
979 if (strstart(filename, "chardev:", &p)) {
980 return qemu_chr_find(p);
981 }
982
983 opts = qemu_chr_parse_compat(label, filename);
984 if (!opts)
985 return NULL;
986
987 chr = qemu_chr_new_from_opts(opts, &err);
988 if (err) {
989 error_report_err(err);
990 }
991 if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
992 monitor_init(chr, MONITOR_USE_READLINE);
993 }
994 qemu_opts_del(opts);
995 return chr;
996 }
997
998 Chardev *qemu_chr_new(const char *label, const char *filename)
999 {
1000 Chardev *chr;
1001 chr = qemu_chr_new_noreplay(label, filename);
1002 if (chr) {
1003 if (replay_mode != REPLAY_MODE_NONE) {
1004 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
1005 }
1006 if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
1007 error_report("Replay: ioctl is not supported "
1008 "for serial devices yet");
1009 }
1010 replay_register_char_driver(chr);
1011 }
1012 return chr;
1013 }
1014
1015 void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
1016 {
1017 Chardev *chr = be->chr;
1018
1019 if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
1020 CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
1021 }
1022 }
1023
1024 void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
1025 {
1026 Chardev *chr = be->chr;
1027
1028 if (!chr) {
1029 return;
1030 }
1031
1032 if (be->fe_open == fe_open) {
1033 return;
1034 }
1035 be->fe_open = fe_open;
1036 if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
1037 CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
1038 }
1039 }
1040
1041 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
1042 GIOFunc func, void *user_data)
1043 {
1044 Chardev *s = be->chr;
1045 GSource *src;
1046 guint tag;
1047
1048 if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
1049 return 0;
1050 }
1051
1052 src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
1053 if (!src) {
1054 return 0;
1055 }
1056
1057 g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
1058 tag = g_source_attach(src, NULL);
1059 g_source_unref(src);
1060
1061 return tag;
1062 }
1063
1064 void qemu_chr_fe_disconnect(CharBackend *be)
1065 {
1066 Chardev *chr = be->chr;
1067
1068 if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
1069 CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
1070 }
1071 }
1072
1073 void qemu_chr_delete(Chardev *chr)
1074 {
1075 QTAILQ_REMOVE(&chardevs, chr, next);
1076 object_unref(OBJECT(chr));
1077 }
1078
1079 ChardevInfoList *qmp_query_chardev(Error **errp)
1080 {
1081 ChardevInfoList *chr_list = NULL;
1082 Chardev *chr;
1083
1084 QTAILQ_FOREACH(chr, &chardevs, next) {
1085 ChardevInfoList *info = g_malloc0(sizeof(*info));
1086 info->value = g_malloc0(sizeof(*info->value));
1087 info->value->label = g_strdup(chr->label);
1088 info->value->filename = g_strdup(chr->filename);
1089 info->value->frontend_open = chr->be && chr->be->fe_open;
1090
1091 info->next = chr_list;
1092 chr_list = info;
1093 }
1094
1095 return chr_list;
1096 }
1097
1098 static void
1099 qmp_prepend_backend(const char *name, void *opaque)
1100 {
1101 ChardevBackendInfoList **list = opaque;
1102 ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
1103
1104 info->value = g_malloc0(sizeof(*info->value));
1105 info->value->name = g_strdup(name);
1106 info->next = *list;
1107 *list = info;
1108 }
1109
1110 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
1111 {
1112 ChardevBackendInfoList *backend_list = NULL;
1113
1114 chardev_name_foreach(qmp_prepend_backend, &backend_list);
1115
1116 return backend_list;
1117 }
1118
1119 Chardev *qemu_chr_find(const char *name)
1120 {
1121 Chardev *chr;
1122
1123 QTAILQ_FOREACH(chr, &chardevs, next) {
1124 if (strcmp(chr->label, name) != 0)
1125 continue;
1126 return chr;
1127 }
1128 return NULL;
1129 }
1130
1131 QemuOptsList qemu_chardev_opts = {
1132 .name = "chardev",
1133 .implied_opt_name = "backend",
1134 .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
1135 .desc = {
1136 {
1137 .name = "backend",
1138 .type = QEMU_OPT_STRING,
1139 },{
1140 .name = "path",
1141 .type = QEMU_OPT_STRING,
1142 },{
1143 .name = "host",
1144 .type = QEMU_OPT_STRING,
1145 },{
1146 .name = "port",
1147 .type = QEMU_OPT_STRING,
1148 },{
1149 .name = "localaddr",
1150 .type = QEMU_OPT_STRING,
1151 },{
1152 .name = "localport",
1153 .type = QEMU_OPT_STRING,
1154 },{
1155 .name = "to",
1156 .type = QEMU_OPT_NUMBER,
1157 },{
1158 .name = "ipv4",
1159 .type = QEMU_OPT_BOOL,
1160 },{
1161 .name = "ipv6",
1162 .type = QEMU_OPT_BOOL,
1163 },{
1164 .name = "wait",
1165 .type = QEMU_OPT_BOOL,
1166 },{
1167 .name = "server",
1168 .type = QEMU_OPT_BOOL,
1169 },{
1170 .name = "delay",
1171 .type = QEMU_OPT_BOOL,
1172 },{
1173 .name = "reconnect",
1174 .type = QEMU_OPT_NUMBER,
1175 },{
1176 .name = "telnet",
1177 .type = QEMU_OPT_BOOL,
1178 },{
1179 .name = "tls-creds",
1180 .type = QEMU_OPT_STRING,
1181 },{
1182 .name = "width",
1183 .type = QEMU_OPT_NUMBER,
1184 },{
1185 .name = "height",
1186 .type = QEMU_OPT_NUMBER,
1187 },{
1188 .name = "cols",
1189 .type = QEMU_OPT_NUMBER,
1190 },{
1191 .name = "rows",
1192 .type = QEMU_OPT_NUMBER,
1193 },{
1194 .name = "mux",
1195 .type = QEMU_OPT_BOOL,
1196 },{
1197 .name = "signal",
1198 .type = QEMU_OPT_BOOL,
1199 },{
1200 .name = "name",
1201 .type = QEMU_OPT_STRING,
1202 },{
1203 .name = "debug",
1204 .type = QEMU_OPT_NUMBER,
1205 },{
1206 .name = "size",
1207 .type = QEMU_OPT_SIZE,
1208 },{
1209 .name = "chardev",
1210 .type = QEMU_OPT_STRING,
1211 },{
1212 .name = "append",
1213 .type = QEMU_OPT_BOOL,
1214 },{
1215 .name = "logfile",
1216 .type = QEMU_OPT_STRING,
1217 },{
1218 .name = "logappend",
1219 .type = QEMU_OPT_BOOL,
1220 },
1221 { /* end of list */ }
1222 },
1223 };
1224
1225 bool qemu_chr_has_feature(Chardev *chr,
1226 ChardevFeature feature)
1227 {
1228 return test_bit(feature, chr->features);
1229 }
1230
1231 void qemu_chr_set_feature(Chardev *chr,
1232 ChardevFeature feature)
1233 {
1234 return set_bit(feature, chr->features);
1235 }
1236
1237 Chardev *qemu_chardev_new(const char *id, const char *typename,
1238 ChardevBackend *backend, Error **errp)
1239 {
1240 Chardev *chr = NULL;
1241 Error *local_err = NULL;
1242 bool be_opened = true;
1243
1244 assert(g_str_has_prefix(typename, "chardev-"));
1245
1246 chr = CHARDEV(object_new(typename));
1247 chr->label = g_strdup(id);
1248
1249 qemu_char_open(chr, backend, &be_opened, &local_err);
1250 if (local_err) {
1251 error_propagate(errp, local_err);
1252 object_unref(OBJECT(chr));
1253 return NULL;
1254 }
1255
1256 if (!chr->filename) {
1257 chr->filename = g_strdup(typename + 8);
1258 }
1259 if (be_opened) {
1260 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
1261 }
1262
1263 return chr;
1264 }
1265
1266 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
1267 Error **errp)
1268 {
1269 const ChardevClass *cc;
1270 ChardevReturn *ret;
1271 Chardev *chr;
1272
1273 cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp);
1274 if (!cc) {
1275 return NULL;
1276 }
1277
1278 chr = qemu_chardev_add(id, object_class_get_name(OBJECT_CLASS(cc)),
1279 backend, errp);
1280 if (!chr) {
1281 return NULL;
1282 }
1283
1284 ret = g_new0(ChardevReturn, 1);
1285 if (CHARDEV_IS_PTY(chr)) {
1286 ret->pty = g_strdup(chr->filename + 4);
1287 ret->has_pty = true;
1288 }
1289
1290 return ret;
1291 }
1292
1293 void qmp_chardev_remove(const char *id, Error **errp)
1294 {
1295 Chardev *chr;
1296
1297 chr = qemu_chr_find(id);
1298 if (chr == NULL) {
1299 error_setg(errp, "Chardev '%s' not found", id);
1300 return;
1301 }
1302 if (qemu_chr_is_busy(chr)) {
1303 error_setg(errp, "Chardev '%s' is busy", id);
1304 return;
1305 }
1306 if (qemu_chr_replay(chr)) {
1307 error_setg(errp,
1308 "Chardev '%s' cannot be unplugged in record/replay mode", id);
1309 return;
1310 }
1311 qemu_chr_delete(chr);
1312 }
1313
1314 void qemu_chr_cleanup(void)
1315 {
1316 Chardev *chr, *tmp;
1317
1318 QTAILQ_FOREACH_SAFE(chr, &chardevs, next, tmp) {
1319 qemu_chr_delete(chr);
1320 }
1321 }
1322
1323 static void register_types(void)
1324 {
1325 type_register_static(&char_type_info);
1326
1327 /* this must be done after machine init, since we register FEs with muxes
1328 * as part of realize functions like serial_isa_realizefn when -nographic
1329 * is specified
1330 */
1331 qemu_add_machine_init_done_notifier(&muxes_realize_notify);
1332 }
1333
1334 type_init(register_types);