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