Changeset 41842 in vbox for trunk/src/VBox/Frontends/VBoxManage

Timestamp:

Jun 20, 2012 11:46:31 AM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

78670

Message:

Main,VBoxManage,docs: bandwidth units changed to bytes (#5582)

Location:

trunk/src/VBox/Frontends/VBoxManage

Files:

• VBoxManageBandwidthControl.cpp (modified) (8 diffs)
• VBoxManageHelp.cpp (modified) (1 diff)
• VBoxManageInfo.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp

@@ -44 +44 @@
 
 /**
+ * Parses a string in the following format "n[k|m|g|K|M|G]". Stores the value
+ * of n expressed in bytes to *pLimit. k meas kilobit, while K means kilobyte.
+ *
+ * @returns Error message or NULL if successful.
+ * @param   pcszLimit       The string to parse.
+ * @param   pLimit          Where to store the result.
+ */
+static const char *parseLimit(const char *pcszLimit, LONG64 *pLimit)
+{
+    int iMultiplier = _1M;
+    char *pszNext = NULL;
+    int rc = RTStrToInt64Ex(pcszLimit, &pszNext, 10, pLimit);
+
+    switch (rc)
+    {
+        case VINF_SUCCESS:
+            break;
+        case VWRN_NUMBER_TOO_BIG:
+            return "Limit is too big\n";
+        case VWRN_TRAILING_CHARS:
+            switch (*pszNext)
+            {
+                case 'G': iMultiplier = _1G;       break;
+                case 'M': iMultiplier = _1M;       break;
+                case 'K': iMultiplier = _1K;       break;
+                case 'g': iMultiplier = 125000000; break;
+                case 'm': iMultiplier = 125000;    break;
+                case 'k': iMultiplier = 125;       break;
+                default:  return "Invalid unit suffix. Valid suffixes are: k, m, g, K, M, G\n";
+            }
+            break;
+        case VWRN_TRAILING_SPACES:
+            return "Trailing spaces in limit!\n";
+        case VERR_NO_DIGITS:
+            return "No digits in limit specifier\n";
+        default:
+            return "Invalid limit specifier\n";
+    }
+    if (*pLimit <= 0)
+        return "Limit must be positive\n";
+    if (*pLimit > INT64_MAX / iMultiplier)
+        return "Limit is too big\n";
+    *pLimit *= iMultiplier;
+
+    return NULL;
+}
+
+/**
  * Handles the 'bandwidthctl myvm add' sub-command.
  * @returns Exit code.
@@ -55 +103 @@
         {
             { "--type",   't', RTGETOPT_REQ_STRING },
-            { "--limit",  'l', RTGETOPT_REQ_UINT32 }
+            { "--limit",  'l', RTGETOPT_REQ_STRING }
         };
 
@@ -61 +109 @@
     Bstr name(a->argv[2]);
     const char *pszType  = NULL;
-    ULONG cMaxMbPerSec   = UINT32_MAX;
+    LONG64 cMaxBytesPerSec   = INT64_MAX;
 
     int c;
@@ -85 +133 @@
             case 'l': // limit
             {
-                cMaxMbPerSec = ValueUnion.u32;
+                if (ValueUnion.psz)
+                {
+                    const char *pcszError = parseLimit(ValueUnion.psz, &cMaxBytesPerSec);
+                    if (pcszError)
+                    {
+                        errorArgument(pcszError);
+                        return RTEXITCODE_FAILURE;
+                    }
+                }
+                else
+                    rc = E_FAIL;
                 break;
             }
@@ -110 +168 @@
     }
     
-    CHECK_ERROR2_RET(bwCtrl, CreateBandwidthGroup(name.raw(), enmType, cMaxMbPerSec), RTEXITCODE_FAILURE);
+    CHECK_ERROR2_RET(bwCtrl, CreateBandwidthGroup(name.raw(), enmType, cMaxBytesPerSec), RTEXITCODE_FAILURE);
 
     return RTEXITCODE_SUCCESS;
@@ -126 +184 @@
     static const RTGETOPTDEF g_aBWCtlAddOptions[] =
         {
-            { "--limit",  'l', RTGETOPT_REQ_UINT32 }
+            { "--limit",  'l', RTGETOPT_REQ_STRING }
         };
 
 
     Bstr name(a->argv[2]);
-    ULONG cMaxMbPerSec   = UINT32_MAX;
+    LONG64 cMaxBytesPerSec   = INT64_MAX;
 
     int c;
@@ -146 +204 @@
             case 'l': // limit
             {
-                cMaxMbPerSec = ValueUnion.u32;
+                if (ValueUnion.psz)
+                {
+                    const char *pcszError = parseLimit(ValueUnion.psz, &cMaxBytesPerSec);
+                    if (pcszError)
+                    {
+                        errorArgument(pcszError);
+                        return RTEXITCODE_FAILURE;
+                    }
+                }
+                else
+                    rc = E_FAIL;
                 break;
             }
@@ -160 +228 @@
 
     
-    if (cMaxMbPerSec != UINT32_MAX)
+    if (cMaxBytesPerSec != INT64_MAX)
     {
         ComPtr<IBandwidthGroup> bwGroup;
         CHECK_ERROR2_RET(bwCtrl, GetBandwidthGroup(name.raw(), bwGroup.asOutParam()), RTEXITCODE_FAILURE);
         if (SUCCEEDED(rc))
-            CHECK_ERROR2_RET(bwGroup, COMSETTER(MaxMbPerSec)(cMaxMbPerSec), RTEXITCODE_FAILURE);
+            CHECK_ERROR2_RET(bwGroup, COMSETTER(MaxBytesPerSec)(cMaxBytesPerSec), RTEXITCODE_FAILURE);
     }
 

trunk/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp

@@ -514 +514 @@
         RTStrmPrintf(pStrm,
                      "VBoxManage bandwidthctl     <uuid|vmname>\n"
-                     "                            add <name> --type <disk|network> --limit <megabytes per second> |\n"
-                     "                            set <name> --limit <megabytes per second> |\n"
+                     "                            add <name> --type disk|network --limit <megabytes per second>[k|m|g|K|M|G] |\n"
+                     "                            set <name> --limit <megabytes per second>[k|m|g|K|M|G] |\n"
                      "                            remove <name> |\n"
                      "                            list [--machinereadable]\n"
+                     "                            (limit units: k=kilobit, m=megabit, g=gigabit, K=kilobyte, M=megabyte, G=gigabyte)\n"
                      "\n");
 

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -260 +260 @@
     {
         Bstr strName;
-        ULONG cMaxMbPerSec;
+        LONG64 cMaxBytesPerSec;
         BandwidthGroupType_T enmType;
 
         CHECK_ERROR_RET(bwGroups[i], COMGETTER(Name)(strName.asOutParam()), rc);
         CHECK_ERROR_RET(bwGroups[i], COMGETTER(Type)(&enmType), rc);
-        CHECK_ERROR_RET(bwGroups[i], COMGETTER(MaxMbPerSec)(&cMaxMbPerSec), rc);
+        CHECK_ERROR_RET(bwGroups[i], COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec), rc);
 
         const char *pszType = bwGroupTypeToString(enmType);
         if (details == VMINFO_MACHINEREADABLE)
-            RTPrintf("BandwidthGroup%zu=%ls,%s,%d\n", i, strName.raw(), pszType, cMaxMbPerSec);
+            RTPrintf("BandwidthGroup%zu=%ls,%s,%lld\n", i, strName.raw(), pszType, cMaxBytesPerSec);
         else
-            RTPrintf("Name: '%ls', Type: %s, Limit: %d Mbytes/sec\n", strName.raw(), pszType, cMaxMbPerSec);
+        {
+            const char *pszUnits = "";
+            LONG64 cBytes = cMaxBytesPerSec;
+            if (!(cBytes % _1G))
+            {
+                pszUnits = "G";
+                cBytes /= _1G;
+            }
+            else if (!(cBytes % _1M))
+            {
+                pszUnits = "M";
+                cBytes /= _1M;
+            }
+            else if (!(cBytes % _1K))
+            {
+                pszUnits = "K";
+                cBytes /= _1K;
+            }
+            const char *pszNetUnits = NULL;
+            if (enmType == BandwidthGroupType_Network)
+            {
+                /*
+                 * We want to report network rate limit in bits/s, not bytes.
+                 * Only if it cannot be express it in kilobits we will fall
+                 * back to reporting it in bytes.
+                 */
+                LONG64 cBits = cMaxBytesPerSec;
+                if (!(cBits % 125))
+                {
+                    cBits /= 125;
+                    pszNetUnits = "k";
+                    if (!(cBits % 1000000))
+                    {
+                        cBits /= 1000000;
+                        pszNetUnits = "g";
+                    }
+                    else if (!(cBits % 1000))
+                    {
+                        cBits /= 1000;
+                        pszNetUnits = "m";
+                    }
+                    RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbits/sec (%lld %sbytes/sec)\n", strName.raw(), pszType, cBits, pszNetUnits, cBytes, pszUnits);
+                }
+            }
+            if (!pszNetUnits)
+                RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbytes/sec\n", strName.raw(), pszType, cBytes, pszUnits);
+        }
     }
     if (details != VMINFO_MACHINEREADABLE)