[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [libvirt] [PATCH 06/11] Convert Xen domain VCPU driver methods to use virDomainDefPtr



Daniel P. Berrange wrote:
> From: "Daniel P. Berrange" <berrange redhat com>
>
> 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>
> ---
>  src/xen/xen_driver.c     | 84 ++++++++++++++++++++++++++++++++++++++++--------
>  src/xen/xen_hypervisor.c | 42 ++++++++++++------------
>  src/xen/xen_hypervisor.h |  9 ++++--
>  src/xen/xend_internal.c  | 81 ++++++++++++++++++++++++++--------------------
>  src/xen/xend_internal.h  | 17 ++++++----
>  src/xen/xm_internal.c    | 30 +++++++++--------
>  src/xen/xm_internal.h    | 19 ++++++++---
>  7 files changed, 187 insertions(+), 95 deletions(-)
>
> diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
> index 8b7dec9..04cb69d 100644
> --- a/src/xen/xen_driver.c
> +++ b/src/xen/xen_driver.c
> @@ -647,11 +647,30 @@ xenUnifiedConnectNumOfDomains(virConnectPtr conn)
>  
>  static virDomainPtr
>  xenUnifiedDomainCreateXML(virConnectPtr conn,
> -                          const char *xmlDesc, unsigned int flags)
> +                          const char *xml,
> +                          unsigned int flags)
>  {
> +    xenUnifiedPrivatePtr priv = conn->privateData;
> +    virDomainDefPtr def = NULL;
> +    virDomainPtr ret = NULL;
> +
>      virCheckFlags(0, NULL);
>  
> -    return xenDaemonCreateXML(conn, xmlDesc);
> +    if (!(def = virDomainDefParseString(xml, priv->caps, priv->xmlopt,
> +                                        1 << VIR_DOMAIN_VIRT_XEN,
> +                                        VIR_DOMAIN_XML_INACTIVE)))
> +        goto cleanup;
> +
> +    if (xenDaemonCreateXML(conn, def) < 0)
> +        goto cleanup;
> +
> +    ret = virGetDomain(conn, def->name, def->uuid);
> +    if (ret)
> +        ret->id = def->id;
> +
> +cleanup:
> +    virDomainDefFree(def);
> +    return ret;
>  }
>   

Should this hunk be in patch 2? Or perhaps it was meant for patch 5?

>  
>  static virDomainPtr
> @@ -1182,6 +1201,8 @@ xenUnifiedDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
>                                unsigned int flags)
>  {
>      xenUnifiedPrivatePtr priv = dom->conn->privateData;
> +    virDomainDefPtr def = NULL;
> +    int ret = -1;
>  
>      virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
>                    VIR_DOMAIN_VCPU_CONFIG |
> @@ -1202,13 +1223,20 @@ xenUnifiedDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
>          return -1;
>      }
>  
> +    if (!(def = xenGetDomainDefForDom(dom)))
> +        goto cleanup;
> +
>      /* Try non-hypervisor methods first, then hypervisor direct method
>       * as a last resort.
>       */
>      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
> -        return xenDaemonDomainSetVcpusFlags(dom, nvcpus, flags);
> +        ret = xenDaemonDomainSetVcpusFlags(dom->conn, def, nvcpus, flags);
> +
> +cleanup:
> +    virDomainDefFree(def);
> +    return ret;
>  }
>  
>  static int
> @@ -1231,15 +1259,24 @@ xenUnifiedDomainPinVcpu(virDomainPtr dom, unsigned int vcpu,
>                          unsigned char *cpumap, int maplen)
>  {
>      xenUnifiedPrivatePtr priv = dom->conn->privateData;
> +    virDomainDefPtr def = NULL;
> +    int ret = -1;
> +
> +    if (!(def = xenGetDomainDefForDom(dom)))
> +        goto cleanup;
>  
>      if (dom->id < 0) {
>          if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
> -            return xenXMDomainPinVcpu(dom, vcpu, cpumap, maplen);
> +            ret = xenXMDomainPinVcpu(dom->conn, def, vcpu, cpumap, maplen);
>          else
> -            return xenDaemonDomainPinVcpu(dom, vcpu, cpumap, maplen);
> +            ret = xenDaemonDomainPinVcpu(dom->conn, def, vcpu, cpumap, maplen);
>      } else {
> -        return xenHypervisorPinVcpu(dom, vcpu, cpumap, maplen);
> +        ret = xenHypervisorPinVcpu(dom->conn, def, vcpu, cpumap, maplen);
>      }
> +
> +cleanup:
> +    virDomainDefFree(def);
> +    return ret;
>  }
>  
>  static int
> @@ -1248,39 +1285,58 @@ xenUnifiedDomainGetVcpus(virDomainPtr dom,
>                           unsigned char *cpumaps, int maplen)
>  {
>      xenUnifiedPrivatePtr priv = dom->conn->privateData;
> +    virDomainDefPtr def = NULL;
> +    int ret = -1;
> +
> +    if (!(def = xenGetDomainDefForDom(dom)))
> +        goto cleanup;
> +
>      if (dom->id < 0) {
>          if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4) {
>              virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
>                             _("Cannot get VCPUs of inactive domain"));
> -            return -1;
> +            goto cleanup;
>          } else {
> -            return xenDaemonDomainGetVcpus(dom, info, maxinfo, cpumaps, maplen);
> +            ret = xenDaemonDomainGetVcpus(dom->conn, def, info, maxinfo, cpumaps, maplen);
>          }
>      } else {
> -        return xenHypervisorGetVcpus(dom, info, maxinfo, cpumaps, maplen);
> +        ret = xenHypervisorGetVcpus(dom->conn, def, info, maxinfo, cpumaps, maplen);
>      }
> +
> +cleanup:
> +    virDomainDefFree(def);
> +    return ret;
>  }
>  
>  static int
>  xenUnifiedDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
>  {
>      xenUnifiedPrivatePtr priv = dom->conn->privateData;
> +    virDomainDefPtr def = NULL;
> +    int ret = -1;
>  
>      virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
>                    VIR_DOMAIN_VCPU_CONFIG |
>                    VIR_DOMAIN_VCPU_MAXIMUM, -1);
>  
> +    if (!(def = xenGetDomainDefForDom(dom)))
> +        goto cleanup;
> +
>      if (dom->id < 0) {
>          if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
> -            return xenXMDomainGetVcpusFlags(dom, flags);
> +            ret = xenXMDomainGetVcpusFlags(dom->conn, def, flags);
>          else
> -            return xenDaemonDomainGetVcpusFlags(dom, flags);
> +            ret = xenDaemonDomainGetVcpusFlags(dom->conn, def, flags);
>      } else {
>          if (flags == (VIR_DOMAIN_VCPU_CONFIG | VIR_DOMAIN_VCPU_MAXIMUM))
> -            return xenHypervisorGetVcpuMax(dom);
> +            ret = xenHypervisorGetVcpuMax(dom->conn, def);
>          else
> -            return xenDaemonDomainGetVcpusFlags(dom, flags);
> +            ret = xenDaemonDomainGetVcpusFlags(dom->conn, def, flags);
>      }
> +
> +cleanup:
> +    virDomainDefFree(def);
> +    return ret;
>  }
>  
>  static int
> diff --git a/src/xen/xen_hypervisor.c b/src/xen/xen_hypervisor.c
> index 423ce85..b97b329 100644
> --- a/src/xen/xen_hypervisor.c
> +++ b/src/xen/xen_hypervisor.c
> @@ -2931,16 +2931,16 @@ xenHypervisorSetMaxMemory(virConnectPtr conn,
>   */
>  
>  int
> -xenHypervisorPinVcpu(virDomainPtr domain, unsigned int vcpu,
> -                     unsigned char *cpumap, int maplen)
> +xenHypervisorPinVcpu(virConnectPtr conn,
> +                     virDomainDefPtr def,
> +                     unsigned int vcpu,
> +                     unsigned char *cpumap,
> +                     int maplen)
>  {
>      int ret;
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> -
> -    if (domain->id < 0)
> -        return -1;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>  
> -    ret = virXen_setvcpumap(priv->handle, domain->id, vcpu,
> +    ret = virXen_setvcpumap(priv->handle, def->id, vcpu,
>                              cpumap, maplen);
>      if (ret < 0)
>          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.
>   */
>  int
> -xenHypervisorGetVcpus(virDomainPtr domain,
> +xenHypervisorGetVcpus(virConnectPtr conn,
> +                      virDomainDefPtr def,
>                        virVcpuInfoPtr info,
>                        int maxinfo,
>                        unsigned char *cpumaps,
> @@ -2975,22 +2976,22 @@ xenHypervisorGetVcpus(virDomainPtr domain,
>  {
>      xen_getdomaininfo dominfo;
>      int ret;
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>      virVcpuInfoPtr ipt;
>      int nbinfo, i;
>  
> -    if (domain->id < 0 || sizeof(cpumap_t) & 7) {
> +    if (sizeof(cpumap_t) & 7) {
>          virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
> -                       _("domain shut off or invalid"));
> +                       _("invalid cpumap_t size"));
>          return -1;
>      }
>  
>      /* first get the number of virtual CPUs in this domain */
>      XEN_GETDOMAININFO_CLEAR(dominfo);
> -    ret = virXen_getdomaininfo(priv->handle, domain->id,
> +    ret = virXen_getdomaininfo(priv->handle, def->id,
>                                 &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",
>                         _("cannot get domain details"));
>          return -1;
> @@ -3003,7 +3004,7 @@ xenHypervisorGetVcpus(virDomainPtr domain,
>  
>      for (i = 0, ipt = info; i < nbinfo; i++, ipt++) {
>          if ((cpumaps != NULL) && (i < maxinfo)) {
> -            ret = virXen_getvcpusinfo(priv->handle, domain->id, i,
> +            ret = virXen_getvcpusinfo(priv->handle, def->id, i,
>                                        ipt,
>                                        (unsigned char *)VIR_GET_CPUMAP(cpumaps, maplen, i),
>                                        maplen);
> @@ -3013,7 +3014,7 @@ xenHypervisorGetVcpus(virDomainPtr domain,
>                  return -1;
>              }
>          } else {
> -            ret = virXen_getvcpusinfo(priv->handle, domain->id, i,
> +            ret = virXen_getvcpusinfo(priv->handle, def->id, i,
>                                        ipt, NULL, 0);
>              if (ret < 0) {
>                  virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
> @@ -3034,22 +3035,23 @@ xenHypervisorGetVcpus(virDomainPtr domain,
>   *  the maximum number of virtual CPUs the guest was booted with.
>   */
>  int
> -xenHypervisorGetVcpuMax(virDomainPtr domain)
> +xenHypervisorGetVcpuMax(virConnectPtr conn,
> +                        virDomainDefPtr def)
>   

Fits on one line.

>  {
>      xen_getdomaininfo dominfo;
>      int ret;
>      int maxcpu;
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>  
>      /* inactive domain */
> -    if (domain->id < 0) {
> +    if (def->id < 0) {
>          maxcpu = MAX_VIRT_CPUS;
>      } else {
>          XEN_GETDOMAININFO_CLEAR(dominfo);
> -        ret = virXen_getdomaininfo(priv->handle, domain->id,
> +        ret = virXen_getdomaininfo(priv->handle, def->id,
>                                     &dominfo);
>  
> -        if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != domain->id))
> +        if ((ret < 0) || (XEN_GETDOMAININFO_DOMAIN(dominfo) != def->id))
>              return -1;
>          maxcpu = XEN_GETDOMAININFO_MAXCPUID(dominfo) + 1;
>      }
> diff --git a/src/xen/xen_hypervisor.h b/src/xen/xen_hypervisor.h
> index 9ee1f13..1cf1e14 100644
> --- a/src/xen/xen_hypervisor.h
> +++ b/src/xen/xen_hypervisor.h
> @@ -89,18 +89,21 @@ int     xenHypervisorSetMaxMemory       (virConnectPtr conn,
>            ATTRIBUTE_NONNULL (1);
>  int     xenHypervisorCheckID            (virConnectPtr conn,
>                                           int id);
> -int     xenHypervisorPinVcpu            (virDomainPtr domain,
> +int     xenHypervisorPinVcpu            (virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           unsigned int vcpu,
>                                           unsigned char *cpumap,
>                                           int maplen)
>            ATTRIBUTE_NONNULL (1);
> -int     xenHypervisorGetVcpus           (virDomainPtr domain,
> +int     xenHypervisorGetVcpus           (virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           virVcpuInfoPtr info,
>                                           int maxinfo,
>                                           unsigned char *cpumaps,
>                                           int maplen)
>            ATTRIBUTE_NONNULL (1);
> -int     xenHypervisorGetVcpuMax         (virDomainPtr domain)
> +int     xenHypervisorGetVcpuMax         (virConnectPtr conn,
> +                                         virDomainDefPtr def)
>            ATTRIBUTE_NONNULL (1);
>  
>  char *  xenHypervisorGetSchedulerType   (virDomainPtr domain,
> diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c
> index 77c4dec..75c980c 100644
> --- a/src/xen/xend_internal.c
> +++ b/src/xen/xend_internal.c
> @@ -1772,7 +1772,8 @@ xenDaemonNodeGetTopology(virConnectPtr conn, virCapsPtr caps)
>   * Returns 0 on success, -1 if an error message was issued
>   */
>  int
> -xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
> +xenDaemonDomainSetVcpusFlags(virConnectPtr conn,
> +                             virDomainDefPtr def,
>   

Comments need updated.

>                               unsigned int vcpus,
>                               unsigned int flags)
>  {
> @@ -1788,7 +1789,7 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
>          return -1;
>      }
>  
> -    if (domain->id < 0) {
> +    if (def->id < 0) {
>          if (flags & VIR_DOMAIN_VCPU_LIVE) {
>              virReportError(VIR_ERR_OPERATION_INVALID, "%s",
>                             _("domain not running"));
> @@ -1806,7 +1807,7 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
>      /* Unfortunately, xend_op does not validate whether this exceeds
>       * the 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",
>                         _("could not determine max vcpus for the domain"));
>          return -1;
> @@ -1819,7 +1820,7 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
>      }
>  
>      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);
>  }
>  
> @@ -1840,14 +1841,15 @@ xenDaemonDomainSetVcpusFlags(virDomainPtr domain,
>   * Returns 0 for success; -1 (with errno) on error
>   */
>  int
> -xenDaemonDomainPinVcpu(virDomainPtr domain,
> +xenDaemonDomainPinVcpu(virConnectPtr conn,
> +                       virDomainDefPtr minidef,
>   

Same here, comments for the function need updated.

>                         unsigned int vcpu,
>                         unsigned char *cpumap,
>                         int maplen)
>  {
>      char buf[VIR_UUID_BUFLEN], mapstr[sizeof(cpumap_t) * 64];
>      int i, j, ret;
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>      virDomainDefPtr def = NULL;
>  
>      if (maplen > (int)sizeof(cpumap_t)) {
> @@ -1875,12 +1877,12 @@ xenDaemonDomainPinVcpu(virDomainPtr domain,
>  
>      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);
>  
> -    if (!(def = xenDaemonDomainFetch(domain->conn,
> -                                     domain->id,
> -                                     domain->name,
> +    if (!(def = xenDaemonDomainFetch(conn,
> +                                     minidef->id,
> +                                     minidef->name,
>                                       NULL)))
>          goto cleanup;
>  
> @@ -1922,7 +1924,9 @@ cleanup:
>  
>   */
>  int
> -xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
> +xenDaemonDomainGetVcpusFlags(virConnectPtr conn,
> +                             virDomainDefPtr def,
> +                             unsigned int flags)
>   

Comments need updated here too.

>  {
>      struct sexpr *root;
>      int ret;
> @@ -1931,13 +1935,13 @@ xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
>                    VIR_DOMAIN_VCPU_CONFIG |
>                    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",
>                         _("domain not active"));
>          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)
>          return -1;
>  
> @@ -1973,7 +1977,8 @@ xenDaemonDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
>   * Returns the number of info filled in case of success, -1 in case of failure.
>   */
>  int
> -xenDaemonDomainGetVcpus(virDomainPtr domain,
> +xenDaemonDomainGetVcpus(virConnectPtr conn,
> +                        virDomainDefPtr def,
>   

Same here.

>                          virVcpuInfoPtr info,
>                          int maxinfo,
>                          unsigned char *cpumaps,
> @@ -1985,7 +1990,7 @@ xenDaemonDomainGetVcpus(virDomainPtr domain,
>      unsigned char *cpumap;
>      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)
>          return -1;
>  
> @@ -2128,25 +2133,25 @@ xenDaemonLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
>   *
>   * Returns a new domain object or NULL in case of failure
>   */
> -virDomainPtr
> -xenDaemonCreateXML(virConnectPtr conn, const char *xmlDesc)
> +int
> +xenDaemonCreateXML(virConnectPtr conn, virDomainDefPtr def)
>  {
>   

Comments need updated here to, but again not sure if these last hunks
were intended for a previous patch.

>      int ret;
>      char *sexpr;
> -    virDomainPtr dom = NULL;
> +    const char *tmp;
> +    struct sexpr *root;
>      xenUnifiedPrivatePtr priv = conn->privateData;
> -    virDomainDefPtr def;
>  
> -    if (!(def = virDomainDefParseString(xmlDesc, priv->caps, priv->xmlopt,
> -                                        1 << VIR_DOMAIN_VIRT_XEN,
> -                                        VIR_DOMAIN_XML_INACTIVE)))
> -        return NULL;
> -
> -    if (!(sexpr = xenFormatSxpr(conn, def, priv->xendConfigVersion))) {
> -        virDomainDefFree(def);
> -        return NULL;
> +    if (def->id != -1) {
> +        virReportError(VIR_ERR_OPERATION_INVALID,
> +                       _("Domain %s is already running"),
> +                       def->name);
> +        return -1;
>      }
>  
> +    if (!(sexpr = xenFormatSxpr(conn, def, priv->xendConfigVersion)))
> +        return -1;
> +
>      ret = xenDaemonDomainCreateXML(conn, sexpr);
>      VIR_FREE(sexpr);
>      if (ret != 0) {
> @@ -2155,8 +2160,19 @@ xenDaemonCreateXML(virConnectPtr conn, const char *xmlDesc)
>  
>      /* This comes before wait_for_devices, to ensure that latter
>         cleanup will destroy the domain upon failure */
> -    if (!(dom = virDomainLookupByName(conn, def->name)))
> +    root = sexpr_get(conn, "/xend/domain/%s?detail=1", def->name);
> +    if (root == NULL)
> +        goto error;
> +
> +    tmp = sexpr_node(root, "domain/domid");
> +    if (!tmp) {
> +        virReportError(VIR_ERR_INTERNAL_ERROR,
> +                       _("Domain %s did not start"),
> +                       def->name);
>          goto error;
> +    }
> +    if (tmp)
> +        def->id = sexpr_int(root, "domain/domid");
>  
>      if (xend_wait_for_devices(conn, def->name) < 0)
>          goto error;
> @@ -2165,16 +2181,13 @@ xenDaemonCreateXML(virConnectPtr conn, const char *xmlDesc)
>          goto error;
>  
>      virDomainDefFree(def);
>   

Freeing def here needs to be killed too, right?

> -    return dom;
> +    return 0;
>  
>    error:
>      /* Make sure we don't leave a still-born domain around */
> -    if (dom != NULL) {
> +    if (def->id != -1)
>          xenDaemonDomainDestroy(conn, def);
> -        virObjectUnref(dom);
> -    }
> -    virDomainDefFree(def);
> -    return NULL;
> +    return -1;
>  }
>  
>  /**
> diff --git a/src/xen/xend_internal.h b/src/xen/xend_internal.h
> index 1284db3..b78145c 100644
> --- a/src/xen/xend_internal.h
> +++ b/src/xen/xend_internal.h
> @@ -140,18 +140,23 @@ int xenDaemonDomainCreate(virConnectPtr conn,
>  int xenDaemonDomainUndefine(virConnectPtr conn,
>                              virDomainDefPtr def);
>  
> -int	xenDaemonDomainSetVcpus		(virDomainPtr domain,
> +int	xenDaemonDomainSetVcpus		(virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           unsigned int vcpus);
> -int	xenDaemonDomainSetVcpusFlags	(virDomainPtr domain,
> +int	xenDaemonDomainSetVcpusFlags	(virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           unsigned int vcpus,
>                                           unsigned int flags);
> -int	xenDaemonDomainPinVcpu		(virDomainPtr domain,
> +int	xenDaemonDomainPinVcpu		(virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           unsigned int vcpu,
>                                           unsigned char *cpumap,
>                                           int maplen);
> -int     xenDaemonDomainGetVcpusFlags    (virDomainPtr domain,
> +int     xenDaemonDomainGetVcpusFlags    (virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           unsigned int flags);
> -int	xenDaemonDomainGetVcpus		(virDomainPtr domain,
> +int	xenDaemonDomainGetVcpus		(virConnectPtr conn,
> +                                         virDomainDefPtr def,
>                                           virVcpuInfoPtr info,
>                                           int maxinfo,
>                                           unsigned char *cpumaps,
> @@ -163,7 +168,7 @@ int xenDaemonDomainGetAutostart          (virDomainPtr dom,
>  int xenDaemonDomainSetAutostart          (virDomainPtr domain,
>                                            int autostart);
>  
> -virDomainPtr xenDaemonCreateXML(virConnectPtr conn, const char *xmlDesc);
> +int xenDaemonCreateXML(virConnectPtr conn, virDomainDefPtr def);
>  virDomainDefPtr xenDaemonLookupByUUID(virConnectPtr conn, const unsigned char *uuid);
>  virDomainDefPtr xenDaemonLookupByName(virConnectPtr conn, const char *domname);
>  int xenDaemonDomainMigratePrepare (virConnectPtr dconn,
>   

Another hunk for a previous patch?

> diff --git a/src/xen/xm_internal.c b/src/xen/xm_internal.c
> index 79f773d..76425dd 100644
> --- a/src/xen/xm_internal.c
> +++ b/src/xen/xm_internal.c
> @@ -656,11 +656,12 @@ cleanup:
>   * Returns 0 on success, -1 if an error message was issued
>   */
>  int
> -xenXMDomainSetVcpusFlags(virDomainPtr domain,
> +xenXMDomainSetVcpusFlags(virConnectPtr conn,
> +                         virDomainDefPtr def,
>   

Function comments need updated.

>                           unsigned int vcpus,
>                           unsigned int flags)
>  {
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>      const char *filename;
>      xenXMConfCachePtr entry;
>      int ret = -1;
> @@ -678,14 +679,14 @@ xenXMDomainSetVcpusFlags(virDomainPtr domain,
>  
>      xenUnifiedLock(priv);
>  
> -    if (!(filename = virHashLookup(priv->nameConfigMap, domain->name)))
> +    if (!(filename = virHashLookup(priv->nameConfigMap, def->name)))
>          goto cleanup;
>  
>      if (!(entry = virHashLookup(priv->configCache, filename)))
>          goto cleanup;
>  
>      /* Hypervisor maximum. */
> -    if ((max = xenUnifiedConnectGetMaxVcpus(domain->conn, NULL)) < 0) {
> +    if ((max = xenUnifiedConnectGetMaxVcpus(conn, NULL)) < 0) {
>          virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
>                         _("could not determine max vcpus for the domain"));
>          goto cleanup;
> @@ -712,7 +713,7 @@ xenXMDomainSetVcpusFlags(virDomainPtr domain,
>      /* If this fails, should we try to undo our changes to the
>       * 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;
>      ret = 0;
>  
> @@ -732,12 +733,14 @@ cleanup:
>   * issued
>   */
>  int
> -xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
> +xenXMDomainGetVcpusFlags(virConnectPtr conn,
> +                         virDomainDefPtr def,
> +                         unsigned int flags)
>   

Same here.

>  {
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>      const char *filename;
>      xenXMConfCachePtr entry;
> -    int ret = -2;
> +    int ret = -1;
>  
>      virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
>                    VIR_DOMAIN_VCPU_CONFIG |
> @@ -750,7 +753,7 @@ xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
>  
>      xenUnifiedLock(priv);
>  
> -    if (!(filename = virHashLookup(priv->nameConfigMap, domain->name)))
> +    if (!(filename = virHashLookup(priv->nameConfigMap, def->name)))
>          goto cleanup;
>  
>      if (!(entry = virHashLookup(priv->configCache, filename)))
> @@ -776,12 +779,13 @@ cleanup:
>   * Returns 0 for success; -1 (with errno) on error
>   */
>  int
> -xenXMDomainPinVcpu(virDomainPtr domain,
> +xenXMDomainPinVcpu(virConnectPtr conn,
> +                   virDomainDefPtr def,
>   

Same here, function comments need updated.

Regards,
Jim

>                     unsigned int vcpu ATTRIBUTE_UNUSED,
>                     unsigned char *cpumap,
>                     int maplen)
>  {
> -    xenUnifiedPrivatePtr priv = domain->conn->privateData;
> +    xenUnifiedPrivatePtr priv = conn->privateData;
>      const char *filename;
>      xenXMConfCachePtr entry;
>      int ret = -1;
> @@ -793,7 +797,7 @@ xenXMDomainPinVcpu(virDomainPtr domain,
>  
>      xenUnifiedLock(priv);
>  
> -    if (!(filename = virHashLookup(priv->nameConfigMap, domain->name))) {
> +    if (!(filename = virHashLookup(priv->nameConfigMap, def->name))) {
>          virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("virHashLookup"));
>          goto cleanup;
>      }
> @@ -807,7 +811,7 @@ xenXMDomainPinVcpu(virDomainPtr domain,
>      entry->def->cpumask = virBitmapNewData(cpumap, maplen);
>      if (!entry->def->cpumask)
>          goto cleanup;
> -    if (xenXMConfigSaveFile(domain->conn, entry->filename, entry->def) < 0)
> +    if (xenXMConfigSaveFile(conn, entry->filename, entry->def) < 0)
>          goto cleanup;
>  
>      ret = 0;
> diff --git a/src/xen/xm_internal.h b/src/xen/xm_internal.h
> index 5a434b9..28087d3 100644
> --- a/src/xen/xm_internal.h
> +++ b/src/xen/xm_internal.h
> @@ -54,12 +54,21 @@ int xenXMDomainSetMaxMemory(virConnectPtr conn,
>                              unsigned long memory);
>  unsigned long long xenXMDomainGetMaxMemory(virConnectPtr conn,
>                                             virDomainDefPtr def);
> -int xenXMDomainSetVcpus(virDomainPtr domain, unsigned int vcpus);
> -int xenXMDomainSetVcpusFlags(virDomainPtr domain, unsigned int vcpus,
> +int xenXMDomainSetVcpus(virConnectPtr conn,
> +                        virDomainDefPtr def,
> +                        unsigned int vcpus);
> +int xenXMDomainSetVcpusFlags(virConnectPtr conn,
> +                             virDomainDefPtr def,
> +                             unsigned int vcpus,
> +                             unsigned int flags);
> +int xenXMDomainGetVcpusFlags(virConnectPtr conn,
> +                             virDomainDefPtr def,
>                               unsigned int flags);
> -int xenXMDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags);
> -int xenXMDomainPinVcpu(virDomainPtr domain, unsigned int vcpu,
> -                       unsigned char *cpumap, int maplen);
> +int xenXMDomainPinVcpu(virConnectPtr conn,
> +                       virDomainDefPtr def,
> +                       unsigned int vcpu,
> +                       unsigned char *cpumap,
> +                       int maplen);
>  virDomainDefPtr xenXMDomainLookupByName(virConnectPtr conn, const char *domname);
>  virDomainDefPtr xenXMDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid);
>  
>   


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]