}
+static int remoteDispatchDomainIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_domain_is_active_args *args,
+ remote_domain_is_active_ret *ret)
+{
+ virDomainPtr domain;
+
+ domain = get_nonnull_domain(conn, args->dom);
+ if (domain == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->active = virDomainIsActive(domain);
+
+ if (ret->active < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchDomainIsPersistent(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_domain_is_persistent_args *args,
+ remote_domain_is_persistent_ret *ret)
+{
+ virDomainPtr domain;
+
+ domain = get_nonnull_domain(conn, args->dom);
+ if (domain == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->persistent = virDomainIsPersistent(domain);
+
+ if (ret->persistent < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchInterfaceIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_interface_is_active_args *args,
+ remote_interface_is_active_ret *ret)
+{
+ virInterfacePtr iface;
+
+ iface = get_nonnull_interface(conn, args->iface);
+ if (iface == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->active = virInterfaceIsActive(iface);
+
+ if (ret->active < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchNetworkIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_network_is_active_args *args,
+ remote_network_is_active_ret *ret)
+{
+ virNetworkPtr network;
+
+ network = get_nonnull_network(conn, args->net);
+ if (network == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->active = virNetworkIsActive(network);
+
+ if (ret->active < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchNetworkIsPersistent(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_network_is_persistent_args *args,
+ remote_network_is_persistent_ret *ret)
+{
+ virNetworkPtr network;
+
+ network = get_nonnull_network(conn, args->net);
+ if (network == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->persistent = virNetworkIsPersistent(network);
+
+ if (ret->persistent < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchStoragePoolIsActive(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_storage_pool_is_active_args *args,
+ remote_storage_pool_is_active_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool(conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->active = virStoragePoolIsActive(pool);
+
+ if (ret->active < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int remoteDispatchStoragePoolIsPersistent(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ remote_storage_pool_is_persistent_args *args,
+ remote_storage_pool_is_persistent_ret *ret)
+{
+ virStoragePoolPtr pool;
+
+ pool = get_nonnull_storage_pool(conn, args->pool);
+ if (pool == NULL) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ ret->persistent = virStoragePoolIsPersistent(pool);
+
+ if (ret->persistent < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int remoteDispatchIsSecure(struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *err,
+ void *args ATTRIBUTE_UNUSED,
+ remote_is_secure_ret *ret)
+{
+ ret->secure = virConnectIsSecure(conn);
+
+ if (ret->secure < 0) {
+ remoteDispatchConnError(err, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+
/*----- Helpers. -----*/
/* get_nonnull_domain and get_nonnull_network turn an on-wire
remote_secret_undefine_args val_remote_secret_undefine_args;
remote_secret_lookup_by_usage_args val_remote_secret_lookup_by_usage_args;
remote_domain_migrate_prepare_tunnel_args val_remote_domain_migrate_prepare_tunnel_args;
+ remote_domain_is_active_args val_remote_domain_is_active_args;
+ remote_domain_is_persistent_args val_remote_domain_is_persistent_args;
+ remote_network_is_active_args val_remote_network_is_active_args;
+ remote_network_is_persistent_args val_remote_network_is_persistent_args;
+ remote_storage_pool_is_active_args val_remote_storage_pool_is_active_args;
+ remote_storage_pool_is_persistent_args val_remote_storage_pool_is_persistent_args;
+ remote_interface_is_active_args val_remote_interface_is_active_args;
remote_error *err,
remote_domain_interface_stats_args *args,
remote_domain_interface_stats_ret *ret);
+static int remoteDispatchDomainIsActive(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_is_active_args *args,
+ remote_domain_is_active_ret *ret);
+static int remoteDispatchDomainIsPersistent(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_domain_is_persistent_args *args,
+ remote_domain_is_persistent_ret *ret);
static int remoteDispatchDomainLookupById(
struct qemud_server *server,
struct qemud_client *client,
remote_error *err,
remote_interface_get_xml_desc_args *args,
remote_interface_get_xml_desc_ret *ret);
+static int remoteDispatchInterfaceIsActive(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_interface_is_active_args *args,
+ remote_interface_is_active_ret *ret);
static int remoteDispatchInterfaceLookupByMacString(
struct qemud_server *server,
struct qemud_client *client,
remote_error *err,
remote_interface_undefine_args *args,
void *ret);
+static int remoteDispatchIsSecure(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ void *args,
+ remote_is_secure_ret *ret);
static int remoteDispatchListDefinedDomains(
struct qemud_server *server,
struct qemud_client *client,
remote_error *err,
remote_network_get_bridge_name_args *args,
remote_network_get_bridge_name_ret *ret);
+static int remoteDispatchNetworkIsActive(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_network_is_active_args *args,
+ remote_network_is_active_ret *ret);
+static int remoteDispatchNetworkIsPersistent(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_network_is_persistent_args *args,
+ remote_network_is_persistent_ret *ret);
static int remoteDispatchNetworkLookupByName(
struct qemud_server *server,
struct qemud_client *client,
remote_error *err,
remote_storage_pool_get_info_args *args,
remote_storage_pool_get_info_ret *ret);
+static int remoteDispatchStoragePoolIsActive(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_storage_pool_is_active_args *args,
+ remote_storage_pool_is_active_ret *ret);
+static int remoteDispatchStoragePoolIsPersistent(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_message_header *hdr,
+ remote_error *err,
+ remote_storage_pool_is_persistent_args *args,
+ remote_storage_pool_is_persistent_ret *ret);
static int remoteDispatchStoragePoolListVolumes(
struct qemud_server *server,
struct qemud_client *client,
remote_secret_get_xml_desc_ret val_remote_secret_get_xml_desc_ret;
remote_secret_get_value_ret val_remote_secret_get_value_ret;
remote_secret_lookup_by_usage_ret val_remote_secret_lookup_by_usage_ret;
+ remote_is_secure_ret val_remote_is_secure_ret;
+ remote_domain_is_active_ret val_remote_domain_is_active_ret;
+ remote_domain_is_persistent_ret val_remote_domain_is_persistent_ret;
+ remote_network_is_active_ret val_remote_network_is_active_ret;
+ remote_network_is_persistent_ret val_remote_network_is_persistent_ret;
+ remote_storage_pool_is_active_ret val_remote_storage_pool_is_active_ret;
+ remote_storage_pool_is_persistent_ret val_remote_storage_pool_is_persistent_ret;
+ remote_interface_is_active_ret val_remote_interface_is_active_ret;
.args_filter = (xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel_args,
.ret_filter = (xdrproc_t) xdr_void,
},
+{ /* IsSecure => 149 */
+ .fn = (dispatch_fn) remoteDispatchIsSecure,
+ .args_filter = (xdrproc_t) xdr_void,
+ .ret_filter = (xdrproc_t) xdr_remote_is_secure_ret,
+},
+{ /* DomainIsActive => 150 */
+ .fn = (dispatch_fn) remoteDispatchDomainIsActive,
+ .args_filter = (xdrproc_t) xdr_remote_domain_is_active_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_is_active_ret,
+},
+{ /* DomainIsPersistent => 151 */
+ .fn = (dispatch_fn) remoteDispatchDomainIsPersistent,
+ .args_filter = (xdrproc_t) xdr_remote_domain_is_persistent_args,
+ .ret_filter = (xdrproc_t) xdr_remote_domain_is_persistent_ret,
+},
+{ /* NetworkIsActive => 152 */
+ .fn = (dispatch_fn) remoteDispatchNetworkIsActive,
+ .args_filter = (xdrproc_t) xdr_remote_network_is_active_args,
+ .ret_filter = (xdrproc_t) xdr_remote_network_is_active_ret,
+},
+{ /* NetworkIsPersistent => 153 */
+ .fn = (dispatch_fn) remoteDispatchNetworkIsPersistent,
+ .args_filter = (xdrproc_t) xdr_remote_network_is_persistent_args,
+ .ret_filter = (xdrproc_t) xdr_remote_network_is_persistent_ret,
+},
+{ /* StoragePoolIsActive => 154 */
+ .fn = (dispatch_fn) remoteDispatchStoragePoolIsActive,
+ .args_filter = (xdrproc_t) xdr_remote_storage_pool_is_active_args,
+ .ret_filter = (xdrproc_t) xdr_remote_storage_pool_is_active_ret,
+},
+{ /* StoragePoolIsPersistent => 155 */
+ .fn = (dispatch_fn) remoteDispatchStoragePoolIsPersistent,
+ .args_filter = (xdrproc_t) xdr_remote_storage_pool_is_persistent_args,
+ .ret_filter = (xdrproc_t) xdr_remote_storage_pool_is_persistent_ret,
+},
+{ /* InterfaceIsActive => 156 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceIsActive,
+ .args_filter = (xdrproc_t) xdr_remote_interface_is_active_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_is_active_ret,
+},
}
+static int
+esxIsSecure(virConnectPtr conn)
+{
+ esxPrivate *priv = (esxPrivate *)conn->privateData;
+
+ if (STRCASEEQ(priv->transport, "https")) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+
+static int
+esxIsEncrypted(virConnectPtr conn)
+{
+ esxPrivate *priv = (esxPrivate *)conn->privateData;
+
+ if (STRCASEEQ(priv->transport, "https")) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
static esxVI_Boolean
esxSupportsVMotion(virConnectPtr conn)
}
+static int
+esxDomainIsActive(virDomainPtr dom)
+{
+ esxPrivate *priv = (esxPrivate *)dom->conn->privateData;
+ esxVI_String *propertyNameList = NULL;
+ esxVI_ObjectContent *virtualMachineList = NULL;
+ esxVI_ObjectContent *virtualMachine = NULL;
+ esxVI_VirtualMachinePowerState powerState;
+ int id_candidate = -1;
+ char *name_candidate = NULL;
+ unsigned char uuid_candidate[VIR_UUID_BUFLEN];
+ char uuid_string[VIR_UUID_STRING_BUFLEN];
+ int ret = -1;
+
+ if (esxVI_EnsureSession(dom->conn, priv->host) < 0) {
+ goto cleanup;
+ }
+
+ if (esxVI_String_AppendValueListToList(dom->conn, &propertyNameList,
+ "configStatus\0"
+ "name\0"
+ "runtime.powerState\0"
+ "config.uuid\0") < 0 ||
+ esxVI_LookupObjectContentByType(dom->conn, priv->host, priv->host->vmFolder,
+ "VirtualMachine", propertyNameList,
+ esxVI_Boolean_True,
+ &virtualMachineList) < 0) {
+ goto cleanup;
+ }
+
+ for (virtualMachine = virtualMachineList; virtualMachine != NULL;
+ virtualMachine = virtualMachine->_next) {
+ VIR_FREE(name_candidate);
+
+ if (esxVI_GetVirtualMachineIdentity(dom->conn, virtualMachine,
+ &id_candidate, &name_candidate,
+ uuid_candidate) < 0) {
+ goto cleanup;
+ }
+
+ if (memcmp(dom->uuid, uuid_candidate,
+ VIR_UUID_BUFLEN * sizeof(unsigned char)) != 0) {
+ continue;
+ }
+
+ if (esxVI_GetVirtualMachinePowerState(dom->conn, virtualMachine,
+ &powerState) < 0) {
+ goto cleanup;
+ }
+
+ /* Only running/suspended virtual machines have an ID != -1 */
+ if (powerState != esxVI_VirtualMachinePowerState_PoweredOff) {
+ ret = 1;
+ } else {
+ ret = 0;
+ }
+
+ break;
+ }
+
+ if (ret == -1) {
+ virUUIDFormat(dom->uuid, uuid_string);
+
+ ESX_ERROR(dom->conn, VIR_ERR_NO_DOMAIN, "No domain with UUID '%s'",
+ uuid_string);
+ }
+
+ cleanup:
+ esxVI_String_Free(&propertyNameList);
+ esxVI_ObjectContent_Free(&virtualMachineList);
+ VIR_FREE(name_candidate);
+
+ return ret;
+}
+
+
+static int
+esxDomainIsPersistent(virDomainPtr dom ATTRIBUTE_UNUSED)
+{
+ /* ESX has no concept of transient domains, so
+ * all of them are persistent */
+ return 1;
+}
static int
esxDomainSuspend(virDomainPtr domain)
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ esxIsEncrypted, /* isEncrypted */
+ esxIsSecure, /* isSecure */
+ esxDomainIsActive, /* domainIsActive */
+ esxDomainIsPersistent, /* domainIsPersistent */
};
return 0;
}
+
+static int lxcIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Trivially secure, since always inside the daemon */
+ return 1;
+}
+
+
+static int lxcIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Not encrypted, but remote driver takes care of that */
+ return 0;
+}
+
+
static char *lxcGetCapabilities(virConnectPtr conn) {
lxc_driver_t *driver = conn->privateData;
char *xml;
return dom;
}
+
+static int lxcDomainIsActive(virDomainPtr dom)
+{
+ lxc_driver_t *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ lxcDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ lxcDriverUnlock(driver);
+ if (!obj) {
+ lxcError(dom->conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = virDomainObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
+static int lxcDomainIsPersistent(virDomainPtr dom)
+{
+ lxc_driver_t *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ lxcDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ lxcDriverUnlock(driver);
+ if (!obj) {
+ lxcError(dom->conn, NULL, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
static int lxcListDomains(virConnectPtr conn, int *ids, int nids) {
lxc_driver_t *driver = conn->privateData;
int n;
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ lxcIsEncrypted,
+ lxcIsSecure,
+ lxcDomainIsActive,
+ lxcDomainIsPersistent,
};
static virStateDriver lxcStateDriver = {
return -1;
}
+
+static int networkIsActive(virNetworkPtr net)
+{
+ struct network_driver *driver = net->conn->privateData;
+ virNetworkObjPtr obj;
+ int ret = -1;
+
+ networkDriverLock(driver);
+ obj = virNetworkFindByUUID(&driver->networks, net->uuid);
+ networkDriverUnlock(driver);
+ if (!obj) {
+ networkReportError(net->conn, NULL, NULL, VIR_ERR_NO_NETWORK, NULL);
+ goto cleanup;
+ }
+ ret = virNetworkObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virNetworkObjUnlock(obj);
+ return ret;
+}
+
+static int networkIsPersistent(virNetworkPtr net)
+{
+ struct network_driver *driver = net->conn->privateData;
+ virNetworkObjPtr obj;
+ int ret = -1;
+
+ networkDriverLock(driver);
+ obj = virNetworkFindByUUID(&driver->networks, net->uuid);
+ networkDriverUnlock(driver);
+ if (!obj) {
+ networkReportError(net->conn, NULL, NULL, VIR_ERR_NO_NETWORK, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virNetworkObjUnlock(obj);
+ return ret;
+}
+
+
static virNetworkPtr networkCreate(virConnectPtr conn, const char *xml) {
struct network_driver *driver = conn->networkPrivateData;
virNetworkDefPtr def;
network = virNetworkFindByUUID(&driver->networks, net->uuid);
if (!network) {
- networkReportError(net->conn, NULL, net, VIR_ERR_INVALID_DOMAIN,
+ networkReportError(net->conn, NULL, net, VIR_ERR_INVALID_NETWORK,
"%s", _("no network with matching uuid"));
goto cleanup;
}
networkGetBridgeName, /* networkGetBridgeName */
networkGetAutostart, /* networkGetAutostart */
networkSetAutostart, /* networkSetAutostart */
- NULL, /* networkIsActive */
- NULL, /* networkIsPersistent */
+ networkIsActive,
+ networkIsPersistent,
};
static virStateDriver networkStateDriver = {
return 0;
}
+
+static int oneIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Not encrypted because it uses HTTP, not HTTPs */
+ return 0;
+}
+
+
+static int oneIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Not secure because it uses HTTP, not HTTPs */
+ return 0;
+}
+
+
static virDomainPtr oneDomainLookupByID(virConnectPtr conn,
int id)
{
NULL, /* nodeDeviceReAttach; */
NULL, /* nodeDeviceReset; */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
+ oneIsEncrypted,
+ oneIsSecure,
NULL, /* domainIsActive */
NULL, /* domainIsPersistent */
};
dom->refs = 1;
dom->pid = veid;
dom->def->id = dom->state == VIR_DOMAIN_SHUTOFF ? -1 : veid;
+ /* XXX OpenVZ doesn't appear to have concept of a transient domain */
+ dom->persistent = 1;
if (virAsprintf(&dom->def->name, "%i", veid) < 0)
goto no_memory;
}
+static int openvzDomainIsActive(virDomainPtr dom)
+{
+ struct openvz_driver *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ openvzDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ openvzDriverUnlock(driver);
+ if (!obj) {
+ openvzError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = virDomainObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
+static int openvzDomainIsPersistent(virDomainPtr dom)
+{
+ struct openvz_driver *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ openvzDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ openvzDriverUnlock(driver);
+ if (!obj) {
+ openvzError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
static char *openvzDomainDumpXML(virDomainPtr dom, int flags) {
struct openvz_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
&driver->domains, vmdef)))
goto cleanup;
vmdef = NULL;
+ vm->persistent = 1;
if (openvzSetInitialConfig(conn, vm->def) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
&driver->domains, vmdef)))
goto cleanup;
vmdef = NULL;
+ /* All OpenVZ domains seem to be persistent - this is a bit of a violation
+ * of this libvirt API which is intended for transient domain creation */
+ vm->persistent = 1;
if (openvzSetInitialConfig(conn, vm->def) < 0) {
openvzError(conn, VIR_ERR_INTERNAL_ERROR,
return "OpenVZ";
}
+static int openvzIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED) {
+ /* Encryption is not relevant / applicable to way we talk to openvz */
+ return 0;
+}
+
+static int openvzIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED) {
+ /* We run CLI tools directly so this is secure */
+ return 1;
+}
+
static char *openvzGetCapabilities(virConnectPtr conn) {
struct openvz_driver *driver = conn->privateData;
char *ret;
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ openvzIsEncrypted,
+ openvzIsSecure,
+ openvzDomainIsActive,
+ openvzDomainIsPersistent,
};
int openvzRegister(void) {
return 0;
}
+
+static int
+phypIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Phyp uses an SSH tunnel, so is always encrypted */
+ return 1;
+}
+
+
+static int
+phypIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Phyp uses an SSH tunnel, so is always secure */
+ return 1;
+}
+
+
LIBSSH2_SESSION *
openSSHSession(virConnectPtr conn, virConnectAuthPtr auth,
int *internal_socket)
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ phypIsEncrypted,
+ phypIsSecure,
+ NULL, /* domainIsActive */
+ NULL, /* domainIsPersistent */
};
int
}
+static int qemuIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Trivially secure, since always inside the daemon */
+ return 1;
+}
+
+static int qemuIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Not encrypted, but remote driver takes care of that */
+ return 0;
+}
+
+
static int kvmGetMaxVCPUs(void) {
int maxvcpus = 1;
return dom;
}
+
+static int qemuDomainIsActive(virDomainPtr dom)
+{
+ struct qemud_driver *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ qemuDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ qemuDriverUnlock(driver);
+ if (!obj) {
+ qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = virDomainObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+static int qemuDomainIsPersistent(virDomainPtr dom)
+{
+ struct qemud_driver *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ qemuDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ qemuDriverUnlock(driver);
+ if (!obj) {
+ qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
struct qemud_driver *driver = conn->privateData;
int ret = -1;
qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
qemudNodeDeviceReset, /* nodeDeviceReset */
qemudDomainMigratePrepareTunnel, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ qemuIsEncrypted,
+ qemuIsSecure,
+ qemuDomainIsActive,
+ qemuDomainIsPersistent,
};
int watch; /* File handle watch */
pid_t pid; /* PID of tunnel process */
int uses_tls; /* TLS enabled on socket? */
+ int is_secure; /* Secure if TLS or SASL or UNIX sockets */
gnutls_session_t session; /* GnuTLS session (if uses_tls != 0). */
char *type; /* Cached return from remoteType. */
int counter; /* Generates serial numbers for RPC. */
case trans_tls:
if (initialise_gnutls (conn) == -1) goto failed;
priv->uses_tls = 1;
+ priv->is_secure = 1;
/*FALLTHROUGH*/
case trans_tcp: {
addr.sun_path[0] = '\0';
autostart_retry:
+ priv->is_secure = 1;
priv->sock = socket (AF_UNIX, SOCK_STREAM, 0);
if (priv->sock == -1) {
virReportSystemError(conn, errno, "%s",
for (j = 0; j < (nr_args-1); j++)
if (cmd_argv[j] == NULL)
goto out_of_memory;
+
+ priv->is_secure = 1;
}
/*FALLTHROUGH*/
close (sv[1]);
priv->sock = sv[0];
priv->pid = pid;
+
+ /* Do not set 'is_secure' flag since we can't guarentee
+ * an external program is secure, and this flag must be
+ * pessimistic */
}
#else /* WIN32 */
return rv;
}
+static int remoteIsSecure(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->privateData;
+ remote_is_secure_ret ret;
+ remoteDriverLock(priv);
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
+ (xdrproc_t) xdr_void, (char *) NULL,
+ (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
+ goto done;
+
+ /* We claim to be secure, if the remote driver
+ * transport itself is secure, and the remote
+ * HV connection is secure
+ *
+ * ie, we don't want to claim to be secure if the
+ * remote driver is used to connect to a XenD
+ * driver using unencrypted HTTP:/// access
+ */
+ rv = priv->is_secure && ret.secure ? 1 : 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int remoteIsEncrypted(virConnectPtr conn)
+{
+ int rv = -1;
+ int encrypted = 0;
+ struct private_data *priv = conn->privateData;
+ remote_is_secure_ret ret;
+ remoteDriverLock(priv);
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_IS_SECURE,
+ (xdrproc_t) xdr_void, (char *) NULL,
+ (xdrproc_t) xdr_remote_is_secure_ret, (char *) &ret) == -1)
+ goto done;
+
+ if (priv->uses_tls)
+ encrypted = 1;
+#if HAVE_SASL
+ else if (priv->saslconn)
+ encrypted = 1;
+#endif
+
+
+ /* We claim to be encrypted, if the remote driver
+ * transport itself is encrypted, and the remote
+ * HV connection is secure.
+ *
+ * Yes, we really don't check the remote 'encrypted'
+ * option, since it will almost always be false,
+ * even if secure (eg UNIX sockets).
+ */
+ rv = encrypted && ret.secure ? 1 : 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
static int
remoteGetMaxVcpus (virConnectPtr conn, const char *type)
{
return rv;
}
+static int
+remoteDomainIsActive(virDomainPtr domain)
+{
+ int rv = -1;
+ remote_domain_is_active_args args;
+ remote_domain_is_active_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain (&args.dom, domain);
+
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_ACTIVE,
+ (xdrproc_t) xdr_remote_domain_is_active_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_is_active_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainIsPersistent(virDomainPtr domain)
+{
+ int rv = -1;
+ remote_domain_is_persistent_args args;
+ remote_domain_is_persistent_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain (&args.dom, domain);
+
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_PERSISTENT,
+ (xdrproc_t) xdr_remote_domain_is_persistent_args, (char *) &args,
+ (xdrproc_t) xdr_remote_domain_is_persistent_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.persistent;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
static virDomainPtr
remoteDomainCreateXML (virConnectPtr conn,
const char *xmlDesc,
return net;
}
+static int
+remoteNetworkIsActive(virNetworkPtr network)
+{
+ int rv = -1;
+ remote_network_is_active_args args;
+ remote_network_is_active_ret ret;
+ struct private_data *priv = network->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network (&args.net, network);
+
+ if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_IS_ACTIVE,
+ (xdrproc_t) xdr_remote_network_is_active_args, (char *) &args,
+ (xdrproc_t) xdr_remote_network_is_active_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNetworkIsPersistent(virNetworkPtr network)
+{
+ int rv = -1;
+ remote_network_is_persistent_args args;
+ remote_network_is_persistent_ret ret;
+ struct private_data *priv = network->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network (&args.net, network);
+
+ if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_IS_PERSISTENT,
+ (xdrproc_t) xdr_remote_network_is_persistent_args, (char *) &args,
+ (xdrproc_t) xdr_remote_network_is_persistent_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.persistent;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
static virNetworkPtr
remoteNetworkCreateXML (virConnectPtr conn, const char *xmlDesc)
{
return iface;
}
+
+static int
+remoteInterfaceIsActive(virInterfacePtr iface)
+{
+ int rv = -1;
+ remote_interface_is_active_args args;
+ remote_interface_is_active_ret ret;
+ struct private_data *priv = iface->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.iface, iface);
+
+ if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_IS_ACTIVE,
+ (xdrproc_t) xdr_remote_interface_is_active_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_is_active_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
static char *
remoteInterfaceGetXMLDesc (virInterfacePtr iface,
unsigned int flags)
}
+static int
+remoteStoragePoolIsActive(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ remote_storage_pool_is_active_args args;
+ remote_storage_pool_is_active_ret ret;
+ struct private_data *priv = pool->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool (&args.pool, pool);
+
+ if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_ACTIVE,
+ (xdrproc_t) xdr_remote_storage_pool_is_active_args, (char *) &args,
+ (xdrproc_t) xdr_remote_storage_pool_is_active_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolIsPersistent(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ remote_storage_pool_is_persistent_args args;
+ remote_storage_pool_is_persistent_ret ret;
+ struct private_data *priv = pool->conn->privateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool (&args.pool, pool);
+
+ if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT,
+ (xdrproc_t) xdr_remote_storage_pool_is_persistent_args, (char *) &args,
+ (xdrproc_t) xdr_remote_storage_pool_is_persistent_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.persistent;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+
static virStoragePoolPtr
remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
{
_("negotiation SSF %d was not strong enough"), ssf);
goto cleanup;
}
+ priv->is_secure = 1;
}
DEBUG0("SASL authentication complete");
remoteNodeDeviceReAttach, /* nodeDeviceReAttach */
remoteNodeDeviceReset, /* nodeDeviceReset */
remoteDomainMigratePrepareTunnel, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ remoteIsEncrypted, /* isEncrypted */
+ remoteIsSecure, /* isSecure */
+ remoteDomainIsActive, /* domainIsActive */
+ remoteDomainIsPersistent, /* domainIsPersistent */
};
static virNetworkDriver network_driver = {
.networkGetBridgeName = remoteNetworkGetBridgeName,
.networkGetAutostart = remoteNetworkGetAutostart,
.networkSetAutostart = remoteNetworkSetAutostart,
- .networkIsActive = NULL,
- .networkIsPersistent = NULL,
+ .networkIsActive = remoteNetworkIsActive,
+ .networkIsPersistent = remoteNetworkIsPersistent,
};
static virInterfaceDriver interface_driver = {
.interfaceUndefine = remoteInterfaceUndefine,
.interfaceCreate = remoteInterfaceCreate,
.interfaceDestroy = remoteInterfaceDestroy,
- .interfaceIsActive = NULL, /* interfaceIsActive */
+ .interfaceIsActive = remoteInterfaceIsActive,
};
static virStorageDriver storage_driver = {
.volGetInfo = remoteStorageVolGetInfo,
.volGetXMLDesc = remoteStorageVolDumpXML,
.volGetPath = remoteStorageVolGetPath,
-
- .poolIsActive = NULL, /* poolIsActive */
- .poolIsPersistent = NULL, /* poolIsEncrypted */
+ .poolIsActive = remoteStoragePoolIsActive,
+ .poolIsPersistent = remoteStoragePoolIsPersistent,
};
static virSecretDriver secret_driver = {
return TRUE;
}
+bool_t
+xdr_remote_is_secure_ret (XDR *xdrs, remote_is_secure_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->secure))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_active_args (XDR *xdrs, remote_domain_is_active_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_active_ret (XDR *xdrs, remote_domain_is_active_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->active))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_persistent_args (XDR *xdrs, remote_domain_is_persistent_args *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_is_persistent_ret (XDR *xdrs, remote_domain_is_persistent_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->persistent))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_active_args (XDR *xdrs, remote_network_is_active_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_active_ret (XDR *xdrs, remote_network_is_active_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->active))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_persistent_args (XDR *xdrs, remote_network_is_persistent_args *objp)
+{
+
+ if (!xdr_remote_nonnull_network (xdrs, &objp->net))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_network_is_persistent_ret (XDR *xdrs, remote_network_is_persistent_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->persistent))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_active_args (XDR *xdrs, remote_storage_pool_is_active_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_active_ret (XDR *xdrs, remote_storage_pool_is_active_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->active))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_persistent_args (XDR *xdrs, remote_storage_pool_is_persistent_args *objp)
+{
+
+ if (!xdr_remote_nonnull_storage_pool (xdrs, &objp->pool))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_storage_pool_is_persistent_ret (XDR *xdrs, remote_storage_pool_is_persistent_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->persistent))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_is_active_args (XDR *xdrs, remote_interface_is_active_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->iface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_is_active_ret (XDR *xdrs, remote_interface_is_active_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->active))
+ return FALSE;
+ return TRUE;
+}
+
bool_t
xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
{
};
typedef struct remote_domain_migrate_prepare_tunnel_args remote_domain_migrate_prepare_tunnel_args;
+struct remote_is_secure_ret {
+ int secure;
+};
+typedef struct remote_is_secure_ret remote_is_secure_ret;
+
+struct remote_domain_is_active_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_is_active_args remote_domain_is_active_args;
+
+struct remote_domain_is_active_ret {
+ int active;
+};
+typedef struct remote_domain_is_active_ret remote_domain_is_active_ret;
+
+struct remote_domain_is_persistent_args {
+ remote_nonnull_domain dom;
+};
+typedef struct remote_domain_is_persistent_args remote_domain_is_persistent_args;
+
+struct remote_domain_is_persistent_ret {
+ int persistent;
+};
+typedef struct remote_domain_is_persistent_ret remote_domain_is_persistent_ret;
+
+struct remote_network_is_active_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_is_active_args remote_network_is_active_args;
+
+struct remote_network_is_active_ret {
+ int active;
+};
+typedef struct remote_network_is_active_ret remote_network_is_active_ret;
+
+struct remote_network_is_persistent_args {
+ remote_nonnull_network net;
+};
+typedef struct remote_network_is_persistent_args remote_network_is_persistent_args;
+
+struct remote_network_is_persistent_ret {
+ int persistent;
+};
+typedef struct remote_network_is_persistent_ret remote_network_is_persistent_ret;
+
+struct remote_storage_pool_is_active_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_is_active_args remote_storage_pool_is_active_args;
+
+struct remote_storage_pool_is_active_ret {
+ int active;
+};
+typedef struct remote_storage_pool_is_active_ret remote_storage_pool_is_active_ret;
+
+struct remote_storage_pool_is_persistent_args {
+ remote_nonnull_storage_pool pool;
+};
+typedef struct remote_storage_pool_is_persistent_args remote_storage_pool_is_persistent_args;
+
+struct remote_storage_pool_is_persistent_ret {
+ int persistent;
+};
+typedef struct remote_storage_pool_is_persistent_ret remote_storage_pool_is_persistent_ret;
+
+struct remote_interface_is_active_args {
+ remote_nonnull_interface iface;
+};
+typedef struct remote_interface_is_active_args remote_interface_is_active_args;
+
+struct remote_interface_is_active_ret {
+ int active;
+};
+typedef struct remote_interface_is_active_ret remote_interface_is_active_ret;
#define REMOTE_PROGRAM 0x20008086
#define REMOTE_PROTOCOL_VERSION 1
REMOTE_PROC_SECRET_UNDEFINE = 146,
REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147,
REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL = 148,
+ REMOTE_PROC_IS_SECURE = 149,
+ REMOTE_PROC_DOMAIN_IS_ACTIVE = 150,
+ REMOTE_PROC_DOMAIN_IS_PERSISTENT = 151,
+ REMOTE_PROC_NETWORK_IS_ACTIVE = 152,
+ REMOTE_PROC_NETWORK_IS_PERSISTENT = 153,
+ REMOTE_PROC_STORAGE_POOL_IS_ACTIVE = 154,
+ REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155,
+ REMOTE_PROC_INTERFACE_IS_ACTIVE = 156,
};
typedef enum remote_procedure remote_procedure;
extern bool_t xdr_remote_secret_lookup_by_usage_args (XDR *, remote_secret_lookup_by_usage_args*);
extern bool_t xdr_remote_secret_lookup_by_usage_ret (XDR *, remote_secret_lookup_by_usage_ret*);
extern bool_t xdr_remote_domain_migrate_prepare_tunnel_args (XDR *, remote_domain_migrate_prepare_tunnel_args*);
+extern bool_t xdr_remote_is_secure_ret (XDR *, remote_is_secure_ret*);
+extern bool_t xdr_remote_domain_is_active_args (XDR *, remote_domain_is_active_args*);
+extern bool_t xdr_remote_domain_is_active_ret (XDR *, remote_domain_is_active_ret*);
+extern bool_t xdr_remote_domain_is_persistent_args (XDR *, remote_domain_is_persistent_args*);
+extern bool_t xdr_remote_domain_is_persistent_ret (XDR *, remote_domain_is_persistent_ret*);
+extern bool_t xdr_remote_network_is_active_args (XDR *, remote_network_is_active_args*);
+extern bool_t xdr_remote_network_is_active_ret (XDR *, remote_network_is_active_ret*);
+extern bool_t xdr_remote_network_is_persistent_args (XDR *, remote_network_is_persistent_args*);
+extern bool_t xdr_remote_network_is_persistent_ret (XDR *, remote_network_is_persistent_ret*);
+extern bool_t xdr_remote_storage_pool_is_active_args (XDR *, remote_storage_pool_is_active_args*);
+extern bool_t xdr_remote_storage_pool_is_active_ret (XDR *, remote_storage_pool_is_active_ret*);
+extern bool_t xdr_remote_storage_pool_is_persistent_args (XDR *, remote_storage_pool_is_persistent_args*);
+extern bool_t xdr_remote_storage_pool_is_persistent_ret (XDR *, remote_storage_pool_is_persistent_ret*);
+extern bool_t xdr_remote_interface_is_active_args (XDR *, remote_interface_is_active_args*);
+extern bool_t xdr_remote_interface_is_active_ret (XDR *, remote_interface_is_active_ret*);
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_secret_lookup_by_usage_args ();
extern bool_t xdr_remote_secret_lookup_by_usage_ret ();
extern bool_t xdr_remote_domain_migrate_prepare_tunnel_args ();
+extern bool_t xdr_remote_is_secure_ret ();
+extern bool_t xdr_remote_domain_is_active_args ();
+extern bool_t xdr_remote_domain_is_active_ret ();
+extern bool_t xdr_remote_domain_is_persistent_args ();
+extern bool_t xdr_remote_domain_is_persistent_ret ();
+extern bool_t xdr_remote_network_is_active_args ();
+extern bool_t xdr_remote_network_is_active_ret ();
+extern bool_t xdr_remote_network_is_persistent_args ();
+extern bool_t xdr_remote_network_is_persistent_ret ();
+extern bool_t xdr_remote_storage_pool_is_active_args ();
+extern bool_t xdr_remote_storage_pool_is_active_ret ();
+extern bool_t xdr_remote_storage_pool_is_persistent_args ();
+extern bool_t xdr_remote_storage_pool_is_persistent_ret ();
+extern bool_t xdr_remote_interface_is_active_args ();
+extern bool_t xdr_remote_interface_is_active_ret ();
extern bool_t xdr_remote_procedure ();
extern bool_t xdr_remote_message_type ();
extern bool_t xdr_remote_message_status ();
remote_nonnull_string dom_xml;
};
+
+struct remote_is_secure_ret {
+ int secure;
+};
+
+
+struct remote_domain_is_active_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_is_active_ret {
+ int active;
+};
+
+
+struct remote_domain_is_persistent_args {
+ remote_nonnull_domain dom;
+};
+
+struct remote_domain_is_persistent_ret {
+ int persistent;
+};
+
+
+struct remote_network_is_active_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_is_active_ret {
+ int active;
+};
+
+struct remote_network_is_persistent_args {
+ remote_nonnull_network net;
+};
+
+struct remote_network_is_persistent_ret {
+ int persistent;
+};
+
+
+struct remote_storage_pool_is_active_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_is_active_ret {
+ int active;
+};
+
+struct remote_storage_pool_is_persistent_args {
+ remote_nonnull_storage_pool pool;
+};
+
+struct remote_storage_pool_is_persistent_ret {
+ int persistent;
+};
+
+
+struct remote_interface_is_active_args {
+ remote_nonnull_interface iface;
+};
+
+struct remote_interface_is_active_ret {
+ int active;
+};
+
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
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_NUM_OF_SECRETS = 139,
REMOTE_PROC_LIST_SECRETS = 140,
+
REMOTE_PROC_SECRET_LOOKUP_BY_UUID = 141,
REMOTE_PROC_SECRET_DEFINE_XML = 142,
REMOTE_PROC_SECRET_GET_XML_DESC = 143,
REMOTE_PROC_SECRET_GET_VALUE = 145,
REMOTE_PROC_SECRET_UNDEFINE = 146,
REMOTE_PROC_SECRET_LOOKUP_BY_USAGE = 147,
+ REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL = 148,
+ REMOTE_PROC_IS_SECURE = 149,
+ REMOTE_PROC_DOMAIN_IS_ACTIVE = 150,
- REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL = 148
-};
+ REMOTE_PROC_DOMAIN_IS_PERSISTENT = 151,
+ REMOTE_PROC_NETWORK_IS_ACTIVE = 152,
+ REMOTE_PROC_NETWORK_IS_PERSISTENT = 153,
+ REMOTE_PROC_STORAGE_POOL_IS_ACTIVE = 154,
+ REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155,
+ REMOTE_PROC_INTERFACE_IS_ACTIVE = 156
+ /*
+ * Notice how the entries are grouped in sets of 10 ?
+ * Nice isn't it. Please keep it this way when adding more.
+ */
+};
+
/*
* RPC wire format
*
}
+static int storagePoolIsActive(virStoragePoolPtr net)
+{
+ virStorageDriverStatePtr driver = net->conn->privateData;
+ virStoragePoolObjPtr obj;
+ int ret = -1;
+
+ storageDriverLock(driver);
+ obj = virStoragePoolObjFindByUUID(&driver->pools, net->uuid);
+ storageDriverUnlock(driver);
+ if (!obj) {
+ virStorageReportError(net->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+ goto cleanup;
+ }
+ ret = virStoragePoolObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virStoragePoolObjUnlock(obj);
+ return ret;
+}
+
+static int storagePoolIsPersistent(virStoragePoolPtr net)
+{
+ virStorageDriverStatePtr driver = net->conn->privateData;
+ virStoragePoolObjPtr obj;
+ int ret = -1;
+
+ storageDriverLock(driver);
+ obj = virStoragePoolObjFindByUUID(&driver->pools, net->uuid);
+ storageDriverUnlock(driver);
+ if (!obj) {
+ virStorageReportError(net->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+ goto cleanup;
+ }
+ ret = obj->configFile ? 1 : 0;
+
+cleanup:
+ if (obj)
+ virStoragePoolObjUnlock(obj);
+ return ret;
+}
+
+
static virStoragePoolPtr
storagePoolCreate(virConnectPtr conn,
const char *xml,
.volGetInfo = storageVolumeGetInfo,
.volGetXMLDesc = storageVolumeGetXMLDesc,
.volGetPath = storageVolumeGetPath,
+
+ .poolIsActive = storagePoolIsActive,
+ .poolIsPersistent = storagePoolIsPersistent,
};
return (0);
}
+static int testIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ return 1;
+}
+
+static int testIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
static int testGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED,
const char *type ATTRIBUTE_UNUSED)
{
return count;
}
+static int testDomainIsActive(virDomainPtr dom)
+{
+ testConnPtr privconn = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virDomainFindByUUID(&privconn->domains, dom->uuid);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = virDomainObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+static int testDomainIsPersistent(virDomainPtr dom)
+{
+ testConnPtr privconn = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virDomainFindByUUID(&privconn->domains, dom->uuid);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
static virDomainPtr
testDomainCreateXML(virConnectPtr conn, const char *xml,
unsigned int flags ATTRIBUTE_UNUSED)
return -1;
}
+
+static int testNetworkIsActive(virNetworkPtr net)
+{
+ testConnPtr privconn = net->conn->privateData;
+ virNetworkObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virNetworkFindByUUID(&privconn->networks, net->uuid);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(net->conn, VIR_ERR_NO_NETWORK, NULL);
+ goto cleanup;
+ }
+ ret = virNetworkObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virNetworkObjUnlock(obj);
+ return ret;
+}
+
+static int testNetworkIsPersistent(virNetworkPtr net)
+{
+ testConnPtr privconn = net->conn->privateData;
+ virNetworkObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virNetworkFindByUUID(&privconn->networks, net->uuid);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(net->conn, VIR_ERR_NO_NETWORK, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virNetworkObjUnlock(obj);
+ return ret;
+}
+
+
static virNetworkPtr testNetworkCreate(virConnectPtr conn, const char *xml) {
testConnPtr privconn = conn->privateData;
virNetworkDefPtr def;
return ret;
}
+static int testInterfaceIsActive(virInterfacePtr iface)
+{
+ testConnPtr privconn = iface->conn->privateData;
+ virInterfaceObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virInterfaceFindByName(&privconn->ifaces, iface->name);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(iface->conn, VIR_ERR_NO_INTERFACE, NULL);
+ goto cleanup;
+ }
+ ret = virInterfaceObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virInterfaceObjUnlock(obj);
+ return ret;
+}
+
+
static char *testInterfaceGetXMLDesc(virInterfacePtr iface,
unsigned int flags ATTRIBUTE_UNUSED)
{
* Storage Driver routines
*/
+
static int testStoragePoolObjSetDefaults(virConnectPtr conn,
virStoragePoolObjPtr pool) {
return 0;
}
+
static virStoragePoolPtr
testStoragePoolLookupByUUID(virConnectPtr conn,
const unsigned char *uuid) {
}
+static int testStoragePoolIsActive(virStoragePoolPtr pool)
+{
+ testConnPtr privconn = pool->conn->privateData;
+ virStoragePoolObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(pool->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+ goto cleanup;
+ }
+ ret = virStoragePoolObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virStoragePoolObjUnlock(obj);
+ return ret;
+}
+
+static int testStoragePoolIsPersistent(virStoragePoolPtr pool)
+{
+ testConnPtr privconn = pool->conn->privateData;
+ virStoragePoolObjPtr obj;
+ int ret = -1;
+
+ testDriverLock(privconn);
+ obj = virStoragePoolObjFindByUUID(&privconn->pools, pool->uuid);
+ testDriverUnlock(privconn);
+ if (!obj) {
+ testError(pool->conn, VIR_ERR_NO_STORAGE_POOL, NULL);
+ goto cleanup;
+ }
+ ret = obj->configFile ? 1 : 0;
+
+cleanup:
+ if (obj)
+ virStoragePoolObjUnlock(obj);
+ return ret;
+}
+
+
+
static int
testStoragePoolStart(virStoragePoolPtr pool,
unsigned int flags ATTRIBUTE_UNUSED) {
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ testIsEncrypted, /* isEncrypted */
+ testIsSecure, /* isEncrypted */
+ testDomainIsActive, /* domainIsActive */
+ testDomainIsPersistent, /* domainIsPersistent */
};
static virNetworkDriver testNetworkDriver = {
testNetworkGetBridgeName, /* networkGetBridgeName */
testNetworkGetAutostart, /* networkGetAutostart */
testNetworkSetAutostart, /* networkSetAutostart */
- NULL, /* networkIsActive */
- NULL, /* networkIsPersistent */
+ testNetworkIsActive, /* networkIsActive */
+ testNetworkIsPersistent, /* networkIsPersistent */
};
static virInterfaceDriver testInterfaceDriver = {
testInterfaceUndefine, /* interfaceUndefine */
testInterfaceCreate, /* interfaceCreate */
testInterfaceDestroy, /* interfaceDestroy */
- NULL, /* interfaceIsActive */
+ testInterfaceIsActive, /* interfaceIsActive */
};
.volGetInfo = testStorageVolumeGetInfo,
.volGetXMLDesc = testStorageVolumeGetXMLDesc,
.volGetPath = testStorageVolumeGetPath,
-
- .poolIsActive = NULL, /* poolIsActive */
- .poolIsPersistent = NULL, /* poolIsPersistent */
+ .poolIsActive = testStoragePoolIsActive,
+ .poolIsPersistent = testStoragePoolIsPersistent,
};
static virDeviceMonitor testDevMonitor = {
}
+static int umlIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Trivially secure, since always inside the daemon */
+ return 1;
+}
+
+
+static int umlIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ /* Not encrypted, but remote driver takes care of that */
+ return 0;
+}
+
+
static char *umlGetCapabilities(virConnectPtr conn) {
struct uml_driver *driver = (struct uml_driver *)conn->privateData;
char *xml;
return dom;
}
+
+static int umlDomainIsActive(virDomainPtr dom)
+{
+ struct uml_driver *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ umlDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ umlDriverUnlock(driver);
+ if (!obj) {
+ umlReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = virDomainObjIsActive(obj);
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
+static int umlDomainIsPersistent(virDomainPtr dom)
+{
+ struct uml_driver *driver = dom->conn->privateData;
+ virDomainObjPtr obj;
+ int ret = -1;
+
+ umlDriverLock(driver);
+ obj = virDomainFindByUUID(&driver->domains, dom->uuid);
+ umlDriverUnlock(driver);
+ if (!obj) {
+ umlReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
+ goto cleanup;
+ }
+ ret = obj->persistent;
+
+cleanup:
+ if (obj)
+ virDomainObjUnlock(obj);
+ return ret;
+}
+
+
static int umlGetVersion(virConnectPtr conn, unsigned long *version) {
struct uml_driver *driver = conn->privateData;
struct utsname ut;
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ umlIsEncrypted,
+ umlIsSecure,
+ umlDomainIsActive,
+ umlDomainIsPersistent,
};
return 0;
}
+static int vboxIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED) {
+ /* Driver is using local, non-network based transport */
+ return 1;
+}
+
+static int vboxIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED) {
+ /* No encryption is needed, or used on the local transport*/
+ return 0;
+}
+
static int vboxGetMaxVcpus(virConnectPtr conn, const char *type ATTRIBUTE_UNUSED) {
vboxGlobalData *data = conn->privateData;
PRUint32 maxCPUCount = 0;
return dom;
}
+
+static int vboxDomainIsActive(virDomainPtr dom) {
+ nsresult rc;
+ vboxGlobalData *data = dom->conn->privateData;
+ IMachine **machines = NULL;
+ PRUint32 machineCnt = 0;
+ vboxIID *iid = NULL;
+ char *machineNameUtf8 = NULL;
+ PRUnichar *machineNameUtf16 = NULL;
+ unsigned char iidl[VIR_UUID_BUFLEN];
+ int i, matched = 0;
+ int ret = -1;
+
+ if(data->vboxObj) {
+ rc = data->vboxObj->vtbl->GetMachines(data->vboxObj, &machineCnt, &machines);
+ if (NS_FAILED(rc)) {
+ vboxError(dom->conn, VIR_ERR_INTERNAL_ERROR,"%s, rc=%08x",
+ "Could not get list of machines",(unsigned)rc);
+ return -1;
+ }
+
+ for (i = 0; i < machineCnt; ++i) {
+ IMachine *machine = machines[i];
+ PRBool isAccessible = PR_FALSE;
+
+ if (!machine)
+ continue;
+
+ machine->vtbl->GetAccessible(machine, &isAccessible);
+ if (isAccessible) {
+
+ machine->vtbl->GetId(machine, &iid);
+ if (!iid)
+ continue;
+ vboxIIDToUUID(iidl, iid);
+ vboxIIDUnalloc(iid);
+
+ if (memcmp(dom->uuid, iidl, VIR_UUID_BUFLEN) == 0) {
+
+ PRUint32 state;
+
+ matched = 1;
+
+ machine->vtbl->GetName(machine, &machineNameUtf16);
+ data->pFuncs->pfnUtf16ToUtf8(machineNameUtf16, &machineNameUtf8);
+
+ machine->vtbl->GetState(machine, &state);
+
+ if ((state == MachineState_Starting) ||
+ (state == MachineState_Running) ||
+ (state == MachineState_Stuck) ||
+ (state == MachineState_Stopping) ||
+ (state == MachineState_Saving) ||
+ (state == MachineState_Restoring) ||
+ (state == MachineState_Discarding) ||
+ (state == MachineState_Paused) )
+ ret = 1;
+ else
+ ret = 0;
+ }
+
+ if (matched == 1)
+ break;
+ }
+ }
+
+ /* Do the cleanup and take care you dont leak any memory */
+ if (machineNameUtf8)
+ data->pFuncs->pfnUtf8Free(machineNameUtf8);
+ if (machineNameUtf16)
+ data->pFuncs->pfnComUnallocMem(machineNameUtf16);
+ for (i = 0; i < machineCnt; ++i) {
+ if (machines[i])
+ machines[i]->vtbl->nsisupports.Release((nsISupports *)machines[i]);
+ }
+ }
+
+ return ret;
+}
+
+
+static int vboxDomainIsPersistent(virDomainPtr dom ATTRIBUTE_UNUSED) {
+ /* XXX All domains appear to be persistent. Is this true ? */
+ return 1;
+}
+
+
static int vboxDomainSuspend(virDomainPtr dom) {
nsresult rc;
vboxGlobalData *data = dom->conn->privateData;
NULL, /* nodeDeviceReAttach */
NULL, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPerrsistent */
+ vboxIsEncrypted,
+ vboxIsSecure,
+ vboxDomainIsActive,
+ vboxDomainIsPersistent,
};
virNetworkDriver NAME(NetworkDriver) = {
#include "memory.h"
#include "node_device_conf.h"
#include "pci.h"
+#include "uuid.h"
#define VIR_FROM_THIS VIR_FROM_XEN
return -1;
}
+static int
+xenUnifiedIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
+static int
+xenUnifiedIsSecure(virConnectPtr conn)
+{
+ GET_PRIVATE(conn);
+ int ret = 1;
+
+ /* All drivers are secure, except for XenD over TCP */
+ if (priv->opened[XEN_UNIFIED_XEND_OFFSET] &&
+ priv->addrfamily != AF_UNIX)
+ ret = 0;
+
+ return ret;
+}
+
static int
xenUnifiedGetMaxVcpus (virConnectPtr conn, const char *type)
{
return NULL;
}
+
+static int
+xenUnifiedDomainIsActive(virDomainPtr dom)
+{
+ virDomainPtr currdom;
+ int ret = -1;
+
+ /* ID field in dom may be outdated, so re-lookup */
+ currdom = xenUnifiedDomainLookupByUUID(dom->conn, dom->uuid);
+
+ if (currdom) {
+ ret = currdom->id == -1 ? 0 : 1;
+ virDomainFree(currdom);
+ }
+
+ return ret;
+}
+
+static int
+xenUnifiedDomainisPersistent(virDomainPtr dom)
+{
+ GET_PRIVATE(dom->conn);
+ virDomainPtr currdom = NULL;
+ int ret = -1;
+
+ if (priv->opened[XEN_UNIFIED_XM_OFFSET]) {
+ /* Old Xen, pre-inactive domain management.
+ * If the XM driver can see the guest, it is definitely persistent */
+ currdom = xenXMDomainLookupByUUID(dom->conn, dom->uuid);
+ if (currdom)
+ ret = 1;
+ else
+ ret = 0;
+ } else {
+ /* New Xen with inactive domain management */
+ if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) {
+ currdom = xenDaemonLookupByUUID(dom->conn, dom->uuid);
+ if (currdom) {
+ if (currdom->id == -1) {
+ /* If its inactive, then trivially, it must be persistent */
+ ret = 1;
+ } else {
+ char *path;
+ char uuidstr[VIR_UUID_STRING_BUFLEN];
+
+ /* If its running there's no official way to tell, so we
+ * go behind xend's back & look at the config dir */
+
+ virUUIDFormat(dom->uuid, uuidstr);
+ if (virAsprintf(&path, "%s/%s", XEND_DOMAINS_DIR, uuidstr) < 0) {
+ virReportOOMError(NULL);
+ goto done;
+ }
+ if (access(path, R_OK) == 0)
+ ret = 1;
+ else if (errno == ENOENT)
+ ret = 0;
+ }
+ }
+ }
+ }
+
+done:
+ if (currdom)
+ virDomainFree(currdom);
+
+ return ret;
+}
+
static int
xenUnifiedDomainSuspend (virDomainPtr dom)
{
xenUnifiedNodeDeviceReAttach, /* nodeDeviceReAttach */
xenUnifiedNodeDeviceReset, /* nodeDeviceReset */
NULL, /* domainMigratePrepareTunnel */
- NULL, /* isEncrypted */
- NULL, /* isSecure */
- NULL, /* domainIsActive */
- NULL, /* domainIsPersistent */
+ xenUnifiedIsEncrypted,
+ xenUnifiedIsSecure,
+ xenUnifiedDomainIsActive,
+ xenUnifiedDomainisPersistent,
};
/**
#define XEN_CONFIG_FORMAT_XM "xen-xm"
#define XEN_CONFIG_FORMAT_SEXPR "xen-sxpr"
+#define XEND_DOMAINS_DIR "/var/lib/xend/domains"
+
/* _xenUnifiedDriver:
*
* Entry points into the underlying Xen drivers. This structure
virReportErrorHelper(NULL, VIR_FROM_XEN_INOTIFY, code, __FILE__, \
__FUNCTION__, __LINE__, fmt)
-#define LIBVIRTD_DOMAINS_DIR "/var/lib/xend/domains"
-
struct xenUnifiedDriver xenInotifyDriver = {
xenInotifyOpen, /* open */
xenInotifyClose, /* close */
* a filename in the manner:
* /var/lib/xend/domains/<uuid>/
*/
- uuid_str = filename + strlen(LIBVIRTD_DOMAINS_DIR) + 1;
+ uuid_str = filename + strlen(XEND_DOMAINS_DIR) + 1;
if (virUUIDParse(uuid_str, rawuuid) < 0) {
virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR,
xenInotifyXendDomainsDirRemoveEntry(virConnectPtr conn,
const char *fname) {
xenUnifiedPrivatePtr priv = conn->privateData;
- const char *uuidstr = fname + strlen(LIBVIRTD_DOMAINS_DIR) + 1;
+ const char *uuidstr = fname + strlen(XEND_DOMAINS_DIR) + 1;
unsigned char uuid[VIR_UUID_BUFLEN];
int i;
priv->useXenConfigCache = 1;
} else {
/* /var/lib/xend/domains/<uuid>/config.sxp */
- priv->configDir = LIBVIRTD_DOMAINS_DIR;
+ priv->configDir = XEND_DOMAINS_DIR;
priv->useXenConfigCache = 0;
if (VIR_ALLOC(priv->configInfoList) < 0) {
virConnectAuthPtr auth,
int flags);
int xenInotifyClose (virConnectPtr conn);
+
#endif
projects / libvirt.git / commitdiff