From 69f439eff387a6ecb52734e400b297a3c85f2285 Mon Sep 17 00:00:00 2001 From: Daniel Lange Date: Tue, 21 Sep 2021 08:35:19 +0200 Subject: New upstream version 3.1.0 --- openbsd/OpenBSDProcessList.c | 240 +++++++++++++++++++++++++++++++++---------- 1 file changed, 185 insertions(+), 55 deletions(-) (limited to 'openbsd/OpenBSDProcessList.c') diff --git a/openbsd/OpenBSDProcessList.c b/openbsd/OpenBSDProcessList.c index ff5c927..cb47395 100644 --- a/openbsd/OpenBSDProcessList.c +++ b/openbsd/OpenBSDProcessList.c @@ -6,7 +6,7 @@ Released under the GNU GPLv2, see the COPYING file in the source distribution for its full text. */ -#include "OpenBSDProcessList.h" +#include "openbsd/OpenBSDProcessList.h" #include #include @@ -25,34 +25,85 @@ in the source distribution for its full text. #include "CRT.h" #include "Macros.h" #include "Object.h" -#include "OpenBSDProcess.h" #include "Process.h" #include "ProcessList.h" #include "Settings.h" #include "XUtils.h" +#include "openbsd/OpenBSDProcess.h" static long fscale; static int pageSize; static int pageSizeKB; -ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidMatchList, uid_t userId) { - const int mib[] = { CTL_HW, HW_NCPU }; - const int fmib[] = { CTL_KERN, KERN_FSCALE }; +static void OpenBSDProcessList_updateCPUcount(ProcessList* super) { + OpenBSDProcessList* opl = (OpenBSDProcessList*) super; + const int nmib[] = { CTL_HW, HW_NCPU }; + const int mib[] = { CTL_HW, HW_NCPUONLINE }; int r; + unsigned int value; + size_t size; + bool change = false; + + size = sizeof(value); + r = sysctl(mib, 2, &value, &size, NULL, 0); + if (r < 0 || value < 1) { + value = 1; + } + + if (value != super->activeCPUs) { + super->activeCPUs = value; + change = true; + } + + size = sizeof(value); + r = sysctl(nmib, 2, &value, &size, NULL, 0); + if (r < 0 || value < 1) { + value = super->activeCPUs; + } + + if (value != super->existingCPUs) { + opl->cpuData = xReallocArray(opl->cpuData, value + 1, sizeof(CPUData)); + super->existingCPUs = value; + change = true; + } + + if (change) { + CPUData* dAvg = &opl->cpuData[0]; + memset(dAvg, '\0', sizeof(CPUData)); + dAvg->totalTime = 1; + dAvg->totalPeriod = 1; + dAvg->online = true; + + for (unsigned int i = 0; i < super->existingCPUs; i++) { + CPUData* d = &opl->cpuData[i + 1]; + memset(d, '\0', sizeof(CPUData)); + d->totalTime = 1; + d->totalPeriod = 1; + + const int ncmib[] = { CTL_KERN, KERN_CPUSTATS, i }; + struct cpustats cpu_stats; + + size = sizeof(cpu_stats); + if (sysctl(ncmib, 3, &cpu_stats, &size, NULL, 0) < 0) { + CRT_fatalError("ncmib sysctl call failed"); + } + d->online = (cpu_stats.cs_flags & CPUSTATS_ONLINE); + } + } +} + + +ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, Hashtable* dynamicColumns, Hashtable* pidMatchList, uid_t userId) { + const int fmib[] = { CTL_KERN, KERN_FSCALE }; size_t size; char errbuf[_POSIX2_LINE_MAX]; OpenBSDProcessList* opl = xCalloc(1, sizeof(OpenBSDProcessList)); ProcessList* pl = (ProcessList*) opl; - ProcessList_init(pl, Class(OpenBSDProcess), usersTable, pidMatchList, userId); + ProcessList_init(pl, Class(OpenBSDProcess), usersTable, dynamicMeters, dynamicColumns, pidMatchList, userId); - size = sizeof(pl->cpuCount); - r = sysctl(mib, 2, &pl->cpuCount, &size, NULL, 0); - if (r < 0 || pl->cpuCount < 1) { - pl->cpuCount = 1; - } - opl->cpus = xCalloc(pl->cpuCount + 1, sizeof(CPUData)); + OpenBSDProcessList_updateCPUcount(pl); size = sizeof(fscale); if (sysctl(fmib, 2, &fscale, &size, NULL, 0) < 0) { @@ -63,17 +114,13 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidMatchList, ui CRT_fatalError("pagesize sysconf call failed"); pageSizeKB = pageSize / ONE_K; - for (int i = 0; i <= pl->cpuCount; i++) { - CPUData* d = opl->cpus + i; - d->totalTime = 1; - d->totalPeriod = 1; - } - opl->kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf); if (opl->kd == NULL) { CRT_fatalError("kvm_openfiles() failed"); } + opl->cpuSpeed = -1; + return pl; } @@ -84,7 +131,7 @@ void ProcessList_delete(ProcessList* this) { kvm_close(opl->kd); } - free(opl->cpus); + free(opl->cpuData); ProcessList_done(this); free(this); @@ -143,15 +190,37 @@ static void OpenBSDProcessList_scanMemoryInfo(ProcessList* pl) { } } -static char* OpenBSDProcessList_readProcessName(kvm_t* kd, const struct kinfo_proc* kproc, int* basenameEnd) { +static void OpenBSDProcessList_updateCwd(const struct kinfo_proc* kproc, Process* proc) { + const int mib[] = { CTL_KERN, KERN_PROC_CWD, kproc->p_pid }; + char buffer[2048]; + size_t size = sizeof(buffer); + if (sysctl(mib, 3, buffer, &size, NULL, 0) != 0) { + free(proc->procCwd); + proc->procCwd = NULL; + return; + } + + /* Kernel threads return an empty buffer */ + if (buffer[0] == '\0') { + free(proc->procCwd); + proc->procCwd = NULL; + return; + } + + free_and_xStrdup(&proc->procCwd, buffer); +} + +static void OpenBSDProcessList_updateProcessName(kvm_t* kd, const struct kinfo_proc* kproc, Process* proc) { + Process_updateComm(proc, kproc->p_comm); + /* * Like OpenBSD's top(1), we try to fall back to the command name * (argv[0]) if we fail to construct the full command. */ char** arg = kvm_getargv(kd, kproc, 500); if (arg == NULL || *arg == NULL) { - *basenameEnd = strlen(kproc->p_comm); - return xStrdup(kproc->p_comm); + Process_updateCmdline(proc, kproc->p_comm, 0, strlen(kproc->p_comm)); + return; } size_t len = 0; @@ -162,22 +231,30 @@ static char* OpenBSDProcessList_readProcessName(kvm_t* kd, const struct kinfo_pr /* don't use xMalloc here - we want to handle huge argv's gracefully */ char* s; if ((s = malloc(len)) == NULL) { - *basenameEnd = strlen(kproc->p_comm); - return xStrdup(kproc->p_comm); + Process_updateCmdline(proc, kproc->p_comm, 0, strlen(kproc->p_comm)); + return; } *s = '\0'; + int start = 0; + int end = 0; for (int i = 0; arg[i] != NULL; i++) { size_t n = strlcat(s, arg[i], len); if (i == 0) { - *basenameEnd = MINIMUM(n, len - 1); + end = MINIMUM(n, len - 1); + /* check if cmdline ended earlier, e.g 'kdeinit5: Running...' */ + for (int j = end; j > 0; j--) { + if (arg[0][j] == ' ' && arg[0][j - 1] != '\\') { + end = (arg[0][j - 1] == ':') ? (j - 1) : j; + } + } } /* the trailing space should get truncated anyway */ strlcat(s, " ", len); } - return s; + Process_updateCmdline(proc, s, start, end); } /* @@ -192,79 +269,108 @@ static double getpcpu(const struct kinfo_proc* kp) { static void OpenBSDProcessList_scanProcs(OpenBSDProcessList* this) { const Settings* settings = this->super.settings; - bool hideKernelThreads = settings->hideKernelThreads; - bool hideUserlandThreads = settings->hideUserlandThreads; + const bool hideKernelThreads = settings->hideKernelThreads; + const bool hideUserlandThreads = settings->hideUserlandThreads; int count = 0; - const struct kinfo_proc* kprocs = kvm_getprocs(this->kd, KERN_PROC_KTHREAD, 0, sizeof(struct kinfo_proc), &count); + const struct kinfo_proc* kprocs = kvm_getprocs(this->kd, KERN_PROC_KTHREAD | KERN_PROC_SHOW_THREADS, 0, sizeof(struct kinfo_proc), &count); for (int i = 0; i < count; i++) { const struct kinfo_proc* kproc = &kprocs[i]; - bool preExisting = false; - Process* proc = ProcessList_getProcess(&this->super, kproc->p_pid, &preExisting, OpenBSDProcess_new); - //OpenBSDProcess* fp = (OpenBSDProcess*) proc; + /* Ignore main threads */ + if (kproc->p_tid != -1) { + Process* containingProcess = ProcessList_findProcess(&this->super, kproc->p_pid); + if (containingProcess) { + if (((OpenBSDProcess*)containingProcess)->addr == kproc->p_addr) + continue; - proc->show = ! ((hideKernelThreads && Process_isKernelThread(proc)) || (hideUserlandThreads && Process_isUserlandThread(proc))); + containingProcess->nlwp++; + } + } + + bool preExisting = false; + Process* proc = ProcessList_getProcess(&this->super, (kproc->p_tid == -1) ? kproc->p_pid : kproc->p_tid, &preExisting, OpenBSDProcess_new); + OpenBSDProcess* fp = (OpenBSDProcess*) proc; if (!preExisting) { proc->ppid = kproc->p_ppid; proc->tpgid = kproc->p_tpgid; proc->tgid = kproc->p_pid; proc->session = kproc->p_sid; - proc->tty_nr = kproc->p_tdev; proc->pgrp = kproc->p__pgid; - proc->st_uid = kproc->p_uid; + proc->isKernelThread = proc->pgrp == 0; + proc->isUserlandThread = kproc->p_tid != -1; proc->starttime_ctime = kproc->p_ustart_sec; Process_fillStarttimeBuffer(proc); - proc->user = UsersTable_getRef(this->super.usersTable, proc->st_uid); ProcessList_add(&this->super, proc); - proc->comm = OpenBSDProcessList_readProcessName(this->kd, kproc, &proc->basenameOffset); + + OpenBSDProcessList_updateProcessName(this->kd, kproc, proc); + + if (settings->flags & PROCESS_FLAG_CWD) { + OpenBSDProcessList_updateCwd(kproc, proc); + } + + proc->tty_nr = kproc->p_tdev; + const char* name = ((dev_t)kproc->p_tdev != NODEV) ? devname(kproc->p_tdev, S_IFCHR) : NULL; + if (!name || String_eq(name, "??")) { + free(proc->tty_name); + proc->tty_name = NULL; + } else { + free_and_xStrdup(&proc->tty_name, name); + } } else { if (settings->updateProcessNames) { - free(proc->comm); - proc->comm = OpenBSDProcessList_readProcessName(this->kd, kproc, &proc->basenameOffset); + OpenBSDProcessList_updateProcessName(this->kd, kproc, proc); } } + fp->addr = kproc->p_addr; proc->m_virt = kproc->p_vm_dsize * pageSizeKB; proc->m_resident = kproc->p_vm_rssize * pageSizeKB; - proc->percent_mem = proc->m_resident / (double)(this->super.totalMem) * 100.0; - proc->percent_cpu = CLAMP(getpcpu(kproc), 0.0, this->super.cpuCount * 100.0); - //proc->nlwp = kproc->p_numthreads; + proc->percent_mem = proc->m_resident / (float)this->super.totalMem * 100.0F; + proc->percent_cpu = CLAMP(getpcpu(kproc), 0.0F, this->super.activeCPUs * 100.0F); proc->nice = kproc->p_nice - 20; proc->time = 100 * (kproc->p_rtime_sec + ((kproc->p_rtime_usec + 500000) / 1000000)); proc->priority = kproc->p_priority - PZERO; + proc->processor = kproc->p_cpuid; + proc->minflt = kproc->p_uru_minflt; + proc->majflt = kproc->p_uru_majflt; + proc->nlwp = 1; + + if (proc->st_uid != kproc->p_uid) { + proc->st_uid = kproc->p_uid; + proc->user = UsersTable_getRef(this->super.usersTable, proc->st_uid); + } switch (kproc->p_stat) { case SIDL: proc->state = 'I'; break; - case SRUN: proc->state = 'R'; break; + case SRUN: proc->state = 'P'; break; case SSLEEP: proc->state = 'S'; break; case SSTOP: proc->state = 'T'; break; case SZOMB: proc->state = 'Z'; break; case SDEAD: proc->state = 'D'; break; - case SONPROC: proc->state = 'P'; break; + case SONPROC: proc->state = 'R'; break; default: proc->state = '?'; } if (Process_isKernelThread(proc)) { this->super.kernelThreads++; + } else if (Process_isUserlandThread(proc)) { + this->super.userlandThreads++; } this->super.totalTasks++; - // SRUN ('R') means runnable, not running - if (proc->state == 'P') { + if (proc->state == 'R') { this->super.runningTasks++; } + + proc->show = ! ((hideKernelThreads && Process_isKernelThread(proc)) || (hideUserlandThreads && Process_isUserlandThread(proc))); proc->updated = true; } } -static unsigned long long saturatingSub(unsigned long long a, unsigned long long b) { - return a > b ? a - b : 0; -} - -static void getKernelCPUTimes(int cpuId, u_int64_t* times) { +static void getKernelCPUTimes(unsigned int cpuId, u_int64_t* times) { const int mib[] = { CTL_KERN, KERN_CPTIME2, cpuId }; size_t length = sizeof(*times) * CPUSTATES; if (sysctl(mib, 3, times, &length, NULL, 0) == -1 || length != sizeof(*times) * CPUSTATES) { @@ -313,9 +419,14 @@ static void OpenBSDProcessList_scanCPUTime(OpenBSDProcessList* this) { u_int64_t kernelTimes[CPUSTATES] = {0}; u_int64_t avg[CPUSTATES] = {0}; - for (int i = 0; i < this->super.cpuCount; i++) { + for (unsigned int i = 0; i < this->super.existingCPUs; i++) { + CPUData* cpu = &this->cpuData[i + 1]; + + if (!cpu->online) { + continue; + } + getKernelCPUTimes(i, kernelTimes); - CPUData* cpu = this->cpus + i + 1; kernelCPUTimesToHtop(kernelTimes, cpu); avg[CP_USER] += cpu->userTime; @@ -329,15 +440,27 @@ static void OpenBSDProcessList_scanCPUTime(OpenBSDProcessList* this) { } for (int i = 0; i < CPUSTATES; i++) { - avg[i] /= this->super.cpuCount; + avg[i] /= this->super.activeCPUs; } - kernelCPUTimesToHtop(avg, this->cpus); + kernelCPUTimesToHtop(avg, &this->cpuData[0]); + + { + const int mib[] = { CTL_HW, HW_CPUSPEED }; + int cpuSpeed; + size_t size = sizeof(cpuSpeed); + if (sysctl(mib, 2, &cpuSpeed, &size, NULL, 0) == -1) { + this->cpuSpeed = -1; + } else { + this->cpuSpeed = cpuSpeed; + } + } } void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) { OpenBSDProcessList* opl = (OpenBSDProcessList*) super; + OpenBSDProcessList_updateCPUcount(super); OpenBSDProcessList_scanMemoryInfo(super); OpenBSDProcessList_scanCPUTime(opl); @@ -348,3 +471,10 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) { OpenBSDProcessList_scanProcs(opl); } + +bool ProcessList_isCPUonline(const ProcessList* super, unsigned int id) { + assert(id < super->existingCPUs); + + const OpenBSDProcessList* opl = (const OpenBSDProcessList*) super; + return opl->cpuData[id + 1].online; +} -- cgit v1.2.3