File indexing completed on 2024-04-28 05:31:39

 /*
     SPDX-FileCopyrightText: 2007 John Tapsell <tapsell@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "process.h"
 #include "processes_local_p.h"
 #include "read_procsmaps_runnable.h"
 
 #include <klocalizedstring.h>
 
 #include <QByteArray>
 #include <QDir>
 #include <QFile>
 #include <QHash>
 #include <QSet>
 #include <QTextStream>
 #include <QThreadPool>
 
 // for sysconf
 #include <unistd.h>
 // for kill and setNice
 #include <dirent.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/types.h>
 // for ionice
 #include <asm/unistd.h>
 #include <sys/ptrace.h>
 // for getsched
 #include <sched.h>
 
 #define PROCESS_BUFFER_SIZE 1000
 
 /* For ionice */
 extern int sys_ioprio_set(int, int, int);
 extern int sys_ioprio_get(int, int);
 
 #define HAVE_IONICE
 /* Check if this system has ionice */
 #if !defined(SYS_ioprio_get) || !defined(SYS_ioprio_set)
 /* All new kernels have SYS_ioprio_get and _set defined, but for the few that do not, here are the definitions */
 #if defined(__i386__)
 #define __NR_ioprio_set 289
 #define __NR_ioprio_get 290
 #elif defined(__ppc__) || defined(__powerpc__)
 #define __NR_ioprio_set 273
 #define __NR_ioprio_get 274
 #elif defined(__x86_64__)
 #define __NR_ioprio_set 251
 #define __NR_ioprio_get 252
 #elif defined(__ia64__)
 #define __NR_ioprio_set 1274
 #define __NR_ioprio_get 1275
 #else
 #ifdef __GNUC__
 #warning "This architecture does not support IONICE.  Disabling ionice feature."
 #endif
 #undef HAVE_IONICE
 #endif
 /* Map these to SYS_ioprio_get */
 #define SYS_ioprio_get __NR_ioprio_get
 #define SYS_ioprio_set __NR_ioprio_set
 
 #endif /* !SYS_ioprio_get */
 
 /* Set up ionice functions */
 #ifdef HAVE_IONICE
 #define IOPRIO_WHO_PROCESS 1
 #define IOPRIO_CLASS_SHIFT 13
 
 /* Expose the kernel calls to userspace via syscall
  * See man ioprio_set  and man ioprio_get   for information on these functions */
 static int ioprio_set(int which, int who, int ioprio)
 {
     return syscall(SYS_ioprio_set, which, who, ioprio);
 }
 
 static int ioprio_get(int which, int who)
 {
     return syscall(SYS_ioprio_get, which, who);
 }
 #endif
 
 namespace KSysGuard
 {
 class ProcessesLocal::Private
 {
 public:
     Private()
     {
         mProcDir = opendir("/proc");
     }
     ~Private();
     inline bool readProcStatus(const QString &dir, Process *process);
     inline bool readProcStat(const QString &dir, Process *process);
     inline bool readProcStatm(const QString &dir, Process *process);
     inline bool readProcCmdline(const QString &dir, Process *process);
     inline bool readProcCGroup(const QString &dir, Process *process);
     inline bool readProcAttr(const QString &dir, Process *process);
     inline bool getNiceness(long pid, Process *process);
     inline bool getIOStatistics(const QString &dir, Process *process);
     QFile mFile;
     char mBuffer[PROCESS_BUFFER_SIZE + 1]; // used as a buffer to read data into
     DIR *mProcDir;
 };
 
 ProcessesLocal::Private::~Private()
 {
     closedir(mProcDir);
 }
 
 ProcessesLocal::ProcessesLocal()
     : d(new Private())
 {
 }
 bool ProcessesLocal::Private::readProcStatus(const QString &dir, Process *process)
 {
     mFile.setFileName(dir + QStringLiteral("status"));
     if (!mFile.open(QIODevice::ReadOnly))
         return false; /* process has terminated in the meantime */
 
     process->setUid(0);
     process->setGid(0);
     process->setTracerpid(-1);
     process->setNumThreads(0);
     process->setNoNewPrivileges(0);
 
     int size;
     int found = 0; // count how many fields we found
     while ((size = mFile.readLine(mBuffer, sizeof(mBuffer))) > 0) { //-1 indicates an error
         switch (mBuffer[0]) {
         case 'N':
             if ((unsigned int)size > sizeof("Name:") && qstrncmp(mBuffer, "Name:", sizeof("Name:") - 1) == 0) {
                 if (process->command().isEmpty()) {
                     process->setName(QString::fromLocal8Bit(mBuffer + sizeof("Name:") - 1, size - sizeof("Name:") + 1).trimmed());
                 }
                 if (++found == 6) {
                     goto finish;
                 }
             } else if ((unsigned int)size > sizeof("NoNewPrivs:") && qstrncmp(mBuffer, "NoNewPrivs:", sizeof("NoNewPrivs:") - 1) == 0) {
                 process->setNoNewPrivileges(atol(mBuffer + sizeof("NoNewPrivs:") - 1));
                 if (++found == 6) {
                     goto finish;
                 }
             }
             break;
         case 'U':
             if ((unsigned int)size > sizeof("Uid:") && qstrncmp(mBuffer, "Uid:", sizeof("Uid:") - 1) == 0) {
                 qlonglong uid;
                 qlonglong euid;
                 qlonglong suid;
                 qlonglong fsuid;
                 sscanf(mBuffer + sizeof("Uid:") - 1, "%lld %lld %lld %lld", &uid, &euid, &suid, &fsuid);
                 process->setUid(uid);
                 process->setEuid(euid);
                 process->setSuid(suid);
                 process->setFsuid(fsuid);
                 if (++found == 6) {
                     goto finish;
                 }
             }
             break;
         case 'G':
             if ((unsigned int)size > sizeof("Gid:") && qstrncmp(mBuffer, "Gid:", sizeof("Gid:") - 1) == 0) {
                 qlonglong gid, egid, sgid, fsgid;
                 sscanf(mBuffer + sizeof("Gid:") - 1, "%lld %lld %lld %lld", &gid, &egid, &sgid, &fsgid);
                 process->setGid(gid);
                 process->setEgid(egid);
                 process->setSgid(sgid);
                 process->setFsgid(fsgid);
                 if (++found == 6) {
                     goto finish;
                 }
             }
             break;
         case 'T':
             if ((unsigned int)size > sizeof("TracerPid:") && qstrncmp(mBuffer, "TracerPid:", sizeof("TracerPid:") - 1) == 0) {
                 process->setTracerpid(atol(mBuffer + sizeof("TracerPid:") - 1));
                 if (process->tracerpid() == 0) {
                     process->setTracerpid(-1);
                 }
                 if (++found == 6) {
                     goto finish;
                 }
             } else if ((unsigned int)size > sizeof("Threads:") && qstrncmp(mBuffer, "Threads:", sizeof("Threads:") - 1) == 0) {
                 process->setNumThreads(atol(mBuffer + sizeof("Threads:") - 1));
                 if (++found == 6) {
                     goto finish;
                 }
             }
             break;
         default:
             break;
         }
     }
 
 finish:
     mFile.close();
     return true;
 }
 
 bool ProcessesLocal::Private::readProcCGroup(const QString &dir, Process *process)
 {
     mFile.setFileName(dir + QStringLiteral("cgroup"));
     if (!mFile.open(QIODevice::ReadOnly)) {
         return false; /* process has terminated in the meantime */
     }
 
     while (mFile.readLine(mBuffer, sizeof(mBuffer)) > 0) { //-1 indicates an error
         if (mBuffer[0] == '0' && mBuffer[1] == ':' && mBuffer[2] == ':') {
             process->setCGroup(QString::fromLocal8Bit(&mBuffer[3]).trimmed());
             break;
         }
     }
     mFile.close();
     return true;
 }
 
 bool ProcessesLocal::Private::readProcAttr(const QString &dir, Process *process)
 {
     mFile.setFileName(dir + QStringLiteral("attr/current"));
     if (!mFile.open(QIODevice::ReadOnly)) {
         return false; /* process has terminated in the meantime */
     }
 
     if (mFile.readLine(mBuffer, sizeof(mBuffer)) > 0) { //-1 indicates an error
         process->setMACContext(QString::fromLocal8Bit(mBuffer).trimmed());
     }
     mFile.close();
     return true;
 }
 
 long ProcessesLocal::getParentPid(long pid)
 {
     if (pid <= 0) {
         return -1;
     }
     d->mFile.setFileName(QStringLiteral("/proc/") + QString::number(pid) + QStringLiteral("/stat"));
     if (!d->mFile.open(QIODevice::ReadOnly)) {
         return -1; /* process has terminated in the meantime */
     }
 
     int size; // amount of data read in
     if ((size = d->mFile.readLine(d->mBuffer, sizeof(d->mBuffer))) <= 0) { //-1 indicates nothing read
         d->mFile.close();
         return -1;
     }
 
     d->mFile.close();
     char *word = d->mBuffer;
     // The command name is the second parameter, and this ends with a closing bracket.  So find the last
     // closing bracket and start from there
     word = strrchr(word, ')');
     if (!word) {
         return -1;
     }
     word++; // Nove to the space after the last ")"
     int current_word = 1;
 
     while (true) {
         if (word[0] == ' ') {
             if (++current_word == 3) {
                 break;
             }
         } else if (word[0] == 0) {
             return -1; // end of data - serious problem
         }
         word++;
     }
     long ppid = atol(++word);
     if (ppid == 0) {
         return -1;
     }
     return ppid;
 }
 
 bool ProcessesLocal::Private::readProcStat(const QString &dir, Process *ps)
 {
     QString filename = dir + QStringLiteral("stat");
     // As an optimization, if the last file read in was stat, then we already have this info in memory
     if (mFile.fileName() != filename) {
         mFile.setFileName(filename);
         if (!mFile.open(QIODevice::ReadOnly)) {
             return false; /* process has terminated in the meantime */
         }
         if (mFile.readLine(mBuffer, sizeof(mBuffer)) <= 0) { //-1 indicates nothing read
             mFile.close();
             return false;
         }
         mFile.close();
     }
 
     char *word = mBuffer;
     // The command name is the second parameter, and this ends with a closing bracket.  So find the last
     // closing bracket and start from there
     word = strrchr(word, ')');
     if (!word) {
         return false;
     }
     word++; // Nove to the space after the last ")"
     int current_word = 1; // We've skipped the process ID and now at the end of the command name
     char status = '\0';
     unsigned long long vmSize = 0;
     unsigned long long vmRSS = 0;
     while (current_word < 23) {
         if (word[0] == ' ') {
             ++current_word;
             switch (current_word) {
             case 2: // status
                 status = word[1]; // Look at the first letter of the status.
                 // We analyze this after the while loop
                 break;
             case 6: // ttyNo
             {
                 int ttyNo = atoi(word + 1);
                 int major = ttyNo >> 8;
                 int minor = ttyNo & 0xff;
                 switch (major) {
                 case 136:
                     ps->setTty(QByteArray("pts/") + QByteArray::number(minor));
                     break;
                 case 5:
                     ps->setTty(QByteArray("tty"));
                     break;
                 case 4:
                     if (minor < 64) {
                         ps->setTty(QByteArray("tty") + QByteArray::number(minor));
                     } else {
                         ps->setTty(QByteArray("ttyS") + QByteArray::number(minor - 64));
                     }
                     break;
                 default:
                     ps->setTty(QByteArray());
                 }
             } break;
             case 13: // userTime
                 ps->setUserTime(atoll(word + 1));
                 break;
             case 14: // sysTime
                 ps->setSysTime(atoll(word + 1));
                 break;
             case 18: // niceLevel
                 ps->setNiceLevel(atoi(word + 1)); /*Or should we use getPriority instead? */
                 break;
             case 21: // startTime
                 ps->setStartTime(atoll(word + 1));
                 break;
             case 22: // vmSize
                 vmSize = atoll(word + 1);
                 break;
             case 23: // vmRSS
                 vmRSS = atoll(word + 1);
                 break;
             default:
                 break;
             }
         } else if (word[0] == 0) {
             return false; // end of data - serious problem
         }
         word++;
     }
 
     /* There was a "(ps->vmRss+3) * sysconf(_SC_PAGESIZE)" here in the original ksysguard code.  I have no idea why!  After comparing it to
      *   meminfo and other tools, this means we report the RSS by 12 bytes differently compared to them.  So I'm removing the +3
      *   to be consistent.  NEXT TIME COMMENT STRANGE THINGS LIKE THAT! :-)
      *
      *   Update: I think I now know why - the kernel allocates 3 pages for
      *   tracking information about each the process. This memory isn't
      *   included in vmRSS..*/
     ps->setVmRSS(vmRSS * (sysconf(_SC_PAGESIZE) / 1024)); /*convert to KiB*/
     ps->setVmSize(vmSize / 1024); /* convert to KiB */
 
     switch (status) {
     case 'R':
         ps->setStatus(Process::Running);
         break;
     case 'S':
         ps->setStatus(Process::Sleeping);
         break;
     case 'D':
         ps->setStatus(Process::DiskSleep);
         break;
     case 'Z':
         ps->setStatus(Process::Zombie);
         break;
     case 'T':
         ps->setStatus(Process::Stopped);
         break;
     case 'W':
         ps->setStatus(Process::Paging);
         break;
     default:
         ps->setStatus(Process::OtherStatus);
         break;
     }
     return true;
 }
 
 bool ProcessesLocal::Private::readProcStatm(const QString &dir, Process *process)
 {
 #ifdef _SC_PAGESIZE
     mFile.setFileName(dir + QStringLiteral("statm"));
     if (!mFile.open(QIODevice::ReadOnly)) {
         return false; /* process has terminated in the meantime */
     }
 
     if (mFile.readLine(mBuffer, sizeof(mBuffer)) <= 0) { //-1 indicates nothing read
         mFile.close();
         return 0;
     }
     mFile.close();
 
     int current_word = 0;
     char *word = mBuffer;
 
     while (true) {
         if (word[0] == ' ') {
             if (++current_word == 2) {
                 // number of pages that are shared
                 break;
             }
         } else if (word[0] == 0) {
             return false; // end of data - serious problem
         }
         word++;
     }
     long shared = atol(word + 1);
 
     /* we use the rss - shared  to find the amount of memory just this app uses */
     process->setVmURSS(process->vmRSS() - (shared * sysconf(_SC_PAGESIZE) / 1024));
 #else
     process->setVmURSS(0);
 #endif
     return true;
 }
 
 bool ProcessesLocal::Private::readProcCmdline(const QString &dir, Process *process)
 {
     if (!process->command().isNull()) {
         return true; // only parse the cmdline once.  This function takes up 25% of the CPU time :-/
     }
     mFile.setFileName(dir + QStringLiteral("cmdline"));
     if (!mFile.open(QIODevice::ReadOnly)) {
         return false; /* process has terminated in the meantime */
     }
 
     QTextStream in(&mFile);
     process->setCommand(in.readAll());
 
     // cmdline separates parameters with the NULL character
     if (!process->command().isEmpty()) {
         // extract non-truncated name from cmdline
         int zeroIndex = process->command().indexOf(QLatin1Char('\0'));
         int processNameStart = process->command().lastIndexOf(QLatin1Char('/'), zeroIndex);
         if (processNameStart == -1) {
             processNameStart = 0;
         } else {
             processNameStart++;
         }
         QString nameFromCmdLine = process->command().mid(processNameStart, zeroIndex - processNameStart);
         if (nameFromCmdLine.startsWith(process->name())) {
             process->setName(nameFromCmdLine);
         }
 
         process->command().replace(QLatin1Char('\0'), QLatin1Char(' '));
     }
 
     mFile.close();
     return true;
 }
 
 bool ProcessesLocal::Private::getNiceness(long pid, Process *process)
 {
     int sched = sched_getscheduler(pid);
     switch (sched) {
     case (SCHED_OTHER):
         process->setScheduler(KSysGuard::Process::Other);
         break;
     case (SCHED_RR):
         process->setScheduler(KSysGuard::Process::RoundRobin);
         break;
     case (SCHED_FIFO):
         process->setScheduler(KSysGuard::Process::Fifo);
         break;
 #ifdef SCHED_IDLE
     case (SCHED_IDLE):
         process->setScheduler(KSysGuard::Process::SchedulerIdle);
         break;
 #endif
 #ifdef SCHED_BATCH
     case (SCHED_BATCH):
         process->setScheduler(KSysGuard::Process::Batch);
         break;
 #endif
     default:
         process->setScheduler(KSysGuard::Process::Other);
     }
     if (sched == SCHED_FIFO || sched == SCHED_RR) {
         struct sched_param param;
         if (sched_getparam(pid, &param) == 0) {
             process->setNiceLevel(param.sched_priority);
         } else {
             process->setNiceLevel(0); // Error getting scheduler parameters.
         }
     }
 
 #ifdef HAVE_IONICE
     int ioprio = ioprio_get(IOPRIO_WHO_PROCESS, pid); /* Returns from 0 to 7 for the iopriority, and -1 if there's an error */
     if (ioprio == -1) {
         process->setIoniceLevel(-1);
         process->setIoPriorityClass(KSysGuard::Process::None);
         return false; /* Error. Just give up. */
     }
     process->setIoniceLevel(ioprio & 0xff); /* Bottom few bits are the priority */
     process->setIoPriorityClass((KSysGuard::Process::IoPriorityClass)(ioprio >> IOPRIO_CLASS_SHIFT)); /* Top few bits are the class */
     return true;
 #else
     return false; /* Do nothing, if we do not support this architecture */
 #endif
 }
 
 bool ProcessesLocal::Private::getIOStatistics(const QString &dir, Process *process)
 {
     QString filename = dir + QStringLiteral("io");
     // As an optimization, if the last file read in was io, then we already have this info in memory
     mFile.setFileName(filename);
     if (!mFile.open(QIODevice::ReadOnly)) {
         return false; /* process has terminated in the meantime */
     }
     if (mFile.read(mBuffer, sizeof(mBuffer)) <= 0) { //-1 indicates nothing read
         mFile.close();
         return false;
     }
     mFile.close();
 
     int current_word = 0; // count from 0
     char *word = mBuffer;
     while (current_word < 6 && word[0] != 0) {
         if (word[0] == ' ') {
             qlonglong number = atoll(word + 1);
             switch (current_word++) {
             case 0: // rchar - characters read
                 process->setIoCharactersRead(number);
                 break;
             case 1: // wchar - characters written
                 process->setIoCharactersWritten(number);
                 break;
             case 2: // syscr - read syscall
                 process->setIoReadSyscalls(number);
                 break;
             case 3: // syscw - write syscall
                 process->setIoWriteSyscalls(number);
                 break;
             case 4: // read_bytes - bytes actually read from I/O
                 process->setIoCharactersActuallyRead(number);
                 break;
             case 5: // write_bytes - bytes actually written to I/O
                 process->setIoCharactersActuallyWritten(number);
             default:
                 break;
             }
         }
         word++;
     }
     return true;
 }
 
 bool ProcessesLocal::updateProcessInfo(long pid, Process *process)
 {
     bool success = true;
     const QString dir = QLatin1String("/proc/") + QString::number(pid) + QLatin1Char('/');
 
     if (mUpdateFlags.testFlag(Processes::Smaps)) {
         auto runnable = new ReadProcSmapsRunnable{dir};
 
         connect(runnable, &ReadProcSmapsRunnable::finished, this, [this, pid](qulonglong pss) {
             Q_EMIT processUpdated(pid, {{Process::VmPSS, pss}});
         });
 
         QThreadPool::globalInstance()->start(runnable);
     }
 
     if (!d->readProcStat(dir, process)) {
         success = false;
     }
     if (!d->readProcStatus(dir, process)) {
         success = false;
     }
     if (!d->readProcStatm(dir, process)) {
         success = false;
     }
     if (!d->readProcCmdline(dir, process)) {
         success = false;
     }
     if (!d->readProcCGroup(dir, process)) {
         success = false;
     }
     if (!d->readProcAttr(dir, process)) {
         success = false;
     }
     if (!d->getNiceness(pid, process)) {
         success = false;
     }
     if (mUpdateFlags.testFlag(Processes::IOStatistics) && !d->getIOStatistics(dir, process)) {
         success = false;
     }
 
     return success;
 }
 
 QSet<long> ProcessesLocal::getAllPids()
 {
     QSet<long> pids;
     if (d->mProcDir == nullptr) {
         return pids; // There's not much we can do without /proc
     }
     struct dirent *entry;
     rewinddir(d->mProcDir);
     while ((entry = readdir(d->mProcDir))) {
         if (entry->d_name[0] >= '0' && entry->d_name[0] <= '9') {
             pids.insert(atol(entry->d_name));
         }
     }
     return pids;
 }
 
 Processes::Error ProcessesLocal::sendSignal(long pid, int sig)
 {
     errno = 0;
     if (pid <= 0) {
         return Processes::InvalidPid;
     }
     if (kill((pid_t)pid, sig)) {
         switch (errno) {
         case ESRCH:
             return Processes::ProcessDoesNotExistOrZombie;
         case EINVAL:
             return Processes::InvalidParameter;
         case EPERM:
             return Processes::InsufficientPermissions;
         }
         // Kill failed
         return Processes::Unknown;
     }
     return Processes::NoError;
 }
 
 Processes::Error ProcessesLocal::setNiceness(long pid, int priority)
 {
     errno = 0;
     if (pid <= 0) {
         return Processes::InvalidPid;
     }
     auto error = [] {
         switch (errno) {
         case ESRCH:
         case ENOENT:
             return Processes::ProcessDoesNotExistOrZombie;
         case EINVAL:
             return Processes::InvalidParameter;
         case EACCES:
         case EPERM:
             return Processes::InsufficientPermissions;
         default:
             return Processes::Unknown;
         }
     };
     auto threadList{QDir(QString::fromLatin1("/proc/%1/task").arg(pid)).entryList(QDir::NoDotAndDotDot | QDir::Dirs)};
     if (threadList.isEmpty()) {
         return error();
     }
     for (auto entry : threadList) {
         int threadId = entry.toInt();
         if (!threadId) {
             return Processes::InvalidParameter;
         }
         if (setpriority(PRIO_PROCESS, threadId, priority)) {
             return error();
         }
     }
     return Processes::NoError;
 }
 
 Processes::Error ProcessesLocal::setScheduler(long pid, int priorityClass, int priority)
 {
     errno = 0;
     if (priorityClass == KSysGuard::Process::Other || priorityClass == KSysGuard::Process::Batch || priorityClass == KSysGuard::Process::SchedulerIdle) {
         priority = 0;
     }
     if (pid <= 0) {
         return Processes::InvalidPid;
     }
     struct sched_param params;
     params.sched_priority = priority;
     int policy;
     switch (priorityClass) {
     case (KSysGuard::Process::Other):
         policy = SCHED_OTHER;
         break;
     case (KSysGuard::Process::RoundRobin):
         policy = SCHED_RR;
         break;
     case (KSysGuard::Process::Fifo):
         policy = SCHED_FIFO;
         break;
 #ifdef SCHED_IDLE
     case (KSysGuard::Process::SchedulerIdle):
         policy = SCHED_IDLE;
         break;
 #endif
 #ifdef SCHED_BATCH
     case (KSysGuard::Process::Batch):
         policy = SCHED_BATCH;
         break;
 #endif
     default:
         return Processes::NotSupported;
     }
 
     auto error = [] {
         switch (errno) {
         case ESRCH:
         case ENOENT:
             return Processes::ProcessDoesNotExistOrZombie;
         case EINVAL:
             return Processes::InvalidParameter;
         case EPERM:
             return Processes::InsufficientPermissions;
         default:
             return Processes::Unknown;
         }
     };
     auto threadList{QDir(QString::fromLatin1("/proc/%1/task").arg(pid)).entryList(QDir::NoDotAndDotDot | QDir::Dirs)};
     if (threadList.isEmpty()) {
         return error();
     }
     for (auto entry : threadList) {
         int threadId = entry.toInt();
         if (!threadId) {
             return Processes::InvalidParameter;
         }
         if (sched_setscheduler(threadId, policy, &params) != 0) {
             return error();
         }
     }
     return Processes::NoError;
 }
 
 Processes::Error ProcessesLocal::setIoNiceness(long pid, int priorityClass, int priority)
 {
     errno = 0;
     if (pid <= 0) {
         return Processes::InvalidPid;
     }
 #ifdef HAVE_IONICE
     if (ioprio_set(IOPRIO_WHO_PROCESS, pid, priority | priorityClass << IOPRIO_CLASS_SHIFT) == -1) {
         // set io niceness failed
         switch (errno) {
         case ESRCH:
             return Processes::ProcessDoesNotExistOrZombie;
             break;
         case EINVAL:
             return Processes::InvalidParameter;
         case EPERM:
             return Processes::InsufficientPermissions;
         }
         return Processes::Unknown;
     }
     return Processes::NoError;
 #else
     return Processes::NotSupported;
 #endif
 }
 
 bool ProcessesLocal::supportsIoNiceness()
 {
 #ifdef HAVE_IONICE
     return true;
 #else
     return false;
 #endif
 }
 
 long long ProcessesLocal::totalPhysicalMemory()
 {
     // Try to get the memory via sysconf.  Note the cast to long long to try to avoid a long overflow
     // Should we use sysconf(_SC_PAGESIZE)  or getpagesize()  ?
 #ifdef _SC_PHYS_PAGES
     return ((long long)sysconf(_SC_PHYS_PAGES)) * (sysconf(_SC_PAGESIZE) / 1024);
 #else
     // This is backup code in case this is not defined.  It should never fail on a linux system.
 
     d->mFile.setFileName("/proc/meminfo");
     if (!d->mFile.open(QIODevice::ReadOnly)) {
         return 0;
     }
 
     int size;
     while ((size = d->mFile.readLine(d->mBuffer, sizeof(d->mBuffer))) > 0) { //-1 indicates an error
         switch (d->mBuffer[0]) {
         case 'M':
             if ((unsigned int)size > sizeof("MemTotal:") && qstrncmp(d->mBuffer, "MemTotal:", sizeof("MemTotal:") - 1) == 0) {
                 d->mFile.close();
                 return atoll(d->mBuffer + sizeof("MemTotal:") - 1);
             }
         }
     }
     return 0; // Not found.  Probably will never happen
 #endif
 }
 ProcessesLocal::~ProcessesLocal()
 {
     delete d;
 }
 
 }