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
  25 #include "qemu/osdep.h"
  26 #include "qemu/cutils.h"
  27 #include "monitor/monitor.h"
  28 #include "qemu/config-file.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/qemu-print.h"
  31 #include "chardev/char.h"
  32 #include "qapi/error.h"
  33 #include "qapi/qapi-commands-char.h"
  34 #include "qapi/qmp/qerror.h"
  35 #include "sysemu/replay.h"
  36 #include "qemu/help_option.h"
  37 #include "qemu/module.h"
  38 #include "qemu/option.h"
  39 #include "qemu/id.h"
  40 #include "qemu/coroutine.h"
  41 #include "qemu/yank.h"
  42
  43 #include "chardev-internal.h"
  44
  45 /***********************************************************/
  46 /* character device */
  47
  48 Object *get_chardevs_root(void)
  49 {
  50     return container_get(object_get_root(), "/chardevs");
  51 }
  52
  53 static void chr_be_event(Chardev *s, QEMUChrEvent event)
  54 {
  55     CharBackend *be = s->be;
  56
  57     if (!be || !be->chr_event) {
  58         return;
  59     }
  60
  61     be->chr_event(be->opaque, event);
  62 }
  63
  64 void qemu_chr_be_event(Chardev *s, QEMUChrEvent event)
  65 {
  66     /* Keep track if the char device is open */
  67     switch (event) {
  68         case CHR_EVENT_OPENED:
  69             s->be_open = 1;
  70             break;
  71         case CHR_EVENT_CLOSED:
  72             s->be_open = 0;
  73             break;
  74     case CHR_EVENT_BREAK:
  75     case CHR_EVENT_MUX_IN:
  76     case CHR_EVENT_MUX_OUT:
  77         /* Ignore */
  78         break;
  79     }
  80
  81     CHARDEV_GET_CLASS(s)->chr_be_event(s, event);
  82 }
  83
  84 /* Not reporting errors from writing to logfile, as logs are
  85  * defined to be "best effort" only */
  86 static void qemu_chr_write_log(Chardev *s, const uint8_t *buf, size_t len)
  87 {
  88     size_t done = 0;
  89     ssize_t ret;
  90
  91     if (s->logfd < 0) {
  92         return;
  93     }
  94
  95     while (done < len) {
  96     retry:
  97         ret = write(s->logfd, buf + done, len - done);
  98         if (ret == -1 && errno == EAGAIN) {
  99             g_usleep(100);
 100             goto retry;
 101         }
 102
 103         if (ret <= 0) {
 104             return;
 105         }
 106         done += ret;
 107     }
 108 }
 109
 110 static int qemu_chr_write_buffer(Chardev *s,
 111                                  const uint8_t *buf, int len,
 112                                  int *offset, bool write_all)
 113 {
 114     ChardevClass *cc = CHARDEV_GET_CLASS(s);
 115     int res = 0;
 116     *offset = 0;
 117
 118     qemu_mutex_lock(&s->chr_write_lock);
 119     while (*offset < len) {
 120     retry:
 121         res = cc->chr_write(s, buf + *offset, len - *offset);
 122         if (res < 0 && errno == EAGAIN && write_all) {
 123             if (qemu_in_coroutine()) {
 124                 qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
 125             } else {
 126                 g_usleep(100);
 127             }
 128             goto retry;
 129         }
 130
 131         if (res <= 0) {
 132             break;
 133         }
 134
 135         *offset += res;
 136         if (!write_all) {
 137             break;
 138         }
 139     }
 140     if (*offset > 0) {
 141         /*
 142          * If some data was written by backend, we should
 143          * only log what was actually written. This method
 144          * may be invoked again to write the remaining
 145          * method, thus we'll log the remainder at that time.
 146          */
 147         qemu_chr_write_log(s, buf, *offset);
 148     } else if (res < 0) {
 149         /*
 150          * If a fatal error was reported by the backend,
 151          * assume this method won't be invoked again with
 152          * this buffer, so log it all right away.
 153          */
 154         qemu_chr_write_log(s, buf, len);
 155     }
 156     qemu_mutex_unlock(&s->chr_write_lock);
 157
 158     return res;
 159 }
 160
 161 int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all)
 162 {
 163     int offset = 0;
 164     int res;
 165
 166     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 167         replay_char_write_event_load(&res, &offset);
 168         assert(offset <= len);
 169         qemu_chr_write_buffer(s, buf, offset, &offset, true);
 170         return res;
 171     }
 172
 173     res = qemu_chr_write_buffer(s, buf, len, &offset, write_all);
 174
 175     if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 176         replay_char_write_event_save(res, offset);
 177     }
 178
 179     if (res < 0) {
 180         return res;
 181     }
 182     return offset;
 183 }
 184
 185 int qemu_chr_be_can_write(Chardev *s)
 186 {
 187     CharBackend *be = s->be;
 188
 189     if (!be || !be->chr_can_read) {
 190         return 0;
 191     }
 192
 193     return be->chr_can_read(be->opaque);
 194 }
 195
 196 void qemu_chr_be_write_impl(Chardev *s, const uint8_t *buf, int len)
 197 {
 198     CharBackend *be = s->be;
 199
 200     if (be && be->chr_read) {
 201         be->chr_read(be->opaque, buf, len);
 202     }
 203 }
 204
 205 void qemu_chr_be_write(Chardev *s, const uint8_t *buf, int len)
 206 {
 207     if (qemu_chr_replay(s)) {
 208         if (replay_mode == REPLAY_MODE_PLAY) {
 209             return;
 210         }
 211         replay_chr_be_write(s, buf, len);
 212     } else {
 213         qemu_chr_be_write_impl(s, buf, len);
 214     }
 215 }
 216
 217 void qemu_chr_be_update_read_handlers(Chardev *s,
 218                                       GMainContext *context)
 219 {
 220     ChardevClass *cc = CHARDEV_GET_CLASS(s);
 221
 222     assert(qemu_chr_has_feature(s, QEMU_CHAR_FEATURE_GCONTEXT)
 223            || !context);
 224     s->gcontext = context;
 225     if (cc->chr_update_read_handler) {
 226         cc->chr_update_read_handler(s);
 227     }
 228 }
 229
 230 int qemu_chr_add_client(Chardev *s, int fd)
 231 {
 232     return CHARDEV_GET_CLASS(s)->chr_add_client ?
 233         CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
 234 }
 235
 236 static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
 237                            bool *be_opened, Error **errp)
 238 {
 239     ChardevClass *cc = CHARDEV_GET_CLASS(chr);
 240     /* Any ChardevCommon member would work */
 241     ChardevCommon *common = backend ? backend->u.null.data : NULL;
 242
 243     if (common && common->logfile) {
 244         int flags = O_WRONLY;
 245         if (common->has_logappend &&
 246             common->logappend) {
 247             flags |= O_APPEND;
 248         } else {
 249             flags |= O_TRUNC;
 250         }
 251         chr->logfd = qemu_create(common->logfile, flags, 0666, errp);
 252         if (chr->logfd < 0) {
 253             return;
 254         }
 255     }
 256
 257     if (cc->open) {
 258         cc->open(chr, backend, be_opened, errp);
 259     }
 260 }
 261
 262 static void char_init(Object *obj)
 263 {
 264     Chardev *chr = CHARDEV(obj);
 265
 266     chr->handover_yank_instance = false;
 267     chr->logfd = -1;
 268     qemu_mutex_init(&chr->chr_write_lock);
 269
 270     /*
 271      * Assume if chr_update_read_handler is implemented it will
 272      * take the updated gcontext into account.
 273      */
 274     if (CHARDEV_GET_CLASS(chr)->chr_update_read_handler) {
 275         qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT);
 276     }
 277
 278 }
 279
 280 static int null_chr_write(Chardev *chr, const uint8_t *buf, int len)
 281 {
 282     return len;
 283 }
 284
 285 static void char_class_init(ObjectClass *oc, void *data)
 286 {
 287     ChardevClass *cc = CHARDEV_CLASS(oc);
 288
 289     cc->chr_write = null_chr_write;
 290     cc->chr_be_event = chr_be_event;
 291 }
 292
 293 static void char_finalize(Object *obj)
 294 {
 295     Chardev *chr = CHARDEV(obj);
 296
 297     if (chr->be) {
 298         chr->be->chr = NULL;
 299     }
 300     g_free(chr->filename);
 301     g_free(chr->label);
 302     if (chr->logfd != -1) {
 303         close(chr->logfd);
 304     }
 305     qemu_mutex_destroy(&chr->chr_write_lock);
 306 }
 307
 308 static const TypeInfo char_type_info = {
 309     .name = TYPE_CHARDEV,
 310     .parent = TYPE_OBJECT,
 311     .instance_size = sizeof(Chardev),
 312     .instance_init = char_init,
 313     .instance_finalize = char_finalize,
 314     .abstract = true,
 315     .class_size = sizeof(ChardevClass),
 316     .class_init = char_class_init,
 317 };
 318
 319 static bool qemu_chr_is_busy(Chardev *s)
 320 {
 321     if (CHARDEV_IS_MUX(s)) {
 322         MuxChardev *d = MUX_CHARDEV(s);
 323         return d->mux_cnt >= 0;
 324     } else {
 325         return s->be != NULL;
 326     }
 327 }
 328
 329 int qemu_chr_wait_connected(Chardev *chr, Error **errp)
 330 {
 331     ChardevClass *cc = CHARDEV_GET_CLASS(chr);
 332
 333     if (cc->chr_wait_connected) {
 334         return cc->chr_wait_connected(chr, errp);
 335     }
 336
 337     return 0;
 338 }
 339
 340 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename,
 341                                 bool permit_mux_mon)
 342 {
 343     char host[65], port[33], width[8], height[8];
 344     int pos;
 345     const char *p;
 346     QemuOpts *opts;
 347     Error *local_err = NULL;
 348
 349     opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
 350     if (local_err) {
 351         error_report_err(local_err);
 352         return NULL;
 353     }
 354
 355     if (strstart(filename, "mon:", &p)) {
 356         if (!permit_mux_mon) {
 357             error_report("mon: isn't supported in this context");
 358             return NULL;
 359         }
 360         filename = p;
 361         qemu_opt_set(opts, "mux", "on", &error_abort);
 362         if (strcmp(filename, "stdio") == 0) {
 363             /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
 364              * but pass it to the guest.  Handle this only for compat syntax,
 365              * for -chardev syntax we have special option for this.
 366              * This is what -nographic did, redirecting+muxing serial+monitor
 367              * to stdio causing Ctrl+C to be passed to guest. */
 368             qemu_opt_set(opts, "signal", "off", &error_abort);
 369         }
 370     }
 371
 372     if (strcmp(filename, "null")    == 0 ||
 373         strcmp(filename, "pty")     == 0 ||
 374         strcmp(filename, "msmouse") == 0 ||
 375         strcmp(filename, "wctablet") == 0 ||
 376         strcmp(filename, "braille") == 0 ||
 377         strcmp(filename, "testdev") == 0 ||
 378         strcmp(filename, "stdio")   == 0) {
 379         qemu_opt_set(opts, "backend", filename, &error_abort);
 380         return opts;
 381     }
 382     if (strstart(filename, "vc", &p)) {
 383         qemu_opt_set(opts, "backend", "vc", &error_abort);
 384         if (*p == ':') {
 385             if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
 386                 /* pixels */
 387                 qemu_opt_set(opts, "width", width, &error_abort);
 388                 qemu_opt_set(opts, "height", height, &error_abort);
 389             } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
 390                 /* chars */
 391                 qemu_opt_set(opts, "cols", width, &error_abort);
 392                 qemu_opt_set(opts, "rows", height, &error_abort);
 393             } else {
 394                 goto fail;
 395             }
 396         }
 397         return opts;
 398     }
 399     if (strcmp(filename, "con:") == 0) {
 400         qemu_opt_set(opts, "backend", "console", &error_abort);
 401         return opts;
 402     }
 403     if (strstart(filename, "COM", NULL)) {
 404         qemu_opt_set(opts, "backend", "serial", &error_abort);
 405         qemu_opt_set(opts, "path", filename, &error_abort);
 406         return opts;
 407     }
 408     if (strstart(filename, "file:", &p)) {
 409         qemu_opt_set(opts, "backend", "file", &error_abort);
 410         qemu_opt_set(opts, "path", p, &error_abort);
 411         return opts;
 412     }
 413     if (strstart(filename, "pipe:", &p)) {
 414         qemu_opt_set(opts, "backend", "pipe", &error_abort);
 415         qemu_opt_set(opts, "path", p, &error_abort);
 416         return opts;
 417     }
 418     if (strstart(filename, "tcp:", &p) ||
 419         strstart(filename, "telnet:", &p) ||
 420         strstart(filename, "tn3270:", &p) ||
 421         strstart(filename, "websocket:", &p)) {
 422         if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
 423             host[0] = 0;
 424             if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
 425                 goto fail;
 426         }
 427         qemu_opt_set(opts, "backend", "socket", &error_abort);
 428         qemu_opt_set(opts, "host", host, &error_abort);
 429         qemu_opt_set(opts, "port", port, &error_abort);
 430         if (p[pos] == ',') {
 431             if (!qemu_opts_do_parse(opts, p + pos + 1, NULL, &local_err)) {
 432                 error_report_err(local_err);
 433                 goto fail;
 434             }
 435         }
 436         if (strstart(filename, "telnet:", &p)) {
 437             qemu_opt_set(opts, "telnet", "on", &error_abort);
 438         } else if (strstart(filename, "tn3270:", &p)) {
 439             qemu_opt_set(opts, "tn3270", "on", &error_abort);
 440         } else if (strstart(filename, "websocket:", &p)) {
 441             qemu_opt_set(opts, "websocket", "on", &error_abort);
 442         }
 443         return opts;
 444     }
 445     if (strstart(filename, "udp:", &p)) {
 446         qemu_opt_set(opts, "backend", "udp", &error_abort);
 447         if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
 448             host[0] = 0;
 449             if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
 450                 goto fail;
 451             }
 452         }
 453         qemu_opt_set(opts, "host", host, &error_abort);
 454         qemu_opt_set(opts, "port", port, &error_abort);
 455         if (p[pos] == '@') {
 456             p += pos + 1;
 457             if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
 458                 host[0] = 0;
 459                 if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
 460                     goto fail;
 461                 }
 462             }
 463             qemu_opt_set(opts, "localaddr", host, &error_abort);
 464             qemu_opt_set(opts, "localport", port, &error_abort);
 465         }
 466         return opts;
 467     }
 468     if (strstart(filename, "unix:", &p)) {
 469         qemu_opt_set(opts, "backend", "socket", &error_abort);
 470         if (!qemu_opts_do_parse(opts, p, "path", &local_err)) {
 471             error_report_err(local_err);
 472             goto fail;
 473         }
 474         return opts;
 475     }
 476     if (strstart(filename, "/dev/parport", NULL) ||
 477         strstart(filename, "/dev/ppi", NULL)) {
 478         qemu_opt_set(opts, "backend", "parallel", &error_abort);
 479         qemu_opt_set(opts, "path", filename, &error_abort);
 480         return opts;
 481     }
 482     if (strstart(filename, "/dev/", NULL)) {
 483         qemu_opt_set(opts, "backend", "serial", &error_abort);
 484         qemu_opt_set(opts, "path", filename, &error_abort);
 485         return opts;
 486     }
 487
 488     error_report("'%s' is not a valid char driver", filename);
 489
 490 fail:
 491     qemu_opts_del(opts);
 492     return NULL;
 493 }
 494
 495 void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
 496 {
 497     const char *logfile = qemu_opt_get(opts, "logfile");
 498
 499     backend->logfile = g_strdup(logfile);
 500     backend->has_logappend = true;
 501     backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
 502 }
 503
 504 static const ChardevClass *char_get_class(const char *driver, Error **errp)
 505 {
 506     ObjectClass *oc;
 507     const ChardevClass *cc;
 508     char *typename = g_strdup_printf("chardev-%s", driver);
 509
 510     oc = module_object_class_by_name(typename);
 511     g_free(typename);
 512
 513     if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
 514         error_setg(errp, "'%s' is not a valid char driver name", driver);
 515         return NULL;
 516     }
 517
 518     if (object_class_is_abstract(oc)) {
 519         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
 520                    "an abstract device type");
 521         return NULL;
 522     }
 523
 524     cc = CHARDEV_CLASS(oc);
 525     if (cc->internal) {
 526         error_setg(errp, "'%s' is not a valid char driver name", driver);
 527         return NULL;
 528     }
 529
 530     return cc;
 531 }
 532
 533 static struct ChardevAlias {
 534     const char *typename;
 535     const char *alias;
 536     bool deprecation_warning_printed;
 537 } chardev_alias_table[] = {
 538 #ifdef HAVE_CHARDEV_PARPORT
 539     { "parallel", "parport" },
 540 #endif
 541 #ifdef HAVE_CHARDEV_SERIAL
 542     { "serial", "tty" },
 543 #endif
 544 };
 545
 546 typedef struct ChadevClassFE {
 547     void (*fn)(const char *name, void *opaque);
 548     void *opaque;
 549 } ChadevClassFE;
 550
 551 static void
 552 chardev_class_foreach(ObjectClass *klass, void *opaque)
 553 {
 554     ChadevClassFE *fe = opaque;
 555
 556     assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
 557     if (CHARDEV_CLASS(klass)->internal) {
 558         return;
 559     }
 560
 561     fe->fn(object_class_get_name(klass) + 8, fe->opaque);
 562 }
 563
 564 static void
 565 chardev_name_foreach(void (*fn)(const char *name, void *opaque),
 566                      void *opaque)
 567 {
 568     ChadevClassFE fe = { .fn = fn, .opaque = opaque };
 569
 570     object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
 571 }
 572
 573 static void
 574 help_string_append(const char *name, void *opaque)
 575 {
 576     GString *str = opaque;
 577
 578     g_string_append_printf(str, "\n  %s", name);
 579 }
 580
 581 static const char *chardev_alias_translate(const char *name)
 582 {
 583     int i;
 584     for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) {
 585         if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
 586             if (!chardev_alias_table[i].deprecation_warning_printed) {
 587                 warn_report("The alias '%s' is deprecated, use '%s' instead",
 588                             name, chardev_alias_table[i].typename);
 589                 chardev_alias_table[i].deprecation_warning_printed = true;
 590             }
 591             return chardev_alias_table[i].typename;
 592         }
 593     }
 594     return name;
 595 }
 596
 597 ChardevBackend *qemu_chr_parse_opts(QemuOpts *opts, Error **errp)
 598 {
 599     Error *local_err = NULL;
 600     const ChardevClass *cc;
 601     ChardevBackend *backend = NULL;
 602     const char *name = chardev_alias_translate(qemu_opt_get(opts, "backend"));
 603
 604     if (name == NULL) {
 605         error_setg(errp, "chardev: \"%s\" missing backend",
 606                    qemu_opts_id(opts));
 607         return NULL;
 608     }
 609
 610     cc = char_get_class(name, errp);
 611     if (cc == NULL) {
 612         return NULL;
 613     }
 614
 615     backend = g_new0(ChardevBackend, 1);
 616     backend->type = CHARDEV_BACKEND_KIND_NULL;
 617
 618     if (cc->parse) {
 619         cc->parse(opts, backend, &local_err);
 620         if (local_err) {
 621             error_propagate(errp, local_err);
 622             qapi_free_ChardevBackend(backend);
 623             return NULL;
 624         }
 625     } else {
 626         ChardevCommon *ccom = g_new0(ChardevCommon, 1);
 627         qemu_chr_parse_common(opts, ccom);
 628         backend->u.null.data = ccom; /* Any ChardevCommon member would work */
 629     }
 630
 631     return backend;
 632 }
 633
 634 Chardev *qemu_chr_new_from_opts(QemuOpts *opts, GMainContext *context,
 635                                 Error **errp)
 636 {
 637     const ChardevClass *cc;
 638     Chardev *chr = NULL;
 639     ChardevBackend *backend = NULL;
 640     const char *name = chardev_alias_translate(qemu_opt_get(opts, "backend"));
 641     const char *id = qemu_opts_id(opts);
 642     char *bid = NULL;
 643
 644     if (name && is_help_option(name)) {
 645         GString *str = g_string_new("");
 646
 647         chardev_name_foreach(help_string_append, str);
 648
 649         qemu_printf("Available chardev backend types: %s\n", str->str);
 650         g_string_free(str, true);
 651         return NULL;
 652     }
 653
 654     if (id == NULL) {
 655         error_setg(errp, "chardev: no id specified");
 656         return NULL;
 657     }
 658
 659     backend = qemu_chr_parse_opts(opts, errp);
 660     if (backend == NULL) {
 661         return NULL;
 662     }
 663
 664     cc = char_get_class(name, errp);
 665     if (cc == NULL) {
 666         goto out;
 667     }
 668
 669     if (qemu_opt_get_bool(opts, "mux", 0)) {
 670         bid = g_strdup_printf("%s-base", id);
 671     }
 672
 673     chr = qemu_chardev_new(bid ? bid : id,
 674                            object_class_get_name(OBJECT_CLASS(cc)),
 675                            backend, context, errp);
 676
 677     if (chr == NULL) {
 678         goto out;
 679     }
 680
 681     if (bid) {
 682         Chardev *mux;
 683         qapi_free_ChardevBackend(backend);
 684         backend = g_new0(ChardevBackend, 1);
 685         backend->type = CHARDEV_BACKEND_KIND_MUX;
 686         backend->u.mux.data = g_new0(ChardevMux, 1);
 687         backend->u.mux.data->chardev = g_strdup(bid);
 688         mux = qemu_chardev_new(id, TYPE_CHARDEV_MUX, backend, context, errp);
 689         if (mux == NULL) {
 690             object_unparent(OBJECT(chr));
 691             chr = NULL;
 692             goto out;
 693         }
 694         chr = mux;
 695     }
 696
 697 out:
 698     qapi_free_ChardevBackend(backend);
 699     g_free(bid);
 700     return chr;
 701 }
 702
 703 Chardev *qemu_chr_new_noreplay(const char *label, const char *filename,
 704                                bool permit_mux_mon, GMainContext *context)
 705 {
 706     const char *p;
 707     Chardev *chr;
 708     QemuOpts *opts;
 709     Error *err = NULL;
 710
 711     if (strstart(filename, "chardev:", &p)) {
 712         return qemu_chr_find(p);
 713     }
 714
 715     opts = qemu_chr_parse_compat(label, filename, permit_mux_mon);
 716     if (!opts)
 717         return NULL;
 718
 719     chr = qemu_chr_new_from_opts(opts, context, &err);
 720     if (!chr) {
 721         error_report_err(err);
 722         goto out;
 723     }
 724
 725     if (qemu_opt_get_bool(opts, "mux", 0)) {
 726         assert(permit_mux_mon);
 727         monitor_init_hmp(chr, true, &err);
 728         if (err) {
 729             error_report_err(err);
 730             object_unparent(OBJECT(chr));
 731             chr = NULL;
 732             goto out;
 733         }
 734     }
 735
 736 out:
 737     qemu_opts_del(opts);
 738     return chr;
 739 }
 740
 741 static Chardev *qemu_chr_new_permit_mux_mon(const char *label,
 742                                           const char *filename,
 743                                           bool permit_mux_mon,
 744                                           GMainContext *context)
 745 {
 746     Chardev *chr;
 747     chr = qemu_chr_new_noreplay(label, filename, permit_mux_mon, context);
 748     if (chr) {
 749         if (replay_mode != REPLAY_MODE_NONE) {
 750             qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
 751         }
 752         if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
 753             error_report("Replay: ioctl is not supported "
 754                          "for serial devices yet");
 755         }
 756         replay_register_char_driver(chr);
 757     }
 758     return chr;
 759 }
 760
 761 Chardev *qemu_chr_new(const char *label, const char *filename,
 762                       GMainContext *context)
 763 {
 764     return qemu_chr_new_permit_mux_mon(label, filename, false, context);
 765 }
 766
 767 Chardev *qemu_chr_new_mux_mon(const char *label, const char *filename,
 768                               GMainContext *context)
 769 {
 770     return qemu_chr_new_permit_mux_mon(label, filename, true, context);
 771 }
 772
 773 static int qmp_query_chardev_foreach(Object *obj, void *data)
 774 {
 775     Chardev *chr = CHARDEV(obj);
 776     ChardevInfoList **list = data;
 777     ChardevInfo *value = g_malloc0(sizeof(*value));
 778
 779     value->label = g_strdup(chr->label);
 780     value->filename = g_strdup(chr->filename);
 781     value->frontend_open = chr->be && chr->be->fe_open;
 782
 783     QAPI_LIST_PREPEND(*list, value);
 784
 785     return 0;
 786 }
 787
 788 ChardevInfoList *qmp_query_chardev(Error **errp)
 789 {
 790     ChardevInfoList *chr_list = NULL;
 791
 792     object_child_foreach(get_chardevs_root(),
 793                          qmp_query_chardev_foreach, &chr_list);
 794
 795     return chr_list;
 796 }
 797
 798 static void
 799 qmp_prepend_backend(const char *name, void *opaque)
 800 {
 801     ChardevBackendInfoList **list = opaque;
 802     ChardevBackendInfo *value;
 803
 804     value = g_new0(ChardevBackendInfo, 1);
 805     value->name = g_strdup(name);
 806     QAPI_LIST_PREPEND(*list, value);
 807 }
 808
 809 ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
 810 {
 811     ChardevBackendInfoList *backend_list = NULL;
 812
 813     chardev_name_foreach(qmp_prepend_backend, &backend_list);
 814
 815     return backend_list;
 816 }
 817
 818 Chardev *qemu_chr_find(const char *name)
 819 {
 820     Object *obj = object_resolve_path_component(get_chardevs_root(), name);
 821
 822     return obj ? CHARDEV(obj) : NULL;
 823 }
 824
 825 QemuOptsList qemu_chardev_opts = {
 826     .name = "chardev",
 827     .implied_opt_name = "backend",
 828     .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
 829     .desc = {
 830         {
 831             .name = "backend",
 832             .type = QEMU_OPT_STRING,
 833         },{
 834             .name = "path",
 835             .type = QEMU_OPT_STRING,
 836         },{
 837             .name = "host",
 838             .type = QEMU_OPT_STRING,
 839         },{
 840             .name = "port",
 841             .type = QEMU_OPT_STRING,
 842         },{
 843             .name = "fd",
 844             .type = QEMU_OPT_STRING,
 845         },{
 846             .name = "localaddr",
 847             .type = QEMU_OPT_STRING,
 848         },{
 849             .name = "localport",
 850             .type = QEMU_OPT_STRING,
 851         },{
 852             .name = "to",
 853             .type = QEMU_OPT_NUMBER,
 854         },{
 855             .name = "ipv4",
 856             .type = QEMU_OPT_BOOL,
 857         },{
 858             .name = "ipv6",
 859             .type = QEMU_OPT_BOOL,
 860         },{
 861             .name = "wait",
 862             .type = QEMU_OPT_BOOL,
 863         },{
 864             .name = "server",
 865             .type = QEMU_OPT_BOOL,
 866         },{
 867             .name = "delay",
 868             .type = QEMU_OPT_BOOL,
 869         },{
 870             .name = "nodelay",
 871             .type = QEMU_OPT_BOOL,
 872         },{
 873             .name = "reconnect",
 874             .type = QEMU_OPT_NUMBER,
 875         },{
 876             .name = "telnet",
 877             .type = QEMU_OPT_BOOL,
 878         },{
 879             .name = "tn3270",
 880             .type = QEMU_OPT_BOOL,
 881         },{
 882             .name = "tls-creds",
 883             .type = QEMU_OPT_STRING,
 884         },{
 885             .name = "tls-authz",
 886             .type = QEMU_OPT_STRING,
 887         },{
 888             .name = "websocket",
 889             .type = QEMU_OPT_BOOL,
 890         },{
 891             .name = "width",
 892             .type = QEMU_OPT_NUMBER,
 893         },{
 894             .name = "height",
 895             .type = QEMU_OPT_NUMBER,
 896         },{
 897             .name = "cols",
 898             .type = QEMU_OPT_NUMBER,
 899         },{
 900             .name = "rows",
 901             .type = QEMU_OPT_NUMBER,
 902         },{
 903             .name = "mux",
 904             .type = QEMU_OPT_BOOL,
 905         },{
 906             .name = "signal",
 907             .type = QEMU_OPT_BOOL,
 908         },{
 909             .name = "name",
 910             .type = QEMU_OPT_STRING,
 911         },{
 912             .name = "debug",
 913             .type = QEMU_OPT_NUMBER,
 914         },{
 915             .name = "size",
 916             .type = QEMU_OPT_SIZE,
 917         },{
 918             .name = "chardev",
 919             .type = QEMU_OPT_STRING,
 920         },{
 921             .name = "append",
 922             .type = QEMU_OPT_BOOL,
 923         },{
 924             .name = "logfile",
 925             .type = QEMU_OPT_STRING,
 926         },{
 927             .name = "logappend",
 928             .type = QEMU_OPT_BOOL,
 929         },{
 930             .name = "mouse",
 931             .type = QEMU_OPT_BOOL,
 932         },{
 933             .name = "clipboard",
 934             .type = QEMU_OPT_BOOL,
 935 #ifdef CONFIG_LINUX
 936         },{
 937             .name = "tight",
 938             .type = QEMU_OPT_BOOL,
 939             .def_value_str = "on",
 940         },{
 941             .name = "abstract",
 942             .type = QEMU_OPT_BOOL,
 943 #endif
 944         },
 945         { /* end of list */ }
 946     },
 947 };
 948
 949 bool qemu_chr_has_feature(Chardev *chr,
 950                           ChardevFeature feature)
 951 {
 952     return test_bit(feature, chr->features);
 953 }
 954
 955 void qemu_chr_set_feature(Chardev *chr,
 956                            ChardevFeature feature)
 957 {
 958     return set_bit(feature, chr->features);
 959 }
 960
 961 static Chardev *chardev_new(const char *id, const char *typename,
 962                             ChardevBackend *backend,
 963                             GMainContext *gcontext,
 964                             bool handover_yank_instance,
 965                             Error **errp)
 966 {
 967     Object *obj;
 968     Chardev *chr = NULL;
 969     Error *local_err = NULL;
 970     bool be_opened = true;
 971
 972     assert(g_str_has_prefix(typename, "chardev-"));
 973     assert(id);
 974
 975     obj = object_new(typename);
 976     chr = CHARDEV(obj);
 977     chr->handover_yank_instance = handover_yank_instance;
 978     chr->label = g_strdup(id);
 979     chr->gcontext = gcontext;
 980
 981     qemu_char_open(chr, backend, &be_opened, &local_err);
 982     if (local_err) {
 983         error_propagate(errp, local_err);
 984         object_unref(obj);
 985         return NULL;
 986     }
 987
 988     if (!chr->filename) {
 989         chr->filename = g_strdup(typename + 8);
 990     }
 991     if (be_opened) {
 992         qemu_chr_be_event(chr, CHR_EVENT_OPENED);
 993     }
 994
 995     return chr;
 996 }
 997
 998 Chardev *qemu_chardev_new(const char *id, const char *typename,
 999                           ChardevBackend *backend,
1000                           GMainContext *gcontext,
1001                           Error **errp)
1002 {
1003     Chardev *chr;
1004     g_autofree char *genid = NULL;
1005
1006     if (!id) {
1007         genid = id_generate(ID_CHR);
1008         id = genid;
1009     }
1010
1011     chr = chardev_new(id, typename, backend, gcontext, false, errp);
1012     if (!chr) {
1013         return NULL;
1014     }
1015
1016     if (!object_property_try_add_child(get_chardevs_root(), id, OBJECT(chr),
1017                                        errp)) {
1018         object_unref(OBJECT(chr));
1019         return NULL;
1020     }
1021     object_unref(OBJECT(chr));
1022
1023     return chr;
1024 }
1025
1026 ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
1027                                Error **errp)
1028 {
1029     ERRP_GUARD();
1030     const ChardevClass *cc;
1031     ChardevReturn *ret;
1032     g_autoptr(Chardev) chr = NULL;
1033
1034     if (qemu_chr_find(id)) {
1035         error_setg(errp, "Chardev with id '%s' already exists", id);
1036         return NULL;
1037     }
1038
1039     cc = char_get_class(ChardevBackendKind_str(backend->type), errp);
1040     if (!cc) {
1041         goto err;
1042     }
1043
1044     chr = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc)),
1045                       backend, NULL, false, errp);
1046     if (!chr) {
1047         goto err;
1048     }
1049
1050     if (!object_property_try_add_child(get_chardevs_root(), id, OBJECT(chr),
1051                                        errp)) {
1052         goto err;
1053     }
1054
1055     ret = g_new0(ChardevReturn, 1);
1056     if (CHARDEV_IS_PTY(chr)) {
1057         ret->pty = g_strdup(chr->filename + 4);
1058     }
1059
1060     return ret;
1061
1062 err:
1063     error_prepend(errp, "Failed to add chardev '%s': ", id);
1064     return NULL;
1065 }
1066
1067 ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend,
1068                                   Error **errp)
1069 {
1070     CharBackend *be;
1071     const ChardevClass *cc, *cc_new;
1072     Chardev *chr, *chr_new;
1073     bool closed_sent = false;
1074     bool handover_yank_instance;
1075     ChardevReturn *ret;
1076
1077     chr = qemu_chr_find(id);
1078     if (!chr) {
1079         error_setg(errp, "Chardev '%s' does not exist", id);
1080         return NULL;
1081     }
1082
1083     if (CHARDEV_IS_MUX(chr)) {
1084         error_setg(errp, "Mux device hotswap not supported yet");
1085         return NULL;
1086     }
1087
1088     if (qemu_chr_replay(chr)) {
1089         error_setg(errp,
1090             "Chardev '%s' cannot be changed in record/replay mode", id);
1091         return NULL;
1092     }
1093
1094     be = chr->be;
1095     if (!be) {
1096         /* easy case */
1097         object_unparent(OBJECT(chr));
1098         return qmp_chardev_add(id, backend, errp);
1099     }
1100
1101     if (!be->chr_be_change) {
1102         error_setg(errp, "Chardev user does not support chardev hotswap");
1103         return NULL;
1104     }
1105
1106     cc = CHARDEV_GET_CLASS(chr);
1107     cc_new = char_get_class(ChardevBackendKind_str(backend->type), errp);
1108     if (!cc_new) {
1109         return NULL;
1110     }
1111
1112     /*
1113      * The new chardev should not register a yank instance if the current
1114      * chardev has registered one already.
1115      */
1116     handover_yank_instance = cc->supports_yank && cc_new->supports_yank;
1117
1118     chr_new = chardev_new(id, object_class_get_name(OBJECT_CLASS(cc_new)),
1119                           backend, chr->gcontext, handover_yank_instance, errp);
1120     if (!chr_new) {
1121         return NULL;
1122     }
1123
1124     if (chr->be_open && !chr_new->be_open) {
1125         qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
1126         closed_sent = true;
1127     }
1128
1129     chr->be = NULL;
1130     qemu_chr_fe_init(be, chr_new, &error_abort);
1131
1132     if (be->chr_be_change(be->opaque) < 0) {
1133         error_setg(errp, "Chardev '%s' change failed", chr_new->label);
1134         chr_new->be = NULL;
1135         qemu_chr_fe_init(be, chr, &error_abort);
1136         if (closed_sent) {
1137             qemu_chr_be_event(chr, CHR_EVENT_OPENED);
1138         }
1139         object_unref(OBJECT(chr_new));
1140         return NULL;
1141     }
1142
1143     /* change successfull, clean up */
1144     chr_new->handover_yank_instance = false;
1145
1146     /*
1147      * When the old chardev is freed, it should not unregister the yank
1148      * instance if the new chardev needs it.
1149      */
1150     chr->handover_yank_instance = handover_yank_instance;
1151
1152     object_unparent(OBJECT(chr));
1153     object_property_add_child(get_chardevs_root(), chr_new->label,
1154                               OBJECT(chr_new));
1155     object_unref(OBJECT(chr_new));
1156
1157     ret = g_new0(ChardevReturn, 1);
1158     if (CHARDEV_IS_PTY(chr_new)) {
1159         ret->pty = g_strdup(chr_new->filename + 4);
1160     }
1161
1162     return ret;
1163 }
1164
1165 void qmp_chardev_remove(const char *id, Error **errp)
1166 {
1167     Chardev *chr;
1168
1169     chr = qemu_chr_find(id);
1170     if (chr == NULL) {
1171         error_setg(errp, "Chardev '%s' not found", id);
1172         return;
1173     }
1174     if (qemu_chr_is_busy(chr)) {
1175         error_setg(errp, "Chardev '%s' is busy", id);
1176         return;
1177     }
1178     if (qemu_chr_replay(chr)) {
1179         error_setg(errp,
1180             "Chardev '%s' cannot be unplugged in record/replay mode", id);
1181         return;
1182     }
1183     object_unparent(OBJECT(chr));
1184 }
1185
1186 void qmp_chardev_send_break(const char *id, Error **errp)
1187 {
1188     Chardev *chr;
1189
1190     chr = qemu_chr_find(id);
1191     if (chr == NULL) {
1192         error_setg(errp, "Chardev '%s' not found", id);
1193         return;
1194     }
1195     qemu_chr_be_event(chr, CHR_EVENT_BREAK);
1196 }
1197
1198 /*
1199  * Add a timeout callback for the chardev (in milliseconds), return
1200  * the GSource object created. Please use this to add timeout hook for
1201  * chardev instead of g_timeout_add() and g_timeout_add_seconds(), to
1202  * make sure the gcontext that the task bound to is correct.
1203  */
1204 GSource *qemu_chr_timeout_add_ms(Chardev *chr, guint ms,
1205                                  GSourceFunc func, void *private)
1206 {
1207     GSource *source = g_timeout_source_new(ms);
1208
1209     assert(func);
1210     g_source_set_callback(source, func, private, NULL);
1211     g_source_attach(source, chr->gcontext);
1212
1213     return source;
1214 }
1215
1216 void qemu_chr_cleanup(void)
1217 {
1218     object_unparent(get_chardevs_root());
1219 }
1220
1221 static void register_types(void)
1222 {
1223     type_register_static(&char_type_info);
1224 }
1225
1226 type_init(register_types);