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