f82e35e38c
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
215 lines
6.1 KiB
C
215 lines
6.1 KiB
C
/*
|
|
* Virtio Serial / Console Support
|
|
*
|
|
* Copyright IBM, Corp. 2008
|
|
* Copyright Red Hat, Inc. 2009, 2010
|
|
*
|
|
* Authors:
|
|
* Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
|
|
* Amit Shah <amit.shah@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
* the COPYING file in the top-level directory.
|
|
*
|
|
*/
|
|
#ifndef _QEMU_VIRTIO_SERIAL_H
|
|
#define _QEMU_VIRTIO_SERIAL_H
|
|
|
|
#include "qdev.h"
|
|
#include "virtio.h"
|
|
|
|
/* == Interface shared between the guest kernel and qemu == */
|
|
|
|
/* The Virtio ID for virtio console / serial ports */
|
|
#define VIRTIO_ID_CONSOLE 3
|
|
|
|
/* Features supported */
|
|
#define VIRTIO_CONSOLE_F_MULTIPORT 1
|
|
|
|
#define VIRTIO_CONSOLE_BAD_ID (~(uint32_t)0)
|
|
|
|
struct virtio_console_config {
|
|
/*
|
|
* These two fields are used by VIRTIO_CONSOLE_F_SIZE which
|
|
* isn't implemented here yet
|
|
*/
|
|
uint16_t cols;
|
|
uint16_t rows;
|
|
|
|
uint32_t max_nr_ports;
|
|
} QEMU_PACKED;
|
|
|
|
struct virtio_console_control {
|
|
uint32_t id; /* Port number */
|
|
uint16_t event; /* The kind of control event (see below) */
|
|
uint16_t value; /* Extra information for the key */
|
|
};
|
|
|
|
struct virtio_serial_conf {
|
|
/* Max. number of ports we can have for a virtio-serial device */
|
|
uint32_t max_virtserial_ports;
|
|
};
|
|
|
|
/* Some events for the internal messages (control packets) */
|
|
#define VIRTIO_CONSOLE_DEVICE_READY 0
|
|
#define VIRTIO_CONSOLE_PORT_ADD 1
|
|
#define VIRTIO_CONSOLE_PORT_REMOVE 2
|
|
#define VIRTIO_CONSOLE_PORT_READY 3
|
|
#define VIRTIO_CONSOLE_CONSOLE_PORT 4
|
|
#define VIRTIO_CONSOLE_RESIZE 5
|
|
#define VIRTIO_CONSOLE_PORT_OPEN 6
|
|
#define VIRTIO_CONSOLE_PORT_NAME 7
|
|
|
|
/* == In-qemu interface == */
|
|
|
|
#define TYPE_VIRTIO_SERIAL_PORT "virtio-serial-port"
|
|
#define VIRTIO_SERIAL_PORT(obj) \
|
|
OBJECT_CHECK(VirtIOSerialPort, (obj), TYPE_VIRTIO_SERIAL_PORT)
|
|
#define VIRTIO_SERIAL_PORT_CLASS(klass) \
|
|
OBJECT_CLASS_CHECK(VirtIOSerialPortClass, (klass), TYPE_VIRTIO_SERIAL_PORT)
|
|
#define VIRTIO_SERIAL_PORT_GET_CLASS(obj) \
|
|
OBJECT_GET_CLASS(VirtIOSerialPortClass, (obj), TYPE_VIRTIO_SERIAL_PORT)
|
|
|
|
typedef struct VirtIOSerial VirtIOSerial;
|
|
typedef struct VirtIOSerialBus VirtIOSerialBus;
|
|
typedef struct VirtIOSerialPort VirtIOSerialPort;
|
|
|
|
typedef struct VirtIOSerialPortClass {
|
|
DeviceClass parent_class;
|
|
|
|
/* Is this a device that binds with hvc in the guest? */
|
|
bool is_console;
|
|
|
|
/*
|
|
* The per-port (or per-app) init function that's called when a
|
|
* new device is found on the bus.
|
|
*/
|
|
int (*init)(VirtIOSerialPort *port);
|
|
/*
|
|
* Per-port exit function that's called when a port gets
|
|
* hot-unplugged or removed.
|
|
*/
|
|
int (*exit)(VirtIOSerialPort *port);
|
|
|
|
/* Callbacks for guest events */
|
|
/* Guest opened device. */
|
|
void (*guest_open)(VirtIOSerialPort *port);
|
|
/* Guest closed device. */
|
|
void (*guest_close)(VirtIOSerialPort *port);
|
|
|
|
/* Guest is now ready to accept data (virtqueues set up). */
|
|
void (*guest_ready)(VirtIOSerialPort *port);
|
|
|
|
/*
|
|
* Guest wrote some data to the port. This data is handed over to
|
|
* the app via this callback. The app can return a size less than
|
|
* 'len'. In this case, throttling will be enabled for this port.
|
|
*/
|
|
ssize_t (*have_data)(VirtIOSerialPort *port, const uint8_t *buf,
|
|
size_t len);
|
|
} VirtIOSerialPortClass;
|
|
|
|
/*
|
|
* This is the state that's shared between all the ports. Some of the
|
|
* state is configurable via command-line options. Some of it can be
|
|
* set by individual devices in their initfn routines. Some of the
|
|
* state is set by the generic qdev device init routine.
|
|
*/
|
|
struct VirtIOSerialPort {
|
|
DeviceState dev;
|
|
|
|
QTAILQ_ENTRY(VirtIOSerialPort) next;
|
|
|
|
/*
|
|
* This field gives us the virtio device as well as the qdev bus
|
|
* that we are associated with
|
|
*/
|
|
VirtIOSerial *vser;
|
|
|
|
VirtQueue *ivq, *ovq;
|
|
|
|
/*
|
|
* This name is sent to the guest and exported via sysfs.
|
|
* The guest could create symlinks based on this information.
|
|
* The name is in the reverse fqdn format, like org.qemu.console.0
|
|
*/
|
|
char *name;
|
|
|
|
/*
|
|
* This id helps identify ports between the guest and the host.
|
|
* The guest sends a "header" with this id with each data packet
|
|
* that it sends and the host can then find out which associated
|
|
* device to send out this data to
|
|
*/
|
|
uint32_t id;
|
|
|
|
/*
|
|
* This is the elem that we pop from the virtqueue. A slow
|
|
* backend that consumes guest data (e.g. the file backend for
|
|
* qemu chardevs) can cause the guest to block till all the output
|
|
* is flushed. This isn't desired, so we keep a note of the last
|
|
* element popped and continue consuming it once the backend
|
|
* becomes writable again.
|
|
*/
|
|
VirtQueueElement elem;
|
|
|
|
/*
|
|
* The index and the offset into the iov buffer that was popped in
|
|
* elem above.
|
|
*/
|
|
uint32_t iov_idx;
|
|
uint64_t iov_offset;
|
|
|
|
/*
|
|
* When unthrottling we use a bottom-half to call flush_queued_data.
|
|
*/
|
|
QEMUBH *bh;
|
|
|
|
/* Is the corresponding guest device open? */
|
|
bool guest_connected;
|
|
/* Is this device open for IO on the host? */
|
|
bool host_connected;
|
|
/* Do apps not want to receive data? */
|
|
bool throttled;
|
|
};
|
|
|
|
/* Interface to the virtio-serial bus */
|
|
|
|
/*
|
|
* Individual ports/apps should call this function to register the port
|
|
* with the virtio-serial bus
|
|
*/
|
|
void virtio_serial_port_qdev_register(DeviceInfo *info);
|
|
|
|
/*
|
|
* Open a connection to the port
|
|
* Returns 0 on success (always).
|
|
*/
|
|
int virtio_serial_open(VirtIOSerialPort *port);
|
|
|
|
/*
|
|
* Close the connection to the port
|
|
* Returns 0 on success (always).
|
|
*/
|
|
int virtio_serial_close(VirtIOSerialPort *port);
|
|
|
|
/*
|
|
* Send data to Guest
|
|
*/
|
|
ssize_t virtio_serial_write(VirtIOSerialPort *port, const uint8_t *buf,
|
|
size_t size);
|
|
|
|
/*
|
|
* Query whether a guest is ready to receive data.
|
|
*/
|
|
size_t virtio_serial_guest_ready(VirtIOSerialPort *port);
|
|
|
|
/*
|
|
* Flow control: Ports can signal to the virtio-serial core to stop
|
|
* sending data or re-start sending data, depending on the 'throttle'
|
|
* value here.
|
|
*/
|
|
void virtio_serial_throttle_port(VirtIOSerialPort *port, bool throttle);
|
|
|
|
#endif
|