Xen queue
* Fix build * xen-block: support feature-large-sector-size * xen-block: Support IOThread polling for PV shared rings * Avoid usage of a VLA * Cleanup Xen headers usage -----BEGIN PGP SIGNATURE----- iQFOBAABCgA4FiEE+AwAYwjiLP2KkueYDPVXL9f7Va8FAl0Q7JgaHGFudGhvbnku cGVyYXJkQGNpdHJpeC5jb20ACgkQDPVXL9f7Va8B1wf/bL9gdT/1R9474ZfbWAGZ KzkCo0C3jXUWRXd9z/UVwkmOhz0tLj1otx0fR+HFM4An+YAY6D0oZAKO9SCHhGDQ XflAK74dw1ieuZI+3Q5PXQO5xM1Oz0J+3TGlOFdZlh5UD68mEzteGnzU/zzs7i4E AZiKVOdO4YzMdHLVO4X/AqZH48n82FxjKcog7cZ9fTqDUz8SZGwJVSWocUZ0yOWb uhAacvhwHeZj64NuNShyF/RM7jolTk4CZWJv8Gy9CPxOM7noQIv0ttwu+QWCmODg pdTxd8HrE4rTnKaQFiHVas/AZ3cOfRw9RjdsARhXtGJq8AaQag9Q0iLZpyBYBfsF 6w== =MDEA -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/aperard/tags/pull-xen-20190624' into staging Xen queue * Fix build * xen-block: support feature-large-sector-size * xen-block: Support IOThread polling for PV shared rings * Avoid usage of a VLA * Cleanup Xen headers usage # gpg: Signature made Mon 24 Jun 2019 16:30:32 BST # gpg: using RSA key F80C006308E22CFD8A92E7980CF5572FD7FB55AF # gpg: issuer "anthony.perard@citrix.com" # gpg: Good signature from "Anthony PERARD <anthony.perard@gmail.com>" [marginal] # gpg: aka "Anthony PERARD <anthony.perard@citrix.com>" [marginal] # gpg: WARNING: This key is not certified with sufficiently trusted signatures! # gpg: It is not certain that the signature belongs to the owner. # Primary key fingerprint: 5379 2F71 024C 600F 778A 7161 D8D5 7199 DF83 42C8 # Subkey fingerprint: F80C 0063 08E2 2CFD 8A92 E798 0CF5 572F D7FB 55AF * remotes/aperard/tags/pull-xen-20190624: xen: Import other xen/io/*.h Revert xen/io/ring.h of "Clean up a few header guard symbols" xen: Drop includes of xen/hvm/params.h xen: Avoid VLA xen-bus / xen-block: add support for event channel polling xen-bus: allow AioContext to be specified for each event channel xen-bus: use a separate fd for each event channel xen-block: support feature-large-sector-size Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
commit
ab67678a59
|
|
@ -13,8 +13,8 @@
|
|||
#ifndef HW_9PFS_XEN_9PFS_H
|
||||
#define HW_9PFS_XEN_9PFS_H
|
||||
|
||||
#include <xen/io/protocols.h>
|
||||
#include "hw/xen/io/ring.h"
|
||||
#include "hw/xen/interface/io/protocols.h"
|
||||
#include "hw/xen/interface/io/ring.h"
|
||||
|
||||
/*
|
||||
* Do not merge into xen-9p-backend.c: clang doesn't allow unused static
|
||||
|
|
|
|||
|
|
@ -58,6 +58,7 @@ struct XenBlockDataPlane {
|
|||
int requests_inflight;
|
||||
unsigned int max_requests;
|
||||
BlockBackend *blk;
|
||||
unsigned int sector_size;
|
||||
QEMUBH *bh;
|
||||
IOThread *iothread;
|
||||
AioContext *ctx;
|
||||
|
|
@ -167,7 +168,7 @@ static int xen_block_parse_request(XenBlockRequest *request)
|
|||
goto err;
|
||||
}
|
||||
|
||||
request->start = request->req.sector_number * XEN_BLKIF_SECTOR_SIZE;
|
||||
request->start = request->req.sector_number * dataplane->sector_size;
|
||||
for (i = 0; i < request->req.nr_segments; i++) {
|
||||
if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) {
|
||||
error_report("error: nr_segments too big");
|
||||
|
|
@ -177,14 +178,14 @@ static int xen_block_parse_request(XenBlockRequest *request)
|
|||
error_report("error: first > last sector");
|
||||
goto err;
|
||||
}
|
||||
if (request->req.seg[i].last_sect * XEN_BLKIF_SECTOR_SIZE >=
|
||||
if (request->req.seg[i].last_sect * dataplane->sector_size >=
|
||||
XC_PAGE_SIZE) {
|
||||
error_report("error: page crossing");
|
||||
goto err;
|
||||
}
|
||||
|
||||
len = (request->req.seg[i].last_sect -
|
||||
request->req.seg[i].first_sect + 1) * XEN_BLKIF_SECTOR_SIZE;
|
||||
request->req.seg[i].first_sect + 1) * dataplane->sector_size;
|
||||
request->size += len;
|
||||
}
|
||||
if (request->start + request->size > blk_getlength(dataplane->blk)) {
|
||||
|
|
@ -218,17 +219,17 @@ static int xen_block_copy_request(XenBlockRequest *request)
|
|||
if (to_domain) {
|
||||
segs[i].dest.foreign.ref = request->req.seg[i].gref;
|
||||
segs[i].dest.foreign.offset = request->req.seg[i].first_sect *
|
||||
XEN_BLKIF_SECTOR_SIZE;
|
||||
dataplane->sector_size;
|
||||
segs[i].source.virt = virt;
|
||||
} else {
|
||||
segs[i].source.foreign.ref = request->req.seg[i].gref;
|
||||
segs[i].source.foreign.offset = request->req.seg[i].first_sect *
|
||||
XEN_BLKIF_SECTOR_SIZE;
|
||||
dataplane->sector_size;
|
||||
segs[i].dest.virt = virt;
|
||||
}
|
||||
segs[i].len = (request->req.seg[i].last_sect -
|
||||
request->req.seg[i].first_sect + 1) *
|
||||
XEN_BLKIF_SECTOR_SIZE;
|
||||
dataplane->sector_size;
|
||||
virt += segs[i].len;
|
||||
}
|
||||
|
||||
|
|
@ -317,7 +318,9 @@ static void xen_block_complete_aio(void *opaque, int ret)
|
|||
}
|
||||
xen_block_release_request(request);
|
||||
|
||||
qemu_bh_schedule(dataplane->bh);
|
||||
if (dataplane->more_work) {
|
||||
qemu_bh_schedule(dataplane->bh);
|
||||
}
|
||||
|
||||
done:
|
||||
aio_context_release(dataplane->ctx);
|
||||
|
|
@ -336,12 +339,12 @@ static bool xen_block_split_discard(XenBlockRequest *request,
|
|||
|
||||
/* Wrap around, or overflowing byte limit? */
|
||||
if (sec_start + sec_count < sec_count ||
|
||||
sec_start + sec_count > INT64_MAX / XEN_BLKIF_SECTOR_SIZE) {
|
||||
sec_start + sec_count > INT64_MAX / dataplane->sector_size) {
|
||||
return false;
|
||||
}
|
||||
|
||||
byte_offset = sec_start * XEN_BLKIF_SECTOR_SIZE;
|
||||
byte_remaining = sec_count * XEN_BLKIF_SECTOR_SIZE;
|
||||
byte_offset = sec_start * dataplane->sector_size;
|
||||
byte_remaining = sec_count * dataplane->sector_size;
|
||||
|
||||
do {
|
||||
byte_chunk = byte_remaining > BDRV_REQUEST_MAX_BYTES ?
|
||||
|
|
@ -514,12 +517,13 @@ static int xen_block_get_request(XenBlockDataPlane *dataplane,
|
|||
*/
|
||||
#define IO_PLUG_THRESHOLD 1
|
||||
|
||||
static void xen_block_handle_requests(XenBlockDataPlane *dataplane)
|
||||
static bool xen_block_handle_requests(XenBlockDataPlane *dataplane)
|
||||
{
|
||||
RING_IDX rc, rp;
|
||||
XenBlockRequest *request;
|
||||
int inflight_atstart = dataplane->requests_inflight;
|
||||
int batched = 0;
|
||||
bool done_something = false;
|
||||
|
||||
dataplane->more_work = 0;
|
||||
|
||||
|
|
@ -551,6 +555,7 @@ static void xen_block_handle_requests(XenBlockDataPlane *dataplane)
|
|||
}
|
||||
xen_block_get_request(dataplane, request, rc);
|
||||
dataplane->rings.common.req_cons = ++rc;
|
||||
done_something = true;
|
||||
|
||||
/* parse them */
|
||||
if (xen_block_parse_request(request) != 0) {
|
||||
|
|
@ -602,10 +607,7 @@ static void xen_block_handle_requests(XenBlockDataPlane *dataplane)
|
|||
blk_io_unplug(dataplane->blk);
|
||||
}
|
||||
|
||||
if (dataplane->more_work &&
|
||||
dataplane->requests_inflight < dataplane->max_requests) {
|
||||
qemu_bh_schedule(dataplane->bh);
|
||||
}
|
||||
return done_something;
|
||||
}
|
||||
|
||||
static void xen_block_dataplane_bh(void *opaque)
|
||||
|
|
@ -617,21 +619,23 @@ static void xen_block_dataplane_bh(void *opaque)
|
|||
aio_context_release(dataplane->ctx);
|
||||
}
|
||||
|
||||
static void xen_block_dataplane_event(void *opaque)
|
||||
static bool xen_block_dataplane_event(void *opaque)
|
||||
{
|
||||
XenBlockDataPlane *dataplane = opaque;
|
||||
|
||||
qemu_bh_schedule(dataplane->bh);
|
||||
return xen_block_handle_requests(dataplane);
|
||||
}
|
||||
|
||||
XenBlockDataPlane *xen_block_dataplane_create(XenDevice *xendev,
|
||||
BlockConf *conf,
|
||||
BlockBackend *blk,
|
||||
unsigned int sector_size,
|
||||
IOThread *iothread)
|
||||
{
|
||||
XenBlockDataPlane *dataplane = g_new0(XenBlockDataPlane, 1);
|
||||
|
||||
dataplane->xendev = xendev;
|
||||
dataplane->blk = conf->blk;
|
||||
dataplane->blk = blk;
|
||||
dataplane->sector_size = sector_size;
|
||||
|
||||
QLIST_INIT(&dataplane->inflight);
|
||||
QLIST_INIT(&dataplane->freelist);
|
||||
|
|
@ -803,7 +807,7 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane,
|
|||
}
|
||||
|
||||
dataplane->event_channel =
|
||||
xen_device_bind_event_channel(xendev, event_channel,
|
||||
xen_device_bind_event_channel(xendev, dataplane->ctx, event_channel,
|
||||
xen_block_dataplane_event, dataplane,
|
||||
&local_err);
|
||||
if (local_err) {
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@
|
|||
typedef struct XenBlockDataPlane XenBlockDataPlane;
|
||||
|
||||
XenBlockDataPlane *xen_block_dataplane_create(XenDevice *xendev,
|
||||
BlockConf *conf,
|
||||
BlockBackend *blk,
|
||||
unsigned int sector_size,
|
||||
IOThread *iothread);
|
||||
void xen_block_dataplane_destroy(XenBlockDataPlane *dataplane);
|
||||
void xen_block_dataplane_start(XenBlockDataPlane *dataplane,
|
||||
|
|
|
|||
|
|
@ -52,11 +52,25 @@ static void xen_block_connect(XenDevice *xendev, Error **errp)
|
|||
XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev);
|
||||
const char *type = object_get_typename(OBJECT(blockdev));
|
||||
XenBlockVdev *vdev = &blockdev->props.vdev;
|
||||
BlockConf *conf = &blockdev->props.conf;
|
||||
unsigned int feature_large_sector_size;
|
||||
unsigned int order, nr_ring_ref, *ring_ref, event_channel, protocol;
|
||||
char *str;
|
||||
|
||||
trace_xen_block_connect(type, vdev->disk, vdev->partition);
|
||||
|
||||
if (xen_device_frontend_scanf(xendev, "feature-large-sector-size", "%u",
|
||||
&feature_large_sector_size) != 1) {
|
||||
feature_large_sector_size = 0;
|
||||
}
|
||||
|
||||
if (feature_large_sector_size != 1 &&
|
||||
conf->logical_block_size != XEN_BLKIF_SECTOR_SIZE) {
|
||||
error_setg(errp, "logical_block_size != %u not supported by frontend",
|
||||
XEN_BLKIF_SECTOR_SIZE);
|
||||
return;
|
||||
}
|
||||
|
||||
if (xen_device_frontend_scanf(xendev, "ring-page-order", "%u",
|
||||
&order) != 1) {
|
||||
nr_ring_ref = 1;
|
||||
|
|
@ -150,7 +164,7 @@ static void xen_block_set_size(XenBlockDevice *blockdev)
|
|||
const char *type = object_get_typename(OBJECT(blockdev));
|
||||
XenBlockVdev *vdev = &blockdev->props.vdev;
|
||||
BlockConf *conf = &blockdev->props.conf;
|
||||
int64_t sectors = blk_getlength(conf->blk) / XEN_BLKIF_SECTOR_SIZE;
|
||||
int64_t sectors = blk_getlength(conf->blk) / conf->logical_block_size;
|
||||
XenDevice *xendev = XEN_DEVICE(blockdev);
|
||||
|
||||
trace_xen_block_size(type, vdev->disk, vdev->partition, sectors);
|
||||
|
|
@ -185,6 +199,7 @@ static void xen_block_realize(XenDevice *xendev, Error **errp)
|
|||
const char *type = object_get_typename(OBJECT(blockdev));
|
||||
XenBlockVdev *vdev = &blockdev->props.vdev;
|
||||
BlockConf *conf = &blockdev->props.conf;
|
||||
BlockBackend *blk = conf->blk;
|
||||
Error *local_err = NULL;
|
||||
|
||||
if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) {
|
||||
|
|
@ -206,8 +221,8 @@ static void xen_block_realize(XenDevice *xendev, Error **errp)
|
|||
* The blkif protocol does not deal with removable media, so it must
|
||||
* always be present, even for CDRom devices.
|
||||
*/
|
||||
assert(conf->blk);
|
||||
if (!blk_is_inserted(conf->blk)) {
|
||||
assert(blk);
|
||||
if (!blk_is_inserted(blk)) {
|
||||
error_setg(errp, "device needs media, but drive is empty");
|
||||
return;
|
||||
}
|
||||
|
|
@ -224,26 +239,20 @@ static void xen_block_realize(XenDevice *xendev, Error **errp)
|
|||
|
||||
blkconf_blocksizes(conf);
|
||||
|
||||
if (conf->logical_block_size != XEN_BLKIF_SECTOR_SIZE) {
|
||||
error_setg(errp, "logical_block_size != %u not supported",
|
||||
XEN_BLKIF_SECTOR_SIZE);
|
||||
return;
|
||||
}
|
||||
|
||||
if (conf->logical_block_size > conf->physical_block_size) {
|
||||
error_setg(
|
||||
errp, "logical_block_size > physical_block_size not supported");
|
||||
return;
|
||||
}
|
||||
|
||||
blk_set_dev_ops(conf->blk, &xen_block_dev_ops, blockdev);
|
||||
blk_set_guest_block_size(conf->blk, conf->logical_block_size);
|
||||
blk_set_dev_ops(blk, &xen_block_dev_ops, blockdev);
|
||||
blk_set_guest_block_size(blk, conf->logical_block_size);
|
||||
|
||||
if (conf->discard_granularity == -1) {
|
||||
conf->discard_granularity = conf->physical_block_size;
|
||||
}
|
||||
|
||||
if (blk_get_flags(conf->blk) & BDRV_O_UNMAP) {
|
||||
if (blk_get_flags(blk) & BDRV_O_UNMAP) {
|
||||
xen_device_backend_printf(xendev, "feature-discard", "%u", 1);
|
||||
xen_device_backend_printf(xendev, "discard-granularity", "%u",
|
||||
conf->discard_granularity);
|
||||
|
|
@ -260,12 +269,13 @@ static void xen_block_realize(XenDevice *xendev, Error **errp)
|
|||
blockdev->device_type);
|
||||
|
||||
xen_device_backend_printf(xendev, "sector-size", "%u",
|
||||
XEN_BLKIF_SECTOR_SIZE);
|
||||
conf->logical_block_size);
|
||||
|
||||
xen_block_set_size(blockdev);
|
||||
|
||||
blockdev->dataplane =
|
||||
xen_block_dataplane_create(xendev, conf, blockdev->props.iothread);
|
||||
xen_block_dataplane_create(xendev, blk, conf->logical_block_size,
|
||||
blockdev->props.iothread);
|
||||
}
|
||||
|
||||
static void xen_block_frontend_changed(XenDevice *xendev,
|
||||
|
|
|
|||
|
|
@ -1,9 +1,8 @@
|
|||
#ifndef XEN_BLKIF_H
|
||||
#define XEN_BLKIF_H
|
||||
|
||||
#include "hw/xen/io/ring.h"
|
||||
#include <xen/io/blkif.h>
|
||||
#include <xen/io/protocols.h>
|
||||
#include "hw/xen/interface/io/blkif.h"
|
||||
#include "hw/xen/interface/io/protocols.h"
|
||||
|
||||
/*
|
||||
* Not a real protocol. Used to generate ring structs which contain
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@
|
|||
#include "chardev/char-fe.h"
|
||||
#include "hw/xen/xen-legacy-backend.h"
|
||||
|
||||
#include <xen/io/console.h>
|
||||
#include "hw/xen/interface/io/console.h"
|
||||
|
||||
struct buffer {
|
||||
uint8_t *data;
|
||||
|
|
|
|||
|
|
@ -32,10 +32,9 @@
|
|||
#include "ui/console.h"
|
||||
#include "hw/xen/xen-legacy-backend.h"
|
||||
|
||||
#include <xen/event_channel.h>
|
||||
#include <xen/io/fbif.h>
|
||||
#include <xen/io/kbdif.h>
|
||||
#include <xen/io/protocols.h>
|
||||
#include "hw/xen/interface/io/fbif.h"
|
||||
#include "hw/xen/interface/io/kbdif.h"
|
||||
#include "hw/xen/interface/io/protocols.h"
|
||||
|
||||
#include "trace.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@
|
|||
#include "exec/address-spaces.h"
|
||||
|
||||
#include <xen/hvm/ioreq.h>
|
||||
#include <xen/hvm/params.h>
|
||||
#include <xen/hvm/e820.h>
|
||||
|
||||
//#define DEBUG_XEN_HVM
|
||||
|
|
@ -120,6 +119,8 @@ typedef struct XenIOState {
|
|||
DeviceListener device_listener;
|
||||
hwaddr free_phys_offset;
|
||||
const XenPhysmap *log_for_dirtybit;
|
||||
/* Buffer used by xen_sync_dirty_bitmap */
|
||||
unsigned long *dirty_bitmap;
|
||||
|
||||
Notifier exit;
|
||||
Notifier suspend;
|
||||
|
|
@ -465,6 +466,8 @@ static int xen_remove_from_physmap(XenIOState *state,
|
|||
QLIST_REMOVE(physmap, list);
|
||||
if (state->log_for_dirtybit == physmap) {
|
||||
state->log_for_dirtybit = NULL;
|
||||
g_free(state->dirty_bitmap);
|
||||
state->dirty_bitmap = NULL;
|
||||
}
|
||||
g_free(physmap);
|
||||
|
||||
|
|
@ -615,7 +618,7 @@ static void xen_sync_dirty_bitmap(XenIOState *state,
|
|||
{
|
||||
hwaddr npages = size >> TARGET_PAGE_BITS;
|
||||
const int width = sizeof(unsigned long) * 8;
|
||||
unsigned long bitmap[DIV_ROUND_UP(npages, width)];
|
||||
size_t bitmap_size = DIV_ROUND_UP(npages, width);
|
||||
int rc, i, j;
|
||||
const XenPhysmap *physmap = NULL;
|
||||
|
||||
|
|
@ -627,13 +630,14 @@ static void xen_sync_dirty_bitmap(XenIOState *state,
|
|||
|
||||
if (state->log_for_dirtybit == NULL) {
|
||||
state->log_for_dirtybit = physmap;
|
||||
state->dirty_bitmap = g_new(unsigned long, bitmap_size);
|
||||
} else if (state->log_for_dirtybit != physmap) {
|
||||
/* Only one range for dirty bitmap can be tracked. */
|
||||
return;
|
||||
}
|
||||
|
||||
rc = xen_track_dirty_vram(xen_domid, start_addr >> TARGET_PAGE_BITS,
|
||||
npages, bitmap);
|
||||
npages, state->dirty_bitmap);
|
||||
if (rc < 0) {
|
||||
#ifndef ENODATA
|
||||
#define ENODATA ENOENT
|
||||
|
|
@ -647,8 +651,8 @@ static void xen_sync_dirty_bitmap(XenIOState *state,
|
|||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(bitmap); i++) {
|
||||
unsigned long map = bitmap[i];
|
||||
for (i = 0; i < bitmap_size; i++) {
|
||||
unsigned long map = state->dirty_bitmap[i];
|
||||
while (map != 0) {
|
||||
j = ctzl(map);
|
||||
map &= ~(1ul << j);
|
||||
|
|
@ -678,6 +682,8 @@ static void xen_log_stop(MemoryListener *listener, MemoryRegionSection *section,
|
|||
|
||||
if (old & ~new & (1 << DIRTY_MEMORY_VGA)) {
|
||||
state->log_for_dirtybit = NULL;
|
||||
g_free(state->dirty_bitmap);
|
||||
state->dirty_bitmap = NULL;
|
||||
/* Disable dirty bit tracking */
|
||||
xen_track_dirty_vram(xen_domid, 0, 0, NULL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,8 +17,6 @@
|
|||
#include "hw/xen/xen-legacy-backend.h"
|
||||
#include "qemu/bitmap.h"
|
||||
|
||||
#include <xen/hvm/params.h>
|
||||
|
||||
#include "sysemu/xen-mapcache.h"
|
||||
#include "trace.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@
|
|||
#include "net/util.h"
|
||||
#include "hw/xen/xen-legacy-backend.h"
|
||||
|
||||
#include <xen/io/netif.h>
|
||||
#include "hw/xen/interface/io/netif.h"
|
||||
|
||||
/* ------------------------------------------------------------- */
|
||||
|
||||
|
|
|
|||
|
|
@ -32,8 +32,7 @@
|
|||
#include "qapi/qmp/qdict.h"
|
||||
#include "qapi/qmp/qstring.h"
|
||||
|
||||
#include "hw/xen/io/ring.h"
|
||||
#include <xen/io/usbif.h>
|
||||
#include "hw/xen/interface/io/usbif.h"
|
||||
|
||||
/*
|
||||
* Check for required support of usbif.h: USBIF_SHORT_NOT_OK was the last
|
||||
|
|
|
|||
|
|
@ -924,23 +924,35 @@ done:
|
|||
}
|
||||
|
||||
struct XenEventChannel {
|
||||
QLIST_ENTRY(XenEventChannel) list;
|
||||
AioContext *ctx;
|
||||
xenevtchn_handle *xeh;
|
||||
evtchn_port_t local_port;
|
||||
XenEventHandler handler;
|
||||
void *opaque;
|
||||
Notifier notifier;
|
||||
};
|
||||
|
||||
static void event_notify(Notifier *n, void *data)
|
||||
static bool xen_device_poll(void *opaque)
|
||||
{
|
||||
XenEventChannel *channel = container_of(n, XenEventChannel, notifier);
|
||||
unsigned long port = (unsigned long)data;
|
||||
XenEventChannel *channel = opaque;
|
||||
|
||||
return channel->handler(channel->opaque);
|
||||
}
|
||||
|
||||
static void xen_device_event(void *opaque)
|
||||
{
|
||||
XenEventChannel *channel = opaque;
|
||||
unsigned long port = xenevtchn_pending(channel->xeh);
|
||||
|
||||
if (port == channel->local_port) {
|
||||
channel->handler(channel->opaque);
|
||||
xen_device_poll(channel);
|
||||
|
||||
xenevtchn_unmask(channel->xeh, port);
|
||||
}
|
||||
}
|
||||
|
||||
XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
|
||||
AioContext *ctx,
|
||||
unsigned int port,
|
||||
XenEventHandler handler,
|
||||
void *opaque, Error **errp)
|
||||
|
|
@ -948,24 +960,40 @@ XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
|
|||
XenEventChannel *channel = g_new0(XenEventChannel, 1);
|
||||
xenevtchn_port_or_error_t local_port;
|
||||
|
||||
local_port = xenevtchn_bind_interdomain(xendev->xeh,
|
||||
channel->xeh = xenevtchn_open(NULL, 0);
|
||||
if (!channel->xeh) {
|
||||
error_setg_errno(errp, errno, "failed xenevtchn_open");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
local_port = xenevtchn_bind_interdomain(channel->xeh,
|
||||
xendev->frontend_id,
|
||||
port);
|
||||
if (local_port < 0) {
|
||||
error_setg_errno(errp, errno, "xenevtchn_bind_interdomain failed");
|
||||
|
||||
g_free(channel);
|
||||
return NULL;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
channel->local_port = local_port;
|
||||
channel->handler = handler;
|
||||
channel->opaque = opaque;
|
||||
channel->notifier.notify = event_notify;
|
||||
|
||||
notifier_list_add(&xendev->event_notifiers, &channel->notifier);
|
||||
channel->ctx = ctx;
|
||||
aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
|
||||
xen_device_event, NULL, xen_device_poll, channel);
|
||||
|
||||
QLIST_INSERT_HEAD(&xendev->event_channels, channel, list);
|
||||
|
||||
return channel;
|
||||
|
||||
fail:
|
||||
if (channel->xeh) {
|
||||
xenevtchn_close(channel->xeh);
|
||||
}
|
||||
|
||||
g_free(channel);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void xen_device_notify_event_channel(XenDevice *xendev,
|
||||
|
|
@ -977,7 +1005,7 @@ void xen_device_notify_event_channel(XenDevice *xendev,
|
|||
return;
|
||||
}
|
||||
|
||||
if (xenevtchn_notify(xendev->xeh, channel->local_port) < 0) {
|
||||
if (xenevtchn_notify(channel->xeh, channel->local_port) < 0) {
|
||||
error_setg_errno(errp, errno, "xenevtchn_notify failed");
|
||||
}
|
||||
}
|
||||
|
|
@ -991,12 +1019,16 @@ void xen_device_unbind_event_channel(XenDevice *xendev,
|
|||
return;
|
||||
}
|
||||
|
||||
notifier_remove(&channel->notifier);
|
||||
QLIST_REMOVE(channel, list);
|
||||
|
||||
if (xenevtchn_unbind(xendev->xeh, channel->local_port) < 0) {
|
||||
aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
|
||||
NULL, NULL, NULL, NULL);
|
||||
|
||||
if (xenevtchn_unbind(channel->xeh, channel->local_port) < 0) {
|
||||
error_setg_errno(errp, errno, "xenevtchn_unbind failed");
|
||||
}
|
||||
|
||||
xenevtchn_close(channel->xeh);
|
||||
g_free(channel);
|
||||
}
|
||||
|
||||
|
|
@ -1005,6 +1037,7 @@ static void xen_device_unrealize(DeviceState *dev, Error **errp)
|
|||
XenDevice *xendev = XEN_DEVICE(dev);
|
||||
XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev);
|
||||
const char *type = object_get_typename(OBJECT(xendev));
|
||||
XenEventChannel *channel, *next;
|
||||
|
||||
if (!xendev->name) {
|
||||
return;
|
||||
|
|
@ -1021,15 +1054,14 @@ static void xen_device_unrealize(DeviceState *dev, Error **errp)
|
|||
xendev_class->unrealize(xendev, errp);
|
||||
}
|
||||
|
||||
/* Make sure all event channels are cleaned up */
|
||||
QLIST_FOREACH_SAFE(channel, &xendev->event_channels, list, next) {
|
||||
xen_device_unbind_event_channel(xendev, channel, NULL);
|
||||
}
|
||||
|
||||
xen_device_frontend_destroy(xendev);
|
||||
xen_device_backend_destroy(xendev);
|
||||
|
||||
if (xendev->xeh) {
|
||||
qemu_set_fd_handler(xenevtchn_fd(xendev->xeh), NULL, NULL, NULL);
|
||||
xenevtchn_close(xendev->xeh);
|
||||
xendev->xeh = NULL;
|
||||
}
|
||||
|
||||
if (xendev->xgth) {
|
||||
xengnttab_close(xendev->xgth);
|
||||
xendev->xgth = NULL;
|
||||
|
|
@ -1046,16 +1078,6 @@ static void xen_device_exit(Notifier *n, void *data)
|
|||
xen_device_unrealize(DEVICE(xendev), &error_abort);
|
||||
}
|
||||
|
||||
static void xen_device_event(void *opaque)
|
||||
{
|
||||
XenDevice *xendev = opaque;
|
||||
unsigned long port = xenevtchn_pending(xendev->xeh);
|
||||
|
||||
notifier_list_notify(&xendev->event_notifiers, (void *)port);
|
||||
|
||||
xenevtchn_unmask(xendev->xeh, port);
|
||||
}
|
||||
|
||||
static void xen_device_realize(DeviceState *dev, Error **errp)
|
||||
{
|
||||
XenDevice *xendev = XEN_DEVICE(dev);
|
||||
|
|
@ -1096,16 +1118,6 @@ static void xen_device_realize(DeviceState *dev, Error **errp)
|
|||
xendev->feature_grant_copy =
|
||||
(xengnttab_grant_copy(xendev->xgth, 0, NULL) == 0);
|
||||
|
||||
xendev->xeh = xenevtchn_open(NULL, 0);
|
||||
if (!xendev->xeh) {
|
||||
error_setg_errno(errp, errno, "failed xenevtchn_open");
|
||||
goto unrealize;
|
||||
}
|
||||
|
||||
notifier_list_init(&xendev->event_notifiers);
|
||||
qemu_set_fd_handler(xenevtchn_fd(xendev->xeh), xen_device_event, NULL,
|
||||
xendev);
|
||||
|
||||
xen_device_backend_create(xendev, &local_err);
|
||||
if (local_err) {
|
||||
error_propagate(errp, local_err);
|
||||
|
|
|
|||
|
|
@ -34,8 +34,6 @@
|
|||
#include "hw/xen/xen_pvdev.h"
|
||||
#include "monitor/qdev.h"
|
||||
|
||||
#include <xen/grant_table.h>
|
||||
|
||||
DeviceState *xen_sysdev;
|
||||
BusState *xen_sysbus;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,36 @@
|
|||
/******************************************************************************
|
||||
* grant_table.h
|
||||
*
|
||||
* Interface for granting foreign access to page frames, and receiving
|
||||
* page-ownership transfers.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (c) 2004, K A Fraser
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PUBLIC_GRANT_TABLE_H__
|
||||
#define __XEN_PUBLIC_GRANT_TABLE_H__
|
||||
|
||||
/*
|
||||
* Reference to a grant entry in a specified domain's grant table.
|
||||
*/
|
||||
typedef uint32_t grant_ref_t;
|
||||
|
||||
#endif /* __XEN_PUBLIC_GRANT_TABLE_H__ */
|
||||
|
|
@ -0,0 +1,712 @@
|
|||
/******************************************************************************
|
||||
* blkif.h
|
||||
*
|
||||
* Unified block-device I/O interface for Xen guest OSes.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (c) 2003-2004, Keir Fraser
|
||||
* Copyright (c) 2012, Spectra Logic Corporation
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PUBLIC_IO_BLKIF_H__
|
||||
#define __XEN_PUBLIC_IO_BLKIF_H__
|
||||
|
||||
#include "ring.h"
|
||||
#include "../grant_table.h"
|
||||
|
||||
/*
|
||||
* Front->back notifications: When enqueuing a new request, sending a
|
||||
* notification can be made conditional on req_event (i.e., the generic
|
||||
* hold-off mechanism provided by the ring macros). Backends must set
|
||||
* req_event appropriately (e.g., using RING_FINAL_CHECK_FOR_REQUESTS()).
|
||||
*
|
||||
* Back->front notifications: When enqueuing a new response, sending a
|
||||
* notification can be made conditional on rsp_event (i.e., the generic
|
||||
* hold-off mechanism provided by the ring macros). Frontends must set
|
||||
* rsp_event appropriately (e.g., using RING_FINAL_CHECK_FOR_RESPONSES()).
|
||||
*/
|
||||
|
||||
#ifndef blkif_vdev_t
|
||||
#define blkif_vdev_t uint16_t
|
||||
#endif
|
||||
#define blkif_sector_t uint64_t
|
||||
|
||||
/*
|
||||
* Feature and Parameter Negotiation
|
||||
* =================================
|
||||
* The two halves of a Xen block driver utilize nodes within the XenStore to
|
||||
* communicate capabilities and to negotiate operating parameters. This
|
||||
* section enumerates these nodes which reside in the respective front and
|
||||
* backend portions of the XenStore, following the XenBus convention.
|
||||
*
|
||||
* All data in the XenStore is stored as strings. Nodes specifying numeric
|
||||
* values are encoded in decimal. Integer value ranges listed below are
|
||||
* expressed as fixed sized integer types capable of storing the conversion
|
||||
* of a properly formated node string, without loss of information.
|
||||
*
|
||||
* Any specified default value is in effect if the corresponding XenBus node
|
||||
* is not present in the XenStore.
|
||||
*
|
||||
* XenStore nodes in sections marked "PRIVATE" are solely for use by the
|
||||
* driver side whose XenBus tree contains them.
|
||||
*
|
||||
* XenStore nodes marked "DEPRECATED" in their notes section should only be
|
||||
* used to provide interoperability with legacy implementations.
|
||||
*
|
||||
* See the XenBus state transition diagram below for details on when XenBus
|
||||
* nodes must be published and when they can be queried.
|
||||
*
|
||||
*****************************************************************************
|
||||
* Backend XenBus Nodes
|
||||
*****************************************************************************
|
||||
*
|
||||
*------------------ Backend Device Identification (PRIVATE) ------------------
|
||||
*
|
||||
* mode
|
||||
* Values: "r" (read only), "w" (writable)
|
||||
*
|
||||
* The read or write access permissions to the backing store to be
|
||||
* granted to the frontend.
|
||||
*
|
||||
* params
|
||||
* Values: string
|
||||
*
|
||||
* A free formatted string providing sufficient information for the
|
||||
* hotplug script to attach the device and provide a suitable
|
||||
* handler (ie: a block device) for blkback to use.
|
||||
*
|
||||
* physical-device
|
||||
* Values: "MAJOR:MINOR"
|
||||
* Notes: 11
|
||||
*
|
||||
* MAJOR and MINOR are the major number and minor number of the
|
||||
* backing device respectively.
|
||||
*
|
||||
* physical-device-path
|
||||
* Values: path string
|
||||
*
|
||||
* A string that contains the absolute path to the disk image. On
|
||||
* NetBSD and Linux this is always a block device, while on FreeBSD
|
||||
* it can be either a block device or a regular file.
|
||||
*
|
||||
* type
|
||||
* Values: "file", "phy", "tap"
|
||||
*
|
||||
* The type of the backing device/object.
|
||||
*
|
||||
*
|
||||
* direct-io-safe
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
*
|
||||
* The underlying storage is not affected by the direct IO memory
|
||||
* lifetime bug. See:
|
||||
* http://lists.xen.org/archives/html/xen-devel/2012-12/msg01154.html
|
||||
*
|
||||
* Therefore this option gives the backend permission to use
|
||||
* O_DIRECT, notwithstanding that bug.
|
||||
*
|
||||
* That is, if this option is enabled, use of O_DIRECT is safe,
|
||||
* in circumstances where we would normally have avoided it as a
|
||||
* workaround for that bug. This option is not relevant for all
|
||||
* backends, and even not necessarily supported for those for
|
||||
* which it is relevant. A backend which knows that it is not
|
||||
* affected by the bug can ignore this option.
|
||||
*
|
||||
* This option doesn't require a backend to use O_DIRECT, so it
|
||||
* should not be used to try to control the caching behaviour.
|
||||
*
|
||||
*--------------------------------- Features ---------------------------------
|
||||
*
|
||||
* feature-barrier
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
*
|
||||
* A value of "1" indicates that the backend can process requests
|
||||
* containing the BLKIF_OP_WRITE_BARRIER request opcode. Requests
|
||||
* of this type may still be returned at any time with the
|
||||
* BLKIF_RSP_EOPNOTSUPP result code.
|
||||
*
|
||||
* feature-flush-cache
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
*
|
||||
* A value of "1" indicates that the backend can process requests
|
||||
* containing the BLKIF_OP_FLUSH_DISKCACHE request opcode. Requests
|
||||
* of this type may still be returned at any time with the
|
||||
* BLKIF_RSP_EOPNOTSUPP result code.
|
||||
*
|
||||
* feature-discard
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
*
|
||||
* A value of "1" indicates that the backend can process requests
|
||||
* containing the BLKIF_OP_DISCARD request opcode. Requests
|
||||
* of this type may still be returned at any time with the
|
||||
* BLKIF_RSP_EOPNOTSUPP result code.
|
||||
*
|
||||
* feature-persistent
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
* Notes: 7
|
||||
*
|
||||
* A value of "1" indicates that the backend can keep the grants used
|
||||
* by the frontend driver mapped, so the same set of grants should be
|
||||
* used in all transactions. The maximum number of grants the backend
|
||||
* can map persistently depends on the implementation, but ideally it
|
||||
* should be RING_SIZE * BLKIF_MAX_SEGMENTS_PER_REQUEST. Using this
|
||||
* feature the backend doesn't need to unmap each grant, preventing
|
||||
* costly TLB flushes. The backend driver should only map grants
|
||||
* persistently if the frontend supports it. If a backend driver chooses
|
||||
* to use the persistent protocol when the frontend doesn't support it,
|
||||
* it will probably hit the maximum number of persistently mapped grants
|
||||
* (due to the fact that the frontend won't be reusing the same grants),
|
||||
* and fall back to non-persistent mode. Backend implementations may
|
||||
* shrink or expand the number of persistently mapped grants without
|
||||
* notifying the frontend depending on memory constraints (this might
|
||||
* cause a performance degradation).
|
||||
*
|
||||
* If a backend driver wants to limit the maximum number of persistently
|
||||
* mapped grants to a value less than RING_SIZE *
|
||||
* BLKIF_MAX_SEGMENTS_PER_REQUEST a LRU strategy should be used to
|
||||
* discard the grants that are less commonly used. Using a LRU in the
|
||||
* backend driver paired with a LIFO queue in the frontend will
|
||||
* allow us to have better performance in this scenario.
|
||||
*
|
||||
*----------------------- Request Transport Parameters ------------------------
|
||||
*
|
||||
* max-ring-page-order
|
||||
* Values: <uint32_t>
|
||||
* Default Value: 0
|
||||
* Notes: 1, 3
|
||||
*
|
||||
* The maximum supported size of the request ring buffer in units of
|
||||
* lb(machine pages). (e.g. 0 == 1 page, 1 = 2 pages, 2 == 4 pages,
|
||||
* etc.).
|
||||
*
|
||||
* max-ring-pages
|
||||
* Values: <uint32_t>
|
||||
* Default Value: 1
|
||||
* Notes: DEPRECATED, 2, 3
|
||||
*
|
||||
* The maximum supported size of the request ring buffer in units of
|
||||
* machine pages. The value must be a power of 2.
|
||||
*
|
||||
*------------------------- Backend Device Properties -------------------------
|
||||
*
|
||||
* discard-enable
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 1
|
||||
*
|
||||
* This optional property, set by the toolstack, instructs the backend
|
||||
* to offer (or not to offer) discard to the frontend. If the property
|
||||
* is missing the backend should offer discard if the backing storage
|
||||
* actually supports it.
|
||||
*
|
||||
* discard-alignment
|
||||
* Values: <uint32_t>
|
||||
* Default Value: 0
|
||||
* Notes: 4, 5
|
||||
*
|
||||
* The offset, in bytes from the beginning of the virtual block device,
|
||||
* to the first, addressable, discard extent on the underlying device.
|
||||
*
|
||||
* discard-granularity
|
||||
* Values: <uint32_t>
|
||||
* Default Value: <"sector-size">
|
||||
* Notes: 4
|
||||
*
|
||||
* The size, in bytes, of the individually addressable discard extents
|
||||
* of the underlying device.
|
||||
*
|
||||
* discard-secure
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
* Notes: 10
|
||||
*
|
||||
* A value of "1" indicates that the backend can process BLKIF_OP_DISCARD
|
||||
* requests with the BLKIF_DISCARD_SECURE flag set.
|
||||
*
|
||||
* info
|
||||
* Values: <uint32_t> (bitmap)
|
||||
*
|
||||
* A collection of bit flags describing attributes of the backing
|
||||
* device. The VDISK_* macros define the meaning of each bit
|
||||
* location.
|
||||
*
|
||||
* sector-size
|
||||
* Values: <uint32_t>
|
||||
*
|
||||
* The logical block size, in bytes, of the underlying storage. This
|
||||
* must be a power of two with a minimum value of 512.
|
||||
*
|
||||
* NOTE: Because of implementation bugs in some frontends this must be
|
||||
* set to 512, unless the frontend advertizes a non-zero value
|
||||
* in its "feature-large-sector-size" xenbus node. (See below).
|
||||
*
|
||||
* physical-sector-size
|
||||
* Values: <uint32_t>
|
||||
* Default Value: <"sector-size">
|
||||
*
|
||||
* The physical block size, in bytes, of the backend storage. This
|
||||
* must be an integer multiple of "sector-size".
|
||||
*
|
||||
* sectors
|
||||
* Values: <uint64_t>
|
||||
*
|
||||
* The size of the backend device, expressed in units of "sector-size".
|
||||
* The product of "sector-size" and "sectors" must also be an integer
|
||||
* multiple of "physical-sector-size", if that node is present.
|
||||
*
|
||||
*****************************************************************************
|
||||
* Frontend XenBus Nodes
|
||||
*****************************************************************************
|
||||
*
|
||||
*----------------------- Request Transport Parameters -----------------------
|
||||
*
|
||||
* event-channel
|
||||
* Values: <uint32_t>
|
||||
*
|
||||
* The identifier of the Xen event channel used to signal activity
|
||||
* in the ring buffer.
|
||||
*
|
||||
* ring-ref
|
||||
* Values: <uint32_t>
|
||||
* Notes: 6
|
||||
*
|
||||
* The Xen grant reference granting permission for the backend to map
|
||||
* the sole page in a single page sized ring buffer.
|
||||
*
|
||||
* ring-ref%u
|
||||
* Values: <uint32_t>
|
||||
* Notes: 6
|
||||
*
|
||||
* For a frontend providing a multi-page ring, a "number of ring pages"
|
||||
* sized list of nodes, each containing a Xen grant reference granting
|
||||
* permission for the backend to map the page of the ring located
|
||||
* at page index "%u". Page indexes are zero based.
|
||||
*
|
||||
* protocol
|
||||
* Values: string (XEN_IO_PROTO_ABI_*)
|
||||
* Default Value: XEN_IO_PROTO_ABI_NATIVE
|
||||
*
|
||||
* The machine ABI rules governing the format of all ring request and
|
||||
* response structures.
|
||||
*
|
||||
* ring-page-order
|
||||
* Values: <uint32_t>
|
||||
* Default Value: 0
|
||||
* Maximum Value: MAX(ffs(max-ring-pages) - 1, max-ring-page-order)
|
||||
* Notes: 1, 3
|
||||
*
|
||||
* The size of the frontend allocated request ring buffer in units
|
||||
* of lb(machine pages). (e.g. 0 == 1 page, 1 = 2 pages, 2 == 4 pages,
|
||||
* etc.).
|
||||
*
|
||||
* num-ring-pages
|
||||
* Values: <uint32_t>
|
||||
* Default Value: 1
|
||||
* Maximum Value: MAX(max-ring-pages,(0x1 << max-ring-page-order))
|
||||
* Notes: DEPRECATED, 2, 3
|
||||
*
|
||||
* The size of the frontend allocated request ring buffer in units of
|
||||
* machine pages. The value must be a power of 2.
|
||||
*
|
||||
*--------------------------------- Features ---------------------------------
|
||||
*
|
||||
* feature-persistent
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
* Notes: 7, 8, 9
|
||||
*
|
||||
* A value of "1" indicates that the frontend will reuse the same grants
|
||||
* for all transactions, allowing the backend to map them with write
|
||||
* access (even when it should be read-only). If the frontend hits the
|
||||
* maximum number of allowed persistently mapped grants, it can fallback
|
||||
* to non persistent mode. This will cause a performance degradation,
|
||||
* since the the backend driver will still try to map those grants
|
||||
* persistently. Since the persistent grants protocol is compatible with
|
||||
* the previous protocol, a frontend driver can choose to work in
|
||||
* persistent mode even when the backend doesn't support it.
|
||||
*
|
||||
* It is recommended that the frontend driver stores the persistently
|
||||
* mapped grants in a LIFO queue, so a subset of all persistently mapped
|
||||
* grants gets used commonly. This is done in case the backend driver
|
||||
* decides to limit the maximum number of persistently mapped grants
|
||||
* to a value less than RING_SIZE * BLKIF_MAX_SEGMENTS_PER_REQUEST.
|
||||
*
|
||||
* feature-large-sector-size
|
||||
* Values: 0/1 (boolean)
|
||||
* Default Value: 0
|
||||
*
|
||||
* A value of "1" indicates that the frontend will correctly supply and
|
||||
* interpret all sector-based quantities in terms of the "sector-size"
|
||||
* value supplied in the backend info, whatever that may be set to.
|
||||
* If this node is not present or its value is "0" then it is assumed
|
||||
* that the frontend requires that the logical block size is 512 as it
|
||||
* is hardcoded (which is the case in some frontend implementations).
|
||||
*
|
||||
*------------------------- Virtual Device Properties -------------------------
|
||||
*
|
||||
* device-type
|
||||
* Values: "disk", "cdrom", "floppy", etc.
|
||||
*
|
||||
* virtual-device
|
||||
* Values: <uint32_t>
|
||||
*
|
||||
* A value indicating the physical device to virtualize within the
|
||||
* frontend's domain. (e.g. "The first ATA disk", "The third SCSI
|
||||
* disk", etc.)
|
||||
*
|
||||
* See docs/misc/vbd-interface.txt for details on the format of this
|
||||
* value.
|
||||
*
|
||||
* Notes
|
||||
* -----
|
||||
* (1) Multi-page ring buffer scheme first developed in the Citrix XenServer
|
||||
* PV drivers.
|
||||
* (2) Multi-page ring buffer scheme first used in some RedHat distributions
|
||||
* including a distribution deployed on certain nodes of the Amazon
|
||||
* EC2 cluster.
|
||||
* (3) Support for multi-page ring buffers was implemented independently,
|
||||
* in slightly different forms, by both Citrix and RedHat/Amazon.
|
||||
* For full interoperability, block front and backends should publish
|
||||
* identical ring parameters, adjusted for unit differences, to the
|
||||
* XenStore nodes used in both schemes.
|
||||
* (4) Devices that support discard functionality may internally allocate space
|
||||
* (discardable extents) in units that are larger than the exported logical
|
||||
* block size. If the backing device has such discardable extents the
|
||||
* backend should provide both discard-granularity and discard-alignment.
|
||||
* Providing just one of the two may be considered an error by the frontend.
|
||||
* Backends supporting discard should include discard-granularity and
|
||||
* discard-alignment even if it supports discarding individual sectors.
|
||||
* Frontends should assume discard-alignment == 0 and discard-granularity
|
||||
* == sector size if these keys are missing.
|
||||
* (5) The discard-alignment parameter allows a physical device to be
|
||||
* partitioned into virtual devices that do not necessarily begin or
|
||||
* end on a discardable extent boundary.
|
||||
* (6) When there is only a single page allocated to the request ring,
|
||||
* 'ring-ref' is used to communicate the grant reference for this
|
||||
* page to the backend. When using a multi-page ring, the 'ring-ref'
|
||||
* node is not created. Instead 'ring-ref0' - 'ring-refN' are used.
|
||||
* (7) When using persistent grants data has to be copied from/to the page
|
||||
* where the grant is currently mapped. The overhead of doing this copy
|
||||
* however doesn't suppress the speed improvement of not having to unmap
|
||||
* the grants.
|
||||
* (8) The frontend driver has to allow the backend driver to map all grants
|
||||
* with write access, even when they should be mapped read-only, since
|
||||
* further requests may reuse these grants and require write permissions.
|
||||
* (9) Linux implementation doesn't have a limit on the maximum number of
|
||||
* grants that can be persistently mapped in the frontend driver, but
|
||||
* due to the frontent driver implementation it should never be bigger
|
||||
* than RING_SIZE * BLKIF_MAX_SEGMENTS_PER_REQUEST.
|
||||
*(10) The discard-secure property may be present and will be set to 1 if the
|
||||
* backing device supports secure discard.
|
||||
*(11) Only used by Linux and NetBSD.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Multiple hardware queues/rings:
|
||||
* If supported, the backend will write the key "multi-queue-max-queues" to
|
||||
* the directory for that vbd, and set its value to the maximum supported
|
||||
* number of queues.
|
||||
* Frontends that are aware of this feature and wish to use it can write the
|
||||
* key "multi-queue-num-queues" with the number they wish to use, which must be
|
||||
* greater than zero, and no more than the value reported by the backend in
|
||||
* "multi-queue-max-queues".
|
||||
*
|
||||
* For frontends requesting just one queue, the usual event-channel and
|
||||
* ring-ref keys are written as before, simplifying the backend processing
|
||||
* to avoid distinguishing between a frontend that doesn't understand the
|
||||
* multi-queue feature, and one that does, but requested only one queue.
|
||||
*
|
||||
* Frontends requesting two or more queues must not write the toplevel
|
||||
* event-channel and ring-ref keys, instead writing those keys under sub-keys
|
||||
* having the name "queue-N" where N is the integer ID of the queue/ring for
|
||||
* which those keys belong. Queues are indexed from zero.
|
||||
* For example, a frontend with two queues must write the following set of
|
||||
* queue-related keys:
|
||||
*
|
||||
* /local/domain/1/device/vbd/0/multi-queue-num-queues = "2"
|
||||
* /local/domain/1/device/vbd/0/queue-0 = ""
|
||||
* /local/domain/1/device/vbd/0/queue-0/ring-ref = "<ring-ref#0>"
|
||||
* /local/domain/1/device/vbd/0/queue-0/event-channel = "<evtchn#0>"
|
||||
* /local/domain/1/device/vbd/0/queue-1 = ""
|
||||
* /local/domain/1/device/vbd/0/queue-1/ring-ref = "<ring-ref#1>"
|
||||
* /local/domain/1/device/vbd/0/queue-1/event-channel = "<evtchn#1>"
|
||||
*
|
||||
* It is also possible to use multiple queues/rings together with
|
||||
* feature multi-page ring buffer.
|
||||
* For example, a frontend requests two queues/rings and the size of each ring
|
||||
* buffer is two pages must write the following set of related keys:
|
||||
*
|
||||
* /local/domain/1/device/vbd/0/multi-queue-num-queues = "2"
|
||||
* /local/domain/1/device/vbd/0/ring-page-order = "1"
|
||||
* /local/domain/1/device/vbd/0/queue-0 = ""
|
||||
* /local/domain/1/device/vbd/0/queue-0/ring-ref0 = "<ring-ref#0>"
|
||||
* /local/domain/1/device/vbd/0/queue-0/ring-ref1 = "<ring-ref#1>"
|
||||
* /local/domain/1/device/vbd/0/queue-0/event-channel = "<evtchn#0>"
|
||||
* /local/domain/1/device/vbd/0/queue-1 = ""
|
||||
* /local/domain/1/device/vbd/0/queue-1/ring-ref0 = "<ring-ref#2>"
|
||||
* /local/domain/1/device/vbd/0/queue-1/ring-ref1 = "<ring-ref#3>"
|
||||
* /local/domain/1/device/vbd/0/queue-1/event-channel = "<evtchn#1>"
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* STATE DIAGRAMS
|
||||
*
|
||||
*****************************************************************************
|
||||
* Startup *
|
||||
*****************************************************************************
|
||||
*
|
||||
* Tool stack creates front and back nodes with state XenbusStateInitialising.
|
||||
*
|
||||
* Front Back
|
||||
* ================================= =====================================
|
||||
* XenbusStateInitialising XenbusStateInitialising
|
||||
* o Query virtual device o Query backend device identification
|
||||
* properties. data.
|
||||
* o Setup OS device instance. o Open and validate backend device.
|
||||
* o Publish backend features and
|
||||
* transport parameters.
|
||||
* |
|
||||
* |
|
||||
* V
|
||||
* XenbusStateInitWait
|
||||
*
|
||||
* o Query backend features and
|
||||
* transport parameters.
|
||||
* o Allocate and initialize the
|
||||
* request ring.
|
||||
* o Publish transport parameters
|
||||
* that will be in effect during
|
||||
* this connection.
|
||||
* |
|
||||
* |
|
||||
* V
|
||||
* XenbusStateInitialised
|
||||
*
|
||||
* o Query frontend transport parameters.
|
||||
* o Connect to the request ring and
|
||||
* event channel.
|
||||
* o Publish backend device properties.
|
||||
* |
|
||||
* |
|
||||
* V
|
||||
* XenbusStateConnected
|
||||
*
|
||||
* o Query backend device properties.
|
||||
* o Finalize OS virtual device
|
||||
* instance.
|
||||
* |
|
||||
* |
|
||||
* V
|
||||
* XenbusStateConnected
|
||||
*
|
||||
* Note: Drivers that do not support any optional features, or the negotiation
|
||||
* of transport parameters, can skip certain states in the state machine:
|
||||
*
|
||||
* o A frontend may transition to XenbusStateInitialised without
|
||||
* waiting for the backend to enter XenbusStateInitWait. In this
|
||||
* case, default transport parameters are in effect and any
|
||||
* transport parameters published by the frontend must contain
|
||||
* their default values.
|
||||
*
|
||||
* o A backend may transition to XenbusStateInitialised, bypassing
|
||||
* XenbusStateInitWait, without waiting for the frontend to first
|
||||
* enter the XenbusStateInitialised state. In this case, default
|
||||
* transport parameters are in effect and any transport parameters
|
||||
* published by the backend must contain their default values.
|
||||
*
|
||||
* Drivers that support optional features and/or transport parameter
|
||||
* negotiation must tolerate these additional state transition paths.
|
||||
* In general this means performing the work of any skipped state
|
||||
* transition, if it has not already been performed, in addition to the
|
||||
* work associated with entry into the current state.
|
||||
*/
|
||||
|
||||
/*
|
||||
* REQUEST CODES.
|
||||
*/
|
||||
#define BLKIF_OP_READ 0
|
||||
#define BLKIF_OP_WRITE 1
|
||||
/*
|
||||
* All writes issued prior to a request with the BLKIF_OP_WRITE_BARRIER
|
||||
* operation code ("barrier request") must be completed prior to the
|
||||
* execution of the barrier request. All writes issued after the barrier
|
||||
* request must not execute until after the completion of the barrier request.
|
||||
*
|
||||
* Optional. See "feature-barrier" XenBus node documentation above.
|
||||
*/
|
||||
#define BLKIF_OP_WRITE_BARRIER 2
|
||||
/*
|
||||
* Commit any uncommitted contents of the backing device's volatile cache
|
||||
* to stable storage.
|
||||
*
|
||||
* Optional. See "feature-flush-cache" XenBus node documentation above.
|
||||
*/
|
||||
#define BLKIF_OP_FLUSH_DISKCACHE 3
|
||||
/*
|
||||
* Used in SLES sources for device specific command packet
|
||||
* contained within the request. Reserved for that purpose.
|
||||
*/
|
||||
#define BLKIF_OP_RESERVED_1 4
|
||||
/*
|
||||
* Indicate to the backend device that a region of storage is no longer in
|
||||
* use, and may be discarded at any time without impact to the client. If
|
||||
* the BLKIF_DISCARD_SECURE flag is set on the request, all copies of the
|
||||
* discarded region on the device must be rendered unrecoverable before the
|
||||
* command returns.
|
||||
*
|
||||
* This operation is analogous to performing a trim (ATA) or unamp (SCSI),
|
||||
* command on a native device.
|
||||
*
|
||||
* More information about trim/unmap operations can be found at:
|
||||
* http://t13.org/Documents/UploadedDocuments/docs2008/
|
||||
* e07154r6-Data_Set_Management_Proposal_for_ATA-ACS2.doc
|
||||
* http://www.seagate.com/staticfiles/support/disc/manuals/
|
||||
* Interface%20manuals/100293068c.pdf
|
||||
*
|
||||
* Optional. See "feature-discard", "discard-alignment",
|
||||
* "discard-granularity", and "discard-secure" in the XenBus node
|
||||
* documentation above.
|
||||
*/
|
||||
#define BLKIF_OP_DISCARD 5
|
||||
|
||||
/*
|
||||
* Recognized if "feature-max-indirect-segments" in present in the backend
|
||||
* xenbus info. The "feature-max-indirect-segments" node contains the maximum
|
||||
* number of segments allowed by the backend per request. If the node is
|
||||
* present, the frontend might use blkif_request_indirect structs in order to
|
||||
* issue requests with more than BLKIF_MAX_SEGMENTS_PER_REQUEST (11). The
|
||||
* maximum number of indirect segments is fixed by the backend, but the
|
||||
* frontend can issue requests with any number of indirect segments as long as
|
||||
* it's less than the number provided by the backend. The indirect_grefs field
|
||||
* in blkif_request_indirect should be filled by the frontend with the
|
||||
* grant references of the pages that are holding the indirect segments.
|
||||
* These pages are filled with an array of blkif_request_segment that hold the
|
||||
* information about the segments. The number of indirect pages to use is
|
||||
* determined by the number of segments an indirect request contains. Every
|
||||
* indirect page can contain a maximum of
|
||||
* (PAGE_SIZE / sizeof(struct blkif_request_segment)) segments, so to
|
||||
* calculate the number of indirect pages to use we have to do
|
||||
* ceil(indirect_segments / (PAGE_SIZE / sizeof(struct blkif_request_segment))).
|
||||
*
|
||||
* If a backend does not recognize BLKIF_OP_INDIRECT, it should *not*
|
||||
* create the "feature-max-indirect-segments" node!
|
||||
*/
|
||||
#define BLKIF_OP_INDIRECT 6
|
||||
|
||||
/*
|
||||
* Maximum scatter/gather segments per request.
|
||||
* This is carefully chosen so that sizeof(blkif_ring_t) <= PAGE_SIZE.
|
||||
* NB. This could be 12 if the ring indexes weren't stored in the same page.
|
||||
*/
|
||||
#define BLKIF_MAX_SEGMENTS_PER_REQUEST 11
|
||||
|
||||
/*
|
||||
* Maximum number of indirect pages to use per request.
|
||||
*/
|
||||
#define BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST 8
|
||||
|
||||
/*
|
||||
* NB. 'first_sect' and 'last_sect' in blkif_request_segment, as well as
|
||||
* 'sector_number' in blkif_request, blkif_request_discard and
|
||||
* blkif_request_indirect are sector-based quantities. See the description
|
||||
* of the "feature-large-sector-size" frontend xenbus node above for
|
||||
* more information.
|
||||
*/
|
||||
struct blkif_request_segment {
|
||||
grant_ref_t gref; /* reference to I/O buffer frame */
|
||||
/* @first_sect: first sector in frame to transfer (inclusive). */
|
||||
/* @last_sect: last sector in frame to transfer (inclusive). */
|
||||
uint8_t first_sect, last_sect;
|
||||
};
|
||||
|
||||
/*
|
||||
* Starting ring element for any I/O request.
|
||||
*/
|
||||
struct blkif_request {
|
||||
uint8_t operation; /* BLKIF_OP_??? */
|
||||
uint8_t nr_segments; /* number of segments */
|
||||
blkif_vdev_t handle; /* only for read/write requests */
|
||||
uint64_t id; /* private guest value, echoed in resp */
|
||||
blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */
|
||||
struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
|
||||
};
|
||||
typedef struct blkif_request blkif_request_t;
|
||||
|
||||
/*
|
||||
* Cast to this structure when blkif_request.operation == BLKIF_OP_DISCARD
|
||||
* sizeof(struct blkif_request_discard) <= sizeof(struct blkif_request)
|
||||
*/
|
||||
struct blkif_request_discard {
|
||||
uint8_t operation; /* BLKIF_OP_DISCARD */
|
||||
uint8_t flag; /* BLKIF_DISCARD_SECURE or zero */
|
||||
#define BLKIF_DISCARD_SECURE (1<<0) /* ignored if discard-secure=0 */
|
||||
blkif_vdev_t handle; /* same as for read/write requests */
|
||||
uint64_t id; /* private guest value, echoed in resp */
|
||||
blkif_sector_t sector_number;/* start sector idx on disk */
|
||||
uint64_t nr_sectors; /* number of contiguous sectors to discard*/
|
||||
};
|
||||
typedef struct blkif_request_discard blkif_request_discard_t;
|
||||
|
||||
struct blkif_request_indirect {
|
||||
uint8_t operation; /* BLKIF_OP_INDIRECT */
|
||||
uint8_t indirect_op; /* BLKIF_OP_{READ/WRITE} */
|
||||
uint16_t nr_segments; /* number of segments */
|
||||
uint64_t id; /* private guest value, echoed in resp */
|
||||
blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */
|
||||
blkif_vdev_t handle; /* same as for read/write requests */
|
||||
grant_ref_t indirect_grefs[BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST];
|
||||
#ifdef __i386__
|
||||
uint64_t pad; /* Make it 64 byte aligned on i386 */
|
||||
#endif
|
||||
};
|
||||
typedef struct blkif_request_indirect blkif_request_indirect_t;
|
||||
|
||||
struct blkif_response {
|
||||
uint64_t id; /* copied from request */
|
||||
uint8_t operation; /* copied from request */
|
||||
int16_t status; /* BLKIF_RSP_??? */
|
||||
};
|
||||
typedef struct blkif_response blkif_response_t;
|
||||
|
||||
/*
|
||||
* STATUS RETURN CODES.
|
||||
*/
|
||||
/* Operation not supported (only happens on barrier writes). */
|
||||
#define BLKIF_RSP_EOPNOTSUPP -2
|
||||
/* Operation failed for some unspecified reason (-EIO). */
|
||||
#define BLKIF_RSP_ERROR -1
|
||||
/* Operation completed successfully. */
|
||||
#define BLKIF_RSP_OKAY 0
|
||||
|
||||
/*
|
||||
* Generate blkif ring structures and types.
|
||||
*/
|
||||
DEFINE_RING_TYPES(blkif, struct blkif_request, struct blkif_response);
|
||||
|
||||
#define VDISK_CDROM 0x1
|
||||
#define VDISK_REMOVABLE 0x2
|
||||
#define VDISK_READONLY 0x4
|
||||
|
||||
#endif /* __XEN_PUBLIC_IO_BLKIF_H__ */
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/******************************************************************************
|
||||
* console.h
|
||||
*
|
||||
* Console I/O interface for Xen guest OSes.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (c) 2005, Keir Fraser
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PUBLIC_IO_CONSOLE_H__
|
||||
#define __XEN_PUBLIC_IO_CONSOLE_H__
|
||||
|
||||
typedef uint32_t XENCONS_RING_IDX;
|
||||
|
||||
#define MASK_XENCONS_IDX(idx, ring) ((idx) & (sizeof(ring)-1))
|
||||
|
||||
struct xencons_interface {
|
||||
char in[1024];
|
||||
char out[2048];
|
||||
XENCONS_RING_IDX in_cons, in_prod;
|
||||
XENCONS_RING_IDX out_cons, out_prod;
|
||||
};
|
||||
|
||||
#ifdef XEN_WANT_FLEX_CONSOLE_RING
|
||||
#include "ring.h"
|
||||
DEFINE_XEN_FLEX_RING(xencons);
|
||||
#endif
|
||||
|
||||
#endif /* __XEN_PUBLIC_IO_CONSOLE_H__ */
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
* fbif.h -- Xen virtual frame buffer device
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (C) 2005 Anthony Liguori <aliguori@us.ibm.com>
|
||||
* Copyright (C) 2006 Red Hat, Inc., Markus Armbruster <armbru@redhat.com>
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PUBLIC_IO_FBIF_H__
|
||||
#define __XEN_PUBLIC_IO_FBIF_H__
|
||||
|
||||
/* Out events (frontend -> backend) */
|
||||
|
||||
/*
|
||||
* Out events may be sent only when requested by backend, and receipt
|
||||
* of an unknown out event is an error.
|
||||
*/
|
||||
|
||||
/* Event type 1 currently not used */
|
||||
/*
|
||||
* Framebuffer update notification event
|
||||
* Capable frontend sets feature-update in xenstore.
|
||||
* Backend requests it by setting request-update in xenstore.
|
||||
*/
|
||||
#define XENFB_TYPE_UPDATE 2
|
||||
|
||||
struct xenfb_update
|
||||
{
|
||||
uint8_t type; /* XENFB_TYPE_UPDATE */
|
||||
int32_t x; /* source x */
|
||||
int32_t y; /* source y */
|
||||
int32_t width; /* rect width */
|
||||
int32_t height; /* rect height */
|
||||
};
|
||||
|
||||
/*
|
||||
* Framebuffer resize notification event
|
||||
* Capable backend sets feature-resize in xenstore.
|
||||
*/
|
||||
#define XENFB_TYPE_RESIZE 3
|
||||
|
||||
struct xenfb_resize
|
||||
{
|
||||
uint8_t type; /* XENFB_TYPE_RESIZE */
|
||||
int32_t width; /* width in pixels */
|
||||
int32_t height; /* height in pixels */
|
||||
int32_t stride; /* stride in bytes */
|
||||
int32_t depth; /* depth in bits */
|
||||
int32_t offset; /* offset of the framebuffer in bytes */
|
||||
};
|
||||
|
||||
#define XENFB_OUT_EVENT_SIZE 40
|
||||
|
||||
union xenfb_out_event
|
||||
{
|
||||
uint8_t type;
|
||||
struct xenfb_update update;
|
||||
struct xenfb_resize resize;
|
||||
char pad[XENFB_OUT_EVENT_SIZE];
|
||||
};
|
||||
|
||||
/* In events (backend -> frontend) */
|
||||
|
||||
/*
|
||||
* Frontends should ignore unknown in events.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Framebuffer refresh period advice
|
||||
* Backend sends it to advise the frontend their preferred period of
|
||||
* refresh. Frontends that keep the framebuffer constantly up-to-date
|
||||
* just ignore it. Frontends that use the advice should immediately
|
||||
* refresh the framebuffer (and send an update notification event if
|
||||
* those have been requested), then use the update frequency to guide
|
||||
* their periodical refreshs.
|
||||
*/
|
||||
#define XENFB_TYPE_REFRESH_PERIOD 1
|
||||
#define XENFB_NO_REFRESH 0
|
||||
|
||||
struct xenfb_refresh_period
|
||||
{
|
||||
uint8_t type; /* XENFB_TYPE_UPDATE_PERIOD */
|
||||
uint32_t period; /* period of refresh, in ms,
|
||||
* XENFB_NO_REFRESH if no refresh is needed */
|
||||
};
|
||||
|
||||
#define XENFB_IN_EVENT_SIZE 40
|
||||
|
||||
union xenfb_in_event
|
||||
{
|
||||
uint8_t type;
|
||||
struct xenfb_refresh_period refresh_period;
|
||||
char pad[XENFB_IN_EVENT_SIZE];
|
||||
};
|
||||
|
||||
/* shared page */
|
||||
|
||||
#define XENFB_IN_RING_SIZE 1024
|
||||
#define XENFB_IN_RING_LEN (XENFB_IN_RING_SIZE / XENFB_IN_EVENT_SIZE)
|
||||
#define XENFB_IN_RING_OFFS 1024
|
||||
#define XENFB_IN_RING(page) \
|
||||
((union xenfb_in_event *)((char *)(page) + XENFB_IN_RING_OFFS))
|
||||
#define XENFB_IN_RING_REF(page, idx) \
|
||||
(XENFB_IN_RING((page))[(idx) % XENFB_IN_RING_LEN])
|
||||
|
||||
#define XENFB_OUT_RING_SIZE 2048
|
||||
#define XENFB_OUT_RING_LEN (XENFB_OUT_RING_SIZE / XENFB_OUT_EVENT_SIZE)
|
||||
#define XENFB_OUT_RING_OFFS (XENFB_IN_RING_OFFS + XENFB_IN_RING_SIZE)
|
||||
#define XENFB_OUT_RING(page) \
|
||||
((union xenfb_out_event *)((char *)(page) + XENFB_OUT_RING_OFFS))
|
||||
#define XENFB_OUT_RING_REF(page, idx) \
|
||||
(XENFB_OUT_RING((page))[(idx) % XENFB_OUT_RING_LEN])
|
||||
|
||||
struct xenfb_page
|
||||
{
|
||||
uint32_t in_cons, in_prod;
|
||||
uint32_t out_cons, out_prod;
|
||||
|
||||
int32_t width; /* the width of the framebuffer (in pixels) */
|
||||
int32_t height; /* the height of the framebuffer (in pixels) */
|
||||
uint32_t line_length; /* the length of a row of pixels (in bytes) */
|
||||
uint32_t mem_length; /* the length of the framebuffer (in bytes) */
|
||||
uint8_t depth; /* the depth of a pixel (in bits) */
|
||||
|
||||
/*
|
||||
* Framebuffer page directory
|
||||
*
|
||||
* Each directory page holds PAGE_SIZE / sizeof(*pd)
|
||||
* framebuffer pages, and can thus map up to PAGE_SIZE *
|
||||
* PAGE_SIZE / sizeof(*pd) bytes. With PAGE_SIZE == 4096 and
|
||||
* sizeof(unsigned long) == 4/8, that's 4 Megs 32 bit and 2 Megs
|
||||
* 64 bit. 256 directories give enough room for a 512 Meg
|
||||
* framebuffer with a max resolution of 12,800x10,240. Should
|
||||
* be enough for a while with room leftover for expansion.
|
||||
*/
|
||||
unsigned long pd[256];
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,566 @@
|
|||
/*
|
||||
* kbdif.h -- Xen virtual keyboard/mouse
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (C) 2005 Anthony Liguori <aliguori@us.ibm.com>
|
||||
* Copyright (C) 2006 Red Hat, Inc., Markus Armbruster <armbru@redhat.com>
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PUBLIC_IO_KBDIF_H__
|
||||
#define __XEN_PUBLIC_IO_KBDIF_H__
|
||||
|
||||
/*
|
||||
*****************************************************************************
|
||||
* Feature and Parameter Negotiation
|
||||
*****************************************************************************
|
||||
*
|
||||
* The two halves of a para-virtual driver utilize nodes within
|
||||
* XenStore to communicate capabilities and to negotiate operating parameters.
|
||||
* This section enumerates these nodes which reside in the respective front and
|
||||
* backend portions of XenStore, following XenBus convention.
|
||||
*
|
||||
* All data in XenStore is stored as strings. Nodes specifying numeric
|
||||
* values are encoded in decimal. Integer value ranges listed below are
|
||||
* expressed as fixed sized integer types capable of storing the conversion
|
||||
* of a properly formated node string, without loss of information.
|
||||
*
|
||||
*****************************************************************************
|
||||
* Backend XenBus Nodes
|
||||
*****************************************************************************
|
||||
*
|
||||
*---------------------------- Features supported ----------------------------
|
||||
*
|
||||
* Capable backend advertises supported features by publishing
|
||||
* corresponding entries in XenStore and puts 1 as the value of the entry.
|
||||
* If a feature is not supported then 0 must be set or feature entry omitted.
|
||||
*
|
||||
* feature-disable-keyboard
|
||||
* Values: <uint>
|
||||
*
|
||||
* If there is no need to expose a virtual keyboard device by the
|
||||
* frontend then this must be set to 1.
|
||||
*
|
||||
* feature-disable-pointer
|
||||
* Values: <uint>
|
||||
*
|
||||
* If there is no need to expose a virtual pointer device by the
|
||||
* frontend then this must be set to 1.
|
||||
*
|
||||
* feature-abs-pointer
|
||||
* Values: <uint>
|
||||
*
|
||||
* Backends, which support reporting of absolute coordinates for pointer
|
||||
* device should set this to 1.
|
||||
*
|
||||
* feature-multi-touch
|
||||
* Values: <uint>
|
||||
*
|
||||
* Backends, which support reporting of multi-touch events
|
||||
* should set this to 1.
|
||||
*
|
||||
* feature-raw-pointer
|
||||
* Values: <uint>
|
||||
*
|
||||
* Backends, which support reporting raw (unscaled) absolute coordinates
|
||||
* for pointer devices should set this to 1. Raw (unscaled) values have
|
||||
* a range of [0, 0x7fff].
|
||||
*
|
||||
*----------------------- Device Instance Parameters ------------------------
|
||||
*
|
||||
* unique-id
|
||||
* Values: <string>
|
||||
*
|
||||
* After device instance initialization it is assigned a unique ID,
|
||||
* so every instance of the frontend can be identified by the backend
|
||||
* by this ID. This can be UUID or such.
|
||||
*
|
||||
*------------------------- Pointer Device Parameters ------------------------
|
||||
*
|
||||
* width
|
||||
* Values: <uint>
|
||||
*
|
||||
* Maximum X coordinate (width) to be used by the frontend
|
||||
* while reporting input events, pixels, [0; UINT32_MAX].
|
||||
*
|
||||
* height
|
||||
* Values: <uint>
|
||||
*
|
||||
* Maximum Y coordinate (height) to be used by the frontend
|
||||
* while reporting input events, pixels, [0; UINT32_MAX].
|
||||
*
|
||||
*----------------------- Multi-touch Device Parameters ----------------------
|
||||
*
|
||||
* multi-touch-num-contacts
|
||||
* Values: <uint>
|
||||
*
|
||||
* Number of simultaneous touches reported.
|
||||
*
|
||||
* multi-touch-width
|
||||
* Values: <uint>
|
||||
*
|
||||
* Width of the touch area to be used by the frontend
|
||||
* while reporting input events, pixels, [0; UINT32_MAX].
|
||||
*
|
||||
* multi-touch-height
|
||||
* Values: <uint>
|
||||
*
|
||||
* Height of the touch area to be used by the frontend
|
||||
* while reporting input events, pixels, [0; UINT32_MAX].
|
||||
*
|
||||
*****************************************************************************
|
||||
* Frontend XenBus Nodes
|
||||
*****************************************************************************
|
||||
*
|
||||
*------------------------------ Feature request -----------------------------
|
||||
*
|
||||
* Capable frontend requests features from backend via setting corresponding
|
||||
* entries to 1 in XenStore. Requests for features not advertised as supported
|
||||
* by the backend have no effect.
|
||||
*
|
||||
* request-abs-pointer
|
||||
* Values: <uint>
|
||||
*
|
||||
* Request backend to report absolute pointer coordinates
|
||||
* (XENKBD_TYPE_POS) instead of relative ones (XENKBD_TYPE_MOTION).
|
||||
*
|
||||
* request-multi-touch
|
||||
* Values: <uint>
|
||||
*
|
||||
* Request backend to report multi-touch events.
|
||||
*
|
||||
* request-raw-pointer
|
||||
* Values: <uint>
|
||||
*
|
||||
* Request backend to report raw unscaled absolute pointer coordinates.
|
||||
* This option is only valid if request-abs-pointer is also set.
|
||||
* Raw unscaled coordinates have the range [0, 0x7fff]
|
||||
*
|
||||
*----------------------- Request Transport Parameters -----------------------
|
||||
*
|
||||
* event-channel
|
||||
* Values: <uint>
|
||||
*
|
||||
* The identifier of the Xen event channel used to signal activity
|
||||
* in the ring buffer.
|
||||
*
|
||||
* page-gref
|
||||
* Values: <uint>
|
||||
*
|
||||
* The Xen grant reference granting permission for the backend to map
|
||||
* a sole page in a single page sized event ring buffer.
|
||||
*
|
||||
* page-ref
|
||||
* Values: <uint>
|
||||
*
|
||||
* OBSOLETE, not recommended for use.
|
||||
* PFN of the shared page.
|
||||
*/
|
||||
|
||||
/*
|
||||
* EVENT CODES.
|
||||
*/
|
||||
|
||||
#define XENKBD_TYPE_MOTION 1
|
||||
#define XENKBD_TYPE_RESERVED 2
|
||||
#define XENKBD_TYPE_KEY 3
|
||||
#define XENKBD_TYPE_POS 4
|
||||
#define XENKBD_TYPE_MTOUCH 5
|
||||
|
||||
/* Multi-touch event sub-codes */
|
||||
|
||||
#define XENKBD_MT_EV_DOWN 0
|
||||
#define XENKBD_MT_EV_UP 1
|
||||
#define XENKBD_MT_EV_MOTION 2
|
||||
#define XENKBD_MT_EV_SYN 3
|
||||
#define XENKBD_MT_EV_SHAPE 4
|
||||
#define XENKBD_MT_EV_ORIENT 5
|
||||
|
||||
/*
|
||||
* CONSTANTS, XENSTORE FIELD AND PATH NAME STRINGS, HELPERS.
|
||||
*/
|
||||
|
||||
#define XENKBD_DRIVER_NAME "vkbd"
|
||||
|
||||
#define XENKBD_FIELD_FEAT_DSBL_KEYBRD "feature-disable-keyboard"
|
||||
#define XENKBD_FIELD_FEAT_DSBL_POINTER "feature-disable-pointer"
|
||||
#define XENKBD_FIELD_FEAT_ABS_POINTER "feature-abs-pointer"
|
||||
#define XENKBD_FIELD_FEAT_RAW_POINTER "feature-raw-pointer"
|
||||
#define XENKBD_FIELD_FEAT_MTOUCH "feature-multi-touch"
|
||||
#define XENKBD_FIELD_REQ_ABS_POINTER "request-abs-pointer"
|
||||
#define XENKBD_FIELD_REQ_RAW_POINTER "request-raw-pointer"
|
||||
#define XENKBD_FIELD_REQ_MTOUCH "request-multi-touch"
|
||||
#define XENKBD_FIELD_RING_GREF "page-gref"
|
||||
#define XENKBD_FIELD_EVT_CHANNEL "event-channel"
|
||||
#define XENKBD_FIELD_WIDTH "width"
|
||||
#define XENKBD_FIELD_HEIGHT "height"
|
||||
#define XENKBD_FIELD_MT_WIDTH "multi-touch-width"
|
||||
#define XENKBD_FIELD_MT_HEIGHT "multi-touch-height"
|
||||
#define XENKBD_FIELD_MT_NUM_CONTACTS "multi-touch-num-contacts"
|
||||
#define XENKBD_FIELD_UNIQUE_ID "unique-id"
|
||||
|
||||
/* OBSOLETE, not recommended for use */
|
||||
#define XENKBD_FIELD_RING_REF "page-ref"
|
||||
|
||||
/*
|
||||
*****************************************************************************
|
||||
* Description of the protocol between frontend and backend driver.
|
||||
*****************************************************************************
|
||||
*
|
||||
* The two halves of a Para-virtual driver communicate with
|
||||
* each other using a shared page and an event channel.
|
||||
* Shared page contains a ring with event structures.
|
||||
*
|
||||
* All reserved fields in the structures below must be 0.
|
||||
*
|
||||
*****************************************************************************
|
||||
* Backend to frontend events
|
||||
*****************************************************************************
|
||||
*
|
||||
* Frontends should ignore unknown in events.
|
||||
* All event packets have the same length (40 octets)
|
||||
* All event packets have common header:
|
||||
*
|
||||
* 0 octet
|
||||
* +-----------------+
|
||||
* | type |
|
||||
* +-----------------+
|
||||
* type - uint8_t, event code, XENKBD_TYPE_???
|
||||
*
|
||||
*
|
||||
* Pointer relative movement event
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MOTION | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | rel_x | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | rel_y | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | rel_z | 16
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 20
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* rel_x - int32_t, relative X motion
|
||||
* rel_y - int32_t, relative Y motion
|
||||
* rel_z - int32_t, relative Z motion (wheel)
|
||||
*/
|
||||
|
||||
struct xenkbd_motion
|
||||
{
|
||||
uint8_t type;
|
||||
int32_t rel_x;
|
||||
int32_t rel_y;
|
||||
int32_t rel_z;
|
||||
};
|
||||
|
||||
/*
|
||||
* Key event (includes pointer buttons)
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_KEY | pressed | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | keycode | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* pressed - uint8_t, 1 if pressed; 0 otherwise
|
||||
* keycode - uint32_t, KEY_* from linux/input.h
|
||||
*/
|
||||
|
||||
struct xenkbd_key
|
||||
{
|
||||
uint8_t type;
|
||||
uint8_t pressed;
|
||||
uint32_t keycode;
|
||||
};
|
||||
|
||||
/*
|
||||
* Pointer absolute position event
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_POS | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | abs_x | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | abs_y | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | rel_z | 16
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 20
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* abs_x - int32_t, absolute X position (in FB pixels)
|
||||
* abs_y - int32_t, absolute Y position (in FB pixels)
|
||||
* rel_z - int32_t, relative Z motion (wheel)
|
||||
*/
|
||||
|
||||
struct xenkbd_position
|
||||
{
|
||||
uint8_t type;
|
||||
int32_t abs_x;
|
||||
int32_t abs_y;
|
||||
int32_t rel_z;
|
||||
};
|
||||
|
||||
/*
|
||||
* Multi-touch event and its sub-types
|
||||
*
|
||||
* All multi-touch event packets have common header:
|
||||
*
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | event_type | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* event_type - unt8_t, multi-touch event sub-type, XENKBD_MT_EV_???
|
||||
* contact_id - unt8_t, ID of the contact
|
||||
*
|
||||
* Touch interactions can consist of one or more contacts.
|
||||
* For each contact, a series of events is generated, starting
|
||||
* with a down event, followed by zero or more motion events,
|
||||
* and ending with an up event. Events relating to the same
|
||||
* contact point can be identified by the ID of the sequence: contact ID.
|
||||
* Contact ID may be reused after XENKBD_MT_EV_UP event and
|
||||
* is in the [0; XENKBD_FIELD_NUM_CONTACTS - 1] range.
|
||||
*
|
||||
* For further information please refer to documentation on Wayland [1],
|
||||
* Linux [2] and Windows [3] multi-touch support.
|
||||
*
|
||||
* [1] https://cgit.freedesktop.org/wayland/wayland/tree/protocol/wayland.xml
|
||||
* [2] https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt
|
||||
* [3] https://msdn.microsoft.com/en-us/library/jj151564(v=vs.85).aspx
|
||||
*
|
||||
*
|
||||
* Multi-touch down event - sent when a new touch is made: touch is assigned
|
||||
* a unique contact ID, sent with this and consequent events related
|
||||
* to this touch.
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | _MT_EV_DOWN | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | abs_x | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | abs_y | 16
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 20
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* abs_x - int32_t, absolute X position, in pixels
|
||||
* abs_y - int32_t, absolute Y position, in pixels
|
||||
*
|
||||
* Multi-touch contact release event
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | _MT_EV_UP | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* Multi-touch motion event
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | _MT_EV_MOTION | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | abs_x | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | abs_y | 16
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 20
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* abs_x - int32_t, absolute X position, in pixels,
|
||||
* abs_y - int32_t, absolute Y position, in pixels,
|
||||
*
|
||||
* Multi-touch input synchronization event - shows end of a set of events
|
||||
* which logically belong together.
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | _MT_EV_SYN | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* Multi-touch shape event - touch point's shape has changed its shape.
|
||||
* Shape is approximated by an ellipse through the major and minor axis
|
||||
* lengths: major is the longer diameter of the ellipse and minor is the
|
||||
* shorter one. Center of the ellipse is reported via
|
||||
* XENKBD_MT_EV_DOWN/XENKBD_MT_EV_MOTION events.
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | _MT_EV_SHAPE | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | major | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | minor | 16
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 20
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* major - unt32_t, length of the major axis, pixels
|
||||
* minor - unt32_t, length of the minor axis, pixels
|
||||
*
|
||||
* Multi-touch orientation event - touch point's shape has changed
|
||||
* its orientation: calculated as a clockwise angle between the major axis
|
||||
* of the ellipse and positive Y axis in degrees, [-180; +180].
|
||||
* 0 1 2 3 octet
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | _TYPE_MTOUCH | _MT_EV_ORIENT | contact_id | reserved | 4
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 8
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | orientation | reserved | 12
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 16
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
* | reserved | 40
|
||||
* +----------------+----------------+----------------+----------------+
|
||||
*
|
||||
* orientation - int16_t, clockwise angle of the major axis
|
||||
*/
|
||||
|
||||
struct xenkbd_mtouch {
|
||||
uint8_t type; /* XENKBD_TYPE_MTOUCH */
|
||||
uint8_t event_type; /* XENKBD_MT_EV_??? */
|
||||
uint8_t contact_id;
|
||||
uint8_t reserved[5]; /* reserved for the future use */
|
||||
union {
|
||||
struct {
|
||||
int32_t abs_x; /* absolute X position, pixels */
|
||||
int32_t abs_y; /* absolute Y position, pixels */
|
||||
} pos;
|
||||
struct {
|
||||
uint32_t major; /* length of the major axis, pixels */
|
||||
uint32_t minor; /* length of the minor axis, pixels */
|
||||
} shape;
|
||||
int16_t orientation; /* clockwise angle of the major axis */
|
||||
} u;
|
||||
};
|
||||
|
||||
#define XENKBD_IN_EVENT_SIZE 40
|
||||
|
||||
union xenkbd_in_event
|
||||
{
|
||||
uint8_t type;
|
||||
struct xenkbd_motion motion;
|
||||
struct xenkbd_key key;
|
||||
struct xenkbd_position pos;
|
||||
struct xenkbd_mtouch mtouch;
|
||||
char pad[XENKBD_IN_EVENT_SIZE];
|
||||
};
|
||||
|
||||
/*
|
||||
*****************************************************************************
|
||||
* Frontend to backend events
|
||||
*****************************************************************************
|
||||
*
|
||||
* Out events may be sent only when requested by backend, and receipt
|
||||
* of an unknown out event is an error.
|
||||
* No out events currently defined.
|
||||
|
||||
* All event packets have the same length (40 octets)
|
||||
* All event packets have common header:
|
||||
* 0 octet
|
||||
* +-----------------+
|
||||
* | type |
|
||||
* +-----------------+
|
||||
* type - uint8_t, event code
|
||||
*/
|
||||
|
||||
#define XENKBD_OUT_EVENT_SIZE 40
|
||||
|
||||
union xenkbd_out_event
|
||||
{
|
||||
uint8_t type;
|
||||
char pad[XENKBD_OUT_EVENT_SIZE];
|
||||
};
|
||||
|
||||
/*
|
||||
*****************************************************************************
|
||||
* Shared page
|
||||
*****************************************************************************
|
||||
*/
|
||||
|
||||
#define XENKBD_IN_RING_SIZE 2048
|
||||
#define XENKBD_IN_RING_LEN (XENKBD_IN_RING_SIZE / XENKBD_IN_EVENT_SIZE)
|
||||
#define XENKBD_IN_RING_OFFS 1024
|
||||
#define XENKBD_IN_RING(page) \
|
||||
((union xenkbd_in_event *)((char *)(page) + XENKBD_IN_RING_OFFS))
|
||||
#define XENKBD_IN_RING_REF(page, idx) \
|
||||
(XENKBD_IN_RING((page))[(idx) % XENKBD_IN_RING_LEN])
|
||||
|
||||
#define XENKBD_OUT_RING_SIZE 1024
|
||||
#define XENKBD_OUT_RING_LEN (XENKBD_OUT_RING_SIZE / XENKBD_OUT_EVENT_SIZE)
|
||||
#define XENKBD_OUT_RING_OFFS (XENKBD_IN_RING_OFFS + XENKBD_IN_RING_SIZE)
|
||||
#define XENKBD_OUT_RING(page) \
|
||||
((union xenkbd_out_event *)((char *)(page) + XENKBD_OUT_RING_OFFS))
|
||||
#define XENKBD_OUT_RING_REF(page, idx) \
|
||||
(XENKBD_OUT_RING((page))[(idx) % XENKBD_OUT_RING_LEN])
|
||||
|
||||
struct xenkbd_page
|
||||
{
|
||||
uint32_t in_cons, in_prod;
|
||||
uint32_t out_cons, out_prod;
|
||||
};
|
||||
|
||||
#endif /* __XEN_PUBLIC_IO_KBDIF_H__ */
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,42 @@
|
|||
/******************************************************************************
|
||||
* protocols.h
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (c) 2008, Keir Fraser
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PROTOCOLS_H__
|
||||
#define __XEN_PROTOCOLS_H__
|
||||
|
||||
#define XEN_IO_PROTO_ABI_X86_32 "x86_32-abi"
|
||||
#define XEN_IO_PROTO_ABI_X86_64 "x86_64-abi"
|
||||
#define XEN_IO_PROTO_ABI_ARM "arm-abi"
|
||||
|
||||
#if defined(__i386__)
|
||||
# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_32
|
||||
#elif defined(__x86_64__)
|
||||
# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_64
|
||||
#elif defined(__arm__) || defined(__aarch64__)
|
||||
# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_ARM
|
||||
#else
|
||||
# error arch fixup needed here
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -24,8 +24,8 @@
|
|||
* Tim Deegan and Andrew Warfield November 2004.
|
||||
*/
|
||||
|
||||
#ifndef XEN_PUBLIC_IO_RING_H
|
||||
#define XEN_PUBLIC_IO_RING_H
|
||||
#ifndef __XEN_PUBLIC_IO_RING_H__
|
||||
#define __XEN_PUBLIC_IO_RING_H__
|
||||
|
||||
/*
|
||||
* When #include'ing this header, you need to provide the following
|
||||
|
|
@ -469,7 +469,7 @@ struct name##_data_intf { \
|
|||
}; \
|
||||
DEFINE_XEN_FLEX_RING(name)
|
||||
|
||||
#endif /* XEN_PUBLIC_IO_RING_H */
|
||||
#endif /* __XEN_PUBLIC_IO_RING_H__ */
|
||||
|
||||
/*
|
||||
* Local variables:
|
||||
|
|
@ -0,0 +1,254 @@
|
|||
/*
|
||||
* usbif.h
|
||||
*
|
||||
* USB I/O interface for Xen guest OSes.
|
||||
*
|
||||
* Copyright (C) 2009, FUJITSU LABORATORIES LTD.
|
||||
* Author: Noboru Iwamatsu <n_iwamatsu@jp.fujitsu.com>
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef __XEN_PUBLIC_IO_USBIF_H__
|
||||
#define __XEN_PUBLIC_IO_USBIF_H__
|
||||
|
||||
#include "ring.h"
|
||||
#include "../grant_table.h"
|
||||
|
||||
/*
|
||||
* Feature and Parameter Negotiation
|
||||
* =================================
|
||||
* The two halves of a Xen pvUSB driver utilize nodes within the XenStore to
|
||||
* communicate capabilities and to negotiate operating parameters. This
|
||||
* section enumerates these nodes which reside in the respective front and
|
||||
* backend portions of the XenStore, following the XenBus convention.
|
||||
*
|
||||
* Any specified default value is in effect if the corresponding XenBus node
|
||||
* is not present in the XenStore.
|
||||
*
|
||||
* XenStore nodes in sections marked "PRIVATE" are solely for use by the
|
||||
* driver side whose XenBus tree contains them.
|
||||
*
|
||||
*****************************************************************************
|
||||
* Backend XenBus Nodes
|
||||
*****************************************************************************
|
||||
*
|
||||
*------------------ Backend Device Identification (PRIVATE) ------------------
|
||||
*
|
||||
* num-ports
|
||||
* Values: unsigned [1...31]
|
||||
*
|
||||
* Number of ports for this (virtual) USB host connector.
|
||||
*
|
||||
* usb-ver
|
||||
* Values: unsigned [1...2]
|
||||
*
|
||||
* USB version of this host connector: 1 = USB 1.1, 2 = USB 2.0.
|
||||
*
|
||||
* port/[1...31]
|
||||
* Values: string
|
||||
*
|
||||
* Physical USB device connected to the given port, e.g. "3-1.5".
|
||||
*
|
||||
*****************************************************************************
|
||||
* Frontend XenBus Nodes
|
||||
*****************************************************************************
|
||||
*
|
||||
*----------------------- Request Transport Parameters -----------------------
|
||||
*
|
||||
* event-channel
|
||||
* Values: unsigned
|
||||
*
|
||||
* The identifier of the Xen event channel used to signal activity
|
||||
* in the ring buffer.
|
||||
*
|
||||
* urb-ring-ref
|
||||
* Values: unsigned
|
||||
*
|
||||
* The Xen grant reference granting permission for the backend to map
|
||||
* the sole page in a single page sized ring buffer. This is the ring
|
||||
* buffer for urb requests.
|
||||
*
|
||||
* conn-ring-ref
|
||||
* Values: unsigned
|
||||
*
|
||||
* The Xen grant reference granting permission for the backend to map
|
||||
* the sole page in a single page sized ring buffer. This is the ring
|
||||
* buffer for connection/disconnection requests.
|
||||
*
|
||||
* protocol
|
||||
* Values: string (XEN_IO_PROTO_ABI_*)
|
||||
* Default Value: XEN_IO_PROTO_ABI_NATIVE
|
||||
*
|
||||
* The machine ABI rules governing the format of all ring request and
|
||||
* response structures.
|
||||
*
|
||||
*/
|
||||
|
||||
enum usb_spec_version {
|
||||
USB_VER_UNKNOWN = 0,
|
||||
USB_VER_USB11,
|
||||
USB_VER_USB20,
|
||||
USB_VER_USB30, /* not supported yet */
|
||||
};
|
||||
|
||||
/*
|
||||
* USB pipe in usbif_request
|
||||
*
|
||||
* - port number: bits 0-4
|
||||
* (USB_MAXCHILDREN is 31)
|
||||
*
|
||||
* - operation flag: bit 5
|
||||
* (0 = submit urb,
|
||||
* 1 = unlink urb)
|
||||
*
|
||||
* - direction: bit 7
|
||||
* (0 = Host-to-Device [Out]
|
||||
* 1 = Device-to-Host [In])
|
||||
*
|
||||
* - device address: bits 8-14
|
||||
*
|
||||
* - endpoint: bits 15-18
|
||||
*
|
||||
* - pipe type: bits 30-31
|
||||
* (00 = isochronous, 01 = interrupt,
|
||||
* 10 = control, 11 = bulk)
|
||||
*/
|
||||
|
||||
#define USBIF_PIPE_PORT_MASK 0x0000001f
|
||||
#define USBIF_PIPE_UNLINK 0x00000020
|
||||
#define USBIF_PIPE_DIR 0x00000080
|
||||
#define USBIF_PIPE_DEV_MASK 0x0000007f
|
||||
#define USBIF_PIPE_DEV_SHIFT 8
|
||||
#define USBIF_PIPE_EP_MASK 0x0000000f
|
||||
#define USBIF_PIPE_EP_SHIFT 15
|
||||
#define USBIF_PIPE_TYPE_MASK 0x00000003
|
||||
#define USBIF_PIPE_TYPE_SHIFT 30
|
||||
#define USBIF_PIPE_TYPE_ISOC 0
|
||||
#define USBIF_PIPE_TYPE_INT 1
|
||||
#define USBIF_PIPE_TYPE_CTRL 2
|
||||
#define USBIF_PIPE_TYPE_BULK 3
|
||||
|
||||
#define usbif_pipeportnum(pipe) ((pipe) & USBIF_PIPE_PORT_MASK)
|
||||
#define usbif_setportnum_pipe(pipe, portnum) ((pipe) | (portnum))
|
||||
|
||||
#define usbif_pipeunlink(pipe) ((pipe) & USBIF_PIPE_UNLINK)
|
||||
#define usbif_pipesubmit(pipe) (!usbif_pipeunlink(pipe))
|
||||
#define usbif_setunlink_pipe(pipe) ((pipe) | USBIF_PIPE_UNLINK)
|
||||
|
||||
#define usbif_pipein(pipe) ((pipe) & USBIF_PIPE_DIR)
|
||||
#define usbif_pipeout(pipe) (!usbif_pipein(pipe))
|
||||
|
||||
#define usbif_pipedevice(pipe) \
|
||||
(((pipe) >> USBIF_PIPE_DEV_SHIFT) & USBIF_PIPE_DEV_MASK)
|
||||
|
||||
#define usbif_pipeendpoint(pipe) \
|
||||
(((pipe) >> USBIF_PIPE_EP_SHIFT) & USBIF_PIPE_EP_MASK)
|
||||
|
||||
#define usbif_pipetype(pipe) \
|
||||
(((pipe) >> USBIF_PIPE_TYPE_SHIFT) & USBIF_PIPE_TYPE_MASK)
|
||||
#define usbif_pipeisoc(pipe) (usbif_pipetype(pipe) == USBIF_PIPE_TYPE_ISOC)
|
||||
#define usbif_pipeint(pipe) (usbif_pipetype(pipe) == USBIF_PIPE_TYPE_INT)
|
||||
#define usbif_pipectrl(pipe) (usbif_pipetype(pipe) == USBIF_PIPE_TYPE_CTRL)
|
||||
#define usbif_pipebulk(pipe) (usbif_pipetype(pipe) == USBIF_PIPE_TYPE_BULK)
|
||||
|
||||
#define USBIF_MAX_SEGMENTS_PER_REQUEST (16)
|
||||
#define USBIF_MAX_PORTNR 31
|
||||
#define USBIF_RING_SIZE 4096
|
||||
|
||||
/*
|
||||
* RING for transferring urbs.
|
||||
*/
|
||||
struct usbif_request_segment {
|
||||
grant_ref_t gref;
|
||||
uint16_t offset;
|
||||
uint16_t length;
|
||||
};
|
||||
|
||||
struct usbif_urb_request {
|
||||
uint16_t id; /* request id */
|
||||
uint16_t nr_buffer_segs; /* number of urb->transfer_buffer segments */
|
||||
|
||||
/* basic urb parameter */
|
||||
uint32_t pipe;
|
||||
uint16_t transfer_flags;
|
||||
#define USBIF_SHORT_NOT_OK 0x0001
|
||||
uint16_t buffer_length;
|
||||
union {
|
||||
uint8_t ctrl[8]; /* setup_packet (Ctrl) */
|
||||
|
||||
struct {
|
||||
uint16_t interval; /* maximum (1024*8) in usb core */
|
||||
uint16_t start_frame; /* start frame */
|
||||
uint16_t number_of_packets; /* number of ISO packet */
|
||||
uint16_t nr_frame_desc_segs; /* number of iso_frame_desc segments */
|
||||
} isoc;
|
||||
|
||||
struct {
|
||||
uint16_t interval; /* maximum (1024*8) in usb core */
|
||||
uint16_t pad[3];
|
||||
} intr;
|
||||
|
||||
struct {
|
||||
uint16_t unlink_id; /* unlink request id */
|
||||
uint16_t pad[3];
|
||||
} unlink;
|
||||
|
||||
} u;
|
||||
|
||||
/* urb data segments */
|
||||
struct usbif_request_segment seg[USBIF_MAX_SEGMENTS_PER_REQUEST];
|
||||
};
|
||||
typedef struct usbif_urb_request usbif_urb_request_t;
|
||||
|
||||
struct usbif_urb_response {
|
||||
uint16_t id; /* request id */
|
||||
uint16_t start_frame; /* start frame (ISO) */
|
||||
int32_t status; /* status (non-ISO) */
|
||||
int32_t actual_length; /* actual transfer length */
|
||||
int32_t error_count; /* number of ISO errors */
|
||||
};
|
||||
typedef struct usbif_urb_response usbif_urb_response_t;
|
||||
|
||||
DEFINE_RING_TYPES(usbif_urb, struct usbif_urb_request, struct usbif_urb_response);
|
||||
#define USB_URB_RING_SIZE __CONST_RING_SIZE(usbif_urb, USBIF_RING_SIZE)
|
||||
|
||||
/*
|
||||
* RING for notifying connect/disconnect events to frontend
|
||||
*/
|
||||
struct usbif_conn_request {
|
||||
uint16_t id;
|
||||
};
|
||||
typedef struct usbif_conn_request usbif_conn_request_t;
|
||||
|
||||
struct usbif_conn_response {
|
||||
uint16_t id; /* request id */
|
||||
uint8_t portnum; /* port number */
|
||||
uint8_t speed; /* usb_device_speed */
|
||||
#define USBIF_SPEED_NONE 0
|
||||
#define USBIF_SPEED_LOW 1
|
||||
#define USBIF_SPEED_FULL 2
|
||||
#define USBIF_SPEED_HIGH 3
|
||||
};
|
||||
typedef struct usbif_conn_response usbif_conn_response_t;
|
||||
|
||||
DEFINE_RING_TYPES(usbif_conn, struct usbif_conn_request, struct usbif_conn_response);
|
||||
#define USB_CONN_RING_SIZE __CONST_RING_SIZE(usbif_conn, USBIF_RING_SIZE)
|
||||
|
||||
#endif /* __XEN_PUBLIC_IO_USBIF_H__ */
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
/*****************************************************************************
|
||||
* xenbus.h
|
||||
*
|
||||
* Xenbus protocol details.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Copyright (C) 2005 XenSource Ltd.
|
||||
*/
|
||||
|
||||
#ifndef _XEN_PUBLIC_IO_XENBUS_H
|
||||
#define _XEN_PUBLIC_IO_XENBUS_H
|
||||
|
||||
/*
|
||||
* The state of either end of the Xenbus, i.e. the current communication
|
||||
* status of initialisation across the bus. States here imply nothing about
|
||||
* the state of the connection between the driver and the kernel's device
|
||||
* layers.
|
||||
*/
|
||||
enum xenbus_state {
|
||||
XenbusStateUnknown = 0,
|
||||
|
||||
XenbusStateInitialising = 1,
|
||||
|
||||
/*
|
||||
* InitWait: Finished early initialisation but waiting for information
|
||||
* from the peer or hotplug scripts.
|
||||
*/
|
||||
XenbusStateInitWait = 2,
|
||||
|
||||
/*
|
||||
* Initialised: Waiting for a connection from the peer.
|
||||
*/
|
||||
XenbusStateInitialised = 3,
|
||||
|
||||
XenbusStateConnected = 4,
|
||||
|
||||
/*
|
||||
* Closing: The device is being closed due to an error or an unplug event.
|
||||
*/
|
||||
XenbusStateClosing = 5,
|
||||
|
||||
XenbusStateClosed = 6,
|
||||
|
||||
/*
|
||||
* Reconfiguring: The device is being reconfigured.
|
||||
*/
|
||||
XenbusStateReconfiguring = 7,
|
||||
|
||||
XenbusStateReconfigured = 8
|
||||
};
|
||||
typedef enum xenbus_state XenbusState;
|
||||
|
||||
#endif /* _XEN_PUBLIC_IO_XENBUS_H */
|
||||
|
|
@ -15,6 +15,7 @@
|
|||
typedef void (*XenWatchHandler)(void *opaque);
|
||||
|
||||
typedef struct XenWatch XenWatch;
|
||||
typedef struct XenEventChannel XenEventChannel;
|
||||
|
||||
typedef struct XenDevice {
|
||||
DeviceState qdev;
|
||||
|
|
@ -28,8 +29,7 @@ typedef struct XenDevice {
|
|||
XenWatch *backend_online_watch;
|
||||
xengnttab_handle *xgth;
|
||||
bool feature_grant_copy;
|
||||
xenevtchn_handle *xeh;
|
||||
NotifierList event_notifiers;
|
||||
QLIST_HEAD(, XenEventChannel) event_channels;
|
||||
} XenDevice;
|
||||
|
||||
typedef char *(*XenDeviceGetName)(XenDevice *xendev, Error **errp);
|
||||
|
|
@ -119,11 +119,10 @@ void xen_device_copy_grant_refs(XenDevice *xendev, bool to_domain,
|
|||
XenDeviceGrantCopySegment segs[],
|
||||
unsigned int nr_segs, Error **errp);
|
||||
|
||||
typedef struct XenEventChannel XenEventChannel;
|
||||
|
||||
typedef void (*XenEventHandler)(void *opaque);
|
||||
typedef bool (*XenEventHandler)(void *opaque);
|
||||
|
||||
XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
|
||||
AioContext *ctx,
|
||||
unsigned int port,
|
||||
XenEventHandler handler,
|
||||
void *opaque, Error **errp);
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
#include <xenctrl.h>
|
||||
#include <xenstore.h>
|
||||
#include <xen/io/xenbus.h>
|
||||
#include "hw/xen/interface/io/xenbus.h"
|
||||
|
||||
#include "hw/hw.h"
|
||||
#include "hw/xen/xen.h"
|
||||
|
|
|
|||
Loading…
Reference in New Issue