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