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