chardev/char.c

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