DRCEReadProcessData.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/dir.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "DRCEReadProcessData.hpp"

EXTERN_C_BEGIN
//-----------------------------------------------------------------------------
static void *xcalloc(void *pointer, int size)
{
  void * ret;
  if (pointer)
    free(pointer);
  if (!(ret = calloc(1, size)))
  {
    fprintf(stderr, "xcalloc: allocation error, size = %d\n", size);
    exit(1);
  }
  return ret;
}
//-----------------------------------------------------------------------------
static void *xmalloc(unsigned int size)
{
  void *p;

  if (size == 0)
    ++size;
  p = malloc(size);
  if (!p)
  {
    fprintf(stderr, "xmalloc: malloc(%u) failed", size);
    exit(1);
  }
  return(p);
}

static int task_dir_missing;
//-----------------------------------------------------------------------------
typedef struct status_table_struct
{
  enum{SZ=10};/*
  status_table_struct(const char* name_, unsigned char len_, void* addr_)
  {
    memset(&name, 0, SZ);
    strcpy((char*)name, name_);
    len = len_;
    addr = addr_;
  }
  status_table_struct(void)
  {
    memset(&name, 0, SZ);
    len = 0;
    addr = NULL;
  }
  status_table_struct& operator=(const status_table_struct& rhs)
  {
    if (&rhs!=this)
    {
      memset(&name, 0, SZ);
      strcpy((char*)name, (char*)(rhs.name));
      len = rhs.len;
      addr = rhs.addr;
    }
    return *this;
  }*/

  unsigned char name[SZ];        // /proc/*/status field name
  unsigned char len;            // name length
//  long offset;                  // jump address offset
  void *addr;
} status_table_struct;

//#define F(x) {#x, sizeof(#x)-1, (long)(&&case_##x - &&base)},
#define F(x) {#x, sizeof(#x)-1, &&case_##x},
#define NUL  {"", 0, 0},

// Suggested method:
// Grep this file for "case_", then strip those down to the name.
// (leave the colon and newline) So "Pid:\n" and "Threads:\n"
// would be lines in the file. (no quote, no escape, etc.)
//
// Watch out for name size in the status_table_struct (grrr, expanding)
// and the number of entries (we mask with 63 for now). The table
// must be padded out to 64 entries, maybe 128 in the future.

static void status2proc(char *S, proc_t *restrict P, int is_proc)
{
  long Threads = 0;
  long Tgid = 0;
  long Pid = 0;

  static const unsigned char asso[] =
  {
    61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
    61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
    61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
    61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
    61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
    61, 61, 61, 61, 61, 61, 61, 61, 15, 61,
    61, 61, 61, 61, 61, 61, 30,  3,  5,  5,
    61,  5, 61,  8, 61, 61,  3, 61, 10, 61,
     6, 61, 13,  0, 30, 25,  0, 61, 61, 61,
    61, 61, 61, 61, 61, 61, 61,  3, 61, 13,
     0,  0, 61, 30, 61, 25, 61, 61, 61,  0,
    61, 61, 61, 61,  5, 61,  0, 61, 61, 61,
     0, 61, 61, 61, 61, 61, 61, 61
  };

  static const status_table_struct table[] = {
    F(VmStk)
    NUL NUL
    F(State)
    NUL
    F(VmExe)
    F(ShdPnd)
    NUL
    F(VmData)
    NUL
    F(Name)
    NUL NUL
    F(VmRSS)
    NUL NUL
    F(VmLck)
    NUL NUL NUL
    F(Gid)
    F(Pid)
    NUL NUL NUL
    F(VmSize)
    NUL NUL
    F(VmLib)
    NUL NUL
    F(PPid)
    NUL
    F(SigCgt)
    NUL
    F(Threads)
    F(SigPnd)
    NUL
    F(SigIgn)
    NUL
    F(Uid)
    NUL NUL NUL NUL NUL NUL NUL NUL NUL
    NUL NUL NUL NUL NUL
    F(Tgid)
    NUL NUL NUL NUL
    F(SigBlk)
    NUL NUL NUL
  };

#undef F
#undef NUL

  P->vm_size = 0;
  P->vm_lock = 0;
  P->vm_rss  = 0;
  P->vm_data = 0;
  P->vm_stack= 0;
  P->vm_exe  = 0;
  P->vm_lib  = 0;
  P->nlwp    = 0;
  P->signal[0] = '\0';  // so we can detect it as missing for very old kernels

  goto base;

  for(;;)
  {
    char *colon;
    status_table_struct entry;

    // advance to next line
    S = strchr(S, '\n');
    if(unlikely(!S))
      break;  // if no newline
    S++;

      // examine a field name (hash and compare)
    base:
      if(unlikely(!*S))
        break;
      entry = table[63 & (asso[(unsigned char)S[3]] + asso[(unsigned char)S[2]] + asso[(unsigned char)S[0]])];
      colon = strchr(S, ':');
      if(unlikely(!colon)) break;
      if(unlikely(colon[1]!='\t')) break;
      if(unlikely(colon-S != entry.len)) continue;
      if(unlikely(memcmp(entry.name,S,colon-S))) continue;

      S = colon+2; // past the '\t'

//    goto *(&&base + entry.offset);
    goto *entry.addr;

    case_Name:
    {
      unsigned u = 0;
      while(u < sizeof P->cmd - 1u)
      {
        int c = *S++;
        if(unlikely(c=='\n'))
          break;
        if(unlikely(c=='\0'))
          break; // should never happen
        if(unlikely(c=='\\'))
        {
          c = *S++;
          if(c=='\n')
            break; // should never happen
          if(!c)
            break; // should never happen
          if(c=='n')
            c='\n'; // else we assume it is '\\'
        }
        P->cmd[u++] = c;
      }
      P->cmd[u] = '\0';
      S--;   // put back the '\n' or '\0'
      continue;
    }
    case_ShdPnd:
      memcpy(P->signal, S, 16);
      P->signal[16] = '\0';
      continue;
    case_SigBlk:
      memcpy(P->blocked, S, 16);
      P->blocked[16] = '\0';
      continue;
    case_SigCgt:
      memcpy(P->sigcatch, S, 16);
      P->sigcatch[16] = '\0';
      continue;
    case_SigIgn:
      memcpy(P->sigignore, S, 16);
      P->sigignore[16] = '\0';
      continue;
    case_SigPnd:
      memcpy(P->_sigpnd, S, 16);
      P->_sigpnd[16] = '\0';
      continue;

    case_State:
      P->state = *S;
      continue;
    case_Tgid:
      Tgid = strtol(S,&S,10);
      continue;
    case_Pid:
      Pid = strtol(S,&S,10);
      continue;
    case_PPid:
      P->ppid = strtol(S,&S,10);
      continue;
    case_Threads:
      Threads = strtol(S,&S,10);
      continue;
    case_Uid:
      P->ruid = strtol(S,&S,10);
      P->euid = strtol(S,&S,10);
      P->suid = strtol(S,&S,10);
      P->fuid = strtol(S,&S,10);
      continue;
    case_Gid:
      P->rgid = strtol(S,&S,10);
      P->egid = strtol(S,&S,10);
      P->sgid = strtol(S,&S,10);
      P->fgid = strtol(S,&S,10);
      continue;
    case_VmData:
      P->vm_data = strtol(S,&S,10);
      continue;
    case_VmExe:
      P->vm_exe = strtol(S,&S,10);
      continue;
    case_VmLck:
      P->vm_lock = strtol(S,&S,10);
      continue;
    case_VmLib:
      P->vm_lib = strtol(S,&S,10);
      continue;
    case_VmRSS:
      P->vm_rss = strtol(S,&S,10);
      continue;
    case_VmSize:
      P->vm_size = strtol(S,&S,10);
      continue;
    case_VmStk:
      P->vm_stack = strtol(S,&S,10);
      continue;
  }

  // recent kernels supply per-tgid pending signals
  if(!is_proc || !P->signal[0])
  {
    memcpy(P->signal, P->_sigpnd, 16);
    P->signal[16] = '\0';
  }
  // Linux 2.4.13-pre1 to max 2.4.xx have a useless "Tgid"
  // that is not initialized for built-in kernel tasks.
  // Only 2.6.0 and above have "Threads" (nlwp) info.
  if(Threads)
  {
    P->nlwp = Threads;
    P->tgid = Tgid;     // the POSIX PID value
    P->tid  = Pid;      // the thread ID
  }
  else
  {
    P->nlwp = 1;
    P->tgid = Pid;
    P->tid  = Pid;
  }
}
//-----------------------------------------------------------------------------
// Reads /proc/*/stat files, being careful not to trip over processes with names
static void stat2proc(const char* S, proc_t *restrict P)
{
  unsigned num;
  char* tmp;

  /* fill in default values for older kernels */
  P->processor = 0;
  P->rtprio = -1;
  P->sched = -1;
  P->nlwp = 0;

  S = strchr(S, '(') + 1;
  tmp = strrchr((char*)S, ')');
  num = tmp - S;
  if(unlikely(num >= sizeof P->cmd)) num = sizeof P->cmd - 1;
  memcpy(P->cmd, S, num);
  P->cmd[num] = '\0';
  S = tmp + 2;                 // skip ") "

  sscanf(S,
     "%c "
     "%10d %10d %10d %10d %10d "
     "%20lu %20lu %20lu %20lu %20lu "
     "%20llu %20llu %20llu %20llu "  /* utime stime cutime cstime */
     "%20lu %20lu "
     "%10d "
     "%10lu "
     "%20llu "  /* start_time */
     "%20lu "
     "%20ld "
     "%20lu %20lu %20lu %20lu %20lu %20lu "
     "%*s %*s %*s %*s " /* discard, no RT signals & Linux 2.1 used hex */
     "%20lu "
     "%10d %10d "
     "%20lu %20lu",
     &P->state,
     &P->ppid, &P->pgrp, &P->session, &P->tty, &P->tpgid,
     &P->flags, &P->min_flt, &P->cmin_flt, &P->maj_flt, &P->cmaj_flt,
     &P->utime, &P->stime, &P->cutime, &P->cstime,
     &P->priority, &P->nice,
     &P->nlwp,
     &P->alarm,
     &P->start_time,
     &P->vsize,
     &P->rss,
     &P->rss_rlim, &P->start_code, &P->end_code, &P->start_stack, &P->kstk_esp, &P->kstk_eip,
/*     P->signal, P->blocked, P->sigignore, P->sigcatch,   */ /* can't use */
     &P->wchan,
/* -- Linux 2.0.35 ends here -- */
     &P->exit_signal, &P->processor,  /* 2.2.1 ends with "exit_signal" */
/* -- Linux 2.2.8 to 2.5.17 end here -- */
     &P->rtprio, &P->sched  /* both added to 2.5.18 */
  );

  if(!P->nlwp)
  {
    P->nlwp = 1;
  }
}
//-----------------------------------------------------------------------------
static void statm2proc(const char* s, proc_t *restrict P)
{
  if (P)
  {
    sscanf(s, "%20ld %20ld %20ld %20ld %20ld %20ld %20ld", &P->size, &P->resident, &P->share, &P->trs, &P->lrs, &P->drs, &P->dt);
  }
}
//-----------------------------------------------------------------------------
static int file2str(const char *directory, const char *what, char *ret, int cap)
{
  static char filename[80];
  int fd, num_read;

  sprintf(filename, "%s/%s", directory, what);
  fd = open(filename, O_RDONLY, 0);
  if(unlikely(fd==-1))
    return -1;
  num_read = read(fd, ret, cap - 1);
  close(fd);
  if(unlikely(num_read<=0))
    return -1;
  ret[num_read] = '\0';
  return num_read;
}

/* These are some nice GNU C expression subscope "inline" functions.
 * The can be used with arbitrary types and evaluate their arguments
 * exactly once.
 */

/* Test if item X of type T is present in the 0 terminated list L */
#   define XinL(T, X, L) ( {                    \
            T  x = (X), *l = (L);               \
            while (*l && *l != x) l++;          \
            *l == x;                            \
        } )

/* Test if item X of type T is present in the list L of length N */
#   define XinLN(T, X, L, N) ( {                \
            T x = (X), *l = (L);                \
            int i = 0, n = (N);                 \
            while (i < n && l[i] != x) i++;     \
            i < n && l[i] == x;                 \
        } )

// This reads process info from /proc in the traditional way, for one process.
// The pid (tgid? tid?) is already in p, and a path to it in path, with some
// room to spare.
static proc_t* simple_readproc(PROCTAB *restrict const PT, proc_t *restrict const p)
{
  static struct stat sb;                // stat() buffer
  static char sbuf[1024];       // buffer for stat,statm
  char *restrict const path = PT->path;
  unsigned flags = PT->flags;

  if (unlikely(stat(path, &sb) == -1))  /* no such dirent (anymore) */
    goto next_proc;

  if ((flags & PROC_UID) && !XinLN(uid_t, sb.st_uid, PT->uids, PT->nuid))
    goto next_proc;                     /* not one of the requested uids */

  p->euid = sb.st_uid;                  /* need a way to get real uid */
  p->egid = sb.st_gid;                  /* need a way to get real gid */

  if (flags & PROC_FILLSTAT)
  {         /* read, parse /proc/#/stat */
    if (unlikely( file2str(path, "stat", sbuf, sizeof sbuf) == -1 ))
            goto next_proc;                     /* error reading /proc/#/stat */
    stat2proc(sbuf, p);                         /* parse /proc/#/stat */
  }

  if (unlikely(flags & PROC_FILLMEM))
  {     /* read, parse /proc/#/statm */
    if (likely( file2str(path, "statm", sbuf, sizeof sbuf) != -1 ))
            statm2proc(sbuf, p);                /* ignore statm errors here */
  }                                             /* statm fields just zero */

  if (flags & PROC_FILLSTATUS)
  {         /* read, parse /proc/#/status */
    if (likely( file2str(path, "status", sbuf, sizeof sbuf) != -1 ))
    {
      status2proc(sbuf, p, 1);
    }
  }

  // if multithreaded, some values are crap
  if(p->nlwp > 1)
  {
    p->wchan = (long)~0ull;
  }

  return p;
next_proc:
  return NULL;
}
//-----------------------------------------------------------------------------
// This finds processes in /proc in the traditional way.
// Return non-zero on success.
static int simple_nextpid(PROCTAB *restrict const PT, proc_t *restrict const p)
{
  static struct direct *ent;            /* dirent handle */
  char *restrict const path = PT->path;
  for (;;)
  {
    ent = readdir(PT->procfs);
    if(unlikely(unlikely(!ent) || unlikely(!ent->d_name)))
      return 0;
    if(likely( likely(*ent->d_name > '0') && likely(*ent->d_name <= '9') ))
      break;
  }
  p->tgid = strtoul(ent->d_name, NULL, 10);
  p->tid = p->tgid;
  memcpy(path, "/proc/", 6);
  strcpy(path+6, ent->d_name);  // trust /proc to not contain evil top-level entries
  return 1;
}

// This finds tasks in /proc/*/task/ in the traditional way.
// Return non-zero on success.
static int simple_nexttid(PROCTAB *restrict const PT, const proc_t *restrict const p, proc_t *restrict const t, char *restrict const path)
{
  static struct direct *ent;            /* dirent handle */
  if(PT->taskdir_user != p->tgid)
  {
    if(PT->taskdir)
    {
      closedir(PT->taskdir);
    }
    // use "path" as some tmp space
    snprintf(path, PROCPATHLEN, "/proc/%d/task", p->tgid);
    PT->taskdir = opendir(path);
    if(!PT->taskdir) return 0;
    PT->taskdir_user = p->tgid;
  }
  for (;;)
  {
    ent = readdir(PT->taskdir);
    if(unlikely(unlikely(!ent) || unlikely(!ent->d_name)))
      return 0;
    if(likely( likely(*ent->d_name > '0') && likely(*ent->d_name <= '9') ))
      break;
  }
  t->tid = strtoul(ent->d_name, NULL, 10);
  t->tgid = p->tgid;
  t->ppid = p->ppid;  // cover for kernel behavior? we want both actually...?
  snprintf(path, PROCPATHLEN, "/proc/%d/task/%s", p->tgid, ent->d_name);
  return 1;
}
//-----------------------------------------------------------------------------
// This "finds" processes in a list that was given to openproc().
// Return non-zero on success. (tgid was handy)
static int listed_nextpid(PROCTAB *restrict const PT, proc_t *restrict const p)
{
  char *restrict const path = PT->path;
  pid_t tgid = *(PT->pids)++;
  if(likely( tgid ))
  {
    snprintf(path, PROCPATHLEN, "/proc/%d", tgid);
    p->tgid = tgid;
    p->tid = tgid;  // they match for leaders
  }
  return tgid;
}
//-----------------------------------------------------------------------------
/* readproc: return a pointer to a proc_t filled with requested info about the
 * next process available matching the restriction set.  If no more such
 * processes are available, return a null pointer (boolean false).  Use the
 * passed buffer instead of allocating space if it is non-NULL.  */

/* This is optimized so that if a PID list is given, only those files are
 * searched for in /proc.  If other lists are given in addition to the PID list,
 * the same logic can follow through as for the no-PID list case.  This is
 * fairly complex, but it does try to not to do any unnecessary work.
 */
static proc_t* readproc(PROCTAB *restrict const PT, proc_t *restrict p)
{
  proc_t* ret;
  proc_t* saved_p;

  PT->did_fake=0;
  saved_p = p;
  if(!p)
    p = (proc_t*)xcalloc(p, sizeof *p); /* passed buf or alloced mem */

  for(;;)
  {
    // fills in the path, plus p->tid and p->tgid
    if (unlikely(! PT->finder(PT,p) ))
      goto out;

    // go read the process data
    ret = PT->reader(PT,p);
    if(ret)
      return ret;
  }

out:
  if(!saved_p)
    free(p);
  return NULL;
}
//-----------------------------------------------------------------------------
// initiate a process table scan
static PROCTAB* openproc(int flags, ...)
{
  va_list ap;
  struct stat sbuf;
  static int did_stat;
  PROCTAB* PT = (PROCTAB*)xmalloc(sizeof(PROCTAB));

  if(!did_stat)
  {
    task_dir_missing = stat("/proc/self/task", &sbuf);
    did_stat = 1;
  }
  PT->taskdir = NULL;
  PT->taskdir_user = -1;
  PT->taskfinder = simple_nexttid;

  PT->reader = simple_readproc;
  if (flags & PROC_PID)
  {
    PT->procfs = NULL;
    PT->finder = listed_nextpid;
  }
  else
  {
    PT->procfs = opendir("/proc");
    if(!PT->procfs) return NULL;
    PT->finder = simple_nextpid;
  }
  PT->flags = flags;

  va_start(ap, flags);          /*  Init args list */
  if (flags & PROC_PID)
    PT->pids = va_arg(ap, pid_t*);
  else if (flags & PROC_UID)
  {
    PT->uids = va_arg(ap, uid_t*);
    PT->nuid = va_arg(ap, int);
  }
  va_end(ap);                           /*  Clean up args list */

  return PT;
}
//-----------------------------------------------------------------------------
// terminate a process table scan
static void closeproc(PROCTAB* PT)
{
  if (PT)
  {
    if (PT->procfs)
      closedir(PT->procfs);
    if (PT->taskdir)
      closedir(PT->taskdir);
    memset(PT,'#',sizeof(PROCTAB));
    free(PT);
  }
}
//-----------------------------------------------------------------------------
// deallocate the space allocated by readproc if the passed rbuf was NULL
static void freeproc(proc_t* p)
{
  if (!p)       /* in case p is NULL */
    return;
  /* ptrs are after strings to avoid copying memory when building them. */
  /* so free is called on the address of the address of strvec[0]. */
  if (p->cmdline)
    free((void*)*p->cmdline);
  if (p->environ)
    free((void*)*p->environ);
  free(p);
}
//-----------------------------------------------------------------------------
/* get_proc_stats - lookup a single tasks information and fill out a proc_t
 *
 * On failure, returns NULL.  On success, returns 'p' and 'p' is a valid
 * and filled out proc_t structure.
 */
static proc_t* getProcStats(pid_t pid, proc_t* p)
{
        static char path[PATH_MAX], sbuf[1024];
        struct stat statbuf;

        sprintf(path, "/proc/%d", pid);
        if (stat(path, &statbuf))
        {
//        printf("path: %s\n", path);
//              perror("stat");
                return NULL;
        }

        p = (proc_t*)xcalloc(p, sizeof *p);

        if (file2str(path, "stat", sbuf, sizeof sbuf) >= 0)
                stat2proc(sbuf, p);     /* parse /proc/#/stat */
        if (file2str(path, "statm", sbuf, sizeof sbuf) >= 0)
                statm2proc(sbuf, p);    /* ignore statm errors here */
        if (file2str(path, "status", sbuf, sizeof sbuf) >= 0)
                status2proc(sbuf, p, 0 /*FIXME*/);

        return p;
}
//-----------------------------------------------------------------------------
EXTERN_C_END

#include <Poco/Logger.h>
#include "Poco/TemporaryFile.h"
#include <iostream>

#include <sstream>
#include <fstream>

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
DRCEReadProcessData* DRCEReadProcessData::pHandler = nullptr;
Poco::Mutex DRCEReadProcessData::mutex;
//-----------------------------------------------------------------------------
DRCEReadProcessData& DRCEReadProcessData::getInstance(void)
{
  Poco::Mutex::ScopedLock lock(mutex);
  if(!pHandler)
    pHandler = new DRCEReadProcessData();
  return *pHandler;
}
//-----------------------------------------------------------------------------
void DRCEReadProcessData::shutdown(void)
{
  Poco::Mutex::ScopedLock lock(mutex);
  if(pHandler)
  {
    delete pHandler;
    pHandler=nullptr;
  }
}
//-----------------------------------------------------------------------------
std::vector<pid_t> DRCEReadProcessData::getAllProcessIds(pid_t pid)
{
  std::vector<pid_t> processes;
  HCE::drce::DRCEReadProcessData::getChildrenList(pid, processes);
  processes.push_back(pid);
  return processes;
}
//-----------------------------------------------------------------------------
void DRCEReadProcessData::getChildrenList(pid_t pid, std::vector<pid_t>& children)
{
  std::vector<ProcessData> processes = DRCEReadProcessData::getProcessDataList();
  for (size_t i=0;i<processes.size();++i)
  {
    if (processes[i].ppid == pid)
    {
      children.push_back(processes[i].pid);
      DRCEReadProcessData::getChildrenList(processes[i].pid, children);
    }
  }
}
//-----------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
std::vector<ProcessData> DRCEReadProcessData::getProcessDataList(void)
{
  Poco::Mutex::ScopedLock lock(mutex);
  std::vector<ProcessData> processes;

  PROCTAB* proc = openproc(PROC_FILLARG | PROC_FILLSTAT | PROC_FILLSTATUS | PROC_FILLMEM);
  if (proc)
  {
    proc_t* procInfo= nullptr;
    while ((procInfo = readproc(proc, nullptr)) != nullptr)
    {
      ProcessData processData;
      processData.pid = procInfo->tid;
      processData.ppid = procInfo->ppid;
      processData.vram = procInfo->vm_size*1024;  // to bytes
      processData.rram = procInfo->vm_rss*1024;   // to bytes
      processData.threads = procInfo->nlwp;
      processData.utime = procInfo->utime;
      processData.stime = procInfo->stime;
      processData.cutime = procInfo->cutime;
      processData.cstime = procInfo->cstime;
      processData.cmd = procInfo->cmd;
      processes.push_back(processData);
      freeproc(procInfo);
    }
  }
  closeproc(proc);

  return processes;
}
//-----------------------------------------------------------------------------
ProcessData DRCEReadProcessData::getProcessData(pid_t pid)
{
  Poco::Mutex::ScopedLock lock(mutex);
  ProcessData processData;

  PROCTAB* proc = openproc(PROC_FILLARG | PROC_FILLSTAT | PROC_FILLSTATUS | PROC_FILLMEM);
  if (proc)
  {
    proc_t* procInfo = nullptr;
    procInfo = getProcStats(pid, procInfo);
    if (procInfo)
    {
      processData.pid = procInfo->tid;
      processData.ppid = procInfo->ppid;
      processData.vram = procInfo->vm_size*1024;  // to bytes
      processData.rram = procInfo->vm_rss*1024;   // to bytes
      processData.threads = procInfo->nlwp;
      processData.utime = procInfo->utime;
      processData.stime = procInfo->stime;
      processData.cutime = procInfo->cutime;
      processData.cstime = procInfo->cstime;
      processData.cmd = procInfo->cmd;
      freeproc(procInfo);
    }
  }
  closeproc(proc);

  return processData;
}
//-----------------------------------------------------------------------------
void DRCEReadProcessData::getProcessAndThreads(unsigned int& processCount, unsigned int& threadsCount)
{
  Poco::Mutex::ScopedLock lock(mutex);
  processCount = 0;
  threadsCount = 0;

  PROCTAB* proc = openproc(PROC_FILLARG | PROC_FILLSTAT | PROC_FILLSTATUS | PROC_FILLMEM);
  if (proc)
  {
    proc_t* procInfo= nullptr;
    while ((procInfo = readproc(proc, nullptr)) != nullptr)
    {
      ++processCount;
      threadsCount += static_cast<unsigned int>(procInfo->nlwp);
      freeproc(procInfo);
    }
  }
  closeproc(proc);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce
} // end namespace HCE