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-common.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 "sysemu/char.h" 32 #include "qmp-commands.h" 33 #include "qapi-visit.h" 34 #include "sysemu/replay.h" 35 #include "qemu/help_option.h" 36 37 #include "char-mux.h" 38 #include "char-io.h" 39 #include "char-parallel.h" 40 #include "char-serial.h" 41 42 /***********************************************************/ 43 /* character device */ 44 45 static QTAILQ_HEAD(ChardevHead, Chardev) chardevs = 46 QTAILQ_HEAD_INITIALIZER(chardevs); 47 48 void qemu_chr_be_event(Chardev *s, int event) 49 { 50 CharBackend *be = s->be; 51 52 /* Keep track if the char device is open */ 53 switch (event) { 54 case CHR_EVENT_OPENED: 55 s->be_open = 1; 56 break; 57 case CHR_EVENT_CLOSED: 58 s->be_open = 0; 59 break; 60 } 61 62 if (!be || !be->chr_event) { 63 return; 64 } 65 66 be->chr_event(be->opaque, event); 67 } 68 69 void qemu_chr_be_generic_open(Chardev *s) 70 { 71 qemu_chr_be_event(s, CHR_EVENT_OPENED); 72 } 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_fe_write_log(Chardev *s, 78 const uint8_t *buf, size_t len) 79 { 80 size_t done = 0; 81 ssize_t ret; 82 83 if (s->logfd < 0) { 84 return; 85 } 86 87 while (done < len) { 88 retry: 89 ret = write(s->logfd, buf + done, len - done); 90 if (ret == -1 && errno == EAGAIN) { 91 g_usleep(100); 92 goto retry; 93 } 94 95 if (ret <= 0) { 96 return; 97 } 98 done += ret; 99 } 100 } 101 102 static int qemu_chr_fe_write_buffer(Chardev *s, 103 const uint8_t *buf, int len, int *offset) 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) { 114 g_usleep(100); 115 goto retry; 116 } 117 118 if (res <= 0) { 119 break; 120 } 121 122 *offset += res; 123 } 124 if (*offset > 0) { 125 qemu_chr_fe_write_log(s, buf, *offset); 126 } 127 qemu_mutex_unlock(&s->chr_write_lock); 128 129 return res; 130 } 131 132 static bool qemu_chr_replay(Chardev *chr) 133 { 134 return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY); 135 } 136 137 int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len) 138 { 139 Chardev *s = be->chr; 140 ChardevClass *cc; 141 int ret; 142 143 if (!s) { 144 return 0; 145 } 146 147 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 148 int offset; 149 replay_char_write_event_load(&ret, &offset); 150 assert(offset <= len); 151 qemu_chr_fe_write_buffer(s, buf, offset, &offset); 152 return ret; 153 } 154 155 cc = CHARDEV_GET_CLASS(s); 156 qemu_mutex_lock(&s->chr_write_lock); 157 ret = cc->chr_write(s, buf, len); 158 159 if (ret > 0) { 160 qemu_chr_fe_write_log(s, buf, ret); 161 } 162 163 qemu_mutex_unlock(&s->chr_write_lock); 164 165 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 166 replay_char_write_event_save(ret, ret < 0 ? 0 : ret); 167 } 168 169 return ret; 170 } 171 172 int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len) 173 { 174 int offset; 175 int res; 176 177 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 178 replay_char_write_event_load(&res, &offset); 179 assert(offset <= len); 180 qemu_chr_fe_write_buffer(s, buf, offset, &offset); 181 return res; 182 } 183 184 res = qemu_chr_fe_write_buffer(s, buf, len, &offset); 185 186 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 187 replay_char_write_event_save(res, offset); 188 } 189 190 if (res < 0) { 191 return res; 192 } 193 return offset; 194 } 195 196 int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len) 197 { 198 Chardev *s = be->chr; 199 200 if (!s) { 201 return 0; 202 } 203 204 return qemu_chr_write_all(s, buf, len); 205 } 206 207 int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len) 208 { 209 Chardev *s = be->chr; 210 int offset = 0, counter = 10; 211 int res; 212 213 if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) { 214 return 0; 215 } 216 217 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 218 return replay_char_read_all_load(buf); 219 } 220 221 while (offset < len) { 222 retry: 223 res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset, 224 len - offset); 225 if (res == -1 && errno == EAGAIN) { 226 g_usleep(100); 227 goto retry; 228 } 229 230 if (res == 0) { 231 break; 232 } 233 234 if (res < 0) { 235 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 236 replay_char_read_all_save_error(res); 237 } 238 return res; 239 } 240 241 offset += res; 242 243 if (!counter--) { 244 break; 245 } 246 } 247 248 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 249 replay_char_read_all_save_buf(buf, offset); 250 } 251 return offset; 252 } 253 254 int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg) 255 { 256 Chardev *s = be->chr; 257 int res; 258 259 if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) { 260 res = -ENOTSUP; 261 } else { 262 res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg); 263 } 264 265 return res; 266 } 267 268 int qemu_chr_be_can_write(Chardev *s) 269 { 270 CharBackend *be = s->be; 271 272 if (!be || !be->chr_can_read) { 273 return 0; 274 } 275 276 return be->chr_can_read(be->opaque); 277 } 278 279 void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len) 280 { 281 CharBackend *be = s->be; 282 283 if (be && be->chr_read) { 284 be->chr_read(be->opaque, buf, len); 285 } 286 } 287 288 void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len) 289 { 290 if (qemu_chr_replay(s)) { 291 if (replay_mode == REPLAY_MODE_PLAY) { 292 return; 293 } 294 replay_chr_be_write(s, buf, len); 295 } else { 296 qemu_chr_be_write_impl(s, buf, len); 297 } 298 } 299 300 int qemu_chr_fe_get_msgfd(CharBackend *be) 301 { 302 Chardev *s = be->chr; 303 int fd; 304 int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1; 305 if (s && qemu_chr_replay(s)) { 306 error_report("Replay: get msgfd is not supported " 307 "for serial devices yet"); 308 exit(1); 309 } 310 return res; 311 } 312 313 int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len) 314 { 315 Chardev *s = be->chr; 316 317 if (!s) { 318 return -1; 319 } 320 321 return CHARDEV_GET_CLASS(s)->get_msgfds ? 322 CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1; 323 } 324 325 int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num) 326 { 327 Chardev *s = be->chr; 328 329 if (!s) { 330 return -1; 331 } 332 333 return CHARDEV_GET_CLASS(s)->set_msgfds ? 334 CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1; 335 } 336 337 int qemu_chr_add_client(Chardev *s, int fd) 338 { 339 return CHARDEV_GET_CLASS(s)->chr_add_client ? 340 CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1; 341 } 342 343 void qemu_chr_fe_accept_input(CharBackend *be) 344 { 345 Chardev *s = be->chr; 346 347 if (!s) { 348 return; 349 } 350 351 if (CHARDEV_GET_CLASS(s)->chr_accept_input) { 352 CHARDEV_GET_CLASS(s)->chr_accept_input(s); 353 } 354 qemu_notify_event(); 355 } 356 357 void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...) 358 { 359 char buf[CHR_READ_BUF_LEN]; 360 va_list ap; 361 va_start(ap, fmt); 362 vsnprintf(buf, sizeof(buf), fmt, ap); 363 /* XXX this blocks entire thread. Rewrite to use 364 * qemu_chr_fe_write and background I/O callbacks */ 365 qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf)); 366 va_end(ap); 367 } 368 369 static void qemu_char_open(Chardev *chr, ChardevBackend *backend, 370 bool *be_opened, Error **errp) 371 { 372 ChardevClass *cc = CHARDEV_GET_CLASS(chr); 373 /* Any ChardevCommon member would work */ 374 ChardevCommon *common = backend ? backend->u.null.data : NULL; 375 376 if (common && common->has_logfile) { 377 int flags = O_WRONLY | O_CREAT; 378 if (common->has_logappend && 379 common->logappend) { 380 flags |= O_APPEND; 381 } else { 382 flags |= O_TRUNC; 383 } 384 chr->logfd = qemu_open(common->logfile, flags, 0666); 385 if (chr->logfd < 0) { 386 error_setg_errno(errp, errno, 387 "Unable to open logfile %s", 388 common->logfile); 389 return; 390 } 391 } 392 393 if (cc->open) { 394 cc->open(chr, backend, be_opened, errp); 395 } 396 } 397 398 static void char_init(Object *obj) 399 { 400 Chardev *chr = CHARDEV(obj); 401 402 chr->logfd = -1; 403 qemu_mutex_init(&chr->chr_write_lock); 404 } 405 406 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len) 407 { 408 return len; 409 } 410 411 static void char_class_init(ObjectClass *oc, void *data) 412 { 413 ChardevClass *cc = CHARDEV_CLASS(oc); 414 415 cc->chr_write = null_chr_write; 416 } 417 418 static void char_finalize(Object *obj) 419 { 420 Chardev *chr = CHARDEV(obj); 421 422 if (chr->be) { 423 chr->be->chr = NULL; 424 } 425 g_free(chr->filename); 426 g_free(chr->label); 427 if (chr->logfd != -1) { 428 close(chr->logfd); 429 } 430 qemu_mutex_destroy(&chr->chr_write_lock); 431 } 432 433 static const TypeInfo char_type_info = { 434 .name = TYPE_CHARDEV, 435 .parent = TYPE_OBJECT, 436 .instance_size = sizeof(Chardev), 437 .instance_init = char_init, 438 .instance_finalize = char_finalize, 439 .abstract = true, 440 .class_size = sizeof(ChardevClass), 441 .class_init = char_class_init, 442 }; 443 444 /** 445 * Called after processing of default and command-line-specified 446 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached 447 * to a mux chardev. This is done here to ensure that 448 * output/prompts/banners are only displayed for the FE that has 449 * focus when initial command-line processing/machine init is 450 * completed. 451 * 452 * After this point, any new FE attached to any new or existing 453 * mux will receive CHR_EVENT_OPENED notifications for the BE 454 * immediately. 455 */ 456 static void muxes_realize_done(Notifier *notifier, void *unused) 457 { 458 Chardev *chr; 459 460 QTAILQ_FOREACH(chr, &chardevs, next) { 461 if (CHARDEV_IS_MUX(chr)) { 462 MuxChardev *d = MUX_CHARDEV(chr); 463 int i; 464 465 /* send OPENED to all already-attached FEs */ 466 for (i = 0; i < d->mux_cnt; i++) { 467 mux_chr_send_event(d, i, CHR_EVENT_OPENED); 468 } 469 /* mark mux as OPENED so any new FEs will immediately receive 470 * OPENED event 471 */ 472 qemu_chr_be_generic_open(chr); 473 } 474 } 475 muxes_realized = true; 476 } 477 478 static Notifier muxes_realize_notify = { 479 .notify = muxes_realize_done, 480 }; 481 482 Chardev *qemu_chr_fe_get_driver(CharBackend *be) 483 { 484 return be->chr; 485 } 486 487 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp) 488 { 489 int tag = 0; 490 491 if (CHARDEV_IS_MUX(s)) { 492 MuxChardev *d = MUX_CHARDEV(s); 493 494 if (d->mux_cnt >= MAX_MUX) { 495 goto unavailable; 496 } 497 498 d->backends[d->mux_cnt] = b; 499 tag = d->mux_cnt++; 500 } else if (s->be) { 501 goto unavailable; 502 } else { 503 s->be = b; 504 } 505 506 b->fe_open = false; 507 b->tag = tag; 508 b->chr = s; 509 return true; 510 511 unavailable: 512 error_setg(errp, QERR_DEVICE_IN_USE, s->label); 513 return false; 514 } 515 516 static bool qemu_chr_is_busy(Chardev *s) 517 { 518 if (CHARDEV_IS_MUX(s)) { 519 MuxChardev *d = MUX_CHARDEV(s); 520 return d->mux_cnt >= 0; 521 } else { 522 return s->be != NULL; 523 } 524 } 525 526 void qemu_chr_fe_deinit(CharBackend *b) 527 { 528 assert(b); 529 530 if (b->chr) { 531 qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true); 532 if (b->chr->be == b) { 533 b->chr->be = NULL; 534 } 535 if (CHARDEV_IS_MUX(b->chr)) { 536 MuxChardev *d = MUX_CHARDEV(b->chr); 537 d->backends[b->tag] = NULL; 538 } 539 b->chr = NULL; 540 } 541 } 542 543 void qemu_chr_fe_set_handlers(CharBackend *b, 544 IOCanReadHandler *fd_can_read, 545 IOReadHandler *fd_read, 546 IOEventHandler *fd_event, 547 void *opaque, 548 GMainContext *context, 549 bool set_open) 550 { 551 Chardev *s; 552 ChardevClass *cc; 553 int fe_open; 554 555 s = b->chr; 556 if (!s) { 557 return; 558 } 559 560 cc = CHARDEV_GET_CLASS(s); 561 if (!opaque && !fd_can_read && !fd_read && !fd_event) { 562 fe_open = 0; 563 remove_fd_in_watch(s, context); 564 } else { 565 fe_open = 1; 566 } 567 b->chr_can_read = fd_can_read; 568 b->chr_read = fd_read; 569 b->chr_event = fd_event; 570 b->opaque = opaque; 571 if (cc->chr_update_read_handler) { 572 cc->chr_update_read_handler(s, context); 573 } 574 575 if (set_open) { 576 qemu_chr_fe_set_open(b, fe_open); 577 } 578 579 if (fe_open) { 580 qemu_chr_fe_take_focus(b); 581 /* We're connecting to an already opened device, so let's make sure we 582 also get the open event */ 583 if (s->be_open) { 584 qemu_chr_be_generic_open(s); 585 } 586 } 587 588 if (CHARDEV_IS_MUX(s)) { 589 mux_chr_set_handlers(s, context); 590 } 591 } 592 593 void qemu_chr_fe_take_focus(CharBackend *b) 594 { 595 if (!b->chr) { 596 return; 597 } 598 599 if (CHARDEV_IS_MUX(b->chr)) { 600 mux_set_focus(b->chr, b->tag); 601 } 602 } 603 604 int qemu_chr_wait_connected(Chardev *chr, Error **errp) 605 { 606 ChardevClass *cc = CHARDEV_GET_CLASS(chr); 607 608 if (cc->chr_wait_connected) { 609 return cc->chr_wait_connected(chr, errp); 610 } 611 612 return 0; 613 } 614 615 int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp) 616 { 617 if (!be->chr) { 618 error_setg(errp, "missing associated backend"); 619 return -1; 620 } 621 622 return qemu_chr_wait_connected(be->chr, errp); 623 } 624 625 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename) 626 { 627 char host[65], port[33], width[8], height[8]; 628 int pos; 629 const char *p; 630 QemuOpts *opts; 631 Error *local_err = NULL; 632 633 opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err); 634 if (local_err) { 635 error_report_err(local_err); 636 return NULL; 637 } 638 639 if (strstart(filename, "mon:", &p)) { 640 filename = p; 641 qemu_opt_set(opts, "mux", "on", &error_abort); 642 if (strcmp(filename, "stdio") == 0) { 643 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default 644 * but pass it to the guest. Handle this only for compat syntax, 645 * for -chardev syntax we have special option for this. 646 * This is what -nographic did, redirecting+muxing serial+monitor 647 * to stdio causing Ctrl+C to be passed to guest. */ 648 qemu_opt_set(opts, "signal", "off", &error_abort); 649 } 650 } 651 652 if (strcmp(filename, "null") == 0 || 653 strcmp(filename, "pty") == 0 || 654 strcmp(filename, "msmouse") == 0 || 655 strcmp(filename, "wctablet") == 0 || 656 strcmp(filename, "braille") == 0 || 657 strcmp(filename, "testdev") == 0 || 658 strcmp(filename, "stdio") == 0) { 659 qemu_opt_set(opts, "backend", filename, &error_abort); 660 return opts; 661 } 662 if (strstart(filename, "vc", &p)) { 663 qemu_opt_set(opts, "backend", "vc", &error_abort); 664 if (*p == ':') { 665 if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) { 666 /* pixels */ 667 qemu_opt_set(opts, "width", width, &error_abort); 668 qemu_opt_set(opts, "height", height, &error_abort); 669 } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) { 670 /* chars */ 671 qemu_opt_set(opts, "cols", width, &error_abort); 672 qemu_opt_set(opts, "rows", height, &error_abort); 673 } else { 674 goto fail; 675 } 676 } 677 return opts; 678 } 679 if (strcmp(filename, "con:") == 0) { 680 qemu_opt_set(opts, "backend", "console", &error_abort); 681 return opts; 682 } 683 if (strstart(filename, "COM", NULL)) { 684 qemu_opt_set(opts, "backend", "serial", &error_abort); 685 qemu_opt_set(opts, "path", filename, &error_abort); 686 return opts; 687 } 688 if (strstart(filename, "file:", &p)) { 689 qemu_opt_set(opts, "backend", "file", &error_abort); 690 qemu_opt_set(opts, "path", p, &error_abort); 691 return opts; 692 } 693 if (strstart(filename, "pipe:", &p)) { 694 qemu_opt_set(opts, "backend", "pipe", &error_abort); 695 qemu_opt_set(opts, "path", p, &error_abort); 696 return opts; 697 } 698 if (strstart(filename, "tcp:", &p) || 699 strstart(filename, "telnet:", &p)) { 700 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { 701 host[0] = 0; 702 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) 703 goto fail; 704 } 705 qemu_opt_set(opts, "backend", "socket", &error_abort); 706 qemu_opt_set(opts, "host", host, &error_abort); 707 qemu_opt_set(opts, "port", port, &error_abort); 708 if (p[pos] == ',') { 709 qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err); 710 if (local_err) { 711 error_report_err(local_err); 712 goto fail; 713 } 714 } 715 if (strstart(filename, "telnet:", &p)) 716 qemu_opt_set(opts, "telnet", "on", &error_abort); 717 return opts; 718 } 719 if (strstart(filename, "udp:", &p)) { 720 qemu_opt_set(opts, "backend", "udp", &error_abort); 721 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) { 722 host[0] = 0; 723 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) { 724 goto fail; 725 } 726 } 727 qemu_opt_set(opts, "host", host, &error_abort); 728 qemu_opt_set(opts, "port", port, &error_abort); 729 if (p[pos] == '@') { 730 p += pos + 1; 731 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { 732 host[0] = 0; 733 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) { 734 goto fail; 735 } 736 } 737 qemu_opt_set(opts, "localaddr", host, &error_abort); 738 qemu_opt_set(opts, "localport", port, &error_abort); 739 } 740 return opts; 741 } 742 if (strstart(filename, "unix:", &p)) { 743 qemu_opt_set(opts, "backend", "socket", &error_abort); 744 qemu_opts_do_parse(opts, p, "path", &local_err); 745 if (local_err) { 746 error_report_err(local_err); 747 goto fail; 748 } 749 return opts; 750 } 751 if (strstart(filename, "/dev/parport", NULL) || 752 strstart(filename, "/dev/ppi", NULL)) { 753 qemu_opt_set(opts, "backend", "parport", &error_abort); 754 qemu_opt_set(opts, "path", filename, &error_abort); 755 return opts; 756 } 757 if (strstart(filename, "/dev/", NULL)) { 758 qemu_opt_set(opts, "backend", "tty", &error_abort); 759 qemu_opt_set(opts, "path", filename, &error_abort); 760 return opts; 761 } 762 763 fail: 764 qemu_opts_del(opts); 765 return NULL; 766 } 767 768 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend) 769 { 770 const char *logfile = qemu_opt_get(opts, "logfile"); 771 772 backend->has_logfile = logfile != NULL; 773 backend->logfile = logfile ? g_strdup(logfile) : NULL; 774 775 backend->has_logappend = true; 776 backend->logappend = qemu_opt_get_bool(opts, "logappend", false); 777 } 778 779 static const ChardevClass *char_get_class(const char *driver, Error **errp) 780 { 781 ObjectClass *oc; 782 const ChardevClass *cc; 783 char *typename = g_strdup_printf("chardev-%s", driver); 784 785 oc = object_class_by_name(typename); 786 g_free(typename); 787 788 if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) { 789 error_setg(errp, "'%s' is not a valid char driver name", driver); 790 return NULL; 791 } 792 793 if (object_class_is_abstract(oc)) { 794 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", 795 "abstract device type"); 796 return NULL; 797 } 798 799 cc = CHARDEV_CLASS(oc); 800 if (cc->internal) { 801 error_setg(errp, "'%s' is not a valid char driver name", driver); 802 return NULL; 803 } 804 805 return cc; 806 } 807 808 static Chardev *qemu_chardev_add(const char *id, const char *typename, 809 ChardevBackend *backend, Error **errp) 810 { 811 Chardev *chr; 812 813 chr = qemu_chr_find(id); 814 if (chr) { 815 error_setg(errp, "Chardev '%s' already exists", id); 816 return NULL; 817 } 818 819 chr = qemu_chardev_new(id, typename, backend, errp); 820 if (!chr) { 821 return NULL; 822 } 823 824 QTAILQ_INSERT_TAIL(&chardevs, chr, next); 825 return chr; 826 } 827 828 static const struct ChardevAlias { 829 const char *typename; 830 const char *alias; 831 } chardev_alias_table[] = { 832 #ifdef HAVE_CHARDEV_PARPORT 833 { "parallel", "parport" }, 834 #endif 835 #ifdef HAVE_CHARDEV_SERIAL 836 { "serial", "tty" }, 837 #endif 838 }; 839 840 typedef struct ChadevClassFE { 841 void (*fn)(const char *name, void *opaque); 842 void *opaque; 843 } ChadevClassFE; 844 845 static void 846 chardev_class_foreach(ObjectClass *klass, void *opaque) 847 { 848 ChadevClassFE *fe = opaque; 849 850 assert(g_str_has_prefix(object_class_get_name(klass), "chardev-")); 851 if (CHARDEV_CLASS(klass)->internal) { 852 return; 853 } 854 855 fe->fn(object_class_get_name(klass) + 8, fe->opaque); 856 } 857 858 static void 859 chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque) 860 { 861 ChadevClassFE fe = { .fn = fn, .opaque = opaque }; 862 int i; 863 864 object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe); 865 866 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) { 867 fn(chardev_alias_table[i].alias, opaque); 868 } 869 } 870 871 static void 872 help_string_append(const char *name, void *opaque) 873 { 874 GString *str = opaque; 875 876 g_string_append_printf(str, "\n%s", name); 877 } 878 879 Chardev *qemu_chr_new_from_opts(QemuOpts *opts, 880 Error **errp) 881 { 882 Error *local_err = NULL; 883 const ChardevClass *cc; 884 Chardev *chr; 885 int i; 886 ChardevBackend *backend = NULL; 887 const char *name = qemu_opt_get(opts, "backend"); 888 const char *id = qemu_opts_id(opts); 889 char *bid = NULL; 890 891 if (name == NULL) { 892 error_setg(errp, "chardev: \"%s\" missing backend", 893 qemu_opts_id(opts)); 894 return NULL; 895 } 896 897 if (is_help_option(name)) { 898 GString *str = g_string_new(""); 899 900 chardev_name_foreach(help_string_append, str); 901 902 error_report("Available chardev backend types: %s", str->str); 903 g_string_free(str, true); 904 exit(0); 905 } 906 907 if (id == NULL) { 908 error_setg(errp, "chardev: no id specified"); 909 return NULL; 910 } 911 912 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) { 913 if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) { 914 name = chardev_alias_table[i].typename; 915 break; 916 } 917 } 918 919 cc = char_get_class(name, errp); 920 if (cc == NULL) { 921 return NULL; 922 } 923 924 backend = g_new0(ChardevBackend, 1); 925 backend->type = CHARDEV_BACKEND_KIND_NULL; 926 927 if (qemu_opt_get_bool(opts, "mux", 0)) { 928 bid = g_strdup_printf("%s-base", id); 929 } 930 931 chr = NULL; 932 if (cc->parse) { 933 cc->parse(opts, backend, &local_err); 934 if (local_err) { 935 error_propagate(errp, local_err); 936 goto out; 937 } 938 } else { 939 ChardevCommon *ccom = g_new0(ChardevCommon, 1); 940 qemu_chr_parse_common(opts, ccom); 941 backend->u.null.data = ccom; /* Any ChardevCommon member would work */ 942 } 943 944 chr = qemu_chardev_add(bid ? bid : id, 945 object_class_get_name(OBJECT_CLASS(cc)), 946 backend, errp); 947 if (chr == NULL) { 948 goto out; 949 } 950 951 if (bid) { 952 Chardev *mux; 953 qapi_free_ChardevBackend(backend); 954 backend = g_new0(ChardevBackend, 1); 955 backend->type = CHARDEV_BACKEND_KIND_MUX; 956 backend->u.mux.data = g_new0(ChardevMux, 1); 957 backend->u.mux.data->chardev = g_strdup(bid); 958 mux = qemu_chardev_add(id, TYPE_CHARDEV_MUX, backend, errp); 959 if (mux == NULL) { 960 qemu_chr_delete(chr); 961 chr = NULL; 962 goto out; 963 } 964 chr = mux; 965 } 966 967 out: 968 qapi_free_ChardevBackend(backend); 969 g_free(bid); 970 return chr; 971 } 972 973 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename) 974 { 975 const char *p; 976 Chardev *chr; 977 QemuOpts *opts; 978 Error *err = NULL; 979 980 if (strstart(filename, "chardev:", &p)) { 981 return qemu_chr_find(p); 982 } 983 984 opts = qemu_chr_parse_compat(label, filename); 985 if (!opts) 986 return NULL; 987 988 chr = qemu_chr_new_from_opts(opts, &err); 989 if (err) { 990 error_report_err(err); 991 } 992 if (chr && qemu_opt_get_bool(opts, "mux", 0)) { 993 monitor_init(chr, MONITOR_USE_READLINE); 994 } 995 qemu_opts_del(opts); 996 return chr; 997 } 998 999 Chardev *qemu_chr_new(const char *label, const char *filename) 1000 { 1001 Chardev *chr; 1002 chr = qemu_chr_new_noreplay(label, filename); 1003 if (chr) { 1004 if (replay_mode != REPLAY_MODE_NONE) { 1005 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY); 1006 } 1007 if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) { 1008 error_report("Replay: ioctl is not supported " 1009 "for serial devices yet"); 1010 } 1011 replay_register_char_driver(chr); 1012 } 1013 return chr; 1014 } 1015 1016 void qemu_chr_fe_set_echo(CharBackend *be, bool echo) 1017 { 1018 Chardev *chr = be->chr; 1019 1020 if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) { 1021 CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo); 1022 } 1023 } 1024 1025 void qemu_chr_fe_set_open(CharBackend *be, int fe_open) 1026 { 1027 Chardev *chr = be->chr; 1028 1029 if (!chr) { 1030 return; 1031 } 1032 1033 if (be->fe_open == fe_open) { 1034 return; 1035 } 1036 be->fe_open = fe_open; 1037 if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) { 1038 CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open); 1039 } 1040 } 1041 1042 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond, 1043 GIOFunc func, void *user_data) 1044 { 1045 Chardev *s = be->chr; 1046 GSource *src; 1047 guint tag; 1048 1049 if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) { 1050 return 0; 1051 } 1052 1053 src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond); 1054 if (!src) { 1055 return 0; 1056 } 1057 1058 g_source_set_callback(src, (GSourceFunc)func, user_data, NULL); 1059 tag = g_source_attach(src, NULL); 1060 g_source_unref(src); 1061 1062 return tag; 1063 } 1064 1065 void qemu_chr_fe_disconnect(CharBackend *be) 1066 { 1067 Chardev *chr = be->chr; 1068 1069 if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) { 1070 CHARDEV_GET_CLASS(chr)->chr_disconnect(chr); 1071 } 1072 } 1073 1074 void qemu_chr_delete(Chardev *chr) 1075 { 1076 QTAILQ_REMOVE(&chardevs, chr, next); 1077 object_unref(OBJECT(chr)); 1078 } 1079 1080 ChardevInfoList *qmp_query_chardev(Error **errp) 1081 { 1082 ChardevInfoList *chr_list = NULL; 1083 Chardev *chr; 1084 1085 QTAILQ_FOREACH(chr, &chardevs, next) { 1086 ChardevInfoList *info = g_malloc0(sizeof(*info)); 1087 info->value = g_malloc0(sizeof(*info->value)); 1088 info->value->label = g_strdup(chr->label); 1089 info->value->filename = g_strdup(chr->filename); 1090 info->value->frontend_open = chr->be && chr->be->fe_open; 1091 1092 info->next = chr_list; 1093 chr_list = info; 1094 } 1095 1096 return chr_list; 1097 } 1098 1099 static void 1100 qmp_prepend_backend(const char *name, void *opaque) 1101 { 1102 ChardevBackendInfoList **list = opaque; 1103 ChardevBackendInfoList *info = g_malloc0(sizeof(*info)); 1104 1105 info->value = g_malloc0(sizeof(*info->value)); 1106 info->value->name = g_strdup(name); 1107 info->next = *list; 1108 *list = info; 1109 } 1110 1111 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp) 1112 { 1113 ChardevBackendInfoList *backend_list = NULL; 1114 1115 chardev_name_foreach(qmp_prepend_backend, &backend_list); 1116 1117 return backend_list; 1118 } 1119 1120 Chardev *qemu_chr_find(const char *name) 1121 { 1122 Chardev *chr; 1123 1124 QTAILQ_FOREACH(chr, &chardevs, next) { 1125 if (strcmp(chr->label, name) != 0) 1126 continue; 1127 return chr; 1128 } 1129 return NULL; 1130 } 1131 1132 QemuOptsList qemu_chardev_opts = { 1133 .name = "chardev", 1134 .implied_opt_name = "backend", 1135 .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), 1136 .desc = { 1137 { 1138 .name = "backend", 1139 .type = QEMU_OPT_STRING, 1140 },{ 1141 .name = "path", 1142 .type = QEMU_OPT_STRING, 1143 },{ 1144 .name = "host", 1145 .type = QEMU_OPT_STRING, 1146 },{ 1147 .name = "port", 1148 .type = QEMU_OPT_STRING, 1149 },{ 1150 .name = "localaddr", 1151 .type = QEMU_OPT_STRING, 1152 },{ 1153 .name = "localport", 1154 .type = QEMU_OPT_STRING, 1155 },{ 1156 .name = "to", 1157 .type = QEMU_OPT_NUMBER, 1158 },{ 1159 .name = "ipv4", 1160 .type = QEMU_OPT_BOOL, 1161 },{ 1162 .name = "ipv6", 1163 .type = QEMU_OPT_BOOL, 1164 },{ 1165 .name = "wait", 1166 .type = QEMU_OPT_BOOL, 1167 },{ 1168 .name = "server", 1169 .type = QEMU_OPT_BOOL, 1170 },{ 1171 .name = "delay", 1172 .type = QEMU_OPT_BOOL, 1173 },{ 1174 .name = "reconnect", 1175 .type = QEMU_OPT_NUMBER, 1176 },{ 1177 .name = "telnet", 1178 .type = QEMU_OPT_BOOL, 1179 },{ 1180 .name = "tls-creds", 1181 .type = QEMU_OPT_STRING, 1182 },{ 1183 .name = "width", 1184 .type = QEMU_OPT_NUMBER, 1185 },{ 1186 .name = "height", 1187 .type = QEMU_OPT_NUMBER, 1188 },{ 1189 .name = "cols", 1190 .type = QEMU_OPT_NUMBER, 1191 },{ 1192 .name = "rows", 1193 .type = QEMU_OPT_NUMBER, 1194 },{ 1195 .name = "mux", 1196 .type = QEMU_OPT_BOOL, 1197 },{ 1198 .name = "signal", 1199 .type = QEMU_OPT_BOOL, 1200 },{ 1201 .name = "name", 1202 .type = QEMU_OPT_STRING, 1203 },{ 1204 .name = "debug", 1205 .type = QEMU_OPT_NUMBER, 1206 },{ 1207 .name = "size", 1208 .type = QEMU_OPT_SIZE, 1209 },{ 1210 .name = "chardev", 1211 .type = QEMU_OPT_STRING, 1212 },{ 1213 .name = "append", 1214 .type = QEMU_OPT_BOOL, 1215 },{ 1216 .name = "logfile", 1217 .type = QEMU_OPT_STRING, 1218 },{ 1219 .name = "logappend", 1220 .type = QEMU_OPT_BOOL, 1221 }, 1222 { /* end of list */ } 1223 }, 1224 }; 1225 1226 bool qemu_chr_has_feature(Chardev *chr, 1227 ChardevFeature feature) 1228 { 1229 return test_bit(feature, chr->features); 1230 } 1231 1232 void qemu_chr_set_feature(Chardev *chr, 1233 ChardevFeature feature) 1234 { 1235 return set_bit(feature, chr->features); 1236 } 1237 1238 Chardev *qemu_chardev_new(const char *id, const char *typename, 1239 ChardevBackend *backend, Error **errp) 1240 { 1241 Chardev *chr = NULL; 1242 Error *local_err = NULL; 1243 bool be_opened = true; 1244 1245 assert(g_str_has_prefix(typename, "chardev-")); 1246 1247 chr = CHARDEV(object_new(typename)); 1248 chr->label = g_strdup(id); 1249 1250 qemu_char_open(chr, backend, &be_opened, &local_err); 1251 if (local_err) { 1252 error_propagate(errp, local_err); 1253 object_unref(OBJECT(chr)); 1254 return NULL; 1255 } 1256 1257 if (!chr->filename) { 1258 chr->filename = g_strdup(typename + 8); 1259 } 1260 if (be_opened) { 1261 qemu_chr_be_event(chr, CHR_EVENT_OPENED); 1262 } 1263 1264 return chr; 1265 } 1266 1267 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, 1268 Error **errp) 1269 { 1270 const ChardevClass *cc; 1271 ChardevReturn *ret; 1272 Chardev *chr; 1273 1274 cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp); 1275 if (!cc) { 1276 return NULL; 1277 } 1278 1279 chr = qemu_chardev_add(id, object_class_get_name(OBJECT_CLASS(cc)), 1280 backend, errp); 1281 if (!chr) { 1282 return NULL; 1283 } 1284 1285 ret = g_new0(ChardevReturn, 1); 1286 if (CHARDEV_IS_PTY(chr)) { 1287 ret->pty = g_strdup(chr->filename + 4); 1288 ret->has_pty = true; 1289 } 1290 1291 return ret; 1292 } 1293 1294 void qmp_chardev_remove(const char *id, Error **errp) 1295 { 1296 Chardev *chr; 1297 1298 chr = qemu_chr_find(id); 1299 if (chr == NULL) { 1300 error_setg(errp, "Chardev '%s' not found", id); 1301 return; 1302 } 1303 if (qemu_chr_is_busy(chr)) { 1304 error_setg(errp, "Chardev '%s' is busy", id); 1305 return; 1306 } 1307 if (qemu_chr_replay(chr)) { 1308 error_setg(errp, 1309 "Chardev '%s' cannot be unplugged in record/replay mode", id); 1310 return; 1311 } 1312 qemu_chr_delete(chr); 1313 } 1314 1315 void qemu_chr_cleanup(void) 1316 { 1317 Chardev *chr, *tmp; 1318 1319 QTAILQ_FOREACH_SAFE(chr, &chardevs, next, tmp) { 1320 qemu_chr_delete(chr); 1321 } 1322 } 1323 1324 static void register_types(void) 1325 { 1326 type_register_static(&char_type_info); 1327 1328 /* this must be done after machine init, since we register FEs with muxes 1329 * as part of realize functions like serial_isa_realizefn when -nographic 1330 * is specified 1331 */ 1332 qemu_add_machine_init_done_notifier(&muxes_realize_notify); 1333 } 1334 1335 type_init(register_types); 1336