From d8dfbbd37ca7855be44391697424edac9015f14f Mon Sep 17 00:00:00 2001 From: marcluque Date: Tue, 12 Oct 2021 00:45:09 +0200 Subject: Tidy up process state handling --- Process.c | 92 ++++++++++++++++------------------ Process.h | 36 +++++++------ darwin/DarwinProcess.c | 18 +++---- dragonflybsd/DragonFlyBSDProcessList.c | 37 +++++++------- freebsd/FreeBSDProcessList.c | 19 +++---- linux/LinuxProcessList.c | 24 +++++++-- netbsd/NetBSDProcessList.c | 29 +++++------ openbsd/OpenBSDProcessList.c | 19 +++---- pcp/PCPProcessList.c | 31 +++++++++--- solaris/SolarisProcessList.c | 19 +++++-- unsupported/UnsupportedProcessList.c | 2 +- 11 files changed, 189 insertions(+), 137 deletions(-) diff --git a/Process.c b/Process.c index eb4ca820..6be36b72 100644 --- a/Process.c +++ b/Process.c @@ -415,7 +415,7 @@ void Process_makeCommandStr(Process* this) { * - a user thread and showThreadNames is not set */ if (Process_isKernelThread(this)) return; - if (this->state == 'Z' && !this->mergedCommand.str) + if (this->state == ZOMBIE && !this->mergedCommand.str) return; if (Process_isUserlandThread(this) && settings->showThreadNames && (showThreadNames == mc->prevShowThreadNames)) return; @@ -749,6 +749,28 @@ void Process_printPercentage(float val, char* buffer, int n, int* attr) { } } +static inline char processStateChar(ProcessState state) { + switch (state) { + case UNKNOWN: return '?'; + case RUNNABLE: return 'U'; + case RUNNING: return 'R'; + case QUEUED: return 'Q'; + case WAITING: return 'W'; + case UNINTERRUPTIBLE_WAIT: return 'D'; + case BLOCKED: return 'B'; + case PAGING: return 'P'; + case STOPPED: return 'T'; + case TRACED: return 't'; + case ZOMBIE: return 'Z'; + case DEFUNCT: return 'X'; + case IDLE: return 'I'; + case SLEEPING: return 'S'; + default: + assert(0); + return '!'; + } +} + void Process_writeField(const Process* this, RichString* str, ProcessField field) { char buffer[256]; size_t n = sizeof(buffer); @@ -883,22 +905,32 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field case SESSION: xSnprintf(buffer, n, "%*d ", Process_pidDigits, this->session); break; case STARTTIME: xSnprintf(buffer, n, "%s", this->starttime_show); break; case STATE: - xSnprintf(buffer, n, "%c ", this->state); + xSnprintf(buffer, n, "%c ", processStateChar(this->state)); switch (this->state) { -#ifdef HTOP_NETBSD - case 'P': -#else - case 'R': -#endif + case RUNNABLE: + case RUNNING: + case TRACED: attr = CRT_colors[PROCESS_RUN_STATE]; break; - case 'D': + + case BLOCKED: + case DEFUNCT: + case STOPPED: + case ZOMBIE: attr = CRT_colors[PROCESS_D_STATE]; break; - case 'I': - case 'S': + + case QUEUED: + case WAITING: + case UNINTERRUPTIBLE_WAIT: + case IDLE: + case SLEEPING: attr = CRT_colors[PROCESS_SHADOW]; break; + + case UNKNOWN: + case PAGING: + break; } break; case ST_UID: xSnprintf(buffer, n, "%*d ", Process_uidDigits, this->st_uid); break; @@ -1072,44 +1104,6 @@ int Process_compare(const void* v1, const void* v2) { return (Settings_getActiveDirection(settings) == 1) ? result : -result; } -static uint8_t stateCompareValue(char state) { - switch (state) { - - case 'S': - return 10; - - case 'I': - return 9; - - case 'X': - return 8; - - case 'Z': - return 7; - - case 't': - return 6; - - case 'T': - return 5; - - case 'L': - return 4; - - case 'D': - return 3; - - case 'R': - return 2; - - case '?': - return 1; - - default: - return 0; - } -} - int Process_compareByKey_Base(const Process* p1, const Process* p2, ProcessField key) { int r; @@ -1164,7 +1158,7 @@ int Process_compareByKey_Base(const Process* p1, const Process* p2, ProcessField r = SPACESHIP_NUMBER(p1->starttime_ctime, p2->starttime_ctime); return r != 0 ? r : SPACESHIP_NUMBER(p1->pid, p2->pid); case STATE: - return SPACESHIP_NUMBER(stateCompareValue(p1->state), stateCompareValue(p2->state)); + return SPACESHIP_NUMBER(p1->state, p2->state); case ST_UID: return SPACESHIP_NUMBER(p1->st_uid, p2->st_uid); case TIME: diff --git a/Process.h b/Process.h index bbdcbf66..26f64349 100644 --- a/Process.h +++ b/Process.h @@ -60,6 +60,26 @@ typedef enum ProcessField_ { LAST_PROCESSFIELD } ProcessField; +/* Core process states (shared by platforms) + * NOTE: The enum has an ordering that is important! + * See processStateChar in process.c for ProcessSate -> letter mapping */ +typedef enum ProcessState_ { + UNKNOWN = 1, + RUNNABLE, + RUNNING, + QUEUED, + WAITING, + UNINTERRUPTIBLE_WAIT, + BLOCKED, + PAGING, + STOPPED, + TRACED, + ZOMBIE, + DEFUNCT, + IDLE, + SLEEPING +} ProcessState; + struct Settings_; /* Holds information about regions of the cmdline that should be @@ -202,20 +222,8 @@ typedef struct Process_ { /* Number of major faults the process has made which have required loading a memory page from disk */ unsigned long int majflt; - /* - * Process state (platform dependent): - * D - Waiting - * I - Idle - * L - Acquiring lock - * R - Running - * S - Sleeping - * T - Stopped (on a signal) - * X - Dead - * Z - Zombie - * t - Tracing stop - * ? - Unknown - */ - char state; + /* Process state enum field (platform dependent) */ + ProcessState state; /* Whether the process was updated during the current scan */ bool updated; diff --git a/darwin/DarwinProcess.c b/darwin/DarwinProcess.c index 43ca2d66..95ae960f 100644 --- a/darwin/DarwinProcess.c +++ b/darwin/DarwinProcess.c @@ -331,7 +331,7 @@ void DarwinProcess_setFromKInfoProc(Process* proc, const struct kinfo_proc* ps, proc->nice = ep->p_nice; proc->priority = ep->p_priority; - proc->state = (ep->p_stat == SZOMB) ? 'Z' : '?'; + proc->state = (ep->p_stat == SZOMB) ? ZOMBIE : UNKNOWN; /* Make sure the updated flag is set */ proc->updated = true; @@ -386,7 +386,7 @@ void DarwinProcess_scanThreads(DarwinProcess* dp) { return; } - if (proc->state == 'Z') { + if (proc->state == ZOMBIE) { return; } @@ -430,15 +430,15 @@ void DarwinProcess_scanThreads(DarwinProcess* dp) { vm_deallocate(mach_task_self(), (vm_address_t) thread_list, sizeof(thread_port_array_t) * thread_count); mach_port_deallocate(mach_task_self(), port); - char state = '?'; + /* Taken from: https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/osfmk/mach/thread_info.h#L129 */ switch (run_state) { - case TH_STATE_RUNNING: state = 'R'; break; - case TH_STATE_STOPPED: state = 'S'; break; - case TH_STATE_WAITING: state = 'W'; break; - case TH_STATE_UNINTERRUPTIBLE: state = 'U'; break; - case TH_STATE_HALTED: state = 'H'; break; + case TH_STATE_RUNNING: proc->state = RUNNING; break; + case TH_STATE_STOPPED: proc->state = STOPPED; break; + case TH_STATE_WAITING: proc->state = WAITING; break; + case TH_STATE_UNINTERRUPTIBLE: proc->state = UNINTERRUPTIBLE_WAIT; break; + case TH_STATE_HALTED: proc->state = BLOCKED; break; + default: proc->state = UNKNOWN; } - proc->state = state; } diff --git a/dragonflybsd/DragonFlyBSDProcessList.c b/dragonflybsd/DragonFlyBSDProcessList.c index e44c164a..b64af6aa 100644 --- a/dragonflybsd/DragonFlyBSDProcessList.c +++ b/dragonflybsd/DragonFlyBSDProcessList.c @@ -542,60 +542,61 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) { } // would be nice if we could store multiple states in proc->state (as enum) and have writeField render them + /* Taken from: https://github.com/DragonFlyBSD/DragonFlyBSD/blob/c163a4d7ee9c6857ee4e04a3a2cbb50c3de29da1/sys/sys/proc_common.h */ switch (kproc->kp_stat) { - case SIDL: proc->state = 'I'; isIdleProcess = true; break; + case SIDL: proc->state = IDLE; isIdleProcess = true; break; case SACTIVE: switch (kproc->kp_lwp.kl_stat) { case LSSLEEP: if (kproc->kp_lwp.kl_flags & LWP_SINTR) // interruptible wait short/long if (kproc->kp_lwp.kl_slptime >= MAXSLP) { - proc->state = 'I'; + proc->state = IDLE; isIdleProcess = true; } else { - proc->state = 'S'; + proc->state = SLEEPING; } else if (kproc->kp_lwp.kl_tdflags & TDF_SINTR) // interruptible lwkt wait - proc->state = 'S'; + proc->state = SLEEPING; else if (kproc->kp_paddr) // uninterruptible wait - proc->state = 'D'; + proc->state = UNINTERRUPTIBLE_WAIT; else // uninterruptible lwkt wait - proc->state = 'B'; + proc->state = UNINTERRUPTIBLE_WAIT; break; case LSRUN: if (kproc->kp_lwp.kl_stat == LSRUN) { if (!(kproc->kp_lwp.kl_tdflags & (TDF_RUNNING | TDF_RUNQ))) - proc->state = 'Q'; + proc->state = QUEUED; else - proc->state = 'R'; + proc->state = RUNNING; } break; case LSSTOP: - proc->state = 'T'; + proc->state = STOPPED; break; default: - proc->state = 'A'; + proc->state = PAGING; break; } break; - case SSTOP: proc->state = 'T'; break; - case SZOMB: proc->state = 'Z'; break; - case SCORE: proc->state = 'C'; break; - default: proc->state = '?'; + case SSTOP: proc->state = STOPPED; break; + case SZOMB: proc->state = ZOMBIE; break; + case SCORE: proc->state = BLOCKED; break; + default: proc->state = UNKNOWN; } if (kproc->kp_flags & P_SWAPPEDOUT) - proc->state = 'W'; + proc->state = SLEEPING; if (kproc->kp_flags & P_TRACED) - proc->state = 'T'; + proc->state = TRACED; if (kproc->kp_flags & P_JAILED) - proc->state = 'J'; + proc->state = TRACED; if (Process_isKernelThread(proc)) super->kernelThreads++; super->totalTasks++; - if (proc->state == 'R') + if (proc->state == RUNNING) super->runningTasks++; proc->show = ! ((hideKernelThreads && Process_isKernelThread(proc)) || (hideUserlandThreads && Process_isUserlandThread(proc))); diff --git a/freebsd/FreeBSDProcessList.c b/freebsd/FreeBSDProcessList.c index 9bbfccba..3bf4c29a 100644 --- a/freebsd/FreeBSDProcessList.c +++ b/freebsd/FreeBSDProcessList.c @@ -578,15 +578,16 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) { proc->nice = PRIO_MAX + 1 + kproc->ki_pri.pri_level - PRI_MIN_IDLE; } + /* Taken from: https://github.com/freebsd/freebsd-src/blob/1ad2d87778970582854082bcedd2df0394fd4933/sys/sys/proc.h#L851 */ switch (kproc->ki_stat) { - case SIDL: proc->state = 'I'; break; - case SRUN: proc->state = 'R'; break; - case SSLEEP: proc->state = 'S'; break; - case SSTOP: proc->state = 'T'; break; - case SZOMB: proc->state = 'Z'; break; - case SWAIT: proc->state = 'D'; break; - case SLOCK: proc->state = 'L'; break; - default: proc->state = '?'; + case SIDL: proc->state = IDLE; break; + case SRUN: proc->state = RUNNING; break; + case SSLEEP: proc->state = SLEEPING; break; + case SSTOP: proc->state = STOPPED; break; + case SZOMB: proc->state = ZOMBIE; break; + case SWAIT: proc->state = WAITING; break; + case SLOCK: proc->state = BLOCKED; break; + default: proc->state = UNKNOWN; } if (Process_isKernelThread(proc)) @@ -595,7 +596,7 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) { proc->show = ! ((hideKernelThreads && Process_isKernelThread(proc)) || (hideUserlandThreads && Process_isUserlandThread(proc))); super->totalTasks++; - if (proc->state == 'R') + if (proc->state == RUNNING) super->runningTasks++; proc->updated = true; } diff --git a/linux/LinuxProcessList.c b/linux/LinuxProcessList.c index d99cc00e..377dd7e6 100644 --- a/linux/LinuxProcessList.c +++ b/linux/LinuxProcessList.c @@ -310,6 +310,22 @@ static inline unsigned long long LinuxProcessList_adjustTime(unsigned long long return t * 100 / jiffy; } +/* Taken from: https://github.com/torvalds/linux/blob/64570fbc14f8d7cb3fe3995f20e26bc25ce4b2cc/fs/proc/array.c#L120 */ +static inline ProcessState LinuxProcessList_getProcessState(char state) { + switch (state) { + case 'S': return SLEEPING; + case 'X': return DEFUNCT; + case 'Z': return ZOMBIE; + case 't': return TRACED; + case 'T': return STOPPED; + case 'D': return UNINTERRUPTIBLE_WAIT; + case 'R': return RUNNING; + case 'P': return BLOCKED; + case 'I': return IDLE; + default: return UNKNOWN; + } +} + static bool LinuxProcessList_readStatFile(Process* process, openat_arg_t procFd, char* command, size_t commLen) { LinuxProcess* lp = (LinuxProcess*) process; @@ -335,7 +351,7 @@ static bool LinuxProcessList_readStatFile(Process* process, openat_arg_t procFd, location = end + 2; /* (3) state - %c */ - process->state = location[0]; + process->state = LinuxProcessList_getProcessState(location[0]); location += 2; /* (4) ppid - %d */ @@ -1098,7 +1114,7 @@ static bool LinuxProcessList_readCmdlineFile(Process* process, openat_arg_t proc return false; if (amtRead == 0) { - if (process->state != 'Z') { + if (process->state != ZOMBIE) { process->isKernelThread = true; } Process_updateCmdline(process, NULL, 0, 0); @@ -1511,7 +1527,7 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, openat_arg_ ProcessList_add(pl, proc); } else { - if (settings->updateProcessNames && proc->state != 'Z') { + if (settings->updateProcessNames && proc->state != ZOMBIE) { if (! LinuxProcessList_readCmdlineFile(proc, procFd)) { goto errorReadingProcess; } @@ -1549,7 +1565,7 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, openat_arg_ } if (!proc->cmdline && statCommand[0] && - (proc->state == 'Z' || Process_isKernelThread(proc) || settings->showThreadNames)) { + (proc->state == ZOMBIE || Process_isKernelThread(proc) || settings->showThreadNames)) { Process_updateCmdline(proc, statCommand, 0, strlen(statCommand)); } diff --git a/netbsd/NetBSDProcessList.c b/netbsd/NetBSDProcessList.c index 379a491b..ab0f0b75 100644 --- a/netbsd/NetBSDProcessList.c +++ b/netbsd/NetBSDProcessList.c @@ -331,31 +331,33 @@ static void NetBSDProcessList_scanProcs(NetBSDProcessList* this) { int nlwps = 0; const struct kinfo_lwp* klwps = kvm_getlwps(this->kd, kproc->p_pid, kproc->p_paddr, sizeof(struct kinfo_lwp), &nlwps); + /* TODO: According to the link below, SDYING should be a regarded state */ + /* Taken from: https://ftp.netbsd.org/pub/NetBSD/NetBSD-current/src/sys/sys/proc.h */ switch (kproc->p_realstat) { - case SIDL: proc->state = 'I'; break; + case SIDL: proc->state = IDLE; break; case SACTIVE: // We only consider the first LWP with a one of the below states. for (int j = 0; j < nlwps; j++) { if (klwps) { switch (klwps[j].l_stat) { - case LSONPROC: proc->state = 'P'; break; - case LSRUN: proc->state = 'R'; break; - case LSSLEEP: proc->state = 'S'; break; - case LSSTOP: proc->state = 'T'; break; - default: proc->state = '?'; + case LSONPROC: proc->state = RUNNING; break; + case LSRUN: proc->state = RUNNABLE; break; + case LSSLEEP: proc->state = SLEEPING; break; + case LSSTOP: proc->state = STOPPED; break; + default: proc->state = UNKNOWN; } - if (proc->state != '?') + if (proc->state != UNKNOWN) break; } else { - proc->state = '?'; + proc->state = UNKNOWN; break; } } break; - case SSTOP: proc->state = 'T'; break; - case SZOMB: proc->state = 'Z'; break; - case SDEAD: proc->state = 'D'; break; - default: proc->state = '?'; + case SSTOP: proc->state = STOPPED; break; + case SZOMB: proc->state = ZOMBIE; break; + case SDEAD: proc->state = DEFUNCT; break; + default: proc->state = UNKNOWN; } if (Process_isKernelThread(proc)) { @@ -365,8 +367,7 @@ static void NetBSDProcessList_scanProcs(NetBSDProcessList* this) { } this->super.totalTasks++; - // SRUN ('R') means runnable, not running - if (proc->state == 'P') { + if (proc->state == RUNNING) { this->super.runningTasks++; } proc->updated = true; diff --git a/openbsd/OpenBSDProcessList.c b/openbsd/OpenBSDProcessList.c index 6f79a775..af7879e3 100644 --- a/openbsd/OpenBSDProcessList.c +++ b/openbsd/OpenBSDProcessList.c @@ -345,15 +345,16 @@ static void OpenBSDProcessList_scanProcs(OpenBSDProcessList* this) { proc->user = UsersTable_getRef(this->super.usersTable, proc->st_uid); } + /* Taken from: https://github.com/openbsd/src/blob/6a38af0976a6870911f4b2de19d8da28723a5778/sys/sys/proc.h#L420 */ switch (kproc->p_stat) { - case SIDL: proc->state = 'I'; 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 = 'R'; break; - default: proc->state = '?'; + case SIDL: proc->state = IDLE; break; + case SRUN: proc->state = RUNNABLE; break; + case SSLEEP: proc->state = SLEEPING; break; + case SSTOP: proc->state = STOPPED; break; + case SZOMB: proc->state = ZOMBIE; break; + case SDEAD: proc->state = DEFUNCT; break; + case SONPROC: proc->state = RUNNING; break; + default: proc->state = UNKNOWN; } if (Process_isKernelThread(proc)) { @@ -363,7 +364,7 @@ static void OpenBSDProcessList_scanProcs(OpenBSDProcessList* this) { } this->super.totalTasks++; - if (proc->state == 'R') { + if (proc->state == RUNNING) { this->super.runningTasks++; } diff --git a/pcp/PCPProcessList.c b/pcp/PCPProcessList.c index 554e43d4..8d866116 100644 --- a/pcp/PCPProcessList.c +++ b/pcp/PCPProcessList.c @@ -142,10 +142,27 @@ static inline char Metric_instance_char(int metric, int pid, int offset, char fa return fallback; } +static inline PCPProcessList_getProcessState(char state) { + switch (state) { + case '?': return UNKNOWN; + case 'R': return RUNNING; + case 'W': return WAITING; + case 'D': return UNINTERRUPTIBLE_WAIT; + case 'P': return PAGING; + case 'T': return STOPPED; + case 't': return TRACED; + case 'Z': return ZOMBIE; + case 'X': return DEFUNCT; + case 'I': return IDLE; + case 'S': return SLEEPING; + default: return UNKNOWN; + } +} + static void PCPProcessList_updateID(Process* process, int pid, int offset) { process->tgid = Metric_instance_u32(PCP_PROC_TGID, pid, offset, 1); process->ppid = Metric_instance_u32(PCP_PROC_PPID, pid, offset, 1); - process->state = Metric_instance_char(PCP_PROC_STATE, pid, offset, '?'); + process->state = PCPProcessList_getProcessState(Metric_instance_char(PCP_PROC_STATE, pid, offset, '?')); } static void PCPProcessList_updateInfo(Process* process, int pid, int offset, char* command, size_t commLen) { @@ -283,7 +300,7 @@ static void PCPProcessList_updateUsername(Process* process, int pid, int offset, static void PCPProcessList_updateCmdline(Process* process, int pid, int offset, const char* comm) { pmAtomValue value; if (!PCPMetric_instance(PCP_PROC_PSARGS, pid, offset, &value, PM_TYPE_STRING)) { - if (process->state != 'Z') + if (process->state != ZOMBIE) process->isKernelThread = true; Process_updateCmdline(process, NULL, 0, 0); return; @@ -351,7 +368,7 @@ static bool PCPProcessList_updateProcesses(PCPProcessList* this, double period, if (preExisting && hideKernelThreads && Process_isKernelThread(proc)) { proc->updated = true; proc->show = false; - if (proc->state == 'R') + if (proc->state == RUNNING) pl->runningTasks++; pl->kernelThreads++; pl->totalTasks++; @@ -360,7 +377,7 @@ static bool PCPProcessList_updateProcesses(PCPProcessList* this, double period, if (preExisting && hideUserlandThreads && Process_isUserlandThread(proc)) { proc->updated = true; proc->show = false; - if (proc->state == 'R') + if (proc->state == RUNNING) pl->runningTasks++; pl->userlandThreads++; pl->totalTasks++; @@ -398,7 +415,7 @@ static bool PCPProcessList_updateProcesses(PCPProcessList* this, double period, PCPProcessList_updateCmdline(proc, pid, offset, command); Process_fillStarttimeBuffer(proc); ProcessList_add(pl, proc); - } else if (settings->updateProcessNames && proc->state != 'Z') { + } else if (settings->updateProcessNames && proc->state != ZOMBIE) { PCPProcessList_updateCmdline(proc, pid, offset, command); } @@ -420,7 +437,7 @@ static bool PCPProcessList_updateProcesses(PCPProcessList* this, double period, if (settings->flags & PROCESS_FLAG_LINUX_AUTOGROUP) PCPProcessList_readAutogroup(pp, pid, offset); - if (proc->state == 'Z' && !proc->cmdline && command[0]) { + if (proc->state == ZOMBIE && !proc->cmdline && command[0]) { Process_updateCmdline(proc, command, 0, strlen(command)); } else if (Process_isThread(proc)) { if ((settings->showThreadNames || Process_isKernelThread(proc)) && command[0]) { @@ -439,7 +456,7 @@ static bool PCPProcessList_updateProcesses(PCPProcessList* this, double period, (hideUserlandThreads && Process_isUserlandThread(proc))); pl->totalTasks++; - if (proc->state == 'R') + if (proc->state == RUNNING) pl->runningTasks++; proc->updated = true; } diff --git a/solaris/SolarisProcessList.c b/solaris/SolarisProcessList.c index 33c64777..71e85fcb 100644 --- a/solaris/SolarisProcessList.c +++ b/solaris/SolarisProcessList.c @@ -363,6 +363,19 @@ static void SolarisProcessList_updateCwd(pid_t pid, Process* proc) { free_and_xStrdup(&proc->procCwd, target); } +/* Taken from: https://docs.oracle.com/cd/E19253-01/817-6223/6mlkidlom/index.html#tbl-sched-state */ +static inline ProcessState SolarisProcessList_getProcessState(char state) { + switch (state) { + case 'S': return SLEEPING; + case 'R': return RUNNABLE; + case 'O': return RUNNING; + case 'Z': return ZOMBIE; + case 'T': return STOPPED; + case 'I': return IDLE; + default: return UNKNOWN; + } +} + /* 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 @@ -402,7 +415,7 @@ static int SolarisProcessList_walkproc(psinfo_t* _psinfo, lwpsinfo_t* _lwpsinfo, proc->priority = _lwpsinfo->pr_pri; proc->nice = _lwpsinfo->pr_nice - NZERO; proc->processor = _lwpsinfo->pr_onpro; - proc->state = _lwpsinfo->pr_sname; + proc->state = SolarisProcessList_getProcessState(_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) @@ -462,11 +475,11 @@ static int SolarisProcessList_walkproc(psinfo_t* _psinfo, lwpsinfo_t* _lwpsinfo, if (proc->isKernelThread && !pl->settings->hideKernelThreads) { pl->kernelThreads += proc->nlwp; pl->totalTasks += proc->nlwp + 1; - if (proc->state == 'O') { + if (proc->state == RUNNING) { pl->runningTasks++; } } else if (!proc->isKernelThread) { - if (proc->state == 'O') { + if (proc->state == RUNNING) { pl->runningTasks++; } if (pl->settings->hideUserlandThreads) { diff --git a/unsupported/UnsupportedProcessList.c b/unsupported/UnsupportedProcessList.c index 470c65b7..b64de411 100644 --- a/unsupported/UnsupportedProcessList.c +++ b/unsupported/UnsupportedProcessList.c @@ -57,7 +57,7 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) { proc->updated = true; - proc->state = 'R'; + proc->state = RUNNING; proc->isKernelThread = false; proc->isUserlandThread = false; proc->show = true; /* Reflected in proc->settings-> "hideXXX" really */ -- cgit v1.2.3