memtune: change the way how we store unlimited value

There was a mess in the way how we store unlimited value for memory
limits and how we handled values provided by user.  Internally there
were two possible ways how to store unlimited value: as 0 value or as
VIR_DOMAIN_MEMORY_PARAM_UNLIMITED.  Because we chose to store memory
limits as unsigned long long, we cannot use -1 to represent unlimited.
It's much easier for us to say that everything greater than
VIR_DOMAIN_MEMORY_PARAM_UNLIMITED means unlimited and leave 0 as valid
value despite that it makes no sense to set limit to 0.

Remove unnecessary function virCompareLimitUlong.  The update of test
is to prevent the 0 to be miss-used as unlimited in future.

Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1146539

Signed-off-by: Pavel Hrdina <phrdina@redhat.com>

diff --git a/docs/formatdomain.html.in b/docs/formatdomain.html.in
index 6276a615f21a559c973b146403a498139bbcf93d..335763fdde8efc87c6cd49fee07a825cc40b6183 100644 (file)
--- a/docs/formatdomain.html.in
+++ b/docs/formatdomain.html.in
@@ -798,7 +798,9 @@
         for <code>&lt;memory&gt;</code>.  For backwards
         compatibility, output is always in
         KiB.  <span class='since'><code>unit</code>
-        since 0.9.11</span></dd>
+        since 0.9.11</span>
+        Possible values for all *_limit parameters are in range from 0 to
+        VIR_DOMAIN_MEMORY_PARAM_UNLIMITED.</dd>
       <dt><code>hard_limit</code></dt>
       <dd> The optional <code>hard_limit</code> element is the maximum memory
         the guest can use. The units for this value are kibibytes (i.e. blocks

diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index 5467befe3d83a9429b5a4cc8b7f607429bd3d31f..01a3fbc3ab1ea3fffb63daec10e8a5f67330f3b0 100644 (file)
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -2320,6 +2320,10 @@ virDomainDefNew(void)
     if (!(ret->numa = virDomainNumaNew()))
         goto error;
 
+    ret->mem.hard_limit = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
+    ret->mem.soft_limit = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
+    ret->mem.swap_hard_limit = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
+
     return ret;
 
  error:
@@ -6926,6 +6930,50 @@ virDomainParseMemory(const char *xpath,
 }
 
 
+/**
+ * virDomainParseMemoryLimit:
+ *
+ * @xpath: XPath to memory amount
+ * @units_xpath: XPath to units attribute
+ * @ctxt: XPath context
+ * @mem: scaled memory amount is stored here
+ *
+ * Parse a memory element or attribute located at @xpath within @ctxt, and
+ * store the result into @mem, in blocks of 1024.  The  value is scaled by
+ * units located at @units_xpath (or the 'unit' attribute under @xpath if
+ * @units_xpath is NULL).  If units are not present, he default scale of 1024
+ * is used.  The value must not exceed VIR_DOMAIN_MEMORY_PARAM_UNLIMITED
+ * once scaled.
+ *
+ * This helper should be used only on *_limit memory elements.
+ *
+ * Return 0 on success, -1 on failure after issuing error.
+ */
+static int
+virDomainParseMemoryLimit(const char *xpath,
+                          const char *units_xpath,
+                          xmlXPathContextPtr ctxt,
+                          unsigned long long *mem)
+{
+    int ret;
+    unsigned long long bytes;
+
+    ret = virDomainParseScaledValue(xpath, units_xpath, ctxt, &bytes, 1024,
+                                    VIR_DOMAIN_MEMORY_PARAM_UNLIMITED << 10,
+                                    false);
+
+    if (ret < 0)
+        return -1;
+
+    if (ret == 0)
+        *mem = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
+    else
+        *mem = virMemoryLimitTruncate(VIR_DIV_UP(bytes, 1024));
+
+    return 0;
+}
+
+
 static int
 virDomainControllerModelTypeFromString(const virDomainControllerDef *def,
                                        const char *model)
@@ -13227,20 +13275,20 @@ virDomainDefParseXML(xmlDocPtr xml,
     VIR_FREE(nodes);
 
     /* Extract other memory tunables */
-    if (virDomainParseMemory("./memtune/hard_limit[1]", NULL, ctxt,
-                             &def->mem.hard_limit, false, false) < 0)
+    if (virDomainParseMemoryLimit("./memtune/hard_limit[1]", NULL, ctxt,
+                                  &def->mem.hard_limit) < 0)
         goto error;
 
-    if (virDomainParseMemory("./memtune/soft_limit[1]", NULL, ctxt,
-                             &def->mem.soft_limit, false, false) < 0)
+    if (virDomainParseMemoryLimit("./memtune/soft_limit[1]", NULL, ctxt,
+                                  &def->mem.soft_limit) < 0)
         goto error;
 
     if (virDomainParseMemory("./memtune/min_guarantee[1]", NULL, ctxt,
                              &def->mem.min_guarantee, false, false) < 0)
         goto error;
 
-    if (virDomainParseMemory("./memtune/swap_hard_limit[1]", NULL, ctxt,
-                             &def->mem.swap_hard_limit, false, false) < 0)
+    if (virDomainParseMemoryLimit("./memtune/swap_hard_limit[1]", NULL, ctxt,
+                                  &def->mem.swap_hard_limit) < 0)
         goto error;
 
     n = virXPathULong("string(./vcpu[1])", ctxt, &count);
@@ -19809,20 +19857,17 @@ virDomainDefFormatInternal(virDomainDefPtr def,
     }
 
     /* add memtune only if there are any */
-    if ((def->mem.hard_limit &&
-         def->mem.hard_limit != VIR_DOMAIN_MEMORY_PARAM_UNLIMITED) ||
-        (def->mem.soft_limit &&
-         def->mem.soft_limit != VIR_DOMAIN_MEMORY_PARAM_UNLIMITED) ||
-        (def->mem.swap_hard_limit &&
-         def->mem.swap_hard_limit != VIR_DOMAIN_MEMORY_PARAM_UNLIMITED) ||
+    if (virMemoryLimitIsSet(def->mem.hard_limit) ||
+        virMemoryLimitIsSet(def->mem.soft_limit) ||
+        virMemoryLimitIsSet(def->mem.swap_hard_limit) ||
         def->mem.min_guarantee) {
         virBufferAddLit(buf, "<memtune>\n");
         virBufferAdjustIndent(buf, 2);
-        if (def->mem.hard_limit) {
+        if (virMemoryLimitIsSet(def->mem.hard_limit)) {
             virBufferAsprintf(buf, "<hard_limit unit='KiB'>"
                               "%llu</hard_limit>\n", def->mem.hard_limit);
         }
-        if (def->mem.soft_limit) {
+        if (virMemoryLimitIsSet(def->mem.soft_limit)) {
             virBufferAsprintf(buf, "<soft_limit unit='KiB'>"
                               "%llu</soft_limit>\n", def->mem.soft_limit);
         }
@@ -19830,7 +19875,7 @@ virDomainDefFormatInternal(virDomainDefPtr def,
             virBufferAsprintf(buf, "<min_guarantee unit='KiB'>"
                               "%llu</min_guarantee>\n", def->mem.min_guarantee);
         }
-        if (def->mem.swap_hard_limit) {
+        if (virMemoryLimitIsSet(def->mem.swap_hard_limit)) {
             virBufferAsprintf(buf, "<swap_hard_limit unit='KiB'>"
                               "%llu</swap_hard_limit>\n", def->mem.swap_hard_limit);
         }

diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
index 89d1eab17203255fe9e90f3a216fa1984338342e..83453978df9aa5aabac347e1fdcea1c6dd9a37e1 100644 (file)
--- a/src/libvirt-domain.c
+++ b/src/libvirt-domain.c
@@ -2075,6 +2075,9 @@ virDomainSetMemoryStatsPeriod(virDomainPtr domain, int period,
  * Change all or a subset of the memory tunables.
  * This function may require privileged access to the hypervisor.
  *
+ * Possible values for all *_limit memory tunables are in range from 0 to
+ * VIR_DOMAIN_MEMORY_PARAM_UNLIMITED.
+ *
  * Returns -1 in case of error, 0 in case of success.
  */
 int

diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 3590bd7371ff0c611bb71c084b1bf3e783b8bcff..a579bc5516a23f9280247e4d6fdc7c475f0cdbb0 100644 (file)
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -2233,7 +2233,6 @@ virUSBDeviceSetUsedBy;
 
 
 # util/virutil.h
-virCompareLimitUlong;
 virDoubleToStr;
 virEnumFromString;
 virEnumToString;

diff --git a/src/lxc/lxc_cgroup.c b/src/lxc/lxc_cgroup.c
index 8e46a0128428188eda573dc96d9c9ae220fa9a6e..5a49e2d5a1d6ec74dae5b8eb9fa9cee2eee54867 100644 (file)
--- a/src/lxc/lxc_cgroup.c
+++ b/src/lxc/lxc_cgroup.c
@@ -149,17 +149,17 @@ static int virLXCCgroupSetupMemTune(virDomainDefPtr def,
     if (virCgroupSetMemory(cgroup, def->mem.max_balloon) < 0)
         goto cleanup;
 
-    if (def->mem.hard_limit &&
-        virCgroupSetMemoryHardLimit(cgroup, def->mem.hard_limit) < 0)
-        goto cleanup;
+    if (virMemoryLimitIsSet(def->mem.hard_limit))
+        if (virCgroupSetMemoryHardLimit(cgroup, def->mem.hard_limit) < 0)
+            goto cleanup;
 
-    if (def->mem.soft_limit &&
-        virCgroupSetMemorySoftLimit(cgroup, def->mem.soft_limit) < 0)
-        goto cleanup;
+    if (virMemoryLimitIsSet(def->mem.soft_limit))
+        if (virCgroupSetMemorySoftLimit(cgroup, def->mem.soft_limit) < 0)
+            goto cleanup;
 
-    if (def->mem.swap_hard_limit &&
-        virCgroupSetMemSwapHardLimit(cgroup, def->mem.swap_hard_limit) < 0)
-        goto cleanup;
+    if (virMemoryLimitIsSet(def->mem.swap_hard_limit))
+        if (virCgroupSetMemSwapHardLimit(cgroup, def->mem.swap_hard_limit) < 0)
+            goto cleanup;
 
     ret = 0;
  cleanup:

diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index 3a28dd55e3123b4989017328ff27f685944e3bd7..6b0dea162839ed75e53b7b1aa3574abfc9773432 100644 (file)
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -874,7 +874,7 @@ lxcDomainSetMemoryParameters(virDomainPtr dom,
         if (set_hard_limit)
             mem_limit = hard_limit;
 
-        if (virCompareLimitUlong(mem_limit, swap_limit) > 0) {
+        if (mem_limit > swap_limit) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
                            _("memory hard_limit tunable value must be lower "
                              "than or equal to swap_hard_limit"));
@@ -902,7 +902,7 @@ lxcDomainSetMemoryParameters(virDomainPtr dom,
     LXC_SET_MEM_PARAMETER(virCgroupSetMemorySoftLimit, soft_limit);
 
     /* set hard limit before swap hard limit if decreasing it */
-    if (virCompareLimitUlong(vm->def->mem.hard_limit, hard_limit) > 0) {
+    if (vm->def->mem.hard_limit > hard_limit) {
         LXC_SET_MEM_PARAMETER(virCgroupSetMemoryHardLimit, hard_limit);
         /* inhibit changing the limit a second time */
         set_hard_limit = false;
@@ -983,7 +983,6 @@ lxcDomainGetMemoryParameters(virDomainPtr dom,
         case 0: /* fill memory hard limit here */
             if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
                 val = vmdef->mem.hard_limit;
-                val = val ? val : VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
             } else if (virCgroupGetMemoryHardLimit(priv->cgroup, &val) < 0) {
                 goto cleanup;
             }
@@ -994,7 +993,6 @@ lxcDomainGetMemoryParameters(virDomainPtr dom,
         case 1: /* fill memory soft limit here */
             if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
                 val = vmdef->mem.soft_limit;
-                val = val ? val : VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
             } else if (virCgroupGetMemorySoftLimit(priv->cgroup, &val) < 0) {
                 goto cleanup;
             }
@@ -1005,7 +1003,6 @@ lxcDomainGetMemoryParameters(virDomainPtr dom,
         case 2: /* fill swap hard limit here */
             if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
                 val = vmdef->mem.swap_hard_limit;
-                val = val ? val : VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
             } else if (virCgroupGetMemSwapHardLimit(priv->cgroup, &val) < 0) {
                 goto cleanup;
             }

diff --git a/src/lxc/lxc_fuse.c b/src/lxc/lxc_fuse.c
index 5c18cff0aec904e214e46eb158a3cc1fb3fb3113..bc2b92c045c1e8b4d5702fca669c50221c23fba5 100644 (file)
--- a/src/lxc/lxc_fuse.c
+++ b/src/lxc/lxc_fuse.c
@@ -165,11 +165,13 @@ static int lxcProcReadMeminfo(char *hostpath, virDomainDefPtr def,
             *ptr = '\0';
 
             if (STREQ(line, "MemTotal") &&
-                (def->mem.hard_limit || def->mem.max_balloon)) {
+                (virMemoryLimitIsSet(def->mem.hard_limit) ||
+                 def->mem.max_balloon)) {
                 virBufferAsprintf(new_meminfo, "MemTotal:       %8llu kB\n",
                                   meminfo.memtotal);
             } else if (STREQ(line, "MemFree") &&
-                       (def->mem.hard_limit || def->mem.max_balloon)) {
+                       (virMemoryLimitIsSet(def->mem.hard_limit) ||
+                        def->mem.max_balloon)) {
                 virBufferAsprintf(new_meminfo, "MemFree:        %8llu kB\n",
                                   (meminfo.memtotal - meminfo.memusage));
             } else if (STREQ(line, "Buffers")) {
@@ -198,10 +200,12 @@ static int lxcProcReadMeminfo(char *hostpath, virDomainDefPtr def,
             } else if (STREQ(line, "Unevictable")) {
                 virBufferAsprintf(new_meminfo, "Unevictable:    %8llu kB\n",
                                   meminfo.unevictable);
-            } else if (STREQ(line, "SwapTotal") && def->mem.swap_hard_limit) {
+            } else if (STREQ(line, "SwapTotal") &&
+                       virMemoryLimitIsSet(def->mem.swap_hard_limit)) {
                 virBufferAsprintf(new_meminfo, "SwapTotal:      %8llu kB\n",
                                   (meminfo.swaptotal - meminfo.memtotal));
-            } else if (STREQ(line, "SwapFree") && def->mem.swap_hard_limit) {
+            } else if (STREQ(line, "SwapFree") &&
+                       virMemoryLimitIsSet(def->mem.swap_hard_limit)) {
                 virBufferAsprintf(new_meminfo, "SwapFree:       %8llu kB\n",
                                   (meminfo.swaptotal - meminfo.memtotal -
                                    meminfo.swapusage + meminfo.memusage));

diff --git a/src/lxc/lxc_native.c b/src/lxc/lxc_native.c
index abf07ce68be6529e27425f9c0b80b712cef82b9e..2ebe6102bf1838aea1208bada1bb1930313d5c13 100644 (file)
--- a/src/lxc/lxc_native.c
+++ b/src/lxc/lxc_native.c
@@ -773,7 +773,7 @@ lxcSetMemTune(virDomainDefPtr def, virConfPtr properties)
             return -1;
         size = size / 1024;
         def->mem.max_balloon = size;
-        def->mem.hard_limit = size;
+        def->mem.hard_limit = virMemoryLimitTruncate(size);
     }
 
     if ((value = virConfGetValue(properties,
@@ -782,7 +782,7 @@ lxcSetMemTune(virDomainDefPtr def, virConfPtr properties)
         if (lxcConvertSize(value->str, &size) < 0)
             return -1;
 
-        def->mem.soft_limit = size / 1024;
+        def->mem.soft_limit = virMemoryLimitTruncate(size / 1024);
     }
 
     if ((value = virConfGetValue(properties,
@@ -791,7 +791,7 @@ lxcSetMemTune(virDomainDefPtr def, virConfPtr properties)
         if (lxcConvertSize(value->str, &size) < 0)
             return -1;
 
-       def->mem.swap_hard_limit = size / 1024;
+        def->mem.swap_hard_limit = virMemoryLimitTruncate(size / 1024);
     }
     return 0;
 }

diff --git a/src/openvz/openvz_conf.c b/src/openvz/openvz_conf.c
index 848e230b6365eafc9b853f5f63f6a841ab48ad48..bfa21410b2b5c73036b0483fc3b7c2037f49b7c0 100644 (file)
--- a/src/openvz/openvz_conf.c
+++ b/src/openvz/openvz_conf.c
@@ -479,12 +479,12 @@ openvzReadMemConf(virDomainDefPtr def, int veid)
             goto error;
         }
         if (barrier == LONG_MAX)
-            def->mem.soft_limit = 0ull;
+            def->mem.soft_limit = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
         else
             def->mem.soft_limit = barrier * kb_per_pages;
 
         if (limit == LONG_MAX)
-            def->mem.hard_limit = 0ull;
+            def->mem.hard_limit = VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
         else
             def->mem.hard_limit = limit * kb_per_pages;
     }

diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c
index 5a5cd8d4b2c60006e1ba227116f79dd84afc25a3..a55e6a658f7778ce39ea0a495b3344a0eb3a42fb 100644 (file)
--- a/src/openvz/openvz_driver.c
+++ b/src/openvz/openvz_driver.c
@@ -1850,7 +1850,7 @@ openvzDomainGetMemoryParameters(virDomainPtr domain,
             if (openvzDomainGetBarrierLimit(domain, name, &barrier, &limit) < 0)
                 goto cleanup;
 
-            val = (limit == LONG_MAX) ? 0ull : limit * kb_per_pages;
+            val = (limit == LONG_MAX) ? VIR_DOMAIN_MEMORY_PARAM_UNLIMITED : limit * kb_per_pages;
             if (virTypedParameterAssign(param, VIR_DOMAIN_MEMORY_HARD_LIMIT,
                                         VIR_TYPED_PARAM_ULLONG, val) < 0)
                 goto cleanup;
@@ -1861,7 +1861,7 @@ openvzDomainGetMemoryParameters(virDomainPtr domain,
             if (openvzDomainGetBarrierLimit(domain, name, &barrier, &limit) < 0)
                 goto cleanup;
 
-            val = (barrier == LONG_MAX) ? 0ull : barrier * kb_per_pages;
+            val = (barrier == LONG_MAX) ? VIR_DOMAIN_MEMORY_PARAM_UNLIMITED : barrier * kb_per_pages;
             if (virTypedParameterAssign(param, VIR_DOMAIN_MEMORY_SOFT_LIMIT,
                                         VIR_TYPED_PARAM_ULLONG, val) < 0)
                 goto cleanup;

diff --git a/src/qemu/qemu_cgroup.c b/src/qemu/qemu_cgroup.c
index f8f0e3c8405b404b85af77dc05d40876bb0ca7ee..2b5a1828741b1e07614d9f6b116320f15d5a945e 100644 (file)
--- a/src/qemu/qemu_cgroup.c
+++ b/src/qemu/qemu_cgroup.c
@@ -471,9 +471,9 @@ qemuSetupMemoryCgroup(virDomainObjPtr vm)
     qemuDomainObjPrivatePtr priv = vm->privateData;
 
     if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_MEMORY)) {
-        if (vm->def->mem.hard_limit != 0 ||
-            vm->def->mem.soft_limit != 0 ||
-            vm->def->mem.swap_hard_limit != 0) {
+        if (virMemoryLimitIsSet(vm->def->mem.hard_limit) ||
+            virMemoryLimitIsSet(vm->def->mem.soft_limit) ||
+            virMemoryLimitIsSet(vm->def->mem.swap_hard_limit)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                            _("Memory cgroup is not available on this host"));
             return -1;
@@ -482,17 +482,17 @@ qemuSetupMemoryCgroup(virDomainObjPtr vm)
         }
     }
 
-    if (vm->def->mem.hard_limit != 0 &&
-        virCgroupSetMemoryHardLimit(priv->cgroup, vm->def->mem.hard_limit) < 0)
-        return -1;
+    if (virMemoryLimitIsSet(vm->def->mem.hard_limit))
+        if (virCgroupSetMemoryHardLimit(priv->cgroup, vm->def->mem.hard_limit) < 0)
+            return -1;
 
-    if (vm->def->mem.soft_limit != 0 &&
-        virCgroupSetMemorySoftLimit(priv->cgroup, vm->def->mem.soft_limit) < 0)
-        return -1;
+    if (virMemoryLimitIsSet(vm->def->mem.soft_limit))
+        if (virCgroupSetMemorySoftLimit(priv->cgroup, vm->def->mem.soft_limit) < 0)
+            return -1;
 
-    if (vm->def->mem.swap_hard_limit != 0 &&
-        virCgroupSetMemSwapHardLimit(priv->cgroup, vm->def->mem.swap_hard_limit) < 0)
-        return -1;
+    if (virMemoryLimitIsSet(vm->def->mem.swap_hard_limit))
+        if (virCgroupSetMemSwapHardLimit(priv->cgroup, vm->def->mem.swap_hard_limit) < 0)
+            return -1;
 
     return 0;
 }

diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index ab813af0646edb8f220e799b5f0161e732351035..1510797def8c23c42e16718b651fadd3d05747ea 100644 (file)
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -8409,8 +8409,10 @@ qemuBuildCommandLine(virConnectPtr conn,
         /* If we have no cgroups then we can have no tunings that
          * require them */
 
-        if (def->mem.hard_limit || def->mem.soft_limit ||
-            def->mem.min_guarantee || def->mem.swap_hard_limit) {
+        if (virMemoryLimitIsSet(def->mem.hard_limit) ||
+            virMemoryLimitIsSet(def->mem.soft_limit) ||
+            def->mem.min_guarantee ||
+            virMemoryLimitIsSet(def->mem.swap_hard_limit)) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                            _("Memory tuning is not available in session mode"));
             goto error;
@@ -10483,7 +10485,7 @@ qemuBuildCommandLine(virConnectPtr conn,
          * space just to be safe (some finer tuning might be
          * nice, though).
          */
-        memKB = def->mem.hard_limit ?
+        memKB = virMemoryLimitIsSet(def->mem.hard_limit) ?
             def->mem.hard_limit : def->mem.max_balloon + 1024 * 1024;
         virCommandSetMaxMemLock(cmd, memKB * 1024);
     }

diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index ffa4e193d6d7167b9b6ce42368f97d23f49135ff..a79bc5ef47ce10ced1851f196338bd07ba3037f1 100644 (file)
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -9143,8 +9143,7 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
 
 #undef VIR_GET_LIMIT_PARAMETER
 
-    /* Swap hard limit must be greater than hard limit.
-     * Note that limit of 0 denotes unlimited */
+    /* Swap hard limit must be greater than hard limit. */
     if (set_swap_hard_limit || set_hard_limit) {
         unsigned long long mem_limit = vm->def->mem.hard_limit;
         unsigned long long swap_limit = vm->def->mem.swap_hard_limit;
@@ -9155,7 +9154,7 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
         if (set_hard_limit)
             mem_limit = hard_limit;
 
-        if (virCompareLimitUlong(mem_limit, swap_limit) > 0) {
+        if (mem_limit > swap_limit) {
             virReportError(VIR_ERR_INVALID_ARG, "%s",
                            _("memory hard_limit tunable value must be lower "
                              "than or equal to swap_hard_limit"));
@@ -9183,7 +9182,7 @@ qemuDomainSetMemoryParameters(virDomainPtr dom,
     QEMU_SET_MEM_PARAMETER(virCgroupSetMemorySoftLimit, soft_limit);
 
     /* set hard limit before swap hard limit if decreasing it */
-    if (virCompareLimitUlong(vm->def->mem.hard_limit, hard_limit) > 0) {
+    if (vm->def->mem.hard_limit > hard_limit) {
         QEMU_SET_MEM_PARAMETER(virCgroupSetMemoryHardLimit, hard_limit);
         /* inhibit changing the limit a second time */
         set_hard_limit = false;
@@ -9279,7 +9278,6 @@ qemuDomainGetMemoryParameters(virDomainPtr dom,
             switch (i) {
             case 0: /* fill memory hard limit here */
                 value = persistentDef->mem.hard_limit;
-                value = value ? value : VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
                 if (virTypedParameterAssign(param, VIR_DOMAIN_MEMORY_HARD_LIMIT,
                                             VIR_TYPED_PARAM_ULLONG, value) < 0)
                     goto cleanup;
@@ -9287,7 +9285,6 @@ qemuDomainGetMemoryParameters(virDomainPtr dom,
 
             case 1: /* fill memory soft limit here */
                 value = persistentDef->mem.soft_limit;
-                value = value ? value : VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
                 if (virTypedParameterAssign(param, VIR_DOMAIN_MEMORY_SOFT_LIMIT,
                                             VIR_TYPED_PARAM_ULLONG, value) < 0)
                     goto cleanup;
@@ -9295,7 +9292,6 @@ qemuDomainGetMemoryParameters(virDomainPtr dom,
 
             case 2: /* fill swap hard limit here */
                 value = persistentDef->mem.swap_hard_limit;
-                value = value ? value : VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
                 if (virTypedParameterAssign(param, VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT,
                                             VIR_TYPED_PARAM_ULLONG, value) < 0)
                     goto cleanup;

diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index 08047ce1f4ee43fdbc67cdf62645a58efa06a8c3..6ad48f7848713447684f147825b38e834bce8cb1 100644 (file)
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -1250,7 +1250,7 @@ qemuDomainAttachHostPCIDevice(virQEMUDriverPtr driver,
          * Kibibytes, but virProcessSetMaxMemLock expects the value in
          * bytes.
          */
-        memKB = vm->def->mem.hard_limit
+        memKB = virMemoryLimitIsSet(vm->def->mem.hard_limit)
             ? vm->def->mem.hard_limit
             : vm->def->mem.max_balloon + (1024 * 1024);
         virProcessSetMaxMemLock(vm->pid, memKB * 1024);

diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 20e40aa37a1ba5fdde5c467edc40e62c01a00a54..83be435a638802d0d2e878c43ca6fad6d1631e68 100644 (file)
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -2986,7 +2986,8 @@ qemuMigrationPrepareAny(virQEMUDriverPtr driver,
                                        QEMU_MIGRATION_COOKIE_NBD)))
         goto cleanup;
 
-    if (STREQ_NULLABLE(protocol, "rdma") && !vm->def->mem.hard_limit) {
+    if (STREQ_NULLABLE(protocol, "rdma") &&
+        !virMemoryLimitIsSet(vm->def->mem.hard_limit)) {
         virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                        _("cannot start RDMA migration with no memory hard "
                          "limit set"));
@@ -4102,7 +4103,7 @@ static int doNativeMigrate(virQEMUDriverPtr driver,
                              "with this QEMU binary"));
             goto cleanup;
         }
-        if (!vm->def->mem.hard_limit) {
+        if (!virMemoryLimitIsSet(vm->def->mem.hard_limit)) {
             virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                            _("cannot start RDMA migration with no memory hard "
                              "limit set"));

diff --git a/src/util/virutil.c b/src/util/virutil.c
index 599d59c4d3f926ca5d305e59d1ff0f7b2d89796b..658723b8e5ff4763ac5205978c75fc01a800dce1 100644 (file)
--- a/src/util/virutil.c
+++ b/src/util/virutil.c
@@ -2364,29 +2364,6 @@ virFindFCHostCapableVport(const char *sysfs_prefix ATTRIBUTE_UNUSED)
 
 #endif /* __linux__ */
 
-/**
- * virCompareLimitUlong:
- *
- * Compare two unsigned long long numbers. Value '0' of the arguments has a
- * special meaning of 'unlimited' and thus greater than any other value.
- *
- * Returns 0 if the numbers are equal, -1 if b is greater, 1 if a is greater.
- */
-int
-virCompareLimitUlong(unsigned long long a, unsigned long long b)
-{
-    if (a == b)
-        return 0;
-
-    if (!b)
-        return -1;
-
-    if (a == 0 || a > b)
-        return 1;
-
-    return -1;
-}
-
 /**
  * virParseOwnershipIds:
  *

diff --git a/src/util/virutil.h b/src/util/virutil.h
index b8f503681e39b43e5b126ae118093b4a4c41845f..25524e21e256091dbbf7b9f71027e24352d89cc1 100644 (file)
--- a/src/util/virutil.h
+++ b/src/util/virutil.h
@@ -210,8 +210,6 @@ char *virGetFCHostNameByWWN(const char *sysfs_prefix,
 
 char *virFindFCHostCapableVport(const char *sysfs_prefix);
 
-int virCompareLimitUlong(unsigned long long a, unsigned long long b);
-
 int virParseOwnershipIds(const char *label, uid_t *uidPtr, gid_t *gidPtr);
 
 const char *virGetEnvBlockSUID(const char *name);

diff --git a/tests/qemuxml2argvdata/qemuxml2argv-memtune.xml b/tests/qemuxml2argvdata/qemuxml2argv-memtune.xml
index 1a244f00980834e4ed5113c3b4d6379615f0ce83..f838d9512fdb60d435a9db22424ed47a02a26f29 100644 (file)
--- a/tests/qemuxml2argvdata/qemuxml2argv-memtune.xml
+++ b/tests/qemuxml2argvdata/qemuxml2argv-memtune.xml
@@ -5,7 +5,7 @@
   <currentMemory unit='KiB'>219136</currentMemory>
   <memtune>
     <hard_limit unit='KiB'>512000</hard_limit>
-    <soft_limit unit='bytes'>131071999</soft_limit>
+    <soft_limit unit='bytes'>0</soft_limit>
     <swap_hard_limit unit='KB'>1048576</swap_hard_limit>
   </memtune>
   <vcpu placement='static'>1</vcpu>

diff --git a/tests/qemuxml2xmloutdata/qemuxml2xmlout-memtune.xml b/tests/qemuxml2xmloutdata/qemuxml2xmlout-memtune.xml
index 92dcacf6ea43b7e2a6f8c7c56582b886b50478e6..07989d18cbe8c6723bcd254467de9e8734ba6768 100644 (file)
--- a/tests/qemuxml2xmloutdata/qemuxml2xmlout-memtune.xml
+++ b/tests/qemuxml2xmloutdata/qemuxml2xmlout-memtune.xml
@@ -5,7 +5,7 @@
   <currentMemory unit='KiB'>219136</currentMemory>
   <memtune>
     <hard_limit unit='KiB'>512000</hard_limit>
-    <soft_limit unit='KiB'>128000</soft_limit>
+    <soft_limit unit='KiB'>0</soft_limit>
     <swap_hard_limit unit='KiB'>1024000</swap_hard_limit>
   </memtune>
   <vcpu placement='static'>1</vcpu>