2005-12-07 18:10:51 +00:00
|
|
|
/*
|
|
|
|
* xen_internal.c: direct access to Xen hypervisor level
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* See COPYING.LIB for the License of this software
|
|
|
|
*
|
|
|
|
* Daniel Veillard <veillard@redhat.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2006-03-23 15:42:10 +00:00
|
|
|
/* required for uint8_t, uint32_t, etc ... */
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
|
2006-03-23 15:42:10 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
/* required for dom0_getdomaininfo_t */
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <xen/dom0_ops.h>
|
2005-12-08 13:26:52 +00:00
|
|
|
#include <xen/version.h>
|
2005-12-07 18:10:51 +00:00
|
|
|
#include <xen/xen.h>
|
2006-06-20 16:07:41 +00:00
|
|
|
#include <xen/linux/privcmd.h>
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-06-20 16:07:41 +00:00
|
|
|
/* #ifndef __LINUX_PUBLIC_PRIVCMD_H__ */
|
2006-06-21 12:15:18 +00:00
|
|
|
typedef struct old_hypercall_struct {
|
|
|
|
unsigned long op;
|
|
|
|
unsigned long arg[5];
|
|
|
|
} old_hypercall_t;
|
|
|
|
#define XEN_OLD_IOCTL_HYPERCALL_CMD \
|
|
|
|
_IOC(_IOC_NONE, 'P', 0, sizeof(old_hypercall_t))
|
|
|
|
|
2006-06-20 16:07:41 +00:00
|
|
|
typedef struct privcmd_hypercall hypercall_t;
|
|
|
|
#define XEN_IOCTL_HYPERCALL_CMD IOCTL_PRIVCMD_HYPERCALL
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
static int xen_ioctl_hypercall_cmd = 0;
|
|
|
|
static int old_hypervisor = 0;
|
|
|
|
static int initialized = 0;
|
|
|
|
static int hv_version = 0;
|
2005-12-07 18:10:51 +00:00
|
|
|
|
|
|
|
#include "internal.h"
|
2006-03-20 17:49:28 +00:00
|
|
|
#include "driver.h"
|
2005-12-07 18:10:51 +00:00
|
|
|
#include "xen_internal.h"
|
|
|
|
|
|
|
|
#define XEN_HYPERVISOR_SOCKET "/proc/xen/privcmd"
|
|
|
|
|
2006-06-13 18:29:42 +00:00
|
|
|
static const char * xenHypervisorGetType(virConnectPtr conn);
|
2006-06-16 12:36:40 +00:00
|
|
|
static unsigned long xenHypervisorGetMaxMemory(virDomainPtr domain);
|
2006-06-21 12:15:18 +00:00
|
|
|
static int xenHypervisorInit(void);
|
2006-06-13 18:29:42 +00:00
|
|
|
|
2006-06-28 18:19:13 +00:00
|
|
|
#ifndef XEN_RO
|
2006-03-20 23:42:12 +00:00
|
|
|
static virDriver xenHypervisorDriver = {
|
2006-06-21 12:56:19 +00:00
|
|
|
VIR_DRV_XEN_HYPERVISOR,
|
2006-03-20 23:42:12 +00:00
|
|
|
"Xen",
|
2006-06-13 16:31:44 +00:00
|
|
|
(DOM0_INTERFACE_VERSION >> 24) * 1000000 +
|
|
|
|
((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +
|
|
|
|
(DOM0_INTERFACE_VERSION & 0xFFFF),
|
2006-06-21 12:15:18 +00:00
|
|
|
xenHypervisorInit, /* init */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorOpen, /* open */
|
|
|
|
xenHypervisorClose, /* close */
|
2006-06-13 18:29:42 +00:00
|
|
|
xenHypervisorGetType, /* type */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorGetVersion, /* version */
|
2006-03-29 12:46:03 +00:00
|
|
|
NULL, /* nodeGetInfo */
|
2006-04-24 18:21:29 +00:00
|
|
|
xenHypervisorListDomains, /* listDomains */
|
|
|
|
xenHypervisorNumOfDomains, /* numOfDomains */
|
2006-03-20 23:42:12 +00:00
|
|
|
NULL, /* domainCreateLinux */
|
|
|
|
NULL, /* domainLookupByID */
|
|
|
|
NULL, /* domainLookupByUUID */
|
|
|
|
NULL, /* domainLookupByName */
|
|
|
|
xenHypervisorPauseDomain, /* domainSuspend */
|
|
|
|
xenHypervisorResumeDomain, /* domainResume */
|
|
|
|
NULL, /* domainShutdown */
|
2006-04-03 13:46:43 +00:00
|
|
|
NULL, /* domainReboot */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorDestroyDomain, /* domainDestroy */
|
|
|
|
NULL, /* domainFree */
|
|
|
|
NULL, /* domainGetName */
|
|
|
|
NULL, /* domainGetID */
|
|
|
|
NULL, /* domainGetUUID */
|
|
|
|
NULL, /* domainGetOSType */
|
2006-06-16 12:36:40 +00:00
|
|
|
xenHypervisorGetMaxMemory, /* domainGetMaxMemory */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorSetMaxMemory, /* domainSetMaxMemory */
|
2006-04-13 17:18:49 +00:00
|
|
|
NULL, /* domainSetMemory */
|
2006-03-20 23:42:12 +00:00
|
|
|
xenHypervisorGetDomainInfo, /* domainGetInfo */
|
|
|
|
NULL, /* domainSave */
|
|
|
|
NULL /* domainRestore */
|
|
|
|
};
|
2006-06-28 18:19:13 +00:00
|
|
|
#endif /* !XEN_RO */
|
2006-03-20 23:42:12 +00:00
|
|
|
|
2006-02-27 21:34:28 +00:00
|
|
|
/**
|
|
|
|
* virXenError:
|
|
|
|
* @conn: the connection if available
|
|
|
|
* @error: the error number
|
|
|
|
* @info: extra information string
|
|
|
|
*
|
|
|
|
* Handle an error at the xend daemon interface
|
|
|
|
*/
|
|
|
|
static void
|
2006-03-15 12:13:25 +00:00
|
|
|
virXenError(virErrorNumber error, const char *info, int value)
|
|
|
|
{
|
2006-02-27 21:34:28 +00:00
|
|
|
const char *errmsg;
|
2006-03-15 12:13:25 +00:00
|
|
|
|
2006-02-27 21:34:28 +00:00
|
|
|
if (error == VIR_ERR_OK)
|
|
|
|
return;
|
|
|
|
|
|
|
|
errmsg = __virErrorMsg(error, info);
|
|
|
|
__virRaiseError(NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
|
2006-03-15 12:13:25 +00:00
|
|
|
errmsg, info, NULL, value, 0, errmsg, info, value);
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorInit:
|
|
|
|
*
|
|
|
|
* Initialize the hypervisor layer. Try to detect the kind of interface
|
|
|
|
* used i.e. pre or post changeset 10277
|
|
|
|
*/
|
|
|
|
int xenHypervisorInit(void)
|
|
|
|
{
|
|
|
|
int fd, ret, cmd;
|
|
|
|
hypercall_t hc;
|
|
|
|
old_hypercall_t old_hc;
|
|
|
|
|
|
|
|
if (initialized) {
|
|
|
|
if (old_hypervisor == -1)
|
|
|
|
return(-1);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
initialized = 1;
|
|
|
|
|
|
|
|
ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
|
|
|
|
if (ret < 0) {
|
|
|
|
old_hypervisor = -1;
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
fd = ret;
|
|
|
|
|
|
|
|
hc.op = __HYPERVISOR_xen_version;
|
|
|
|
hc.arg[0] = (unsigned long) XENVER_version;
|
|
|
|
hc.arg[1] = 0;
|
|
|
|
|
|
|
|
cmd = IOCTL_PRIVCMD_HYPERCALL;
|
|
|
|
ret = ioctl(fd, cmd, (unsigned long) &hc);
|
|
|
|
|
|
|
|
if ((ret != -1) && (ret != 0)) {
|
2006-06-21 12:56:19 +00:00
|
|
|
/* fprintf(stderr, "Using new hypervisor call: %X\n", ret); */
|
2006-06-21 12:15:18 +00:00
|
|
|
hv_version = ret;
|
|
|
|
xen_ioctl_hypercall_cmd = cmd;
|
|
|
|
old_hypervisor = 0;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
old_hc.op = __HYPERVISOR_xen_version;
|
|
|
|
old_hc.arg[0] = (unsigned long) XENVER_version;
|
|
|
|
old_hc.arg[1] = 0;
|
|
|
|
cmd = _IOC(_IOC_NONE, 'P', 0, sizeof(old_hypercall_t));
|
|
|
|
ret = ioctl(fd, cmd, (unsigned long) &old_hc);
|
|
|
|
if ((ret != -1) && (ret != 0)) {
|
2006-06-21 12:56:19 +00:00
|
|
|
/* fprintf(stderr, "Using old hypervisor call: %X\n", ret); */
|
2006-06-21 12:15:18 +00:00
|
|
|
hv_version = ret;
|
|
|
|
xen_ioctl_hypercall_cmd = cmd;
|
|
|
|
old_hypervisor = 1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
old_hypervisor = -1;
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", IOCTL_PRIVCMD_HYPERCALL);
|
|
|
|
close(fd);
|
|
|
|
return(-1);
|
|
|
|
|
|
|
|
done:
|
|
|
|
close(fd);
|
|
|
|
return(0);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-06-28 18:19:13 +00:00
|
|
|
#ifndef XEN_RO
|
2006-06-21 12:15:18 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorRegister:
|
|
|
|
*
|
|
|
|
* Registers the xenHypervisor driver
|
|
|
|
*/
|
|
|
|
void xenHypervisorRegister(void)
|
|
|
|
{
|
|
|
|
if (initialized == 0)
|
|
|
|
xenHypervisorInit();
|
|
|
|
|
|
|
|
virRegisterDriver(&xenHypervisorDriver);
|
|
|
|
}
|
2006-06-28 18:19:13 +00:00
|
|
|
#endif /* !XEN_RO */
|
2006-06-21 12:15:18 +00:00
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorOpen:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @conn: pointer to the connection block
|
|
|
|
* @name: URL for the target, NULL for local
|
|
|
|
* @flags: combination of virDrvOpenFlag(s)
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
|
|
|
* Connects to the Xen hypervisor.
|
|
|
|
*
|
2006-03-20 17:49:28 +00:00
|
|
|
* Returns 0 or -1 in case of error.
|
2005-12-07 18:10:51 +00:00
|
|
|
*/
|
2006-03-15 12:13:25 +00:00
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorOpen(virConnectPtr conn, const char *name, int flags)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
if (initialized == 0)
|
|
|
|
xenHypervisorInit();
|
|
|
|
|
2006-06-13 18:29:42 +00:00
|
|
|
if ((name != NULL) && (strcasecmp(name, "xen")))
|
2006-03-20 17:49:28 +00:00
|
|
|
return(-1);
|
|
|
|
|
|
|
|
conn->handle = -1;
|
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR);
|
2006-02-27 21:34:28 +00:00
|
|
|
if (ret < 0) {
|
2006-03-20 17:49:28 +00:00
|
|
|
if (!(flags & VIR_DRV_OPEN_QUIET))
|
2006-03-15 12:13:25 +00:00
|
|
|
virXenError(VIR_ERR_NO_XEN, XEN_HYPERVISOR_SOCKET, 0);
|
|
|
|
return (-1);
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2006-03-20 17:49:28 +00:00
|
|
|
conn->handle = ret;
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-04-24 18:21:29 +00:00
|
|
|
return(0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorClose:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @conn: pointer to the connection block
|
2005-12-07 18:10:51 +00:00
|
|
|
*
|
|
|
|
* Close the connection to the Xen hypervisor.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success or -1 in case of error.
|
|
|
|
*/
|
2006-03-15 12:13:25 +00:00
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorClose(virConnectPtr conn)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
ret = close(conn->handle);
|
2005-12-07 18:10:51 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorDoOldOp:
|
|
|
|
* @handle: the handle to the Xen hypervisor
|
|
|
|
* @op: pointer to the hyperviros operation structure
|
|
|
|
*
|
|
|
|
* Do an hypervisor operation though the old interface,
|
|
|
|
* this leads to an hypervisor call through ioctl.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xenHypervisorDoOldOp(int handle, dom0_op_t * op)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
old_hypercall_t hc;
|
|
|
|
|
|
|
|
memset(&hc, 0, sizeof(hc));
|
|
|
|
op->interface_version = hv_version << 8;
|
|
|
|
hc.op = __HYPERVISOR_dom0_op;
|
|
|
|
hc.arg[0] = (unsigned long) op;
|
|
|
|
|
|
|
|
if (mlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(dom0_op_t));
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
|
|
|
|
if (ret < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (munlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(dom0_op_t));
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorDoOp:
|
|
|
|
* @handle: the handle to the Xen hypervisor
|
|
|
|
* @op: pointer to the hyperviros operation structure
|
|
|
|
*
|
|
|
|
* Do an hypervisor operation, this leads to an hypervisor call through ioctl.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success and -1 in case of error.
|
|
|
|
*/
|
|
|
|
static int
|
2006-03-15 12:13:25 +00:00
|
|
|
xenHypervisorDoOp(int handle, dom0_op_t * op)
|
|
|
|
{
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
|
|
|
hypercall_t hc;
|
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
if (old_hypervisor)
|
|
|
|
return(xenHypervisorDoOldOp(handle, op));
|
|
|
|
|
|
|
|
memset(&hc, 0, sizeof(hc));
|
2005-12-07 18:10:51 +00:00
|
|
|
op->interface_version = DOM0_INTERFACE_VERSION;
|
|
|
|
hc.op = __HYPERVISOR_dom0_op;
|
2006-03-15 12:13:25 +00:00
|
|
|
hc.arg[0] = (unsigned long) op;
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-02-27 21:34:28 +00:00
|
|
|
if (mlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking", sizeof(dom0_op_t));
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-06-21 12:15:18 +00:00
|
|
|
ret = ioctl(handle, xen_ioctl_hypercall_cmd, (unsigned long) &hc);
|
2006-02-27 21:34:28 +00:00
|
|
|
if (ret < 0) {
|
2006-06-21 12:15:18 +00:00
|
|
|
virXenError(VIR_ERR_XEN_CALL, " ioctl ", xen_ioctl_hypercall_cmd);
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-02-27 21:34:28 +00:00
|
|
|
if (munlock(op, sizeof(dom0_op_t)) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " releasing", sizeof(dom0_op_t));
|
2005-12-07 18:10:51 +00:00
|
|
|
ret = -1;
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
|
|
|
|
return (0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
2006-06-13 18:29:42 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetType:
|
|
|
|
* @conn: pointer to the Xen Hypervisor block
|
|
|
|
*
|
|
|
|
* Get the version level of the Hypervisor running.
|
|
|
|
*
|
|
|
|
* Returns -1 in case of error, 0 otherwise. if the version can't be
|
|
|
|
* extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
|
|
|
|
* @hvVer value is major * 1,000,000 + minor * 1,000 + release
|
|
|
|
*/
|
|
|
|
static const char *
|
|
|
|
xenHypervisorGetType(virConnectPtr conn)
|
|
|
|
{
|
|
|
|
if (!VIR_IS_CONNECT(conn)) {
|
|
|
|
virXenError(VIR_ERR_INVALID_CONN, __FUNCTION__, 0);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
return("Xen");
|
|
|
|
}
|
|
|
|
|
2005-12-08 13:26:52 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetVersion:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @conn: pointer to the connection block
|
|
|
|
* @hvVer: where to store the version
|
2005-12-08 13:26:52 +00:00
|
|
|
*
|
|
|
|
* Call the hypervisor to extracts his own internal API version
|
|
|
|
*
|
2006-03-20 17:49:28 +00:00
|
|
|
* Returns 0 in case of success, -1 in case of error
|
2005-12-08 13:26:52 +00:00
|
|
|
*/
|
2006-03-20 17:49:28 +00:00
|
|
|
int
|
|
|
|
xenHypervisorGetVersion(virConnectPtr conn, unsigned long *hvVer)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0) || (hvVer == NULL))
|
|
|
|
return (-1);
|
2006-06-21 12:15:18 +00:00
|
|
|
*hvVer = (hv_version >> 16) * 1000000 + (hv_version & 0xFFFF) * 1000;
|
2006-03-20 17:49:28 +00:00
|
|
|
return(0);
|
2005-12-08 13:26:52 +00:00
|
|
|
}
|
|
|
|
|
2006-04-24 18:21:29 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorNumOfDomains:
|
|
|
|
* @conn: pointer to the connection block
|
|
|
|
*
|
|
|
|
* Provides the number of active domains.
|
|
|
|
*
|
|
|
|
* Returns the number of domain found or -1 in case of error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorNumOfDomains(virConnectPtr conn)
|
|
|
|
{
|
|
|
|
dom0_op_t op;
|
|
|
|
dom0_getdomaininfo_t *dominfos;
|
|
|
|
int ret, nbids;
|
|
|
|
static int last_maxids = 2;
|
|
|
|
int maxids = last_maxids;
|
|
|
|
|
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
retry:
|
|
|
|
dominfos = malloc(maxids * sizeof(dom0_getdomaininfo_t));
|
|
|
|
if (dominfos == NULL) {
|
|
|
|
virXenError(VIR_ERR_NO_MEMORY, "failed to allocate %d domain info",
|
|
|
|
maxids);
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(dominfos, 0, sizeof(dom0_getdomaininfo_t) * maxids);
|
|
|
|
|
|
|
|
if (mlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking",
|
|
|
|
sizeof(dom0_getdomaininfo_t) * maxids);
|
|
|
|
free(dominfos);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
op.cmd = DOM0_GETDOMAININFOLIST;
|
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) 0;
|
|
|
|
op.u.getdomaininfolist.max_domains = maxids;
|
|
|
|
op.u.getdomaininfolist.buffer = dominfos;
|
|
|
|
op.u.getdomaininfolist.num_domains = maxids;
|
|
|
|
|
|
|
|
ret = xenHypervisorDoOp(conn->handle, &op);
|
|
|
|
|
|
|
|
if (munlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " release",
|
|
|
|
sizeof(dom0_getdomaininfo_t) * maxids);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(dominfos);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
nbids = op.u.getdomaininfolist.num_domains;
|
|
|
|
if (nbids == maxids) {
|
|
|
|
last_maxids *= 2;
|
|
|
|
maxids *= 2;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if ((nbids < 0) || (nbids > maxids))
|
|
|
|
return(-1);
|
|
|
|
return(nbids);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorListDomains:
|
|
|
|
* @conn: pointer to the connection block
|
|
|
|
* @ids: array to collect the list of IDs of active domains
|
|
|
|
* @maxids: size of @ids
|
|
|
|
*
|
|
|
|
* Collect the list of active domains, and store their ID in @maxids
|
|
|
|
*
|
|
|
|
* Returns the number of domain found or -1 in case of error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorListDomains(virConnectPtr conn, int *ids, int maxids)
|
|
|
|
{
|
|
|
|
dom0_op_t op;
|
|
|
|
dom0_getdomaininfo_t *dominfos;
|
|
|
|
int ret, nbids, i;
|
|
|
|
|
|
|
|
if ((conn == NULL) || (conn->handle < 0) ||
|
|
|
|
(ids == NULL) || (maxids < 1))
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
dominfos = malloc(maxids * sizeof(dom0_getdomaininfo_t));
|
|
|
|
if (dominfos == NULL) {
|
|
|
|
virXenError(VIR_ERR_NO_MEMORY, "failed to allocate %d domain info",
|
|
|
|
maxids);
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(dominfos, 0, sizeof(dom0_getdomaininfo_t) * maxids);
|
|
|
|
memset(ids, 0, maxids * sizeof(int));
|
|
|
|
|
|
|
|
if (mlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking",
|
|
|
|
sizeof(dom0_getdomaininfo_t) * maxids);
|
|
|
|
free(dominfos);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
op.cmd = DOM0_GETDOMAININFOLIST;
|
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) 0;
|
|
|
|
op.u.getdomaininfolist.max_domains = maxids;
|
|
|
|
op.u.getdomaininfolist.buffer = dominfos;
|
|
|
|
op.u.getdomaininfolist.num_domains = maxids;
|
|
|
|
|
|
|
|
ret = xenHypervisorDoOp(conn->handle, &op);
|
|
|
|
|
|
|
|
if (munlock(dominfos, sizeof(dom0_getdomaininfo_t) * maxids) < 0) {
|
|
|
|
virXenError(VIR_ERR_XEN_CALL, " release",
|
|
|
|
sizeof(dom0_getdomaininfo_t) * maxids);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
free(dominfos);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
nbids = op.u.getdomaininfolist.num_domains;
|
|
|
|
if ((nbids < 0) || (nbids > maxids)) {
|
|
|
|
free(dominfos);
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0;i < nbids;i++) {
|
|
|
|
ids[i] = dominfos[i].domain;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(dominfos);
|
|
|
|
return (nbids);
|
|
|
|
}
|
|
|
|
|
2006-06-16 12:36:40 +00:00
|
|
|
/**
|
2006-06-29 22:12:47 +00:00
|
|
|
* xenHypervisorGetDomMaxMemory:
|
|
|
|
* @conn: connection data
|
|
|
|
* @id: domain id
|
2006-06-16 12:36:40 +00:00
|
|
|
*
|
|
|
|
* Retrieve the maximum amount of physical memory allocated to a
|
2006-06-29 22:12:47 +00:00
|
|
|
* domain.
|
2006-06-16 12:36:40 +00:00
|
|
|
*
|
|
|
|
* Returns the memory size in kilobytes or 0 in case of error.
|
|
|
|
*/
|
2006-06-29 22:12:47 +00:00
|
|
|
unsigned long
|
|
|
|
xenHypervisorGetDomMaxMemory(virConnectPtr conn, int id)
|
2006-06-16 12:36:40 +00:00
|
|
|
{
|
|
|
|
dom0_op_t op;
|
|
|
|
dom0_getdomaininfo_t dominfo;
|
|
|
|
int ret;
|
|
|
|
|
2006-06-29 22:12:47 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0))
|
2006-06-16 12:36:40 +00:00
|
|
|
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;
|
2006-06-29 22:12:47 +00:00
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) id;
|
2006-06-16 12:36:40 +00:00
|
|
|
op.u.getdomaininfolist.max_domains = 1;
|
|
|
|
op.u.getdomaininfolist.buffer = &dominfo;
|
|
|
|
op.u.getdomaininfolist.num_domains = 1;
|
2006-06-29 22:12:47 +00:00
|
|
|
dominfo.domain = id;
|
2006-06-16 12:36:40 +00:00
|
|
|
|
2006-06-29 22:12:47 +00:00
|
|
|
ret = xenHypervisorDoOp(conn->handle, &op);
|
2006-06-16 12:36:40 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-06-29 22:12:47 +00:00
|
|
|
/**
|
|
|
|
* 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));
|
|
|
|
}
|
|
|
|
|
2005-12-07 18:10:51 +00:00
|
|
|
/**
|
2006-06-29 23:53:31 +00:00
|
|
|
* xenHypervisorGetDomInfo:
|
|
|
|
* @conn: connection data
|
|
|
|
* @id: the domain ID
|
2005-12-07 18:10:51 +00:00
|
|
|
* @info: the place where informations should be stored
|
|
|
|
*
|
|
|
|
* Do an hypervisor call to get the related set of domain informations.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-06-29 23:53:31 +00:00
|
|
|
xenHypervisorGetDomInfo(virConnectPtr conn, int id, virDomainInfoPtr info)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-07 18:10:51 +00:00
|
|
|
dom0_op_t op;
|
2006-03-20 17:49:28 +00:00
|
|
|
dom0_getdomaininfo_t dominfo;
|
2005-12-07 18:10:51 +00:00
|
|
|
int ret;
|
|
|
|
|
2006-06-29 23:53:31 +00:00
|
|
|
if ((conn == NULL) || (conn->handle < 0) || (info == NULL))
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
memset(info, 0, sizeof(virDomainInfo));
|
|
|
|
memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t));
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-04-24 18:21:29 +00:00
|
|
|
if (mlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
|
2006-03-15 12:13:25 +00:00
|
|
|
virXenError(VIR_ERR_XEN_CALL, " locking",
|
|
|
|
sizeof(dom0_getdomaininfo_t));
|
|
|
|
return (-1);
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
|
|
|
|
op.cmd = DOM0_GETDOMAININFOLIST;
|
2006-06-29 23:53:31 +00:00
|
|
|
op.u.getdomaininfolist.first_domain = (domid_t) id;
|
2005-12-07 18:10:51 +00:00
|
|
|
op.u.getdomaininfolist.max_domains = 1;
|
2006-03-20 17:49:28 +00:00
|
|
|
op.u.getdomaininfolist.buffer = &dominfo;
|
2005-12-08 10:12:18 +00:00
|
|
|
op.u.getdomaininfolist.num_domains = 1;
|
2006-06-29 23:53:31 +00:00
|
|
|
dominfo.domain = id;
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-06-29 23:53:31 +00:00
|
|
|
ret = xenHypervisorDoOp(conn->handle, &op);
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2006-04-24 18:21:29 +00:00
|
|
|
if (munlock(&dominfo, sizeof(dom0_getdomaininfo_t)) < 0) {
|
2006-03-15 12:13:25 +00:00
|
|
|
virXenError(VIR_ERR_XEN_CALL, " release",
|
|
|
|
sizeof(dom0_getdomaininfo_t));
|
2005-12-07 18:10:51 +00:00
|
|
|
ret = -1;
|
2006-02-27 21:34:28 +00:00
|
|
|
}
|
2005-12-07 18:10:51 +00:00
|
|
|
|
2005-12-08 10:12:18 +00:00
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
2006-03-20 17:49:28 +00:00
|
|
|
|
|
|
|
switch (dominfo.flags & 0xFF) {
|
|
|
|
case DOMFLAGS_DYING:
|
|
|
|
info->state = VIR_DOMAIN_SHUTDOWN;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_SHUTDOWN:
|
|
|
|
info->state = VIR_DOMAIN_SHUTOFF;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_PAUSED:
|
|
|
|
info->state = VIR_DOMAIN_PAUSED;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_BLOCKED:
|
|
|
|
info->state = VIR_DOMAIN_BLOCKED;
|
|
|
|
break;
|
|
|
|
case DOMFLAGS_RUNNING:
|
|
|
|
info->state = VIR_DOMAIN_RUNNING;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
info->state = VIR_DOMAIN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the API brings back the cpu time in nanoseconds,
|
|
|
|
* convert to microseconds, same thing convert to
|
|
|
|
* kilobytes from page counts
|
|
|
|
*/
|
|
|
|
info->cpuTime = dominfo.cpu_time;
|
|
|
|
info->memory = dominfo.tot_pages * 4;
|
|
|
|
info->maxMem = dominfo.max_pages * 4;
|
|
|
|
info->nrVirtCpu = dominfo.nr_online_vcpus;
|
2006-03-15 12:13:25 +00:00
|
|
|
return (0);
|
2005-12-07 18:10:51 +00:00
|
|
|
}
|
|
|
|
|
2006-06-29 23:53:31 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorGetDomainInfo:
|
|
|
|
* @domain: pointer to the domain block
|
|
|
|
* @info: the place where informations should be stored
|
|
|
|
*
|
|
|
|
* Do an hypervisor call to get the related set of domain informations.
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
|
|
|
|
{
|
|
|
|
dom0_op_t op;
|
|
|
|
dom0_getdomaininfo_t dominfo;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0) || (info == NULL) ||
|
|
|
|
(domain->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
return(xenHypervisorGetDomInfo(domain->conn, domain->handle, info));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2005-12-08 17:16:24 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorPauseDomain:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-08 17:16:24 +00:00
|
|
|
*
|
|
|
|
* Do an hypervisor call to pause the given domain
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorPauseDomain(virDomainPtr domain)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-08 17:16:24 +00:00
|
|
|
dom0_op_t op;
|
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
2005-12-08 17:16:24 +00:00
|
|
|
op.cmd = DOM0_PAUSEDOMAIN;
|
2006-03-20 17:49:28 +00:00
|
|
|
op.u.pausedomain.domain = (domid_t) domain->handle;
|
2005-12-08 17:16:24 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
ret = xenHypervisorDoOp(domain->conn->handle, &op);
|
2005-12-08 17:16:24 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-08 17:16:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorResumeDomain:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-08 17:16:24 +00:00
|
|
|
*
|
|
|
|
* Do an hypervisor call to resume the given domain
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorResumeDomain(virDomainPtr domain)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-08 17:16:24 +00:00
|
|
|
dom0_op_t op;
|
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
2005-12-08 17:16:24 +00:00
|
|
|
op.cmd = DOM0_UNPAUSEDOMAIN;
|
2006-03-20 17:49:28 +00:00
|
|
|
op.u.unpausedomain.domain = (domid_t) domain->handle;
|
2005-12-08 17:16:24 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
ret = xenHypervisorDoOp(domain->conn->handle, &op);
|
2005-12-08 17:16:24 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-08 17:16:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorDestroyDomain:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-08 17:16:24 +00:00
|
|
|
*
|
|
|
|
* Do an hypervisor call to destroy the given domain
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorDestroyDomain(virDomainPtr domain)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-08 17:16:24 +00:00
|
|
|
dom0_op_t op;
|
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
2005-12-08 17:16:24 +00:00
|
|
|
op.cmd = DOM0_DESTROYDOMAIN;
|
2006-03-20 17:49:28 +00:00
|
|
|
op.u.destroydomain.domain = (domid_t) domain->handle;
|
2005-12-08 17:16:24 +00:00
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
ret = xenHypervisorDoOp(domain->conn->handle, &op);
|
2005-12-08 17:16:24 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-08 17:16:24 +00:00
|
|
|
}
|
|
|
|
|
2005-12-12 13:22:20 +00:00
|
|
|
/**
|
|
|
|
* xenHypervisorSetMaxMemory:
|
2006-03-20 17:49:28 +00:00
|
|
|
* @domain: pointer to the domain block
|
2005-12-12 13:22:20 +00:00
|
|
|
* @memory: the max memory size in kilobytes.
|
|
|
|
*
|
|
|
|
* Do an hypervisor call to change the maximum amount of memory used
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
2006-03-20 17:49:28 +00:00
|
|
|
xenHypervisorSetMaxMemory(virDomainPtr domain, unsigned long memory)
|
2006-03-15 12:13:25 +00:00
|
|
|
{
|
2005-12-12 13:22:20 +00:00
|
|
|
dom0_op_t op;
|
|
|
|
int ret;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
if ((domain == NULL) || (domain->conn == NULL) ||
|
|
|
|
(domain->conn->handle < 0))
|
|
|
|
return (-1);
|
|
|
|
|
2005-12-12 13:22:20 +00:00
|
|
|
op.cmd = DOM0_SETDOMAINMAXMEM;
|
2006-03-20 17:49:28 +00:00
|
|
|
op.u.setdomainmaxmem.domain = (domid_t) domain->handle;
|
2005-12-12 13:22:20 +00:00
|
|
|
op.u.setdomainmaxmem.max_memkb = memory;
|
|
|
|
|
2006-03-20 17:49:28 +00:00
|
|
|
ret = xenHypervisorDoOp(domain->conn->handle, &op);
|
2005-12-12 13:22:20 +00:00
|
|
|
|
|
|
|
if (ret < 0)
|
2006-03-15 12:13:25 +00:00
|
|
|
return (-1);
|
|
|
|
return (0);
|
2005-12-12 13:22:20 +00:00
|
|
|
}
|
2006-06-16 15:28:26 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* xenHypervisorCheckID:
|
|
|
|
* @domain: pointer to the domain block
|
|
|
|
* @info: the place where informations should be stored
|
|
|
|
*
|
|
|
|
* Do an hypervisor call to verify the domain ID is valid
|
|
|
|
*
|
|
|
|
* Returns 0 in case of success, -1 in case of error.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xenHypervisorCheckID(virConnectPtr conn, int id)
|
|
|
|
{
|
|
|
|
dom0_op_t op;
|
|
|
|
dom0_getdomaininfo_t dominfo;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((conn->handle < 0) || (id < 0))
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
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 (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 (-1);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|