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