diff --git a/ChangeLog b/ChangeLog index 0fcd4ee26d353a56ab380cff0c4080342ccaa156..5ad82484adf9e7d7d5b07c685af2230388c3f67e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,10 @@ +Mon Mar 20 18:43:19 CET 2006 Daniel Veillard + + * src/driver.h src/internal.h src/libvirt.c src/xen_internal.c + src/xen_internal.h docs/apibuild.py: starting the refactoring, + first the direct Xen hypervisor module. New header describing the + entry points of a driver. + Wed Mar 15 13:10:25 CET 2006 Daniel Veillard * src/hash.c src/hash.h src/internal.h src/libvirt.c src/sexpr.c diff --git a/docs/apibuild.py b/docs/apibuild.py index 9cbd9f7ffb9eee9d4a737968d8861cdbb8cbbb31..712d4427aa113fabe80373a1d5a5ae8aa181a38b 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -22,6 +22,7 @@ ignored_files = { "hash.c": "internal hash table stuff", "hash.h": "internal hash table stuff", "internal.h": "internal includes and defines", + "driver.h": "internal driver interfaces", "xend_internal.h": "internal includes and defines", "xend_internal.c": "internal code", "sexpr.h": "internal includes and defines", diff --git a/src/driver.h b/src/driver.h new file mode 100644 index 0000000000000000000000000000000000000000..08853704f3cba358ad900175159866b26c43caf0 --- /dev/null +++ b/src/driver.h @@ -0,0 +1,136 @@ +/* + * driver.h: description of the set of interfaces provided by a + * entry point to the virtualization engine + */ + +#ifndef __VIR_DRIVER_H__ +#define __VIR_DRIVER_H__ + +#include "libvirt.h" +#include "virterror.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + VIR_DRV_OPEN_QUIET = 1, + VIR_DRV_OPEN_RO = 2 +} virDrvOpenFlag; + +typedef int + (*virDrvInit) (void); +typedef int + (*virDrvOpen) (virConnectPtr conn, + const char *name, + int flags); +typedef int + (*virDrvClose) (virConnectPtr conn); +typedef const char * + (*virDrvGetType) (virConnectPtr conn); +typedef int + (*virDrvGetVersion) (void * conn, + unsigned long *hvVer); +typedef int + (*virDrvListDomains) (virConnectPtr conn, + int *ids, + int maxids); +typedef int + (*virDrvNumOfDomains) (virConnectPtr conn); +typedef virDomainPtr + (*virDrvDomainCreateLinux) (virConnectPtr conn, + const char *xmlDesc, + unsigned int flags); +typedef virDomainPtr + (*virDrvDomainLookupByID) (virConnectPtr conn, + int id); +typedef virDomainPtr + (*virDrvDomainLookupByUUID) (virConnectPtr conn, + const unsigned char *uuid); +typedef virDomainPtr + (*virDrvDomainLookupByName) (virConnectPtr conn, + const char *name); +typedef int + (*virDrvDomainSuspend) (virDomainPtr domain); +typedef int + (*virDrvDomainResume) (virDomainPtr domain); +typedef int + (*virDrvDomainShutdown) (virDomainPtr domain); +typedef int + (*virDrvDomainDestroy) (virDomainPtr domain); +typedef int + (*virDrvDomainFree) (virDomainPtr domain); +typedef const char * + (*virDrvDomainGetName) (virDomainPtr domain); +typedef int + (*virDrvDomainGetID) (virDomainPtr domain); +typedef int + (*virDrvDomainGetUUID) (virDomainPtr domain, + unsigned char *uuid); +typedef char * + (*virDrvDomainGetOSType) (virDomainPtr domain); +typedef unsigned long + (*virDrvDomainGetMaxMemory) (virDomainPtr domain); +typedef int + (*virDrvDomainSetMaxMemory) (virDomainPtr domain, + unsigned long memory); +typedef int + (*virDrvDomainGetInfo) (virDomainPtr domain, + virDomainInfoPtr info); +typedef int + (*virDrvDomainSave) (virDomainPtr domain, + const char *to); +typedef int + (*virDrvDomainRestore) (virConnectPtr conn, + const char *from); + +typedef struct _virDriver virDriver; +typedef virDriver *virDriverPtr; + +/** + * _virDriver: + * + * Structure associated to a virtualization driver, defining the various + * entry points for it. + */ +struct _virDriver { + const char *name; + virDrvInit init; + virDrvOpen open; + virDrvClose close; + virDrvGetType type; + virDrvGetVersion version; + virDrvListDomains listDomains; + virDrvNumOfDomains numOfDomains; + virDrvDomainCreateLinux domainCreateLinux; + virDrvDomainLookupByID domainLookupByID; + virDrvDomainLookupByUUID domainLookupByUUID; + virDrvDomainLookupByName domainLookupByName; + virDrvDomainSuspend domainSuspend; + virDrvDomainResume domainResume; + virDrvDomainShutdown domainShutdown; + virDrvDomainDestroy domainDestroy; + virDrvDomainFree domainFree; + virDrvDomainGetName domainGetName; + virDrvDomainGetID domainGetID; + virDrvDomainGetUUID domainGetUUID; + virDrvDomainGetOSType domainGetOSType; + virDrvDomainGetMaxMemory domainGetMaxMemory; + virDrvDomainSetMaxMemory domainSetMaxMemory; + virDrvDomainGetInfo domainGetInfo; + virDrvDomainSave domainSave; + virDrvDomainRestore domainRestore; +}; + + +/* + * Registration + * TODO: also need ways to (des)activate a given driver + * lookup based on the URI given in a virConnectOpen(ReadOnly) + */ +int virRegisterDriver(virDriverPtr); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_DRIVER_H__ */ diff --git a/src/internal.h b/src/internal.h index 7993df006b372daa169a23bfa2fc7328ab426a51..ce6428033db37d42d8bbaa1a0c5d6c95ddf2ace9 100644 --- a/src/internal.h +++ b/src/internal.h @@ -74,70 +74,70 @@ extern "C" { * * Internal structure associated to a connection */ - struct _virConnect { - unsigned int magic; /* specific value to check */ - int handle; /* internal handle used for hypercall */ - struct xs_handle *xshandle; /* handle to talk to the xenstore */ - - /* connection to xend */ - int type; /* PF_UNIX or PF_INET */ - int len; /* lenght of addr */ - struct sockaddr *addr; /* type of address used */ - struct sockaddr_un addr_un; /* the unix address */ - struct sockaddr_in addr_in; /* the inet address */ - - /* error stuff */ - virError err; /* the last error */ - virErrorFunc handler; /* associated handlet */ - void *userData; /* the user data */ - - /* misc */ - virHashTablePtr domains; /* hash table for known domains */ - int flags; /* a set of connection flags */ - }; +struct _virConnect { + unsigned int magic; /* specific value to check */ + int handle; /* internal handle used for hypercall */ + struct xs_handle *xshandle; /* handle to talk to the xenstore */ + + /* connection to xend */ + int type; /* PF_UNIX or PF_INET */ + int len; /* lenght of addr */ + struct sockaddr *addr; /* type of address used */ + struct sockaddr_un addr_un; /* the unix address */ + struct sockaddr_in addr_in; /* the inet address */ + + /* error stuff */ + virError err; /* the last error */ + virErrorFunc handler; /* associated handlet */ + void *userData; /* the user data */ + + /* misc */ + virHashTablePtr domains; /* hash table for known domains */ + int flags; /* a set of connection flags */ +}; /** - * virDomainFlags: - * - * a set of special flag values associated to the domain - */ +* virDomainFlags: +* +* a set of special flag values associated to the domain +*/ - enum { - DOMAIN_IS_SHUTDOWN = (1 << 0) /* the domain is being shutdown */ - } virDomainFlags; +enum { + DOMAIN_IS_SHUTDOWN = (1 << 0) /* the domain is being shutdown */ +} virDomainFlags; /** - * _virDomain: - * - * Internal structure associated to a domain - */ - struct _virDomain { - unsigned int magic; /* specific value to check */ - virConnectPtr conn; /* pointer back to the connection */ - char *name; /* the domain external name */ - char *path; /* the domain internal path */ - int handle; /* internal handle for the dmonain ID */ - int flags; /* extra flags */ - unsigned char uuid[16]; /* the domain unique identifier */ - }; +* _virDomain: +* +* Internal structure associated to a domain +*/ +struct _virDomain { + unsigned int magic; /* specific value to check */ + virConnectPtr conn; /* pointer back to the connection */ + char *name; /* the domain external name */ + char *path; /* the domain internal path */ + int handle; /* internal handle for the domnain ID */ + int flags; /* extra flags */ + unsigned char uuid[16]; /* the domain unique identifier */ +}; /* - * Internal routines - */ - char *virDomainGetVM(virDomainPtr domain); - char *virDomainGetVMInfo(virDomainPtr domain, - const char *vm, const char *name); - - void __virRaiseError(virConnectPtr conn, - virDomainPtr dom, - int domain, - int code, - virErrorLevel level, - const char *str1, - const char *str2, - const char *str3, - int int1, int int2, const char *msg, ...); - const char *__virErrorMsg(virErrorNumber error, const char *info); +* Internal routines +*/ +char *virDomainGetVM(virDomainPtr domain); +char *virDomainGetVMInfo(virDomainPtr domain, + const char *vm, const char *name); + +void __virRaiseError(virConnectPtr conn, + virDomainPtr dom, + int domain, + int code, + virErrorLevel level, + const char *str1, + const char *str2, + const char *str3, + int int1, int int2, const char *msg, ...); +const char *__virErrorMsg(virErrorNumber error, const char *info); #ifdef __cplusplus } diff --git a/src/libvirt.c b/src/libvirt.c index 236b9514d56fb179439f1d58ec7d8e4db794318b..6d7099bd7f933d49fb8387c953f48110024eace4 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -19,6 +19,7 @@ #include #include #include "internal.h" +#include "driver.h" #include "xen_internal.h" #include "xend_internal.h" #include "hash.h" @@ -137,7 +138,7 @@ virConnectPtr virConnectOpen(const char *name) { virConnectPtr ret = NULL; - int handle = -1; + int res; struct xs_handle *xshandle = NULL; /* we can only talk to the local Xen supervisor ATM */ @@ -146,8 +147,16 @@ virConnectOpen(const char *name) return (NULL); } - handle = xenHypervisorOpen(0); - if (handle == -1) { + ret = (virConnectPtr) malloc(sizeof(virConnect)); + if (ret == NULL) { + virLibConnError(NULL, VIR_ERR_NO_MEMORY, "Allocating connection"); + goto failed; + } + memset(ret, 0, sizeof(virConnect)); + ret->magic = VIR_CONNECT_MAGIC; + + res = xenHypervisorOpen(ret, name, 0); + if (res < 0) { goto failed; } xshandle = xs_daemon_open(); @@ -156,14 +165,6 @@ virConnectOpen(const char *name) goto failed; } - ret = (virConnectPtr) malloc(sizeof(virConnect)); - if (ret == NULL) { - virLibConnError(NULL, VIR_ERR_NO_MEMORY, "Allocating connection"); - goto failed; - } - memset(ret, 0, sizeof(virConnect)); - ret->magic = VIR_CONNECT_MAGIC; - ret->handle = handle; ret->xshandle = xshandle; if (xend_setup(ret) < 0) goto failed; @@ -174,8 +175,7 @@ virConnectOpen(const char *name) return (ret); failed: - if (handle >= 0) - xenHypervisorClose(handle); + xenHypervisorClose(ret); if (xshandle != NULL) xs_daemon_close(xshandle); if (ret != NULL) @@ -197,7 +197,7 @@ virConnectPtr virConnectOpenReadOnly(const char *name) { int method = 0; - int handle; + int res; virConnectPtr ret = NULL; struct xs_handle *xshandle = NULL; @@ -207,16 +207,6 @@ virConnectOpenReadOnly(const char *name) return (NULL); } - handle = xenHypervisorOpen(1); - if (handle >= 0) - method++; - else - handle = -1; - - xshandle = xs_daemon_open_readonly(); - if (xshandle != NULL) - method++; - ret = (virConnectPtr) malloc(sizeof(virConnect)); if (ret == NULL) { virLibConnError(NULL, VIR_ERR_NO_MEMORY, "Allocating connection"); @@ -224,7 +214,15 @@ virConnectOpenReadOnly(const char *name) } memset(ret, 0, sizeof(virConnect)); ret->magic = VIR_CONNECT_MAGIC; - ret->handle = handle; + + res = xenHypervisorOpen(ret, name, VIR_DRV_OPEN_QUIET | VIR_DRV_OPEN_RO); + if (res >= 0) + method++; + + xshandle = xs_daemon_open_readonly(); + if (xshandle != NULL) + method++; + ret->xshandle = xshandle; if (xend_setup(ret) == 0) method++; @@ -240,8 +238,7 @@ virConnectOpenReadOnly(const char *name) return (ret); failed: - if (handle >= 0) - xenHypervisorClose(handle); + xenHypervisorClose(ret); if (xshandle != NULL) xs_daemon_close(xshandle); if (ret != NULL) { @@ -266,6 +263,8 @@ static int virConnectCheckStoreID(virConnectPtr conn, int id) { if (conn->handle >= 0) { + TODO + /* dom0_getdomaininfo_t dominfo; int tmp; @@ -273,6 +272,7 @@ virConnectCheckStoreID(virConnectPtr conn, int id) tmp = xenHypervisorGetDomainInfo(conn->handle, id, &dominfo); if (tmp < 0) return (-1); + */ } return (0); } @@ -313,8 +313,7 @@ virConnectClose(virConnectPtr conn) if (conn->xshandle != NULL) xs_daemon_close(conn->xshandle); conn->xshandle = NULL; - if (conn->handle != -1) - xenHypervisorClose(conn->handle); + xenHypervisorClose(conn); conn->handle = -1; free(conn); return (0); @@ -373,8 +372,7 @@ virConnectGetVersion(virConnectPtr conn, unsigned long *hvVer) return (0); } - ver = xenHypervisorGetVersion(conn->handle); - *hvVer = (ver >> 16) * 1000000 + (ver & 0xFFFF) * 1000; + ver = xenHypervisorGetVersion(conn, hvVer); return (0); } @@ -961,7 +959,7 @@ virDomainDestroy(virDomainPtr domain) return (0); } - ret = xenHypervisorDestroyDomain(domain->conn->handle, domain->handle); + ret = xenHypervisorDestroyDomain(domain); if (ret < 0) return (-1); @@ -1023,8 +1021,7 @@ virDomainSuspend(virDomainPtr domain) return (0); /* then try a direct hypervisor access */ - return (xenHypervisorPauseDomain - (domain->conn->handle, domain->handle)); + return (xenHypervisorPauseDomain(domain)); } /** @@ -1053,8 +1050,7 @@ virDomainResume(virDomainPtr domain) return (0); /* then try a direct hypervisor access */ - return (xenHypervisorResumeDomain - (domain->conn->handle, domain->handle)); + return (xenHypervisorResumeDomain(domain)); } /** @@ -1278,7 +1274,8 @@ virDomainGetID(virDomainPtr domain) * * Get the type of domain operation system. * - * Returns the new string or NULL in case of error + * Returns the new string or NULL in case of error, the string must be + * freed by the caller. */ char * virDomainGetOSType(virDomainPtr domain) @@ -1330,15 +1327,12 @@ virDomainGetMaxMemory(virDomainPtr domain) free(tmp); } } else { - dom0_getdomaininfo_t dominfo; + virDomainInfo dominfo; int tmp; - dominfo.domain = domain->handle; - tmp = - xenHypervisorGetDomainInfo(domain->conn->handle, - domain->handle, &dominfo); + tmp = xenHypervisorGetDomainInfo(domain, &dominfo); if (tmp >= 0) - ret = dominfo.max_pages * 4; + ret = dominfo.maxMem; } return (ret); } @@ -1373,8 +1367,7 @@ virDomainSetMaxMemory(virDomainPtr domain, unsigned long memory) return (-1); if (domain->conn->xshandle == NULL) return (-1); - ret = xenHypervisorSetMaxMemory(domain->conn->handle, domain->handle, - memory); + ret = xenHypervisorSetMaxMemory(domain, memory); if (ret < 0) return (-1); @@ -1429,12 +1422,15 @@ virDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) * if we have direct access though the hypervisor do a direct call */ if (domain->conn->handle >= 0) { + ret = xenHypervisorGetDomainInfo(domain, info); + if (ret < 0) + goto xend_info; + return (0); + /* dom0_getdomaininfo_t dominfo; dominfo.domain = domain->handle; - ret = - xenHypervisorGetDomainInfo(domain->conn->handle, - domain->handle, &dominfo); + ret = xenHypervisorGetDomainInfo(domain, &dominfo); if (ret < 0) goto xend_info; @@ -1458,16 +1454,15 @@ virDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info) 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; return (0); + */ } xend_info: diff --git a/src/xen_internal.c b/src/xen_internal.c index 30d94feb3ee0e7260c5cfa6e5ce0ca302c129399..316aefd4685d1411527c53ee5f1164513b64353b 100644 --- a/src/xen_internal.c +++ b/src/xen_internal.c @@ -31,6 +31,7 @@ typedef struct hypercall_struct { #include "internal.h" +#include "driver.h" #include "xen_internal.h" #define XEN_HYPERVISOR_SOCKET "/proc/xen/privcmd" @@ -58,44 +59,52 @@ virXenError(virErrorNumber error, const char *info, int value) /** * xenHypervisorOpen: - * @quiet: don'r raise an error on failure if set + * @conn: pointer to the connection block + * @name: URL for the target, NULL for local + * @flags: combination of virDrvOpenFlag(s) * * Connects to the Xen hypervisor. * - * Returns the handle or -1 in case of error. + * Returns 0 or -1 in case of error. */ int -xenHypervisorOpen(int quiet) +xenHypervisorOpen(virConnectPtr conn, const char *name, int flags) { int ret; + if ((name != NULL) && (strcmp(name, "xen"))) + return(-1); + + conn->handle = -1; + ret = open(XEN_HYPERVISOR_SOCKET, O_RDWR); if (ret < 0) { - if (!quiet) + if (!(flags & VIR_DRV_OPEN_QUIET)) virXenError(VIR_ERR_NO_XEN, XEN_HYPERVISOR_SOCKET, 0); return (-1); } + conn->handle = ret; return (ret); } /** * xenHypervisorClose: - * @handle: the handle to the Xen hypervisor + * @conn: pointer to the connection block * * Close the connection to the Xen hypervisor. * * Returns 0 in case of success or -1 in case of error. */ int -xenHypervisorClose(int handle) +xenHypervisorClose(virConnectPtr conn) { int ret; - if (handle < 0) + if ((conn == NULL) || (conn->handle < 0)) return (-1); - ret = close(handle); + ret = close(conn->handle); if (ret < 0) return (-1); return (0); @@ -145,41 +154,42 @@ xenHypervisorDoOp(int handle, dom0_op_t * op) /** * xenHypervisorGetVersion: - * @handle: the handle to the Xen hypervisor + * @conn: pointer to the connection block + * @hvVer: where to store the version * * Call the hypervisor to extracts his own internal API version * - * Returns the hypervisor running version or 0 in case of error. + * Returns 0 in case of success, -1 in case of error */ -unsigned long -xenHypervisorGetVersion(int handle) +int +xenHypervisorGetVersion(virConnectPtr conn, unsigned long *hvVer) { int ret; unsigned int cmd; hypercall_t hc; + if ((conn == NULL) || (conn->handle < 0) || (hvVer == NULL)) + return (-1); + *hvVer = 0; + hc.op = __HYPERVISOR_xen_version; hc.arg[0] = (unsigned long) XENVER_version; hc.arg[1] = 0; cmd = _IOC(_IOC_NONE, 'P', 0, sizeof(hc)); - ret = ioctl(handle, cmd, (unsigned long) &hc); + ret = ioctl(conn->handle, cmd, (unsigned long) &hc); if (ret < 0) { virXenError(VIR_ERR_XEN_CALL, " getting version ", XENVER_version); - return (0); + return (-1); } - /* - * use unsigned long in case the version grows behind expectations - * allowed by int - */ - return ((unsigned long) ret); + *hvVer = (ret >> 16) * 1000000 + (ret & 0xFFFF) * 1000; + return(0); } /** * xenHypervisorGetDomainInfo: - * @handle: the handle to the Xen hypervisor - * @domain: the domain ID + * @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. @@ -187,16 +197,18 @@ xenHypervisorGetVersion(int handle) * Returns 0 in case of success, -1 in case of error. */ int -xenHypervisorGetDomainInfo(int handle, int domain, - dom0_getdomaininfo_t * info) +xenHypervisorGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info) { dom0_op_t op; + dom0_getdomaininfo_t dominfo; int ret; - if (info == NULL) + if ((domain == NULL) || (domain->conn == NULL) || + (domain->conn->handle < 0) || (info == NULL)) return (-1); - memset(info, 0, sizeof(dom0_getdomaininfo_t)); + memset(info, 0, sizeof(virDomainInfo)); + memset(&dominfo, 0, sizeof(dom0_getdomaininfo_t)); if (mlock(info, sizeof(dom0_getdomaininfo_t)) < 0) { virXenError(VIR_ERR_XEN_CALL, " locking", @@ -205,13 +217,13 @@ xenHypervisorGetDomainInfo(int handle, int domain, } op.cmd = DOM0_GETDOMAININFOLIST; - op.u.getdomaininfolist.first_domain = (domid_t) domain; + op.u.getdomaininfolist.first_domain = (domid_t) domain->handle; op.u.getdomaininfolist.max_domains = 1; - op.u.getdomaininfolist.buffer = info; + op.u.getdomaininfolist.buffer = &dominfo; op.u.getdomaininfolist.num_domains = 1; - info->domain = domain; + dominfo.domain = domain->handle; - ret = xenHypervisorDoOp(handle, &op); + ret = xenHypervisorDoOp(domain->conn->handle, &op); if (munlock(info, sizeof(dom0_getdomaininfo_t)) < 0) { virXenError(VIR_ERR_XEN_CALL, " release", @@ -221,28 +233,61 @@ xenHypervisorGetDomainInfo(int handle, int domain, if (ret < 0) return (-1); + + 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; return (0); } /** * xenHypervisorPauseDomain: - * @handle: the handle to the Xen hypervisor - * @domain: the domain ID + * @domain: pointer to the domain block * * Do an hypervisor call to pause the given domain * * Returns 0 in case of success, -1 in case of error. */ int -xenHypervisorPauseDomain(int handle, int domain) +xenHypervisorPauseDomain(virDomainPtr domain) { dom0_op_t op; int ret; + if ((domain == NULL) || (domain->conn == NULL) || + (domain->conn->handle < 0)) + return (-1); + op.cmd = DOM0_PAUSEDOMAIN; - op.u.pausedomain.domain = (domid_t) domain; + op.u.pausedomain.domain = (domid_t) domain->handle; - ret = xenHypervisorDoOp(handle, &op); + ret = xenHypervisorDoOp(domain->conn->handle, &op); if (ret < 0) return (-1); @@ -251,23 +296,26 @@ xenHypervisorPauseDomain(int handle, int domain) /** * xenHypervisorResumeDomain: - * @handle: the handle to the Xen hypervisor - * @domain: the domain ID + * @domain: pointer to the domain block * * Do an hypervisor call to resume the given domain * * Returns 0 in case of success, -1 in case of error. */ int -xenHypervisorResumeDomain(int handle, int domain) +xenHypervisorResumeDomain(virDomainPtr domain) { dom0_op_t op; int ret; + if ((domain == NULL) || (domain->conn == NULL) || + (domain->conn->handle < 0)) + return (-1); + op.cmd = DOM0_UNPAUSEDOMAIN; - op.u.unpausedomain.domain = (domid_t) domain; + op.u.unpausedomain.domain = (domid_t) domain->handle; - ret = xenHypervisorDoOp(handle, &op); + ret = xenHypervisorDoOp(domain->conn->handle, &op); if (ret < 0) return (-1); @@ -276,23 +324,26 @@ xenHypervisorResumeDomain(int handle, int domain) /** * xenHypervisorDestroyDomain: - * @handle: the handle to the Xen hypervisor - * @domain: the domain ID + * @domain: pointer to the domain block * * Do an hypervisor call to destroy the given domain * * Returns 0 in case of success, -1 in case of error. */ int -xenHypervisorDestroyDomain(int handle, int domain) +xenHypervisorDestroyDomain(virDomainPtr domain) { dom0_op_t op; int ret; + if ((domain == NULL) || (domain->conn == NULL) || + (domain->conn->handle < 0)) + return (-1); + op.cmd = DOM0_DESTROYDOMAIN; - op.u.destroydomain.domain = (domid_t) domain; + op.u.destroydomain.domain = (domid_t) domain->handle; - ret = xenHypervisorDoOp(handle, &op); + ret = xenHypervisorDoOp(domain->conn->handle, &op); if (ret < 0) return (-1); @@ -301,8 +352,7 @@ xenHypervisorDestroyDomain(int handle, int domain) /** * xenHypervisorSetMaxMemory: - * @handle: the handle to the Xen hypervisor - * @domain: the domain ID + * @domain: pointer to the domain block * @memory: the max memory size in kilobytes. * * Do an hypervisor call to change the maximum amount of memory used @@ -310,16 +360,20 @@ xenHypervisorDestroyDomain(int handle, int domain) * Returns 0 in case of success, -1 in case of error. */ int -xenHypervisorSetMaxMemory(int handle, int domain, unsigned long memory) +xenHypervisorSetMaxMemory(virDomainPtr domain, unsigned long memory) { dom0_op_t op; int ret; + if ((domain == NULL) || (domain->conn == NULL) || + (domain->conn->handle < 0)) + return (-1); + op.cmd = DOM0_SETDOMAINMAXMEM; - op.u.setdomainmaxmem.domain = (domid_t) domain; + op.u.setdomainmaxmem.domain = (domid_t) domain->handle; op.u.setdomainmaxmem.max_memkb = memory; - ret = xenHypervisorDoOp(handle, &op); + ret = xenHypervisorDoOp(domain->conn->handle, &op); if (ret < 0) return (-1); diff --git a/src/xen_internal.h b/src/xen_internal.h index 6ff7d29e022d93c8315a690fa49d2ab77a6f7c41..62c1840971f7a778a23b9f7c6d651cb81ac5ec70 100644 --- a/src/xen_internal.h +++ b/src/xen_internal.h @@ -21,17 +21,19 @@ extern "C" { #endif - int xenHypervisorOpen(int quiet); - int xenHypervisorClose(int handle); - unsigned long xenHypervisorGetVersion(int handle); - int xenHypervisorDestroyDomain(int handle, int domain); - int xenHypervisorResumeDomain(int handle, int domain); - int xenHypervisorPauseDomain(int handle, int domain); - int xenHypervisorGetDomainInfo(int handle, - int domain, - dom0_getdomaininfo_t * info); - int xenHypervisorSetMaxMemory(int handle, - int domain, unsigned long memory); +int xenHypervisorOpen (virConnectPtr conn, + const char *name, + int flags); +int xenHypervisorClose (virConnectPtr conn); +int xenHypervisorGetVersion (virConnectPtr conn, + unsigned long *hvVer); +int xenHypervisorDestroyDomain (virDomainPtr domain); +int xenHypervisorResumeDomain (virDomainPtr domain); +int xenHypervisorPauseDomain (virDomainPtr domain); +int xenHypervisorGetDomainInfo (virDomainPtr domain, + virDomainInfoPtr info); +int xenHypervisorSetMaxMemory (virDomainPtr domain, + unsigned long memory); #ifdef __cplusplus }