chardev/char.c

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