hw/virtio-serial-bus.c

   1 /*
   2  * A bus for connecting virtio serial and console ports
   3  *
   4  * Copyright (C) 2009 Red Hat, Inc.
   5  *
   6  * Author(s):
   7  *  Amit Shah <amit.shah@redhat.com>
   8  *
   9  * Some earlier parts are:
  10  *  Copyright IBM, Corp. 2008
  11  * authored by
  12  *  Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
  13  *
  14  * This work is licensed under the terms of the GNU GPL, version 2.  See
  15  * the COPYING file in the top-level directory.
  16  */
  17
  18 #include "monitor.h"
  19 #include "qemu-queue.h"
  20 #include "sysbus.h"
  21 #include "virtio-serial.h"
  22
  23 /* The virtio-serial bus on top of which the ports will ride as devices */
  24 struct VirtIOSerialBus {
  25     BusState qbus;
  26
  27     /* This is the parent device that provides the bus for ports. */
  28     VirtIOSerial *vser;
  29
  30     /* The maximum number of ports that can ride on top of this bus */
  31     uint32_t max_nr_ports;
  32 };
  33
  34 struct VirtIOSerial {
  35     VirtIODevice vdev;
  36
  37     VirtQueue *c_ivq, *c_ovq;
  38     /* Arrays of ivqs and ovqs: one per port */
  39     VirtQueue **ivqs, **ovqs;
  40
  41     VirtIOSerialBus *bus;
  42
  43     QTAILQ_HEAD(, VirtIOSerialPort) ports;
  44     struct virtio_console_config config;
  45 };
  46
  47 static VirtIOSerialPort *find_port_by_id(VirtIOSerial *vser, uint32_t id)
  48 {
  49     VirtIOSerialPort *port;
  50
  51     QTAILQ_FOREACH(port, &vser->ports, next) {
  52         if (port->id == id)
  53             return port;
  54     }
  55     return NULL;
  56 }
  57
  58 static VirtIOSerialPort *find_port_by_vq(VirtIOSerial *vser, VirtQueue *vq)
  59 {
  60     VirtIOSerialPort *port;
  61
  62     QTAILQ_FOREACH(port, &vser->ports, next) {
  63         if (port->ivq == vq || port->ovq == vq)
  64             return port;
  65     }
  66     return NULL;
  67 }
  68
  69 static size_t write_to_port(VirtIOSerialPort *port,
  70                             const uint8_t *buf, size_t size)
  71 {
  72     VirtQueueElement elem;
  73     VirtQueue *vq;
  74     size_t offset = 0;
  75     size_t len = 0;
  76
  77     vq = port->ivq;
  78     if (!virtio_queue_ready(vq)) {
  79         return 0;
  80     }
  81     if (!size) {
  82         return 0;
  83     }
  84
  85     while (offset < size) {
  86         int i;
  87
  88         if (!virtqueue_pop(vq, &elem)) {
  89             break;
  90         }
  91
  92         for (i = 0; offset < size && i < elem.in_num; i++) {
  93             len = MIN(elem.in_sg[i].iov_len, size - offset);
  94
  95             memcpy(elem.in_sg[i].iov_base, buf + offset, len);
  96             offset += len;
  97         }
  98         virtqueue_push(vq, &elem, len);
  99     }
 100
 101     virtio_notify(&port->vser->vdev, vq);
 102     return offset;
 103 }
 104
 105 static size_t send_control_msg(VirtIOSerialPort *port, void *buf, size_t len)
 106 {
 107     VirtQueueElement elem;
 108     VirtQueue *vq;
 109     struct virtio_console_control *cpkt;
 110
 111     vq = port->vser->c_ivq;
 112     if (!virtio_queue_ready(vq)) {
 113         return 0;
 114     }
 115     if (!virtqueue_pop(vq, &elem)) {
 116         return 0;
 117     }
 118
 119     cpkt = (struct virtio_console_control *)buf;
 120     stl_p(&cpkt->id, port->id);
 121     memcpy(elem.in_sg[0].iov_base, buf, len);
 122
 123     virtqueue_push(vq, &elem, len);
 124     virtio_notify(&port->vser->vdev, vq);
 125     return len;
 126 }
 127
 128 static size_t send_control_event(VirtIOSerialPort *port, uint16_t event,
 129                                  uint16_t value)
 130 {
 131     struct virtio_console_control cpkt;
 132
 133     stw_p(&cpkt.event, event);
 134     stw_p(&cpkt.value, value);
 135
 136     return send_control_msg(port, &cpkt, sizeof(cpkt));
 137 }
 138
 139 /* Functions for use inside qemu to open and read from/write to ports */
 140 int virtio_serial_open(VirtIOSerialPort *port)
 141 {
 142     return 0;
 143 }
 144
 145 int virtio_serial_close(VirtIOSerialPort *port)
 146 {
 147     return 0;
 148 }
 149
 150 /* Individual ports/apps call this function to write to the guest. */
 151 ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
 152                             size_t size)
 153 {
 154     return write_to_port(port, buf, size);
 155 }
 156
 157 /*
 158  * Readiness of the guest to accept data on a port.
 159  * Returns max. data the guest can receive
 160  */
 161 size_t virtio_serial_guest_ready(VirtIOSerialPort *port)
 162 {
 163     VirtQueue *vq = port->ivq;
 164
 165     if (!virtio_queue_ready(vq) ||
 166         !(port->vser->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) ||
 167         virtio_queue_empty(vq)) {
 168         return 0;
 169     }
 170
 171     if (virtqueue_avail_bytes(vq, 4096, 0)) {
 172         return 4096;
 173     }
 174     if (virtqueue_avail_bytes(vq, 1, 0)) {
 175         return 1;
 176     }
 177     return 0;
 178 }
 179
 180 /* Guest wants to notify us of some event */
 181 static void handle_control_message(VirtIOSerial *vser, void *buf)
 182 {
 183     struct VirtIOSerialPort *port;
 184     struct virtio_console_control cpkt, *gcpkt;
 185
 186     gcpkt = buf;
 187     port = find_port_by_id(vser, ldl_p(&gcpkt->id));
 188     if (!port)
 189         return;
 190
 191     cpkt.event = lduw_p(&gcpkt->event);
 192     cpkt.value = lduw_p(&gcpkt->value);
 193
 194     switch(cpkt.event) {
 195     case VIRTIO_CONSOLE_PORT_READY:
 196         /*
 197          * Now that we know the guest asked for the port name, we're
 198          * sure the guest has initialised whatever state is necessary
 199          * for this port. Now's a good time to let the guest know if
 200          * this port is a console port so that the guest can hook it
 201          * up to hvc.
 202          */
 203         if (port->is_console) {
 204             send_control_event(port, VIRTIO_CONSOLE_CONSOLE_PORT, 1);
 205         }
 206         /*
 207          * When the guest has asked us for this information it means
 208          * the guest is all setup and has its virtqueues
 209          * initialised. If some app is interested in knowing about
 210          * this event, let it know.
 211          */
 212         if (port->info->guest_ready) {
 213             port->info->guest_ready(port);
 214         }
 215         break;
 216     }
 217 }
 218
 219 static void control_in(VirtIODevice *vdev, VirtQueue *vq)
 220 {
 221 }
 222
 223 static void control_out(VirtIODevice *vdev, VirtQueue *vq)
 224 {
 225     VirtQueueElement elem;
 226     VirtIOSerial *vser;
 227
 228     vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
 229
 230     while (virtqueue_pop(vq, &elem)) {
 231         handle_control_message(vser, elem.out_sg[0].iov_base);
 232         virtqueue_push(vq, &elem, elem.out_sg[0].iov_len);
 233     }
 234     virtio_notify(vdev, vq);
 235 }
 236
 237 /* Guest wrote something to some port. */
 238 static void handle_output(VirtIODevice *vdev, VirtQueue *vq)
 239 {
 240     VirtIOSerial *vser;
 241     VirtQueueElement elem;
 242
 243     vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
 244
 245     while (virtqueue_pop(vq, &elem)) {
 246         VirtIOSerialPort *port;
 247         size_t ret;
 248
 249         port = find_port_by_vq(vser, vq);
 250         if (!port) {
 251             ret = 0;
 252             goto next_buf;
 253         }
 254
 255         /*
 256          * A port may not have any handler registered for consuming the
 257          * data that the guest sends or it may not have a chardev associated
 258          * with it. Just ignore the data in that case.
 259          */
 260         if (!port->info->have_data) {
 261             ret = 0;
 262             goto next_buf;
 263         }
 264
 265         /* The guest always sends only one sg */
 266         ret = port->info->have_data(port, elem.out_sg[0].iov_base,
 267                                     elem.out_sg[0].iov_len);
 268
 269     next_buf:
 270         virtqueue_push(vq, &elem, ret);
 271     }
 272     virtio_notify(vdev, vq);
 273 }
 274
 275 static void handle_input(VirtIODevice *vdev, VirtQueue *vq)
 276 {
 277 }
 278
 279 static uint32_t get_features(VirtIODevice *vdev, uint32_t features)
 280 {
 281     features |= (1 << VIRTIO_CONSOLE_F_MULTIPORT);
 282
 283     return features;
 284 }
 285
 286 /* Guest requested config info */
 287 static void get_config(VirtIODevice *vdev, uint8_t *config_data)
 288 {
 289     VirtIOSerial *vser;
 290
 291     vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
 292     memcpy(config_data, &vser->config, sizeof(struct virtio_console_config));
 293 }
 294
 295 static void set_config(VirtIODevice *vdev, const uint8_t *config_data)
 296 {
 297     struct virtio_console_config config;
 298
 299     memcpy(&config, config_data, sizeof(config));
 300 }
 301
 302 static void virtio_serial_save(QEMUFile *f, void *opaque)
 303 {
 304     VirtIOSerial *s = opaque;
 305
 306     /* The virtio device */
 307     virtio_save(&s->vdev, f);
 308
 309     /* The config space */
 310     qemu_put_be16s(f, &s->config.cols);
 311     qemu_put_be16s(f, &s->config.rows);
 312     qemu_put_be32s(f, &s->config.nr_ports);
 313 }
 314
 315 static int virtio_serial_load(QEMUFile *f, void *opaque, int version_id)
 316 {
 317     VirtIOSerial *s = opaque;
 318
 319     if (version_id > 2) {
 320         return -EINVAL;
 321     }
 322     /* The virtio device */
 323     virtio_load(&s->vdev, f);
 324
 325     if (version_id < 2) {
 326         return 0;
 327     }
 328
 329     /* The config space */
 330     qemu_get_be16s(f, &s->config.cols);
 331     qemu_get_be16s(f, &s->config.rows);
 332     s->config.nr_ports = qemu_get_be32(f);
 333
 334     return 0;
 335 }
 336
 337 static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
 338
 339 static struct BusInfo virtser_bus_info = {
 340     .name      = "virtio-serial-bus",
 341     .size      = sizeof(VirtIOSerialBus),
 342     .print_dev = virtser_bus_dev_print,
 343 };
 344
 345 static VirtIOSerialBus *virtser_bus_new(DeviceState *dev)
 346 {
 347     VirtIOSerialBus *bus;
 348
 349     bus = FROM_QBUS(VirtIOSerialBus, qbus_create(&virtser_bus_info, dev,
 350                                                  "virtio-serial-bus"));
 351     bus->qbus.allow_hotplug = 1;
 352
 353     return bus;
 354 }
 355
 356 static void virtser_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
 357 {
 358     VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev);
 359     VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);
 360
 361     monitor_printf(mon, "%*s dev-prop-int: id: %u\n",
 362                    indent, "", port->id);
 363 }
 364
 365 static int virtser_port_qdev_init(DeviceState *qdev, DeviceInfo *base)
 366 {
 367     VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev);
 368     VirtIOSerialPortInfo *info = DO_UPCAST(VirtIOSerialPortInfo, qdev, base);
 369     VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);
 370     VirtIOSerialBus *bus = DO_UPCAST(VirtIOSerialBus, qbus, qdev->parent_bus);
 371     int ret;
 372     bool plugging_port0;
 373
 374     port->vser = bus->vser;
 375
 376     /*
 377      * Is the first console port we're seeing? If so, put it up at
 378      * location 0. This is done for backward compatibility (old
 379      * kernel, new qemu).
 380      */
 381     plugging_port0 = port->is_console && !find_port_by_id(port->vser, 0);
 382
 383     if (port->vser->config.nr_ports == bus->max_nr_ports && !plugging_port0) {
 384         qemu_error("virtio-serial-bus: Maximum device limit reached\n");
 385         return -1;
 386     }
 387     dev->info = info;
 388
 389     ret = info->init(dev);
 390     if (ret) {
 391         return ret;
 392     }
 393
 394     port->id = plugging_port0 ? 0 : port->vser->config.nr_ports++;
 395
 396     QTAILQ_INSERT_TAIL(&port->vser->ports, port, next);
 397     port->ivq = port->vser->ivqs[port->id];
 398     port->ovq = port->vser->ovqs[port->id];
 399
 400     /* Send an update to the guest about this new port added */
 401     virtio_notify_config(&port->vser->vdev);
 402
 403     return ret;
 404 }
 405
 406 static int virtser_port_qdev_exit(DeviceState *qdev)
 407 {
 408     VirtIOSerialDevice *dev = DO_UPCAST(VirtIOSerialDevice, qdev, qdev);
 409     VirtIOSerialPort *port = DO_UPCAST(VirtIOSerialPort, dev, &dev->qdev);
 410     VirtIOSerial *vser = port->vser;
 411
 412     /*
 413      * Don't decrement nr_ports here; thus we keep a linearly
 414      * increasing port id. Not utilising an id again saves us a couple
 415      * of complications:
 416      *
 417      * - Not having to bother about sending the port id to the guest
 418      *   kernel on hotplug or on addition of new ports; the guest can
 419      *   also linearly increment the port number. This is preferable
 420      *   because the config space won't have the need to store a
 421      *   ports_map.
 422      *
 423      * - Extra state to be stored for all the "holes" that got created
 424      *   so that we keep filling in the ids from the least available
 425      *   index.
 426      *
 427      * When such a functionality is desired, a control message to add
 428      * a port can be introduced.
 429      */
 430     QTAILQ_REMOVE(&vser->ports, port, next);
 431
 432     if (port->info->exit)
 433         port->info->exit(dev);
 434
 435     return 0;
 436 }
 437
 438 void virtio_serial_port_qdev_register(VirtIOSerialPortInfo *info)
 439 {
 440     info->qdev.init = virtser_port_qdev_init;
 441     info->qdev.bus_info = &virtser_bus_info;
 442     info->qdev.exit = virtser_port_qdev_exit;
 443     info->qdev.unplug = qdev_simple_unplug_cb;
 444     qdev_register(&info->qdev);
 445 }
 446
 447 VirtIODevice *virtio_serial_init(DeviceState *dev, uint32_t max_nr_ports)
 448 {
 449     VirtIOSerial *vser;
 450     VirtIODevice *vdev;
 451     uint32_t i;
 452
 453     if (!max_nr_ports)
 454         return NULL;
 455
 456     vdev = virtio_common_init("virtio-serial", VIRTIO_ID_CONSOLE,
 457                               sizeof(struct virtio_console_config),
 458                               sizeof(VirtIOSerial));
 459
 460     vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
 461
 462     /* Spawn a new virtio-serial bus on which the ports will ride as devices */
 463     vser->bus = virtser_bus_new(dev);
 464     vser->bus->vser = vser;
 465     QTAILQ_INIT(&vser->ports);
 466
 467     vser->bus->max_nr_ports = max_nr_ports;
 468     vser->ivqs = qemu_malloc(max_nr_ports * sizeof(VirtQueue *));
 469     vser->ovqs = qemu_malloc(max_nr_ports * sizeof(VirtQueue *));
 470
 471     /* Add a queue for host to guest transfers for port 0 (backward compat) */
 472     vser->ivqs[0] = virtio_add_queue(vdev, 128, handle_input);
 473     /* Add a queue for guest to host transfers for port 0 (backward compat) */
 474     vser->ovqs[0] = virtio_add_queue(vdev, 128, handle_output);
 475
 476     /* control queue: host to guest */
 477     vser->c_ivq = virtio_add_queue(vdev, 16, control_in);
 478     /* control queue: guest to host */
 479     vser->c_ovq = virtio_add_queue(vdev, 16, control_out);
 480
 481     for (i = 1; i < vser->bus->max_nr_ports; i++) {
 482         /* Add a per-port queue for host to guest transfers */
 483         vser->ivqs[i] = virtio_add_queue(vdev, 128, handle_input);
 484         /* Add a per-per queue for guest to host transfers */
 485         vser->ovqs[i] = virtio_add_queue(vdev, 128, handle_output);
 486     }
 487
 488     vser->config.max_nr_ports = max_nr_ports;
 489     /*
 490      * Reserve location 0 for a console port for backward compat
 491      * (old kernel, new qemu)
 492      */
 493     vser->config.nr_ports = 1;
 494
 495     vser->vdev.get_features = get_features;
 496     vser->vdev.get_config = get_config;
 497     vser->vdev.set_config = set_config;
 498
 499     /*
 500      * Register for the savevm section with the virtio-console name
 501      * to preserve backward compat
 502      */
 503     register_savevm("virtio-console", -1, 2, virtio_serial_save,
 504                     virtio_serial_load, vser);
 505
 506     return vdev;
 507 }