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
24 #include "qemu/osdep.h"
25 #include "qemu/cutils.h"
26 #include "monitor/monitor.h"
27 #include "sysemu/sysemu.h"
28 #include "qemu/config-file.h"
29 #include "qemu/error-report.h"
30 #include "chardev/char.h"
31 #include "qmp-commands.h"
32 #include "qapi-visit.h"
33 #include "sysemu/replay.h"
34 #include "qemu/help_option.h"
36 #include "chardev/char-mux.h"
38 /***********************************************************/
39 /* character device */
41 static Object
*get_chardevs_root(void)
43 return container_get(object_get_root(), "/chardevs");
46 static void chr_be_event(Chardev
*s
, int event
)
48 CharBackend
*be
= s
->be
;
50 if (!be
|| !be
->chr_event
) {
54 be
->chr_event(be
->opaque
, event
);
57 void qemu_chr_be_event(Chardev
*s
, int event
)
59 /* Keep track if the char device is open */
61 case CHR_EVENT_OPENED
:
64 case CHR_EVENT_CLOSED
:
69 CHARDEV_GET_CLASS(s
)->chr_be_event(s
, event
);
72 /* Not reporting errors from writing to logfile, as logs are
73 * defined to be "best effort" only */
74 static void qemu_chr_write_log(Chardev
*s
, const uint8_t *buf
, size_t len
)
85 ret
= write(s
->logfd
, buf
+ done
, len
- done
);
86 if (ret
== -1 && errno
== EAGAIN
) {
98 static int qemu_chr_write_buffer(Chardev
*s
,
99 const uint8_t *buf
, int len
,
100 int *offset
, bool write_all
)
102 ChardevClass
*cc
= CHARDEV_GET_CLASS(s
);
106 qemu_mutex_lock(&s
->chr_write_lock
);
107 while (*offset
< len
) {
109 res
= cc
->chr_write(s
, buf
+ *offset
, len
- *offset
);
110 if (res
< 0 && errno
== EAGAIN
&& write_all
) {
125 qemu_chr_write_log(s
, buf
, *offset
);
127 qemu_mutex_unlock(&s
->chr_write_lock
);
132 int qemu_chr_write(Chardev
*s
, const uint8_t *buf
, int len
, bool write_all
)
137 if (qemu_chr_replay(s
) && replay_mode
== REPLAY_MODE_PLAY
) {
138 replay_char_write_event_load(&res
, &offset
);
139 assert(offset
<= len
);
140 qemu_chr_write_buffer(s
, buf
, offset
, &offset
, true);
144 res
= qemu_chr_write_buffer(s
, buf
, len
, &offset
, write_all
);
146 if (qemu_chr_replay(s
) && replay_mode
== REPLAY_MODE_RECORD
) {
147 replay_char_write_event_save(res
, offset
);
156 int qemu_chr_be_can_write(Chardev
*s
)
158 CharBackend
*be
= s
->be
;
160 if (!be
|| !be
->chr_can_read
) {
164 return be
->chr_can_read(be
->opaque
);
167 void qemu_chr_be_write_impl(Chardev
*s
, uint8_t *buf
, int len
)
169 CharBackend
*be
= s
->be
;
171 if (be
&& be
->chr_read
) {
172 be
->chr_read(be
->opaque
, buf
, len
);
176 void qemu_chr_be_write(Chardev
*s
, uint8_t *buf
, int len
)
178 if (qemu_chr_replay(s
)) {
179 if (replay_mode
== REPLAY_MODE_PLAY
) {
182 replay_chr_be_write(s
, buf
, len
);
184 qemu_chr_be_write_impl(s
, buf
, len
);
188 void qemu_chr_be_update_read_handlers(Chardev
*s
,
189 GMainContext
*context
)
191 ChardevClass
*cc
= CHARDEV_GET_CLASS(s
);
193 s
->gcontext
= context
;
194 if (cc
->chr_update_read_handler
) {
195 cc
->chr_update_read_handler(s
);
199 int qemu_chr_add_client(Chardev
*s
, int fd
)
201 return CHARDEV_GET_CLASS(s
)->chr_add_client
?
202 CHARDEV_GET_CLASS(s
)->chr_add_client(s
, fd
) : -1;
205 static void qemu_char_open(Chardev
*chr
, ChardevBackend
*backend
,
206 bool *be_opened
, Error
**errp
)
208 ChardevClass
*cc
= CHARDEV_GET_CLASS(chr
);
209 /* Any ChardevCommon member would work */
210 ChardevCommon
*common
= backend
? backend
->u
.null
.data
: NULL
;
212 if (common
&& common
->has_logfile
) {
213 int flags
= O_WRONLY
| O_CREAT
;
214 if (common
->has_logappend
&&
220 chr
->logfd
= qemu_open(common
->logfile
, flags
, 0666);
221 if (chr
->logfd
< 0) {
222 error_setg_errno(errp
, errno
,
223 "Unable to open logfile %s",
230 cc
->open(chr
, backend
, be_opened
, errp
);
234 static void char_init(Object
*obj
)
236 Chardev
*chr
= CHARDEV(obj
);
239 qemu_mutex_init(&chr
->chr_write_lock
);
242 static int null_chr_write(Chardev
*chr
, const uint8_t *buf
, int len
)
247 static void char_class_init(ObjectClass
*oc
, void *data
)
249 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
251 cc
->chr_write
= null_chr_write
;
252 cc
->chr_be_event
= chr_be_event
;
255 static void char_finalize(Object
*obj
)
257 Chardev
*chr
= CHARDEV(obj
);
262 g_free(chr
->filename
);
264 if (chr
->logfd
!= -1) {
267 qemu_mutex_destroy(&chr
->chr_write_lock
);
270 static const TypeInfo char_type_info
= {
271 .name
= TYPE_CHARDEV
,
272 .parent
= TYPE_OBJECT
,
273 .instance_size
= sizeof(Chardev
),
274 .instance_init
= char_init
,
275 .instance_finalize
= char_finalize
,
277 .class_size
= sizeof(ChardevClass
),
278 .class_init
= char_class_init
,
282 * Called after processing of default and command-line-specified
283 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
284 * to a mux chardev. This is done here to ensure that
285 * output/prompts/banners are only displayed for the FE that has
286 * focus when initial command-line processing/machine init is
289 * After this point, any new FE attached to any new or existing
290 * mux will receive CHR_EVENT_OPENED notifications for the BE
293 static int open_muxes(Object
*child
, void *opaque
)
295 if (CHARDEV_IS_MUX(child
)) {
296 /* send OPENED to all already-attached FEs */
297 mux_chr_send_all_event(CHARDEV(child
), CHR_EVENT_OPENED
);
298 /* mark mux as OPENED so any new FEs will immediately receive
301 qemu_chr_be_event(CHARDEV(child
), CHR_EVENT_OPENED
);
307 static void muxes_realize_done(Notifier
*notifier
, void *unused
)
309 muxes_realized
= true;
310 object_child_foreach(get_chardevs_root(), open_muxes
, NULL
);
313 static Notifier muxes_realize_notify
= {
314 .notify
= muxes_realize_done
,
317 static bool qemu_chr_is_busy(Chardev
*s
)
319 if (CHARDEV_IS_MUX(s
)) {
320 MuxChardev
*d
= MUX_CHARDEV(s
);
321 return d
->mux_cnt
>= 0;
323 return s
->be
!= NULL
;
327 int qemu_chr_wait_connected(Chardev
*chr
, Error
**errp
)
329 ChardevClass
*cc
= CHARDEV_GET_CLASS(chr
);
331 if (cc
->chr_wait_connected
) {
332 return cc
->chr_wait_connected(chr
, errp
);
338 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
)
340 char host
[65], port
[33], width
[8], height
[8];
344 Error
*local_err
= NULL
;
346 opts
= qemu_opts_create(qemu_find_opts("chardev"), label
, 1, &local_err
);
348 error_report_err(local_err
);
352 if (strstart(filename
, "mon:", &p
)) {
354 qemu_opt_set(opts
, "mux", "on", &error_abort
);
355 if (strcmp(filename
, "stdio") == 0) {
356 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
357 * but pass it to the guest. Handle this only for compat syntax,
358 * for -chardev syntax we have special option for this.
359 * This is what -nographic did, redirecting+muxing serial+monitor
360 * to stdio causing Ctrl+C to be passed to guest. */
361 qemu_opt_set(opts
, "signal", "off", &error_abort
);
365 if (strcmp(filename
, "null") == 0 ||
366 strcmp(filename
, "pty") == 0 ||
367 strcmp(filename
, "msmouse") == 0 ||
368 strcmp(filename
, "wctablet") == 0 ||
369 strcmp(filename
, "braille") == 0 ||
370 strcmp(filename
, "testdev") == 0 ||
371 strcmp(filename
, "stdio") == 0) {
372 qemu_opt_set(opts
, "backend", filename
, &error_abort
);
375 if (strstart(filename
, "vc", &p
)) {
376 qemu_opt_set(opts
, "backend", "vc", &error_abort
);
378 if (sscanf(p
+1, "%7[0-9]x%7[0-9]", width
, height
) == 2) {
380 qemu_opt_set(opts
, "width", width
, &error_abort
);
381 qemu_opt_set(opts
, "height", height
, &error_abort
);
382 } else if (sscanf(p
+1, "%7[0-9]Cx%7[0-9]C", width
, height
) == 2) {
384 qemu_opt_set(opts
, "cols", width
, &error_abort
);
385 qemu_opt_set(opts
, "rows", height
, &error_abort
);
392 if (strcmp(filename
, "con:") == 0) {
393 qemu_opt_set(opts
, "backend", "console", &error_abort
);
396 if (strstart(filename
, "COM", NULL
)) {
397 qemu_opt_set(opts
, "backend", "serial", &error_abort
);
398 qemu_opt_set(opts
, "path", filename
, &error_abort
);
401 if (strstart(filename
, "file:", &p
)) {
402 qemu_opt_set(opts
, "backend", "file", &error_abort
);
403 qemu_opt_set(opts
, "path", p
, &error_abort
);
406 if (strstart(filename
, "pipe:", &p
)) {
407 qemu_opt_set(opts
, "backend", "pipe", &error_abort
);
408 qemu_opt_set(opts
, "path", p
, &error_abort
);
411 if (strstart(filename
, "tcp:", &p
) ||
412 strstart(filename
, "telnet:", &p
) ||
413 strstart(filename
, "tn3270:", &p
)) {
414 if (sscanf(p
, "%64[^:]:%32[^,]%n", host
, port
, &pos
) < 2) {
416 if (sscanf(p
, ":%32[^,]%n", port
, &pos
) < 1)
419 qemu_opt_set(opts
, "backend", "socket", &error_abort
);
420 qemu_opt_set(opts
, "host", host
, &error_abort
);
421 qemu_opt_set(opts
, "port", port
, &error_abort
);
423 qemu_opts_do_parse(opts
, p
+pos
+1, NULL
, &local_err
);
425 error_report_err(local_err
);
429 if (strstart(filename
, "telnet:", &p
)) {
430 qemu_opt_set(opts
, "telnet", "on", &error_abort
);
431 } else if (strstart(filename
, "tn3270:", &p
)) {
432 qemu_opt_set(opts
, "tn3270", "on", &error_abort
);
436 if (strstart(filename
, "udp:", &p
)) {
437 qemu_opt_set(opts
, "backend", "udp", &error_abort
);
438 if (sscanf(p
, "%64[^:]:%32[^@,]%n", host
, port
, &pos
) < 2) {
440 if (sscanf(p
, ":%32[^@,]%n", port
, &pos
) < 1) {
444 qemu_opt_set(opts
, "host", host
, &error_abort
);
445 qemu_opt_set(opts
, "port", port
, &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
, "localaddr", host
, &error_abort
);
455 qemu_opt_set(opts
, "localport", port
, &error_abort
);
459 if (strstart(filename
, "unix:", &p
)) {
460 qemu_opt_set(opts
, "backend", "socket", &error_abort
);
461 qemu_opts_do_parse(opts
, p
, "path", &local_err
);
463 error_report_err(local_err
);
468 if (strstart(filename
, "/dev/parport", NULL
) ||
469 strstart(filename
, "/dev/ppi", NULL
)) {
470 qemu_opt_set(opts
, "backend", "parallel", &error_abort
);
471 qemu_opt_set(opts
, "path", filename
, &error_abort
);
474 if (strstart(filename
, "/dev/", NULL
)) {
475 qemu_opt_set(opts
, "backend", "serial", &error_abort
);
476 qemu_opt_set(opts
, "path", filename
, &error_abort
);
485 void qemu_chr_parse_common(QemuOpts
*opts
, ChardevCommon
*backend
)
487 const char *logfile
= qemu_opt_get(opts
, "logfile");
489 backend
->has_logfile
= logfile
!= NULL
;
490 backend
->logfile
= g_strdup(logfile
);
492 backend
->has_logappend
= true;
493 backend
->logappend
= qemu_opt_get_bool(opts
, "logappend", false);
496 static const ChardevClass
*char_get_class(const char *driver
, Error
**errp
)
499 const ChardevClass
*cc
;
500 char *typename
= g_strdup_printf("chardev-%s", driver
);
502 oc
= object_class_by_name(typename
);
505 if (!object_class_dynamic_cast(oc
, TYPE_CHARDEV
)) {
506 error_setg(errp
, "'%s' is not a valid char driver name", driver
);
510 if (object_class_is_abstract(oc
)) {
511 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "driver",
512 "abstract device type");
516 cc
= CHARDEV_CLASS(oc
);
518 error_setg(errp
, "'%s' is not a valid char driver name", driver
);
525 static const struct ChardevAlias
{
526 const char *typename
;
528 } chardev_alias_table
[] = {
529 #ifdef HAVE_CHARDEV_PARPORT
530 { "parallel", "parport" },
532 #ifdef HAVE_CHARDEV_SERIAL
537 typedef struct ChadevClassFE
{
538 void (*fn
)(const char *name
, void *opaque
);
543 chardev_class_foreach(ObjectClass
*klass
, void *opaque
)
545 ChadevClassFE
*fe
= opaque
;
547 assert(g_str_has_prefix(object_class_get_name(klass
), "chardev-"));
548 if (CHARDEV_CLASS(klass
)->internal
) {
552 fe
->fn(object_class_get_name(klass
) + 8, fe
->opaque
);
556 chardev_name_foreach(void (*fn
)(const char *name
, void *opaque
), void *opaque
)
558 ChadevClassFE fe
= { .fn
= fn
, .opaque
= opaque
};
561 object_class_foreach(chardev_class_foreach
, TYPE_CHARDEV
, false, &fe
);
563 for (i
= 0; i
< (int)ARRAY_SIZE(chardev_alias_table
); i
++) {
564 fn(chardev_alias_table
[i
].alias
, opaque
);
569 help_string_append(const char *name
, void *opaque
)
571 GString
*str
= opaque
;
573 g_string_append_printf(str
, "\n%s", name
);
576 static const char *chardev_alias_translate(const char *name
)
579 for (i
= 0; i
< (int)ARRAY_SIZE(chardev_alias_table
); i
++) {
580 if (g_strcmp0(chardev_alias_table
[i
].alias
, name
) == 0) {
581 return chardev_alias_table
[i
].typename
;
587 ChardevBackend
*qemu_chr_parse_opts(QemuOpts
*opts
, Error
**errp
)
589 Error
*local_err
= NULL
;
590 const ChardevClass
*cc
;
591 ChardevBackend
*backend
= NULL
;
592 const char *name
= chardev_alias_translate(qemu_opt_get(opts
, "backend"));
595 error_setg(errp
, "chardev: \"%s\" missing backend",
600 cc
= char_get_class(name
, errp
);
605 backend
= g_new0(ChardevBackend
, 1);
606 backend
->type
= CHARDEV_BACKEND_KIND_NULL
;
609 cc
->parse(opts
, backend
, &local_err
);
611 error_propagate(errp
, local_err
);
612 qapi_free_ChardevBackend(backend
);
616 ChardevCommon
*ccom
= g_new0(ChardevCommon
, 1);
617 qemu_chr_parse_common(opts
, ccom
);
618 backend
->u
.null
.data
= ccom
; /* Any ChardevCommon member would work */
624 Chardev
*qemu_chr_new_from_opts(QemuOpts
*opts
, Error
**errp
)
626 const ChardevClass
*cc
;
628 ChardevBackend
*backend
= NULL
;
629 const char *name
= chardev_alias_translate(qemu_opt_get(opts
, "backend"));
630 const char *id
= qemu_opts_id(opts
);
633 if (name
&& is_help_option(name
)) {
634 GString
*str
= g_string_new("");
636 chardev_name_foreach(help_string_append
, str
);
638 error_report("Available chardev backend types: %s", str
->str
);
639 g_string_free(str
, true);
644 error_setg(errp
, "chardev: no id specified");
648 backend
= qemu_chr_parse_opts(opts
, errp
);
649 if (backend
== NULL
) {
653 cc
= char_get_class(name
, errp
);
658 if (qemu_opt_get_bool(opts
, "mux", 0)) {
659 bid
= g_strdup_printf("%s-base", id
);
662 chr
= qemu_chardev_new(bid
? bid
: id
,
663 object_class_get_name(OBJECT_CLASS(cc
)),
672 qapi_free_ChardevBackend(backend
);
673 backend
= g_new0(ChardevBackend
, 1);
674 backend
->type
= CHARDEV_BACKEND_KIND_MUX
;
675 backend
->u
.mux
.data
= g_new0(ChardevMux
, 1);
676 backend
->u
.mux
.data
->chardev
= g_strdup(bid
);
677 mux
= qemu_chardev_new(id
, TYPE_CHARDEV_MUX
, backend
, errp
);
679 object_unparent(OBJECT(chr
));
687 qapi_free_ChardevBackend(backend
);
692 Chardev
*qemu_chr_new_noreplay(const char *label
, const char *filename
)
699 if (strstart(filename
, "chardev:", &p
)) {
700 return qemu_chr_find(p
);
703 opts
= qemu_chr_parse_compat(label
, filename
);
707 chr
= qemu_chr_new_from_opts(opts
, &err
);
709 error_report_err(err
);
711 if (chr
&& qemu_opt_get_bool(opts
, "mux", 0)) {
712 monitor_init(chr
, MONITOR_USE_READLINE
);
718 Chardev
*qemu_chr_new(const char *label
, const char *filename
)
721 chr
= qemu_chr_new_noreplay(label
, filename
);
723 if (replay_mode
!= REPLAY_MODE_NONE
) {
724 qemu_chr_set_feature(chr
, QEMU_CHAR_FEATURE_REPLAY
);
726 if (qemu_chr_replay(chr
) && CHARDEV_GET_CLASS(chr
)->chr_ioctl
) {
727 error_report("Replay: ioctl is not supported "
728 "for serial devices yet");
730 replay_register_char_driver(chr
);
735 static int qmp_query_chardev_foreach(Object
*obj
, void *data
)
737 Chardev
*chr
= CHARDEV(obj
);
738 ChardevInfoList
**list
= data
;
739 ChardevInfoList
*info
= g_malloc0(sizeof(*info
));
741 info
->value
= g_malloc0(sizeof(*info
->value
));
742 info
->value
->label
= g_strdup(chr
->label
);
743 info
->value
->filename
= g_strdup(chr
->filename
);
744 info
->value
->frontend_open
= chr
->be
&& chr
->be
->fe_open
;
752 ChardevInfoList
*qmp_query_chardev(Error
**errp
)
754 ChardevInfoList
*chr_list
= NULL
;
756 object_child_foreach(get_chardevs_root(),
757 qmp_query_chardev_foreach
, &chr_list
);
763 qmp_prepend_backend(const char *name
, void *opaque
)
765 ChardevBackendInfoList
**list
= opaque
;
766 ChardevBackendInfoList
*info
= g_malloc0(sizeof(*info
));
768 info
->value
= g_malloc0(sizeof(*info
->value
));
769 info
->value
->name
= g_strdup(name
);
774 ChardevBackendInfoList
*qmp_query_chardev_backends(Error
**errp
)
776 ChardevBackendInfoList
*backend_list
= NULL
;
778 chardev_name_foreach(qmp_prepend_backend
, &backend_list
);
783 Chardev
*qemu_chr_find(const char *name
)
785 Object
*obj
= object_resolve_path_component(get_chardevs_root(), name
);
787 return obj
? CHARDEV(obj
) : NULL
;
790 QemuOptsList qemu_chardev_opts
= {
792 .implied_opt_name
= "backend",
793 .head
= QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts
.head
),
797 .type
= QEMU_OPT_STRING
,
800 .type
= QEMU_OPT_STRING
,
803 .type
= QEMU_OPT_STRING
,
806 .type
= QEMU_OPT_STRING
,
809 .type
= QEMU_OPT_STRING
,
812 .type
= QEMU_OPT_STRING
,
815 .type
= QEMU_OPT_NUMBER
,
818 .type
= QEMU_OPT_BOOL
,
821 .type
= QEMU_OPT_BOOL
,
824 .type
= QEMU_OPT_BOOL
,
827 .type
= QEMU_OPT_BOOL
,
830 .type
= QEMU_OPT_BOOL
,
833 .type
= QEMU_OPT_NUMBER
,
836 .type
= QEMU_OPT_BOOL
,
839 .type
= QEMU_OPT_BOOL
,
842 .type
= QEMU_OPT_STRING
,
845 .type
= QEMU_OPT_NUMBER
,
848 .type
= QEMU_OPT_NUMBER
,
851 .type
= QEMU_OPT_NUMBER
,
854 .type
= QEMU_OPT_NUMBER
,
857 .type
= QEMU_OPT_BOOL
,
860 .type
= QEMU_OPT_BOOL
,
863 .type
= QEMU_OPT_STRING
,
866 .type
= QEMU_OPT_NUMBER
,
869 .type
= QEMU_OPT_SIZE
,
872 .type
= QEMU_OPT_STRING
,
875 .type
= QEMU_OPT_BOOL
,
878 .type
= QEMU_OPT_STRING
,
881 .type
= QEMU_OPT_BOOL
,
883 { /* end of list */ }
887 bool qemu_chr_has_feature(Chardev
*chr
,
888 ChardevFeature feature
)
890 return test_bit(feature
, chr
->features
);
893 void qemu_chr_set_feature(Chardev
*chr
,
894 ChardevFeature feature
)
896 return set_bit(feature
, chr
->features
);
899 Chardev
*qemu_chardev_new(const char *id
, const char *typename
,
900 ChardevBackend
*backend
,
905 Error
*local_err
= NULL
;
906 bool be_opened
= true;
908 assert(g_str_has_prefix(typename
, "chardev-"));
910 obj
= object_new(typename
);
912 chr
->label
= g_strdup(id
);
914 qemu_char_open(chr
, backend
, &be_opened
, &local_err
);
919 if (!chr
->filename
) {
920 chr
->filename
= g_strdup(typename
+ 8);
923 qemu_chr_be_event(chr
, CHR_EVENT_OPENED
);
927 object_property_add_child(get_chardevs_root(), id
, obj
, &local_err
);
936 error_propagate(errp
, local_err
);
944 ChardevReturn
*qmp_chardev_add(const char *id
, ChardevBackend
*backend
,
947 const ChardevClass
*cc
;
951 cc
= char_get_class(ChardevBackendKind_str(backend
->type
), errp
);
956 chr
= qemu_chardev_new(id
, object_class_get_name(OBJECT_CLASS(cc
)),
962 ret
= g_new0(ChardevReturn
, 1);
963 if (CHARDEV_IS_PTY(chr
)) {
964 ret
->pty
= g_strdup(chr
->filename
+ 4);
971 ChardevReturn
*qmp_chardev_change(const char *id
, ChardevBackend
*backend
,
975 const ChardevClass
*cc
;
976 Chardev
*chr
, *chr_new
;
977 bool closed_sent
= false;
980 chr
= qemu_chr_find(id
);
982 error_setg(errp
, "Chardev '%s' does not exist", id
);
986 if (CHARDEV_IS_MUX(chr
)) {
987 error_setg(errp
, "Mux device hotswap not supported yet");
991 if (qemu_chr_replay(chr
)) {
993 "Chardev '%s' cannot be changed in record/replay mode", id
);
1000 object_unparent(OBJECT(chr
));
1001 return qmp_chardev_add(id
, backend
, errp
);
1004 if (!be
->chr_be_change
) {
1005 error_setg(errp
, "Chardev user does not support chardev hotswap");
1009 cc
= char_get_class(ChardevBackendKind_str(backend
->type
), errp
);
1014 chr_new
= qemu_chardev_new(NULL
, object_class_get_name(OBJECT_CLASS(cc
)),
1019 chr_new
->label
= g_strdup(id
);
1021 if (chr
->be_open
&& !chr_new
->be_open
) {
1022 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1027 qemu_chr_fe_init(be
, chr_new
, &error_abort
);
1029 if (be
->chr_be_change(be
->opaque
) < 0) {
1030 error_setg(errp
, "Chardev '%s' change failed", chr_new
->label
);
1032 qemu_chr_fe_init(be
, chr
, &error_abort
);
1034 qemu_chr_be_event(chr
, CHR_EVENT_OPENED
);
1036 object_unref(OBJECT(chr_new
));
1040 object_unparent(OBJECT(chr
));
1041 object_property_add_child(get_chardevs_root(), chr_new
->label
,
1042 OBJECT(chr_new
), &error_abort
);
1043 object_unref(OBJECT(chr_new
));
1045 ret
= g_new0(ChardevReturn
, 1);
1046 if (CHARDEV_IS_PTY(chr_new
)) {
1047 ret
->pty
= g_strdup(chr_new
->filename
+ 4);
1048 ret
->has_pty
= true;
1054 void qmp_chardev_remove(const char *id
, Error
**errp
)
1058 chr
= qemu_chr_find(id
);
1060 error_setg(errp
, "Chardev '%s' not found", id
);
1063 if (qemu_chr_is_busy(chr
)) {
1064 error_setg(errp
, "Chardev '%s' is busy", id
);
1067 if (qemu_chr_replay(chr
)) {
1069 "Chardev '%s' cannot be unplugged in record/replay mode", id
);
1072 object_unparent(OBJECT(chr
));
1075 void qmp_chardev_send_break(const char *id
, Error
**errp
)
1079 chr
= qemu_chr_find(id
);
1081 error_setg(errp
, "Chardev '%s' not found", id
);
1084 qemu_chr_be_event(chr
, CHR_EVENT_BREAK
);
1087 void qemu_chr_cleanup(void)
1089 object_unparent(get_chardevs_root());
1092 static void register_types(void)
1094 type_register_static(&char_type_info
);
1096 /* this must be done after machine init, since we register FEs with muxes
1097 * as part of realize functions like serial_isa_realizefn when -nographic
1100 qemu_add_machine_init_done_notifier(&muxes_realize_notify
);
1103 type_init(register_types
);