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 "sysemu/block-backend.h" 30 #include "qemu/error-report.h" 31 #include "qemu/timer.h" 32 #include "sysemu/char.h" 33 #include "hw/usb.h" 34 #include "qmp-commands.h" 35 #include "qapi/clone-visitor.h" 36 #include "qapi-visit.h" 37 #include "qemu/base64.h" 38 #include "io/channel-socket.h" 39 #include "io/channel-file.h" 40 #include "io/channel-tls.h" 41 #include "sysemu/replay.h" 42 #include "qemu/help_option.h" 43 44 #include <zlib.h> 45 46 #ifndef _WIN32 47 #include <sys/times.h> 48 #include <sys/wait.h> 49 #include <termios.h> 50 #include <sys/ioctl.h> 51 #include <sys/resource.h> 52 #include <sys/socket.h> 53 #include <netinet/in.h> 54 #include <net/if.h> 55 #include <arpa/inet.h> 56 #include <netdb.h> 57 #include <sys/select.h> 58 #ifdef CONFIG_BSD 59 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 60 #include <dev/ppbus/ppi.h> 61 #include <dev/ppbus/ppbconf.h> 62 #elif defined(__DragonFly__) 63 #include <dev/misc/ppi/ppi.h> 64 #include <bus/ppbus/ppbconf.h> 65 #endif 66 #else 67 #ifdef __linux__ 68 #include <linux/ppdev.h> 69 #include <linux/parport.h> 70 #endif 71 #ifdef __sun__ 72 #include <sys/ethernet.h> 73 #include <sys/sockio.h> 74 #include <netinet/arp.h> 75 #include <netinet/in.h> 76 #include <netinet/in_systm.h> 77 #include <netinet/ip.h> 78 #include <netinet/ip_icmp.h> // must come after ip.h 79 #include <netinet/udp.h> 80 #include <netinet/tcp.h> 81 #endif 82 #endif 83 #endif 84 85 #include "qemu/sockets.h" 86 #include "ui/qemu-spice.h" 87 88 #include "char-mux.h" 89 #include "char-fd.h" 90 #include "char-io.h" 91 #ifdef _WIN32 92 #include "char-win.h" 93 #include "char-win-stdio.h" 94 #endif 95 96 /***********************************************************/ 97 /* character device */ 98 99 static QTAILQ_HEAD(ChardevHead, Chardev) chardevs = 100 QTAILQ_HEAD_INITIALIZER(chardevs); 101 102 void qemu_chr_be_event(Chardev *s, int event) 103 { 104 CharBackend *be = s->be; 105 106 /* Keep track if the char device is open */ 107 switch (event) { 108 case CHR_EVENT_OPENED: 109 s->be_open = 1; 110 break; 111 case CHR_EVENT_CLOSED: 112 s->be_open = 0; 113 break; 114 } 115 116 if (!be || !be->chr_event) { 117 return; 118 } 119 120 be->chr_event(be->opaque, event); 121 } 122 123 void qemu_chr_be_generic_open(Chardev *s) 124 { 125 qemu_chr_be_event(s, CHR_EVENT_OPENED); 126 } 127 128 129 /* Not reporting errors from writing to logfile, as logs are 130 * defined to be "best effort" only */ 131 static void qemu_chr_fe_write_log(Chardev *s, 132 const uint8_t *buf, size_t len) 133 { 134 size_t done = 0; 135 ssize_t ret; 136 137 if (s->logfd < 0) { 138 return; 139 } 140 141 while (done < len) { 142 retry: 143 ret = write(s->logfd, buf + done, len - done); 144 if (ret == -1 && errno == EAGAIN) { 145 g_usleep(100); 146 goto retry; 147 } 148 149 if (ret <= 0) { 150 return; 151 } 152 done += ret; 153 } 154 } 155 156 static int qemu_chr_fe_write_buffer(Chardev *s, 157 const uint8_t *buf, int len, int *offset) 158 { 159 ChardevClass *cc = CHARDEV_GET_CLASS(s); 160 int res = 0; 161 *offset = 0; 162 163 qemu_mutex_lock(&s->chr_write_lock); 164 while (*offset < len) { 165 retry: 166 res = cc->chr_write(s, buf + *offset, len - *offset); 167 if (res < 0 && errno == EAGAIN) { 168 g_usleep(100); 169 goto retry; 170 } 171 172 if (res <= 0) { 173 break; 174 } 175 176 *offset += res; 177 } 178 if (*offset > 0) { 179 qemu_chr_fe_write_log(s, buf, *offset); 180 } 181 qemu_mutex_unlock(&s->chr_write_lock); 182 183 return res; 184 } 185 186 static bool qemu_chr_replay(Chardev *chr) 187 { 188 return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY); 189 } 190 191 int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len) 192 { 193 Chardev *s = be->chr; 194 ChardevClass *cc; 195 int ret; 196 197 if (!s) { 198 return 0; 199 } 200 201 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 202 int offset; 203 replay_char_write_event_load(&ret, &offset); 204 assert(offset <= len); 205 qemu_chr_fe_write_buffer(s, buf, offset, &offset); 206 return ret; 207 } 208 209 cc = CHARDEV_GET_CLASS(s); 210 qemu_mutex_lock(&s->chr_write_lock); 211 ret = cc->chr_write(s, buf, len); 212 213 if (ret > 0) { 214 qemu_chr_fe_write_log(s, buf, ret); 215 } 216 217 qemu_mutex_unlock(&s->chr_write_lock); 218 219 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 220 replay_char_write_event_save(ret, ret < 0 ? 0 : ret); 221 } 222 223 return ret; 224 } 225 226 int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len) 227 { 228 int offset; 229 int res; 230 231 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 232 replay_char_write_event_load(&res, &offset); 233 assert(offset <= len); 234 qemu_chr_fe_write_buffer(s, buf, offset, &offset); 235 return res; 236 } 237 238 res = qemu_chr_fe_write_buffer(s, buf, len, &offset); 239 240 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 241 replay_char_write_event_save(res, offset); 242 } 243 244 if (res < 0) { 245 return res; 246 } 247 return offset; 248 } 249 250 int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len) 251 { 252 Chardev *s = be->chr; 253 254 if (!s) { 255 return 0; 256 } 257 258 return qemu_chr_write_all(s, buf, len); 259 } 260 261 int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len) 262 { 263 Chardev *s = be->chr; 264 int offset = 0, counter = 10; 265 int res; 266 267 if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) { 268 return 0; 269 } 270 271 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) { 272 return replay_char_read_all_load(buf); 273 } 274 275 while (offset < len) { 276 retry: 277 res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset, 278 len - offset); 279 if (res == -1 && errno == EAGAIN) { 280 g_usleep(100); 281 goto retry; 282 } 283 284 if (res == 0) { 285 break; 286 } 287 288 if (res < 0) { 289 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 290 replay_char_read_all_save_error(res); 291 } 292 return res; 293 } 294 295 offset += res; 296 297 if (!counter--) { 298 break; 299 } 300 } 301 302 if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) { 303 replay_char_read_all_save_buf(buf, offset); 304 } 305 return offset; 306 } 307 308 int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg) 309 { 310 Chardev *s = be->chr; 311 int res; 312 313 if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) { 314 res = -ENOTSUP; 315 } else { 316 res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg); 317 } 318 319 return res; 320 } 321 322 int qemu_chr_be_can_write(Chardev *s) 323 { 324 CharBackend *be = s->be; 325 326 if (!be || !be->chr_can_read) { 327 return 0; 328 } 329 330 return be->chr_can_read(be->opaque); 331 } 332 333 void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len) 334 { 335 CharBackend *be = s->be; 336 337 if (be && be->chr_read) { 338 be->chr_read(be->opaque, buf, len); 339 } 340 } 341 342 void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len) 343 { 344 if (qemu_chr_replay(s)) { 345 if (replay_mode == REPLAY_MODE_PLAY) { 346 return; 347 } 348 replay_chr_be_write(s, buf, len); 349 } else { 350 qemu_chr_be_write_impl(s, buf, len); 351 } 352 } 353 354 int qemu_chr_fe_get_msgfd(CharBackend *be) 355 { 356 Chardev *s = be->chr; 357 int fd; 358 int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1; 359 if (s && qemu_chr_replay(s)) { 360 error_report("Replay: get msgfd is not supported " 361 "for serial devices yet"); 362 exit(1); 363 } 364 return res; 365 } 366 367 int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len) 368 { 369 Chardev *s = be->chr; 370 371 if (!s) { 372 return -1; 373 } 374 375 return CHARDEV_GET_CLASS(s)->get_msgfds ? 376 CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1; 377 } 378 379 int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num) 380 { 381 Chardev *s = be->chr; 382 383 if (!s) { 384 return -1; 385 } 386 387 return CHARDEV_GET_CLASS(s)->set_msgfds ? 388 CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1; 389 } 390 391 int qemu_chr_add_client(Chardev *s, int fd) 392 { 393 return CHARDEV_GET_CLASS(s)->chr_add_client ? 394 CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1; 395 } 396 397 void qemu_chr_fe_accept_input(CharBackend *be) 398 { 399 Chardev *s = be->chr; 400 401 if (!s) { 402 return; 403 } 404 405 if (CHARDEV_GET_CLASS(s)->chr_accept_input) { 406 CHARDEV_GET_CLASS(s)->chr_accept_input(s); 407 } 408 qemu_notify_event(); 409 } 410 411 void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...) 412 { 413 char buf[CHR_READ_BUF_LEN]; 414 va_list ap; 415 va_start(ap, fmt); 416 vsnprintf(buf, sizeof(buf), fmt, ap); 417 /* XXX this blocks entire thread. Rewrite to use 418 * qemu_chr_fe_write and background I/O callbacks */ 419 qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf)); 420 va_end(ap); 421 } 422 423 static void qemu_char_open(Chardev *chr, ChardevBackend *backend, 424 bool *be_opened, Error **errp) 425 { 426 ChardevClass *cc = CHARDEV_GET_CLASS(chr); 427 /* Any ChardevCommon member would work */ 428 ChardevCommon *common = backend ? backend->u.null.data : NULL; 429 430 if (common && common->has_logfile) { 431 int flags = O_WRONLY | O_CREAT; 432 if (common->has_logappend && 433 common->logappend) { 434 flags |= O_APPEND; 435 } else { 436 flags |= O_TRUNC; 437 } 438 chr->logfd = qemu_open(common->logfile, flags, 0666); 439 if (chr->logfd < 0) { 440 error_setg_errno(errp, errno, 441 "Unable to open logfile %s", 442 common->logfile); 443 return; 444 } 445 } 446 447 if (cc->open) { 448 cc->open(chr, backend, be_opened, errp); 449 } 450 } 451 452 static void char_init(Object *obj) 453 { 454 Chardev *chr = CHARDEV(obj); 455 456 chr->logfd = -1; 457 qemu_mutex_init(&chr->chr_write_lock); 458 } 459 460 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len) 461 { 462 return len; 463 } 464 465 static void char_class_init(ObjectClass *oc, void *data) 466 { 467 ChardevClass *cc = CHARDEV_CLASS(oc); 468 469 cc->chr_write = null_chr_write; 470 } 471 472 static void char_finalize(Object *obj) 473 { 474 Chardev *chr = CHARDEV(obj); 475 476 if (chr->be) { 477 chr->be->chr = NULL; 478 } 479 g_free(chr->filename); 480 g_free(chr->label); 481 if (chr->logfd != -1) { 482 close(chr->logfd); 483 } 484 qemu_mutex_destroy(&chr->chr_write_lock); 485 } 486 487 static const TypeInfo char_type_info = { 488 .name = TYPE_CHARDEV, 489 .parent = TYPE_OBJECT, 490 .instance_size = sizeof(Chardev), 491 .instance_init = char_init, 492 .instance_finalize = char_finalize, 493 .abstract = true, 494 .class_size = sizeof(ChardevClass), 495 .class_init = char_class_init, 496 }; 497 498 /** 499 * Called after processing of default and command-line-specified 500 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached 501 * to a mux chardev. This is done here to ensure that 502 * output/prompts/banners are only displayed for the FE that has 503 * focus when initial command-line processing/machine init is 504 * completed. 505 * 506 * After this point, any new FE attached to any new or existing 507 * mux will receive CHR_EVENT_OPENED notifications for the BE 508 * immediately. 509 */ 510 static void muxes_realize_done(Notifier *notifier, void *unused) 511 { 512 Chardev *chr; 513 514 QTAILQ_FOREACH(chr, &chardevs, next) { 515 if (CHARDEV_IS_MUX(chr)) { 516 MuxChardev *d = MUX_CHARDEV(chr); 517 int i; 518 519 /* send OPENED to all already-attached FEs */ 520 for (i = 0; i < d->mux_cnt; i++) { 521 mux_chr_send_event(d, i, CHR_EVENT_OPENED); 522 } 523 /* mark mux as OPENED so any new FEs will immediately receive 524 * OPENED event 525 */ 526 qemu_chr_be_generic_open(chr); 527 } 528 } 529 muxes_realized = true; 530 } 531 532 static Notifier muxes_realize_notify = { 533 .notify = muxes_realize_done, 534 }; 535 536 Chardev *qemu_chr_fe_get_driver(CharBackend *be) 537 { 538 return be->chr; 539 } 540 541 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp) 542 { 543 int tag = 0; 544 545 if (CHARDEV_IS_MUX(s)) { 546 MuxChardev *d = MUX_CHARDEV(s); 547 548 if (d->mux_cnt >= MAX_MUX) { 549 goto unavailable; 550 } 551 552 d->backends[d->mux_cnt] = b; 553 tag = d->mux_cnt++; 554 } else if (s->be) { 555 goto unavailable; 556 } else { 557 s->be = b; 558 } 559 560 b->fe_open = false; 561 b->tag = tag; 562 b->chr = s; 563 return true; 564 565 unavailable: 566 error_setg(errp, QERR_DEVICE_IN_USE, s->label); 567 return false; 568 } 569 570 static bool qemu_chr_is_busy(Chardev *s) 571 { 572 if (CHARDEV_IS_MUX(s)) { 573 MuxChardev *d = MUX_CHARDEV(s); 574 return d->mux_cnt >= 0; 575 } else { 576 return s->be != NULL; 577 } 578 } 579 580 void qemu_chr_fe_deinit(CharBackend *b) 581 { 582 assert(b); 583 584 if (b->chr) { 585 qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true); 586 if (b->chr->be == b) { 587 b->chr->be = NULL; 588 } 589 if (CHARDEV_IS_MUX(b->chr)) { 590 MuxChardev *d = MUX_CHARDEV(b->chr); 591 d->backends[b->tag] = NULL; 592 } 593 b->chr = NULL; 594 } 595 } 596 597 void qemu_chr_fe_set_handlers(CharBackend *b, 598 IOCanReadHandler *fd_can_read, 599 IOReadHandler *fd_read, 600 IOEventHandler *fd_event, 601 void *opaque, 602 GMainContext *context, 603 bool set_open) 604 { 605 Chardev *s; 606 ChardevClass *cc; 607 int fe_open; 608 609 s = b->chr; 610 if (!s) { 611 return; 612 } 613 614 cc = CHARDEV_GET_CLASS(s); 615 if (!opaque && !fd_can_read && !fd_read && !fd_event) { 616 fe_open = 0; 617 remove_fd_in_watch(s); 618 } else { 619 fe_open = 1; 620 } 621 b->chr_can_read = fd_can_read; 622 b->chr_read = fd_read; 623 b->chr_event = fd_event; 624 b->opaque = opaque; 625 if (cc->chr_update_read_handler) { 626 cc->chr_update_read_handler(s, context); 627 } 628 629 if (set_open) { 630 qemu_chr_fe_set_open(b, fe_open); 631 } 632 633 if (fe_open) { 634 qemu_chr_fe_take_focus(b); 635 /* We're connecting to an already opened device, so let's make sure we 636 also get the open event */ 637 if (s->be_open) { 638 qemu_chr_be_generic_open(s); 639 } 640 } 641 642 if (CHARDEV_IS_MUX(s)) { 643 mux_chr_set_handlers(s, context); 644 } 645 } 646 647 void qemu_chr_fe_take_focus(CharBackend *b) 648 { 649 if (!b->chr) { 650 return; 651 } 652 653 if (CHARDEV_IS_MUX(b->chr)) { 654 mux_set_focus(b->chr, b->tag); 655 } 656 } 657 658 #ifndef _WIN32 659 static void qemu_chr_open_pipe(Chardev *chr, 660 ChardevBackend *backend, 661 bool *be_opened, 662 Error **errp) 663 { 664 ChardevHostdev *opts = backend->u.pipe.data; 665 int fd_in, fd_out; 666 char *filename_in; 667 char *filename_out; 668 const char *filename = opts->device; 669 670 filename_in = g_strdup_printf("%s.in", filename); 671 filename_out = g_strdup_printf("%s.out", filename); 672 TFR(fd_in = qemu_open(filename_in, O_RDWR | O_BINARY)); 673 TFR(fd_out = qemu_open(filename_out, O_RDWR | O_BINARY)); 674 g_free(filename_in); 675 g_free(filename_out); 676 if (fd_in < 0 || fd_out < 0) { 677 if (fd_in >= 0) 678 close(fd_in); 679 if (fd_out >= 0) 680 close(fd_out); 681 TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY)); 682 if (fd_in < 0) { 683 error_setg_file_open(errp, errno, filename); 684 return; 685 } 686 } 687 qemu_chr_open_fd(chr, fd_in, fd_out); 688 } 689 690 /* init terminal so that we can grab keys */ 691 static struct termios oldtty; 692 static int old_fd0_flags; 693 static bool stdio_in_use; 694 static bool stdio_allow_signal; 695 static bool stdio_echo_state; 696 697 static void qemu_chr_set_echo_stdio(Chardev *chr, bool echo); 698 699 static void term_exit(void) 700 { 701 tcsetattr (0, TCSANOW, &oldtty); 702 fcntl(0, F_SETFL, old_fd0_flags); 703 } 704 705 static void term_stdio_handler(int sig) 706 { 707 /* restore echo after resume from suspend. */ 708 qemu_chr_set_echo_stdio(NULL, stdio_echo_state); 709 } 710 711 static void qemu_chr_set_echo_stdio(Chardev *chr, bool echo) 712 { 713 struct termios tty; 714 715 stdio_echo_state = echo; 716 tty = oldtty; 717 if (!echo) { 718 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 719 |INLCR|IGNCR|ICRNL|IXON); 720 tty.c_oflag |= OPOST; 721 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 722 tty.c_cflag &= ~(CSIZE|PARENB); 723 tty.c_cflag |= CS8; 724 tty.c_cc[VMIN] = 1; 725 tty.c_cc[VTIME] = 0; 726 } 727 if (!stdio_allow_signal) 728 tty.c_lflag &= ~ISIG; 729 730 tcsetattr (0, TCSANOW, &tty); 731 } 732 733 static void char_stdio_finalize(Object *obj) 734 { 735 term_exit(); 736 } 737 738 static void qemu_chr_open_stdio(Chardev *chr, 739 ChardevBackend *backend, 740 bool *be_opened, 741 Error **errp) 742 { 743 ChardevStdio *opts = backend->u.stdio.data; 744 struct sigaction act; 745 746 if (is_daemonized()) { 747 error_setg(errp, "cannot use stdio with -daemonize"); 748 return; 749 } 750 751 if (stdio_in_use) { 752 error_setg(errp, "cannot use stdio by multiple character devices"); 753 return; 754 } 755 756 stdio_in_use = true; 757 old_fd0_flags = fcntl(0, F_GETFL); 758 tcgetattr(0, &oldtty); 759 qemu_set_nonblock(0); 760 atexit(term_exit); 761 762 memset(&act, 0, sizeof(act)); 763 act.sa_handler = term_stdio_handler; 764 sigaction(SIGCONT, &act, NULL); 765 766 qemu_chr_open_fd(chr, 0, 1); 767 768 if (opts->has_signal) { 769 stdio_allow_signal = opts->signal; 770 } 771 qemu_chr_set_echo_stdio(chr, false); 772 } 773 774 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \ 775 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \ 776 || defined(__GLIBC__) 777 778 #define HAVE_CHARDEV_SERIAL 1 779 #define HAVE_CHARDEV_PTY 1 780 781 typedef struct { 782 Chardev parent; 783 QIOChannel *ioc; 784 int read_bytes; 785 786 /* Protected by the Chardev chr_write_lock. */ 787 int connected; 788 guint timer_tag; 789 guint open_tag; 790 } PtyChardev; 791 792 #define PTY_CHARDEV(obj) OBJECT_CHECK(PtyChardev, (obj), TYPE_CHARDEV_PTY) 793 794 static void pty_chr_update_read_handler_locked(Chardev *chr); 795 static void pty_chr_state(Chardev *chr, int connected); 796 797 static gboolean pty_chr_timer(gpointer opaque) 798 { 799 struct Chardev *chr = CHARDEV(opaque); 800 PtyChardev *s = PTY_CHARDEV(opaque); 801 802 qemu_mutex_lock(&chr->chr_write_lock); 803 s->timer_tag = 0; 804 s->open_tag = 0; 805 if (!s->connected) { 806 /* Next poll ... */ 807 pty_chr_update_read_handler_locked(chr); 808 } 809 qemu_mutex_unlock(&chr->chr_write_lock); 810 return FALSE; 811 } 812 813 /* Called with chr_write_lock held. */ 814 static void pty_chr_rearm_timer(Chardev *chr, int ms) 815 { 816 PtyChardev *s = PTY_CHARDEV(chr); 817 char *name; 818 819 if (s->timer_tag) { 820 g_source_remove(s->timer_tag); 821 s->timer_tag = 0; 822 } 823 824 if (ms == 1000) { 825 name = g_strdup_printf("pty-timer-secs-%s", chr->label); 826 s->timer_tag = g_timeout_add_seconds(1, pty_chr_timer, chr); 827 } else { 828 name = g_strdup_printf("pty-timer-ms-%s", chr->label); 829 s->timer_tag = g_timeout_add(ms, pty_chr_timer, chr); 830 } 831 g_source_set_name_by_id(s->timer_tag, name); 832 g_free(name); 833 } 834 835 /* Called with chr_write_lock held. */ 836 static void pty_chr_update_read_handler_locked(Chardev *chr) 837 { 838 PtyChardev *s = PTY_CHARDEV(chr); 839 GPollFD pfd; 840 int rc; 841 QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc); 842 843 pfd.fd = fioc->fd; 844 pfd.events = G_IO_OUT; 845 pfd.revents = 0; 846 do { 847 rc = g_poll(&pfd, 1, 0); 848 } while (rc == -1 && errno == EINTR); 849 assert(rc >= 0); 850 851 if (pfd.revents & G_IO_HUP) { 852 pty_chr_state(chr, 0); 853 } else { 854 pty_chr_state(chr, 1); 855 } 856 } 857 858 static void pty_chr_update_read_handler(Chardev *chr, 859 GMainContext *context) 860 { 861 qemu_mutex_lock(&chr->chr_write_lock); 862 pty_chr_update_read_handler_locked(chr); 863 qemu_mutex_unlock(&chr->chr_write_lock); 864 } 865 866 /* Called with chr_write_lock held. */ 867 static int char_pty_chr_write(Chardev *chr, const uint8_t *buf, int len) 868 { 869 PtyChardev *s = PTY_CHARDEV(chr); 870 871 if (!s->connected) { 872 /* guest sends data, check for (re-)connect */ 873 pty_chr_update_read_handler_locked(chr); 874 if (!s->connected) { 875 return 0; 876 } 877 } 878 return io_channel_send(s->ioc, buf, len); 879 } 880 881 static GSource *pty_chr_add_watch(Chardev *chr, GIOCondition cond) 882 { 883 PtyChardev *s = PTY_CHARDEV(chr); 884 if (!s->connected) { 885 return NULL; 886 } 887 return qio_channel_create_watch(s->ioc, cond); 888 } 889 890 static int pty_chr_read_poll(void *opaque) 891 { 892 Chardev *chr = CHARDEV(opaque); 893 PtyChardev *s = PTY_CHARDEV(opaque); 894 895 s->read_bytes = qemu_chr_be_can_write(chr); 896 return s->read_bytes; 897 } 898 899 static gboolean pty_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque) 900 { 901 Chardev *chr = CHARDEV(opaque); 902 PtyChardev *s = PTY_CHARDEV(opaque); 903 gsize len; 904 uint8_t buf[CHR_READ_BUF_LEN]; 905 ssize_t ret; 906 907 len = sizeof(buf); 908 if (len > s->read_bytes) 909 len = s->read_bytes; 910 if (len == 0) { 911 return TRUE; 912 } 913 ret = qio_channel_read(s->ioc, (char *)buf, len, NULL); 914 if (ret <= 0) { 915 pty_chr_state(chr, 0); 916 return FALSE; 917 } else { 918 pty_chr_state(chr, 1); 919 qemu_chr_be_write(chr, buf, ret); 920 } 921 return TRUE; 922 } 923 924 static gboolean qemu_chr_be_generic_open_func(gpointer opaque) 925 { 926 Chardev *chr = CHARDEV(opaque); 927 PtyChardev *s = PTY_CHARDEV(opaque); 928 929 s->open_tag = 0; 930 qemu_chr_be_generic_open(chr); 931 return FALSE; 932 } 933 934 /* Called with chr_write_lock held. */ 935 static void pty_chr_state(Chardev *chr, int connected) 936 { 937 PtyChardev *s = PTY_CHARDEV(chr); 938 939 if (!connected) { 940 if (s->open_tag) { 941 g_source_remove(s->open_tag); 942 s->open_tag = 0; 943 } 944 remove_fd_in_watch(chr); 945 s->connected = 0; 946 /* (re-)connect poll interval for idle guests: once per second. 947 * We check more frequently in case the guests sends data to 948 * the virtual device linked to our pty. */ 949 pty_chr_rearm_timer(chr, 1000); 950 } else { 951 if (s->timer_tag) { 952 g_source_remove(s->timer_tag); 953 s->timer_tag = 0; 954 } 955 if (!s->connected) { 956 g_assert(s->open_tag == 0); 957 s->connected = 1; 958 s->open_tag = g_idle_add(qemu_chr_be_generic_open_func, chr); 959 } 960 if (!chr->fd_in_tag) { 961 chr->fd_in_tag = io_add_watch_poll(chr, s->ioc, 962 pty_chr_read_poll, 963 pty_chr_read, 964 chr, NULL); 965 } 966 } 967 } 968 969 static void char_pty_finalize(Object *obj) 970 { 971 Chardev *chr = CHARDEV(obj); 972 PtyChardev *s = PTY_CHARDEV(obj); 973 974 qemu_mutex_lock(&chr->chr_write_lock); 975 pty_chr_state(chr, 0); 976 object_unref(OBJECT(s->ioc)); 977 if (s->timer_tag) { 978 g_source_remove(s->timer_tag); 979 s->timer_tag = 0; 980 } 981 qemu_mutex_unlock(&chr->chr_write_lock); 982 qemu_chr_be_event(chr, CHR_EVENT_CLOSED); 983 } 984 985 static void char_pty_open(Chardev *chr, 986 ChardevBackend *backend, 987 bool *be_opened, 988 Error **errp) 989 { 990 PtyChardev *s; 991 int master_fd, slave_fd; 992 char pty_name[PATH_MAX]; 993 char *name; 994 995 master_fd = qemu_openpty_raw(&slave_fd, pty_name); 996 if (master_fd < 0) { 997 error_setg_errno(errp, errno, "Failed to create PTY"); 998 return; 999 } 1000 1001 close(slave_fd); 1002 qemu_set_nonblock(master_fd); 1003 1004 chr->filename = g_strdup_printf("pty:%s", pty_name); 1005 error_report("char device redirected to %s (label %s)", 1006 pty_name, chr->label); 1007 1008 s = PTY_CHARDEV(chr); 1009 s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd)); 1010 name = g_strdup_printf("chardev-pty-%s", chr->label); 1011 qio_channel_set_name(QIO_CHANNEL(s->ioc), name); 1012 g_free(name); 1013 s->timer_tag = 0; 1014 *be_opened = false; 1015 } 1016 1017 static void char_pty_class_init(ObjectClass *oc, void *data) 1018 { 1019 ChardevClass *cc = CHARDEV_CLASS(oc); 1020 1021 cc->open = char_pty_open; 1022 cc->chr_write = char_pty_chr_write; 1023 cc->chr_update_read_handler = pty_chr_update_read_handler; 1024 cc->chr_add_watch = pty_chr_add_watch; 1025 } 1026 1027 static const TypeInfo char_pty_type_info = { 1028 .name = TYPE_CHARDEV_PTY, 1029 .parent = TYPE_CHARDEV, 1030 .instance_size = sizeof(PtyChardev), 1031 .instance_finalize = char_pty_finalize, 1032 .class_init = char_pty_class_init, 1033 }; 1034 1035 static void tty_serial_init(int fd, int speed, 1036 int parity, int data_bits, int stop_bits) 1037 { 1038 struct termios tty; 1039 speed_t spd; 1040 1041 #if 0 1042 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n", 1043 speed, parity, data_bits, stop_bits); 1044 #endif 1045 tcgetattr (fd, &tty); 1046 1047 #define check_speed(val) if (speed <= val) { spd = B##val; break; } 1048 speed = speed * 10 / 11; 1049 do { 1050 check_speed(50); 1051 check_speed(75); 1052 check_speed(110); 1053 check_speed(134); 1054 check_speed(150); 1055 check_speed(200); 1056 check_speed(300); 1057 check_speed(600); 1058 check_speed(1200); 1059 check_speed(1800); 1060 check_speed(2400); 1061 check_speed(4800); 1062 check_speed(9600); 1063 check_speed(19200); 1064 check_speed(38400); 1065 /* Non-Posix values follow. They may be unsupported on some systems. */ 1066 check_speed(57600); 1067 check_speed(115200); 1068 #ifdef B230400 1069 check_speed(230400); 1070 #endif 1071 #ifdef B460800 1072 check_speed(460800); 1073 #endif 1074 #ifdef B500000 1075 check_speed(500000); 1076 #endif 1077 #ifdef B576000 1078 check_speed(576000); 1079 #endif 1080 #ifdef B921600 1081 check_speed(921600); 1082 #endif 1083 #ifdef B1000000 1084 check_speed(1000000); 1085 #endif 1086 #ifdef B1152000 1087 check_speed(1152000); 1088 #endif 1089 #ifdef B1500000 1090 check_speed(1500000); 1091 #endif 1092 #ifdef B2000000 1093 check_speed(2000000); 1094 #endif 1095 #ifdef B2500000 1096 check_speed(2500000); 1097 #endif 1098 #ifdef B3000000 1099 check_speed(3000000); 1100 #endif 1101 #ifdef B3500000 1102 check_speed(3500000); 1103 #endif 1104 #ifdef B4000000 1105 check_speed(4000000); 1106 #endif 1107 spd = B115200; 1108 } while (0); 1109 1110 cfsetispeed(&tty, spd); 1111 cfsetospeed(&tty, spd); 1112 1113 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 1114 |INLCR|IGNCR|ICRNL|IXON); 1115 tty.c_oflag |= OPOST; 1116 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG); 1117 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB); 1118 switch(data_bits) { 1119 default: 1120 case 8: 1121 tty.c_cflag |= CS8; 1122 break; 1123 case 7: 1124 tty.c_cflag |= CS7; 1125 break; 1126 case 6: 1127 tty.c_cflag |= CS6; 1128 break; 1129 case 5: 1130 tty.c_cflag |= CS5; 1131 break; 1132 } 1133 switch(parity) { 1134 default: 1135 case 'N': 1136 break; 1137 case 'E': 1138 tty.c_cflag |= PARENB; 1139 break; 1140 case 'O': 1141 tty.c_cflag |= PARENB | PARODD; 1142 break; 1143 } 1144 if (stop_bits == 2) 1145 tty.c_cflag |= CSTOPB; 1146 1147 tcsetattr (fd, TCSANOW, &tty); 1148 } 1149 1150 static int tty_serial_ioctl(Chardev *chr, int cmd, void *arg) 1151 { 1152 FDChardev *s = FD_CHARDEV(chr); 1153 QIOChannelFile *fioc = QIO_CHANNEL_FILE(s->ioc_in); 1154 1155 switch(cmd) { 1156 case CHR_IOCTL_SERIAL_SET_PARAMS: 1157 { 1158 QEMUSerialSetParams *ssp = arg; 1159 tty_serial_init(fioc->fd, 1160 ssp->speed, ssp->parity, 1161 ssp->data_bits, ssp->stop_bits); 1162 } 1163 break; 1164 case CHR_IOCTL_SERIAL_SET_BREAK: 1165 { 1166 int enable = *(int *)arg; 1167 if (enable) { 1168 tcsendbreak(fioc->fd, 1); 1169 } 1170 } 1171 break; 1172 case CHR_IOCTL_SERIAL_GET_TIOCM: 1173 { 1174 int sarg = 0; 1175 int *targ = (int *)arg; 1176 ioctl(fioc->fd, TIOCMGET, &sarg); 1177 *targ = 0; 1178 if (sarg & TIOCM_CTS) 1179 *targ |= CHR_TIOCM_CTS; 1180 if (sarg & TIOCM_CAR) 1181 *targ |= CHR_TIOCM_CAR; 1182 if (sarg & TIOCM_DSR) 1183 *targ |= CHR_TIOCM_DSR; 1184 if (sarg & TIOCM_RI) 1185 *targ |= CHR_TIOCM_RI; 1186 if (sarg & TIOCM_DTR) 1187 *targ |= CHR_TIOCM_DTR; 1188 if (sarg & TIOCM_RTS) 1189 *targ |= CHR_TIOCM_RTS; 1190 } 1191 break; 1192 case CHR_IOCTL_SERIAL_SET_TIOCM: 1193 { 1194 int sarg = *(int *)arg; 1195 int targ = 0; 1196 ioctl(fioc->fd, TIOCMGET, &targ); 1197 targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR 1198 | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS); 1199 if (sarg & CHR_TIOCM_CTS) 1200 targ |= TIOCM_CTS; 1201 if (sarg & CHR_TIOCM_CAR) 1202 targ |= TIOCM_CAR; 1203 if (sarg & CHR_TIOCM_DSR) 1204 targ |= TIOCM_DSR; 1205 if (sarg & CHR_TIOCM_RI) 1206 targ |= TIOCM_RI; 1207 if (sarg & CHR_TIOCM_DTR) 1208 targ |= TIOCM_DTR; 1209 if (sarg & CHR_TIOCM_RTS) 1210 targ |= TIOCM_RTS; 1211 ioctl(fioc->fd, TIOCMSET, &targ); 1212 } 1213 break; 1214 default: 1215 return -ENOTSUP; 1216 } 1217 return 0; 1218 } 1219 #endif /* __linux__ || __sun__ */ 1220 1221 #if defined(__linux__) 1222 1223 #define HAVE_CHARDEV_PARPORT 1 1224 1225 typedef struct { 1226 Chardev parent; 1227 int fd; 1228 int mode; 1229 } ParallelChardev; 1230 1231 #define PARALLEL_CHARDEV(obj) \ 1232 OBJECT_CHECK(ParallelChardev, (obj), TYPE_CHARDEV_PARALLEL) 1233 1234 static int pp_hw_mode(ParallelChardev *s, uint16_t mode) 1235 { 1236 if (s->mode != mode) { 1237 int m = mode; 1238 if (ioctl(s->fd, PPSETMODE, &m) < 0) 1239 return 0; 1240 s->mode = mode; 1241 } 1242 return 1; 1243 } 1244 1245 static int pp_ioctl(Chardev *chr, int cmd, void *arg) 1246 { 1247 ParallelChardev *drv = PARALLEL_CHARDEV(chr); 1248 int fd = drv->fd; 1249 uint8_t b; 1250 1251 switch(cmd) { 1252 case CHR_IOCTL_PP_READ_DATA: 1253 if (ioctl(fd, PPRDATA, &b) < 0) 1254 return -ENOTSUP; 1255 *(uint8_t *)arg = b; 1256 break; 1257 case CHR_IOCTL_PP_WRITE_DATA: 1258 b = *(uint8_t *)arg; 1259 if (ioctl(fd, PPWDATA, &b) < 0) 1260 return -ENOTSUP; 1261 break; 1262 case CHR_IOCTL_PP_READ_CONTROL: 1263 if (ioctl(fd, PPRCONTROL, &b) < 0) 1264 return -ENOTSUP; 1265 /* Linux gives only the lowest bits, and no way to know data 1266 direction! For better compatibility set the fixed upper 1267 bits. */ 1268 *(uint8_t *)arg = b | 0xc0; 1269 break; 1270 case CHR_IOCTL_PP_WRITE_CONTROL: 1271 b = *(uint8_t *)arg; 1272 if (ioctl(fd, PPWCONTROL, &b) < 0) 1273 return -ENOTSUP; 1274 break; 1275 case CHR_IOCTL_PP_READ_STATUS: 1276 if (ioctl(fd, PPRSTATUS, &b) < 0) 1277 return -ENOTSUP; 1278 *(uint8_t *)arg = b; 1279 break; 1280 case CHR_IOCTL_PP_DATA_DIR: 1281 if (ioctl(fd, PPDATADIR, (int *)arg) < 0) 1282 return -ENOTSUP; 1283 break; 1284 case CHR_IOCTL_PP_EPP_READ_ADDR: 1285 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) { 1286 struct ParallelIOArg *parg = arg; 1287 int n = read(fd, parg->buffer, parg->count); 1288 if (n != parg->count) { 1289 return -EIO; 1290 } 1291 } 1292 break; 1293 case CHR_IOCTL_PP_EPP_READ: 1294 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) { 1295 struct ParallelIOArg *parg = arg; 1296 int n = read(fd, parg->buffer, parg->count); 1297 if (n != parg->count) { 1298 return -EIO; 1299 } 1300 } 1301 break; 1302 case CHR_IOCTL_PP_EPP_WRITE_ADDR: 1303 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) { 1304 struct ParallelIOArg *parg = arg; 1305 int n = write(fd, parg->buffer, parg->count); 1306 if (n != parg->count) { 1307 return -EIO; 1308 } 1309 } 1310 break; 1311 case CHR_IOCTL_PP_EPP_WRITE: 1312 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) { 1313 struct ParallelIOArg *parg = arg; 1314 int n = write(fd, parg->buffer, parg->count); 1315 if (n != parg->count) { 1316 return -EIO; 1317 } 1318 } 1319 break; 1320 default: 1321 return -ENOTSUP; 1322 } 1323 return 0; 1324 } 1325 1326 static void qemu_chr_open_pp_fd(Chardev *chr, 1327 int fd, 1328 bool *be_opened, 1329 Error **errp) 1330 { 1331 ParallelChardev *drv = PARALLEL_CHARDEV(chr); 1332 1333 if (ioctl(fd, PPCLAIM) < 0) { 1334 error_setg_errno(errp, errno, "not a parallel port"); 1335 close(fd); 1336 return; 1337 } 1338 1339 drv->fd = fd; 1340 drv->mode = IEEE1284_MODE_COMPAT; 1341 } 1342 #endif /* __linux__ */ 1343 1344 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) 1345 1346 #define HAVE_CHARDEV_PARPORT 1 1347 1348 typedef struct { 1349 Chardev parent; 1350 int fd; 1351 } ParallelChardev; 1352 1353 #define PARALLEL_CHARDEV(obj) \ 1354 OBJECT_CHECK(ParallelChardev, (obj), TYPE_CHARDEV_PARALLEL) 1355 1356 static int pp_ioctl(Chardev *chr, int cmd, void *arg) 1357 { 1358 ParallelChardev *drv = PARALLEL_CHARDEV(chr); 1359 uint8_t b; 1360 1361 switch (cmd) { 1362 case CHR_IOCTL_PP_READ_DATA: 1363 if (ioctl(drv->fd, PPIGDATA, &b) < 0) { 1364 return -ENOTSUP; 1365 } 1366 *(uint8_t *)arg = b; 1367 break; 1368 case CHR_IOCTL_PP_WRITE_DATA: 1369 b = *(uint8_t *)arg; 1370 if (ioctl(drv->fd, PPISDATA, &b) < 0) { 1371 return -ENOTSUP; 1372 } 1373 break; 1374 case CHR_IOCTL_PP_READ_CONTROL: 1375 if (ioctl(drv->fd, PPIGCTRL, &b) < 0) { 1376 return -ENOTSUP; 1377 } 1378 *(uint8_t *)arg = b; 1379 break; 1380 case CHR_IOCTL_PP_WRITE_CONTROL: 1381 b = *(uint8_t *)arg; 1382 if (ioctl(drv->fd, PPISCTRL, &b) < 0) { 1383 return -ENOTSUP; 1384 } 1385 break; 1386 case CHR_IOCTL_PP_READ_STATUS: 1387 if (ioctl(drv->fd, PPIGSTATUS, &b) < 0) { 1388 return -ENOTSUP; 1389 } 1390 *(uint8_t *)arg = b; 1391 break; 1392 default: 1393 return -ENOTSUP; 1394 } 1395 return 0; 1396 } 1397 1398 static void qemu_chr_open_pp_fd(Chardev *chr, 1399 int fd, 1400 bool *be_opened, 1401 Error **errp) 1402 { 1403 ParallelChardev *drv = PARALLEL_CHARDEV(chr); 1404 drv->fd = fd; 1405 *be_opened = false; 1406 } 1407 #endif 1408 1409 #else /* _WIN32 */ 1410 1411 #define HAVE_CHARDEV_SERIAL 1 1412 1413 #define MAXCONNECT 1 1414 #define NTIMEOUT 5000 1415 1416 static int win_chr_pipe_init(Chardev *chr, const char *filename, 1417 Error **errp) 1418 { 1419 WinChardev *s = WIN_CHARDEV(chr); 1420 OVERLAPPED ov; 1421 int ret; 1422 DWORD size; 1423 char *openname; 1424 1425 s->fpipe = TRUE; 1426 1427 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL); 1428 if (!s->hsend) { 1429 error_setg(errp, "Failed CreateEvent"); 1430 goto fail; 1431 } 1432 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL); 1433 if (!s->hrecv) { 1434 error_setg(errp, "Failed CreateEvent"); 1435 goto fail; 1436 } 1437 1438 openname = g_strdup_printf("\\\\.\\pipe\\%s", filename); 1439 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 1440 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | 1441 PIPE_WAIT, 1442 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL); 1443 g_free(openname); 1444 if (s->hcom == INVALID_HANDLE_VALUE) { 1445 error_setg(errp, "Failed CreateNamedPipe (%lu)", GetLastError()); 1446 s->hcom = NULL; 1447 goto fail; 1448 } 1449 1450 ZeroMemory(&ov, sizeof(ov)); 1451 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); 1452 ret = ConnectNamedPipe(s->hcom, &ov); 1453 if (ret) { 1454 error_setg(errp, "Failed ConnectNamedPipe"); 1455 goto fail; 1456 } 1457 1458 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE); 1459 if (!ret) { 1460 error_setg(errp, "Failed GetOverlappedResult"); 1461 if (ov.hEvent) { 1462 CloseHandle(ov.hEvent); 1463 ov.hEvent = NULL; 1464 } 1465 goto fail; 1466 } 1467 1468 if (ov.hEvent) { 1469 CloseHandle(ov.hEvent); 1470 ov.hEvent = NULL; 1471 } 1472 qemu_add_polling_cb(win_chr_pipe_poll, chr); 1473 return 0; 1474 1475 fail: 1476 return -1; 1477 } 1478 1479 1480 static void qemu_chr_open_pipe(Chardev *chr, 1481 ChardevBackend *backend, 1482 bool *be_opened, 1483 Error **errp) 1484 { 1485 ChardevHostdev *opts = backend->u.pipe.data; 1486 const char *filename = opts->device; 1487 1488 if (win_chr_pipe_init(chr, filename, errp) < 0) { 1489 return; 1490 } 1491 } 1492 1493 static void qemu_chr_open_win_con(Chardev *chr, 1494 ChardevBackend *backend, 1495 bool *be_opened, 1496 Error **errp) 1497 { 1498 qemu_chr_open_win_file(chr, GetStdHandle(STD_OUTPUT_HANDLE)); 1499 } 1500 1501 static void char_console_class_init(ObjectClass *oc, void *data) 1502 { 1503 ChardevClass *cc = CHARDEV_CLASS(oc); 1504 1505 cc->open = qemu_chr_open_win_con; 1506 } 1507 1508 static const TypeInfo char_console_type_info = { 1509 .name = TYPE_CHARDEV_CONSOLE, 1510 .parent = TYPE_CHARDEV_WIN, 1511 .class_init = char_console_class_init, 1512 }; 1513 1514 #endif /* !_WIN32 */ 1515 1516 int qemu_chr_wait_connected(Chardev *chr, Error **errp) 1517 { 1518 ChardevClass *cc = CHARDEV_GET_CLASS(chr); 1519 1520 if (cc->chr_wait_connected) { 1521 return cc->chr_wait_connected(chr, errp); 1522 } 1523 1524 return 0; 1525 } 1526 1527 int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp) 1528 { 1529 if (!be->chr) { 1530 error_setg(errp, "missing associated backend"); 1531 return -1; 1532 } 1533 1534 return qemu_chr_wait_connected(be->chr, errp); 1535 } 1536 1537 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename) 1538 { 1539 char host[65], port[33], width[8], height[8]; 1540 int pos; 1541 const char *p; 1542 QemuOpts *opts; 1543 Error *local_err = NULL; 1544 1545 opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err); 1546 if (local_err) { 1547 error_report_err(local_err); 1548 return NULL; 1549 } 1550 1551 if (strstart(filename, "mon:", &p)) { 1552 filename = p; 1553 qemu_opt_set(opts, "mux", "on", &error_abort); 1554 if (strcmp(filename, "stdio") == 0) { 1555 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default 1556 * but pass it to the guest. Handle this only for compat syntax, 1557 * for -chardev syntax we have special option for this. 1558 * This is what -nographic did, redirecting+muxing serial+monitor 1559 * to stdio causing Ctrl+C to be passed to guest. */ 1560 qemu_opt_set(opts, "signal", "off", &error_abort); 1561 } 1562 } 1563 1564 if (strcmp(filename, "null") == 0 || 1565 strcmp(filename, "pty") == 0 || 1566 strcmp(filename, "msmouse") == 0 || 1567 strcmp(filename, "braille") == 0 || 1568 strcmp(filename, "testdev") == 0 || 1569 strcmp(filename, "stdio") == 0) { 1570 qemu_opt_set(opts, "backend", filename, &error_abort); 1571 return opts; 1572 } 1573 if (strstart(filename, "vc", &p)) { 1574 qemu_opt_set(opts, "backend", "vc", &error_abort); 1575 if (*p == ':') { 1576 if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) { 1577 /* pixels */ 1578 qemu_opt_set(opts, "width", width, &error_abort); 1579 qemu_opt_set(opts, "height", height, &error_abort); 1580 } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) { 1581 /* chars */ 1582 qemu_opt_set(opts, "cols", width, &error_abort); 1583 qemu_opt_set(opts, "rows", height, &error_abort); 1584 } else { 1585 goto fail; 1586 } 1587 } 1588 return opts; 1589 } 1590 if (strcmp(filename, "con:") == 0) { 1591 qemu_opt_set(opts, "backend", "console", &error_abort); 1592 return opts; 1593 } 1594 if (strstart(filename, "COM", NULL)) { 1595 qemu_opt_set(opts, "backend", "serial", &error_abort); 1596 qemu_opt_set(opts, "path", filename, &error_abort); 1597 return opts; 1598 } 1599 if (strstart(filename, "file:", &p)) { 1600 qemu_opt_set(opts, "backend", "file", &error_abort); 1601 qemu_opt_set(opts, "path", p, &error_abort); 1602 return opts; 1603 } 1604 if (strstart(filename, "pipe:", &p)) { 1605 qemu_opt_set(opts, "backend", "pipe", &error_abort); 1606 qemu_opt_set(opts, "path", p, &error_abort); 1607 return opts; 1608 } 1609 if (strstart(filename, "tcp:", &p) || 1610 strstart(filename, "telnet:", &p)) { 1611 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { 1612 host[0] = 0; 1613 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) 1614 goto fail; 1615 } 1616 qemu_opt_set(opts, "backend", "socket", &error_abort); 1617 qemu_opt_set(opts, "host", host, &error_abort); 1618 qemu_opt_set(opts, "port", port, &error_abort); 1619 if (p[pos] == ',') { 1620 qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err); 1621 if (local_err) { 1622 error_report_err(local_err); 1623 goto fail; 1624 } 1625 } 1626 if (strstart(filename, "telnet:", &p)) 1627 qemu_opt_set(opts, "telnet", "on", &error_abort); 1628 return opts; 1629 } 1630 if (strstart(filename, "udp:", &p)) { 1631 qemu_opt_set(opts, "backend", "udp", &error_abort); 1632 if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) { 1633 host[0] = 0; 1634 if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) { 1635 goto fail; 1636 } 1637 } 1638 qemu_opt_set(opts, "host", host, &error_abort); 1639 qemu_opt_set(opts, "port", port, &error_abort); 1640 if (p[pos] == '@') { 1641 p += pos + 1; 1642 if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) { 1643 host[0] = 0; 1644 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) { 1645 goto fail; 1646 } 1647 } 1648 qemu_opt_set(opts, "localaddr", host, &error_abort); 1649 qemu_opt_set(opts, "localport", port, &error_abort); 1650 } 1651 return opts; 1652 } 1653 if (strstart(filename, "unix:", &p)) { 1654 qemu_opt_set(opts, "backend", "socket", &error_abort); 1655 qemu_opts_do_parse(opts, p, "path", &local_err); 1656 if (local_err) { 1657 error_report_err(local_err); 1658 goto fail; 1659 } 1660 return opts; 1661 } 1662 if (strstart(filename, "/dev/parport", NULL) || 1663 strstart(filename, "/dev/ppi", NULL)) { 1664 qemu_opt_set(opts, "backend", "parport", &error_abort); 1665 qemu_opt_set(opts, "path", filename, &error_abort); 1666 return opts; 1667 } 1668 if (strstart(filename, "/dev/", NULL)) { 1669 qemu_opt_set(opts, "backend", "tty", &error_abort); 1670 qemu_opt_set(opts, "path", filename, &error_abort); 1671 return opts; 1672 } 1673 1674 fail: 1675 qemu_opts_del(opts); 1676 return NULL; 1677 } 1678 1679 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend) 1680 { 1681 const char *logfile = qemu_opt_get(opts, "logfile"); 1682 1683 backend->has_logfile = logfile != NULL; 1684 backend->logfile = logfile ? g_strdup(logfile) : NULL; 1685 1686 backend->has_logappend = true; 1687 backend->logappend = qemu_opt_get_bool(opts, "logappend", false); 1688 } 1689 1690 1691 static void qemu_chr_parse_file_out(QemuOpts *opts, ChardevBackend *backend, 1692 Error **errp) 1693 { 1694 const char *path = qemu_opt_get(opts, "path"); 1695 ChardevFile *file; 1696 1697 backend->type = CHARDEV_BACKEND_KIND_FILE; 1698 if (path == NULL) { 1699 error_setg(errp, "chardev: file: no filename given"); 1700 return; 1701 } 1702 file = backend->u.file.data = g_new0(ChardevFile, 1); 1703 qemu_chr_parse_common(opts, qapi_ChardevFile_base(file)); 1704 file->out = g_strdup(path); 1705 1706 file->has_append = true; 1707 file->append = qemu_opt_get_bool(opts, "append", false); 1708 } 1709 1710 static void qemu_chr_parse_stdio(QemuOpts *opts, ChardevBackend *backend, 1711 Error **errp) 1712 { 1713 ChardevStdio *stdio; 1714 1715 backend->type = CHARDEV_BACKEND_KIND_STDIO; 1716 stdio = backend->u.stdio.data = g_new0(ChardevStdio, 1); 1717 qemu_chr_parse_common(opts, qapi_ChardevStdio_base(stdio)); 1718 stdio->has_signal = true; 1719 stdio->signal = qemu_opt_get_bool(opts, "signal", true); 1720 } 1721 1722 static void char_stdio_class_init(ObjectClass *oc, void *data) 1723 { 1724 ChardevClass *cc = CHARDEV_CLASS(oc); 1725 1726 cc->parse = qemu_chr_parse_stdio; 1727 #ifndef _WIN32 1728 cc->open = qemu_chr_open_stdio; 1729 cc->chr_set_echo = qemu_chr_set_echo_stdio; 1730 #endif 1731 } 1732 1733 static const TypeInfo char_stdio_type_info = { 1734 .name = TYPE_CHARDEV_STDIO, 1735 #ifdef _WIN32 1736 .parent = TYPE_CHARDEV_WIN_STDIO, 1737 #else 1738 .parent = TYPE_CHARDEV_FD, 1739 .instance_finalize = char_stdio_finalize, 1740 #endif 1741 .class_init = char_stdio_class_init, 1742 }; 1743 1744 #ifdef HAVE_CHARDEV_SERIAL 1745 static void qemu_chr_parse_serial(QemuOpts *opts, ChardevBackend *backend, 1746 Error **errp) 1747 { 1748 const char *device = qemu_opt_get(opts, "path"); 1749 ChardevHostdev *serial; 1750 1751 backend->type = CHARDEV_BACKEND_KIND_SERIAL; 1752 if (device == NULL) { 1753 error_setg(errp, "chardev: serial/tty: no device path given"); 1754 return; 1755 } 1756 serial = backend->u.serial.data = g_new0(ChardevHostdev, 1); 1757 qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(serial)); 1758 serial->device = g_strdup(device); 1759 } 1760 #endif 1761 1762 #ifdef HAVE_CHARDEV_PARPORT 1763 static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend, 1764 Error **errp) 1765 { 1766 const char *device = qemu_opt_get(opts, "path"); 1767 ChardevHostdev *parallel; 1768 1769 backend->type = CHARDEV_BACKEND_KIND_PARALLEL; 1770 if (device == NULL) { 1771 error_setg(errp, "chardev: parallel: no device path given"); 1772 return; 1773 } 1774 parallel = backend->u.parallel.data = g_new0(ChardevHostdev, 1); 1775 qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(parallel)); 1776 parallel->device = g_strdup(device); 1777 } 1778 #endif 1779 1780 static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend, 1781 Error **errp) 1782 { 1783 const char *device = qemu_opt_get(opts, "path"); 1784 ChardevHostdev *dev; 1785 1786 backend->type = CHARDEV_BACKEND_KIND_PIPE; 1787 if (device == NULL) { 1788 error_setg(errp, "chardev: pipe: no device path given"); 1789 return; 1790 } 1791 dev = backend->u.pipe.data = g_new0(ChardevHostdev, 1); 1792 qemu_chr_parse_common(opts, qapi_ChardevHostdev_base(dev)); 1793 dev->device = g_strdup(device); 1794 } 1795 1796 static void char_pipe_class_init(ObjectClass *oc, void *data) 1797 { 1798 ChardevClass *cc = CHARDEV_CLASS(oc); 1799 1800 cc->parse = qemu_chr_parse_pipe; 1801 cc->open = qemu_chr_open_pipe; 1802 } 1803 1804 static const TypeInfo char_pipe_type_info = { 1805 .name = TYPE_CHARDEV_PIPE, 1806 #ifdef _WIN32 1807 .parent = TYPE_CHARDEV_WIN, 1808 #else 1809 .parent = TYPE_CHARDEV_FD, 1810 #endif 1811 .class_init = char_pipe_class_init, 1812 }; 1813 1814 static const ChardevClass *char_get_class(const char *driver, Error **errp) 1815 { 1816 ObjectClass *oc; 1817 const ChardevClass *cc; 1818 char *typename = g_strdup_printf("chardev-%s", driver); 1819 1820 oc = object_class_by_name(typename); 1821 g_free(typename); 1822 1823 if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) { 1824 error_setg(errp, "'%s' is not a valid char driver name", driver); 1825 return NULL; 1826 } 1827 1828 if (object_class_is_abstract(oc)) { 1829 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver", 1830 "abstract device type"); 1831 return NULL; 1832 } 1833 1834 cc = CHARDEV_CLASS(oc); 1835 if (cc->internal) { 1836 error_setg(errp, "'%s' is not a valid char driver name", driver); 1837 return NULL; 1838 } 1839 1840 return cc; 1841 } 1842 1843 static Chardev *qemu_chardev_add(const char *id, const char *typename, 1844 ChardevBackend *backend, Error **errp) 1845 { 1846 Chardev *chr; 1847 1848 chr = qemu_chr_find(id); 1849 if (chr) { 1850 error_setg(errp, "Chardev '%s' already exists", id); 1851 return NULL; 1852 } 1853 1854 chr = qemu_chardev_new(id, typename, backend, errp); 1855 if (!chr) { 1856 return NULL; 1857 } 1858 1859 QTAILQ_INSERT_TAIL(&chardevs, chr, next); 1860 return chr; 1861 } 1862 1863 static const struct ChardevAlias { 1864 const char *typename; 1865 const char *alias; 1866 } chardev_alias_table[] = { 1867 #ifdef HAVE_CHARDEV_PARPORT 1868 { "parallel", "parport" }, 1869 #endif 1870 #ifdef HAVE_CHARDEV_SERIAL 1871 { "serial", "tty" }, 1872 #endif 1873 }; 1874 1875 typedef struct ChadevClassFE { 1876 void (*fn)(const char *name, void *opaque); 1877 void *opaque; 1878 } ChadevClassFE; 1879 1880 static void 1881 chardev_class_foreach(ObjectClass *klass, void *opaque) 1882 { 1883 ChadevClassFE *fe = opaque; 1884 1885 assert(g_str_has_prefix(object_class_get_name(klass), "chardev-")); 1886 if (CHARDEV_CLASS(klass)->internal) { 1887 return; 1888 } 1889 1890 fe->fn(object_class_get_name(klass) + 8, fe->opaque); 1891 } 1892 1893 static void 1894 chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque) 1895 { 1896 ChadevClassFE fe = { .fn = fn, .opaque = opaque }; 1897 int i; 1898 1899 object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe); 1900 1901 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) { 1902 fn(chardev_alias_table[i].alias, opaque); 1903 } 1904 } 1905 1906 static void 1907 help_string_append(const char *name, void *opaque) 1908 { 1909 GString *str = opaque; 1910 1911 g_string_append_printf(str, "\n%s", name); 1912 } 1913 1914 Chardev *qemu_chr_new_from_opts(QemuOpts *opts, 1915 Error **errp) 1916 { 1917 Error *local_err = NULL; 1918 const ChardevClass *cc; 1919 Chardev *chr; 1920 int i; 1921 ChardevBackend *backend = NULL; 1922 const char *name = qemu_opt_get(opts, "backend"); 1923 const char *id = qemu_opts_id(opts); 1924 char *bid = NULL; 1925 1926 if (name == NULL) { 1927 error_setg(errp, "chardev: \"%s\" missing backend", 1928 qemu_opts_id(opts)); 1929 return NULL; 1930 } 1931 1932 if (is_help_option(name)) { 1933 GString *str = g_string_new(""); 1934 1935 chardev_name_foreach(help_string_append, str); 1936 1937 error_report("Available chardev backend types: %s", str->str); 1938 g_string_free(str, true); 1939 exit(0); 1940 } 1941 1942 if (id == NULL) { 1943 error_setg(errp, "chardev: no id specified"); 1944 return NULL; 1945 } 1946 1947 for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) { 1948 if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) { 1949 name = chardev_alias_table[i].typename; 1950 break; 1951 } 1952 } 1953 1954 cc = char_get_class(name, errp); 1955 if (cc == NULL) { 1956 return NULL; 1957 } 1958 1959 backend = g_new0(ChardevBackend, 1); 1960 backend->type = CHARDEV_BACKEND_KIND_NULL; 1961 1962 if (qemu_opt_get_bool(opts, "mux", 0)) { 1963 bid = g_strdup_printf("%s-base", id); 1964 } 1965 1966 chr = NULL; 1967 if (cc->parse) { 1968 cc->parse(opts, backend, &local_err); 1969 if (local_err) { 1970 error_propagate(errp, local_err); 1971 goto out; 1972 } 1973 } else { 1974 ChardevCommon *ccom = g_new0(ChardevCommon, 1); 1975 qemu_chr_parse_common(opts, ccom); 1976 backend->u.null.data = ccom; /* Any ChardevCommon member would work */ 1977 } 1978 1979 chr = qemu_chardev_add(bid ? bid : id, 1980 object_class_get_name(OBJECT_CLASS(cc)), 1981 backend, errp); 1982 if (chr == NULL) { 1983 goto out; 1984 } 1985 1986 if (bid) { 1987 Chardev *mux; 1988 qapi_free_ChardevBackend(backend); 1989 backend = g_new0(ChardevBackend, 1); 1990 backend->type = CHARDEV_BACKEND_KIND_MUX; 1991 backend->u.mux.data = g_new0(ChardevMux, 1); 1992 backend->u.mux.data->chardev = g_strdup(bid); 1993 mux = qemu_chardev_add(id, TYPE_CHARDEV_MUX, backend, errp); 1994 if (mux == NULL) { 1995 qemu_chr_delete(chr); 1996 chr = NULL; 1997 goto out; 1998 } 1999 chr = mux; 2000 } 2001 2002 out: 2003 qapi_free_ChardevBackend(backend); 2004 g_free(bid); 2005 return chr; 2006 } 2007 2008 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename) 2009 { 2010 const char *p; 2011 Chardev *chr; 2012 QemuOpts *opts; 2013 Error *err = NULL; 2014 2015 if (strstart(filename, "chardev:", &p)) { 2016 return qemu_chr_find(p); 2017 } 2018 2019 opts = qemu_chr_parse_compat(label, filename); 2020 if (!opts) 2021 return NULL; 2022 2023 chr = qemu_chr_new_from_opts(opts, &err); 2024 if (err) { 2025 error_report_err(err); 2026 } 2027 if (chr && qemu_opt_get_bool(opts, "mux", 0)) { 2028 monitor_init(chr, MONITOR_USE_READLINE); 2029 } 2030 qemu_opts_del(opts); 2031 return chr; 2032 } 2033 2034 Chardev *qemu_chr_new(const char *label, const char *filename) 2035 { 2036 Chardev *chr; 2037 chr = qemu_chr_new_noreplay(label, filename); 2038 if (chr) { 2039 if (replay_mode != REPLAY_MODE_NONE) { 2040 qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY); 2041 } 2042 if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) { 2043 error_report("Replay: ioctl is not supported " 2044 "for serial devices yet"); 2045 } 2046 replay_register_char_driver(chr); 2047 } 2048 return chr; 2049 } 2050 2051 void qemu_chr_fe_set_echo(CharBackend *be, bool echo) 2052 { 2053 Chardev *chr = be->chr; 2054 2055 if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) { 2056 CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo); 2057 } 2058 } 2059 2060 void qemu_chr_fe_set_open(CharBackend *be, int fe_open) 2061 { 2062 Chardev *chr = be->chr; 2063 2064 if (!chr) { 2065 return; 2066 } 2067 2068 if (be->fe_open == fe_open) { 2069 return; 2070 } 2071 be->fe_open = fe_open; 2072 if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) { 2073 CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open); 2074 } 2075 } 2076 2077 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond, 2078 GIOFunc func, void *user_data) 2079 { 2080 Chardev *s = be->chr; 2081 GSource *src; 2082 guint tag; 2083 2084 if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) { 2085 return 0; 2086 } 2087 2088 src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond); 2089 if (!src) { 2090 return 0; 2091 } 2092 2093 g_source_set_callback(src, (GSourceFunc)func, user_data, NULL); 2094 tag = g_source_attach(src, NULL); 2095 g_source_unref(src); 2096 2097 return tag; 2098 } 2099 2100 void qemu_chr_fe_disconnect(CharBackend *be) 2101 { 2102 Chardev *chr = be->chr; 2103 2104 if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) { 2105 CHARDEV_GET_CLASS(chr)->chr_disconnect(chr); 2106 } 2107 } 2108 2109 void qemu_chr_delete(Chardev *chr) 2110 { 2111 QTAILQ_REMOVE(&chardevs, chr, next); 2112 object_unref(OBJECT(chr)); 2113 } 2114 2115 ChardevInfoList *qmp_query_chardev(Error **errp) 2116 { 2117 ChardevInfoList *chr_list = NULL; 2118 Chardev *chr; 2119 2120 QTAILQ_FOREACH(chr, &chardevs, next) { 2121 ChardevInfoList *info = g_malloc0(sizeof(*info)); 2122 info->value = g_malloc0(sizeof(*info->value)); 2123 info->value->label = g_strdup(chr->label); 2124 info->value->filename = g_strdup(chr->filename); 2125 info->value->frontend_open = chr->be && chr->be->fe_open; 2126 2127 info->next = chr_list; 2128 chr_list = info; 2129 } 2130 2131 return chr_list; 2132 } 2133 2134 static void 2135 qmp_prepend_backend(const char *name, void *opaque) 2136 { 2137 ChardevBackendInfoList **list = opaque; 2138 ChardevBackendInfoList *info = g_malloc0(sizeof(*info)); 2139 2140 info->value = g_malloc0(sizeof(*info->value)); 2141 info->value->name = g_strdup(name); 2142 info->next = *list; 2143 *list = info; 2144 } 2145 2146 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp) 2147 { 2148 ChardevBackendInfoList *backend_list = NULL; 2149 2150 chardev_name_foreach(qmp_prepend_backend, &backend_list); 2151 2152 return backend_list; 2153 } 2154 2155 Chardev *qemu_chr_find(const char *name) 2156 { 2157 Chardev *chr; 2158 2159 QTAILQ_FOREACH(chr, &chardevs, next) { 2160 if (strcmp(chr->label, name) != 0) 2161 continue; 2162 return chr; 2163 } 2164 return NULL; 2165 } 2166 2167 QemuOptsList qemu_chardev_opts = { 2168 .name = "chardev", 2169 .implied_opt_name = "backend", 2170 .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head), 2171 .desc = { 2172 { 2173 .name = "backend", 2174 .type = QEMU_OPT_STRING, 2175 },{ 2176 .name = "path", 2177 .type = QEMU_OPT_STRING, 2178 },{ 2179 .name = "host", 2180 .type = QEMU_OPT_STRING, 2181 },{ 2182 .name = "port", 2183 .type = QEMU_OPT_STRING, 2184 },{ 2185 .name = "localaddr", 2186 .type = QEMU_OPT_STRING, 2187 },{ 2188 .name = "localport", 2189 .type = QEMU_OPT_STRING, 2190 },{ 2191 .name = "to", 2192 .type = QEMU_OPT_NUMBER, 2193 },{ 2194 .name = "ipv4", 2195 .type = QEMU_OPT_BOOL, 2196 },{ 2197 .name = "ipv6", 2198 .type = QEMU_OPT_BOOL, 2199 },{ 2200 .name = "wait", 2201 .type = QEMU_OPT_BOOL, 2202 },{ 2203 .name = "server", 2204 .type = QEMU_OPT_BOOL, 2205 },{ 2206 .name = "delay", 2207 .type = QEMU_OPT_BOOL, 2208 },{ 2209 .name = "reconnect", 2210 .type = QEMU_OPT_NUMBER, 2211 },{ 2212 .name = "telnet", 2213 .type = QEMU_OPT_BOOL, 2214 },{ 2215 .name = "tls-creds", 2216 .type = QEMU_OPT_STRING, 2217 },{ 2218 .name = "width", 2219 .type = QEMU_OPT_NUMBER, 2220 },{ 2221 .name = "height", 2222 .type = QEMU_OPT_NUMBER, 2223 },{ 2224 .name = "cols", 2225 .type = QEMU_OPT_NUMBER, 2226 },{ 2227 .name = "rows", 2228 .type = QEMU_OPT_NUMBER, 2229 },{ 2230 .name = "mux", 2231 .type = QEMU_OPT_BOOL, 2232 },{ 2233 .name = "signal", 2234 .type = QEMU_OPT_BOOL, 2235 },{ 2236 .name = "name", 2237 .type = QEMU_OPT_STRING, 2238 },{ 2239 .name = "debug", 2240 .type = QEMU_OPT_NUMBER, 2241 },{ 2242 .name = "size", 2243 .type = QEMU_OPT_SIZE, 2244 },{ 2245 .name = "chardev", 2246 .type = QEMU_OPT_STRING, 2247 },{ 2248 .name = "append", 2249 .type = QEMU_OPT_BOOL, 2250 },{ 2251 .name = "logfile", 2252 .type = QEMU_OPT_STRING, 2253 },{ 2254 .name = "logappend", 2255 .type = QEMU_OPT_BOOL, 2256 }, 2257 { /* end of list */ } 2258 }, 2259 }; 2260 2261 #ifdef _WIN32 2262 2263 static void qmp_chardev_open_file(Chardev *chr, 2264 ChardevBackend *backend, 2265 bool *be_opened, 2266 Error **errp) 2267 { 2268 ChardevFile *file = backend->u.file.data; 2269 HANDLE out; 2270 DWORD accessmode; 2271 DWORD flags; 2272 2273 if (file->has_in) { 2274 error_setg(errp, "input file not supported"); 2275 return; 2276 } 2277 2278 if (file->has_append && file->append) { 2279 /* Append to file if it already exists. */ 2280 accessmode = FILE_GENERIC_WRITE & ~FILE_WRITE_DATA; 2281 flags = OPEN_ALWAYS; 2282 } else { 2283 /* Truncate file if it already exists. */ 2284 accessmode = GENERIC_WRITE; 2285 flags = CREATE_ALWAYS; 2286 } 2287 2288 out = CreateFile(file->out, accessmode, FILE_SHARE_READ, NULL, flags, 2289 FILE_ATTRIBUTE_NORMAL, NULL); 2290 if (out == INVALID_HANDLE_VALUE) { 2291 error_setg(errp, "open %s failed", file->out); 2292 return; 2293 } 2294 2295 qemu_chr_open_win_file(chr, out); 2296 } 2297 2298 static void qmp_chardev_open_serial(Chardev *chr, 2299 ChardevBackend *backend, 2300 bool *be_opened, 2301 Error **errp) 2302 { 2303 ChardevHostdev *serial = backend->u.serial.data; 2304 2305 win_chr_init(chr, serial->device, errp); 2306 } 2307 2308 #else /* WIN32 */ 2309 2310 static void qmp_chardev_open_file(Chardev *chr, 2311 ChardevBackend *backend, 2312 bool *be_opened, 2313 Error **errp) 2314 { 2315 ChardevFile *file = backend->u.file.data; 2316 int flags, in = -1, out; 2317 2318 flags = O_WRONLY | O_CREAT | O_BINARY; 2319 if (file->has_append && file->append) { 2320 flags |= O_APPEND; 2321 } else { 2322 flags |= O_TRUNC; 2323 } 2324 2325 out = qmp_chardev_open_file_source(file->out, flags, errp); 2326 if (out < 0) { 2327 return; 2328 } 2329 2330 if (file->has_in) { 2331 flags = O_RDONLY; 2332 in = qmp_chardev_open_file_source(file->in, flags, errp); 2333 if (in < 0) { 2334 qemu_close(out); 2335 return; 2336 } 2337 } 2338 2339 qemu_chr_open_fd(chr, in, out); 2340 } 2341 2342 #ifdef HAVE_CHARDEV_SERIAL 2343 static void qmp_chardev_open_serial(Chardev *chr, 2344 ChardevBackend *backend, 2345 bool *be_opened, 2346 Error **errp) 2347 { 2348 ChardevHostdev *serial = backend->u.serial.data; 2349 int fd; 2350 2351 fd = qmp_chardev_open_file_source(serial->device, O_RDWR, errp); 2352 if (fd < 0) { 2353 return; 2354 } 2355 qemu_set_nonblock(fd); 2356 tty_serial_init(fd, 115200, 'N', 8, 1); 2357 2358 qemu_chr_open_fd(chr, fd, fd); 2359 } 2360 #endif 2361 2362 #ifdef HAVE_CHARDEV_PARPORT 2363 static void qmp_chardev_open_parallel(Chardev *chr, 2364 ChardevBackend *backend, 2365 bool *be_opened, 2366 Error **errp) 2367 { 2368 ChardevHostdev *parallel = backend->u.parallel.data; 2369 int fd; 2370 2371 fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp); 2372 if (fd < 0) { 2373 return; 2374 } 2375 qemu_chr_open_pp_fd(chr, fd, be_opened, errp); 2376 } 2377 2378 static void char_parallel_class_init(ObjectClass *oc, void *data) 2379 { 2380 ChardevClass *cc = CHARDEV_CLASS(oc); 2381 2382 cc->parse = qemu_chr_parse_parallel; 2383 cc->open = qmp_chardev_open_parallel; 2384 #if defined(__linux__) 2385 cc->chr_ioctl = pp_ioctl; 2386 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) 2387 cc->chr_ioctl = pp_ioctl; 2388 #endif 2389 } 2390 2391 static void char_parallel_finalize(Object *obj) 2392 { 2393 #if defined(__linux__) 2394 Chardev *chr = CHARDEV(obj); 2395 ParallelChardev *drv = PARALLEL_CHARDEV(chr); 2396 int fd = drv->fd; 2397 2398 pp_hw_mode(drv, IEEE1284_MODE_COMPAT); 2399 ioctl(fd, PPRELEASE); 2400 close(fd); 2401 qemu_chr_be_event(chr, CHR_EVENT_CLOSED); 2402 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) 2403 /* FIXME: close fd? */ 2404 #endif 2405 } 2406 2407 static const TypeInfo char_parallel_type_info = { 2408 .name = TYPE_CHARDEV_PARALLEL, 2409 .parent = TYPE_CHARDEV, 2410 .instance_size = sizeof(ParallelChardev), 2411 .instance_finalize = char_parallel_finalize, 2412 .class_init = char_parallel_class_init, 2413 }; 2414 #endif 2415 2416 #endif /* WIN32 */ 2417 2418 static void char_file_class_init(ObjectClass *oc, void *data) 2419 { 2420 ChardevClass *cc = CHARDEV_CLASS(oc); 2421 2422 cc->parse = qemu_chr_parse_file_out; 2423 cc->open = qmp_chardev_open_file; 2424 } 2425 2426 static const TypeInfo char_file_type_info = { 2427 .name = TYPE_CHARDEV_FILE, 2428 #ifdef _WIN32 2429 .parent = TYPE_CHARDEV_WIN, 2430 #else 2431 .parent = TYPE_CHARDEV_FD, 2432 #endif 2433 .class_init = char_file_class_init, 2434 }; 2435 2436 #ifdef HAVE_CHARDEV_SERIAL 2437 2438 static void char_serial_class_init(ObjectClass *oc, void *data) 2439 { 2440 ChardevClass *cc = CHARDEV_CLASS(oc); 2441 2442 cc->parse = qemu_chr_parse_serial; 2443 cc->open = qmp_chardev_open_serial; 2444 #ifndef _WIN32 2445 cc->chr_ioctl = tty_serial_ioctl; 2446 #endif 2447 } 2448 2449 static const TypeInfo char_serial_type_info = { 2450 .name = TYPE_CHARDEV_SERIAL, 2451 #ifdef _WIN32 2452 .parent = TYPE_CHARDEV_WIN, 2453 #else 2454 .parent = TYPE_CHARDEV_FD, 2455 #endif 2456 .class_init = char_serial_class_init, 2457 }; 2458 #endif 2459 2460 bool qemu_chr_has_feature(Chardev *chr, 2461 ChardevFeature feature) 2462 { 2463 return test_bit(feature, chr->features); 2464 } 2465 2466 void qemu_chr_set_feature(Chardev *chr, 2467 ChardevFeature feature) 2468 { 2469 return set_bit(feature, chr->features); 2470 } 2471 2472 Chardev *qemu_chardev_new(const char *id, const char *typename, 2473 ChardevBackend *backend, Error **errp) 2474 { 2475 Chardev *chr = NULL; 2476 Error *local_err = NULL; 2477 bool be_opened = true; 2478 2479 assert(g_str_has_prefix(typename, "chardev-")); 2480 2481 chr = CHARDEV(object_new(typename)); 2482 chr->label = g_strdup(id); 2483 2484 qemu_char_open(chr, backend, &be_opened, &local_err); 2485 if (local_err) { 2486 error_propagate(errp, local_err); 2487 object_unref(OBJECT(chr)); 2488 return NULL; 2489 } 2490 2491 if (!chr->filename) { 2492 chr->filename = g_strdup(typename + 8); 2493 } 2494 if (be_opened) { 2495 qemu_chr_be_event(chr, CHR_EVENT_OPENED); 2496 } 2497 2498 return chr; 2499 } 2500 2501 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, 2502 Error **errp) 2503 { 2504 const ChardevClass *cc; 2505 ChardevReturn *ret; 2506 Chardev *chr; 2507 2508 cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp); 2509 if (!cc) { 2510 return NULL; 2511 } 2512 2513 chr = qemu_chardev_add(id, object_class_get_name(OBJECT_CLASS(cc)), 2514 backend, errp); 2515 if (!chr) { 2516 return NULL; 2517 } 2518 2519 ret = g_new0(ChardevReturn, 1); 2520 if (CHARDEV_IS_PTY(chr)) { 2521 ret->pty = g_strdup(chr->filename + 4); 2522 ret->has_pty = true; 2523 } 2524 2525 return ret; 2526 } 2527 2528 void qmp_chardev_remove(const char *id, Error **errp) 2529 { 2530 Chardev *chr; 2531 2532 chr = qemu_chr_find(id); 2533 if (chr == NULL) { 2534 error_setg(errp, "Chardev '%s' not found", id); 2535 return; 2536 } 2537 if (qemu_chr_is_busy(chr)) { 2538 error_setg(errp, "Chardev '%s' is busy", id); 2539 return; 2540 } 2541 if (qemu_chr_replay(chr)) { 2542 error_setg(errp, 2543 "Chardev '%s' cannot be unplugged in record/replay mode", id); 2544 return; 2545 } 2546 qemu_chr_delete(chr); 2547 } 2548 2549 void qemu_chr_cleanup(void) 2550 { 2551 Chardev *chr, *tmp; 2552 2553 QTAILQ_FOREACH_SAFE(chr, &chardevs, next, tmp) { 2554 qemu_chr_delete(chr); 2555 } 2556 } 2557 2558 static void register_types(void) 2559 { 2560 type_register_static(&char_type_info); 2561 type_register_static(&char_file_type_info); 2562 type_register_static(&char_stdio_type_info); 2563 #ifdef HAVE_CHARDEV_SERIAL 2564 type_register_static(&char_serial_type_info); 2565 #endif 2566 #ifdef HAVE_CHARDEV_PARPORT 2567 type_register_static(&char_parallel_type_info); 2568 #endif 2569 #ifdef HAVE_CHARDEV_PTY 2570 type_register_static(&char_pty_type_info); 2571 #endif 2572 #ifdef _WIN32 2573 type_register_static(&char_console_type_info); 2574 #endif 2575 type_register_static(&char_pipe_type_info); 2576 2577 /* this must be done after machine init, since we register FEs with muxes 2578 * as part of realize functions like serial_isa_realizefn when -nographic 2579 * is specified 2580 */ 2581 qemu_add_machine_init_done_notifier(&muxes_realize_notify); 2582 } 2583 2584 type_init(register_types); 2585