Files moved and added for supporting separate platforms.

linux/IOPriorityPanel.c

@@ -41,3 +41,4 @@ Panel* IOPriorityPanel_new(IOPriority currPrio) {
 IOPriority IOPriorityPanel_getIOPriority(Panel* this) {
    return (IOPriority) ( ((ListItem*) Panel_getSelected(this))->key );
 }
+

linux/IOPriorityPanel.h

@@ -17,4 +17,5 @@ Panel* IOPriorityPanel_new(IOPriority currPrio);
 
 IOPriority IOPriorityPanel_getIOPriority(Panel* this);
 
+
 #endif

linux/LinuxCRT.c

@@ -0,0 +1,36 @@
+/*
+htop - LinuxCRT.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h"
+#include "CRT.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
+void CRT_handleSIGSEGV(int sgn) {
+   (void) sgn;
+   CRT_done();
+   #ifdef __linux
+   fprintf(stderr, "\n\nhtop " VERSION " aborting. Please report bug at http://hisham.hm/htop\n");
+   #ifdef HAVE_EXECINFO_H
+   size_t size = backtrace(backtraceArray, sizeof(backtraceArray) / sizeof(void *));
+   fprintf(stderr, "\n Please include in your report the following backtrace: \n");
+   backtrace_symbols_fd(backtraceArray, size, 2);
+   fprintf(stderr, "\nAdditionally, in order to make the above backtrace useful,");
+   fprintf(stderr, "\nplease also run the following command to generate a disassembly of your binary:");
+   fprintf(stderr, "\n\n   objdump -d `which htop` > ~/htop.objdump");
+   fprintf(stderr, "\n\nand then attach the file ~/htop.objdump to your bug report.");
+   fprintf(stderr, "\n\nThank you for helping to improve htop!\n\n");
+   #endif
+   #else
+   fprintf(stderr, "\nUnfortunately, you seem to be using an unsupported platform!");
+   fprintf(stderr, "\nPlease contact your platform package mantainer!\n\n");
+   #endif
+   abort();
+}

linux/LinuxProcess.c

@@ -0,0 +1,85 @@
+/*
+htop - LinuxProcess.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Process.h"
+
+/*{
+
+typedef struct LinuxProcess_ {
+   Process super;
+   IOPriority ioPriority;
+} LinuxProcess;
+
+}*/
+
+/*
+[1] Note that before kernel 2.6.26 a process that has not asked for
+an io priority formally uses "none" as scheduling class, but the
+io scheduler will treat such processes as if it were in the best
+effort class. The priority within the best effort class will  be
+dynamically  derived  from  the  cpu  nice level of the process:
+io_priority = (cpu_nice + 20) / 5. -- From ionice(1) man page
+*/
+#define LinuxProcess_effectiveIOPriority(p_) (IOPriority_class(p_->ioPriority) == IOPRIO_CLASS_NONE ? IOPriority_tuple(IOPRIO_CLASS_BE, (p_->nice + 20) / 5) : p_->ioPriority)
+
+IOPriority LinuxProcess_updateIOPriority(Process* this) {
+   IOPriority ioprio = syscall(SYS_ioprio_get, IOPRIO_WHO_PROCESS, this->pid);
+   this->ioPriority = ioprio;
+   return ioprio;
+}
+
+bool LinuxProcess_setIOPriority(Process* this, IOPriority ioprio) {
+   syscall(SYS_ioprio_set, IOPRIO_WHO_PROCESS, this->pid, ioprio);
+   return (Process_updateIOPriority(this) == ioprio);
+}
+
+void LinuxProcess_writeField(Process* this, RichString* str, ProcessField field) {
+   switch (field) {
+   case IO_PRIORITY: {
+      int klass = IOPriority_class(this->ioPriority);
+      if (klass == IOPRIO_CLASS_NONE) {
+         // see note [1] above
+         snprintf(buffer, n, "B%1d ", (int) (this->nice + 20) / 5);
+      } else if (klass == IOPRIO_CLASS_BE) {
+         snprintf(buffer, n, "B%1d ", IOPriority_data(this->ioPriority));
+      } else if (klass == IOPRIO_CLASS_RT) {
+         attr = CRT_colors[PROCESS_HIGH_PRIORITY];
+         snprintf(buffer, n, "R%1d ", IOPriority_data(this->ioPriority));
+      } else if (this->ioPriority == IOPriority_Idle) {
+         attr = CRT_colors[PROCESS_LOW_PRIORITY]; 
+         snprintf(buffer, n, "id ");
+      } else {
+         snprintf(buffer, n, "?? ");
+      }
+      break;
+   }
+   default:
+      snprintf(buffer, n, "- ");
+   }
+   RichString_append(str, attr, buffer);
+   }
+}
+
+long LinuxProcess_compare(const void* v1, const void* v2) {
+   LinuxProcess *p1, *p2;
+   ProcessList *pl = ((Process*)v1)->pl;
+   if (pl->direction == 1) {
+      p1 = (LinuxProcess*)v1;
+      p2 = (LinuxProcess*)v2;
+   } else {
+      p2 = (LinuxProcess*)v1;
+      p1 = (LinuxProcess*)v2;
+   }
+   switch (pl->sortKey) {
+   case IO_PRIORITY:
+      return Process_effectiveIOPriority(p1) - Process_effectiveIOPriority(p2);
+   default:
+      return (p1->pid - p2->pid);
+   }
+   test_diff:
+   return (diff > 0) ? 1 : (diff < 0 ? -1 : 0);
+}

linux/LinuxProcessList.c

@@ -0,0 +1,692 @@
+/*
+htop - LinuxProcessList.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "ProcessList.h"
+
+/*{
+
+#ifndef PROCDIR
+#define PROCDIR "/proc"
+#endif
+
+#ifndef PROCSTATFILE
+#define PROCSTATFILE PROCDIR "/stat"
+#endif
+
+#ifndef PROCMEMINFOFILE
+#define PROCMEMINFOFILE PROCDIR "/meminfo"
+#endif
+
+}*/
+   
+ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList) {
+   ProcessList* this = calloc(1, sizeof(ProcessList));
+   ProcessList_init(this, usersTable, pidWhiteList);
+
+   // Update CPU count:
+   FILE* file = fopen(PROCSTATFILE, "r");
+   if (file == NULL) {
+      CRT_fatalError("Cannot open " PROCSTATFILE);
+   }
+   char buffer[256];
+   int cpus = -1;
+   do {
+      cpus++;
+      fgets(buffer, 255, file);
+   } while (String_startsWith(buffer, "cpu"));
+   fclose(file);
+
+   this->cpuCount = MAX(cpus - 1, 1);
+   this->cpus = realloc(this->cpus, cpus * sizeof(CPUData));
+
+   for (int i = 0; i < cpus; i++) {
+      this->cpus[i].totalTime = 1;
+      this->cpus[i].totalPeriod = 1;
+   }
+
+   #ifdef HAVE_OPENVZ
+   this->flags |= PROCESS_FLAG_OPENVZ;
+   #endif
+
+   return this;
+}
+
+static ssize_t xread(int fd, void *buf, size_t count) {
+  // Read some bytes. Retry on EINTR and when we don't get as many bytes as we requested.
+  size_t alreadyRead = 0;
+  for(;;) {
+     ssize_t res = read(fd, buf, count);
+     if (res == -1 && errno == EINTR) continue;
+     if (res > 0) {
+       buf = ((char*)buf)+res;
+       count -= res;
+       alreadyRead += res;
+     }
+     if (res == -1) return -1;
+     if (count == 0 || res == 0) return alreadyRead;
+  }
+}
+
+static bool LinuxProcessList_readStatFile(Process *process, const char* dirname, const char* name, char* command) {
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/stat", dirname, name);
+   int fd = open(filename, O_RDONLY);
+   if (fd == -1)
+      return false;
+
+   static char buf[MAX_READ+1];
+
+   int size = xread(fd, buf, MAX_READ);
+   close(fd);
+   if (size <= 0) return false;
+   buf[size] = '\0';
+
+   assert(process->pid == atoi(buf));
+   char *location = strchr(buf, ' ');
+   if (!location) return false;
+
+   location += 2;
+   char *end = strrchr(location, ')');
+   if (!end) return false;
+   
+   int commsize = end - location;
+   memcpy(command, location, commsize);
+   command[commsize] = '\0';
+   location = end + 2;
+
+   process->state = location[0];
+   location += 2;
+   process->ppid = strtol(location, &location, 10);
+   location += 1;
+   process->pgrp = strtoul(location, &location, 10);
+   location += 1;
+   process->session = strtoul(location, &location, 10);
+   location += 1;
+   process->tty_nr = strtoul(location, &location, 10);
+   location += 1;
+   process->tpgid = strtol(location, &location, 10);
+   location += 1;
+   process->flags = strtoul(location, &location, 10);
+   location += 1;
+   process->minflt = strtoull(location, &location, 10);
+   location += 1;
+   process->cminflt = strtoull(location, &location, 10);
+   location += 1;
+   process->majflt = strtoull(location, &location, 10);
+   location += 1;
+   process->cmajflt = strtoull(location, &location, 10);
+   location += 1;
+   process->utime = strtoull(location, &location, 10);
+   location += 1;
+   process->stime = strtoull(location, &location, 10);
+   location += 1;
+   process->cutime = strtoull(location, &location, 10);
+   location += 1;
+   process->cstime = strtoull(location, &location, 10);
+   location += 1;
+   process->priority = strtol(location, &location, 10);
+   location += 1;
+   process->nice = strtol(location, &location, 10);
+   location += 1;
+   process->nlwp = strtol(location, &location, 10);
+   location += 1;
+   for (int i=0; i<17; i++) location = strchr(location, ' ')+1;
+   process->exit_signal = strtol(location, &location, 10);
+   location += 1;
+   assert(location != NULL);
+   process->processor = strtol(location, &location, 10);
+   assert(location == NULL);
+
+   return true;
+}
+
+
+static bool LinuxProcessList_statProcessDir(Process* process, const char* dirname, char* name, time_t curTime) {
+   char filename[MAX_NAME+1];
+   filename[MAX_NAME] = '\0';
+
+   snprintf(filename, MAX_NAME, "%s/%s", dirname, name);
+   struct stat sstat;
+   int statok = stat(filename, &sstat);
+   if (statok == -1)
+      return false;
+   process->st_uid = sstat.st_uid;
+  
+   struct tm date;
+   time_t ctime = sstat.st_ctime;
+   process->starttime_ctime = ctime;
+   (void) localtime_r((time_t*) &ctime, &date);
+   strftime(process->starttime_show, 7, ((ctime > curTime - 86400) ? "%R " : "%b%d "), &date);
+   
+   return true;
+}
+
+#ifdef HAVE_TASKSTATS
+
+static void LinuxProcessList_readIoFile(Process* process, const char* dirname, char* name, unsigned long long now) {
+   char filename[MAX_NAME+1];
+   filename[MAX_NAME] = '\0';
+
+   snprintf(filename, MAX_NAME, "%s/%s/io", dirname, name);
+   int fd = open(filename, O_RDONLY);
+   if (fd == -1)
+      return;
+   
+   char buffer[1024];
+   ssize_t buflen = xread(fd, buffer, 1023);
+   close(fd);
+   if (buflen < 1) return;
+   buffer[buflen] = '\0';
+   unsigned long long last_read = process->io_read_bytes;
+   unsigned long long last_write = process->io_write_bytes;
+   char *buf = buffer;
+   char *line = NULL;
+   while ((line = strsep(&buf, "\n")) != NULL) {
+      switch (line[0]) {
+      case 'r':
+         if (line[1] == 'c' && strncmp(line+2, "har: ", 5) == 0)
+            process->io_rchar = strtoull(line+7, NULL, 10);
+         else if (strncmp(line+1, "ead_bytes: ", 11) == 0) {
+            process->io_read_bytes = strtoull(line+12, NULL, 10);
+            process->io_rate_read_bps = 
+               ((double)(process->io_read_bytes - last_read))/(((double)(now - process->io_rate_read_time))/1000);
+            process->io_rate_read_time = now;
+         }
+         break;
+      case 'w':
+         if (line[1] == 'c' && strncmp(line+2, "har: ", 5) == 0)
+            process->io_wchar = strtoull(line+7, NULL, 10);
+         else if (strncmp(line+1, "rite_bytes: ", 12) == 0) {
+            process->io_write_bytes = strtoull(line+13, NULL, 10);
+            process->io_rate_write_bps = 
+               ((double)(process->io_write_bytes - last_write))/(((double)(now - process->io_rate_write_time))/1000);
+            process->io_rate_write_time = now;
+         }
+         break;
+      case 's':
+         if (line[5] == 'r' && strncmp(line+1, "yscr: ", 6) == 0)
+            process->io_syscr = strtoull(line+7, NULL, 10);
+         else if (strncmp(line+1, "yscw: ", 6) == 0)
+            sscanf(line, "syscw: %32llu", &process->io_syscw);
+            process->io_syscw = strtoull(line+7, NULL, 10);
+         break;
+      case 'c':
+         if (strncmp(line+1, "ancelled_write_bytes: ", 22) == 0)
+           process->io_cancelled_write_bytes = strtoull(line+23, NULL, 10);
+      }
+   }
+}
+
+#endif
+
+
+
+static bool LinuxProcessList_readStatmFile(Process* process, const char* dirname, const char* name) {
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/statm", dirname, name);
+   int fd = open(filename, O_RDONLY);
+   if (fd == -1)
+      return false;
+   char buf[256];
+   ssize_t rres = xread(fd, buf, 255);
+   close(fd);
+   if (rres < 1) return false;
+
+   char *p = buf;
+   errno = 0;
+   process->m_size = strtol(p, &p, 10); if (*p == ' ') p++;
+   process->m_resident = strtol(p, &p, 10); if (*p == ' ') p++;
+   process->m_share = strtol(p, &p, 10); if (*p == ' ') p++;
+   process->m_trs = strtol(p, &p, 10); if (*p == ' ') p++;
+   process->m_lrs = strtol(p, &p, 10); if (*p == ' ') p++;
+   process->m_drs = strtol(p, &p, 10); if (*p == ' ') p++;
+   process->m_dt = strtol(p, &p, 10);
+   return (errno == 0);
+}
+
+#ifdef HAVE_OPENVZ
+
+static void LinuxProcessList_readOpenVZData(ProcessList* this, Process* process, const char* dirname, const char* name) {
+   if ( (!(this->flags & PROCESS_FLAG_OPENVZ)) || (access("/proc/vz", R_OK) != 0)) {
+      process->vpid = process->pid;
+      process->ctid = 0;
+      this->flags |= ~PROCESS_FLAG_OPENVZ;
+      return;
+   }
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/stat", dirname, name);
+   FILE* file = fopen(filename, "r");
+   if (!file) 
+      return;
+   fscanf(file, 
+      "%*32u %*32s %*1c %*32u %*32u %*32u %*32u %*32u %*32u %*32u "
+      "%*32u %*32u %*32u %*32u %*32u %*32u %*32u %*32u "
+      "%*32u %*32u %*32u %*32u %*32u %*32u %*32u %*32u "
+      "%*32u %*32u %*32u %*32u %*32u %*32u %*32u %*32u "
+      "%*32u %*32u %*32u %*32u %*32u %*32u %*32u %*32u "
+      "%*32u %*32u %*32u %*32u %*32u %*32u %*32u "
+      "%*32u %*32u %32u %32u",
+      &process->vpid, &process->ctid);
+   fclose(file);
+}
+
+#endif
+
+#ifdef HAVE_CGROUP
+
+static void LinuxProcessList_readCGroupFile(Process* process, const char* dirname, const char* name) {
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/cgroup", dirname, name);
+   FILE* file = fopen(filename, "r");
+   if (!file) {
+      process->cgroup = strdup("");
+      return;
+   }
+   char buffer[256];
+   char *ok = fgets(buffer, 255, file);
+   if (ok) {
+      char* trimmed = String_trim(buffer);
+      int nFields;
+      char** fields = String_split(trimmed, ':', &nFields);
+      free(trimmed);
+      if (nFields >= 3) {
+         process->cgroup = strndup(fields[2] + 1, 10);
+      } else {
+         process->cgroup = strdup("");
+      }
+      String_freeArray(fields);
+   }
+   fclose(file);
+}
+
+#endif
+
+#ifdef HAVE_VSERVER
+
+static void LinuxProcessList_readVServerData(Process* process, const char* dirname, const char* name) {
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/status", dirname, name);
+   FILE* file = fopen(filename, "r");
+   if (!file)
+      return;
+   char buffer[256];
+   process->vxid = 0;
+   while (fgets(buffer, 255, file)) {
+      if (String_startsWith(buffer, "VxID:")) {
+         int vxid;
+         int ok = sscanf(buffer, "VxID:\t%32d", &vxid);
+         if (ok >= 1) {
+            process->vxid = vxid;
+         }
+      }
+      #if defined HAVE_ANCIENT_VSERVER
+      else if (String_startsWith(buffer, "s_context:")) {
+         int vxid;
+         int ok = sscanf(buffer, "s_context:\t%32d", &vxid);
+         if (ok >= 1) {
+            process->vxid = vxid;
+         }
+      }
+      #endif
+   }
+   fclose(file);
+}
+
+#endif
+
+#ifdef HAVE_OOM
+
+static void LinuxProcessList_readOomData(Process* process, const char* dirname, const char* name) {
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/oom_score", dirname, name);
+   FILE* file = fopen(filename, "r");
+   if (!file)
+      return;
+   char buffer[256];
+   if (fgets(buffer, 255, file)) {
+      unsigned int oom;
+      int ok = sscanf(buffer, "%32u", &oom);
+      if (ok >= 1) {
+         process->oom = oom;
+      }
+   }
+   fclose(file);
+}
+
+#endif
+
+static bool LinuxProcessList_readCmdlineFile(Process* process, const char* dirname, const char* name) {
+   if (Process_isKernelThread(process))
+      return true;
+
+   char filename[MAX_NAME+1];
+   snprintf(filename, MAX_NAME, "%s/%s/cmdline", dirname, name);
+   int fd = open(filename, O_RDONLY);
+   if (fd == -1)
+      return false;
+         
+   char command[4096+1]; // max cmdline length on Linux
+   int amtRead = xread(fd, command, sizeof(command) - 1);
+   close(fd);
+   int tokenEnd = 0; 
+   if (amtRead > 0) {
+      for (int i = 0; i < amtRead; i++)
+         if (command[i] == '\0' || command[i] == '\n') {
+            if (tokenEnd == 0) {
+               tokenEnd = i;
+            }
+            command[i] = ' ';
+         }
+   }
+   if (tokenEnd == 0) {
+      tokenEnd = amtRead;
+   }
+   command[amtRead] = '\0';
+   free(process->comm);
+   process->comm = strdup(command);
+   process->basenameOffset = tokenEnd;
+
+   return true;
+}
+
+static bool LinuxProcessList_processEntries(ProcessList* this, const char* dirname, Process* parent, double period, struct timeval tv) {
+   DIR* dir;
+   struct dirent* entry;
+
+   time_t curTime = tv.tv_sec;
+   #ifdef HAVE_TASKSTATS
+   unsigned long long now = tv.tv_sec*1000LL+tv.tv_usec/1000LL;
+   #endif
+
+   dir = opendir(dirname);
+   if (!dir) return false;
+   int cpus = this->cpuCount;
+   bool hideKernelThreads = this->hideKernelThreads;
+   bool hideUserlandThreads = this->hideUserlandThreads;
+   while ((entry = readdir(dir)) != NULL) {
+      char* name = entry->d_name;
+
+      // The RedHat kernel hides threads with a dot.
+      // I believe this is non-standard.
+      if ((!this->hideThreads) && name[0] == '.') {
+         name++;
+      }
+
+      // Just skip all non-number directories.
+      if (name[0] < '0' || name[0] > '9') {
+         continue;
+      }
+
+      // filename is a number: process directory
+      int pid = atoi(name);
+     
+      if (parent && pid == parent->pid)
+         continue;
+
+      if (pid <= 0) 
+         continue;
+
+      Process* process = NULL;
+      Process* existingProcess = (Process*) Hashtable_get(this->processTable, pid);
+
+      if (existingProcess) {
+         assert(Vector_indexOf(this->processes, existingProcess, Process_pidCompare) != -1);
+         process = existingProcess;
+         assert(process->pid == pid);
+      } else {
+         process = Process_new(this);
+         assert(process->comm == NULL);
+         process->pid = pid;
+         process->tgid = parent ? parent->pid : pid;
+      }
+
+      char subdirname[MAX_NAME+1];
+      snprintf(subdirname, MAX_NAME, "%s/%s/task", dirname, name);
+      LinuxProcessList_processEntries(this, subdirname, process, period, tv);
+
+      #ifdef HAVE_TASKSTATS
+      if (this->flags & PROCESS_FLAG_IO)
+         LinuxProcessList_readIoFile(process, dirname, name, now);
+      #endif
+
+      if (! LinuxProcessList_readStatmFile(process, dirname, name))
+         goto errorReadingProcess;
+
+      process->show = ! ((hideKernelThreads && Process_isKernelThread(process)) || (hideUserlandThreads && Process_isUserlandThread(process)));
+
+      char command[MAX_NAME+1];
+      unsigned long long int lasttimes = (process->utime + process->stime);
+      if (! LinuxProcessList_readStatFile(process, dirname, name, command))
+         goto errorReadingProcess;
+      if (this->flags & PROCESS_FLAG_IOPRIO)
+         Process_updateIOPriority(process);
+      float percent_cpu = (process->utime + process->stime - lasttimes) / period * 100.0;
+      process->percent_cpu = MAX(MIN(percent_cpu, cpus*100.0), 0.0);
+      if (isnan(process->percent_cpu)) process->percent_cpu = 0.0;
+      process->percent_mem = (process->m_resident * PAGE_SIZE_KB) / (double)(this->totalMem) * 100.0;
+
+      if(!existingProcess) {
+
+         if (! LinuxProcessList_statProcessDir(process, dirname, name, curTime))
+            goto errorReadingProcess;
+
+         process->user = UsersTable_getRef(this->usersTable, process->st_uid);
+
+         #ifdef HAVE_OPENVZ
+         LinuxProcessList_readOpenVZData(this, process, dirname, name);
+         #endif
+         
+         #ifdef HAVE_VSERVER
+         if (this->flags & PROCESS_FLAG_VSERVER)
+            LinuxProcessList_readVServerData(process, dirname, name);
+         #endif
+
+         if (! LinuxProcessList_readCmdlineFile(process, dirname, name))
+            goto errorReadingProcess;
+
+         ProcessList_add(this, process);
+      } else {
+         if (this->updateProcessNames) {
+            if (! LinuxProcessList_readCmdlineFile(process, dirname, name))
+               goto errorReadingProcess;
+         }
+      }
+
+      #ifdef HAVE_CGROUP
+      if (this->flags & PROCESS_FLAG_CGROUP)
+         LinuxProcessList_readCGroupFile(process, dirname, name);
+      #endif
+      
+      #ifdef HAVE_OOM
+      LinuxProcessList_readOomData(process, dirname, name);
+      #endif
+
+      if (process->state == 'Z') {
+         free(process->comm);
+         process->basenameOffset = -1;
+         process->comm = strdup(command);
+      } else if (Process_isThread(process)) {
+         if (this->showThreadNames || Process_isKernelThread(process) || process->state == 'Z') {
+            free(process->comm);
+            process->basenameOffset = -1;
+            process->comm = strdup(command);
+         } else if (this->showingThreadNames) {
+            if (! LinuxProcessList_readCmdlineFile(process, dirname, name))
+               goto errorReadingProcess;
+         }
+         if (Process_isKernelThread(process)) {
+            this->kernelThreads++;
+         } else {
+            this->userlandThreads++;
+         }
+      }
+
+      this->totalTasks++;
+      if (process->state == 'R')
+         this->runningTasks++;
+      process->updated = true;
+
+      continue;
+
+      // Exception handler.
+      errorReadingProcess: {
+         if (process->comm) {
+            free(process->comm);
+            process->basenameOffset = -1;
+            process->comm = NULL;
+         }
+         if (existingProcess)
+            ProcessList_remove(this, process);
+         else
+            Process_delete((Object*)process);
+      }
+   }
+   closedir(dir);
+   return true;
+}
+
+void ProcessList_scan(ProcessList* this) {
+   unsigned long long int usertime, nicetime, systemtime, idletime;
+   unsigned long long int swapFree = 0;
+
+   FILE* file = fopen(PROCMEMINFOFILE, "r");
+   if (file == NULL) {
+      CRT_fatalError("Cannot open " PROCMEMINFOFILE);
+   }
+   int cpus = this->cpuCount;
+   assert(cpus > 0);
+   {
+      char buffer[128];
+      while (fgets(buffer, 128, file)) {
+   
+         switch (buffer[0]) {
+         case 'M':
+            if (String_startsWith(buffer, "MemTotal:"))
+               sscanf(buffer, "MemTotal: %32llu kB", &this->totalMem);
+            else if (String_startsWith(buffer, "MemFree:"))
+               sscanf(buffer, "MemFree: %32llu kB", &this->freeMem);
+            else if (String_startsWith(buffer, "MemShared:"))
+               sscanf(buffer, "MemShared: %32llu kB", &this->sharedMem);
+            break;
+         case 'B':
+            if (String_startsWith(buffer, "Buffers:"))
+               sscanf(buffer, "Buffers: %32llu kB", &this->buffersMem);
+            break;
+         case 'C':
+            if (String_startsWith(buffer, "Cached:"))
+               sscanf(buffer, "Cached: %32llu kB", &this->cachedMem);
+            break;
+         case 'S':
+            if (String_startsWith(buffer, "SwapTotal:"))
+               sscanf(buffer, "SwapTotal: %32llu kB", &this->totalSwap);
+            if (String_startsWith(buffer, "SwapFree:"))
+               sscanf(buffer, "SwapFree: %32llu kB", &swapFree);
+            break;
+         }
+      }
+   }
+
+   this->usedMem = this->totalMem - this->freeMem;
+   this->usedSwap = this->totalSwap - swapFree;
+   fclose(file);
+
+   file = fopen(PROCSTATFILE, "r");
+   if (file == NULL) {
+      CRT_fatalError("Cannot open " PROCSTATFILE);
+   }
+   for (int i = 0; i <= cpus; i++) {
+      char buffer[256];
+      int cpuid;
+      unsigned long long int ioWait, irq, softIrq, steal, guest, guestnice;
+      unsigned long long int systemalltime, idlealltime, totaltime, virtalltime;
+      ioWait = irq = softIrq = steal = guest = guestnice = 0;
+      // Dependending on your kernel version,
+      // 5, 7, 8 or 9 of these fields will be set.
+      // The rest will remain at zero.
+      fgets(buffer, 255, file);
+      if (i == 0)
+         sscanf(buffer, "cpu  %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu", &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
+      else {
+         sscanf(buffer, "cpu%4d %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu", &cpuid, &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
+         assert(cpuid == i - 1);
+      }
+      // Guest time is already accounted in usertime
+      usertime = usertime - guest;
+      nicetime = nicetime - guestnice;
+      // Fields existing on kernels >= 2.6
+      // (and RHEL's patched kernel 2.4...)
+      idlealltime = idletime + ioWait;
+      systemalltime = systemtime + irq + softIrq;
+      virtalltime = guest + guestnice;
+      totaltime = usertime + nicetime + systemalltime + idlealltime + steal + virtalltime;
+      CPUData* cpuData = &(this->cpus[i]);
+      assert (usertime >= cpuData->userTime);
+      assert (nicetime >= cpuData->niceTime);
+      assert (systemtime >= cpuData->systemTime);
+      assert (idletime >= cpuData->idleTime);
+      assert (totaltime >= cpuData->totalTime);
+      assert (systemalltime >= cpuData->systemAllTime);
+      assert (idlealltime >= cpuData->idleAllTime);
+      assert (ioWait >= cpuData->ioWaitTime);
+      assert (irq >= cpuData->irqTime);
+      assert (softIrq >= cpuData->softIrqTime);
+      assert (steal >= cpuData->stealTime);
+      assert (virtalltime >= cpuData->guestTime);
+      cpuData->userPeriod = usertime - cpuData->userTime;
+      cpuData->nicePeriod = nicetime - cpuData->niceTime;
+      cpuData->systemPeriod = systemtime - cpuData->systemTime;
+      cpuData->systemAllPeriod = systemalltime - cpuData->systemAllTime;
+      cpuData->idleAllPeriod = idlealltime - cpuData->idleAllTime;
+      cpuData->idlePeriod = idletime - cpuData->idleTime;
+      cpuData->ioWaitPeriod = ioWait - cpuData->ioWaitTime;
+      cpuData->irqPeriod = irq - cpuData->irqTime;
+      cpuData->softIrqPeriod = softIrq - cpuData->softIrqTime;
+      cpuData->stealPeriod = steal - cpuData->stealTime;
+      cpuData->guestPeriod = virtalltime - cpuData->guestTime;
+      cpuData->totalPeriod = totaltime - cpuData->totalTime;
+      cpuData->userTime = usertime;
+      cpuData->niceTime = nicetime;
+      cpuData->systemTime = systemtime;
+      cpuData->systemAllTime = systemalltime;
+      cpuData->idleAllTime = idlealltime;
+      cpuData->idleTime = idletime;
+      cpuData->ioWaitTime = ioWait;
+      cpuData->irqTime = irq;
+      cpuData->softIrqTime = softIrq;
+      cpuData->stealTime = steal;
+      cpuData->guestTime = virtalltime;
+      cpuData->totalTime = totaltime;
+   }
+   double period = (double)this->cpus[0].totalPeriod / cpus; fclose(file);
+
+   // mark all process as "dirty"
+   for (int i = 0; i < Vector_size(this->processes); i++) {
+      Process* p = (Process*) Vector_get(this->processes, i);
+      p->updated = false;
+   }
+   
+   this->totalTasks = 0;
+   this->userlandThreads = 0;
+   this->kernelThreads = 0;
+   this->runningTasks = 0;
+
+   struct timeval tv;
+   gettimeofday(&tv, NULL);
+   LinuxProcessList_processEntries(this, PROCDIR, NULL, period, tv);
+   
+   this->showingThreadNames = this->showThreadNames;
+   
+   for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
+      Process* p = (Process*) Vector_get(this->processes, i);
+      if (p->updated == false)
+         ProcessList_remove(this, p);
+      else
+         p->updated = false;
+   }
+
+}
+

linux/Platform.c

@@ -0,0 +1,31 @@
+/*
+htop - linux/Platform.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "IOPriority.h"
+#include "IOPriorityPanel.h"
+
+static Htop_Reaction Platform_actionSetIOPriority(Panel* panel, ProcessList* pl, Header* header) {
+   (void) panel, (void) pl;
+   Process* p = (Process*) Panel_getSelected(panel);
+   if (!p) return HTOP_OK;
+   IOPriority ioprio = p->ioPriority;
+   Panel* ioprioPanel = IOPriorityPanel_new(ioprio);
+   const char* fuFunctions[] = {"Set    ", "Cancel ", NULL};
+   void* set = pickFromVector(panel, ioprioPanel, 21, fuFunctions, header);
+   if (set) {
+      IOPriority ioprio = IOPriorityPanel_getIOPriority(ioprioPanel);
+      bool ok = Action_foreachProcess(panel, (Action_ForeachProcessFn) Process_setIOPriority, (size_t) ioprio, NULL);
+      if (!ok)
+         beep();
+   }
+   Panel_delete((Object*)ioprioPanel);
+   return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
+}
+
+void Platform_setBindings(Htop_Action* keys) {
+   keys['i'] = Platform_actionSetIOPriority;
+}

unsupported/Platform.c

@@ -0,0 +1,17 @@
+/*
+htop - unsupported/Platform.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Platform.h"
+
+/*{
+#include "Action.h"
+}*/
+
+void Platform_setBindings(Htop_Action* keys) {
+   (void) keys;
+}
+

unsupported/Platform.h

@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Platform
+#define HEADER_Platform
+/*
+htop - unsupported/Platform.h
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Action.h"
+
+void Platform_setBindings(Htop_Action* keys);
+
+
+#endif

unsupported/UnsupportedCRT.c

@@ -0,0 +1,21 @@
+/*
+htop - UnsupportedCRT.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h"
+#include "CRT.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+void CRT_handleSIGSEGV(int sgn) {
+   (void) sgn;
+   CRT_done();
+   fprintf(stderr, "\n\nhtop " VERSION " aborting.\n");
+   fprintf(stderr, "\nUnfortunately, you seem to be using an unsupported platform!");
+   fprintf(stderr, "\nPlease contact your platform package mantainer!\n\n");
+   abort();
+}
+

unsupported/UnsupportedCRT.h

@@ -0,0 +1,15 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_UnsupportedCRT
+#define HEADER_UnsupportedCRT
+/*
+htop - UnsupportedCRT.h
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+void CRT_handleSIGSEGV(int sgn);
+
+
+#endif

unsupported/UnsupportedProcessList.c

@@ -0,0 +1,32 @@
+/*
+htop - UnsupportedProcessList.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "ProcessList.h"
+
+#include <stdlib.h>
+
+/*{
+
+}*/
+
+ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList) {
+   ProcessList* this = calloc(1, sizeof(ProcessList));
+   ProcessList_init(this, usersTable, pidWhiteList);
+
+   // Update CPU count:
+   this->cpuCount = 1;
+   this->cpus = calloc(1, sizeof(CPUData));
+   this->cpus[0].totalTime = 1;
+   this->cpus[0].totalPeriod = 1;
+   
+   return this;
+}
+
+void ProcessList_scan(ProcessList* this) {
+   (void) this;
+   // stub!
+}

unsupported/UnsupportedProcessList.h

@@ -0,0 +1,18 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_UnsupportedProcessList
+#define HEADER_UnsupportedProcessList
+/*
+htop - UnsupportedProcessList.h
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+
+
+ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList);
+
+void ProcessList_scan(ProcessList* this);
+
+#endif