summaryrefslogtreecommitdiffstats
path: root/ksysguard/ksysguardd
diff options
context:
space:
mode:
Diffstat (limited to 'ksysguard/ksysguardd')
-rw-r--r--ksysguard/ksysguardd/OpenBSD/CMakeLists.txt2
-rw-r--r--ksysguard/ksysguardd/OpenBSD/ProcessList.c500
-rw-r--r--ksysguard/ksysguardd/OpenBSD/ProcessList.h38
-rw-r--r--ksysguard/ksysguardd/modules.h2
4 files changed, 541 insertions, 1 deletions
diff --git a/ksysguard/ksysguardd/OpenBSD/CMakeLists.txt b/ksysguard/ksysguardd/OpenBSD/CMakeLists.txt
index 9f856d3d1..f71d35579 100644
--- a/ksysguard/ksysguardd/OpenBSD/CMakeLists.txt
+++ b/ksysguard/ksysguardd/OpenBSD/CMakeLists.txt
@@ -21,5 +21,5 @@ include_directories(
tde_add_library( ksysguardd STATIC
SOURCES
- cpu.c memory.c
+ cpu.c memory.c ProcessList.c
)
diff --git a/ksysguard/ksysguardd/OpenBSD/ProcessList.c b/ksysguard/ksysguardd/OpenBSD/ProcessList.c
new file mode 100644
index 000000000..393212fc9
--- /dev/null
+++ b/ksysguard/ksysguardd/OpenBSD/ProcessList.c
@@ -0,0 +1,500 @@
+/*
+ KSysGuard, the KDE System Guard
+
+ Copyright (c) 1999-2000 Hans Petter Bieker<bieker@kde.org>
+ Copyright (c) 1999 Chris Schlaeger <cs@kde.org>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+#include <config.h>
+
+#include <ctype.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include "../../gui/SignalIDs.h"
+#include "Command.h"
+#include "ProcessList.h"
+#include "ccont.h"
+#include "ksysguardd.h"
+
+CONTAINER ProcessList = 0;
+
+#define BUFSIZE 1024
+
+typedef struct
+{
+ /* This flag is set for all found processes at the beginning of the
+ * process list update. Processes that do not have this flag set will
+ * be assumed dead and removed from the list. The flag is cleared after
+ * each list update. */
+ int alive;
+
+ /* the process ID */
+ pid_t pid;
+
+ /* the parent process ID */
+ pid_t ppid;
+
+ /* the real user ID */
+ uid_t uid;
+
+ /* the real group ID */
+ gid_t gid;
+
+ /* a character description of the process status */
+ char status[16];
+
+ /* the number of the tty the process owns */
+ int ttyNo;
+
+ /*
+ * The nice level. The range should be -20 to 20. I'm not sure
+ * whether this is true for all platforms.
+ */
+ int niceLevel;
+
+ /*
+ * The scheduling priority.
+ */
+ int priority;
+
+ /*
+ * The total amount of memory the process uses. This includes shared and
+ * swapped memory.
+ */
+ unsigned int vmSize;
+
+ /*
+ * The amount of physical memory the process currently uses.
+ */
+ unsigned int vmRss;
+
+ /*
+ * The amount of memory (shared/swapped/etc) the process shares with
+ * other processes.
+ */
+ unsigned int vmLib;
+
+ /*
+ * The number of 1/100 of a second the process has spend in user space.
+ * If a machine has an uptime of 1 1/2 years or longer this is not a
+ * good idea. I never thought that the stability of UNIX could get me
+ * into trouble! ;)
+ */
+ unsigned int userTime;
+
+ /*
+ * The number of 1/100 of a second the process has spend in system space.
+ * If a machine has an uptime of 1 1/2 years or longer this is not a
+ * good idea. I never thought that the stability of UNIX could get me
+ * into trouble! ;)
+ */
+ unsigned int sysTime;
+
+ /* system time as multime of 100ms */
+ int centStamp;
+
+ /* the current CPU load (in %) from user space */
+ double userLoad;
+
+ /* the current CPU load (in %) from system space */
+ double sysLoad;
+
+ /* the name of the process */
+ char name[64];
+
+ /* the command used to start the process */
+ char cmdline[256];
+
+ /* the login name of the user that owns this process */
+ char userName[32];
+} ProcessInfo;
+
+static unsigned ProcessCount;
+
+static int
+processCmp(void* p1, void* p2)
+{
+ return (((ProcessInfo*) p1)->pid - ((ProcessInfo*) p2)->pid);
+}
+
+static ProcessInfo*
+findProcessInList(int pid)
+{
+ ProcessInfo key;
+ long index;
+
+ key.pid = pid;
+ if ((index = search_ctnr(ProcessList, processCmp, &key)) < 0)
+ return (0);
+
+ return (get_ctnr(ProcessList, index));
+}
+
+static void
+fillProcessCmdline(char *cmdline, struct kinfo_proc *p, size_t maxlen)
+{
+ int mib[4];
+ int ret = -1;
+ static char *argbuf = NULL;
+ static size_t arglen = 0;
+
+ strlcpy(cmdline, p->p_comm, maxlen);
+
+ if (!argbuf) {
+ arglen = 1024;
+ argbuf = malloc(arglen);
+ }
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC_ARGS;
+ mib[2] = p->p_pid;
+ mib[3] = KERN_PROC_ARGV;
+
+ while (argbuf) {
+ ret = sysctl(mib, 4, argbuf, &arglen, NULL, 0);
+ if (ret == -1 && errno == ENOMEM) {
+ char *n;
+ n = realloc(argbuf, arglen * 2);
+ if (n != 0) {
+ argbuf = n;
+ arglen *= 2;
+ continue;
+ }
+ }
+ break;
+ }
+
+ if (ret != 1) {
+ char **argv;
+ int argc;
+
+ argv = (char **)argbuf;
+ if (argv[0] != NULL)
+ strlcpy(cmdline, argv[0], maxlen);
+ for (argc = 1; argv[argc] != NULL; argc++) {
+ strlcat(cmdline, " ", maxlen);
+ strlcat(cmdline, argv[argc], maxlen);
+ }
+ } else {
+ strlcpy(cmdline, p->p_comm, maxlen);
+ }
+}
+
+static int
+updateProcess(struct kinfo_proc *p)
+{
+ static char *statuses[] = { "idle","run","sleep","stop","zombie" };
+
+ ProcessInfo* ps;
+ struct passwd* pwent;
+ pid_t pid = p->p_pid;
+
+ if ((ps = findProcessInList(pid)) == 0)
+ {
+ ps = (ProcessInfo*) malloc(sizeof(ProcessInfo));
+ ps->pid = pid;
+ ps->centStamp = 0;
+ push_ctnr(ProcessList, ps);
+ bsort_ctnr(ProcessList, processCmp);
+ }
+
+ ps->alive = 1;
+
+ ps->pid = p->p_pid;
+ ps->ppid = p->p_ppid;
+ ps->uid = p->p_uid;
+ ps->gid = p->p_gid;
+ ps->priority = p->p_priority;
+ ps->niceLevel = p->p_nice;
+
+ /* this isn't usertime -- it's total time (??) */
+ ps->userTime = p->p_uutime_sec*100+p->p_uutime_usec/100;
+ ps->sysTime = 0;
+ ps->sysLoad = 0;
+
+ /* memory, process name, process uid */
+ /* find out user name with process uid */
+ pwent = getpwuid(ps->uid);
+ strlcpy(ps->userName,pwent&&pwent->pw_name? pwent->pw_name:"????",sizeof(ps->userName));
+ ps->userName[sizeof(ps->userName)-1]='\0';
+
+ ps->userLoad = p->p_pctcpu / 100;
+ ps->vmSize = (p->p_vm_tsize +
+ p->p_vm_dsize +
+ p->p_vm_ssize) * getpagesize();
+ ps->vmRss = p->p_vm_rssize * getpagesize();
+ strlcpy(ps->name,p->p_comm ? p->p_comm : "????", sizeof(ps->name));
+ strlcpy(ps->status,(p->p_stat>=1)&&(p->p_stat<=5)? statuses[p->p_stat-1]:"????", sizeof(ps->status));
+
+ fillProcessCmdline(ps->cmdline, p, sizeof(ps->cmdline));
+ /* process command line */
+
+ return (0);
+}
+
+static void
+cleanupProcessList(void)
+{
+ ProcessInfo* ps;
+
+ ProcessCount = 0;
+ /* All processes that do not have the active flag set are assumed dead
+ * and will be removed from the list. The alive flag is cleared. */
+ for (ps = first_ctnr(ProcessList); ps; ps = next_ctnr(ProcessList))
+ {
+ if (ps->alive)
+ {
+ /* Process is still alive. Just clear flag. */
+ ps->alive = 0;
+ ProcessCount++;
+ }
+ else
+ {
+ /* Process has probably died. We remove it from the list and
+ * destruct the data structure. i needs to be decremented so
+ * that after i++ the next list element will be inspected. */
+ free(remove_ctnr(ProcessList));
+ }
+ }
+}
+
+/*
+================================ public part ==================================
+*/
+
+void
+initProcessList(struct SensorModul* sm)
+{
+ ProcessList = new_ctnr();
+
+ registerMonitor("ps", "table", printProcessList, printProcessListInfo, sm);
+ registerMonitor("pscount", "integer", printProcessCount, printProcessCountInfo, sm);
+
+ if (!RunAsDaemon)
+ {
+ registerCommand("kill", killProcess);
+ registerCommand("setpriority", setPriority);
+ }
+
+ updateProcessList();
+}
+
+void
+exitProcessList(void)
+{
+ removeMonitor("ps");
+ removeMonitor("pscount");
+
+ if (ProcessList)
+ free (ProcessList);
+}
+
+int
+updateProcessList(void)
+{
+ int mib[6];
+ size_t len;
+ size_t num;
+ struct kinfo_proc *p;
+
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_ALL;
+ mib[3] = 0;
+ mib[4] = sizeof(struct kinfo_proc);
+ mib[5] = 0;
+ if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1)
+ return 0;
+ len = 5 * len / 4;
+ p = malloc(len);
+ if (!p)
+ return 0;
+ mib[5] = len/ sizeof(struct kinfo_proc);
+ if (sysctl(mib, 6, p, &len, NULL, 0) == -1)
+ return 0;
+
+ for (num = 0; num < len / sizeof(struct kinfo_proc); num++)
+ updateProcess(&p[num]);
+ free(p);
+ cleanupProcessList();
+
+ return (0);
+}
+
+void
+printProcessListInfo(const char* cmd)
+{
+ fprintf(CurrentClient, "Name\tPID\tPPID\tUID\tGID\tStatus\tUser%%\tSystem%%\tNice\tVmSize\tVmRss\tLogin\tCommand\n");
+ fprintf(CurrentClient, "s\td\td\td\td\tS\tf\tf\td\tD\tD\ts\ts\n");
+}
+
+void
+printProcessList(const char* cmd)
+{
+ ProcessInfo* ps;
+
+ for (ps = first_ctnr(ProcessList); ps; ps = next_ctnr(ProcessList))
+ {
+ fprintf(CurrentClient, "%s\t%ld\t%ld\t%ld\t%ld\t%s\t%.2f\t%.2f\t%d\t%d\t%d\t%s\t%s\n",
+ ps->name, (long)ps->pid, (long)ps->ppid,
+ (long)ps->uid, (long)ps->gid, ps->status,
+ ps->userLoad, ps->sysLoad, ps->niceLevel,
+ ps->vmSize / 1024, ps->vmRss / 1024, ps->userName, ps->cmdline);
+ }
+}
+
+void
+printProcessCount(const char* cmd)
+{
+ fprintf(CurrentClient, "%d\n", ProcessCount);
+}
+
+void
+printProcessCountInfo(const char* cmd)
+{
+ fprintf(CurrentClient, "Number of Processes\t1\t65535\t\n");
+}
+
+void
+killProcess(const char* cmd)
+{
+ int sig, pid;
+
+ sscanf(cmd, "%*s %d %d", &pid, &sig);
+ switch(sig)
+ {
+ case MENU_ID_SIGABRT:
+ sig = SIGABRT;
+ break;
+ case MENU_ID_SIGALRM:
+ sig = SIGALRM;
+ break;
+ case MENU_ID_SIGCHLD:
+ sig = SIGCHLD;
+ break;
+ case MENU_ID_SIGCONT:
+ sig = SIGCONT;
+ break;
+ case MENU_ID_SIGFPE:
+ sig = SIGFPE;
+ break;
+ case MENU_ID_SIGHUP:
+ sig = SIGHUP;
+ break;
+ case MENU_ID_SIGILL:
+ sig = SIGILL;
+ break;
+ case MENU_ID_SIGINT:
+ sig = SIGINT;
+ break;
+ case MENU_ID_SIGKILL:
+ sig = SIGKILL;
+ break;
+ case MENU_ID_SIGPIPE:
+ sig = SIGPIPE;
+ break;
+ case MENU_ID_SIGQUIT:
+ sig = SIGQUIT;
+ break;
+ case MENU_ID_SIGSEGV:
+ sig = SIGSEGV;
+ break;
+ case MENU_ID_SIGSTOP:
+ sig = SIGSTOP;
+ break;
+ case MENU_ID_SIGTERM:
+ sig = SIGTERM;
+ break;
+ case MENU_ID_SIGTSTP:
+ sig = SIGTSTP;
+ break;
+ case MENU_ID_SIGTTIN:
+ sig = SIGTTIN;
+ break;
+ case MENU_ID_SIGTTOU:
+ sig = SIGTTOU;
+ break;
+ case MENU_ID_SIGUSR1:
+ sig = SIGUSR1;
+ break;
+ case MENU_ID_SIGUSR2:
+ sig = SIGUSR2;
+ break;
+ }
+ if (kill((pid_t) pid, sig))
+ {
+ switch(errno)
+ {
+ case EINVAL:
+ fprintf(CurrentClient, "4\t%d\n", pid);
+ break;
+ case ESRCH:
+ fprintf(CurrentClient, "3\t%d\n", pid);
+ break;
+ case EPERM:
+ fprintf(CurrentClient, "2\t%d\n", pid);
+ break;
+ default:
+ fprintf(CurrentClient, "1\t%d\n", pid); /* unknown error */
+ break;
+ }
+
+ }
+ else
+ fprintf(CurrentClient, "0\t%d\n", pid);
+}
+
+void
+setPriority(const char* cmd)
+{
+ int pid, prio;
+
+ sscanf(cmd, "%*s %d %d", &pid, &prio);
+ if (setpriority(PRIO_PROCESS, pid, prio))
+ {
+ switch(errno)
+ {
+ case EINVAL:
+ fprintf(CurrentClient, "4\n");
+ break;
+ case ESRCH:
+ fprintf(CurrentClient, "3\n");
+ break;
+ case EPERM:
+ case EACCES:
+ fprintf(CurrentClient, "2\n");
+ break;
+ default:
+ fprintf(CurrentClient, "1\n"); /* unknown error */
+ break;
+ }
+ }
+ else
+ fprintf(CurrentClient, "0\n");
+}
diff --git a/ksysguard/ksysguardd/OpenBSD/ProcessList.h b/ksysguard/ksysguardd/OpenBSD/ProcessList.h
new file mode 100644
index 000000000..925c55f5a
--- /dev/null
+++ b/ksysguard/ksysguardd/OpenBSD/ProcessList.h
@@ -0,0 +1,38 @@
+/*
+ KSysGuard, the KDE System Guard
+
+ Copyright (c) 1999 Chris Schlaeger <cs@kde.org>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+*/
+
+#ifndef _process_list_h_
+#define _process_list_h_
+
+void initProcessList(struct SensorModul* sm);
+void exitProcessList(void);
+
+int updateProcessList(void);
+
+void printProcessList(const char*);
+void printProcessListInfo(const char*);
+void printProcessCount(const char* cmd);
+void printProcessCountInfo(const char* cmd);
+
+void killProcess(const char* cmd);
+void setPriority(const char* cmd);
+
+#endif
diff --git a/ksysguard/ksysguardd/modules.h b/ksysguard/ksysguardd/modules.h
index 5c214c7f0..06b290b27 100644
--- a/ksysguard/ksysguardd/modules.h
+++ b/ksysguard/ksysguardd/modules.h
@@ -79,6 +79,7 @@
#ifdef OSTYPE_OpenBSD
#include "cpu.h"
#include "memory.h"
+#include "ProcessList.h"
#endif /* OSTYPE_OpenBSD */
typedef void (*VSFunc)( struct SensorModul* );
@@ -143,6 +144,7 @@ struct SensorModul SensorModulList[] = {
#ifdef OSTYPE_OpenBSD
{ "CpuInfo", initCpuInfo, exitCpuInfo, updateCpuInfo, NULLVVFUNC, 0, NULLTIME },
{ "Memory", initMemory, exitMemory, updateMemory, NULLVVFUNC, 0, NULLTIME },
+ { "ProcessList", initProcessList, exitProcessList, updateProcessList, NULLVVFUNC, 0, NULLTIME },
#endif /* OSTYPE_OpenBSD */
{ NULL, NULLVSFUNC, NULLVVFUNC, NULLIVFUNC, NULLVVFUNC, 0, NULLTIME }
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-10 10:54:57 +0000