hw/char/xen_console.c

   1 /*
   2  *  Copyright (C) International Business Machines  Corp., 2005
   3  *  Author(s): Anthony Liguori <aliguori@us.ibm.com>
   4  *
   5  *  Copyright (C) Red Hat 2007
   6  *
   7  *  Xen Console
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; under version 2 of the License.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "qemu/osdep.h"
  23 #include "qemu/cutils.h"
  24 #include <sys/select.h>
  25 #include <termios.h>
  26
  27 #include "qapi/error.h"
  28 #include "sysemu/sysemu.h"
  29 #include "chardev/char-fe.h"
  30 #include "hw/xen/xen-backend.h"
  31 #include "hw/xen/xen-bus-helper.h"
  32 #include "hw/qdev-properties.h"
  33 #include "hw/qdev-properties-system.h"
  34 #include "hw/xen/interface/io/console.h"
  35 #include "hw/xen/interface/io/xs_wire.h"
  36 #include "hw/xen/interface/grant_table.h"
  37 #include "hw/i386/kvm/xen_primary_console.h"
  38 #include "trace.h"
  39
  40 struct buffer {
  41     uint8_t *data;
  42     size_t consumed;
  43     size_t size;
  44     size_t capacity;
  45     size_t max_capacity;
  46 };
  47
  48 struct XenConsole {
  49     struct XenDevice  xendev;  /* must be first */
  50     XenEventChannel   *event_channel;
  51     int               dev;
  52     struct buffer     buffer;
  53     char              *fe_path;
  54     unsigned int      ring_ref;
  55     void              *sring;
  56     CharBackend       chr;
  57     int               backlog;
  58 };
  59 typedef struct XenConsole XenConsole;
  60
  61 #define TYPE_XEN_CONSOLE_DEVICE "xen-console"
  62 OBJECT_DECLARE_SIMPLE_TYPE(XenConsole, XEN_CONSOLE_DEVICE)
  63
  64 static bool buffer_append(XenConsole *con)
  65 {
  66     struct buffer *buffer = &con->buffer;
  67     XENCONS_RING_IDX cons, prod, size;
  68     struct xencons_interface *intf = con->sring;
  69
  70     cons = intf->out_cons;
  71     prod = intf->out_prod;
  72     xen_mb();
  73
  74     size = prod - cons;
  75     if ((size == 0) || (size > sizeof(intf->out)))
  76         return false;
  77
  78     if ((buffer->capacity - buffer->size) < size) {
  79         buffer->capacity += (size + 1024);
  80         buffer->data = g_realloc(buffer->data, buffer->capacity);
  81     }
  82
  83     while (cons != prod)
  84         buffer->data[buffer->size++] = intf->out[
  85             MASK_XENCONS_IDX(cons++, intf->out)];
  86
  87     xen_mb();
  88     intf->out_cons = cons;
  89     xen_device_notify_event_channel(XEN_DEVICE(con), con->event_channel, NULL);
  90
  91     if (buffer->max_capacity &&
  92         buffer->size > buffer->max_capacity) {
  93         /* Discard the middle of the data. */
  94
  95         size_t over = buffer->size - buffer->max_capacity;
  96         uint8_t *maxpos = buffer->data + buffer->max_capacity;
  97
  98         memmove(maxpos - over, maxpos, over);
  99         buffer->data = g_realloc(buffer->data, buffer->max_capacity);
 100         buffer->size = buffer->capacity = buffer->max_capacity;
 101
 102         if (buffer->consumed > buffer->max_capacity - over)
 103             buffer->consumed = buffer->max_capacity - over;
 104     }
 105     return true;
 106 }
 107
 108 static void buffer_advance(struct buffer *buffer, size_t len)
 109 {
 110     buffer->consumed += len;
 111     if (buffer->consumed == buffer->size) {
 112         buffer->consumed = 0;
 113         buffer->size = 0;
 114     }
 115 }
 116
 117 static int ring_free_bytes(XenConsole *con)
 118 {
 119     struct xencons_interface *intf = con->sring;
 120     XENCONS_RING_IDX cons, prod, space;
 121
 122     cons = intf->in_cons;
 123     prod = intf->in_prod;
 124     xen_mb();
 125
 126     space = prod - cons;
 127     if (space > sizeof(intf->in))
 128         return 0; /* ring is screwed: ignore it */
 129
 130     return (sizeof(intf->in) - space);
 131 }
 132
 133 static int xencons_can_receive(void *opaque)
 134 {
 135     XenConsole *con = opaque;
 136     return ring_free_bytes(con);
 137 }
 138
 139 static void xencons_receive(void *opaque, const uint8_t *buf, int len)
 140 {
 141     XenConsole *con = opaque;
 142     struct xencons_interface *intf = con->sring;
 143     XENCONS_RING_IDX prod;
 144     int i, max;
 145
 146     max = ring_free_bytes(con);
 147     /* The can_receive() func limits this, but check again anyway */
 148     if (max < len)
 149         len = max;
 150
 151     prod = intf->in_prod;
 152     for (i = 0; i < len; i++) {
 153         intf->in[MASK_XENCONS_IDX(prod++, intf->in)] =
 154             buf[i];
 155     }
 156     xen_wmb();
 157     intf->in_prod = prod;
 158     xen_device_notify_event_channel(XEN_DEVICE(con), con->event_channel, NULL);
 159 }
 160
 161 static bool xencons_send(XenConsole *con)
 162 {
 163     ssize_t len, size;
 164
 165     size = con->buffer.size - con->buffer.consumed;
 166     if (qemu_chr_fe_backend_connected(&con->chr)) {
 167         len = qemu_chr_fe_write(&con->chr,
 168                                 con->buffer.data + con->buffer.consumed,
 169                                 size);
 170     } else {
 171         len = size;
 172     }
 173     if (len < 1) {
 174         if (!con->backlog) {
 175             con->backlog = 1;
 176         }
 177     } else {
 178         buffer_advance(&con->buffer, len);
 179         if (con->backlog && len == size) {
 180             con->backlog = 0;
 181         }
 182     }
 183     return len > 0;
 184 }
 185
 186 /* -------------------------------------------------------------------- */
 187
 188 static bool con_event(void *_xendev)
 189 {
 190     XenConsole *con = XEN_CONSOLE_DEVICE(_xendev);
 191     bool done_something;
 192
 193     if (xen_device_backend_get_state(&con->xendev) != XenbusStateConnected) {
 194         return false;
 195     }
 196
 197     done_something = buffer_append(con);
 198
 199     if (con->buffer.size - con->buffer.consumed) {
 200         done_something |= xencons_send(con);
 201     }
 202     return done_something;
 203 }
 204
 205 /* -------------------------------------------------------------------- */
 206
 207 static bool xen_console_connect(XenDevice *xendev, Error **errp)
 208 {
 209     ERRP_GUARD();
 210     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 211     unsigned int port, limit;
 212
 213     if (xen_device_frontend_scanf(xendev, "ring-ref", "%u",
 214                                   &con->ring_ref) != 1) {
 215         error_setg(errp, "failed to read ring-ref");
 216         return false;
 217     }
 218
 219     if (xen_device_frontend_scanf(xendev, "port", "%u", &port) != 1) {
 220         error_setg(errp, "failed to read remote port");
 221         return false;
 222     }
 223
 224     if (xen_device_frontend_scanf(xendev, "limit", "%u", &limit) == 1) {
 225         con->buffer.max_capacity = limit;
 226     }
 227
 228     con->event_channel = xen_device_bind_event_channel(xendev, port,
 229                                                        con_event,
 230                                                        con,
 231                                                        errp);
 232     if (!con->event_channel) {
 233         return false;
 234     }
 235
 236     switch (con->dev) {
 237     case 0:
 238         /*
 239          * The primary console is special. For real Xen the ring-ref is
 240          * actually a GFN which needs to be mapped as foreignmem.
 241          */
 242         if (xen_mode != XEN_EMULATE) {
 243             xen_pfn_t mfn = (xen_pfn_t)con->ring_ref;
 244             con->sring = qemu_xen_foreignmem_map(xendev->frontend_id, NULL,
 245                                                  PROT_READ | PROT_WRITE,
 246                                                  1, &mfn, NULL);
 247             if (!con->sring) {
 248                 error_setg(errp, "failed to map console page");
 249                 return false;
 250             }
 251             break;
 252         }
 253
 254         /*
 255          * For Xen emulation, we still follow the convention of ring-ref
 256          * holding the GFN, but we map the fixed GNTTAB_RESERVED_CONSOLE
 257          * grant ref because there is no implementation of foreignmem
 258          * operations for emulated mode. The emulation code which handles
 259          * the guest-side page and event channel also needs to be informed
 260          * of the backend event channel port, in order to reconnect to it
 261          * after a soft reset.
 262          */
 263         xen_primary_console_set_be_port(
 264             xen_event_channel_get_local_port(con->event_channel));
 265         con->ring_ref = GNTTAB_RESERVED_CONSOLE;
 266         /* fallthrough */
 267     default:
 268         con->sring = xen_device_map_grant_refs(xendev,
 269                                                &con->ring_ref, 1,
 270                                                PROT_READ | PROT_WRITE,
 271                                                errp);
 272         if (!con->sring) {
 273             error_prepend(errp, "failed to map console grant ref: ");
 274             return false;
 275         }
 276         break;
 277     }
 278
 279     trace_xen_console_connect(con->dev, con->ring_ref, port,
 280                               con->buffer.max_capacity);
 281
 282     qemu_chr_fe_set_handlers(&con->chr, xencons_can_receive,
 283                              xencons_receive, NULL, NULL, con, NULL,
 284                              true);
 285     return true;
 286 }
 287
 288 static void xen_console_disconnect(XenDevice *xendev, Error **errp)
 289 {
 290     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 291
 292     trace_xen_console_disconnect(con->dev);
 293
 294     qemu_chr_fe_set_handlers(&con->chr, NULL, NULL, NULL, NULL,
 295                              con, NULL, true);
 296
 297     if (con->event_channel) {
 298         xen_device_unbind_event_channel(xendev, con->event_channel,
 299                                         errp);
 300         con->event_channel = NULL;
 301
 302         if (xen_mode == XEN_EMULATE && !con->dev) {
 303             xen_primary_console_set_be_port(0);
 304         }
 305     }
 306
 307     if (con->sring) {
 308         if (!con->dev && xen_mode != XEN_EMULATE) {
 309             qemu_xen_foreignmem_unmap(con->sring, 1);
 310         } else {
 311             xen_device_unmap_grant_refs(xendev, con->sring,
 312                                         &con->ring_ref, 1, errp);
 313         }
 314         con->sring = NULL;
 315     }
 316 }
 317
 318 static void xen_console_frontend_changed(XenDevice *xendev,
 319                                          enum xenbus_state frontend_state,
 320                                          Error **errp)
 321 {
 322     ERRP_GUARD();
 323     enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
 324
 325     switch (frontend_state) {
 326     case XenbusStateInitialised:
 327     case XenbusStateConnected:
 328         if (backend_state == XenbusStateConnected) {
 329             break;
 330         }
 331
 332         xen_console_disconnect(xendev, errp);
 333         if (*errp) {
 334             break;
 335         }
 336
 337         if (!xen_console_connect(xendev, errp)) {
 338             xen_device_backend_set_state(xendev, XenbusStateClosing);
 339             break;
 340         }
 341
 342         xen_device_backend_set_state(xendev, XenbusStateConnected);
 343         break;
 344
 345     case XenbusStateClosing:
 346         xen_device_backend_set_state(xendev, XenbusStateClosing);
 347         break;
 348
 349     case XenbusStateClosed:
 350     case XenbusStateUnknown:
 351         xen_console_disconnect(xendev, errp);
 352         if (*errp) {
 353             break;
 354         }
 355
 356         xen_device_backend_set_state(xendev, XenbusStateClosed);
 357         break;
 358
 359     default:
 360         break;
 361     }
 362 }
 363
 364 static char *xen_console_get_name(XenDevice *xendev, Error **errp)
 365 {
 366     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 367
 368     if (con->dev == -1) {
 369         XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
 370         char fe_path[XENSTORE_ABS_PATH_MAX + 1];
 371         int idx = (xen_mode == XEN_EMULATE) ? 0 : 1;
 372         char *value;
 373
 374         /* Theoretically we could go up to INT_MAX here but that's overkill */
 375         while (idx < 100) {
 376             if (!idx) {
 377                 snprintf(fe_path, sizeof(fe_path),
 378                          "/local/domain/%u/console", xendev->frontend_id);
 379             } else {
 380                 snprintf(fe_path, sizeof(fe_path),
 381                          "/local/domain/%u/device/console/%u",
 382                          xendev->frontend_id, idx);
 383             }
 384             value = qemu_xen_xs_read(xenbus->xsh, XBT_NULL, fe_path, NULL);
 385             if (!value) {
 386                 if (errno == ENOENT) {
 387                     con->dev = idx;
 388                     goto found;
 389                 }
 390                 error_setg(errp, "cannot read %s: %s", fe_path,
 391                            strerror(errno));
 392                 return NULL;
 393             }
 394             free(value);
 395             idx++;
 396         }
 397         error_setg(errp, "cannot find device index for console device");
 398         return NULL;
 399     }
 400  found:
 401     return g_strdup_printf("%u", con->dev);
 402 }
 403
 404 static void xen_console_unrealize(XenDevice *xendev)
 405 {
 406     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 407
 408     trace_xen_console_unrealize(con->dev);
 409
 410     /* Disconnect from the frontend in case this has not already happened */
 411     xen_console_disconnect(xendev, NULL);
 412
 413     qemu_chr_fe_deinit(&con->chr, false);
 414 }
 415
 416 static void xen_console_realize(XenDevice *xendev, Error **errp)
 417 {
 418     ERRP_GUARD();
 419     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 420     Chardev *cs = qemu_chr_fe_get_driver(&con->chr);
 421     unsigned int u;
 422
 423     if (!cs) {
 424         error_setg(errp, "no backing character device");
 425         return;
 426     }
 427
 428     if (con->dev == -1) {
 429         error_setg(errp, "no device index provided");
 430         return;
 431     }
 432
 433     /*
 434      * The Xen primary console is special. The ring-ref is actually a GFN to
 435      * be mapped directly as foreignmem (not a grant ref), and the guest port
 436      * was allocated *for* the guest by the toolstack. The guest gets these
 437      * through HVMOP_get_param and can use the console long before it's got
 438      * XenStore up and running. We cannot create those for a true Xen guest,
 439      * but we can for Xen emulation.
 440      */
 441     if (!con->dev) {
 442         if (xen_mode == XEN_EMULATE) {
 443             xen_primary_console_create();
 444         } else if (xen_device_frontend_scanf(xendev, "ring-ref", "%u", &u)
 445                    != 1 ||
 446                    xen_device_frontend_scanf(xendev, "port", "%u", &u) != 1) {
 447             error_setg(errp, "cannot create primary Xen console");
 448             return;
 449         }
 450     }
 451
 452     trace_xen_console_realize(con->dev, object_get_typename(OBJECT(cs)));
 453
 454     if (CHARDEV_IS_PTY(cs)) {
 455         /* Strip the leading 'pty:' */
 456         xen_device_frontend_printf(xendev, "tty", "%s", cs->filename + 4);
 457     }
 458
 459     /* No normal PV driver initialization for the primary console under Xen */
 460     if (!con->dev && xen_mode != XEN_EMULATE) {
 461         xen_console_connect(xendev, errp);
 462     }
 463 }
 464
 465 static char *console_frontend_path(struct qemu_xs_handle *xenstore,
 466                                    unsigned int dom_id, unsigned int dev)
 467 {
 468     if (!dev) {
 469         return g_strdup_printf("/local/domain/%u/console", dom_id);
 470     } else {
 471         return g_strdup_printf("/local/domain/%u/device/console/%u", dom_id,
 472                                dev);
 473     }
 474 }
 475
 476 static char *xen_console_get_frontend_path(XenDevice *xendev, Error **errp)
 477 {
 478     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 479     XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
 480     char *ret = console_frontend_path(xenbus->xsh, xendev->frontend_id,
 481                                       con->dev);
 482
 483     if (!ret) {
 484         error_setg(errp, "failed to create frontend path");
 485     }
 486     return ret;
 487 }
 488
 489
 490 static Property xen_console_properties[] = {
 491     DEFINE_PROP_CHR("chardev", XenConsole, chr),
 492     DEFINE_PROP_INT32("idx", XenConsole, dev, -1),
 493     DEFINE_PROP_END_OF_LIST(),
 494 };
 495
 496 static void xen_console_class_init(ObjectClass *class, void *data)
 497 {
 498     DeviceClass *dev_class = DEVICE_CLASS(class);
 499     XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
 500
 501     xendev_class->backend = "console";
 502     xendev_class->device = "console";
 503     xendev_class->get_name = xen_console_get_name;
 504     xendev_class->realize = xen_console_realize;
 505     xendev_class->frontend_changed = xen_console_frontend_changed;
 506     xendev_class->unrealize = xen_console_unrealize;
 507     xendev_class->get_frontend_path = xen_console_get_frontend_path;
 508
 509     device_class_set_props(dev_class, xen_console_properties);
 510 }
 511
 512 static const TypeInfo xen_console_type_info = {
 513     .name = TYPE_XEN_CONSOLE_DEVICE,
 514     .parent = TYPE_XEN_DEVICE,
 515     .instance_size = sizeof(XenConsole),
 516     .class_init = xen_console_class_init,
 517 };
 518
 519 static void xen_console_register_types(void)
 520 {
 521     type_register_static(&xen_console_type_info);
 522 }
 523
 524 type_init(xen_console_register_types)
 525
 526 /* Called to instantiate a XenConsole when the backend is detected. */
 527 static void xen_console_device_create(XenBackendInstance *backend,
 528                                       QDict *opts, Error **errp)
 529 {
 530     ERRP_GUARD();
 531     XenBus *xenbus = xen_backend_get_bus(backend);
 532     const char *name = xen_backend_get_name(backend);
 533     unsigned long number;
 534     char *fe = NULL, *type = NULL, *output = NULL;
 535     char label[32];
 536     XenDevice *xendev = NULL;
 537     XenConsole *con;
 538     Chardev *cd = NULL;
 539     struct qemu_xs_handle *xsh = xenbus->xsh;
 540
 541     if (qemu_strtoul(name, NULL, 10, &number) || number > INT_MAX) {
 542         error_setg(errp, "failed to parse name '%s'", name);
 543         goto fail;
 544     }
 545
 546     trace_xen_console_device_create(number);
 547
 548     fe = console_frontend_path(xsh, xen_domid, number);
 549     if (fe == NULL) {
 550         error_setg(errp, "failed to generate frontend path");
 551         goto fail;
 552     }
 553
 554     if (xs_node_scanf(xsh, XBT_NULL, fe, "type", errp, "%ms", &type) != 1) {
 555         error_prepend(errp, "failed to read console device type: ");
 556         goto fail;
 557     }
 558
 559     if (strcmp(type, "ioemu")) {
 560         error_setg(errp, "declining to handle console type '%s'",
 561                    type);
 562         goto fail;
 563     }
 564
 565     xendev = XEN_DEVICE(qdev_new(TYPE_XEN_CONSOLE_DEVICE));
 566     con = XEN_CONSOLE_DEVICE(xendev);
 567
 568     con->dev = number;
 569
 570     snprintf(label, sizeof(label), "xencons%ld", number);
 571
 572     if (xs_node_scanf(xsh, XBT_NULL, fe, "output", NULL, "%ms", &output) == 1) {
 573         /*
 574          * FIXME: sure we want to support implicit
 575          * muxed monitors here?
 576          */
 577         cd = qemu_chr_new_mux_mon(label, output, NULL);
 578         if (!cd) {
 579             error_setg(errp, "console: No valid chardev found at '%s': ",
 580                        output);
 581             goto fail;
 582         }
 583     } else if (number) {
 584         cd = serial_hd(number);
 585         if (!cd) {
 586             error_prepend(errp, "console: No serial device #%ld found: ",
 587                           number);
 588             goto fail;
 589         }
 590     } else {
 591         /* No 'output' node on primary console: use null. */
 592         cd = qemu_chr_new(label, "null", NULL);
 593         if (!cd) {
 594             error_setg(errp, "console: failed to create null device");
 595             goto fail;
 596         }
 597     }
 598
 599     if (!qemu_chr_fe_init(&con->chr, cd, errp)) {
 600         error_prepend(errp, "console: failed to initialize backing chardev: ");
 601         goto fail;
 602     }
 603
 604     if (qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {
 605         xen_backend_set_device(backend, xendev);
 606         goto done;
 607     }
 608
 609     error_prepend(errp, "realization of console device %lu failed: ",
 610                   number);
 611
 612  fail:
 613     if (xendev) {
 614         object_unparent(OBJECT(xendev));
 615     }
 616  done:
 617     g_free(fe);
 618     free(type);
 619     free(output);
 620 }
 621
 622 static void xen_console_device_destroy(XenBackendInstance *backend,
 623                                        Error **errp)
 624 {
 625     ERRP_GUARD();
 626     XenDevice *xendev = xen_backend_get_device(backend);
 627     XenConsole *con = XEN_CONSOLE_DEVICE(xendev);
 628
 629     trace_xen_console_device_destroy(con->dev);
 630
 631     object_unparent(OBJECT(xendev));
 632 }
 633
 634 static const XenBackendInfo xen_console_backend_info  = {
 635     .type = "console",
 636     .create = xen_console_device_create,
 637     .destroy = xen_console_device_destroy,
 638 };
 639
 640 static void xen_console_register_backend(void)
 641 {
 642     xen_backend_register(&xen_console_backend_info);
 643 }
 644
 645 xen_backend_init(xen_console_register_backend);