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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "ProcessList.h"
|
2011-12-26 21:35:57 +00:00
|
|
|
|
|
|
|
#include "CRT.h"
|
2006-07-11 06:13:32 +00:00
|
|
|
#include "String.h"
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2011-12-26 21:35:57 +00:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/utsname.h>
|
2006-03-04 18:16:49 +00:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <stdbool.h>
|
2006-03-24 03:39:04 +00:00
|
|
|
#include <stdarg.h>
|
2010-02-25 01:43:18 +00:00
|
|
|
#include <math.h>
|
2011-12-26 21:35:57 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
2006-03-04 18:16:49 +00:00
|
|
|
#include <assert.h>
|
2013-04-29 23:00:15 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
/*{
|
2011-12-26 21:35:57 +00:00
|
|
|
#include "Vector.h"
|
|
|
|
#include "Hashtable.h"
|
|
|
|
#include "UsersTable.h"
|
|
|
|
#include "Panel.h"
|
|
|
|
#include "Process.h"
|
2010-08-24 23:20:38 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
#ifndef PROCDIR
|
|
|
|
#define PROCDIR "/proc"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef PROCSTATFILE
|
2007-05-17 18:29:30 +00:00
|
|
|
#define PROCSTATFILE PROCDIR "/stat"
|
2006-03-04 18:16:49 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef PROCMEMINFOFILE
|
2007-05-17 18:29:30 +00:00
|
|
|
#define PROCMEMINFOFILE PROCDIR "/meminfo"
|
2006-03-04 18:16:49 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef MAX_NAME
|
2006-03-24 03:39:04 +00:00
|
|
|
#define MAX_NAME 128
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef MAX_READ
|
2006-07-11 06:13:32 +00:00
|
|
|
#define MAX_READ 2048
|
2006-03-04 18:16:49 +00:00
|
|
|
#endif
|
|
|
|
|
2011-03-22 20:37:08 +00:00
|
|
|
#ifndef ProcessList_cpuId
|
2011-09-08 02:48:53 +00:00
|
|
|
#define ProcessList_cpuId(pl, cpu) ((pl)->countCPUsFromZero ? (cpu) : (cpu)+1)
|
2011-03-22 20:37:08 +00:00
|
|
|
#endif
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2011-11-03 22:12:12 +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;
|
|
|
|
|
2010-08-24 23:20:38 +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_ {
|
2014-02-27 19:35:22 +00:00
|
|
|
const char **treeStr;
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector* processes;
|
|
|
|
Vector* processes2;
|
2006-03-04 18:16:49 +00:00
|
|
|
Hashtable* processTable;
|
|
|
|
UsersTable* usersTable;
|
|
|
|
|
2011-12-01 12:31:57 +00:00
|
|
|
Panel* panel;
|
2012-02-02 23:45:40 +00:00
|
|
|
int following;
|
2011-12-01 12:31:57 +00:00
|
|
|
uid_t userId;
|
|
|
|
const char* incFilter;
|
2012-08-10 21:54:41 +00:00
|
|
|
Hashtable* pidWhiteList;
|
2011-12-01 12:31:57 +00:00
|
|
|
|
2010-08-24 23:20:38 +00:00
|
|
|
int cpuCount;
|
2006-03-04 18:16:49 +00:00
|
|
|
int totalTasks;
|
2010-11-23 13:28:47 +00:00
|
|
|
int userlandThreads;
|
|
|
|
int kernelThreads;
|
2006-03-04 18:16:49 +00:00
|
|
|
int runningTasks;
|
|
|
|
|
2011-11-21 02:52:41 +00:00
|
|
|
#ifdef HAVE_LIBHWLOC
|
2011-09-24 00:30:47 +00:00
|
|
|
hwloc_topology_t topology;
|
|
|
|
bool topologyOk;
|
|
|
|
#endif
|
2010-08-24 23:20:38 +00:00
|
|
|
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
|
|
|
|
2013-05-24 22:46:01 +00:00
|
|
|
int flags;
|
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;
|
2008-03-08 23:39:48 +00:00
|
|
|
bool highlightThreads;
|
2007-11-09 00:40:59 +00:00
|
|
|
bool detailedCPUTime;
|
2011-03-22 20:37:08 +00:00
|
|
|
bool countCPUsFromZero;
|
2012-10-20 00:43:25 +00:00
|
|
|
bool updateProcessNames;
|
2013-12-18 02:58:34 +00:00
|
|
|
bool accountGuestInCPUMeter;
|
2014-02-27 19:35:22 +00:00
|
|
|
bool userOnly;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
} ProcessList;
|
2011-11-03 22:12:12 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
}*/
|
|
|
|
|
2006-06-06 20:41:01 +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
|
|
|
|
2011-11-03 22:12:12 +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 ─
|
|
|
|
};
|
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
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;
|
|
|
|
start:;
|
|
|
|
ssize_t res = read(fd, buf, count);
|
|
|
|
if (res == -1 && errno == EINTR) goto start;
|
|
|
|
if (res > 0) {
|
|
|
|
buf = ((char*)buf)+res;
|
|
|
|
count -= res;
|
|
|
|
alreadyRead += res;
|
|
|
|
}
|
|
|
|
if (res == -1) return -1;
|
|
|
|
if (count == 0 || res == 0) return alreadyRead;
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
|
2012-08-10 21:54:41 +00:00
|
|
|
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList) {
|
2006-03-04 18:16:49 +00:00
|
|
|
ProcessList* this;
|
2014-01-16 20:51:16 +00:00
|
|
|
this = calloc(1, sizeof(ProcessList));
|
2012-12-05 15:12:20 +00:00
|
|
|
this->processes = Vector_new(Class(Process), true, DEFAULT_SIZE);
|
2011-11-18 06:08:56 +00:00
|
|
|
this->processTable = Hashtable_new(140, false);
|
2006-03-04 18:16:49 +00:00
|
|
|
this->usersTable = usersTable;
|
2012-08-10 21:54:41 +00:00
|
|
|
this->pidWhiteList = pidWhiteList;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
/* tree-view auxiliary buffers */
|
2012-12-05 15:12:20 +00:00
|
|
|
this->processes2 = Vector_new(Class(Process), true, DEFAULT_SIZE);
|
2006-03-24 03:39:04 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
FILE* file = fopen(PROCSTATFILE, "r");
|
2012-10-19 18:59:48 +00:00
|
|
|
if (file == NULL) {
|
|
|
|
CRT_fatalError("Cannot open " PROCSTATFILE);
|
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
char buffer[256];
|
2010-08-24 23:20:38 +00:00
|
|
|
int cpus = -1;
|
2006-03-04 18:16:49 +00:00
|
|
|
do {
|
2010-08-24 23:20:38 +00:00
|
|
|
cpus++;
|
2010-11-22 12:40:20 +00:00
|
|
|
fgets(buffer, 255, file);
|
2006-03-04 18:16:49 +00:00
|
|
|
} while (String_startsWith(buffer, "cpu"));
|
2010-11-22 12:40:20 +00:00
|
|
|
fclose(file);
|
2010-08-24 23:20:38 +00:00
|
|
|
this->cpuCount = cpus - 1;
|
2011-09-24 00:30:47 +00:00
|
|
|
|
2011-11-21 02:52:41 +00:00
|
|
|
#ifdef HAVE_LIBHWLOC
|
2011-09-24 00:30:47 +00:00
|
|
|
this->topologyOk = false;
|
|
|
|
int topoErr = hwloc_topology_init(&this->topology);
|
|
|
|
if (topoErr == 0) {
|
|
|
|
topoErr = hwloc_topology_load(this->topology);
|
|
|
|
this->topologyOk = true;
|
|
|
|
}
|
|
|
|
#endif
|
2014-01-16 20:51:16 +00:00
|
|
|
this->cpus = calloc(cpus, sizeof(CPUData));
|
2006-10-04 16:25:41 +00:00
|
|
|
|
2010-08-24 23:20:38 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2014-01-16 20:51:16 +00:00
|
|
|
this->fields = calloc(LAST_PROCESSFIELD+1, sizeof(ProcessField));
|
2006-05-30 13:45:40 +00:00
|
|
|
// TODO: turn 'fields' into a Vector,
|
2006-03-04 18:16:49 +00:00
|
|
|
// (and ProcessFields into proper objects).
|
2013-05-24 22:46:01 +00:00
|
|
|
this->flags = 0;
|
2006-03-04 18:16:49 +00:00
|
|
|
for (int i = 0; defaultHeaders[i]; i++) {
|
|
|
|
this->fields[i] = defaultHeaders[i];
|
2013-05-24 22:46:01 +00:00
|
|
|
this->fields[i] |= Process_fieldFlags[defaultHeaders[i]];
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
this->sortKey = PERCENT_CPU;
|
|
|
|
this->direction = 1;
|
|
|
|
this->hideThreads = false;
|
|
|
|
this->shadowOtherUsers = false;
|
2010-11-22 12:40:20 +00:00
|
|
|
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;
|
2007-11-09 00:40:59 +00:00
|
|
|
this->detailedCPUTime = false;
|
2011-03-22 20:37:08 +00:00
|
|
|
this->countCPUsFromZero = false;
|
2012-10-20 00:43:25 +00:00
|
|
|
this->updateProcessNames = false;
|
2011-11-03 22:12:12 +00:00
|
|
|
this->treeStr = NULL;
|
2012-03-30 01:20:32 +00:00
|
|
|
this->following = -1;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2012-12-05 15:12:20 +00:00
|
|
|
if (CRT_utf8)
|
|
|
|
this->treeStr = CRT_utf8 ? ProcessList_treeStrUtf8 : ProcessList_treeStrAscii;
|
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ProcessList_delete(ProcessList* this) {
|
|
|
|
Hashtable_delete(this->processTable);
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector_delete(this->processes);
|
|
|
|
Vector_delete(this->processes2);
|
2010-08-24 23:20:38 +00:00
|
|
|
free(this->cpus);
|
2006-03-04 18:16:49 +00:00
|
|
|
free(this->fields);
|
|
|
|
free(this);
|
|
|
|
}
|
|
|
|
|
2011-12-01 12:31:57 +00:00
|
|
|
void ProcessList_setPanel(ProcessList* this, Panel* panel) {
|
|
|
|
this->panel = panel;
|
|
|
|
}
|
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
void ProcessList_invertSortOrder(ProcessList* this) {
|
|
|
|
if (this->direction == 1)
|
|
|
|
this->direction = -1;
|
|
|
|
else
|
|
|
|
this->direction = 1;
|
|
|
|
}
|
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
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]];
|
2012-10-04 23:59:45 +00:00
|
|
|
if (!this->treeView && this->sortKey == fields[i])
|
2010-11-22 12:40:20 +00:00
|
|
|
RichString_append(header, CRT_colors[PANEL_HIGHLIGHT_FOCUS], field);
|
2006-03-04 18:16:49 +00:00
|
|
|
else
|
2010-11-22 12:40:20 +00:00
|
|
|
RichString_append(header, CRT_colors[PANEL_HEADER_FOCUS], field);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-09 08:58:38 +00:00
|
|
|
static void ProcessList_add(ProcessList* this, Process* p) {
|
2006-11-08 20:12:57 +00:00
|
|
|
assert(Vector_indexOf(this->processes, p, Process_pidCompare) == -1);
|
|
|
|
assert(Hashtable_get(this->processTable, p->pid) == NULL);
|
2010-08-24 23:20:38 +00:00
|
|
|
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector_add(this->processes, p);
|
2006-03-04 18:16:49 +00:00
|
|
|
Hashtable_put(this->processTable, p->pid, p);
|
2010-08-24 23:20:38 +00:00
|
|
|
|
2006-11-08 20:12:57 +00:00
|
|
|
assert(Vector_indexOf(this->processes, p, Process_pidCompare) != -1);
|
|
|
|
assert(Hashtable_get(this->processTable, p->pid) != NULL);
|
2006-11-12 21:53:56 +00:00
|
|
|
assert(Hashtable_count(this->processTable) == Vector_count(this->processes));
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
2008-03-09 08:58:38 +00:00
|
|
|
static void ProcessList_remove(ProcessList* this, Process* p) {
|
2006-11-08 20:12:57 +00:00
|
|
|
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;
|
2007-04-05 19:53:23 +00:00
|
|
|
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;
|
2006-11-12 21:53:56 +00:00
|
|
|
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) {
|
2006-05-30 13:45:40 +00:00
|
|
|
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) {
|
2012-12-05 15:12:20 +00:00
|
|
|
Vector* children = Vector_new(Class(Process), false, DEFAULT_SIZE);
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2006-11-08 20:12:57 +00:00
|
|
|
for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
|
2006-05-30 13:45:40 +00:00
|
|
|
Process* process = (Process*) (Vector_get(this->processes, i));
|
2014-04-11 11:45:24 +00:00
|
|
|
if (process->show && (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));
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector_add(children, process);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
}
|
2006-05-30 13:45:40 +00:00
|
|
|
int size = Vector_size(children);
|
2006-03-04 18:16:49 +00:00
|
|
|
for (int i = 0; i < size; i++) {
|
2006-05-30 13:45:40 +00:00
|
|
|
Process* process = (Process*) (Vector_get(children, i));
|
2010-11-22 12:40:20 +00:00
|
|
|
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);
|
2010-11-24 12:00:34 +00:00
|
|
|
ProcessList_buildTree(this, process->pid, level+1, (i < size - 1) ? nextIndent : indent, direction, show ? process->showChildren : false);
|
2011-11-03 22:12:12 +00:00
|
|
|
if (i == size - 1)
|
|
|
|
process->indent = -nextIndent;
|
|
|
|
else
|
|
|
|
process->indent = nextIndent;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector_delete(children);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ProcessList_sort(ProcessList* this) {
|
|
|
|
if (!this->treeView) {
|
2011-11-18 06:08:56 +00:00
|
|
|
Vector_insertionSort(this->processes);
|
2006-03-04 18:16:49 +00:00
|
|
|
} else {
|
2007-11-08 23:23:01 +00:00
|
|
|
// Save settings
|
2006-03-04 18:16:49 +00:00
|
|
|
int direction = this->direction;
|
|
|
|
int sortKey = this->sortKey;
|
2007-11-08 23:23:01 +00:00
|
|
|
// Sort by PID
|
2006-03-04 18:16:49 +00:00
|
|
|
this->sortKey = PID;
|
|
|
|
this->direction = 1;
|
2011-11-18 06:08:56 +00:00
|
|
|
Vector_quickSort(this->processes);
|
2007-11-08 23:23:01 +00:00
|
|
|
// Restore settings
|
2006-03-04 18:16:49 +00:00
|
|
|
this->sortKey = sortKey;
|
|
|
|
this->direction = direction;
|
2007-11-08 23:23:01 +00:00
|
|
|
// Take PID 1 as root and add to the new listing
|
2006-11-12 21:53:56 +00:00
|
|
|
int vsize = Vector_size(this->processes);
|
2006-05-30 13:45:40 +00:00
|
|
|
Process* init = (Process*) (Vector_take(this->processes, 0));
|
2008-09-23 06:29:03 +00:00
|
|
|
// 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;
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector_add(this->processes2, init);
|
2007-11-08 23:23:01 +00:00
|
|
|
// Recursively empty list
|
2010-06-17 19:02:03 +00:00
|
|
|
ProcessList_buildTree(this, init->pid, 0, 0, direction, true);
|
2007-11-08 23:23:01 +00:00
|
|
|
// Add leftovers
|
2006-11-12 21:53:56 +00:00
|
|
|
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);
|
2006-11-12 21:53:56 +00:00
|
|
|
}
|
|
|
|
assert(Vector_size(this->processes2) == vsize); (void)vsize;
|
|
|
|
assert(Vector_size(this->processes) == 0);
|
2007-11-08 23:23:01 +00:00
|
|
|
// Swap listings around
|
2006-05-30 13:45:40 +00:00
|
|
|
Vector* t = this->processes;
|
2006-03-04 18:16:49 +00:00
|
|
|
this->processes = this->processes2;
|
|
|
|
this->processes2 = t;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
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);
|
2013-04-29 23:00:15 +00:00
|
|
|
int fd = open(filename, O_RDONLY);
|
|
|
|
if (fd == -1)
|
2010-11-22 12:40:20 +00:00
|
|
|
return false;
|
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
static char buf[MAX_READ+1];
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
int size = xread(fd, buf, MAX_READ);
|
|
|
|
close(fd);
|
|
|
|
if (!size) return false;
|
|
|
|
buf[size] = '\0';
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
assert(process->pid == atoi(buf));
|
2006-03-04 18:16:49 +00:00
|
|
|
char *location = strchr(buf, ' ');
|
2013-04-29 23:00:15 +00:00
|
|
|
if (!location) return false;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
location += 2;
|
|
|
|
char *end = strrchr(location, ')');
|
2013-04-29 23:00:15 +00:00
|
|
|
if (!end) return false;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
int commsize = end - location;
|
|
|
|
memcpy(command, location, commsize);
|
|
|
|
command[commsize] = '\0';
|
|
|
|
location = end + 2;
|
2010-11-22 12:40:20 +00:00
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
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;
|
|
|
|
location = strchr(location, ' ')+1;
|
|
|
|
location = strchr(location, ' ')+1;
|
|
|
|
location = strchr(location, ' ')+1;
|
|
|
|
location = strchr(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;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
static bool ProcessList_statProcessDir(Process* process, const char* dirname, char* name, time_t curTime) {
|
2010-11-22 12:40:20 +00:00
|
|
|
char filename[MAX_NAME+1];
|
|
|
|
filename[MAX_NAME] = '\0';
|
2007-11-08 23:23:01 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
snprintf(filename, MAX_NAME, "%s/%s", dirname, name);
|
2007-11-08 23:23:01 +00:00
|
|
|
struct stat sstat;
|
2010-11-22 12:40:20 +00:00
|
|
|
int statok = stat(filename, &sstat);
|
2007-11-08 23:23:01 +00:00
|
|
|
if (statok == -1)
|
|
|
|
return false;
|
2010-11-22 12:40:20 +00:00
|
|
|
process->st_uid = sstat.st_uid;
|
2010-03-29 18:36:11 +00:00
|
|
|
|
|
|
|
struct tm date;
|
|
|
|
time_t ctime = sstat.st_ctime;
|
2010-11-22 12:40:20 +00:00
|
|
|
process->starttime_ctime = ctime;
|
2010-03-29 18:36:11 +00:00
|
|
|
(void) localtime_r((time_t*) &ctime, &date);
|
2013-04-29 23:00:15 +00:00
|
|
|
strftime(process->starttime_show, 7, ((ctime > curTime - 86400) ? "%R " : "%b%d "), &date);
|
2010-03-29 18:36:11 +00:00
|
|
|
|
2007-11-08 23:23:01 +00:00
|
|
|
return true;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
2008-03-09 08:02:22 +00:00
|
|
|
#ifdef HAVE_TASKSTATS
|
2008-03-09 08:58:38 +00:00
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
static void ProcessList_readIoFile(Process* process, const char* dirname, char* name, unsigned long long now) {
|
2010-11-22 12:40:20 +00:00
|
|
|
char filename[MAX_NAME+1];
|
|
|
|
filename[MAX_NAME] = '\0';
|
2008-03-09 08:02:22 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
snprintf(filename, MAX_NAME, "%s/%s/io", dirname, name);
|
2013-04-29 23:00:15 +00:00
|
|
|
int fd = open(filename, O_RDONLY);
|
|
|
|
if (fd == -1)
|
2010-11-22 12:40:20 +00:00
|
|
|
return;
|
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
char buffer[1024];
|
|
|
|
ssize_t buflen = xread(fd, buffer, 1023);
|
|
|
|
close(fd);
|
|
|
|
if (buflen < 1) return;
|
|
|
|
buffer[buflen] = '\0';
|
2010-11-22 12:40:20 +00:00
|
|
|
unsigned long long last_read = process->io_read_bytes;
|
|
|
|
unsigned long long last_write = process->io_write_bytes;
|
2013-04-29 23:00:15 +00:00
|
|
|
char *buf = buffer;
|
|
|
|
char *line = NULL;
|
|
|
|
while ((line = strsep(&buf, "\n")) != NULL) {
|
|
|
|
switch (line[0]) {
|
2011-11-18 06:08:56 +00:00
|
|
|
case 'r':
|
2013-04-29 23:00:15 +00:00
|
|
|
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);
|
2011-11-18 06:08:56 +00:00
|
|
|
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':
|
2013-04-29 23:00:15 +00:00
|
|
|
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);
|
2011-11-18 06:08:56 +00:00
|
|
|
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':
|
2013-04-29 23:00:15 +00:00
|
|
|
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: %llu", &process->io_syscw);
|
|
|
|
process->io_syscw = strtoull(line+7, NULL, 10);
|
2011-11-18 06:08:56 +00:00
|
|
|
break;
|
|
|
|
case 'c':
|
2013-04-29 23:00:15 +00:00
|
|
|
if (strncmp(line+1, "ancelled_write_bytes: ", 22) == 0)
|
|
|
|
process->io_cancelled_write_bytes = strtoull(line+23, NULL, 10);
|
2010-11-22 12:40:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#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);
|
2013-04-29 23:00:15 +00:00
|
|
|
int fd = open(filename, O_RDONLY);
|
|
|
|
if (fd == -1)
|
2010-11-22 12:40:20 +00:00
|
|
|
return false;
|
2013-04-29 23:00:15 +00:00
|
|
|
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);
|
2010-11-22 12:40:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#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,
|
2011-10-25 00:05:46 +00:00
|
|
|
"%*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",
|
2010-11-22 12:40:20 +00:00
|
|
|
&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);
|
2011-08-29 20:45:29 +00:00
|
|
|
int nFields;
|
|
|
|
char** fields = String_split(trimmed, ':', &nFields);
|
2010-11-22 12:40:20 +00:00
|
|
|
free(trimmed);
|
2011-08-29 20:45:29 +00:00
|
|
|
if (nFields >= 3) {
|
|
|
|
process->cgroup = strndup(fields[2] + 1, 10);
|
|
|
|
} else {
|
|
|
|
process->cgroup = strdup("");
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
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;
|
2008-03-09 08:02:22 +00:00
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
}
|
|
|
|
#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;
|
2008-03-09 08:02:22 +00:00
|
|
|
}
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
#endif
|
2008-03-09 08:02:22 +00:00
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
fclose(file);
|
2008-03-09 08:02:22 +00:00
|
|
|
}
|
2008-03-09 08:58:38 +00:00
|
|
|
|
2008-03-09 08:02:22 +00:00
|
|
|
#endif
|
|
|
|
|
2014-01-29 22:41:55 +00:00
|
|
|
#ifdef HAVE_OOM
|
|
|
|
|
|
|
|
static void ProcessList_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)
|
2014-02-27 20:11:23 +00:00
|
|
|
return;
|
2014-01-29 22:41:55 +00:00
|
|
|
char buffer[256];
|
|
|
|
if (!fgets(buffer, 255, file)) {
|
2014-02-27 20:11:23 +00:00
|
|
|
return;
|
2014-01-29 22:41:55 +00:00
|
|
|
}
|
|
|
|
unsigned int oom;
|
|
|
|
int ok = sscanf(buffer, "%u", &oom);
|
|
|
|
if (ok >= 1) {
|
2014-02-27 20:11:23 +00:00
|
|
|
process->oom = oom;
|
2014-01-29 22:41:55 +00:00
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
static bool ProcessList_readCmdlineFile(Process* process, const char* dirname, const char* name) {
|
|
|
|
if (Process_isKernelThread(process))
|
|
|
|
return true;
|
2012-08-10 21:54:41 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
char filename[MAX_NAME+1];
|
|
|
|
snprintf(filename, MAX_NAME, "%s/%s/cmdline", dirname, name);
|
2013-04-29 23:00:15 +00:00
|
|
|
int fd = open(filename, O_RDONLY);
|
|
|
|
if (fd == -1)
|
2010-11-22 12:40:20 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
char command[4096+1]; // max cmdline length on Linux
|
2013-04-29 23:00:15 +00:00
|
|
|
int amtRead = xread(fd, command, sizeof(command) - 1);
|
|
|
|
close(fd);
|
2014-02-27 20:11:23 +00:00
|
|
|
int tokenEnd = 0;
|
2010-11-22 12:40:20 +00:00
|
|
|
if (amtRead > 0) {
|
|
|
|
for (int i = 0; i < amtRead; i++)
|
|
|
|
if (command[i] == '\0' || command[i] == '\n') {
|
2014-02-27 20:11:23 +00:00
|
|
|
if (tokenEnd == 0) {
|
|
|
|
tokenEnd = i;
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
command[i] = ' ';
|
|
|
|
}
|
|
|
|
}
|
2014-02-27 20:11:23 +00:00
|
|
|
if (tokenEnd == 0) {
|
|
|
|
tokenEnd = amtRead;
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
command[amtRead] = '\0';
|
|
|
|
free(process->comm);
|
2011-12-25 20:23:53 +00:00
|
|
|
process->comm = strdup(command);
|
2014-04-09 20:43:54 +00:00
|
|
|
process->basenameOffset = tokenEnd;
|
2012-08-10 21:54:41 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
static bool ProcessList_processEntries(ProcessList* this, const char* dirname, Process* parent, double period, struct timeval tv) {
|
2006-03-04 18:16:49 +00:00
|
|
|
DIR* dir;
|
|
|
|
struct dirent* entry;
|
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
time_t curTime = tv.tv_sec;
|
|
|
|
#ifdef HAVE_TASKSTATS
|
|
|
|
unsigned long long now = tv.tv_sec*1000+tv.tv_usec/1000;
|
|
|
|
#endif
|
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
dir = opendir(dirname);
|
2008-03-08 23:39:48 +00:00
|
|
|
if (!dir) return false;
|
2010-08-24 23:20:38 +00:00
|
|
|
int cpus = this->cpuCount;
|
2010-11-22 12:40:20 +00:00
|
|
|
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;
|
2013-04-29 23:00:15 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
// filename is a number: process directory
|
2010-11-22 12:40:20 +00:00
|
|
|
int pid = atoi(name);
|
|
|
|
|
|
|
|
if (parent && pid == parent->pid)
|
2010-11-20 20:27:37 +00:00
|
|
|
continue;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
if (pid <= 0)
|
|
|
|
continue;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +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;
|
2009-02-17 17:12:59 +00:00
|
|
|
process->tgid = parent ? parent->pid : pid;
|
2010-11-22 12:40:20 +00:00
|
|
|
}
|
2008-03-08 23:39:48 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
char subdirname[MAX_NAME+1];
|
|
|
|
snprintf(subdirname, MAX_NAME, "%s/%s/task", dirname, name);
|
2013-04-29 23:00:15 +00:00
|
|
|
ProcessList_processEntries(this, subdirname, process, period, tv);
|
2008-03-08 23:39:48 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
#ifdef HAVE_TASKSTATS
|
2013-05-24 22:46:01 +00:00
|
|
|
if (this->flags & PROCESS_FLAG_IO)
|
|
|
|
ProcessList_readIoFile(process, dirname, name, now);
|
2010-11-22 12:40:20 +00:00
|
|
|
#endif
|
2008-09-23 05:56:15 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
if (! ProcessList_readStatmFile(process, dirname, name))
|
|
|
|
goto errorReadingProcess;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
process->show = ! ((hideKernelThreads && Process_isKernelThread(process)) || (hideUserlandThreads && Process_isUserlandThread(process)));
|
2008-03-08 23:39:48 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
char command[MAX_NAME+1];
|
2011-05-26 16:32:05 +00:00
|
|
|
unsigned long long int lasttimes = (process->utime + process->stime);
|
2010-11-22 12:40:20 +00:00
|
|
|
if (! ProcessList_readStatFile(process, dirname, name, command))
|
|
|
|
goto errorReadingProcess;
|
2013-05-24 22:46:01 +00:00
|
|
|
if (this->flags & PROCESS_FLAG_IOPRIO)
|
|
|
|
Process_updateIOPriority(process);
|
2012-05-28 00:47:05 +00:00
|
|
|
float percent_cpu = (process->utime + process->stime - lasttimes) / period * 100.0;
|
2010-11-22 12:40:20 +00:00
|
|
|
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;
|
2006-07-11 06:13:32 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
if(!existingProcess) {
|
2006-07-11 06:13:32 +00:00
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
if (! ProcessList_statProcessDir(process, dirname, name, curTime))
|
2006-07-11 06:13:32 +00:00
|
|
|
goto errorReadingProcess;
|
|
|
|
|
2010-11-26 16:51:20 +00:00
|
|
|
process->user = UsersTable_getRef(this->usersTable, process->st_uid);
|
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
#ifdef HAVE_OPENVZ
|
2013-05-24 22:46:01 +00:00
|
|
|
if (this->flags & PROCESS_FLAG_OPENVZ)
|
|
|
|
ProcessList_readOpenVZData(process, dirname, name);
|
2010-11-22 12:40:20 +00:00
|
|
|
#endif
|
2006-07-12 01:16:03 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
#ifdef HAVE_CGROUP
|
2013-05-24 22:46:01 +00:00
|
|
|
if (this->flags & PROCESS_FLAG_CGROUP)
|
|
|
|
ProcessList_readCGroupFile(process, dirname, name);
|
2010-11-22 12:40:20 +00:00
|
|
|
#endif
|
2006-07-12 01:16:03 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
#ifdef HAVE_VSERVER
|
2013-05-24 22:46:01 +00:00
|
|
|
if (this->flags & PROCESS_FLAG_VSERVER)
|
|
|
|
ProcessList_readVServerData(process, dirname, name);
|
2010-11-22 12:40:20 +00:00
|
|
|
#endif
|
|
|
|
|
2014-01-29 22:41:55 +00:00
|
|
|
#ifdef HAVE_OOM
|
|
|
|
ProcessList_readOomData(process, dirname, name);
|
|
|
|
#endif
|
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
if (! ProcessList_readCmdlineFile(process, dirname, name))
|
2006-07-12 01:16:03 +00:00
|
|
|
goto errorReadingProcess;
|
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
ProcessList_add(this, process);
|
2012-10-20 00:43:25 +00:00
|
|
|
} else {
|
|
|
|
if (this->updateProcessNames) {
|
|
|
|
if (! ProcessList_readCmdlineFile(process, dirname, name))
|
|
|
|
goto errorReadingProcess;
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
}
|
2010-02-25 01:37:31 +00:00
|
|
|
|
2011-03-17 04:26:28 +00:00
|
|
|
if (process->state == 'Z') {
|
|
|
|
free(process->comm);
|
2014-04-09 20:43:54 +00:00
|
|
|
process->basenameOffset = -1;
|
2011-12-25 20:23:53 +00:00
|
|
|
process->comm = strdup(command);
|
2011-03-17 04:26:28 +00:00
|
|
|
} else if (Process_isThread(process)) {
|
2010-11-22 12:40:20 +00:00
|
|
|
if (this->showThreadNames || Process_isKernelThread(process) || process->state == 'Z') {
|
2010-08-24 23:20:38 +00:00
|
|
|
free(process->comm);
|
2014-04-09 20:43:54 +00:00
|
|
|
process->basenameOffset = -1;
|
2011-12-25 20:23:53 +00:00
|
|
|
process->comm = strdup(command);
|
2010-11-22 12:40:20 +00:00
|
|
|
} else if (this->showingThreadNames) {
|
|
|
|
if (! ProcessList_readCmdlineFile(process, dirname, name))
|
|
|
|
goto errorReadingProcess;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2010-11-23 13:28:47 +00:00
|
|
|
if (Process_isKernelThread(process)) {
|
|
|
|
this->kernelThreads++;
|
|
|
|
} else {
|
|
|
|
this->userlandThreads++;
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
this->totalTasks++;
|
|
|
|
if (process->state == 'R')
|
|
|
|
this->runningTasks++;
|
|
|
|
process->updated = true;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
continue;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
// Exception handler.
|
|
|
|
errorReadingProcess: {
|
|
|
|
if (process->comm) {
|
|
|
|
free(process->comm);
|
2014-04-09 20:43:54 +00:00
|
|
|
process->basenameOffset = -1;
|
2010-11-22 12:40:20 +00:00
|
|
|
process->comm = NULL;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
if (existingProcess)
|
|
|
|
ProcessList_remove(this, process);
|
|
|
|
else
|
|
|
|
Process_delete((Object*)process);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
closedir(dir);
|
2008-03-08 23:39:48 +00:00
|
|
|
return true;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ProcessList_scan(ProcessList* this) {
|
2010-08-24 23:20:38 +00:00
|
|
|
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
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
FILE* file = fopen(PROCMEMINFOFILE, "r");
|
2012-10-19 18:59:48 +00:00
|
|
|
if (file == NULL) {
|
|
|
|
CRT_fatalError("Cannot open " PROCMEMINFOFILE);
|
|
|
|
}
|
2010-08-24 23:20:38 +00:00
|
|
|
int cpus = this->cpuCount;
|
2010-02-25 01:37:31 +00:00
|
|
|
{
|
|
|
|
char buffer[128];
|
2010-11-22 12:40:20 +00:00
|
|
|
while (fgets(buffer, 128, file)) {
|
2010-02-25 01:37:31 +00:00
|
|
|
|
|
|
|
switch (buffer[0]) {
|
|
|
|
case 'M':
|
|
|
|
if (String_startsWith(buffer, "MemTotal:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
sscanf(buffer, "MemTotal: %llu kB", &this->totalMem);
|
2010-02-25 01:37:31 +00:00
|
|
|
else if (String_startsWith(buffer, "MemFree:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
sscanf(buffer, "MemFree: %llu kB", &this->freeMem);
|
2010-02-25 01:37:31 +00:00
|
|
|
else if (String_startsWith(buffer, "MemShared:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
sscanf(buffer, "MemShared: %llu kB", &this->sharedMem);
|
2010-02-25 01:37:31 +00:00
|
|
|
break;
|
|
|
|
case 'B':
|
|
|
|
if (String_startsWith(buffer, "Buffers:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
sscanf(buffer, "Buffers: %llu kB", &this->buffersMem);
|
2010-02-25 01:37:31 +00:00
|
|
|
break;
|
|
|
|
case 'C':
|
|
|
|
if (String_startsWith(buffer, "Cached:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
sscanf(buffer, "Cached: %llu kB", &this->cachedMem);
|
2010-02-25 01:37:31 +00:00
|
|
|
break;
|
|
|
|
case 'S':
|
|
|
|
if (String_startsWith(buffer, "SwapTotal:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
sscanf(buffer, "SwapTotal: %llu kB", &this->totalSwap);
|
2010-02-25 01:37:31 +00:00
|
|
|
if (String_startsWith(buffer, "SwapFree:"))
|
2010-11-22 12:40:20 +00:00
|
|
|
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-24 03:39:04 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
this->usedMem = this->totalMem - this->freeMem;
|
|
|
|
this->usedSwap = this->totalSwap - swapFree;
|
2010-11-22 12:40:20 +00:00
|
|
|
fclose(file);
|
2006-03-24 03:39:04 +00:00
|
|
|
|
2010-11-22 12:40:20 +00:00
|
|
|
file = fopen(PROCSTATFILE, "r");
|
2012-10-19 18:59:48 +00:00
|
|
|
if (file == NULL) {
|
|
|
|
CRT_fatalError("Cannot open " PROCSTATFILE);
|
|
|
|
}
|
2010-08-24 23:20:38 +00:00
|
|
|
for (int i = 0; i <= cpus; i++) {
|
2006-03-04 18:16:49 +00:00
|
|
|
char buffer[256];
|
|
|
|
int cpuid;
|
2013-12-18 02:20:39 +00:00
|
|
|
unsigned long long int ioWait, irq, softIrq, steal, guest, guestnice;
|
|
|
|
ioWait = irq = softIrq = steal = guest = guestnice = 0;
|
2006-03-04 18:16:49 +00:00
|
|
|
// Dependending on your kernel version,
|
2013-12-18 02:20:39 +00:00
|
|
|
// 5, 7, 8 or 9 of these fields will be set.
|
2006-03-04 18:16:49 +00:00
|
|
|
// The rest will remain at zero.
|
2010-11-22 12:40:20 +00:00
|
|
|
fgets(buffer, 255, file);
|
2006-03-04 18:16:49 +00:00
|
|
|
if (i == 0)
|
2013-12-18 02:20:39 +00:00
|
|
|
sscanf(buffer, "cpu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu", &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
|
2006-03-04 18:16:49 +00:00
|
|
|
else {
|
2013-12-18 02:20:39 +00:00
|
|
|
sscanf(buffer, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu", &cpuid, &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
|
2006-03-04 18:16:49 +00:00
|
|
|
assert(cpuid == i - 1);
|
|
|
|
}
|
2013-12-18 02:20:39 +00:00
|
|
|
// Guest time is already accounted in usertime
|
|
|
|
usertime = usertime - guest;
|
|
|
|
nicetime = nicetime - guestnice;
|
2006-03-04 18:16:49 +00:00
|
|
|
// Fields existing on kernels >= 2.6
|
|
|
|
// (and RHEL's patched kernel 2.4...)
|
2007-11-09 00:40:59 +00:00
|
|
|
idlealltime = idletime + ioWait;
|
2010-08-24 23:20:38 +00:00
|
|
|
systemalltime = systemtime + irq + softIrq;
|
2013-12-18 02:20:39 +00:00
|
|
|
virtalltime = guest + guestnice;
|
|
|
|
totaltime = usertime + nicetime + systemalltime + idlealltime + steal + virtalltime;
|
2010-08-24 23:20:38 +00:00
|
|
|
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);
|
2013-12-18 02:20:39 +00:00
|
|
|
assert (virtalltime >= cpuData->guestTime);
|
2010-08-24 23:20:38 +00:00
|
|
|
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;
|
2013-12-18 02:20:39 +00:00
|
|
|
cpuData->guestPeriod = virtalltime - cpuData->guestTime;
|
2010-08-24 23:20:38 +00:00
|
|
|
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;
|
2013-12-18 02:20:39 +00:00
|
|
|
cpuData->guestTime = virtalltime;
|
2010-08-24 23:20:38 +00:00
|
|
|
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"
|
2006-05-30 13:45:40 +00:00
|
|
|
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;
|
2010-11-23 13:28:47 +00:00
|
|
|
this->userlandThreads = 0;
|
|
|
|
this->kernelThreads = 0;
|
2006-03-04 18:16:49 +00:00
|
|
|
this->runningTasks = 0;
|
2008-03-08 23:39:48 +00:00
|
|
|
|
2013-04-29 23:00:15 +00:00
|
|
|
struct timeval tv;
|
|
|
|
gettimeofday(&tv, NULL);
|
|
|
|
ProcessList_processEntries(this, PROCDIR, NULL, period, tv);
|
2010-02-25 01:37:31 +00:00
|
|
|
|
|
|
|
this->showingThreadNames = this->showThreadNames;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2006-05-30 13:45:40 +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;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2008-03-14 18:50:49 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2010-08-24 23:20:38 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2011-12-01 12:31:57 +00:00
|
|
|
|
2012-11-10 00:31:37 +00:00
|
|
|
void ProcessList_rebuildPanel(ProcessList* this, bool flags, int following, bool userOnly, uid_t userId, const char* incFilter) {
|
2011-12-01 12:31:57 +00:00
|
|
|
if (!flags) {
|
2012-02-02 23:45:40 +00:00
|
|
|
following = this->following;
|
2011-12-01 12:31:57 +00:00
|
|
|
userOnly = this->userOnly;
|
|
|
|
userId = this->userId;
|
|
|
|
incFilter = this->incFilter;
|
|
|
|
} else {
|
2012-02-02 23:45:40 +00:00
|
|
|
this->following = following;
|
2011-12-01 12:31:57 +00:00
|
|
|
this->userOnly = userOnly;
|
|
|
|
this->userId = userId;
|
|
|
|
this->incFilter = incFilter;
|
|
|
|
}
|
|
|
|
|
|
|
|
int currPos = Panel_getSelectedIndex(this->panel);
|
2012-03-30 01:20:32 +00:00
|
|
|
pid_t currPid = following != -1 ? following : 0;
|
2011-12-01 12:31:57 +00:00
|
|
|
int currScrollV = this->panel->scrollV;
|
|
|
|
|
|
|
|
Panel_prune(this->panel);
|
|
|
|
int size = ProcessList_size(this);
|
|
|
|
int idx = 0;
|
|
|
|
for (int i = 0; i < size; i++) {
|
|
|
|
bool hidden = false;
|
|
|
|
Process* p = ProcessList_get(this, i);
|
|
|
|
|
|
|
|
if ( (!p->show)
|
|
|
|
|| (userOnly && (p->st_uid != userId))
|
2012-11-10 00:31:37 +00:00
|
|
|
|| (incFilter && !(String_contains_i(p->comm, incFilter)))
|
2012-08-10 21:54:41 +00:00
|
|
|
|| (this->pidWhiteList && !Hashtable_get(this->pidWhiteList, p->pid)) )
|
2011-12-01 12:31:57 +00:00
|
|
|
hidden = true;
|
|
|
|
|
|
|
|
if (!hidden) {
|
|
|
|
Panel_set(this->panel, idx, (Object*)p);
|
2012-02-02 23:45:40 +00:00
|
|
|
if ((following == -1 && idx == currPos) || (following != -1 && p->pid == currPid)) {
|
2011-12-01 12:31:57 +00:00
|
|
|
Panel_setSelected(this->panel, idx);
|
|
|
|
this->panel->scrollV = currScrollV;
|
|
|
|
}
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|