* src/proxy_internal.c src/proxy_internal.h src/driver.h src/libvirt.c

  src/Makefile.am: moved proxy/proxy.h and proxy/proxy_client.c as
  proxy_internal.[ch] and integrated them as a new driver.
* proxy/Makefile.am proxy/libvirt_proxy.c src/xen_internal.c
  src/xen_internal.h src/xend_internal.c: various related cleanups.
Daniel

ChangeLog

+Thu Jun 29 22:19:51 EDT 2006 Daniel Veillard <veillard@redhat.com>
+
+	* src/proxy_internal.c src/proxy_internal.h src/driver.h src/libvirt.c
+	  src/Makefile.am: moved proxy/proxy.h and proxy/proxy_client.c as
+	  proxy_internal.[ch] and integrated them as a new driver.
+	* proxy/Makefile.am proxy/libvirt_proxy.c src/xen_internal.c 
+	  src/xen_internal.h src/xend_internal.c: various related cleanups.
+
 Thu Jun 29 14:53:01 EDT 2006 Daniel Veillard <veillard@redhat.com>
 
 	* proxy/libvirt_proxy.c proxy/proxy.h proxy/proxy_client.c: more

proxy/Makefile.am

@@ -2,8 +2,6 @@
 
 INCLUDES = -I$(top_builddir)/include -I@top_srcdir@/include \
            -I@top_srcdir@/proxy -I@top_srcdir@/src @LIBXML_CFLAGS@ \
-	   -DBINDIR=\""$(libexecdir)"\"	\
-	   -DBUILDDIR=\""$(top_builddir)"\" \
 	   -DXEN_RO
 
 
@@ -13,13 +11,7 @@ LIBS=
 libvirt_proxy_SOURCES = libvirt_proxy.c @top_srcdir@/src/xend_internal.c \
 	    @top_srcdir@/src/xen_internal.c @top_srcdir@/src/virterror.c \
 	    @top_srcdir@/src/sexpr.c
-
 libvirt_proxy_LDFLAGS =
 libvirt_proxy_DEPENDENCIES =
 libvirt_proxy_LDADD =
 
-noinst_PROGRAMS= test_proxy
-test_proxy_SOURCES = proxy_client.c
-test_proxy_LDFLAGS = 
-test_proxy_DEPENDENCIES =
-test_proxy_LDADD =

proxy/libvirt_proxy.c

@@ -17,8 +17,8 @@
 #include <sys/poll.h>
 #include <sys/socket.h>
 #include <sys/un.h>
-#include "proxy.h"
 #include "internal.h"
+#include "proxy_internal.h"
 #include "xen_internal.h"
 #include "xend_internal.h"
 
@@ -278,7 +278,8 @@ proxyWriteClientSocket(int nr, virProxyPacketPtr req) {
     int ret;
 
     if ((nr <= 0) || (nr > nbClients) || (req == NULL) ||
-        (req->len < sizeof(virProxyPacket)) || (req->len > 4096) ||
+        (req->len < sizeof(virProxyPacket)) ||
+	(req->len > sizeof(virProxyFullPacket)) ||
 	(pollInfos[nr].fd < 0)) {
 	fprintf(stderr, "write to client %d in error", nr);
 	proxyCloseClientSocket(nr);
@@ -327,12 +328,12 @@ retry:
  */
 static int
 proxyReadClientSocket(int nr) {
-    char buffer[4096];
-    virProxyPacketPtr req;
+    virProxyFullPacket request;
+    virProxyPacketPtr req = (virProxyPacketPtr) &request;
     int ret;
 
 retry:
-    ret = read(pollInfos[nr].fd, buffer, sizeof(virProxyPacket));
+    ret = read(pollInfos[nr].fd, req, sizeof(virProxyPacket));
     if (ret < 0) {
         if (errno == EINTR) {
 	    if (debug > 0)
@@ -357,7 +358,6 @@ retry:
         fprintf(stderr, "read %d bytes from client %d on socket %d\n",
 	        ret, nr, pollInfos[nr].fd);
     
-    req = (virProxyPacketPtr) &buffer[0];
     if ((req->version != PROXY_PROTO_VERSION) ||
         (req->len < sizeof(virProxyPacket)))
 	goto comm_error;
@@ -380,10 +380,8 @@ retry:
 
 	    if (req->len != sizeof(virProxyPacket))
 	        goto comm_error;
-	    maxids = (sizeof(buffer) - sizeof(virProxyPacket)) / sizeof(int);
-	    maxids -= 10; /* just to be sure that should still be plenty */
-	    ret = xenHypervisorListDomains(conn,
-	                           (int *) &buffer[sizeof(virProxyPacket)],
+	    maxids = sizeof(request.extra.arg) / sizeof(int);
+	    ret = xenHypervisorListDomains(conn, &request.extra.arg[0],
 				           maxids);
 	    if (ret < 0) {
 	        req->len = sizeof(virProxyPacket);
@@ -400,6 +398,10 @@ retry:
 	    req->data.arg = xenHypervisorNumOfDomains(conn);
 	    break;
 	case VIR_PROXY_MAX_MEMORY:
+	    if (req->len != sizeof(virProxyPacket))
+	        goto comm_error;
+	    req->data.larg = xenHypervisorGetDomMaxMemory(conn, req->data.arg);
+	    break;
 	case VIR_PROXY_DOMAIN_INFO:
 	case VIR_PROXY_NODE_INFO:
 	case VIR_PROXY_LOOKUP_ID:

src/Makefile.am

 ## Process this file with automake to produce Makefile.in
 
-INCLUDES = -I$(top_builddir)/include -I@top_srcdir@/include @LIBXML_CFLAGS@
+INCLUDES = -I$(top_builddir)/include -I@top_srcdir@/include @LIBXML_CFLAGS@ \
+	   -DBINDIR=\""$(libexecdir)"\"
 DEPS = libvirt.la
 LDADDS = @STATIC_BINARIES@ libvirt.la
 VIRSH_LIBS = @VIRSH_LIBS@
@@ -23,7 +24,8 @@ libvirt_la_SOURCES =						\
 		xend_internal.c xend_internal.h			\
 		sexpr.c sexpr.h					\
 		virterror.c					\
-		driver.h
+		driver.h					\
+		proxy_internal.c proxy_internal.h
 
 bin_PROGRAMS = virsh
 

src/driver.h

@@ -20,7 +20,8 @@ typedef enum {
     VIR_DRV_XEN_HYPERVISOR = 1,
     VIR_DRV_XEN_STORE = 2,
     VIR_DRV_XEN_DAEMON = 3,
-    VIR_DRV_TEST = 4
+    VIR_DRV_TEST = 4,
+    VIR_DRV_XEN_PROXY = 5
 } virDrvNo;
 
 

src/libvirt.c

@@ -28,6 +28,7 @@
 #include "xen_internal.h"
 #include "xend_internal.h"
 #include "xs_internal.h"
+#include "proxy_internal.h"
 #include "xml.h"
 #include "test.h"
 
@@ -69,6 +70,7 @@ virInitialize(void)
      * Note that the order is important the first ones have a higher priority
      */
     xenHypervisorRegister();
+    xenProxyRegister();
     xenDaemonRegister();
     xenStoreRegister();
     testRegister();
@@ -244,7 +246,8 @@ virConnectOpen(const char *name)
 	     * all related drivers.
 	     */
 	    if ((res < 0) && (for_xen) &&
-	        (!strncasecmp(virDriverTab[i]->name, "xen", 3)))
+	        (!strncasecmp(virDriverTab[i]->name, "xen", 3)) &&
+		(virDriverTab[i]->no != VIR_DRV_XEN_PROXY))
 		goto failed;
 	    if (res == 0)
 	        ret->drivers[ret->nb_drivers++] = virDriverTab[i];

proxy/proxy_client.c → src/proxy_internal.c

@@ -18,13 +18,71 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <sys/wait.h>
-#include "proxy.h"
 #include "internal.h"
+#include "driver.h"
+#include "proxy_internal.h"
 
 #define STANDALONE
 
-static int debug = 1;
+static int debug = 0;
+
+static int xenProxyClose(virConnectPtr conn);
+static int xenProxyOpen(virConnectPtr conn, const char *name, int flags);
+static int xenProxyGetVersion(virConnectPtr conn, unsigned long *hvVer);
+static int xenProxyNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info);
+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 virDriver xenProxyDriver = {
+    VIR_DRV_XEN_PROXY,
+    "XenProxy",
+    0,
+    NULL, /* init */
+    xenProxyOpen, /* open */
+    xenProxyClose, /* close */
+    NULL, /* type */
+    xenProxyGetVersion, /* version */
+    NULL, /* nodeGetInfo */
+    xenProxyListDomains, /* listDomains */
+    xenProxyNumOfDomains, /* numOfDomains */
+    NULL, /* domainCreateLinux */
+    xenProxyLookupByID, /* domainLookupByID */
+    xenProxyLookupByUUID, /* domainLookupByUUID */
+    xenProxyDomainLookupByName, /* domainLookupByName */
+    NULL, /* domainSuspend */
+    NULL, /* domainResume */
+    NULL, /* domainShutdown */
+    NULL, /* domainReboot */
+    NULL, /* domainDestroy */
+    NULL, /* domainFree */
+    NULL, /* domainGetName */
+    NULL, /* domainGetID */
+    NULL, /* domainGetUUID */
+    NULL, /* domainGetOSType */
+    xenProxyDomainGetMaxMemory, /* domainGetMaxMemory */
+    NULL, /* domainSetMaxMemory */
+    NULL, /* domainSetMemory */
+    xenProxyDomainGetInfo, /* domainGetInfo */
+    NULL, /* domainSave */
+    NULL /* domainRestore */
+};
 
+/**
+ * xenProxyRegister:
+ *
+ * Registers the xenHypervisor driver
+ */
+void xenProxyRegister(void)
+{
+    virRegisterDriver(&xenProxyDriver);
+}
 /************************************************************************
  *									*
  *			Error handling					*
@@ -42,16 +100,14 @@ static int debug = 1;
 static void
 virProxyError(virConnectPtr conn, virErrorNumber error, const char *info)
 {
+    const char *errmsg;
+
     if (error == VIR_ERR_OK)
         return;
 
-#if 0
-    const char *errmsg;
-
     errmsg = __virErrorMsg(error, info);
     __virRaiseError(conn, NULL, VIR_FROM_XEND, error, VIR_ERR_ERROR,
                     errmsg, info, NULL, 0, 0, errmsg, info);
-#endif
 }
 
 /************************************************************************
@@ -70,10 +126,8 @@ static const char *
 virProxyFindServerPath(void)
 {
     static const char *serverPaths[] = {
-#ifdef STANDALONE
-        "/usr/bin/libvirt_proxy_dbg",
-#endif
         BINDIR "/libvirt_proxy",
+        "/usr/bin/libvirt_proxy_dbg",
         NULL
     };
     int i;
@@ -170,7 +224,6 @@ virProxyOpenClientSocket(const char *path) {
 retry:
     fd = socket(PF_UNIX, SOCK_STREAM, 0);
     if (fd < 0) {
-        fprintf(stderr, "Failed to create unix socket");
 	return(-1);
     }
 
@@ -187,7 +240,6 @@ retry:
      * now bind the socket to that address and listen on it
      */
     if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
-        fprintf(stderr, "Failed to connect to socket %s\n", path);
 	close(fd);
 	if (trials < 3) {
 	    if (virProxyForkServer() < 0)
@@ -309,12 +361,13 @@ retry:
  *
  * Shutdown the Xen proxy communication layer
  */
-void
+static int
 xenProxyClose(virConnectPtr conn) {
     if ((conn == NULL) || (conn->proxy < 0))
-        return;
+        return(-1);
     virProxyCloseClientSocket(conn->proxy);
     conn->proxy = -1;
+    return (0);
 }
 
 static int 
@@ -385,7 +438,7 @@ retry:
 	}
 	if (res->len > sizeof(virProxyPacket)) {
 	    ret  = virProxyReadClientSocket(conn->proxy,
-	                                    &(answer->extra.arg[0]),
+	                           (char *) &(answer->extra.arg[0]),
 	                                    res->len - ret);
 	    if (ret != (int) (res->len - sizeof(virProxyPacket))) {
 		fprintf(stderr,
@@ -417,35 +470,41 @@ retry:
 /**
  * xenProxyInit:
  * @conn: pointer to the hypervisor connection
+ * @name: URL for the target, NULL for local
+ * @flags: combination of virDrvOpenFlag(s)
  *
  * Try to initialize the Xen proxy communication layer
+ * This can be opened only for a read-only kind of access
  *
  * Returns 0 in case of success, and -1 in case of failure
  */
 int
-xenProxyInit(virConnectPtr conn) {
+xenProxyOpen(virConnectPtr conn, const char *name, int flags)
+{
     virProxyPacket req;
     int ret;
     int fd;
+    
+    if ((name != NULL) && (strcasecmp(name, "xen")))
+        return(-1);
+    if (!(flags & VIR_DRV_OPEN_RO))
+        return(-1);
         
-    if (!VIR_IS_CONNECT(conn)) {
-        virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
-        return (-1);
-    }
-
-    if (conn->proxy <= 0) {
-	fd = virProxyOpenClientSocket(PROXY_SOCKET_PATH);
-	if (fd < 0) {
-	    return(-1);
-	}
-	conn->proxy = fd;
+    conn->proxy = -1;
+    fd = virProxyOpenClientSocket(PROXY_SOCKET_PATH);
+    if (fd < 0) {
+        if (!(flags & VIR_DRV_OPEN_QUIET))
+	    virProxyError(conn, VIR_ERR_NO_XEN, PROXY_SOCKET_PATH);
+	return(-1);
     }
+    conn->proxy = fd;
 
     memset(&req, 0, sizeof(req));
     req.command = VIR_PROXY_NONE;
     req.len = sizeof(req);
     ret = xenProxyCommand(conn, &req, NULL);
     if ((ret < 0) || (req.command != VIR_PROXY_NONE)) {
+        virProxyError(conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
         xenProxyClose(conn);
 	return(-1);
     }
@@ -495,19 +554,6 @@ xenProxyGetVersion(virConnectPtr conn, unsigned long *hvVer)
     return(0);
 }
 
-/**
- * xenProxyNodeGetInfo:
- * @conn: pointer to the Xen Daemon block
- * @info: pointer to a virNodeInfo structure allocated by the user
- * 
- * Extract hardware information about the node.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-static int
-xenProxyNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) {
-}
-
 /**
  * xenProxyListDomains:
  * @conn: pointer to the hypervisor connection
@@ -543,8 +589,12 @@ xenProxyListDomains(virConnectPtr conn, int *ids, int maxids)
 	return(-1);
     }
     nb = ans.data.arg;
-    if ((nb > 1020) || (nb <= 0))
+    if ((nb > 1020) || (nb <= 0) ||
+        (ans.len <= sizeof(virProxyPacket)) ||
+	(ans.len > sizeof(virProxyFullPacket))) {
+        virProxyError(conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
         return(-1);
+    }
     if (nb > maxids)
         nb = maxids;
     memmove(ids, &ans.extra.arg[0], nb * sizeof(int));
@@ -565,7 +615,6 @@ xenProxyNumOfDomains(virConnectPtr conn)
 {
     virProxyPacket req;
     int ret;
-    int nb;
 
     if (!VIR_IS_CONNECT(conn)) {
         virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
@@ -582,106 +631,164 @@ xenProxyNumOfDomains(virConnectPtr conn)
     return(req.data.arg);
 }
 
+
 /**
- * xenProxyLookupByID:
+ * xenProxyDomainGetDomMaxMemory:
  * @conn: pointer to the hypervisor connection
  * @id: the domain ID number
  *
- * Try to find a domain based on the hypervisor ID number
+ * Ask the Xen Daemon for the maximum memory allowed for a domain
  *
- * Returns the domain name (to be freed) or NULL in case of failure
+ * Returns the memory size in kilobytes or 0 in case of error.
  */
-static char *
-xenProxyLookupByID(virConnectPtr conn, int id) {
+static unsigned long
+xenProxyDomainGetDomMaxMemory(virConnectPtr conn, int id)
+{
+    virProxyPacket req;
+    int ret;
+
+    if (!VIR_IS_CONNECT(conn)) {
+        virProxyError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
+        return (-1);
+    }
+    memset(&req, 0, sizeof(req));
+    req.command = VIR_PROXY_MAX_MEMORY;
+    req.data.arg = id;
+    req.len = sizeof(req);
+    ret = xenProxyCommand(conn, &req, NULL);
+    if (ret < 0) {
+        xenProxyClose(conn);
+	return(-1);
+    }
+    return(req.data.larg);
 }
 
 /**
- * xenProxyLookupByUUID:
- * @conn: pointer to the hypervisor connection
- * @uuid: the raw UUID for the domain
+ * xenProxyDomainGetMaxMemory:
+ * @domain: pointer to the domain block
  *
- * Try to lookup a domain on xend based on its UUID.
+ * Ask the Xen Daemon for the maximum memory allowed for a domain
  *
- * Returns the domain id or -1 in case of error
+ * Returns the memory size in kilobytes or 0 in case of error.
  */
-static int
-xenProxyLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+static unsigned long
+xenProxyDomainGetMaxMemory(virDomainPtr domain)
 {
+    if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+	if (domain == NULL)
+	    virProxyError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+	else
+	    virProxyError(domain->conn, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+        return (0);
+    }
+    return(xenProxyDomainGetDomMaxMemory(domain->conn, domain->handle));
 }
 
 /**
- * xenProxyDomainLookupByName:
- * @conn: A xend instance
- * @name: The name of the domain
+ * xenProxyDomainGetInfo:
+ * @domain: a domain object
+ * @info: pointer to a virDomainInfo structure allocated by the user
  *
- * This method looks up information about a domain based on its name
+ * This method looks up information about a domain and update the
+ * information block provided.
  *
- * Returns domain id or -1 in case of error
+ * Returns 0 in case of success, -1 in case of error
  */
 static int
-xenProxyDomainLookupByName(virConnectPtr conn, const char *domname)
+xenProxyDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
 {
-}
+    virProxyPacket req;
+    virProxyFullPacket ans;
+    int ret;
+
+    if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+	if (domain == NULL)
+	    virProxyError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+	else
+	    virProxyError(domain->conn, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+        return (0);
+    }
+    if (info == NULL) {
+        virProxyError(domain->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+	return (-1);
+    }
+    memset(&req, 0, sizeof(req));
+    req.command = VIR_PROXY_DOMAIN_INFO;
+    req.len = sizeof(req);
+    ret = xenProxyCommand(domain->conn, &req, &ans);
+    if (ret < 0) {
+        xenProxyClose(domain->conn);
+	return(-1);
+    }
+    if (ans.len != sizeof(virProxyPacket) + sizeof(virDomainInfo)) {
+        virProxyError(domain->conn, VIR_ERR_OPERATION_FAILED, __FUNCTION__);
+	return (-1);
+    }
+    memmove(info, &ans.extra.dinfo, sizeof(virDomainInfo));
 
+    return(0);
+}
 
 /**
- * xenProxyDomainGetMaxMemory:
- * @domain: pointer to the domain block
+ * xenProxyLookupByID:
+ * @conn: pointer to the hypervisor connection
+ * @id: the domain ID number
  *
- * Ask the Xen Daemon for the maximum memory allowed for a domain
+ * Try to find a domain based on the hypervisor ID number
  *
- * Returns the memory size in kilobytes or 0 in case of error.
+ * Returns a new domain object or NULL in case of failure
  */
-unsigned long
-xenProxyDomainGetMaxMemory(virDomainPtr domain)
+static virDomainPtr
+xenProxyLookupByID(virConnectPtr conn, int id)
 {
+    TODO
+    return(NULL);
 }
 
 /**
- * xenProxyDomainGetInfo:
- * @domain: a domain object
- * @info: pointer to a virDomainInfo structure allocated by the user
+ * xenProxyLookupByUUID:
+ * @conn: pointer to the hypervisor connection
+ * @uuid: the raw UUID for the domain
  *
- * This method looks up information about a domain and update the
- * information block provided.
+ * Try to lookup a domain on xend based on its UUID.
  *
- * Returns 0 in case of success, -1 in case of error
+ * Returns a new domain object or NULL in case of failure
  */
-int
-xenProxyDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
+static virDomainPtr
+xenProxyLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
 {
+    TODO
+    return(NULL);
 }
 
-#ifdef STANDALONE
-int main(int argc, char **argv) {
-    int ret;
-    unsigned long ver;
-    virConnect conn;
-
-    memset(&conn, 0, sizeof(conn));
-    conn.magic = VIR_CONNECT_MAGIC;
-    ret = xenProxyInit(&conn);
-    if (ret == 0) {
-        ret = xenProxyGetVersion(&conn, &ver);
-	if (ret != 0) {
-	    fprintf(stderr, "Failed to get version from proxy\n");
-	} else {
-	    int ids[50], i;
-
-	    printf("Proxy running with version %lu\n", ver);
-	    ret = xenProxyNumOfDomains(&conn);
-	    printf("There is %d running domains:", ret);
-	    ret = xenProxyListDomains(&conn, &ids, 50);
-	    if (ret < 0) {
-	        fprintf(stderr, "Failed to list domains\n");
-	    }
-	    for (i = 0;i < ret;i++)
-	        printf(" %d", ids[i]);
-	    printf("\n");
+/**
+ * xenProxyDomainLookupByName:
+ * @conn: A xend instance
+ * @name: The name of the domain
+ *
+ * This method looks up information about a domain based on its name
+ *
+ * Returns a new domain object or NULL in case of failure
+ */
+static virDomainPtr
+xenProxyDomainLookupByName(virConnectPtr conn, const char *domname)
+{
+    TODO
+    return(NULL);
+}
 
-	}
-	xenProxyClose(&conn);
-    }
-    exit(0);
+/**
+ * xenProxyNodeGetInfo:
+ * @conn: pointer to the Xen Daemon block
+ * @info: pointer to a virNodeInfo structure allocated by the user
+ * 
+ * Extract hardware information about the node.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+xenProxyNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) {
+    TODO
+    return(-1);
 }
-#endif
+

proxy/proxy.h → src/proxy_internal.h

@@ -74,7 +74,9 @@ struct _virProxyFullPacket {
     } data;
     /* that should be aligned on a 16bytes boundary */
     union {
+        char       str[4080];   /* extra char array */
         int        arg[1020];   /* extra int array */
+	virDomainInfo dinfo;	/* domain informations */
     } extra;
 };
 typedef struct _virProxyFullPacket virProxyFullPacket;
@@ -82,8 +84,7 @@ typedef  virProxyFullPacket *virProxyFullPacketPtr;
 /*
  * Functions callable from libvirt library
  */
-int xenProxyInit(virConnectPtr conn);
-void xenProxyClose(virConnectPtr conn);
+void xenProxyRegister(void);
 
 #ifdef __cplusplus
 }

src/xen_internal.c

@@ -510,24 +510,23 @@ xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
 }
 
 /**
- * xenHypervisorGetMaxMemory:
- * @domain: a domain object or NULL
+ * xenHypervisorGetDomMaxMemory:
+ * @conn: connection data
+ * @id: domain id
  * 
  * Retrieve the maximum amount of physical memory allocated to a
- * domain. If domain is NULL, then this get the amount of memory reserved
- * to Domain0 i.e. the domain where the application runs.
+ * domain.
  *
  * Returns the memory size in kilobytes or 0 in case of error.
  */
-static unsigned long
-xenHypervisorGetMaxMemory(virDomainPtr domain)
+unsigned long
+xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
 {
     dom0_op_t op;
     dom0_getdomaininfo_t dominfo;
     int ret;
 
-    if ((domain == NULL) || (domain->conn == NULL) ||
-        (domain->conn->handle < 0))
+    if ((conn == NULL) || (conn->handle < 0))
         return (0);
 
     memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
@@ -539,13 +538,13 @@ xenHypervisorGetMaxMemory(virDomainPtr domain)
     }
 
     op.cmd = DOM0_GETDOMAININFOLIST;
-    op.u.getdomaininfolist.first_domain = (domid_t) domain->handle;
+    op.u.getdomaininfolist.first_domain = (domid_t) id;
     op.u.getdomaininfolist.max_domains = 1;
     op.u.getdomaininfolist.buffer = &dominfo;
     op.u.getdomaininfolist.num_domains = 1;
-    dominfo.domain = domain->handle;
+    dominfo.domain = id;
 
-    ret = xenHypervisorDoOp(domain->conn->handle, &op);
+    ret = xenHypervisorDoOp(conn->handle, &op);
 
     if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
         virXenError(VIR_ERR_XEN_CALL, " release",
@@ -559,6 +558,26 @@ xenHypervisorGetMaxMemory(virDomainPtr domain)
     return((unsigned long) dominfo.max_pages * 4);
 }
 
+/**
+ * xenHypervisorGetMaxMemory:
+ * @domain: a domain object or NULL
+ * 
+ * Retrieve the maximum amount of physical memory allocated to a
+ * domain. If domain is NULL, then this get the amount of memory reserved
+ * to Domain0 i.e. the domain where the application runs.
+ *
+ * Returns the memory size in kilobytes or 0 in case of error.
+ */
+static unsigned long
+xenHypervisorGetMaxMemory(virDomainPtr domain)
+{
+    if ((domain == NULL) || (domain->conn == NULL) ||
+        (domain->conn->handle < 0))
+        return (0);
+
+    return(xenHypervisorGetDomMaxMemory(domain->conn, domain->handle));
+}
+
 /**
  * xenHypervisorGetDomainInfo:
  * @domain: pointer to the domain block

src/xen_internal.h

@@ -25,6 +25,9 @@ int	xenHypervisorOpen		(virConnectPtr conn,
 int	xenHypervisorClose		(virConnectPtr conn);
 int	xenHypervisorGetVersion		(virConnectPtr conn,
 				 	 unsigned long *hvVer);
+unsigned long
+        xenHypervisorGetDomMaxMemory	(virConnectPtr conn,
+					 int id);
 int	xenHypervisorNumOfDomains	(virConnectPtr conn);
 int	xenHypervisorListDomains	(virConnectPtr conn,
 					 int *ids,

src/xend_internal.c

@@ -194,7 +194,6 @@ do_connect(virConnectPtr xend)
     }
 
     if (connect(s, xend->addr, xend->len) == -1) {
-        virXendError(xend, VIR_ERR_NO_CONNECT, "Xen Daemon");
         serrno = errno;
         close(s);
         errno = serrno;
@@ -2096,6 +2095,7 @@ xenDaemonNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info) {
     return (ret);
 }
 
+#ifndef XEN_RO
 /**
  * xenDaemonGetType:
  * @conn: pointer to the Xen Daemon block
@@ -2115,6 +2115,7 @@ xenDaemonGetType(virConnectPtr conn)
     }
     return("XenDaemon");
 }
+#endif
 
 /**
  * xenDaemonGetVersion:
@@ -2243,6 +2244,7 @@ error:
     return(ret);
 }
 
+#ifndef XEN_RO
 /**
  * xenDaemonLookupByID:
  * @conn: pointer to the hypervisor connection
@@ -2430,3 +2432,5 @@ xenDaemonCreateLinux(virConnectPtr conn, const char *xmlDesc,
     return (NULL);
 }
 
+#endif
+