conf: Replace read access to def->maxvcpus with accessor

Finalize the refactor by adding the 'virDomainDefGetVCpusMax' getter and
reusing it accross libvirt.

src/conf/domain_conf.c

@@ -1304,6 +1304,13 @@ virDomainDefHasVcpusOffline(const virDomainDef *def)
 }
 
 
+unsigned int
+virDomainDefGetVcpusMax(const virDomainDef *def)
+{
+    return def->maxvcpus;
+}
+
+
 virDomainDiskDefPtr
 virDomainDiskDefNew(virDomainXMLOptionPtr xmlopt)
 {
@@ -14983,7 +14990,8 @@ virDomainDefParseXML(xmlDocPtr xml,
 
         for (i = 0; i < def->cputune.nvcpusched; i++) {
             if (virDomainThreadSchedParse(nodes[i],
-                                          0, def->maxvcpus - 1,
+                                          0,
+                                          virDomainDefGetVcpusMax(def) - 1,
                                           "vcpus",
                                           &def->cputune.vcpusched[i]) < 0)
                 goto error;
@@ -15060,7 +15068,7 @@ virDomainDefParseXML(xmlDocPtr xml,
             goto error;
 
         if (def->cpu->sockets &&
-            def->maxvcpus >
+            virDomainDefGetVcpusMax(def) >
             def->cpu->sockets * def->cpu->cores * def->cpu->threads) {
             virReportError(VIR_ERR_XML_DETAIL, "%s",
                            _("Maximum CPUs greater than topology limit"));
@@ -15072,14 +15080,14 @@ virDomainDefParseXML(xmlDocPtr xml,
     if (virDomainNumaDefCPUParseXML(def->numa, ctxt) < 0)
         goto error;
 
-    if (virDomainNumaGetCPUCountTotal(def->numa) > def->maxvcpus) {
+    if (virDomainNumaGetCPUCountTotal(def->numa) > virDomainDefGetVcpusMax(def)) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                        _("Number of CPUs in <numa> exceeds the"
                          " <vcpu> count"));
         goto error;
     }
 
-    if (virDomainNumaGetMaxCPUID(def->numa) >= def->maxvcpus) {
+    if (virDomainNumaGetMaxCPUID(def->numa) >= virDomainDefGetVcpusMax(def)) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                        _("CPU IDs in <numa> exceed the <vcpu> count"));
         goto error;
@@ -17556,10 +17564,10 @@ virDomainDefCheckABIStability(virDomainDefPtr src,
                        dst->vcpus, src->vcpus);
         goto error;
     }
-    if (src->maxvcpus != dst->maxvcpus) {
+    if (virDomainDefGetVcpusMax(src) != virDomainDefGetVcpusMax(dst)) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                        _("Target domain vCPU max %d does not match source %d"),
-                       dst->maxvcpus, src->maxvcpus);
+                       virDomainDefGetVcpusMax(dst), virDomainDefGetVcpusMax(src));
         goto error;
     }
 
@@ -21530,7 +21538,7 @@ virDomainDefFormatInternal(virDomainDefPtr def,
     }
     if (virDomainDefHasVcpusOffline(def))
         virBufferAsprintf(buf, " current='%u'", def->vcpus);
-    virBufferAsprintf(buf, ">%u</vcpu>\n", def->maxvcpus);
+    virBufferAsprintf(buf, ">%u</vcpu>\n", virDomainDefGetVcpusMax(def));
 
     if (def->niothreadids > 0) {
         virBufferAsprintf(buf, "<iothreads>%u</iothreads>\n",

src/conf/domain_conf.h

@@ -2345,6 +2345,7 @@ struct _virDomainDef {
 
 int virDomainDefSetVcpusMax(virDomainDefPtr def, unsigned int vcpus);
 bool virDomainDefHasVcpusOffline(const virDomainDef *def);
+unsigned int virDomainDefGetVcpusMax(const virDomainDef *def);
 
 unsigned long long virDomainDefGetMemoryInitial(const virDomainDef *def);
 void virDomainDefSetMemoryTotal(virDomainDefPtr def, unsigned long long size);

src/libvirt_private.syms

@@ -217,6 +217,7 @@ virDomainDefGetDefaultEmulator;
 virDomainDefGetMemoryActual;
 virDomainDefGetMemoryInitial;
 virDomainDefGetSecurityLabelDef;
+virDomainDefGetVcpusMax;
 virDomainDefHasDeviceAddress;
 virDomainDefHasMemoryHotplug;
 virDomainDefHasVcpusOffline;

src/libxl/libxl_conf.c

@@ -643,8 +643,8 @@ libxlMakeDomBuildInfo(virDomainDefPtr def,
     else
         libxl_domain_build_info_init_type(b_info, LIBXL_DOMAIN_TYPE_PV);
 
-    b_info->max_vcpus = def->maxvcpus;
-    if (libxl_cpu_bitmap_alloc(ctx, &b_info->avail_vcpus, def->maxvcpus))
+    b_info->max_vcpus = virDomainDefGetVcpusMax(def);
+    if (libxl_cpu_bitmap_alloc(ctx, &b_info->avail_vcpus, b_info->max_vcpus))
         return -1;
     libxl_bitmap_set_none(&b_info->avail_vcpus);
     for (i = 0; i < def->vcpus; i++)

src/libxl/libxl_driver.c

@@ -2159,8 +2159,8 @@ libxlDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
         goto endjob;
     }
 
-    if (!(flags & VIR_DOMAIN_VCPU_MAXIMUM) && vm->def->maxvcpus < max)
-        max = vm->def->maxvcpus;
+    if (!(flags & VIR_DOMAIN_VCPU_MAXIMUM) && virDomainDefGetVcpusMax(vm->def) < max)
+        max = virDomainDefGetVcpusMax(vm->def);
 
     if (nvcpus > max) {
         virReportError(VIR_ERR_INVALID_ARG,
@@ -2297,7 +2297,10 @@ libxlDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
         def = vm->newDef ? vm->newDef : vm->def;
     }
 
-    ret = (flags & VIR_DOMAIN_VCPU_MAXIMUM) ? def->maxvcpus : def->vcpus;
+    if (flags & VIR_DOMAIN_VCPU_MAXIMUM)
+        ret = virDomainDefGetVcpusMax(def);
+    else
+        ret = def->vcpus;
 
  cleanup:
     if (vm)
@@ -4699,7 +4702,7 @@ libxlDomainGetPerCPUStats(libxlDriverPrivatePtr driver,
     if (nparams == 0 && ncpus != 0)
         return LIBXL_NB_TOTAL_CPU_STAT_PARAM;
     else if (nparams == 0)
-        return vm->def->maxvcpus;
+        return virDomainDefGetVcpusMax(vm->def);
 
     cfg = libxlDriverConfigGet(driver);
     if ((vcpuinfo = libxl_list_vcpu(cfg->ctx, vm->def->id, &maxcpu,

src/openvz/openvz_driver.c

@@ -1035,8 +1035,8 @@ openvzDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int fla
                        _("current vcpu count must equal maximum"));
         goto cleanup;
     }
-    if (vm->def->maxvcpus > 0) {
-        if (openvzDomainSetVcpusInternal(vm, vm->def->maxvcpus) < 0) {
+    if (virDomainDefGetVcpusMax(vm->def)) {
+        if (openvzDomainSetVcpusInternal(vm, virDomainDefGetVcpusMax(vm->def)) < 0) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                            _("Could not set number of vCPUs"));
              goto cleanup;
@@ -1133,8 +1133,8 @@ openvzDomainCreateXML(virConnectPtr conn, const char *xml,
     vm->def->id = vm->pid;
     virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED);
 
-    if (vm->def->maxvcpus > 0) {
-        if (openvzDomainSetVcpusInternal(vm, vm->def->maxvcpus) < 0) {
+    if (virDomainDefGetVcpusMax(vm->def) > 0) {
+        if (openvzDomainSetVcpusInternal(vm, virDomainDefGetVcpusMax(vm->def)) < 0) {
             virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                            _("Could not set number of vCPUs"));
             goto cleanup;

src/qemu/qemu_command.c

@@ -7963,7 +7963,7 @@ qemuBuildSmpArgStr(const virDomainDef *def,
 
     if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY)) {
         if (virDomainDefHasVcpusOffline(def))
-            virBufferAsprintf(&buf, ",maxcpus=%u", def->maxvcpus);
+            virBufferAsprintf(&buf, ",maxcpus=%u", virDomainDefGetVcpusMax(def));
         /* sockets, cores, and threads are either all zero
          * or all non-zero, thus checking one of them is enough */
         if (def->cpu && def->cpu->sockets) {
@@ -7971,7 +7971,7 @@ qemuBuildSmpArgStr(const virDomainDef *def,
             virBufferAsprintf(&buf, ",cores=%u", def->cpu->cores);
             virBufferAsprintf(&buf, ",threads=%u", def->cpu->threads);
         } else {
-            virBufferAsprintf(&buf, ",sockets=%u", def->maxvcpus);
+            virBufferAsprintf(&buf, ",sockets=%u", virDomainDefGetVcpusMax(def));
             virBufferAsprintf(&buf, ",cores=%u", 1);
             virBufferAsprintf(&buf, ",threads=%u", 1);
         }

src/qemu/qemu_driver.c

@@ -4911,10 +4911,10 @@ qemuDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     }
 
     if (def)
-        maxvcpus = def->maxvcpus;
+        maxvcpus = virDomainDefGetVcpusMax(def);
     if (persistentDef) {
-        if (!maxvcpus || maxvcpus > persistentDef->maxvcpus)
-            maxvcpus = persistentDef->maxvcpus;
+        if (!maxvcpus || maxvcpus > virDomainDefGetVcpusMax(persistentDef))
+            maxvcpus = virDomainDefGetVcpusMax(persistentDef);
     }
     if (!(flags & VIR_DOMAIN_VCPU_MAXIMUM) && nvcpus > maxvcpus) {
         virReportError(VIR_ERR_INVALID_ARG,
@@ -5557,7 +5557,7 @@ qemuDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
         }
     } else {
         if (flags & VIR_DOMAIN_VCPU_MAXIMUM)
-            ret = def->maxvcpus;
+            ret = virDomainDefGetVcpusMax(def);
         else
             ret = def->vcpus;
     }
@@ -19078,7 +19078,7 @@ qemuDomainGetStatsVcpu(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                               &record->nparams,
                               maxparams,
                               "vcpu.maximum",
-                              (unsigned) dom->def->maxvcpus) < 0)
+                              virDomainDefGetVcpusMax(dom->def)) < 0)
         return -1;
 
     if (VIR_ALLOC_N(cpuinfo, dom->def->vcpus) < 0)

src/qemu/qemu_process.c

@@ -3869,7 +3869,7 @@ qemuValidateCpuMax(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
     if (!maxCpus)
         return true;
 
-    if (def->maxvcpus > maxCpus) {
+    if (virDomainDefGetVcpusMax(def) > maxCpus) {
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                        "%s", _("Maximum CPUs greater than specified machine type limit"));
         return false;

src/test/test_driver.c

@@ -2313,7 +2313,10 @@ testDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
     if (!(def = virDomainObjGetOneDef(vm, flags)))
         goto cleanup;
 
-    ret = (flags & VIR_DOMAIN_VCPU_MAXIMUM) ? def->maxvcpus : def->vcpus;
+    if (flags & VIR_DOMAIN_VCPU_MAXIMUM)
+        ret = virDomainDefGetVcpusMax(def);
+    else
+        ret = def->vcpus;
 
  cleanup:
     virDomainObjEndAPI(&vm);
@@ -2356,19 +2359,19 @@ testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus,
     if (virDomainObjGetDefs(privdom, flags, &def, &persistentDef) < 0)
         goto cleanup;
 
-    if (def && def->maxvcpus < nrCpus) {
+    if (def && virDomainDefGetVcpusMax(def) < nrCpus) {
         virReportError(VIR_ERR_INVALID_ARG,
                        _("requested cpu amount exceeds maximum (%d > %d)"),
-                       nrCpus, def->maxvcpus);
+                       nrCpus, virDomainDefGetVcpusMax(def));
         goto cleanup;
     }
 
     if (persistentDef &&
         !(flags & VIR_DOMAIN_VCPU_MAXIMUM) &&
-        persistentDef->maxvcpus < nrCpus) {
+        virDomainDefGetVcpusMax(persistentDef) < nrCpus) {
         virReportError(VIR_ERR_INVALID_ARG,
                        _("requested cpu amount exceeds maximum (%d > %d)"),
-                       nrCpus, persistentDef->maxvcpus);
+                       nrCpus, virDomainDefGetVcpusMax(persistentDef));
         goto cleanup;
     }
 

src/vbox/vbox_common.c

@@ -1899,11 +1899,11 @@ vboxDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                        _("current vcpu count must equal maximum"));
     }
-    rc = gVBoxAPI.UIMachine.SetCPUCount(machine, def->maxvcpus);
+    rc = gVBoxAPI.UIMachine.SetCPUCount(machine, virDomainDefGetVcpusMax(def));
     if (NS_FAILED(rc)) {
         virReportError(VIR_ERR_INTERNAL_ERROR,
                        _("could not set the number of virtual CPUs to: %u, rc=%08x"),
-                       def->maxvcpus, (unsigned)rc);
+                       virDomainDefGetVcpusMax(def), (unsigned)rc);
     }
 
     rc = gVBoxAPI.UIMachine.SetCPUProperty(machine, CPUPropertyType_PAE,

src/vmx/vmx.c

@@ -3071,6 +3071,7 @@ virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt, virDomainDe
     bool scsi_present[4] = { false, false, false, false };
     int scsi_virtualDev[4] = { -1, -1, -1, -1 };
     bool floppy_present[2] = { false, false };
+    unsigned int maxvcpus;
 
     if (ctx->formatFileName == NULL) {
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -3186,15 +3187,16 @@ virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt, virDomainDe
                          "'current'"));
         goto cleanup;
     }
-    if (def->maxvcpus <= 0 || (def->maxvcpus % 2 != 0 && def->maxvcpus != 1)) {
+    maxvcpus = virDomainDefGetVcpusMax(def);
+    if (maxvcpus == 0 || (maxvcpus % 2 != 0 && maxvcpus != 1)) {
         virReportError(VIR_ERR_INTERNAL_ERROR,
-                       _("Expecting domain XML entry 'vcpu' to be an unsigned "
-                         "integer (1 or a multiple of 2) but found %d"),
-                       def->maxvcpus);
+                       _("Expecting domain XML entry 'vcpu' to be 1 or a "
+                         "multiple of 2 but found %d"),
+                       maxvcpus);
         goto cleanup;
     }
 
-    virBufferAsprintf(&buffer, "numvcpus = \"%d\"\n", def->maxvcpus);
+    virBufferAsprintf(&buffer, "numvcpus = \"%d\"\n", maxvcpus);
 
     /* def:cpumask -> vmx:sched.cpu.affinity */
     if (def->cpumask && virBitmapSize(def->cpumask) > 0) {
@@ -3207,11 +3209,11 @@ virVMXFormatConfig(virVMXContext *ctx, virDomainXMLOptionPtr xmlopt, virDomainDe
         while ((bit = virBitmapNextSetBit(def->cpumask, bit)) >= 0)
             ++sched_cpu_affinity_length;
 
-        if (sched_cpu_affinity_length < def->maxvcpus) {
+        if (sched_cpu_affinity_length < maxvcpus) {
             virReportError(VIR_ERR_INTERNAL_ERROR,
                            _("Expecting domain XML attribute 'cpuset' of entry "
                              "'vcpu' to contain at least %d CPU(s)"),
-                           def->maxvcpus);
+                           maxvcpus);
             goto cleanup;
         }
 

src/vz/vz_driver.c

@@ -1372,7 +1372,7 @@ vzDomainGetVcpusFlags(virDomainPtr dom,
         goto cleanup;
 
     if (flags & VIR_DOMAIN_VCPU_MAXIMUM)
-        ret = privdom->def->maxvcpus;
+        ret = virDomainDefGetVcpusMax(privdom->def);
     else
         ret = privdom->def->vcpus;
 

src/xen/xm_internal.c

@@ -695,7 +695,8 @@ xenXMDomainSetVcpusFlags(virConnectPtr conn,
     /* Can't specify a current larger than stored maximum; but
      * reducing maximum can silently reduce current.  */
     if (!(flags & VIR_DOMAIN_VCPU_MAXIMUM))
-        max = entry->def->maxvcpus;
+        max = virDomainDefGetVcpusMax(entry->def);
+
     if (vcpus > max) {
         virReportError(VIR_ERR_INVALID_ARG,
                        _("requested vcpus is greater than max allowable"
@@ -760,8 +761,10 @@ xenXMDomainGetVcpusFlags(virConnectPtr conn,
     if (!(entry = virHashLookup(priv->configCache, filename)))
         goto cleanup;
 
-    ret = ((flags & VIR_DOMAIN_VCPU_MAXIMUM) ? entry->def->maxvcpus
-           : entry->def->vcpus);
+    if (flags & VIR_DOMAIN_VCPU_MAXIMUM)
+        ret = virDomainDefGetVcpusMax(entry->def);
+    else
+        ret = entry->def->vcpus;
 
  cleanup:
     xenUnifiedUnlock(priv);

src/xenapi/xenapi_utils.c

@@ -504,8 +504,8 @@ createVMRecordFromXml(virConnectPtr conn, virDomainDefPtr def,
     else
         (*record)->memory_dynamic_max = (*record)->memory_static_max;
 
-    if (def->maxvcpus) {
-        (*record)->vcpus_max = (int64_t) def->maxvcpus;
+    if (virDomainDefGetVcpusMax(def) > 0) {
+        (*record)->vcpus_max = (int64_t) virDomainDefGetVcpusMax(def);
         (*record)->vcpus_at_startup = (int64_t) def->vcpus;
     }
     if (def->onPoweroff)

src/xenconfig/xen_common.c

@@ -508,7 +508,7 @@ xenParseCPUFeatures(virConfPtr conf, virDomainDefPtr def)
     if (xenConfigGetULong(conf, "vcpu_avail", &count, -1) < 0)
         return -1;
 
-    def->vcpus = MIN(count_one_bits_l(count), def->maxvcpus);
+    def->vcpus = MIN(count_one_bits_l(count), virDomainDefGetVcpusMax(def));
     if (xenConfigGetString(conf, "cpus", &str, NULL) < 0)
         return -1;
 
@@ -1528,7 +1528,7 @@ xenFormatCPUAllocation(virConfPtr conf, virDomainDefPtr def)
     int ret = -1;
     char *cpus = NULL;
 
-    if (xenConfigSetInt(conf, "vcpus", def->maxvcpus) < 0)
+    if (xenConfigSetInt(conf, "vcpus", virDomainDefGetVcpusMax(def)) < 0)
         goto cleanup;
 
     /* Computing the vcpu_avail bitmask works because MAX_VIRT_CPUS is

src/xenconfig/xen_sxpr.c

@@ -1176,8 +1176,8 @@ xenParseSxpr(const struct sexpr *root,
     if (virDomainDefSetVcpusMax(def, sexpr_int(root, "domain/vcpus")) < 0)
         goto error;
     def->vcpus = count_one_bits_l(sexpr_u64(root, "domain/vcpu_avail"));
-    if (!def->vcpus || def->maxvcpus < def->vcpus)
-        def->vcpus = def->maxvcpus;
+    if (!def->vcpus || virDomainDefGetVcpusMax(def) < def->vcpus)
+        def->vcpus = virDomainDefGetVcpusMax(def);
 
     tmp = sexpr_node(root, "domain/on_poweroff");
     if (tmp != NULL) {
@@ -2237,7 +2237,7 @@ xenFormatSxpr(virConnectPtr conn,
     virBufferAsprintf(&buf, "(memory %llu)(maxmem %llu)",
                       VIR_DIV_UP(def->mem.cur_balloon, 1024),
                       VIR_DIV_UP(virDomainDefGetMemoryActual(def), 1024));
-    virBufferAsprintf(&buf, "(vcpus %u)", def->maxvcpus);
+    virBufferAsprintf(&buf, "(vcpus %u)", virDomainDefGetVcpusMax(def));
     /* Computing the vcpu_avail bitmask works because MAX_VIRT_CPUS is
        either 32, or 64 on a platform where long is big enough.  */
     if (virDomainDefHasVcpusOffline(def))
@@ -2321,7 +2321,7 @@ xenFormatSxpr(virConnectPtr conn,
             else
                 virBufferEscapeSexpr(&buf, "(kernel '%s')", def->os.loader->path);
 
-            virBufferAsprintf(&buf, "(vcpus %u)", def->maxvcpus);
+            virBufferAsprintf(&buf, "(vcpus %u)", virDomainDefGetVcpusMax(def));
             if (virDomainDefHasVcpusOffline(def))
                 virBufferAsprintf(&buf, "(vcpu_avail %lu)",
                                   (1UL << def->vcpus) - 1);