static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
static virSecretPtr get_nonnull_secret (virConnectPtr conn, remote_nonnull_secret secret);
static virNWFilterPtr get_nonnull_nwfilter (virConnectPtr conn, remote_nonnull_nwfilter nwfilter);
+static virDomainSnapshotPtr get_nonnull_domain_snapshot (virConnectPtr conn, remote_nonnull_domain_snapshot snapshot);
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
static void make_nonnull_interface (remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
static void make_nonnull_node_device (remote_nonnull_node_device *dev_dst, virNodeDevicePtr dev_src);
static void make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
static void make_nonnull_nwfilter (remote_nonnull_nwfilter *net_dst, virNWFilterPtr nwfilter_src);
+static void make_nonnull_domain_snapshot (remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src);
#include "remote_dispatch_prototypes.h"
return 0;
}
+static int
+remoteDispatchDomainSnapshotCreateXml (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_snapshot_create_xml_args *args,
+ remote_domain_snapshot_create_xml_ret *ret)
+{
+ virDomainSnapshotPtr snapshot;
+ virDomainPtr domain;
+
+ domain = get_nonnull_domain(conn, args->domain);
+ if (domain == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ snapshot = virDomainSnapshotCreateXML(domain, args->xml_desc, args->flags);
+ if (snapshot == NULL) {
+ virDomainFree(domain);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain_snapshot(&ret->snap, snapshot);
+
+ virDomainSnapshotFree(snapshot);
+ virDomainFree(domain);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainSnapshotDumpXml (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_snapshot_dump_xml_args *args,
+ remote_domain_snapshot_dump_xml_ret *ret)
+{
+ virDomainSnapshotPtr snapshot;
+
+ snapshot = get_nonnull_domain_snapshot(conn, args->snap);
+ if (snapshot == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virDomainSnapshotGetXMLDesc(snapshot, args->flags);
+ if (!ret->xml) {
+ virDomainSnapshotFree(snapshot);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virDomainSnapshotFree(snapshot);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainSnapshotNum (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_snapshot_num_args *args,
+ remote_domain_snapshot_num_ret *ret)
+{
+ virDomainPtr domain;
+
+ domain = get_nonnull_domain(conn, args->domain);
+ if (domain == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->num = virDomainSnapshotNum(domain, args->flags);
+ if (ret->num == -1) {
+ virDomainFree(domain);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virDomainFree(domain);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainSnapshotListNames (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_snapshot_list_names_args *args,
+ remote_domain_snapshot_list_names_ret *ret)
+{
+ virDomainPtr domain;
+
+ if (args->nameslen > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX) {
+ remoteDispatchFormatError (rerr, "%s",
+ _("nameslen > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX"));
+ return -1;
+ }
+
+ domain = get_nonnull_domain(conn, args->domain);
+ if (domain == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->nameslen) < 0) {
+ virDomainFree(domain);
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len = virDomainSnapshotListNames(domain,
+ ret->names.names_val,
+ args->nameslen,
+ args->flags);
+ if (ret->names.names_len == -1) {
+ virDomainFree(domain);
+ VIR_FREE(ret->names.names_val);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virDomainFree(domain);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainSnapshotLookupByName (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_snapshot_lookup_by_name_args *args,
+ remote_domain_snapshot_lookup_by_name_ret *ret)
+{
+ virDomainSnapshotPtr snapshot;
+ virDomainPtr domain;
+
+ domain = get_nonnull_domain(conn, args->domain);
+ if (domain == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ snapshot = virDomainSnapshotLookupByName(domain, args->name, args->flags);
+ if (snapshot == NULL) {
+ virDomainFree(domain);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain_snapshot (&ret->snap, snapshot);
+
+ virDomainSnapshotFree(snapshot);
+ virDomainFree(domain);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainHasCurrentSnapshot(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_has_current_snapshot_args *args,
+ remote_domain_has_current_snapshot_ret *ret)
+{
+ virDomainPtr domain;
+ int result;
+
+ domain = get_nonnull_domain(conn, args->domain);
+ if (domain == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ result = virDomainHasCurrentSnapshot(domain, args->flags);
+ if (result < 0) {
+ virDomainFree(domain);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ ret->result = result;
+
+ virDomainFree(domain);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainSnapshotCurrent(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_snapshot_current_args *args,
+ remote_domain_snapshot_current_ret *ret)
+{
+ virDomainSnapshotPtr snapshot;
+ virDomainPtr domain;
+
+ domain = get_nonnull_domain(conn, args->domain);
+ if (domain == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ snapshot = virDomainSnapshotCurrent(domain, args->flags);
+ if (snapshot == NULL) {
+ virDomainFree(domain);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_domain_snapshot(&ret->snap, snapshot);
+
+ virDomainSnapshotFree(snapshot);
+ virDomainFree(domain);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainRevertToSnapshot (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_revert_to_snapshot_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainSnapshotPtr snapshot;
+
+ snapshot = get_nonnull_domain_snapshot(conn, args->snap);
+ if (snapshot == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainRevertToSnapshot(snapshot, args->flags) == -1) {
+ virDomainSnapshotFree(snapshot);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virDomainSnapshotFree(snapshot);
+
+ return 0;
+}
+
+static int
+remoteDispatchDomainSnapshotDelete (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_snapshot_delete_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virDomainSnapshotPtr snapshot;
+
+ snapshot = get_nonnull_domain_snapshot(conn, args->snap);
+ if (snapshot == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virDomainSnapshotDelete(snapshot, args->flags) == -1) {
+ virDomainSnapshotFree(snapshot);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ virDomainSnapshotFree(snapshot);
+
+ return 0;
+}
+
static int
remoteDispatchDomainEventsRegisterAny (struct qemud_server *server ATTRIBUTE_UNUSED,
return virGetNWFilter (conn, nwfilter.name, BAD_CAST nwfilter.uuid);
}
+static virDomainSnapshotPtr
+get_nonnull_domain_snapshot (virConnectPtr conn, remote_nonnull_domain_snapshot snapshot)
+{
+ virDomainPtr domain;
+ domain = get_nonnull_domain(conn, snapshot.domain);
+ if (domain == NULL)
+ return NULL;
+ return virGetDomainSnapshot(domain, snapshot.name);
+}
+
/* Make remote_nonnull_domain and remote_nonnull_network. */
static void
make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
nwfilter_dst->name = strdup (nwfilter_src->name);
memcpy (nwfilter_dst->uuid, nwfilter_src->uuid, VIR_UUID_BUFLEN);
}
+
+static void
+make_nonnull_domain_snapshot (remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src)
+{
+ snapshot_dst->name = strdup(snapshot_src->name);
+ make_nonnull_domain(&snapshot_dst->domain, snapshot_src->domain);
+}
remote_domain_managed_save_args val_remote_domain_managed_save_args;
remote_domain_has_managed_save_image_args val_remote_domain_has_managed_save_image_args;
remote_domain_managed_save_remove_args val_remote_domain_managed_save_remove_args;
+ remote_domain_snapshot_create_xml_args val_remote_domain_snapshot_create_xml_args;
+ remote_domain_snapshot_dump_xml_args val_remote_domain_snapshot_dump_xml_args;
+ remote_domain_snapshot_num_args val_remote_domain_snapshot_num_args;
+ remote_domain_snapshot_list_names_args val_remote_domain_snapshot_list_names_args;
+ remote_domain_snapshot_lookup_by_name_args val_remote_domain_snapshot_lookup_by_name_args;
+ remote_domain_has_current_snapshot_args val_remote_domain_has_current_snapshot_args;
+ remote_domain_snapshot_current_args val_remote_domain_snapshot_current_args;
+ remote_domain_revert_to_snapshot_args val_remote_domain_revert_to_snapshot_args;
+ remote_domain_snapshot_delete_args val_remote_domain_snapshot_delete_args;
remote_error *err,
remote_domain_shutdown_args *args,
void *ret);
+static int remoteDispatchDomainSnapshotCreateXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_create_xml_args *args,
+ remote_domain_snapshot_create_xml_ret *ret);
+static int remoteDispatchDomainSnapshotDumpXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_dump_xml_args *args,
+ remote_domain_snapshot_dump_xml_ret *ret);
+static int remoteDispatchDomainSnapshotNum(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_num_args *args,
+ remote_domain_snapshot_num_ret *ret);
+static int remoteDispatchDomainSnapshotListNames(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_list_names_args *args,
+ remote_domain_snapshot_list_names_ret *ret);
+static int remoteDispatchDomainSnapshotLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_lookup_by_name_args *args,
+ remote_domain_snapshot_lookup_by_name_ret *ret);
+static int remoteDispatchDomainHasCurrentSnapshot(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_has_current_snapshot_args *args,
+ remote_domain_has_current_snapshot_ret *ret);
+static int remoteDispatchDomainSnapshotCurrent(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_current_args *args,
+ remote_domain_snapshot_current_ret *ret);
+static int remoteDispatchDomainRevertToSnapshot(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_revert_to_snapshot_args *args,
+ void *ret);
+static int remoteDispatchDomainSnapshotDelete(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_snapshot_delete_args *args,
+ void *ret);
static int remoteDispatchDomainSuspend(
struct qemud_server *server,
struct qemud_client *client,
remote_list_nwfilters_ret val_remote_list_nwfilters_ret;
remote_nwfilter_define_xml_ret val_remote_nwfilter_define_xml_ret;
remote_domain_has_managed_save_image_ret val_remote_domain_has_managed_save_image_ret;
+ remote_domain_snapshot_create_xml_ret val_remote_domain_snapshot_create_xml_ret;
+ remote_domain_snapshot_dump_xml_ret val_remote_domain_snapshot_dump_xml_ret;
+ remote_domain_snapshot_num_ret val_remote_domain_snapshot_num_ret;
+ remote_domain_snapshot_list_names_ret val_remote_domain_snapshot_list_names_ret;
+ remote_domain_snapshot_lookup_by_name_ret val_remote_domain_snapshot_lookup_by_name_ret;
+ remote_domain_has_current_snapshot_ret val_remote_domain_has_current_snapshot_ret;
+ remote_domain_snapshot_current_ret val_remote_domain_snapshot_current_ret;
.args_filter = (xdrproc_t) xdr_remote_domain_managed_save_remove_args,
.ret_filter = (xdrproc_t) xdr_void,
},
+{ /* DomainSnapshotCreateXml => 185 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotCreateXml,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_create_xml_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_snapshot_create_xml_ret,
+},
+{ /* DomainSnapshotDumpXml => 186 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotDumpXml,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_dump_xml_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_snapshot_dump_xml_ret,
+},
+{ /* DomainSnapshotNum => 187 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotNum,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_num_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_snapshot_num_ret,
+},
+{ /* DomainSnapshotListNames => 188 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotListNames,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_list_names_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_snapshot_list_names_ret,
+},
+{ /* DomainSnapshotLookupByName => 189 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotLookupByName,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_ret,
+},
+{ /* DomainHasCurrentSnapshot => 190 */
+ .fn = (dispatch_fn) remoteDispatchDomainHasCurrentSnapshot,
+ .args_filter = (xdrproc_t) xdr_remote_domain_has_current_snapshot_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_has_current_snapshot_ret,
+},
+{ /* DomainSnapshotCurrent => 191 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotCurrent,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_current_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_snapshot_current_ret,
+},
+{ /* DomainRevertToSnapshot => 192 */
+ .fn = (dispatch_fn) remoteDispatchDomainRevertToSnapshot,
+ .args_filter = (xdrproc_t) xdr_remote_domain_revert_to_snapshot_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* DomainSnapshotDelete => 193 */
+ .fn = (dispatch_fn) remoteDispatchDomainSnapshotDelete,
+ .args_filter = (xdrproc_t) xdr_remote_domain_snapshot_delete_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
VIR_DOMAIN_EVENT_STARTED_BOOTED = 0, /* Normal startup from boot */
VIR_DOMAIN_EVENT_STARTED_MIGRATED = 1, /* Incoming migration from another host */
VIR_DOMAIN_EVENT_STARTED_RESTORED = 2, /* Restored from a state file */
+ VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT = 3, /* Restored from snapshot */
} virDomainEventStartedDetailType;
/**
VIR_DOMAIN_EVENT_STOPPED_MIGRATED = 3, /* Migrated off to another host */
VIR_DOMAIN_EVENT_STOPPED_SAVED = 4, /* Saved to a state file */
VIR_DOMAIN_EVENT_STOPPED_FAILED = 5, /* Host emulator/mgmt failed */
+ VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT = 6, /* offline snapshot loaded */
} virDomainEventStoppedDetailType;
virDomainJobInfoPtr info);
int virDomainAbortJob(virDomainPtr dom);
+/**
+ * virDomainSnapshot:
+ *
+ * a virDomainSnapshot is a private structure representing a snapshot of
+ * a domain.
+ */
+typedef struct _virDomainSnapshot virDomainSnapshot;
+
+/**
+ * virDomainSnapshotPtr:
+ *
+ * a virDomainSnapshotPtr is pointer to a virDomainSnapshot private structure,
+ * and is the type used to reference a domain snapshot in the API.
+ */
+typedef virDomainSnapshot *virDomainSnapshotPtr;
+
+/* Take a snapshot of the current VM state */
+virDomainSnapshotPtr virDomainSnapshotCreateXML(virDomainPtr domain,
+ const char *xmlDesc,
+ unsigned int flags);
+
+/* Dump the XML of a snapshot */
+char *virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+/* Return the number of snapshots for this domain */
+int virDomainSnapshotNum(virDomainPtr domain, unsigned int flags);
+
+/* Get the names of all snapshots for this domain */
+int virDomainSnapshotListNames(virDomainPtr domain, char **names, int nameslen,
+ unsigned int flags);
+
+/* Get a handle to a named snapshot */
+virDomainSnapshotPtr virDomainSnapshotLookupByName(virDomainPtr domain,
+ const char *name,
+ unsigned int flags);
+
+/* Check whether a domain has a snapshot which is currently used */
+int virDomainHasCurrentSnapshot(virDomainPtr domain, unsigned flags);
+
+/* Get a handle to the current snapshot */
+virDomainSnapshotPtr virDomainSnapshotCurrent(virDomainPtr domain,
+ unsigned int flags);
+
+/* Revert the domain to a point-in-time snapshot. The
+ * state of the guest after this call will be the state
+ * of the guest when the snapshot in question was taken
+ */
+int virDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+/* Delete a snapshot */
+typedef enum {
+ VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN = (1 << 0),
+} virDomainSnapshotDeleteFlags;
+
+int virDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+int virDomainSnapshotFree(virDomainSnapshotPtr snapshot);
/* A generic callback definition. Specific events usually have a customization
* with extra parameters */
VIR_FROM_CPU, /* Error from CPU driver */
VIR_FROM_XENAPI, /* Error from XenAPI */
VIR_FROM_NWFILTER, /* Error from network filter driver */
- VIR_FROM_HOOK /* Error from Synchronous hooks */
+ VIR_FROM_HOOK, /* Error from Synchronous hooks */
+ VIR_FROM_DOMAIN_SNAPSHOT, /* Error from domain snapshot */
} virErrorDomain;
VIR_ERR_MIGRATE_PERSIST_FAILED, /* a migration worked, but making the
VM persist on the dest host failed */
VIR_ERR_HOOK_SCRIPT_FAILED, /* a synchronous hook script failed */
+ VIR_ERR_INVALID_DOMAIN_SNAPSHOT, /* invalid domain snapshot */
+ VIR_ERR_NO_DOMAIN_SNAPSHOT, /* domain snapshot not found */
} virErrorNumber;
/**
'const virStreamPtr': ('O', "virStream", "virStreamPtr", "virStreamPtr"),
'virStream *': ('O', "virStream", "virStreamPtr", "virStreamPtr"),
'const virStream *': ('O', "virStream", "virStreamPtr", "virStreamPtr"),
+
+ 'virDomainSnapshotPtr': ('O', "virDomainSnapshot", "virDomainSnapshotPtr", "virDomainSnapshotPtr"),
}
py_return_types = {
'virNodeListDevices',
'virNodeDeviceListCaps',
'virConnectBaselineCPU',
+ 'virDomainSnapshotListNames',
)
return (ret);
}
+PyObject *
+libvirt_virDomainSnapshotPtrWrap(virDomainSnapshotPtr node)
+{
+ PyObject *ret;
+
+ if (node == NULL) {
+ Py_INCREF(Py_None);
+ return (Py_None);
+ }
+ ret =
+ PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "virDomainSnapshotPtr",
+ NULL);
+ return (ret);
+}
+
PyObject *
libvirt_virEventHandleCallbackWrap(virEventHandleCallback node)
{
} PyvirStream_Object;
+#define PyvirDomainSnapshot_Get(v) (((v) == Py_None) ? NULL : \
+ (((PyvirDomainSnapshot_Object *)(v))->obj))
+
+typedef struct {
+ PyObject_HEAD
+ virDomainSnapshotPtr obj;
+} PyvirDomainSnapshot_Object;
+
+
#define PyvirEventHandleCallback_Get(v) (((v) == Py_None) ? NULL : \
(((PyvirEventHandleCallback_Object *)(v))->obj))
PyObject * libvirt_virNodeDevicePtrWrap(virNodeDevicePtr node);
PyObject * libvirt_virSecretPtrWrap(virSecretPtr node);
PyObject * libvirt_virStreamPtrWrap(virStreamPtr node);
+PyObject * libvirt_virDomainSnapshotPtrWrap(virDomainSnapshotPtr node);
/* Provide simple macro statement wrappers (adapted from GLib, in turn from Perl):
virUnrefSecret(secret);
}
+/**
+ * virDomainSnapshotFreeName:
+ * @snapshot: a domain snapshotobject
+ *
+ * Destroy the domain snapshot object, this is just used by the domain hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virDomainSnapshotFreeName(virDomainSnapshotPtr snapshot, const char *name ATTRIBUTE_UNUSED)
+{
+ return (virUnrefDomainSnapshot(snapshot));
+}
+
/**
* virGetConnect:
*
ret->id = -1;
if (uuid != NULL)
memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
+ ret->snapshots = virHashCreate(20);
if (virHashAddEntry(conn->domains, name, ret) < 0) {
virMutexUnlock(&conn->lock);
domain->magic = -1;
domain->id = -1;
VIR_FREE(domain->name);
+ if (domain->snapshots != NULL)
+ virHashFree(domain->snapshots, (virHashDeallocator) virDomainSnapshotFreeName);
VIR_FREE(domain);
if (conn) {
virMutexUnlock(&pool->conn->lock);
return (refs);
}
+
+
+virDomainSnapshotPtr
+virGetDomainSnapshot(virDomainPtr domain, const char *name)
+{
+ virDomainSnapshotPtr ret = NULL;
+
+ if ((!VIR_IS_DOMAIN(domain)) || (name == NULL)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(NULL);
+ }
+ virMutexLock(&domain->conn->lock);
+
+ ret = (virDomainSnapshotPtr) virHashLookup(domain->snapshots, name);
+ if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
+ virMutexUnlock(&domain->conn->lock);
+ virReportOOMError();
+ goto error;
+ }
+ ret->name = strdup(name);
+ if (ret->name == NULL) {
+ virMutexUnlock(&domain->conn->lock);
+ virReportOOMError();
+ goto error;
+ }
+ ret->magic = VIR_SNAPSHOT_MAGIC;
+ ret->domain = domain;
+
+ if (virHashAddEntry(domain->snapshots, name, ret) < 0) {
+ virMutexUnlock(&domain->conn->lock);
+ virLibConnError(domain->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("failed to add snapshot to domain hash table"));
+ goto error;
+ }
+ domain->refs++;
+ DEBUG("New hash entry %p", ret);
+ } else {
+ DEBUG("Existing hash entry %p: refs now %d", ret, ret->refs+1);
+ }
+ ret->refs++;
+ virMutexUnlock(&domain->conn->lock);
+ return(ret);
+
+ error:
+ if (ret != NULL) {
+ VIR_FREE(ret->name);
+ VIR_FREE(ret);
+ }
+ return(NULL);
+}
+
+
+static void
+virReleaseDomainSnapshot(virDomainSnapshotPtr snapshot)
+{
+ virDomainPtr domain = snapshot->domain;
+ DEBUG("release snapshot %p %s", snapshot, snapshot->name);
+
+ if (virHashRemoveEntry(domain->snapshots, snapshot->name, NULL) < 0) {
+ virMutexUnlock(&domain->conn->lock);
+ virLibConnError(domain->conn, VIR_ERR_INTERNAL_ERROR,
+ "%s", _("snapshot missing from domain hash table"));
+ domain = NULL;
+ }
+
+ snapshot->magic = -1;
+ VIR_FREE(snapshot->name);
+ VIR_FREE(snapshot);
+
+ if (domain) {
+ DEBUG("unref domain %p %d", domain, domain->refs);
+ domain->refs--;
+ if (domain->refs == 0) {
+ virReleaseDomain(domain);
+ /* Already unlocked mutex */
+ return;
+ }
+ virMutexUnlock(&domain->conn->lock);
+ }
+}
+
+int
+virUnrefDomainSnapshot(virDomainSnapshotPtr snapshot)
+{
+ int refs;
+
+ if (!VIR_IS_DOMAIN_SNAPSHOT(snapshot)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+
+ virMutexLock(&snapshot->domain->conn->lock);
+ DEBUG("unref snapshot %p %s %d", snapshot, snapshot->name, snapshot->refs);
+ snapshot->refs--;
+ refs = snapshot->refs;
+ if (refs == 0) {
+ virReleaseDomainSnapshot(snapshot);
+ /* Already unlocked mutex */
+ return (0);
+ }
+
+ virMutexUnlock(&snapshot->domain->conn->lock);
+ return (refs);
+}
# define VIR_IS_NWFILTER(obj) ((obj) && (obj)->magic==VIR_NWFILTER_MAGIC)
# define VIR_IS_CONNECTED_NWFILTER(obj) (VIR_IS_NWFILTER(obj) && VIR_IS_CONNECT((obj)->conn))
+/**
+ * VIR_SNAPSHOT_MAGIC:
+ *
+ * magic value used to protect the API when pointers to snapshot structures
+ * are passed down by the users.
+ */
+# define VIR_SNAPSHOT_MAGIC 0x6666DEAD
+# define VIR_IS_SNAPSHOT(obj) ((obj) && (obj)->magic==VIR_SNAPSHOT_MAGIC)
+# define VIR_IS_DOMAIN_SNAPSHOT(obj) (VIR_IS_SNAPSHOT(obj) && VIR_IS_DOMAIN((obj)->domain))
/**
* _virConnect:
char *name; /* the domain external name */
int id; /* the domain ID */
unsigned char uuid[VIR_UUID_BUFLEN]; /* the domain unique identifier */
+ virHashTablePtr snapshots; /* hash table for known snapshots */
};
/**
void *privateData;
};
+/**
+ * _virDomainSnapshot
+ *
+ * Internal structure associated with a domain snapshot
+ */
+struct _virDomainSnapshot {
+ unsigned int magic;
+ int refs;
+ char *name;
+ virDomainPtr domain;
+};
/************************************************************************
* *
const unsigned char *uuid);
int virUnrefNWFilter(virNWFilterPtr pool);
+virDomainSnapshotPtr virGetDomainSnapshot(virDomainPtr domain,
+ const char *name);
+int virUnrefDomainSnapshot(virDomainSnapshotPtr pool);
+
#endif
typedef int
(*virDrvDomainManagedSaveRemove)(virDomainPtr domain, unsigned int flags);
+typedef virDomainSnapshotPtr
+ (*virDrvDomainSnapshotCreateXML)(virDomainPtr domain,
+ const char *xmlDesc,
+ unsigned int flags);
+
+typedef char *
+ (*virDrvDomainSnapshotDumpXML)(virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+typedef int
+ (*virDrvDomainSnapshotNum)(virDomainPtr domain, unsigned int flags);
+
+typedef int
+ (*virDrvDomainSnapshotListNames)(virDomainPtr domain, char **names,
+ int nameslen,
+ unsigned int flags);
+
+typedef virDomainSnapshotPtr
+ (*virDrvDomainSnapshotLookupByName)(virDomainPtr domain,
+ const char *name,
+ unsigned int flags);
+
+typedef int
+ (*virDrvDomainHasCurrentSnapshot)(virDomainPtr domain, unsigned int flags);
+
+typedef virDomainSnapshotPtr
+ (*virDrvDomainSnapshotCurrent)(virDomainPtr domain,
+ unsigned int flags);
+
+typedef int
+ (*virDrvDomainRevertToSnapshot)(virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+typedef int
+ (*virDrvDomainSnapshotDelete)(virDomainSnapshotPtr snapshot,
+ unsigned int flags);
+
+
/**
* _virDriver:
*
virDrvDomainManagedSave domainManagedSave;
virDrvDomainHasManagedSaveImage domainHasManagedSaveImage;
virDrvDomainManagedSaveRemove domainManagedSaveRemove;
+ virDrvDomainSnapshotCreateXML domainSnapshotCreateXML;
+ virDrvDomainSnapshotDumpXML domainSnapshotDumpXML;
+ virDrvDomainSnapshotNum domainSnapshotNum;
+ virDrvDomainSnapshotListNames domainSnapshotListNames;
+ virDrvDomainSnapshotLookupByName domainSnapshotLookupByName;
+ virDrvDomainHasCurrentSnapshot domainHasCurrentSnapshot;
+ virDrvDomainSnapshotCurrent domainSnapshotCurrent;
+ virDrvDomainRevertToSnapshot domainRevertToSnapshot;
+ virDrvDomainSnapshotDelete domainSnapshotDelete;
};
typedef int
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
errmsg, info, NULL, 0, 0, errmsg, info);
}
+/**
+ * virLibDomainSnapshotError:
+ * @snapshot: the snapshot if available
+ * @error: the error number
+ * @info: extra information string
+ *
+ * Handle an error at the domain snapshot level
+ */
+static void
+virLibDomainSnapshotError(virDomainSnapshotPtr snapshot, virErrorNumber error, const char *info)
+{
+ virConnectPtr conn = NULL;
+ const char *errmsg;
+
+ if (error == VIR_ERR_OK)
+ return;
+
+ errmsg = virErrorMsg(error, info);
+ if (error != VIR_ERR_INVALID_DOMAIN_SNAPSHOT)
+ conn = snapshot->domain->conn;
+
+ virRaiseError(conn, NULL, NULL, VIR_FROM_DOMAIN_SNAPSHOT, error, VIR_ERR_ERROR,
+ errmsg, info, NULL, 0, 0, errmsg, info);
+}
+
/**
* virRegisterNetworkDriver:
* @driver: pointer to a network driver block
virDispatchError(conn);
return -1;
}
+
+/**
+ * virDomainSnapshotCreateXML:
+ * @domain: a domain object
+ * @xmlDesc: string containing an XML description of the domain
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Creates a new snapshot of a domain based on the snapshot xml
+ * contained in xmlDesc.
+ *
+ * Returns an (opaque) virDomainSnapshotPtr on success, NULL on failure.
+ */
+virDomainSnapshotPtr
+virDomainSnapshotCreateXML(virDomainPtr domain,
+ const char *xmlDesc,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+
+ DEBUG("domain=%p, xmlDesc=%s, flags=%u", domain, xmlDesc, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ virDispatchError(NULL);
+ return NULL;
+ }
+
+ conn = domain->conn;
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibConnError(conn, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->driver->domainSnapshotCreateXML) {
+ virDomainSnapshotPtr ret;
+ ret = conn->driver->domainSnapshotCreateXML(domain, xmlDesc, flags);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+/**
+ * virDomainSnapshotGetXMLDesc:
+ * @snapshot: a domain snapshot object
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Provide an XML description of the domain snapshot.
+ *
+ * Returns a 0 terminated UTF-8 encoded XML instance, or NULL in case of error.
+ * the caller must free() the returned value.
+ */
+char *
+virDomainSnapshotGetXMLDesc(virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+ DEBUG("snapshot=%p, flags=%d", snapshot, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_DOMAIN_SNAPSHOT(snapshot)) {
+ virLibDomainSnapshotError(NULL, VIR_ERR_INVALID_DOMAIN_SNAPSHOT,
+ __FUNCTION__);
+ virDispatchError(NULL);
+ return (NULL);
+ }
+
+ conn = snapshot->domain->conn;
+
+ if ((conn->flags & VIR_CONNECT_RO) && (flags & VIR_DOMAIN_XML_SECURE)) {
+ virLibConnError(conn, VIR_ERR_OPERATION_DENIED,
+ _("virDomainSnapshotGetXMLDesc with secure flag"));
+ goto error;
+ }
+
+ if (conn->driver->domainSnapshotDumpXML) {
+ char *ret;
+ ret = conn->driver->domainSnapshotDumpXML(snapshot, flags);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+/**
+ * virDomainSnapshotNum:
+ * @domain: a domain object
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Provides the number of domain snapshots for this domain..
+ *
+ * Returns the number of domain snapshost found or -1 in case of error.
+ */
+int
+virDomainSnapshotNum(virDomainPtr domain, unsigned int flags)
+{
+ virConnectPtr conn;
+ DEBUG("domain=%p", domain);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ conn = domain->conn;
+ if (conn->driver->domainSnapshotNum) {
+ int ret = conn->driver->domainSnapshotNum(domain, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return -1;
+}
+
+/**
+ * virDomainSnapshotListNames:
+ * @domain: a domain object
+ * @names: array to collect the list of names of snapshots
+ * @nameslen: size of @names
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Collect the list of domain snapshots for the given domain, and store
+ * their names in @names. Caller is responsible for freeing each member
+ * of the array.
+ *
+ * Returns the number of domain snapshots found or -1 in case of error.
+ */
+int
+virDomainSnapshotListNames(virDomainPtr domain, char **names, int nameslen,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+
+ DEBUG("domain=%p, names=%p, nameslen=%d, flags=%u",
+ domain, names, nameslen, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ conn = domain->conn;
+
+ if ((names == NULL) || (nameslen < 0)) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->driver->domainSnapshotListNames) {
+ int ret = conn->driver->domainSnapshotListNames(domain, names,
+ nameslen, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return -1;
+}
+
+/**
+ * virDomainSnapshotLookupByName:
+ * @domain: a domain object
+ * @name: name for the domain snapshot
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Try to lookup a domain snapshot based on its name.
+ *
+ * Returns a domain snapshot object or NULL in case of failure. If the
+ * domain snapshot cannot be found, then the VIR_ERR_NO_DOMAIN_SNAPSHOT
+ * error is raised.
+ */
+virDomainSnapshotPtr
+virDomainSnapshotLookupByName(virDomainPtr domain,
+ const char *name,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+ DEBUG("domain=%p, name=%s, flags=%u", domain, name, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ virDispatchError(NULL);
+ return (NULL);
+ }
+
+ conn = domain->conn;
+
+ if (name == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->driver->domainSnapshotLookupByName) {
+ virDomainSnapshotPtr dom;
+ dom = conn->driver->domainSnapshotLookupByName(domain, name, flags);
+ if (!dom)
+ goto error;
+ return dom;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+/**
+ * virDomainHasCurrentSnapshot:
+ * @domain: pointer to the domain object
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Determine if the domain has a current snapshot.
+ *
+ * Returns 1 if such snapshot exists, 0 if it doesn't, -1 on error.
+ */
+int
+virDomainHasCurrentSnapshot(virDomainPtr domain, unsigned int flags)
+{
+ virConnectPtr conn;
+ DEBUG("domain=%p, flags=%u", domain, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ conn = domain->conn;
+
+ if (conn->driver->domainHasCurrentSnapshot) {
+ int ret = conn->driver->domainHasCurrentSnapshot(domain, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return -1;
+}
+
+/**
+ * virDomainSnapshotCurrent:
+ * @domain: a domain object
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Get the current snapshot for a domain, if any.
+ *
+ * Returns a domain snapshot object or NULL in case of failure. If the
+ * current domain snapshot cannot be found, then the VIR_ERR_NO_DOMAIN_SNAPSHOT
+ * error is raised.
+ */
+virDomainSnapshotPtr
+virDomainSnapshotCurrent(virDomainPtr domain,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+ DEBUG("domain=%p, flags=%u", domain, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+ virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ virDispatchError(NULL);
+ return (NULL);
+ }
+
+ conn = domain->conn;
+
+ if (conn->driver->domainSnapshotCurrent) {
+ virDomainSnapshotPtr snap;
+ snap = conn->driver->domainSnapshotCurrent(domain, flags);
+ if (!snap)
+ goto error;
+ return snap;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+/**
+ * virDomainRevertToSnapshot
+ * @snapshot: a domain snapshot object
+ * @flags: unused flag parameters; callers should pass 0
+ *
+ * Revert the domain to a given snapshot.
+ *
+ * Returns 0 if the creation is successful, -1 on error.
+ */
+int
+virDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+
+ DEBUG("snapshot=%p, flags=%u", snapshot, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_DOMAIN_SNAPSHOT(snapshot)) {
+ virLibDomainSnapshotError(NULL, VIR_ERR_INVALID_DOMAIN_SNAPSHOT,
+ __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ conn = snapshot->domain->conn;
+
+ if (conn->driver->domainRevertToSnapshot) {
+ int ret = conn->driver->domainRevertToSnapshot(snapshot, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return -1;
+}
+
+/**
+ * virDomainSnapshotDelete
+ * @snapshot: a domain snapshot object
+ * @flags: flag parameters
+ *
+ * Delete the snapshot.
+ *
+ * If @flags is 0, then just this snapshot is deleted, and changes from
+ * this snapshot are automatically merged into children snapshots. If
+ * flags is VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN, then this snapshot
+ * and any children snapshots are deleted.
+ *
+ * Returns 0 if the snapshot was successfully deleted, -1 on error.
+ */
+int
+virDomainSnapshotDelete(virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+
+ DEBUG("snapshot=%p, flags=%u", snapshot, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_DOMAIN_SNAPSHOT(snapshot)) {
+ virLibDomainSnapshotError(NULL, VIR_ERR_INVALID_DOMAIN_SNAPSHOT,
+ __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ conn = snapshot->domain->conn;
+
+ if (conn->driver->domainSnapshotDelete) {
+ int ret = conn->driver->domainSnapshotDelete(snapshot, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+error:
+ virDispatchError(conn);
+ return -1;
+}
+
+/**
+ * virDomainSnapshotFree:
+ * @snapshot: a domain snapshot object
+ *
+ * Free the domain snapshot object. The snapshot itself is not modified.
+ * The data structure is freed and should not be used thereafter.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+int
+virDomainSnapshotFree(virDomainSnapshotPtr snapshot)
+{
+ DEBUG("snapshot=%p", snapshot);
+
+ virResetLastError();
+
+ if (!VIR_IS_DOMAIN_SNAPSHOT(snapshot)) {
+ virLibDomainSnapshotError(NULL, VIR_ERR_INVALID_DOMAIN_SNAPSHOT,
+ __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+ if (virUnrefDomainSnapshot(snapshot) < 0) {
+ virDispatchError(NULL);
+ return -1;
+ }
+ return 0;
+}
virUnrefStream;
virGetNWFilter;
virUnrefNWFilter;
+virGetDomainSnapshot;
# domain_conf.h
virDomainManagedSave;
virDomainHasManagedSaveImage;
virDomainManagedSaveRemove;
+ virDomainSnapshotCreateXML;
+ virDomainSnapshotGetXMLDesc;
+ virDomainSnapshotNum;
+ virDomainSnapshotListNames;
+ virDomainSnapshotLookupByName;
+ virDomainHasCurrentSnapshot;
+ virDomainSnapshotCurrent;
+ virDomainRevertToSnapshot;
+ virDomainSnapshotDelete;
+ virDomainSnapshotFree;
} LIBVIRT_0.7.7;
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
static virStateDriver lxcStateDriver = {
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
static virStateDriver oneStateDriver = {
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
int openvzRegister(void) {
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
int
qemuDomainManagedSave, /* domainManagedSave */
qemuDomainHasManagedSaveImage, /* domainHasManagedSaveImage */
qemuDomainManagedSaveRemove, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
static virNodeDevicePtr get_nonnull_node_device (virConnectPtr conn, remote_nonnull_node_device dev);
static virSecretPtr get_nonnull_secret (virConnectPtr conn, remote_nonnull_secret secret);
+static virDomainSnapshotPtr get_nonnull_domain_snapshot (virDomainPtr domain, remote_nonnull_domain_snapshot snapshot);
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
static void make_nonnull_interface (remote_nonnull_interface *interface_dst, virInterfacePtr interface_src);
static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
static void make_nonnull_secret (remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
static void make_nonnull_nwfilter (remote_nonnull_nwfilter *nwfilter_dst, virNWFilterPtr nwfilter_src);
+static void make_nonnull_domain_snapshot (remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src);
void remoteDomainEventFired(int watch, int fd, int event, void *data);
void remoteDomainEventQueueFlush(int timer, void *opaque);
/*----------------------------------------------------------------------*/
return rv;
}
+static virDomainSnapshotPtr
+remoteDomainSnapshotCreateXML(virDomainPtr domain,
+ const char *xmlDesc,
+ unsigned int flags)
+{
+ virDomainSnapshotPtr snapshot = NULL;
+ remote_domain_snapshot_create_xml_args args;
+ remote_domain_snapshot_create_xml_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain (&args.domain, domain);
+ args.xml_desc = (char *) xmlDesc;
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML,
+ (xdrproc_t) xdr_remote_domain_snapshot_create_xml_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_snapshot_create_xml_ret, (char *) &ret) == -1)
+ goto done;
+
+ snapshot = get_nonnull_domain_snapshot(domain, ret.snap);
+ xdr_free ((xdrproc_t) &xdr_remote_domain_snapshot_create_xml_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return snapshot;
+}
+
+
+static char *
+remoteDomainSnapshotDumpXML(virDomainSnapshotPtr snapshot, unsigned int flags)
+{
+ char *rv = NULL;
+ remote_domain_snapshot_dump_xml_args args;
+ remote_domain_snapshot_dump_xml_ret ret;
+ struct private_data *priv = snapshot->domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain_snapshot(&args.snap, snapshot);
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DUMP_XML,
+ (xdrproc_t) xdr_remote_domain_snapshot_dump_xml_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_snapshot_dump_xml_ret, (char *) &ret) == -1)
+ goto done;
+
+ /* Caller frees. */
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
+static int
+remoteDomainSnapshotNum (virDomainPtr domain, unsigned int flags)
+{
+ int rv = -1;
+ remote_domain_snapshot_num_args args;
+ remote_domain_snapshot_num_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain (&args.domain, domain);
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_NUM,
+ (xdrproc_t) xdr_remote_domain_snapshot_num_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_snapshot_num_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
+static int
+remoteDomainSnapshotListNames (virDomainPtr domain, char **const names,
+ int nameslen, unsigned int flags)
+{
+ int rv = -1;
+ int i;
+ remote_domain_snapshot_list_names_args args;
+ remote_domain_snapshot_list_names_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ if (nameslen > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX) {
+ errorf (domain->conn, VIR_ERR_RPC,
+ _("too many remote domain snapshot names: %d > %d"),
+ nameslen, REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX);
+ goto done;
+ }
+
+ make_nonnull_domain(&args.domain, domain);
+ args.nameslen = nameslen;
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES,
+ (xdrproc_t) xdr_remote_domain_snapshot_list_names_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_snapshot_list_names_ret, (char *) &ret) == -1)
+ goto done;
+
+ if (ret.names.names_len > nameslen) {
+ errorf (domain->conn, VIR_ERR_RPC,
+ _("too many remote domain snapshots: %d > %d"),
+ ret.names.names_len, nameslen);
+ goto cleanup;
+ }
+
+ /* This call is caller-frees (although that isn't clear from
+ * the documentation). However xdr_free will free up both the
+ * names and the list of pointers, so we have to strdup the
+ * names here.
+ */
+ for (i = 0; i < ret.names.names_len; ++i) {
+ names[i] = strdup (ret.names.names_val[i]);
+
+ if (names[i] == NULL) {
+ for (--i; i >= 0; --i)
+ VIR_FREE(names[i]);
+
+ virReportOOMError();
+ goto cleanup;
+ }
+ }
+
+ rv = ret.names.names_len;
+
+cleanup:
+ xdr_free ((xdrproc_t) xdr_remote_domain_snapshot_list_names_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
+static virDomainSnapshotPtr
+remoteDomainSnapshotLookupByName (virDomainPtr domain, const char *name,
+ unsigned int flags)
+{
+ virDomainSnapshotPtr snapshot = NULL;
+ remote_domain_snapshot_lookup_by_name_args args;
+ remote_domain_snapshot_lookup_by_name_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.domain, domain);
+ args.name = (char *) name;
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME,
+ (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_ret, (char *) &ret) == -1)
+ goto done;
+
+ snapshot = get_nonnull_domain_snapshot (domain, ret.snap);
+ xdr_free ((xdrproc_t) &xdr_remote_domain_snapshot_lookup_by_name_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return snapshot;
+}
+
+
+static int
+remoteDomainHasCurrentSnapshot(virDomainPtr domain, unsigned int flags)
+{
+ int rv = -1;
+ remote_domain_has_current_snapshot_args args;
+ remote_domain_has_current_snapshot_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.domain, domain);
+ args.flags = flags;
+
+ if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT,
+ (xdrproc_t) xdr_remote_domain_has_current_snapshot_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_has_current_snapshot_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.result;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
+static virDomainSnapshotPtr
+remoteDomainSnapshotCurrent(virDomainPtr domain,
+ unsigned int flags)
+{
+ virDomainSnapshotPtr snapshot = NULL;
+ remote_domain_snapshot_current_args args;
+ remote_domain_snapshot_current_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.domain, domain);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+ if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT,
+ (xdrproc_t) xdr_remote_domain_snapshot_current_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_snapshot_current_ret, (char *) &ret) == -1)
+ goto done;
+
+ snapshot = get_nonnull_domain_snapshot(domain, ret.snap);
+ xdr_free((xdrproc_t) &xdr_remote_domain_snapshot_current_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return snapshot;
+}
+
+
+static int
+remoteDomainRevertToSnapshot (virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ int rv = -1;
+ remote_domain_revert_to_snapshot_args args;
+ struct private_data *priv = snapshot->domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain_snapshot(&args.snap, snapshot);
+ args.flags = flags;
+
+ if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT,
+ (xdrproc_t) xdr_remote_domain_revert_to_snapshot_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
+static int
+remoteDomainSnapshotDelete (virDomainSnapshotPtr snapshot,
+ unsigned int flags)
+{
+ int rv = -1;
+ remote_domain_snapshot_delete_args args;
+ struct private_data *priv = snapshot->domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain_snapshot(&args.snap, snapshot);
+ args.flags = flags;
+
+ if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE,
+ (xdrproc_t) xdr_remote_domain_snapshot_delete_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int remoteDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr dom,
return virGetNWFilter (conn, nwfilter.name, BAD_CAST nwfilter.uuid);
}
+static virDomainSnapshotPtr
+get_nonnull_domain_snapshot (virDomainPtr domain, remote_nonnull_domain_snapshot snapshot)
+{
+ return virGetDomainSnapshot(domain, snapshot.name);
+}
+
/* Make remote_nonnull_domain and remote_nonnull_network. */
static void
memcpy (nwfilter_dst->uuid, nwfilter_src->uuid, VIR_UUID_BUFLEN);
}
+static void
+make_nonnull_domain_snapshot (remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src)
+{
+ snapshot_dst->name = snapshot_src->name;
+ make_nonnull_domain(&snapshot_dst->domain, snapshot_src->domain);
+}
+
/*----------------------------------------------------------------------*/
unsigned long remoteVersion(void)
remoteDomainManagedSave, /* domainManagedSave */
remoteDomainHasManagedSaveImage, /* domainHasManagedSaveImage */
remoteDomainManagedSaveRemove, /* domainManagedSaveRemove */
+ remoteDomainSnapshotCreateXML, /* domainSnapshotCreateXML */
+ remoteDomainSnapshotDumpXML, /* domainSnapshotDumpXML */
+ remoteDomainSnapshotNum, /* domainSnapshotNum */
+ remoteDomainSnapshotListNames, /* domainSnapshotListNames */
+ remoteDomainSnapshotLookupByName, /* domainSnapshotLookupByName */
+ remoteDomainHasCurrentSnapshot, /* domainHasCurrentSnapshot */
+ remoteDomainSnapshotCurrent, /* domainSnapshotCurrent */
+ remoteDomainRevertToSnapshot, /* domainRevertToSnapshot */
+ remoteDomainSnapshotDelete, /* domainSnapshotDelete */
};
static virNetworkDriver network_driver = {
return TRUE;
}
+bool_t
+xdr_remote_nonnull_domain_snapshot (XDR *xdrs, remote_nonnull_domain_snapshot *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ return TRUE;
+}
+
bool_t
xdr_remote_domain (XDR *xdrs, remote_domain *objp)
{
return TRUE;
}
+bool_t
+xdr_remote_domain_snapshot_create_xml_args (XDR *xdrs, remote_domain_snapshot_create_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml_desc))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_create_xml_ret (XDR *xdrs, remote_domain_snapshot_create_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain_snapshot (xdrs, &objp->snap))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_dump_xml_args (XDR *xdrs, remote_domain_snapshot_dump_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain_snapshot (xdrs, &objp->snap))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_dump_xml_ret (XDR *xdrs, remote_domain_snapshot_dump_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_num_args (XDR *xdrs, remote_domain_snapshot_num_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_num_ret (XDR *xdrs, remote_domain_snapshot_num_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_list_names_args (XDR *xdrs, remote_domain_snapshot_list_names_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->nameslen))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_list_names_ret (XDR *xdrs, remote_domain_snapshot_list_names_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len, REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_lookup_by_name_args (XDR *xdrs, remote_domain_snapshot_lookup_by_name_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_lookup_by_name_ret (XDR *xdrs, remote_domain_snapshot_lookup_by_name_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain_snapshot (xdrs, &objp->snap))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_has_current_snapshot_args (XDR *xdrs, remote_domain_has_current_snapshot_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_has_current_snapshot_ret (XDR *xdrs, remote_domain_has_current_snapshot_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->result))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_current_args (XDR *xdrs, remote_domain_snapshot_current_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->domain))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_current_ret (XDR *xdrs, remote_domain_snapshot_current_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_domain_snapshot (xdrs, &objp->snap))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_revert_to_snapshot_args (XDR *xdrs, remote_domain_revert_to_snapshot_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain_snapshot (xdrs, &objp->snap))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_snapshot_delete_args (XDR *xdrs, remote_domain_snapshot_delete_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain_snapshot (xdrs, &objp->snap))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
bool_t
xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
{
#define REMOTE_AUTH_SASL_DATA_MAX 65536
#define REMOTE_AUTH_TYPE_LIST_MAX 20
#define REMOTE_DOMAIN_MEMORY_STATS_MAX 1024
+#define REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX 1024
#define REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX 65536
#define REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX 65536
#define REMOTE_SECURITY_MODEL_MAX VIR_SECURITY_MODEL_BUFLEN
};
typedef struct remote_nonnull_secret remote_nonnull_secret;
+struct remote_nonnull_domain_snapshot {
+ remote_nonnull_string name;
+ remote_nonnull_domain domain;
+};
+typedef struct remote_nonnull_domain_snapshot remote_nonnull_domain_snapshot;
+
typedef remote_nonnull_domain *remote_domain;
typedef remote_nonnull_network *remote_network;
u_int flags;
};
typedef struct remote_domain_managed_save_remove_args remote_domain_managed_save_remove_args;
+
+struct remote_domain_snapshot_create_xml_args {
+ remote_nonnull_domain domain;
+ remote_nonnull_string xml_desc;
+ int flags;
+};
+typedef struct remote_domain_snapshot_create_xml_args remote_domain_snapshot_create_xml_args;
+
+struct remote_domain_snapshot_create_xml_ret {
+ remote_nonnull_domain_snapshot snap;
+};
+typedef struct remote_domain_snapshot_create_xml_ret remote_domain_snapshot_create_xml_ret;
+
+struct remote_domain_snapshot_dump_xml_args {
+ remote_nonnull_domain_snapshot snap;
+ int flags;
+};
+typedef struct remote_domain_snapshot_dump_xml_args remote_domain_snapshot_dump_xml_args;
+
+struct remote_domain_snapshot_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_domain_snapshot_dump_xml_ret remote_domain_snapshot_dump_xml_ret;
+
+struct remote_domain_snapshot_num_args {
+ remote_nonnull_domain domain;
+ int flags;
+};
+typedef struct remote_domain_snapshot_num_args remote_domain_snapshot_num_args;
+
+struct remote_domain_snapshot_num_ret {
+ int num;
+};
+typedef struct remote_domain_snapshot_num_ret remote_domain_snapshot_num_ret;
+
+struct remote_domain_snapshot_list_names_args {
+ remote_nonnull_domain domain;
+ int nameslen;
+ int flags;
+};
+typedef struct remote_domain_snapshot_list_names_args remote_domain_snapshot_list_names_args;
+
+struct remote_domain_snapshot_list_names_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_domain_snapshot_list_names_ret remote_domain_snapshot_list_names_ret;
+
+struct remote_domain_snapshot_lookup_by_name_args {
+ remote_nonnull_domain domain;
+ remote_nonnull_string name;
+ int flags;
+};
+typedef struct remote_domain_snapshot_lookup_by_name_args remote_domain_snapshot_lookup_by_name_args;
+
+struct remote_domain_snapshot_lookup_by_name_ret {
+ remote_nonnull_domain_snapshot snap;
+};
+typedef struct remote_domain_snapshot_lookup_by_name_ret remote_domain_snapshot_lookup_by_name_ret;
+
+struct remote_domain_has_current_snapshot_args {
+ remote_nonnull_domain domain;
+ int flags;
+};
+typedef struct remote_domain_has_current_snapshot_args remote_domain_has_current_snapshot_args;
+
+struct remote_domain_has_current_snapshot_ret {
+ int result;
+};
+typedef struct remote_domain_has_current_snapshot_ret remote_domain_has_current_snapshot_ret;
+
+struct remote_domain_snapshot_current_args {
+ remote_nonnull_domain domain;
+ int flags;
+};
+typedef struct remote_domain_snapshot_current_args remote_domain_snapshot_current_args;
+
+struct remote_domain_snapshot_current_ret {
+ remote_nonnull_domain_snapshot snap;
+};
+typedef struct remote_domain_snapshot_current_ret remote_domain_snapshot_current_ret;
+
+struct remote_domain_revert_to_snapshot_args {
+ remote_nonnull_domain_snapshot snap;
+ int flags;
+};
+typedef struct remote_domain_revert_to_snapshot_args remote_domain_revert_to_snapshot_args;
+
+struct remote_domain_snapshot_delete_args {
+ remote_nonnull_domain_snapshot snap;
+ int flags;
+};
+typedef struct remote_domain_snapshot_delete_args remote_domain_snapshot_delete_args;
#define REMOTE_PROGRAM 0x20008086
#define REMOTE_PROTOCOL_VERSION 1
REMOTE_PROC_DOMAIN_MANAGED_SAVE = 182,
REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE = 183,
REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE = 184,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML = 185,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_DUMP_XML = 186,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_NUM = 187,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES = 188,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME = 189,
+ REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT = 190,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT = 191,
+ REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT = 192,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE = 193,
};
typedef enum remote_procedure remote_procedure;
extern bool_t xdr_remote_nonnull_storage_vol (XDR *, remote_nonnull_storage_vol*);
extern bool_t xdr_remote_nonnull_node_device (XDR *, remote_nonnull_node_device*);
extern bool_t xdr_remote_nonnull_secret (XDR *, remote_nonnull_secret*);
+extern bool_t xdr_remote_nonnull_domain_snapshot (XDR *, remote_nonnull_domain_snapshot*);
extern bool_t xdr_remote_domain (XDR *, remote_domain*);
extern bool_t xdr_remote_network (XDR *, remote_network*);
extern bool_t xdr_remote_nwfilter (XDR *, remote_nwfilter*);
extern bool_t xdr_remote_domain_has_managed_save_image_args (XDR *, remote_domain_has_managed_save_image_args*);
extern bool_t xdr_remote_domain_has_managed_save_image_ret (XDR *, remote_domain_has_managed_save_image_ret*);
extern bool_t xdr_remote_domain_managed_save_remove_args (XDR *, remote_domain_managed_save_remove_args*);
+extern bool_t xdr_remote_domain_snapshot_create_xml_args (XDR *, remote_domain_snapshot_create_xml_args*);
+extern bool_t xdr_remote_domain_snapshot_create_xml_ret (XDR *, remote_domain_snapshot_create_xml_ret*);
+extern bool_t xdr_remote_domain_snapshot_dump_xml_args (XDR *, remote_domain_snapshot_dump_xml_args*);
+extern bool_t xdr_remote_domain_snapshot_dump_xml_ret (XDR *, remote_domain_snapshot_dump_xml_ret*);
+extern bool_t xdr_remote_domain_snapshot_num_args (XDR *, remote_domain_snapshot_num_args*);
+extern bool_t xdr_remote_domain_snapshot_num_ret (XDR *, remote_domain_snapshot_num_ret*);
+extern bool_t xdr_remote_domain_snapshot_list_names_args (XDR *, remote_domain_snapshot_list_names_args*);
+extern bool_t xdr_remote_domain_snapshot_list_names_ret (XDR *, remote_domain_snapshot_list_names_ret*);
+extern bool_t xdr_remote_domain_snapshot_lookup_by_name_args (XDR *, remote_domain_snapshot_lookup_by_name_args*);
+extern bool_t xdr_remote_domain_snapshot_lookup_by_name_ret (XDR *, remote_domain_snapshot_lookup_by_name_ret*);
+extern bool_t xdr_remote_domain_has_current_snapshot_args (XDR *, remote_domain_has_current_snapshot_args*);
+extern bool_t xdr_remote_domain_has_current_snapshot_ret (XDR *, remote_domain_has_current_snapshot_ret*);
+extern bool_t xdr_remote_domain_snapshot_current_args (XDR *, remote_domain_snapshot_current_args*);
+extern bool_t xdr_remote_domain_snapshot_current_ret (XDR *, remote_domain_snapshot_current_ret*);
+extern bool_t xdr_remote_domain_revert_to_snapshot_args (XDR *, remote_domain_revert_to_snapshot_args*);
+extern bool_t xdr_remote_domain_snapshot_delete_args (XDR *, remote_domain_snapshot_delete_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*);
extern bool_t xdr_remote_nonnull_storage_vol ();
extern bool_t xdr_remote_nonnull_node_device ();
extern bool_t xdr_remote_nonnull_secret ();
+extern bool_t xdr_remote_nonnull_domain_snapshot ();
extern bool_t xdr_remote_domain ();
extern bool_t xdr_remote_network ();
extern bool_t xdr_remote_nwfilter ();
extern bool_t xdr_remote_domain_has_managed_save_image_args ();
extern bool_t xdr_remote_domain_has_managed_save_image_ret ();
extern bool_t xdr_remote_domain_managed_save_remove_args ();
+extern bool_t xdr_remote_domain_snapshot_create_xml_args ();
+extern bool_t xdr_remote_domain_snapshot_create_xml_ret ();
+extern bool_t xdr_remote_domain_snapshot_dump_xml_args ();
+extern bool_t xdr_remote_domain_snapshot_dump_xml_ret ();
+extern bool_t xdr_remote_domain_snapshot_num_args ();
+extern bool_t xdr_remote_domain_snapshot_num_ret ();
+extern bool_t xdr_remote_domain_snapshot_list_names_args ();
+extern bool_t xdr_remote_domain_snapshot_list_names_ret ();
+extern bool_t xdr_remote_domain_snapshot_lookup_by_name_args ();
+extern bool_t xdr_remote_domain_snapshot_lookup_by_name_ret ();
+extern bool_t xdr_remote_domain_has_current_snapshot_args ();
+extern bool_t xdr_remote_domain_has_current_snapshot_ret ();
+extern bool_t xdr_remote_domain_snapshot_current_args ();
+extern bool_t xdr_remote_domain_snapshot_current_ret ();
+extern bool_t xdr_remote_domain_revert_to_snapshot_args ();
+extern bool_t xdr_remote_domain_snapshot_delete_args ();
extern bool_t xdr_remote_procedure ();
extern bool_t xdr_remote_message_type ();
extern bool_t xdr_remote_message_status ();
/* Upper limit on list of memory stats */
const REMOTE_DOMAIN_MEMORY_STATS_MAX = 1024;
+/* Upper limit on lists of domain snapshots. */
+const REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX = 1024;
+
/* Maximum length of a block peek buffer message.
* Note applications need to be aware of this limit and issue multiple
* requests for large amounts of data.
remote_nonnull_string usageID;
};
+/* A snapshot which may not be NULL. */
+struct remote_nonnull_domain_snapshot {
+ remote_nonnull_string name;
+ remote_nonnull_domain domain;
+};
+
/* A domain or network which may be NULL. */
typedef remote_nonnull_domain *remote_domain;
typedef remote_nonnull_network *remote_network;
unsigned flags;
};
+struct remote_domain_snapshot_create_xml_args {
+ remote_nonnull_domain domain;
+ remote_nonnull_string xml_desc;
+ int flags;
+};
+
+struct remote_domain_snapshot_create_xml_ret {
+ remote_nonnull_domain_snapshot snap;
+};
+
+struct remote_domain_snapshot_dump_xml_args {
+ remote_nonnull_domain_snapshot snap;
+ int flags;
+};
+
+struct remote_domain_snapshot_dump_xml_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_domain_snapshot_num_args {
+ remote_nonnull_domain domain;
+ int flags;
+};
+
+struct remote_domain_snapshot_num_ret {
+ int num;
+};
+
+struct remote_domain_snapshot_list_names_args {
+ remote_nonnull_domain domain;
+ int nameslen;
+ int flags;
+};
+
+struct remote_domain_snapshot_list_names_ret {
+ remote_nonnull_string names<REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX>;
+};
+
+struct remote_domain_snapshot_lookup_by_name_args {
+ remote_nonnull_domain domain;
+ remote_nonnull_string name;
+ int flags;
+};
+
+struct remote_domain_snapshot_lookup_by_name_ret {
+ remote_nonnull_domain_snapshot snap;
+};
+
+struct remote_domain_has_current_snapshot_args {
+ remote_nonnull_domain domain;
+ int flags;
+};
+
+struct remote_domain_has_current_snapshot_ret {
+ int result;
+};
+
+struct remote_domain_snapshot_current_args {
+ remote_nonnull_domain domain;
+ int flags;
+};
+
+struct remote_domain_snapshot_current_ret {
+ remote_nonnull_domain_snapshot snap;
+};
+
+struct remote_domain_revert_to_snapshot_args {
+ remote_nonnull_domain_snapshot snap;
+ int flags;
+};
+
+struct remote_domain_snapshot_delete_args {
+ remote_nonnull_domain_snapshot snap;
+ int flags;
+};
+
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
REMOTE_PROC_NWFILTER_UNDEFINE = 181,
REMOTE_PROC_DOMAIN_MANAGED_SAVE = 182,
REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE = 183,
- REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE = 184
+ REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE = 184,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML = 185,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_DUMP_XML = 186,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_NUM = 187,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES = 188,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME = 189,
+ REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT = 190,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT = 191,
+ REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT = 192,
+ REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE = 193
/*
* Notice how the entries are grouped in sets of 10 ?
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
static virNetworkDriver testNetworkDriver = {
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
case VIR_FROM_HOOK:
dom = "Sync Hook ";
break;
+ case VIR_FROM_DOMAIN_SNAPSHOT:
+ dom = "Domain Snapshot ";
+ break;
}
return(dom);
}
else
errmsg = _("Hook script execution failed: %s");
break;
+ case VIR_ERR_INVALID_DOMAIN_SNAPSHOT:
+ if (info == NULL)
+ errmsg = _("Invalid snapshot");
+ else
+ errmsg = _("Invalid snapshot: %s");
+ break;
+ case VIR_ERR_NO_DOMAIN_SNAPSHOT:
+ if (info == NULL)
+ errmsg = _("Domain snapshot not found");
+ else
+ errmsg = _("Domain snapshot not found: %s");
+ break;
}
return (errmsg);
}
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
virNetworkDriver NAME(NetworkDriver) = {
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
/**
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
+ NULL, /* domainSnapshotCreateXML */
+ NULL, /* domainSnapshotDumpXML */
+ NULL, /* domainSnapshotNum */
+ NULL, /* domainSnapshotListNames */
+ NULL, /* domainSnapshotLookupByName */
+ NULL, /* domainHasCurrentSnapshot */
+ NULL, /* domainSnapshotCurrent */
+ NULL, /* domainRevertToSnapshot */
+ NULL, /* domainSnapshotDelete */
};
/**
projects / thirdparty / libvirt.git / commitdiff
