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