Changeset 85574 in vbox for trunk

Timestamp:

Jul 31, 2020 12:45:16 PM (5 years ago)

Author:

vboxsync

Message:

Main: Added ISystemProperties::getCPUProfiles.

Location:

trunk/src/VBox/Main

Files:

• Makefile.kmk (modified) (1 diff)
• idl/VirtualBox.xidl (modified) (5 diffs)
• include/CPUProfileImpl.h (added)
• include/SystemPropertiesImpl.h (modified) (4 diffs)
• src-server/CPUProfileImpl.cpp (added)
• src-server/SystemPropertiesImpl.cpp (modified) (4 diffs)

trunk/src/VBox/Main/Makefile.kmk

@@ -564 +564 @@
         src-server/ClientToken.cpp \
         src-server/CloudProviderManagerImpl.cpp \
+        src-server/CPUProfileImpl.cpp \
         src-server/DataStreamImpl.cpp \
         src-server/DHCPServerImpl.cpp \

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -978 +978 @@
         The session is being unlocked.
       </desc>
+    </const>
+  </enum>
+
+  <enum
+    name="CPUArchitecture"
+    uuid="4a2c9915-12f1-43b2-bb84-e4bd4d5ca227"
+    >
+    <desc>Basic CPU architecture types.</desc>
+    <const name="Any"                 value="0">
+      <desc>Matches any CPU architecture.</desc>
+    </const>
+    <const name="x86"                 value="1">
+      <desc>32-bit (and 16-bit) x86.</desc>
+    </const>
+    <const name="AMD64"               value="2">
+      <desc>64-bit x86.  (Also known as x86-64 or x64.)</desc>
     </const>
   </enum>
@@ -6548 +6564 @@
         to change.
 
-        The profiles are found in src/VBox/VMM/VMMR3/cpus/.
+        Use the <link to="ISystemProperties::getCPUProfiles" /> method to get
+        currently available CPU profiles.
       </desc>
     </attribute>
@@ -10729 +10746 @@
 
   <!--
+  // ICPUProfile
+  /////////////////////////////////////////////////////////////////////////
+  -->
+  <interface
+    name="ICPUProfile"
+    extends="$unknown"
+    uuid="b7fda727-7a08-46ee-8dd8-f8d7308b519c"
+    wsmap="managed"
+    reservedMethods="4" reservedAttributes="8"
+    >
+    <desc>CPU profile. Immutable.</desc>
+    <attribute name="name" type="wstring" readonly="yes">
+      <desc>The name.</desc>
+    </attribute>
+    <attribute name="fullName" type="wstring" readonly="yes">
+      <desc>The full name.</desc>
+    </attribute>
+    <attribute name="architecture" type="CPUArchitecture" readonly="yes">
+      <desc>The CPU architecture.</desc>
+    </attribute>
+  </interface>
+
+  <!--
   // ISystemProperties
   /////////////////////////////////////////////////////////////////////////
@@ -10749 +10789 @@
     name="ISystemProperties"
     extends="$unknown"
-    uuid="027bc463-929c-40e8-bf16-fea557cd8e7e"
+    uuid="81c55eb1-d584-41a7-aa0b-08b71cddd773"
     wsmap="managed"
     reservedMethods="4" reservedAttributes="16"
@@ -11457 +11497 @@
       <param name="maxInstances" type="unsigned long" dir="return">
         <desc>The maximum number of instances for the given USB controller type.</desc>
+      </param>
+    </method>
+
+    <method name="getCPUProfiles">
+      <desc>Returns CPU profiles matching the given criteria.</desc>
+
+      <param name="architecture" type="CPUArchitecture" dir="in">
+        <desc>The architecture to get profiles for. Required.</desc>
+      </param>
+      <param name="namePattern" type="wstring" dir="in">
+        <desc>Name pattern. Simple wildcard matching using asterisk (*) and
+          question mark (?).</desc>
+      </param>
+      <param name="profiles" type="ICPUProfile" safearray="yes" dir="return">
+        <desc>The matching CPU profiles.</desc>
       </param>
     </method>

trunk/src/VBox/Main/include/SystemPropertiesImpl.h

@@ -27 +27 @@
 #include "SystemPropertiesWrap.h"
 
+class CPUProfile;
 
 namespace settings
@@ -38 +39 @@
 public:
     typedef std::list<ComObjPtr<MediumFormat> > MediumFormatList;
+    typedef std::list<ComObjPtr<CPUProfile> > CPUProfileList_T;
 
     DECLARE_EMPTY_CTOR_DTOR(SystemProperties)
@@ -169 +171 @@
                                                USBControllerType_T aType,
                                                ULONG *aMaxInstances) RT_OVERRIDE;
+    HRESULT getCPUProfiles(CPUArchitecture_T aArchitecture, const com::Utf8Str &aNamePattern,
+                           std::vector<ComPtr<ICPUProfile> > &aProfiles) RT_OVERRIDE;
 
     HRESULT i_getUserHomeDirectory(Utf8Str &strPath);
@@ -188 +192 @@
     MediumFormatList m_llMediumFormats;
 
+    bool                m_fLoadedX86CPUProfiles;    /**< Set if we've loaded the x86 and AMD64 CPU profiles. */
+    CPUProfileList_T    m_llCPUProfiles;            /**< List of loaded CPU profiles. */
+
     friend class VirtualBox;
 };

trunk/src/VBox/Main/src-server/SystemPropertiesImpl.cpp

@@ -23 +23 @@
 # include "ExtPackManagerImpl.h"
 #endif
+#include "CPUProfileImpl.h"
 #include "AutoCaller.h"
 #include "Global.h"
@@ -42 +43 @@
 #include <VBox/settings.h>
 #include <VBox/vd.h>
+#include <VBox/vmm/cpum.h>
 
 // defines
@@ -50 +52 @@
 
 SystemProperties::SystemProperties()
-    : mParent(NULL),
-      m(new settings::SystemProperties)
+    : mParent(NULL)
+    , m(new settings::SystemProperties)
+    , m_fLoadedX86CPUProfiles(false)
 {
 }
@@ -710 +713 @@
     return S_OK;
 }
+
+HRESULT SystemProperties::getCPUProfiles(CPUArchitecture_T aArchitecture, const com::Utf8Str &aNamePattern,
+                                         std::vector<ComPtr<ICPUProfile> > &aProfiles)
+{
+    /*
+     * Validate and adjust the architecture.
+     */
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    CPUArchitecture_T enmSecondaryArch = aArchitecture;
+    bool fLoaded;
+    switch (aArchitecture)
+    {
+        case CPUArchitecture_Any:
+            aArchitecture = CPUArchitecture_AMD64;
+            RT_FALL_THROUGH();
+        case CPUArchitecture_AMD64:
+            enmSecondaryArch = CPUArchitecture_x86;
+            RT_FALL_THROUGH();
+        case CPUArchitecture_x86:
+            fLoaded = m_fLoadedX86CPUProfiles;
+            break;
+        default:
+            return setError(E_INVALIDARG, tr("Invalid or unsupported architecture value: %d"), aArchitecture);
+    }
+
+    /*
+     * Do we need to load the profiles?
+     */
+    HRESULT hrc;
+    if (fLoaded)
+        hrc = S_OK;
+    else
+    {
+        alock.release();
+        AutoWriteLock alockWrite(this COMMA_LOCKVAL_SRC_POS);
+
+        /*
+         * Translate the architecture to a VMM module handle.
+         */
+        const char *pszVMM;
+        switch (aArchitecture)
+        {
+            case CPUArchitecture_AMD64:
+            case CPUArchitecture_x86:
+                pszVMM = "VBoxVMM";
+                fLoaded = m_fLoadedX86CPUProfiles;
+                break;
+            default:
+                AssertFailedReturn(E_INVALIDARG);
+        }
+        if (fLoaded)
+            hrc = S_OK;
+        else
+        {
+            char szPath[RTPATH_MAX];
+            int vrc = RTPathAppPrivateArch(szPath, sizeof(szPath));
+            if (RT_SUCCESS(vrc))
+                vrc = RTPathAppend(szPath, sizeof(szPath), pszVMM);
+            if (RT_SUCCESS(vrc))
+                vrc = RTStrCat(szPath, sizeof(szPath), RTLdrGetSuff());
+            if (RT_SUCCESS(vrc))
+            {
+                RTLDRMOD hMod = NIL_RTLDRMOD;
+                vrc = RTLdrLoad(szPath, &hMod);
+                if (RT_SUCCESS(vrc))
+                {
+                    /*
+                     * Resolve the CPUMDb APIs we need.
+                     */
+                    PFNCPUMDBGETENTRIES      pfnGetEntries
+                        = (PFNCPUMDBGETENTRIES)RTLdrGetFunction(hMod, "CPUMR3DbGetEntries");
+                    PFNCPUMDBGETENTRYBYINDEX pfnGetEntryByIndex
+                        = (PFNCPUMDBGETENTRYBYINDEX)RTLdrGetFunction(hMod, "CPUMR3DbGetEntryByIndex");
+                    if (pfnGetEntries && pfnGetEntryByIndex)
+                    {
+                        size_t const cExistingProfiles = m_llCPUProfiles.size();
+
+                        /*
+                         * Instantate the profiles.
+                         */
+                        hrc = S_OK;
+                        uint32_t const cEntries = pfnGetEntries();
+                        for (uint32_t i = 0; i < cEntries; i++)
+                        {
+                            PCCPUMDBENTRY pDbEntry = pfnGetEntryByIndex(i);
+                            AssertBreakStmt(pDbEntry, hrc = setError(E_UNEXPECTED, "CPUMR3DbGetEntryByIndex failed for %i", i));
+
+                            ComObjPtr<CPUProfile> ptrProfile;
+                            hrc = ptrProfile.createObject();
+                            if (SUCCEEDED(hrc))
+                            {
+                                hrc = ptrProfile->initFromDbEntry(pDbEntry);
+                                if (SUCCEEDED(hrc))
+                                {
+                                    try
+                                    {
+                                        m_llCPUProfiles.push_back(ptrProfile);
+                                        continue;
+                                    }
+                                    catch (std::bad_alloc &)
+                                    {
+                                        hrc = E_OUTOFMEMORY;
+                                    }
+                                }
+                            }
+                            break;
+                        }
+
+                        /*
+                         * On success update the flag and retake the read lock.
+                         * If we fail, drop the profiles we added to the list.
+                         */
+                        if (SUCCEEDED(hrc))
+                        {
+                            switch (aArchitecture)
+                            {
+                                case CPUArchitecture_AMD64:
+                                case CPUArchitecture_x86:
+                                    m_fLoadedX86CPUProfiles = true;
+                                    break;
+                                default:
+                                    AssertFailedStmt(hrc = E_INVALIDARG);
+                            }
+
+                            alockWrite.release();
+                            alock.acquire();
+                        }
+                        else
+                            m_llCPUProfiles.resize(cExistingProfiles);
+                    }
+                    else
+                        hrc = setErrorVrc(VERR_SYMBOL_NOT_FOUND,
+                                          tr("'%s' is missing symbols: CPUMR3DbGetEntries, CPUMR3DbGetEntryByIndex"), szPath);
+                    RTLdrClose(hMod);
+                }
+                else
+                    hrc = setErrorVrc(vrc, tr("Failed to construct load '%s': %Rrc"), szPath, vrc);
+            }
+            else
+                hrc = setErrorVrc(vrc, tr("Failed to construct path to the VMM DLL/Dylib/SharedObject: %Rrc"), vrc);
+        }
+    }
+    if (SUCCEEDED(hrc))
+    {
+        /*
+         * Return the matching profiles.
+         */
+        /* Count matches: */
+        size_t cMatches = 0;
+        for (CPUProfileList_T::const_iterator it = m_llCPUProfiles.begin(); it != m_llCPUProfiles.end(); ++it)
+            if ((*it)->i_match(aArchitecture, enmSecondaryArch, aNamePattern))
+                cMatches++;
+
+        /* Resize the output array. */
+        try
+        {
+            aProfiles.resize(cMatches);
+        }
+        catch (std::bad_alloc &)
+        {
+            aProfiles.resize(0);
+            hrc = E_OUTOFMEMORY;
+        }
+
+        /* Get the return objects: */
+        if (SUCCEEDED(hrc) && cMatches > 0)
+        {
+            size_t iMatch = 0;
+            for (CPUProfileList_T::const_iterator it = m_llCPUProfiles.begin(); it != m_llCPUProfiles.end(); ++it)
+                if ((*it)->i_match(aArchitecture, enmSecondaryArch, aNamePattern))
+                {
+                    AssertBreakStmt(iMatch < cMatches, hrc = E_UNEXPECTED);
+                    hrc = (*it).queryInterfaceTo(aProfiles[iMatch].asOutParam());
+                    if (SUCCEEDED(hrc))
+                        iMatch++;
+                    else
+                        break;
+                }
+            AssertStmt(iMatch == cMatches || FAILED(hrc), hrc = E_UNEXPECTED);
+        }
+    }
+    return hrc;
+}
+
 
 HRESULT SystemProperties::getDefaultMachineFolder(com::Utf8Str &aDefaultMachineFolder)