htop/ProcessList.c

891 lines
28 KiB
C
Raw Normal View History

2006-03-04 18:16:49 +00:00
/*
htop - ProcessList.c
(C) 2004,2005 Hisham H. Muhammad
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
#ifndef CONFIG_H
#define CONFIG_H
#include "config.h"
#endif
2006-03-04 18:16:49 +00:00
#include "ProcessList.h"
#include "Process.h"
#include "Vector.h"
2006-03-04 18:16:49 +00:00
#include "UsersTable.h"
#include "Hashtable.h"
#include "String.h"
2006-03-04 18:16:49 +00:00
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <stdbool.h>
#include <sys/utsname.h>
#include <stdarg.h>
2010-02-25 01:43:18 +00:00
#include <math.h>
2006-03-04 18:16:49 +00:00
#include "debug.h"
#include <assert.h>
/*{
2006-03-04 18:16:49 +00:00
#ifndef PROCDIR
#define PROCDIR "/proc"
#endif
#ifndef PROCSTATFILE
#define PROCSTATFILE PROCDIR "/stat"
2006-03-04 18:16:49 +00:00
#endif
#ifndef PROCMEMINFOFILE
#define PROCMEMINFOFILE PROCDIR "/meminfo"
2006-03-04 18:16:49 +00:00
#endif
#ifndef MAX_NAME
#define MAX_NAME 128
#endif
#ifndef MAX_READ
#define MAX_READ 2048
2006-03-04 18:16:49 +00:00
#endif
#ifndef ProcessList_cpuId
#define ProcessList_cpuId(pl, cpu) ((pl)->countCPUsFromZero ? (cpu) : (cpu)+1)
#endif
2006-03-04 18:16:49 +00:00
typedef enum TreeStr_ {
TREE_STR_HORZ,
TREE_STR_VERT,
TREE_STR_RTEE,
TREE_STR_BEND,
TREE_STR_TEND,
TREE_STR_OPEN,
TREE_STR_SHUT,
TREE_STR_COUNT
} TreeStr;
typedef enum TreeType_ {
TREE_TYPE_AUTO,
TREE_TYPE_ASCII,
TREE_TYPE_UTF8,
} TreeType;
2006-03-04 18:16:49 +00:00
typedef struct CPUData_ {
unsigned long long int totalTime;
unsigned long long int userTime;
unsigned long long int systemTime;
unsigned long long int systemAllTime;
unsigned long long int idleAllTime;
unsigned long long int idleTime;
unsigned long long int niceTime;
unsigned long long int ioWaitTime;
unsigned long long int irqTime;
unsigned long long int softIrqTime;
unsigned long long int stealTime;
unsigned long long int guestTime;
unsigned long long int totalPeriod;
unsigned long long int userPeriod;
unsigned long long int systemPeriod;
unsigned long long int systemAllPeriod;
unsigned long long int idleAllPeriod;
unsigned long long int idlePeriod;
unsigned long long int nicePeriod;
unsigned long long int ioWaitPeriod;
unsigned long long int irqPeriod;
unsigned long long int softIrqPeriod;
unsigned long long int stealPeriod;
unsigned long long int guestPeriod;
} CPUData;
2006-03-04 18:16:49 +00:00
typedef struct ProcessList_ {
Vector* processes;
Vector* processes2;
2006-03-04 18:16:49 +00:00
Hashtable* processTable;
UsersTable* usersTable;
int cpuCount;
2006-03-04 18:16:49 +00:00
int totalTasks;
int userlandThreads;
int kernelThreads;
2006-03-04 18:16:49 +00:00
int runningTasks;
#ifdef HAVE_HWLOC
hwloc_topology_t topology;
bool topologyOk;
#endif
CPUData* cpus;
2006-06-05 21:28:54 +00:00
unsigned long long int totalMem;
unsigned long long int usedMem;
unsigned long long int freeMem;
unsigned long long int sharedMem;
unsigned long long int buffersMem;
unsigned long long int cachedMem;
unsigned long long int totalSwap;
unsigned long long int usedSwap;
unsigned long long int freeSwap;
2006-03-04 18:16:49 +00:00
ProcessField* fields;
ProcessField sortKey;
int direction;
bool hideThreads;
bool shadowOtherUsers;
2010-02-25 01:37:31 +00:00
bool showThreadNames;
bool showingThreadNames;
2006-03-04 18:16:49 +00:00
bool hideKernelThreads;
bool hideUserlandThreads;
bool treeView;
bool highlightBaseName;
bool highlightMegabytes;
bool highlightThreads;
bool detailedCPUTime;
bool countCPUsFromZero;
const char **treeStr;
2006-03-04 18:16:49 +00:00
} ProcessList;
2006-03-04 18:16:49 +00:00
}*/
static ProcessField defaultHeaders[] = { PID, USER, PRIORITY, NICE, M_SIZE, M_RESIDENT, M_SHARE, STATE, PERCENT_CPU, PERCENT_MEM, TIME, COMM, 0 };
2006-03-04 18:16:49 +00:00
const char *ProcessList_treeStrAscii[TREE_STR_COUNT] = {
"-", // TREE_STR_HORZ
"|", // TREE_STR_VERT
"`", // TREE_STR_RTEE
"`", // TREE_STR_BEND
",", // TREE_STR_TEND
"+", // TREE_STR_OPEN
"-", // TREE_STR_SHUT
};
const char *ProcessList_treeStrUtf8[TREE_STR_COUNT] = {
"\xe2\x94\x80", // TREE_STR_HORZ ─
"\xe2\x94\x82", // TREE_STR_VERT │
"\xe2\x94\x9c", // TREE_STR_RTEE ├
"\xe2\x94\x94", // TREE_STR_BEND └
"\xe2\x94\x8c", // TREE_STR_TEND ┌
"+", // TREE_STR_OPEN +
"\xe2\x94\x80", // TREE_STR_SHUT ─
};
2006-03-04 18:16:49 +00:00
ProcessList* ProcessList_new(UsersTable* usersTable) {
ProcessList* this;
this = calloc(sizeof(ProcessList), 1);
this->processes = Vector_new(PROCESS_CLASS, true, DEFAULT_SIZE, Process_compare);
this->processTable = Hashtable_new(140, false);
2006-03-04 18:16:49 +00:00
this->usersTable = usersTable;
/* tree-view auxiliary buffers */
this->processes2 = Vector_new(PROCESS_CLASS, true, DEFAULT_SIZE, Process_compare);
FILE* file = fopen(PROCSTATFILE, "r");
assert(file != NULL);
2006-03-04 18:16:49 +00:00
char buffer[256];
int cpus = -1;
2006-03-04 18:16:49 +00:00
do {
cpus++;
fgets(buffer, 255, file);
2006-03-04 18:16:49 +00:00
} while (String_startsWith(buffer, "cpu"));
fclose(file);
this->cpuCount = cpus - 1;
#ifdef HAVE_HWLOC
this->topologyOk = false;
int topoErr = hwloc_topology_init(&this->topology);
if (topoErr == 0) {
topoErr = hwloc_topology_load(this->topology);
this->topologyOk = true;
}
#endif
this->cpus = calloc(sizeof(CPUData), cpus);
for (int i = 0; i < cpus; i++) {
this->cpus[i].totalTime = 1;
this->cpus[i].totalPeriod = 1;
2006-03-04 18:16:49 +00:00
}
this->fields = calloc(sizeof(ProcessField), LAST_PROCESSFIELD+1);
// TODO: turn 'fields' into a Vector,
2006-03-04 18:16:49 +00:00
// (and ProcessFields into proper objects).
for (int i = 0; defaultHeaders[i]; i++) {
this->fields[i] = defaultHeaders[i];
}
this->sortKey = PERCENT_CPU;
this->direction = 1;
this->hideThreads = false;
this->shadowOtherUsers = false;
this->showThreadNames = false;
this->showingThreadNames = false;
2006-03-04 18:16:49 +00:00
this->hideKernelThreads = false;
this->hideUserlandThreads = false;
this->treeView = false;
this->highlightBaseName = false;
this->highlightMegabytes = false;
this->detailedCPUTime = false;
this->countCPUsFromZero = false;
this->treeStr = NULL;
2006-03-04 18:16:49 +00:00
return this;
}
void ProcessList_delete(ProcessList* this) {
Hashtable_delete(this->processTable);
Vector_delete(this->processes);
Vector_delete(this->processes2);
free(this->cpus);
2006-03-04 18:16:49 +00:00
free(this->fields);
free(this);
}
void ProcessList_invertSortOrder(ProcessList* this) {
if (this->direction == 1)
this->direction = -1;
else
this->direction = 1;
}
void ProcessList_printHeader(ProcessList* this, RichString* header) {
RichString_prune(header);
2006-03-04 18:16:49 +00:00
ProcessField* fields = this->fields;
for (int i = 0; fields[i]; i++) {
2010-02-25 01:37:31 +00:00
const char* field = Process_fieldTitles[fields[i]];
2006-03-04 18:16:49 +00:00
if (this->sortKey == fields[i])
RichString_append(header, CRT_colors[PANEL_HIGHLIGHT_FOCUS], field);
2006-03-04 18:16:49 +00:00
else
RichString_append(header, CRT_colors[PANEL_HEADER_FOCUS], field);
2006-03-04 18:16:49 +00:00
}
}
static void ProcessList_add(ProcessList* this, Process* p) {
assert(Vector_indexOf(this->processes, p, Process_pidCompare) == -1);
assert(Hashtable_get(this->processTable, p->pid) == NULL);
Vector_add(this->processes, p);
2006-03-04 18:16:49 +00:00
Hashtable_put(this->processTable, p->pid, p);
assert(Vector_indexOf(this->processes, p, Process_pidCompare) != -1);
assert(Hashtable_get(this->processTable, p->pid) != NULL);
assert(Hashtable_count(this->processTable) == Vector_count(this->processes));
2006-03-04 18:16:49 +00:00
}
static void ProcessList_remove(ProcessList* this, Process* p) {
assert(Vector_indexOf(this->processes, p, Process_pidCompare) != -1);
assert(Hashtable_get(this->processTable, p->pid) != NULL);
Process* pp = Hashtable_remove(this->processTable, p->pid);
2006-11-08 21:49:52 +00:00
assert(pp == p); (void)pp;
unsigned int pid = p->pid;
2010-02-25 01:37:31 +00:00
int idx = Vector_indexOf(this->processes, p, Process_pidCompare);
assert(idx != -1);
if (idx >= 0) Vector_remove(this->processes, idx);
2006-11-08 21:49:52 +00:00
assert(Hashtable_get(this->processTable, pid) == NULL); (void)pid;
assert(Hashtable_count(this->processTable) == Vector_count(this->processes));
2006-03-04 18:16:49 +00:00
}
2010-02-25 01:37:31 +00:00
Process* ProcessList_get(ProcessList* this, int idx) {
return (Process*) (Vector_get(this->processes, idx));
2006-03-04 18:16:49 +00:00
}
int ProcessList_size(ProcessList* this) {
return (Vector_size(this->processes));
2006-03-04 18:16:49 +00:00
}
2010-06-17 19:02:03 +00:00
static void ProcessList_buildTree(ProcessList* this, pid_t pid, int level, int indent, int direction, bool show) {
Vector* children = Vector_new(PROCESS_CLASS, false, DEFAULT_SIZE, Process_compare);
2006-03-04 18:16:49 +00:00
for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
Process* process = (Process*) (Vector_get(this->processes, i));
if (process->tgid == pid || (process->tgid == process->pid && process->ppid == pid)) {
2010-02-25 01:37:31 +00:00
process = (Process*) (Vector_take(this->processes, i));
Vector_add(children, process);
2006-03-04 18:16:49 +00:00
}
}
int size = Vector_size(children);
2006-03-04 18:16:49 +00:00
for (int i = 0; i < size; i++) {
Process* process = (Process*) (Vector_get(children, i));
if (!show)
process->show = false;
int s = this->processes2->items;
if (direction == 1)
Vector_add(this->processes2, process);
else
Vector_insert(this->processes2, 0, process);
assert(this->processes2->items == s+1); (void)s;
int nextIndent = indent | (1 << level);
ProcessList_buildTree(this, process->pid, level+1, (i < size - 1) ? nextIndent : indent, direction, show ? process->showChildren : false);
if (i == size - 1)
process->indent = -nextIndent;
else
process->indent = nextIndent;
2006-03-04 18:16:49 +00:00
}
Vector_delete(children);
2006-03-04 18:16:49 +00:00
}
void ProcessList_sort(ProcessList* this) {
if (!this->treeView) {
Vector_insertionSort(this->processes);
2006-03-04 18:16:49 +00:00
} else {
// Save settings
2006-03-04 18:16:49 +00:00
int direction = this->direction;
int sortKey = this->sortKey;
// Sort by PID
2006-03-04 18:16:49 +00:00
this->sortKey = PID;
this->direction = 1;
Vector_quickSort(this->processes);
// Restore settings
2006-03-04 18:16:49 +00:00
this->sortKey = sortKey;
this->direction = direction;
// Take PID 1 as root and add to the new listing
int vsize = Vector_size(this->processes);
Process* init = (Process*) (Vector_take(this->processes, 0));
// This assertion crashes on hardened kernels.
// I wonder how well tree view works on those systems.
// assert(init->pid == 1);
2006-03-04 18:16:49 +00:00
init->indent = 0;
Vector_add(this->processes2, init);
// Recursively empty list
2010-06-17 19:02:03 +00:00
ProcessList_buildTree(this, init->pid, 0, 0, direction, true);
// Add leftovers
while (Vector_size(this->processes)) {
Process* p = (Process*) (Vector_take(this->processes, 0));
p->indent = 0;
Vector_add(this->processes2, p);
2010-06-17 19:02:03 +00:00
ProcessList_buildTree(this, p->pid, 0, 0, direction, p->showChildren);
}
assert(Vector_size(this->processes2) == vsize); (void)vsize;
assert(Vector_size(this->processes) == 0);
// Swap listings around
Vector* t = this->processes;
2006-03-04 18:16:49 +00:00
this->processes = this->processes2;
this->processes2 = t;
}
}
static bool ProcessList_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);
FILE* file = fopen(filename, "r");
if (!file)
return false;
2006-03-04 18:16:49 +00:00
static char buf[MAX_READ];
int size = fread(buf, 1, MAX_READ, file);
if (!size) { fclose(file); return false; }
2006-03-04 18:16:49 +00:00
assert(process->pid == atoi(buf));
2006-03-04 18:16:49 +00:00
char *location = strchr(buf, ' ');
if (!location) { fclose(file); return false; }
2006-03-04 18:16:49 +00:00
location += 2;
char *end = strrchr(location, ')');
if (!end) { fclose(file); return false; }
2006-03-04 18:16:49 +00:00
int commsize = end - location;
memcpy(command, location, commsize);
command[commsize] = '\0';
location = end + 2;
int num = sscanf(location,
"%c %d %u %u %u "
"%d %lu "
"%*u %*u %*u %*u "
2011-03-28 19:06:06 +00:00
"%llu %llu %llu %llu "
"%ld %ld %ld "
"%*d %*u %*u %*d %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u "
"%d %d",
&process->state, &process->ppid, &process->pgrp, &process->session, &process->tty_nr,
&process->tpgid, &process->flags,
&process->utime, &process->stime, &process->cutime, &process->cstime,
&process->priority, &process->nice, &process->nlwp,
&process->exit_signal, &process->processor);
fclose(file);
return (num == 16);
2006-03-04 18:16:49 +00:00
}
static bool ProcessList_statProcessDir(Process* process, const char* dirname, char* name) {
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;
2010-03-29 18:36:11 +00:00
struct tm date;
time_t ctime = sstat.st_ctime;
process->starttime_ctime = ctime;
2010-03-29 18:36:11 +00:00
(void) localtime_r((time_t*) &ctime, &date);
strftime(process->starttime_show, 7, ((ctime > time(NULL) - 86400) ? "%R " : "%b%d "), &date);
2010-03-29 18:36:11 +00:00
return true;
2006-03-04 18:16:49 +00:00
}
#ifdef HAVE_TASKSTATS
static void ProcessList_readIoFile(Process* process, const char* dirname, char* name) {
char filename[MAX_NAME+1];
filename[MAX_NAME] = '\0';
snprintf(filename, MAX_NAME, "%s/%s/io", dirname, name);
FILE* file = fopen(filename, "r");
if (!file)
return;
char buffer[256];
buffer[255] = '\0';
struct timeval tv;
gettimeofday(&tv,NULL);
unsigned long long now = tv.tv_sec*1000+tv.tv_usec/1000;
unsigned long long last_read = process->io_read_bytes;
unsigned long long last_write = process->io_write_bytes;
while (fgets(buffer, 255, file)) {
switch (buffer[0]) {
case 'r':
if (buffer[1] == 'c')
sscanf(buffer, "rchar: %llu", &process->io_rchar);
else if (sscanf(buffer, "read_bytes: %llu", &process->io_read_bytes)) {
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 (buffer[1] == 'c')
sscanf(buffer, "wchar: %llu", &process->io_wchar);
else if (sscanf(buffer, "write_bytes: %llu", &process->io_write_bytes)) {
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 (buffer[5] == 'r')
sscanf(buffer, "syscr: %llu", &process->io_syscr);
else
sscanf(buffer, "syscw: %llu", &process->io_syscw);
break;
case 'c':
sscanf(buffer, "cancelled_write_bytes: %llu", &process->io_cancelled_write_bytes);
}
}
fclose(file);
}
#endif
static bool ProcessList_readStatmFile(Process* process, const char* dirname, const char* name) {
char filename[MAX_NAME+1];
snprintf(filename, MAX_NAME, "%s/%s/statm", dirname, name);
FILE* file = fopen(filename, "r");
if (!file)
return false;
int num = fscanf(file, "%32d %32d %32d %32d %32d %32d %32d",
&process->m_size, &process->m_resident, &process->m_share,
&process->m_trs, &process->m_lrs, &process->m_drs,
&process->m_dt);
fclose(file);
return (num == 7);
}
#ifdef HAVE_OPENVZ
static void ProcessList_readOpenVZData(Process* process, const char* dirname, const char* name) {
if (access("/proc/vz", R_OK) != 0) {
process->vpid = process->pid;
process->ctid = 0;
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 ProcessList_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 ProcessList_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%d", &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%d", &vxid);
if (ok >= 1) {
process->vxid = vxid;
}
}
#endif
}
fclose(file);
}
#endif
static bool ProcessList_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);
FILE* file = fopen(filename, "r");
if (!file)
return false;
char command[4096+1]; // max cmdline length on Linux
int amtRead = fread(command, 1, sizeof(command) - 1, file);
if (amtRead > 0) {
for (int i = 0; i < amtRead; i++)
if (command[i] == '\0' || command[i] == '\n') {
command[i] = ' ';
}
}
command[amtRead] = '\0';
fclose(file);
free(process->comm);
process->comm = String_copy(command);
return true;
}
2011-05-26 16:32:05 +00:00
static bool ProcessList_processEntries(ProcessList* this, const char* dirname, Process* parent, double period) {
2006-03-04 18:16:49 +00:00
DIR* dir;
struct dirent* entry;
dir = opendir(dirname);
if (!dir) return false;
int cpus = this->cpuCount;
bool hideKernelThreads = this->hideKernelThreads;
bool hideUserlandThreads = this->hideUserlandThreads;
2006-03-04 18:16:49 +00:00
while ((entry = readdir(dir)) != NULL) {
char* name = entry->d_name;
// filename is a number: process directory
int pid = atoi(name);
if (parent && pid == parent->pid)
continue;
2006-03-04 18:16:49 +00:00
// The RedHat kernel hides threads with a dot.
// I believe this is non-standard.
if ((!this->hideThreads) && pid == 0 && name[0] == '.') {
2010-11-24 01:02:29 +00:00
pid = atoi(name + 1);
2006-03-04 18:16:49 +00:00
}
if (pid <= 0)
continue;
2006-03-04 18:16:49 +00:00
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);
ProcessList_processEntries(this, subdirname, process, period);
#ifdef HAVE_TASKSTATS
ProcessList_readIoFile(process, dirname, name);
#endif
if (! ProcessList_readStatmFile(process, dirname, name))
goto errorReadingProcess;
2006-03-04 18:16:49 +00:00
process->show = ! ((hideKernelThreads && Process_isKernelThread(process)) || (hideUserlandThreads && Process_isUserlandThread(process)));
char command[MAX_NAME+1];
2011-05-26 16:32:05 +00:00
unsigned long long int lasttimes = (process->utime + process->stime);
if (! ProcessList_readStatFile(process, dirname, name, command))
goto errorReadingProcess;
int 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;
2011-05-26 16:32:05 +00:00
process->percent_mem = (process->m_resident * PAGE_SIZE_KB) / (double)(this->totalMem) * 100.0;
if(!existingProcess) {
if (! ProcessList_statProcessDir(process, dirname, name))
goto errorReadingProcess;
process->user = UsersTable_getRef(this->usersTable, process->st_uid);
#ifdef HAVE_OPENVZ
ProcessList_readOpenVZData(process, dirname, name);
#endif
#ifdef HAVE_CGROUP
ProcessList_readCGroupFile(process, dirname, name);
#endif
#ifdef HAVE_VSERVER
ProcessList_readVServerData(process, dirname, name);
#endif
if (! ProcessList_readCmdlineFile(process, dirname, name))
goto errorReadingProcess;
ProcessList_add(this, process);
}
2010-02-25 01:37:31 +00:00
if (process->state == 'Z') {
free(process->comm);
process->comm = String_copy(command);
} else if (Process_isThread(process)) {
if (this->showThreadNames || Process_isKernelThread(process) || process->state == 'Z') {
free(process->comm);
2010-02-25 01:37:31 +00:00
process->comm = String_copy(command);
} else if (this->showingThreadNames) {
if (! ProcessList_readCmdlineFile(process, dirname, name))
goto errorReadingProcess;
2006-03-04 18:16:49 +00:00
}
if (Process_isKernelThread(process)) {
this->kernelThreads++;
} else {
this->userlandThreads++;
}
}
2006-03-04 18:16:49 +00:00
this->totalTasks++;
if (process->state == 'R')
this->runningTasks++;
process->updated = true;
2006-03-04 18:16:49 +00:00
continue;
2006-03-04 18:16:49 +00:00
// Exception handler.
errorReadingProcess: {
if (process->comm) {
free(process->comm);
process->comm = NULL;
2006-03-04 18:16:49 +00:00
}
if (existingProcess)
ProcessList_remove(this, process);
else
Process_delete((Object*)process);
2006-03-04 18:16:49 +00:00
}
}
closedir(dir);
return true;
2006-03-04 18:16:49 +00:00
}
void ProcessList_scan(ProcessList* this) {
unsigned long long int usertime, nicetime, systemtime, systemalltime, idlealltime, idletime, totaltime, virtalltime;
2009-10-16 20:03:18 +00:00
unsigned long long int swapFree = 0;
2006-03-04 18:16:49 +00:00
FILE* file = fopen(PROCMEMINFOFILE, "r");
assert(file != NULL);
int cpus = this->cpuCount;
2010-02-25 01:37:31 +00:00
{
char buffer[128];
while (fgets(buffer, 128, file)) {
2010-02-25 01:37:31 +00:00
switch (buffer[0]) {
case 'M':
if (String_startsWith(buffer, "MemTotal:"))
sscanf(buffer, "MemTotal: %llu kB", &this->totalMem);
2010-02-25 01:37:31 +00:00
else if (String_startsWith(buffer, "MemFree:"))
sscanf(buffer, "MemFree: %llu kB", &this->freeMem);
2010-02-25 01:37:31 +00:00
else if (String_startsWith(buffer, "MemShared:"))
sscanf(buffer, "MemShared: %llu kB", &this->sharedMem);
2010-02-25 01:37:31 +00:00
break;
case 'B':
if (String_startsWith(buffer, "Buffers:"))
sscanf(buffer, "Buffers: %llu kB", &this->buffersMem);
2010-02-25 01:37:31 +00:00
break;
case 'C':
if (String_startsWith(buffer, "Cached:"))
sscanf(buffer, "Cached: %llu kB", &this->cachedMem);
2010-02-25 01:37:31 +00:00
break;
case 'S':
if (String_startsWith(buffer, "SwapTotal:"))
sscanf(buffer, "SwapTotal: %llu kB", &this->totalSwap);
2010-02-25 01:37:31 +00:00
if (String_startsWith(buffer, "SwapFree:"))
sscanf(buffer, "SwapFree: %llu kB", &swapFree);
2010-02-25 01:37:31 +00:00
break;
}
2006-03-04 18:16:49 +00:00
}
}
2006-03-04 18:16:49 +00:00
this->usedMem = this->totalMem - this->freeMem;
this->usedSwap = this->totalSwap - swapFree;
fclose(file);
file = fopen(PROCSTATFILE, "r");
assert(file != NULL);
for (int i = 0; i <= cpus; i++) {
2006-03-04 18:16:49 +00:00
char buffer[256];
int cpuid;
unsigned long long int ioWait, irq, softIrq, steal, guest;
ioWait = irq = softIrq = steal = guest = 0;
2006-03-04 18:16:49 +00:00
// Dependending on your kernel version,
// 5, 7 or 8 of these fields will be set.
// The rest will remain at zero.
fgets(buffer, 255, file);
2006-03-04 18:16:49 +00:00
if (i == 0)
sscanf(buffer, "cpu %llu %llu %llu %llu %llu %llu %llu %llu %llu", &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest);
2006-03-04 18:16:49 +00:00
else {
sscanf(buffer, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu", &cpuid, &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest);
2006-03-04 18:16:49 +00:00
assert(cpuid == i - 1);
}
// Fields existing on kernels >= 2.6
// (and RHEL's patched kernel 2.4...)
idlealltime = idletime + ioWait;
systemalltime = systemtime + irq + softIrq;
virtalltime = steal + guest;
totaltime = usertime + nicetime + systemalltime + idlealltime + 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 (guest >= 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 = guest - 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 = guest;
cpuData->totalTime = totaltime;
2006-03-04 18:16:49 +00:00
}
2011-05-26 16:32:05 +00:00
double period = (double)this->cpus[0].totalPeriod / cpus; fclose(file);
2006-03-04 18:16:49 +00:00
// mark all process as "dirty"
for (int i = 0; i < Vector_size(this->processes); i++) {
Process* p = (Process*) Vector_get(this->processes, i);
2006-03-04 18:16:49 +00:00
p->updated = false;
}
this->totalTasks = 0;
this->userlandThreads = 0;
this->kernelThreads = 0;
2006-03-04 18:16:49 +00:00
this->runningTasks = 0;
ProcessList_processEntries(this, PROCDIR, NULL, period);
2010-02-25 01:37:31 +00:00
this->showingThreadNames = this->showThreadNames;
2006-03-04 18:16:49 +00:00
for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
Process* p = (Process*) Vector_get(this->processes, i);
2006-03-04 18:16:49 +00:00
if (p->updated == false)
ProcessList_remove(this, p);
else
p->updated = false;
}
}
ProcessField ProcessList_keyAt(ProcessList* this, int at) {
int x = 0;
ProcessField* fields = this->fields;
ProcessField field;
for (int i = 0; (field = fields[i]); i++) {
int len = strlen(Process_fieldTitles[field]);
if (at >= x && at <= x + len) {
return field;
}
x += len;
}
return COMM;
}
void ProcessList_expandTree(ProcessList* this) {
int size = Vector_size(this->processes);
for (int i = 0; i < size; i++) {
Process* process = (Process*) Vector_get(this->processes, i);
process->showChildren = true;
}
}