External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-22 05:35:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
Daniel Veillard 2006-06-29 22:12:47 +00:00
parent c386d9747b
commit 337211e731
11 changed files with 304 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ChangeLog
View File

@ -1,3 +1,11 @@
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

8
proxy/Makefile.am
View File

@ -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 =

22
proxy/libvirt_proxy.c
View File

@ -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:

6
src/Makefile.am
View File

@ -1,6 +1,7 @@
## 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

3
src/driver.h
View File

@ -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;

5
src/libvirt.c
View File

@ -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];

319
proxy/proxy_client.c → src/proxy_internal.c
View File

@ -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,48 +631,38 @@ 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) {
}
/**
* xenProxyLookupByUUID:
* @conn: pointer to the hypervisor connection
* @uuid: the raw UUID for the domain
*
* Try to lookup a domain on xend based on its UUID.
*
* Returns the domain id or -1 in case of error
*/
static int
xenProxyLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
static unsigned long
xenProxyDomainGetDomMaxMemory(virConnectPtr conn, int id)
{
}
virProxyPacket req;
int ret;
/**
* xenProxyDomainLookupByName:
* @conn: A xend instance
* @name: The name of the domain
*
* This method looks up information about a domain based on its name
*
* Returns domain id or -1 in case of error
*/
static int
xenProxyDomainLookupByName(virConnectPtr conn, const char *domname)
{
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);
}
/**
* xenProxyDomainGetMaxMemory:
* @domain: pointer to the domain block
@ -632,9 +671,17 @@ xenProxyDomainLookupByName(virConnectPtr conn, const char *domname)
*
* Returns the memory size in kilobytes or 0 in case of error.
*/
unsigned long
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));
}
/**
@ -647,41 +694,101 @@ xenProxyDomainGetMaxMemory(virDomainPtr domain)
*
* Returns 0 in case of success, -1 in case of error
*/
int
static int
xenProxyDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
{
}
#ifdef STANDALONE
int main(int argc, char **argv) {
virProxyPacket req;
virProxyFullPacket ans;
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");
}
xenProxyClose(&conn);
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);
}
exit(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);
}
#endif
/**
* xenProxyLookupByID:
* @conn: pointer to the hypervisor connection
* @id: the domain ID number
*
* Try to find a domain based on the hypervisor ID number
*
* Returns a new domain object or NULL in case of failure
*/
static virDomainPtr
xenProxyLookupByID(virConnectPtr conn, int id)
{
TODO
return(NULL);
}
/**
* xenProxyLookupByUUID:
* @conn: pointer to the hypervisor connection
* @uuid: the raw UUID for the domain
*
* Try to lookup a domain on xend based on its UUID.
*
* Returns a new domain object or NULL in case of failure
*/
static virDomainPtr
xenProxyLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
{
TODO
return(NULL);
}
/**
* 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);
}
/**
* 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);
}

5
proxy/proxy.h → src/proxy_internal.h
View File

@ -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
}

81
src/xen_internal.c
View File

@ -509,6 +509,55 @@ xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
return (nbids);
}
/**
* xenHypervisorGetDomMaxMemory:
* @conn: connection data
* @id: domain id
*
* Retrieve the maximum amount of physical memory allocated to a
* domain.
*
* Returns the memory size in kilobytes or 0 in case of error.
*/
unsigned long
xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
{
dom0_op_t op;
dom0_getdomaininfo_t dominfo;
int ret;
if ((conn == NULL) || (conn->handle < 0))
return (0);
memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
if (mlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking",
sizeof(dom0_getdomaininfo_t));
return (0);
}
op.cmd = DOM0_GETDOMAININFOLIST;
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 = id;
ret = xenHypervisorDoOp(conn->handle, &op);
if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " release",
sizeof(dom0_getdomaininfo_t));
ret = -1;
}
if (ret < 0)
return (0);
return((unsigned long) dominfo.max_pages * 4);
}
/**
* xenHypervisorGetMaxMemory:
* @domain: a domain object or NULL
@ -522,41 +571,11 @@ xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
static unsigned long
xenHypervisorGetMaxMemory(virDomainPtr domain)
{
dom0_op_t op;
dom0_getdomaininfo_t dominfo;
int ret;
if ((domain == NULL) || (domain->conn == NULL) ||
(domain->conn->handle < 0))
return (0);
memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
if (mlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " locking",
sizeof(dom0_getdomaininfo_t));
return (0);
}
op.cmd = DOM0_GETDOMAININFOLIST;
op.u.getdomaininfolist.first_domain = (domid_t) domain->handle;
op.u.getdomaininfolist.max_domains = 1;
op.u.getdomaininfolist.buffer = &dominfo;
op.u.getdomaininfolist.num_domains = 1;
dominfo.domain = domain->handle;
ret = xenHypervisorDoOp(domain->conn->handle, &op);
if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
virXenError(VIR_ERR_XEN_CALL, " release",
sizeof(dom0_getdomaininfo_t));
ret = -1;
}
if (ret < 0)
return (0);
return((unsigned long) dominfo.max_pages * 4);
return(xenHypervisorGetDomMaxMemory(domain->conn, domain->handle));
}
/**

3
src/xen_internal.h
View File

@ -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,

6
src/xend_internal.c
View File

@ -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