3:51 p.m.
The following series of patches introduce support for generic data
streams in the libvirt API, the remote protocol, client & daemon.
The public API takes the form of a new object virStreamPtr and
methods to read/write/close it
The remote protocol was the main hard bit. Since the protocol
allows multiple concurrent API calls on a single connection,
this needed to also allow concurrent data streams. It is also
not acceptable for a large data stream to block other traffic
while it is transferring.
Thus, we introduce a new protocol message type 'REMOTE_STREAM'
to handle transfer for the stream data. A method involving a
data streams starts off in the normal way with a REMOTE_CALL
to the server, and a REMOTE_REPLY response message. If this
was successful, there now follows the data stream traffic.
For outgoing streams (data from client to server), the client
will send zero or more REMOTE_STREAM packets containing the
data with status == REMOTE_CONTINUE. These are asynchronous
and not acknowledged by the server. At any time the server
may send an async message with a type of REMOTE_STREAM and
status of REMOTE_ERROR. This indicates to the client that the
transfer is aborting at server request. If the client wishes
to abort, it can send the server a REMOTE_STREAM+REMOTE_ERROR
message. If the client finishes its data transfer, it will
send a final REMOTE_STREAM+REMOTE_OK message, and the server
will respond with the same. This full roundtrip handshake
ensures any async error messages are guarenteed to be flushed
For incoming data streams (data from server to client), the
server sends zero or more REMOTE_STREAM packets containing the
data with status == REMOTE_CONTINUE. These are asynchronous
and not acknowledged by the client. At any time the client
may send an async message with a type of REMOTE_STREAM and
status of REMOTE_ERROR. This indicates to the server that the
transfer is aborting at client request. If the server wishes
to abort, it can send the server a REMOTE_STREAM+REMOTE_ERROR
message. When the server finishes its data transfer, it will
send a final REMOTE_STREAM+REMOTE_CONTINUE message ewith a
data length of zero (ie EOF). The client will then send a
REMOTE_STREAM+REMOTE_OK packet and the server will respond
with the same. This full roundtrip handshake ensures any async
error messages are guarenteed to be flushed
This all ensures that multiple data streams can be active in
parallel, and with a maximum data packet size of 256 KB, no
single stream can cause too much latency on the connection for
other API calls/streams.
The only thing it does not allow for is one API method to use
two or more streams. These may be famous last words, but I
don't think that use case will be neccessary for any of our
APIs...
The last 5 patches with a subject of [DEMO] are *NOT* intended
to be committed to the repository. They merely demonstrate the
use of data streams for a couple of hypothetical file upload
and download APIs. Actually they were mostly to allow me to
test the code streams code without messing around with the QEMU
migration code.
The immediate use case for this data stream code is Chris' QEMU
migration patchset.
The next use case is to allow serial console access to be tunnelled
over libvirtd, eg to make 'virsh console GUEST' work remotely.
This use case is why I included the support for non-blocking data
streams and event loop integration (not required for Chris'
migration use case)
Anyway, assuming Chris confirms that I've not broken his code, then
patches 1-6 are targetted for this next release.
.x-sc_avoid_write | 3
include/libvirt/libvirt.h | 101 ++++
include/libvirt/libvirt.h.in | 101 ++++
po/POTFILES.in | 1
qemud/Makefile.am | 1
qemud/dispatch.c | 131 ++++++
qemud/dispatch.h | 17
qemud/event.c | 54 +-
qemud/qemud.c | 56 +-
qemud/qemud.h | 33 +
qemud/remote.c | 237 ++++++++++-
qemud/remote.h | 1
qemud/remote_dispatch_args.h | 2
qemud/remote_dispatch_prototypes.h | 153 +++++++
qemud/remote_dispatch_table.h | 10
qemud/remote_generate_stubs.pl | 1
qemud/remote_protocol.c | 18
qemud/remote_protocol.h | 20
qemud/remote_protocol.x | 57 ++
qemud/stream.c | 605 +++++++++++++++++++++++++++++
qemud/stream.h | 53 ++
src/datatypes.c | 59 ++
src/datatypes.h | 33 +
src/driver.h | 40 +
src/esx/esx_driver.c | 2
src/libvirt.c | 769 +++++++++++++++++++++++++++++++++++++
src/libvirt_private.syms | 2
src/libvirt_public.syms | 18
src/lxc_driver.c | 2
src/opennebula/one_driver.c | 2
src/openvz_driver.c | 2
src/qemu_driver.c | 2
src/remote_internal.c | 601 ++++++++++++++++++++++++++++
src/test.c | 477 ++++++++++++++++++++++
src/uml_driver.c | 2
src/vbox/vbox_tmpl.c | 3
src/virsh.c | 164 +++++++
src/xen_unified.c | 2
tests/eventtest.c | 19
39 files changed, 3783 insertions(+), 71 deletions(-)
Regards,
Daniel
3:51 p.m.
New subject: [libvirt] [PATCH 01/11] Add public API definition for data stream handling
* include/libvirt/libvirt.h, include/libvirt/libvirt.h.in: Public
API contract for virStreamPtr object
* src/libvirt_public.syms: Export data stream APIs
* src/libvirt_private.syms: Export internal helper APIs
* src/libvirt.c: Data stream API driver dispatch
* src/datatypes.h, src/datatypes.c: Internal helpers for virStreamPtr
object
* src/driver.h: Define internal driver API for streams
* .x-sc_avoid_write: Ignore src/libvirt.c because it trips
up on comments including write()
---
.x-sc_avoid_write | 1 +
include/libvirt/libvirt.h | 93 ++++++
include/libvirt/libvirt.h.in | 93 ++++++
src/datatypes.c | 59 ++++
src/datatypes.h | 33 ++
src/driver.h | 34 ++
src/libvirt.c | 683 ++++++++++++++++++++++++++++++++++++++++++
src/libvirt_private.syms | 2 +
src/libvirt_public.syms | 15 +
9 files changed, 1013 insertions(+), 0 deletions(-)
diff --git a/.x-sc_avoid_write b/.x-sc_avoid_write
index 8ed87c5..c5a7535 100644
--- a/.x-sc_avoid_write
+++ b/.x-sc_avoid_write
@@ -1,5 +1,6 @@
^src/util\.c$
^src/xend_internal\.c$
^src/util-lib\.c$
+^src/libvirt\.c$
^qemud/qemud.c$
^gnulib/
diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index 855f755..5dcecfd 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -110,6 +110,24 @@ typedef enum {
VIR_DOMAIN_NONE = 0
} virDomainCreateFlags;
+
+
+/**
+ * virStream:
+ *
+ * a virStream is a private structure representing a data stream.
+ */
+typedef struct _virStream virStream;
+
+/**
+ * virStreamPtr:
+ *
+ * a virStreamPtr is pointer to a virStream private structure, this is the
+ * type used to reference a data stream in the API.
+ */
+typedef virStream *virStreamPtr;
+
+
/**
* VIR_SECURITY_LABEL_BUFLEN:
*
@@ -1448,6 +1466,81 @@ void virEventRegisterImpl(virEventAddHandleFunc addHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout);
+
+enum {
+ VIR_STREAM_NONBLOCK = (1 << 0),
+};
+
+virStreamPtr virStreamNew(virConnectPtr conn,
+ unsigned int flags);
+int virStreamRef(virStreamPtr st);
+
+int virStreamSend(virStreamPtr st,
+ const char *data,
+ size_t nbytes);
+
+int virStreamRecv(virStreamPtr st,
+ char *data,
+ size_t nbytes);
+
+
+typedef int (*virStreamSourceFunc)(virStreamPtr st,
+ char *data,
+ size_t nbytes,
+ void *opaque);
+
+int virStreamSendAll(virStreamPtr st,
+ virStreamSourceFunc handler,
+ void *opaque);
+
+typedef int (*virStreamSinkFunc)(virStreamPtr st,
+ const char *data,
+ size_t nbytes,
+ void *opaque);
+
+int virStreamRecvAll(virStreamPtr st,
+ virStreamSinkFunc handler,
+ void *opaque);
+
+typedef enum {
+ VIR_STREAM_EVENT_READABLE = (1 << 0),
+ VIR_STREAM_EVENT_WRITABLE = (1 << 1),
+ VIR_STREAM_EVENT_ERROR = (1 << 2),
+ VIR_STREAM_EVENT_HANGUP = (1 << 3),
+} virStreamEventType;
+
+
+/**
+ * virStreamEventCallback:
+ *
+ * @stream: stream on which the event occurred
+ * @events: bitset of events from virEventHandleType constants
+ * @opaque: user data registered with handle
+ *
+ * Callback for receiving stream events. The callback will
+ * be invoked once for each event which is pending.
+ */
+typedef void (*virStreamEventCallback)(virStreamPtr stream, int events, void *opaque);
+
+int virStreamEventAddCallback(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff);
+
+int virStreamEventUpdateCallback(virStreamPtr stream,
+ int events);
+
+int virStreamEventRemoveCallback(virStreamPtr stream);
+
+
+int virStreamFinish(virStreamPtr st);
+int virStreamAbort(virStreamPtr st);
+
+int virStreamFree(virStreamPtr st);
+
+
+
#ifdef __cplusplus
}
#endif
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index e6536c7..db091dc 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -110,6 +110,24 @@ typedef enum {
VIR_DOMAIN_NONE = 0
} virDomainCreateFlags;
+
+
+/**
+ * virStream:
+ *
+ * a virStream is a private structure representing a data stream.
+ */
+typedef struct _virStream virStream;
+
+/**
+ * virStreamPtr:
+ *
+ * a virStreamPtr is pointer to a virStream private structure, this is the
+ * type used to reference a data stream in the API.
+ */
+typedef virStream *virStreamPtr;
+
+
/**
* VIR_SECURITY_LABEL_BUFLEN:
*
@@ -1448,6 +1466,81 @@ void virEventRegisterImpl(virEventAddHandleFunc addHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout);
+
+enum {
+ VIR_STREAM_NONBLOCK = (1 << 0),
+};
+
+virStreamPtr virStreamNew(virConnectPtr conn,
+ unsigned int flags);
+int virStreamRef(virStreamPtr st);
+
+int virStreamSend(virStreamPtr st,
+ const char *data,
+ size_t nbytes);
+
+int virStreamRecv(virStreamPtr st,
+ char *data,
+ size_t nbytes);
+
+
+typedef int (*virStreamSourceFunc)(virStreamPtr st,
+ char *data,
+ size_t nbytes,
+ void *opaque);
+
+int virStreamSendAll(virStreamPtr st,
+ virStreamSourceFunc handler,
+ void *opaque);
+
+typedef int (*virStreamSinkFunc)(virStreamPtr st,
+ const char *data,
+ size_t nbytes,
+ void *opaque);
+
+int virStreamRecvAll(virStreamPtr st,
+ virStreamSinkFunc handler,
+ void *opaque);
+
+typedef enum {
+ VIR_STREAM_EVENT_READABLE = (1 << 0),
+ VIR_STREAM_EVENT_WRITABLE = (1 << 1),
+ VIR_STREAM_EVENT_ERROR = (1 << 2),
+ VIR_STREAM_EVENT_HANGUP = (1 << 3),
+} virStreamEventType;
+
+
+/**
+ * virStreamEventCallback:
+ *
+ * @stream: stream on which the event occurred
+ * @events: bitset of events from virEventHandleType constants
+ * @opaque: user data registered with handle
+ *
+ * Callback for receiving stream events. The callback will
+ * be invoked once for each event which is pending.
+ */
+typedef void (*virStreamEventCallback)(virStreamPtr stream, int events, void *opaque);
+
+int virStreamEventAddCallback(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff);
+
+int virStreamEventUpdateCallback(virStreamPtr stream,
+ int events);
+
+int virStreamEventRemoveCallback(virStreamPtr stream);
+
+
+int virStreamFinish(virStreamPtr st);
+int virStreamAbort(virStreamPtr st);
+
+int virStreamFree(virStreamPtr st);
+
+
+
#ifdef __cplusplus
}
#endif
diff --git a/src/datatypes.c b/src/datatypes.c
index d03a679..3611b62 100644
--- a/src/datatypes.c
+++ b/src/datatypes.c
@@ -1129,3 +1129,62 @@ virUnrefNodeDevice(virNodeDevicePtr dev) {
virMutexUnlock(&dev->conn->lock);
return (refs);
}
+
+
+virStreamPtr virGetStream(virConnectPtr conn) {
+ virStreamPtr ret = NULL;
+
+ virMutexLock(&conn->lock);
+
+ if (VIR_ALLOC(ret) < 0) {
+ virReportOOMError(conn);
+ goto error;
+ }
+ ret->magic = VIR_STREAM_MAGIC;
+ ret->conn = conn;
+ conn->refs++;
+ ret->refs++;
+ virMutexUnlock(&conn->lock);
+ return(ret);
+
+error:
+ virMutexUnlock(&conn->lock);
+ VIR_FREE(ret);
+ return(NULL);
+}
+
+static void
+virReleaseStream(virStreamPtr st) {
+ virConnectPtr conn = st->conn;
+ DEBUG("release dev %p", st);
+
+ st->magic = -1;
+ VIR_FREE(st);
+
+ DEBUG("unref connection %p %d", conn, conn->refs);
+ conn->refs--;
+ if (conn->refs == 0) {
+ virReleaseConnect(conn);
+ /* Already unlocked mutex */
+ return;
+ }
+
+ virMutexUnlock(&conn->lock);
+}
+
+int virUnrefStream(virStreamPtr st) {
+ int refs;
+
+ virMutexLock(&st->conn->lock);
+ DEBUG("unref stream %p %d", st, st->refs);
+ st->refs--;
+ refs = st->refs;
+ if (refs == 0) {
+ virReleaseStream(st);
+ /* Already unlocked mutex */
+ return (0);
+ }
+
+ virMutexUnlock(&st->conn->lock);
+ return (refs);
+}
diff --git a/src/datatypes.h b/src/datatypes.h
index da83e02..0fed07f 100644
--- a/src/datatypes.h
+++ b/src/datatypes.h
@@ -100,6 +100,17 @@
/**
+ * VIR_STREAM_MAGIC:
+ *
+ * magic value used to protect the API when pointers to stream structures
+ * are passed down by the users.
+ */
+#define VIR_STREAM_MAGIC 0x1DEAD666
+#define VIR_IS_STREAM(obj) ((obj) &&
(obj)->magic==VIR_STREAM_MAGIC)
+#define VIR_IS_CONNECTED_STREAM(obj) (VIR_IS_STREAM(obj) &&
VIR_IS_CONNECT((obj)->conn))
+
+
+/**
* _virConnect:
*
* Internal structure associated to a connection
@@ -234,6 +245,25 @@ struct _virNodeDevice {
};
+typedef int (*virStreamAbortFunc)(virStreamPtr, void *opaque);
+typedef int (*virStreamFinishFunc)(virStreamPtr, void *opaque);
+
+/**
+ * _virStream:
+ *
+ * Internal structure associated with an input stream
+ */
+struct _virStream {
+ unsigned int magic;
+ virConnectPtr conn;
+ int refs;
+ int flags;
+
+ virStreamDriverPtr driver;
+ void *privateData;
+};
+
+
/************************************************************************
* *
* API for domain/connections (de)allocations and lookups *
@@ -270,4 +300,7 @@ virNodeDevicePtr virGetNodeDevice(virConnectPtr conn,
const char *name);
int virUnrefNodeDevice(virNodeDevicePtr dev);
+virStreamPtr virGetStream(virConnectPtr conn);
+int virUnrefStream(virStreamPtr st);
+
#endif
diff --git a/src/driver.h b/src/driver.h
index 79d46ff..25d34b6 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -799,6 +799,40 @@ struct _virDeviceMonitor {
virDrvNodeDeviceDestroy deviceDestroy;
};
+typedef struct _virStreamDriver virStreamDriver;
+typedef virStreamDriver *virStreamDriverPtr;
+
+typedef int (*virDrvStreamSend)(virStreamPtr st,
+ const char *data,
+ size_t nbytes);
+typedef int (*virDrvStreamRecv)(virStreamPtr st,
+ char *data,
+ size_t nbytes);
+
+typedef int (*virDrvStreamEventAddCallback)(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff);
+
+typedef int (*virDrvStreamEventUpdateCallback)(virStreamPtr stream,
+ int events);
+typedef int (*virDrvStreamEventRemoveCallback)(virStreamPtr stream);
+typedef int (*virDrvStreamFinish)(virStreamPtr st);
+typedef int (*virDrvStreamAbort)(virStreamPtr st);
+
+
+struct _virStreamDriver {
+ virDrvStreamSend streamSend;
+ virDrvStreamRecv streamRecv;
+ virDrvStreamEventAddCallback streamAddCallback;
+ virDrvStreamEventUpdateCallback streamUpdateCallback;
+ virDrvStreamEventRemoveCallback streamRemoveCallback;
+ virDrvStreamFinish streamFinish;
+ virDrvStreamAbort streamAbort;
+};
+
+
/*
* Registration
* TODO: also need ways to (des)activate a given driver
diff --git a/src/libvirt.c b/src/libvirt.c
index ca8e003..d6536f4 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -559,6 +559,10 @@ virLibNodeDeviceError(virNodeDevicePtr dev, virErrorNumber error,
errmsg, info, NULL, 0, 0, errmsg, info);
}
+#define virLibStreamError(conn, code, fmt...) \
+ virReportErrorHelper(conn, VIR_FROM_NONE, code, __FILE__, \
+ __FUNCTION__, __LINE__, fmt)
+
/**
* virRegisterNetworkDriver:
* @driver: pointer to a network driver block
@@ -8626,3 +8630,682 @@ error:
virSetConnError(conn);
return -1;
}
+
+
+/**
+ * virStreamNew:
+ * @conn: pointer to the connection
+ * @flags: control features of the stream
+ *
+ * Creates a new stream object which can be used to perform
+ * streamed I/O with other public API function.
+ *
+ * When no longer needed, a stream object must be released
+ * with virStreamFree. If a data stream has been used,
+ * then the application must call virStreamFinish or
+ * virStreamAbort before free'ing to, in order to notify
+ * the driver of termination.
+ *
+ * If a non-blocking data stream is required passed
+ * VIR_STREAM_NONBLOCK for flags, otherwise pass 0.
+ *
+ * Returns the new stream, or NULL upon error
+ */
+virStreamPtr
+virStreamNew(virConnectPtr conn,
+ unsigned int flags)
+{
+ virStreamPtr st;
+
+ DEBUG("conn=%p, flags=%u", conn, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (NULL);
+ }
+
+ st = virGetStream(conn);
+ if (st)
+ st->flags = flags;
+
+ return st;
+}
+
+
+/**
+ * virStreamRef:
+ * @stream: pointer to the stream
+ *
+ * Increment the reference count on the stream. For each
+ * additional call to this method, there shall be a corresponding
+ * call to virStreamFree to release the reference count, once
+ * the caller no longer needs the reference to this object.
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+int
+virStreamRef(virStreamPtr stream)
+{
+ if ((!VIR_IS_CONNECTED_STREAM(stream))) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+ virMutexLock(&stream->conn->lock);
+ DEBUG("stream=%p refs=%d", stream, stream->refs);
+ stream->refs++;
+ virMutexUnlock(&stream->conn->lock);
+ return 0;
+}
+
+
+/**
+ * virStreamSend:
+ * @stream: pointer to the stream object
+ * @data: buffer to write to stream
+ * @nbytes: size of @data buffer
+ *
+ * Write a series of bytes to the stream. This method may
+ * block the calling application for an arbitrary amount
+ * of time. Once an application has finished sending data
+ * it should call virStreamFinish to wait for succesful
+ * confirmation from the driver, or detect any error
+ *
+ * This method may not be used if a stream source has been
+ * registered
+ *
+ * Errors are not guaranteed to be reported synchronously
+ * with the call, but may instead be delayed until a
+ * subsequent call.
+ *
+ * A example using this with a hypothetical file upload
+ * API looks like
+ *
+ * virStreamPtr st = virStreamNew(conn, 0);
+ * int fd = open("demo.iso", O_RDONLY)
+ *
+ * virConnectUploadFile(conn, "demo.iso", st);
+ *
+ * while (1) {
+ * char buf[1024];
+ * int got = read(fd, buf, 1024);
+ * if (got < 0) {
+ * virStreamAbort(st);
+ * break;
+ * }
+ * if (got == 0) {
+ * virStreamFinish(st);
+ * break;
+ * }
+ * int offset = 0;
+ * while (offset < got) {
+ * int sent = virStreamSend(st, buf+offset, got-offset)
+ * if (sent < 0) {
+ * virStreamAbort(st);
+ * goto done;
+ * }
+ * offset += sent;
+ * }
+ * }
+ * done:
+ * virStreamFree(st);
+ * close(fd);
+ *
+ * Returns the number of bytes written, which may be less
+ * than requested.
+ *
+ * Returns -1 upon error, at which time the stream will
+ * be marked as aborted, and the caller should now release
+ * the stream with virStreamFree.
+ *
+ * Returns -2 if the outgoing transmit buffers are full &
+ * the stream is marked as non-blocking.
+ */
+int virStreamSend(virStreamPtr stream,
+ const char *data,
+ size_t nbytes)
+{
+ DEBUG("stream=%p, data=%p, nbytes=%zi", stream, data, nbytes);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamSend) {
+ int ret;
+ ret = (stream->driver->streamSend)(stream, data, nbytes);
+ if (ret == -2)
+ return -2;
+
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+/**
+ * virStreamRecv:
+ * @stream: pointer to the stream object
+ * @data: buffer to write to stream
+ * @nbytes: size of @data buffer
+ *
+ * Write a series of bytes to the stream. This method may
+ * block the calling application for an arbitrary amount
+ * of time.
+ *
+ * Errors are not guaranteed to be reported synchronously
+ * with the call, but may instead be delayed until a
+ * subsequent call.
+ *
+ * A example using this with a hypothetical file download
+ * API looks like
+ *
+ * virStreamPtr st = virStreamNew(conn, 0);
+ * int fd = open("demo.iso", O_WRONLY, 0600)
+ *
+ * virConnectDownloadFile(conn, "demo.iso", st);
+ *
+ * while (1) {
+ * char buf[1024];
+ * int got = virStreamRecv(st, buf, 1024);
+ * if (got < 0)
+ * break;
+ * if (got == 0) {
+ * virStreamFinish(st);
+ * break;
+ * }
+ * int offset = 0;
+ * while (offset < got) {
+ * int sent = write(fd, buf+offset, got-offset)
+ * if (sent < 0) {
+ * virStreamAbort(st);
+ * goto done;
+ * }
+ * offset += sent;
+ * }
+ * }
+ * done:
+ * virStreamFree(st);
+ * close(fd);
+ *
+ *
+ * Returns the number of bytes read, which may be less
+ * than requested.
+ *
+ * Returns 0 when the end of the stream is reached, at
+ * which time the caller should invoke virStreamFinish()
+ * to get confirmation of stream completion.
+ *
+ * Returns -1 upon error, at which time the stream will
+ * be marked as aborted, and the caller should now release
+ * the stream with virStreamFree.
+ *
+ * Returns -2 if there is no data pending to be read & the
+ * stream is marked as non-blocking.
+ */
+int virStreamRecv(virStreamPtr stream,
+ char *data,
+ size_t nbytes)
+{
+ DEBUG("stream=%p, data=%p, nbytes=%zi", stream, data, nbytes);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamRecv) {
+ int ret;
+ ret = (stream->driver->streamRecv)(stream, data, nbytes);
+ if (ret == -2)
+ return -2;
+
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+
+/**
+ * virStreamSendAll:
+ * @stream: pointer to the stream object
+ * @handler: source callback for reading data from application
+ * @opaque: application defined data
+ *
+ * Send the entire data stream, reading the data from the
+ * requested data source. This is simply a convenient alternative
+ * to virStreamSend, for apps that do blocking-I/o.
+ *
+ * A example using this with a hypothetical file upload
+ * API looks like
+ *
+ * int mysource(virStreamPtr st, char *buf, int nbytes, void *opaque) {
+ * int *fd = opaque;
+ *
+ * return read(*fd, buf, nbytes);
+ * }
+ *
+ * virStreamPtr st = virStreamNew(conn, 0);
+ * int fd = open("demo.iso", O_RDONLY)
+ *
+ * virConnectUploadFile(conn, st);
+ * virStreamSendAll(st, mysource, &fd);
+ * virStreamFree(st);
+ * close(fd);
+ *
+ * Returns 0 if all the data was succesfully sent. The stream
+ * will be marked as finished on success, so the caller need
+ * only call virStreamFree().
+ *
+ * Returns -1 upon any error, with the stream being marked as
+ * aborted, so the caller need only call virStreamFree()
+ */
+int virStreamSendAll(virStreamPtr stream,
+ virStreamSourceFunc handler,
+ void *opaque)
+{
+ char *bytes = NULL;
+ int want = 1024*64;
+ int ret = -1;
+ DEBUG("stream=%p, handler=%p, opaque=%p", stream, handler, opaque);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->flags & VIR_STREAM_NONBLOCK) {
+ virLibConnError(NULL, VIR_ERR_OPERATION_INVALID,
+ _("data sources cannot be used for non-blocking
streams"));
+ goto cleanup;
+ }
+
+ if (VIR_ALLOC_N(bytes, want) < 0) {
+ virReportOOMError(stream->conn);
+ goto cleanup;
+ }
+
+ for (;;) {
+ int got, offset = 0;
+ got = (handler)(stream, bytes, want, opaque);
+ if (got < 0) {
+ virStreamAbort(stream);
+ goto cleanup;
+ }
+ if (got == 0)
+ break;
+ while (offset < got) {
+ int done;
+ done = virStreamSend(stream, bytes + offset, got - offset);
+ if (done < 0)
+ goto cleanup;
+ offset += done;
+ }
+ }
+ ret = 0;
+
+cleanup:
+ VIR_FREE(bytes);
+
+ /* Copy to connection error object for back compatability */
+ if (ret != 0)
+ virSetConnError(stream->conn);
+
+ return ret;
+}
+
+
+/**
+ * virStreamRecvAll:
+ * @stream: pointer to the stream object
+ * @handler: sink callback for writing data to application
+ * @opaque: application defined data
+ *
+ * Receive the entire data stream, sending the data to the
+ * requested data sink. This is simply a convenient alternative
+ * to virStreamRecv, for apps that do blocking-I/o.
+ *
+ * A example using this with a hypothetical file download
+ * API looks like
+ *
+ * int mysink(virStreamPtr st, const char *buf, int nbytes, void *opaque) {
+ * int *fd = opaque;
+ *
+ * return write(*fd, buf, nbytes);
+ * }
+ *
+ * virStreamPtr st = virStreamNew(conn, 0);
+ * int fd = open("demo.iso", O_WRONLY)
+ *
+ * virConnectUploadFile(conn, st);
+ * virStreamRecvAll(st, mysink, &fd);
+ * virStreamFree(st);
+ * close(fd);
+ *
+ * Returns 0 if all the data was succesfully received. The stream
+ * will be marked as finished on success, so the caller need
+ * only call virStreamFree().
+ *
+ * Returns -1 upon any error, with the stream being marked as
+ * aborted, so the caller need only call virStreamFree()
+ */
+int virStreamRecvAll(virStreamPtr stream,
+ virStreamSinkFunc handler,
+ void *opaque)
+{
+ char *bytes = NULL;
+ int want = 1024*64;
+ int ret = -1;
+ DEBUG("stream=%p, handler=%p, opaque=%p", stream, handler, opaque);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->flags & VIR_STREAM_NONBLOCK) {
+ virLibConnError(NULL, VIR_ERR_OPERATION_INVALID,
+ _("data sinks cannot be used for non-blocking
streams"));
+ goto cleanup;
+ }
+
+
+ if (VIR_ALLOC_N(bytes, want) < 0) {
+ virReportOOMError(stream->conn);
+ goto cleanup;
+ }
+
+ for (;;) {
+ int got, offset = 0;
+ got = virStreamRecv(stream, bytes, want);
+ if (got < 0)
+ goto cleanup;
+ if (got == 0)
+ break;
+ while (offset < got) {
+ int done;
+ done = (handler)(stream, bytes + offset, got - offset, opaque);
+ if (done < 0) {
+ virStreamAbort(stream);
+ goto cleanup;
+ }
+ offset += done;
+ }
+ }
+ ret = 0;
+
+cleanup:
+ VIR_FREE(bytes);
+
+ /* Copy to connection error object for back compatability */
+ if (ret != 0)
+ virSetConnError(stream->conn);
+
+ return ret;
+}
+
+
+/**
+ * virStreamEventAddCallback
+ * @stream: pointer to the stream object
+ * @events: set of events to monitor
+ * @cb: callback to invoke when an event occurs
+ * @opaque: application defined data
+ * @ff: callback to free @opaque data
+ *
+ * Register a callback to be notified when a stream
+ * becomes writable, or readable. This is most commonly
+ * used in conjunction with non-blocking data streams
+ * to integrate into an event loop
+ *
+ * Return 0 on success, -1 upon error
+ */
+int virStreamEventAddCallback(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff)
+{
+ DEBUG("stream=%p, events=%d, cb=%p, opaque=%p, ff=%p", stream, events, cb,
opaque, ff);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamAddCallback) {
+ int ret;
+ ret = (stream->driver->streamAddCallback)(stream, events, cb, opaque, ff);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+
+/**
+ * virStreamEventUpdateCallback
+ * @stream: pointer to the stream object
+ * @events: set of events to monitor
+ *
+ * Changes the set of events to monitor for a stream. This allows
+ * for event notification to be changed without having to
+ * unregister & register the callback completely. This method
+ * is guarenteed to succeed if a callback is already registered
+ *
+ * Returns 0 on success, -1 if no callback is registered
+ */
+int virStreamEventUpdateCallback(virStreamPtr stream,
+ int events)
+{
+ DEBUG("stream=%p, events=%d", stream, events);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamUpdateCallback) {
+ int ret;
+ ret = (stream->driver->streamUpdateCallback)(stream, events);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+
+/**
+ * virStreamEventRemoveCallback
+ * @stream: pointer to the stream object
+ *
+ * Remove a event callback from the stream
+ *
+ * Return 0 on success, -1 on error
+ */
+int virStreamEventRemoveCallback(virStreamPtr stream)
+{
+ DEBUG("stream=%p", stream);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamRemoveCallback) {
+ int ret;
+ ret = (stream->driver->streamRemoveCallback)(stream);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+
+/**
+ * virStreamFinish:
+ * @stream: pointer to the stream object
+ *
+ * Indicate that there is no further data is to be transmitted
+ * on the stream. For output streams this should be called once
+ * all data has been written. For input streams this should be
+ * called once virStreamRecv returns end-of-file.
+ *
+ * This method is a synchronization point for all asynchronous
+ * errors, so if this returns a success code the application can
+ * be sure that all data has been successfully processed.
+ *
+ * Returns 0 on success, -1 upon error
+ */
+int virStreamFinish(virStreamPtr stream)
+{
+ DEBUG("stream=%p", stream);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamFinish) {
+ int ret;
+ ret = (stream->driver->streamFinish)(stream);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+
+/**
+ * virStreamAbort:
+ * @stream: pointer to the stream object
+ *
+ * Request that the in progress data transfer be cancelled
+ * abnormally before the end of the stream has been reached.
+ * For output streams this can be used to inform the driver
+ * that the stream is being terminated early. For input
+ * streams this can be used to inform the driver that it
+ * should stop sending data.
+ *
+ * Returns 0 on success, -1 upon error
+ */
+int virStreamAbort(virStreamPtr stream)
+{
+ DEBUG("stream=%p", stream);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (stream->driver &&
+ stream->driver->streamAbort) {
+ int ret;
+ ret = (stream->driver->streamAbort)(stream);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(stream->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(stream->conn);
+ return -1;
+}
+
+
+/**
+ * virStreamFree:
+ * @stream: pointer to the stream object
+ *
+ * Decrement the reference count on a stream, releasing
+ * the stream object if the reference count has hit zero.
+ *
+ * There must not be a active data transfer in progress
+ * when releasing the stream. If a stream needs to be
+ * disposed of prior to end of stream being reached, then
+ * the virStreamAbort function should be called first.
+ *
+ * Returns 0 upon success, or -1 on error
+ */
+int virStreamFree(virStreamPtr stream)
+{
+ DEBUG("stream=%p", stream);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_STREAM(stream)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ /* XXX Enforce shutdown before free'ing resources ? */
+
+ if (virUnrefStream(stream) < 0)
+ return (-1);
+ return (0);
+}
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 2bf4e15..12d552e 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -56,6 +56,8 @@ virUnrefStorageVol;
virGetNodeDevice;
virUnrefDomain;
virUnrefConnect;
+virGetStream;
+virUnrefStream;
# domain_conf.h
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index c06f51e..f48b8c5 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -291,4 +291,19 @@ LIBVIRT_0.7.0 {
virConnectListDefinedInterfaces;
} LIBVIRT_0.6.4;
+LIBVIRT_0.7.1 {
+ virStreamNew;
+ virStreamRef;
+ virStreamSend;
+ virStreamRecv;
+ virStreamSendAll;
+ virStreamRecvAll;
+ virStreamEventAddCallback;
+ virStreamEventUpdateCallback;
+ virStreamEventRemoveCallback;
+ virStreamFinish;
+ virStreamAbort;
+ virStreamFree;
+} LIBVIRT_0.7.0;
+
# .... define new API here using predicted next version number ....
--
1.6.2.5
5:09 a.m.
New subject: [libvirt] [PATCH 01/11] Add public API definition for data stream handling
On Mon, Aug 24, 2009 at 09:51:04PM +0100, Daniel P. Berrange wrote:
* include/libvirt/libvirt.h, include/libvirt/libvirt.h.in: Public
API contract for virStreamPtr object
* src/libvirt_public.syms: Export data stream APIs
* src/libvirt_private.syms: Export internal helper APIs
* src/libvirt.c: Data stream API driver dispatch
* src/datatypes.h, src/datatypes.c: Internal helpers for virStreamPtr
object
* src/driver.h: Define internal driver API for streams
* .x-sc_avoid_write: Ignore src/libvirt.c because it trips
up on comments including write()
[...]
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -110,6 +110,24 @@ typedef enum {
VIR_DOMAIN_NONE = 0
} virDomainCreateFlags;
+
+
+/**
+ * virStream:
+ *
+ * a virStream is a private structure representing a data stream.
+ */
+typedef struct _virStream virStream;
+
+/**
+ * virStreamPtr:
+ *
+ * a virStreamPtr is pointer to a virStream private structure, this is the
+ * type used to reference a data stream in the API.
+ */
+typedef virStream *virStreamPtr;
+
+
/**
* VIR_SECURITY_LABEL_BUFLEN:
*
@@ -1448,6 +1466,81 @@ void virEventRegisterImpl(virEventAddHandleFunc addHandle,
virEventAddTimeoutFunc addTimeout,
virEventUpdateTimeoutFunc updateTimeout,
virEventRemoveTimeoutFunc removeTimeout);
+
+enum {
+ VIR_STREAM_NONBLOCK = (1 << 0),
+};
+
+virStreamPtr virStreamNew(virConnectPtr conn,
+ unsigned int flags);
Would flags be sufficient if we were to encode some priorities to
streams? If we end up limiting the number of active streams, giving
higher priority or some reserved slots for quicker operations may
be important, flags should be sufficient for this if the need arise
so I don't see a problem but I raise the point.
+int virStreamRef(virStreamPtr st);
+
+int virStreamSend(virStreamPtr st,
+ const char *data,
+ size_t nbytes);
+
+int virStreamRecv(virStreamPtr st,
+ char *data,
+ size_t nbytes);
+
+
+typedef int (*virStreamSourceFunc)(virStreamPtr st,
+ char *data,
+ size_t nbytes,
+ void *opaque);
I think the signature is fine but we need to document all the
arguments and the return values.
+int virStreamSendAll(virStreamPtr st,
+ virStreamSourceFunc handler,
+ void *opaque);
Hum, I had to look at the comment to really understand. I'm not
100% sure, maybe we should allow for handler() to be called multiple
time, not just once.
For example I would allow virStreamSendAll() code to call handler
multiple time, until the handler like a read() returns 0 (or -1 on
error), in any case the signature should be documented fully.
+typedef int (*virStreamSinkFunc)(virStreamPtr st,
+ const char *data,
+ size_t nbytes,
+ void *opaque);
Same thing do we allow a sink function to be called repeatedly ?
If we want to allow this in some ways we will need an extra argument
to indicate the end of the stream. Even if we don't plan this yet, I
would suggest to add a flags to allow for this possibility in the
future. With a chunk size of 256K at the protocol level it may not
be a good idea to keep the full data in memory, so I would allow
for this interface to call the sink multiple times. And IMHO it's best
to pass the indication of end of transfer directly at the sink level
rather than wait for the virStreamFree() coming from the user.
+int virStreamRecvAll(virStreamPtr st,
+ virStreamSinkFunc handler,
+ void *opaque);
Okay
+typedef enum {
+ VIR_STREAM_EVENT_READABLE = (1 << 0),
+ VIR_STREAM_EVENT_WRITABLE = (1 << 1),
+ VIR_STREAM_EVENT_ERROR = (1 << 2),
+ VIR_STREAM_EVENT_HANGUP = (1 << 3),
+} virStreamEventType;
+
+
+/**
+ * virStreamEventCallback:
+ *
+ * @stream: stream on which the event occurred
+ * @events: bitset of events from virEventHandleType constants
+ * @opaque: user data registered with handle
+ *
+ * Callback for receiving stream events. The callback will
+ * be invoked once for each event which is pending.
+ */
+typedef void (*virStreamEventCallback)(virStreamPtr stream, int events, void *opaque);
+
+int virStreamEventAddCallback(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff);
+
+int virStreamEventUpdateCallback(virStreamPtr stream,
+ int events);
+
+int virStreamEventRemoveCallback(virStreamPtr stream);
+
+
+int virStreamFinish(virStreamPtr st);
+int virStreamAbort(virStreamPtr st);
For those 2 maybe add a flag, to allow for example background disconnection.
Even if the stream wasn't created ASYNC, we may want sometime to
abruptly end without waiting.
+int virStreamFree(virStreamPtr st);
With the exception of the extra flags suggestion for the sink callback
and finish/abort, the aPI looks fine to me.
[...]
+/**
+ * virStreamSendAll:
+ * @stream: pointer to the stream object
+ * @handler: source callback for reading data from application
+ * @opaque: application defined data
+ *
+ * Send the entire data stream, reading the data from the
+ * requested data source. This is simply a convenient alternative
+ * to virStreamSend, for apps that do blocking-I/o.
+ *
+ * A example using this with a hypothetical file upload
+ * API looks like
+ *
+ * int mysource(virStreamPtr st, char *buf, int nbytes, void *opaque) {
+ * int *fd = opaque;
+ *
+ * return read(*fd, buf, nbytes);
+ * }
+ *
+ * virStreamPtr st = virStreamNew(conn, 0);
+ * int fd = open("demo.iso", O_RDONLY)
+ *
+ * virConnectUploadFile(conn, st);
+ * virStreamSendAll(st, mysource, &fd);
+ * virStreamFree(st);
+ * close(fd);
Hum, the clasic example of blocking I/Os is if people use multithreaded
apps.
What is a second thread calls calls virStreamAbort() while
virStreamSendAll() is in progress, e.g. the user clicked on an abort
button from the UI ?
Same question for virStreamRecvAll() ?
+ * Returns 0 if all the data was succesfully sent. The stream
+ * will be marked as finished on success, so the caller need
+ * only call virStreamFree().
+ *
+ * Returns -1 upon any error, with the stream being marked as
+ * aborted, so the caller need only call virStreamFree()
+ */
+int virStreamSendAll(virStreamPtr stream,
+ virStreamSourceFunc handler,
+ void *opaque)
+ * virConnectUploadFile(conn, st);
+ * virStreamRecvAll(st, mysink, &fd);
+ * virStreamFree(st);
+ * close(fd);
Would the current API allow for the sink callback to close the fd()
at the end of the transfer ? Right now, I don't think so because we
don't know what is the last callback (assuming multiple ones).
Except for those couple of uncertainties, the API looks fine to me !
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
6:25 a.m.
New subject: [libvirt] [PATCH 01/11] Add public API definition for data stream handling
On Fri, Sep 25, 2009 at 12:09:34PM +0200, Daniel Veillard wrote:
On Mon, Aug 24, 2009 at 09:51:04PM +0100, Daniel P. Berrange wrote:
> @@ -1448,6 +1466,81 @@ void virEventRegisterImpl(virEventAddHandleFunc addHandle,
> virEventAddTimeoutFunc addTimeout,
> virEventUpdateTimeoutFunc updateTimeout,
> virEventRemoveTimeoutFunc removeTimeout);
> +
> +enum {
> + VIR_STREAM_NONBLOCK = (1 << 0),
> +};
> +
> +virStreamPtr virStreamNew(virConnectPtr conn,
> + unsigned int flags);
Would flags be sufficient if we were to encode some priorities to
streams? If we end up limiting the number of active streams, giving
higher priority or some reserved slots for quicker operations may
be important, flags should be sufficient for this if the need arise
so I don't see a problem but I raise the point.
I guess it would be sufficient if you wanted todo LOW/MEDIUM/HIGH
static priorties.
If we wanted to get more advanced, we could always introduce an
extra API, since there is always a point between virStreamNew()
and then using it, eg in virConnectUploadFile(), when you can
do more setup calls. We already allow event callbacks to be
registered this way, so we could in future add a
virStreamSetPriority(virStreamPtr st, ....options ...);
if we needed more than just plain flags.
On the subject of flags though, I've never been entirely sure
about whether it would be worth mandating the use of a flag(s)
for indicating I/O direction at time of stream creation.
Currently this is implicit base on the API that the stream is
later used with,
eg, currently
virStreamPtr st = virStreamNew(conn, 0);
virConnectUploadFile(conn, st, filename);
implicitly configures the stream for writing, but I constantly
wonder whether we ought to make it explicit via a flag like
virStreamPtr st = virStreamNew(conn, VIR_STREAM_WRITE);
virConnectUploadFile(conn, st, filename);
and require that the call of virStreamNew() provide either
VIR_STREAM_WRITE, or VIR_STREAM_READ, or both. ANd then also
have the methods using streams like virConnectUploadFile
check that the flags match.
If we wanted to mandate use of READ/WRITE flags for stream
creation, we'd obviously need todo it from teh start, since
we couldn't add that as a mandatory flag once the API is
released & in use by apps.
> +int virStreamRef(virStreamPtr st);
> +
> +int virStreamSend(virStreamPtr st,
> + const char *data,
> + size_t nbytes);
> +
> +int virStreamRecv(virStreamPtr st,
> + char *data,
> + size_t nbytes);
> +
> +
> +typedef int (*virStreamSourceFunc)(virStreamPtr st,
> + char *data,
> + size_t nbytes,
> + void *opaque);
I think the signature is fine but we need to document all the
arguments and the return values.
> +int virStreamSendAll(virStreamPtr st,
> + virStreamSourceFunc handler,
> + void *opaque);
Hum, I had to look at the comment to really understand. I'm not
100% sure, maybe we should allow for handler() to be called multiple
time, not just once.
For example I would allow virStreamSendAll() code to call handler
multiple time, until the handler like a read() returns 0 (or -1 on
error), in any case the signature should be documented fully.
This method is essentially just a convenient way to call the
virStreamSend() in a loop, for apps that are happy todo blocking
data I/O. As such the handler() will definitely be called multiple
times to fetch the data to be sent. You can see how it was used
later on in this patch, where virStreamSendAll is implemented.
I expect most apps would use virStreamSend() though, to allow
them todo interruptible & non-blocking I/O
> +typedef int (*virStreamSinkFunc)(virStreamPtr st,
> + const char *data,
> + size_t nbytes,
> + void *opaque);
Same thing do we allow a sink function to be called repeatedly ?
If we want to allow this in some ways we will need an extra argument
to indicate the end of the stream. Even if we don't plan this yet, I
would suggest to add a flags to allow for this possibility in the
future. With a chunk size of 256K at the protocol level it may not
be a good idea to keep the full data in memory, so I would allow
for this interface to call the sink multiple times. And IMHO it's best
to pass the indication of end of transfer directly at the sink level
rather than wait for the virStreamFree() coming from the user.
> +int virStreamRecvAll(virStreamPtr st,
> + virStreamSinkFunc handler,
> + void *opaque);
Okay
Same as for SendAll, this API will invoke the handler multilpe
times to write out data that is being received. In both cases
the implementation is invoking the handler with 64kb buffers
to avoid pulling lots of data into memory.
> +typedef enum {
> + VIR_STREAM_EVENT_READABLE = (1 << 0),
> + VIR_STREAM_EVENT_WRITABLE = (1 << 1),
> + VIR_STREAM_EVENT_ERROR = (1 << 2),
> + VIR_STREAM_EVENT_HANGUP = (1 << 3),
> +} virStreamEventType;
> +
> +
> +/**
> + * virStreamEventCallback:
> + *
> + * @stream: stream on which the event occurred
> + * @events: bitset of events from virEventHandleType constants
> + * @opaque: user data registered with handle
> + *
> + * Callback for receiving stream events. The callback will
> + * be invoked once for each event which is pending.
> + */
> +typedef void (*virStreamEventCallback)(virStreamPtr stream, int events, void
*opaque);
> +
> +int virStreamEventAddCallback(virStreamPtr stream,
> + int events,
> + virStreamEventCallback cb,
> + void *opaque,
> + virFreeCallback ff);
> +
> +int virStreamEventUpdateCallback(virStreamPtr stream,
> + int events);
> +
> +int virStreamEventRemoveCallback(virStreamPtr stream);
> +
> +
> +int virStreamFinish(virStreamPtr st);
> +int virStreamAbort(virStreamPtr st);
For those 2 maybe add a flag, to allow for example background disconnection.
Even if the stream wasn't created ASYNC, we may want sometime to
abruptly end without waiting.
The virStreamAbort() operation is always asynchronous, regardless of
whether the stream is non-blocking. The virStreamFinish() operation
has to be synchronous, because for it to be useful you need to do
a round-trip to flush any error being sent back from the server. So
I don't think we need any flags here. If you want to close it abruptly
then virStreamAbort() is suitable, if you want to close it cleanly
then virStreamFinish() is suitable.
> +/**
> + * virStreamSendAll:
> + * @stream: pointer to the stream object
> + * @handler: source callback for reading data from application
> + * @opaque: application defined data
> + *
> + * Send the entire data stream, reading the data from the
> + * requested data source. This is simply a convenient alternative
> + * to virStreamSend, for apps that do blocking-I/o.
> + *
> + * A example using this with a hypothetical file upload
> + * API looks like
> + *
> + * int mysource(virStreamPtr st, char *buf, int nbytes, void *opaque) {
> + * int *fd = opaque;
> + *
> + * return read(*fd, buf, nbytes);
> + * }
> + *
> + * virStreamPtr st = virStreamNew(conn, 0);
> + * int fd = open("demo.iso", O_RDONLY)
> + *
> + * virConnectUploadFile(conn, st);
> + * virStreamSendAll(st, mysource, &fd);
> + * virStreamFree(st);
> + * close(fd);
Hum, the clasic example of blocking I/Os is if people use multithreaded
apps.
What is a second thread calls calls virStreamAbort() while
virStreamSendAll() is in progress, e.g. the user clicked on an abort
button from the UI ?
Same question for virStreamRecvAll() ?
If you want to abort a stream part way through, then you should not
be using virStreamSendAll/RecvAll. These APIs are optional convenience
APIs for apps which are happy todo a blocking operation. Apps which
need ability to abort part way through can use the virStreamRecv()
and virStreamSend() APIs instead.
That all said, it is safe for another thread to call virStreamAbort(),
it will cause this Send/RecvAll method to return an error on the next
virStreamSend/Recv call it makes
> + * Returns 0 if all the data was succesfully sent. The stream
> + * will be marked as finished on success, so the caller need
> + * only call virStreamFree().
> + *
> + * Returns -1 upon any error, with the stream being marked as
> + * aborted, so the caller need only call virStreamFree()
> + */
> +int virStreamSendAll(virStreamPtr stream,
> + virStreamSourceFunc handler,
> + void *opaque)
> + * virConnectUploadFile(conn, st);
> + * virStreamRecvAll(st, mysink, &fd);
> + * virStreamFree(st);
> + * close(fd);
Would the current API allow for the sink callback to close the fd()
at the end of the transfer ? Right now, I don't think so because we
don't know what is the last callback (assuming multiple ones).
The sink/source callbacks do not need to close the FD since this is easily
done with RecvAll/SendAll returns control to the application. THis is
in fact important, because it is not until RecvAll/SendAll returns that
you can call virStreamFinish to check for success. If it did not suceed
then you may want do other cleanup before closing the FD, such as
unlinking the file
Regards,
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
7:32 a.m.
New subject: [libvirt] [PATCH 01/11] Add public API definition for data stream handling
On Fri, Sep 25, 2009 at 12:25:50PM +0100, Daniel P. Berrange wrote:
On Fri, Sep 25, 2009 at 12:09:34PM +0200, Daniel Veillard wrote:
> On Mon, Aug 24, 2009 at 09:51:04PM +0100, Daniel P. Berrange wrote:
> > @@ -1448,6 +1466,81 @@ void virEventRegisterImpl(virEventAddHandleFunc
addHandle,
> > virEventAddTimeoutFunc addTimeout,
> > virEventUpdateTimeoutFunc updateTimeout,
> > virEventRemoveTimeoutFunc removeTimeout);
> > +
> > +enum {
> > + VIR_STREAM_NONBLOCK = (1 << 0),
> > +};
> > +
> > +virStreamPtr virStreamNew(virConnectPtr conn,
> > + unsigned int flags);
>
> Would flags be sufficient if we were to encode some priorities to
> streams? If we end up limiting the number of active streams, giving
> higher priority or some reserved slots for quicker operations may
> be important, flags should be sufficient for this if the need arise
> so I don't see a problem but I raise the point.
I guess it would be sufficient if you wanted todo LOW/MEDIUM/HIGH
static priorties.
yeah, I just wanted to make sure it didn't contradict something you
may have in mind :-)
If we wanted to get more advanced, we could always introduce an
extra API, since there is always a point between virStreamNew()
and then using it, eg in virConnectUploadFile(), when you can
do more setup calls. We already allow event callbacks to be
registered this way, so we could in future add a
virStreamSetPriority(virStreamPtr st, ....options ...);
right,
if we needed more than just plain flags.
On the subject of flags though, I've never been entirely sure
about whether it would be worth mandating the use of a flag(s)
for indicating I/O direction at time of stream creation.
Currently this is implicit base on the API that the stream is
later used with,
eg, currently
virStreamPtr st = virStreamNew(conn, 0);
virConnectUploadFile(conn, st, filename);
implicitly configures the stream for writing, but I constantly
wonder whether we ought to make it explicit via a flag like
virStreamPtr st = virStreamNew(conn, VIR_STREAM_WRITE);
virConnectUploadFile(conn, st, filename);
and require that the call of virStreamNew() provide either
VIR_STREAM_WRITE, or VIR_STREAM_READ, or both. ANd then also
have the methods using streams like virConnectUploadFile
check that the flags match.
Hum, this would then raise the signal that stream can be used
both ways, do we really want to suggest this at the API level,
I can see how we're gonna use this internally, but aren't we opening
the door to much complexity ?
If we wanted to mandate use of READ/WRITE flags for stream
creation, we'd obviously need todo it from teh start, since
we couldn't add that as a mandatory flag once the API is
released & in use by apps.
yes that's a good point, a design issue too. If you really expect API
usage for both read and write, then I would say we should make those
flags mandatory. The only point is that our existing flags use in APIs
are just fine with 0 as being the 'default', and we would break this
but it's not a big deal IMHO, that will be caught immediately.
>
> > +int virStreamRef(virStreamPtr st);
> > +
> > +int virStreamSend(virStreamPtr st,
> > + const char *data,
> > + size_t nbytes);
> > +
> > +int virStreamRecv(virStreamPtr st,
> > + char *data,
> > + size_t nbytes);
> > +
> > +
> > +typedef int (*virStreamSourceFunc)(virStreamPtr st,
> > + char *data,
> > + size_t nbytes,
> > + void *opaque);
>
> I think the signature is fine but we need to document all the
> arguments and the return values.
>
> > +int virStreamSendAll(virStreamPtr st,
> > + virStreamSourceFunc handler,
> > + void *opaque);
>
> Hum, I had to look at the comment to really understand. I'm not
> 100% sure, maybe we should allow for handler() to be called multiple
> time, not just once.
> For example I would allow virStreamSendAll() code to call handler
> multiple time, until the handler like a read() returns 0 (or -1 on
> error), in any case the signature should be documented fully.
This method is essentially just a convenient way to call the
virStreamSend() in a loop, for apps that are happy todo blocking
data I/O. As such the handler() will definitely be called multiple
times to fetch the data to be sent. You can see how it was used
later on in this patch, where virStreamSendAll is implemented.
I expect most apps would use virStreamSend() though, to allow
them todo interruptible & non-blocking I/O
Okay, but let's describe all args and return values for the callbacks.
> > +typedef int (*virStreamSinkFunc)(virStreamPtr st,
> > + const char *data,
> > + size_t nbytes,
> > + void *opaque);
>
> Same thing do we allow a sink function to be called repeatedly ?
> If we want to allow this in some ways we will need an extra argument
> to indicate the end of the stream. Even if we don't plan this yet, I
> would suggest to add a flags to allow for this possibility in the
> future. With a chunk size of 256K at the protocol level it may not
> be a good idea to keep the full data in memory, so I would allow
> for this interface to call the sink multiple times. And IMHO it's best
> to pass the indication of end of transfer directly at the sink level
> rather than wait for the virStreamFree() coming from the user.
>
> > +int virStreamRecvAll(virStreamPtr st,
> > + virStreamSinkFunc handler,
> > + void *opaque);
>
> Okay
Same as for SendAll, this API will invoke the handler multilpe
times to write out data that is being received. In both cases
the implementation is invoking the handler with 64kb buffers
to avoid pulling lots of data into memory.
Okay, but I think being able to indicate there that a packet is the
last one may be important, for example if the application design prefer
to initiate the closure of the transfer (close/sync/...) as soon as
possible.
Also how flexible are we in the design with callbacks taling a long
time to complete, for example reads crossing the network, or slow
output devices ? Maybe this should be hinted in the callback
descriptions.
[...]
> > +int virStreamFinish(virStreamPtr st);
> > +int virStreamAbort(virStreamPtr st);
>
> For those 2 maybe add a flag, to allow for example background disconnection.
> Even if the stream wasn't created ASYNC, we may want sometime to
> abruptly end without waiting.
The virStreamAbort() operation is always asynchronous, regardless of
whether the stream is non-blocking. The virStreamFinish() operation
has to be synchronous, because for it to be useful you need to do
a round-trip to flush any error being sent back from the server. So
I don't think we need any flags here. If you want to close it abruptly
then virStreamAbort() is suitable, if you want to close it cleanly
then virStreamFinish() is suitable.
hum, okay ...
[...]
> > + * virConnectUploadFile(conn, st);
> > + * virStreamSendAll(st, mysource, &fd);
> > + * virStreamFree(st);
> > + * close(fd);
>
>
> Hum, the clasic example of blocking I/Os is if people use multithreaded
> apps.
> What is a second thread calls calls virStreamAbort() while
> virStreamSendAll() is in progress, e.g. the user clicked on an abort
> button from the UI ?
> Same question for virStreamRecvAll() ?
If you want to abort a stream part way through, then you should not
be using virStreamSendAll/RecvAll. These APIs are optional convenience
APIs for apps which are happy todo a blocking operation. Apps which
need ability to abort part way through can use the virStreamRecv()
and virStreamSend() APIs instead.
Callback programming is hard, people get very easilly confused by them
and handling of errors can turn really nasty if you use them a lot. So
I think it's important to have foolproof synchronous transfers, even if
you think they may be a bit abused, it's really easier on the
programmer.
That all said, it is safe for another thread to call
virStreamAbort(),
it will cause this Send/RecvAll method to return an error on the next
virStreamSend/Recv call it makes
good :-)
>
> > + * Returns 0 if all the data was succesfully sent. The stream
> > + * will be marked as finished on success, so the caller need
> > + * only call virStreamFree().
> > + *
> > + * Returns -1 upon any error, with the stream being marked as
> > + * aborted, so the caller need only call virStreamFree()
> > + */
> > +int virStreamSendAll(virStreamPtr stream,
> > + virStreamSourceFunc handler,
> > + void *opaque)
>
>
> > + * virConnectUploadFile(conn, st);
> > + * virStreamRecvAll(st, mysink, &fd);
> > + * virStreamFree(st);
> > + * close(fd);
>
> Would the current API allow for the sink callback to close the fd()
> at the end of the transfer ? Right now, I don't think so because we
> don't know what is the last callback (assuming multiple ones).
The sink/source callbacks do not need to close the FD since this is easily
done with RecvAll/SendAll returns control to the application. THis is
in fact important, because it is not until RecvAll/SendAll returns that
you can call virStreamFinish to check for success. If it did not suceed
then you may want do other cleanup before closing the FD, such as
unlinking the file
Hum, the two example for RecvAll and SendAll don't suggest
virStreamFinish() to be called to get the status, I would expect error
reporting to show up as the result code from RecvAll and SendAll.
I still think the callbacks behaviour should be clarified especially
behaviour and reporting in case of error.
thanks,
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
8:09 a.m.
New subject: [libvirt] [PATCH 01/11] Add public API definition for data stream handling
On Fri, Sep 25, 2009 at 02:32:39PM +0200, Daniel Veillard wrote:
On Fri, Sep 25, 2009 at 12:25:50PM +0100, Daniel P. Berrange wrote:
> if we needed more than just plain flags.
>
>
> On the subject of flags though, I've never been entirely sure
> about whether it would be worth mandating the use of a flag(s)
> for indicating I/O direction at time of stream creation.
> Currently this is implicit base on the API that the stream is
> later used with,
>
> eg, currently
>
> virStreamPtr st = virStreamNew(conn, 0);
>
> virConnectUploadFile(conn, st, filename);
>
> implicitly configures the stream for writing, but I constantly
> wonder whether we ought to make it explicit via a flag like
>
> virStreamPtr st = virStreamNew(conn, VIR_STREAM_WRITE);
>
> virConnectUploadFile(conn, st, filename);
>
> and require that the call of virStreamNew() provide either
> VIR_STREAM_WRITE, or VIR_STREAM_READ, or both. ANd then also
> have the methods using streams like virConnectUploadFile
> check that the flags match.
Hum, this would then raise the signal that stream can be used
both ways, do we really want to suggest this at the API level,
I can see how we're gonna use this internally, but aren't we opening
the door to much complexity ?
Yeah, that's more or less why I left it out so far - I've not
yet found a case where I absolutely needed the WRITE/READ
flags to be set explicitly by apps.
> If we wanted to mandate use of READ/WRITE flags for stream
> creation, we'd obviously need todo it from teh start, since
> we couldn't add that as a mandatory flag once the API is
> released & in use by apps.
yes that's a good point, a design issue too. If you really expect API
usage for both read and write, then I would say we should make those
flags mandatory. The only point is that our existing flags use in APIs
are just fine with 0 as being the 'default', and we would break this
but it's not a big deal IMHO, that will be caught immediately.
There is one likely API where we'd have a full read+write stream.
I've thought about adding ability to tunnel a serial port PTY
over libvirt, so 'virsh console' could be made to work remotely.
eg, something like
virDomainOpenConsole(virDomainPtr dom, virStreamPtr stream
const char *consolename);
In this case you'd be reading & writing from /to the same
stream. It still wouldn't really require that we set the
READ+WRITE flags when doing virStreamNew()
> > > +typedef int (*virStreamSinkFunc)(virStreamPtr st,
> > > + const char *data,
> > > + size_t nbytes,
> > > + void *opaque);
> >
> > Same thing do we allow a sink function to be called repeatedly ?
> > If we want to allow this in some ways we will need an extra argument
> > to indicate the end of the stream. Even if we don't plan this yet, I
> > would suggest to add a flags to allow for this possibility in the
> > future. With a chunk size of 256K at the protocol level it may not
> > be a good idea to keep the full data in memory, so I would allow
> > for this interface to call the sink multiple times. And IMHO it's best
> > to pass the indication of end of transfer directly at the sink level
> > rather than wait for the virStreamFree() coming from the user.
> >
> > > +int virStreamRecvAll(virStreamPtr st,
> > > + virStreamSinkFunc handler,
> > > + void *opaque);
> >
> > Okay
>
> Same as for SendAll, this API will invoke the handler multilpe
> times to write out data that is being received. In both cases
> the implementation is invoking the handler with 64kb buffers
> to avoid pulling lots of data into memory.
Okay, but I think being able to indicate there that a packet is the
last one may be important, for example if the application design prefer
to initiate the closure of the transfer (close/sync/...) as soon as
possible.
Actually in the case of the 'source' function, the app already
knows when its got to the end, because its source funtion will
be returning '0' for end-of-file.
For the 'sink' function we'd have to make sure we called it once
at the end with a length of '0' to indicate EOF in that direction.
I can't remember offhand if we'll do that already or not.
Also how flexible are we in the design with callbacks taling a
long
time to complete, for example reads crossing the network, or slow
output devices ? Maybe this should be hinted in the callback
descriptions.
These callbacks are the app's responsibility & execute in its
context, so libvirt doesn't care whether they are slow or fast
to execute. Everything internal to libvirt relating to streams
is non-blocking & fast.
> > > + * virConnectUploadFile(conn, st);
> > > + * virStreamSendAll(st, mysource, &fd);
> > > + * virStreamFree(st);
> > > + * close(fd);
> >
> > > + * virConnectUploadFile(conn, st);
> > > + * virStreamRecvAll(st, mysink, &fd);
> > > + * virStreamFree(st);
> > > + * close(fd);
> >
> > Would the current API allow for the sink callback to close the fd()
> > at the end of the transfer ? Right now, I don't think so because we
> > don't know what is the last callback (assuming multiple ones).
>
> The sink/source callbacks do not need to close the FD since this is easily
> done with RecvAll/SendAll returns control to the application. THis is
> in fact important, because it is not until RecvAll/SendAll returns that
> you can call virStreamFinish to check for success. If it did not suceed
> then you may want do other cleanup before closing the FD, such as
> unlinking the file
Hum, the two example for RecvAll and SendAll don't suggest
virStreamFinish() to be called to get the status, I would expect error
reporting to show up as the result code from RecvAll and SendAll.
Actually these 2 code examples are wrong. There should be a call
to virStreamFinish in there, before the virStreamFree. This was
not required in an earlier version of my patch, because SendAll
would call Finish for you, but I realized this made it impossible
for callers to detect certain error conditions. So the app should
always call either Finish or Abort once they're done with I/O.
I'll update the example
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
8:51 a.m.
New subject: [libvirt] [PATCH 01/11] Add public API definition for data stream handling
On Fri, Sep 25, 2009 at 02:09:54PM +0100, Daniel P. Berrange wrote:
On Fri, Sep 25, 2009 at 02:32:39PM +0200, Daniel Veillard wrote:
> Hum, this would then raise the signal that stream can be used
> both ways, do we really want to suggest this at the API level,
> I can see how we're gonna use this internally, but aren't we opening
> the door to much complexity ?
Yeah, that's more or less why I left it out so far - I've not
yet found a case where I absolutely needed the WRITE/READ
flags to be set explicitly by apps.
Okay, let's keep it that way. Ultimately we could add another API
to create the Stream.
> > If we wanted to mandate use of READ/WRITE flags for stream
> > creation, we'd obviously need todo it from teh start, since
> > we couldn't add that as a mandatory flag once the API is
> > released & in use by apps.
>
> yes that's a good point, a design issue too. If you really expect API
> usage for both read and write, then I would say we should make those
> flags mandatory. The only point is that our existing flags use in APIs
> are just fine with 0 as being the 'default', and we would break this
> but it's not a big deal IMHO, that will be caught immediately.
There is one likely API where we'd have a full read+write stream.
I've thought about adding ability to tunnel a serial port PTY
over libvirt, so 'virsh console' could be made to work remotely.
eg, something like
virDomainOpenConsole(virDomainPtr dom, virStreamPtr stream
const char *consolename);
In this case you'd be reading & writing from /to the same
stream. It still wouldn't really require that we set the
READ+WRITE flags when doing virStreamNew()
okay
> > > > +typedef int (*virStreamSinkFunc)(virStreamPtr
st,
> > > > + const char *data,
> > > > + size_t nbytes,
> > > > + void *opaque);
> > >
> > > Same thing do we allow a sink function to be called repeatedly ?
> > > If we want to allow this in some ways we will need an extra argument
> > > to indicate the end of the stream. Even if we don't plan this yet, I
> > > would suggest to add a flags to allow for this possibility in the
> > > future. With a chunk size of 256K at the protocol level it may not
> > > be a good idea to keep the full data in memory, so I would allow
> > > for this interface to call the sink multiple times. And IMHO it's
best
> > > to pass the indication of end of transfer directly at the sink level
> > > rather than wait for the virStreamFree() coming from the user.
> > >
> > > > +int virStreamRecvAll(virStreamPtr st,
> > > > + virStreamSinkFunc handler,
> > > > + void *opaque);
> > >
> > > Okay
> >
> > Same as for SendAll, this API will invoke the handler multilpe
> > times to write out data that is being received. In both cases
> > the implementation is invoking the handler with 64kb buffers
> > to avoid pulling lots of data into memory.
>
> Okay, but I think being able to indicate there that a packet is the
> last one may be important, for example if the application design prefer
> to initiate the closure of the transfer (close/sync/...) as soon as
> possible.
Actually in the case of the 'source' function, the app already
knows when its got to the end, because its source funtion will
be returning '0' for end-of-file.
yes for read it's not a problem
For the 'sink' function we'd have to make sure we called
it once
at the end with a length of '0' to indicate EOF in that direction.
I can't remember offhand if we'll do that already or not.
ah write 0 lenght, yes that's another way to pass the signal.
> Also how flexible are we in the design with callbacks taling a
long
> time to complete, for example reads crossing the network, or slow
> output devices ? Maybe this should be hinted in the callback
> descriptions.
These callbacks are the app's responsibility & execute in its
context, so libvirt doesn't care whether they are slow or fast
to execute. Everything internal to libvirt relating to streams
is non-blocking & fast.
okidoc, I just wanted to doub;e-check :-)
> > The sink/source callbacks do not need to close the FD since
this is easily
> > done with RecvAll/SendAll returns control to the application. THis is
> > in fact important, because it is not until RecvAll/SendAll returns that
> > you can call virStreamFinish to check for success. If it did not suceed
> > then you may want do other cleanup before closing the FD, such as
> > unlinking the file
>
> Hum, the two example for RecvAll and SendAll don't suggest
> virStreamFinish() to be called to get the status, I would expect error
> reporting to show up as the result code from RecvAll and SendAll.
Actually these 2 code examples are wrong. There should be a call
to virStreamFinish in there, before the virStreamFree. This was
not required in an earlier version of my patch, because SendAll
would call Finish for you, but I realized this made it impossible
for callers to detect certain error conditions. So the app should
always call either Finish or Abort once they're done with I/O.
I'll update the example
Ah, okay !
ACK
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
3:51 p.m.
New subject: [libvirt] [PATCH 02/11] Avoid polling on FDs with no events enabled
If a file descriptor with events=0 was added to the libvirtd
event loop, it would still be added to the poll() fds' array.
While it wouldn't see any POLLIN/OUT events, it'd still get
triggered for HANGUP/ERROR events which was not in compliance
with the libvirt events API contract.
* qemud/event.c: Don't poll on FDs with events=0
* tests/eventtest.c: Add test case to validate fix to event.c
---
qemud/event.c | 54 +++++++++++++++++++++++++++++++++++++---------------
tests/eventtest.c | 19 ++++++++++++++++++
2 files changed, 57 insertions(+), 16 deletions(-)
diff --git a/qemud/event.c b/qemud/event.c
index a57d967..10847c4 100644
--- a/qemud/event.c
+++ b/qemud/event.c
@@ -109,7 +109,7 @@ int virEventAddHandleImpl(int fd, int events,
void *opaque,
virFreeCallback ff) {
int watch;
- EVENT_DEBUG("Add handle %d %d %p %p", fd, events, cb, opaque);
+ EVENT_DEBUG("Add handle fd=%d events=%d cb=%p opaque=%p", fd, events, cb,
opaque);
virEventLock();
if (eventLoop.handlesCount == eventLoop.handlesAlloc) {
EVENT_DEBUG("Used %d handle slots, adding %d more",
@@ -170,7 +170,7 @@ void virEventUpdateHandleImpl(int watch, int events) {
*/
int virEventRemoveHandleImpl(int watch) {
int i;
- EVENT_DEBUG("Remove handle %d", watch);
+ EVENT_DEBUG("Remove handle w=%d", watch);
if (watch <= 0) {
VIR_WARN("Ignoring invalid remove watch %d", watch);
@@ -350,22 +350,32 @@ static int virEventCalculateTimeout(int *timeout) {
* file handles. The caller must free the returned data struct
* returns: the pollfd array, or NULL on error
*/
-static struct pollfd *virEventMakePollFDs(void) {
+static struct pollfd *virEventMakePollFDs(int *nfds) {
struct pollfd *fds;
int i;
+ *nfds = 0;
+ for (i = 0 ; i < eventLoop.handlesCount ; i++) {
+ if (eventLoop.handles[i].events)
+ (*nfds)++;
+ }
+
/* Setup the poll file handle data structs */
- if (VIR_ALLOC_N(fds, eventLoop.handlesCount) < 0)
+ if (VIR_ALLOC_N(fds, *nfds) < 0)
return NULL;
+ *nfds = 0;
for (i = 0 ; i < eventLoop.handlesCount ; i++) {
EVENT_DEBUG("Prepare n=%d w=%d, f=%d e=%d", i,
eventLoop.handles[i].watch,
eventLoop.handles[i].fd,
eventLoop.handles[i].events);
- fds[i].fd = eventLoop.handles[i].fd;
- fds[i].events = eventLoop.handles[i].events;
- fds[i].revents = 0;
+ if (!eventLoop.handles[i].events)
+ continue;
+ fds[*nfds].fd = eventLoop.handles[i].fd;
+ fds[*nfds].events = eventLoop.handles[i].events;
+ fds[*nfds].revents = 0;
+ (*nfds)++;
//EVENT_DEBUG("Wait for %d %d", eventLoop.handles[i].fd,
eventLoop.handles[i].events);
}
@@ -391,6 +401,7 @@ static int virEventDispatchTimeouts(void) {
int i;
/* Save this now - it may be changed during dispatch */
int ntimeouts = eventLoop.timeoutsCount;
+ DEBUG("Dispatch %d", ntimeouts);
if (gettimeofday(&tv, NULL) < 0) {
return -1;
@@ -429,28 +440,38 @@ static int virEventDispatchTimeouts(void) {
* Returns 0 upon success, -1 if an error occurred
*/
static int virEventDispatchHandles(int nfds, struct pollfd *fds) {
- int i;
+ int i, n;
+ DEBUG("Dispatch %d", nfds);
/* NB, use nfds not eventLoop.handlesCount, because new
* fds might be added on end of list, and they're not
* in the fds array we've got */
- for (i = 0 ; i < nfds ; i++) {
+ for (i = 0, n = 0 ; n < nfds && i < eventLoop.handlesCount ; n++) {
+ while ((eventLoop.handles[i].fd != fds[n].fd ||
+ eventLoop.handles[i].events == 0) &&
+ i < eventLoop.handlesCount) {
+ i++;
+ }
+ if (i == eventLoop.handlesCount)
+ break;
+
+ DEBUG("i=%d w=%d", i, eventLoop.handles[i].watch);
if (eventLoop.handles[i].deleted) {
EVENT_DEBUG("Skip deleted n=%d w=%d f=%d", i,
eventLoop.handles[i].watch, eventLoop.handles[i].fd);
continue;
}
- if (fds[i].revents) {
+ if (fds[n].revents) {
virEventHandleCallback cb = eventLoop.handles[i].cb;
void *opaque = eventLoop.handles[i].opaque;
- int hEvents = virPollEventToEventHandleType(fds[i].revents);
+ int hEvents = virPollEventToEventHandleType(fds[n].revents);
EVENT_DEBUG("Dispatch n=%d f=%d w=%d e=%d %p", i,
- fds[i].fd, eventLoop.handles[i].watch,
- fds[i].revents, eventLoop.handles[i].opaque);
+ fds[n].fd, eventLoop.handles[i].watch,
+ fds[n].revents, eventLoop.handles[i].opaque);
virEventUnlock();
(cb)(eventLoop.handles[i].watch,
- fds[i].fd, hEvents, opaque);
+ fds[n].fd, hEvents, opaque);
virEventLock();
}
}
@@ -465,6 +486,7 @@ static int virEventDispatchHandles(int nfds, struct pollfd *fds) {
*/
static int virEventCleanupTimeouts(void) {
int i;
+ DEBUG("Cleanup %d", eventLoop.timeoutsCount);
/* Remove deleted entries, shuffling down remaining
* entries as needed to form contiguous series
@@ -505,6 +527,7 @@ static int virEventCleanupTimeouts(void) {
*/
static int virEventCleanupHandles(void) {
int i;
+ DEBUG("Cleanupo %d", eventLoop.handlesCount);
/* Remove deleted entries, shuffling down remaining
* entries as needed to form contiguous series
@@ -554,10 +577,9 @@ int virEventRunOnce(void) {
virEventCleanupHandles() < 0)
goto error;
- if (!(fds = virEventMakePollFDs()) ||
+ if (!(fds = virEventMakePollFDs(&nfds)) ||
virEventCalculateTimeout(&timeout) < 0)
goto error;
- nfds = eventLoop.handlesCount;
virEventUnlock();
diff --git a/tests/eventtest.c b/tests/eventtest.c
index d25381d..68ac2fc 100644
--- a/tests/eventtest.c
+++ b/tests/eventtest.c
@@ -430,6 +430,25 @@ mymain(int argc, char **argv)
for (i = 0 ; i < NUM_TIME ; i++)
virEventRemoveTimeoutImpl(timers[i].timer);
+ resetAll();
+
+ /* Final test, register same FD twice, once with no
+ * events, and make sure the right callback runs */
+ handles[0].pipeFD[0] = handles[1].pipeFD[0];
+ handles[0].pipeFD[1] = handles[1].pipeFD[1];
+
+ handles[0].watch = virEventAddHandleImpl(handles[0].pipeFD[0],
+ 0,
+ testPipeReader,
+ &handles[0], NULL);
+ handles[1].watch = virEventAddHandleImpl(handles[1].pipeFD[0],
+ VIR_EVENT_HANDLE_READABLE,
+ testPipeReader,
+ &handles[1], NULL);
+ startJob("Write duplicate", &test);
+ ret = safewrite(handles[1].pipeFD[1], &one, 1);
+ if (finishJob(1, -1) != EXIT_SUCCESS)
+ return EXIT_FAILURE;
//pthread_kill(eventThread, SIGTERM);
--
1.6.2.5
10:28 a.m.
New subject: [libvirt] [PATCH 02/11] Avoid polling on FDs with no events enabled
On Mon, Aug 24, 2009 at 09:51:05PM +0100, Daniel P. Berrange wrote:
If a file descriptor with events=0 was added to the libvirtd
event loop, it would still be added to the poll() fds' array.
While it wouldn't see any POLLIN/OUT events, it'd still get
triggered for HANGUP/ERROR events which was not in compliance
with the libvirt events API contract.
Independantly of the rest of the stream patches this sounds fine to
push,
ACK,
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
9:53 a.m.
New subject: [libvirt] [PATCH 02/11] Avoid polling on FDs with no events enabled
Daniel Veillard wrote:
On Mon, Aug 24, 2009 at 09:51:05PM +0100, Daniel P. Berrange wrote:
> If a file descriptor with events=0 was added to the libvirtd
> event loop, it would still be added to the poll() fds' array.
> While it wouldn't see any POLLIN/OUT events, it'd still get
> triggered for HANGUP/ERROR events which was not in compliance
> with the libvirt events API contract.
Independantly of the rest of the stream patches this sounds fine to
push,
Hm, this patch seems to be causing a regression. If I start up a KVM guest, let
it completely boot, then run "shutdown -h now" inside the guest, the guest
properly shuts down and qemu-kvm exits. However, it is never removed from the
list of "active" guests (i.e. it shows up in "virsh list"), and the
state is set
to "no state". Reverting just this patch fixes the issue. I'll look at it
some
more to try to figure out what is happening, but we might want to revert it for
the time being (since we don't technically need it at the moment).
--
Chris Lalancette
4:35 a.m.
New subject: [libvirt] [PATCH 02/11] Avoid polling on FDs with no events enabled
Chris Lalancette wrote:
Daniel Veillard wrote:
> On Mon, Aug 24, 2009 at 09:51:05PM +0100, Daniel P. Berrange wrote:
>> If a file descriptor with events=0 was added to the libvirtd
>> event loop, it would still be added to the poll() fds' array.
>> While it wouldn't see any POLLIN/OUT events, it'd still get
>> triggered for HANGUP/ERROR events which was not in compliance
>> with the libvirt events API contract.
> Independantly of the rest of the stream patches this sounds fine to
> push,
Hm, this patch seems to be causing a regression. If I start up a KVM guest, let
it completely boot, then run "shutdown -h now" inside the guest, the guest
properly shuts down and qemu-kvm exits. However, it is never removed from the
list of "active" guests (i.e. it shows up in "virsh list"), and the
state is set
to "no state". Reverting just this patch fixes the issue. I'll look at it
some
more to try to figure out what is happening, but we might want to revert it for
the time being (since we don't technically need it at the moment).
OK, danpb pointed out the problem. Don't revert this patch, I'll post a follow
up to fix the problem in a couple of minutes.
--
Chris Lalancette
3:51 p.m.
New subject: [libvirt] [PATCH 03/11] Helper functions for processing data streams in libvirtd
Defines the extensions to the remote protocol for generic
data streams. Adds a bunch of helper code to the libvirtd
daemon for working with data streams.
* qemud/Makefile.am: Add stream.c/stream.h to build
* qemud/stream.c, qemud/stream.h: Generic helper functions for
creating new streams, associating streams with clients, finding
existing streams for a client and removing/deleting streams.
* qemud/remote_protocol.x: Add a new 'REMOTE_STREAM' constant
for the 'enum remote_message_type' for encoding stream data
in wire messages. Add a new 'REMOTE_CONTINUE' constant to
'enum remote_message_status' to indicate further data stream
messsages are expected to follow. Document how the
remote_message_header is used to encode data streams
* qemud/remote_protocol.h: Regenerate
* qemud/dispatch.c: Remove assumption that a error message
sent to client is always type=REMOTE_REPLY. It may now
also be type=REMOTE_STREAM. Add convenient method for
sending outgoing stream data packets. Log and ignore
non-filtered incoming stream packets. Add a method for
serializing a stream error message
* qemud/dispatch.h: Add API for serializing stream errors
and sending stream data packets
* qemud/qemud.h: Add struct qemud_client_stream for tracking
active data streams for clients. Tweak filter function
operation so that it accepts a client object too.
* qemud/qemud.c: Refactor code for free'ing message objects
which have been fully transmitted into separate method.
Release all active streams when client shuts down. Change
filter function to be responsible for queueing the message
---
qemud/Makefile.am | 1 +
qemud/dispatch.c | 127 ++++++++++++++++++++++++++++-
qemud/dispatch.h | 17 ++++
qemud/qemud.c | 54 ++++++++----
qemud/qemud.h | 32 ++++++-
qemud/remote_protocol.h | 4 +
qemud/remote_protocol.x | 44 +++++++++-
qemud/stream.c | 210 +++++++++++++++++++++++++++++++++++++++++++++++
qemud/stream.h | 49 +++++++++++
9 files changed, 509 insertions(+), 29 deletions(-)
create mode 100644 qemud/stream.c
create mode 100644 qemud/stream.h
diff --git a/qemud/Makefile.am b/qemud/Makefile.am
index 959ff88..5f1376e 100644
--- a/qemud/Makefile.am
+++ b/qemud/Makefile.am
@@ -5,6 +5,7 @@ DAEMON_SOURCES = \
qemud.c qemud.h \
remote.c remote.h \
dispatch.c dispatch.h \
+ stream.c stream.h \
remote_dispatch_prototypes.h \
remote_dispatch_table.h \
remote_dispatch_args.h \
diff --git a/qemud/dispatch.c b/qemud/dispatch.c
index a60f2f4..1934d24 100644
--- a/qemud/dispatch.c
+++ b/qemud/dispatch.c
@@ -104,7 +104,7 @@ void remoteDispatchOOMError (remote_error *rerr)
{
remoteDispatchStringError(rerr,
VIR_ERR_NO_MEMORY,
- NULL);
+ "out of memory");
}
@@ -136,6 +136,10 @@ remoteSerializeError(struct qemud_client *client,
unsigned int len;
struct qemud_client_message *msg = NULL;
+ DEBUG("prog=%d ver=%d proc=%d type=%d serial=%d, msg=%s",
+ program, version, procedure, type, serial,
+ rerr->message ? *rerr->message : "(none)");
+
if (VIR_ALLOC(msg) < 0)
goto fatal_error;
@@ -206,19 +210,38 @@ fatal_error:
*
* Returns 0 if the error was sent, -1 upon fatal error
*/
-static int
+int
remoteSerializeReplyError(struct qemud_client *client,
remote_error *rerr,
remote_message_header *req) {
+ /*
+ * For data streams, errors are sent back as data streams
+ * For method calls, errors are sent back as method replies
+ */
return remoteSerializeError(client,
rerr,
req->prog,
req->vers,
req->proc,
- REMOTE_REPLY,
+ req->type == REMOTE_STREAM ? REMOTE_STREAM :
REMOTE_REPLY,
req->serial);
}
+int
+remoteSerializeStreamError(struct qemud_client *client,
+ remote_error *rerr,
+ int proc,
+ int serial)
+{
+ return remoteSerializeError(client,
+ rerr,
+ REMOTE_PROGRAM,
+ REMOTE_PROTOCOL_VERSION,
+ proc,
+ REMOTE_STREAM,
+ serial);
+}
+
/*
* @msg: the complete incoming message, whose header to decode
*
@@ -338,6 +361,10 @@ remoteDispatchClientRequest (struct qemud_server *server,
{
remote_error rerr;
+ DEBUG("prog=%d ver=%d type=%d satus=%d serial=%d proc=%d",
+ msg->hdr.prog, msg->hdr.vers, msg->hdr.type,
+ msg->hdr.status, msg->hdr.serial, msg->hdr.proc);
+
memset(&rerr, 0, sizeof rerr);
/* Check version, etc. */
@@ -358,11 +385,24 @@ remoteDispatchClientRequest (struct qemud_server *server,
case REMOTE_CALL:
return remoteDispatchClientCall(server, client, msg);
+ case REMOTE_STREAM:
+ /* Since stream data is non-acked, async, we may continue to received
+ * stream packets after we closed down a stream. Just drop & ignore
+ * these.
+ */
+ VIR_INFO("Ignoring unexpected stream data serial=%d proc=%d
status=%d",
+ msg->hdr.serial, msg->hdr.proc, msg->hdr.status);
+ qemudClientMessageRelease(client, msg);
+ break;
+
default:
remoteDispatchFormatError (&rerr, _("type (%d) != REMOTE_CALL"),
(int) msg->hdr.type);
+ goto error;
}
+ return 0;
+
error:
return remoteSerializeReplyError(client, &rerr, &msg->hdr);
}
@@ -532,3 +572,84 @@ xdr_error:
fatal_error:
return -1;
}
+
+
+int
+remoteSendStreamData(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ const char *data,
+ size_t len)
+{
+ struct qemud_client_message *msg;
+ XDR xdr;
+
+ DEBUG("client=%p stream=%p data=%p len=%d", client, stream, data, len);
+
+ if (VIR_ALLOC(msg) < 0) {
+ return -1;
+ }
+
+ /* Return header. We're re-using same message object, so
+ * only need to tweak type/status fields */
+ msg->hdr.prog = REMOTE_PROGRAM;
+ msg->hdr.vers = REMOTE_PROTOCOL_VERSION;
+ msg->hdr.proc = stream->procedure;
+ msg->hdr.type = REMOTE_STREAM;
+ msg->hdr.serial = stream->serial;
+ /*
+ * NB
+ * data != NULL + len > 0 => REMOTE_CONTINUE (Sending back data)
+ * data != NULL + len == 0 => REMOTE_CONTINUE (Sending read EOF)
+ * data == NULL => REMOTE_OK (Sending finish handshake
confirmation)
+ */
+ msg->hdr.status = data ? REMOTE_CONTINUE : REMOTE_OK;
+
+ if (remoteEncodeClientMessageHeader(msg) < 0)
+ goto fatal_error;
+
+ if (data && len) {
+ if ((msg->bufferLength - msg->bufferOffset) < len)
+ goto fatal_error;
+
+ /* Now for the payload */
+ xdrmem_create (&xdr,
+ msg->buffer,
+ msg->bufferLength,
+ XDR_ENCODE);
+
+ /* Skip over existing header already written */
+ if (xdr_setpos(&xdr, msg->bufferOffset) == 0)
+ goto xdr_error;
+
+ memcpy(msg->buffer + msg->bufferOffset, data, len);
+ msg->bufferOffset += len;
+
+ /* Update the length word. */
+ len = msg->bufferOffset;
+ if (xdr_setpos (&xdr, 0) == 0)
+ goto xdr_error;
+
+ if (!xdr_u_int (&xdr, &len))
+ goto xdr_error;
+
+ xdr_destroy (&xdr);
+
+ DEBUG("Total %d", msg->bufferOffset);
+ }
+
+ /* Reset ready for I/O */
+ msg->bufferLength = msg->bufferOffset;
+ msg->bufferOffset = 0;
+
+ /* Put reply on end of tx queue to send out */
+ qemudClientMessageQueuePush(&client->tx, msg);
+ qemudUpdateClientEvent(client);
+
+ return 0;
+
+xdr_error:
+ xdr_destroy (&xdr);
+fatal_error:
+ VIR_FREE(msg);
+ return -1;
+}
diff --git a/qemud/dispatch.h b/qemud/dispatch.h
index 1d85df9..03a699c 100644
--- a/qemud/dispatch.h
+++ b/qemud/dispatch.h
@@ -49,6 +49,17 @@ void remoteDispatchOOMError (remote_error *rerr);
void remoteDispatchConnError (remote_error *rerr,
virConnectPtr conn);
+
+int
+remoteSerializeReplyError(struct qemud_client *client,
+ remote_error *rerr,
+ remote_message_header *req);
+int
+remoteSerializeStreamError(struct qemud_client *client,
+ remote_error *rerr,
+ int proc,
+ int serial);
+
/* Having this here is dubious. It should be in remote.h
* but qemud.c shouldn't depend on that header directly.
* Refactor this later to deal with this properly.
@@ -60,4 +71,10 @@ int remoteRelayDomainEvent (virConnectPtr conn ATTRIBUTE_UNUSED,
void *opaque);
+int
+remoteSendStreamData(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ const char *data,
+ size_t len);
+
#endif /* __LIBVIRTD_DISPATCH_H__ */
diff --git a/qemud/qemud.c b/qemud/qemud.c
index e657cf2..6c81dec 100644
--- a/qemud/qemud.c
+++ b/qemud/qemud.c
@@ -61,6 +61,7 @@
#include "conf.h"
#include "event.h"
#include "memory.h"
+#include "stream.h"
#ifdef HAVE_AVAHI
#include "mdns.h"
#endif
@@ -1718,10 +1719,15 @@ readmore:
/* Check if any filters match this message */
filter = client->filters;
while (filter) {
- if ((filter->query)(msg, filter->opaque)) {
- qemudClientMessageQueuePush(&filter->dx, msg);
+ int ret;
+ ret = (filter->query)(client, msg, filter->opaque);
+ if (ret == 1) {
msg = NULL;
break;
+ } else if (ret == -1) {
+ VIR_FREE(msg);
+ qemudDispatchClientFailure(client);
+ return;
}
filter = filter->next;
}
@@ -1883,6 +1889,29 @@ static ssize_t qemudClientWrite(struct qemud_client *client) {
}
+void
+qemudClientMessageRelease(struct qemud_client *client,
+ struct qemud_client_message *msg)
+{
+ if (!msg->async)
+ client->nrequests--;
+
+ /* See if the recv queue is currently throttled */
+ if (!client->rx &&
+ client->nrequests < max_client_requests) {
+ /* Reset message record for next RX attempt */
+ memset(msg, 0, sizeof(*msg));
+ client->rx = msg;
+ /* Get ready to receive next message */
+ client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
+ } else {
+ VIR_FREE(msg);
+ }
+
+ qemudUpdateClientEvent(client);
+}
+
+
/*
* Process all queued client->tx messages until
* we would block on I/O
@@ -1906,26 +1935,10 @@ qemudDispatchClientWrite(struct qemud_client *client) {
/* Get finished reply from head of tx queue */
reply = qemudClientMessageQueueServe(&client->tx);
- /* If its not an async message, then we have
- * just completed an RPC request */
- if (!reply->async)
- client->nrequests--;
-
- /* Move record to end of 'rx' ist */
- if (!client->rx &&
- client->nrequests < max_client_requests) {
- /* Reset message record for next RX attempt */
- client->rx = reply;
- client->rx->bufferOffset = 0;
- client->rx->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
- } else {
- VIR_FREE(reply);
- }
+ qemudClientMessageRelease(client, reply);
if (client->closing)
qemudDispatchClientFailure(client);
- else
- qemudUpdateClientEvent(client);
}
}
}
@@ -2137,6 +2150,9 @@ static void qemudFreeClient(struct qemud_client *client) {
VIR_FREE(msg);
}
+ while (client->streams)
+ remoteRemoveClientStream(client, client->streams);
+
if (client->conn)
virConnectClose(client->conn);
virMutexDestroy(&client->lock);
diff --git a/qemud/qemud.h b/qemud/qemud.h
index 254db44..8ef5871 100644
--- a/qemud/qemud.h
+++ b/qemud/qemud.h
@@ -129,26 +129,43 @@ struct qemud_client_message {
unsigned int bufferLength;
unsigned int bufferOffset;
- int async : 1;
+ unsigned int async : 1;
remote_message_header hdr;
struct qemud_client_message *next;
};
+struct qemud_client;
+
/* Allow for filtering of incoming messages to a custom
* dispatch processing queue, instead of client->dx.
*/
-typedef int (*qemud_client_filter_func)(struct qemud_client_message *msg, void *opaque);
+typedef int (*qemud_client_filter_func)(struct qemud_client *client,
+ struct qemud_client_message *msg, void *opaque);
struct qemud_client_filter {
qemud_client_filter_func query;
void *opaque;
- struct qemud_client_message *dx;
-
struct qemud_client_filter *next;
};
+struct qemud_client_stream {
+ virStreamPtr st;
+ int procedure;
+ int serial;
+
+ unsigned int recvEOF : 1;
+ unsigned int closed : 1;
+
+ struct qemud_client_filter filter;
+
+ struct qemud_client_message *rx;
+ int tx;
+
+ struct qemud_client_stream *next;
+};
+
/* Stores the per-client connection state */
struct qemud_client {
virMutex lock;
@@ -197,6 +214,10 @@ struct qemud_client {
* end up on the 'dx' queue */
struct qemud_client_filter *filters;
+ /* Data streams */
+ struct qemud_client_stream *streams;
+
+
/* This is only valid if a remote open call has been made on this
* connection, otherwise it will be NULL. Also if remote close is
* called, it will be set back to NULL if that succeeds.
@@ -275,6 +296,9 @@ qemudClientMessageQueuePush(struct qemud_client_message **queue,
struct qemud_client_message *
qemudClientMessageQueueServe(struct qemud_client_message **queue);
+void
+qemudClientMessageRelease(struct qemud_client *client,
+ struct qemud_client_message *msg);
#if HAVE_POLKIT
diff --git a/qemud/remote_protocol.h b/qemud/remote_protocol.h
index 2e5bc81..2ff9075 100644
--- a/qemud/remote_protocol.h
+++ b/qemud/remote_protocol.h
@@ -16,6 +16,8 @@ extern "C" {
#include "internal.h"
#include <arpa/inet.h>
#define REMOTE_MESSAGE_MAX 262144
+#define REMOTE_MESSAGE_HEADER_MAX 24
+#define REMOTE_MESSAGE_PAYLOAD_MAX 262120
#define REMOTE_STRING_MAX 65536
typedef char *remote_nonnull_string;
@@ -1576,12 +1578,14 @@ enum remote_message_type {
REMOTE_CALL = 0,
REMOTE_REPLY = 1,
REMOTE_MESSAGE = 2,
+ REMOTE_STREAM = 3,
};
typedef enum remote_message_type remote_message_type;
enum remote_message_status {
REMOTE_OK = 0,
REMOTE_ERROR = 1,
+ REMOTE_CONTINUE = 2,
};
typedef enum remote_message_status remote_message_status;
#define REMOTE_MESSAGE_HEADER_XDR_LEN 4
diff --git a/qemud/remote_protocol.x b/qemud/remote_protocol.x
index 8f9b6db..e24c428 100644
--- a/qemud/remote_protocol.x
+++ b/qemud/remote_protocol.x
@@ -44,6 +44,12 @@
/* Maximum total message size (serialised). */
const REMOTE_MESSAGE_MAX = 262144;
+/* Size of struct remote_message_header (serialized)*/
+const REMOTE_MESSAGE_HEADER_MAX = 24;
+
+/* Size of message payload */
+const REMOTE_MESSAGE_PAYLOAD_MAX = 262120;
+
/* Length of long, but not unbounded, strings.
* This is an arbitrary limit designed to stop the decoder from trying
* to allocate unbounded amounts of memory when fed with a bad message.
@@ -1448,8 +1454,27 @@ enum remote_procedure {
* * serial matches that from the corresponding REMOTE_CALL
*
* - type == REMOTE_MESSAGE
- * * serial matches that from the corresponding REMOTE_CALL, or zero
+ * * serial is always zero
+ *
+ * - type == REMOTE_STREAM
+ * * serial matches that from the corresponding REMOTE_CALL
*
+ * and the 'status' field varies according to:
+ *
+ * - type == REMOTE_CALL
+ * * REMOTE_OK always
+ *
+ * - type == REMOTE_REPLY
+ * * REMOTE_OK if RPC finished successfully
+ * * REMOTE_ERROR if something failed
+ *
+ * - type == REMOTE_MESSAGE
+ * * REMOTE_OK always
+ *
+ * - type == REMOTE_STREAM
+ * * REMOTE_CONTINUE if more data is following
+ * * REMOTE_OK if stream is complete
+ * * REMOTE_ERROR if stream had an error
*
* Payload varies according to type and status:
*
@@ -1468,6 +1493,13 @@ enum remote_procedure {
* * status == REMOTE_ERROR
* remote_error Error information
*
+ * - type == REMOTE_STREAM
+ * * status == REMOTE_CONTINUE
+ * byte[] raw stream data
+ * * status == REMOTE_ERROR
+ * remote_error error information
+ * * status == REMOTE_OK
+ * <empty>
*/
enum remote_message_type {
/* client -> server. args from a method call */
@@ -1475,7 +1507,9 @@ enum remote_message_type {
/* server -> client. reply/error from a method call */
REMOTE_REPLY = 1,
/* either direction. async notification */
- REMOTE_MESSAGE = 2
+ REMOTE_MESSAGE = 2,
+ /* either direction. stream data packet */
+ REMOTE_STREAM = 3
};
enum remote_message_status {
@@ -1487,7 +1521,11 @@ enum remote_message_status {
/* For replies, indicates that an error happened, and a struct
* remote_error follows.
*/
- REMOTE_ERROR = 1
+ REMOTE_ERROR = 1,
+
+ /* For streams, indicates that more data is still expected
+ */
+ REMOTE_CONTINUE = 2
};
/* 4 byte length word per header */
diff --git a/qemud/stream.c b/qemud/stream.c
new file mode 100644
index 0000000..1644a1b
--- /dev/null
+++ b/qemud/stream.c
@@ -0,0 +1,210 @@
+/*
+ * stream.c: APIs for managing client streams
+ *
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Daniel P. Berrange <berrange(a)redhat.com>
+ */
+
+
+#include <config.h>
+
+#include "stream.h"
+#include "memory.h"
+#include "dispatch.h"
+#include "logging.h"
+
+
+/*
+ * @client: a locked client object
+ *
+ * Invoked by the main loop when filtering incoming messages.
+ *
+ * Returns 1 if the message was processed, 0 if skipped,
+ * -1 on fatal client error
+ */
+static int
+remoteStreamFilter(struct qemud_client *client ATTRIBUTE_UNUSED,
+ struct qemud_client_message *msg ATTRIBUTE_UNUSED,
+ void *opaque ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
+
+/*
+ * @conn: a connection object to associate the stream with
+ * @hdr: the method call to associate with the stram
+ *
+ * Creates a new stream for this conn
+ *
+ * Returns a new stream object, or NULL upon OOM
+ */
+struct qemud_client_stream *
+remoteCreateClientStream(virConnectPtr conn,
+ remote_message_header *hdr)
+{
+ struct qemud_client_stream *stream;
+
+ DEBUG("proc=%d serial=%d", hdr->proc, hdr->serial);
+
+ if (VIR_ALLOC(stream) < 0)
+ return NULL;
+
+ stream->procedure = hdr->proc;
+ stream->serial = hdr->serial;
+
+ stream->st = virStreamNew(conn, VIR_STREAM_NONBLOCK);
+ if (!stream->st) {
+ VIR_FREE(stream);
+ return NULL;
+ }
+
+ stream->filter.query = remoteStreamFilter;
+ stream->filter.opaque = stream;
+
+ return stream;
+}
+
+/*
+ * @stream: an unused client stream
+ *
+ * Frees the memory associated with this inactive client
+ * stream
+ */
+void remoteFreeClientStream(struct qemud_client *client,
+ struct qemud_client_stream *stream)
+{
+ struct qemud_client_message *msg;
+
+ if (!stream)
+ return;
+
+ DEBUG("proc=%d serial=%d", stream->procedure, stream->serial);
+
+ msg = stream->rx;
+ while (msg) {
+ struct qemud_client_message *tmp = msg->next;
+ qemudClientMessageRelease(client, msg);
+ msg = tmp;
+ }
+
+ virStreamFree(stream->st);
+ VIR_FREE(stream);
+}
+
+
+/*
+ * @client: a locked client to add the stream to
+ * @stream: a stream to add
+ */
+int remoteAddClientStream(struct qemud_client *client,
+ struct qemud_client_stream *stream)
+{
+ struct qemud_client_stream *tmp = client->streams;
+
+ DEBUG("client=%p proc=%d serial=%d", client, stream->procedure,
stream->serial);
+
+ if (tmp) {
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = stream;
+ } else {
+ client->streams = stream;
+ }
+
+ stream->filter.next = client->filters;
+ client->filters = &stream->filter;
+
+ stream->tx = 1;
+
+ return 0;
+}
+
+
+/*
+ * @client: a locked client object
+ * @procedure: procedure associated with the stream
+ * @serial: serial number associated with the stream
+ *
+ * Finds a existing active stream
+ *
+ * Returns a stream object matching the procedure+serial number, or NULL
+ */
+struct qemud_client_stream *
+remoteFindClientStream(struct qemud_client *client,
+ virStreamPtr st)
+{
+ struct qemud_client_stream *stream = client->streams;
+
+ while (stream) {
+ if (stream->st == st)
+ return stream;
+ stream = stream->next;
+ }
+
+ return NULL;
+}
+
+
+/*
+ * @client: a locked client object
+ * @stream: an inactive, closed stream object
+ *
+ * Removes a stream from the list of active streams for the client
+ *
+ * Returns 0 if the stream was removd, -1 if it doesn't exist
+ */
+int
+remoteRemoveClientStream(struct qemud_client *client,
+ struct qemud_client_stream *stream)
+{
+ DEBUG("client=%p proc=%d serial=%d", client, stream->procedure,
stream->serial);
+
+ struct qemud_client_stream *curr = client->streams;
+ struct qemud_client_stream *prev = NULL;
+ struct qemud_client_filter *filter = NULL;
+
+ if (client->filters == &stream->filter) {
+ client->filters = client->filters->next;
+ } else {
+ filter = client->filters;
+ while (filter) {
+ if (filter->next == &stream->filter) {
+ filter->next = filter->next->next;
+ break;
+ }
+ }
+ }
+
+ if (!stream->closed)
+ virStreamAbort(stream->st);
+
+ while (curr) {
+ if (curr == stream) {
+ if (prev)
+ prev->next = curr->next;
+ else
+ client->streams = curr->next;
+ remoteFreeClientStream(client, stream);
+ return 0;
+ }
+ prev = curr;
+ curr = curr->next;
+ }
+ return -1;
+}
diff --git a/qemud/stream.h b/qemud/stream.h
new file mode 100644
index 0000000..fe5ce6f
--- /dev/null
+++ b/qemud/stream.h
@@ -0,0 +1,49 @@
+/*
+ * stream.h: APIs for managing client streams
+ *
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Daniel P. Berrange <berrange(a)redhat.com>
+ */
+
+
+#ifndef __LIBVIRTD_STREAM_H__
+#define __LIBVIRTD_STREAM_H__
+
+#include "qemud.h"
+
+
+
+struct qemud_client_stream *
+remoteCreateClientStream(virConnectPtr conn,
+ remote_message_header *hdr);
+
+void remoteFreeClientStream(struct qemud_client *client,
+ struct qemud_client_stream *stream);
+
+int remoteAddClientStream(struct qemud_client *client,
+ struct qemud_client_stream *stream);
+
+struct qemud_client_stream *
+remoteFindClientStream(struct qemud_client *client,
+ virStreamPtr stream);
+
+int
+remoteRemoveClientStream(struct qemud_client *client,
+ struct qemud_client_stream *stream);
+
+#endif /* __LIBVIRTD_STREAM_H__ */
--
1.6.2.5
5:20 a.m.
New subject: [libvirt] [PATCH 03/11] Helper functions for processing data streams in libvirtd
On Mon, Aug 24, 2009 at 09:51:06PM +0100, Daniel P. Berrange wrote:
Defines the extensions to the remote protocol for generic
data streams. Adds a bunch of helper code to the libvirtd
daemon for working with data streams.
* qemud/Makefile.am: Add stream.c/stream.h to build
* qemud/stream.c, qemud/stream.h: Generic helper functions for
creating new streams, associating streams with clients, finding
existing streams for a client and removing/deleting streams.
* qemud/remote_protocol.x: Add a new 'REMOTE_STREAM' constant
for the 'enum remote_message_type' for encoding stream data
in wire messages. Add a new 'REMOTE_CONTINUE' constant to
'enum remote_message_status' to indicate further data stream
messsages are expected to follow. Document how the
remote_message_header is used to encode data streams
* qemud/remote_protocol.h: Regenerate
* qemud/dispatch.c: Remove assumption that a error message
sent to client is always type=REMOTE_REPLY. It may now
also be type=REMOTE_STREAM. Add convenient method for
sending outgoing stream data packets. Log and ignore
non-filtered incoming stream packets. Add a method for
serializing a stream error message
* qemud/dispatch.h: Add API for serializing stream errors
and sending stream data packets
* qemud/qemud.h: Add struct qemud_client_stream for tracking
active data streams for clients. Tweak filter function
operation so that it accepts a client object too.
* qemud/qemud.c: Refactor code for free'ing message objects
which have been fully transmitted into separate method.
Release all active streams when client shuts down. Change
filter function to be responsible for queueing the message
ACK, but this is hard to review, only testing can really bring
confidence for this kind of code :-)
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
3:51 p.m.
New subject: [libvirt] [PATCH 04/11] Handle incoming data streams in libvirtd
* qemud/stream.c: Handle incoming stream data packets, queuing until
stream becomes writable. Handle stream completion handshake
* po/POTFILES.in: Add qemud/stream.c
---
po/POTFILES.in | 1 +
qemud/stream.c | 305 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 303 insertions(+), 3 deletions(-)
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 66d3ebd..d144689 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -1,6 +1,7 @@
qemud/dispatch.c
qemud/qemud.c
qemud/remote.c
+qemud/stream.c
src/bridge.c
src/conf.c
src/console.c
diff --git a/qemud/stream.c b/qemud/stream.c
index 1644a1b..1fe0e58 100644
--- a/qemud/stream.c
+++ b/qemud/stream.c
@@ -28,6 +28,93 @@
#include "dispatch.h"
#include "logging.h"
+static int
+remoteStreamHandleWrite(struct qemud_client *client,
+ struct qemud_client_stream *stream);
+static int
+remoteStreamHandleFinish(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ struct qemud_client_message *msg);
+static int
+remoteStreamHandleAbort(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ struct qemud_client_message *msg);
+
+
+
+static void
+remoteStreamUpdateEvents(struct qemud_client_stream *stream)
+{
+ int newEvents = 0;
+ if (stream->rx)
+ newEvents |= VIR_STREAM_EVENT_WRITABLE;
+
+ virStreamEventUpdateCallback(stream->st, newEvents);
+}
+
+
+/*
+ * Callback that gets invoked when a stream becomes writable/readable
+ */
+static void
+remoteStreamEvent(virStreamPtr st, int events, void *opaque)
+{
+ struct qemud_client *client = opaque;
+ struct qemud_client_stream *stream;
+
+ /* XXX sub-optimal - we really should be taking the server lock
+ * first, but we have no handle to the server object
+ * We're lucky to get away with it for now, due to this callback
+ * executing in the main thread, but this should really be fixed
+ */
+ virMutexLock(&client->lock);
+
+ stream = remoteFindClientStream(client, st);
+
+ if (!stream) {
+ VIR_WARN("event for client=%p stream st=%p, but missing stream state",
client, st);
+ virStreamEventRemoveCallback(st);
+ goto cleanup;
+ }
+
+ DEBUG("st=%p events=%d", st, events);
+
+ if (events & VIR_STREAM_EVENT_WRITABLE) {
+ if (remoteStreamHandleWrite(client, stream) < 0) {
+ remoteRemoveClientStream(client, stream);
+ qemudDispatchClientFailure(client);
+ goto cleanup;
+ }
+ }
+
+ if (!stream->closed &&
+ (events & (VIR_STREAM_EVENT_ERROR | VIR_STREAM_EVENT_HANGUP))) {
+ int ret;
+ remote_error rerr;
+ memset(&rerr, 0, sizeof rerr);
+ stream->closed = 1;
+ virStreamAbort(stream->st);
+ if (events & VIR_STREAM_EVENT_HANGUP)
+ remoteDispatchFormatError(&rerr, "%s", _("stream had
unexpected termination"));
+ else
+ remoteDispatchFormatError(&rerr, "%s", _("stream had I/O
failure"));
+ ret = remoteSerializeStreamError(client, &rerr, stream->procedure,
stream->serial);
+ remoteRemoveClientStream(client, stream);
+ if (ret < 0)
+ qemudDispatchClientFailure(client);
+ goto cleanup;
+ }
+
+ if (stream->closed) {
+ remoteRemoveClientStream(client, stream);
+ } else {
+ remoteStreamUpdateEvents(stream);
+ }
+
+cleanup:
+ virMutexUnlock(&client->lock);
+}
+
/*
* @client: a locked client object
@@ -38,10 +125,54 @@
* -1 on fatal client error
*/
static int
-remoteStreamFilter(struct qemud_client *client ATTRIBUTE_UNUSED,
- struct qemud_client_message *msg ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+remoteStreamFilter(struct qemud_client *client,
+ struct qemud_client_message *msg, void *opaque)
{
+ struct qemud_client_stream *stream = opaque;
+
+ if (msg->hdr.serial == stream->serial &&
+ msg->hdr.proc == stream->procedure &&
+ msg->hdr.type == REMOTE_STREAM) {
+ DEBUG("Incoming rx=%p serial=%d proc=%d status=%d",
+ stream->rx, msg->hdr.proc, msg->hdr.serial, msg->hdr.status);
+
+ /* If there are queued packets, we need to queue all further
+ * messages, since they must be processed strictly in order.
+ * If there are no queued packets, then OK/ERROR messages
+ * should be processed immediately. Data packets are still
+ * queued to only be processed when the stream is marked as
+ * writable.
+ */
+ if (stream->rx) {
+ qemudClientMessageQueuePush(&stream->rx, msg);
+ remoteStreamUpdateEvents(stream);
+ } else {
+ int ret = 0;
+ switch (msg->hdr.status) {
+ case REMOTE_OK:
+ ret = remoteStreamHandleFinish(client, stream, msg);
+ if (ret == 0)
+ qemudClientMessageRelease(client, msg);
+ break;
+
+ case REMOTE_CONTINUE:
+ qemudClientMessageQueuePush(&stream->rx, msg);
+ remoteStreamUpdateEvents(stream);
+ break;
+
+ case REMOTE_ERROR:
+ default:
+ ret = remoteStreamHandleAbort(client, stream, msg);
+ if (ret == 0)
+ qemudClientMessageRelease(client, msg);
+ break;
+ }
+
+ if (ret < 0)
+ return -1;
+ }
+ return 1;
+ }
return 0;
}
@@ -119,6 +250,10 @@ int remoteAddClientStream(struct qemud_client *client,
DEBUG("client=%p proc=%d serial=%d", client, stream->procedure,
stream->serial);
+ if (virStreamEventAddCallback(stream->st, 0,
+ remoteStreamEvent, client, NULL) < 0)
+ return -1;
+
if (tmp) {
while (tmp->next)
tmp = tmp->next;
@@ -132,6 +267,8 @@ int remoteAddClientStream(struct qemud_client *client,
stream->tx = 1;
+ remoteStreamUpdateEvents(stream);
+
return 0;
}
@@ -208,3 +345,165 @@ remoteRemoveClientStream(struct qemud_client *client,
}
return -1;
}
+
+
+/*
+ * Returns:
+ * -1 if fatal error occurred
+ * 0 if message was fully processed
+ * 1 if message is still being processed
+ */
+static int
+remoteStreamHandleWriteData(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ struct qemud_client_message *msg)
+{
+ remote_error rerr;
+ int ret;
+
+ DEBUG("stream=%p proc=%d serial=%d len=%d offset=%d",
+ stream, msg->hdr.proc, msg->hdr.serial, msg->bufferLength,
msg->bufferOffset);
+
+ memset(&rerr, 0, sizeof rerr);
+
+ ret = virStreamSend(stream->st,
+ msg->buffer + msg->bufferOffset,
+ msg->bufferLength - msg->bufferOffset);
+
+ if (ret > 0) {
+ msg->bufferOffset += ret;
+
+ /* Partial write, so indicate we have more todo later */
+ if (msg->bufferOffset < msg->bufferLength)
+ return 1;
+ } else if (ret == -2) {
+ /* Blocking, so indicate we have more todo later */
+ return 1;
+ } else {
+ VIR_INFO0("Stream send failed");
+ stream->closed = 1;
+ remoteDispatchConnError(&rerr, client->conn);
+ return remoteSerializeReplyError(client, &rerr, &msg->hdr);
+ }
+
+ return 0;
+}
+
+
+/*
+ * Process an finish handshake from the client.
+ *
+ * Returns a REMOTE_OK confirmation if successful, or a REMOTE_ERROR
+ * if there was a stream error
+ *
+ * Returns 0 if successfully sent RPC reply, -1 upon fatal error
+ */
+static int
+remoteStreamHandleFinish(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ struct qemud_client_message *msg)
+{
+ remote_error rerr;
+ int ret;
+
+ DEBUG("stream=%p proc=%d serial=%d",
+ stream, msg->hdr.proc, msg->hdr.serial);
+
+ memset(&rerr, 0, sizeof rerr);
+
+ stream->closed = 1;
+ ret = virStreamFinish(stream->st);
+
+ if (ret < 0) {
+ remoteDispatchConnError(&rerr, client->conn);
+ return remoteSerializeReplyError(client, &rerr, &msg->hdr);
+ } else {
+ /* Send zero-length confirm */
+ if (remoteSendStreamData(client, stream, NULL, 0) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/*
+ * Process an abort request from the client.
+ *
+ * Returns 0 if successfully aborted, -1 upon error
+ */
+static int
+remoteStreamHandleAbort(struct qemud_client *client,
+ struct qemud_client_stream *stream,
+ struct qemud_client_message *msg)
+{
+ remote_error rerr;
+
+ DEBUG("stream=%p proc=%d serial=%d",
+ stream, msg->hdr.proc, msg->hdr.serial);
+
+ memset(&rerr, 0, sizeof rerr);
+
+ stream->closed = 1;
+ virStreamAbort(stream->st);
+
+ if (msg->hdr.status == REMOTE_ERROR)
+ remoteDispatchFormatError(&rerr, "%s", _("stream aborted at
client request"));
+ else {
+ VIR_WARN("unexpected stream status %d", msg->hdr.status);
+ remoteDispatchFormatError(&rerr, _("stream aborted with unexpected
status %d"),
+ msg->hdr.status);
+ }
+
+ return remoteSerializeReplyError(client, &rerr, &msg->hdr);
+}
+
+
+
+/*
+ * Called when the stream is signalled has being able to accept
+ * data writes. Will process all pending incoming messages
+ * until they're all gone, or I/O blocks
+ *
+ * Returns 0 on success, or -1 upon fatal error
+ */
+static int
+remoteStreamHandleWrite(struct qemud_client *client,
+ struct qemud_client_stream *stream)
+{
+ struct qemud_client_message *msg, *tmp;
+
+ DEBUG("stream=%p", stream);
+
+ msg = stream->rx;
+ while (msg && !stream->closed) {
+ int ret;
+ switch (msg->hdr.status) {
+ case REMOTE_OK:
+ ret = remoteStreamHandleFinish(client, stream, msg);
+ break;
+
+ case REMOTE_CONTINUE:
+ ret = remoteStreamHandleWriteData(client, stream, msg);
+ break;
+
+ case REMOTE_ERROR:
+ default:
+ ret = remoteStreamHandleAbort(client, stream, msg);
+ break;
+ }
+
+ if (ret == 0)
+ qemudClientMessageQueueServe(&stream->rx);
+ else if (ret < 0)
+ return -1;
+ else
+ break; /* still processing data */
+
+ tmp = msg->next;
+ qemudClientMessageRelease(client, msg);
+ msg = tmp;
+ }
+
+ return 0;
+}
--
1.6.2.5
5:32 a.m.
New subject: [libvirt] [PATCH 04/11] Handle incoming data streams in libvirtd
On Mon, Aug 24, 2009 at 09:51:07PM +0100, Daniel P. Berrange wrote:
* qemud/stream.c: Handle incoming stream data packets, queuing until
stream becomes writable. Handle stream completion handshake
* po/POTFILES.in: Add qemud/stream.c
[...]
+/*
+ * Callback that gets invoked when a stream becomes writable/readable
+ */
+static void
+remoteStreamEvent(virStreamPtr st, int events, void *opaque)
+{
+ struct qemud_client *client = opaque;
+ struct qemud_client_stream *stream;
+
+ /* XXX sub-optimal - we really should be taking the server lock
+ * first, but we have no handle to the server object
+ * We're lucky to get away with it for now, due to this callback
+ * executing in the main thread, but this should really be fixed
+ */
+ virMutexLock(&client->lock);
Shouldn't the stream stucture carry a reference to the
connection/server ?
[...]
static int
-remoteStreamFilter(struct qemud_client *client ATTRIBUTE_UNUSED,
- struct qemud_client_message *msg ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+remoteStreamFilter(struct qemud_client *client,
+ struct qemud_client_message *msg, void *opaque)
{
+ struct qemud_client_stream *stream = opaque;
+
+ if (msg->hdr.serial == stream->serial &&
+ msg->hdr.proc == stream->procedure &&
+ msg->hdr.type == REMOTE_STREAM) {
+ DEBUG("Incoming rx=%p serial=%d proc=%d status=%d",
+ stream->rx, msg->hdr.proc, msg->hdr.serial, msg->hdr.status);
+
+ /* If there are queued packets, we need to queue all further
+ * messages, since they must be processed strictly in order.
+ * If there are no queued packets, then OK/ERROR messages
+ * should be processed immediately. Data packets are still
+ * queued to only be processed when the stream is marked as
+ * writable.
+ */
Since we are already separating different classes of packets, why not
extend this to provide 2-3 classes for the data too: BACKGROUND/NORMAL/URGENT
that can be added later using the current flags for creating a stream.
ACK, though this need much testing, ideally we can automate this in
TCK, especially about Abort effect at various point in time of a
transfer. This is hard to test by the application writer so we should
try to make the API as foolproof as prossible.
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
3:51 p.m.
New subject: [libvirt] [PATCH 05/11] Handle outgoing data streams in libvirtd
* qemud/dispatch.c: Set streamTX flag on outgoing data packets
* qemud/qemud.h: Add streamTX flag to track outgoing data
* qemud/qemud.c: Re-enable further TX when outgoing data packet
has been fully sent.
* qemud/stream.h, qemud/strea.c: Add method for enabling TX.
Support reading from streams and transmitting data out to client
---
qemud/dispatch.c | 2 +
qemud/qemud.c | 4 ++-
qemud/qemud.h | 1 +
qemud/stream.c | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
qemud/stream.h | 4 ++
5 files changed, 106 insertions(+), 1 deletions(-)
diff --git a/qemud/dispatch.c b/qemud/dispatch.c
index 1934d24..7417001 100644
--- a/qemud/dispatch.c
+++ b/qemud/dispatch.c
@@ -636,6 +636,8 @@ remoteSendStreamData(struct qemud_client *client,
DEBUG("Total %d", msg->bufferOffset);
}
+ if (data)
+ msg->streamTX = 1;
/* Reset ready for I/O */
msg->bufferLength = msg->bufferOffset;
diff --git a/qemud/qemud.c b/qemud/qemud.c
index 6c81dec..af71495 100644
--- a/qemud/qemud.c
+++ b/qemud/qemud.c
@@ -1893,7 +1893,9 @@ void
qemudClientMessageRelease(struct qemud_client *client,
struct qemud_client_message *msg)
{
- if (!msg->async)
+ if (msg->streamTX) {
+ remoteStreamMessageFinished(client, msg);
+ } else if (!msg->async)
client->nrequests--;
/* See if the recv queue is currently throttled */
diff --git a/qemud/qemud.h b/qemud/qemud.h
index 8ef5871..911cdc3 100644
--- a/qemud/qemud.h
+++ b/qemud/qemud.h
@@ -130,6 +130,7 @@ struct qemud_client_message {
unsigned int bufferOffset;
unsigned int async : 1;
+ unsigned int streamTX : 1;
remote_message_header hdr;
diff --git a/qemud/stream.c b/qemud/stream.c
index 1fe0e58..584268d 100644
--- a/qemud/stream.c
+++ b/qemud/stream.c
@@ -32,6 +32,9 @@ static int
remoteStreamHandleWrite(struct qemud_client *client,
struct qemud_client_stream *stream);
static int
+remoteStreamHandleRead(struct qemud_client *client,
+ struct qemud_client_stream *stream);
+static int
remoteStreamHandleFinish(struct qemud_client *client,
struct qemud_client_stream *stream,
struct qemud_client_message *msg);
@@ -48,6 +51,8 @@ remoteStreamUpdateEvents(struct qemud_client_stream *stream)
int newEvents = 0;
if (stream->rx)
newEvents |= VIR_STREAM_EVENT_WRITABLE;
+ if (stream->tx && !stream->recvEOF)
+ newEvents |= VIR_STREAM_EVENT_READABLE;
virStreamEventUpdateCallback(stream->st, newEvents);
}
@@ -87,6 +92,16 @@ remoteStreamEvent(virStreamPtr st, int events, void *opaque)
}
}
+ if (!stream->recvEOF &&
+ (events & (VIR_STREAM_EVENT_READABLE | VIR_STREAM_EVENT_HANGUP))) {
+ events = events & ~(VIR_STREAM_EVENT_READABLE | VIR_STREAM_EVENT_HANGUP);
+ if (remoteStreamHandleRead(client, stream) < 0) {
+ remoteRemoveClientStream(client, stream);
+ qemudDispatchClientFailure(client);
+ goto cleanup;
+ }
+ }
+
if (!stream->closed &&
(events & (VIR_STREAM_EVENT_ERROR | VIR_STREAM_EVENT_HANGUP))) {
int ret;
@@ -507,3 +522,84 @@ remoteStreamHandleWrite(struct qemud_client *client,
return 0;
}
+
+
+
+/*
+ * Invoked when a stream is signalled as having data
+ * available to read. This reads upto one message
+ * worth of data, and then queues that for transmission
+ * to the client.
+ *
+ * Returns 0 if data was queued for TX, or a error RPC
+ * was sent, or -1 on fatal error, indicating client should
+ * be killed
+ */
+static int
+remoteStreamHandleRead(struct qemud_client *client,
+ struct qemud_client_stream *stream)
+{
+ char *buffer;
+ size_t bufferLen = REMOTE_MESSAGE_PAYLOAD_MAX;
+ int ret;
+
+ DEBUG("stream=%p", stream);
+
+ /* Shouldn't ever be called unless we're marked able to
+ * transmit, but doesn't hurt to check */
+ if (!stream->tx)
+ return 0;
+
+ if (VIR_ALLOC_N(buffer, bufferLen) < 0)
+ return -1;
+
+ ret = virStreamRecv(stream->st, buffer, bufferLen);
+ if (ret == -2) {
+ /* Should never get this, since we're only called when we know
+ * we're readable, but hey things change... */
+ ret = 0;
+ } else if (ret < 0) {
+ remote_error rerr;
+ memset(&rerr, 0, sizeof rerr);
+ remoteDispatchConnError(&rerr, NULL);
+
+ ret = remoteSerializeStreamError(client, &rerr, stream->procedure,
stream->serial);
+ } else {
+ stream->tx = 0;
+ if (ret == 0)
+ stream->recvEOF = 1;
+ ret = remoteSendStreamData(client, stream, buffer, ret);
+ }
+
+ VIR_FREE(buffer);
+ return ret;
+}
+
+
+/*
+ * Invoked when an outgoing data packet message has been fully sent.
+ * This simply re-enables TX of further data.
+ *
+ * The idea is to stop the daemon growing without bound due to
+ * fast stream, but slow client
+ */
+void
+remoteStreamMessageFinished(struct qemud_client *client,
+ struct qemud_client_message *msg)
+{
+ struct qemud_client_stream *stream = client->streams;
+
+ while (stream) {
+ if (msg->hdr.proc == stream->procedure &&
+ msg->hdr.serial == stream->serial)
+ break;
+ stream = stream->next;
+ }
+
+ DEBUG("Message client=%p stream=%p proc=%d serial=%d", client, stream,
msg->hdr.proc, msg->hdr.serial);
+
+ if (stream) {
+ stream->tx = 1;
+ remoteStreamUpdateEvents(stream);
+ }
+}
diff --git a/qemud/stream.h b/qemud/stream.h
index fe5ce6f..de738ba 100644
--- a/qemud/stream.h
+++ b/qemud/stream.h
@@ -46,4 +46,8 @@ int
remoteRemoveClientStream(struct qemud_client *client,
struct qemud_client_stream *stream);
+void
+remoteStreamMessageFinished(struct qemud_client *client,
+ struct qemud_client_message *msg);
+
#endif /* __LIBVIRTD_STREAM_H__ */
--
1.6.2.5
3:51 p.m.
New subject: [libvirt] [PATCH 06/11] Handle data streams in remote client
* src/remote_internal.c: Add helper APIs for processing data streams
---
src/remote_internal.c | 530 ++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 524 insertions(+), 6 deletions(-)
diff --git a/src/remote_internal.c b/src/remote_internal.c
index de3c288..12e3bb9 100644
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -1,4 +1,3 @@
-
/*
* remote_internal.c: driver to provide access to libvirtd running
* on a remote machine
@@ -111,7 +110,8 @@ enum {
struct remote_thread_call {
int mode;
- /* 4 byte length, followed by RPC message header+body */
+ /* Buffer for outgoing data packet
+ * 4 byte length, followed by RPC message header+body */
char buffer[4 + REMOTE_MESSAGE_MAX];
unsigned int bufferLength;
unsigned int bufferOffset;
@@ -121,6 +121,7 @@ struct remote_thread_call {
virCond cond;
+ int want_reply;
xdrproc_t ret_filter;
char *ret;
@@ -129,6 +130,26 @@ struct remote_thread_call {
struct remote_thread_call *next;
};
+struct private_stream_data {
+ unsigned int has_error : 1;
+ remote_error err;
+
+ unsigned int serial;
+ unsigned int proc_nr;
+
+ /* XXX this is potentially unbounded if the client
+ * app has domain events registered, since packets
+ * may be read off wire, while app isn't ready to
+ * recv them. Figure out how to address this some
+ * time....
+ */
+ char *incoming;
+ unsigned int incomingOffset;
+ unsigned int incomingLength;
+
+ struct private_stream_data *next;
+};
+
struct private_data {
virMutex lock;
@@ -155,7 +176,8 @@ struct private_data {
unsigned int saslEncodedOffset;
#endif
- /* 4 byte length, followed by RPC message header+body */
+ /* Buffer for incoming data packets
+ * 4 byte length, followed by RPC message header+body */
char buffer[4 + REMOTE_MESSAGE_MAX];
unsigned int bufferLength;
unsigned int bufferOffset;
@@ -176,6 +198,8 @@ struct private_data {
/* List of threads currently waiting for dispatch */
struct remote_thread_call *waitDispatch;
+
+ struct private_stream_data *streams;
};
enum {
@@ -194,6 +218,10 @@ static void remoteDriverUnlock(struct private_data *driver)
virMutexUnlock(&driver->lock);
}
+static int remoteIO(virConnectPtr conn,
+ struct private_data *priv,
+ int flags,
+ struct remote_thread_call *thiscall);
static int call (virConnectPtr conn, struct private_data *priv,
int flags, int proc_nr,
xdrproc_t args_filter, char *args,
@@ -6319,6 +6347,361 @@ done:
return rv;
}
+
+#if 0
+static struct private_stream_data *
+remoteStreamOpen(virStreamPtr st,
+ int output ATTRIBUTE_UNUSED,
+ unsigned int proc_nr,
+ unsigned int serial)
+{
+ struct private_data *priv = st->conn->privateData;
+ struct private_stream_data *stpriv;
+
+ if (VIR_ALLOC(stpriv) < 0)
+ return NULL;
+
+ /* Initialize call object used to receive replies */
+ stpriv->proc_nr = proc_nr;
+ stpriv->serial = serial;
+
+ stpriv->next = priv->streams;
+ priv->streams = stpriv;
+
+ return stpriv;
+}
+
+
+static int
+remoteStreamPacket(virStreamPtr st,
+ int status,
+ const char *data,
+ size_t nbytes)
+{
+ DEBUG("st=%p status=%d data=%p nbytes=%d", st, status, data, nbytes);
+ struct private_data *priv = st->conn->privateData;
+ struct private_stream_data *privst = st->privateData;
+ XDR xdr;
+ struct remote_thread_call *thiscall;
+ remote_message_header hdr;
+
+ memset(&hdr, 0, sizeof hdr);
+
+ if (VIR_ALLOC(thiscall) < 0) {
+ virReportOOMError(st->conn);
+ return -1;
+ }
+
+ thiscall->mode = REMOTE_MODE_WAIT_TX;
+ thiscall->serial = privst->serial;
+ thiscall->proc_nr = privst->proc_nr;
+ if (status == REMOTE_OK ||
+ status == REMOTE_ERROR)
+ thiscall->want_reply = 1;
+
+ if (virCondInit(&thiscall->cond) < 0) {
+ VIR_FREE(thiscall);
+ error (st->conn, VIR_ERR_INTERNAL_ERROR,
+ _("cannot initialize mutex"));
+ return -1;
+ }
+
+ /* Don't fill in any other fields in 'thiscall' since
+ * we're not expecting a reply for this */
+
+ hdr.prog = REMOTE_PROGRAM;
+ hdr.vers = REMOTE_PROTOCOL_VERSION;
+ hdr.proc = privst->proc_nr;
+ hdr.type = REMOTE_STREAM;
+ hdr.serial = privst->serial;
+ hdr.status = status;
+
+
+ /* Length must include the length word itself (always encoded in
+ * 4 bytes as per RFC 4506), so offset start length. We write this
+ * later.
+ */
+ thiscall->bufferLength = REMOTE_MESSAGE_HEADER_XDR_LEN;
+
+ /* Serialise header followed by args. */
+ xdrmem_create (&xdr, thiscall->buffer + thiscall->bufferLength,
+ REMOTE_MESSAGE_MAX, XDR_ENCODE);
+ if (!xdr_remote_message_header (&xdr, &hdr)) {
+ error (st->conn,
+ VIR_ERR_RPC, _("xdr_remote_message_header failed"));
+ goto error;
+ }
+
+ thiscall->bufferLength += xdr_getpos (&xdr);
+ xdr_destroy (&xdr);
+
+ if (status == REMOTE_CONTINUE) {
+ if (((4 + REMOTE_MESSAGE_MAX) - thiscall->bufferLength) < nbytes) {
+ errorf(st->conn,
+ VIR_ERR_RPC, _("data size %d too large for payload %d"),
+ nbytes, ((4 + REMOTE_MESSAGE_MAX) - thiscall->bufferLength));
+ goto error;
+ }
+
+ memcpy(thiscall->buffer + thiscall->bufferLength, data, nbytes);
+ thiscall->bufferLength += nbytes;
+ }
+
+ /* Go back to packet start and encode the length word. */
+ xdrmem_create (&xdr, thiscall->buffer, REMOTE_MESSAGE_HEADER_XDR_LEN,
XDR_ENCODE);
+ if (!xdr_u_int (&xdr, &thiscall->bufferLength)) {
+ error(st->conn, VIR_ERR_RPC,
+ _("xdr_u_int (length word)"));
+ goto error;
+ }
+ xdr_destroy (&xdr);
+
+ /* remoteIO frees 'thiscall' for us (XXX that's dubious semantics) */
+ if (remoteIO(st->conn, priv, 0, thiscall) < 0)
+ return -1;
+
+ return nbytes;
+
+error:
+ xdr_destroy (&xdr);
+ VIR_FREE(thiscall);
+ return -1;
+}
+
+static int
+remoteStreamHasError(virStreamPtr st) {
+ struct private_stream_data *privst = st->privateData;
+ if (!privst->has_error) {
+ return 0;
+ }
+
+ VIR_WARN0("Raising async error");
+ virRaiseErrorFull(st->conn,
+ __FILE__, __FUNCTION__, __LINE__,
+ privst->err.domain,
+ privst->err.code,
+ privst->err.level,
+ privst->err.str1 ? *privst->err.str1 : NULL,
+ privst->err.str2 ? *privst->err.str2 : NULL,
+ privst->err.str3 ? *privst->err.str3 : NULL,
+ privst->err.int1,
+ privst->err.int2,
+ "%s", privst->err.message ? *privst->err.message :
NULL);
+
+ return 1;
+}
+
+static void
+remoteStreamRelease(virStreamPtr st)
+{
+ struct private_data *priv = st->conn->privateData;
+ struct private_stream_data *privst = st->privateData;
+
+ if (priv->streams == privst)
+ priv->streams = privst->next;
+ else {
+ struct private_stream_data *tmp = priv->streams;
+ while (tmp && tmp->next) {
+ if (tmp->next == privst) {
+ tmp->next = privst->next;
+ break;
+ }
+ }
+ }
+
+ if (privst->has_error)
+ xdr_free((xdrproc_t)xdr_remote_error, (char *)&privst->err);
+
+ VIR_FREE(privst);
+
+ st->driver = NULL;
+ st->privateData = NULL;
+}
+
+
+static int
+remoteStreamSend(virStreamPtr st,
+ const char *data,
+ size_t nbytes)
+{
+ DEBUG("st=%p data=%p nbytes=%d", st, data, nbytes);
+ struct private_data *priv = st->conn->privateData;
+ int rv = -1;
+
+ remoteDriverLock(priv);
+
+ if (remoteStreamHasError(st))
+ goto cleanup;
+
+ rv = remoteStreamPacket(st,
+ REMOTE_CONTINUE,
+ data,
+ nbytes);
+
+cleanup:
+ if (rv == -1)
+ remoteStreamRelease(st);
+
+ remoteDriverUnlock(priv);
+
+ return rv;
+}
+
+
+static int
+remoteStreamRecv(virStreamPtr st,
+ char *data,
+ size_t nbytes)
+{
+ DEBUG("st=%p data=%p nbytes=%d", st, data, nbytes);
+ struct private_data *priv = st->conn->privateData;
+ struct private_stream_data *privst = st->privateData;
+ int rv = -1;
+
+ remoteDriverLock(priv);
+
+ if (remoteStreamHasError(st))
+ goto cleanup;
+
+ if (!privst->incomingOffset) {
+ struct remote_thread_call *thiscall;
+
+ if (VIR_ALLOC(thiscall) < 0) {
+ virReportOOMError(st->conn);
+ goto cleanup;
+ }
+
+ /* We're not really doing an RPC calls, so we're
+ * skipping straight to RX part */
+ thiscall->mode = REMOTE_MODE_WAIT_RX;
+ thiscall->serial = privst->serial;
+ thiscall->proc_nr = privst->proc_nr;
+ thiscall->want_reply = 1;
+
+ if (virCondInit(&thiscall->cond) < 0) {
+ VIR_FREE(thiscall);
+ error (st->conn, VIR_ERR_INTERNAL_ERROR,
+ _("cannot initialize mutex"));
+ goto cleanup;
+ }
+
+ /* remoteIO frees 'thiscall' for us (XXX that's dubious semantics)
*/
+ if (remoteIO(st->conn, priv, 0, thiscall) < 0)
+ goto cleanup;
+ }
+
+ DEBUG("After IO %d", privst->incomingOffset);
+ if (privst->incomingOffset) {
+ int want = privst->incomingOffset;
+ if (want > nbytes)
+ want = nbytes;
+ memcpy(data, privst->incoming, want);
+ if (want < privst->incomingOffset) {
+ memmove(privst->incoming, privst->incoming + want,
privst->incomingOffset - want);
+ privst->incomingOffset -= want;
+ } else {
+ VIR_FREE(privst->incoming);
+ privst->incomingOffset = privst->incomingLength = 0;
+ }
+ rv = want;
+ } else {
+ rv = 0;
+ }
+
+ DEBUG("Done %d", rv);
+
+cleanup:
+ if (rv == -1)
+ remoteStreamRelease(st);
+ remoteDriverUnlock(priv);
+
+ return rv;
+}
+
+static int
+remoteStreamEventAddCallback(virStreamPtr stream ATTRIBUTE_UNUSED,
+ int events ATTRIBUTE_UNUSED,
+ virStreamEventCallback cb ATTRIBUTE_UNUSED,
+ void *opaque ATTRIBUTE_UNUSED,
+ virFreeCallback ff ATTRIBUTE_UNUSED)
+{
+ return -1;
+}
+
+static int
+remoteStreamEventUpdateCallback(virStreamPtr stream ATTRIBUTE_UNUSED,
+ int events ATTRIBUTE_UNUSED)
+{
+ return -1;
+}
+
+
+static int
+remoteStreamEventRemoveCallback(virStreamPtr stream ATTRIBUTE_UNUSED)
+{
+ return -1;
+}
+
+static int
+remoteStreamFinish(virStreamPtr st)
+{
+ struct private_data *priv = st->conn->privateData;
+ int ret = -1;
+
+ remoteDriverLock(priv);
+
+ if (remoteStreamHasError(st))
+ goto cleanup;
+
+ ret = remoteStreamPacket(st,
+ REMOTE_OK,
+ NULL,
+ 0);
+
+cleanup:
+ remoteStreamRelease(st);
+
+ remoteDriverUnlock(priv);
+ return ret;
+}
+
+static int
+remoteStreamAbort(virStreamPtr st)
+{
+ struct private_data *priv = st->conn->privateData;
+ int ret = -1;
+
+ remoteDriverLock(priv);
+
+ if (remoteStreamHasError(st))
+ goto cleanup;
+
+ ret = remoteStreamPacket(st,
+ REMOTE_ERROR,
+ NULL,
+ 0);
+
+cleanup:
+ remoteStreamRelease(st);
+
+ remoteDriverUnlock(priv);
+ return ret;
+}
+
+
+
+static virStreamDriver remoteStreamDrv = {
+ .streamRecv = remoteStreamRecv,
+ .streamSend = remoteStreamSend,
+ .streamFinish = remoteStreamFinish,
+ .streamAbort = remoteStreamAbort,
+ .streamAddCallback = remoteStreamEventAddCallback,
+ .streamUpdateCallback = remoteStreamEventUpdateCallback,
+ .streamRemoveCallback = remoteStreamEventRemoveCallback,
+};
+#endif
+
+
/*----------------------------------------------------------------------*/
@@ -6350,6 +6733,7 @@ prepareCall(virConnectPtr conn,
rv->proc_nr = proc_nr;
rv->ret_filter = ret_filter;
rv->ret = ret;
+ rv->want_reply = 1;
hdr.prog = REMOTE_PROGRAM;
hdr.vers = REMOTE_PROTOCOL_VERSION;
@@ -6535,7 +6919,10 @@ remoteIOWriteMessage(virConnectPtr conn,
if (priv->saslEncodedOffset == priv->saslEncodedLength) {
priv->saslEncoded = NULL;
priv->saslEncodedOffset = priv->saslEncodedLength = 0;
- thecall->mode = REMOTE_MODE_WAIT_RX;
+ if (thecall->want_reply)
+ thecall->mode = REMOTE_MODE_WAIT_RX;
+ else
+ thecall->mode = REMOTE_MODE_COMPLETE;
}
} else {
#endif
@@ -6549,7 +6936,10 @@ remoteIOWriteMessage(virConnectPtr conn,
if (thecall->bufferOffset == thecall->bufferLength) {
thecall->bufferOffset = thecall->bufferLength = 0;
- thecall->mode = REMOTE_MODE_WAIT_RX;
+ if (thecall->want_reply)
+ thecall->mode = REMOTE_MODE_WAIT_RX;
+ else
+ thecall->mode = REMOTE_MODE_COMPLETE;
}
#if HAVE_SASL
}
@@ -6703,6 +7093,12 @@ processCallDispatchMessage(virConnectPtr conn, struct private_data
*priv,
remote_message_header *hdr,
XDR *xdr);
+static int
+processCallDispatchStream(virConnectPtr conn, struct private_data *priv,
+ int in_open,
+ remote_message_header *hdr,
+ XDR *xdr);
+
static int
processCallDispatch(virConnectPtr conn, struct private_data *priv,
@@ -6712,14 +7108,19 @@ processCallDispatch(virConnectPtr conn, struct private_data
*priv,
int len = priv->bufferLength - 4;
int rv = -1;
+ /* Length word has already been read */
+ priv->bufferOffset = 4;
+
/* Deserialise reply header. */
- xdrmem_create (&xdr, priv->buffer + 4, len, XDR_DECODE);
+ xdrmem_create (&xdr, priv->buffer + priv->bufferOffset, len, XDR_DECODE);
if (!xdr_remote_message_header (&xdr, &hdr)) {
error (in_open ? NULL : conn,
VIR_ERR_RPC, _("invalid header in reply"));
return -1;
}
+ priv->bufferOffset += xdr_getpos(&xdr);
+
/* Check program, version, etc. are what we expect. */
if (hdr.prog != REMOTE_PROGRAM) {
virRaiseError (in_open ? NULL : conn,
@@ -6738,6 +7139,7 @@ processCallDispatch(virConnectPtr conn, struct private_data *priv,
return -1;
}
+
switch (hdr.type) {
case REMOTE_REPLY: /* Normal RPC replies */
rv = processCallDispatchReply(conn, priv, in_open,
@@ -6749,6 +7151,11 @@ processCallDispatch(virConnectPtr conn, struct private_data *priv,
&hdr, &xdr);
break;
+ case REMOTE_STREAM: /* Stream protocol */
+ rv = processCallDispatchStream(conn, priv, in_open,
+ &hdr, &xdr);
+ break;
+
default:
virRaiseError (in_open ? NULL : conn,
NULL, NULL, VIR_FROM_REMOTE,
@@ -6811,6 +7218,7 @@ processCallDispatchReply(virConnectPtr conn, struct private_data
*priv,
return 0;
case REMOTE_ERROR:
+ VIR_WARN0("Method call error");
memset (&thecall->err, 0, sizeof thecall->err);
if (!xdr_remote_error (xdr, &thecall->err)) {
error (in_open ? NULL : conn,
@@ -6854,6 +7262,113 @@ processCallDispatchMessage(virConnectPtr conn, struct private_data
*priv,
return 0;
}
+static int
+processCallDispatchStream(virConnectPtr conn ATTRIBUTE_UNUSED,
+ struct private_data *priv,
+ int in_open ATTRIBUTE_UNUSED,
+ remote_message_header *hdr,
+ XDR *xdr) {
+ struct private_stream_data *privst;
+ struct remote_thread_call *thecall;
+
+ /* Try and find a matching stream */
+ privst = priv->streams;
+ while (privst &&
+ privst->serial != hdr->serial &&
+ privst->proc_nr != hdr->proc)
+ privst = privst->next;
+
+ if (!privst) {
+ VIR_WARN("No registered stream matching serial=%d, proc=%d",
+ hdr->serial, hdr->proc);
+ return -1;
+ }
+
+ /* See if there's also a (optional) call waiting for this reply */
+ thecall = priv->waitDispatch;
+ while (thecall &&
+ thecall->serial != hdr->serial)
+ thecall = thecall->next;
+
+
+ /* Status is either REMOTE_OK (meaning that what follows is a ret
+ * structure), or REMOTE_ERROR (and what follows is a remote_error
+ * structure).
+ */
+ switch (hdr->status) {
+ case REMOTE_CONTINUE: {
+ int avail = privst->incomingLength - privst->incomingOffset;
+ int need = priv->bufferLength - priv->bufferOffset;
+ VIR_WARN0("Got a stream data packet");
+
+ /* XXX flag stream as complete somwhere if need==0 */
+
+ if (need > avail) {
+ int extra = need - avail;
+ if (VIR_REALLOC_N(privst->incoming,
+ privst->incomingLength + extra) < 0) {
+ VIR_WARN0("Out of memory");
+ return -1;
+ }
+ privst->incomingLength += extra;
+ }
+
+ memcpy(privst->incoming + privst->incomingOffset,
+ priv->buffer + priv->bufferOffset,
+ priv->bufferLength - priv->bufferOffset);
+ privst->incomingOffset += (priv->bufferLength - priv->bufferOffset);
+
+ if (thecall && thecall->want_reply) {
+ VIR_WARN("Got sync data packet offset=%d",
privst->incomingOffset);
+ thecall->mode = REMOTE_MODE_COMPLETE;
+ } else {
+ VIR_WARN("Got aysnc data packet offset=%d",
privst->incomingOffset);
+ }
+ return 0;
+ }
+
+ case REMOTE_OK:
+ VIR_WARN0("Got a synchronous confirm");
+ if (!thecall) {
+ VIR_WARN0("Got unexpected stream finish confirmation");
+ return -1;
+ }
+ thecall->mode = REMOTE_MODE_COMPLETE;
+ return 0;
+
+ case REMOTE_ERROR:
+ if (thecall && thecall->want_reply) {
+ VIR_WARN0("Got a synchronous error");
+ /* Give the error straight to this call */
+ memset (&thecall->err, 0, sizeof thecall->err);
+ if (!xdr_remote_error (xdr, &thecall->err)) {
+ error (in_open ? NULL : conn,
+ VIR_ERR_RPC, _("unmarshalling remote_error"));
+ return -1;
+ }
+ thecall->mode = REMOTE_MODE_ERROR;
+ } else {
+ VIR_WARN0("Got a asynchronous error");
+ /* No call, so queue the error against the stream */
+ if (privst->has_error) {
+ VIR_WARN0("Got unexpected duplicate stream error");
+ return -1;
+ }
+ privst->has_error = 1;
+ memset (&privst->err, 0, sizeof privst->err);
+ if (!xdr_remote_error (xdr, &privst->err)) {
+ VIR_WARN0("Failed to unmarshall error");
+ return -1;
+ }
+ }
+ return 0;
+
+ default:
+ VIR_WARN("Stream with unexpected serial=%d, proc=%d, status=%d",
+ hdr->serial, hdr->proc, hdr->status);
+ return -1;
+ }
+}
static int
remoteIOHandleInput(virConnectPtr conn, struct private_data *priv,
@@ -6934,6 +7449,9 @@ remoteIOEventLoop(virConnectPtr conn,
tmp = tmp->next;
}
+ if (priv->streams)
+ fds[0].events |= POLLIN;
+
/* Release lock while poll'ing so other threads
* can stuff themselves on the queue */
remoteDriverUnlock(priv);
--
1.6.2.5
3:51 p.m.
New subject: [libvirt] [PATCH 07/11] DEMO: Add public API for file upload & download to demo streams
* include/libvirt/libvirt.h.in: Add virConnectPutFile and
virConnectGetFile APis to demo streams
* src/driver.h, src/libvirt.c, src/libvirt_public.syms: Stub
code for get/putfile APIs
* src/esx/esx_driver.c, src/lxc_driver.c, src/opennebula/one_driver.c,
src/openvz_driver.c, src/qemu_driver.c, src/remote_internal.c,
src/test.c, src/uml_driver.c, src/vbox/vbox_tmpl.c,
src/xen_unified.c: Add dummy entries in driver table for new
APIs
---
include/libvirt/libvirt.h | 8 ++++
include/libvirt/libvirt.h.in | 8 ++++
src/driver.h | 6 +++
src/esx/esx_driver.c | 2 +
src/libvirt.c | 86 ++++++++++++++++++++++++++++++++++++++++++
src/libvirt_public.syms | 3 +
src/lxc_driver.c | 2 +
src/opennebula/one_driver.c | 2 +
src/openvz_driver.c | 2 +
src/qemu_driver.c | 2 +
src/remote_internal.c | 2 +
src/test.c | 2 +
src/uml_driver.c | 2 +
src/vbox/vbox_tmpl.c | 3 +-
src/xen_unified.c | 2 +
15 files changed, 131 insertions(+), 1 deletions(-)
diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index 5dcecfd..a654a05 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -1540,6 +1540,14 @@ int virStreamAbort(virStreamPtr st);
int virStreamFree(virStreamPtr st);
+int virConnectPutFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st);
+
+int virConnectGetFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st);
+
#ifdef __cplusplus
}
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index db091dc..d6c52dc 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -1540,6 +1540,14 @@ int virStreamAbort(virStreamPtr st);
int virStreamFree(virStreamPtr st);
+int virConnectPutFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st);
+
+int virConnectGetFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st);
+
#ifdef __cplusplus
}
diff --git a/src/driver.h b/src/driver.h
index 25d34b6..bc862a8 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -344,6 +344,10 @@ typedef int
(*virDrvNodeDeviceReset)
(virNodeDevicePtr dev);
+
+typedef int (*virDrvPutFile)(virConnectPtr conn, const char *name, virStreamPtr st);
+typedef int (*virDrvGetFile)(virConnectPtr conn, const char *name, virStreamPtr st);
+
/**
* _virDriver:
*
@@ -424,6 +428,8 @@ struct _virDriver {
virDrvNodeDeviceDettach nodeDeviceDettach;
virDrvNodeDeviceReAttach nodeDeviceReAttach;
virDrvNodeDeviceReset nodeDeviceReset;
+ virDrvPutFile putFile;
+ virDrvGetFile getFile;
};
typedef int
diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c
index 0225e9a..d094ac1 100644
--- a/src/esx/esx_driver.c
+++ b/src/esx/esx_driver.c
@@ -2941,6 +2941,8 @@ static virDriver esxDriver = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
+ NULL,
+ NULL
};
diff --git a/src/libvirt.c b/src/libvirt.c
index d6536f4..f460876 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -9309,3 +9309,89 @@ int virStreamFree(virStreamPtr stream)
return (-1);
return (0);
}
+
+
+int virConnectPutFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st)
+{
+ VIR_DEBUG("conn=%p, name=%s, stream=%p", conn, NULLSTR(name), st);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return -1;
+ }
+
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibConnError(conn, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (name == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+ if (conn != st->conn) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->driver->putFile) {
+ int rv = conn->driver->putFile(conn, name, st);
+ if (rv < 0)
+ goto error;
+ return rv;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return -1;
+}
+
+
+int virConnectGetFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st)
+{
+ VIR_DEBUG("conn=%p, name=%s, stream=%p", conn, NULLSTR(name), st);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return -1;
+ }
+
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibConnError(conn, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (name == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+ if (conn != st->conn) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->driver->getFile) {
+ int rv = conn->driver->getFile(conn, name, st);
+ if (rv < 0)
+ goto error;
+ return rv;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return -1;
+}
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index f48b8c5..d06c0a4 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -304,6 +304,9 @@ LIBVIRT_0.7.1 {
virStreamFinish;
virStreamAbort;
virStreamFree;
+ virConnectPutFile;
+ virConnectGetFile;
} LIBVIRT_0.7.0;
+
# .... define new API here using predicted next version number ....
diff --git a/src/lxc_driver.c b/src/lxc_driver.c
index bd0cf0e..b9bf1e4 100644
--- a/src/lxc_driver.c
+++ b/src/lxc_driver.c
@@ -1931,6 +1931,8 @@ static virDriver lxcDriver = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
static virStateDriver lxcStateDriver = {
diff --git a/src/opennebula/one_driver.c b/src/opennebula/one_driver.c
index 135397c..184720b 100644
--- a/src/opennebula/one_driver.c
+++ b/src/opennebula/one_driver.c
@@ -779,6 +779,8 @@ static virDriver oneDriver = {
NULL, /* nodeDeviceDettach; */
NULL, /* nodeDeviceReAttach; */
NULL, /* nodeDeviceReset; */
+ NULL,
+ NULL
};
static virStateDriver oneStateDriver = {
diff --git a/src/openvz_driver.c b/src/openvz_driver.c
index 6b7c49d..fdc3a6e 100644
--- a/src/openvz_driver.c
+++ b/src/openvz_driver.c
@@ -1392,6 +1392,8 @@ static virDriver openvzDriver = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
int openvzRegister(void) {
diff --git a/src/qemu_driver.c b/src/qemu_driver.c
index eb22940..81485b5 100644
--- a/src/qemu_driver.c
+++ b/src/qemu_driver.c
@@ -7261,6 +7261,8 @@ static virDriver qemuDriver = {
qemudNodeDeviceDettach, /* nodeDeviceDettach */
qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
qemudNodeDeviceReset, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
diff --git a/src/remote_internal.c b/src/remote_internal.c
index 12e3bb9..c8ea1a3 100644
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -8047,6 +8047,8 @@ static virDriver remote_driver = {
remoteNodeDeviceDettach, /* nodeDeviceDettach */
remoteNodeDeviceReAttach, /* nodeDeviceReAttach */
remoteNodeDeviceReset, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
static virNetworkDriver network_driver = {
diff --git a/src/test.c b/src/test.c
index 305f2c9..cda7be7 100644
--- a/src/test.c
+++ b/src/test.c
@@ -4242,6 +4242,8 @@ static virDriver testDriver = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
static virNetworkDriver testNetworkDriver = {
diff --git a/src/uml_driver.c b/src/uml_driver.c
index dc1e8ef..53e7e10 100644
--- a/src/uml_driver.c
+++ b/src/uml_driver.c
@@ -1853,6 +1853,8 @@ static virDriver umlDriver = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index d3158ef..5a3079e 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -5621,7 +5621,8 @@ virDriver NAME(Driver) = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
-
+ NULL,
+ NULL,
};
virNetworkDriver NAME(NetworkDriver) = {
diff --git a/src/xen_unified.c b/src/xen_unified.c
index dfa9ca5..ac52ce9 100644
--- a/src/xen_unified.c
+++ b/src/xen_unified.c
@@ -1722,6 +1722,8 @@ static virDriver xenUnifiedDriver = {
xenUnifiedNodeDeviceDettach, /* nodeDeviceDettach */
xenUnifiedNodeDeviceReAttach, /* nodeDeviceReAttach */
xenUnifiedNodeDeviceReset, /* nodeDeviceReset */
+ NULL,
+ NULL,
};
/**
--
1.6.2.5
3:51 p.m.
New subject: [libvirt] [PATCH 08/11] DEMO: Add file put / get commands to virsh as a stream demo
* src/virsh.c: Implement 'put' and 'get' commands
* .x-sc_avoid_write: Ignore src/virsh.c
---
.x-sc_avoid_write | 1 +
src/virsh.c | 164 +++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 165 insertions(+), 0 deletions(-)
diff --git a/.x-sc_avoid_write b/.x-sc_avoid_write
index c5a7535..c37574d 100644
--- a/.x-sc_avoid_write
+++ b/.x-sc_avoid_write
@@ -2,5 +2,6 @@
^src/xend_internal\.c$
^src/util-lib\.c$
^src/libvirt\.c$
+^src/virsh\.c$
^qemud/qemud.c$
^gnulib/
diff --git a/src/virsh.c b/src/virsh.c
index 2d0cf81..6387a3c 100644
--- a/src/virsh.c
+++ b/src/virsh.c
@@ -6780,6 +6780,167 @@ cmdEdit (vshControl *ctl, const vshCmd *cmd)
}
/*
+ * "put" command
+ */
+static const vshCmdInfo info_put[] = {
+ {"help", gettext_noop("upload a file")},
+ {"desc", gettext_noop("Upload a file")},
+ {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_put[] = {
+ {"file", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("file")},
+ {"name", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("name")},
+ {NULL, 0, 0, NULL}
+};
+
+
+static int
+cmdPutSource(virStreamPtr st ATTRIBUTE_UNUSED,
+ char *bytes, size_t nbytes, void *opaque)
+{
+ int *fd = opaque;
+
+ return read(*fd, bytes, nbytes);
+}
+
+/*
+ */
+static int
+cmdPut (vshControl *ctl, const vshCmd *cmd)
+{
+ char *file = NULL;
+ char *name = NULL;
+ int ret = FALSE;
+ int fd = -1;
+ virStreamPtr st = NULL;
+
+ if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
+ goto cleanup;
+
+ name = vshCommandOptString (cmd, "name", NULL);
+ if (name == NULL)
+ goto cleanup;
+ file = vshCommandOptString (cmd, "file", NULL);
+ if (file == NULL)
+ goto cleanup;
+
+ if ((fd = open(file, O_RDONLY)) < 0) {
+ vshError(ctl, FALSE, "cannot read %s", name);
+ goto cleanup;
+ }
+
+ st = virStreamNew(ctl->conn, 0);
+ if (virConnectPutFile(ctl->conn, name, st) < 0)
+ goto cleanup;
+
+ if (virStreamSendAll(st, cmdPutSource, &fd) < 0)
+ goto cleanup;
+
+ if (close(fd) < 0) {
+ virStreamAbort(st);
+ goto cleanup;
+ }
+ fd = -1;
+ if (virStreamFinish(st) < 0)
+ goto cleanup;
+
+ ret = TRUE;
+
+cleanup:
+ if (st)
+ virStreamFree(st);
+ free(name);
+ free(file);
+ if (fd != -1)
+ close(fd);
+ return ret;
+}
+
+
+
+/*
+ * "get" command
+ */
+static const vshCmdInfo info_get[] = {
+ {"help", gettext_noop("upload a file")},
+ {"desc", gettext_noop("Upload a file")},
+ {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_get[] = {
+ {"file", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("file")},
+ {"name", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("name")},
+ {NULL, 0, 0, NULL}
+};
+
+
+static int
+cmdGetSink(virStreamPtr st ATTRIBUTE_UNUSED,
+ const char *bytes, size_t nbytes, void *opaque)
+{
+ int *fd = opaque;
+
+ return write(*fd, bytes, nbytes);
+}
+
+/*
+ */
+static int
+cmdGet (vshControl *ctl, const vshCmd *cmd)
+{
+ char *file = NULL;
+ char *name = NULL;
+ int ret = FALSE;
+ int fd = -1;
+ virStreamPtr st = NULL;
+
+ if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
+ goto cleanup;
+
+ name = vshCommandOptString (cmd, "name", NULL);
+ if (name == NULL)
+ goto cleanup;
+ file = vshCommandOptString (cmd, "file", NULL);
+ if (file == NULL)
+ goto cleanup;
+
+ if ((fd = open(file, O_WRONLY|O_TRUNC|O_CREAT,0700)) < 0) {
+ vshError(ctl, FALSE, "cannot create %s", name);
+ goto cleanup;
+ }
+
+ st = virStreamNew(ctl->conn, 0);
+ if (virConnectGetFile(ctl->conn, name, st) < 0)
+ goto cleanup;
+
+ if (virStreamRecvAll(st, cmdGetSink, &fd) < 0)
+ goto cleanup;
+
+ if (close(fd) < 0) {
+ virStreamAbort(st);
+ goto cleanup;
+ }
+ fd = -1;
+ if (virStreamFinish(st) < 0)
+ goto cleanup;
+
+ ret = TRUE;
+
+cleanup:
+ if (ret == FALSE)
+ unlink(file);
+ if (st)
+ virStreamFree(st);
+ free(name);
+ free(file);
+ if (fd != -1)
+ close(fd);
+ return ret;
+}
+
+
+/*
* "net-edit" command
*/
static const vshCmdInfo info_network_edit[] = {
@@ -6958,6 +7119,9 @@ static const vshCmdDef commands[] = {
{"vcpupin", cmdVcpupin, opts_vcpupin, info_vcpupin},
{"version", cmdVersion, NULL, info_version},
{"vncdisplay", cmdVNCDisplay, opts_vncdisplay, info_vncdisplay},
+
+ {"put", cmdPut, opts_put, info_put},
+ {"get", cmdGet, opts_get, info_get},
{NULL, NULL, NULL, NULL}
};
--
1.6.2.5
3:51 p.m.
New subject: [libvirt] [PATCH 09/11] DEMO: Implement get/put for test driver
* src/test.c: Implement get/put APIs
* .x-sc_avoid_write: ignore src/test.c
---
.x-sc_avoid_write | 1 +
src/test.c | 479 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 478 insertions(+), 2 deletions(-)
diff --git a/.x-sc_avoid_write b/.x-sc_avoid_write
index c37574d..201a064 100644
--- a/.x-sc_avoid_write
+++ b/.x-sc_avoid_write
@@ -2,6 +2,7 @@
^src/xend_internal\.c$
^src/util-lib\.c$
^src/libvirt\.c$
+^src/test\.c$
^src/virsh\.c$
^qemud/qemud.c$
^gnulib/
diff --git a/src/test.c b/src/test.c
index cda7be7..3a4731e 100644
--- a/src/test.c
+++ b/src/test.c
@@ -30,6 +30,9 @@
#include <unistd.h>
#include <sys/stat.h>
#include <libxml/xmlsave.h>
+#if HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
#include "virterror_internal.h"
@@ -4174,6 +4177,478 @@ static void testDomainEventQueue(testConnPtr driver,
}
+struct testStreamFile {
+ int pid;
+ int fd;
+ char *filename;
+ int watch;
+ unsigned int create : 1;
+ unsigned int dispatching : 1;
+ unsigned int cbRemoved : 1;
+ virStreamEventCallback cb;
+ void *opaque;
+ virFreeCallback ff;
+};
+typedef struct testStreamFile *testStreamFilePtr;
+
+
+static int testStreamFileFree(testStreamFilePtr fs,
+ int aborting)
+{
+ int ret = 0;
+ int saved = 0;
+ int childstat = 0;
+
+ if (!fs)
+ return 0;
+
+ if (fs->fd != -1) {
+ if (close(fs->fd) != 0 && !aborting) {
+ saved = errno;
+ ret = -1;
+ }
+ }
+ /* Wait for intermediate process to exit */
+ while (waitpid(fs->pid, &childstat, 0) == -1 &&
+ errno == EINTR);
+
+ if (childstat != 0) {
+ saved = EIO;
+ ret = -1;
+ }
+
+ if ((aborting || ret != 0) && fs->create)
+ unlink(fs->filename);
+ VIR_FREE(fs->filename);
+ VIR_FREE(fs);
+ if (ret != 0)
+ errno = saved;
+
+ return ret;
+}
+
+static int testStreamFileClose(virStreamPtr st,
+ int aborting)
+{
+ testStreamFilePtr fs = st->privateData;
+ int ret = 0;
+
+ if (!fs)
+ return 0;
+
+ if (fs->watch > 0)
+ virEventRemoveHandle(fs->watch);
+
+ ret = testStreamFileFree(fs, aborting);
+
+ st->privateData = NULL;
+ return ret;
+}
+
+static testStreamFilePtr
+testStreamFileOpen(virStreamPtr st,
+ const char *filename,
+ int create)
+{
+ testStreamFilePtr fs = NULL;
+ int ret;
+ char *arg = NULL;
+ int fds[2] = { -1, -1 };
+ const char *cmd[] = {
+ "dd", arg, NULL
+ };
+
+ if (!create &&
+ access(filename, R_OK) < 0) {
+ virReportSystemError(st->conn, errno,
+ _("cannot access '%s'"), filename);
+ goto error;
+ }
+
+ if (VIR_ALLOC(fs) < 0)
+ goto no_memory;
+ fs->fd = -1;
+ fs->watch = 0;
+ fs->create = create;
+
+ if (!(fs->filename = strdup(filename)))
+ goto no_memory;
+
+ if (create) {
+ ret = virAsprintf(&arg, "of=%s", filename);
+ } else {
+ ret = virAsprintf(&arg, "if=%s", filename);
+ }
+ if (ret < 0)
+ goto no_memory;
+ cmd[1] = arg;
+
+ if (pipe(fds) < 0) {
+ virReportSystemError(st->conn, errno, "%s",
+ _("cannot allocate pipe"));
+ goto error;
+ }
+
+ if ((st->flags & VIR_STREAM_NONBLOCK) &&
+ virSetNonBlock(create ? fds[1] : fds[0]) < 0) {
+ virReportSystemError(st->conn, errno, "%s",
+ _("cannot make stream non-blocking"));
+ goto error;
+ }
+
+ ret = virExec(st->conn, cmd, NULL, NULL, &fs->pid,
+ create ? fds[0] : -1,
+ create ? NULL : &fds[1], NULL, 0);
+
+ if (ret < 0)
+ goto error;
+
+ if (create) {
+ close(fds[0]);
+ fs->fd = fds[1];
+ } else {
+ close(fds[1]);
+ fs->fd = fds[0];
+ }
+
+ VIR_FREE(arg);
+ return fs;
+
+no_memory:
+ virReportOOMError(st->conn);
+error:
+ testStreamFileFree(fs, 1);
+ VIR_FREE(arg);
+ if (fds[0] != -1) close(fds[0]);
+ if (fds[1] != -1) close(fds[1]);
+ return NULL;
+}
+
+static int
+testStreamFileAbort(virStreamPtr st)
+{
+ testConnPtr privconn = st->conn->privateData;
+ int ret;
+
+ testDriverLock(privconn);
+
+ ret = testStreamFileClose(st, 1);
+
+ testDriverUnlock(privconn);
+ return 0;
+}
+
+static int
+testStreamFileFinish(virStreamPtr st)
+{
+ testConnPtr privconn = st->conn->privateData;
+ int ret = -1;
+
+ if (!st->privateData) {
+ testError(st->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("stream is not open"));
+ return -1;
+ }
+
+ testDriverLock(privconn);
+
+ ret = testStreamFileClose(st, 0);
+ if (ret != 0)
+ virReportSystemError(st->conn, errno, "%s",
+ _("cannot close stream"));
+
+ testDriverUnlock(privconn);
+ return ret;
+}
+
+static int
+testStreamFileWrite(virStreamPtr st,
+ const char *bytes,
+ size_t nbytes)
+{
+ testConnPtr privconn = st->conn->privateData;
+ testStreamFilePtr fs = st->privateData;
+ int ret;
+
+ if (!fs) {
+ testError(st->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("stream is not open"));
+ return -1;
+ }
+
+ testDriverLock(privconn);
+
+retry:
+ ret = write(fs->fd, bytes, nbytes);
+ if (ret < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK) {
+ ret = -2;
+ } else if (errno == EINTR) {
+ goto retry;
+ } else {
+ ret = -1;
+ virReportSystemError(st->conn, errno, "%s",
+ _("cannot write to stream"));
+ testStreamFileClose(st, 1);
+ }
+ }
+
+ testDriverUnlock(privconn);
+ return ret;
+}
+
+static int
+testStreamFileRead(virStreamPtr st,
+ char *bytes,
+ size_t nbytes)
+{
+ testConnPtr privconn = st->conn->privateData;
+ testStreamFilePtr fs = st->privateData;
+ int ret;
+
+ if (!fs) {
+ testError(st->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("stream is not open"));
+ return -1;
+ }
+
+ testDriverLock(privconn);
+
+retry:
+ ret = read(fs->fd, bytes, nbytes);
+ if (ret < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK) {
+ ret = -2;
+ } else if (errno == EINTR) {
+ goto retry;
+ } else {
+ ret = -1;
+ virReportSystemError(st->conn, errno, "%s",
+ _("cannot read from stream"));
+ testStreamFileClose(st, 1);
+ }
+ }
+
+ testDriverUnlock(privconn);
+ return ret;
+}
+
+static void
+testStreamFileEvent(int watch ATTRIBUTE_UNUSED,
+ int fd ATTRIBUTE_UNUSED,
+ int events, void *opaque) {
+ virStreamPtr stream = opaque;
+ testConnPtr privconn = stream->conn->privateData;
+ testStreamFilePtr fs = stream->privateData;
+ virStreamEventCallback cb;
+ void *cbopaque;
+ virFreeCallback ff;
+
+ testDriverLock(privconn);
+
+ if (!fs || !fs->cb) {
+ testDriverUnlock(privconn);
+ return;
+ }
+
+ cb = fs->cb;
+ cbopaque = fs->opaque;
+ ff = fs->ff;
+ fs->dispatching = 1;
+ testDriverUnlock(privconn);
+
+ cb(stream, events, cbopaque);
+
+ testDriverLock(privconn);
+ if (stream->privateData == NULL) {
+ if (ff)
+ (ff)(cbopaque);
+ } else {
+ fs->dispatching = 0;
+ if (fs->cbRemoved && ff)
+ (ff)(cbopaque);
+ }
+ testDriverUnlock(privconn);
+}
+
+static int
+testStreamFileAddCallback(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff)
+{
+ testConnPtr privconn = stream->conn->privateData;
+ testStreamFilePtr fs = stream->privateData;
+ int ret = -1;
+
+ if (!fs) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("stream is not open"));
+ return -1;
+ }
+
+ testDriverLock(privconn);
+
+ if (fs->watch != 0) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR, "%s",
+ _("stream already has a callback registered"));
+ goto cleanup;
+ }
+
+ if ((fs->watch = virEventAddHandle(fs->fd, events,
+ testStreamFileEvent,
+ stream,
+ NULL)) < 0) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR, "%s",
+ _("cannot register file watch on stream"));
+ goto cleanup;
+ }
+
+ fs->cbRemoved = 0;
+ fs->cb = cb;
+ fs->opaque = opaque;
+ fs->ff = ff;
+ virStreamRef(stream);
+
+ ret = 0;
+
+cleanup:
+ testDriverUnlock(privconn);
+ return ret;
+}
+
+static int
+testStreamFileUpdateCallback(virStreamPtr stream,
+ int events)
+{
+ testConnPtr privconn = stream->conn->privateData;
+ testStreamFilePtr fs = stream->privateData;
+ int ret = -1;
+
+ if (!fs) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("stream is not open"));
+ return -1;
+ }
+
+ testDriverLock(privconn);
+
+ if (fs->watch == 0) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR, "%s",
+ _("stream does not have a callback registered"));
+ goto cleanup;
+ }
+
+ virEventUpdateHandle(fs->watch, events);
+
+ ret = 0;
+
+cleanup:
+ testDriverUnlock(privconn);
+ return ret;
+}
+
+static int
+testStreamFileRemoveCallback(virStreamPtr stream)
+{
+ testConnPtr privconn = stream->conn->privateData;
+ testStreamFilePtr fs = stream->privateData;
+ int ret = -1;
+
+ if (!fs) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("stream is not open"));
+ return -1;
+ }
+
+ testDriverLock(privconn);
+
+ if (fs->watch == 0) {
+ testError(stream->conn, VIR_ERR_INTERNAL_ERROR, "%s",
+ _("stream does not have a callback registered"));
+ goto cleanup;
+ }
+
+ virEventRemoveHandle(fs->watch);
+ if (fs->dispatching)
+ fs->cbRemoved = 1;
+ else if (fs->ff)
+ (fs->ff)(fs->opaque);
+
+ fs->watch = 0;
+ fs->ff = NULL;
+ fs->cb = NULL;
+ fs->opaque = NULL;
+
+ virStreamFree(stream);
+
+ ret = 0;
+
+cleanup:
+ testDriverUnlock(privconn);
+ return ret;
+}
+
+
+static virStreamDriver streamFileDrv = {
+ .streamRecv = testStreamFileRead,
+ .streamSend = testStreamFileWrite,
+ .streamFinish = testStreamFileFinish,
+ .streamAbort = testStreamFileAbort,
+ .streamAddCallback = testStreamFileAddCallback,
+ .streamUpdateCallback = testStreamFileUpdateCallback,
+ .streamRemoveCallback = testStreamFileRemoveCallback
+};
+
+static int
+testConnectPutFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st)
+{
+ testConnPtr privconn = conn->privateData;
+ testStreamFilePtr fs = NULL;
+ int ret = -1;
+ testDriverLock(privconn);
+
+ if (!(fs = testStreamFileOpen(st, name, 1)))
+ goto cleanup;
+
+ st->driver = &streamFileDrv;
+ st->privateData = fs;
+ ret = 0;
+
+cleanup:
+ testDriverUnlock(privconn);
+
+ return ret;
+}
+
+
+static int
+testConnectGetFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st)
+{
+ testConnPtr privconn = conn->privateData;
+ testStreamFilePtr fs = NULL;
+ int ret = -1;
+ testDriverLock(privconn);
+
+ if (!(fs = testStreamFileOpen(st, name, 0)))
+ goto cleanup;
+
+ st->driver = &streamFileDrv;
+ st->privateData = fs;
+ ret = 0;
+
+cleanup:
+ testDriverUnlock(privconn);
+
+ return ret;
+}
+
+
static virDriver testDriver = {
VIR_DRV_TEST,
"Test",
@@ -4242,8 +4717,8 @@ static virDriver testDriver = {
NULL, /* nodeDeviceDettach */
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
- NULL,
- NULL,
+ testConnectPutFile,
+ testConnectGetFile,
};
static virNetworkDriver testNetworkDriver = {
--
1.6.2.5
3:51 p.m.
New subject: [libvirt] [PATCH 10/11] DEMO: Pass remote_message_header to dispatch functions
* qemud/dispatch.c: Pass msg->hdr to API handlers
* qemud/remote.c, qemud/remote.h: Add remote_message_header to
all API handlers
* qemud/remote_generate_stubs.pl: Update to include the
remote_message_header in API handler definitions
* qemud/remote_dispatch_prototypes.h: Re-generate
---
qemud/dispatch.c | 2 +-
qemud/remote.c | 173 ++++++++++++++++++++++++++++++++----
qemud/remote.h | 1 +
qemud/remote_dispatch_prototypes.h | 137 ++++++++++++++++++++++++++++
qemud/remote_generate_stubs.pl | 1 +
5 files changed, 297 insertions(+), 17 deletions(-)
diff --git a/qemud/dispatch.c b/qemud/dispatch.c
index 7417001..0c6a902 100644
--- a/qemud/dispatch.c
+++ b/qemud/dispatch.c
@@ -496,7 +496,7 @@ remoteDispatchClientCall (struct qemud_server *server,
*
* 'conn', 'rerr', 'args and 'ret'
*/
- rv = (data->fn)(server, client, conn, &rerr, &args, &ret);
+ rv = (data->fn)(server, client, conn, &msg->hdr, &rerr, &args,
&ret);
virMutexLock(&server->lock);
virMutexLock(&client->lock);
diff --git a/qemud/remote.c b/qemud/remote.c
index d32d513..3034023 100644
--- a/qemud/remote.c
+++ b/qemud/remote.c
@@ -127,6 +127,7 @@ static int
remoteDispatchOpen (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
struct remote_open_args *args, void *ret ATTRIBUTE_UNUSED)
{
@@ -174,6 +175,7 @@ static int
remoteDispatchClose (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr ATTRIBUTE_UNUSED,
void *args ATTRIBUTE_UNUSED, void *ret ATTRIBUTE_UNUSED)
{
@@ -191,6 +193,7 @@ static int
remoteDispatchSupportsFeature (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_supports_feature_args *args,
remote_supports_feature_ret *ret)
{
@@ -208,6 +211,7 @@ static int
remoteDispatchGetType (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED, remote_get_type_ret *ret)
{
@@ -235,6 +239,7 @@ static int
remoteDispatchGetVersion (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_get_version_ret *ret)
@@ -254,6 +259,7 @@ static int
remoteDispatchGetHostname (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_get_hostname_ret *ret)
@@ -274,6 +280,7 @@ static int
remoteDispatchGetUri (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_get_uri_ret *ret)
@@ -295,6 +302,7 @@ static int
remoteDispatchGetMaxVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_get_max_vcpus_args *args,
remote_get_max_vcpus_ret *ret)
@@ -315,6 +323,7 @@ static int
remoteDispatchNodeGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_node_get_info_ret *ret)
@@ -342,6 +351,7 @@ static int
remoteDispatchGetCapabilities (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_get_capabilities_ret *ret)
@@ -362,6 +372,7 @@ static int
remoteDispatchNodeGetCellsFreeMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_get_cells_free_memory_args *args,
remote_node_get_cells_free_memory_ret *ret)
@@ -399,6 +410,7 @@ static int
remoteDispatchNodeGetFreeMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_node_get_free_memory_ret *ret)
@@ -419,6 +431,7 @@ static int
remoteDispatchDomainGetSchedulerType (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_scheduler_type_args *args,
remote_domain_get_scheduler_type_ret *ret)
@@ -450,6 +463,7 @@ static int
remoteDispatchDomainGetSchedulerParameters (struct qemud_server *server
ATTRIBUTE_UNUSED,
struct qemud_client *client
ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_scheduler_parameters_args
*args,
remote_domain_get_scheduler_parameters_ret
*ret)
@@ -533,6 +547,7 @@ static int
remoteDispatchDomainSetSchedulerParameters (struct qemud_server *server
ATTRIBUTE_UNUSED,
struct qemud_client *client
ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_set_scheduler_parameters_args
*args,
void *ret ATTRIBUTE_UNUSED)
@@ -596,6 +611,7 @@ static int
remoteDispatchDomainBlockStats (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_block_stats_args *args,
remote_domain_block_stats_ret *ret)
@@ -631,6 +647,7 @@ static int
remoteDispatchDomainInterfaceStats (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_interface_stats_args *args,
remote_domain_interface_stats_ret *ret)
@@ -669,6 +686,7 @@ static int
remoteDispatchDomainBlockPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_block_peek_args *args,
remote_domain_block_peek_ret *ret)
@@ -721,6 +739,7 @@ static int
remoteDispatchDomainMemoryPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_memory_peek_args *args,
remote_domain_memory_peek_ret *ret)
@@ -771,6 +790,7 @@ static int
remoteDispatchDomainAttachDevice (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_attach_device_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -796,6 +816,7 @@ static int
remoteDispatchDomainCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_create_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -821,6 +842,7 @@ static int
remoteDispatchDomainCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_create_xml_args *args,
remote_domain_create_xml_ret *ret)
@@ -843,6 +865,7 @@ static int
remoteDispatchDomainDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_define_xml_args *args,
remote_domain_define_xml_ret *ret)
@@ -865,6 +888,7 @@ static int
remoteDispatchDomainDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_destroy_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -890,6 +914,7 @@ static int
remoteDispatchDomainDetachDevice (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_detach_device_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -916,6 +941,7 @@ static int
remoteDispatchDomainDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_dump_xml_args *args,
remote_domain_dump_xml_ret *ret)
@@ -943,6 +969,7 @@ static int
remoteDispatchDomainXmlFromNative (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_xml_from_native_args *args,
remote_domain_xml_from_native_ret *ret)
@@ -963,6 +990,7 @@ static int
remoteDispatchDomainXmlToNative (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_xml_to_native_args *args,
remote_domain_xml_to_native_ret *ret)
@@ -984,6 +1012,7 @@ static int
remoteDispatchDomainGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_autostart_args *args,
remote_domain_get_autostart_ret *ret)
@@ -1009,6 +1038,7 @@ static int
remoteDispatchDomainGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_info_args *args,
remote_domain_get_info_ret *ret)
@@ -1043,6 +1073,7 @@ static int
remoteDispatchDomainGetMaxMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_max_memory_args *args,
remote_domain_get_max_memory_ret *ret)
@@ -1069,6 +1100,7 @@ static int
remoteDispatchDomainGetMaxVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_max_vcpus_args *args,
remote_domain_get_max_vcpus_ret *ret)
@@ -1095,6 +1127,7 @@ static int
remoteDispatchDomainGetSecurityLabel(struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_security_label_args *args,
remote_domain_get_security_label_ret *ret)
@@ -1132,6 +1165,7 @@ static int
remoteDispatchNodeGetSecurityModel(struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_node_get_security_model_ret *ret)
@@ -1165,6 +1199,7 @@ static int
remoteDispatchDomainGetOsType (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_os_type_args *args,
remote_domain_get_os_type_ret *ret)
@@ -1192,6 +1227,7 @@ static int
remoteDispatchDomainGetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_get_vcpus_args *args,
remote_domain_get_vcpus_ret *ret)
@@ -1272,6 +1308,7 @@ static int
remoteDispatchDomainMigratePrepare (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_migrate_prepare_args *args,
remote_domain_migrate_prepare_ret *ret)
@@ -1320,6 +1357,7 @@ static int
remoteDispatchDomainMigratePerform (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_migrate_perform_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1354,6 +1392,7 @@ static int
remoteDispatchDomainMigrateFinish (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_migrate_finish_args *args,
remote_domain_migrate_finish_ret *ret)
@@ -1380,6 +1419,7 @@ static int
remoteDispatchDomainMigratePrepare2 (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_migrate_prepare2_args *args,
remote_domain_migrate_prepare2_ret *ret)
@@ -1424,6 +1464,7 @@ static int
remoteDispatchDomainMigrateFinish2 (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_migrate_finish2_args *args,
remote_domain_migrate_finish2_ret *ret)
@@ -1451,6 +1492,7 @@ static int
remoteDispatchListDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_defined_domains_args *args,
remote_list_defined_domains_ret *ret)
@@ -1484,6 +1526,7 @@ static int
remoteDispatchDomainLookupById (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_lookup_by_id_args *args,
remote_domain_lookup_by_id_ret *ret)
@@ -1505,6 +1548,7 @@ static int
remoteDispatchDomainLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_lookup_by_name_args *args,
remote_domain_lookup_by_name_ret *ret)
@@ -1526,6 +1570,7 @@ static int
remoteDispatchDomainLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_lookup_by_uuid_args *args,
remote_domain_lookup_by_uuid_ret *ret)
@@ -1547,6 +1592,7 @@ static int
remoteDispatchNumOfDefinedDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_defined_domains_ret *ret)
@@ -1565,6 +1611,7 @@ static int
remoteDispatchDomainPinVcpu (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_pin_vcpu_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1600,6 +1647,7 @@ static int
remoteDispatchDomainReboot (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_reboot_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1625,6 +1673,7 @@ static int
remoteDispatchDomainRestore (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_restore_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1642,6 +1691,7 @@ static int
remoteDispatchDomainResume (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_resume_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1667,6 +1717,7 @@ static int
remoteDispatchDomainSave (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_save_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1692,6 +1743,7 @@ static int
remoteDispatchDomainCoreDump (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_core_dump_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1717,6 +1769,7 @@ static int
remoteDispatchDomainSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_set_autostart_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1742,6 +1795,7 @@ static int
remoteDispatchDomainSetMaxMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_set_max_memory_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1767,6 +1821,7 @@ static int
remoteDispatchDomainSetMemory (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_set_memory_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1792,6 +1847,7 @@ static int
remoteDispatchDomainSetVcpus (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_set_vcpus_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1817,6 +1873,7 @@ static int
remoteDispatchDomainShutdown (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_shutdown_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1842,6 +1899,7 @@ static int
remoteDispatchDomainSuspend (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_suspend_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1867,6 +1925,7 @@ static int
remoteDispatchDomainUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_domain_undefine_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -1892,6 +1951,7 @@ static int
remoteDispatchListDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_defined_networks_args *args,
remote_list_defined_networks_ret *ret)
@@ -1925,6 +1985,7 @@ static int
remoteDispatchListDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_domains_args *args,
remote_list_domains_ret *ret)
@@ -1957,6 +2018,7 @@ static int
remoteDispatchListNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_networks_args *args,
remote_list_networks_ret *ret)
@@ -1990,6 +2052,7 @@ static int
remoteDispatchNetworkCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_create_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -2015,6 +2078,7 @@ static int
remoteDispatchNetworkCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_create_xml_args *args,
remote_network_create_xml_ret *ret)
@@ -2036,6 +2100,7 @@ static int
remoteDispatchNetworkDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_define_xml_args *args,
remote_network_define_xml_ret *ret)
@@ -2057,6 +2122,7 @@ static int
remoteDispatchNetworkDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_destroy_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -2082,6 +2148,7 @@ static int
remoteDispatchNetworkDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_dump_xml_args *args,
remote_network_dump_xml_ret *ret)
@@ -2109,6 +2176,7 @@ static int
remoteDispatchNetworkGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_get_autostart_args *args,
remote_network_get_autostart_ret *ret)
@@ -2134,6 +2202,7 @@ static int
remoteDispatchNetworkGetBridgeName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_get_bridge_name_args *args,
remote_network_get_bridge_name_ret *ret)
@@ -2161,6 +2230,7 @@ static int
remoteDispatchNetworkLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_lookup_by_name_args *args,
remote_network_lookup_by_name_ret *ret)
@@ -2182,6 +2252,7 @@ static int
remoteDispatchNetworkLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_lookup_by_uuid_args *args,
remote_network_lookup_by_uuid_ret *ret)
@@ -2203,6 +2274,7 @@ static int
remoteDispatchNetworkSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_set_autostart_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -2228,6 +2300,7 @@ static int
remoteDispatchNetworkUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_network_undefine_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -2253,6 +2326,7 @@ static int
remoteDispatchNumOfDefinedNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_defined_networks_ret *ret)
@@ -2271,6 +2345,7 @@ static int
remoteDispatchNumOfDomains (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_domains_ret *ret)
@@ -2289,6 +2364,7 @@ static int
remoteDispatchNumOfNetworks (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_networks_ret *ret)
@@ -2309,6 +2385,7 @@ static int
remoteDispatchNumOfInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_interfaces_ret *ret)
@@ -2327,6 +2404,7 @@ static int
remoteDispatchListInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_interfaces_args *args,
remote_list_interfaces_ret *ret)
@@ -2360,6 +2438,7 @@ static int
remoteDispatchNumOfDefinedInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_defined_interfaces_ret *ret)
@@ -2378,6 +2457,7 @@ static int
remoteDispatchListDefinedInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_defined_interfaces_args *args,
remote_list_defined_interfaces_ret *ret)
@@ -2411,6 +2491,7 @@ static int
remoteDispatchInterfaceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_interface_lookup_by_name_args *args,
remote_interface_lookup_by_name_ret *ret)
@@ -2432,6 +2513,7 @@ static int
remoteDispatchInterfaceLookupByMacString (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_interface_lookup_by_mac_string_args
*args,
remote_interface_lookup_by_mac_string_ret
*ret)
@@ -2453,6 +2535,7 @@ static int
remoteDispatchInterfaceGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_interface_get_xml_desc_args *args,
remote_interface_get_xml_desc_ret *ret)
@@ -2480,6 +2563,7 @@ static int
remoteDispatchInterfaceDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_interface_define_xml_args *args,
remote_interface_define_xml_ret *ret)
@@ -2499,11 +2583,12 @@ remoteDispatchInterfaceDefineXml (struct qemud_server *server
ATTRIBUTE_UNUSED,
static int
remoteDispatchInterfaceUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_undefine_args *args,
- void *ret ATTRIBUTE_UNUSED)
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_interface_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
{
virInterfacePtr iface;
@@ -2524,11 +2609,12 @@ remoteDispatchInterfaceUndefine (struct qemud_server *server
ATTRIBUTE_UNUSED,
static int
remoteDispatchInterfaceCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_create_args *args,
- void *ret ATTRIBUTE_UNUSED)
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_interface_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
{
virInterfacePtr iface;
@@ -2549,11 +2635,12 @@ remoteDispatchInterfaceCreate (struct qemud_server *server
ATTRIBUTE_UNUSED,
static int
remoteDispatchInterfaceDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
- struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn,
- remote_error *rerr,
- remote_interface_destroy_args *args,
- void *ret ATTRIBUTE_UNUSED)
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_interface_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
{
virInterfacePtr iface;
@@ -2578,6 +2665,7 @@ static int
remoteDispatchAuthList (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_auth_list_ret *ret)
@@ -2636,6 +2724,7 @@ static int
remoteDispatchAuthSaslInit (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_auth_sasl_init_ret *ret)
@@ -2893,6 +2982,7 @@ static int
remoteDispatchAuthSaslStart (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_auth_sasl_start_args *args,
remote_auth_sasl_start_ret *ret)
@@ -2980,6 +3070,7 @@ static int
remoteDispatchAuthSaslStep (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_auth_sasl_step_args *args,
remote_auth_sasl_step_ret *ret)
@@ -3069,6 +3160,7 @@ static int
remoteDispatchAuthSaslInit (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_auth_sasl_init_ret *ret ATTRIBUTE_UNUSED)
@@ -3082,6 +3174,7 @@ static int
remoteDispatchAuthSaslStart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_auth_sasl_start_args *args ATTRIBUTE_UNUSED,
remote_auth_sasl_start_ret *ret ATTRIBUTE_UNUSED)
@@ -3094,7 +3187,8 @@ remoteDispatchAuthSaslStart (struct qemud_server *server
ATTRIBUTE_UNUSED,
static int
remoteDispatchAuthSaslStep (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
- virConnectPtr conn ATTRIBUTE_UNUSED,
+ virConnectPtr conn ATTRIBUTE_UNUSED
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_auth_sasl_step_args *args ATTRIBUTE_UNUSED,
remote_auth_sasl_step_ret *ret ATTRIBUTE_UNUSED)
@@ -3111,6 +3205,7 @@ static int
remoteDispatchAuthPolkit (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_auth_polkit_ret *ret)
@@ -3223,6 +3318,7 @@ static int
remoteDispatchAuthPolkit (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn ATTRIBUTE_UNUSED,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_auth_polkit_ret *ret ATTRIBUTE_UNUSED)
@@ -3243,6 +3339,7 @@ static int
remoteDispatchListDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_defined_storage_pools_args *args,
remote_list_defined_storage_pools_ret *ret)
@@ -3276,6 +3373,7 @@ static int
remoteDispatchListStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_list_storage_pools_args *args,
remote_list_storage_pools_ret *ret)
@@ -3309,6 +3407,7 @@ static int
remoteDispatchFindStoragePoolSources (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_find_storage_pool_sources_args *args,
remote_find_storage_pool_sources_ret *ret)
@@ -3331,6 +3430,7 @@ static int
remoteDispatchStoragePoolCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_create_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3356,6 +3456,7 @@ static int
remoteDispatchStoragePoolCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_create_xml_args *args,
remote_storage_pool_create_xml_ret *ret)
@@ -3377,6 +3478,7 @@ static int
remoteDispatchStoragePoolDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_define_xml_args *args,
remote_storage_pool_define_xml_ret *ret)
@@ -3398,6 +3500,7 @@ static int
remoteDispatchStoragePoolBuild (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_build_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3424,6 +3527,7 @@ static int
remoteDispatchStoragePoolDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_destroy_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3449,6 +3553,7 @@ static int
remoteDispatchStoragePoolDelete (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_delete_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3474,6 +3579,7 @@ static int
remoteDispatchStoragePoolRefresh (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_refresh_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3499,6 +3605,7 @@ static int
remoteDispatchStoragePoolGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_get_info_args *args,
remote_storage_pool_get_info_ret *ret)
@@ -3532,6 +3639,7 @@ static int
remoteDispatchStoragePoolDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_dump_xml_args *args,
remote_storage_pool_dump_xml_ret *ret)
@@ -3559,6 +3667,7 @@ static int
remoteDispatchStoragePoolGetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_get_autostart_args *args,
remote_storage_pool_get_autostart_ret *ret)
@@ -3585,6 +3694,7 @@ static int
remoteDispatchStoragePoolLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_lookup_by_name_args *args,
remote_storage_pool_lookup_by_name_ret *ret)
@@ -3606,6 +3716,7 @@ static int
remoteDispatchStoragePoolLookupByUuid (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_lookup_by_uuid_args *args,
remote_storage_pool_lookup_by_uuid_ret *ret)
@@ -3627,6 +3738,7 @@ static int
remoteDispatchStoragePoolLookupByVolume (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_lookup_by_volume_args
*args,
remote_storage_pool_lookup_by_volume_ret *ret)
@@ -3656,6 +3768,7 @@ static int
remoteDispatchStoragePoolSetAutostart (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_set_autostart_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3681,6 +3794,7 @@ static int
remoteDispatchStoragePoolUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_undefine_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3706,6 +3820,7 @@ static int
remoteDispatchNumOfStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_storage_pools_ret *ret)
@@ -3724,6 +3839,7 @@ static int
remoteDispatchNumOfDefinedStoragePools (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
void *args ATTRIBUTE_UNUSED,
remote_num_of_defined_storage_pools_ret *ret)
@@ -3742,6 +3858,7 @@ static int
remoteDispatchStoragePoolListVolumes (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_list_volumes_args *args,
remote_storage_pool_list_volumes_ret *ret)
@@ -3785,6 +3902,7 @@ static int
remoteDispatchStoragePoolNumOfVolumes (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_pool_num_of_volumes_args *args,
remote_storage_pool_num_of_volumes_ret *ret)
@@ -3818,6 +3936,7 @@ static int
remoteDispatchStorageVolCreateXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_create_xml_args *args,
remote_storage_vol_create_xml_ret *ret)
@@ -3847,6 +3966,7 @@ static int
remoteDispatchStorageVolCreateXmlFrom (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_create_xml_from_args *args,
remote_storage_vol_create_xml_from_ret *ret)
@@ -3882,6 +4002,7 @@ static int
remoteDispatchStorageVolDelete (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_delete_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -3907,6 +4028,7 @@ static int
remoteDispatchStorageVolGetInfo (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_get_info_args *args,
remote_storage_vol_get_info_ret *ret)
@@ -3939,6 +4061,7 @@ static int
remoteDispatchStorageVolDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_dump_xml_args *args,
remote_storage_vol_dump_xml_ret *ret)
@@ -3967,6 +4090,7 @@ static int
remoteDispatchStorageVolGetPath (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_get_path_args *args,
remote_storage_vol_get_path_ret *ret)
@@ -3995,6 +4119,7 @@ static int
remoteDispatchStorageVolLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_lookup_by_name_args *args,
remote_storage_vol_lookup_by_name_ret *ret)
@@ -4024,6 +4149,7 @@ static int
remoteDispatchStorageVolLookupByKey (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_lookup_by_key_args *args,
remote_storage_vol_lookup_by_key_ret *ret)
@@ -4046,6 +4172,7 @@ static int
remoteDispatchStorageVolLookupByPath (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_storage_vol_lookup_by_path_args *args,
remote_storage_vol_lookup_by_path_ret *ret)
@@ -4072,6 +4199,7 @@ static int
remoteDispatchNodeNumOfDevices (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_num_of_devices_args *args,
remote_node_num_of_devices_ret *ret)
@@ -4094,6 +4222,7 @@ static int
remoteDispatchNodeListDevices (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_list_devices_args *args,
remote_node_list_devices_ret *ret)
@@ -4130,6 +4259,7 @@ static int
remoteDispatchNodeDeviceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_lookup_by_name_args *args,
remote_node_device_lookup_by_name_ret *ret)
@@ -4154,6 +4284,7 @@ static int
remoteDispatchNodeDeviceDumpXml (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_dump_xml_args *args,
remote_node_device_dump_xml_ret *ret)
@@ -4183,6 +4314,7 @@ static int
remoteDispatchNodeDeviceGetParent (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_get_parent_args *args,
remote_node_device_get_parent_ret *ret)
@@ -4225,6 +4357,7 @@ static int
remoteDispatchNodeDeviceNumOfCaps (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_num_of_caps_args *args,
remote_node_device_num_of_caps_ret *ret)
@@ -4253,6 +4386,7 @@ static int
remoteDispatchNodeDeviceListCaps (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_list_caps_args *args,
remote_node_device_list_caps_ret *ret)
@@ -4295,6 +4429,7 @@ static int
remoteDispatchNodeDeviceDettach (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_dettach_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -4321,6 +4456,7 @@ static int
remoteDispatchNodeDeviceReAttach (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_re_attach_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -4347,6 +4483,7 @@ static int
remoteDispatchNodeDeviceReset (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_reset_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -4373,6 +4510,7 @@ static int
remoteDispatchNodeDeviceCreateXml(struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_create_xml_args *args,
remote_node_device_create_xml_ret *ret)
@@ -4396,6 +4534,7 @@ static int
remoteDispatchNodeDeviceDestroy(struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr,
remote_node_device_destroy_args *args,
void *ret ATTRIBUTE_UNUSED)
@@ -4425,6 +4564,7 @@ static int
remoteDispatchDomainEventsRegister (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr ATTRIBUTE_UNUSED,
void *args ATTRIBUTE_UNUSED,
remote_domain_events_register_ret *ret
ATTRIBUTE_UNUSED)
@@ -4444,6 +4584,7 @@ static int
remoteDispatchDomainEventsDeregister (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
remote_error *rerr ATTRIBUTE_UNUSED,
void *args ATTRIBUTE_UNUSED,
remote_domain_events_deregister_ret *ret
ATTRIBUTE_UNUSED)
diff --git a/qemud/remote.h b/qemud/remote.h
index e3ee696..9baf045 100644
--- a/qemud/remote.h
+++ b/qemud/remote.h
@@ -54,6 +54,7 @@ typedef union {
typedef int (*dispatch_fn) (struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
dispatch_args *args,
dispatch_ret *ret);
diff --git a/qemud/remote_dispatch_prototypes.h b/qemud/remote_dispatch_prototypes.h
index d9f6aad..a25ea16 100644
--- a/qemud/remote_dispatch_prototypes.h
+++ b/qemud/remote_dispatch_prototypes.h
@@ -6,6 +6,7 @@ static int remoteDispatchAuthList(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_auth_list_ret *ret);
@@ -13,6 +14,7 @@ static int remoteDispatchAuthPolkit(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_auth_polkit_ret *ret);
@@ -20,6 +22,7 @@ static int remoteDispatchAuthSaslInit(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_auth_sasl_init_ret *ret);
@@ -27,6 +30,7 @@ static int remoteDispatchAuthSaslStart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_auth_sasl_start_args *args,
remote_auth_sasl_start_ret *ret);
@@ -34,6 +38,7 @@ static int remoteDispatchAuthSaslStep(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_auth_sasl_step_args *args,
remote_auth_sasl_step_ret *ret);
@@ -41,6 +46,7 @@ static int remoteDispatchClose(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
void *ret);
@@ -48,6 +54,7 @@ static int remoteDispatchDomainAttachDevice(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_attach_device_args *args,
void *ret);
@@ -55,6 +62,7 @@ static int remoteDispatchDomainBlockPeek(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_block_peek_args *args,
remote_domain_block_peek_ret *ret);
@@ -62,6 +70,7 @@ static int remoteDispatchDomainBlockStats(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_block_stats_args *args,
remote_domain_block_stats_ret *ret);
@@ -69,6 +78,7 @@ static int remoteDispatchDomainCoreDump(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_core_dump_args *args,
void *ret);
@@ -76,6 +86,7 @@ static int remoteDispatchDomainCreate(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_create_args *args,
void *ret);
@@ -83,6 +94,7 @@ static int remoteDispatchDomainCreateXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_create_xml_args *args,
remote_domain_create_xml_ret *ret);
@@ -90,6 +102,7 @@ static int remoteDispatchDomainDefineXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_define_xml_args *args,
remote_domain_define_xml_ret *ret);
@@ -97,6 +110,7 @@ static int remoteDispatchDomainDestroy(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_destroy_args *args,
void *ret);
@@ -104,6 +118,7 @@ static int remoteDispatchDomainDetachDevice(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_detach_device_args *args,
void *ret);
@@ -111,6 +126,7 @@ static int remoteDispatchDomainDumpXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_dump_xml_args *args,
remote_domain_dump_xml_ret *ret);
@@ -118,6 +134,7 @@ static int remoteDispatchDomainEventsDeregister(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_domain_events_deregister_ret *ret);
@@ -125,6 +142,7 @@ static int remoteDispatchDomainEventsRegister(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_domain_events_register_ret *ret);
@@ -132,6 +150,7 @@ static int remoteDispatchDomainGetAutostart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_autostart_args *args,
remote_domain_get_autostart_ret *ret);
@@ -139,6 +158,7 @@ static int remoteDispatchDomainGetInfo(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_info_args *args,
remote_domain_get_info_ret *ret);
@@ -146,6 +166,7 @@ static int remoteDispatchDomainGetMaxMemory(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_max_memory_args *args,
remote_domain_get_max_memory_ret *ret);
@@ -153,6 +174,7 @@ static int remoteDispatchDomainGetMaxVcpus(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_max_vcpus_args *args,
remote_domain_get_max_vcpus_ret *ret);
@@ -160,6 +182,7 @@ static int remoteDispatchDomainGetOsType(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_os_type_args *args,
remote_domain_get_os_type_ret *ret);
@@ -167,6 +190,7 @@ static int remoteDispatchDomainGetSchedulerParameters(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_scheduler_parameters_args *args,
remote_domain_get_scheduler_parameters_ret *ret);
@@ -174,6 +198,7 @@ static int remoteDispatchDomainGetSchedulerType(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_scheduler_type_args *args,
remote_domain_get_scheduler_type_ret *ret);
@@ -181,6 +206,7 @@ static int remoteDispatchDomainGetSecurityLabel(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_security_label_args *args,
remote_domain_get_security_label_ret *ret);
@@ -188,6 +214,7 @@ static int remoteDispatchDomainGetVcpus(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_get_vcpus_args *args,
remote_domain_get_vcpus_ret *ret);
@@ -195,6 +222,7 @@ static int remoteDispatchDomainInterfaceStats(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_interface_stats_args *args,
remote_domain_interface_stats_ret *ret);
@@ -202,6 +230,7 @@ static int remoteDispatchDomainLookupById(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_lookup_by_id_args *args,
remote_domain_lookup_by_id_ret *ret);
@@ -209,6 +238,7 @@ static int remoteDispatchDomainLookupByName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_lookup_by_name_args *args,
remote_domain_lookup_by_name_ret *ret);
@@ -216,6 +246,7 @@ static int remoteDispatchDomainLookupByUuid(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_lookup_by_uuid_args *args,
remote_domain_lookup_by_uuid_ret *ret);
@@ -223,6 +254,7 @@ static int remoteDispatchDomainMemoryPeek(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_memory_peek_args *args,
remote_domain_memory_peek_ret *ret);
@@ -230,6 +262,7 @@ static int remoteDispatchDomainMigrateFinish(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_migrate_finish_args *args,
remote_domain_migrate_finish_ret *ret);
@@ -237,6 +270,7 @@ static int remoteDispatchDomainMigrateFinish2(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_migrate_finish2_args *args,
remote_domain_migrate_finish2_ret *ret);
@@ -244,6 +278,7 @@ static int remoteDispatchDomainMigratePerform(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_migrate_perform_args *args,
void *ret);
@@ -251,6 +286,7 @@ static int remoteDispatchDomainMigratePrepare(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_migrate_prepare_args *args,
remote_domain_migrate_prepare_ret *ret);
@@ -258,6 +294,7 @@ static int remoteDispatchDomainMigratePrepare2(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_migrate_prepare2_args *args,
remote_domain_migrate_prepare2_ret *ret);
@@ -265,6 +302,7 @@ static int remoteDispatchDomainPinVcpu(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_pin_vcpu_args *args,
void *ret);
@@ -272,6 +310,7 @@ static int remoteDispatchDomainReboot(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_reboot_args *args,
void *ret);
@@ -279,6 +318,7 @@ static int remoteDispatchDomainRestore(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_restore_args *args,
void *ret);
@@ -286,6 +326,7 @@ static int remoteDispatchDomainResume(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_resume_args *args,
void *ret);
@@ -293,6 +334,7 @@ static int remoteDispatchDomainSave(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_save_args *args,
void *ret);
@@ -300,6 +342,7 @@ static int remoteDispatchDomainSetAutostart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_set_autostart_args *args,
void *ret);
@@ -307,6 +350,7 @@ static int remoteDispatchDomainSetMaxMemory(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_set_max_memory_args *args,
void *ret);
@@ -314,6 +358,7 @@ static int remoteDispatchDomainSetMemory(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_set_memory_args *args,
void *ret);
@@ -321,6 +366,7 @@ static int remoteDispatchDomainSetSchedulerParameters(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_set_scheduler_parameters_args *args,
void *ret);
@@ -328,6 +374,7 @@ static int remoteDispatchDomainSetVcpus(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_set_vcpus_args *args,
void *ret);
@@ -335,6 +382,7 @@ static int remoteDispatchDomainShutdown(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_shutdown_args *args,
void *ret);
@@ -342,6 +390,7 @@ static int remoteDispatchDomainSuspend(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_suspend_args *args,
void *ret);
@@ -349,6 +398,7 @@ static int remoteDispatchDomainUndefine(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_undefine_args *args,
void *ret);
@@ -356,6 +406,7 @@ static int remoteDispatchDomainXmlFromNative(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_xml_from_native_args *args,
remote_domain_xml_from_native_ret *ret);
@@ -363,6 +414,7 @@ static int remoteDispatchDomainXmlToNative(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_domain_xml_to_native_args *args,
remote_domain_xml_to_native_ret *ret);
@@ -370,6 +422,7 @@ static int remoteDispatchFindStoragePoolSources(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_find_storage_pool_sources_args *args,
remote_find_storage_pool_sources_ret *ret);
@@ -377,6 +430,7 @@ static int remoteDispatchGetCapabilities(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_get_capabilities_ret *ret);
@@ -384,6 +438,7 @@ static int remoteDispatchGetHostname(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_get_hostname_ret *ret);
@@ -391,6 +446,7 @@ static int remoteDispatchGetMaxVcpus(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_get_max_vcpus_args *args,
remote_get_max_vcpus_ret *ret);
@@ -398,6 +454,7 @@ static int remoteDispatchGetType(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_get_type_ret *ret);
@@ -405,6 +462,7 @@ static int remoteDispatchGetUri(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_get_uri_ret *ret);
@@ -412,6 +470,7 @@ static int remoteDispatchGetVersion(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_get_version_ret *ret);
@@ -419,6 +478,7 @@ static int remoteDispatchInterfaceCreate(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_create_args *args,
void *ret);
@@ -426,6 +486,7 @@ static int remoteDispatchInterfaceDefineXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_define_xml_args *args,
remote_interface_define_xml_ret *ret);
@@ -433,6 +494,7 @@ static int remoteDispatchInterfaceDestroy(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_destroy_args *args,
void *ret);
@@ -440,6 +502,7 @@ static int remoteDispatchInterfaceGetXmlDesc(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_get_xml_desc_args *args,
remote_interface_get_xml_desc_ret *ret);
@@ -447,6 +510,7 @@ static int remoteDispatchInterfaceLookupByMacString(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_lookup_by_mac_string_args *args,
remote_interface_lookup_by_mac_string_ret *ret);
@@ -454,6 +518,7 @@ static int remoteDispatchInterfaceLookupByName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_lookup_by_name_args *args,
remote_interface_lookup_by_name_ret *ret);
@@ -461,6 +526,7 @@ static int remoteDispatchInterfaceUndefine(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_interface_undefine_args *args,
void *ret);
@@ -468,6 +534,7 @@ static int remoteDispatchListDefinedDomains(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_defined_domains_args *args,
remote_list_defined_domains_ret *ret);
@@ -475,6 +542,7 @@ static int remoteDispatchListDefinedInterfaces(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_defined_interfaces_args *args,
remote_list_defined_interfaces_ret *ret);
@@ -482,6 +550,7 @@ static int remoteDispatchListDefinedNetworks(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_defined_networks_args *args,
remote_list_defined_networks_ret *ret);
@@ -489,6 +558,7 @@ static int remoteDispatchListDefinedStoragePools(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_defined_storage_pools_args *args,
remote_list_defined_storage_pools_ret *ret);
@@ -496,6 +566,7 @@ static int remoteDispatchListDomains(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_domains_args *args,
remote_list_domains_ret *ret);
@@ -503,6 +574,7 @@ static int remoteDispatchListInterfaces(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_interfaces_args *args,
remote_list_interfaces_ret *ret);
@@ -510,6 +582,7 @@ static int remoteDispatchListNetworks(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_networks_args *args,
remote_list_networks_ret *ret);
@@ -517,6 +590,7 @@ static int remoteDispatchListStoragePools(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_list_storage_pools_args *args,
remote_list_storage_pools_ret *ret);
@@ -524,6 +598,7 @@ static int remoteDispatchNetworkCreate(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_create_args *args,
void *ret);
@@ -531,6 +606,7 @@ static int remoteDispatchNetworkCreateXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_create_xml_args *args,
remote_network_create_xml_ret *ret);
@@ -538,6 +614,7 @@ static int remoteDispatchNetworkDefineXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_define_xml_args *args,
remote_network_define_xml_ret *ret);
@@ -545,6 +622,7 @@ static int remoteDispatchNetworkDestroy(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_destroy_args *args,
void *ret);
@@ -552,6 +630,7 @@ static int remoteDispatchNetworkDumpXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_dump_xml_args *args,
remote_network_dump_xml_ret *ret);
@@ -559,6 +638,7 @@ static int remoteDispatchNetworkGetAutostart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_get_autostart_args *args,
remote_network_get_autostart_ret *ret);
@@ -566,6 +646,7 @@ static int remoteDispatchNetworkGetBridgeName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_get_bridge_name_args *args,
remote_network_get_bridge_name_ret *ret);
@@ -573,6 +654,7 @@ static int remoteDispatchNetworkLookupByName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_lookup_by_name_args *args,
remote_network_lookup_by_name_ret *ret);
@@ -580,6 +662,7 @@ static int remoteDispatchNetworkLookupByUuid(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_lookup_by_uuid_args *args,
remote_network_lookup_by_uuid_ret *ret);
@@ -587,6 +670,7 @@ static int remoteDispatchNetworkSetAutostart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_set_autostart_args *args,
void *ret);
@@ -594,6 +678,7 @@ static int remoteDispatchNetworkUndefine(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_network_undefine_args *args,
void *ret);
@@ -601,6 +686,7 @@ static int remoteDispatchNodeDeviceCreateXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_create_xml_args *args,
remote_node_device_create_xml_ret *ret);
@@ -608,6 +694,7 @@ static int remoteDispatchNodeDeviceDestroy(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_destroy_args *args,
void *ret);
@@ -615,6 +702,7 @@ static int remoteDispatchNodeDeviceDettach(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_dettach_args *args,
void *ret);
@@ -622,6 +710,7 @@ static int remoteDispatchNodeDeviceDumpXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_dump_xml_args *args,
remote_node_device_dump_xml_ret *ret);
@@ -629,6 +718,7 @@ static int remoteDispatchNodeDeviceGetParent(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_get_parent_args *args,
remote_node_device_get_parent_ret *ret);
@@ -636,6 +726,7 @@ static int remoteDispatchNodeDeviceListCaps(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_list_caps_args *args,
remote_node_device_list_caps_ret *ret);
@@ -643,6 +734,7 @@ static int remoteDispatchNodeDeviceLookupByName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_lookup_by_name_args *args,
remote_node_device_lookup_by_name_ret *ret);
@@ -650,6 +742,7 @@ static int remoteDispatchNodeDeviceNumOfCaps(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_num_of_caps_args *args,
remote_node_device_num_of_caps_ret *ret);
@@ -657,6 +750,7 @@ static int remoteDispatchNodeDeviceReAttach(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_re_attach_args *args,
void *ret);
@@ -664,6 +758,7 @@ static int remoteDispatchNodeDeviceReset(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_device_reset_args *args,
void *ret);
@@ -671,6 +766,7 @@ static int remoteDispatchNodeGetCellsFreeMemory(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_get_cells_free_memory_args *args,
remote_node_get_cells_free_memory_ret *ret);
@@ -678,6 +774,7 @@ static int remoteDispatchNodeGetFreeMemory(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_node_get_free_memory_ret *ret);
@@ -685,6 +782,7 @@ static int remoteDispatchNodeGetInfo(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_node_get_info_ret *ret);
@@ -692,6 +790,7 @@ static int remoteDispatchNodeGetSecurityModel(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_node_get_security_model_ret *ret);
@@ -699,6 +798,7 @@ static int remoteDispatchNodeListDevices(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_list_devices_args *args,
remote_node_list_devices_ret *ret);
@@ -706,6 +806,7 @@ static int remoteDispatchNodeNumOfDevices(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_node_num_of_devices_args *args,
remote_node_num_of_devices_ret *ret);
@@ -713,6 +814,7 @@ static int remoteDispatchNumOfDefinedDomains(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_defined_domains_ret *ret);
@@ -720,6 +822,7 @@ static int remoteDispatchNumOfDefinedInterfaces(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_defined_interfaces_ret *ret);
@@ -727,6 +830,7 @@ static int remoteDispatchNumOfDefinedNetworks(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_defined_networks_ret *ret);
@@ -734,6 +838,7 @@ static int remoteDispatchNumOfDefinedStoragePools(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_defined_storage_pools_ret *ret);
@@ -741,6 +846,7 @@ static int remoteDispatchNumOfDomains(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_domains_ret *ret);
@@ -748,6 +854,7 @@ static int remoteDispatchNumOfInterfaces(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_interfaces_ret *ret);
@@ -755,6 +862,7 @@ static int remoteDispatchNumOfNetworks(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_networks_ret *ret);
@@ -762,6 +870,7 @@ static int remoteDispatchNumOfStoragePools(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
void *args,
remote_num_of_storage_pools_ret *ret);
@@ -769,6 +878,7 @@ static int remoteDispatchOpen(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_open_args *args,
void *ret);
@@ -776,6 +886,7 @@ static int remoteDispatchStoragePoolBuild(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_build_args *args,
void *ret);
@@ -783,6 +894,7 @@ static int remoteDispatchStoragePoolCreate(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_create_args *args,
void *ret);
@@ -790,6 +902,7 @@ static int remoteDispatchStoragePoolCreateXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_create_xml_args *args,
remote_storage_pool_create_xml_ret *ret);
@@ -797,6 +910,7 @@ static int remoteDispatchStoragePoolDefineXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_define_xml_args *args,
remote_storage_pool_define_xml_ret *ret);
@@ -804,6 +918,7 @@ static int remoteDispatchStoragePoolDelete(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_delete_args *args,
void *ret);
@@ -811,6 +926,7 @@ static int remoteDispatchStoragePoolDestroy(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_destroy_args *args,
void *ret);
@@ -818,6 +934,7 @@ static int remoteDispatchStoragePoolDumpXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_dump_xml_args *args,
remote_storage_pool_dump_xml_ret *ret);
@@ -825,6 +942,7 @@ static int remoteDispatchStoragePoolGetAutostart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_get_autostart_args *args,
remote_storage_pool_get_autostart_ret *ret);
@@ -832,6 +950,7 @@ static int remoteDispatchStoragePoolGetInfo(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_get_info_args *args,
remote_storage_pool_get_info_ret *ret);
@@ -839,6 +958,7 @@ static int remoteDispatchStoragePoolListVolumes(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_list_volumes_args *args,
remote_storage_pool_list_volumes_ret *ret);
@@ -846,6 +966,7 @@ static int remoteDispatchStoragePoolLookupByName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_lookup_by_name_args *args,
remote_storage_pool_lookup_by_name_ret *ret);
@@ -853,6 +974,7 @@ static int remoteDispatchStoragePoolLookupByUuid(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_lookup_by_uuid_args *args,
remote_storage_pool_lookup_by_uuid_ret *ret);
@@ -860,6 +982,7 @@ static int remoteDispatchStoragePoolLookupByVolume(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_lookup_by_volume_args *args,
remote_storage_pool_lookup_by_volume_ret *ret);
@@ -867,6 +990,7 @@ static int remoteDispatchStoragePoolNumOfVolumes(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_num_of_volumes_args *args,
remote_storage_pool_num_of_volumes_ret *ret);
@@ -874,6 +998,7 @@ static int remoteDispatchStoragePoolRefresh(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_refresh_args *args,
void *ret);
@@ -881,6 +1006,7 @@ static int remoteDispatchStoragePoolSetAutostart(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_set_autostart_args *args,
void *ret);
@@ -888,6 +1014,7 @@ static int remoteDispatchStoragePoolUndefine(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_pool_undefine_args *args,
void *ret);
@@ -895,6 +1022,7 @@ static int remoteDispatchStorageVolCreateXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_create_xml_args *args,
remote_storage_vol_create_xml_ret *ret);
@@ -902,6 +1030,7 @@ static int remoteDispatchStorageVolCreateXmlFrom(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_create_xml_from_args *args,
remote_storage_vol_create_xml_from_ret *ret);
@@ -909,6 +1038,7 @@ static int remoteDispatchStorageVolDelete(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_delete_args *args,
void *ret);
@@ -916,6 +1046,7 @@ static int remoteDispatchStorageVolDumpXml(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_dump_xml_args *args,
remote_storage_vol_dump_xml_ret *ret);
@@ -923,6 +1054,7 @@ static int remoteDispatchStorageVolGetInfo(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_get_info_args *args,
remote_storage_vol_get_info_ret *ret);
@@ -930,6 +1062,7 @@ static int remoteDispatchStorageVolGetPath(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_get_path_args *args,
remote_storage_vol_get_path_ret *ret);
@@ -937,6 +1070,7 @@ static int remoteDispatchStorageVolLookupByKey(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_lookup_by_key_args *args,
remote_storage_vol_lookup_by_key_ret *ret);
@@ -944,6 +1078,7 @@ static int remoteDispatchStorageVolLookupByName(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_lookup_by_name_args *args,
remote_storage_vol_lookup_by_name_ret *ret);
@@ -951,6 +1086,7 @@ static int remoteDispatchStorageVolLookupByPath(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_storage_vol_lookup_by_path_args *args,
remote_storage_vol_lookup_by_path_ret *ret);
@@ -958,6 +1094,7 @@ static int remoteDispatchSupportsFeature(
struct qemud_server *server,
struct qemud_client *client,
virConnectPtr conn,
+ remote_message_header *hdr,
remote_error *err,
remote_supports_feature_args *args,
remote_supports_feature_ret *ret);
diff --git a/qemud/remote_generate_stubs.pl b/qemud/remote_generate_stubs.pl
index 9bca0cc..8b26e3d 100755
--- a/qemud/remote_generate_stubs.pl
+++ b/qemud/remote_generate_stubs.pl
@@ -115,6 +115,7 @@ elsif ($opt_p) {
print " struct qemud_server *server,\n";
print " struct qemud_client *client,\n";
print " virConnectPtr conn,\n";
+ print " remote_message_header *hdr,\n";
print " remote_error *err,\n";
print " $calls{$_}->{args} *args,\n";
print " $calls{$_}->{ret} *ret);\n";
--
1.6.2.5
3:51 p.m.
New subject: [libvirt] [PATCH 11/11] DEMO: Implement get/put in remote driver client & libvirtd
* qemud/remote.c: Implement remoteDispatchPutFile and
remoteDispatchGetFile API handlers
* qemud/remote_protocol.x: Define wire protocol for the
virConnectGetFile/PutFile APIs
* qemud/remote_protocol.c, qemud/remote_protocol.h,
qemud/remote_dispatch_table.h, qemud/remote_dispatch_prototypes.h,
qemud/remote_dispatch_args.h: Re-generate
* src/remote_internal.c: Client side of get/put APIs
---
qemud/remote.c | 64 ++++++++++++++++++++++++++++++
qemud/remote_dispatch_args.h | 2 +
qemud/remote_dispatch_prototypes.h | 16 +++++++
qemud/remote_dispatch_table.h | 10 +++++
qemud/remote_protocol.c | 18 ++++++++
qemud/remote_protocol.h | 16 +++++++
qemud/remote_protocol.x | 13 +++++-
src/remote_internal.c | 77 ++++++++++++++++++++++++++++++++++--
8 files changed, 210 insertions(+), 6 deletions(-)
diff --git a/qemud/remote.c b/qemud/remote.c
index 3034023..ff060b3 100644
--- a/qemud/remote.c
+++ b/qemud/remote.c
@@ -55,6 +55,7 @@
#include "datatypes.h"
#include "memory.h"
#include "util.h"
+#include "stream.h"
#define VIR_FROM_THIS VIR_FROM_REMOTE
#define REMOTE_DEBUG(fmt, ...) DEBUG(fmt, __VA_ARGS__)
@@ -4554,6 +4555,69 @@ remoteDispatchNodeDeviceDestroy(struct qemud_server *server
ATTRIBUTE_UNUSED,
return 0;
}
+static int remoteDispatchPutFile(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *rerr,
+ remote_put_file_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ struct qemud_client_stream *stream;
+
+ stream = remoteCreateClientStream(conn, hdr);
+ if (!stream) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virConnectPutFile(conn, args->name, stream->st) < 0) {
+ remoteDispatchConnError(rerr, conn);
+ remoteFreeClientStream(client, stream);
+ return -1;
+ }
+
+ if (remoteAddClientStream(client, stream) < 0) {
+ remoteDispatchConnError(rerr, conn);
+ virStreamAbort(stream->st);
+ remoteFreeClientStream(client, stream);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchGetFile(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *rerr,
+ remote_get_file_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ struct qemud_client_stream *stream;
+
+ stream = remoteCreateClientStream(conn, hdr);
+ if (!stream) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virConnectGetFile(conn, args->name, stream->st) < 0) {
+ remoteDispatchConnError(rerr, conn);
+ remoteFreeClientStream(client, stream);
+ return -1;
+ }
+
+ if (remoteAddClientStream(client, stream) < 0) {
+ remoteDispatchConnError(rerr, conn);
+ virStreamAbort(stream->st);
+ remoteFreeClientStream(client, stream);
+ return -1;
+ }
+
+ return 0;
+}
diff --git a/qemud/remote_dispatch_args.h b/qemud/remote_dispatch_args.h
index 9dacfb8..e0415cb 100644
--- a/qemud/remote_dispatch_args.h
+++ b/qemud/remote_dispatch_args.h
@@ -117,3 +117,5 @@
remote_domain_xml_from_native_args val_remote_domain_xml_from_native_args;
remote_domain_xml_to_native_args val_remote_domain_xml_to_native_args;
remote_list_defined_interfaces_args val_remote_list_defined_interfaces_args;
+ remote_put_file_args val_remote_put_file_args;
+ remote_get_file_args val_remote_get_file_args;
diff --git a/qemud/remote_dispatch_prototypes.h b/qemud/remote_dispatch_prototypes.h
index a25ea16..1814aba 100644
--- a/qemud/remote_dispatch_prototypes.h
+++ b/qemud/remote_dispatch_prototypes.h
@@ -434,6 +434,14 @@ static int remoteDispatchGetCapabilities(
remote_error *err,
void *args,
remote_get_capabilities_ret *ret);
+static int remoteDispatchGetFile(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_get_file_args *args,
+ void *ret);
static int remoteDispatchGetHostname(
struct qemud_server *server,
struct qemud_client *client,
@@ -882,6 +890,14 @@ static int remoteDispatchOpen(
remote_error *err,
remote_open_args *args,
void *ret);
+static int remoteDispatchPutFile(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_put_file_args *args,
+ void *ret);
static int remoteDispatchStoragePoolBuild(
struct qemud_server *server,
struct qemud_client *client,
diff --git a/qemud/remote_dispatch_table.h b/qemud/remote_dispatch_table.h
index 449786d..1325ac5 100644
--- a/qemud/remote_dispatch_table.h
+++ b/qemud/remote_dispatch_table.h
@@ -697,3 +697,13 @@
.args_filter = (xdrproc_t) xdr_remote_list_defined_interfaces_args,
.ret_filter = (xdrproc_t) xdr_remote_list_defined_interfaces_ret,
},
+{ /* PutFile => 139 */
+ .fn = (dispatch_fn) remoteDispatchPutFile,
+ .args_filter = (xdrproc_t) xdr_remote_put_file_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* GetFile => 140 */
+ .fn = (dispatch_fn) remoteDispatchGetFile,
+ .args_filter = (xdrproc_t) xdr_remote_get_file_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
diff --git a/qemud/remote_protocol.c b/qemud/remote_protocol.c
index 7b46096..279a590 100644
--- a/qemud/remote_protocol.c
+++ b/qemud/remote_protocol.c
@@ -2534,6 +2534,24 @@ xdr_remote_domain_xml_to_native_ret (XDR *xdrs,
remote_domain_xml_to_native_ret
}
bool_t
+xdr_remote_put_file_args (XDR *xdrs, remote_put_file_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_get_file_args (XDR *xdrs, remote_get_file_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
{
diff --git a/qemud/remote_protocol.h b/qemud/remote_protocol.h
index 2ff9075..394b982 100644
--- a/qemud/remote_protocol.h
+++ b/qemud/remote_protocol.h
@@ -1429,6 +1429,16 @@ struct remote_domain_xml_to_native_ret {
remote_nonnull_string nativeConfig;
};
typedef struct remote_domain_xml_to_native_ret remote_domain_xml_to_native_ret;
+
+struct remote_put_file_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_put_file_args remote_put_file_args;
+
+struct remote_get_file_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_get_file_args remote_get_file_args;
#define REMOTE_PROGRAM 0x20008086
#define REMOTE_PROTOCOL_VERSION 1
@@ -1571,6 +1581,8 @@ enum remote_procedure {
REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
+ REMOTE_PROC_PUT_FILE = 139,
+ REMOTE_PROC_GET_FILE = 140,
};
typedef enum remote_procedure remote_procedure;
@@ -1835,6 +1847,8 @@ extern bool_t xdr_remote_domain_xml_from_native_args (XDR *,
remote_domain_xml_
extern bool_t xdr_remote_domain_xml_from_native_ret (XDR *,
remote_domain_xml_from_native_ret*);
extern bool_t xdr_remote_domain_xml_to_native_args (XDR *,
remote_domain_xml_to_native_args*);
extern bool_t xdr_remote_domain_xml_to_native_ret (XDR *,
remote_domain_xml_to_native_ret*);
+extern bool_t xdr_remote_put_file_args (XDR *, remote_put_file_args*);
+extern bool_t xdr_remote_get_file_args (XDR *, remote_get_file_args*);
extern bool_t xdr_remote_procedure (XDR *, remote_procedure*);
extern bool_t xdr_remote_message_type (XDR *, remote_message_type*);
extern bool_t xdr_remote_message_status (XDR *, remote_message_status*);
@@ -2073,6 +2087,8 @@ extern bool_t xdr_remote_domain_xml_from_native_args ();
extern bool_t xdr_remote_domain_xml_from_native_ret ();
extern bool_t xdr_remote_domain_xml_to_native_args ();
extern bool_t xdr_remote_domain_xml_to_native_ret ();
+extern bool_t xdr_remote_put_file_args ();
+extern bool_t xdr_remote_get_file_args ();
extern bool_t xdr_remote_procedure ();
extern bool_t xdr_remote_message_type ();
extern bool_t xdr_remote_message_status ();
diff --git a/qemud/remote_protocol.x b/qemud/remote_protocol.x
index e24c428..42c71ca 100644
--- a/qemud/remote_protocol.x
+++ b/qemud/remote_protocol.x
@@ -1272,6 +1272,14 @@ struct remote_domain_xml_to_native_ret {
};
+struct remote_put_file_args {
+ remote_nonnull_string name;
+};
+
+struct remote_get_file_args {
+ remote_nonnull_string name;
+};
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
@@ -1428,9 +1436,10 @@ enum remote_procedure {
REMOTE_PROC_INTERFACE_DESTROY = 134,
REMOTE_PROC_DOMAIN_XML_FROM_NATIVE = 135,
REMOTE_PROC_DOMAIN_XML_TO_NATIVE = 136,
-
REMOTE_PROC_NUM_OF_DEFINED_INTERFACES = 137,
- REMOTE_PROC_LIST_DEFINED_INTERFACES = 138
+ REMOTE_PROC_LIST_DEFINED_INTERFACES = 138,
+ REMOTE_PROC_PUT_FILE = 139,
+ REMOTE_PROC_GET_FILE = 140
};
diff --git a/src/remote_internal.c b/src/remote_internal.c
index c8ea1a3..8b1d1c6 100644
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -6348,7 +6348,6 @@ done:
}
-#if 0
static struct private_stream_data *
remoteStreamOpen(virStreamPtr st,
int output ATTRIBUTE_UNUSED,
@@ -6699,7 +6698,77 @@ static virStreamDriver remoteStreamDrv = {
.streamUpdateCallback = remoteStreamEventUpdateCallback,
.streamRemoveCallback = remoteStreamEventRemoveCallback,
};
-#endif
+
+static int
+remoteConnectPutFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st)
+{
+ struct private_data *priv = conn->privateData;
+ struct private_stream_data *privst = NULL;
+ int rv = -1;
+ remote_put_file_args args;
+
+ remoteDriverLock(priv);
+
+ if (!(privst = remoteStreamOpen(st, 1, REMOTE_PROC_PUT_FILE, priv->counter)))
+ goto done;
+
+ st->driver = &remoteStreamDrv;
+ st->privateData = privst;
+
+ args.name = (char *) name;
+
+ if (call (conn, priv, 0, REMOTE_PROC_PUT_FILE,
+ (xdrproc_t) xdr_remote_put_file_args, (char *) &args,
+ (xdrproc_t) xdr_void, NULL) == -1) {
+ remoteStreamRelease(st);
+ goto done;
+ }
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+
+ return rv;
+}
+
+
+static int
+remoteConnectGetFile(virConnectPtr conn,
+ const char *name,
+ virStreamPtr st)
+{
+ struct private_data *priv = conn->privateData;
+ struct private_stream_data *privst = NULL;
+ int rv = -1;
+ remote_put_file_args args;
+
+ remoteDriverLock(priv);
+
+ if (!(privst = remoteStreamOpen(st, 1, REMOTE_PROC_GET_FILE, priv->counter)))
+ goto done;
+
+ st->driver = &remoteStreamDrv;
+ st->privateData = privst;
+
+ args.name = (char *) name;
+
+ if (call (conn, priv, 0, REMOTE_PROC_GET_FILE,
+ (xdrproc_t) xdr_remote_put_file_args, (char *) &args,
+ (xdrproc_t) xdr_void, NULL) == -1) {
+ remoteStreamRelease(st);
+ goto done;
+ }
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+
+ return rv;
+}
/*----------------------------------------------------------------------*/
@@ -8047,8 +8116,8 @@ static virDriver remote_driver = {
remoteNodeDeviceDettach, /* nodeDeviceDettach */
remoteNodeDeviceReAttach, /* nodeDeviceReAttach */
remoteNodeDeviceReset, /* nodeDeviceReset */
- NULL,
- NULL,
+ remoteConnectPutFile,
+ remoteConnectGetFile,
};
static virNetworkDriver network_driver = {
--
1.6.2.5
7:35 a.m.
Daniel P. Berrange wrote:
The immediate use case for this data stream code is Chris' QEMU
migration patchset.
The next use case is to allow serial console access to be tunnelled
over libvirtd, eg to make 'virsh console GUEST' work remotely.
This use case is why I included the support for non-blocking data
streams and event loop integration (not required for Chris'
migration use case)
Anyway, assuming Chris confirms that I've not broken his code, then
patches 1-6 are targetted for this next release.
I'm sorry for the very long delay in getting back to this. I've been playing
around with my tunnelled migration patches on top of this code, and I just can't
seem to make the new nonblocking stuff work properly. I'm getting a couple of
behaviors that are highly undesirable:
1) Immediately after starting the stream, I get a virStreamRecv() callback on
the destination side. The problem is that this is wrong for migration; there's
no data that I can read *from* the destination qemu process which makes any
sense. While I could implement the method and just throw away the data, that
doesn't seem right to me. This leads to...
2) A crash in libvirtd on the source side of the destination. It doesn't
happen every single time, but when it has happened I've traced it down to the
fact that src/remote_internal.c:remoteDomainEventFired() can get called *after*
conn->privateData has been set to NULL, leading to a SEGV on NULL pointer
dereference. I can provide a core-dump for this if needed.
3) (minor) The python bindings refuse to build with these patches in place.
It's probably just a matter of fixing up the generator.py, but it needs to be done.
I've uploaded the code that I'm trying out at the moment to:
http://gitorious.org/~clalance/libvirt/clalance-staging/commits/tunnelled...
Dan, can you take a look and make any suggestions about where I might be going
wrong? If you want to test out the tunnelled migration yourself, you'll need to
make sure you at least have the "exec non-blocking patch" (i.e. c/s
907500095851230a480b14bc852c4e49d32cb16d from the upstream qemu repo) in place.
I have a qemu F-11 package with this patch in it available at:
http://people.redhat.com/clalance/qemu-exec-nonblock
--
Chris Lalancette
12:38 p.m.
On Tue, Sep 15, 2009 at 02:35:02PM +0200, Chris Lalancette wrote:
I've uploaded the code that I'm trying out at the moment to:
http://gitorious.org/~clalance/libvirt/clalance-staging/commits/tunnelled...
Dan, can you take a look and make any suggestions about where I might be going
wrong?
I've not look at your migration code yet, but there's a mistake in your
change to the test driver.
http://gitorious.org/~clalance/libvirt/clalance-staging/commit/e77dc1f1ba...
The test driver is delibrately not using saferead/write because those
helpers do not handle EAGAIN. If you get EGAIN they'll return -1 and
you are left with no idea how much data you've written which is not
helpful :-) At very least this will cause the stream to terminate with
an error message. If I got something wrong, perhaps its causing a crash.
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
2:35 a.m.
Daniel P. Berrange wrote:
On Tue, Sep 15, 2009 at 02:35:02PM +0200, Chris Lalancette wrote:
> I've uploaded the code that I'm trying out at the moment to:
>
> http://gitorious.org/~clalance/libvirt/clalance-staging/commits/tunnelled...
>
> Dan, can you take a look and make any suggestions about where I might be going
> wrong?
I've not look at your migration code yet, but there's a mistake in your
change to the test driver.
http://gitorious.org/~clalance/libvirt/clalance-staging/commit/e77dc1f1ba...
The test driver is delibrately not using saferead/write because those
helpers do not handle EAGAIN. If you get EGAIN they'll return -1 and
you are left with no idea how much data you've written which is not
helpful :-) At very least this will cause the stream to terminate with
an error message. If I got something wrong, perhaps its causing a crash.
Ah, I see. I've switched that back, and switched over my tunnelled
implementation as well, but it doesn't seem to have an effect on my problem.
--
Chris Lalancette
3:54 p.m.
On Wed, Sep 16, 2009 at 09:35:21AM +0200, Chris Lalancette wrote:
Daniel P. Berrange wrote:
> On Tue, Sep 15, 2009 at 02:35:02PM +0200, Chris Lalancette wrote:
>> I've uploaded the code that I'm trying out at the moment to:
>>
>>
http://gitorious.org/~clalance/libvirt/clalance-staging/commits/tunnelled...
>>
>> Dan, can you take a look and make any suggestions about where I might be going
>> wrong?
>
> I've not look at your migration code yet, but there's a mistake in your
> change to the test driver.
>
>
http://gitorious.org/~clalance/libvirt/clalance-staging/commit/e77dc1f1ba...
>
> The test driver is delibrately not using saferead/write because those
> helpers do not handle EAGAIN. If you get EGAIN they'll return -1 and
> you are left with no idea how much data you've written which is not
> helpful :-) At very least this will cause the stream to terminate with
> an error message. If I got something wrong, perhaps its causing a crash.
Ah, I see. I've switched that back, and switched over my tunnelled
implementation as well, but it doesn't seem to have an effect on my problem.
I still see a safewrite() in the your virStreamWrite() impl in the
code currently pushed to gitorious.or, but perhaps you've changed
that locally already. The other thing is that if the stream open
flags included VIR_STREAM_NONBLOCK, you must make sur eyou put your
socket in non-blocking mode, eg
if ((st->flags & VIR_STREAM_NONBLOCK) &&
virSetNonBlock(create ? fds[1] : fds[0]) < 0) {
virReportSystemError(st->conn, errno, "%s",
_("cannot make stream non-blocking"));
goto error;
}
in your stream open method. That shouldn't have caused a crash though - it
would merely make libvirtd non-responsive for a while it QEMU blocked
the incoming migration socket.
All in all though the code looks reasonable and I don't see any obvious
problems. I'll have to try running it to see if any crash appears....
Regards,
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
9:21 a.m.
Daniel P. Berrange wrote:
I still see a safewrite() in the your virStreamWrite() impl in the
code currently pushed to gitorious.or, but perhaps you've changed
that locally already. The other thing is that if the stream open
Yeah, sorry, I just never pushed it up to gitorious. I'll make the changes
along with the virSetNonBlock() and push it up there, probably tomorrow.
flags included VIR_STREAM_NONBLOCK, you must make sur eyou put your
socket in non-blocking mode, eg
if ((st->flags & VIR_STREAM_NONBLOCK) &&
virSetNonBlock(create ? fds[1] : fds[0]) < 0) {
virReportSystemError(st->conn, errno, "%s",
_("cannot make stream non-blocking"));
goto error;
}
in your stream open method. That shouldn't have caused a crash though - it
would merely make libvirtd non-responsive for a while it QEMU blocked
the incoming migration socket.
All in all though the code looks reasonable and I don't see any obvious
problems. I'll have to try running it to see if any crash appears....
Thanks.
--
Chris Lalancette
9:29 a.m.
On Tue, Sep 15, 2009 at 02:35:02PM +0200, Chris Lalancette wrote:
Daniel P. Berrange wrote:
> The immediate use case for this data stream code is Chris' QEMU
> migration patchset.
>
> The next use case is to allow serial console access to be tunnelled
> over libvirtd, eg to make 'virsh console GUEST' work remotely.
> This use case is why I included the support for non-blocking data
> streams and event loop integration (not required for Chris'
> migration use case)
>
> Anyway, assuming Chris confirms that I've not broken his code, then
> patches 1-6 are targetted for this next release.
I'm sorry for the very long delay in getting back to this. I've been playing
around with my tunnelled migration patches on top of this code, and I just can't
seem to make the new nonblocking stuff work properly. I'm getting a couple of
behaviors that are highly undesirable:
1) Immediately after starting the stream, I get a virStreamRecv() callback on
the destination side. The problem is that this is wrong for migration; there's
no data that I can read *from* the destination qemu process which makes any
sense. While I could implement the method and just throw away the data, that
doesn't seem right to me. This leads to...
I realize this is due to the remoteAddClientStream() method in
qemud/stream.c. It unconditionally sets 'stream->tx' to 1. I
didn't notice the problem myself, since the test driver is using
pipes which are unidirectional, but yor UNIX domain socket is
bi-directional.
We could either add a flag to remoteAddClientStream() to indicate
whether the stream should allow read or write or both. Or you
might be able to call shutdown(sockfd, SHUT_RD) on your UNIX
socket to indicate that its only going to be used for write
effectively making it unidirectional.
A 3rd option is to define more flags for virStreamNew(), one for
READ, one for WRITE, and have the remote daemon pay attention to
these
2) A crash in libvirtd on the source side of the destination. It
doesn't
happen every single time, but when it has happened I've traced it down to the
fact that src/remote_internal.c:remoteDomainEventFired() can get called *after*
conn->privateData has been set to NULL, leading to a SEGV on NULL pointer
dereference. I can provide a core-dump for this if needed.
I don't have any explanation for this - its a little wierd and we ought
to try and figure it out if possible.
3) (minor) The python bindings refuse to build with these patches in
place.
Yeah I completely forgot to add rules for virSecret APIs there
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
3:07 a.m.
Daniel P. Berrange wrote:
> 1) Immediately after starting the stream, I get a
virStreamRecv() callback on
> the destination side. The problem is that this is wrong for migration; there's
> no data that I can read *from* the destination qemu process which makes any
> sense. While I could implement the method and just throw away the data, that
> doesn't seem right to me. This leads to...
I realize this is due to the remoteAddClientStream() method in
qemud/stream.c. It unconditionally sets 'stream->tx' to 1. I
didn't notice the problem myself, since the test driver is using
pipes which are unidirectional, but yor UNIX domain socket is
bi-directional.
We could either add a flag to remoteAddClientStream() to indicate
whether the stream should allow read or write or both. Or you
might be able to call shutdown(sockfd, SHUT_RD) on your UNIX
socket to indicate that its only going to be used for write
effectively making it unidirectional.
I tried the shutdown(sockfd, SHUT_RD) method, without success. Then I commented
out the stream->tx = 1 line as a test, and the migration (mostly) worked. At
least, it transferred the data to the other side, at which point trying to
"virsh console" on the destination side caused a libvirtd segfault again. So
your idea is correct, although I think we still have a problem with the cleanup
of the stream. I'm still debugging that.
--
Chris Lalancette
12:25 p.m.
In looking at your migration patches I realized we could tweak
things a little bit to allow the implementation of a new style
migration API which does not require the destination virConnectPtr
object. More importantly this could be used independantly of
the tunnelled migration. So the patch that follows takes the
public API bits of your migration code and adds a new flag
VIR_MIGRATE_PEER2PEER, and virDomainMigrateToURI method. It
implements it for the Xen driver.
For the QEMU driver you already have code which copes with the
combination of VIR_MIGRATE_PEER2PEER + VIR_MIGRATE_TUNNELLED.
We could easily adapt that to also cope with doing a migration
using VIR_MIGRATE_PEER2PEER on its own. ie, source libvirtd
opens connection to destination libvirtd, runs the existing
prepare method, then uses QEMU monitor todo a plain TCP migration
and then invokes the existing finish method.
This patch applies between the data streams code & your migration
code - it'll clash a little - it ought to cover everything you
have relating to the public API with exception of the new internal
method virDomainMigratePrepareTunnel
Regards,
Daniel
12:25 p.m.
New subject: [libvirt] [PATCH] Support a new peer-to-peer migration mode & public API
Introduces several new public API options for migration
- VIR_MIGRATE_PEER2PEER: With this flag the client only
invokes the virDomainMigratePerform method, expecting
the source host driver to do whatever is required to
complete the entire migration process.
- VIR_MIGRATE_TUNNELLED: With this flag the actual data
for migration will be tunnelled over the libvirtd RPC
channel. This requires that VIR_MIGRATE_PEER2PEER is
also set.
- virDomainMigrateToURI: This is variant of the existing
virDomainMigrate method which can be used when the
VIR_MIGRATE_PEER2PEER flag is set. The benefit of this
method is that no virConnectPtr object is required for
the destination host, only a destination URI.
The URI for VIR_MIGRATE_TUNNELLED must be a valid libvirt
URI. For non-tunnelled migration a hypervisor specific
migration URI is used.
* include/libvirt/libvirt.h, include/libvirt/libvirt.h.in:
Add VIR_MIGRATE_PEER2PEER, VIR_MIGRATE_TUNNELLED and
virDomainMigrateToURI.
* src/driver.h: Remove feature flags
* src/libvirt_internal.h: Add feature flags, and include
new VIR_FEATURE_MIGRATE_P2P indicating support for the
new VIR_MIGRATE_PEER2PEER mode.
* src/libvirt.c: Implement support for VIR_MIGRATE_PEER2PEER
and virDomainMigrateToURI APIs.
* src/virsh.c: Add --p2p and --tunnelled args and use the
new virDomainMigrateToURI method where possible.
* src/xen_unified.c: Advertise support for P2P migration
* src/xend_internal.c: Accept VIR_MIGRATE_PEER2PEER flag.
* src/libvirt_public.syms: Export virDomainMigrateToURI
method
---
include/libvirt/libvirt.h | 8 ++-
include/libvirt/libvirt.h.in | 8 ++-
src/driver.h | 19 ----
src/internal.h | 2 +
src/libvirt.c | 224 +++++++++++++++++++++++++++++++++++++-----
src/libvirt_internal.h | 30 ++++++
src/libvirt_public.syms | 1 +
src/virsh.c | 42 ++++++--
src/xen_unified.c | 7 +-
src/xend_internal.c | 6 +
10 files changed, 286 insertions(+), 61 deletions(-)
diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index 10ec04a..1745396 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -336,7 +336,9 @@ typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr;
/* Domain migration flags. */
typedef enum {
- VIR_MIGRATE_LIVE = 1, /* live migration */
+ VIR_MIGRATE_LIVE = (1 << 0), /* live migration */
+ VIR_MIGRATE_PEER2PEER = (1 << 1), /* direct source -> dest host
control channel */
+ VIR_MIGRATE_TUNNELLED = (1 << 2), /* tunnel migration data over
libvirtd connection */
} virDomainMigrateFlags;
/* Domain migration. */
@@ -344,6 +346,10 @@ virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr
dconn,
unsigned long flags, const char *dname,
const char *uri, unsigned long bandwidth);
+int virDomainMigrateToURI (virDomainPtr domain, const char *duri,
+ unsigned long flags, const char *dname,
+ unsigned long bandwidth);
+
/**
* VIR_NODEINFO_MAXCPUS:
* @nodeinfo: virNodeInfo instance
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 012d30e..5e1a500 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -336,7 +336,9 @@ typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr;
/* Domain migration flags. */
typedef enum {
- VIR_MIGRATE_LIVE = 1, /* live migration */
+ VIR_MIGRATE_LIVE = (1 << 0), /* live migration */
+ VIR_MIGRATE_PEER2PEER = (1 << 1), /* direct source -> dest host
control channel */
+ VIR_MIGRATE_TUNNELLED = (1 << 2), /* tunnel migration data over
libvirtd connection */
} virDomainMigrateFlags;
/* Domain migration. */
@@ -344,6 +346,10 @@ virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr
dconn,
unsigned long flags, const char *dname,
const char *uri, unsigned long bandwidth);
+int virDomainMigrateToURI (virDomainPtr domain, const char *duri,
+ unsigned long flags, const char *dname,
+ unsigned long bandwidth);
+
/**
* VIR_NODEINFO_MAXCPUS:
* @nodeinfo: virNodeInfo instance
diff --git a/src/driver.h b/src/driver.h
index 6a3dcc2..893e98b 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -44,25 +44,6 @@ typedef enum {
VIR_DRV_OPEN_ERROR = -2,
} virDrvOpenStatus;
-/* Feature detection. This is a libvirt-private interface for determining
- * what features are supported by the driver.
- *
- * The remote driver passes features through to the real driver at the
- * remote end unmodified, except if you query a VIR_DRV_FEATURE_REMOTE*
- * feature.
- */
- /* Driver supports V1-style virDomainMigrate, ie. domainMigratePrepare/
- * domainMigratePerform/domainMigrateFinish.
- */
-#define VIR_DRV_FEATURE_MIGRATION_V1 1
-
- /* Driver is not local. */
-#define VIR_DRV_FEATURE_REMOTE 2
-
- /* Driver supports V2-style virDomainMigrate, ie. domainMigratePrepare2/
- * domainMigratePerform/domainMigrateFinish2.
- */
-#define VIR_DRV_FEATURE_MIGRATION_V2 3
/* Internal feature-detection macro. Don't call drv->supports_feature
* directly, because it may be NULL, use this macro instead.
diff --git a/src/internal.h b/src/internal.h
index 8fa579c..bd1cfe6 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -24,6 +24,8 @@
#include "libvirt/libvirt.h"
#include "libvirt/virterror.h"
+#include "libvirt_internal.h"
+
/* On architectures which lack these limits, define them (ie. Cygwin).
* Note that the libvirt code should be robust enough to handle the
* case where actual value is longer than these limits (eg. by setting
diff --git a/src/libvirt.c b/src/libvirt.c
index 124e5db..481afec 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -35,7 +35,6 @@
#include "virterror_internal.h"
#include "logging.h"
#include "datatypes.h"
-#include "libvirt_internal.h"
#include "driver.h"
#include "uuid.h"
@@ -3059,6 +3058,38 @@ virDomainMigrateVersion2 (virDomainPtr domain,
return ddomain;
}
+
+ /*
+ * This is sort of a migration v3
+ *
+ * This performs a peer-2-peer migration where source host
+ * does all the communication with the destination host.
+ */
+static int
+virDomainMigrateP2P (virDomainPtr domain,
+ unsigned long flags,
+ const char *dname,
+ const char *uri,
+ unsigned long bandwidth)
+{
+ if (!domain->conn->driver->domainMigratePerform) {
+ virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ return -1;
+ }
+
+ /* Perform the migration. The driver isn't supposed to return
+ * until the migration is complete.
+ */
+ return domain->conn->driver->domainMigratePerform(domain,
+ NULL, /* cookie */
+ 0, /* cookielen */
+ uri,
+ flags,
+ dname,
+ bandwidth);
+}
+
+
/**
* virDomainMigrate:
* @domain: a domain object
@@ -3072,22 +3103,34 @@ virDomainMigrateVersion2 (virDomainPtr domain,
* host given by dconn (a connection to the destination host).
*
* Flags may be one of more of the following:
- * VIR_MIGRATE_LIVE Attempt a live migration.
+ * VIR_MIGRATE_LIVE Do not pause the VM during migration
+ * VIR_MIGRATE_PEER2PEER Direct connection between source & destination hosts
+ * VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel
+ *
+ * VIR_MIGRATE_TUNNELLED requires that VIR_MIGRATE_PEER2PEER be set.
+ * Applications using the VIR_MIGRATE_PEER2PEER flag will probably
+ * prefer to invoke virDomainMigrateToURI, avoiding the need to
+ * open connection to the destination host themselves.
*
* If a hypervisor supports renaming domains during migration,
* then you may set the dname parameter to the new name (otherwise
* it keeps the same name). If this is not supported by the
* hypervisor, dname must be NULL or else you will get an error.
*
- * Since typically the two hypervisors connect directly to each
- * other in order to perform the migration, you may need to specify
- * a path from the source to the destination. This is the purpose
- * of the uri parameter. If uri is NULL, then libvirt will try to
- * find the best method. Uri may specify the hostname or IP address
- * of the destination host as seen from the source. Or uri may be
- * a URI giving transport, hostname, user, port, etc. in the usual
- * form. Refer to driver documentation for the particular URIs
- * supported.
+ * If the VIR_MIGRATE_TUNNELLED flag is set, the uri parameter
+ * must be a valid libvirt connection URI, by which the source
+ * libvirt driver can connect to the destination libvirt. If
+ * omitted, the dconn connection object will be queried for its
+ * current URI.
+ *
+ * If the VIR_MIGRATE_TUNNELED flag is NOT set, the URI parameter
+ * takes a hypervisor specific format. The hypervisor capabilities
+ * XML includes details of the support URI schemes. If omitted
+ * the dconn will be asked for a default URI.
+ *
+ * In either case it is typically only neccessary to specify a
+ * URI if the destination host has multiple interfaces and a
+ * specific interface is required to transmit migration data.
*
* The maximum bandwidth (in Mbps) that will be used to do migration
* can be specified with the bandwidth parameter. If set to 0,
@@ -3142,24 +3185,50 @@ virDomainMigrate (virDomainPtr domain,
goto error;
}
- /* Check that migration is supported by both drivers. */
- if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
- VIR_DRV_FEATURE_MIGRATION_V1) &&
- VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
- VIR_DRV_FEATURE_MIGRATION_V1))
- ddomain = virDomainMigrateVersion1 (domain, dconn, flags, dname, uri,
bandwidth);
- else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
- VIR_DRV_FEATURE_MIGRATION_V2) &&
- VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
- VIR_DRV_FEATURE_MIGRATION_V2))
- ddomain = virDomainMigrateVersion2 (domain, dconn, flags, dname, uri,
bandwidth);
- else {
- virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
- goto error;
+ if (flags & VIR_MIGRATE_PEER2PEER) {
+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_P2P)) {
+ char *duri = NULL;
+ if (!uri)
+ duri = virConnectGetURI(dconn);
+
+ if (virDomainMigrateP2P (domain, flags, dname, uri ? uri : duri, bandwidth)
< 0) {
+ VIR_FREE(duri);
+ goto error;
+ }
+ VIR_FREE(duri);
+
+ ddomain = virDomainLookupByName (dconn, dname ? dname : domain->name);
+ } else {
+ virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ goto error;
+ }
+ } else {
+ if (flags & VIR_MIGRATE_TUNNELLED) {
+ virLibConnError(domain->conn, VIR_ERR_OPERATION_INVALID,
+ _("cannot perform tunnelled migration without using
peer2peer flag"));
+ goto error;
+ }
+
+ /* Check that migration is supported by both drivers. */
+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_V1) &&
+ VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
+ VIR_DRV_FEATURE_MIGRATION_V1))
+ ddomain = virDomainMigrateVersion1 (domain, dconn, flags, dname, uri,
bandwidth);
+ else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_V2) &&
+ VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
+ VIR_DRV_FEATURE_MIGRATION_V2))
+ ddomain = virDomainMigrateVersion2 (domain, dconn, flags, dname, uri,
bandwidth);
+ else {
+ virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ goto error;
+ }
}
- if (ddomain == NULL)
- goto error;
+ if (ddomain == NULL)
+ goto error;
return ddomain;
@@ -3169,6 +3238,107 @@ error:
return NULL;
}
+
+/**
+ * virDomainMigrateToURI:
+ * @domain: a domain object
+ * @duri: libvirt connection URI for destination host
+ * @flags: flags
+ * @dname: (optional) rename domain to this at destination
+ * @bandwidth: (optional) specify migration bandwidth limit in Mbps
+ *
+ * Migrate the domain object from its current host to the destination
+ * host given by duri. The duri is a libvirt connection URI that the
+ * source host will use to talk to the destination.
+ *
+ * The difference from the regular virDomainMigrate method is
+ * that the calling application does not need a direct connection
+ * to the destination host. The source libvirt driver makes a
+ * direct peer-to-peer connection to the destination libvirtd
+ * without the client appliction being involved.
+ *
+ * The VIR_MIGRATE_PEER2PEER flag is mandatory for this method.
+ * If an application wishes to run without this flag, then it
+ * may use the alternative virDomainMigrate method which requires
+ * an virConnectPtr object for the destination host
+ *
+ * The following additional flags may also be set
+ * VIR_MIGRATE_LIVE Do not pause the VM during migration
+ * VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel
+ *
+ * If a hypervisor supports renaming domains during migration,
+ * then you may set the dname parameter to the new name (otherwise
+ * it keeps the same name). If this is not supported by the
+ * hypervisor, dname must be NULL or else you will get an error.
+ *
+ * The maximum bandwidth (in Mbps) that will be used to do migration
+ * can be specified with the bandwidth parameter. If set to 0,
+ * libvirt will choose a suitable default. Some hypervisors do
+ * not support this feature and will return an error if bandwidth
+ * is not 0.
+ *
+ * To see which features are supported by the current hypervisor,
+ * see virConnectGetCapabilities, /capabilities/host/migration_features.
+ *
+ * There are many limitations on migration imposed by the underlying
+ * technology - for example it may not be possible to migrate between
+ * different processors even with the same architecture, or between
+ * different types of hypervisor.
+ *
+ * Returns 0 if the migration succeeded, -1 upon error.
+ */
+int
+virDomainMigrateToURI (virDomainPtr domain,
+ const char *duri,
+ unsigned long flags,
+ const char *dname,
+ unsigned long bandwidth)
+{
+ DEBUG("domain=%p, duri=%p, flags=%lu, dname=%s, bandwidth=%lu",
+ domain, NULLSTR(duri), flags, NULLSTR(dname), bandwidth);
+
+ virResetLastError();
+
+ /* First checkout the source */
+ if (!VIR_IS_CONNECTED_DOMAIN (domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ return -1;
+ }
+ if (domain->conn->flags & VIR_CONNECT_RO) {
+ virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (duri == NULL) {
+ virLibConnError (domain->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ /* XXX perhaps we should just automatically set this flag instead ? */
+ if (flags & VIR_MIGRATE_PEER2PEER) {
+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_P2P)) {
+ if (virDomainMigrateP2P (domain, flags, dname, duri, bandwidth) < 0)
+ goto error;
+ } else {
+ virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ goto error;
+ }
+ } else {
+ virLibConnError (domain->conn, VIR_ERR_OPERATION_INVALID,
+ _("cannot migrate to a destination URI without peer2peer
flag"));
+ goto error;
+ }
+
+ return 0;
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(domain->conn);
+ return -1;
+}
+
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
index 5913798..5f1a7fe 100644
--- a/src/libvirt_internal.h
+++ b/src/libvirt_internal.h
@@ -17,6 +17,7 @@
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
+ * NB This file is (secret) ABI sensitive. Append only
*/
#ifndef __LIBVIRT_H_
@@ -31,6 +32,35 @@ int virStateReload(void);
int virStateActive(void);
#endif
+/* Feature detection. This is a libvirt-private interface for determining
+ * what features are supported by the driver.
+ *
+ * The remote driver passes features through to the real driver at the
+ * remote end unmodified, except if you query a VIR_DRV_FEATURE_REMOTE*
+ * feature.
+ *
+ */
+enum {
+ /* Driver supports V1-style virDomainMigrate, ie. domainMigratePrepare/
+ * domainMigratePerform/domainMigrateFinish.
+ */
+ VIR_DRV_FEATURE_MIGRATION_V1 = 1,
+
+ /* Driver is not local. */
+ VIR_DRV_FEATURE_REMOTE = 2,
+
+ /* Driver supports V2-style virDomainMigrate, ie. domainMigratePrepare2/
+ * domainMigratePerform/domainMigrateFinish2.
+ */
+ VIR_DRV_FEATURE_MIGRATION_V2 = 3,
+
+ /* Driver supports peer-2-peer virDomainMigrate ie soruce host
+ * do all the prepare/perform/finish steps directly
+ */
+ VIR_DRV_FEATURE_MIGRATION_P2P = 4,
+};
+
+
int virDrvSupportsFeature (virConnectPtr conn, int feature);
int virDomainMigratePrepare (virConnectPtr dconn,
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index 888ea26..757e54c 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -323,6 +323,7 @@ LIBVIRT_0.7.1 {
virStreamFinish;
virStreamAbort;
virStreamFree;
+ virDomainMigrateToURI;
} LIBVIRT_0.7.0;
# .... define new API here using predicted next version number ....
diff --git a/src/virsh.c b/src/virsh.c
index 4825f1c..cabbd3d 100644
--- a/src/virsh.c
+++ b/src/virsh.c
@@ -2463,6 +2463,8 @@ static const vshCmdInfo info_migrate[] = {
static const vshCmdOptDef opts_migrate[] = {
{"live", VSH_OT_BOOL, 0, gettext_noop("live migration")},
+ {"p2p", VSH_OT_BOOL, 0, gettext_noop("peer-2-peer migration")},
+ {"tunnelled", VSH_OT_BOOL, 0, gettext_noop("tunnelled
migration")},
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("domain name, id
or uuid")},
{"desturi", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("connection URI
of the destination host")},
{"migrateuri", VSH_OT_DATA, 0, gettext_noop("migration URI, usually
can be omitted")},
@@ -2478,8 +2480,6 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
const char *migrateuri;
const char *dname;
int flags = 0, found, ret = FALSE;
- virConnectPtr dconn = NULL;
- virDomainPtr ddom = NULL;
if (!vshConnectionUsability (ctl, ctl->conn, TRUE))
return FALSE;
@@ -2500,20 +2500,40 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool (cmd, "live"))
flags |= VIR_MIGRATE_LIVE;
- /* Temporarily connect to the destination host. */
- dconn = virConnectOpenAuth (desturi, virConnectAuthPtrDefault, 0);
- if (!dconn) goto done;
+ if (vshCommandOptBool (cmd, "p2p"))
+ flags |= VIR_MIGRATE_PEER2PEER;
- /* Migrate. */
- ddom = virDomainMigrate (dom, dconn, flags, dname, migrateuri, 0);
- if (!ddom) goto done;
+ if (vshCommandOptBool (cmd, "tunnelled"))
+ flags |= VIR_MIGRATE_TUNNELLED;
- ret = TRUE;
+ if ((flags & VIR_MIGRATE_PEER2PEER)) {
+ /* For peer2peer migration we only expect one URI, a libvirt URI */
+
+ if (migrateuri != NULL) {
+ vshError(ctl, FALSE, "%s", _("migrate: Unexpected migrateuri
for peer2peer migration"));
+ goto done;
+ }
+
+ if (virDomainMigrateToURI (dom, desturi, flags, dname, 0) == 0)
+ ret = TRUE;
+ } else {
+ /* For regular live migration, connect to the destination host directly. */
+ virConnectPtr dconn = NULL;
+ virDomainPtr ddom = NULL;
+
+ dconn = virConnectOpenAuth (desturi, virConnectAuthPtrDefault, 0);
+ if (!dconn) goto done;
+
+ ddom = virDomainMigrate (dom, dconn, flags, dname, migrateuri, 0);
+ if (ddom) {
+ virDomainFree(ddom);
+ ret = TRUE;
+ }
+ virConnectClose (dconn);
+ }
done:
if (dom) virDomainFree (dom);
- if (ddom) virDomainFree (ddom);
- if (dconn) virConnectClose (dconn);
return ret;
}
diff --git a/src/xen_unified.c b/src/xen_unified.c
index dfa9ca5..954b187 100644
--- a/src/xen_unified.c
+++ b/src/xen_unified.c
@@ -455,8 +455,11 @@ static int
xenUnifiedSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
{
switch (feature) {
- case VIR_DRV_FEATURE_MIGRATION_V1: return 1;
- default: return 0;
+ case VIR_DRV_FEATURE_MIGRATION_V1:
+ case VIR_DRV_FEATURE_MIGRATION_P2P:
+ return 1;
+ default:
+ return 0;
}
}
diff --git a/src/xend_internal.c b/src/xend_internal.c
index 7f55116..da5c039 100644
--- a/src/xend_internal.c
+++ b/src/xend_internal.c
@@ -4400,6 +4400,12 @@ xenDaemonDomainMigratePerform (virDomainPtr domain,
strcpy (live, "1");
flags &= ~VIR_MIGRATE_LIVE;
}
+ /* Trivially support this in Xen, since XenD on dest is always
+ * ready to accept incoming migration */
+ if ((flags & VIR_MIGRATE_PEER2PEER)) {
+ flags &= ~VIR_MIGRATE_PEER2PEER;
+ }
+ /* XXX we could easily do tunnelled migration too if we want to */
if (flags != 0) {
virXendError (conn, VIR_ERR_NO_SUPPORT,
"%s", _("xenDaemonDomainMigrate: unsupported
flag"));
--
1.6.2.5
7:43 a.m.
New subject: [libvirt] [PATCH] Support a new peer-to-peer migration mode & public API
[ Sending again due to mail output problems ]
On Thu, Sep 17, 2009 at 06:25:01PM +0100, Daniel P. Berrange wrote:
Introduces several new public API options for migration
- VIR_MIGRATE_PEER2PEER: With this flag the client only
invokes the virDomainMigratePerform method, expecting
the source host driver to do whatever is required to
complete the entire migration process.
- VIR_MIGRATE_TUNNELLED: With this flag the actual data
for migration will be tunnelled over the libvirtd RPC
channel. This requires that VIR_MIGRATE_PEER2PEER is
also set.
Hum, I would rather add that when entering libvirt.c entry point
set explicitely VIR_MIGRATE_PEER2PEER if VIR_MIGRATE_TUNNELLED is asked
for, that's an internal impl. detail.
- virDomainMigrateToURI: This is variant of the existing
virDomainMigrate method which can be used when the
VIR_MIGRATE_PEER2PEER flag is set. The benefit of this
method is that no virConnectPtr object is required for
the destination host, only a destination URI.
Sounds good if we have proper error handling. I'm also wondering
how authentification and access control can be handled in that mode,
the normal method of access somehow garantee that the user credentials
can be checked in some ways, but if it's direct daemon to daemon
talking how can this be performed ?
The URI for VIR_MIGRATE_TUNNELLED must be a valid libvirt
URI. For non-tunnelled migration a hypervisor specific
migration URI is used.
[...]
diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index 10ec04a..1745396 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -336,7 +336,9 @@ typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr;
/* Domain migration flags. */
typedef enum {
- VIR_MIGRATE_LIVE = 1, /* live migration */
+ VIR_MIGRATE_LIVE = (1 << 0), /* live migration */
+ VIR_MIGRATE_PEER2PEER = (1 << 1), /* direct source -> dest host
control channel */
+ VIR_MIGRATE_TUNNELLED = (1 << 2), /* tunnel migration data over
libvirtd connection */
} virDomainMigrateFlags;
/* Domain migration. */
@@ -344,6 +346,10 @@ virDomainPtr virDomainMigrate (virDomainPtr domain, virConnectPtr
dconn,
unsigned long flags, const char *dname,
const char *uri, unsigned long bandwidth);
+int virDomainMigrateToURI (virDomainPtr domain, const char *duri,
+ unsigned long flags, const char *dname,
+ unsigned long bandwidth);
+
s/duri/dest/ or target, the fact it's a connection URI should be made
obvious in the function comment.
[...]
+ } else {
+ if (flags & VIR_MIGRATE_TUNNELLED) {
+ virLibConnError(domain->conn, VIR_ERR_OPERATION_INVALID,
+ _("cannot perform tunnelled migration without using
peer2peer flag"));
+ goto error;
+ }
I don't really agree, we should just or the flag and hide this from
the API user.
+
+/**
+ * virDomainMigrateToURI:
+ * @domain: a domain object
+ * @duri: libvirt connection URI for destination host
+ * @flags: flags
+ * @dname: (optional) rename domain to this at destination
+ * @bandwidth: (optional) specify migration bandwidth limit in Mbps
+ *
+ * Migrate the domain object from its current host to the destination
+ * host given by duri. The duri is a libvirt connection URI that the
+ * source host will use to talk to the destination.
+ *
+ * The difference from the regular virDomainMigrate method is
+ * that the calling application does not need a direct connection
+ * to the destination host. The source libvirt driver makes a
+ * direct peer-to-peer connection to the destination libvirtd
+ * without the client appliction being involved.
+ *
+ * The VIR_MIGRATE_PEER2PEER flag is mandatory for this method.
+ * If an application wishes to run without this flag, then it
+ * may use the alternative virDomainMigrate method which requires
+ * an virConnectPtr object for the destination host
looks good except that block. Why force a flag systematically ?
+ * The following additional flags may also be set
+ * VIR_MIGRATE_LIVE Do not pause the VM during migration
+ * VIR_MIGRATE_TUNNELLED Tunnel migration data over the libvirt RPC channel
+ *
+ * If a hypervisor supports renaming domains during migration,
+ * then you may set the dname parameter to the new name (otherwise
+ * it keeps the same name). If this is not supported by the
+ * hypervisor, dname must be NULL or else you will get an error.
+ *
+ * The maximum bandwidth (in Mbps) that will be used to do migration
+ * can be specified with the bandwidth parameter. If set to 0,
+ * libvirt will choose a suitable default. Some hypervisors do
+ * not support this feature and will return an error if bandwidth
+ * is not 0.
+ *
+ * To see which features are supported by the current hypervisor,
+ * see virConnectGetCapabilities, /capabilities/host/migration_features.
+ *
+ * There are many limitations on migration imposed by the underlying
+ * technology - for example it may not be possible to migrate between
+ * different processors even with the same architecture, or between
+ * different types of hypervisor.
+ *
+ * Returns 0 if the migration succeeded, -1 upon error.
+ */
+int
+virDomainMigrateToURI (virDomainPtr domain,
+ const char *duri,
+ unsigned long flags,
+ const char *dname,
+ unsigned long bandwidth)
+{
+ DEBUG("domain=%p, duri=%p, flags=%lu, dname=%s, bandwidth=%lu",
+ domain, NULLSTR(duri), flags, NULLSTR(dname), bandwidth);
+
+ virResetLastError();
+
+ /* First checkout the source */
+ if (!VIR_IS_CONNECTED_DOMAIN (domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ return -1;
+ }
+ if (domain->conn->flags & VIR_CONNECT_RO) {
+ virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (duri == NULL) {
+ virLibConnError (domain->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ /* XXX perhaps we should just automatically set this flag instead ? */
Ah , yes :-)
+ if (flags & VIR_MIGRATE_PEER2PEER) {
+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_P2P)) {
+ if (virDomainMigrateP2P (domain, flags, dname, duri, bandwidth) < 0)
+ goto error;
+ } else {
+ virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ goto error;
+ }
+ } else {
+ virLibConnError (domain->conn, VIR_ERR_OPERATION_INVALID,
+ _("cannot migrate to a destination URI without peer2peer
flag"));
+ goto error;
+ }
+
+ return 0;
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(domain->conn);
+ return -1;
+}
+
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
index 5913798..5f1a7fe 100644
--- a/src/libvirt_internal.h
+++ b/src/libvirt_internal.h
@@ -17,6 +17,7 @@
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
+ * NB This file is (secret) ABI sensitive. Append only
Huh ???
*/
#ifndef __LIBVIRT_H_
@@ -31,6 +32,35 @@ int virStateReload(void);
int virStateActive(void);
#endif
+/* Feature detection. This is a libvirt-private interface for determining
+ * what features are supported by the driver.
+ *
+ * The remote driver passes features through to the real driver at the
+ * remote end unmodified, except if you query a VIR_DRV_FEATURE_REMOTE*
+ * feature.
+ *
+ */
+enum {
+ /* Driver supports V1-style virDomainMigrate, ie. domainMigratePrepare/
+ * domainMigratePerform/domainMigrateFinish.
+ */
+ VIR_DRV_FEATURE_MIGRATION_V1 = 1,
+
+ /* Driver is not local. */
+ VIR_DRV_FEATURE_REMOTE = 2,
+
+ /* Driver supports V2-style virDomainMigrate, ie. domainMigratePrepare2/
+ * domainMigratePerform/domainMigrateFinish2.
+ */
+ VIR_DRV_FEATURE_MIGRATION_V2 = 3,
+
+ /* Driver supports peer-2-peer virDomainMigrate ie soruce host
+ * do all the prepare/perform/finish steps directly
+ */
+ VIR_DRV_FEATURE_MIGRATION_P2P = 4,
+};
+
+
int virDrvSupportsFeature (virConnectPtr conn, int feature);
int virDomainMigratePrepare (virConnectPtr dconn,
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index 888ea26..757e54c 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -323,6 +323,7 @@ LIBVIRT_0.7.1 {
virStreamFinish;
virStreamAbort;
virStreamFree;
+ virDomainMigrateToURI;
} LIBVIRT_0.7.0;
# .... define new API here using predicted next version number ....
diff --git a/src/virsh.c b/src/virsh.c
index 4825f1c..cabbd3d 100644
--- a/src/virsh.c
+++ b/src/virsh.c
@@ -2463,6 +2463,8 @@ static const vshCmdInfo info_migrate[] = {
static const vshCmdOptDef opts_migrate[] = {
{"live", VSH_OT_BOOL, 0, gettext_noop("live migration")},
+ {"p2p", VSH_OT_BOOL, 0, gettext_noop("peer-2-peer migration")},
+ {"tunnelled", VSH_OT_BOOL, 0, gettext_noop("tunnelled
migration")},
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("domain name, id
or uuid")},
{"desturi", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("connection URI
of the destination host")},
{"migrateuri", VSH_OT_DATA, 0, gettext_noop("migration URI, usually
can be omitted")},
@@ -2478,8 +2480,6 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
const char *migrateuri;
const char *dname;
int flags = 0, found, ret = FALSE;
- virConnectPtr dconn = NULL;
- virDomainPtr ddom = NULL;
if (!vshConnectionUsability (ctl, ctl->conn, TRUE))
return FALSE;
@@ -2500,20 +2500,40 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool (cmd, "live"))
flags |= VIR_MIGRATE_LIVE;
- /* Temporarily connect to the destination host. */
- dconn = virConnectOpenAuth (desturi, virConnectAuthPtrDefault, 0);
- if (!dconn) goto done;
+ if (vshCommandOptBool (cmd, "p2p"))
+ flags |= VIR_MIGRATE_PEER2PEER;
- /* Migrate. */
- ddom = virDomainMigrate (dom, dconn, flags, dname, migrateuri, 0);
- if (!ddom) goto done;
+ if (vshCommandOptBool (cmd, "tunnelled"))
+ flags |= VIR_MIGRATE_TUNNELLED;
- ret = TRUE;
+ if ((flags & VIR_MIGRATE_PEER2PEER)) {
+ /* For peer2peer migration we only expect one URI, a libvirt URI */
+
+ if (migrateuri != NULL) {
+ vshError(ctl, FALSE, "%s", _("migrate: Unexpected migrateuri
for peer2peer migration"));
+ goto done;
+ }
+
+ if (virDomainMigrateToURI (dom, desturi, flags, dname, 0) == 0)
+ ret = TRUE;
+ } else {
+ /* For regular live migration, connect to the destination host directly. */
+ virConnectPtr dconn = NULL;
+ virDomainPtr ddom = NULL;
+
+ dconn = virConnectOpenAuth (desturi, virConnectAuthPtrDefault, 0);
+ if (!dconn) goto done;
+
+ ddom = virDomainMigrate (dom, dconn, flags, dname, migrateuri, 0);
+ if (ddom) {
+ virDomainFree(ddom);
+ ret = TRUE;
+ }
+ virConnectClose (dconn);
+ }
done:
if (dom) virDomainFree (dom);
- if (ddom) virDomainFree (ddom);
- if (dconn) virConnectClose (dconn);
return ret;
}
diff --git a/src/xen_unified.c b/src/xen_unified.c
index dfa9ca5..954b187 100644
--- a/src/xen_unified.c
+++ b/src/xen_unified.c
@@ -455,8 +455,11 @@ static int
xenUnifiedSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
{
switch (feature) {
- case VIR_DRV_FEATURE_MIGRATION_V1: return 1;
- default: return 0;
+ case VIR_DRV_FEATURE_MIGRATION_V1:
+ case VIR_DRV_FEATURE_MIGRATION_P2P:
+ return 1;
+ default:
+ return 0;
}
}
diff --git a/src/xend_internal.c b/src/xend_internal.c
index 7f55116..da5c039 100644
--- a/src/xend_internal.c
+++ b/src/xend_internal.c
@@ -4400,6 +4400,12 @@ xenDaemonDomainMigratePerform (virDomainPtr domain,
strcpy (live, "1");
flags &= ~VIR_MIGRATE_LIVE;
}
+ /* Trivially support this in Xen, since XenD on dest is always
+ * ready to accept incoming migration */
+ if ((flags & VIR_MIGRATE_PEER2PEER)) {
+ flags &= ~VIR_MIGRATE_PEER2PEER;
+ }
+ /* XXX we could easily do tunnelled migration too if we want to */
if (flags != 0) {
virXendError (conn, VIR_ERR_NO_SUPPORT,
"%s", _("xenDaemonDomainMigrate: unsupported
flag"));
Sounds and looks good to me, with the small caveat of the required
VIR_MIGRATE_PEER2PEER flag and making sure it would work later with
QEmu/KVM before commiting this.
I must admit peer-2-peer left me a bit puzzled at the beginning
it wasn't obvious what kind of transfer it actually meant. Only de
the documentation clarified it but I have no better suggestion :-)
"direct" maybe ...
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
8:27 a.m.
New subject: [libvirt] [PATCH] Support a new peer-to-peer migration mode & public API
On Tue, Sep 22, 2009 at 02:43:20PM +0200, Daniel Veillard wrote:
[ Sending again due to mail output problems ]
On Thu, Sep 17, 2009 at 06:25:01PM +0100, Daniel P. Berrange wrote:
> Introduces several new public API options for migration
>
> - VIR_MIGRATE_PEER2PEER: With this flag the client only
> invokes the virDomainMigratePerform method, expecting
> the source host driver to do whatever is required to
> complete the entire migration process.
> - VIR_MIGRATE_TUNNELLED: With this flag the actual data
> for migration will be tunnelled over the libvirtd RPC
> channel. This requires that VIR_MIGRATE_PEER2PEER is
> also set.
Hum, I would rather add that when entering libvirt.c entry point
set explicitely VIR_MIGRATE_PEER2PEER if VIR_MIGRATE_TUNNELLED is asked
for, that's an internal impl. detail.
I didn't do that, because I wanted to leave open the option
to supporting TUNNELLED mode, without PEER2PEER mode. I
don't really know what that would look like, but I think it
is better future proofing to not presume one implies the other.
> - virDomainMigrateToURI: This is variant of the existing
> virDomainMigrate method which can be used when the
> VIR_MIGRATE_PEER2PEER flag is set. The benefit of this
> method is that no virConnectPtr object is required for
> the destination host, only a destination URI.
Sounds good if we have proper error handling. I'm also wondering
how authentification and access control can be handled in that mode,
the normal method of access somehow garantee that the user credentials
can be checked in some ways, but if it's direct daemon to daemon
talking how can this be performed ?
The client application authenticates with the source libvirtd
in the normal manner. The source libvirtd will authenticate
with the destination libvirtd directly.
The client application will not be authenticating with the
destination libvirtd itself.
While this may sound like a security issue, I don't think it
really is. It is more of an authorization problem - eg the
admin needs to declare somewhere which libvirtd instances
are allowed to migrate guests between then. This authorization
problem is really outside the scope of the client application
or our public app API
>
> +int virDomainMigrateToURI (virDomainPtr domain, const char *duri,
> + unsigned long flags, const char *dname,
> + unsigned long bandwidth);
> +
s/duri/dest/ or target, the fact it's a connection URI should be made
obvious in the function comment.
Yep, the function comment later only clearly describes what URIs are
acceptable.
[...]
> + } else {
> + if (flags & VIR_MIGRATE_TUNNELLED) {
> + virLibConnError(domain->conn, VIR_ERR_OPERATION_INVALID,
> + _("cannot perform tunnelled migration without
using peer2peer flag"));
> + goto error;
> + }
I don't really agree, we should just or the flag and hide this from
the API user.
I really did want to leave open the option of relaxing this restriction
in the future, and thus didn't want to automatically set the PEER2PEER
flag - once its set we can never unset it in the future.
> +
> +
> /*
> * Not for public use. This function is part of the internal
> * implementation of migration in the remote case.
> diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
> index 5913798..5f1a7fe 100644
> --- a/src/libvirt_internal.h
> +++ b/src/libvirt_internal.h
> @@ -17,6 +17,7 @@
> * License along with this library; if not, write to the Free Software
> * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> *
> + * NB This file is (secret) ABI sensitive. Append only
Huh ???
The methods here are encoded in the wire protocol ABI,
but not included in the public libvirt.h header. Hence
they are ABI sensitive, but secret & thus append only
like the rest of our API
> diff --git a/src/xen_unified.c b/src/xen_unified.c
> index dfa9ca5..954b187 100644
> --- a/src/xen_unified.c
> +++ b/src/xen_unified.c
> @@ -455,8 +455,11 @@ static int
> xenUnifiedSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
> {
> switch (feature) {
> - case VIR_DRV_FEATURE_MIGRATION_V1: return 1;
> - default: return 0;
> + case VIR_DRV_FEATURE_MIGRATION_V1:
> + case VIR_DRV_FEATURE_MIGRATION_P2P:
> + return 1;
> + default:
> + return 0;
> }
> }
>
> diff --git a/src/xend_internal.c b/src/xend_internal.c
> index 7f55116..da5c039 100644
> --- a/src/xend_internal.c
> +++ b/src/xend_internal.c
> @@ -4400,6 +4400,12 @@ xenDaemonDomainMigratePerform (virDomainPtr domain,
> strcpy (live, "1");
> flags &= ~VIR_MIGRATE_LIVE;
> }
> + /* Trivially support this in Xen, since XenD on dest is always
> + * ready to accept incoming migration */
> + if ((flags & VIR_MIGRATE_PEER2PEER)) {
> + flags &= ~VIR_MIGRATE_PEER2PEER;
> + }
> + /* XXX we could easily do tunnelled migration too if we want to */
> if (flags != 0) {
> virXendError (conn, VIR_ERR_NO_SUPPORT,
> "%s", _("xenDaemonDomainMigrate: unsupported
flag"));
Sounds and looks good to me, with the small caveat of the required
VIR_MIGRATE_PEER2PEER flag and making sure it would work later with
QEmu/KVM before commiting this.
I must admit peer-2-peer left me a bit puzzled at the beginning
it wasn't obvious what kind of transfer it actually meant. Only de
the documentation clarified it but I have no better suggestion :-)
"direct" maybe ...
I called it peer-2-peer, because the 2 libvirtd instances are talking
to each other p2p, rather than having all communcation go via
the client application.
Regards,
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
8:56 a.m.
New subject: [libvirt] [PATCH] Support a new peer-to-peer migration mode & public API
On Fri, Sep 25, 2009 at 02:27:23PM +0100, Daniel P. Berrange wrote:
On Tue, Sep 22, 2009 at 02:43:20PM +0200, Daniel Veillard wrote:
> [ Sending again due to mail output problems ]
>
> On Thu, Sep 17, 2009 at 06:25:01PM +0100, Daniel P. Berrange wrote:
> > Introduces several new public API options for migration
> >
> > - VIR_MIGRATE_PEER2PEER: With this flag the client only
> > invokes the virDomainMigratePerform method, expecting
> > the source host driver to do whatever is required to
> > complete the entire migration process.
> > - VIR_MIGRATE_TUNNELLED: With this flag the actual data
> > for migration will be tunnelled over the libvirtd RPC
> > channel. This requires that VIR_MIGRATE_PEER2PEER is
> > also set.
>
> Hum, I would rather add that when entering libvirt.c entry point
> set explicitely VIR_MIGRATE_PEER2PEER if VIR_MIGRATE_TUNNELLED is asked
> for, that's an internal impl. detail.
I didn't do that, because I wanted to leave open the option
to supporting TUNNELLED mode, without PEER2PEER mode. I
don't really know what that would look like, but I think it
is better future proofing to not presume one implies the other.
Okay, let's go for this.
> > - virDomainMigrateToURI: This is variant of the existing
> > virDomainMigrate method which can be used when the
> > VIR_MIGRATE_PEER2PEER flag is set. The benefit of this
> > method is that no virConnectPtr object is required for
> > the destination host, only a destination URI.
>
> Sounds good if we have proper error handling. I'm also wondering
> how authentification and access control can be handled in that mode,
> the normal method of access somehow garantee that the user credentials
> can be checked in some ways, but if it's direct daemon to daemon
> talking how can this be performed ?
The client application authenticates with the source libvirtd
in the normal manner. The source libvirtd will authenticate
with the destination libvirtd directly.
The client application will not be authenticating with the
destination libvirtd itself.
While this may sound like a security issue, I don't think it
really is. It is more of an authorization problem - eg the
admin needs to declare somewhere which libvirtd instances
are allowed to migrate guests between then. This authorization
problem is really outside the scope of the client application
or our public app API
Okay, as soon as you want to allow automatic migrations that
will be considered normal.
> >
> > +int virDomainMigrateToURI (virDomainPtr domain, const char *duri,
> > + unsigned long flags, const char *dname,
> > + unsigned long bandwidth);
> > +
>
> s/duri/dest/ or target, the fact it's a connection URI should be made
> obvious in the function comment.
Yep, the function comment later only clearly describes what URIs are
acceptable.
> [...]
> > + } else {
> > + if (flags & VIR_MIGRATE_TUNNELLED) {
> > + virLibConnError(domain->conn, VIR_ERR_OPERATION_INVALID,
> > + _("cannot perform tunnelled migration without
using peer2peer flag"));
> > + goto error;
> > + }
>
> I don't really agree, we should just or the flag and hide this from
> the API user.
I really did want to leave open the option of relaxing this restriction
in the future, and thus didn't want to automatically set the PEER2PEER
flag - once its set we can never unset it in the future.
> > +
> > +
> > /*
> > * Not for public use. This function is part of the internal
> > * implementation of migration in the remote case.
> > diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
> > index 5913798..5f1a7fe 100644
> > --- a/src/libvirt_internal.h
> > +++ b/src/libvirt_internal.h
> > @@ -17,6 +17,7 @@
> > * License along with this library; if not, write to the Free Software
> > * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> > *
> > + * NB This file is (secret) ABI sensitive. Append only
>
> Huh ???
The methods here are encoded in the wire protocol ABI,
but not included in the public libvirt.h header. Hence
they are ABI sensitive, but secret & thus append only
like the rest of our API
> > diff --git a/src/xen_unified.c b/src/xen_unified.c
> > index dfa9ca5..954b187 100644
> > --- a/src/xen_unified.c
> > +++ b/src/xen_unified.c
> > @@ -455,8 +455,11 @@ static int
> > xenUnifiedSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
> > {
> > switch (feature) {
> > - case VIR_DRV_FEATURE_MIGRATION_V1: return 1;
> > - default: return 0;
> > + case VIR_DRV_FEATURE_MIGRATION_V1:
> > + case VIR_DRV_FEATURE_MIGRATION_P2P:
> > + return 1;
> > + default:
> > + return 0;
> > }
> > }
> >
> > diff --git a/src/xend_internal.c b/src/xend_internal.c
> > index 7f55116..da5c039 100644
> > --- a/src/xend_internal.c
> > +++ b/src/xend_internal.c
> > @@ -4400,6 +4400,12 @@ xenDaemonDomainMigratePerform (virDomainPtr domain,
> > strcpy (live, "1");
> > flags &= ~VIR_MIGRATE_LIVE;
> > }
> > + /* Trivially support this in Xen, since XenD on dest is always
> > + * ready to accept incoming migration */
> > + if ((flags & VIR_MIGRATE_PEER2PEER)) {
> > + flags &= ~VIR_MIGRATE_PEER2PEER;
> > + }
> > + /* XXX we could easily do tunnelled migration too if we want to */
> > if (flags != 0) {
> > virXendError (conn, VIR_ERR_NO_SUPPORT,
> > "%s", _("xenDaemonDomainMigrate:
unsupported flag"));
>
> Sounds and looks good to me, with the small caveat of the required
> VIR_MIGRATE_PEER2PEER flag and making sure it would work later with
> QEmu/KVM before commiting this.
>
> I must admit peer-2-peer left me a bit puzzled at the beginning
> it wasn't obvious what kind of transfer it actually meant. Only de
> the documentation clarified it but I have no better suggestion :-)
> "direct" maybe ...
I called it peer-2-peer, because the 2 libvirtd instances are talking
to each other p2p, rather than having all communcation go via
the client application.
it's just that p2p raises the idea of a mesh of machines in my mind
and I'm probably not the only one :-) No problem !
ACK
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
8:57 a.m.
New subject: [libvirt] [PATCH] Support a new peer-to-peer migration mode & public API
On 09/17/2009 07:25 PM, Daniel P. Berrange wrote:
+ if (flags& VIR_MIGRATE_PEER2PEER) {
+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_P2P)) {
+ char *duri = NULL;
Is there a reason why you shouldn't try a VIR_MIGRATE_PEER2PEER if dconn
is NULL, rather than having a separate flag? If I read the code
correctly, this would make virDomainMigrateToURI unnecessary.
Paolo
4:43 p.m.
New subject: [libvirt] [PATCH 1/1] Support a new peer-to-peer migration mode
This patch introduces a peer-to-peer migration protocol where the client
only invokes the virDomainMigratePerform method, expecting the source
host driver to do whatever is required to complete the entire migration
process.
This method is used by virsh whenever the hypervisor supports it and the
destination URI is not given.
In addition, this patch makes the dconn parameter to virDomainMigrate
optional. In this case, libvirt will try to use peer-to-peer migration
or, alternatively, will fall back to opening a temporary connection.
* src/driver.h: Remove feature flags.
* src/libvirt_internal.h: Add feature flags, and include
new VIR_DRV_FEATURE_MIGRATION_P2P indicating support for the
new migration protocol. Add VIR_MIGRATE_PEER2PEER private
flag passed to virMigratePerform.
* src/libvirt.c: Implement support for peer-to-peer migration.
* src/virsh.c: Let libvirt create the dconn where possible.
* src/xen/xen_driver.c: Advertise support for P2P migration
* src/xen/xend_internal.c: Accept VIR_MIGRATE_PEER2PEER.
---
Is there a reason why you shouldn't try a VIR_MIGRATE_PEER2PEER
if dconn is NULL, rather than having a separate flag?
Well it wasn't that simple, anyway this is what I meant.
I splitted out the non-fleshed-out tunnelled migration parts to
ease committing. However I've not tested this beyond compiling yet.
docs/libvirt-api.xml | 23 +++---
docs/libvirt-refs.xml | 120 +++++++++++++++++++-------------
src/driver.h | 19 -----
src/internal.h | 2 +
src/libvirt.c | 177 +++++++++++++++++++++++++++++++++++------------
src/libvirt_internal.h | 36 ++++++++++
src/xen/xen_driver.c | 7 ++-
src/xen/xend_internal.c | 5 ++
tools/virsh.c | 28 ++++---
9 files changed, 279 insertions(+), 138 deletions(-)
diff --git a/src/driver.h b/src/driver.h
index 6a3dcc2..893e98b 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -44,25 +44,6 @@ typedef enum {
VIR_DRV_OPEN_ERROR = -2,
} virDrvOpenStatus;
-/* Feature detection. This is a libvirt-private interface for determining
- * what features are supported by the driver.
- *
- * The remote driver passes features through to the real driver at the
- * remote end unmodified, except if you query a VIR_DRV_FEATURE_REMOTE*
- * feature.
- */
- /* Driver supports V1-style virDomainMigrate, ie. domainMigratePrepare/
- * domainMigratePerform/domainMigrateFinish.
- */
-#define VIR_DRV_FEATURE_MIGRATION_V1 1
-
- /* Driver is not local. */
-#define VIR_DRV_FEATURE_REMOTE 2
-
- /* Driver supports V2-style virDomainMigrate, ie. domainMigratePrepare2/
- * domainMigratePerform/domainMigrateFinish2.
- */
-#define VIR_DRV_FEATURE_MIGRATION_V2 3
/* Internal feature-detection macro. Don't call drv->supports_feature
* directly, because it may be NULL, use this macro instead.
diff --git a/src/internal.h b/src/internal.h
index 8fa579c..bd1cfe6 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -24,6 +24,8 @@
#include "libvirt/libvirt.h"
#include "libvirt/virterror.h"
+#include "libvirt_internal.h"
+
/* On architectures which lack these limits, define them (ie. Cygwin).
* Note that the libvirt code should be robust enough to handle the
* case where actual value is longer than these limits (eg. by setting
diff --git a/src/libvirt.c b/src/libvirt.c
index dacf8c4..f0ec640 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -35,7 +35,6 @@
#include "virterror_internal.h"
#include "logging.h"
#include "datatypes.h"
-#include "libvirt_internal.h"
#include "driver.h"
#include "uuid.h"
@@ -3044,6 +3043,39 @@ virDomainMigrateVersion2 (virDomainPtr domain,
return ddomain;
}
+
+ /*
+ * This is sort of a migration v3
+ *
+ * This performs a peer-to-peer migration where source host
+ * does all the communication with the destination host.
+ */
+static int
+virDomainMigrateP2P (virDomainPtr domain,
+ unsigned long flags,
+ const char *dname,
+ const char *uri,
+ unsigned long bandwidth)
+{
+ if (!domain->conn->driver->domainMigratePerform) {
+ virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ return -1;
+ }
+
+ /* Perform the migration. The driver isn't supposed to return
+ * until the migration is complete.
+ */
+ flags |= VIR_MIGRATE_PEER2PEER;
+ return domain->conn->driver->domainMigratePerform(domain,
+ NULL, /* cookie */
+ 0, /* cookielen */
+ uri,
+ flags,
+ dname,
+ bandwidth);
+}
+
+
/**
* virDomainMigrate:
* @domain: a domain object
@@ -3057,22 +3089,23 @@ virDomainMigrateVersion2 (virDomainPtr domain,
* host given by dconn (a connection to the destination host).
*
* Flags may be one of more of the following:
- * VIR_MIGRATE_LIVE Attempt a live migration.
+ * VIR_MIGRATE_LIVE Do not pause the VM during migration
*
* If a hypervisor supports renaming domains during migration,
* then you may set the dname parameter to the new name (otherwise
* it keeps the same name). If this is not supported by the
* hypervisor, dname must be NULL or else you will get an error.
*
- * Since typically the two hypervisors connect directly to each
- * other in order to perform the migration, you may need to specify
- * a path from the source to the destination. This is the purpose
- * of the uri parameter. If uri is NULL, then libvirt will try to
- * find the best method. Uri may specify the hostname or IP address
- * of the destination host as seen from the source. Or uri may be
- * a URI giving transport, hostname, user, port, etc. in the usual
- * form. Refer to driver documentation for the particular URIs
- * supported.
+ * dconn can be NULL. Then the uri parameter will then be a
+ * valid libvirt connection URI, by which the source libvirt
+ * driver can connect to the destination libvirt.
+ *
+ * If the dconn argument is set, the URI parameter takes a
+ * hypervisor specific format. The hypervisor capabilities XML
+ * includes details of the support URI schemes. If omitted the dconn
+ * will be asked for a default URI. It is typically only necessary
+ * to specify a URI if the destination host has multiple interfaces
+ * and a specific interface is required to transmit migration data.
*
* The maximum bandwidth (in Mbps) that will be used to do migration
* can be specified with the bandwidth parameter. If set to 0,
@@ -3089,8 +3122,10 @@ virDomainMigrateVersion2 (virDomainPtr domain,
* different types of hypervisor.
*
* Returns the new domain object if the migration was successful,
- * or NULL in case of error. Note that the new domain object
- * exists in the scope of the destination connection (dconn).
+ * or NULL in case of error. Note that the new domain object
+ * exists in the scope of the destination connection (dconn) if
+ * one was provided; else the migrated domain is returned
+ * with an added reference.
*/
virDomainPtr
virDomainMigrate (virDomainPtr domain,
@@ -3101,6 +3136,9 @@ virDomainMigrate (virDomainPtr domain,
unsigned long bandwidth)
{
virDomainPtr ddomain = NULL;
+ int protocol = 0;
+ int free_conn = 0;
+
DEBUG("domain=%p, dconn=%p, flags=%lu, dname=%s, uri=%s, bandwidth=%lu",
domain, dconn, flags, NULLSTR(dname), NULLSTR(uri), bandwidth);
@@ -3109,51 +3147,103 @@ virDomainMigrate (virDomainPtr domain,
/* First checkout the source */
if (!VIR_IS_CONNECTED_DOMAIN (domain)) {
virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
- return NULL;
+ goto cleanup;
}
if (domain->conn->flags & VIR_CONNECT_RO) {
virLibDomainError(domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
- goto error;
+ goto cleanup;
}
- /* Now checkout the destination */
- if (!VIR_IS_CONNECT (dconn)) {
- virLibConnError (domain->conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
- goto error;
- }
- if (dconn->flags & VIR_CONNECT_RO) {
- /* NB, deliberately report error against source object, not dest */
- virLibDomainError (domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
- goto error;
- }
+ /* Now see if we have to open the destination ourselves... */
+ if (!dconn) {
+ if (!uri) {
+ virLibConnError (domain->conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ goto cleanup;
+ }
+
+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_P2P))
+ protocol = VIR_DRV_FEATURE_MIGRATION_P2P;
+ else {
+ dconn = virConnectOpenAuth (uri, virConnectAuthPtrDefault, 0);
+ uri = NULL;
+ if (!dconn)
+ goto cleanup;
+ free_conn = 1;
+ }
+ }
+
+ /* ... and check it out. */
+ if (dconn) {
+ if (!VIR_IS_CONNECT (dconn)) {
+ virLibConnError (domain->conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ goto cleanup;
+ }
+ if (dconn->flags & VIR_CONNECT_RO) {
+ /* NB, deliberately report error against source object, not dest */
+ virLibDomainError (domain, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto cleanup;
+ }
- /* Check that migration is supported by both drivers. */
- if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
- VIR_DRV_FEATURE_MIGRATION_V1) &&
- VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
- VIR_DRV_FEATURE_MIGRATION_V1))
- ddomain = virDomainMigrateVersion1 (domain, dconn, flags, dname, uri,
bandwidth);
- else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
- VIR_DRV_FEATURE_MIGRATION_V2) &&
- VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
- VIR_DRV_FEATURE_MIGRATION_V2))
+ /* Choose a protocol. Some features are not supported by
+ * all protocols. */
+ if (!uri &&
+ VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_P2P))
+ protocol = VIR_DRV_FEATURE_MIGRATION_P2P;
+
+ /* For these, migration has to be supported by both drivers. */
+ else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_V1) &&
+ VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
+ VIR_DRV_FEATURE_MIGRATION_V1))
+ protocol = VIR_DRV_FEATURE_MIGRATION_V1;
+
+ else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ VIR_DRV_FEATURE_MIGRATION_V2) &&
+ VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
+ VIR_DRV_FEATURE_MIGRATION_V2))
+ protocol = VIR_DRV_FEATURE_MIGRATION_V2;
+ }
+
+ if (protocol == VIR_DRV_FEATURE_MIGRATION_P2P) {
+ char *duri = NULL;
+ if (!uri)
+ uri = duri = virConnectGetURI(dconn);
+
+ if (virDomainMigrateP2P (domain, flags, dname, uri, bandwidth) < 0) {
+ VIR_FREE(duri);
+ goto cleanup;
+ }
+ VIR_FREE(duri);
+
+ if (dconn)
+ ddomain = virDomainLookupByName (dconn, dname ? dname : domain->name);
+ else {
+ ddomain = domain;
+ virDomainRef (domain);
+ }
+ } else if (protocol == VIR_DRV_FEATURE_MIGRATION_V1)
+ ddomain = virDomainMigrateVersion1 (domain, dconn, flags, dname, uri,
bandwidth);
+ else if (protocol == VIR_DRV_FEATURE_MIGRATION_V2)
ddomain = virDomainMigrateVersion2 (domain, dconn, flags, dname, uri,
bandwidth);
else {
virLibConnError (domain->conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
- goto error;
+ goto cleanup;
}
- if (ddomain == NULL)
- goto error;
-
- return ddomain;
-error:
+cleanup:
/* Copy to connection error object for back compatability */
- virSetConnError(domain->conn);
- return NULL;
+ if (ddomain == NULL)
+ virSetConnError(domain->conn);
+ if (free_conn)
+ virConnectClose(dconn);
+ return ddomain;
}
+
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
index 5913798..024c9dd 100644
--- a/src/libvirt_internal.h
+++ b/src/libvirt_internal.h
@@ -17,6 +17,7 @@
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
+ * NB: This file is private, but still contributes to the ABI. Append only.
*/
#ifndef __LIBVIRT_H_
@@ -31,6 +32,41 @@ int virStateReload(void);
int virStateActive(void);
#endif
+/* Feature detection. This is a libvirt-private interface for determining
+ * what features are supported by the driver.
+ *
+ * The remote driver passes features through to the real driver at the
+ * remote end unmodified, except if you query a VIR_DRV_FEATURE_REMOTE*
+ * feature.
+ *
+ */
+enum {
+ /* Driver supports V1-style virDomainMigrate, ie. domainMigratePrepare/
+ * domainMigratePerform/domainMigrateFinish.
+ */
+ VIR_DRV_FEATURE_MIGRATION_V1 = 1,
+
+ /* Driver is not local. */
+ VIR_DRV_FEATURE_REMOTE = 2,
+
+ /* Driver supports V2-style virDomainMigrate, ie. domainMigratePrepare2/
+ * domainMigratePerform/domainMigrateFinish2.
+ */
+ VIR_DRV_FEATURE_MIGRATION_V2 = 3,
+
+ /* Driver supports peer-to-peer virDomainMigrate ie. the source host
+ * will do all the prepare/perform/finish steps directly
+ */
+ VIR_DRV_FEATURE_MIGRATION_P2P = 4,
+};
+
+enum {
+ /* Driver was requested peer-to-peer virDomainMigrate. This is
+ * needed because the perform callback is shared.
+ */
+ VIR_MIGRATE_PEER2PEER = (1 << 16),
+} virDomainInternalMigrateFlags;
+
int virDrvSupportsFeature (virConnectPtr conn, int feature);
int virDomainMigratePrepare (virConnectPtr dconn,
diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index 9e1bc32..bc6fdfd 100644
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -455,8 +455,11 @@ static int
xenUnifiedSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
{
switch (feature) {
- case VIR_DRV_FEATURE_MIGRATION_V1: return 1;
- default: return 0;
+ case VIR_DRV_FEATURE_MIGRATION_V1:
+ case VIR_DRV_FEATURE_MIGRATION_P2P:
+ return 1;
+ default:
+ return 0;
}
}
diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c
index 49bdba9..e9b1de6 100644
--- a/src/xen/xend_internal.c
+++ b/src/xen/xend_internal.c
@@ -4409,6 +4409,11 @@ xenDaemonDomainMigratePerform (virDomainPtr domain,
strcpy (live, "1");
flags &= ~VIR_MIGRATE_LIVE;
}
+ /* Trivially support this in Xen, since XenD on dest is always
+ * ready to accept incoming migration */
+ if ((flags & VIR_MIGRATE_PEER2PEER)) {
+ flags &= ~VIR_MIGRATE_PEER2PEER;
+ }
if (flags != 0) {
virXendError (conn, VIR_ERR_NO_SUPPORT,
"%s", _("xenDaemonDomainMigrate: unsupported
flag"));
diff --git a/tools/virsh.c b/tools/virsh.c
index 3482389..a3d92df 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -2472,13 +2472,13 @@ static const vshCmdOptDef opts_migrate[] = {
static int
cmdMigrate (vshControl *ctl, const vshCmd *cmd)
{
+ virConnectPtr dconn = NULL;
virDomainPtr dom = NULL;
+ virDomainPtr ddom = NULL;
const char *desturi;
const char *migrateuri;
const char *dname;
int flags = 0, found, ret = FALSE;
- virConnectPtr dconn = NULL;
- virDomainPtr ddom = NULL;
if (!vshConnectionUsability (ctl, ctl->conn, TRUE))
return FALSE;
@@ -2499,20 +2499,24 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool (cmd, "live"))
flags |= VIR_MIGRATE_LIVE;
- /* Temporarily connect to the destination host. */
- dconn = virConnectOpenAuth (desturi, virConnectAuthPtrDefault, 0);
- if (!dconn) goto done;
-
- /* Migrate. */
- ddom = virDomainMigrate (dom, dconn, flags, dname, migrateuri, 0);
- if (!ddom) goto done;
+ if (migrateuri == NULL) {
+ /* Let libvirt handle opening the connection if necessary. */
+ ddom = virDomainMigrate (dom, NULL, flags, dname, desturi, 0);
+ } else {
+ dconn = virConnectOpenAuth (desturi, virConnectAuthPtrDefault, 0);
+ if (!dconn) goto done;
+ ddom = virDomainMigrate (dom, dconn, flags, dname, migrateuri, 0);
+ }
- ret = TRUE;
+ if (ddom) {
+ virDomainFree(ddom);
+ ret = TRUE;
+ }
+ if (dconn)
+ virConnectClose (dconn);
done:
if (dom) virDomainFree (dom);
- if (ddom) virDomainFree (ddom);
- if (dconn) virConnectClose (dconn);
return ret;
}
--
1.6.2.5
4:43 p.m.
New subject: [libvirt] [PATCH 2/1] Non-support for VIR_MIGRATE_TUNNELLED
This is just an example. Unlike the previous patch, this one
of course is not ready for committing.
* include/libvirt/libvirt.h.in: Add VIR_MIGRATE_TUNNELLED.
* src/libvirt.c: Implement non-support for VIR_MIGRATE_TUNNELLED.
* src/virsh.c: Add --tunnelled arg to virsh migrate.
---
include/libvirt/libvirt.h.in | 3 ++-
src/libvirt.c | 14 +++++++++++---
tools/virsh.c | 4 ++++
3 files changed, 17 insertions(+), 4 deletions(-)
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 4e63e48..fa54be1 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -336,7 +336,8 @@ typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr;
/* Domain migration flags. */
typedef enum {
- VIR_MIGRATE_LIVE = 1, /* live migration */
+ VIR_MIGRATE_LIVE = (1 << 0), /* live migration */
+ VIR_MIGRATE_TUNNELLED = (1 << 1), /* tunnel migration data over
libvirtd connection */
} virDomainMigrateFlags;
/* Domain migration. */
diff --git a/src/libvirt.c b/src/libvirt.c
index f0ec640..811c50d 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -2918,6 +2918,8 @@ virDomainMigrateVersion1 (virDomainPtr domain,
char *cookie = NULL;
int cookielen = 0;
+ assert (!(flags & VIR_MIGRATE_TUNNELLED));
+
/* Prepare the migration.
*
* The destination host may return a cookie, or leave cookie as
@@ -2982,6 +2984,8 @@ virDomainMigrateVersion2 (virDomainPtr domain,
char *dom_xml = NULL;
int cookielen = 0, ret;
+ assert (!(flags & VIR_MIGRATE_TUNNELLED));
+
/* Prepare the migration.
*
* The destination host may return a cookie, or leave cookie as
@@ -3098,7 +3102,9 @@ virDomainMigrateP2P (virDomainPtr domain,
*
* dconn can be NULL. Then the uri parameter will then be a
* valid libvirt connection URI, by which the source libvirt
- * driver can connect to the destination libvirt.
+ * driver can connect to the destination libvirt. If this
+ * scheme is used and the hypervisor supports it, the
+ * VIR_MIGRATE_TUNNELLED flag can also be set.
*
* If the dconn argument is set, the URI parameter takes a
* hypervisor specific format. The hypervisor capabilities XML
@@ -3192,13 +3198,15 @@ virDomainMigrate (virDomainPtr domain,
protocol = VIR_DRV_FEATURE_MIGRATION_P2P;
/* For these, migration has to be supported by both drivers. */
- else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ else if (!(flags & VIR_MIGRATE_TUNNELLED) &&
+ VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
VIR_DRV_FEATURE_MIGRATION_V1) &&
VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
VIR_DRV_FEATURE_MIGRATION_V1))
protocol = VIR_DRV_FEATURE_MIGRATION_V1;
- else if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
+ else if (!(flags & VIR_MIGRATE_TUNNELLED) &&
+ VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
VIR_DRV_FEATURE_MIGRATION_V2) &&
VIR_DRV_SUPPORTS_FEATURE (dconn->driver, dconn,
VIR_DRV_FEATURE_MIGRATION_V2))
diff --git a/tools/virsh.c b/tools/virsh.c
index a3d92df..55b1d76 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -2462,6 +2462,7 @@ static const vshCmdInfo info_migrate[] = {
static const vshCmdOptDef opts_migrate[] = {
{"live", VSH_OT_BOOL, 0, gettext_noop("live migration")},
+ {"tunnelled", VSH_OT_BOOL, 0, gettext_noop("tunnelled
migration")},
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("domain name, id
or uuid")},
{"desturi", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("connection URI
of the destination host")},
{"migrateuri", VSH_OT_DATA, 0, gettext_noop("migration URI, usually
can be omitted")},
@@ -2499,6 +2500,9 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool (cmd, "live"))
flags |= VIR_MIGRATE_LIVE;
+ if (vshCommandOptBool (cmd, "tunnelled"))
+ flags |= VIR_MIGRATE_TUNNELLED;
+
if (migrateuri == NULL) {
/* Let libvirt handle opening the connection if necessary. */
ddom = virDomainMigrate (dom, NULL, flags, dname, desturi, 0);
--
1.6.2.5
6:53 a.m.
New subject: [libvirt] [PATCH 1/1] Support a new peer-to-peer migration mode
On Thu, Oct 01, 2009 at 11:43:17PM +0200, Paolo Bonzini wrote:
+
+ if (dconn)
+ ddomain = virDomainLookupByName (dconn, dname ? dname : domain->name);
+ else {
+ ddomain = domain;
+ virDomainRef (domain);
+ }
This bit of code is exactly why we need a new API - the return value is
declared to be a virDomainPtr on the destination host, not just a copy
of the original source domain which no longer even exists on the source
host if it was a transient domain.
Regards,
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
7:06 a.m.
New subject: [libvirt] [PATCH 1/1] Support a new peer-to-peer migration mode
On 10/02/2009 01:53 PM, Daniel P. Berrange wrote:
This bit of code is exactly why we need a new API - the return value
is
declared to be a virDomainPtr on the destination host, not just a copy
of the original source domain which no longer even exists on the source
host if it was a transient domain.
Yeah, I really did not like this.
In Chris's code he actually opens the connection (after the migration is
complete) in order to return the destination domain.
Does that make sense?
Paolo
7:11 a.m.
New subject: [libvirt] [PATCH 1/1] Support a new peer-to-peer migration mode
On Fri, Oct 02, 2009 at 02:06:12PM +0200, Paolo Bonzini wrote:
On 10/02/2009 01:53 PM, Daniel P. Berrange wrote:
>This bit of code is exactly why we need a new API - the return value is
>declared to be a virDomainPtr on the destination host, not just a copy
>of the original source domain which no longer even exists on the source
>host if it was a transient domain.
Yeah, I really did not like this.
In Chris's code he actually opens the connection (after the migration is
complete) in order to return the destination domain.
Does that make sense?
Not really, because one of the requirements from libvirt-qpid is that
we have an API that only needs a localhost connection for migration,
to avoid the need to configure client app security credentials.
This implies we cannot either require a destination virConnectPtr in
the API, not open one internally.
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
6:51 a.m.
New subject: [libvirt] [PATCH] Support a new peer-to-peer migration mode & public API
On Thu, Oct 01, 2009 at 03:57:13PM +0200, Paolo Bonzini wrote:
On 09/17/2009 07:25 PM, Daniel P. Berrange wrote:
>+ if (flags& VIR_MIGRATE_PEER2PEER) {
>+ if (VIR_DRV_SUPPORTS_FEATURE (domain->conn->driver, domain->conn,
>+ VIR_DRV_FEATURE_MIGRATION_P2P)) {
>+ char *duri = NULL;
Is there a reason why you shouldn't try a VIR_MIGRATE_PEER2PEER if dconn
is NULL, rather than having a separate flag? If I read the code
correctly, this would make virDomainMigrateToURI unnecessary.
If 'dconn' is NULL, it is impossible to create a 'virDomainPtr' on the
destination connection, which is required as the return value of the
virDomainMigrate function to indicate success.
Hence we need a new virDomainMigrateToURI method which returns an 'int'
status code, instead of virDomainPtr
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
2:58 a.m.
On Mon, Aug 24, 2009 at 09:51:03PM +0100, Daniel P. Berrange wrote:
The following series of patches introduce support for generic data
streams in the libvirt API, the remote protocol, client & daemon.
The public API takes the form of a new object virStreamPtr and
methods to read/write/close it
The remote protocol was the main hard bit. Since the protocol
allows multiple concurrent API calls on a single connection,
this needed to also allow concurrent data streams. It is also
not acceptable for a large data stream to block other traffic
while it is transferring.
Thus, we introduce a new protocol message type 'REMOTE_STREAM'
to handle transfer for the stream data. A method involving a
data streams starts off in the normal way with a REMOTE_CALL
to the server, and a REMOTE_REPLY response message. If this
was successful, there now follows the data stream traffic.
For outgoing streams (data from client to server), the client
will send zero or more REMOTE_STREAM packets containing the
data with status == REMOTE_CONTINUE. These are asynchronous
and not acknowledged by the server. At any time the server
may send an async message with a type of REMOTE_STREAM and
status of REMOTE_ERROR. This indicates to the client that the
transfer is aborting at server request. If the client wishes
to abort, it can send the server a REMOTE_STREAM+REMOTE_ERROR
message. If the client finishes its data transfer, it will
send a final REMOTE_STREAM+REMOTE_OK message, and the server
will respond with the same. This full roundtrip handshake
ensures any async error messages are guarenteed to be flushed
For incoming data streams (data from server to client), the
server sends zero or more REMOTE_STREAM packets containing the
data with status == REMOTE_CONTINUE. These are asynchronous
and not acknowledged by the client. At any time the client
may send an async message with a type of REMOTE_STREAM and
status of REMOTE_ERROR. This indicates to the server that the
transfer is aborting at client request. If the server wishes
to abort, it can send the server a REMOTE_STREAM+REMOTE_ERROR
message. When the server finishes its data transfer, it will
send a final REMOTE_STREAM+REMOTE_CONTINUE message ewith a
data length of zero (ie EOF). The client will then send a
REMOTE_STREAM+REMOTE_OK packet and the server will respond
with the same. This full roundtrip handshake ensures any async
error messages are guarenteed to be flushed
This all ensures that multiple data streams can be active in
parallel, and with a maximum data packet size of 256 KB, no
single stream can cause too much latency on the connection for
other API calls/streams.
Okay, this is very similar in principle with HTTP pipelining
with IMHO the same benefits and the same potential drawbacks.
A couple of things to check might be:
- the maximum amount of concurrent active streams allowed,
for example suppose you want to migrate in emergency
all the domains out of a failing machine, some level of
serialization may be better than say attempting to migrate
all 100 domains at the same time. 10 parallel stream might
be better, but we need to make sure the API allows to report
such condition.
- the maximum chunking size, but with 256k I think this is
covered.
- synchronization internally between threads to avoid deadlocks
or poor performances, that can be very hard to debug, so I
guess an effort should be provided to explain how things are
designed internally.
But this sounds fine in general.
The only thing it does not allow for is one API method to use
two or more streams. These may be famous last words, but I
don't think that use case will be neccessary for any of our
APIs...
as long as the limitation is documented especially in the parts
of teh code where the assumption is made, sounds fine.
The last 5 patches with a subject of [DEMO] are *NOT* intended
to be committed to the repository. They merely demonstrate the
use of data streams for a couple of hypothetical file upload
and download APIs. Actually they were mostly to allow me to
test the code streams code without messing around with the QEMU
migration code.
The immediate use case for this data stream code is Chris' QEMU
migration patchset.
The next use case is to allow serial console access to be tunnelled
over libvirtd, eg to make 'virsh console GUEST' work remotely.
This use case is why I included the support for non-blocking data
streams and event loop integration (not required for Chris'
migration use case)
Okay, next to individual patches reviews,
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
6:07 a.m.
On Fri, Sep 25, 2009 at 09:58:51AM +0200, Daniel Veillard wrote:
On Mon, Aug 24, 2009 at 09:51:03PM +0100, Daniel P. Berrange wrote:
Okay, this is very similar in principle with HTTP pipelining
with IMHO the same benefits and the same potential drawbacks.
A couple of things to check might be:
- the maximum amount of concurrent active streams allowed,
for example suppose you want to migrate in emergency
all the domains out of a failing machine, some level of
serialization may be better than say attempting to migrate
all 100 domains at the same time. 10 parallel stream might
be better, but we need to make sure the API allows to report
such condition.
We could certainly add a tunable in /etc/libvirt/libvirtd.conf
that limits the number of streams that are allowed per client.
- the maximum chunking size, but with 256k I think this is
covered.
Yes, the remote protocol itself limits each message to 256k
currently. I think this is a good enough size, since it avoids
the stream delaying RPC calls, and the encryption chunk size
is going to be smaller than this anyway, so you won't gain much
from larger chunks.
- synchronization internally between threads to avoid deadlocks
or poor performances, that can be very hard to debug, so I
guess an effort should be provided to explain how things are
designed internally.
Each individual virStreamPtr object is directly associated with
a single API call, so in essence each virStreamPtr should only
really be used from a single thread. That said, the virStreamPtr
internal drivers should all lock the virStreamPtr object as
they require to provide safety.
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
9:46 a.m.
FYI,
the data streams patches are now committed
Daniel
On Fri, Sep 25, 2009 at 09:58:51AM +0200, Daniel Veillard wrote:
On Mon, Aug 24, 2009 at 09:51:03PM +0100, Daniel P. Berrange wrote:
> The following series of patches introduce support for generic data
> streams in the libvirt API, the remote protocol, client & daemon.
>
> The public API takes the form of a new object virStreamPtr and
> methods to read/write/close it
>
> The remote protocol was the main hard bit. Since the protocol
> allows multiple concurrent API calls on a single connection,
> this needed to also allow concurrent data streams. It is also
> not acceptable for a large data stream to block other traffic
> while it is transferring.
>
> Thus, we introduce a new protocol message type 'REMOTE_STREAM'
> to handle transfer for the stream data. A method involving a
> data streams starts off in the normal way with a REMOTE_CALL
> to the server, and a REMOTE_REPLY response message. If this
> was successful, there now follows the data stream traffic.
>
> For outgoing streams (data from client to server), the client
> will send zero or more REMOTE_STREAM packets containing the
> data with status == REMOTE_CONTINUE. These are asynchronous
> and not acknowledged by the server. At any time the server
> may send an async message with a type of REMOTE_STREAM and
> status of REMOTE_ERROR. This indicates to the client that the
> transfer is aborting at server request. If the client wishes
> to abort, it can send the server a REMOTE_STREAM+REMOTE_ERROR
> message. If the client finishes its data transfer, it will
> send a final REMOTE_STREAM+REMOTE_OK message, and the server
> will respond with the same. This full roundtrip handshake
> ensures any async error messages are guarenteed to be flushed
>
> For incoming data streams (data from server to client), the
> server sends zero or more REMOTE_STREAM packets containing the
> data with status == REMOTE_CONTINUE. These are asynchronous
> and not acknowledged by the client. At any time the client
> may send an async message with a type of REMOTE_STREAM and
> status of REMOTE_ERROR. This indicates to the server that the
> transfer is aborting at client request. If the server wishes
> to abort, it can send the server a REMOTE_STREAM+REMOTE_ERROR
> message. When the server finishes its data transfer, it will
> send a final REMOTE_STREAM+REMOTE_CONTINUE message ewith a
> data length of zero (ie EOF). The client will then send a
> REMOTE_STREAM+REMOTE_OK packet and the server will respond
> with the same. This full roundtrip handshake ensures any async
> error messages are guarenteed to be flushed
>
> This all ensures that multiple data streams can be active in
> parallel, and with a maximum data packet size of 256 KB, no
> single stream can cause too much latency on the connection for
> other API calls/streams.
Okay, this is very similar in principle with HTTP pipelining
with IMHO the same benefits and the same potential drawbacks.
A couple of things to check might be:
- the maximum amount of concurrent active streams allowed,
for example suppose you want to migrate in emergency
all the domains out of a failing machine, some level of
serialization may be better than say attempting to migrate
all 100 domains at the same time. 10 parallel stream might
be better, but we need to make sure the API allows to report
such condition.
- the maximum chunking size, but with 256k I think this is
covered.
- synchronization internally between threads to avoid deadlocks
or poor performances, that can be very hard to debug, so I
guess an effort should be provided to explain how things are
designed internally.
But this sounds fine in general.
> The only thing it does not allow for is one API method to use
> two or more streams. These may be famous last words, but I
> don't think that use case will be neccessary for any of our
> APIs...
as long as the limitation is documented especially in the parts
of teh code where the assumption is made, sounds fine.
> The last 5 patches with a subject of [DEMO] are *NOT* intended
> to be committed to the repository. They merely demonstrate the
> use of data streams for a couple of hypothetical file upload
> and download APIs. Actually they were mostly to allow me to
> test the code streams code without messing around with the QEMU
> migration code.
>
> The immediate use case for this data stream code is Chris' QEMU
> migration patchset.
>
> The next use case is to allow serial console access to be tunnelled
> over libvirtd, eg to make 'virsh console GUEST' work remotely.
> This use case is why I included the support for non-blocking data
> streams and event loop integration (not required for Chris'
> migration use case)
Okay, next to individual patches reviews,
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
5343
days inactive
5382
days old
43 comments
5 participants
participants (5)
-
Chris Lalancette -
Daniel P. Berrange -
Daniel Veillard -
Paolo Bonzini -
Paolo Bonzini