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