linux-user: Add support for a group of btrfs ioctls used for snapshots
[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
25 #include "qemu/osdep.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 "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"
40 #include "qemu/id.h"
41 #include "qemu/coroutine.h"
42
43 #include "chardev-internal.h"
44
45 /***********************************************************/
46 /* character device */
47
48 Object *get_chardevs_root(void)
49 {
50 return container_get(object_get_root(), "/chardevs");
51 }
52
53 static void chr_be_event(Chardev *s, QEMUChrEvent event)
54 {
55 CharBackend *be = s->be;
56
57 if (!be || !be->chr_event) {
58 return;
59 }
60
61 be->chr_event(be->opaque, event);
62 }
63
64 void qemu_chr_be_event(Chardev *s, QEMUChrEvent event)
65 {
66 /* Keep track if the char device is open */
67 switch (event) {
68 case CHR_EVENT_OPENED:
69 s->be_open = 1;
70 break;
71 case CHR_EVENT_CLOSED:
72 s->be_open = 0;
73 break;
74 case CHR_EVENT_BREAK:
75 case CHR_EVENT_MUX_IN:
76 case CHR_EVENT_MUX_OUT:
77 /* Ignore */
78 break;
79 }
80
81 CHARDEV_GET_CLASS(s)->chr_be_event(s, event);
82 }
83
84 /* Not reporting errors from writing to logfile, as logs are
85 * defined to be "best effort" only */
86 static void qemu_chr_write_log(Chardev *s, const uint8_t *buf, size_t len)
87 {
88 size_t done = 0;
89 ssize_t ret;
90
91 if (s->logfd < 0) {
92 return;
93 }
94
95 while (done < len) {
96 retry:
97 ret = write(s->logfd, buf + done, len - done);
98 if (ret == -1 && errno == EAGAIN) {
99 g_usleep(100);
100 goto retry;
101 }
102
103 if (ret <= 0) {
104 return;
105 }
106 done += ret;
107 }
108 }
109
110 static int qemu_chr_write_buffer(Chardev *s,
111 const uint8_t *buf, int len,
112 int *offset, bool write_all)
113 {
114 ChardevClass *cc = CHARDEV_GET_CLASS(s);
115 int res = 0;
116 *offset = 0;
117
118 qemu_mutex_lock(&s->chr_write_lock);
119 while (*offset < len) {
120 retry:
121 res = cc->chr_write(s, buf + *offset, len - *offset);
122 if (res < 0 && errno == EAGAIN && write_all) {
123 if (qemu_in_coroutine()) {
124 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
125 } else {
126 g_usleep(100);
127 }
128 goto retry;
129 }
130
131 if (res <= 0) {
132 break;
133 }
134
135 *offset += res;
136 if (!write_all) {
137 break;
138 }
139 }
140 if (*offset > 0) {
141 qemu_chr_write_log(s, buf, *offset);
142 }
143 qemu_mutex_unlock(&s->chr_write_lock);
144
145 return res;
146 }
147
148 int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all)
149 {
150 int offset = 0;
151 int res;
152
153 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
154 replay_char_write_event_load(&res, &offset);
155 assert(offset <= len);
156 qemu_chr_write_buffer(s, buf, offset, &offset, true);
157 return res;
158 }
159
160 res = qemu_chr_write_buffer(s, buf, len, &offset, write_all);
161
162 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
163 replay_char_write_event_save(res, offset);
164 }
165
166 if (res < 0) {
167 return res;
168 }
169 return offset;
170 }
171
172 int qemu_chr_be_can_write(Chardev *s)
173 {
174 CharBackend *be = s->be;
175
176 if (!be || !be->chr_can_read) {
177 return 0;
178 }
179
180 return be->chr_can_read(be->opaque);
181 }
182
183 void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len)
184 {
185 CharBackend *be = s->be;
186
187 if (be && be->chr_read) {
188 be->chr_read(be->opaque, buf, len);
189 }
190 }
191
192 void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len)
193 {
194 if (qemu_chr_replay(s)) {
195 if (replay_mode == REPLAY_MODE_PLAY) {
196 return;
197 }
198 replay_chr_be_write(s, buf, len);
199 } else {
200 qemu_chr_be_write_impl(s, buf, len);
201 }
202 }
203
204 void qemu_chr_be_update_read_handlers(Chardev *s,
205 GMainContext *context)
206 {
207 ChardevClass *cc = CHARDEV_GET_CLASS(s);
208
209 assert(qemu_chr_has_feature(s, QEMU_CHAR_FEATURE_GCONTEXT)
210 || !context);
211 s->gcontext = context;
212 if (cc->chr_update_read_handler) {
213 cc->chr_update_read_handler(s);
214 }
215 }
216
217 int qemu_chr_add_client(Chardev *s, int fd)
218 {
219 return CHARDEV_GET_CLASS(s)->chr_add_client ?
220 CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
221 }
222
223 static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
224 bool *be_opened, Error **errp)
225 {
226 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
227 /* Any ChardevCommon member would work */
228 ChardevCommon *common = backend ? backend->u.null.data : NULL;
229
230 if (common && common->has_logfile) {
231 int flags = O_WRONLY | O_CREAT;
232 if (common->has_logappend &&
233 common->logappend) {
234 flags |= O_APPEND;
235 } else {
236 flags |= O_TRUNC;
237 }
238 chr->logfd = qemu_open(common->logfile, flags, 0666);
239 if (chr->logfd < 0) {
240 error_setg_errno(errp, errno,
241 "Unable to open logfile %s",
242 common->logfile);
243 return;
244 }
245 }
246
247 if (cc->open) {
248 cc->open(chr, backend, be_opened, errp);
249 }
250 }
251
252 static void char_init(Object *obj)
253 {
254 Chardev *chr = CHARDEV(obj);
255
256 chr->logfd = -1;
257 qemu_mutex_init(&chr->chr_write_lock);
258
259 /*
260 * Assume if chr_update_read_handler is implemented it will
261 * take the updated gcontext into account.
262 */
263 if (CHARDEV_GET_CLASS(chr)->chr_update_read_handler) {
264 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT);
265 }
266
267 }
268
269 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len)
270 {
271 return len;
272 }
273
274 static void char_class_init(ObjectClass *oc, void *data)
275 {
276 ChardevClass *cc = CHARDEV_CLASS(oc);
277
278 cc->chr_write = null_chr_write;
279 cc->chr_be_event = chr_be_event;
280 }
281
282 static void char_finalize(Object *obj)
283 {
284 Chardev *chr = CHARDEV(obj);
285
286 if (chr->be) {
287 chr->be->chr = NULL;
288 }
289 g_free(chr->filename);
290 g_free(chr->label);
291 if (chr->logfd != -1) {
292 close(chr->logfd);
293 }
294 qemu_mutex_destroy(&chr->chr_write_lock);
295 }
296
297 static const TypeInfo char_type_info = {
298 .name = TYPE_CHARDEV,
299 .parent = TYPE_OBJECT,
300 .instance_size = sizeof(Chardev),
301 .instance_init = char_init,
302 .instance_finalize = char_finalize,
303 .abstract = true,
304 .class_size = sizeof(ChardevClass),
305 .class_init = char_class_init,
306 };
307
308 static bool qemu_chr_is_busy(Chardev *s)
309 {
310 if (CHARDEV_IS_MUX(s)) {
311 MuxChardev *d = MUX_CHARDEV(s);
312 return d->mux_cnt >= 0;
313 } else {
314 return s->be != NULL;
315 }
316 }
317
318 int qemu_chr_wait_connected(Chardev *chr, Error **errp)
319 {
320 ChardevClass *cc = CHARDEV_GET_CLASS(chr);
321
322 if (cc->chr_wait_connected) {
323 return cc->chr_wait_connected(chr, errp);
324 }
325
326 return 0;
327 }
328
329 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,
330 bool permit_mux_mon)
331 {
332 char host[65], port[33], width[8], height[8];
333 int pos;
334 const char *p;
335 QemuOpts *opts;
336 Error *local_err = NULL;
337
338 opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
339 if (local_err) {
340 error_report_err(local_err);
341 return NULL;
342 }
343
344 if (strstart(filename, "mon:", &p)) {
345 if (!permit_mux_mon) {
346 error_report("mon: isn't supported in this context");
347 return NULL;
348 }
349 filename = p;
350 qemu_opt_set(opts, "mux", "on", &error_abort);
351 if (strcmp(filename, "stdio") == 0) {
352 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
353 * but pass it to the guest. Handle this only for compat syntax,
354 * for -chardev syntax we have special option for this.
355 * This is what -nographic did, redirecting+muxing serial+monitor
356 * to stdio causing Ctrl+C to be passed to guest. */
357 qemu_opt_set(opts, "signal", "off", &error_abort);
358 }
359 }
360
361 if (strcmp(filename, "null") == 0 ||
362 strcmp(filename, "pty") == 0 ||
363 strcmp(filename, "msmouse") == 0 ||
364 strcmp(filename, "wctablet") == 0 ||
365 strcmp(filename, "braille") == 0 ||
366 strcmp(filename, "testdev") == 0 ||
367 strcmp(filename, "stdio") == 0) {
368 qemu_opt_set(opts, "backend", filename, &error_abort);
369 return opts;
370 }
371 if (strstart(filename, "vc", &p)) {
372 qemu_opt_set(opts, "backend", "vc", &error_abort);
373 if (*p == ':') {
374 if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
375 /* pixels */
376 qemu_opt_set(opts, "width", width, &error_abort);
377 qemu_opt_set(opts, "height", height, &error_abort);
378 } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
379 /* chars */
380 qemu_opt_set(opts, "cols", width, &error_abort);
381 qemu_opt_set(opts, "rows", height, &error_abort);
382 } else {
383 goto fail;
384 }
385 }
386 return opts;
387 }
388 if (strcmp(filename, "con:") == 0) {
389 qemu_opt_set(opts, "backend", "console", &error_abort);
390 return opts;
391 }
392 if (strstart(filename, "COM", NULL)) {
393 qemu_opt_set(opts, "backend", "serial", &error_abort);
394 qemu_opt_set(opts, "path", filename, &error_abort);
395 return opts;
396 }
397 if (strstart(filename, "file:", &p)) {
398 qemu_opt_set(opts, "backend", "file", &error_abort);
399 qemu_opt_set(opts, "path", p, &error_abort);
400 return opts;
401 }
402 if (strstart(filename, "pipe:", &p)) {
403 qemu_opt_set(opts, "backend", "pipe", &error_abort);
404 qemu_opt_set(opts, "path", p, &error_abort);
405 return opts;
406 }
407 if (strstart(filename, "tcp:", &p) ||
408 strstart(filename, "telnet:", &p) ||
409 strstart(filename, "tn3270:", &p) ||
410 strstart(filename, "websocket:", &p)) {
411 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
412 host[0] = 0;
413 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
414 goto fail;
415 }
416 qemu_opt_set(opts, "backend", "socket", &error_abort);
417 qemu_opt_set(opts, "host", host, &error_abort);
418 qemu_opt_set(opts, "port", port, &error_abort);
419 if (p[pos] == ',') {
420 if (!qemu_opts_do_parse(opts, p + pos + 1, NULL, &local_err)) {
421 error_report_err(local_err);
422 goto fail;
423 }
424 }
425 if (strstart(filename, "telnet:", &p)) {
426 qemu_opt_set(opts, "telnet", "on", &error_abort);
427 } else if (strstart(filename, "tn3270:", &p)) {
428 qemu_opt_set(opts, "tn3270", "on", &error_abort);
429 } else if (strstart(filename, "websocket:", &p)) {
430 qemu_opt_set(opts, "websocket", "on", &error_abort);
431 }
432 return opts;
433 }
434 if (strstart(filename, "udp:", &p)) {
435 qemu_opt_set(opts, "backend", "udp", &error_abort);
436 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
437 host[0] = 0;
438 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
439 goto fail;
440 }
441 }
442 qemu_opt_set(opts, "host", host, &error_abort);
443 qemu_opt_set(opts, "port", port, &error_abort);
444 if (p[pos] == '@') {
445 p += pos + 1;
446 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
447 host[0] = 0;
448 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
449 goto fail;
450 }
451 }
452 qemu_opt_set(opts, "localaddr", host, &error_abort);
453 qemu_opt_set(opts, "localport", port, &error_abort);
454 }
455 return opts;
456 }
457 if (strstart(filename, "unix:", &p)) {
458 qemu_opt_set(opts, "backend", "socket", &error_abort);
459 if (!qemu_opts_do_parse(opts, p, "path", &local_err)) {
460 error_report_err(local_err);
461 goto fail;
462 }
463 return opts;
464 }
465 if (strstart(filename, "/dev/parport", NULL) ||
466 strstart(filename, "/dev/ppi", NULL)) {
467 qemu_opt_set(opts, "backend", "parallel", &error_abort);
468 qemu_opt_set(opts, "path", filename, &error_abort);
469 return opts;
470 }
471 if (strstart(filename, "/dev/", NULL)) {
472 qemu_opt_set(opts, "backend", "serial", &error_abort);
473 qemu_opt_set(opts, "path", filename, &error_abort);
474 return opts;
475 }
476
477 error_report("'%s' is not a valid char driver", filename);
478
479 fail:
480 qemu_opts_del(opts);
481 return NULL;
482 }
483
484 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
485 {
486 const char *logfile = qemu_opt_get(opts, "logfile");
487
488 backend->has_logfile = logfile != NULL;
489 backend->logfile = g_strdup(logfile);
490
491 backend->has_logappend = true;
492 backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
493 }
494
495 static const ChardevClass *char_get_class(const char *driver, Error **errp)
496 {
497 ObjectClass *oc;
498 const ChardevClass *cc;
499 char *typename = g_strdup_printf("chardev-%s", driver);
500
501 oc = module_object_class_by_name(typename);
502 g_free(typename);
503
504 if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
505 error_setg(errp, "'%s' is not a valid char driver name", driver);
506 return NULL;
507 }
508
509 if (object_class_is_abstract(oc)) {
510 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
511 "abstract device type");
512 return NULL;
513 }
514
515 cc = CHARDEV_CLASS(oc);
516 if (cc->internal) {
517 error_setg(errp, "'%s' is not a valid char driver name", driver);
518 return NULL;
519 }
520
521 return cc;
522 }
523
524 static const struct ChardevAlias {
525 const char *typename;
526 const char *alias;
527 } chardev_alias_table[] = {
528 #ifdef HAVE_CHARDEV_PARPORT
529 { "parallel", "parport" },
530 #endif
531 #ifdef HAVE_CHARDEV_SERIAL
532 { "serial", "tty" },
533 #endif
534 };
535
536 typedef struct ChadevClassFE {
537 void (*fn)(const char *name, void *opaque);
538 void *opaque;
539 } ChadevClassFE;
540
541 static void
542 chardev_class_foreach(ObjectClass *klass, void *opaque)
543 {
544 ChadevClassFE *fe = opaque;
545
546 assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
547 if (CHARDEV_CLASS(klass)->internal) {
548 return;
549 }
550
551 fe->fn(object_class_get_name(klass) + 8, fe->opaque);
552 }
553
554 static void
555 chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque)
556 {
557 ChadevClassFE fe = { .fn = fn, .opaque = opaque };
558 int i;
559
560 object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
561
562 for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) {
563 fn(chardev_alias_table[i].alias, opaque);
564 }
565 }
566
567 static void
568 help_string_append(const char *name, void *opaque)
569 {
570 GString *str = opaque;
571
572 g_string_append_printf(str, "\n %s", name);
573 }
574
575 static const char *chardev_alias_translate(const char *name)
576 {
577 int i;
578 for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) {
579 if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
580 return chardev_alias_table[i].typename;
581 }
582 }
583 return name;
584 }
585
586 ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts, Error **errp)
587 {
588 Error *local_err = NULL;
589 const ChardevClass *cc;
590 ChardevBackend *backend = NULL;
591 const char *name = chardev_alias_translate(qemu_opt_get(opts, "backend"));
592
593 if (name == NULL) {
594 error_setg(errp, "chardev: \"%s\" missing backend",
595 qemu_opts_id(opts));
596 return NULL;
597 }
598
599 cc = char_get_class(name, errp);
600 if (cc == NULL) {
601 return NULL;
602 }
603
604 backend = g_new0(ChardevBackend, 1);
605 backend->type = CHARDEV_BACKEND_KIND_NULL;
606
607 if (cc->parse) {
608 cc->parse(opts, backend, &local_err);
609 if (local_err) {
610 error_propagate(errp, local_err);
611 qapi_free_ChardevBackend(backend);
612 return NULL;
613 }
614 } else {
615 ChardevCommon *ccom = g_new0(ChardevCommon, 1);
616 qemu_chr_parse_common(opts, ccom);
617 backend->u.null.data = ccom; /* Any ChardevCommon member would work */
618 }
619
620 return backend;
621 }
622
623 Chardev *qemu_chr_new_from_opts(QemuOpts *opts, GMainContext *context,
624 Error **errp)
625 {
626 const ChardevClass *cc;
627 Chardev *chr = NULL;
628 ChardevBackend *backend = NULL;
629 const char *name = chardev_alias_translate(qemu_opt_get(opts, "backend"));
630 const char *id = qemu_opts_id(opts);
631 char *bid = NULL;
632
633 if (name && is_help_option(name)) {
634 GString *str = g_string_new("");
635
636 chardev_name_foreach(help_string_append, str);
637
638 qemu_printf("Available chardev backend types: %s\n", str->str);
639 g_string_free(str, true);
640 return NULL;
641 }
642
643 if (id == NULL) {
644 error_setg(errp, "chardev: no id specified");
645 return NULL;
646 }
647
648 backend = qemu_chr_parse_opts(opts, errp);
649 if (backend == NULL) {
650 return NULL;
651 }
652
653 cc = char_get_class(name, errp);
654 if (cc == NULL) {
655 goto out;
656 }
657
658 if (qemu_opt_get_bool(opts, "mux", 0)) {
659 bid = g_strdup_printf("%s-base", id);
660 }
661
662 chr = qemu_chardev_new(bid ? bid : id,
663 object_class_get_name(OBJECT_CLASS(cc)),
664 backend, context, errp);
665
666 if (chr == NULL) {
667 goto out;
668 }
669
670 if (bid) {
671 Chardev *mux;
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, context, errp);
678 if (mux == NULL) {
679 object_unparent(OBJECT(chr));
680 chr = NULL;
681 goto out;
682 }
683 chr = mux;
684 }
685
686 out:
687 qapi_free_ChardevBackend(backend);
688 g_free(bid);
689 return chr;
690 }
691
692 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename,
693 bool permit_mux_mon, GMainContext *context)
694 {
695 const char *p;
696 Chardev *chr;
697 QemuOpts *opts;
698 Error *err = NULL;
699
700 if (strstart(filename, "chardev:", &p)) {
701 return qemu_chr_find(p);
702 }
703
704 opts = qemu_chr_parse_compat(label, filename, permit_mux_mon);
705 if (!opts)
706 return NULL;
707
708 chr = qemu_chr_new_from_opts(opts, context, &err);
709 if (!chr) {
710 error_report_err(err);
711 goto out;
712 }
713
714 if (qemu_opt_get_bool(opts, "mux", 0)) {
715 assert(permit_mux_mon);
716 monitor_init_hmp(chr, true, &err);
717 if (err) {
718 error_report_err(err);
719 object_unparent(OBJECT(chr));
720 chr = NULL;
721 goto out;
722 }
723 }
724
725 out:
726 qemu_opts_del(opts);
727 return chr;
728 }
729
730 static Chardev *qemu_chr_new_permit_mux_mon(const char *label,
731 const char *filename,
732 bool permit_mux_mon,
733 GMainContext *context)
734 {
735 Chardev *chr;
736 chr = qemu_chr_new_noreplay(label, filename, permit_mux_mon, context);
737 if (chr) {
738 if (replay_mode != REPLAY_MODE_NONE) {
739 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
740 }
741 if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
742 error_report("Replay: ioctl is not supported "
743 "for serial devices yet");
744 }
745 replay_register_char_driver(chr);
746 }
747 return chr;
748 }
749
750 Chardev *qemu_chr_new(const char *label, const char *filename,
751 GMainContext *context)
752 {
753 return qemu_chr_new_permit_mux_mon(label, filename, false, context);
754 }
755
756 Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename,
757 GMainContext *context)
758 {
759 return qemu_chr_new_permit_mux_mon(label, filename, true, context);
760 }
761
762 static int qmp_query_chardev_foreach(Object *obj, void *data)
763 {
764 Chardev *chr = CHARDEV(obj);
765 ChardevInfoList **list = data;
766 ChardevInfoList *info = g_malloc0(sizeof(*info));
767
768 info->value = g_malloc0(sizeof(*info->value));
769 info->value->label = g_strdup(chr->label);
770 info->value->filename = g_strdup(chr->filename);
771 info->value->frontend_open = chr->be && chr->be->fe_open;
772
773 info->next = *list;
774 *list = info;
775
776 return 0;
777 }
778
779 ChardevInfoList *qmp_query_chardev(Error **errp)
780 {
781 ChardevInfoList *chr_list = NULL;
782
783 object_child_foreach(get_chardevs_root(),
784 qmp_query_chardev_foreach, &chr_list);
785
786 return chr_list;
787 }
788
789 static void
790 qmp_prepend_backend(const char *name, void *opaque)
791 {
792 ChardevBackendInfoList **list = opaque;
793 ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
794
795 info->value = g_malloc0(sizeof(*info->value));
796 info->value->name = g_strdup(name);
797 info->next = *list;
798 *list = info;
799 }
800
801 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
802 {
803 ChardevBackendInfoList *backend_list = NULL;
804
805 chardev_name_foreach(qmp_prepend_backend, &backend_list);
806
807 return backend_list;
808 }
809
810 Chardev *qemu_chr_find(const char *name)
811 {
812 Object *obj = object_resolve_path_component(get_chardevs_root(), name);
813
814 return obj ? CHARDEV(obj) : NULL;
815 }
816
817 QemuOptsList qemu_chardev_opts = {
818 .name = "chardev",
819 .implied_opt_name = "backend",
820 .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
821 .desc = {
822 {
823 .name = "backend",
824 .type = QEMU_OPT_STRING,
825 },{
826 .name = "path",
827 .type = QEMU_OPT_STRING,
828 },{
829 .name = "host",
830 .type = QEMU_OPT_STRING,
831 },{
832 .name = "port",
833 .type = QEMU_OPT_STRING,
834 },{
835 .name = "fd",
836 .type = QEMU_OPT_STRING,
837 },{
838 .name = "localaddr",
839 .type = QEMU_OPT_STRING,
840 },{
841 .name = "localport",
842 .type = QEMU_OPT_STRING,
843 },{
844 .name = "to",
845 .type = QEMU_OPT_NUMBER,
846 },{
847 .name = "ipv4",
848 .type = QEMU_OPT_BOOL,
849 },{
850 .name = "ipv6",
851 .type = QEMU_OPT_BOOL,
852 },{
853 .name = "wait",
854 .type = QEMU_OPT_BOOL,
855 },{
856 .name = "server",
857 .type = QEMU_OPT_BOOL,
858 },{
859 .name = "delay",
860 .type = QEMU_OPT_BOOL,
861 },{
862 .name = "reconnect",
863 .type = QEMU_OPT_NUMBER,
864 },{
865 .name = "telnet",
866 .type = QEMU_OPT_BOOL,
867 },{
868 .name = "tn3270",
869 .type = QEMU_OPT_BOOL,
870 },{
871 .name = "tls-creds",
872 .type = QEMU_OPT_STRING,
873 },{
874 .name = "tls-authz",
875 .type = QEMU_OPT_STRING,
876 },{
877 .name = "websocket",
878 .type = QEMU_OPT_BOOL,
879 },{
880 .name = "width",
881 .type = QEMU_OPT_NUMBER,
882 },{
883 .name = "height",
884 .type = QEMU_OPT_NUMBER,
885 },{
886 .name = "cols",
887 .type = QEMU_OPT_NUMBER,
888 },{
889 .name = "rows",
890 .type = QEMU_OPT_NUMBER,
891 },{
892 .name = "mux",
893 .type = QEMU_OPT_BOOL,
894 },{
895 .name = "signal",
896 .type = QEMU_OPT_BOOL,
897 },{
898 .name = "name",
899 .type = QEMU_OPT_STRING,
900 },{
901 .name = "debug",
902 .type = QEMU_OPT_NUMBER,
903 },{
904 .name = "size",
905 .type = QEMU_OPT_SIZE,
906 },{
907 .name = "chardev",
908 .type = QEMU_OPT_STRING,
909 },{
910 .name = "append",
911 .type = QEMU_OPT_BOOL,
912 },{
913 .name = "logfile",
914 .type = QEMU_OPT_STRING,
915 },{
916 .name = "logappend",
917 .type = QEMU_OPT_BOOL,
918 },{
919 .name = "tight",
920 .type = QEMU_OPT_BOOL,
921 .def_value_str = "on",
922 },{
923 .name = "abstract",
924 .type = QEMU_OPT_BOOL,
925 },
926 { /* end of list */ }
927 },
928 };
929
930 bool qemu_chr_has_feature(Chardev *chr,
931 ChardevFeature feature)
932 {
933 return test_bit(feature, chr->features);
934 }
935
936 void qemu_chr_set_feature(Chardev *chr,
937 ChardevFeature feature)
938 {
939 return set_bit(feature, chr->features);
940 }
941
942 static Chardev *chardev_new(const char *id, const char *typename,
943 ChardevBackend *backend,
944 GMainContext *gcontext,
945 Error **errp)
946 {
947 Object *obj;
948 Chardev *chr = NULL;
949 Error *local_err = NULL;
950 bool be_opened = true;
951
952 assert(g_str_has_prefix(typename, "chardev-"));
953
954 obj = object_new(typename);
955 chr = CHARDEV(obj);
956 chr->label = g_strdup(id);
957 chr->gcontext = gcontext;
958
959 qemu_char_open(chr, backend, &be_opened, &local_err);
960 if (local_err) {
961 goto end;
962 }
963
964 if (!chr->filename) {
965 chr->filename = g_strdup(typename + 8);
966 }
967 if (be_opened) {
968 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
969 }
970
971 if (id) {
972 object_property_try_add_child(get_chardevs_root(), id, obj,
973 &local_err);
974 if (local_err) {
975 goto end;
976 }
977 object_unref(obj);
978 }
979
980 end:
981 if (local_err) {
982 error_propagate(errp, local_err);
983 object_unref(obj);
984 return NULL;
985 }
986
987 return chr;
988 }
989
990 Chardev *qemu_chardev_new(const char *id, const char *typename,
991 ChardevBackend *backend,
992 GMainContext *gcontext,
993 Error **errp)
994 {
995 g_autofree char *genid = NULL;
996
997 if (!id) {
998 genid = id_generate(ID_CHR);
999 id = genid;
1000 }
1001
1002 return chardev_new(id, typename, backend, gcontext, errp);
1003 }
1004
1005 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
1006 Error **errp)
1007 {
1008 const ChardevClass *cc;
1009 ChardevReturn *ret;
1010 Chardev *chr;
1011
1012 cc = char_get_class(ChardevBackendKind_str(backend->type), errp);
1013 if (!cc) {
1014 return NULL;
1015 }
1016
1017 chr = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc)),
1018 backend, NULL, errp);
1019 if (!chr) {
1020 return NULL;
1021 }
1022
1023 ret = g_new0(ChardevReturn, 1);
1024 if (CHARDEV_IS_PTY(chr)) {
1025 ret->pty = g_strdup(chr->filename + 4);
1026 ret->has_pty = true;
1027 }
1028
1029 return ret;
1030 }
1031
1032 ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend,
1033 Error **errp)
1034 {
1035 CharBackend *be;
1036 const ChardevClass *cc;
1037 Chardev *chr, *chr_new;
1038 bool closed_sent = false;
1039 ChardevReturn *ret;
1040
1041 chr = qemu_chr_find(id);
1042 if (!chr) {
1043 error_setg(errp, "Chardev '%s' does not exist", id);
1044 return NULL;
1045 }
1046
1047 if (CHARDEV_IS_MUX(chr)) {
1048 error_setg(errp, "Mux device hotswap not supported yet");
1049 return NULL;
1050 }
1051
1052 if (qemu_chr_replay(chr)) {
1053 error_setg(errp,
1054 "Chardev '%s' cannot be changed in record/replay mode", id);
1055 return NULL;
1056 }
1057
1058 be = chr->be;
1059 if (!be) {
1060 /* easy case */
1061 object_unparent(OBJECT(chr));
1062 return qmp_chardev_add(id, backend, errp);
1063 }
1064
1065 if (!be->chr_be_change) {
1066 error_setg(errp, "Chardev user does not support chardev hotswap");
1067 return NULL;
1068 }
1069
1070 cc = char_get_class(ChardevBackendKind_str(backend->type), errp);
1071 if (!cc) {
1072 return NULL;
1073 }
1074
1075 chr_new = chardev_new(NULL, object_class_get_name(OBJECT_CLASS(cc)),
1076 backend, chr->gcontext, errp);
1077 if (!chr_new) {
1078 return NULL;
1079 }
1080 chr_new->label = g_strdup(id);
1081
1082 if (chr->be_open && !chr_new->be_open) {
1083 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1084 closed_sent = true;
1085 }
1086
1087 chr->be = NULL;
1088 qemu_chr_fe_init(be, chr_new, &error_abort);
1089
1090 if (be->chr_be_change(be->opaque) < 0) {
1091 error_setg(errp, "Chardev '%s' change failed", chr_new->label);
1092 chr_new->be = NULL;
1093 qemu_chr_fe_init(be, chr, &error_abort);
1094 if (closed_sent) {
1095 qemu_chr_be_event(chr, CHR_EVENT_OPENED);
1096 }
1097 object_unref(OBJECT(chr_new));
1098 return NULL;
1099 }
1100
1101 object_unparent(OBJECT(chr));
1102 object_property_add_child(get_chardevs_root(), chr_new->label,
1103 OBJECT(chr_new));
1104 object_unref(OBJECT(chr_new));
1105
1106 ret = g_new0(ChardevReturn, 1);
1107 if (CHARDEV_IS_PTY(chr_new)) {
1108 ret->pty = g_strdup(chr_new->filename + 4);
1109 ret->has_pty = true;
1110 }
1111
1112 return ret;
1113 }
1114
1115 void qmp_chardev_remove(const char *id, Error **errp)
1116 {
1117 Chardev *chr;
1118
1119 chr = qemu_chr_find(id);
1120 if (chr == NULL) {
1121 error_setg(errp, "Chardev '%s' not found", id);
1122 return;
1123 }
1124 if (qemu_chr_is_busy(chr)) {
1125 error_setg(errp, "Chardev '%s' is busy", id);
1126 return;
1127 }
1128 if (qemu_chr_replay(chr)) {
1129 error_setg(errp,
1130 "Chardev '%s' cannot be unplugged in record/replay mode", id);
1131 return;
1132 }
1133 object_unparent(OBJECT(chr));
1134 }
1135
1136 void qmp_chardev_send_break(const char *id, Error **errp)
1137 {
1138 Chardev *chr;
1139
1140 chr = qemu_chr_find(id);
1141 if (chr == NULL) {
1142 error_setg(errp, "Chardev '%s' not found", id);
1143 return;
1144 }
1145 qemu_chr_be_event(chr, CHR_EVENT_BREAK);
1146 }
1147
1148 /*
1149 * Add a timeout callback for the chardev (in milliseconds), return
1150 * the GSource object created. Please use this to add timeout hook for
1151 * chardev instead of g_timeout_add() and g_timeout_add_seconds(), to
1152 * make sure the gcontext that the task bound to is correct.
1153 */
1154 GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms,
1155 GSourceFunc func, void *private)
1156 {
1157 GSource *source = g_timeout_source_new(ms);
1158
1159 assert(func);
1160 g_source_set_callback(source, func, private, NULL);
1161 g_source_attach(source, chr->gcontext);
1162
1163 return source;
1164 }
1165
1166 void qemu_chr_cleanup(void)
1167 {
1168 object_unparent(get_chardevs_root());
1169 }
1170
1171 static void register_types(void)
1172 {
1173 type_register_static(&char_type_info);
1174 }
1175
1176 type_init(register_types);