4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "qemu/cutils.h"
27 #include "monitor/monitor.h"
28 #include "monitor/qmp-helpers.h"
29 #include "qemu/config-file.h"
30 #include "qemu/error-report.h"
31 #include "qemu/qemu-print.h"
32 #include "chardev/char.h"
33 #include "qapi/error.h"
34 #include "qapi/qapi-commands-char.h"
35 #include "qapi/qmp/qerror.h"
36 #include "sysemu/replay.h"
37 #include "qemu/help_option.h"
38 #include "qemu/module.h"
39 #include "qemu/option.h"
41 #include "qemu/coroutine.h"
42 #include "qemu/yank.h"
44 #include "chardev-internal.h"
46 /***********************************************************/
47 /* character device */
49 Object *get_chardevs_root(void)
51 return container_get(object_get_root(), "/chardevs");
54 static void chr_be_event(Chardev *s, QEMUChrEvent event)
56 CharBackend *be = s->be;
58 if (!be || !be->chr_event) {
62 be->chr_event(be->opaque, event);
65 void qemu_chr_be_event(Chardev *s, QEMUChrEvent event)
67 /* Keep track if the char device is open */
69 case CHR_EVENT_OPENED:
72 case CHR_EVENT_CLOSED:
76 case CHR_EVENT_MUX_IN:
77 case CHR_EVENT_MUX_OUT:
82 CHARDEV_GET_CLASS(s)->chr_be_event(s, event);
85 /* Not reporting errors from writing to logfile, as logs are
86 * defined to be "best effort" only */
87 static void qemu_chr_write_log(Chardev *s, const uint8_t *buf, size_t len)
98 ret = write(s->logfd, buf + done, len - done);
99 if (ret == -1 && errno == EAGAIN) {
111 static int qemu_chr_write_buffer(Chardev *s,
112 const uint8_t *buf, int len,
113 int *offset, bool write_all)
115 ChardevClass *cc = CHARDEV_GET_CLASS(s);
119 qemu_mutex_lock(&s->chr_write_lock);
120 while (*offset < len) {
122 res = cc->chr_write(s, buf + *offset, len - *offset);
123 if (res < 0 && errno == EAGAIN && write_all) {
124 if (qemu_in_coroutine()) {
125 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
143 * If some data was written by backend, we should
144 * only log what was actually written. This method
145 * may be invoked again to write the remaining
146 * method, thus we'll log the remainder at that time.
148 qemu_chr_write_log(s, buf, *offset);
149 } else if (res < 0) {
151 * If a fatal error was reported by the backend,
152 * assume this method won't be invoked again with
153 * this buffer, so log it all right away.
155 qemu_chr_write_log(s, buf, len);
157 qemu_mutex_unlock(&s->chr_write_lock);
162 int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all)
167 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
168 replay_char_write_event_load(&res, &offset);
169 assert(offset <= len);
170 qemu_chr_write_buffer(s, buf, offset, &offset, true);
174 res = qemu_chr_write_buffer(s, buf, len, &offset, write_all);
176 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
177 replay_char_write_event_save(res, offset);
186 int qemu_chr_be_can_write(Chardev *s)
188 CharBackend *be = s->be;
190 if (!be || !be->chr_can_read) {
194 return be->chr_can_read(be->opaque);
197 void qemu_chr_be_write_impl(Chardev *s, const uint8_t *buf, int len)
199 CharBackend *be = s->be;
201 if (be && be->chr_read) {
202 be->chr_read(be->opaque, buf, len);
206 void qemu_chr_be_write(Chardev *s, const uint8_t *buf, int len)
208 if (qemu_chr_replay(s)) {
209 if (replay_mode == REPLAY_MODE_PLAY) {
212 replay_chr_be_write(s, buf, len);
214 qemu_chr_be_write_impl(s, buf, len);
218 void qemu_chr_be_update_read_handlers(Chardev *s,
219 GMainContext *context)
221 ChardevClass *cc = CHARDEV_GET_CLASS(s);
223 assert(qemu_chr_has_feature(s, QEMU_CHAR_FEATURE_GCONTEXT)
225 s->gcontext = context;
226 if (cc->chr_update_read_handler) {
227 cc->chr_update_read_handler(s);
231 int qemu_chr_add_client(Chardev *s, int fd)
233 return CHARDEV_GET_CLASS(s)->chr_add_client ?
234 CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
237 static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
238 bool *be_opened, Error **errp)
240 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
241 /* Any ChardevCommon member would work */
242 ChardevCommon *common = backend ? backend->u.null.data : NULL;
244 if (common && common->logfile) {
245 int flags = O_WRONLY;
246 if (common->has_logappend &&
252 chr->logfd = qemu_create(common->logfile, flags, 0666, errp);
253 if (chr->logfd < 0) {
259 cc->open(chr, backend, be_opened, errp);
263 static void char_init(Object *obj)
265 Chardev *chr = CHARDEV(obj);
267 chr->handover_yank_instance = false;
269 qemu_mutex_init(&chr->chr_write_lock);
272 * Assume if chr_update_read_handler is implemented it will
273 * take the updated gcontext into account.
275 if (CHARDEV_GET_CLASS(chr)->chr_update_read_handler) {
276 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT);
281 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len)
286 static void char_class_init(ObjectClass *oc, void *data)
288 ChardevClass *cc = CHARDEV_CLASS(oc);
290 cc->chr_write = null_chr_write;
291 cc->chr_be_event = chr_be_event;
294 static void char_finalize(Object *obj)
296 Chardev *chr = CHARDEV(obj);
301 g_free(chr->filename);
303 if (chr->logfd != -1) {
306 qemu_mutex_destroy(&chr->chr_write_lock);
309 static const TypeInfo char_type_info = {
310 .name = TYPE_CHARDEV,
311 .parent = TYPE_OBJECT,
312 .instance_size = sizeof(Chardev),
313 .instance_init = char_init,
314 .instance_finalize = char_finalize,
316 .class_size = sizeof(ChardevClass),
317 .class_init = char_class_init,
320 static bool qemu_chr_is_busy(Chardev *s)
322 if (CHARDEV_IS_MUX(s)) {
323 MuxChardev *d = MUX_CHARDEV(s);
324 return d->mux_cnt >= 0;
326 return s->be != NULL;
330 int qemu_chr_wait_connected(Chardev *chr, Error **errp)
332 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
334 if (cc->chr_wait_connected) {
335 return cc->chr_wait_connected(chr, errp);
341 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,
344 char host[65], port[33], width[8], height[8];
348 Error *local_err = NULL;
350 opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
352 error_report_err(local_err);
356 if (strstart(filename, "mon:", &p)) {
357 if (!permit_mux_mon) {
358 error_report("mon: isn't supported in this context");
362 qemu_opt_set(opts, "mux", "on", &error_abort);
363 if (strcmp(filename, "stdio") == 0) {
364 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
365 * but pass it to the guest. Handle this only for compat syntax,
366 * for -chardev syntax we have special option for this.
367 * This is what -nographic did, redirecting+muxing serial+monitor
368 * to stdio causing Ctrl+C to be passed to guest. */
369 qemu_opt_set(opts, "signal", "off", &error_abort);
373 if (strcmp(filename, "null") == 0 ||
374 strcmp(filename, "pty") == 0 ||
375 strcmp(filename, "msmouse") == 0 ||
376 strcmp(filename, "wctablet") == 0 ||
377 strcmp(filename, "braille") == 0 ||
378 strcmp(filename, "testdev") == 0 ||
379 strcmp(filename, "stdio") == 0) {
380 qemu_opt_set(opts, "backend", filename, &error_abort);
383 if (strstart(filename, "vc", &p)) {
384 qemu_opt_set(opts, "backend", "vc", &error_abort);
386 if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
388 qemu_opt_set(opts, "width", width, &error_abort);
389 qemu_opt_set(opts, "height", height, &error_abort);
390 } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
392 qemu_opt_set(opts, "cols", width, &error_abort);
393 qemu_opt_set(opts, "rows", height, &error_abort);
400 if (strcmp(filename, "con:") == 0) {
401 qemu_opt_set(opts, "backend", "console", &error_abort);
404 if (strstart(filename, "COM", NULL)) {
405 qemu_opt_set(opts, "backend", "serial", &error_abort);
406 qemu_opt_set(opts, "path", filename, &error_abort);
409 if (strstart(filename, "file:", &p)) {
410 qemu_opt_set(opts, "backend", "file", &error_abort);
411 qemu_opt_set(opts, "path", p, &error_abort);
414 if (strstart(filename, "pipe:", &p)) {
415 qemu_opt_set(opts, "backend", "pipe", &error_abort);
416 qemu_opt_set(opts, "path", p, &error_abort);
419 if (strstart(filename, "tcp:", &p) ||
420 strstart(filename, "telnet:", &p) ||
421 strstart(filename, "tn3270:", &p) ||
422 strstart(filename, "websocket:", &p)) {
423 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
425 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
428 qemu_opt_set(opts, "backend", "socket", &error_abort);
429 qemu_opt_set(opts, "host", host, &error_abort);
430 qemu_opt_set(opts, "port", port, &error_abort);
432 if (!qemu_opts_do_parse(opts, p + pos + 1, NULL, &local_err)) {
433 error_report_err(local_err);
437 if (strstart(filename, "telnet:", &p)) {
438 qemu_opt_set(opts, "telnet", "on", &error_abort);
439 } else if (strstart(filename, "tn3270:", &p)) {
440 qemu_opt_set(opts, "tn3270", "on", &error_abort);
441 } else if (strstart(filename, "websocket:", &p)) {
442 qemu_opt_set(opts, "websocket", "on", &error_abort);
446 if (strstart(filename, "udp:", &p)) {
447 qemu_opt_set(opts, "backend", "udp", &error_abort);
448 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
450 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
454 qemu_opt_set(opts, "host", host, &error_abort);
455 qemu_opt_set(opts, "port", port, &error_abort);
458 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
460 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
464 qemu_opt_set(opts, "localaddr", host, &error_abort);
465 qemu_opt_set(opts, "localport", port, &error_abort);
469 if (strstart(filename, "unix:", &p)) {
470 qemu_opt_set(opts, "backend", "socket", &error_abort);
471 if (!qemu_opts_do_parse(opts, p, "path", &local_err)) {
472 error_report_err(local_err);
477 if (strstart(filename, "/dev/parport", NULL) ||
478 strstart(filename, "/dev/ppi", NULL)) {
479 qemu_opt_set(opts, "backend", "parallel", &error_abort);
480 qemu_opt_set(opts, "path", filename, &error_abort);
483 if (strstart(filename, "/dev/", NULL)) {
484 qemu_opt_set(opts, "backend", "serial", &error_abort);
485 qemu_opt_set(opts, "path", filename, &error_abort);
489 error_report("'%s' is not a valid char driver", filename);
496 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
498 const char *logfile = qemu_opt_get(opts, "logfile");
500 backend->logfile = g_strdup(logfile);
501 backend->has_logappend = true;
502 backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
505 static const ChardevClass *char_get_class(const char *driver, Error **errp)
508 const ChardevClass *cc;
509 char *typename = g_strdup_printf("chardev-%s", driver);
511 oc = module_object_class_by_name(typename);
514 if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
515 error_setg(errp, "'%s' is not a valid char driver name", driver);
519 if (object_class_is_abstract(oc)) {
520 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
521 "an abstract device type");
525 cc = CHARDEV_CLASS(oc);
527 error_setg(errp, "'%s' is not a valid char driver name", driver);
534 typedef struct ChadevClassFE {
535 void (*fn)(const char *name, void *opaque);
540 chardev_class_foreach(ObjectClass *klass, void *opaque)
542 ChadevClassFE *fe = opaque;
544 assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
545 if (CHARDEV_CLASS(klass)->internal) {
549 fe->fn(object_class_get_name(klass) + 8, fe->opaque);
553 chardev_name_foreach(void (*fn)(const char *name, void *opaque),
556 ChadevClassFE fe = { .fn = fn, .opaque = opaque };
558 object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
562 help_string_append(const char *name, void *opaque)
564 GString *str = opaque;
566 g_string_append_printf(str, "\n %s", name);
569 ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts, Error **errp)
571 Error *local_err = NULL;
572 const ChardevClass *cc;
573 ChardevBackend *backend = NULL;
574 const char *name = qemu_opt_get(opts, "backend");
577 error_setg(errp, "chardev: \"%s\" missing backend",
582 cc = char_get_class(name, errp);
587 backend = g_new0(ChardevBackend, 1);
588 backend->type = CHARDEV_BACKEND_KIND_NULL;
591 cc->parse(opts, backend, &local_err);
593 error_propagate(errp, local_err);
594 qapi_free_ChardevBackend(backend);
598 ChardevCommon *ccom = g_new0(ChardevCommon, 1);
599 qemu_chr_parse_common(opts, ccom);
600 backend->u.null.data = ccom; /* Any ChardevCommon member would work */
606 Chardev *qemu_chr_new_from_opts(QemuOpts *opts, GMainContext *context,
609 const ChardevClass *cc;
611 ChardevBackend *backend = NULL;
612 const char *name = qemu_opt_get(opts, "backend");
613 const char *id = qemu_opts_id(opts);
616 if (name && is_help_option(name)) {
617 GString *str = g_string_new("");
619 chardev_name_foreach(help_string_append, str);
621 qemu_printf("Available chardev backend types: %s\n", str->str);
622 g_string_free(str, true);
627 error_setg(errp, "chardev: no id specified");
631 backend = qemu_chr_parse_opts(opts, errp);
632 if (backend == NULL) {
636 cc = char_get_class(name, errp);
641 if (qemu_opt_get_bool(opts, "mux", 0)) {
642 bid = g_strdup_printf("%s-base", id);
645 chr = qemu_chardev_new(bid ? bid : id,
646 object_class_get_name(OBJECT_CLASS(cc)),
647 backend, context, errp);
655 qapi_free_ChardevBackend(backend);
656 backend = g_new0(ChardevBackend, 1);
657 backend->type = CHARDEV_BACKEND_KIND_MUX;
658 backend->u.mux.data = g_new0(ChardevMux, 1);
659 backend->u.mux.data->chardev = g_strdup(bid);
660 mux = qemu_chardev_new(id, TYPE_CHARDEV_MUX, backend, context, errp);
662 object_unparent(OBJECT(chr));
670 qapi_free_ChardevBackend(backend);
675 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename,
676 bool permit_mux_mon, GMainContext *context)
683 if (strstart(filename, "chardev:", &p)) {
684 return qemu_chr_find(p);
687 opts = qemu_chr_parse_compat(label, filename, permit_mux_mon);
691 chr = qemu_chr_new_from_opts(opts, context, &err);
693 error_report_err(err);
697 if (qemu_opt_get_bool(opts, "mux", 0)) {
698 assert(permit_mux_mon);
699 monitor_init_hmp(chr, true, &err);
701 error_report_err(err);
702 object_unparent(OBJECT(chr));
713 static Chardev *qemu_chr_new_permit_mux_mon(const char *label,
714 const char *filename,
716 GMainContext *context)
719 chr = qemu_chr_new_noreplay(label, filename, permit_mux_mon, context);
721 if (replay_mode != REPLAY_MODE_NONE) {
722 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
724 if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
725 error_report("Replay: ioctl is not supported "
726 "for serial devices yet");
728 replay_register_char_driver(chr);
733 Chardev *qemu_chr_new(const char *label, const char *filename,
734 GMainContext *context)
736 return qemu_chr_new_permit_mux_mon(label, filename, false, context);
739 Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename,
740 GMainContext *context)
742 return qemu_chr_new_permit_mux_mon(label, filename, true, context);
745 static int qmp_query_chardev_foreach(Object *obj, void *data)
747 Chardev *chr = CHARDEV(obj);
748 ChardevInfoList **list = data;
749 ChardevInfo *value = g_malloc0(sizeof(*value));
751 value->label = g_strdup(chr->label);
752 value->filename = g_strdup(chr->filename);
753 value->frontend_open = chr->be && chr->be->fe_open;
755 QAPI_LIST_PREPEND(*list, value);
760 ChardevInfoList *qmp_query_chardev(Error **errp)
762 ChardevInfoList *chr_list = NULL;
764 object_child_foreach(get_chardevs_root(),
765 qmp_query_chardev_foreach, &chr_list);
771 qmp_prepend_backend(const char *name, void *opaque)
773 ChardevBackendInfoList **list = opaque;
774 ChardevBackendInfo *value;
776 value = g_new0(ChardevBackendInfo, 1);
777 value->name = g_strdup(name);
778 QAPI_LIST_PREPEND(*list, value);
781 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
783 ChardevBackendInfoList *backend_list = NULL;
785 chardev_name_foreach(qmp_prepend_backend, &backend_list);
790 Chardev *qemu_chr_find(const char *name)
792 Object *obj = object_resolve_path_component(get_chardevs_root(), name);
794 return obj ? CHARDEV(obj) : NULL;
797 QemuOptsList qemu_chardev_opts = {
799 .implied_opt_name = "backend",
800 .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
804 .type = QEMU_OPT_STRING,
807 .type = QEMU_OPT_STRING,
809 .name = "input-path",
810 .type = QEMU_OPT_STRING,
813 .type = QEMU_OPT_STRING,
816 .type = QEMU_OPT_STRING,
819 .type = QEMU_OPT_STRING,
822 .type = QEMU_OPT_STRING,
825 .type = QEMU_OPT_STRING,
828 .type = QEMU_OPT_NUMBER,
831 .type = QEMU_OPT_BOOL,
834 .type = QEMU_OPT_BOOL,
837 .type = QEMU_OPT_BOOL,
840 .type = QEMU_OPT_BOOL,
843 .type = QEMU_OPT_BOOL,
846 .type = QEMU_OPT_BOOL,
849 .type = QEMU_OPT_NUMBER,
852 .type = QEMU_OPT_BOOL,
855 .type = QEMU_OPT_BOOL,
858 .type = QEMU_OPT_STRING,
861 .type = QEMU_OPT_STRING,
864 .type = QEMU_OPT_BOOL,
867 .type = QEMU_OPT_NUMBER,
870 .type = QEMU_OPT_NUMBER,
873 .type = QEMU_OPT_NUMBER,
876 .type = QEMU_OPT_NUMBER,
879 .type = QEMU_OPT_BOOL,
882 .type = QEMU_OPT_BOOL,
885 .type = QEMU_OPT_STRING,
888 .type = QEMU_OPT_NUMBER,
891 .type = QEMU_OPT_SIZE,
894 .type = QEMU_OPT_STRING,
897 .type = QEMU_OPT_BOOL,
900 .type = QEMU_OPT_STRING,
903 .type = QEMU_OPT_BOOL,
906 .type = QEMU_OPT_BOOL,
909 .type = QEMU_OPT_BOOL,
913 .type = QEMU_OPT_BOOL,
914 .def_value_str = "on",
917 .type = QEMU_OPT_BOOL,
920 { /* end of list */ }
924 bool qemu_chr_has_feature(Chardev *chr,
925 ChardevFeature feature)
927 return test_bit(feature, chr->features);
930 void qemu_chr_set_feature(Chardev *chr,
931 ChardevFeature feature)
933 return set_bit(feature, chr->features);
936 static Chardev *chardev_new(const char *id, const char *typename,
937 ChardevBackend *backend,
938 GMainContext *gcontext,
939 bool handover_yank_instance,
944 Error *local_err = NULL;
945 bool be_opened = true;
947 assert(g_str_has_prefix(typename, "chardev-"));
950 obj = object_new(typename);
952 chr->handover_yank_instance = handover_yank_instance;
953 chr->label = g_strdup(id);
954 chr->gcontext = gcontext;
956 qemu_char_open(chr, backend, &be_opened, &local_err);
958 error_propagate(errp, local_err);
963 if (!chr->filename) {
964 chr->filename = g_strdup(typename + 8);
967 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
973 Chardev *qemu_chardev_new(const char *id, const char *typename,
974 ChardevBackend *backend,
975 GMainContext *gcontext,
979 g_autofree char *genid = NULL;
982 genid = id_generate(ID_CHR);
986 chr = chardev_new(id, typename, backend, gcontext, false, errp);
991 if (!object_property_try_add_child(get_chardevs_root(), id, OBJECT(chr),
993 object_unref(OBJECT(chr));
996 object_unref(OBJECT(chr));
1001 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
1005 const ChardevClass *cc;
1007 g_autoptr(Chardev) chr = NULL;
1009 if (qemu_chr_find(id)) {
1010 error_setg(errp, "Chardev with id '%s' already exists", id);
1014 cc = char_get_class(ChardevBackendKind_str(backend->type), errp);
1019 chr = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc)),
1020 backend, NULL, false, errp);
1025 if (!object_property_try_add_child(get_chardevs_root(), id, OBJECT(chr),
1030 ret = g_new0(ChardevReturn, 1);
1031 if (CHARDEV_IS_PTY(chr)) {
1032 ret->pty = g_strdup(chr->filename + 4);
1038 error_prepend(errp, "Failed to add chardev '%s': ", id);
1042 ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend,
1046 const ChardevClass *cc, *cc_new;
1047 Chardev *chr, *chr_new;
1048 bool closed_sent = false;
1049 bool handover_yank_instance;
1052 chr = qemu_chr_find(id);
1054 error_setg(errp, "Chardev '%s' does not exist", id);
1058 if (CHARDEV_IS_MUX(chr)) {
1059 error_setg(errp, "Mux device hotswap not supported yet");
1063 if (qemu_chr_replay(chr)) {
1065 "Chardev '%s' cannot be changed in record/replay mode", id);
1072 object_unparent(OBJECT(chr));
1073 return qmp_chardev_add(id, backend, errp);
1076 if (!be->chr_be_change) {
1077 error_setg(errp, "Chardev user does not support chardev hotswap");
1081 cc = CHARDEV_GET_CLASS(chr);
1082 cc_new = char_get_class(ChardevBackendKind_str(backend->type), errp);
1088 * The new chardev should not register a yank instance if the current
1089 * chardev has registered one already.
1091 handover_yank_instance = cc->supports_yank && cc_new->supports_yank;
1093 chr_new = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc_new)),
1094 backend, chr->gcontext, handover_yank_instance, errp);
1099 if (chr->be_open && !chr_new->be_open) {
1100 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1105 qemu_chr_fe_init(be, chr_new, &error_abort);
1107 if (be->chr_be_change(be->opaque) < 0) {
1108 error_setg(errp, "Chardev '%s' change failed", chr_new->label);
1110 qemu_chr_fe_init(be, chr, &error_abort);
1112 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
1114 object_unref(OBJECT(chr_new));
1118 /* change successful, clean up */
1119 chr_new->handover_yank_instance = false;
1122 * When the old chardev is freed, it should not unregister the yank
1123 * instance if the new chardev needs it.
1125 chr->handover_yank_instance = handover_yank_instance;
1127 object_unparent(OBJECT(chr));
1128 object_property_add_child(get_chardevs_root(), chr_new->label,
1130 object_unref(OBJECT(chr_new));
1132 ret = g_new0(ChardevReturn, 1);
1133 if (CHARDEV_IS_PTY(chr_new)) {
1134 ret->pty = g_strdup(chr_new->filename + 4);
1140 void qmp_chardev_remove(const char *id, Error **errp)
1144 chr = qemu_chr_find(id);
1146 error_setg(errp, "Chardev '%s' not found", id);
1149 if (qemu_chr_is_busy(chr)) {
1150 error_setg(errp, "Chardev '%s' is busy", id);
1153 if (qemu_chr_replay(chr)) {
1155 "Chardev '%s' cannot be unplugged in record/replay mode", id);
1158 object_unparent(OBJECT(chr));
1161 void qmp_chardev_send_break(const char *id, Error **errp)
1165 chr = qemu_chr_find(id);
1167 error_setg(errp, "Chardev '%s' not found", id);
1170 qemu_chr_be_event(chr, CHR_EVENT_BREAK);
1173 bool qmp_add_client_char(int fd, bool has_skipauth, bool skipauth,
1174 bool has_tls, bool tls, const char *protocol,
1177 Chardev *s = qemu_chr_find(protocol);
1180 error_setg(errp, "protocol '%s' is invalid", protocol);
1183 if (qemu_chr_add_client(s, fd) < 0) {
1184 error_setg(errp, "failed to add client");
1191 * Add a timeout callback for the chardev (in milliseconds), return
1192 * the GSource object created. Please use this to add timeout hook for
1193 * chardev instead of g_timeout_add() and g_timeout_add_seconds(), to
1194 * make sure the gcontext that the task bound to is correct.
1196 GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms,
1197 GSourceFunc func, void *private)
1199 GSource *source = g_timeout_source_new(ms);
1202 g_source_set_callback(source, func, private, NULL);
1203 g_source_attach(source, chr->gcontext);
1208 void qemu_chr_cleanup(void)
1210 object_unparent(get_chardevs_root());
1213 static void register_types(void)
1215 type_register_static(&char_type_info);
1218 type_init(register_types);