From 26422af6088129b99864b75ed4ce5395aa578f2b Mon Sep 17 00:00:00 2001 From: Hisham Muhammad Date: Mon, 24 Nov 2014 18:55:49 -0200 Subject: [PATCH] Files moved and added for supporting separate platforms. --- IOPriority.c => linux/IOPriority.c | 0 IOPriority.h => linux/IOPriority.h | 0 IOPriorityPanel.c => linux/IOPriorityPanel.c | 1 + IOPriorityPanel.h => linux/IOPriorityPanel.h | 1 + linux/LinuxCRT.c | 36 + linux/LinuxProcess.c | 85 +++ linux/LinuxProcessList.c | 692 +++++++++++++++++++ linux/Platform.c | 31 + unsupported/Platform.c | 17 + unsupported/Platform.h | 17 + unsupported/UnsupportedCRT.c | 21 + unsupported/UnsupportedCRT.h | 15 + unsupported/UnsupportedProcessList.c | 32 + unsupported/UnsupportedProcessList.h | 18 + 14 files changed, 966 insertions(+) rename IOPriority.c => linux/IOPriority.c (100%) rename IOPriority.h => linux/IOPriority.h (100%) rename IOPriorityPanel.c => linux/IOPriorityPanel.c (99%) rename IOPriorityPanel.h => linux/IOPriorityPanel.h (99%) create mode 100644 linux/LinuxCRT.c create mode 100644 linux/LinuxProcess.c create mode 100644 linux/LinuxProcessList.c create mode 100644 linux/Platform.c create mode 100644 unsupported/Platform.c create mode 100644 unsupported/Platform.h create mode 100644 unsupported/UnsupportedCRT.c create mode 100644 unsupported/UnsupportedCRT.h create mode 100644 unsupported/UnsupportedProcessList.c create mode 100644 unsupported/UnsupportedProcessList.h diff --git a/IOPriority.c b/linux/IOPriority.c similarity index 100% rename from IOPriority.c rename to linux/IOPriority.c diff --git a/IOPriority.h b/linux/IOPriority.h similarity index 100% rename from IOPriority.h rename to linux/IOPriority.h diff --git a/IOPriorityPanel.c b/linux/IOPriorityPanel.c similarity index 99% rename from IOPriorityPanel.c rename to linux/IOPriorityPanel.c index 04d98b18..e42259fb 100644 --- a/IOPriorityPanel.c +++ b/linux/IOPriorityPanel.c @@ -41,3 +41,4 @@ Panel* IOPriorityPanel_new(IOPriority currPrio) { IOPriority IOPriorityPanel_getIOPriority(Panel* this) { return (IOPriority) ( ((ListItem*) Panel_getSelected(this))->key ); } + diff --git a/IOPriorityPanel.h b/linux/IOPriorityPanel.h similarity index 99% rename from IOPriorityPanel.h rename to linux/IOPriorityPanel.h index f87af4e4..9f77a4d9 100644 --- a/IOPriorityPanel.h +++ b/linux/IOPriorityPanel.h @@ -17,4 +17,5 @@ Panel* IOPriorityPanel_new(IOPriority currPrio); IOPriority IOPriorityPanel_getIOPriority(Panel* this); + #endif diff --git a/linux/LinuxCRT.c b/linux/LinuxCRT.c new file mode 100644 index 00000000..e0a12821 --- /dev/null +++ b/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 +#include +#ifdef HAVE_EXECINFO_H +#include +#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(); +} diff --git a/linux/LinuxProcess.c b/linux/LinuxProcess.c new file mode 100644 index 00000000..9b509a98 --- /dev/null +++ b/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); +} diff --git a/linux/LinuxProcessList.c b/linux/LinuxProcessList.c new file mode 100644 index 00000000..ff85a2c7 --- /dev/null +++ b/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; + } + +} + diff --git a/linux/Platform.c b/linux/Platform.c new file mode 100644 index 00000000..496343df --- /dev/null +++ b/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; +} diff --git a/unsupported/Platform.c b/unsupported/Platform.c new file mode 100644 index 00000000..b65fec40 --- /dev/null +++ b/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; +} + diff --git a/unsupported/Platform.h b/unsupported/Platform.h new file mode 100644 index 00000000..65a31993 --- /dev/null +++ b/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 diff --git a/unsupported/UnsupportedCRT.c b/unsupported/UnsupportedCRT.c new file mode 100644 index 00000000..c4e65eeb --- /dev/null +++ b/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 +#include + +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(); +} + diff --git a/unsupported/UnsupportedCRT.h b/unsupported/UnsupportedCRT.h new file mode 100644 index 00000000..3c808ca6 --- /dev/null +++ b/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 diff --git a/unsupported/UnsupportedProcessList.c b/unsupported/UnsupportedProcessList.c new file mode 100644 index 00000000..6fdca53f --- /dev/null +++ b/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 + +/*{ + +}*/ + +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! +} diff --git a/unsupported/UnsupportedProcessList.h b/unsupported/UnsupportedProcessList.h new file mode 100644 index 00000000..d95c8e5c --- /dev/null +++ b/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