+Fri Jul 6 16:08:00 BST 2007 Richard W.M. Jones <rjones@redhat.com>
+
+ * src/proxy_internal.c, src/proxy_internal.h,
+ src.xen_internal.c, src/xen_internal.h,
+ src/xen_unified.c, src/xen_unified.h,
+ src/xend_internal.c, src/xend_internal.h,
+ src/xm_internal.c, src/xm_internal.h,
+ src/xs_internal.c, src/xs_internal.h: The interface
+ between xen_unified.c and its underlying driver now uses
+ a custom structure (struct xenUnifiedDriver) instead
+ of reusing virDriver.
+ * src/xen_unified.c: virDomainLookup* functions in Xen
+ now throw VIR_ERR_NO_DOMAIN if the domain does not exist.
+ * src/xs_internal.c: Fix indentation.
+
Fri Jul 6 17:06:52 CEST 2007 Daniel Veillard <veillard@redhat.com>
* src/virsh.c: fix an error in the default help string, bug #247197
static char *xenProxyGetCapabilities(virConnectPtr conn);
static int xenProxyListDomains(virConnectPtr conn, int *ids, int maxids);
static int xenProxyNumOfDomains(virConnectPtr conn);
-static virDomainPtr xenProxyLookupByID(virConnectPtr conn, int id);
-static virDomainPtr xenProxyLookupByUUID(virConnectPtr conn,
- const unsigned char *uuid);
-static virDomainPtr xenProxyDomainLookupByName(virConnectPtr conn,
- const char *domname);
static unsigned long xenProxyDomainGetMaxMemory(virDomainPtr domain);
static int xenProxyDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info);
static char *xenProxyDomainDumpXML(virDomainPtr domain, int flags);
static char *xenProxyDomainGetOSType(virDomainPtr domain);
-virDriver xenProxyDriver = {
- -1,
- "XenProxy",
- 0,
+struct xenUnifiedDriver xenProxyDriver = {
xenProxyOpen, /* open */
xenProxyClose, /* close */
NULL, /* type */
xenProxyGetVersion, /* version */
NULL, /* hostname */
NULL, /* URI */
- NULL, /* getMaxVcpus */
xenProxyNodeGetInfo, /* nodeGetInfo */
xenProxyGetCapabilities, /* getCapabilities */
xenProxyListDomains, /* listDomains */
xenProxyNumOfDomains, /* numOfDomains */
NULL, /* domainCreateLinux */
- xenProxyLookupByID, /* domainLookupByID */
- xenProxyLookupByUUID, /* domainLookupByUUID */
- xenProxyDomainLookupByName, /* domainLookupByName */
NULL, /* domainSuspend */
NULL, /* domainResume */
NULL, /* domainShutdown */
*
* Returns a new domain object or NULL in case of failure
*/
-static virDomainPtr
+virDomainPtr
xenProxyLookupByID(virConnectPtr conn, int id)
{
virProxyPacket req;
*
* Returns a new domain object or NULL in case of failure
*/
-static virDomainPtr
+virDomainPtr
xenProxyLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
virProxyFullPacket req;
}
/**
- * xenProxyDomainLookupByName:
+ * xenProxyLookupByName:
* @conn: A xend instance
* @name: The name of the domain
*
*
* Returns a new domain object or NULL in case of failure
*/
-static virDomainPtr
-xenProxyDomainLookupByName(virConnectPtr conn, const char *name)
+virDomainPtr
+xenProxyLookupByName(virConnectPtr conn, const char *name)
{
virProxyFullPacket req;
int ret, len;
typedef struct _virProxyFullPacket virProxyFullPacket;
typedef virProxyFullPacket *virProxyFullPacketPtr;
-extern virDriver xenProxyDriver;
-int xenProxyInit (void);
+/* xen_unified makes direct calls or indirect calls through here. */
+extern struct xenUnifiedDriver xenProxyDriver;
+extern int xenProxyInit (void);
+
+extern virDomainPtr xenProxyLookupByID(virConnectPtr conn, int id);
+extern virDomainPtr xenProxyLookupByUUID(virConnectPtr conn,
+ const unsigned char *uuid);
+extern virDomainPtr xenProxyLookupByName(virConnectPtr conn,
+ const char *domname);
#ifdef __cplusplus
}
#endif
#ifndef PROXY
-virDriver xenHypervisorDriver = {
- -1,
- "Xen",
- (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
- ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
- (DOM0_INTERFACE_VERSION & 0xFFFF),
+struct xenUnifiedDriver xenHypervisorDriver = {
xenHypervisorOpen, /* open */
xenHypervisorClose, /* close */
xenHypervisorGetType, /* type */
xenHypervisorGetVersion, /* version */
NULL, /* hostname */
NULL, /* URI */
- xenHypervisorGetMaxVcpus, /* getMaxVcpus */
NULL, /* nodeGetInfo */
xenHypervisorGetCapabilities, /* getCapabilities */
xenHypervisorListDomains, /* listDomains */
xenHypervisorNumOfDomains, /* numOfDomains */
NULL, /* domainCreateLinux */
- NULL, /* domainLookupByID */
- NULL, /* domainLookupByUUID */
- NULL, /* domainLookupByName */
xenHypervisorPauseDomain, /* domainSuspend */
xenHypervisorResumeDomain, /* domainResume */
NULL, /* domainShutdown */
extern "C" {
#endif
-extern virDriver xenHypervisorDriver;
+extern struct xenUnifiedDriver xenHypervisorDriver;
int xenHypervisorInit (void);
/* The following calls are made directly by the Xen proxy: */
* xend_internal, xs_internal and xm_internal). Historically
* the body of libvirt.c handled the five Xen drivers,
* and contained Xen-specific code.
- *
- * The interface between Xen drivers and xen_unified is
- * the same as for "ordinary" libvirt drivers (ie. virDriverPtr),
- * however this is just for convenience and may be changed
- * in future. Libvirt.c should no longer call directly
- * to the five underlying Xen drivers.
*/
#include <stdint.h>
#include "xm_internal.h"
/* The five Xen drivers below us. */
-static virDriverPtr drivers[XEN_UNIFIED_NR_DRIVERS] = {
- &xenHypervisorDriver,
- &xenProxyDriver,
- &xenDaemonDriver,
- &xenStoreDriver,
- &xenXMDriver
+static struct xenUnifiedDriver *drivers[XEN_UNIFIED_NR_DRIVERS] = {
+ [XEN_UNIFIED_HYPERVISOR_OFFSET] = &xenHypervisorDriver,
+ [XEN_UNIFIED_PROXY_OFFSET] = &xenProxyDriver,
+ [XEN_UNIFIED_XEND_OFFSET] = &xenDaemonDriver,
+ [XEN_UNIFIED_XS_OFFSET] = &xenStoreDriver,
+ [XEN_UNIFIED_XM_OFFSET] = &xenXMDriver,
};
-static const int hypervisor_offset = 0;
-static const int proxy_offset = 1;
/**
* xenUnifiedError:
continue;
/* Ignore proxy for root */
- if (i == proxy_offset && getuid() == 0)
+ if (i == XEN_UNIFIED_PROXY_OFFSET && getuid() == 0)
continue;
if (drivers[i]->open &&
/* If as root, then all drivers must succeed.
If non-root, then only proxy must succeed */
- if (!priv->opened[i] && (getuid() == 0 || i == proxy_offset)) {
+ if (!priv->opened[i] &&
+ (getuid() == 0 || i == XEN_UNIFIED_PROXY_OFFSET)) {
for (j = 0; j < i; ++j)
if (priv->opened[j]) drivers[j]->close (conn);
free (priv->name);
xenUnifiedGetMaxVcpus (virConnectPtr conn, const char *type)
{
GET_PRIVATE(conn);
- int i;
-
- if (!type)
- type = "Xen";
- for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (priv->opened[i] && strcmp (drivers[i]->name, type) == 0)
- return drivers[i]->getMaxVcpus (conn, type);
+ if (type && STRCASENEQ (type, "Xen")) {
+ xenUnifiedError (conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return -1;
+ }
- return -1;
+ if (priv->opened[XEN_UNIFIED_HYPERVISOR_OFFSET])
+ return xenHypervisorGetMaxVcpus (conn, type);
+ else {
+ xenUnifiedError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+ return -1;
+ }
}
static int
return NULL;
}
+/* Assumption made in underlying drivers:
+ * If the domain is "not found" and there is no other error, then
+ * the Lookup* functions return a NULL but do not set virterror.
+ */
static virDomainPtr
xenUnifiedDomainLookupByID (virConnectPtr conn, int id)
{
GET_PRIVATE(conn);
- int i;
virDomainPtr ret;
- for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (priv->opened[i] && drivers[i]->domainLookupByID) {
- ret = drivers[i]->domainLookupByID (conn, id);
- if (ret) return ret;
- }
+ /* Reset any connection-level errors in virterror first, in case
+ * there is one hanging around from a previous call.
+ */
+ virConnResetLastError (conn);
+
+ /* Try proxy. */
+ if (priv->opened[XEN_UNIFIED_PROXY_OFFSET]) {
+ ret = xenProxyLookupByID (conn, id);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+
+ /* Try xend. */
+ if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) {
+ ret = xenDaemonLookupByID (conn, id);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+ /* Not found. */
+ xenUnifiedError (conn, VIR_ERR_NO_DOMAIN, __FUNCTION__);
return NULL;
}
const unsigned char *uuid)
{
GET_PRIVATE(conn);
- int i;
virDomainPtr ret;
- for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (priv->opened[i] && drivers[i]->domainLookupByUUID) {
- ret = drivers[i]->domainLookupByUUID (conn, uuid);
- if (ret) return ret;
- }
+ /* Reset any connection-level errors in virterror first, in case
+ * there is one hanging around from a previous call.
+ */
+ virConnResetLastError (conn);
+
+ /* Try proxy. */
+ if (priv->opened[XEN_UNIFIED_PROXY_OFFSET]) {
+ ret = xenProxyLookupByUUID (conn, uuid);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+
+ /* Try xend. */
+ if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) {
+ ret = xenDaemonLookupByUUID (conn, uuid);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+ /* Try XM for inactive domains. */
+ if (priv->opened[XEN_UNIFIED_XM_OFFSET]) {
+ ret = xenXMDomainLookupByUUID (conn, uuid);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+
+ /* Not found. */
+ xenUnifiedError (conn, VIR_ERR_NO_DOMAIN, __FUNCTION__);
return NULL;
}
const char *name)
{
GET_PRIVATE(conn);
- int i;
virDomainPtr ret;
- for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (priv->opened[i] && drivers[i]->domainLookupByName) {
- ret = drivers[i]->domainLookupByName (conn, name);
- if (ret) return ret;
- }
+ /* Reset any connection-level errors in virterror first, in case
+ * there is one hanging around from a previous call.
+ */
+ virConnResetLastError (conn);
+
+ /* Try proxy. */
+ if (priv->opened[XEN_UNIFIED_PROXY_OFFSET]) {
+ ret = xenProxyLookupByName (conn, name);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+
+ /* Try xend. */
+ if (priv->opened[XEN_UNIFIED_XEND_OFFSET]) {
+ ret = xenDaemonLookupByName (conn, name);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+
+ /* Try xenstore for inactive domains. */
+ if (priv->opened[XEN_UNIFIED_XS_OFFSET]) {
+ ret = xenStoreLookupByName (conn, name);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+
+ /* Try XM for inactive domains. */
+ if (priv->opened[XEN_UNIFIED_XM_OFFSET]) {
+ ret = xenXMDomainLookupByName (conn, name);
+ if (ret || conn->err.code != VIR_ERR_OK)
+ return ret;
+ }
+ /* Not found. */
+ xenUnifiedError (conn, VIR_ERR_NO_DOMAIN, __FUNCTION__);
return NULL;
}
* as a last resort.
*/
for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (i != hypervisor_offset &&
+ if (i != XEN_UNIFIED_HYPERVISOR_OFFSET &&
priv->opened[i] &&
drivers[i]->domainSuspend &&
drivers[i]->domainSuspend (dom) == 0)
return 0;
- if (priv->opened[hypervisor_offset] &&
- drivers[hypervisor_offset]->domainSuspend &&
- drivers[hypervisor_offset]->domainSuspend (dom) == 0)
+ if (priv->opened[XEN_UNIFIED_HYPERVISOR_OFFSET] &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainSuspend &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainSuspend (dom) == 0)
return 0;
return -1;
* as a last resort.
*/
for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (i != hypervisor_offset &&
+ if (i != XEN_UNIFIED_HYPERVISOR_OFFSET &&
priv->opened[i] &&
drivers[i]->domainResume &&
drivers[i]->domainResume (dom) == 0)
return 0;
- if (priv->opened[hypervisor_offset] &&
- drivers[hypervisor_offset]->domainResume &&
- drivers[hypervisor_offset]->domainResume (dom) == 0)
+ if (priv->opened[XEN_UNIFIED_HYPERVISOR_OFFSET] &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainResume &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainResume (dom) == 0)
return 0;
return -1;
* as a last resort.
*/
for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (i != hypervisor_offset &&
+ if (i != XEN_UNIFIED_HYPERVISOR_OFFSET &&
priv->opened[i] &&
drivers[i]->domainDestroy &&
drivers[i]->domainDestroy (dom) == 0)
return 0;
if (priv->opened[i] &&
- drivers[hypervisor_offset]->domainDestroy &&
- drivers[hypervisor_offset]->domainDestroy (dom) == 0)
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainDestroy &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainDestroy (dom) == 0)
return 0;
return -1;
* as a last resort.
*/
for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
- if (i != hypervisor_offset &&
+ if (i != XEN_UNIFIED_HYPERVISOR_OFFSET &&
priv->opened[i] &&
drivers[i]->domainSetVcpus &&
drivers[i]->domainSetVcpus (dom, nvcpus) == 0)
return 0;
- if (priv->opened[hypervisor_offset] &&
- drivers[hypervisor_offset]->domainSetVcpus &&
- drivers[hypervisor_offset]->domainSetVcpus (dom, nvcpus) == 0)
+ if (priv->opened[XEN_UNIFIED_HYPERVISOR_OFFSET] &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainSetVcpus &&
+ drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainSetVcpus (dom, nvcpus) == 0)
return 0;
return -1;
extern int xenUnifiedRegister (void);
+#define XEN_UNIFIED_HYPERVISOR_OFFSET 0
+#define XEN_UNIFIED_PROXY_OFFSET 1
+#define XEN_UNIFIED_XEND_OFFSET 2
+#define XEN_UNIFIED_XS_OFFSET 3
+#define XEN_UNIFIED_XM_OFFSET 4
#define XEN_UNIFIED_NR_DRIVERS 5
+/* _xenUnifiedDriver:
+ *
+ * Entry points into the underlying Xen drivers. This structure
+ * will eventually go away and instead xen unified will make direct
+ * calls to the underlying Xen drivers.
+ *
+ * To reiterate - the goal is to remove elements from this structure
+ * until it is empty, replacing indirect calls through this
+ * structure with direct calls in xen_unified.c.
+ */
+struct xenUnifiedDriver {
+ virDrvOpen open;
+ virDrvClose close;
+ virDrvGetType type;
+ virDrvGetVersion version;
+ virDrvGetHostname getHostname;
+ virDrvGetURI getURI;
+ virDrvNodeGetInfo nodeGetInfo;
+ virDrvGetCapabilities getCapabilities;
+ virDrvListDomains listDomains;
+ virDrvNumOfDomains numOfDomains;
+ virDrvDomainCreateLinux domainCreateLinux;
+ virDrvDomainSuspend domainSuspend;
+ virDrvDomainResume domainResume;
+ virDrvDomainShutdown domainShutdown;
+ virDrvDomainReboot domainReboot;
+ virDrvDomainDestroy domainDestroy;
+ virDrvDomainGetOSType domainGetOSType;
+ virDrvDomainGetMaxMemory domainGetMaxMemory;
+ virDrvDomainSetMaxMemory domainSetMaxMemory;
+ virDrvDomainSetMemory domainSetMemory;
+ virDrvDomainGetInfo domainGetInfo;
+ virDrvDomainSave domainSave;
+ virDrvDomainRestore domainRestore;
+ virDrvDomainCoreDump domainCoreDump;
+ virDrvDomainSetVcpus domainSetVcpus;
+ virDrvDomainPinVcpu domainPinVcpu;
+ virDrvDomainGetVcpus domainGetVcpus;
+ virDrvDomainGetMaxVcpus domainGetMaxVcpus;
+ virDrvDomainDumpXML domainDumpXML;
+ virDrvListDefinedDomains listDefinedDomains;
+ virDrvNumOfDefinedDomains numOfDefinedDomains;
+ virDrvDomainCreate domainCreate;
+ virDrvDomainDefineXML domainDefineXML;
+ virDrvDomainUndefine domainUndefine;
+ virDrvDomainAttachDevice domainAttachDevice;
+ virDrvDomainDetachDevice domainDetachDevice;
+ virDrvDomainGetAutostart domainGetAutostart;
+ virDrvDomainSetAutostart domainSetAutostart;
+ virDrvDomainGetSchedulerType domainGetSchedulerType;
+ virDrvDomainGetSchedulerParameters domainGetSchedulerParameters;
+ virDrvDomainSetSchedulerParameters domainSetSchedulerParameters;
+};
+
/* xenUnifiedPrivatePtr:
*
* Per-connection private data, stored in conn->privateData. All Xen
static int xenDaemonNumOfDomains(virConnectPtr conn);
static int xenDaemonListDefinedDomains(virConnectPtr conn, char **const names, int maxnames);
static int xenDaemonNumOfDefinedDomains(virConnectPtr conn);
-static virDomainPtr xenDaemonLookupByID(virConnectPtr conn, int id);
-static virDomainPtr xenDaemonLookupByUUID(virConnectPtr conn,
- const unsigned char *uuid);
static virDomainPtr xenDaemonCreateLinux(virConnectPtr conn,
const char *xmlDesc,
unsigned int flags);
#endif /* PROXY */
#ifndef PROXY
-virDriver xenDaemonDriver = {
- -1,
- "XenDaemon",
- (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
- ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
- (DOM0_INTERFACE_VERSION & 0xFFFF),
+struct xenUnifiedDriver xenDaemonDriver = {
xenDaemonOpen, /* open */
xenDaemonClose, /* close */
xenDaemonGetType, /* type */
xenDaemonGetVersion, /* version */
NULL, /* hostname */
NULL, /* URI */
- NULL, /* getMaxVcpus */
xenDaemonNodeGetInfo, /* nodeGetInfo */
NULL, /* getCapabilities */
xenDaemonListDomains, /* listDomains */
xenDaemonNumOfDomains, /* numOfDomains */
xenDaemonCreateLinux, /* domainCreateLinux */
- xenDaemonLookupByID, /* domainLookupByID */
- xenDaemonLookupByUUID, /* domainLookupByUUID */
- xenDaemonDomainLookupByName, /* domainLookupByName */
xenDaemonDomainSuspend, /* domainSuspend */
xenDaemonDomainResume, /* domainResume */
xenDaemonDomainShutdown, /* domainShutdown */
#ifndef PROXY
/**
- * xenDaemonDomainLookupByName:
+ * xenDaemonLookupByName:
* @conn: A xend instance
* @name: The name of the domain
*
* Returns domain info on success; NULL (with errno) on error
*/
virDomainPtr
-xenDaemonDomainLookupByName(virConnectPtr conn, const char *domname)
+xenDaemonLookupByName(virConnectPtr conn, const char *domname)
{
struct sexpr *root;
virDomainPtr ret = NULL;
*
* Returns a new domain object or NULL in case of failure
*/
-static virDomainPtr
+virDomainPtr
xenDaemonLookupByID(virConnectPtr conn, int id) {
char *name = NULL;
unsigned char uuid[VIR_UUID_BUFLEN];
*
* Returns a new domain object or NULL in case of failure
*/
-static virDomainPtr
+virDomainPtr
xenDaemonLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
virDomainPtr ret;
char *xend_parse_domain_sexp(virConnectPtr conn, char *root, int xendConfigVersion);
-extern virDriver xenDaemonDriver;
-int xenDaemonInit (void);
-
/* refactored ones */
int xenDaemonOpen(virConnectPtr conn, const char *name, int flags);
int xenDaemonClose(virConnectPtr conn);
int xenDaemonDomainSetMaxMemory(virDomainPtr domain, unsigned long memory);
int xenDaemonDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info);
char *xenDaemonDomainDumpXML(virDomainPtr domain, int flags);
-virDomainPtr xenDaemonDomainLookupByName(virConnectPtr conn, const char *domname);
unsigned long xenDaemonDomainGetMaxMemory(virDomainPtr domain);
char **xenDaemonListDomainsOld(virConnectPtr xend);
unsigned char *cpumaps,
int maplen);
+/* xen_unified calls through here. */
+extern struct xenUnifiedDriver xenDaemonDriver;
+int xenDaemonInit (void);
+
+virDomainPtr xenDaemonLookupByID(virConnectPtr conn, int id);
+virDomainPtr xenDaemonLookupByUUID(virConnectPtr conn, const unsigned char *uuid);
+virDomainPtr xenDaemonLookupByName(virConnectPtr conn, const char *domname);
+
#ifdef __cplusplus
}
#endif
#define XEND_PCI_CONFIG_PREFIX "xend-pci-"
#define QEMU_IF_SCRIPT "qemu-ifup"
-virDriver xenXMDriver = {
- -1,
- "XenXM",
- (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
- ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
- (DOM0_INTERFACE_VERSION & 0xFFFF),
+struct xenUnifiedDriver xenXMDriver = {
xenXMOpen, /* open */
xenXMClose, /* close */
xenXMGetType, /* type */
NULL, /* version */
NULL, /* hostname */
NULL, /* URI */
- NULL, /* getMaxVcpus */
NULL, /* nodeGetInfo */
NULL, /* getCapabilities */
NULL, /* listDomains */
NULL, /* numOfDomains */
NULL, /* domainCreateLinux */
- NULL, /* domainLookupByID */
- xenXMDomainLookupByUUID, /* domainLookupByUUID */
- xenXMDomainLookupByName, /* domainLookupByName */
NULL, /* domainSuspend */
NULL, /* domainResume */
NULL, /* domainShutdown */
if (ctx->count == ctx->max)
return;
- dom = xenDaemonDomainLookupByName(ctx->conn, name);
+ dom = xenDaemonLookupByName(ctx->conn, name);
if (!dom) {
ctx->names[ctx->count] = strdup(name);
ctx->count++;
extern "C" {
#endif
-extern virDriver xenXMDriver;
+extern struct xenUnifiedDriver xenXMDriver;
int xenXMInit (void);
int xenXMOpen(virConnectPtr conn, const char *name, int flags);
#ifndef PROXY
static char *xenStoreDomainGetOSType(virDomainPtr domain);
-virDriver xenStoreDriver = {
- -1,
- "XenStore",
- (DOM0_INTERFACE_VERSION >> 24) * 1000000 +
- ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
- (DOM0_INTERFACE_VERSION & 0xFFFF),
+struct xenUnifiedDriver xenStoreDriver = {
xenStoreOpen, /* open */
xenStoreClose, /* close */
NULL, /* type */
NULL, /* version */
NULL, /* hostname */
NULL, /* URI */
- NULL, /* getMaxVcpus */
NULL, /* nodeGetInfo */
NULL, /* getCapabilities */
xenStoreListDomains, /* listDomains */
NULL, /* numOfDomains */
NULL, /* domainCreateLinux */
- NULL, /* domainLookupByID */
- NULL, /* domainLookupByUUID */
- xenStoreDomainLookupByName, /* domainLookupByName */
NULL, /* domainSuspend */
NULL, /* domainResume */
xenStoreDomainShutdown, /* domainShutdown */
}
/**
- * xenStoreDomainLookupByName:
+ * xenStoreLookupByName:
* @conn: A xend instance
* @name: The name of the domain
*
* Returns a new domain object or NULL in case of failure
*/
virDomainPtr
-xenStoreDomainLookupByName(virConnectPtr conn, const char *name)
+xenStoreLookupByName(virConnectPtr conn, const char *name)
{
virDomainPtr ret = NULL;
unsigned int num, i, len;
goto done;
for (i = 0; i < num; i++) {
- id = strtol(idlist[i], &endptr, 10);
- if ((endptr == idlist[i]) || (*endptr != 0)) {
- goto done;
- }
+ id = strtol(idlist[i], &endptr, 10);
+ if ((endptr == idlist[i]) || (*endptr != 0)) {
+ goto done;
+ }
#if 0
- if (virConnectCheckStoreID(conn, (int) id) < 0)
- continue;
+ if (virConnectCheckStoreID(conn, (int) id) < 0)
+ continue;
#endif
- snprintf(prop, 199, "/local/domain/%s/name", idlist[i]);
- prop[199] = 0;
- tmp = xs_read(priv->xshandle, 0, prop, &len);
- if (tmp != NULL) {
- found = !strcmp(name, tmp);
- free(tmp);
- if (found)
- break;
- }
+ snprintf(prop, 199, "/local/domain/%s/name", idlist[i]);
+ prop[199] = 0;
+ tmp = xs_read(priv->xshandle, 0, prop, &len);
+ if (tmp != NULL) {
+ found = STREQ (name, tmp);
+ free(tmp);
+ if (found)
+ break;
+ }
}
path = xs_get_domain_path(priv->xshandle, (unsigned int) id);
extern "C" {
#endif
-extern virDriver xenStoreDriver;
+extern struct xenUnifiedDriver xenStoreDriver;
int xenStoreInit (void);
int xenStoreOpen (virConnectPtr conn,
int xenStoreListDomains (virConnectPtr conn,
int *ids,
int maxids);
-virDomainPtr xenStoreDomainLookupByName(virConnectPtr conn,
+virDomainPtr xenStoreLookupByName(virConnectPtr conn,
const char *name);
unsigned long xenStoreGetMaxMemory (virDomainPtr domain);
int xenStoreDomainSetMemory (virDomainPtr domain,
projects / libvirt.git / commitdiff