htop/solaris/SolarisProcessList.c

543 lines
19 KiB
C
Raw Normal View History

/*
htop - SolarisProcessList.c
(C) 2014 Hisham H. Muhammad
(C) 2017,2018 Guy M. Broome
Released under the GNU GPLv2, see the COPYING file
in the source distribution for its full text.
*/
#include "solaris/SolarisProcessList.h"
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/user.h>
#include <limits.h>
#include <string.h>
#include <procfs.h>
#include <errno.h>
#include <pwd.h>
#include <math.h>
#include <time.h>
#include "CRT.h"
2021-05-19 17:01:30 +00:00
#include "solaris/Platform.h"
#include "solaris/SolarisProcess.h"
2021-04-29 15:12:43 +00:00
#define GZONE "global "
#define UZONE "unknown "
static int pageSize;
static int pageSizeKB;
2021-05-19 17:09:57 +00:00
static char* SolarisProcessList_readZoneName(kstat_ctl_t* kd, SolarisProcess* sproc) {
2020-10-31 21:14:27 +00:00
char* zname;
if ( sproc->zoneid == 0 ) {
zname = xStrdup(GZONE);
} else if ( kd == NULL ) {
zname = xStrdup(UZONE);
} else {
kstat_t* ks = kstat_lookup_wrapper( kd, "zones", sproc->zoneid, NULL );
2020-10-31 21:14:27 +00:00
zname = xStrdup(ks == NULL ? UZONE : ks->ks_name);
}
return zname;
}
static void SolarisProcessList_updateCPUcount(ProcessList* super) {
SolarisProcessList* spl = (SolarisProcessList*) super;
long int s;
bool change = false;
s = sysconf(_SC_NPROCESSORS_CONF);
if (s < 1)
2021-08-08 13:10:34 +00:00
CRT_fatalError("Cannot get existing CPU count by sysconf(_SC_NPROCESSORS_CONF)");
if (s != super->existingCPUs) {
if (s == 1) {
spl->cpus = xRealloc(spl->cpus, sizeof(CPUData));
spl->cpus[0].online = true;
} else {
spl->cpus = xReallocArray(spl->cpus, s + 1, sizeof(CPUData));
spl->cpus[0].online = true; /* average is always "online" */
for (int i = 1; i < s + 1; i++) {
spl->cpus[i].online = false;
}
}
change = true;
super->existingCPUs = s;
}
s = sysconf(_SC_NPROCESSORS_ONLN);
if (s < 1)
CRT_fatalError("Cannot get active CPU count by sysconf(_SC_NPROCESSORS_ONLN)");
if (s != super->activeCPUs) {
change = true;
super->activeCPUs = s;
}
if (change) {
kstat_close(spl->kd);
spl->kd = kstat_open();
if (!spl->kd)
CRT_fatalError("Cannot open kstat handle");
}
}
Add a new DynamicMeter class for runtime Meter extension This commit is based on exploratory work by Sohaib Mohamed. The end goal is two-fold - to support addition of Meters we build via configuration files for both the PCP platform and for scripts ( https://github.com/htop-dev/htop/issues/526 ) Here, we focus on generic code and the PCP support. A new class DynamicMeter is introduced - it uses the special case 'param' field handling that previously was used only by the CPUMeter, such that every runtime-configured Meter is given a unique identifier. Unlike with the CPUMeter this is used internally only. When reading/writing to htoprc instead of CPU(N) - where N is an integer param (CPU number) - we use the string name for each meter. For example, if we have a configuration for a DynamicMeter for some Redis metrics, we might read and write "Dynamic(redis)". This identifier is subsequently matched (back) up to the configuration file so we're able to re-create arbitrary user configurations. The PCP platform configuration file format is fairly simple. We expand configs from several directories, including the users homedir alongside htoprc (below htop/meters/) and also /etc/pcp/htop/meters. The format will be described via a new pcp-htop(5) man page, but its basically ini-style and each Meter has one or more metric expressions associated, as well as specifications for labels, color and so on via a dot separated notation for individual metrics within the Meter. A few initial sample configuration files are provided below ./pcp/meters that give the general idea. The PCP "derived" metric specification - see pmRegisterDerived(3) - is used as the syntax for specifying metrics in PCP DynamicMeters.
2021-06-23 07:44:56 +00:00
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, Hashtable* pidMatchList, uid_t userId) {
SolarisProcessList* spl = xCalloc(1, sizeof(SolarisProcessList));
ProcessList* pl = (ProcessList*) spl;
Add a new DynamicMeter class for runtime Meter extension This commit is based on exploratory work by Sohaib Mohamed. The end goal is two-fold - to support addition of Meters we build via configuration files for both the PCP platform and for scripts ( https://github.com/htop-dev/htop/issues/526 ) Here, we focus on generic code and the PCP support. A new class DynamicMeter is introduced - it uses the special case 'param' field handling that previously was used only by the CPUMeter, such that every runtime-configured Meter is given a unique identifier. Unlike with the CPUMeter this is used internally only. When reading/writing to htoprc instead of CPU(N) - where N is an integer param (CPU number) - we use the string name for each meter. For example, if we have a configuration for a DynamicMeter for some Redis metrics, we might read and write "Dynamic(redis)". This identifier is subsequently matched (back) up to the configuration file so we're able to re-create arbitrary user configurations. The PCP platform configuration file format is fairly simple. We expand configs from several directories, including the users homedir alongside htoprc (below htop/meters/) and also /etc/pcp/htop/meters. The format will be described via a new pcp-htop(5) man page, but its basically ini-style and each Meter has one or more metric expressions associated, as well as specifications for labels, color and so on via a dot separated notation for individual metrics within the Meter. A few initial sample configuration files are provided below ./pcp/meters that give the general idea. The PCP "derived" metric specification - see pmRegisterDerived(3) - is used as the syntax for specifying metrics in PCP DynamicMeters.
2021-06-23 07:44:56 +00:00
ProcessList_init(pl, Class(SolarisProcess), usersTable, dynamicMeters, pidMatchList, userId);
spl->kd = kstat_open();
if (!spl->kd)
CRT_fatalError("Cannot open kstat handle");
pageSize = sysconf(_SC_PAGESIZE);
if (pageSize == -1)
CRT_fatalError("Cannot get pagesize by sysconf(_SC_PAGESIZE)");
pageSizeKB = pageSize / 1024;
SolarisProcessList_updateCPUcount(pl);
return pl;
}
static inline void SolarisProcessList_scanCPUTime(ProcessList* pl) {
const SolarisProcessList* spl = (SolarisProcessList*) pl;
unsigned int activeCPUs = pl->activeCPUs;
unsigned int existingCPUs = pl->existingCPUs;
2020-10-31 22:28:02 +00:00
kstat_t* cpuinfo = NULL;
kstat_named_t* idletime = NULL;
kstat_named_t* intrtime = NULL;
kstat_named_t* krnltime = NULL;
kstat_named_t* usertime = NULL;
kstat_named_t* cpu_freq = NULL;
double idlebuf = 0;
double intrbuf = 0;
double krnlbuf = 0;
double userbuf = 0;
int arrskip = 0;
assert(existingCPUs > 0);
assert(spl->kd);
if (existingCPUs > 1) {
2020-10-31 21:14:27 +00:00
// Store values for the stats loop one extra element up in the array
// to leave room for the average to be calculated afterwards
arrskip++;
}
// Calculate per-CPU statistics first
for (unsigned int i = 0; i < existingCPUs; i++) {
CPUData* cpuData = &(spl->cpus[i + arrskip]);
if ((cpuinfo = kstat_lookup_wrapper(spl->kd, "cpu", i, "sys")) != NULL) {
cpuData->online = true;
if (kstat_read(spl->kd, cpuinfo, NULL) != -1) {
idletime = kstat_data_lookup_wrapper(cpuinfo, "cpu_nsec_idle");
intrtime = kstat_data_lookup_wrapper(cpuinfo, "cpu_nsec_intr");
krnltime = kstat_data_lookup_wrapper(cpuinfo, "cpu_nsec_kernel");
usertime = kstat_data_lookup_wrapper(cpuinfo, "cpu_nsec_user");
}
} else {
cpuData->online = false;
continue;
}
assert( (idletime != NULL) && (intrtime != NULL)
&& (krnltime != NULL) && (usertime != NULL) );
if (pl->settings->showCPUFrequency) {
if ((cpuinfo = kstat_lookup_wrapper(spl->kd, "cpu_info", i, NULL)) != NULL) {
if (kstat_read(spl->kd, cpuinfo, NULL) != -1) {
cpu_freq = kstat_data_lookup_wrapper(cpuinfo, "current_clock_Hz");
}
}
assert( cpu_freq != NULL );
}
2020-11-21 23:47:32 +00:00
uint64_t totaltime = (idletime->value.ui64 - cpuData->lidle)
+ (intrtime->value.ui64 - cpuData->lintr)
+ (krnltime->value.ui64 - cpuData->lkrnl)
+ (usertime->value.ui64 - cpuData->luser);
// Calculate percentages of deltas since last reading
cpuData->userPercent = ((usertime->value.ui64 - cpuData->luser) / (double)totaltime) * 100.0;
cpuData->nicePercent = (double)0.0; // Not implemented on Solaris
cpuData->systemPercent = ((krnltime->value.ui64 - cpuData->lkrnl) / (double)totaltime) * 100.0;
cpuData->irqPercent = ((intrtime->value.ui64 - cpuData->lintr) / (double)totaltime) * 100.0;
cpuData->systemAllPercent = cpuData->systemPercent + cpuData->irqPercent;
cpuData->idlePercent = ((idletime->value.ui64 - cpuData->lidle) / (double)totaltime) * 100.0;
// Store current values to use for the next round of deltas
cpuData->luser = usertime->value.ui64;
cpuData->lkrnl = krnltime->value.ui64;
cpuData->lintr = intrtime->value.ui64;
cpuData->lidle = idletime->value.ui64;
// Add frequency in MHz
cpuData->frequency = pl->settings->showCPUFrequency ? (double)cpu_freq->value.ui64 / 1E6 : NAN;
// Accumulate the current percentages into buffers for later average calculation
if (existingCPUs > 1) {
userbuf += cpuData->userPercent;
krnlbuf += cpuData->systemPercent;
intrbuf += cpuData->irqPercent;
idlebuf += cpuData->idlePercent;
}
}
2019-10-31 16:39:12 +00:00
if (existingCPUs > 1) {
CPUData* cpuData = &(spl->cpus[0]);
cpuData->userPercent = userbuf / activeCPUs;
cpuData->nicePercent = (double)0.0; // Not implemented on Solaris
cpuData->systemPercent = krnlbuf / activeCPUs;
cpuData->irqPercent = intrbuf / activeCPUs;
cpuData->systemAllPercent = cpuData->systemPercent + cpuData->irqPercent;
cpuData->idlePercent = idlebuf / activeCPUs;
}
}
static inline void SolarisProcessList_scanMemoryInfo(ProcessList* pl) {
SolarisProcessList* spl = (SolarisProcessList*) pl;
static kstat_t *meminfo = NULL;
int ksrphyserr = -1;
kstat_named_t *totalmem_pgs = NULL;
kstat_named_t *freemem_pgs = NULL;
kstat_named_t *pages = NULL;
struct swaptable *sl = NULL;
struct swapent *swapdev = NULL;
uint64_t totalswap = 0;
uint64_t totalfree = 0;
int nswap = 0;
2019-10-31 16:39:12 +00:00
char *spath = NULL;
char *spathbase = NULL;
// Part 1 - physical memory
if (spl->kd != NULL && meminfo == NULL) {
// Look up the kstat chain just once, it never changes
meminfo = kstat_lookup_wrapper(spl->kd, "unix", 0, "system_pages");
2020-10-31 22:28:02 +00:00
}
if (meminfo != NULL) {
ksrphyserr = kstat_read(spl->kd, meminfo, NULL);
}
if (ksrphyserr != -1) {
totalmem_pgs = kstat_data_lookup_wrapper(meminfo, "physmem");
freemem_pgs = kstat_data_lookup_wrapper(meminfo, "freemem");
pages = kstat_data_lookup_wrapper(meminfo, "pagestotal");
pl->totalMem = totalmem_pgs->value.ui64 * pageSizeKB;
if (pl->totalMem > freemem_pgs->value.ui64 * pageSizeKB) {
pl->usedMem = pl->totalMem - freemem_pgs->value.ui64 * pageSizeKB;
2020-11-01 00:09:51 +00:00
} else {
pl->usedMem = 0; // This can happen in non-global zone (in theory)
}
// Not sure how to implement this on Solaris - suggestions welcome!
2019-10-31 16:39:12 +00:00
pl->cachedMem = 0;
// Not really "buffers" but the best Solaris analogue that I can find to
// "memory in use but not by programs or the kernel itself"
pl->buffersMem = (totalmem_pgs->value.ui64 - pages->value.ui64) * pageSizeKB;
2020-10-31 21:14:27 +00:00
} else {
// Fall back to basic sysconf if kstat isn't working
pl->totalMem = sysconf(_SC_PHYS_PAGES) * pageSize;
pl->buffersMem = 0;
pl->cachedMem = 0;
pl->usedMem = pl->totalMem - (sysconf(_SC_AVPHYS_PAGES) * pageSize);
}
2019-10-31 16:39:12 +00:00
// Part 2 - swap
nswap = swapctl(SC_GETNSWP, NULL);
2020-10-31 21:14:27 +00:00
if (nswap > 0) {
sl = xMalloc((nswap * sizeof(swapent_t)) + sizeof(int));
}
if (sl != NULL) {
spathbase = xMalloc( nswap * MAXPATHLEN );
}
2019-10-31 16:39:12 +00:00
if (spathbase != NULL) {
spath = spathbase;
swapdev = sl->swt_ent;
for (int i = 0; i < nswap; i++, swapdev++) {
swapdev->ste_path = spath;
spath += MAXPATHLEN;
}
sl->swt_n = nswap;
}
nswap = swapctl(SC_LIST, sl);
2019-10-31 16:39:12 +00:00
if (nswap > 0) {
swapdev = sl->swt_ent;
for (int i = 0; i < nswap; i++, swapdev++) {
totalswap += swapdev->ste_pages;
totalfree += swapdev->ste_free;
}
}
free(spathbase);
free(sl);
pl->totalSwap = totalswap * pageSizeKB;
pl->usedSwap = pl->totalSwap - (totalfree * pageSizeKB);
}
2019-07-08 02:43:39 +00:00
static inline void SolarisProcessList_scanZfsArcstats(ProcessList* pl) {
SolarisProcessList* spl = (SolarisProcessList*) pl;
kstat_t *arcstats = NULL;
int ksrphyserr = -1;
kstat_named_t *cur_kstat = NULL;
2020-10-31 21:14:27 +00:00
if (spl->kd != NULL) {
arcstats = kstat_lookup_wrapper(spl->kd, "zfs", 0, "arcstats");
2020-10-31 21:14:27 +00:00
}
if (arcstats != NULL) {
ksrphyserr = kstat_read(spl->kd, arcstats, NULL);
}
2019-07-08 02:43:39 +00:00
if (ksrphyserr != -1) {
cur_kstat = kstat_data_lookup_wrapper( arcstats, "size" );
2019-07-08 02:43:39 +00:00
spl->zfs.size = cur_kstat->value.ui64 / 1024;
spl->zfs.enabled = spl->zfs.size > 0 ? 1 : 0;
cur_kstat = kstat_data_lookup_wrapper( arcstats, "c_max" );
2019-07-08 02:43:39 +00:00
spl->zfs.max = cur_kstat->value.ui64 / 1024;
cur_kstat = kstat_data_lookup_wrapper( arcstats, "mfu_size" );
spl->zfs.MFU = cur_kstat != NULL ? cur_kstat->value.ui64 / 1024 : 0;
2019-07-08 02:43:39 +00:00
cur_kstat = kstat_data_lookup_wrapper( arcstats, "mru_size" );
spl->zfs.MRU = cur_kstat != NULL ? cur_kstat->value.ui64 / 1024 : 0;
2019-07-08 02:43:39 +00:00
cur_kstat = kstat_data_lookup_wrapper( arcstats, "anon_size" );
spl->zfs.anon = cur_kstat != NULL ? cur_kstat->value.ui64 / 1024 : 0;
2019-07-08 02:43:39 +00:00
cur_kstat = kstat_data_lookup_wrapper( arcstats, "hdr_size" );
spl->zfs.header = cur_kstat != NULL ? cur_kstat->value.ui64 / 1024 : 0;
2019-07-08 02:43:39 +00:00
cur_kstat = kstat_data_lookup_wrapper( arcstats, "other_size" );
spl->zfs.other = cur_kstat != NULL ? cur_kstat->value.ui64 / 1024 : 0;
if ((cur_kstat = kstat_data_lookup_wrapper( arcstats, "compressed_size" )) != NULL) {
spl->zfs.compressed = cur_kstat->value.ui64 / 1024;
spl->zfs.isCompressed = 1;
cur_kstat = kstat_data_lookup_wrapper( arcstats, "uncompressed_size" );
spl->zfs.uncompressed = cur_kstat->value.ui64 / 1024;
} else {
spl->zfs.isCompressed = 0;
}
2019-07-08 02:43:39 +00:00
}
}
void ProcessList_delete(ProcessList* pl) {
SolarisProcessList* spl = (SolarisProcessList*) pl;
ProcessList_done(pl);
free(spl->cpus);
2020-11-01 00:09:51 +00:00
if (spl->kd) {
kstat_close(spl->kd);
}
free(spl);
}
static void SolarisProcessList_updateExe(pid_t pid, Process* proc) {
char path[32];
xSnprintf(path, sizeof(path), "/proc/%d/path/a.out", pid);
char target[PATH_MAX];
ssize_t ret = readlink(path, target, sizeof(target) - 1);
if (ret <= 0)
return;
target[ret] = '\0';
Process_updateExe(proc, target);
}
2021-05-25 17:11:56 +00:00
static void SolarisProcessList_updateCwd(pid_t pid, Process* proc) {
char path[32];
xSnprintf(path, sizeof(path), "/proc/%d/cwd", pid);
char target[PATH_MAX];
ssize_t ret = readlink(path, target, sizeof(target) - 1);
if (ret <= 0)
return;
target[ret] = '\0';
free_and_xStrdup(&proc->procCwd, target);
}
/* NOTE: the following is a callback function of type proc_walk_f
* and MUST conform to the appropriate definition in order
* to work. See libproc(3LIB) on a Solaris or Illumos
* system for more info.
2019-10-31 16:39:12 +00:00
*/
2021-05-19 17:09:57 +00:00
static int SolarisProcessList_walkproc(psinfo_t* _psinfo, lwpsinfo_t* _lwpsinfo, void* listptr) {
bool preExisting;
pid_t getpid;
// Setup process list
2020-10-31 22:28:02 +00:00
ProcessList* pl = (ProcessList*) listptr;
SolarisProcessList* spl = (SolarisProcessList*) listptr;
id_t lwpid_real = _lwpsinfo->pr_lwpid;
2020-11-01 00:09:51 +00:00
if (lwpid_real > 1023) {
return 0;
}
pid_t lwpid = (_psinfo->pr_pid * 1024) + lwpid_real;
bool onMasterLWP = (_lwpsinfo->pr_lwpid == _psinfo->pr_lwp.pr_lwpid);
if (onMasterLWP) {
getpid = _psinfo->pr_pid * 1024;
} else {
getpid = lwpid;
2019-10-31 16:39:12 +00:00
}
2020-10-31 22:28:02 +00:00
Process* proc = ProcessList_getProcess(pl, getpid, &preExisting, SolarisProcess_new);
SolarisProcess* sproc = (SolarisProcess*) proc;
// Common code pass 1
proc->show = false;
sproc->taskid = _psinfo->pr_taskid;
sproc->projid = _psinfo->pr_projid;
sproc->poolid = _psinfo->pr_poolid;
sproc->contid = _psinfo->pr_contract;
proc->priority = _lwpsinfo->pr_pri;
proc->nice = _lwpsinfo->pr_nice - NZERO;
proc->processor = _lwpsinfo->pr_onpro;
proc->state = _lwpsinfo->pr_sname;
// NOTE: This 'percentage' is a 16-bit BINARY FRACTIONS where 1.0 = 0x8000
// Source: https://docs.oracle.com/cd/E19253-01/816-5174/proc-4/index.html
// (accessed on 18 November 2017)
2020-10-31 22:28:02 +00:00
proc->percent_mem = ((uint16_t)_psinfo->pr_pctmem / (double)32768) * (double)100.0;
proc->pgrp = _psinfo->pr_pgid;
proc->nlwp = _psinfo->pr_nlwp;
proc->session = _psinfo->pr_sid;
proc->tty_nr = _psinfo->pr_ttydev;
const char* name = (_psinfo->pr_ttydev != PRNODEV) ? ttyname(_psinfo->pr_ttydev) : NULL;
if (!name) {
free(proc->tty_name);
proc->tty_name = NULL;
} else {
free_and_xStrdup(&proc->tty_name, name);
}
2021-07-14 17:25:04 +00:00
proc->m_resident = _psinfo->pr_rssize; // KB
proc->m_virt = _psinfo->pr_size; // KB
2021-06-18 18:43:16 +00:00
if (proc->st_uid != _psinfo->pr_euid) {
proc->st_uid = _psinfo->pr_euid;
proc->user = UsersTable_getRef(pl->usersTable, proc->st_uid);
}
if (!preExisting) {
sproc->realpid = _psinfo->pr_pid;
sproc->lwpid = lwpid_real;
sproc->zoneid = _psinfo->pr_zoneid;
2020-10-31 22:28:02 +00:00
sproc->zname = SolarisProcessList_readZoneName(spl->kd, sproc);
SolarisProcessList_updateExe(_psinfo->pr_pid, proc);
2021-05-25 17:11:56 +00:00
Process_updateComm(proc, _psinfo->pr_fname);
Process_updateCmdline(proc, _psinfo->pr_psargs, 0, 0);
2021-05-25 17:11:56 +00:00
if (proc->settings->flags & PROCESS_FLAG_CWD) {
SolarisProcessList_updateCwd(_psinfo->pr_pid, proc);
}
}
// End common code pass 1
if (onMasterLWP) { // Are we on the representative LWP?
proc->ppid = (_psinfo->pr_ppid * 1024);
proc->tgid = (_psinfo->pr_ppid * 1024);
sproc->realppid = _psinfo->pr_ppid;
sproc->realtgid = _psinfo->pr_ppid;
// See note above (in common section) about this BINARY FRACTION
2020-10-31 22:28:02 +00:00
proc->percent_cpu = ((uint16_t)_psinfo->pr_pctcpu / (double)32768) * (double)100.0;
proc->time = _psinfo->pr_time.tv_sec;
2020-10-31 19:52:20 +00:00
if (!preExisting) { // Tasks done only for NEW processes
proc->isUserlandThread = false;
proc->starttime_ctime = _psinfo->pr_start.tv_sec;
}
// Update proc and thread counts based on settings
if (proc->isKernelThread && !pl->settings->hideKernelThreads) {
pl->kernelThreads += proc->nlwp;
2020-10-31 22:28:02 +00:00
pl->totalTasks += proc->nlwp + 1;
2020-11-01 00:09:51 +00:00
if (proc->state == 'O') {
pl->runningTasks++;
}
} else if (!proc->isKernelThread) {
2020-11-01 00:09:51 +00:00
if (proc->state == 'O') {
pl->runningTasks++;
}
if (pl->settings->hideUserlandThreads) {
pl->totalTasks++;
} else {
pl->userlandThreads += proc->nlwp;
2020-10-31 22:28:02 +00:00
pl->totalTasks += proc->nlwp + 1;
}
}
proc->show = !(pl->settings->hideKernelThreads && proc->isKernelThread);
} else { // We are not in the master LWP, so jump to the LWP handling code
2020-10-31 22:28:02 +00:00
proc->percent_cpu = ((uint16_t)_lwpsinfo->pr_pctcpu / (double)32768) * (double)100.0;
proc->time = _lwpsinfo->pr_time.tv_sec;
if (!preExisting) { // Tasks done only for NEW LWPs
proc->isUserlandThread = true;
proc->ppid = _psinfo->pr_pid * 1024;
proc->tgid = _psinfo->pr_pid * 1024;
sproc->realppid = _psinfo->pr_pid;
sproc->realtgid = _psinfo->pr_pid;
proc->starttime_ctime = _lwpsinfo->pr_start.tv_sec;
}
// Top-level process only gets this for the representative LWP
if (proc->isKernelThread && !pl->settings->hideKernelThreads) {
2020-10-31 22:28:02 +00:00
proc->show = true;
}
if (!proc->isKernelThread && !pl->settings->hideUserlandThreads) {
2020-10-31 22:28:02 +00:00
proc->show = true;
}
} // Top-level LWP or subordinate LWP
// Common code pass 2
if (!preExisting) {
if ((sproc->realppid <= 0) && !(sproc->realpid <= 1)) {
proc->isKernelThread = true;
} else {
proc->isKernelThread = false;
}
Process_fillStarttimeBuffer(proc);
ProcessList_add(pl, proc);
}
2021-04-18 16:10:04 +00:00
proc->updated = true;
// End common code pass 2
return 0;
}
void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
SolarisProcessList_updateCPUcount(super);
SolarisProcessList_scanCPUTime(super);
SolarisProcessList_scanMemoryInfo(super);
SolarisProcessList_scanZfsArcstats(super);
// in pause mode only gather global data for meters (CPU/memory/...)
2020-11-01 00:09:51 +00:00
if (pauseProcessUpdate) {
return;
2020-11-01 00:09:51 +00:00
}
super->kernelThreads = 1;
proc_walk(&SolarisProcessList_walkproc, super, PR_WALK_LWP);
}
2021-06-12 20:04:37 +00:00
bool ProcessList_isCPUonline(const ProcessList* super, unsigned int id) {
assert(id < super->existingCPUs);
const SolarisProcessList* spl = (const SolarisProcessList*) super;
2021-06-12 20:04:37 +00:00
return (super->existingCPUs == 1) ? true : spl->cpus[id + 1].online;
2021-06-12 20:04:37 +00:00
}