Changeset 10419 in vbox

Timestamp:

Jul 9, 2008 1:46:17 PM (17 years ago)

Author:

vboxsync

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

33078

Message:

Linux implementation of the RTMp* bits we current need in ring-3.

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (2 diffs)
• r3/linux/mp-linux.cpp (copied) (copied from trunk/src/VBox/Runtime/r3/win/mp-win.cpp ) (6 diffs)
• testcase/Makefile.kmk (modified) (2 diffs)
• testcase/tstMp-1.cpp (copied) (copied from trunk/src/VBox/Runtime/testcase/tstCidr.cpp ) (4 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -321 +321 @@
         generic/RTMpGetCurFrequency-generic.cpp \
         generic/RTMpGetMaxFrequency-generic.cpp \
+        r3/linux/mp-linux.cpp \
         r3/linux/sched-linux.cpp \
         r3/linux/time-linux.cpp \
@@ -333 +334 @@
         r3/posix/process-posix.cpp \
         r3/posix/rand-posix.cpp \
-        r3/posix/RTMpGetCount-posix.cpp \
         r3/posix/RTTimeNow-posix.cpp \
         r3/posix/semrw-posix.cpp \

trunk/src/VBox/Runtime/r3/linux/mp-linux.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - Multiprocessor, Windows.
+ * IPRT - Multiprocessor, Linux.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -34 +34 @@
 *******************************************************************************/
 #define LOG_GROUP RTLOGGROUP_SYSTEM
-#include <Windows.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/sysctl.h>
+#include <sys/stat.h>
+#include <sys/fcntl.h>
+#include <errno.h>
+
 #include <iprt/mp.h>
 #include <iprt/cpuset.h>
 #include <iprt/assert.h>
+#include <iprt/string.h>
+
+
+/** @todo move the rtLinuxSysFs* bits into sysfs.cpp and sysfs.h. */
+
+/**
+ * Checks if a sysfs file (or directory, device, symlink, whatever) exists.
+ *
+ * @returns true / false, errno is preserved.
+ * @param   pszFormat   The name format, without "/sys/".
+ * @param   va          The format args.
+ */
+bool rtLinuxSysFsExistsV(const char *pszFormat, va_list va)
+{
+    int iSavedErrno = errno;
+
+    /*
+     * Construct the filename and call stat.
+     */
+    char szFilename[128];
+    static const size_t cchPrefix = sizeof("/sys/") - 1;
+    strcpy(szFilename, "/sys/");
+    size_t cch = RTStrPrintfV(&szFilename[cchPrefix], sizeof(szFilename) - cchPrefix, pszFormat, va);
+    Assert(cch < sizeof(szFilename) - cchPrefix - 1);
+
+    struct stat st;
+    bool fRet = stat(szFilename, &st) == 0;
+
+    errno = iSavedErrno;
+    return fRet;
+}
+
+/**
+ * Checks if a sysfs file (or directory, device, symlink, whatever) exists.
+ *
+ * @returns true / false, errno is preserved.
+ * @param   pszFormat   The name format, without "/sys/".
+ * @param   ...         The format args.
+ */
+bool rtLinuxSysFsExists(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    bool fRet = rtLinuxSysFsExistsV(pszFormat, va);
+    va_end(va);
+    return fRet;
+}
+
+
+/**
+ * Opens a sysfs file.
+ *
+ * @returns The file descriptor. -1 and errno on failure.
+ * @param   pszFormat   The name format, without "/sys/".
+ * @param   va          The format args.
+ */
+int rtLinuxSysFsOpenV(const char *pszFormat, va_list va)
+{
+    /*
+     * Construct the filename and call open.
+     */
+    char szFilename[128];
+    static const size_t cchPrefix = sizeof("/sys/") - 1;
+    strcpy(szFilename, "/sys/");
+    size_t cch = RTStrPrintfV(&szFilename[cchPrefix], sizeof(szFilename) - cchPrefix, pszFormat, va);
+    Assert(cch < sizeof(szFilename) - cchPrefix - 1);
+
+    return open(szFilename, O_RDONLY, 0);
+}
+
+
+/**
+ * Opens a sysfs file.
+ *
+ * @returns The file descriptor. -1 and errno on failure.
+ * @param   pszFormat   The name format, without "/sys/".
+ * @param   ...         The format args.
+ */
+int rtLinuxSysFsOpen(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    int fd = rtLinuxSysFsOpenV(pszFormat, va);
+    va_end(va);
+    return fd;
+}
+
+
+/**
+ * Closes a file opened with rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
+ *
+ * @param   fd
+ */
+void rtLinuxSysFsClose(int fd)
+{
+    int iSavedErrno = errno;
+    close(fd);
+    errno = iSavedErrno;
+}
+
+
+/**
+ * Closes a file opened with rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
+ *
+ * @returns The number of bytes read. -1 and errno on failure.
+ * @param   fd          The file descriptor returned by rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
+ * @param   pszBuf      Where to store the string.
+ * @param   cchBuf      The size of the buffer. Must be at least 2 bytes.
+ */
+ssize_t rtLinuxSysFsReadStr(int fd, char *pszBuf, size_t cchBuf)
+{
+    Assert(cchBuf > 1);
+    ssize_t cchRead = read(fd, pszBuf, cchBuf - 1);
+    pszBuf[cchRead >= 0 ? cchRead : 0] = '\0';
+    return cchRead;
+}
+
+
+/**
+ * Reads a sysfs file.
+ *
+ * @returns 64-bit signed value on success, -1 and errno on failure.
+ * @param   uBase       The number base, 0 for autodetect.
+ * @param   pszFormat   The filename format, without "/sys/".
+ * @param   va          Format args.
+ */
+int64_t rtLinuxSysFsReadIntFileV(unsigned uBase, const char *pszFormat, va_list va)
+{
+    int fd = rtLinuxSysFsOpenV(pszFormat, va);
+    if (fd == -1)
+        return -1;
+
+    int64_t i64Ret = -1;
+    char szNum[128];
+    ssize_t cchNum = rtLinuxSysFsReadStr(fd, szNum, sizeof(szNum));
+    if (cchNum > 0)
+    {
+        int rc = RTStrToInt64Ex(szNum, NULL, uBase, &i64Ret);
+        if (RT_FAILURE(rc))
+        {
+            i64Ret = -1;
+            errno = -ETXTBSY; /* just something that won't happen at read / open. */
+        }
+    }
+    else if (cchNum == 0)
+        errno = -ETXTBSY; /* just something that won't happen at read / open. */
+
+    rtLinuxSysFsClose(fd);
+    return i64Ret;
+}
+
+
+/**
+ * Reads a sysfs file.
+ *
+ * @returns 64-bit signed value on success, -1 and errno on failure.
+ * @param   uBase       The number base, 0 for autodetect.
+ * @param   pszFormat   The filename format, without "/sys/".
+ * @param   ...         Format args.
+ */
+static int64_t rtLinuxSysFsReadIntFile(unsigned uBase, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    int64_t i64Ret = rtLinuxSysFsReadIntFileV(uBase, pszFormat, va);
+    va_end(va);
+    return i64Ret;
+}
+
+
+/**
+ * Internal worker that determins the max possible CPU count.
+ *
+ * @returns Max cpus.
+ */
+DECLINLINE(RTCPUID) rtMpLinuxMaxCpus(void)
+{
+    int cMax = sysconf(_SC_NPROCESSORS_CONF);
+    Assert(cMax >= 1);
+    return cMax;
+}
 
 
@@ -44 +231 @@
 RTDECL(int) RTMpCpuIdToSetIndex(RTCPUID idCpu)
 {
-    return idCpu < MAXIMUM_PROCESSORS ? idCpu : -1;
+    return idCpu < rtMpLinuxMaxCpus() ? idCpu : -1;
 }
 
@@ -50 +237 @@
 RTDECL(RTCPUID) RTMpCpuIdFromSetIndex(int iCpu)
 {
-    return (unsigned)iCpu < MAXIMUM_PROCESSORS ? iCpu : NIL_RTCPUID;
+    return (unsigned)iCpu < rtMpLinuxMaxCpus() ? iCpu : NIL_RTCPUID;
 }
 
@@ -56 +243 @@
 RTDECL(RTCPUID) RTMpGetMaxCpuId(void)
 {
-    return MAXIMUM_PROCESSORS - 1;
+    return rtMpLinuxMaxCpus() - 1;
 }
 
@@ -62 +249 @@
 RTDECL(bool) RTMpIsCpuOnline(RTCPUID idCpu)
 {
+    /** @todo check if there is a simpler interface than this... */
+    int i = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/online", (int)idCpu);
+    if (    i == -1
+        &&  rtLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu))
+    {
+        Assert(!rtLinuxSysFsExists("devices/system/cpu/cpu%d/online", (int)idCpu));
+        i = 1;
+    }
+
+    Assert(i == 0 || i == -1 || i == 1);
+    return i != 0 && i != -1;
+}
+
+
+RTDECL(bool) RTMpIsCpuPossible(RTCPUID idCpu)
+{
+    /** @todo check this up with hotplugging! */
+    return rtLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu);
+}
+
+
+RTDECL(PRTCPUSET) RTMpGetSet(PRTCPUSET pSet)
+{
+    RTCpuSetEmpty(pSet);
+    RTCPUID cMax = rtMpLinuxMaxCpus();
+    for (RTCPUID idCpu = 0; idCpu < cMax; idCpu++)
+        if (RTMpIsCpuPossible(idCpu))
+            RTCpuSetAdd(pSet, idCpu);
+    return pSet;
+}
+
+
+RTDECL(RTCPUID) RTMpGetCount(void)
+{
     RTCPUSET Set;
-    return RTCpuSetIsMember(RTMpGetOnlineSet(&Set), idCpu);
-}
-
-
-RTDECL(bool) RTMpIsCpuPossible(RTCPUID idCpu)
-{
-    RTCPUSET Set;
-    return RTCpuSetIsMember(RTMpGetSet(&Set), idCpu);
-}
-
-
-RTDECL(PRTCPUSET) RTMpGetSet(PRTCPUSET pSet)
-{
-    RTCPUID idCpu = RTMpGetCount();
+    RTMpGetSet(&Set);
+    return RTCpuSetCount(&Set);
+}
+
+
+RTDECL(PRTCPUSET) RTMpGetOnlineSet(PRTCPUSET pSet)
+{
     RTCpuSetEmpty(pSet);
-    while (idCpu-- > 0)
-        RTCpuSetAdd(pSet, idCpu);
+    RTCPUID cMax = rtMpLinuxMaxCpus();
+    for (RTCPUID idCpu = 0; idCpu < cMax; idCpu++)
+        if (RTMpIsCpuOnline(idCpu))
+            RTCpuSetAdd(pSet, idCpu);
     return pSet;
-}
-
-
-RTDECL(RTCPUID) RTMpGetCount(void)
-{
-    SYSTEM_INFO SysInfo;
-    GetSystemInfo(&SysInfo);
-    Assert((RTCPUID)SysInfo.dwNumberOfProcessors == SysInfo.dwNumberOfProcessors);
-    return SysInfo.dwNumberOfProcessors;
-}
-
-
-RTDECL(PRTCPUSET) RTMpGetOnlineSet(PRTCPUSET pSet)
-{
-    SYSTEM_INFO SysInfo;
-    GetSystemInfo(&SysInfo);
-    return RTCpuSetFromU64(pSet, SysInfo.dwActiveProcessorMask);
 }
 

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -72 +72 @@
         tstLog \
         tstMove \
+        tstMp-1 \
         tstNoCrt-1 \
         tstPath \
@@ -246 +247 @@
 tstMove_SOURCES = tstMove.cpp
 
+tstMp-1_SOURCES = tstMp-1.cpp
+
 tstNoCrt-1_DEFS = RT_WITHOUT_NOCRT_WRAPPER_ALIASES
 tstNoCrt-1_SOURCES = \

trunk/src/VBox/Runtime/testcase/tstMp-1.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - IPv4.
+ * IPRT Testcase - RTMp.
  */
 
@@ -33 +33 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include <iprt/cidr.h>
+#include <iprt/mp.h>
+#include <iprt/cpuset.h>
 #include <iprt/err.h>
 #include <iprt/stream.h>
@@ -42 +43 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-#define CHECKNETWORK(string, expected_result, expected_network, expected_netmask) \
-    do { \
-        RTIPV4ADDR network, netmask; \
-        int result = RTCidrStrToIPv4(string, &network, &netmask); \
-        if (expected_result && !result) \
-        { \
-            g_cErrors++; \
-            RTPrintf("%s, %d: %s: expected %Vrc got %Vrc\n", \
-                    __FUNCTION__, __LINE__, string, expected_result, result); \
-        } \
-        else if (   expected_result != result \
-                 || (   result == VINF_SUCCESS \
-                     && (   expected_network != network \
-                         || expected_netmask != netmask))) \
-        { \
-            g_cErrors++; \
-            RTPrintf("%s, %d: '%s': expected %Vrc got %Vrc, expected network %08x got %08x, expected netmask %08x got %08x\n", \
-                    __FUNCTION__, __LINE__, string, expected_result, result, expected_network, network, expected_netmask, netmask); \
-        } \
-    } while (0)
-
 
 /*******************************************************************************
@@ -73 +53 @@
 {
     RTR3Init();
-    CHECKNETWORK("10.0.0/24",                VINF_SUCCESS, 0x0A000000, 0xFFFFFF00);
-    CHECKNETWORK("10.0.0/8",                 VINF_SUCCESS, 0x0A000000, 0xFF000000);
-    CHECKNETWORK("10.0.0./24",     VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("0.1.0/24",       VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.255.0.0/24",  VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.1234.0.0/24", VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.256.0.0/24",  VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.0.0/3",       VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.1.2.3/8",               VINF_SUCCESS, 0x0A010203, 0xFF000000);
-    CHECKNETWORK("10.0.0/29",      VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.0.0/240",     VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.0.0/24.",     VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.1.2/16",                VINF_SUCCESS, 0x0A010200, 0xFFFF0000);
-    CHECKNETWORK("1.2.3.4",                  VINF_SUCCESS, 0x01020304, 0xFFFFFFFF);
+    RTPrintf("tstMp-1: TESTING...\n");
+
+#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS) || defined(RT_OS_LINUX)
+    /*
+     * Present and possible CPUs.
+     */
+    RTCPUID cCpus = RTMpGetCount();
+    if (cCpus > 0)
+        RTPrintf("tstMp-1: RTMpGetCount -> %d\n", (int)cCpus);
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetCount -> %d\n", (int)cCpus);
+        g_cErrors++;
+        cCpus = 1;
+    }
+
+    RTCPUSET Set;
+    PRTCPUSET pSet = RTMpGetSet(&Set);
+    if (pSet == &Set)
+    {
+        if ((RTCPUID)RTCpuSetCount(&Set) != cCpus)
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetSet returned a set with a different cpu count; %d, expected %d\n",
+                     RTCpuSetCount(&Set), cCpus);
+            g_cErrors++;
+        }
+        RTPrintf("tstMp-1: Possible CPU mask:\n");
+        for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
+        {
+            if (RTCpuSetIsMemberByIndex(&Set, iCpu))
+            {
+                RTPrintf("tstMp-1: %2d - id %d\n", iCpu, RTMpCpuIdFromSetIndex(iCpu));
+                if (!RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(iCpu)))
+                {
+                    RTPrintf("tstMp-1: FAILURE: Cpu with index %d is returned by RTCpuSet but not RTMpIsCpuPossible!\n", iCpu);
+                    g_cErrors++;
+                }
+            }
+            else if (RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(iCpu)))
+            {
+                RTPrintf("tstMp-1: FAILURE: Cpu with index %d is returned by RTMpIsCpuPossible but not RTCpuSet!\n", iCpu);
+                g_cErrors++;
+            }
+        }
+    }
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetSet -> %p, expected %p\n", pSet, &Set);
+        g_cErrors++;
+        RTCpuSetEmpty(&Set);
+        RTCpuSetAdd(&Set, RTMpCpuIdFromSetIndex(0));
+    }
+
+    /*
+     * Online CPUs.
+     */
+    RTCPUID cCpusOnline = RTMpGetOnlineCount();
+    if (cCpusOnline > 0)
+    {
+        if (cCpusOnline <= cCpus)
+            RTPrintf("tstMp-1: RTMpGetOnlineCount -> %d\n", (int)cCpusOnline);
+        else
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineCount -> %d, expected <= %d\n", (int)cCpusOnline, (int)cCpus);
+            g_cErrors++;
+            cCpusOnline = cCpus;
+        }
+    }
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineCount -> %d\n", (int)cCpusOnline);
+        g_cErrors++;
+        cCpusOnline = 1;
+    }
+
+    RTCPUSET SetOnline;
+    pSet = RTMpGetOnlineSet(&SetOnline);
+    if (pSet == &SetOnline)
+    {
+        if (RTCpuSetCount(&SetOnline) <= 0)
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet returned an empty set!\n");
+            g_cErrors++;
+        }
+        else if ((RTCPUID)RTCpuSetCount(&SetOnline) > cCpus)
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet returned a too high value; %d, expected <= %d\n",
+                     RTCpuSetCount(&SetOnline), cCpus);
+            g_cErrors++;
+        }
+        RTPrintf("tstMp-1: Online CPU mask:\n");
+        for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
+            if (RTCpuSetIsMemberByIndex(&SetOnline, iCpu))
+            {
+                RTPrintf("tstMp-1: %2d - id %d\n", iCpu, RTMpCpuIdFromSetIndex(iCpu));
+                if (!RTCpuSetIsMemberByIndex(&Set, iCpu))
+                {
+                    RTPrintf("tstMp-1: FAILURE: online cpu with index %2d is not a member of the possible cpu set!\n", iCpu);
+                    g_cErrors++;
+                }
+            }
+
+        /* There isn't any sane way of testing RTMpIsCpuOnline really... :-/ */
+    }
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet -> %p, expected %p\n", pSet, &Set);
+        g_cErrors++;
+    }
+
+#else
+    RTPrintf("tstMp-1: SKIPPED - RTMp is not implemented on this host OS.\n");
+#endif
+
     if (!g_cErrors)
-        RTPrintf("tstIp: SUCCESS\n", g_cErrors);
+        RTPrintf("tstMp-1: SUCCESS\n", g_cErrors);
     else
-        RTPrintf("tstIp: FAILURE - %d errors\n", g_cErrors);
+        RTPrintf("tstMp-1: FAILURE - %d errors\n", g_cErrors);
     return !!g_cErrors;
 }