2006-03-04 18:16:49 +00:00
|
|
|
/*
|
|
|
|
htop - htop.c
|
2011-05-26 16:32:50 +00:00
|
|
|
(C) 2004-2011 Hisham H. Muhammad
|
2006-03-04 18:16:49 +00:00
|
|
|
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
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
#include "CRT.h"
|
2006-05-30 13:47:28 +00:00
|
|
|
#include "Panel.h"
|
2006-03-04 18:16:49 +00:00
|
|
|
#include "UsersTable.h"
|
|
|
|
#include "RichString.h"
|
|
|
|
#include "Settings.h"
|
|
|
|
#include "ScreenManager.h"
|
|
|
|
#include "FunctionBar.h"
|
|
|
|
#include "ListItem.h"
|
2011-12-26 21:35:57 +00:00
|
|
|
#include "String.h"
|
|
|
|
#include "ColumnsPanel.h"
|
2006-05-30 13:47:28 +00:00
|
|
|
#include "CategoriesPanel.h"
|
|
|
|
#include "SignalsPanel.h"
|
2006-03-04 18:16:49 +00:00
|
|
|
#include "TraceScreen.h"
|
2009-06-02 04:51:23 +00:00
|
|
|
#include "OpenFilesScreen.h"
|
2007-11-08 23:23:01 +00:00
|
|
|
#include "AffinityPanel.h"
|
2014-11-24 20:55:03 +00:00
|
|
|
#include "Platform.h"
|
2012-11-10 00:31:37 +00:00
|
|
|
#include "IncSet.h"
|
2014-11-24 20:55:03 +00:00
|
|
|
#include "Action.h"
|
2014-11-20 01:17:52 +00:00
|
|
|
#include "htop.h"
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2011-12-26 21:35:57 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <locale.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
#include <pwd.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/time.h>
|
2014-04-22 21:19:24 +00:00
|
|
|
#include <time.h>
|
2011-12-26 21:35:57 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
//#link m
|
|
|
|
|
2015-03-21 19:52:54 +00:00
|
|
|
#define COPYRIGHT "(C) 2004-2015 Hisham Muhammad"
|
2014-11-20 01:17:52 +00:00
|
|
|
|
2008-03-09 08:58:38 +00:00
|
|
|
static void printVersionFlag() {
|
2010-02-25 02:04:24 +00:00
|
|
|
fputs("htop " VERSION " - " COPYRIGHT "\n"
|
|
|
|
"Released under the GNU GPL.\n\n",
|
|
|
|
stdout);
|
2006-03-04 18:16:49 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2014-04-09 21:02:50 +00:00
|
|
|
static const char* defaultFunctions[] = {"Help ", "Setup ", "Search", "Filter", "Tree ", "SortBy", "Nice -", "Nice +", "Kill ", "Quit ", NULL};
|
|
|
|
|
2008-03-09 08:58:38 +00:00
|
|
|
static void printHelpFlag() {
|
2010-02-25 02:04:24 +00:00
|
|
|
fputs("htop " VERSION " - " COPYRIGHT "\n"
|
|
|
|
"Released under the GNU GPL.\n\n"
|
2012-08-10 21:54:41 +00:00
|
|
|
"-C --no-color Use a monochrome color scheme\n"
|
|
|
|
"-d --delay=DELAY Set the delay between updates, in tenths of seconds\n"
|
|
|
|
"-h --help Print this help screen\n"
|
|
|
|
"-s --sort-key=COLUMN Sort by COLUMN (try --sort-key=help for a list)\n"
|
|
|
|
"-u --user=USERNAME Show only processes of a given user\n"
|
|
|
|
"-p --pid=PID,[,PID,PID...] Show only the given PIDs\n"
|
2010-02-25 02:04:24 +00:00
|
|
|
"-v --version Print version info\n"
|
|
|
|
"\n"
|
|
|
|
"Long options may be passed with a single dash.\n\n"
|
|
|
|
"Press F1 inside htop for online help.\n"
|
|
|
|
"See 'man htop' for more information.\n",
|
|
|
|
stdout);
|
2006-03-04 18:16:49 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2014-01-14 02:24:12 +00:00
|
|
|
static struct { const char* key; const char* info; } helpLeft[] = {
|
|
|
|
{ .key = " Arrows: ", .info = "scroll process list" },
|
|
|
|
{ .key = " Digits: ", .info = "incremental PID search" },
|
|
|
|
{ .key = " F3 /: ", .info = "incremental name search" },
|
|
|
|
{ .key = " F4 \\: ",.info = "incremental name filtering" },
|
|
|
|
{ .key = " F5 t: ", .info = "tree view" },
|
|
|
|
{ .key = " u: ", .info = "show processes of a single user" },
|
|
|
|
{ .key = " H: ", .info = "hide/show user threads" },
|
|
|
|
{ .key = " K: ", .info = "hide/show kernel threads" },
|
|
|
|
{ .key = " F: ", .info = "cursor follows process" },
|
2014-04-09 21:02:50 +00:00
|
|
|
{ .key = " F6 + -: ", .info = "expand/collapse tree" },
|
2014-01-14 02:24:12 +00:00
|
|
|
{ .key = " P M T: ", .info = "sort by CPU%, MEM% or TIME" },
|
|
|
|
{ .key = " I: ", .info = "invert sort order" },
|
|
|
|
{ .key = " F6 >: ", .info = "select sort column" },
|
|
|
|
{ .key = NULL, .info = NULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct { const char* key; const char* info; } helpRight[] = {
|
|
|
|
{ .key = " Space: ", .info = "tag process" },
|
|
|
|
{ .key = " c: ", .info = "tag process and its children" },
|
|
|
|
{ .key = " U: ", .info = "untag all processes" },
|
|
|
|
{ .key = " F9 k: ", .info = "kill process/tagged processes" },
|
|
|
|
{ .key = " F7 ]: ", .info = "higher priority (root only)" },
|
|
|
|
{ .key = " F8 [: ", .info = "lower priority (+ nice)" },
|
|
|
|
#if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY)
|
|
|
|
{ .key = " a: ", .info = "set CPU affinity" },
|
|
|
|
#endif
|
|
|
|
{ .key = " i: ", .info = "set IO prority" },
|
|
|
|
{ .key = " l: ", .info = "list open files with lsof" },
|
|
|
|
{ .key = " s: ", .info = "trace syscalls with strace" },
|
|
|
|
{ .key = " ", .info = "" },
|
|
|
|
{ .key = " F2 S: ", .info = "setup" },
|
|
|
|
{ .key = " F1 h: ", .info = "show this help screen" },
|
|
|
|
{ .key = " F10 q: ", .info = "quit" },
|
|
|
|
{ .key = NULL, .info = NULL }
|
|
|
|
};
|
|
|
|
|
2008-03-09 08:58:38 +00:00
|
|
|
static void showHelp(ProcessList* pl) {
|
2006-03-04 18:16:49 +00:00
|
|
|
clear();
|
|
|
|
attrset(CRT_colors[HELP_BOLD]);
|
2008-03-08 23:30:35 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < LINES-1; i++)
|
|
|
|
mvhline(i, 0, ' ', COLS);
|
|
|
|
|
2010-02-25 02:04:24 +00:00
|
|
|
mvaddstr(0, 0, "htop " VERSION " - " COPYRIGHT);
|
2006-03-04 18:16:49 +00:00
|
|
|
mvaddstr(1, 0, "Released under the GNU GPL. See 'man' page for more info.");
|
|
|
|
|
|
|
|
attrset(CRT_colors[DEFAULT_COLOR]);
|
|
|
|
mvaddstr(3, 0, "CPU usage bar: ");
|
|
|
|
#define addattrstr(a,s) attrset(a);addstr(s)
|
|
|
|
addattrstr(CRT_colors[BAR_BORDER], "[");
|
2007-11-09 00:40:59 +00:00
|
|
|
if (pl->detailedCPUTime) {
|
2014-04-24 16:15:52 +00:00
|
|
|
addattrstr(CRT_colors[CPU_NICE_TEXT], "low"); addstr("/");
|
2006-10-04 14:21:27 +00:00
|
|
|
addattrstr(CRT_colors[CPU_NORMAL], "normal"); addstr("/");
|
|
|
|
addattrstr(CRT_colors[CPU_KERNEL], "kernel"); addstr("/");
|
|
|
|
addattrstr(CRT_colors[CPU_IRQ], "irq"); addstr("/");
|
2007-11-09 00:40:59 +00:00
|
|
|
addattrstr(CRT_colors[CPU_SOFTIRQ], "soft-irq"); addstr("/");
|
2010-08-24 23:20:38 +00:00
|
|
|
addattrstr(CRT_colors[CPU_STEAL], "steal"); addstr("/");
|
2013-12-18 02:58:34 +00:00
|
|
|
addattrstr(CRT_colors[CPU_GUEST], "guest"); addstr("/");
|
|
|
|
addattrstr(CRT_colors[CPU_IOWAIT], "io-wait");
|
2006-10-04 14:21:27 +00:00
|
|
|
addattrstr(CRT_colors[BAR_SHADOW], " used%");
|
|
|
|
} else {
|
2014-04-24 16:15:52 +00:00
|
|
|
addattrstr(CRT_colors[CPU_NICE_TEXT], "low-priority"); addstr("/");
|
2006-10-04 14:21:27 +00:00
|
|
|
addattrstr(CRT_colors[CPU_NORMAL], "normal"); addstr("/");
|
2010-08-24 23:20:38 +00:00
|
|
|
addattrstr(CRT_colors[CPU_KERNEL], "kernel"); addstr("/");
|
|
|
|
addattrstr(CRT_colors[CPU_STEAL], "virtualiz");
|
|
|
|
addattrstr(CRT_colors[BAR_SHADOW], " used%");
|
2006-10-04 14:21:27 +00:00
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
addattrstr(CRT_colors[BAR_BORDER], "]");
|
|
|
|
attrset(CRT_colors[DEFAULT_COLOR]);
|
|
|
|
mvaddstr(4, 0, "Memory bar: ");
|
|
|
|
addattrstr(CRT_colors[BAR_BORDER], "[");
|
|
|
|
addattrstr(CRT_colors[MEMORY_USED], "used"); addstr("/");
|
2014-04-24 16:15:52 +00:00
|
|
|
addattrstr(CRT_colors[MEMORY_BUFFERS_TEXT], "buffers"); addstr("/");
|
2006-03-04 18:16:49 +00:00
|
|
|
addattrstr(CRT_colors[MEMORY_CACHE], "cache");
|
2010-08-24 23:20:38 +00:00
|
|
|
addattrstr(CRT_colors[BAR_SHADOW], " used/total");
|
2006-03-04 18:16:49 +00:00
|
|
|
addattrstr(CRT_colors[BAR_BORDER], "]");
|
|
|
|
attrset(CRT_colors[DEFAULT_COLOR]);
|
|
|
|
mvaddstr(5, 0, "Swap bar: ");
|
|
|
|
addattrstr(CRT_colors[BAR_BORDER], "[");
|
|
|
|
addattrstr(CRT_colors[SWAP], "used");
|
2010-08-24 23:20:38 +00:00
|
|
|
addattrstr(CRT_colors[BAR_SHADOW], " used/total");
|
2006-03-04 18:16:49 +00:00
|
|
|
addattrstr(CRT_colors[BAR_BORDER], "]");
|
|
|
|
attrset(CRT_colors[DEFAULT_COLOR]);
|
2006-10-04 14:21:27 +00:00
|
|
|
mvaddstr(6,0, "Type and layout of header meters are configurable in the setup screen.");
|
2009-02-18 00:34:18 +00:00
|
|
|
if (CRT_colorScheme == COLORSCHEME_MONOCHROME) {
|
|
|
|
mvaddstr(7, 0, "In monochrome, meters are displayed through different chars, in order: |#*@$%&");
|
|
|
|
}
|
|
|
|
mvaddstr( 8, 0, " Status: R: running; S: sleeping; T: traced/stopped; Z: zombie; D: disk sleep");
|
2014-01-14 02:24:12 +00:00
|
|
|
for (int i = 0; helpLeft[i].info; i++) { mvaddstr(9+i, 9, helpLeft[i].info); }
|
|
|
|
for (int i = 0; helpRight[i].info; i++) { mvaddstr(9+i, 49, helpRight[i].info); }
|
2006-03-04 18:16:49 +00:00
|
|
|
attrset(CRT_colors[HELP_BOLD]);
|
2014-01-14 02:24:12 +00:00
|
|
|
for (int i = 0; helpLeft[i].key; i++) { mvaddstr(9+i, 0, helpLeft[i].key); }
|
|
|
|
for (int i = 0; helpRight[i].key; i++) { mvaddstr(9+i, 40, helpRight[i].key); }
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
attrset(CRT_colors[HELP_BOLD]);
|
|
|
|
mvaddstr(23,0, "Press any key to return.");
|
|
|
|
attrset(CRT_colors[DEFAULT_COLOR]);
|
|
|
|
refresh();
|
|
|
|
CRT_readKey();
|
|
|
|
clear();
|
|
|
|
}
|
|
|
|
|
2010-02-25 01:43:18 +00:00
|
|
|
static const char* CategoriesFunctions[] = {" ", " ", " ", " ", " ", " ", " ", " ", " ", "Done ", NULL};
|
2008-04-23 07:24:27 +00:00
|
|
|
|
2011-03-22 20:37:08 +00:00
|
|
|
static void Setup_run(Settings* settings, const Header* header) {
|
|
|
|
ScreenManager* scr = ScreenManager_new(0, header->height, 0, -1, HORIZONTAL, header, true);
|
2006-05-30 14:00:18 +00:00
|
|
|
CategoriesPanel* panelCategories = CategoriesPanel_new(settings, scr);
|
2009-06-02 04:51:23 +00:00
|
|
|
ScreenManager_add(scr, (Panel*) panelCategories, FunctionBar_new(CategoriesFunctions, NULL, NULL), 16);
|
2006-05-30 14:00:18 +00:00
|
|
|
CategoriesPanel_makeMetersPage(panelCategories);
|
|
|
|
Panel* panelFocus;
|
2006-03-04 18:16:49 +00:00
|
|
|
int ch;
|
2006-05-30 14:00:18 +00:00
|
|
|
ScreenManager_run(scr, &panelFocus, &ch);
|
2006-03-04 18:16:49 +00:00
|
|
|
ScreenManager_delete(scr);
|
|
|
|
}
|
|
|
|
|
2012-10-04 23:59:45 +00:00
|
|
|
static bool changePriority(Panel* panel, int delta) {
|
|
|
|
bool anyTagged;
|
2014-11-24 20:55:03 +00:00
|
|
|
bool ok = Action_foreachProcess(panel, (Action_ForeachProcessFn) Process_changePriorityBy, delta, &anyTagged);
|
2007-12-17 05:57:28 +00:00
|
|
|
if (!ok)
|
|
|
|
beep();
|
2006-03-04 18:16:49 +00:00
|
|
|
return anyTagged;
|
|
|
|
}
|
|
|
|
|
2009-06-02 04:51:23 +00:00
|
|
|
static void addUserToVector(int key, void* userCast, void* panelCast) {
|
2006-03-04 18:16:49 +00:00
|
|
|
char* user = (char*) userCast;
|
2006-05-30 14:00:18 +00:00
|
|
|
Panel* panel = (Panel*) panelCast;
|
|
|
|
Panel_add(panel, (Object*) ListItem_new(user, key));
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
2011-08-26 21:04:26 +00:00
|
|
|
static bool setUserOnly(const char* userName, bool* userOnly, uid_t* userId) {
|
2006-03-04 18:16:49 +00:00
|
|
|
struct passwd* user = getpwnam(userName);
|
|
|
|
if (user) {
|
|
|
|
*userOnly = true;
|
|
|
|
*userId = user->pw_uid;
|
2011-08-26 21:04:26 +00:00
|
|
|
return true;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2011-08-26 21:04:26 +00:00
|
|
|
return false;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
|
2012-11-10 00:31:37 +00:00
|
|
|
static const char* getMainPanelValue(Panel* panel, int i) {
|
|
|
|
Process* p = (Process*) Panel_get(panel, i);
|
|
|
|
if (p)
|
|
|
|
return p->comm;
|
|
|
|
return "";
|
2011-09-08 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
2014-01-14 02:22:52 +00:00
|
|
|
static void tagAllChildren(Panel* panel, Process* parent) {
|
|
|
|
parent->tag = true;
|
|
|
|
pid_t ppid = parent->pid;
|
|
|
|
for (int i = 0; i < Panel_size(panel); i++) {
|
|
|
|
Process* p = (Process*) Panel_get(panel, i);
|
|
|
|
if (!p->tag && p->ppid == ppid) {
|
|
|
|
tagAllChildren(panel, p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-09 21:02:50 +00:00
|
|
|
static bool expandCollapse(Panel* panel) {
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (!p) return false;
|
|
|
|
p->showChildren = !p->showChildren;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
static inline Htop_Reaction setSortKey(ProcessList* pl, ProcessField sortKey) {
|
|
|
|
pl->sortKey = sortKey;
|
|
|
|
pl->direction = 1;
|
|
|
|
pl->treeView = false;
|
|
|
|
return HTOP_REFRESH | HTOP_SAVE_SETTINGS | HTOP_UPDATE_PANELHDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction sortBy(Panel* panel, ProcessList* pl, Header* header) {
|
|
|
|
Htop_Reaction reaction = HTOP_OK;
|
2014-04-09 21:02:50 +00:00
|
|
|
Panel* sortPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem));
|
|
|
|
Panel_setHeader(sortPanel, "Sort by");
|
|
|
|
const char* fuFunctions[] = {"Sort ", "Cancel ", NULL};
|
|
|
|
ProcessField* fields = pl->fields;
|
|
|
|
for (int i = 0; fields[i]; i++) {
|
|
|
|
char* name = String_trim(Process_fieldNames[fields[i]]);
|
|
|
|
Panel_add(sortPanel, (Object*) ListItem_new(name, fields[i]));
|
|
|
|
if (fields[i] == pl->sortKey)
|
|
|
|
Panel_setSelected(sortPanel, i);
|
|
|
|
free(name);
|
|
|
|
}
|
2014-11-24 21:22:50 +00:00
|
|
|
ListItem* field = (ListItem*) Action_pickFromVector(panel, sortPanel, 15, fuFunctions, header);
|
2014-04-09 21:02:50 +00:00
|
|
|
if (field) {
|
2014-11-20 01:17:52 +00:00
|
|
|
reaction |= setSortKey(pl, field->key);
|
2014-04-09 21:02:50 +00:00
|
|
|
}
|
|
|
|
Object_delete(sortPanel);
|
2014-11-20 01:17:52 +00:00
|
|
|
return reaction | HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
|
2014-04-09 21:02:50 +00:00
|
|
|
}
|
|
|
|
|
2014-04-22 21:19:24 +00:00
|
|
|
static void millisleep(unsigned long millisec) {
|
2014-04-21 22:37:57 +00:00
|
|
|
struct timespec req = {
|
|
|
|
.tv_sec = 0,
|
|
|
|
.tv_nsec = millisec * 1000000L
|
|
|
|
};
|
|
|
|
while(nanosleep(&req,&req)==-1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
// ----------------------------------------
|
|
|
|
|
|
|
|
static Htop_Reaction actionResize(Panel* panel) {
|
|
|
|
Panel_resize(panel, COLS, LINES-(panel->y)-1);
|
|
|
|
return HTOP_REDRAW_BAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionSortByMemory(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
return setSortKey(pl, PERCENT_MEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionSortByCPU(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
return setSortKey(pl, PERCENT_CPU);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionSortByTime(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
return setSortKey(pl, TIME);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionToggleKernelThreads(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
pl->hideKernelThreads = !pl->hideKernelThreads;
|
|
|
|
return HTOP_RECALCULATE | HTOP_SAVE_SETTINGS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionToggleUserlandThreads(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
pl->hideUserlandThreads = !pl->hideUserlandThreads;
|
|
|
|
pl->hideThreads = pl->hideUserlandThreads;
|
|
|
|
return HTOP_RECALCULATE | HTOP_SAVE_SETTINGS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionToggleTreeView(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
pl->treeView = !pl->treeView;
|
|
|
|
if (pl->treeView) pl->direction = 1;
|
|
|
|
ProcessList_expandTree(pl);
|
|
|
|
return HTOP_REFRESH | HTOP_SAVE_SETTINGS | HTOP_KEEP_FOLLOWING | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionIncFilter(Panel* panel, ProcessList* pl, Header* header, State* state) {
|
|
|
|
(void) panel, (void) pl, (void) header;
|
|
|
|
IncSet_activate(state->inc, INC_FILTER);
|
|
|
|
return HTOP_REFRESH | HTOP_KEEP_FOLLOWING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionIncSearch(Panel* panel, ProcessList* pl, Header* header, State* state) {
|
|
|
|
(void) panel, (void) pl, (void) header;
|
|
|
|
IncSet_activate(state->inc, INC_SEARCH);
|
|
|
|
return HTOP_REFRESH | HTOP_KEEP_FOLLOWING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionHigherPriority(Panel* panel) {
|
|
|
|
bool changed = changePriority(panel, -1);
|
|
|
|
return changed ? HTOP_REFRESH : HTOP_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionLowerPriority(Panel* panel) {
|
|
|
|
bool changed = changePriority(panel, 1);
|
|
|
|
return changed ? HTOP_REFRESH : HTOP_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionInvertSortOrder(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
ProcessList_invertSortOrder(pl);
|
|
|
|
return HTOP_REFRESH | HTOP_SAVE_SETTINGS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionSetSortColumn(Panel* panel, ProcessList* pl, Header* header) {
|
|
|
|
return sortBy(panel, pl, header);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionExpandOrCollapse(Panel* panel) {
|
|
|
|
bool changed = expandCollapse(panel);
|
|
|
|
return changed ? HTOP_RECALCULATE : HTOP_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionExpandCollapseOrSortColumn(Panel* panel, ProcessList* pl, Header* header) {
|
|
|
|
return pl->treeView ? actionExpandOrCollapse(panel) : actionSetSortColumn(panel, pl, header);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionQuit() {
|
|
|
|
return HTOP_QUIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionSetAffinity(Panel* panel, ProcessList* pl, Header* header) {
|
|
|
|
if (pl->cpuCount == 1)
|
|
|
|
return HTOP_OK;
|
|
|
|
#if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY)
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (!p) return HTOP_OK;
|
|
|
|
Affinity* affinity = Process_getAffinity(p);
|
|
|
|
if (!affinity) return HTOP_OK;
|
|
|
|
Panel* affinityPanel = AffinityPanel_new(pl, affinity);
|
|
|
|
Affinity_delete(affinity);
|
|
|
|
|
|
|
|
const char* fuFunctions[] = {"Set ", "Cancel ", NULL};
|
2014-11-24 21:22:50 +00:00
|
|
|
void* set = Action_pickFromVector(panel, affinityPanel, 15, fuFunctions, header);
|
2014-11-20 01:17:52 +00:00
|
|
|
if (set) {
|
|
|
|
Affinity* affinity = AffinityPanel_getAffinity(affinityPanel);
|
2014-11-24 20:55:03 +00:00
|
|
|
bool ok = Action_foreachProcess(panel, (Action_ForeachProcessFn) Process_setAffinity, (size_t) affinity, NULL);
|
2014-11-20 01:17:52 +00:00
|
|
|
if (!ok) beep();
|
|
|
|
Affinity_delete(affinity);
|
|
|
|
}
|
|
|
|
Panel_delete((Object*)affinityPanel);
|
2014-11-24 20:55:03 +00:00
|
|
|
#else
|
|
|
|
(void) panel;
|
|
|
|
(void) header;
|
2014-11-20 01:17:52 +00:00
|
|
|
#endif
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionKill(Panel* panel, ProcessList* pl, Header* header) {
|
|
|
|
(void) pl;
|
|
|
|
Panel* signalsPanel = (Panel*) SignalsPanel_new();
|
|
|
|
const char* fuFunctions[] = {"Send ", "Cancel ", NULL};
|
2014-11-24 21:22:50 +00:00
|
|
|
ListItem* sgn = (ListItem*) Action_pickFromVector(panel, signalsPanel, 15, fuFunctions, header);
|
2014-11-20 01:17:52 +00:00
|
|
|
if (sgn) {
|
|
|
|
if (sgn->key != 0) {
|
|
|
|
Panel_setHeader(panel, "Sending...");
|
|
|
|
Panel_draw(panel, true);
|
|
|
|
refresh();
|
2014-11-24 20:55:03 +00:00
|
|
|
Action_foreachProcess(panel, (Action_ForeachProcessFn) Process_sendSignal, (size_t) sgn->key, NULL);
|
2014-11-20 01:17:52 +00:00
|
|
|
napms(500);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Panel_delete((Object*)signalsPanel);
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionFilterByUser(Panel* panel, ProcessList* pl, Header* header, State* state) {
|
|
|
|
Panel* usersPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem));
|
|
|
|
Panel_setHeader(usersPanel, "Show processes of:");
|
|
|
|
UsersTable_foreach(state->ut, addUserToVector, usersPanel);
|
|
|
|
Vector_insertionSort(usersPanel->items);
|
|
|
|
ListItem* allUsers = ListItem_new("All users", -1);
|
|
|
|
Panel_insert(usersPanel, 0, (Object*) allUsers);
|
|
|
|
const char* fuFunctions[] = {"Show ", "Cancel ", NULL};
|
2014-11-24 21:22:50 +00:00
|
|
|
ListItem* picked = (ListItem*) Action_pickFromVector(panel, usersPanel, 20, fuFunctions, header);
|
2014-11-20 01:17:52 +00:00
|
|
|
if (picked) {
|
|
|
|
if (picked == allUsers) {
|
|
|
|
pl->userOnly = false;
|
|
|
|
} else {
|
|
|
|
setUserOnly(ListItem_getRef(picked), &(pl->userOnly), &(pl->userId));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Panel_delete((Object*)usersPanel);
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionFollow() {
|
|
|
|
return HTOP_KEEP_FOLLOWING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionSetup(Panel* panel, ProcessList* pl, Header* header, State* state) {
|
|
|
|
(void) pl;
|
|
|
|
Setup_run(state->settings, header);
|
|
|
|
// TODO: shouldn't need this, colors should be dynamic
|
|
|
|
int headerHeight = Header_calculateHeight(header);
|
|
|
|
Panel_move(panel, 0, headerHeight);
|
|
|
|
Panel_resize(panel, COLS, LINES-headerHeight-1);
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR | HTOP_UPDATE_PANELHDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionLsof(Panel* panel) {
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (!p) return HTOP_OK;
|
|
|
|
OpenFilesScreen* ts = OpenFilesScreen_new(p);
|
|
|
|
OpenFilesScreen_run(ts);
|
|
|
|
OpenFilesScreen_delete(ts);
|
|
|
|
clear();
|
|
|
|
CRT_enableDelay();
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionStrace(Panel* panel) {
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (!p) return HTOP_OK;
|
|
|
|
TraceScreen* ts = TraceScreen_new(p);
|
|
|
|
TraceScreen_run(ts);
|
|
|
|
TraceScreen_delete(ts);
|
|
|
|
clear();
|
|
|
|
CRT_enableDelay();
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionTag(Panel* panel) {
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (!p) return HTOP_OK;
|
|
|
|
Process_toggleTag(p);
|
|
|
|
Panel_onKey(panel, KEY_DOWN);
|
|
|
|
return HTOP_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionRedraw() {
|
|
|
|
clear();
|
|
|
|
return HTOP_REFRESH | HTOP_REDRAW_BAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionHelp(Panel* panel, ProcessList* pl) {
|
|
|
|
(void) panel;
|
|
|
|
showHelp(pl);
|
|
|
|
return HTOP_RECALCULATE | HTOP_REDRAW_BAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionUntagAll(Panel* panel) {
|
|
|
|
for (int i = 0; i < Panel_size(panel); i++) {
|
|
|
|
Process* p = (Process*) Panel_get(panel, i);
|
|
|
|
p->tag = false;
|
|
|
|
}
|
|
|
|
return HTOP_REFRESH;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Htop_Reaction actionTagAllChildren(Panel* panel) {
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (!p) return HTOP_OK;
|
|
|
|
tagAllChildren(panel, p);
|
|
|
|
return HTOP_OK;
|
|
|
|
}
|
|
|
|
|
2014-11-24 20:55:03 +00:00
|
|
|
static void setBindings(Htop_Action* keys) {
|
2014-11-20 01:17:52 +00:00
|
|
|
keys[KEY_RESIZE] = actionResize;
|
|
|
|
keys['M'] = actionSortByMemory;
|
|
|
|
keys['T'] = actionSortByTime;
|
|
|
|
keys['P'] = actionSortByCPU;
|
|
|
|
keys['H'] = actionToggleUserlandThreads;
|
|
|
|
keys['K'] = actionToggleKernelThreads;
|
|
|
|
keys['t'] = actionToggleTreeView;
|
|
|
|
keys[KEY_F(5)] = actionToggleTreeView;
|
|
|
|
keys[KEY_F(4)] = actionIncFilter;
|
|
|
|
keys['\\'] = actionIncFilter;
|
|
|
|
keys[KEY_F(3)] = actionIncSearch;
|
|
|
|
keys['/'] = actionIncSearch;
|
|
|
|
|
|
|
|
keys[']'] = actionHigherPriority;
|
|
|
|
keys[KEY_F(7)] = actionHigherPriority;
|
|
|
|
keys['['] = actionLowerPriority;
|
|
|
|
keys[KEY_F(8)] = actionLowerPriority;
|
|
|
|
keys['I'] = actionInvertSortOrder;
|
|
|
|
keys[KEY_F(6)] = actionExpandCollapseOrSortColumn;
|
|
|
|
keys[KEY_F(18)] = actionExpandCollapseOrSortColumn;
|
|
|
|
keys['<'] = actionSetSortColumn;
|
|
|
|
keys[','] = actionSetSortColumn;
|
|
|
|
keys['>'] = actionSetSortColumn;
|
|
|
|
keys['.'] = actionSetSortColumn;
|
|
|
|
keys[KEY_F(10)] = actionQuit;
|
|
|
|
keys['q'] = actionQuit;
|
|
|
|
keys['a'] = actionSetAffinity;
|
|
|
|
keys[KEY_F(9)] = actionKill;
|
|
|
|
keys['k'] = actionKill;
|
|
|
|
keys['+'] = actionExpandOrCollapse;
|
|
|
|
keys['='] = actionExpandOrCollapse;
|
|
|
|
keys['-'] = actionExpandOrCollapse;
|
|
|
|
keys['u'] = actionFilterByUser;
|
|
|
|
keys['F'] = actionFollow;
|
|
|
|
keys['S'] = actionSetup;
|
|
|
|
keys['C'] = actionSetup;
|
|
|
|
keys[KEY_F(2)] = actionSetup;
|
|
|
|
keys['l'] = actionLsof;
|
|
|
|
keys['s'] = actionStrace;
|
|
|
|
keys[' '] = actionTag;
|
|
|
|
keys['\014'] = actionRedraw; // Ctrl+L
|
|
|
|
keys[KEY_F(1)] = actionHelp;
|
|
|
|
keys['h'] = actionHelp;
|
|
|
|
keys['?'] = actionHelp;
|
|
|
|
keys['U'] = actionUntagAll;
|
|
|
|
keys['c'] = actionTagAllChildren;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ----------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
static void updateTreeFunctions(FunctionBar* fuBar, bool mode) {
|
|
|
|
if (mode) {
|
|
|
|
FunctionBar_setLabel(fuBar, KEY_F(5), "Sorted");
|
|
|
|
FunctionBar_setLabel(fuBar, KEY_F(6), "Collap");
|
|
|
|
} else {
|
|
|
|
FunctionBar_setLabel(fuBar, KEY_F(5), "Tree ");
|
|
|
|
FunctionBar_setLabel(fuBar, KEY_F(6), "SortBy");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
int main(int argc, char** argv) {
|
|
|
|
|
|
|
|
int delay = -1;
|
|
|
|
bool userOnly = false;
|
|
|
|
uid_t userId = 0;
|
2010-02-25 02:04:24 +00:00
|
|
|
int usecolors = 1;
|
2012-08-10 21:54:41 +00:00
|
|
|
char *argCopy;
|
|
|
|
char *pid;
|
|
|
|
Hashtable *pidWhiteList = NULL;
|
2010-02-25 02:04:24 +00:00
|
|
|
|
|
|
|
int opt, opti=0;
|
|
|
|
static struct option long_opts[] =
|
|
|
|
{
|
|
|
|
{"help", no_argument, 0, 'h'},
|
|
|
|
{"version", no_argument, 0, 'v'},
|
|
|
|
{"delay", required_argument, 0, 'd'},
|
|
|
|
{"sort-key", required_argument, 0, 's'},
|
|
|
|
{"user", required_argument, 0, 'u'},
|
|
|
|
{"no-color", no_argument, 0, 'C'},
|
|
|
|
{"no-colour",no_argument, 0, 'C'},
|
2012-08-10 21:54:41 +00:00
|
|
|
{"pid", required_argument, 0, 'p'},
|
2010-02-25 02:04:24 +00:00
|
|
|
{0,0,0,0}
|
|
|
|
};
|
2006-08-04 20:54:37 +00:00
|
|
|
int sortKey = 0;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2008-03-09 02:33:23 +00:00
|
|
|
char *lc_ctype = getenv("LC_CTYPE");
|
|
|
|
if(lc_ctype != NULL)
|
|
|
|
setlocale(LC_CTYPE, lc_ctype);
|
2011-11-03 22:12:12 +00:00
|
|
|
else if ((lc_ctype = getenv("LC_ALL")))
|
|
|
|
setlocale(LC_CTYPE, lc_ctype);
|
2008-03-09 02:33:23 +00:00
|
|
|
else
|
2011-11-03 22:12:12 +00:00
|
|
|
setlocale(LC_CTYPE, "");
|
2008-03-09 02:33:23 +00:00
|
|
|
|
2010-02-25 02:04:24 +00:00
|
|
|
/* Parse arguments */
|
2012-08-10 21:54:41 +00:00
|
|
|
while ((opt = getopt_long(argc, argv, "hvCs:d:u:p:", long_opts, &opti))) {
|
2010-02-25 02:04:24 +00:00
|
|
|
if (opt == EOF) break;
|
|
|
|
switch (opt) {
|
|
|
|
case 'h':
|
|
|
|
printHelpFlag();
|
|
|
|
break;
|
|
|
|
case 'v':
|
|
|
|
printVersionFlag();
|
|
|
|
break;
|
|
|
|
case 's':
|
2011-09-08 04:47:48 +00:00
|
|
|
if (strcmp(optarg, "help") == 0) {
|
2010-02-25 02:04:24 +00:00
|
|
|
for (int j = 1; j < LAST_PROCESSFIELD; j++)
|
|
|
|
printf ("%s\n", Process_fieldNames[j]);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
sortKey = ColumnsPanel_fieldNameToIndex(optarg);
|
|
|
|
if (sortKey == -1) {
|
|
|
|
fprintf(stderr, "Error: invalid column \"%s\".\n", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'd':
|
2014-04-21 22:16:16 +00:00
|
|
|
if (sscanf(optarg, "%16d", &delay) == 1) {
|
2011-08-26 21:04:26 +00:00
|
|
|
if (delay < 1) delay = 1;
|
|
|
|
if (delay > 100) delay = 100;
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "Error: invalid delay value \"%s\".\n", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-02-25 02:04:24 +00:00
|
|
|
break;
|
|
|
|
case 'u':
|
2011-08-26 21:04:26 +00:00
|
|
|
if (!setUserOnly(optarg, &userOnly, &userId)) {
|
|
|
|
fprintf(stderr, "Error: invalid user \"%s\".\n", optarg);
|
|
|
|
exit(1);
|
|
|
|
}
|
2010-02-25 02:04:24 +00:00
|
|
|
break;
|
|
|
|
case 'C':
|
|
|
|
usecolors=0;
|
2012-08-10 21:54:41 +00:00
|
|
|
break;
|
2014-04-21 22:16:16 +00:00
|
|
|
case 'p': {
|
2012-08-10 21:54:41 +00:00
|
|
|
argCopy = strdup(optarg);
|
2014-04-21 22:16:16 +00:00
|
|
|
char* saveptr;
|
|
|
|
pid = strtok_r(argCopy, ",", &saveptr);
|
2012-08-10 21:54:41 +00:00
|
|
|
|
|
|
|
if( !pidWhiteList ) {
|
|
|
|
pidWhiteList = Hashtable_new(8, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
while( pid ) {
|
|
|
|
unsigned int num_pid = atoi(pid);
|
|
|
|
Hashtable_put(pidWhiteList, num_pid, (void *) 1);
|
2014-04-21 22:16:16 +00:00
|
|
|
pid = strtok_r(NULL, ",", &saveptr);
|
2012-08-10 21:54:41 +00:00
|
|
|
}
|
|
|
|
free(argCopy);
|
|
|
|
|
2010-02-25 02:04:24 +00:00
|
|
|
break;
|
2014-04-21 22:16:16 +00:00
|
|
|
}
|
2011-08-26 21:04:26 +00:00
|
|
|
default:
|
|
|
|
exit(1);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
}
|
2010-02-25 02:04:24 +00:00
|
|
|
|
|
|
|
|
2006-03-13 17:29:18 +00:00
|
|
|
if (access(PROCDIR, R_OK) != 0) {
|
|
|
|
fprintf(stderr, "Error: could not read procfs (compiled to look in %s).\n", PROCDIR);
|
|
|
|
exit(1);
|
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2012-12-05 15:12:20 +00:00
|
|
|
#ifdef HAVE_LIBNCURSESW
|
|
|
|
char *locale = setlocale(LC_ALL, NULL);
|
|
|
|
if (locale == NULL || locale[0] == '\0')
|
|
|
|
locale = setlocale(LC_CTYPE, NULL);
|
|
|
|
if (locale != NULL &&
|
|
|
|
(strstr(locale, "UTF-8") ||
|
|
|
|
strstr(locale, "utf-8") ||
|
|
|
|
strstr(locale, "UTF8") ||
|
|
|
|
strstr(locale, "utf8")))
|
|
|
|
CRT_utf8 = true;
|
|
|
|
else
|
|
|
|
CRT_utf8 = false;
|
|
|
|
#endif
|
|
|
|
|
2014-11-24 20:55:03 +00:00
|
|
|
UsersTable* ut = UsersTable_new();
|
|
|
|
ProcessList* pl = ProcessList_new(ut, pidWhiteList);
|
2014-11-20 01:17:52 +00:00
|
|
|
pl->userOnly = userOnly;
|
|
|
|
pl->userId = userId;
|
2014-11-27 22:10:23 +00:00
|
|
|
Process_setupColumnWidths();
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
Header* header = Header_new(pl);
|
2014-11-24 20:55:03 +00:00
|
|
|
Settings* settings = Settings_new(pl, header, pl->cpuCount);
|
2006-03-04 18:16:49 +00:00
|
|
|
int headerHeight = Header_calculateHeight(header);
|
|
|
|
|
|
|
|
// FIXME: move delay code to settings
|
|
|
|
if (delay != -1)
|
|
|
|
settings->delay = delay;
|
2010-02-25 02:04:24 +00:00
|
|
|
if (!usecolors)
|
|
|
|
settings->colorScheme = COLORSCHEME_MONOCHROME;
|
2011-11-03 22:12:12 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
CRT_init(settings->delay, settings->colorScheme);
|
2011-12-01 12:31:57 +00:00
|
|
|
|
2012-12-05 15:12:20 +00:00
|
|
|
Panel* panel = Panel_new(0, headerHeight, COLS, LINES - headerHeight - 2, false, &Process_class);
|
2011-12-01 12:31:57 +00:00
|
|
|
ProcessList_setPanel(pl, panel);
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2014-04-09 21:02:50 +00:00
|
|
|
FunctionBar* defaultBar = FunctionBar_new(defaultFunctions, NULL, NULL);
|
2014-11-20 01:17:52 +00:00
|
|
|
updateTreeFunctions(defaultBar, pl->treeView);
|
2014-04-09 21:02:50 +00:00
|
|
|
|
2008-03-14 18:50:49 +00:00
|
|
|
if (sortKey > 0) {
|
|
|
|
pl->sortKey = sortKey;
|
2014-11-20 01:17:52 +00:00
|
|
|
pl->treeView = false;
|
2008-03-14 18:50:49 +00:00
|
|
|
pl->direction = 1;
|
|
|
|
}
|
2010-11-22 12:40:20 +00:00
|
|
|
ProcessList_printHeader(pl, Panel_getHeader(panel));
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2012-11-10 00:31:37 +00:00
|
|
|
IncSet* inc = IncSet_new(defaultBar);
|
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
ProcessList_scan(pl);
|
2014-04-21 22:37:57 +00:00
|
|
|
millisleep(75);
|
2014-06-04 19:45:55 +00:00
|
|
|
ProcessList_scan(pl);
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
FunctionBar_draw(defaultBar, NULL);
|
|
|
|
|
|
|
|
int acc = 0;
|
|
|
|
bool follow = false;
|
|
|
|
|
|
|
|
struct timeval tv;
|
|
|
|
double oldTime = 0.0;
|
|
|
|
|
2011-03-22 20:37:08 +00:00
|
|
|
int ch = ERR;
|
2006-03-04 18:16:49 +00:00
|
|
|
int closeTimeout = 0;
|
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
bool drawPanel = true;
|
2012-12-05 15:12:20 +00:00
|
|
|
|
2014-04-09 21:02:50 +00:00
|
|
|
bool collapsed = false;
|
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
Htop_Action keys[KEY_MAX] = { NULL };
|
|
|
|
setBindings(keys);
|
2014-11-24 20:55:03 +00:00
|
|
|
Platform_setBindings(keys);
|
2014-11-20 01:17:52 +00:00
|
|
|
|
|
|
|
State state = {
|
|
|
|
.inc = inc,
|
|
|
|
.settings = settings,
|
|
|
|
.ut = ut,
|
|
|
|
};
|
2014-11-24 20:55:03 +00:00
|
|
|
|
|
|
|
bool quit = false;
|
|
|
|
int sortTimeout = 0;
|
|
|
|
int resetSortTimeout = 5;
|
|
|
|
bool doRefresh = true;
|
|
|
|
bool forceRecalculate = false;
|
2014-11-20 01:17:52 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
while (!quit) {
|
|
|
|
gettimeofday(&tv, NULL);
|
2014-04-21 22:16:16 +00:00
|
|
|
double newTime = ((double)tv.tv_sec * 10) + ((double)tv.tv_usec / 100000);
|
2014-11-20 01:17:52 +00:00
|
|
|
bool timeToRecalculate = (newTime - oldTime > settings->delay);
|
|
|
|
if (newTime < oldTime) timeToRecalculate = true; // clock was adjusted?
|
2014-11-24 21:22:50 +00:00
|
|
|
int following = follow ? Action_selectedPid(panel) : -1;
|
2014-11-20 01:17:52 +00:00
|
|
|
if (timeToRecalculate) {
|
2012-12-05 15:12:20 +00:00
|
|
|
Header_draw(header);
|
2006-03-04 18:16:49 +00:00
|
|
|
oldTime = newTime;
|
2012-12-05 15:12:20 +00:00
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
if (doRefresh) {
|
2014-11-20 01:17:52 +00:00
|
|
|
if (timeToRecalculate || forceRecalculate) {
|
2006-03-04 18:16:49 +00:00
|
|
|
ProcessList_scan(pl);
|
2014-11-20 01:17:52 +00:00
|
|
|
forceRecalculate = false;
|
2009-02-17 18:13:25 +00:00
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
if (sortTimeout == 0 || pl->treeView) {
|
2006-03-04 18:16:49 +00:00
|
|
|
ProcessList_sort(pl);
|
2014-11-20 01:17:52 +00:00
|
|
|
sortTimeout = 1;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
ProcessList_rebuildPanel(pl, true, following, IncSet_filter(inc));
|
|
|
|
drawPanel = true;
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
doRefresh = true;
|
2014-04-09 21:02:50 +00:00
|
|
|
|
|
|
|
if (pl->treeView) {
|
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (p) {
|
|
|
|
if (!p->showChildren && !collapsed) {
|
|
|
|
FunctionBar_setLabel(defaultBar, KEY_F(6), "Expand");
|
|
|
|
FunctionBar_draw(defaultBar, NULL);
|
|
|
|
} else if (p->showChildren && collapsed) {
|
|
|
|
FunctionBar_setLabel(defaultBar, KEY_F(6), "Collap");
|
|
|
|
FunctionBar_draw(defaultBar, NULL);
|
|
|
|
}
|
|
|
|
collapsed = !p->showChildren;
|
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
} else {
|
|
|
|
collapsed = false;
|
2014-04-09 21:02:50 +00:00
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
if (drawPanel) {
|
2012-12-05 15:12:20 +00:00
|
|
|
Panel_draw(panel, true);
|
2014-04-09 21:02:50 +00:00
|
|
|
}
|
2012-12-05 15:12:20 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
int prev = ch;
|
2012-11-10 00:31:37 +00:00
|
|
|
if (inc->active)
|
2011-09-24 00:30:47 +00:00
|
|
|
move(LINES-1, CRT_cursorX);
|
2006-03-04 18:16:49 +00:00
|
|
|
ch = getch();
|
|
|
|
|
|
|
|
if (ch == ERR) {
|
2012-11-10 00:31:37 +00:00
|
|
|
if (!inc->active)
|
2014-11-20 01:17:52 +00:00
|
|
|
sortTimeout--;
|
|
|
|
if (prev == ch && !timeToRecalculate) {
|
2006-03-04 18:16:49 +00:00
|
|
|
closeTimeout++;
|
2011-03-28 19:06:06 +00:00
|
|
|
if (closeTimeout == 100) {
|
2006-03-04 18:16:49 +00:00
|
|
|
break;
|
2011-03-28 19:06:06 +00:00
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
} else
|
|
|
|
closeTimeout = 0;
|
2014-11-20 01:17:52 +00:00
|
|
|
drawPanel = false;
|
2006-03-04 18:16:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
drawPanel = true;
|
|
|
|
|
|
|
|
Htop_Reaction reaction = HTOP_OK;
|
2006-03-04 18:16:49 +00:00
|
|
|
|
|
|
|
if (ch == KEY_MOUSE) {
|
|
|
|
MEVENT mevent;
|
|
|
|
int ok = getmouse(&mevent);
|
|
|
|
if (ok == OK) {
|
2011-05-26 16:32:50 +00:00
|
|
|
if (mevent.bstate & BUTTON1_CLICKED) {
|
|
|
|
if (mevent.y == panel->y) {
|
|
|
|
int x = panel->scrollH + mevent.x + 1;
|
|
|
|
ProcessField field = ProcessList_keyAt(pl, x);
|
|
|
|
if (field == pl->sortKey) {
|
|
|
|
ProcessList_invertSortOrder(pl);
|
2014-11-20 01:17:52 +00:00
|
|
|
pl->treeView = false;
|
|
|
|
reaction |= HTOP_REDRAW_BAR;
|
2011-05-26 16:32:50 +00:00
|
|
|
} else {
|
2014-11-20 01:17:52 +00:00
|
|
|
reaction |= setSortKey(pl, field);
|
2011-05-26 16:32:50 +00:00
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
sortTimeout = 0;
|
|
|
|
ch = ERR;
|
2011-05-26 16:32:50 +00:00
|
|
|
} else if (mevent.y >= panel->y + 1 && mevent.y < LINES - 1) {
|
|
|
|
Panel_setSelected(panel, mevent.y - panel->y + panel->scrollV - 1);
|
|
|
|
follow = true;
|
2014-11-20 01:17:52 +00:00
|
|
|
ch = ERR;
|
2011-05-26 16:32:50 +00:00
|
|
|
} if (mevent.y == LINES - 1) {
|
2012-11-10 00:31:37 +00:00
|
|
|
ch = FunctionBar_synthesizeEvent(inc->bar, mevent.x);
|
2008-03-14 18:50:49 +00:00
|
|
|
}
|
2011-05-26 16:32:50 +00:00
|
|
|
} else if (mevent.bstate & BUTTON4_CLICKED) {
|
|
|
|
ch = KEY_UP;
|
|
|
|
#if NCURSES_MOUSE_VERSION > 1
|
|
|
|
} else if (mevent.bstate & BUTTON5_CLICKED) {
|
|
|
|
ch = KEY_DOWN;
|
|
|
|
#endif
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-10 00:31:37 +00:00
|
|
|
if (inc->active) {
|
|
|
|
doRefresh = IncSet_handleKey(inc, ch, panel, getMainPanelValue, NULL);
|
2014-04-25 19:05:25 +00:00
|
|
|
if (!inc->active) {
|
|
|
|
follow = true;
|
|
|
|
}
|
2012-11-10 00:31:37 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isdigit((char)ch)) {
|
|
|
|
if (Panel_size(panel) == 0) continue;
|
|
|
|
pid_t pid = ch-48 + acc;
|
2014-04-09 17:47:32 +00:00
|
|
|
for (int i = 0; i < ProcessList_size(pl); i++) {
|
2012-11-10 00:31:37 +00:00
|
|
|
Panel_setSelected(panel, i);
|
2014-04-09 17:47:32 +00:00
|
|
|
Process* p = (Process*) Panel_getSelected(panel);
|
|
|
|
if (p && p->pid == pid) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-11-10 00:31:37 +00:00
|
|
|
acc = pid * 10;
|
|
|
|
if (acc > 10000000)
|
|
|
|
acc = 0;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
acc = 0;
|
|
|
|
}
|
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
if(ch != ERR && keys[ch]) {
|
|
|
|
reaction |= (keys[ch])(panel, pl, header, &state);
|
|
|
|
} else {
|
|
|
|
doRefresh = false;
|
|
|
|
sortTimeout = resetSortTimeout;
|
|
|
|
Panel_onKey(panel, ch);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
|
|
|
|
// Reaction handlers:
|
2007-11-08 23:23:01 +00:00
|
|
|
|
2014-11-20 01:17:52 +00:00
|
|
|
if (reaction & HTOP_REDRAW_BAR) {
|
|
|
|
updateTreeFunctions(defaultBar, pl->treeView);
|
|
|
|
IncSet_drawBar(inc);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
if (reaction & HTOP_UPDATE_PANELHDR) {
|
2012-10-04 23:59:45 +00:00
|
|
|
ProcessList_printHeader(pl, Panel_getHeader(panel));
|
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
if (reaction & HTOP_REFRESH) {
|
2011-09-08 01:17:26 +00:00
|
|
|
doRefresh = true;
|
2014-11-20 01:17:52 +00:00
|
|
|
sortTimeout = 0;
|
|
|
|
}
|
|
|
|
if (reaction & HTOP_RECALCULATE) {
|
|
|
|
forceRecalculate = true;
|
|
|
|
sortTimeout = 0;
|
|
|
|
}
|
|
|
|
if (reaction & HTOP_SAVE_SETTINGS) {
|
2006-03-04 18:16:49 +00:00
|
|
|
settings->changed = true;
|
|
|
|
}
|
2014-11-20 01:17:52 +00:00
|
|
|
if (reaction & HTOP_QUIT) {
|
|
|
|
quit = true;
|
|
|
|
}
|
|
|
|
follow = (reaction & HTOP_KEEP_FOLLOWING);
|
2006-03-04 18:16:49 +00:00
|
|
|
}
|
|
|
|
attron(CRT_colors[RESET_COLOR]);
|
|
|
|
mvhline(LINES-1, 0, ' ', COLS);
|
|
|
|
attroff(CRT_colors[RESET_COLOR]);
|
|
|
|
refresh();
|
|
|
|
|
|
|
|
CRT_done();
|
|
|
|
if (settings->changed)
|
|
|
|
Settings_write(settings);
|
|
|
|
Header_delete(header);
|
|
|
|
ProcessList_delete(pl);
|
2014-11-20 01:17:52 +00:00
|
|
|
|
2006-03-04 18:16:49 +00:00
|
|
|
FunctionBar_delete((Object*)defaultBar);
|
2011-09-08 01:17:26 +00:00
|
|
|
Panel_delete((Object*)panel);
|
2014-11-20 01:17:52 +00:00
|
|
|
|
|
|
|
IncSet_delete(inc);
|
2006-03-04 18:16:49 +00:00
|
|
|
UsersTable_delete(ut);
|
|
|
|
Settings_delete(settings);
|
2014-11-20 01:17:52 +00:00
|
|
|
|
2012-08-10 21:54:41 +00:00
|
|
|
if(pidWhiteList) {
|
|
|
|
Hashtable_delete(pidWhiteList);
|
|
|
|
}
|
2006-03-04 18:16:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|