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