VirtualBox

Changeset 15399 in vbox for trunk/src/VBox/Runtime/r3/linux


Ignore:
Timestamp:
Dec 12, 2008 10:02:14 PM (16 years ago)
Author:
vboxsync
Message:

iprt: new Linux sysfs APIs

Location:
trunk/src/VBox/Runtime/r3/linux
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed

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

    r10482 r15399  
    3434*******************************************************************************/
    3535#define LOG_GROUP RTLOGGROUP_SYSTEM
    36 #include <unistd.h>
    3736#include <stdio.h>
    38 #include <sys/sysctl.h>
    39 #include <sys/stat.h>
    40 #include <sys/fcntl.h>
    4137#include <errno.h>
    4238
    … …  
    4541#include <iprt/assert.h>
    4642#include <iprt/string.h>
    47 
    48 
    49 /** @todo move the rtLinuxSysFs* bits into sysfs.cpp and sysfs.h. */
    50 
    51 /**
    52  * Checks if a sysfs file (or directory, device, symlink, whatever) exists.
    53  *
    54  * @returns true / false, errno is preserved.
    55  * @param   pszFormat   The name format, without "/sys/".
    56  * @param   va          The format args.
    57  */
    58 bool rtLinuxSysFsExistsV(const char *pszFormat, va_list va)
    59 {
    60     int iSavedErrno = errno;
    61 
    62     /*
    63      * Construct the filename and call stat.
    64      */
    65     char szFilename[128];
    66     static const size_t cchPrefix = sizeof("/sys/") - 1;
    67     strcpy(szFilename, "/sys/");
    68     size_t cch = RTStrPrintfV(&szFilename[cchPrefix], sizeof(szFilename) - cchPrefix, pszFormat, va);
    69     Assert(cch < sizeof(szFilename) - cchPrefix - 1); NOREF(cch);
    70 
    71     struct stat st;
    72     bool fRet = stat(szFilename, &st) == 0;
    73 
    74     errno = iSavedErrno;
    75     return fRet;
    76 }
    77 
    78 /**
    79  * Checks if a sysfs file (or directory, device, symlink, whatever) exists.
    80  *
    81  * @returns true / false, errno is preserved.
    82  * @param   pszFormat   The name format, without "/sys/".
    83  * @param   ...         The format args.
    84  */
    85 bool rtLinuxSysFsExists(const char *pszFormat, ...)
    86 {
    87     va_list va;
    88     va_start(va, pszFormat);
    89     bool fRet = rtLinuxSysFsExistsV(pszFormat, va);
    90     va_end(va);
    91     return fRet;
    92 }
    93 
    94 
    95 /**
    96  * Opens a sysfs file.
    97  *
    98  * @returns The file descriptor. -1 and errno on failure.
    99  * @param   pszFormat   The name format, without "/sys/".
    100  * @param   va          The format args.
    101  */
    102 int rtLinuxSysFsOpenV(const char *pszFormat, va_list va)
    103 {
    104     /*
    105      * Construct the filename and call open.
    106      */
    107     char szFilename[128];
    108     static const size_t cchPrefix = sizeof("/sys/") - 1;
    109     strcpy(szFilename, "/sys/");
    110     size_t cch = RTStrPrintfV(&szFilename[cchPrefix], sizeof(szFilename) - cchPrefix, pszFormat, va);
    111     Assert(cch < sizeof(szFilename) - cchPrefix - 1); NOREF(cch);
    112 
    113     return open(szFilename, O_RDONLY, 0);
    114 }
    115 
    116 
    117 /**
    118  * Opens a sysfs file.
    119  *
    120  * @returns The file descriptor. -1 and errno on failure.
    121  * @param   pszFormat   The name format, without "/sys/".
    122  * @param   ...         The format args.
    123  */
    124 int rtLinuxSysFsOpen(const char *pszFormat, ...)
    125 {
    126     va_list va;
    127     va_start(va, pszFormat);
    128     int fd = rtLinuxSysFsOpenV(pszFormat, va);
    129     va_end(va);
    130     return fd;
    131 }
    132 
    133 
    134 /**
    135  * Closes a file opened with rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
    136  *
    137  * @param   fd
    138  */
    139 void rtLinuxSysFsClose(int fd)
    140 {
    141     int iSavedErrno = errno;
    142     close(fd);
    143     errno = iSavedErrno;
    144 }
    145 
    146 
    147 /**
    148  * Closes a file opened with rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
    149  *
    150  * @returns The number of bytes read. -1 and errno on failure.
    151  * @param   fd          The file descriptor returned by rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
    152  * @param   pszBuf      Where to store the string.
    153  * @param   cchBuf      The size of the buffer. Must be at least 2 bytes.
    154  */
    155 ssize_t rtLinuxSysFsReadStr(int fd, char *pszBuf, size_t cchBuf)
    156 {
    157     Assert(cchBuf > 1);
    158     ssize_t cchRead = read(fd, pszBuf, cchBuf - 1);
    159     pszBuf[cchRead >= 0 ? cchRead : 0] = '\0';
    160     return cchRead;
    161 }
    162 
    163 
    164 /**
    165  * Reads a sysfs file.
    166  *
    167  * @returns 64-bit signed value on success, -1 and errno on failure.
    168  * @param   uBase       The number base, 0 for autodetect.
    169  * @param   pszFormat   The filename format, without "/sys/".
    170  * @param   va          Format args.
    171  */
    172 int64_t rtLinuxSysFsReadIntFileV(unsigned uBase, const char *pszFormat, va_list va)
    173 {
    174     int fd = rtLinuxSysFsOpenV(pszFormat, va);
    175     if (fd == -1)
    176         return -1;
    177 
    178     int64_t i64Ret = -1;
    179     char szNum[128];
    180     ssize_t cchNum = rtLinuxSysFsReadStr(fd, szNum, sizeof(szNum));
    181     if (cchNum > 0)
    182     {
    183         int rc = RTStrToInt64Ex(szNum, NULL, uBase, &i64Ret);
    184         if (RT_FAILURE(rc))
    185         {
    186             i64Ret = -1;
    187             errno = -ETXTBSY; /* just something that won't happen at read / open. */
    188         }
    189     }
    190     else if (cchNum == 0)
    191         errno = -ETXTBSY; /* just something that won't happen at read / open. */
    192 
    193     rtLinuxSysFsClose(fd);
    194     return i64Ret;
    195 }
    196 
    197 
    198 /**
    199  * Reads a sysfs file.
    200  *
    201  * @returns 64-bit signed value on success, -1 and errno on failure.
    202  * @param   uBase       The number base, 0 for autodetect.
    203  * @param   pszFormat   The filename format, without "/sys/".
    204  * @param   ...         Format args.
    205  */
    206 static int64_t rtLinuxSysFsReadIntFile(unsigned uBase, const char *pszFormat, ...)
    207 {
    208     va_list va;
    209     va_start(va, pszFormat);
    210     int64_t i64Ret = rtLinuxSysFsReadIntFileV(uBase, pszFormat, va);
    211     va_end(va);
    212     return i64Ret;
    213 }
     43#include <iprt/linux/sysfs.h>
    21444
    21545
    … …  
    23161        int cMax = 1;
    23262        for (unsigned iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
    233             if (rtLinuxSysFsExists("devices/system/cpu/cpu%d", iCpu))
     63            if (RTLinuxSysFsExists("devices/system/cpu/cpu%d", iCpu))
    23464                cMax = iCpu + 1;
    23565        ASMAtomicUoWriteU32((uint32_t volatile *)&s_cMax, cMax);
    … …  
    310140{
    311141    /** @todo check if there is a simpler interface than this... */
    312     int i = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/online", (int)idCpu);
     142    int i = RTLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/online", (int)idCpu);
    313143    if (    i == -1
    314         &&  rtLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu))
    315     {
    316         Assert(!rtLinuxSysFsExists("devices/system/cpu/cpu%d/online", (int)idCpu));
     144        &&  RTLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu))
     145    {
     146        Assert(!RTLinuxSysFsExists("devices/system/cpu/cpu%d/online", (int)idCpu));
    317147        i = 1;
    318148    }
    … …  
    326156{
    327157    /** @todo check this up with hotplugging! */
    328     return rtLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu);
     158    return RTLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu);
    329159}
    330160
    … …  
    370200RTDECL(uint32_t) RTMpGetCurFrequency(RTCPUID idCpu)
    371201{
    372     int64_t kHz = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/cpufreq/cpuinfo_cur_freq", (int)idCpu);
     202    int64_t kHz = RTLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/cpufreq/cpuinfo_cur_freq", (int)idCpu);
    373203    if (kHz == -1)
    374204    {
    … …  
    388218RTDECL(uint32_t) RTMpGetMaxFrequency(RTCPUID idCpu)
    389219{
    390     int64_t kHz = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", (int)idCpu);
     220    int64_t kHz = RTLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", (int)idCpu);
    391221    if (kHz == -1)
    392222    {
    … …  
    395225         * would provide current frequency information, which is wrong.
    396226         */
    397         if (!rtLinuxSysFsExists("devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", (int)idCpu))
     227        if (!RTLinuxSysFsExists("devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", (int)idCpu))
    398228            kHz = rtMpLinuxGetFrequency(idCpu) * 1000;
    399229        else

  • trunk/src/VBox/Runtime/r3/linux/sysfs.cpp

    r14990 r15399  
    11/* $Id$ */
    22/** @file
    3  * IPRT - Multiprocessor, Linux.
     3 * IPRT - Linux sysfs access.
    44 */
    55
    … …  
    4141#include <errno.h>
    4242
    43 #include <iprt/mp.h>
    44 #include <iprt/cpuset.h>
     43#include <iprt/linux/sysfs.h>
    4544#include <iprt/assert.h>
     45#include <iprt/param.h>
    4646#include <iprt/string.h>
    4747
    4848
    49 /** @todo move the rtLinuxSysFs* bits into sysfs.cpp and sysfs.h. */
     49/**
     50 * Constructs the path of a sysfs file from the format paramaters passed,
     51 * prepending "/sys/" if the path is relative.
     52 *
     53 * @returns The number of characters written, or -1 and errno on failure.
     54 * @param   pszBuf     Where to write the path.  Must be at least
     55 *                     sizeof("/sys/") characters long
     56 * @param   cchBuf     The size of the buffer pointed to by @a pszBuf
     57 * @param   pszFormat  The name format, either absolute or relative to "/sys/".
     58 * @param   va         The format args.
     59 */
     60static ssize_t rtLinuxSysFsConstructPath(char *pszBuf, size_t cchBuf,
     61                                         const char *pszFormat, va_list va)
     62{
     63    char szFilename[RTPATH_MAX];
     64    const char szPrefix[] = "/sys/";
     65    if (cchBuf < sizeof(szPrefix))
     66        AssertFailedReturnStmt(errno = EINVAL, -1);
     67    size_t cch = RTStrPrintfV(szFilename, sizeof(szFilename), pszFormat, va);
     68    if (szFilename[0] == '/')
     69        *pszBuf = '\0';
     70    else
     71        strcpy(pszBuf, szPrefix);
     72    strncat(pszBuf, szFilename, cchBuf);
     73    return strlen(pszBuf);
     74}
    5075
    5176/**
    … …  
    5378 *
    5479 * @returns true / false, errno is preserved.
    55  * @param   pszFormat   The name format, without "/sys/".
     80 * @param   pszFormat   The name format, either absolute or relative to "/sys/".
    5681 * @param   va          The format args.
    5782 */
    58 bool rtLinuxSysFsExistsV(const char *pszFormat, va_list va)
     83bool RTLinuxSysFsExistsV(const char *pszFormat, va_list va)
    5984{
    6085    int iSavedErrno = errno;
    … …  
    6388     * Construct the filename and call stat.
    6489     */
    65     char szFilename[128];
    66     static const size_t cchPrefix = sizeof("/sys/") - 1;
    67     strcpy(szFilename, "/sys/");
    68     size_t cch = RTStrPrintfV(&szFilename[cchPrefix], sizeof(szFilename) - cchPrefix, pszFormat, va);
    69     Assert(cch < sizeof(szFilename) - cchPrefix - 1); NOREF(cch);
    70 
    71     struct stat st;
    72     bool fRet = stat(szFilename, &st) == 0;
     90    char szFilename[RTPATH_MAX];
     91    bool fRet = false;
     92    ssize_t rc = rtLinuxSysFsConstructPath(szFilename, sizeof(szFilename),
     93                                           pszFormat, va);
     94    if (rc > 0 && static_cast<size_t>(rc) < sizeof(szFilename))
     95    {
     96        struct stat st;
     97        fRet = stat(szFilename, &st) == 0;
     98    }
    7399
    74100    errno = iSavedErrno;
    … …  
    80106 *
    81107 * @returns true / false, errno is preserved.
    82  * @param   pszFormat   The name format, without "/sys/".
     108 * @param   pszFormat   The name format, either absolute or relative to "/sys/".
    83109 * @param   ...         The format args.
    84110 */
    85 bool rtLinuxSysFsExists(const char *pszFormat, ...)
    86 {
    87     va_list va;
    88     va_start(va, pszFormat);
    89     bool fRet = rtLinuxSysFsExistsV(pszFormat, va);
     111bool RTLinuxSysFsExists(const char *pszFormat, ...)
     112{
     113    va_list va;
     114    va_start(va, pszFormat);
     115    bool fRet = RTLinuxSysFsExistsV(pszFormat, va);
    90116    va_end(va);
    91117    return fRet;
    … …  
    97123 *
    98124 * @returns The file descriptor. -1 and errno on failure.
    99  * @param   pszFormat   The name format, without "/sys/".
     125 * @param   pszFormat   The name format, either absolute or relative to "/sys/".
    100126 * @param   va          The format args.
    101127 */
    102 int rtLinuxSysFsOpenV(const char *pszFormat, va_list va)
     128int RTLinuxSysFsOpenV(const char *pszFormat, va_list va)
    103129{
    104130    /*
    105131     * Construct the filename and call open.
    106132     */
    107     char szFilename[128];
    108     static const size_t cchPrefix = sizeof("/sys/") - 1;
    109     strcpy(szFilename, "/sys/");
    110     size_t cch = RTStrPrintfV(&szFilename[cchPrefix], sizeof(szFilename) - cchPrefix, pszFormat, va);
    111     Assert(cch < sizeof(szFilename) - cchPrefix - 1); NOREF(cch);
    112 
    113     return open(szFilename, O_RDONLY, 0);
     133    char szFilename[RTPATH_MAX];
     134    ssize_t rc = rtLinuxSysFsConstructPath(szFilename, sizeof(szFilename),
     135                                           pszFormat, va);
     136    if (rc > 0 && static_cast<size_t>(rc) < sizeof(szFilename))
     137        rc = open(szFilename, O_RDONLY, 0);
     138    return rc;
    114139}
    115140
    … …  
    119144 *
    120145 * @returns The file descriptor. -1 and errno on failure.
    121  * @param   pszFormat   The name format, without "/sys/".
     146 * @param   pszFormat   The name format, either absolute or relative to "/sys/".
    122147 * @param   ...         The format args.
    123148 */
    124 int rtLinuxSysFsOpen(const char *pszFormat, ...)
    125 {
    126     va_list va;
    127     va_start(va, pszFormat);
    128     int fd = rtLinuxSysFsOpenV(pszFormat, va);
     149int RTLinuxSysFsOpen(const char *pszFormat, ...)
     150{
     151    va_list va;
     152    va_start(va, pszFormat);
     153    int fd = RTLinuxSysFsOpenV(pszFormat, va);
    129154    va_end(va);
    130155    return fd;
    … …  
    133158
    134159/**
    135  * Closes a file opened with rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
     160 * Closes a file opened with RTLinuxSysFsOpen or RTLinuxSysFsOpenV.
    136161 *
    137162 * @param   fd
    138163 */
    139 void rtLinuxSysFsClose(int fd)
     164void RTLinuxSysFsClose(int fd)
    140165{
    141166    int iSavedErrno = errno;
    … …  
    146171
    147172/**
    148  * Closes a file opened with rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
     173 * Reads a string from a file opened with RTLinuxSysFsOpen or RTLinuxSysFsOpenV.
    149174 *
    150175 * @returns The number of bytes read. -1 and errno on failure.
    151  * @param   fd          The file descriptor returned by rtLinuxSysFsOpen or rtLinuxSysFsOpenV.
     176 * @param   fd          The file descriptor returned by RTLinuxSysFsOpen or RTLinuxSysFsOpenV.
    152177 * @param   pszBuf      Where to store the string.
    153178 * @param   cchBuf      The size of the buffer. Must be at least 2 bytes.
    154179 */
    155 ssize_t rtLinuxSysFsReadStr(int fd, char *pszBuf, size_t cchBuf)
     180ssize_t RTLinuxSysFsReadStr(int fd, char *pszBuf, size_t cchBuf)
    156181{
    157182    Assert(cchBuf > 1);
    … …  
    163188
    164189/**
    165  * Reads a sysfs file.
     190 * Reads a number from a sysfs file.
    166191 *
    167192 * @returns 64-bit signed value on success, -1 and errno on failure.
    168193 * @param   uBase       The number base, 0 for autodetect.
    169  * @param   pszFormat   The filename format, without "/sys/".
     194 * @param   pszFormat   The filename format, either absolute or relative to "/sys/".
    170195 * @param   va          Format args.
    171196 */
    172 int64_t rtLinuxSysFsReadIntFileV(unsigned uBase, const char *pszFormat, va_list va)
    173 {
    174     int fd = rtLinuxSysFsOpenV(pszFormat, va);
     197int64_t RTLinuxSysFsReadIntFileV(unsigned uBase, const char *pszFormat, va_list va)
     198{
     199    int fd = RTLinuxSysFsOpenV(pszFormat, va);
    175200    if (fd == -1)
    176201        return -1;
    … …  
    178203    int64_t i64Ret = -1;
    179204    char szNum[128];
    180     ssize_t cchNum = rtLinuxSysFsReadStr(fd, szNum, sizeof(szNum));
     205    ssize_t cchNum = RTLinuxSysFsReadStr(fd, szNum, sizeof(szNum));
    181206    if (cchNum > 0)
    182207    {
    … …  
    191216        errno = -ETXTBSY; /* just something that won't happen at read / open. */
    192217
    193     rtLinuxSysFsClose(fd);
     218    RTLinuxSysFsClose(fd);
    194219    return i64Ret;
    195220}
    … …  
    197222
    198223/**
    199  * Reads a sysfs file.
     224 * Reads a number from a sysfs file.
    200225 *
    201226 * @returns 64-bit signed value on success, -1 and errno on failure.
    202227 * @param   uBase       The number base, 0 for autodetect.
    203  * @param   pszFormat   The filename format, without "/sys/".
     228 * @param   pszFormat   The filename format, either absolute or relative to "/sys/".
    204229 * @param   ...         Format args.
    205230 */
    206 static int64_t rtLinuxSysFsReadIntFile(unsigned uBase, const char *pszFormat, ...)
    207 {
    208     va_list va;
    209     va_start(va, pszFormat);
    210     int64_t i64Ret = rtLinuxSysFsReadIntFileV(uBase, pszFormat, va);
     231int64_t RTLinuxSysFsReadIntFile(unsigned uBase, const char *pszFormat, ...)
     232{
     233    va_list va;
     234    va_start(va, pszFormat);
     235    int64_t i64Ret = RTLinuxSysFsReadIntFileV(uBase, pszFormat, va);
    211236    va_end(va);
    212237    return i64Ret;
    … …  
    215240
    216241/**
    217  * Internal worker that determins the max possible CPU count.
    218  *
    219  * @returns Max cpus.
    220  */
    221 static RTCPUID rtMpLinuxMaxCpus(void)
    222 {
    223 #if 0 /* this doesn't do the right thing :-/ */
    224     int cMax = sysconf(_SC_NPROCESSORS_CONF);
    225     Assert(cMax >= 1);
    226     return cMax;
    227 #else
    228     static uint32_t s_cMax = 0;
    229     if (!s_cMax)
    230     {
    231         int cMax = 1;
    232         for (unsigned iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
    233             if (rtLinuxSysFsExists("devices/system/cpu/cpu%d", iCpu))
    234                 cMax = iCpu + 1;
    235         ASMAtomicUoWriteU32((uint32_t volatile *)&s_cMax, cMax);
    236         return cMax;
    237     }
    238     return s_cMax;
    239 #endif
    240 }
    241 
    242 /**
    243  * Internal worker that picks the processor speed in MHz from /proc/cpuinfo.
    244  *
    245  * @returns CPU frequency.
    246  */
    247 static uint32_t rtMpLinuxGetFrequency(RTCPUID idCpu)
    248 {
    249     FILE *pFile = fopen("/proc/cpuinfo", "r");
    250     if (!pFile)
    251         return 0;
    252 
    253     char sz[256];
    254     RTCPUID idCpuFound = NIL_RTCPUID;
    255     uint32_t Frequency = 0;
    256     while (fgets(sz, sizeof(sz), pFile))
    257     {
    258         char *psz;
    259         if (   !strncmp(sz, "processor", 9)
    260             && (sz[10] == ' ' || sz[10] == '\t' || sz[10] == ':')
    261             && (psz = strchr(sz, ':')))
    262         {
    263             psz += 2;
    264             int64_t iCpu;
    265             int rc = RTStrToInt64Ex(psz, NULL, 0, &iCpu);
    266             if (RT_SUCCESS(rc))
    267                 idCpuFound = iCpu;
    268         }
    269         else if (   idCpu == idCpuFound
    270                  && !strncmp(sz, "cpu MHz", 7)
    271                  && (sz[10] == ' ' || sz[10] == '\t' || sz[10] == ':')
    272                  && (psz = strchr(sz, ':')))
    273         {
    274             psz += 2;
    275             int64_t v;
    276             int rc = RTStrToInt64Ex(psz, &psz, 0, &v);
    277             if (RT_SUCCESS(rc))
    278             {
    279                 Frequency = v;
    280                 break;
    281             }
    282         }
    283     }
    284     fclose(pFile);
    285     return Frequency;
    286 }
    287 
    288 
    289 /** @todo RTmpCpuId(). */
    290 
    291 RTDECL(int) RTMpCpuIdToSetIndex(RTCPUID idCpu)
    292 {
    293     return idCpu < rtMpLinuxMaxCpus() ? idCpu : -1;
    294 }
    295 
    296 
    297 RTDECL(RTCPUID) RTMpCpuIdFromSetIndex(int iCpu)
    298 {
    299     return (unsigned)iCpu < rtMpLinuxMaxCpus() ? iCpu : NIL_RTCPUID;
    300 }
    301 
    302 
    303 RTDECL(RTCPUID) RTMpGetMaxCpuId(void)
    304 {
    305     return rtMpLinuxMaxCpus() - 1;
    306 }
    307 
    308 
    309 RTDECL(bool) RTMpIsCpuOnline(RTCPUID idCpu)
    310 {
    311     /** @todo check if there is a simpler interface than this... */
    312     int i = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/online", (int)idCpu);
    313     if (    i == -1
    314         &&  rtLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu))
    315     {
    316         Assert(!rtLinuxSysFsExists("devices/system/cpu/cpu%d/online", (int)idCpu));
    317         i = 1;
    318     }
    319 
    320     Assert(i == 0 || i == -1 || i == 1);
    321     return i != 0 && i != -1;
    322 }
    323 
    324 
    325 RTDECL(bool) RTMpIsCpuPossible(RTCPUID idCpu)
    326 {
    327     /** @todo check this up with hotplugging! */
    328     return rtLinuxSysFsExists("devices/system/cpu/cpu%d", (int)idCpu);
    329 }
    330 
    331 
    332 RTDECL(PRTCPUSET) RTMpGetSet(PRTCPUSET pSet)
    333 {
    334     RTCpuSetEmpty(pSet);
    335     RTCPUID cMax = rtMpLinuxMaxCpus();
    336     for (RTCPUID idCpu = 0; idCpu < cMax; idCpu++)
    337         if (RTMpIsCpuPossible(idCpu))
    338             RTCpuSetAdd(pSet, idCpu);
    339     return pSet;
    340 }
    341 
    342 
    343 RTDECL(RTCPUID) RTMpGetCount(void)
    344 {
    345     RTCPUSET Set;
    346     RTMpGetSet(&Set);
    347     return RTCpuSetCount(&Set);
    348 }
    349 
    350 
    351 RTDECL(PRTCPUSET) RTMpGetOnlineSet(PRTCPUSET pSet)
    352 {
    353     RTCpuSetEmpty(pSet);
    354     RTCPUID cMax = rtMpLinuxMaxCpus();
    355     for (RTCPUID idCpu = 0; idCpu < cMax; idCpu++)
    356         if (RTMpIsCpuOnline(idCpu))
    357             RTCpuSetAdd(pSet, idCpu);
    358     return pSet;
    359 }
    360 
    361 
    362 RTDECL(RTCPUID) RTMpGetOnlineCount(void)
    363 {
    364     RTCPUSET Set;
    365     RTMpGetOnlineSet(&Set);
    366     return RTCpuSetCount(&Set);
    367 }
    368 
    369 
    370 RTDECL(uint32_t) RTMpGetCurFrequency(RTCPUID idCpu)
    371 {
    372     int64_t kHz = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/cpufreq/cpuinfo_cur_freq", (int)idCpu);
    373     if (kHz == -1)
    374     {
    375         /*
    376          * The file may be just unreadable - in that case use plan B, i.e.
    377          * /proc/cpuinfo to get the data we want. The assumption is that if
    378          * cpuinfo_cur_freq doesn't exist then the speed won't change, and
    379          * thus cur == max. If it does exist then cpuinfo contains the
    380          * current frequency.
    381          */
    382         kHz = rtMpLinuxGetFrequency(idCpu) * 1000;
    383     }
    384     return (kHz + 999) / 1000;
    385 }
    386 
    387 
    388 RTDECL(uint32_t) RTMpGetMaxFrequency(RTCPUID idCpu)
    389 {
    390     int64_t kHz = rtLinuxSysFsReadIntFile(0, "devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", (int)idCpu);
    391     if (kHz == -1)
    392     {
    393         /*
    394          * Check if the file isn't there - if it is there, then /proc/cpuinfo
    395          * would provide current frequency information, which is wrong.
    396          */
    397         if (!rtLinuxSysFsExists("devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", (int)idCpu))
    398             kHz = rtMpLinuxGetFrequency(idCpu) * 1000;
    399         else
    400             kHz = 0;
    401     }
    402     return (kHz + 999) / 1000;
    403 }
     242 * Reads a string from a sysfs file.  If the file contains a newline, we only
     243 * return the text up until there.
     244 *
     245 * @returns number of characters read on success, -1 and errno on failure.
     246 * @param   pszBuf      Where to store the path element.  Must be at least two
     247 *                      characters, but a longer buffer would be advisable.
     248 * @param   cchBuf      The size of the buffer pointed to by @a pszBuf.
     249 * @param   pszFormat   The filename format, either absolute or relative to "/sys/".
     250 * @param   va          Format args.
     251 */
     252ssize_t RTLinuxSysFsReadStrFileV(char *pszBuf, size_t cchBuf, const char *pszFormat, va_list va)
     253{
     254    int fd = RTLinuxSysFsOpenV(pszFormat, va);
     255    if (fd == -1)
     256        return -1;
     257
     258    ssize_t cchRet = RTLinuxSysFsReadStr(fd, pszBuf, cchBuf);
     259    RTLinuxSysFsClose(fd);
     260    char *pchNewLine = NULL;
     261    if (cchRet > 0)
     262        pchNewLine = reinterpret_cast<char *>(memchr(pszBuf, '\n', cchRet));
     263    if (pchNewLine != NULL)
     264        *pchNewLine = '\0';
     265    return cchRet;
     266}
     267
     268
     269/**
     270 * Reads a string from a sysfs file.  If the file contains a newline, we only
     271 * return the text up until there.
     272 *
     273 * @returns number of characters read on success, -1 and errno on failure.
     274 * @param   pszBuf      Where to store the path element.  Must be at least two
     275 *                      characters, but a longer buffer would be advisable.
     276 * @param   cchBuf      The size of the buffer pointed to by @a pszBuf.
     277 * @param   pszFormat   The filename format, either absolute or relative to "/sys/".
     278 * @param   ...         Format args.
     279 */
     280ssize_t RTLinuxSysFsReadStrFile(char *pszBuf, size_t cchBuf, const char *pszFormat, ...)
     281{
     282    va_list va;
     283    va_start(va, pszFormat);
     284    ssize_t cchRet = RTLinuxSysFsReadStrFileV(pszBuf, cchBuf, pszFormat, va);
     285    va_end(va);
     286    return cchRet;
     287}
     288
     289
     290/**
     291 * Reads the last element of the path of the file pointed to by the symbolic
     292 * link specified.  This is needed at least to get the name of the driver
     293 * associated with a device, where pszFormat should be the "driver" link in the
     294 * devices sysfs directory.
     295 *
     296 * @returns The number of characters written on success, -1 and errno on failure.
     297 * @param   pszBuf      Where to store the path element.  Must be at least two
     298 *                      characters, but a longer buffer would be advisable.
     299 * @param   cchBuf      The size of the buffer pointed to by @a pszBuf.
     300 * @param   pszFormat   The filename format, either absolute or relative to "/sys/".
     301 * @param   ...         Format args.
     302 */
     303int RTLinuxSysFsGetLinkDest(char *pszBuf, size_t cchBuf, const char *pszFormat, ...)
     304{
     305    if (cchBuf < 2)
     306        AssertFailedReturnStmt(errno = EINVAL, -1);
     307    va_list va;
     308    va_start(va, pszFormat);
     309    char szFilename[RTPATH_MAX], szLink[RTPATH_MAX];
     310    int rc = rtLinuxSysFsConstructPath(szFilename, sizeof(szFilename), pszFormat, va);
     311    va_end(va);
     312    if (rc == sizeof(szFilename))
     313    {
     314        rc = -1;
     315        errno = EINVAL;  /* Bad format arguements */
     316    }
     317    if (rc > 0)
     318        rc = readlink(szFilename, szLink, sizeof(szLink));
     319    if (rc > 0 && static_cast<size_t>(rc) > sizeof(szLink) - 1)
     320    {
     321        rc = -1;
     322        errno = EIO;  /* The path name can't be this big. */
     323    }
     324    if (rc >= 0)
     325    {
     326        szLink[rc] = '\0';
     327        char *lastPart = strrchr(szLink, '/');
     328        Assert(lastPart != NULL);  /* rtLinuxSysFsConstructPath guarantees a path
     329                                    * starting with '/'. */
     330        *pszBuf = '\0';
     331        strncat(pszBuf, lastPart + 1, cchBuf);
     332        rc = strlen(pszBuf);
     333    }
     334    return rc;
     335}
     336
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette