ProcessList.c 29.2 KB
Newer Older
Hisham Muhammad's avatar
Hisham Muhammad committed
1
2
3
4
5
6
7
8
/*
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"
Hisham Muhammad's avatar
Hisham Muhammad committed
9
10

#include "CRT.h"
11
#include "String.h"
Hisham Muhammad's avatar
Hisham Muhammad committed
12

Hisham Muhammad's avatar
Hisham Muhammad committed
13
14
#include <sys/time.h>
#include <sys/utsname.h>
Hisham Muhammad's avatar
Hisham Muhammad committed
15
16
17
18
19
20
21
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <stdbool.h>
Hisham Muhammad's avatar
Hisham Muhammad committed
22
#include <stdarg.h>
Hisham Muhammad's avatar
Hisham Muhammad committed
23
#include <math.h>
Hisham Muhammad's avatar
Hisham Muhammad committed
24
25
#include <string.h>
#include <time.h>
Hisham Muhammad's avatar
Hisham Muhammad committed
26
27
28
#include <assert.h>

/*{
Hisham Muhammad's avatar
Hisham Muhammad committed
29
30
31
32
33
34
#include "Vector.h"
#include "Hashtable.h"
#include "UsersTable.h"
#include "Panel.h"
#include "Process.h"
#include <sys/types.h>
35

Hisham Muhammad's avatar
Hisham Muhammad committed
36
37
38
39
40
#ifndef PROCDIR
#define PROCDIR "/proc"
#endif

#ifndef PROCSTATFILE
41
#define PROCSTATFILE PROCDIR "/stat"
Hisham Muhammad's avatar
Hisham Muhammad committed
42
43
44
#endif

#ifndef PROCMEMINFOFILE
45
#define PROCMEMINFOFILE PROCDIR "/meminfo"
Hisham Muhammad's avatar
Hisham Muhammad committed
46
47
48
#endif

#ifndef MAX_NAME
Hisham Muhammad's avatar
Hisham Muhammad committed
49
50
51
52
#define MAX_NAME 128
#endif

#ifndef MAX_READ
53
#define MAX_READ 2048
Hisham Muhammad's avatar
Hisham Muhammad committed
54
55
#endif

56
#ifndef ProcessList_cpuId
57
#define ProcessList_cpuId(pl, cpu) ((pl)->countCPUsFromZero ? (cpu) : (cpu)+1)
58
#endif
Hisham Muhammad's avatar
Hisham Muhammad committed
59

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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;
Hisham Muhammad's avatar
Hisham Muhammad committed
76

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
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;

Hisham Muhammad's avatar
Hisham Muhammad committed
105
typedef struct ProcessList_ {
106
107
   Vector* processes;
   Vector* processes2;
Hisham Muhammad's avatar
Hisham Muhammad committed
108
109
110
   Hashtable* processTable;
   UsersTable* usersTable;

111
112
113
114
115
116
117
   Panel* panel;
   bool follow;
   bool userOnly;
   uid_t userId;
   bool filtering;
   const char* incFilter;

118
   int cpuCount;
Hisham Muhammad's avatar
Hisham Muhammad committed
119
   int totalTasks;
120
121
   int userlandThreads;
   int kernelThreads;
Hisham Muhammad's avatar
Hisham Muhammad committed
122
123
   int runningTasks;

124
   #ifdef HAVE_LIBHWLOC
125
126
127
   hwloc_topology_t topology;
   bool topologyOk;
   #endif
128
   CPUData* cpus;
129
130
131
132
133
134
135
136
137
138

   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;
Hisham Muhammad's avatar
Hisham Muhammad committed
139
140
141
142
143
144

   ProcessField* fields;
   ProcessField sortKey;
   int direction;
   bool hideThreads;
   bool shadowOtherUsers;
Hisham Muhammad's avatar
Hisham Muhammad committed
145
146
   bool showThreadNames;
   bool showingThreadNames;
Hisham Muhammad's avatar
Hisham Muhammad committed
147
148
149
150
151
   bool hideKernelThreads;
   bool hideUserlandThreads;
   bool treeView;
   bool highlightBaseName;
   bool highlightMegabytes;
152
   bool highlightThreads;
153
   bool detailedCPUTime;
154
   bool countCPUsFromZero;
155
   const char **treeStr;
Hisham Muhammad's avatar
Hisham Muhammad committed
156
157

} ProcessList;
158

Hisham Muhammad's avatar
Hisham Muhammad committed
159
160
}*/

161
static ProcessField defaultHeaders[] = { PID, USER, PRIORITY, NICE, M_SIZE, M_RESIDENT, M_SHARE, STATE, PERCENT_CPU, PERCENT_MEM, TIME, COMM, 0 };
Hisham Muhammad's avatar
Hisham Muhammad committed
162

163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
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 ─
};

Hisham Muhammad's avatar
Hisham Muhammad committed
183
184
ProcessList* ProcessList_new(UsersTable* usersTable) {
   ProcessList* this;
185
   this = calloc(sizeof(ProcessList), 1);
186
   this->processes = Vector_new(PROCESS_CLASS, true, DEFAULT_SIZE, Process_compare);
187
   this->processTable = Hashtable_new(140, false);
Hisham Muhammad's avatar
Hisham Muhammad committed
188
189
190
   this->usersTable = usersTable;
   
   /* tree-view auxiliary buffers */
191
   this->processes2 = Vector_new(PROCESS_CLASS, true, DEFAULT_SIZE, Process_compare);
Hisham Muhammad's avatar
Hisham Muhammad committed
192
   
193
194
   FILE* file = fopen(PROCSTATFILE, "r");
   assert(file != NULL);
Hisham Muhammad's avatar
Hisham Muhammad committed
195
   char buffer[256];
196
   int cpus = -1;
Hisham Muhammad's avatar
Hisham Muhammad committed
197
   do {
198
      cpus++;
199
      fgets(buffer, 255, file);
Hisham Muhammad's avatar
Hisham Muhammad committed
200
   } while (String_startsWith(buffer, "cpu"));
201
   fclose(file);
202
   this->cpuCount = cpus - 1;
203

204
#ifdef HAVE_LIBHWLOC
205
206
207
208
209
210
211
   this->topologyOk = false;
   int topoErr = hwloc_topology_init(&this->topology);
   if (topoErr == 0) {
      topoErr = hwloc_topology_load(this->topology);
      this->topologyOk = true;
   }
#endif
212
   this->cpus = calloc(sizeof(CPUData), cpus);
213

214
215
216
   for (int i = 0; i < cpus; i++) {
      this->cpus[i].totalTime = 1;
      this->cpus[i].totalPeriod = 1;
Hisham Muhammad's avatar
Hisham Muhammad committed
217
218
219
   }

   this->fields = calloc(sizeof(ProcessField), LAST_PROCESSFIELD+1);
220
   // TODO: turn 'fields' into a Vector,
Hisham Muhammad's avatar
Hisham Muhammad committed
221
222
223
224
225
226
227
228
   // (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;
229
230
   this->showThreadNames = false;
   this->showingThreadNames = false;
Hisham Muhammad's avatar
Hisham Muhammad committed
231
232
233
234
235
   this->hideKernelThreads = false;
   this->hideUserlandThreads = false;
   this->treeView = false;
   this->highlightBaseName = false;
   this->highlightMegabytes = false;
236
   this->detailedCPUTime = false;
237
   this->countCPUsFromZero = false;
238
   this->treeStr = NULL;
Hisham Muhammad's avatar
Hisham Muhammad committed
239
240
241
242
243
244

   return this;
}

void ProcessList_delete(ProcessList* this) {
   Hashtable_delete(this->processTable);
245
246
   Vector_delete(this->processes);
   Vector_delete(this->processes2);
247
   free(this->cpus);
Hisham Muhammad's avatar
Hisham Muhammad committed
248
249
250
251
   free(this->fields);
   free(this);
}

252
253
254
255
void ProcessList_setPanel(ProcessList* this, Panel* panel) {
   this->panel = panel;
}

Hisham Muhammad's avatar
Hisham Muhammad committed
256
257
258
259
260
261
262
void ProcessList_invertSortOrder(ProcessList* this) {
   if (this->direction == 1)
      this->direction = -1;
   else
      this->direction = 1;
}

263
264
void ProcessList_printHeader(ProcessList* this, RichString* header) {
   RichString_prune(header);
Hisham Muhammad's avatar
Hisham Muhammad committed
265
266
   ProcessField* fields = this->fields;
   for (int i = 0; fields[i]; i++) {
Hisham Muhammad's avatar
Hisham Muhammad committed
267
      const char* field = Process_fieldTitles[fields[i]];
Hisham Muhammad's avatar
Hisham Muhammad committed
268
      if (this->sortKey == fields[i])
269
         RichString_append(header, CRT_colors[PANEL_HIGHLIGHT_FOCUS], field);
Hisham Muhammad's avatar
Hisham Muhammad committed
270
      else
271
         RichString_append(header, CRT_colors[PANEL_HEADER_FOCUS], field);
Hisham Muhammad's avatar
Hisham Muhammad committed
272
273
274
   }
}

275
static void ProcessList_add(ProcessList* this, Process* p) {
276
277
   assert(Vector_indexOf(this->processes, p, Process_pidCompare) == -1);
   assert(Hashtable_get(this->processTable, p->pid) == NULL);
278
   
279
   Vector_add(this->processes, p);
Hisham Muhammad's avatar
Hisham Muhammad committed
280
   Hashtable_put(this->processTable, p->pid, p);
281
   
282
283
   assert(Vector_indexOf(this->processes, p, Process_pidCompare) != -1);
   assert(Hashtable_get(this->processTable, p->pid) != NULL);
284
   assert(Hashtable_count(this->processTable) == Vector_count(this->processes));
Hisham Muhammad's avatar
Hisham Muhammad committed
285
286
}

287
static void ProcessList_remove(ProcessList* this, Process* p) {
288
289
290
   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);
291
   assert(pp == p); (void)pp;
292
   unsigned int pid = p->pid;
Hisham Muhammad's avatar
Hisham Muhammad committed
293
294
295
   int idx = Vector_indexOf(this->processes, p, Process_pidCompare);
   assert(idx != -1);
   if (idx >= 0) Vector_remove(this->processes, idx);
296
   assert(Hashtable_get(this->processTable, pid) == NULL); (void)pid;
297
   assert(Hashtable_count(this->processTable) == Vector_count(this->processes));
Hisham Muhammad's avatar
Hisham Muhammad committed
298
299
}

Hisham Muhammad's avatar
Hisham Muhammad committed
300
301
Process* ProcessList_get(ProcessList* this, int idx) {
   return (Process*) (Vector_get(this->processes, idx));
Hisham Muhammad's avatar
Hisham Muhammad committed
302
303
304
}

int ProcessList_size(ProcessList* this) {
305
   return (Vector_size(this->processes));
Hisham Muhammad's avatar
Hisham Muhammad committed
306
307
}

Hisham Muhammad's avatar
Hisham Muhammad committed
308
static void ProcessList_buildTree(ProcessList* this, pid_t pid, int level, int indent, int direction, bool show) {
309
   Vector* children = Vector_new(PROCESS_CLASS, false, DEFAULT_SIZE, Process_compare);
Hisham Muhammad's avatar
Hisham Muhammad committed
310

311
   for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
312
      Process* process = (Process*) (Vector_get(this->processes, i));
313
      if (process->tgid == pid || (process->tgid == process->pid && process->ppid == pid)) {
Hisham Muhammad's avatar
Hisham Muhammad committed
314
         process = (Process*) (Vector_take(this->processes, i));
315
         Vector_add(children, process);
Hisham Muhammad's avatar
Hisham Muhammad committed
316
317
      }
   }
318
   int size = Vector_size(children);
Hisham Muhammad's avatar
Hisham Muhammad committed
319
   for (int i = 0; i < size; i++) {
320
      Process* process = (Process*) (Vector_get(children, i));
321
322
323
324
325
326
327
328
329
      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);
330
      ProcessList_buildTree(this, process->pid, level+1, (i < size - 1) ? nextIndent : indent, direction, show ? process->showChildren : false);
331
332
333
334
      if (i == size - 1)
         process->indent = -nextIndent;
      else
         process->indent = nextIndent;
Hisham Muhammad's avatar
Hisham Muhammad committed
335
   }
336
   Vector_delete(children);
Hisham Muhammad's avatar
Hisham Muhammad committed
337
338
339
340
}

void ProcessList_sort(ProcessList* this) {
   if (!this->treeView) {
341
      Vector_insertionSort(this->processes);
Hisham Muhammad's avatar
Hisham Muhammad committed
342
   } else {
343
      // Save settings
Hisham Muhammad's avatar
Hisham Muhammad committed
344
345
      int direction = this->direction;
      int sortKey = this->sortKey;
346
      // Sort by PID
Hisham Muhammad's avatar
Hisham Muhammad committed
347
348
      this->sortKey = PID;
      this->direction = 1;
349
      Vector_quickSort(this->processes);
350
      // Restore settings
Hisham Muhammad's avatar
Hisham Muhammad committed
351
352
      this->sortKey = sortKey;
      this->direction = direction;
353
      // Take PID 1 as root and add to the new listing
354
      int vsize = Vector_size(this->processes);
355
      Process* init = (Process*) (Vector_take(this->processes, 0));
356
357
358
      // This assertion crashes on hardened kernels.
      // I wonder how well tree view works on those systems.
      // assert(init->pid == 1);
Hisham Muhammad's avatar
Hisham Muhammad committed
359
      init->indent = 0;
360
      Vector_add(this->processes2, init);
361
      // Recursively empty list
Hisham Muhammad's avatar
Hisham Muhammad committed
362
      ProcessList_buildTree(this, init->pid, 0, 0, direction, true);
363
      // Add leftovers
364
365
366
367
      while (Vector_size(this->processes)) {
         Process* p = (Process*) (Vector_take(this->processes, 0));
         p->indent = 0;
         Vector_add(this->processes2, p);
Hisham Muhammad's avatar
Hisham Muhammad committed
368
         ProcessList_buildTree(this, p->pid, 0, 0, direction, p->showChildren);
369
370
371
      }
      assert(Vector_size(this->processes2) == vsize); (void)vsize;
      assert(Vector_size(this->processes) == 0);
372
      // Swap listings around
373
      Vector* t = this->processes;
Hisham Muhammad's avatar
Hisham Muhammad committed
374
375
376
377
378
      this->processes = this->processes2;
      this->processes2 = t;
   }
}

379
380
381
382
383
384
385
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;

Hisham Muhammad's avatar
Hisham Muhammad committed
386
387
   static char buf[MAX_READ];

388
389
   int size = fread(buf, 1, MAX_READ, file);
   if (!size) { fclose(file); return false; }
Hisham Muhammad's avatar
Hisham Muhammad committed
390

391
   assert(process->pid == atoi(buf));
Hisham Muhammad's avatar
Hisham Muhammad committed
392
   char *location = strchr(buf, ' ');
393
   if (!location) { fclose(file); return false; }
Hisham Muhammad's avatar
Hisham Muhammad committed
394
395
396

   location += 2;
   char *end = strrchr(location, ')');
397
   if (!end) { fclose(file); return false; }
Hisham Muhammad's avatar
Hisham Muhammad committed
398
399
400
401
402
   
   int commsize = end - location;
   memcpy(command, location, commsize);
   command[commsize] = '\0';
   location = end + 2;
403
404
405
406
407

   int num = sscanf(location, 
      "%c %d %u %u %u "
      "%d %lu "
      "%*u %*u %*u %*u "
408
      "%llu %llu %llu %llu "
409
410
      "%ld %ld %ld "
      "%*d %*u %*u %*d %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u "
411
      "%d %d",
412
413
414
415
416
417
418
      &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);
Hisham Muhammad's avatar
Hisham Muhammad committed
419
420
}

421
422
423
static bool ProcessList_statProcessDir(Process* process, const char* dirname, char* name) {
   char filename[MAX_NAME+1];
   filename[MAX_NAME] = '\0';
424

425
   snprintf(filename, MAX_NAME, "%s/%s", dirname, name);
426
   struct stat sstat;
427
   int statok = stat(filename, &sstat);
428
429
   if (statok == -1)
      return false;
430
   process->st_uid = sstat.st_uid;
Hisham Muhammad's avatar
Hisham Muhammad committed
431
432
433
  
   struct tm date;
   time_t ctime = sstat.st_ctime;
434
   process->starttime_ctime = ctime;
Hisham Muhammad's avatar
Hisham Muhammad committed
435
   (void) localtime_r((time_t*) &ctime, &date);
436
   strftime(process->starttime_show, 7, ((ctime > time(NULL) - 86400) ? "%R " : "%b%d "), &date);
Hisham Muhammad's avatar
Hisham Muhammad committed
437
   
438
   return true;
Hisham Muhammad's avatar
Hisham Muhammad committed
439
440
}

441
#ifdef HAVE_TASKSTATS
442

443
444
445
static void ProcessList_readIoFile(Process* process, const char* dirname, char* name) {
   char filename[MAX_NAME+1];
   filename[MAX_NAME] = '\0';
446

447
448
449
450
451
452
453
454
455
456
457
458
459
   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)) {
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
      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);
487
488
489
490
491
492
493
494
495
496
497
498
499
500
      }
   }
   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;

501
   int num = fscanf(file, "%32d %32d %32d %32d %32d %32d %32d",
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
       &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, 
523
524
525
526
527
528
529
      "%*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",
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
      &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);
550
551
      int nFields;
      char** fields = String_split(trimmed, ':', &nFields);
552
      free(trimmed);
553
554
555
556
557
      if (nFields >= 3) {
         process->cgroup = strndup(fields[2] + 1, 10);
      } else {
         process->cgroup = strdup("");
      }
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
      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;
581
         }
582
583
584
585
586
587
588
      }
      #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;
589
590
         }
      }
591
      #endif
592
   }
593
   fclose(file);
594
}
595

596
597
#endif

598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
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);
Hisham Muhammad's avatar
Hisham Muhammad committed
618
   process->comm = strdup(command);
619
620
621
622
   return true;
}


Hisham Muhammad's avatar
Hisham Muhammad committed
623
static bool ProcessList_processEntries(ProcessList* this, const char* dirname, Process* parent, double period) {
Hisham Muhammad's avatar
Hisham Muhammad committed
624
625
626
627
   DIR* dir;
   struct dirent* entry;

   dir = opendir(dirname);
628
   if (!dir) return false;
629
   int cpus = this->cpuCount;
630
631
   bool hideKernelThreads = this->hideKernelThreads;
   bool hideUserlandThreads = this->hideUserlandThreads;
Hisham Muhammad's avatar
Hisham Muhammad committed
632
633
634
   while ((entry = readdir(dir)) != NULL) {
      char* name = entry->d_name;
      // filename is a number: process directory
635
636
637
      int pid = atoi(name);
     
      if (parent && pid == parent->pid)
638
         continue;
Hisham Muhammad's avatar
Hisham Muhammad committed
639
640
641
642

      // The RedHat kernel hides threads with a dot.
      // I believe this is non-standard.
      if ((!this->hideThreads) && pid == 0 && name[0] == '.') {
Hisham Muhammad's avatar
Hisham Muhammad committed
643
         pid = atoi(name + 1);
Hisham Muhammad's avatar
Hisham Muhammad committed
644
      }
645
646
      if (pid <= 0) 
         continue;
Hisham Muhammad's avatar
Hisham Muhammad committed
647

648
649
650
651
652
653
654
655
656
657
658
      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;
659
         process->tgid = parent ? parent->pid : pid;
660
      }
661

662
663
664
      char subdirname[MAX_NAME+1];
      snprintf(subdirname, MAX_NAME, "%s/%s/task", dirname, name);
      ProcessList_processEntries(this, subdirname, process, period);
665

666
667
668
      #ifdef HAVE_TASKSTATS
      ProcessList_readIoFile(process, dirname, name);
      #endif
669

670
671
      if (! ProcessList_readStatmFile(process, dirname, name))
         goto errorReadingProcess;
Hisham Muhammad's avatar
Hisham Muhammad committed
672

673
      process->show = ! ((hideKernelThreads && Process_isKernelThread(process)) || (hideUserlandThreads && Process_isUserlandThread(process)));
674

675
      char command[MAX_NAME+1];
Hisham Muhammad's avatar
Hisham Muhammad committed
676
      unsigned long long int lasttimes = (process->utime + process->stime);
677
678
679
680
681
      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;
Hisham Muhammad's avatar
Hisham Muhammad committed
682
      process->percent_mem = (process->m_resident * PAGE_SIZE_KB) / (double)(this->totalMem) * 100.0;
683

684
      if(!existingProcess) {
685

686
         if (! ProcessList_statProcessDir(process, dirname, name))
687
688
            goto errorReadingProcess;

689
690
         process->user = UsersTable_getRef(this->usersTable, process->st_uid);

691
692
693
         #ifdef HAVE_OPENVZ
         ProcessList_readOpenVZData(process, dirname, name);
         #endif
694

695
696
697
         #ifdef HAVE_CGROUP
         ProcessList_readCGroupFile(process, dirname, name);
         #endif
698
         
699
700
701
702
703
         #ifdef HAVE_VSERVER
         ProcessList_readVServerData(process, dirname, name);
         #endif
         
         if (! ProcessList_readCmdlineFile(process, dirname, name))
704
705
            goto errorReadingProcess;

706
707
         ProcessList_add(this, process);
      }
Hisham Muhammad's avatar
Hisham Muhammad committed
708

709
710
      if (process->state == 'Z') {
         free(process->comm);
Hisham Muhammad's avatar
Hisham Muhammad committed
711
         process->comm = strdup(command);
712
      } else if (Process_isThread(process)) {
713
         if (this->showThreadNames || Process_isKernelThread(process) || process->state == 'Z') {
714
            free(process->comm);
Hisham Muhammad's avatar
Hisham Muhammad committed
715
            process->comm = strdup(command);
716
717
718
         } else if (this->showingThreadNames) {
            if (! ProcessList_readCmdlineFile(process, dirname, name))
               goto errorReadingProcess;
Hisham Muhammad's avatar
Hisham Muhammad committed
719
         }
720
721
722
723
724
         if (Process_isKernelThread(process)) {
            this->kernelThreads++;
         } else {
            this->userlandThreads++;
         }
725
      }
Hisham Muhammad's avatar
Hisham Muhammad committed
726

727
728
729
730
      this->totalTasks++;
      if (process->state == 'R')
         this->runningTasks++;
      process->updated = true;
Hisham Muhammad's avatar
Hisham Muhammad committed
731

732
      continue;
Hisham Muhammad's avatar
Hisham Muhammad committed
733

734
735
736
737
738
      // Exception handler.
      errorReadingProcess: {
         if (process->comm) {
            free(process->comm);
            process->comm = NULL;
Hisham Muhammad's avatar
Hisham Muhammad committed
739
         }
740
741
742
743
         if (existingProcess)
            ProcessList_remove(this, process);
         else
            Process_delete((Object*)process);
Hisham Muhammad's avatar
Hisham Muhammad committed
744
745
746
      }
   }
   closedir(dir);
747
   return true;
Hisham Muhammad's avatar
Hisham Muhammad committed
748
749
750
}

void ProcessList_scan(ProcessList* this) {
751
   unsigned long long int usertime, nicetime, systemtime, systemalltime, idlealltime, idletime, totaltime, virtalltime;
Hisham Muhammad's avatar
Hisham Muhammad committed
752
   unsigned long long int swapFree = 0;
Hisham Muhammad's avatar
Hisham Muhammad committed
753

754
755
   FILE* file = fopen(PROCMEMINFOFILE, "r");
   assert(file != NULL);
756
   int cpus = this->cpuCount;
Hisham Muhammad's avatar
Hisham Muhammad committed
757
758
   {
      char buffer[128];
759
      while (fgets(buffer, 128, file)) {
Hisham Muhammad's avatar
Hisham Muhammad committed
760
761
762
763
   
         switch (buffer[0]) {
         case 'M':
            if (String_startsWith(buffer, "MemTotal:"))
764
               sscanf(buffer, "MemTotal: %llu kB", &this->totalMem);
Hisham Muhammad's avatar
Hisham Muhammad committed
765
            else if (String_startsWith(buffer, "MemFree:"))
766
               sscanf(buffer, "MemFree: %llu kB", &this->freeMem);
Hisham Muhammad's avatar
Hisham Muhammad committed
767
            else if (String_startsWith(buffer, "MemShared:"))
768
               sscanf(buffer, "MemShared: %llu kB", &this->sharedMem);
Hisham Muhammad's avatar
Hisham Muhammad committed
769
770
771
            break;
         case 'B':
            if (String_startsWith(buffer, "Buffers:"))
772
               sscanf(buffer, "Buffers: %llu kB", &this->buffersMem);
Hisham Muhammad's avatar
Hisham Muhammad committed
773
774
775
            break;
         case 'C':
            if (String_startsWith(buffer, "Cached:"))
776
               sscanf(buffer, "Cached: %llu kB", &this->cachedMem);
Hisham Muhammad's avatar
Hisham Muhammad committed
777
778
779
            break;
         case 'S':
            if (String_startsWith(buffer, "SwapTotal:"))
780
               sscanf(buffer, "SwapTotal: %llu kB", &this->totalSwap);
Hisham Muhammad's avatar
Hisham Muhammad committed
781
            if (String_startsWith(buffer, "SwapFree:"))
782
               sscanf(buffer, "SwapFree: %llu kB", &swapFree);
Hisham Muhammad's avatar
Hisham Muhammad committed
783
784
            break;
         }
Hisham Muhammad's avatar
Hisham Muhammad committed
785
786
      }
   }
Hisham Muhammad's avatar
Hisham Muhammad committed
787

Hisham Muhammad's avatar
Hisham Muhammad committed
788
789
   this->usedMem = this->totalMem - this->freeMem;
   this->usedSwap = this->totalSwap - swapFree;
790
   fclose(file);
Hisham Muhammad's avatar
Hisham Muhammad committed
791

792
793
   file = fopen(PROCSTATFILE, "r");
   assert(file != NULL);
794
   for (int i = 0; i <= cpus; i++) {
Hisham Muhammad's avatar
Hisham Muhammad committed
795
796
      char buffer[256];
      int cpuid;
797
798
      unsigned long long int ioWait, irq, softIrq, steal, guest;
      ioWait = irq = softIrq = steal = guest = 0;
Hisham Muhammad's avatar
Hisham Muhammad committed
799
800
801
      // Dependending on your kernel version,
      // 5, 7 or 8 of these fields will be set.
      // The rest will remain at zero.
802
      fgets(buffer, 255, file);
Hisham Muhammad's avatar
Hisham Muhammad committed
803
      if (i == 0)
804
         sscanf(buffer, "cpu  %llu %llu %llu %llu %llu %llu %llu %llu %llu", &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest);
Hisham Muhammad's avatar
Hisham Muhammad committed
805
      else {
806
         sscanf(buffer, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu %llu", &cpuid, &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest);
Hisham Muhammad's avatar
Hisham Muhammad committed
807
808
809
810
         assert(cpuid == i - 1);
      }
      // Fields existing on kernels >= 2.6
      // (and RHEL's patched kernel 2.4...)
811
      idlealltime = idletime + ioWait;
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
      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;
Hisham Muhammad's avatar
Hisham Muhammad committed
852
   }
Hisham Muhammad's avatar
Hisham Muhammad committed
853
   double period = (double)this->cpus[0].totalPeriod / cpus; fclose(file);
Hisham Muhammad's avatar
Hisham Muhammad committed
854
855

   // mark all process as "dirty"
856
857
   for (int i = 0; i < Vector_size(this->processes); i++) {
      Process* p = (Process*) Vector_get(this->processes, i);
Hisham Muhammad's avatar
Hisham Muhammad committed
858
859
860
861
      p->updated = false;
   }
   
   this->totalTasks = 0;
862
863
   this->userlandThreads = 0;
   this->kernelThreads = 0;
Hisham Muhammad's avatar
Hisham Muhammad committed
864
   this->runningTasks = 0;
865

866
   ProcessList_processEntries(this, PROCDIR, NULL, period);
Hisham Muhammad's avatar
Hisham Muhammad committed
867
868
   
   this->showingThreadNames = this->showThreadNames;
Hisham Muhammad's avatar
Hisham Muhammad committed
869
   
870
871
   for (int i = Vector_size(this->processes) - 1; i >= 0; i--) {
      Process* p = (Process*) Vector_get(this->processes, i);
Hisham Muhammad's avatar
Hisham Muhammad committed
872
873
874
875
876
877
878
      if (p->updated == false)
         ProcessList_remove(this, p);
      else
         p->updated = false;
   }

}
879
880
881
882
883
884
885
886
887
888
889
890
891
892

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;
}
893
894
895
896
897
898
899
900

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;
   }
}
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944

void ProcessList_rebuildPanel(ProcessList* this, bool flags, bool follow, bool userOnly, uid_t userId, bool filtering, const char* incFilter) {
   if (!flags) {
      follow = this->follow;
      userOnly = this->userOnly;
      userId = this->userId;
      filtering = this->filtering;
      incFilter = this->incFilter;
   } else {
      this->follow = follow;
      this->userOnly = userOnly;
      this->userId = userId;
      this->filtering = filtering;
      this->incFilter = incFilter;
   }

   int currPos = Panel_getSelectedIndex(this->panel);
   pid_t currPid = 0;
   int currScrollV = this->panel->scrollV;
   if (follow)
      currPid = ProcessList_get(this, currPos)->pid;

   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))
         || (filtering && !(String_contains_i(p->comm, incFilter))) )
         hidden = true;

      if (!hidden) {
         Panel_set(this->panel, idx, (Object*)p);
         if ((!follow && idx == currPos) || (follow && p->pid == currPid)) {
            Panel_setSelected(this->panel, idx);
            this->panel->scrollV = currScrollV;
         }
         idx++;
      }
   }
}