NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

Convert Xen domain VCPU driver methods to use virDomainDefPtr

Browse Source 
Introduce use of a virDomainDefPtr in the domain VCPU
APIs to simplify introduction of ACL security checks.
The virDomainPtr cannot be safely used, since the app
may have supplied mis-matching name/uuid/id fields. eg
the name points to domain X, while the uuid points to
domain Y. Resolving the virDomainPtr to a virDomainDefPtr
ensures a consistent name/uuid/id set.

Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
This commit is contained in:
Daniel P. Berrange 2013-05-01 18:37:29 +01:00
parent 18b14012e4
commit 95e18efddd
7 changed files with 152 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
src/xen/xen_driver.c
View File

@ -1199,6 +1199,8 @@ xenUnifiedDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
unsigned int flags) unsigned int flags)
{ {
xenUnifiedPrivatePtr priv = dom->conn->privateData; xenUnifiedPrivatePtr priv = dom->conn->privateData;
virDomainDefPtr def = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_VCPU_LIVE | virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_CONFIG |
@ -1219,13 +1221,20 @@ xenUnifiedDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
return -1; return -1;
} }
if (!(def = xenGetDomainDefForDom(dom)))
goto cleanup;
/* Try non-hypervisor methods first, then hypervisor direct method /* Try non-hypervisor methods first, then hypervisor direct method
* as a last resort. * as a last resort.
*/ */
if (dom->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) if (dom->id < 0 && priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
return xenXMDomainSetVcpusFlags(dom, nvcpus, flags); ret = xenXMDomainSetVcpusFlags(dom->conn, def, nvcpus, flags);
else else
return xenDaemonDomainSetVcpusFlags(dom, nvcpus, flags); ret = xenDaemonDomainSetVcpusFlags(dom->conn, def, nvcpus, flags);
cleanup:
virDomainDefFree(def);
return ret;
} }
static int static int
@ -1248,15 +1257,24 @@ xenUnifiedDomainPinVcpu(virDomainPtr dom, unsigned int vcpu,
unsigned char *cpumap, int maplen) unsigned char *cpumap, int maplen)
{ {
xenUnifiedPrivatePtr priv = dom->conn->privateData; xenUnifiedPrivatePtr priv = dom->conn->privateData;
virDomainDefPtr def = NULL;
int ret = -1;
if (!(def = xenGetDomainDefForDom(dom)))
goto cleanup;
if (dom->id < 0) { if (dom->id < 0) {
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
return xenXMDomainPinVcpu(dom, vcpu, cpumap, maplen); ret = xenXMDomainPinVcpu(dom->conn, def, vcpu, cpumap, maplen);
else else
return xenDaemonDomainPinVcpu(dom, vcpu, cpumap, maplen); ret = xenDaemonDomainPinVcpu(dom->conn, def, vcpu, cpumap, maplen);
} else { } else {
return xenHypervisorPinVcpu(dom, vcpu, cpumap, maplen); ret = xenHypervisorPinVcpu(dom->conn, def, vcpu, cpumap, maplen);
} }
cleanup:
virDomainDefFree(def);
return ret;
} }
static int static int
@ -1265,39 +1283,58 @@ xenUnifiedDomainGetVcpus(virDomainPtr dom,
unsigned char *cpumaps, int maplen) unsigned char *cpumaps, int maplen)
{ {
xenUnifiedPrivatePtr priv = dom->conn->privateData; xenUnifiedPrivatePtr priv = dom->conn->privateData;
virDomainDefPtr def = NULL;
int ret = -1;
if (!(def = xenGetDomainDefForDom(dom)))
goto cleanup;
if (dom->id < 0) { if (dom->id < 0) {
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) { if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Cannot get VCPUs of inactive domain")); _("Cannot get VCPUs of inactive domain"));
return -1; goto cleanup;
} else { } else {
return xenDaemonDomainGetVcpus(dom, info, maxinfo, cpumaps, maplen); ret = xenDaemonDomainGetVcpus(dom->conn, def, info, maxinfo, cpumaps, maplen);
} }
} else { } else {
return xenHypervisorGetVcpus(dom, info, maxinfo, cpumaps, maplen); ret = xenHypervisorGetVcpus(dom->conn, def, info, maxinfo, cpumaps, maplen);
} }
cleanup:
virDomainDefFree(def);
return ret;
} }
static int static int
xenUnifiedDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags) xenUnifiedDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{ {
xenUnifiedPrivatePtr priv = dom->conn->privateData; xenUnifiedPrivatePtr priv = dom->conn->privateData;
virDomainDefPtr def = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_VCPU_LIVE | virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_CONFIG |
VIR_DOMAIN_VCPU_MAXIMUM, -1); VIR_DOMAIN_VCPU_MAXIMUM, -1);
if (!(def = xenGetDomainDefForDom(dom)))
goto cleanup;
if (dom->id < 0) { if (dom->id < 0) {
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
return xenXMDomainGetVcpusFlags(dom, flags); ret = xenXMDomainGetVcpusFlags(dom->conn, def, flags);
else else
return xenDaemonDomainGetVcpusFlags(dom, flags); ret = xenDaemonDomainGetVcpusFlags(dom->conn, def, flags);
} else { } else {
if (flags == (VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_MAXIMUM)) if (flags == (VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_MAXIMUM))
return xenHypervisorGetVcpuMax(dom); ret = xenHypervisorGetVcpuMax(dom->conn, def);
else else
return xenDaemonDomainGetVcpusFlags(dom, flags); ret = xenDaemonDomainGetVcpusFlags(dom->conn, def, flags);
} }
cleanup:
virDomainDefFree(def);
return ret;
} }
static int static int

42
src/xen/xen_hypervisor.c
View File

@ -2931,16 +2931,16 @@ xenHypervisorSetMaxMemory(virConnectPtr conn,
*/ */
int int
xenHypervisorPinVcpu(virDomainPtr domain, unsigned int vcpu, xenHypervisorPinVcpu(virConnectPtr conn,
unsigned char *cpumap, int maplen) virDomainDefPtr def,
unsigned int vcpu,
unsigned char *cpumap,
int maplen)
{ {
int ret; int ret;
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
if (domain->id < 0) ret = virXen_setvcpumap(priv->handle, def->id, vcpu,
return -1;
ret = virXen_setvcpumap(priv->handle, domain->id, vcpu,
cpumap, maplen); cpumap, maplen);
if (ret < 0) if (ret < 0)
return -1; return -1;
@ -2967,7 +2967,8 @@ xenHypervisorPinVcpu(virDomainPtr domain, unsigned int vcpu,
* Returns the number of info filled in case of success, -1 in case of failure. * Returns the number of info filled in case of success, -1 in case of failure.
*/ */
int int
xenHypervisorGetVcpus(virDomainPtr domain, xenHypervisorGetVcpus(virConnectPtr conn,
virDomainDefPtr def,
virVcpuInfoPtr info, virVcpuInfoPtr info,
int maxinfo, int maxinfo,
unsigned char *cpumaps, unsigned char *cpumaps,
@ -2975,22 +2976,22 @@ xenHypervisorGetVcpus(virDomainPtr domain,
{ {
xen_getdomaininfo dominfo; xen_getdomaininfo dominfo;
int ret; int ret;
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
virVcpuInfoPtr ipt; virVcpuInfoPtr ipt;
int nbinfo, i; int nbinfo, i;
if (domain->id < 0 || sizeof(cpumap_t) & 7) { if (sizeof(cpumap_t) & 7) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("domain shut off or invalid")); _("invalid cpumap_t size"));
return -1; return -1;
} }
/* first get the number of virtual CPUs in this domain */ /* first get the number of virtual CPUs in this domain */
XEN_GETDOMAININFO_CLEAR(dominfo); XEN_GETDOMAININFO_CLEAR(dominfo);
ret = virXen_getdomaininfo(priv->handle, domain->id, ret = virXen_getdomaininfo(priv->handle, def->id,
&dominfo); &dominfo);
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id)) { if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != def->id)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot get domain details")); _("cannot get domain details"));
return -1; return -1;
@ -3003,7 +3004,7 @@ xenHypervisorGetVcpus(virDomainPtr domain,
for (i = 0, ipt = info; i < nbinfo; i++, ipt++) { for (i = 0, ipt = info; i < nbinfo; i++, ipt++) {
if ((cpumaps != NULL) && (i < maxinfo)) { if ((cpumaps != NULL) && (i < maxinfo)) {
ret = virXen_getvcpusinfo(priv->handle, domain->id, i, ret = virXen_getvcpusinfo(priv->handle, def->id, i,
ipt, ipt,
(unsigned char *)VIR_GET_CPUMAP(cpumaps, maplen, i), (unsigned char *)VIR_GET_CPUMAP(cpumaps, maplen, i),
maplen); maplen);
@ -3013,7 +3014,7 @@ xenHypervisorGetVcpus(virDomainPtr domain,
return -1; return -1;
} }
} else { } else {
ret = virXen_getvcpusinfo(priv->handle, domain->id, i, ret = virXen_getvcpusinfo(priv->handle, def->id, i,
ipt, NULL, 0); ipt, NULL, 0);
if (ret < 0) { if (ret < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@ -3034,22 +3035,23 @@ xenHypervisorGetVcpus(virDomainPtr domain,
* the maximum number of virtual CPUs the guest was booted with. * the maximum number of virtual CPUs the guest was booted with.
*/ */
int int
xenHypervisorGetVcpuMax(virDomainPtr domain) xenHypervisorGetVcpuMax(virConnectPtr conn,
virDomainDefPtr def)
{ {
xen_getdomaininfo dominfo; xen_getdomaininfo dominfo;
int ret; int ret;
int maxcpu; int maxcpu;
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
/* inactive domain */ /* inactive domain */
if (domain->id < 0) { if (def->id < 0) {
maxcpu = MAX_VIRT_CPUS; maxcpu = MAX_VIRT_CPUS;
} else { } else {
XEN_GETDOMAININFO_CLEAR(dominfo); XEN_GETDOMAININFO_CLEAR(dominfo);
ret = virXen_getdomaininfo(priv->handle, domain->id, ret = virXen_getdomaininfo(priv->handle, def->id,
&dominfo); &dominfo);
if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id)) if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != def->id))
return -1; return -1;
maxcpu = XEN_GETDOMAININFO_MAXCPUID(dominfo) + 1; maxcpu = XEN_GETDOMAININFO_MAXCPUID(dominfo) + 1;
} }

9
src/xen/xen_hypervisor.h
View File

@ -89,18 +89,21 @@ int xenHypervisorSetMaxMemory (virConnectPtr conn,
ATTRIBUTE_NONNULL (1); ATTRIBUTE_NONNULL (1);
int xenHypervisorCheckID (virConnectPtr conn, int xenHypervisorCheckID (virConnectPtr conn,
int id); int id);
int xenHypervisorPinVcpu (virDomainPtr domain, int xenHypervisorPinVcpu (virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpu, unsigned int vcpu,
unsigned char *cpumap, unsigned char *cpumap,
int maplen) int maplen)
ATTRIBUTE_NONNULL (1); ATTRIBUTE_NONNULL (1);
int xenHypervisorGetVcpus (virDomainPtr domain, int xenHypervisorGetVcpus (virConnectPtr conn,
virDomainDefPtr def,
virVcpuInfoPtr info, virVcpuInfoPtr info,
int maxinfo, int maxinfo,
unsigned char *cpumaps, unsigned char *cpumaps,
int maplen) int maplen)
ATTRIBUTE_NONNULL (1); ATTRIBUTE_NONNULL (1);
int xenHypervisorGetVcpuMax (virDomainPtr domain) int xenHypervisorGetVcpuMax (virConnectPtr conn,
virDomainDefPtr def)
ATTRIBUTE_NONNULL (1); ATTRIBUTE_NONNULL (1);
char * xenHypervisorGetSchedulerType (virDomainPtr domain, char * xenHypervisorGetSchedulerType (virDomainPtr domain,

47
src/xen/xend_internal.c
View File

@ -1772,7 +1772,8 @@ xenDaemonNodeGetTopology(virConnectPtr conn, virCapsPtr caps)
/** /**
* xenDaemonDomainSetVcpusFlags: * xenDaemonDomainSetVcpusFlags:
* @domain: pointer to domain object * @conn: the connection object
* @def: domain configuration
* @nvcpus: the new number of virtual CPUs for this domain * @nvcpus: the new number of virtual CPUs for this domain
* @flags: bitwise-ORd from virDomainVcpuFlags * @flags: bitwise-ORd from virDomainVcpuFlags
* *
@ -1781,7 +1782,8 @@ xenDaemonNodeGetTopology(virConnectPtr conn, virCapsPtr caps)
* Returns 0 on success, -1 if an error message was issued * Returns 0 on success, -1 if an error message was issued
*/ */
int int
xenDaemonDomainSetVcpusFlags(virDomainPtr domain, xenDaemonDomainSetVcpusFlags(virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpus, unsigned int vcpus,
unsigned int flags) unsigned int flags)
{ {
@ -1797,7 +1799,7 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
return -1; return -1;
} }
if (domain->id < 0) { if (def->id < 0) {
if (flags & VIR_DOMAIN_VCPU_LIVE) { if (flags & VIR_DOMAIN_VCPU_LIVE) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s", virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain not running")); _("domain not running"));
@ -1815,7 +1817,7 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
/* Unfortunately, xend_op does not validate whether this exceeds /* Unfortunately, xend_op does not validate whether this exceeds
* the maximum. */ * the maximum. */
flags |= VIR_DOMAIN_VCPU_MAXIMUM; flags |= VIR_DOMAIN_VCPU_MAXIMUM;
if ((max = xenDaemonDomainGetVcpusFlags(domain, flags)) < 0) { if ((max = xenDaemonDomainGetVcpusFlags(conn, def, flags)) < 0) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s", virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("could not determine max vcpus for the domain")); _("could not determine max vcpus for the domain"));
return -1; return -1;
@ -1828,13 +1830,14 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
} }
snprintf(buf, sizeof(buf), "%d", vcpus); snprintf(buf, sizeof(buf), "%d", vcpus);
return xend_op(domain->conn, domain->name, "op", "set_vcpus", "vcpus", return xend_op(conn, def->name, "op", "set_vcpus", "vcpus",
buf, NULL); buf, NULL);
} }
/** /**
* xenDaemonDomainPinCpu: * xenDaemonDomainPinCpu:
* @domain: pointer to domain object * @conn: the connection object
* @minidef: minimal domain configuration
* @vcpu: virtual CPU number * @vcpu: virtual CPU number
* @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes)
* @maplen: length of cpumap in bytes * @maplen: length of cpumap in bytes
@ -1849,14 +1852,15 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
* Returns 0 for success; -1 (with errno) on error * Returns 0 for success; -1 (with errno) on error
*/ */
int int
xenDaemonDomainPinVcpu(virDomainPtr domain, xenDaemonDomainPinVcpu(virConnectPtr conn,
virDomainDefPtr minidef,
unsigned int vcpu, unsigned int vcpu,
unsigned char *cpumap, unsigned char *cpumap,
int maplen) int maplen)
{ {
char buf[VIR_UUID_BUFLEN], mapstr[sizeof(cpumap_t) * 64]; char buf[VIR_UUID_BUFLEN], mapstr[sizeof(cpumap_t) * 64];
int i, j, ret; int i, j, ret;
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
virDomainDefPtr def = NULL; virDomainDefPtr def = NULL;
if (maplen > (int)sizeof(cpumap_t)) { if (maplen > (int)sizeof(cpumap_t)) {
@ -1884,12 +1888,12 @@ xenDaemonDomainPinVcpu(virDomainPtr domain,
snprintf(buf, sizeof(buf), "%d", vcpu); snprintf(buf, sizeof(buf), "%d", vcpu);
ret = xend_op(domain->conn, domain->name, "op", "pincpu", "vcpu", buf, ret = xend_op(conn, minidef->name, "op", "pincpu", "vcpu", buf,
"cpumap", mapstr, NULL); "cpumap", mapstr, NULL);
if (!(def = xenDaemonDomainFetch(domain->conn, if (!(def = xenDaemonDomainFetch(conn,
domain->id, minidef->id,
domain->name, minidef->name,
NULL))) NULL)))
goto cleanup; goto cleanup;
@ -1921,7 +1925,8 @@ cleanup:
/** /**
* xenDaemonDomainGetVcpusFlags: * xenDaemonDomainGetVcpusFlags:
* @domain: pointer to domain object * @conn: the connection object
* @def: domain configuration
* @flags: bitwise-ORd from virDomainVcpuFlags * @flags: bitwise-ORd from virDomainVcpuFlags
* *
* Extract information about virtual CPUs of domain according to flags. * Extract information about virtual CPUs of domain according to flags.
@ -1931,7 +1936,9 @@ cleanup:
*/ */
int int
xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags) xenDaemonDomainGetVcpusFlags(virConnectPtr conn,
virDomainDefPtr def,
unsigned int flags)
{ {
struct sexpr *root; struct sexpr *root;
int ret; int ret;
@ -1940,13 +1947,13 @@ xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_CONFIG |
VIR_DOMAIN_VCPU_MAXIMUM, -1); VIR_DOMAIN_VCPU_MAXIMUM, -1);
if (domain->id < 0 && (flags & VIR_DOMAIN_VCPU_LIVE)) { if (def->id < 0 && (flags & VIR_DOMAIN_VCPU_LIVE)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s", virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain not active")); _("domain not active"));
return -1; return -1;
} }
root = sexpr_get(domain->conn, "/xend/domain/%s?detail=1", domain->name); root = sexpr_get(conn, "/xend/domain/%s?detail=1", def->name);
if (root == NULL) if (root == NULL)
return -1; return -1;
@ -1964,7 +1971,8 @@ xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
/** /**
* virDomainGetVcpus: * virDomainGetVcpus:
* @domain: pointer to domain object, or NULL for Domain0 * @conn: the connection object
* @def: domain configuration
* @info: pointer to an array of virVcpuInfo structures (OUT) * @info: pointer to an array of virVcpuInfo structures (OUT)
* @maxinfo: number of structures in info array * @maxinfo: number of structures in info array
* @cpumaps: pointer to a bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT) * @cpumaps: pointer to a bit map of real CPUs for all vcpus of this domain (in 8-bit bytes) (OUT)
@ -1982,7 +1990,8 @@ xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
* Returns the number of info filled in case of success, -1 in case of failure. * Returns the number of info filled in case of success, -1 in case of failure.
*/ */
int int
xenDaemonDomainGetVcpus(virDomainPtr domain, xenDaemonDomainGetVcpus(virConnectPtr conn,
virDomainDefPtr def,
virVcpuInfoPtr info, virVcpuInfoPtr info,
int maxinfo, int maxinfo,
unsigned char *cpumaps, unsigned char *cpumaps,
@ -1994,7 +2003,7 @@ xenDaemonDomainGetVcpus(virDomainPtr domain,
unsigned char *cpumap; unsigned char *cpumap;
int vcpu, cpu; int vcpu, cpu;
root = sexpr_get(domain->conn, "/xend/domain/%s?op=vcpuinfo", domain->name); root = sexpr_get(conn, "/xend/domain/%s?op=vcpuinfo", def->name);
if (root == NULL) if (root == NULL)
return -1; return -1;

15
src/xen/xend_internal.h
View File

@ -147,18 +147,23 @@ int xenDaemonDomainCreate(virConnectPtr conn,
int xenDaemonDomainUndefine(virConnectPtr conn, int xenDaemonDomainUndefine(virConnectPtr conn,
virDomainDefPtr def); virDomainDefPtr def);
int xenDaemonDomainSetVcpus (virDomainPtr domain, int xenDaemonDomainSetVcpus (virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpus); unsigned int vcpus);
int xenDaemonDomainSetVcpusFlags (virDomainPtr domain, int xenDaemonDomainSetVcpusFlags (virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpus, unsigned int vcpus,
unsigned int flags); unsigned int flags);
int xenDaemonDomainPinVcpu (virDomainPtr domain, int xenDaemonDomainPinVcpu (virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpu, unsigned int vcpu,
unsigned char *cpumap, unsigned char *cpumap,
int maplen); int maplen);
int xenDaemonDomainGetVcpusFlags (virDomainPtr domain, int xenDaemonDomainGetVcpusFlags (virConnectPtr conn,
virDomainDefPtr def,
unsigned int flags); unsigned int flags);
int xenDaemonDomainGetVcpus (virDomainPtr domain, int xenDaemonDomainGetVcpus (virConnectPtr conn,
virDomainDefPtr def,
virVcpuInfoPtr info, virVcpuInfoPtr info,
int maxinfo, int maxinfo,
unsigned char *cpumaps, unsigned char *cpumaps,

39
src/xen/xm_internal.c
View File

@ -648,7 +648,8 @@ cleanup:
/* /*
* xenXMDomainSetVcpusFlags: * xenXMDomainSetVcpusFlags:
* @domain: pointer to domain object * @conn: the connection object
* @def: domain configuration
* @nvcpus: number of vcpus * @nvcpus: number of vcpus
* @flags: bitwise-ORd from virDomainVcpuFlags * @flags: bitwise-ORd from virDomainVcpuFlags
* *
@ -657,11 +658,12 @@ cleanup:
* Returns 0 on success, -1 if an error message was issued * Returns 0 on success, -1 if an error message was issued
*/ */
int int
xenXMDomainSetVcpusFlags(virDomainPtr domain, xenXMDomainSetVcpusFlags(virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpus, unsigned int vcpus,
unsigned int flags) unsigned int flags)
{ {
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
const char *filename; const char *filename;
xenXMConfCachePtr entry; xenXMConfCachePtr entry;
int ret = -1; int ret = -1;
@ -679,14 +681,14 @@ xenXMDomainSetVcpusFlags(virDomainPtr domain,
xenUnifiedLock(priv); xenUnifiedLock(priv);
if (!(filename = virHashLookup(priv->nameConfigMap, domain->name))) if (!(filename = virHashLookup(priv->nameConfigMap, def->name)))
goto cleanup; goto cleanup;
if (!(entry = virHashLookup(priv->configCache, filename))) if (!(entry = virHashLookup(priv->configCache, filename)))
goto cleanup; goto cleanup;
/* Hypervisor maximum. */ /* Hypervisor maximum. */
if ((max = xenUnifiedConnectGetMaxVcpus(domain->conn, NULL)) < 0) { if ((max = xenUnifiedConnectGetMaxVcpus(conn, NULL)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("could not determine max vcpus for the domain")); _("could not determine max vcpus for the domain"));
goto cleanup; goto cleanup;
@ -713,7 +715,7 @@ xenXMDomainSetVcpusFlags(virDomainPtr domain,
/* If this fails, should we try to undo our changes to the /* If this fails, should we try to undo our changes to the
* in-memory representation of the config file. I say not! * in-memory representation of the config file. I say not!
*/ */
if (xenXMConfigSaveFile(domain->conn, entry->filename, entry->def) < 0) if (xenXMConfigSaveFile(conn, entry->filename, entry->def) < 0)
goto cleanup; goto cleanup;
ret = 0; ret = 0;
@ -724,7 +726,8 @@ cleanup:
/** /**
* xenXMDomainGetVcpusFlags: * xenXMDomainGetVcpusFlags:
* @domain: pointer to domain object * @conn: the connection object
* @def: domain configuration
* @flags: bitwise-ORd from virDomainVcpuFlags * @flags: bitwise-ORd from virDomainVcpuFlags
* *
* Extract information about virtual CPUs of domain according to flags. * Extract information about virtual CPUs of domain according to flags.
@ -733,12 +736,14 @@ cleanup:
* issued * issued
*/ */
int int
xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags) xenXMDomainGetVcpusFlags(virConnectPtr conn,
virDomainDefPtr def,
unsigned int flags)
{ {
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
const char *filename; const char *filename;
xenXMConfCachePtr entry; xenXMConfCachePtr entry;
int ret = -2; int ret = -1;
virCheckFlags(VIR_DOMAIN_VCPU_LIVE | virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_CONFIG |
@ -751,7 +756,7 @@ xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
xenUnifiedLock(priv); xenUnifiedLock(priv);
if (!(filename = virHashLookup(priv->nameConfigMap, domain->name))) if (!(filename = virHashLookup(priv->nameConfigMap, def->name)))
goto cleanup; goto cleanup;
if (!(entry = virHashLookup(priv->configCache, filename))) if (!(entry = virHashLookup(priv->configCache, filename)))
@ -767,7 +772,8 @@ cleanup:
/** /**
* xenXMDomainPinVcpu: * xenXMDomainPinVcpu:
* @domain: pointer to domain object * @conn: the connection object
* @def: domain configuration
* @vcpu: virtual CPU number (reserved) * @vcpu: virtual CPU number (reserved)
* @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes) * @cpumap: pointer to a bit map of real CPUs (in 8-bit bytes)
* @maplen: length of cpumap in bytes * @maplen: length of cpumap in bytes
@ -777,12 +783,13 @@ cleanup:
* Returns 0 for success; -1 (with errno) on error * Returns 0 for success; -1 (with errno) on error
*/ */
int int
xenXMDomainPinVcpu(virDomainPtr domain, xenXMDomainPinVcpu(virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpu ATTRIBUTE_UNUSED, unsigned int vcpu ATTRIBUTE_UNUSED,
unsigned char *cpumap, unsigned char *cpumap,
int maplen) int maplen)
{ {
xenUnifiedPrivatePtr priv = domain->conn->privateData; xenUnifiedPrivatePtr priv = conn->privateData;
const char *filename; const char *filename;
xenXMConfCachePtr entry; xenXMConfCachePtr entry;
int ret = -1; int ret = -1;
@ -794,7 +801,7 @@ xenXMDomainPinVcpu(virDomainPtr domain,
xenUnifiedLock(priv); xenUnifiedLock(priv);
if (!(filename = virHashLookup(priv->nameConfigMap, domain->name))) { if (!(filename = virHashLookup(priv->nameConfigMap, def->name))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("virHashLookup")); virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("virHashLookup"));
goto cleanup; goto cleanup;
} }
@ -808,7 +815,7 @@ xenXMDomainPinVcpu(virDomainPtr domain,
entry->def->cpumask = virBitmapNewData(cpumap, maplen); entry->def->cpumask = virBitmapNewData(cpumap, maplen);
if (!entry->def->cpumask) if (!entry->def->cpumask)
goto cleanup; goto cleanup;
if (xenXMConfigSaveFile(domain->conn, entry->filename, entry->def) < 0) if (xenXMConfigSaveFile(conn, entry->filename, entry->def) < 0)
goto cleanup; goto cleanup;
ret = 0; ret = 0;

19
src/xen/xm_internal.h
View File

@ -54,12 +54,21 @@ int xenXMDomainSetMaxMemory(virConnectPtr conn,
unsigned long memory); unsigned long memory);
unsigned long long xenXMDomainGetMaxMemory(virConnectPtr conn, unsigned long long xenXMDomainGetMaxMemory(virConnectPtr conn,
virDomainDefPtr def); virDomainDefPtr def);
int xenXMDomainSetVcpus(virDomainPtr domain, unsigned int vcpus); int xenXMDomainSetVcpus(virConnectPtr conn,
int xenXMDomainSetVcpusFlags(virDomainPtr domain, unsigned int vcpus, virDomainDefPtr def,
unsigned int vcpus);
int xenXMDomainSetVcpusFlags(virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpus,
unsigned int flags); unsigned int flags);
int xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags); int xenXMDomainGetVcpusFlags(virConnectPtr conn,
int xenXMDomainPinVcpu(virDomainPtr domain, unsigned int vcpu, virDomainDefPtr def,
unsigned char *cpumap, int maplen); unsigned int flags);
int xenXMDomainPinVcpu(virConnectPtr conn,
virDomainDefPtr def,
unsigned int vcpu,
unsigned char *cpumap,
int maplen);
virDomainDefPtr xenXMDomainLookupByName(virConnectPtr conn, const char *domname); virDomainDefPtr xenXMDomainLookupByName(virConnectPtr conn, const char *domname);
virDomainDefPtr xenXMDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid); virDomainDefPtr xenXMDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid);