Changeset 69654 in vbox for trunk/src/VBox

Timestamp:

Nov 10, 2017 7:22:45 PM (7 years ago)

Author:

vboxsync

Message:

VBoxCpuReporter: cleanups

Location:

trunk/src/VBox/VMM/tools

Files:

• Makefile.kmk (modified) (1 diff)
• VBoxCpuReport.cpp (modified) (19 diffs)
• VBoxCpuReport.h (modified) (1 diff)
• VBoxCpuReportMsrLinux.cpp (moved) (moved from trunk/src/VBox/VMM/tools/MsrLinux.cpp ) (6 diffs)
• VBoxCpuReportMsrSup.cpp (moved) (moved from trunk/src/VBox/VMM/tools/MsrSup.cpp ) (1 diff)

trunk/src/VBox/VMM/tools/Makefile.kmk

@@ -60 +60 @@
 VBoxCpuReport_SOURCES   = \
         VBoxCpuReport.cpp \
-        MsrSup.cpp        \
-       ../VMMR3/CPUMR3CpuId.cpp
-VBoxCpuReport_SOURCES.linux = MsrLinux.cpp
+        VBoxCpuReportMsrSup.cpp \
+        ../VMMR3/CPUMR3CpuId.cpp
+VBoxCpuReport_SOURCES.linux = \
+        VBoxCpuReportMsrLinux.cpp
 VBoxCpuReport_DEFS.linux    = VBCR_HAVE_PLATFORM_MSR_PROBER
 VBoxCpuReport_LIBS      = \

trunk/src/VBox/VMM/tools/VBoxCpuReport.cpp

@@ -79 +79 @@
 static uint64_t         g_uMsrIntelP6FsbFrequency = UINT64_MAX;
 
-/** MSR prober routines. */
-static VBMSRFNS         g_MsrAcc;
-/** Wheter MSR prober can read/modify/restore MSRs more or less
- *  atomically, without allowing other code to be executed. */
-static bool             g_fAtomicMsrMod;
+/** The MSR accessors interface. */
+static VBCPUREPMSRACCESSORS g_MsrAcc;
+
+
 
 void vbCpuRepDebug(const char *pszMsg, ...)
@@ -226 +225 @@
 {
     bool fGp;
-    int rc = g_MsrAcc.msrWrite(uMsr, NIL_RTCPUID, uValue, &fGp);
+    int rc = g_MsrAcc.pfnMsrWrite(uMsr, NIL_RTCPUID, uValue, &fGp);
     AssertRC(rc);
     return RT_SUCCESS(rc) && !fGp;
@@ -237 +236 @@
     *puValue = 0;
     bool fGp;
-    int rc = g_MsrAcc.msrRead(uMsr, NIL_RTCPUID, puValue, &fGp);
+    int rc = g_MsrAcc.pfnMsrProberRead(uMsr, NIL_RTCPUID, puValue, &fGp);
     AssertRC(rc);
     return RT_SUCCESS(rc) && !fGp;
@@ -247 +246 @@
 {
     SUPMSRPROBERMODIFYRESULT Result;
-    int rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, UINT64_MAX, 0, &Result);
+    int rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, UINT64_MAX, 0, &Result);
     return RT_SUCCESS(rc)
         && !Result.fBeforeGp
@@ -260 +259 @@
 {
     SUPMSRPROBERMODIFYRESULT Result;
-    int rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, 0, 0, &Result);
+    int rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, 0, 0, &Result);
     return RT_SUCCESS(rc)
         && !Result.fBeforeGp
@@ -288 +287 @@
         /* Set it. */
         SUPMSRPROBERMODIFYRESULT ResultSet;
-        int rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, ~fBitMask, fBitMask, &ResultSet);
+        int rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, ~fBitMask, fBitMask, &ResultSet);
         if (RT_FAILURE(rc))
-            return RTMsgErrorRc(rc, "msrModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, fBitMask, rc);
+            return RTMsgErrorRc(rc, "pfnMsrProberModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, fBitMask, rc);
 
         /* Clear it. */
         SUPMSRPROBERMODIFYRESULT ResultClear;
-        rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, ~fBitMask, 0, &ResultClear);
+        rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, ~fBitMask, 0, &ResultClear);
         if (RT_FAILURE(rc))
-            return RTMsgErrorRc(rc, "msrModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, 0, rc);
+            return RTMsgErrorRc(rc, "pfnMsrProberModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, 0, rc);
 
         if (ResultSet.fModifyGp || ResultClear.fModifyGp)
@@ -331 +330 @@
     /* Set it. */
     SUPMSRPROBERMODIFYRESULT ResultSet;
-    int rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, ~fBitMask, fBitMask, &ResultSet);
+    int rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, ~fBitMask, fBitMask, &ResultSet);
     if (RT_FAILURE(rc))
-        return RTMsgErrorRc(-2, "msrModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, fBitMask, rc);
+        return RTMsgErrorRc(-2, "pfnMsrProberModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, fBitMask, rc);
 
     /* Clear it. */
     SUPMSRPROBERMODIFYRESULT ResultClear;
-    rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, ~fBitMask, 0, &ResultClear);
+    rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, ~fBitMask, 0, &ResultClear);
     if (RT_FAILURE(rc))
-        return RTMsgErrorRc(-2, "msrModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, 0, rc);
+        return RTMsgErrorRc(-2, "pfnMsrProberModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, ~fBitMask, 0, rc);
 
     if (ResultSet.fModifyGp || ResultClear.fModifyGp)
@@ -370 +369 @@
 {
     SUPMSRPROBERMODIFYRESULT Result;
-    int rc = g_MsrAcc.msrModify(uMsr, NIL_RTCPUID, fAndMask, fOrMask, &Result);
+    int rc = g_MsrAcc.pfnMsrProberModify(uMsr, NIL_RTCPUID, fAndMask, fOrMask, &Result);
     if (RT_FAILURE(rc))
     {
-        RTMsgError("g_MsrAcc.msrModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, fAndMask, fOrMask, rc);
+        RTMsgError("g_MsrAcc.pfnMsrProberModify(%#x,,%#llx,%#llx,): %Rrc", uMsr, fAndMask, fOrMask, rc);
         return false;
     }
@@ -538 +537 @@
                 uint64_t uValue = 0;
                 bool     fGp    = true;
-                int rc = g_MsrAcc.msrRead(uMsr, NIL_RTCPUID, &uValue, &fGp);
+                int rc = g_MsrAcc.pfnMsrProberRead(uMsr, NIL_RTCPUID, &uValue, &fGp);
                 if (RT_FAILURE(rc))
                 {
                     RTMemFree(*ppaMsrs);
                     *ppaMsrs = NULL;
-                    return RTMsgErrorRc(rc, "msrRead failed on %#x: %Rrc\n", uMsr, rc);
+                    return RTMsgErrorRc(rc, "pfnMsrProberRead failed on %#x: %Rrc\n", uMsr, rc);
                 }
 
@@ -569 +568 @@
 #endif
                     fGp = true;
-                    rc = g_MsrAcc.msrWrite(uMsr, NIL_RTCPUID, 0, &fGp);
+                    rc = g_MsrAcc.pfnMsrProberWrite(uMsr, NIL_RTCPUID, 0, &fGp);
                     if (RT_FAILURE(rc))
                     {
                         RTMemFree(*ppaMsrs);
                         *ppaMsrs = NULL;
-                        return RTMsgErrorRc(rc, "msrWrite failed on %#x: %Rrc\n", uMsr, rc);
+                        return RTMsgErrorRc(rc, "pfnMsrProberWrite failed on %#x: %Rrc\n", uMsr, rc);
                     }
                     uValue = 0;
@@ -2558 +2557 @@
          */
         case 0x00000010: /* IA32_TIME_STAMP_COUNTER */
-            if (!g_fAtomicMsrMod)
+            if (!g_MsrAcc.fAtomic)
                 return VBCPUREPBADNESS_BOND_VILLAIN;
             break;
@@ -2575 +2574 @@
         case 0xc0000101: /* AMD64_GS_BASE */
         case 0xc0000102: /* AMD64_KERNEL_GS_BASE */
-            if (!g_fAtomicMsrMod)
+            if (!g_MsrAcc.fAtomic)
                 return VBCPUREPBADNESS_MIGHT_BITE;
             break;
@@ -3364 +3363 @@
 
     /* If the OS uses the APIC, we have to be super careful. */
-    if (!g_fAtomicMsrMod)
+    if (!g_MsrAcc.fAtomic)
         fSkipMask |= UINT64_C(0x0000000ffffff000);
 
@@ -3394 +3393 @@
 
     /* If the OS is using MONITOR/MWAIT we'd better not disable it! */
-    if (!g_fAtomicMsrMod)
+    if (!g_MsrAcc.fAtomic)
         fSkipMask |= RT_BIT(18);
 
@@ -3692 +3691 @@
     {
         fSkipMask |= MSR_K6_EFER_LME;
-        if (!g_fAtomicMsrMod && (uValue & MSR_K6_EFER_SCE))
+        if (!g_MsrAcc.fAtomic && (uValue & MSR_K6_EFER_SCE))
             fSkipMask |= MSR_K6_EFER_SCE;
     }
@@ -4404 +4403 @@
      * First try the the support library (also checks if we can really read MSRs).
      */
-    int rc = SupDrvMsrProberInit(&g_MsrAcc, &g_fAtomicMsrMod);
+    int rc = VbCpuRepMsrProberInitSupDrv(&g_MsrAcc);
     if (RT_FAILURE(rc))
     {
 #ifdef VBCR_HAVE_PLATFORM_MSR_PROBER
         /* Next try a platform-specific interface. */
-        rc = PlatformMsrProberInit(&g_MsrAcc, &g_fAtomicMsrMod);
+        rc = VbCpuRepMsrProberInitPlatform(&g_MsrAcc);
 #endif
         if (RT_FAILURE(rc))
@@ -4420 +4419 @@
     uint64_t uValue;
     bool     fGp;
-    rc = g_MsrAcc.msrRead(MSR_IA32_TSC, NIL_RTCPUID, &uValue, &fGp);
+    rc = g_MsrAcc.pfnMsrProberRead(MSR_IA32_TSC, NIL_RTCPUID, &uValue, &fGp);
     if (RT_FAILURE(rc))
     {
@@ -4427 +4426 @@
     }
     vbCpuRepDebug("MSR_IA32_TSC: %#llx fGp=%RTbool\n", uValue, fGp);
-    rc = g_MsrAcc.msrRead(0xdeadface, NIL_RTCPUID, &uValue, &fGp);
+    rc = g_MsrAcc.pfnMsrProberRead(0xdeadface, NIL_RTCPUID, &uValue, &fGp);
     vbCpuRepDebug("0xdeadface: %#llx fGp=%RTbool rc=%Rrc\n", uValue, fGp, rc);
 
@@ -4485 +4484 @@
         paMsrs = NULL;
     }
-    g_MsrAcc.msrProberTerm();
+    if (g_MsrAcc.pfnTerm)
+        g_MsrAcc.pfnTerm();
     RT_ZERO(g_MsrAcc);
     return rc;

trunk/src/VBox/VMM/tools/VBoxCpuReport.h

@@ -16 +16 @@
  */
 
-typedef struct VBMSRFNS {
-   int (*msrRead)(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue, bool *pfGp);
-   int (*msrWrite)(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue, bool *pfGp);
-   int (*msrModify)(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask, PSUPMSRPROBERMODIFYRESULT pResult);
-   int (*msrProberTerm)(void);
-} VBMSRFNS;
+
+#ifndef ___VBoxCpuReport_h___
+#define ___VBoxCpuReport_h___
+
+#include <VBox/sup.h>
+
+RT_C_DECLS_BEGIN
+
+typedef struct VBCPUREPMSRACCESSORS
+{
+    /** Wheter MSR prober can read/modify/restore MSRs more or less
+     *  atomically, without allowing other code to be executed. */
+    bool                    fAtomic;
+    /** @copydoc SUPR3MsrProberRead  */
+    DECLCALLBACKMEMBER(int, pfnMsrProberRead)(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue, bool *pfGp);
+    /** @copydoc SUPR3MsrProberWrite  */
+    DECLCALLBACKMEMBER(int, pfnMsrProberWrite)(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue, bool *pfGp);
+    /** @copydoc SUPR3MsrProberModify */
+    DECLCALLBACKMEMBER(int, pfnMsrProberModify)(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask,
+                                                PSUPMSRPROBERMODIFYRESULT pResult);
+    /** Termination callback, optional. */
+    DECLCALLBACKMEMBER(void, pfnTerm)(void);
+} VBCPUREPMSRACCESSORS;
+typedef VBCPUREPMSRACCESSORS *PVBCPUREPMSRACCESSORS;
 
 extern void vbCpuRepDebug(const char *pszMsg, ...);
 extern void vbCpuRepPrintf(const char *pszMsg, ...);
-extern int SupDrvMsrProberInit(VBMSRFNS *fnsMsr, bool *pfAtomicMsrMod);
-extern int PlatformMsrProberInit(VBMSRFNS *fnsMsr, bool *pfAtomicMsrMod);
+extern int  VbCpuRepMsrProberInitSupDrv(PVBCPUREPMSRACCESSORS pMsrAccessors);
+extern int  VbCpuRepMsrProberInitPlatform(PVBCPUREPMSRACCESSORS pMsrAccessors);
 
+RT_C_DECLS_END
+
+#endif
+

trunk/src/VBox/VMM/tools/VBoxCpuReportMsrLinux.cpp

@@ -20 +20 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
-#include <iprt/ctype.h>
+#include "VBoxCpuReport.h"
+
+#include <iprt/file.h>
 #include <iprt/thread.h>
 
-#include <VBox/sup.h>
-#include "VBoxCpuReport.h"
-
-#include <unistd.h>
+#ifndef RT_OS_WINDOWS
+# include <unistd.h>
+#else /* RT_OS_WINDOWS: for test compiling this file on windows */
+# include <io.h>
+int pread(int, void *, size_t, off_t);
+int pwrite(int, void const *, size_t, off_t);
+#endif
 #include <fcntl.h>
 #include <errno.h>
 
 
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
 #define MSR_DEV_NAME    "/dev/cpu/0/msr"
-
-
-/*********************************************************************************************************************************
-*   Structures and Typedefs                                                                                                      *
-*********************************************************************************************************************************/
 
 
@@ -46 +49 @@
 
 
+/**
+ * @interface_method_impl{VBCPUREPMSRACCESSORS,pfnMsrProberRead}
+ */
 static int linuxMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue, bool *pfGp)
 {
@@ -65 +71 @@
 }
 
+
+/**
+ * @interface_method_impl{VBCPUREPMSRACCESSORS,pfnMsrProberWrite}
+ */
 static int linuxMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue, bool *pfGp)
 {
@@ -84 +94 @@
 }
 
-static int linuxMsrProberModify(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask, PSUPMSRPROBERMODIFYRESULT pResult)
+/**
+ * @interface_method_impl{VBCPUREPMSRACCESSORS,pfnMsrProberModify}
+ */
+static DECLCALLBACK(int) linuxMsrProberModify(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask,
+                                              PSUPMSRPROBERMODIFYRESULT pResult)
 {
     int         rc = VINF_SUCCESS;
@@ -100 +114 @@
     RTThreadSleep(10);
 #endif
-    rcBefore = pread(g_fdMsr, &uBefore, sizeof(uBefore), uMsr) != sizeof(uBefore);
+    rcBefore = pread(g_fdMsr, &uBefore, sizeof(uBefore), uMsr);
     uWrite = (uBefore & fAndMask) | fOrMask;
     rcWrite = pwrite(g_fdMsr, &uWrite, sizeof(uWrite), uMsr);
-    rcAfter = pread(g_fdMsr, &uAfter, sizeof(uAfter), uMsr) != sizeof(uAfter);
-    rcRestore = pwrite(g_fdMsr, &uBefore, sizeof(uBefore), uMsr) != sizeof(uBefore);
+    rcAfter = pread(g_fdMsr, &uAfter, sizeof(uAfter), uMsr);
+    rcRestore = pwrite(g_fdMsr, &uBefore, sizeof(uBefore), uMsr);
 
 #if 0
@@ -114 +128 @@
     pResult->uWritten   = uWrite;
     pResult->uAfter     = uAfter;
-    pResult->fBeforeGp  = rcBefore;
-    pResult->fModifyGp  = rcWrite != sizeof(uWrite);
-    pResult->fAfterGp   = rcAfter;
-    pResult->fRestoreGp = rcRestore;
+    pResult->fBeforeGp  = rcBefore  != sizeof(uBefore);
+    pResult->fModifyGp  = rcWrite   != sizeof(uWrite);
+    pResult->fAfterGp   = rcAfter   != sizeof(uAfter);
+    pResult->fRestoreGp = rcRestore != sizeof(uBefore);
 
     return rc;
 }
 
-static int linuxMsrProberTerm(void)
+
+/**
+ * @interface_method_impl{VBCPUREPMSRACCESSORS,pfnTerm}
+ */
+static DECLCALLBACK(void) linuxMsrProberTerm(void)
 {
-    if (g_fdMsr < 0)
-        return VERR_INVALID_STATE;
-
-    close(g_fdMsr);
-    return VINF_SUCCESS;
+    if (g_fdMsr >= 0)
+    {
+        close(g_fdMsr);
+        g_fdMsr = -1;
+    }
 }
 
-int PlatformMsrProberInit(VBMSRFNS *fnsMsr, bool *pfAtomicMsrMod)
+int VbCpuRepMsrProberInitPlatform(PVBCPUREPMSRACCESSORS pMsrAccessors)
 {
-    if (access(MSR_DEV_NAME, F_OK))
+    RTFILE hFile;
+    int rc = RTFileOpen(&hFile, MSR_DEV_NAME, RTFILE_O_READWRITE | RTFILE_O_DENY_NONE | RTFILE_O_OPEN);
+    if (RT_SUCCESS(rc))
     {
-        vbCpuRepDebug("warning: The " MSR_DEV_NAME " device does not exist\n");
-        return VERR_NOT_FOUND;
+        g_fdMsr = RTFileToNative(hFile);
+        Assert(g_fdMsr != -1);
+
+        pMsrAccessors->fAtomic             = false; /* Can't modify/restore MSRs without trip to R3. */
+        pMsrAccessors->pfnMsrProberRead    = linuxMsrProberRead;
+        pMsrAccessors->pfnMsrProberWrite   = linuxMsrProberWrite;
+        pMsrAccessors->pfnMsrProberModify  = linuxMsrProberModify;
+        pMsrAccessors->pfnTerm             = linuxMsrProberTerm;
+        return VINF_SUCCESS;
     }
-
-    g_fdMsr = open(MSR_DEV_NAME, O_RDWR);
-    if (g_fdMsr <= 0)
-    {
-        vbCpuRepDebug("warning: Failed to open " MSR_DEV_NAME "\n");
-        return VERR_ACCESS_DENIED;
-    }
-
-    fnsMsr->msrRead       = linuxMsrProberRead;
-    fnsMsr->msrWrite      = linuxMsrProberWrite;
-    fnsMsr->msrModify     = linuxMsrProberModify;
-    fnsMsr->msrProberTerm = linuxMsrProberTerm;
-    *pfAtomicMsrMod       = false;  /* Can't modify/restore MSRs without trip to R3. */
-
-    return VINF_SUCCESS;
+    vbCpuRepDebug("warning: Failed to open " MSR_DEV_NAME ": %Rrc\n", rc);
+    return rc;
 }

trunk/src/VBox/VMM/tools/VBoxCpuReportMsrSup.cpp

@@ -20 +20 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
-#include <iprt/ctype.h>
+#include "VBoxCpuReport.h"
 #include <iprt/x86.h>
 
-#include <VBox/sup.h>
-#include "VBoxCpuReport.h"
 
+int VbCpuRepMsrProberInitSupDrv(PVBCPUREPMSRACCESSORS pMsrFunctions)
+{
+    int rc = SUPR3Init(NULL);
+    if (RT_SUCCESS(rc))
+    {
+        /* Test if the MSR prober is available, since the interface is optional. The TSC MSR will exist on any supported CPU. */
+        uint64_t uValue;
+        bool     fGp;
+        rc = SUPR3MsrProberRead(MSR_IA32_TSC, NIL_RTCPUID, &uValue, &fGp);
+        if (   rc != VERR_NOT_IMPLEMENTED
+            && rc != VERR_INVALID_FUNCTION)
+        {
+            pMsrFunctions->fAtomic            = true;
+            pMsrFunctions->pfnMsrProberRead   = SUPR3MsrProberRead;
+            pMsrFunctions->pfnMsrProberWrite  = SUPR3MsrProberWrite;
+            pMsrFunctions->pfnMsrProberModify = SUPR3MsrProberModify;
 
-/* Wrappers to mask funny SUPR3 calling conventions on some platforms. */
-static int supMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue, bool *pfGp)
-{
-    return SUPR3MsrProberRead(uMsr, idCpu, puValue, pfGp);
+            pMsrFunctions->pfnTerm            = NULL;
+            return VINF_SUCCESS;
+
+        }
+        vbCpuRepDebug("warning: MSR probing not supported by the support driver (%Rrc).\n", rc);
+    }
+    else
+        vbCpuRepDebug("warning: Unable to initialize the support library (%Rrc).\n", rc);
+    return rc;
 }
 
-static int supMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue, bool *pfGp)
-{
-    return SUPR3MsrProberWrite(uMsr, idCpu, uValue, pfGp);
-}
-
-static int supMsrProberModify(uint32_t uMsr, RTCPUID idCpu, uint64_t fAndMask, uint64_t fOrMask, PSUPMSRPROBERMODIFYRESULT pResult)
-{
-    return SUPR3MsrProberModify(uMsr, idCpu, fAndMask, fOrMask, pResult);
-}
-
-static int supMsrProberTerm(void)
-{
-    return VINF_SUCCESS;
-}
-
-int SupDrvMsrProberInit(VBMSRFNS *fnsMsr, bool *pfAtomicMsrMod)
-{
-    int rc = SUPR3Init(NULL);
-    if (RT_FAILURE(rc))
-    {
-        vbCpuRepDebug("warning: Unable to initialize the support library (%Rrc).\n", rc);
-        return VERR_NOT_FOUND;
-    }
-
-    /* Test if the MSR prober is available, since the interface is optional. The TSC MSR will exist on any supported CPU. */
-    uint64_t uValue;
-    bool     fGp;
-    rc = SUPR3MsrProberRead(MSR_IA32_TSC, NIL_RTCPUID, &uValue, &fGp);
-    if (RT_FAILURE(rc))
-    {
-        vbCpuRepDebug("warning: MSR probing not supported by the support driver (%Rrc).\n", rc);
-        return VERR_NOT_SUPPORTED;
-    }
-
-    fnsMsr->msrRead       = supMsrProberRead;
-    fnsMsr->msrWrite      = supMsrProberWrite;
-    fnsMsr->msrModify     = supMsrProberModify;
-    fnsMsr->msrProberTerm = supMsrProberTerm;
-    *pfAtomicMsrMod       = true;
-
-    return VINF_SUCCESS;
-}