chardev/char.c

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