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