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