xref: /freebsd/usr.bin/top/machine.c (revision db36566345d3516bab3774cd4d252e64ba8d41ee)
1511d9c65SJoerg Wunsch /*
2511d9c65SJoerg Wunsch  * top - a top users display for Unix
3511d9c65SJoerg Wunsch  *
4511d9c65SJoerg Wunsch  * DESCRIPTION:
5511d9c65SJoerg Wunsch  * Originally written for BSD4.4 system by Christos Zoulas.
6511d9c65SJoerg Wunsch  * Ported to FreeBSD 2.x by Steven Wallace && Wolfram Schneider
7f3b2c2d1SWolfram Schneider  * Order support hacked in from top-3.5beta6/machine/m_aix41.c
8f3b2c2d1SWolfram Schneider  *   by Monte Mitzelfelt (for latest top see http://www.groupsys.com/topinfo/)
9511d9c65SJoerg Wunsch  *
10511d9c65SJoerg Wunsch  * AUTHOR:  Christos Zoulas <christos@ee.cornell.edu>
118d0d2676SEitan Adler  *          Steven Wallace  <swallace@FreeBSD.org>
12511d9c65SJoerg Wunsch  *          Wolfram Schneider <wosch@FreeBSD.org>
1339d513ecSRobert Watson  *          Thomas Moestl <tmoestl@gmx.net>
148d0d2676SEitan Adler  *          Eitan Adler <eadler@FreeBSD.org>
15511d9c65SJoerg Wunsch  *
16c3aac50fSPeter Wemm  * $FreeBSD$
17511d9c65SJoerg Wunsch  */
18511d9c65SJoerg Wunsch 
19511d9c65SJoerg Wunsch #include <sys/errno.h>
208d0d2676SEitan Adler #include <sys/fcntl.h>
219f8096e3SEitan Adler #include <sys/param.h>
228d0d2676SEitan Adler #include <sys/priority.h>
23511d9c65SJoerg Wunsch #include <sys/proc.h>
24e5aff02fSPeter Wemm #include <sys/resource.h>
2551c834c4SEitan Adler #include <sys/sbuf.h>
26cd23263cSDag-Erling Smørgrav #include <sys/sysctl.h>
27cd23263cSDag-Erling Smørgrav #include <sys/time.h>
28cd23263cSDag-Erling Smørgrav #include <sys/user.h>
29511d9c65SJoerg Wunsch 
30666cf873SEitan Adler #include <assert.h>
31d9b2153bSSergey Kandaurov #include <err.h>
32ac8f40eaSEitan Adler #include <libgen.h>
33cd23263cSDag-Erling Smørgrav #include <kvm.h>
34cd23263cSDag-Erling Smørgrav #include <math.h>
354946a00bSDag-Erling Smørgrav #include <paths.h>
36cd23263cSDag-Erling Smørgrav #include <stdio.h>
370b2f6ed1SEitan Adler #include <stdbool.h>
388d0d2676SEitan Adler #include <stdint.h>
39511d9c65SJoerg Wunsch #include <stdlib.h>
4042649453SStefan Farfeleder #include <string.h>
418d0d2676SEitan Adler #include <time.h>
4239d513ecSRobert Watson #include <unistd.h>
43faac60c8SStanislav Sedov #include <vis.h>
44511d9c65SJoerg Wunsch 
45511d9c65SJoerg Wunsch #include "top.h"
46fcfaa473SEitan Adler #include "display.h"
4747ffa267SEitan Adler #include "machine.h"
4847ffa267SEitan Adler #include "loadavg.h"
497f18d5d3SJohn Baldwin #include "screen.h"
5039d513ecSRobert Watson #include "utils.h"
5103117570SPeter Wemm #include "layout.h"
52511d9c65SJoerg Wunsch 
5339d513ecSRobert Watson #define GETSYSCTL(name, var) getsysctl(name, &(var), sizeof(var))
5439d513ecSRobert Watson 
55fcfaa473SEitan Adler extern struct timeval timeout;
5694154ff8SPeter Wemm static int smpmode;
57db6bb7fcSAlfred Perlstein enum displaymodes displaymode;
5851c834c4SEitan Adler static const int namelength = 10;
59069f49cfSBryan Drewery /* TOP_JID_LEN based on max of 999999 */
6051c834c4SEitan Adler #define TOP_JID_LEN 6
6151c834c4SEitan Adler #define TOP_SWAP_LEN 5
627f18d5d3SJohn Baldwin static int cmdlengthdelta;
63511d9c65SJoerg Wunsch 
64511d9c65SJoerg Wunsch /* get_process_info passes back a handle.  This is what it looks like: */
65511d9c65SJoerg Wunsch 
66789e3877SBruce Evans struct handle {
67511d9c65SJoerg Wunsch 	struct kinfo_proc **next_proc;	/* points to next valid proc pointer */
68511d9c65SJoerg Wunsch 	int remaining;			/* number of pointers remaining */
69511d9c65SJoerg Wunsch };
70511d9c65SJoerg Wunsch 
71511d9c65SJoerg Wunsch 
72511d9c65SJoerg Wunsch /* define what weighted cpu is.  */
731f7d2501SKirk McKusick #define weighted_cpu(pct, pp) ((pp)->ki_swtime == 0 ? 0.0 : \
741f7d2501SKirk McKusick 			 ((pct) / (1.0 - exp((pp)->ki_swtime * logcpu))))
75511d9c65SJoerg Wunsch 
76511d9c65SJoerg Wunsch /* what we consider to be process size: */
771f7d2501SKirk McKusick #define PROCSIZE(pp) ((pp)->ki_size / 1024)
78511d9c65SJoerg Wunsch 
79db6bb7fcSAlfred Perlstein #define RU(pp)	(&(pp)->ki_rusage)
80db6bb7fcSAlfred Perlstein 
81a9053954SJohn Baldwin #define	PCTCPU(pp) (pcpu[pp - pbase])
82db6bb7fcSAlfred Perlstein 
83511d9c65SJoerg Wunsch /* process state names for the "STATE" column of the display */
84511d9c65SJoerg Wunsch /* the extra nulls in the string "run" are for adding a slash and
85511d9c65SJoerg Wunsch    the processor number when needed */
86511d9c65SJoerg Wunsch 
87960a7f39SEitan Adler static const char *state_abbrev[] = {
880d632649SJohn Baldwin 	"", "START", "RUN\0\0\0", "SLEEP", "STOP", "ZOMB", "WAIT", "LOCK"
89511d9c65SJoerg Wunsch };
90511d9c65SJoerg Wunsch 
91511d9c65SJoerg Wunsch 
92511d9c65SJoerg Wunsch static kvm_t *kd;
93511d9c65SJoerg Wunsch 
94511d9c65SJoerg Wunsch /* values that we stash away in _init and use in later routines */
95511d9c65SJoerg Wunsch 
96511d9c65SJoerg Wunsch static double logcpu;
97511d9c65SJoerg Wunsch 
98511d9c65SJoerg Wunsch /* these are retrieved from the kernel in _init */
99511d9c65SJoerg Wunsch 
100511d9c65SJoerg Wunsch static load_avg  ccpu;
101511d9c65SJoerg Wunsch 
10239d513ecSRobert Watson /* these are used in the get_ functions */
103511d9c65SJoerg Wunsch 
10439d513ecSRobert Watson static int lastpid;
105511d9c65SJoerg Wunsch 
106511d9c65SJoerg Wunsch /* these are for calculating cpu state percentages */
107511d9c65SJoerg Wunsch 
108511d9c65SJoerg Wunsch static long cp_time[CPUSTATES];
109511d9c65SJoerg Wunsch static long cp_old[CPUSTATES];
110511d9c65SJoerg Wunsch static long cp_diff[CPUSTATES];
111511d9c65SJoerg Wunsch 
112511d9c65SJoerg Wunsch /* these are for detailing the process states */
113511d9c65SJoerg Wunsch 
1149f8096e3SEitan Adler static const char *procstatenames[] = {
115511d9c65SJoerg Wunsch 	"", " starting, ", " running, ", " sleeping, ", " stopped, ",
1160d632649SJohn Baldwin 	" zombie, ", " waiting, ", " lock, ",
117511d9c65SJoerg Wunsch 	NULL
118511d9c65SJoerg Wunsch };
119eae589f1SEitan Adler static int process_states[nitems(procstatenames)];
120511d9c65SJoerg Wunsch 
121511d9c65SJoerg Wunsch /* these are for detailing the cpu states */
122511d9c65SJoerg Wunsch 
123a5ca08edSEitan Adler static int cpu_states[CPUSTATES];
1249f8096e3SEitan Adler static const char *cpustatenames[] = {
125511d9c65SJoerg Wunsch 	"user", "nice", "system", "interrupt", "idle", NULL
126511d9c65SJoerg Wunsch };
127511d9c65SJoerg Wunsch 
128511d9c65SJoerg Wunsch /* these are for detailing the memory statistics */
129511d9c65SJoerg Wunsch 
1309f8096e3SEitan Adler static const char *memorynames[] = {
131cc59e3a7SMark Johnston 	"K Active, ", "K Inact, ", "K Laundry, ", "K Wired, ", "K Buf, ",
132789e3877SBruce Evans 	"K Free", NULL
133511d9c65SJoerg Wunsch };
134eae589f1SEitan Adler static int memory_stats[nitems(memorynames)];
135511d9c65SJoerg Wunsch 
1369f8096e3SEitan Adler static const char *arcnames[] = {
137b49af68cSJohn Baldwin 	"K Total, ", "K MFU, ", "K MRU, ", "K Anon, ", "K Header, ", "K Other",
1382e52fb92SJohn Baldwin 	NULL
1392e52fb92SJohn Baldwin };
140eae589f1SEitan Adler static int arc_stats[nitems(arcnames)];
1412e52fb92SJohn Baldwin 
1429f8096e3SEitan Adler static const char *carcnames[] = {
143d9a72328SAllan Jude 	"K Compressed, ", "K Uncompressed, ", ":1 Ratio, ",
1441dbfa4b5SAllan Jude 	NULL
1451dbfa4b5SAllan Jude };
146eae589f1SEitan Adler static int carc_stats[nitems(carcnames)];
1471dbfa4b5SAllan Jude 
1489f8096e3SEitan Adler static const char *swapnames[] = {
149511d9c65SJoerg Wunsch 	"K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out",
150511d9c65SJoerg Wunsch 	NULL
151511d9c65SJoerg Wunsch };
152eae589f1SEitan Adler static int swap_stats[nitems(swapnames)];
153511d9c65SJoerg Wunsch 
154511d9c65SJoerg Wunsch 
155511d9c65SJoerg Wunsch /* these are for keeping track of the proc array */
156511d9c65SJoerg Wunsch 
157511d9c65SJoerg Wunsch static int nproc;
158511d9c65SJoerg Wunsch static int onproc = -1;
159511d9c65SJoerg Wunsch static int pref_len;
160511d9c65SJoerg Wunsch static struct kinfo_proc *pbase;
161511d9c65SJoerg Wunsch static struct kinfo_proc **pref;
162db6bb7fcSAlfred Perlstein static struct kinfo_proc *previous_procs;
163db6bb7fcSAlfred Perlstein static struct kinfo_proc **previous_pref;
164db6bb7fcSAlfred Perlstein static int previous_proc_count = 0;
165db6bb7fcSAlfred Perlstein static int previous_proc_count_max = 0;
166a9053954SJohn Baldwin static int previous_thread;
167a9053954SJohn Baldwin 
168a9053954SJohn Baldwin /* data used for recalculating pctcpu */
169a9053954SJohn Baldwin static double *pcpu;
170a9053954SJohn Baldwin static struct timespec proc_uptime;
171a9053954SJohn Baldwin static struct timeval proc_wall_time;
172a9053954SJohn Baldwin static struct timeval previous_wall_time;
173a9053954SJohn Baldwin static uint64_t previous_interval = 0;
174511d9c65SJoerg Wunsch 
1757fe9a86aSAlfred Perlstein /* total number of io operations */
1767fe9a86aSAlfred Perlstein static long total_inblock;
1777fe9a86aSAlfred Perlstein static long total_oublock;
1787fe9a86aSAlfred Perlstein static long total_majflt;
1797fe9a86aSAlfred Perlstein 
180511d9c65SJoerg Wunsch /* these are for getting the memory statistics */
181511d9c65SJoerg Wunsch 
182a9053954SJohn Baldwin static int arc_enabled;
1831dbfa4b5SAllan Jude static int carc_enabled;
184511d9c65SJoerg Wunsch static int pageshift;		/* log base 2 of the pagesize */
185511d9c65SJoerg Wunsch 
186511d9c65SJoerg Wunsch /* define pagetok in terms of pageshift */
187511d9c65SJoerg Wunsch 
188511d9c65SJoerg Wunsch #define pagetok(size) ((size) << pageshift)
189511d9c65SJoerg Wunsch 
190b6924c93SDag-Erling Smørgrav /* swap usage */
191b6924c93SDag-Erling Smørgrav #define ki_swap(kip) \
192b6924c93SDag-Erling Smørgrav     ((kip)->ki_swrss > (kip)->ki_rssize ? (kip)->ki_swrss - (kip)->ki_rssize : 0)
193b6924c93SDag-Erling Smørgrav 
19426b2243aSGiorgos Keramidas /*
19532efd263SGiorgos Keramidas  * Sorting orders.  The first element is the default.
19626b2243aSGiorgos Keramidas  */
1971d5b01e6SEitan Adler static const char *ordernames[] = {
19832efd263SGiorgos Keramidas 	"cpu", "size", "res", "time", "pri", "threads",
1996000ced1SRong-En Fan 	"total", "read", "write", "fault", "vcsw", "ivcsw",
200b6924c93SDag-Erling Smørgrav 	"jid", "swap", "pid", NULL
20126b2243aSGiorgos Keramidas };
202f3b2c2d1SWolfram Schneider 
20303117570SPeter Wemm /* Per-cpu time states */
20403117570SPeter Wemm static int maxcpu;
20503117570SPeter Wemm static int maxid;
20603117570SPeter Wemm static int ncpus;
207cda7a5d5SEitan Adler static unsigned long cpumask;
20803117570SPeter Wemm static long *times;
20903117570SPeter Wemm static long *pcpu_cp_time;
21003117570SPeter Wemm static long *pcpu_cp_old;
21103117570SPeter Wemm static long *pcpu_cp_diff;
21203117570SPeter Wemm static int *pcpu_cpu_states;
21303117570SPeter Wemm 
214b6924c93SDag-Erling Smørgrav static int compare_swap(const void *a, const void *b);
2156000ced1SRong-En Fan static int compare_jid(const void *a, const void *b);
216de916c8bSBruce Evans static int compare_pid(const void *a, const void *b);
2172417d97eSJohn Baldwin static int compare_tid(const void *a, const void *b);
218de916c8bSBruce Evans static const char *format_nice(const struct kinfo_proc *pp);
219de916c8bSBruce Evans static void getsysctl(const char *name, void *ptr, size_t len);
220de916c8bSBruce Evans static int swapmode(int *retavail, int *retfree);
2212e52fb92SJohn Baldwin static void update_layout(void);
222f9995000SPietro Cerutti static int find_uid(uid_t needle, int *haystack);
223f9995000SPietro Cerutti 
224f9995000SPietro Cerutti static int
225f9995000SPietro Cerutti find_uid(uid_t needle, int *haystack)
226f9995000SPietro Cerutti {
227f9995000SPietro Cerutti 	size_t i = 0;
228f9995000SPietro Cerutti 
229f9995000SPietro Cerutti 	for (; i < TOP_MAX_UIDS; ++i)
230f9995000SPietro Cerutti 		if ((uid_t)haystack[i] == needle)
231f9995000SPietro Cerutti 			return 1;
232d408c8f7SEitan Adler 	return (0);
233f9995000SPietro Cerutti }
234de916c8bSBruce Evans 
23551f202e9SJohn Baldwin void
236fcc3d62fSJohn Baldwin toggle_pcpustats(void)
23751f202e9SJohn Baldwin {
23851f202e9SJohn Baldwin 
23951f202e9SJohn Baldwin 	if (ncpus == 1)
24051f202e9SJohn Baldwin 		return;
2412e52fb92SJohn Baldwin 	update_layout();
2422e52fb92SJohn Baldwin }
24351f202e9SJohn Baldwin 
2442e52fb92SJohn Baldwin /* Adjust display based on ncpus and the ARC state. */
2452e52fb92SJohn Baldwin static void
2462e52fb92SJohn Baldwin update_layout(void)
2472e52fb92SJohn Baldwin {
2482e52fb92SJohn Baldwin 
24951f202e9SJohn Baldwin 	y_mem = 3;
25054900c9bSJohn Baldwin 	y_arc = 4;
2511dbfa4b5SAllan Jude 	y_carc = 5;
2521dbfa4b5SAllan Jude 	y_swap = 4 + arc_enabled + carc_enabled;
2531dbfa4b5SAllan Jude 	y_idlecursor = 5 + arc_enabled + carc_enabled;
2541dbfa4b5SAllan Jude 	y_message = 5 + arc_enabled + carc_enabled;
2551dbfa4b5SAllan Jude 	y_header = 6 + arc_enabled + carc_enabled;
2561dbfa4b5SAllan Jude 	y_procs = 7 + arc_enabled + carc_enabled;
2571dbfa4b5SAllan Jude 	Header_lines = 7 + arc_enabled + carc_enabled;
2582e52fb92SJohn Baldwin 
2592e52fb92SJohn Baldwin 	if (pcpu_stats) {
26054900c9bSJohn Baldwin 		y_mem += ncpus - 1;
26154900c9bSJohn Baldwin 		y_arc += ncpus - 1;
2621dbfa4b5SAllan Jude 		y_carc += ncpus - 1;
2632e52fb92SJohn Baldwin 		y_swap += ncpus - 1;
2642e52fb92SJohn Baldwin 		y_idlecursor += ncpus - 1;
2652e52fb92SJohn Baldwin 		y_message += ncpus - 1;
2662e52fb92SJohn Baldwin 		y_header += ncpus - 1;
2672e52fb92SJohn Baldwin 		y_procs += ncpus - 1;
2682e52fb92SJohn Baldwin 		Header_lines += ncpus - 1;
26951f202e9SJohn Baldwin 	}
27051f202e9SJohn Baldwin }
27151f202e9SJohn Baldwin 
272511d9c65SJoerg Wunsch int
2734b9ca404SEitan Adler machine_init(struct statics *statics)
274511d9c65SJoerg Wunsch {
27551f202e9SJohn Baldwin 	int i, j, empty, pagesize;
2762e52fb92SJohn Baldwin 	uint64_t arc_size;
27721e289d4SAllan Jude 	int carc_en;
27851f202e9SJohn Baldwin 	size_t size;
27994154ff8SPeter Wemm 
28051f202e9SJohn Baldwin 	size = sizeof(smpmode);
28151f202e9SJohn Baldwin 	if ((sysctlbyname("machdep.smp_active", &smpmode, &size,
282789e3877SBruce Evans 	    NULL, 0) != 0 &&
28351f202e9SJohn Baldwin 	    sysctlbyname("kern.smp.active", &smpmode, &size,
284789e3877SBruce Evans 	    NULL, 0) != 0) ||
28551f202e9SJohn Baldwin 	    size != sizeof(smpmode))
28694154ff8SPeter Wemm 		smpmode = 0;
287511d9c65SJoerg Wunsch 
2881dbfa4b5SAllan Jude 	size = sizeof(arc_size);
2892e52fb92SJohn Baldwin 	if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
2902e52fb92SJohn Baldwin 	    NULL, 0) == 0 && arc_size != 0)
2912e52fb92SJohn Baldwin 		arc_enabled = 1;
2928781788dSMark Johnston 	size = sizeof(carc_en);
2938781788dSMark Johnston 	if (arc_enabled &&
2948781788dSMark Johnston 	    sysctlbyname("vfs.zfs.compressed_arc_enabled", &carc_en, &size,
2958781788dSMark Johnston 	    NULL, 0) == 0 && carc_en == 1)
2968781788dSMark Johnston 		carc_enabled = 1;
2972e52fb92SJohn Baldwin 
2984946a00bSDag-Erling Smørgrav 	kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
2994946a00bSDag-Erling Smørgrav 	if (kd == NULL)
3004946a00bSDag-Erling Smørgrav 		return (-1);
301511d9c65SJoerg Wunsch 
30239d513ecSRobert Watson 	GETSYSCTL("kern.ccpu", ccpu);
303511d9c65SJoerg Wunsch 
304511d9c65SJoerg Wunsch 	/* this is used in calculating WCPU -- calculate it ahead of time */
305511d9c65SJoerg Wunsch 	logcpu = log(loaddouble(ccpu));
306511d9c65SJoerg Wunsch 
307511d9c65SJoerg Wunsch 	pbase = NULL;
308511d9c65SJoerg Wunsch 	pref = NULL;
309a9053954SJohn Baldwin 	pcpu = NULL;
310511d9c65SJoerg Wunsch 	nproc = 0;
311511d9c65SJoerg Wunsch 	onproc = -1;
312789e3877SBruce Evans 
313789e3877SBruce Evans 	/* get the page size and calculate pageshift from it */
314511d9c65SJoerg Wunsch 	pagesize = getpagesize();
315511d9c65SJoerg Wunsch 	pageshift = 0;
3164946a00bSDag-Erling Smørgrav 	while (pagesize > 1) {
317511d9c65SJoerg Wunsch 		pageshift++;
318511d9c65SJoerg Wunsch 		pagesize >>= 1;
319511d9c65SJoerg Wunsch 	}
320511d9c65SJoerg Wunsch 
321511d9c65SJoerg Wunsch 	/* we only need the amount of log(2)1024 for our conversion */
322511d9c65SJoerg Wunsch 	pageshift -= LOG1024;
323511d9c65SJoerg Wunsch 
324511d9c65SJoerg Wunsch 	/* fill in the statics information */
325511d9c65SJoerg Wunsch 	statics->procstate_names = procstatenames;
326511d9c65SJoerg Wunsch 	statics->cpustate_names = cpustatenames;
327511d9c65SJoerg Wunsch 	statics->memory_names = memorynames;
3282e52fb92SJohn Baldwin 	if (arc_enabled)
3292e52fb92SJohn Baldwin 		statics->arc_names = arcnames;
3302e52fb92SJohn Baldwin 	else
3312e52fb92SJohn Baldwin 		statics->arc_names = NULL;
3321dbfa4b5SAllan Jude 	if (carc_enabled)
3331dbfa4b5SAllan Jude 		statics->carc_names = carcnames;
3341dbfa4b5SAllan Jude 	else
3351dbfa4b5SAllan Jude 		statics->carc_names = NULL;
336511d9c65SJoerg Wunsch 	statics->swap_names = swapnames;
3375d320d4bSAlfred Perlstein 	statics->order_names = ordernames;
338511d9c65SJoerg Wunsch 
33951f202e9SJohn Baldwin 	/* Allocate state for per-CPU stats. */
34003117570SPeter Wemm 	cpumask = 0;
34103117570SPeter Wemm 	ncpus = 0;
34203117570SPeter Wemm 	GETSYSCTL("kern.smp.maxcpus", maxcpu);
343d0bb69dcSEitan Adler 	times = calloc(maxcpu * CPUSTATES, sizeof(long));
34403117570SPeter Wemm 	if (times == NULL)
34559c8d5dcSEitan Adler 		err(1, "calloc for kern.smp.maxcpus");
346a2cda47aSEitan Adler 	size = sizeof(long) * maxcpu * CPUSTATES;
34703117570SPeter Wemm 	if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
34803117570SPeter Wemm 		err(1, "sysctlbyname kern.cp_times");
3493aaa0832SRuslan Ermilov 	pcpu_cp_time = calloc(1, size);
35003117570SPeter Wemm 	maxid = (size / CPUSTATES / sizeof(long)) - 1;
35103117570SPeter Wemm 	for (i = 0; i <= maxid; i++) {
35203117570SPeter Wemm 		empty = 1;
35303117570SPeter Wemm 		for (j = 0; empty && j < CPUSTATES; j++) {
35403117570SPeter Wemm 			if (times[i * CPUSTATES + j] != 0)
35503117570SPeter Wemm 				empty = 0;
35603117570SPeter Wemm 		}
35703117570SPeter Wemm 		if (!empty) {
35803117570SPeter Wemm 			cpumask |= (1ul << i);
35903117570SPeter Wemm 			ncpus++;
36003117570SPeter Wemm 		}
36103117570SPeter Wemm 	}
362d0bb69dcSEitan Adler 	assert(ncpus > 0);
363d0bb69dcSEitan Adler 	pcpu_cp_old = calloc(ncpus * CPUSTATES, sizeof(long));
364d0bb69dcSEitan Adler 	pcpu_cp_diff = calloc(ncpus * CPUSTATES, sizeof(long));
365d0bb69dcSEitan Adler 	pcpu_cpu_states = calloc(ncpus * CPUSTATES, sizeof(int));
366fcc3d62fSJohn Baldwin 	statics->ncpus = ncpus;
36751f202e9SJohn Baldwin 
3682e52fb92SJohn Baldwin 	update_layout();
36903117570SPeter Wemm 
370511d9c65SJoerg Wunsch 	/* all done! */
371511d9c65SJoerg Wunsch 	return (0);
372511d9c65SJoerg Wunsch }
373511d9c65SJoerg Wunsch 
37451c834c4SEitan Adler char *
3759f8096e3SEitan Adler format_header(const char *uname_field)
376511d9c65SJoerg Wunsch {
37751c834c4SEitan Adler 	static struct sbuf* header = NULL;
378511d9c65SJoerg Wunsch 
37951c834c4SEitan Adler 	/* clean up from last time. */
38051c834c4SEitan Adler 	if (header != NULL) {
3810515b88eSEitan Adler 		sbuf_clear(header);
3820515b88eSEitan Adler 	} else {
38351c834c4SEitan Adler 		header = sbuf_new_auto();
3840515b88eSEitan Adler 	}
385b6924c93SDag-Erling Smørgrav 
386db6bb7fcSAlfred Perlstein 	switch (displaymode) {
38751c834c4SEitan Adler 	case DISP_CPU: {
38851c834c4SEitan Adler 		sbuf_printf(header, "  %s", ps.thread_id ? " THR" : "PID");
38951c834c4SEitan Adler 		sbuf_printf(header, "%*s", ps.jail ? TOP_JID_LEN : 0,
39051c834c4SEitan Adler 									ps.jail ? " JID" : "");
39151c834c4SEitan Adler 		sbuf_printf(header, " %-*.*s  ", namelength, namelength, uname_field);
39251c834c4SEitan Adler 		sbuf_cat(header, "THR PRI NICE  SIZE   RES ");
393*db365663SEitan Adler 		if (ps.swap) {
394*db365663SEitan Adler 			sbuf_printf(header, "%*s ", TOP_SWAP_LEN - 1, "SWAP");
395*db365663SEitan Adler 		}
396*db365663SEitan Adler 		sbuf_cat(header, "STATE    ");
397*db365663SEitan Adler 		if (smpmode) {
398*db365663SEitan Adler 			sbuf_cat(header, "C   ");
399*db365663SEitan Adler 		}
40051c834c4SEitan Adler 		sbuf_cat(header, "TIME ");
401*db365663SEitan Adler 		sbuf_printf(header, "%6s ", ps.wcpu ? "WCPU" : "CPU");
40251c834c4SEitan Adler 		sbuf_cat(header, "COMMAND");
40351c834c4SEitan Adler 		sbuf_finish(header);
404db6bb7fcSAlfred Perlstein 		break;
40551c834c4SEitan Adler 	}
40651c834c4SEitan Adler 	case DISP_IO: {
4070515b88eSEitan Adler 		sbuf_printf(header, "  %s%*s %-*.*s",
4083edda95cSEitan Adler 			ps.thread_id ? " THR" : "PID",
40951c834c4SEitan Adler 		    ps.jail ? TOP_JID_LEN : 0, ps.jail ? " JID" : "",
410a2aff8b2SPeter Wemm 		    namelength, namelength, uname_field);
4110515b88eSEitan Adler 		sbuf_cat(header, "   VCSW  IVCSW   READ  WRITE  FAULT  TOTAL PERCENT COMMAND");
412bbf750fbSGiorgos Keramidas 		break;
41351c834c4SEitan Adler 	}
414666cf873SEitan Adler 	case DISP_MAX:
415666cf873SEitan Adler 		assert("displaymode must not be set to DISP_MAX");
416bbf750fbSGiorgos Keramidas 	}
41751c834c4SEitan Adler 
41851c834c4SEitan Adler 	cmdlengthdelta = sbuf_len(header) - 7;
41951c834c4SEitan Adler 	return sbuf_data(header);
420511d9c65SJoerg Wunsch }
421511d9c65SJoerg Wunsch 
422511d9c65SJoerg Wunsch static int swappgsin = -1;
423511d9c65SJoerg Wunsch static int swappgsout = -1;
424511d9c65SJoerg Wunsch 
42503117570SPeter Wemm 
426511d9c65SJoerg Wunsch void
427f6a10feaSDag-Erling Smørgrav get_system_info(struct system_info *si)
428511d9c65SJoerg Wunsch {
42998e53e5bSAndrew Gallatin 	struct loadavg sysload;
430a2641311SDavid E. O'Brien 	int mib[2];
431a2641311SDavid E. O'Brien 	struct timeval boottime;
4322e52fb92SJohn Baldwin 	uint64_t arc_stat, arc_stat2;
43303117570SPeter Wemm 	int i, j;
43403117570SPeter Wemm 	size_t size;
435511d9c65SJoerg Wunsch 
43651f202e9SJohn Baldwin 	/* get the CPU stats */
43703117570SPeter Wemm 	size = (maxid + 1) * CPUSTATES * sizeof(long);
43803117570SPeter Wemm 	if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
43903117570SPeter Wemm 		err(1, "sysctlbyname kern.cp_times");
44039d513ecSRobert Watson 	GETSYSCTL("kern.cp_time", cp_time);
44198e53e5bSAndrew Gallatin 	GETSYSCTL("vm.loadavg", sysload);
44239d513ecSRobert Watson 	GETSYSCTL("kern.lastpid", lastpid);
443511d9c65SJoerg Wunsch 
444511d9c65SJoerg Wunsch 	/* convert load averages to doubles */
445511d9c65SJoerg Wunsch 	for (i = 0; i < 3; i++)
4464946a00bSDag-Erling Smørgrav 		si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
447511d9c65SJoerg Wunsch 
44851f202e9SJohn Baldwin 	/* convert cp_time counts to percentages */
449f89db435SRuslan Ermilov 	for (i = j = 0; i <= maxid; i++) {
450f89db435SRuslan Ermilov 		if ((cpumask & (1ul << i)) == 0)
45103117570SPeter Wemm 			continue;
45203117570SPeter Wemm 		percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
45303117570SPeter Wemm 		    &pcpu_cp_time[j * CPUSTATES],
45403117570SPeter Wemm 		    &pcpu_cp_old[j * CPUSTATES],
45503117570SPeter Wemm 		    &pcpu_cp_diff[j * CPUSTATES]);
456f89db435SRuslan Ermilov 		j++;
45703117570SPeter Wemm 	}
45803117570SPeter Wemm 	percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
459511d9c65SJoerg Wunsch 
460511d9c65SJoerg Wunsch 	/* sum memory & swap statistics */
461511d9c65SJoerg Wunsch 	{
462511d9c65SJoerg Wunsch 		static unsigned int swap_delay = 0;
463511d9c65SJoerg Wunsch 		static int swapavail = 0;
464511d9c65SJoerg Wunsch 		static int swapfree = 0;
465a0b9e7e3SJohn Baldwin 		static long bufspace = 0;
46683c9dea1SGleb Smirnoff 		static uint64_t nspgsin, nspgsout;
467511d9c65SJoerg Wunsch 
46839d513ecSRobert Watson 		GETSYSCTL("vfs.bufspace", bufspace);
46939d513ecSRobert Watson 		GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
47039d513ecSRobert Watson 		GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
471cc59e3a7SMark Johnston 		GETSYSCTL("vm.stats.vm.v_laundry_count", memory_stats[2]);
472cc59e3a7SMark Johnston 		GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[3]);
47339d513ecSRobert Watson 		GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
47439d513ecSRobert Watson 		GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
47539d513ecSRobert Watson 		GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
476511d9c65SJoerg Wunsch 		/* convert memory stats to Kbytes */
4776243f7acSThomas Moestl 		memory_stats[0] = pagetok(memory_stats[0]);
4786243f7acSThomas Moestl 		memory_stats[1] = pagetok(memory_stats[1]);
4796243f7acSThomas Moestl 		memory_stats[2] = pagetok(memory_stats[2]);
4806243f7acSThomas Moestl 		memory_stats[3] = pagetok(memory_stats[3]);
481511d9c65SJoerg Wunsch 		memory_stats[4] = bufspace / 1024;
4826243f7acSThomas Moestl 		memory_stats[5] = pagetok(memory_stats[5]);
483511d9c65SJoerg Wunsch 		memory_stats[6] = -1;
484511d9c65SJoerg Wunsch 
485511d9c65SJoerg Wunsch 		/* first interval */
486511d9c65SJoerg Wunsch 		if (swappgsin < 0) {
487511d9c65SJoerg Wunsch 			swap_stats[4] = 0;
488511d9c65SJoerg Wunsch 			swap_stats[5] = 0;
489511d9c65SJoerg Wunsch 		}
490511d9c65SJoerg Wunsch 
491511d9c65SJoerg Wunsch 		/* compute differences between old and new swap statistic */
492511d9c65SJoerg Wunsch 		else {
49339d513ecSRobert Watson 			swap_stats[4] = pagetok(((nspgsin - swappgsin)));
49439d513ecSRobert Watson 			swap_stats[5] = pagetok(((nspgsout - swappgsout)));
495511d9c65SJoerg Wunsch 		}
496511d9c65SJoerg Wunsch 
49739d513ecSRobert Watson 		swappgsin = nspgsin;
49839d513ecSRobert Watson 		swappgsout = nspgsout;
499511d9c65SJoerg Wunsch 
500511d9c65SJoerg Wunsch 		/* call CPU heavy swapmode() only for changes */
501511d9c65SJoerg Wunsch 		if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
502511d9c65SJoerg Wunsch 			swap_stats[3] = swapmode(&swapavail, &swapfree);
503511d9c65SJoerg Wunsch 			swap_stats[0] = swapavail;
504511d9c65SJoerg Wunsch 			swap_stats[1] = swapavail - swapfree;
505511d9c65SJoerg Wunsch 			swap_stats[2] = swapfree;
506511d9c65SJoerg Wunsch 		}
507511d9c65SJoerg Wunsch 		swap_delay = 1;
508511d9c65SJoerg Wunsch 		swap_stats[6] = -1;
509511d9c65SJoerg Wunsch 	}
510511d9c65SJoerg Wunsch 
5112e52fb92SJohn Baldwin 	if (arc_enabled) {
5122e52fb92SJohn Baldwin 		GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
5132e52fb92SJohn Baldwin 		arc_stats[0] = arc_stat >> 10;
5142e52fb92SJohn Baldwin 		GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
5152e52fb92SJohn Baldwin 		arc_stats[1] = arc_stat >> 10;
5162e52fb92SJohn Baldwin 		GETSYSCTL("vfs.zfs.mru_size", arc_stat);
5172e52fb92SJohn Baldwin 		arc_stats[2] = arc_stat >> 10;
5182e52fb92SJohn Baldwin 		GETSYSCTL("vfs.zfs.anon_size", arc_stat);
5192e52fb92SJohn Baldwin 		arc_stats[3] = arc_stat >> 10;
5202e52fb92SJohn Baldwin 		GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
5212e52fb92SJohn Baldwin 		GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
522b3c88c28SEitan Adler 		arc_stats[4] = (arc_stat + arc_stat2) >> 10;
5232e52fb92SJohn Baldwin 		GETSYSCTL("kstat.zfs.misc.arcstats.other_size", arc_stat);
5242e52fb92SJohn Baldwin 		arc_stats[5] = arc_stat >> 10;
5252e52fb92SJohn Baldwin 		si->arc = arc_stats;
5262e52fb92SJohn Baldwin 	}
5271dbfa4b5SAllan Jude 	if (carc_enabled) {
5281dbfa4b5SAllan Jude 		GETSYSCTL("kstat.zfs.misc.arcstats.compressed_size", arc_stat);
5291dbfa4b5SAllan Jude 		carc_stats[0] = arc_stat >> 10;
530d9a72328SAllan Jude 		carc_stats[2] = arc_stat >> 10; /* For ratio */
5311dbfa4b5SAllan Jude 		GETSYSCTL("kstat.zfs.misc.arcstats.uncompressed_size", arc_stat);
5321dbfa4b5SAllan Jude 		carc_stats[1] = arc_stat >> 10;
5331dbfa4b5SAllan Jude 		si->carc = carc_stats;
5341dbfa4b5SAllan Jude 	}
5352e52fb92SJohn Baldwin 
536511d9c65SJoerg Wunsch 	/* set arrays and strings */
53703117570SPeter Wemm 	if (pcpu_stats) {
53803117570SPeter Wemm 		si->cpustates = pcpu_cpu_states;
53903117570SPeter Wemm 		si->ncpus = ncpus;
54003117570SPeter Wemm 	} else {
541511d9c65SJoerg Wunsch 		si->cpustates = cpu_states;
54203117570SPeter Wemm 		si->ncpus = 1;
54303117570SPeter Wemm 	}
544511d9c65SJoerg Wunsch 	si->memory = memory_stats;
545511d9c65SJoerg Wunsch 	si->swap = swap_stats;
546511d9c65SJoerg Wunsch 
547511d9c65SJoerg Wunsch 
548511d9c65SJoerg Wunsch 	if (lastpid > 0) {
549511d9c65SJoerg Wunsch 		si->last_pid = lastpid;
550511d9c65SJoerg Wunsch 	} else {
551511d9c65SJoerg Wunsch 		si->last_pid = -1;
552511d9c65SJoerg Wunsch 	}
553a2641311SDavid E. O'Brien 
554a2641311SDavid E. O'Brien 	/*
555a2641311SDavid E. O'Brien 	 * Print how long system has been up.
556a2641311SDavid E. O'Brien 	 * (Found by looking getting "boottime" from the kernel)
557a2641311SDavid E. O'Brien 	 */
558a2641311SDavid E. O'Brien 	mib[0] = CTL_KERN;
559a2641311SDavid E. O'Brien 	mib[1] = KERN_BOOTTIME;
5602e52fb92SJohn Baldwin 	size = sizeof(boottime);
561a22656f0SEnji Cooper 	if (sysctl(mib, nitems(mib), &boottime, &size, NULL, 0) != -1 &&
562a2641311SDavid E. O'Brien 	    boottime.tv_sec != 0) {
563a2641311SDavid E. O'Brien 		si->boottime = boottime;
564a2641311SDavid E. O'Brien 	} else {
565a2641311SDavid E. O'Brien 		si->boottime.tv_sec = -1;
566a2641311SDavid E. O'Brien 	}
567511d9c65SJoerg Wunsch }
568511d9c65SJoerg Wunsch 
56998c151d6SAlfred Perlstein #define NOPROC	((void *)-1)
57098c151d6SAlfred Perlstein 
571dcd6f4bdSAlfred Perlstein /*
572dcd6f4bdSAlfred Perlstein  * We need to compare data from the old process entry with the new
573dcd6f4bdSAlfred Perlstein  * process entry.
574dcd6f4bdSAlfred Perlstein  * To facilitate doing this quickly we stash a pointer in the kinfo_proc
575dcd6f4bdSAlfred Perlstein  * structure to cache the mapping.  We also use a negative cache pointer
576dcd6f4bdSAlfred Perlstein  * of NOPROC to avoid duplicate lookups.
577dcd6f4bdSAlfred Perlstein  * XXX: this could be done when the actual processes are fetched, we do
578dcd6f4bdSAlfred Perlstein  * it here out of laziness.
579dcd6f4bdSAlfred Perlstein  */
580666cf873SEitan Adler static const struct kinfo_proc *
581db6bb7fcSAlfred Perlstein get_old_proc(struct kinfo_proc *pp)
582db6bb7fcSAlfred Perlstein {
583d408c8f7SEitan Adler 	const struct kinfo_proc * const *oldpp, *oldp;
584db6bb7fcSAlfred Perlstein 
585dcd6f4bdSAlfred Perlstein 	/*
586dcd6f4bdSAlfred Perlstein 	 * If this is the first fetch of the kinfo_procs then we don't have
587dcd6f4bdSAlfred Perlstein 	 * any previous entries.
588dcd6f4bdSAlfred Perlstein 	 */
589db6bb7fcSAlfred Perlstein 	if (previous_proc_count == 0)
590db6bb7fcSAlfred Perlstein 		return (NULL);
591dcd6f4bdSAlfred Perlstein 	/* negative cache? */
59298c151d6SAlfred Perlstein 	if (pp->ki_udata == NOPROC)
59398c151d6SAlfred Perlstein 		return (NULL);
594dcd6f4bdSAlfred Perlstein 	/* cached? */
59598c151d6SAlfred Perlstein 	if (pp->ki_udata != NULL)
59698c151d6SAlfred Perlstein 		return (pp->ki_udata);
597dcd6f4bdSAlfred Perlstein 	/*
598dcd6f4bdSAlfred Perlstein 	 * Not cached,
599dcd6f4bdSAlfred Perlstein 	 * 1) look up based on pid.
600dcd6f4bdSAlfred Perlstein 	 * 2) compare process start.
601dcd6f4bdSAlfred Perlstein 	 * If we fail here, then setup a negative cache entry, otherwise
602dcd6f4bdSAlfred Perlstein 	 * cache it.
603dcd6f4bdSAlfred Perlstein 	 */
604db6bb7fcSAlfred Perlstein 	oldpp = bsearch(&pp, previous_pref, previous_proc_count,
6052417d97eSJohn Baldwin 	    sizeof(*previous_pref), ps.thread ? compare_tid : compare_pid);
60698c151d6SAlfred Perlstein 	if (oldpp == NULL) {
60798c151d6SAlfred Perlstein 		pp->ki_udata = NOPROC;
608db6bb7fcSAlfred Perlstein 		return (NULL);
60998c151d6SAlfred Perlstein 	}
610db6bb7fcSAlfred Perlstein 	oldp = *oldpp;
6118d0d2676SEitan Adler 	if (memcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
61298c151d6SAlfred Perlstein 		pp->ki_udata = NOPROC;
613db6bb7fcSAlfred Perlstein 		return (NULL);
61498c151d6SAlfred Perlstein 	}
61598c151d6SAlfred Perlstein 	pp->ki_udata = oldp;
616db6bb7fcSAlfred Perlstein 	return (oldp);
617db6bb7fcSAlfred Perlstein }
618db6bb7fcSAlfred Perlstein 
619dcd6f4bdSAlfred Perlstein /*
620dcd6f4bdSAlfred Perlstein  * Return the total amount of IO done in blocks in/out and faults.
621dcd6f4bdSAlfred Perlstein  * store the values individually in the pointers passed in.
622dcd6f4bdSAlfred Perlstein  */
623666cf873SEitan Adler static long
6249f8096e3SEitan Adler get_io_stats(const struct kinfo_proc *pp, long *inp, long *oup, long *flp,
625789e3877SBruce Evans     long *vcsw, long *ivcsw)
626db6bb7fcSAlfred Perlstein {
627db6bb7fcSAlfred Perlstein 	const struct kinfo_proc *oldp;
628db6bb7fcSAlfred Perlstein 	static struct kinfo_proc dummy;
629db6bb7fcSAlfred Perlstein 	long ret;
630db6bb7fcSAlfred Perlstein 
631db6bb7fcSAlfred Perlstein 	oldp = get_old_proc(pp);
632db6bb7fcSAlfred Perlstein 	if (oldp == NULL) {
6338d0d2676SEitan Adler 		memset(&dummy, 0, sizeof(dummy));
634db6bb7fcSAlfred Perlstein 		oldp = &dummy;
635db6bb7fcSAlfred Perlstein 	}
6367fe9a86aSAlfred Perlstein 	*inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
6377fe9a86aSAlfred Perlstein 	*oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
6387fe9a86aSAlfred Perlstein 	*flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
6395d320d4bSAlfred Perlstein 	*vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
6405d320d4bSAlfred Perlstein 	*ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
641db6bb7fcSAlfred Perlstein 	ret =
642db6bb7fcSAlfred Perlstein 	    (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
643db6bb7fcSAlfred Perlstein 	    (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
644db6bb7fcSAlfred Perlstein 	    (RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
645db6bb7fcSAlfred Perlstein 	return (ret);
646db6bb7fcSAlfred Perlstein }
647db6bb7fcSAlfred Perlstein 
648dcd6f4bdSAlfred Perlstein /*
649a9053954SJohn Baldwin  * If there was a previous update, use the delta in ki_runtime over
650a9053954SJohn Baldwin  * the previous interval to calculate pctcpu.  Otherwise, fall back
651a9053954SJohn Baldwin  * to using the kernel's ki_pctcpu.
652a9053954SJohn Baldwin  */
653a9053954SJohn Baldwin static double
654a9053954SJohn Baldwin proc_calc_pctcpu(struct kinfo_proc *pp)
655a9053954SJohn Baldwin {
656a9053954SJohn Baldwin 	const struct kinfo_proc *oldp;
657a9053954SJohn Baldwin 
658a9053954SJohn Baldwin 	if (previous_interval != 0) {
659a9053954SJohn Baldwin 		oldp = get_old_proc(pp);
660a9053954SJohn Baldwin 		if (oldp != NULL)
661a9053954SJohn Baldwin 			return ((double)(pp->ki_runtime - oldp->ki_runtime)
662a9053954SJohn Baldwin 			    / previous_interval);
663a9053954SJohn Baldwin 
664a9053954SJohn Baldwin 		/*
665a9053954SJohn Baldwin 		 * If this process/thread was created during the previous
666a9053954SJohn Baldwin 		 * interval, charge it's total runtime to the previous
667a9053954SJohn Baldwin 		 * interval.
668a9053954SJohn Baldwin 		 */
669a9053954SJohn Baldwin 		else if (pp->ki_start.tv_sec > previous_wall_time.tv_sec ||
670a9053954SJohn Baldwin 		    (pp->ki_start.tv_sec == previous_wall_time.tv_sec &&
671a9053954SJohn Baldwin 		    pp->ki_start.tv_usec >= previous_wall_time.tv_usec))
672a9053954SJohn Baldwin 			return ((double)pp->ki_runtime / previous_interval);
673a9053954SJohn Baldwin 	}
674a9053954SJohn Baldwin 	return (pctdouble(pp->ki_pctcpu));
675a9053954SJohn Baldwin }
676a9053954SJohn Baldwin 
677a9053954SJohn Baldwin /*
678a9053954SJohn Baldwin  * Return true if this process has used any CPU time since the
679a9053954SJohn Baldwin  * previous update.
680a9053954SJohn Baldwin  */
681a9053954SJohn Baldwin static int
682a9053954SJohn Baldwin proc_used_cpu(struct kinfo_proc *pp)
683a9053954SJohn Baldwin {
684a9053954SJohn Baldwin 	const struct kinfo_proc *oldp;
685a9053954SJohn Baldwin 
686a9053954SJohn Baldwin 	oldp = get_old_proc(pp);
687a9053954SJohn Baldwin 	if (oldp == NULL)
688a9053954SJohn Baldwin 		return (PCTCPU(pp) != 0);
689a9053954SJohn Baldwin 	return (pp->ki_runtime != oldp->ki_runtime ||
690a9053954SJohn Baldwin 	    RU(pp)->ru_nvcsw != RU(oldp)->ru_nvcsw ||
691a9053954SJohn Baldwin 	    RU(pp)->ru_nivcsw != RU(oldp)->ru_nivcsw);
692a9053954SJohn Baldwin }
693a9053954SJohn Baldwin 
694a9053954SJohn Baldwin /*
695dcd6f4bdSAlfred Perlstein  * Return the total number of block in/out and faults by a process.
696dcd6f4bdSAlfred Perlstein  */
697666cf873SEitan Adler static long
6989f8096e3SEitan Adler get_io_total(const struct kinfo_proc *pp)
6997fe9a86aSAlfred Perlstein {
7007fe9a86aSAlfred Perlstein 	long dummy;
7017fe9a86aSAlfred Perlstein 
7025d320d4bSAlfred Perlstein 	return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
7037fe9a86aSAlfred Perlstein }
7047fe9a86aSAlfred Perlstein 
705511d9c65SJoerg Wunsch static struct handle handle;
706511d9c65SJoerg Wunsch 
7071b7645c6SEitan Adler void *
708f6a10feaSDag-Erling Smørgrav get_process_info(struct system_info *si, struct process_select *sel,
7094946a00bSDag-Erling Smørgrav     int (*compare)(const void *, const void *))
710511d9c65SJoerg Wunsch {
711970636e9SAlfred Perlstein 	int i;
712970636e9SAlfred Perlstein 	int total_procs;
7137fe9a86aSAlfred Perlstein 	long p_io;
7145d320d4bSAlfred Perlstein 	long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
715a9053954SJohn Baldwin 	long nsec;
716970636e9SAlfred Perlstein 	int active_procs;
717970636e9SAlfred Perlstein 	struct kinfo_proc **prefp;
718970636e9SAlfred Perlstein 	struct kinfo_proc *pp;
719a9053954SJohn Baldwin 	struct timespec previous_proc_uptime;
720511d9c65SJoerg Wunsch 
721db6bb7fcSAlfred Perlstein 	/*
722a9053954SJohn Baldwin 	 * If thread state was toggled, don't cache the previous processes.
723a9053954SJohn Baldwin 	 */
724a9053954SJohn Baldwin 	if (previous_thread != sel->thread)
725a9053954SJohn Baldwin 		nproc = 0;
726a9053954SJohn Baldwin 	previous_thread = sel->thread;
727a9053954SJohn Baldwin 
728a9053954SJohn Baldwin 	/*
729db6bb7fcSAlfred Perlstein 	 * Save the previous process info.
730db6bb7fcSAlfred Perlstein 	 */
731db6bb7fcSAlfred Perlstein 	if (previous_proc_count_max < nproc) {
732db6bb7fcSAlfred Perlstein 		free(previous_procs);
7334fedcd49SEitan Adler 		previous_procs = calloc(nproc, sizeof(*previous_procs));
734db6bb7fcSAlfred Perlstein 		free(previous_pref);
7354fedcd49SEitan Adler 		previous_pref = calloc(nproc, sizeof(*previous_pref));
736db6bb7fcSAlfred Perlstein 		if (previous_procs == NULL || previous_pref == NULL) {
7374fedcd49SEitan Adler 			fprintf(stderr, "top: Out of memory.\n");
73851b29cb7SRoman Bogorodskiy 			quit(TOP_EX_SYS_ERROR);
739db6bb7fcSAlfred Perlstein 		}
740db6bb7fcSAlfred Perlstein 		previous_proc_count_max = nproc;
741db6bb7fcSAlfred Perlstein 	}
742db6bb7fcSAlfred Perlstein 	if (nproc) {
743db6bb7fcSAlfred Perlstein 		for (i = 0; i < nproc; i++)
744db6bb7fcSAlfred Perlstein 			previous_pref[i] = &previous_procs[i];
7455dc98aeeSEitan Adler 		memcpy(previous_procs, pbase, nproc * sizeof(*previous_procs));
746789e3877SBruce Evans 		qsort(previous_pref, nproc, sizeof(*previous_pref),
7472417d97eSJohn Baldwin 		    ps.thread ? compare_tid : compare_pid);
748db6bb7fcSAlfred Perlstein 	}
749db6bb7fcSAlfred Perlstein 	previous_proc_count = nproc;
750a9053954SJohn Baldwin 	previous_proc_uptime = proc_uptime;
751a9053954SJohn Baldwin 	previous_wall_time = proc_wall_time;
752a9053954SJohn Baldwin 	previous_interval = 0;
753db6bb7fcSAlfred Perlstein 
754b225f36eSJohn Baldwin 	pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
755b225f36eSJohn Baldwin 	    0, &nproc);
7564fb80c70SEitan Adler 	gettimeofday(&proc_wall_time, NULL);
757a9053954SJohn Baldwin 	if (clock_gettime(CLOCK_UPTIME, &proc_uptime) != 0)
758a9053954SJohn Baldwin 		memset(&proc_uptime, 0, sizeof(proc_uptime));
759a9053954SJohn Baldwin 	else if (previous_proc_uptime.tv_sec != 0 &&
760a9053954SJohn Baldwin 	    previous_proc_uptime.tv_nsec != 0) {
761a9053954SJohn Baldwin 		previous_interval = (proc_uptime.tv_sec -
762a9053954SJohn Baldwin 		    previous_proc_uptime.tv_sec) * 1000000;
763a9053954SJohn Baldwin 		nsec = proc_uptime.tv_nsec - previous_proc_uptime.tv_nsec;
764a9053954SJohn Baldwin 		if (nsec < 0) {
765a9053954SJohn Baldwin 			previous_interval -= 1000000;
766a9053954SJohn Baldwin 			nsec += 1000000000;
767a9053954SJohn Baldwin 		}
768a9053954SJohn Baldwin 		previous_interval += nsec / 1000;
769a9053954SJohn Baldwin 	}
770a9053954SJohn Baldwin 	if (nproc > onproc) {
771a9053954SJohn Baldwin 		pref = realloc(pref, sizeof(*pref) * nproc);
772a9053954SJohn Baldwin 		pcpu = realloc(pcpu, sizeof(*pcpu) * nproc);
773a9053954SJohn Baldwin 		onproc = nproc;
774a9053954SJohn Baldwin 	}
775a9053954SJohn Baldwin 	if (pref == NULL || pbase == NULL || pcpu == NULL) {
7764fb80c70SEitan Adler 		fprintf(stderr, "top: Out of memory.\n");
77751b29cb7SRoman Bogorodskiy 		quit(TOP_EX_SYS_ERROR);
778511d9c65SJoerg Wunsch 	}
779511d9c65SJoerg Wunsch 	/* get a pointer to the states summary array */
780511d9c65SJoerg Wunsch 	si->procstates = process_states;
781511d9c65SJoerg Wunsch 
782511d9c65SJoerg Wunsch 	/* count up process states and get pointers to interesting procs */
783511d9c65SJoerg Wunsch 	total_procs = 0;
784511d9c65SJoerg Wunsch 	active_procs = 0;
7857fe9a86aSAlfred Perlstein 	total_inblock = 0;
7867fe9a86aSAlfred Perlstein 	total_oublock = 0;
7877fe9a86aSAlfred Perlstein 	total_majflt = 0;
7880059e710SEitan Adler 	memset(process_states, 0, sizeof(process_states));
789511d9c65SJoerg Wunsch 	prefp = pref;
7904946a00bSDag-Erling Smørgrav 	for (pp = pbase, i = 0; i < nproc; pp++, i++) {
7917fe9a86aSAlfred Perlstein 
792d62a717dSDag-Erling Smørgrav 		if (pp->ki_stat == 0)
793d62a717dSDag-Erling Smørgrav 			/* not in use */
794d62a717dSDag-Erling Smørgrav 			continue;
795d62a717dSDag-Erling Smørgrav 
796ef436ca6SEitan Adler 		if (!sel->self && pp->ki_pid == mypid && sel->pid == -1)
797d62a717dSDag-Erling Smørgrav 			/* skip self */
798d62a717dSDag-Erling Smørgrav 			continue;
799d62a717dSDag-Erling Smørgrav 
800ef436ca6SEitan Adler 		if (!sel->system && (pp->ki_flag & P_SYSTEM) && sel->pid == -1)
801d62a717dSDag-Erling Smørgrav 			/* skip system process */
802d62a717dSDag-Erling Smørgrav 			continue;
803d62a717dSDag-Erling Smørgrav 
804789e3877SBruce Evans 		p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
805789e3877SBruce Evans 		    &p_vcsw, &p_ivcsw);
8067fe9a86aSAlfred Perlstein 		total_inblock += p_inblock;
8077fe9a86aSAlfred Perlstein 		total_oublock += p_oublock;
8087fe9a86aSAlfred Perlstein 		total_majflt += p_majflt;
809511d9c65SJoerg Wunsch 		total_procs++;
8104901ca08SEitan Adler 		process_states[(unsigned char)pp->ki_stat]++;
811d62a717dSDag-Erling Smørgrav 
812d62a717dSDag-Erling Smørgrav 		if (pp->ki_stat == SZOMB)
813d62a717dSDag-Erling Smørgrav 			/* skip zombies */
814d62a717dSDag-Erling Smørgrav 			continue;
815d62a717dSDag-Erling Smørgrav 
816ef436ca6SEitan Adler 		if (!sel->kidle && pp->ki_tdflags & TDF_IDLETD && sel->pid == -1)
817034b7b80SJohn Baldwin 			/* skip kernel idle process */
818034b7b80SJohn Baldwin 			continue;
819034b7b80SJohn Baldwin 
820a9053954SJohn Baldwin 		PCTCPU(pp) = proc_calc_pctcpu(pp);
821e876f6d0SJohn Baldwin 		if (sel->thread && PCTCPU(pp) > 1.0)
822e876f6d0SJohn Baldwin 			PCTCPU(pp) = 1.0;
8234fb80c70SEitan Adler 		if (displaymode == DISP_CPU && !sel->idle &&
824a9053954SJohn Baldwin 		    (!proc_used_cpu(pp) ||
825d1b76f3fSStefan Eßer 		     pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
826d62a717dSDag-Erling Smørgrav 			/* skip idle or non-running processes */
827d62a717dSDag-Erling Smørgrav 			continue;
828d62a717dSDag-Erling Smørgrav 
8294fb80c70SEitan Adler 		if (displaymode == DISP_IO && !sel->idle && p_io == 0)
830d62a717dSDag-Erling Smørgrav 			/* skip processes that aren't doing I/O */
831d62a717dSDag-Erling Smørgrav 			continue;
832d62a717dSDag-Erling Smørgrav 
8334fb80c70SEitan Adler 		if (sel->jid != -1 && pp->ki_jid != sel->jid)
8341b60f972SBryan Drewery 			/* skip proc. that don't belong to the selected JID */
8351b60f972SBryan Drewery 			continue;
8361b60f972SBryan Drewery 
8374fb80c70SEitan Adler 		if (sel->uid[0] != -1 && !find_uid(pp->ki_ruid, sel->uid))
838789e3877SBruce Evans 			/* skip proc. that don't belong to the selected UID */
839d62a717dSDag-Erling Smørgrav 			continue;
840d62a717dSDag-Erling Smørgrav 
8414fb80c70SEitan Adler 		if (sel->pid != -1 && pp->ki_pid != sel->pid)
84251b29cb7SRoman Bogorodskiy 			continue;
84351b29cb7SRoman Bogorodskiy 
844511d9c65SJoerg Wunsch 		*prefp++ = pp;
845511d9c65SJoerg Wunsch 		active_procs++;
846511d9c65SJoerg Wunsch 	}
847511d9c65SJoerg Wunsch 
848511d9c65SJoerg Wunsch 	/* if requested, sort the "interesting" processes */
849511d9c65SJoerg Wunsch 	if (compare != NULL)
8504946a00bSDag-Erling Smørgrav 		qsort(pref, active_procs, sizeof(*pref), compare);
851511d9c65SJoerg Wunsch 
852511d9c65SJoerg Wunsch 	/* remember active and total counts */
853511d9c65SJoerg Wunsch 	si->p_total = total_procs;
8545ef89dbfSEitan Adler 	si->p_pactive = pref_len = active_procs;
855511d9c65SJoerg Wunsch 
856511d9c65SJoerg Wunsch 	/* pass back a handle */
857511d9c65SJoerg Wunsch 	handle.next_proc = pref;
858511d9c65SJoerg Wunsch 	handle.remaining = active_procs;
8594fb80c70SEitan Adler 	return (&handle);
860511d9c65SJoerg Wunsch }
861511d9c65SJoerg Wunsch 
862970636e9SAlfred Perlstein char *
8638caf462eSEitan Adler format_next_process(struct handle * xhandle, char *(*get_userid)(int), int flags)
864511d9c65SJoerg Wunsch {
865970636e9SAlfred Perlstein 	struct kinfo_proc *pp;
866db6bb7fcSAlfred Perlstein 	const struct kinfo_proc *oldp;
867970636e9SAlfred Perlstein 	long cputime;
868dbcdf411SEitan Adler 	char status[22];
869666cf873SEitan Adler 	size_t state;
870db6bb7fcSAlfred Perlstein 	struct rusage ru, *rup;
8717fe9a86aSAlfred Perlstein 	long p_tot, s_tot;
872faac60c8SStanislav Sedov 	char *cmdbuf = NULL;
873eae589f1SEitan Adler 	char **args;
87478210af9SRui Paulo 	const int cmdlen = 128;
8750515b88eSEitan Adler 	static struct sbuf* procbuf = NULL;
8760515b88eSEitan Adler 
8770515b88eSEitan Adler 	/* clean up from last time. */
8780515b88eSEitan Adler 	if (procbuf != NULL) {
8790515b88eSEitan Adler 		sbuf_clear(procbuf);
8800515b88eSEitan Adler 	} else {
8810515b88eSEitan Adler 		procbuf = sbuf_new_auto();
8820515b88eSEitan Adler 	}
8830515b88eSEitan Adler 
884511d9c65SJoerg Wunsch 
885511d9c65SJoerg Wunsch 	/* find and remember the next proc structure */
8868caf462eSEitan Adler 	pp = *(xhandle->next_proc++);
8878caf462eSEitan Adler 	xhandle->remaining--;
888511d9c65SJoerg Wunsch 
889a8224b82SBruce Evans 	/* get the process's command name */
890b61ce5b0SJeff Roberson 	if ((pp->ki_flag & P_INMEM) == 0) {
891511d9c65SJoerg Wunsch 		/*
892511d9c65SJoerg Wunsch 		 * Print swapped processes as <pname>
893511d9c65SJoerg Wunsch 		 */
894789e3877SBruce Evans 		size_t len;
895789e3877SBruce Evans 
896789e3877SBruce Evans 		len = strlen(pp->ki_comm);
8974946a00bSDag-Erling Smørgrav 		if (len > sizeof(pp->ki_comm) - 3)
8984946a00bSDag-Erling Smørgrav 			len = sizeof(pp->ki_comm) - 3;
8994946a00bSDag-Erling Smørgrav 		memmove(pp->ki_comm + 1, pp->ki_comm, len);
9004946a00bSDag-Erling Smørgrav 		pp->ki_comm[0] = '<';
9014946a00bSDag-Erling Smørgrav 		pp->ki_comm[len + 1] = '>';
9024946a00bSDag-Erling Smørgrav 		pp->ki_comm[len + 2] = '\0';
903511d9c65SJoerg Wunsch 	}
904511d9c65SJoerg Wunsch 
905a8224b82SBruce Evans 	/*
906a8224b82SBruce Evans 	 * Convert the process's runtime from microseconds to seconds.  This
907a8224b82SBruce Evans 	 * time includes the interrupt time although that is not wanted here.
908a8224b82SBruce Evans 	 * ps(1) is similarly sloppy.
909a8224b82SBruce Evans 	 */
9101f7d2501SKirk McKusick 	cputime = (pp->ki_runtime + 500000) / 1000000;
911511d9c65SJoerg Wunsch 
912511d9c65SJoerg Wunsch 	/* generate "STATE" field */
9131f7d2501SKirk McKusick 	switch (state = pp->ki_stat) {
914511d9c65SJoerg Wunsch 	case SRUN:
915b666b032SJung-uk Kim 		if (smpmode && pp->ki_oncpu != NOCPU)
9161f7d2501SKirk McKusick 			sprintf(status, "CPU%d", pp->ki_oncpu);
917511d9c65SJoerg Wunsch 		else
918511d9c65SJoerg Wunsch 			strcpy(status, "RUN");
919511d9c65SJoerg Wunsch 		break;
9200d632649SJohn Baldwin 	case SLOCK:
9210d632649SJohn Baldwin 		if (pp->ki_kiflag & KI_LOCKBLOCK) {
9220d632649SJohn Baldwin 			sprintf(status, "*%.6s", pp->ki_lockname);
923089f9b7eSJohn Baldwin 			break;
924089f9b7eSJohn Baldwin 		}
925089f9b7eSJohn Baldwin 		/* fall through */
926511d9c65SJoerg Wunsch 	case SSLEEP:
9271f7d2501SKirk McKusick 		sprintf(status, "%.6s", pp->ki_wmesg);
928511d9c65SJoerg Wunsch 		break;
929511d9c65SJoerg Wunsch 	default:
9301005b436SBill Fenner 
9319f8096e3SEitan Adler 		if (state < nitems(state_abbrev)) {
9324946a00bSDag-Erling Smørgrav 			sprintf(status, "%.6s", state_abbrev[state]);
9339f8096e3SEitan Adler 		} else {
934986a5bafSEitan Adler 			sprintf(status, "?%5zu", state);
9359f8096e3SEitan Adler 		}
936511d9c65SJoerg Wunsch 		break;
937511d9c65SJoerg Wunsch 	}
938511d9c65SJoerg Wunsch 
9394fedcd49SEitan Adler 	cmdbuf = calloc(cmdlen + 1, 1);
940faac60c8SStanislav Sedov 	if (cmdbuf == NULL) {
9414fedcd49SEitan Adler 		warn("calloc(%d)", cmdlen + 1);
942faac60c8SStanislav Sedov 		return NULL;
943faac60c8SStanislav Sedov 	}
944faac60c8SStanislav Sedov 
945faac60c8SStanislav Sedov 	if (!(flags & FMT_SHOWARGS)) {
9467ab24ea3SJulian Elischer 		if (ps.thread && pp->ki_flag & P_HADTHREADS &&
947925af544SBjoern A. Zeeb 		    pp->ki_tdname[0]) {
9483d32d4a7SEric van Gyzen 			snprintf(cmdbuf, cmdlen, "%s{%s%s}", pp->ki_comm,
9493d32d4a7SEric van Gyzen 			    pp->ki_tdname, pp->ki_moretdname);
9507ab24ea3SJulian Elischer 		} else {
95178210af9SRui Paulo 			snprintf(cmdbuf, cmdlen, "%s", pp->ki_comm);
952faac60c8SStanislav Sedov 		}
9537ab24ea3SJulian Elischer 	} else {
9547ab24ea3SJulian Elischer 		if (pp->ki_flag & P_SYSTEM ||
9557ab24ea3SJulian Elischer 		    pp->ki_args == NULL ||
95678210af9SRui Paulo 		    (args = kvm_getargv(kd, pp, cmdlen)) == NULL ||
9577ab24ea3SJulian Elischer 		    !(*args)) {
9587ab24ea3SJulian Elischer 			if (ps.thread && pp->ki_flag & P_HADTHREADS &&
959925af544SBjoern A. Zeeb 		    	    pp->ki_tdname[0]) {
96078210af9SRui Paulo 				snprintf(cmdbuf, cmdlen,
9613d32d4a7SEric van Gyzen 				    "[%s{%s%s}]", pp->ki_comm, pp->ki_tdname,
9623d32d4a7SEric van Gyzen 				    pp->ki_moretdname);
9637ab24ea3SJulian Elischer 			} else {
96478210af9SRui Paulo 				snprintf(cmdbuf, cmdlen,
9657ab24ea3SJulian Elischer 				    "[%s]", pp->ki_comm);
9667ab24ea3SJulian Elischer 			}
9677ab24ea3SJulian Elischer 		} else {
968eae589f1SEitan Adler 			const char *src;
969eae589f1SEitan Adler 			char *dst, *argbuf;
970eae589f1SEitan Adler 			const char *cmd;
971faac60c8SStanislav Sedov 			size_t argbuflen;
972faac60c8SStanislav Sedov 			size_t len;
973faac60c8SStanislav Sedov 
97478210af9SRui Paulo 			argbuflen = cmdlen * 4;
9754fedcd49SEitan Adler 			argbuf = calloc(argbuflen + 1, 1);
976faac60c8SStanislav Sedov 			if (argbuf == NULL) {
9774fedcd49SEitan Adler 				warn("calloc(%zu)", argbuflen + 1);
978faac60c8SStanislav Sedov 				free(cmdbuf);
979faac60c8SStanislav Sedov 				return NULL;
980faac60c8SStanislav Sedov 			}
981faac60c8SStanislav Sedov 
982faac60c8SStanislav Sedov 			dst = argbuf;
983faac60c8SStanislav Sedov 
984faac60c8SStanislav Sedov 			/* Extract cmd name from argv */
985ac8f40eaSEitan Adler 			cmd = basename(*args);
986faac60c8SStanislav Sedov 
987faac60c8SStanislav Sedov 			for (; (src = *args++) != NULL; ) {
988faac60c8SStanislav Sedov 				if (*src == '\0')
989faac60c8SStanislav Sedov 					continue;
990faac60c8SStanislav Sedov 				len = (argbuflen - (dst - argbuf) - 1) / 4;
9917ab24ea3SJulian Elischer 				strvisx(dst, src,
992cd59e2f3SMarcelo Araujo 				    MIN(strlen(src), len),
993faac60c8SStanislav Sedov 				    VIS_NL | VIS_CSTYLE);
994faac60c8SStanislav Sedov 				while (*dst != '\0')
995faac60c8SStanislav Sedov 					dst++;
996faac60c8SStanislav Sedov 				if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
997faac60c8SStanislav Sedov 					*dst++ = ' '; /* add delimiting space */
998faac60c8SStanislav Sedov 			}
999faac60c8SStanislav Sedov 			if (dst != argbuf && dst[-1] == ' ')
1000faac60c8SStanislav Sedov 				dst--;
1001faac60c8SStanislav Sedov 			*dst = '\0';
1002faac60c8SStanislav Sedov 
1003c618a522SBjoern A. Zeeb 			if (strcmp(cmd, pp->ki_comm) != 0) {
1004c618a522SBjoern A. Zeeb 				if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1005c618a522SBjoern A. Zeeb 				    pp->ki_tdname[0])
100678210af9SRui Paulo 					snprintf(cmdbuf, cmdlen,
10073d32d4a7SEric van Gyzen 					    "%s (%s){%s%s}", argbuf,
10083d32d4a7SEric van Gyzen 					    pp->ki_comm, pp->ki_tdname,
10093d32d4a7SEric van Gyzen 					    pp->ki_moretdname);
1010c618a522SBjoern A. Zeeb 				else
101178210af9SRui Paulo 					snprintf(cmdbuf, cmdlen,
10127ab24ea3SJulian Elischer 					    "%s (%s)", argbuf, pp->ki_comm);
1013c618a522SBjoern A. Zeeb 			} else {
1014c618a522SBjoern A. Zeeb 				if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1015c618a522SBjoern A. Zeeb 				    pp->ki_tdname[0])
101678210af9SRui Paulo 					snprintf(cmdbuf, cmdlen,
10173d32d4a7SEric van Gyzen 					    "%s{%s%s}", argbuf, pp->ki_tdname,
10183d32d4a7SEric van Gyzen 					    pp->ki_moretdname);
1019faac60c8SStanislav Sedov 				else
102078210af9SRui Paulo 					strlcpy(cmdbuf, argbuf, cmdlen);
1021c618a522SBjoern A. Zeeb 			}
1022faac60c8SStanislav Sedov 			free(argbuf);
1023faac60c8SStanislav Sedov 		}
10247ab24ea3SJulian Elischer 	}
1025faac60c8SStanislav Sedov 
1026db6bb7fcSAlfred Perlstein 	if (displaymode == DISP_IO) {
1027db6bb7fcSAlfred Perlstein 		oldp = get_old_proc(pp);
1028db6bb7fcSAlfred Perlstein 		if (oldp != NULL) {
1029789e3877SBruce Evans 			ru.ru_inblock = RU(pp)->ru_inblock -
1030789e3877SBruce Evans 			    RU(oldp)->ru_inblock;
1031789e3877SBruce Evans 			ru.ru_oublock = RU(pp)->ru_oublock -
1032789e3877SBruce Evans 			    RU(oldp)->ru_oublock;
1033db6bb7fcSAlfred Perlstein 			ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
10345d320d4bSAlfred Perlstein 			ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
10355d320d4bSAlfred Perlstein 			ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
1036db6bb7fcSAlfred Perlstein 			rup = &ru;
1037db6bb7fcSAlfred Perlstein 		} else {
1038db6bb7fcSAlfred Perlstein 			rup = RU(pp);
1039db6bb7fcSAlfred Perlstein 		}
10407fe9a86aSAlfred Perlstein 		p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
10417fe9a86aSAlfred Perlstein 		s_tot = total_inblock + total_oublock + total_majflt;
1042db6bb7fcSAlfred Perlstein 
10430515b88eSEitan Adler 		sbuf_printf(procbuf, "%5d ", (ps.thread_id) ? pp->ki_tid : pp->ki_pid);
1044*db365663SEitan Adler 
1045*db365663SEitan Adler 		if (ps.jail) {
1046*db365663SEitan Adler 			sbuf_printf(procbuf, "%*d ", TOP_JID_LEN - 1, pp->ki_jid);
1047*db365663SEitan Adler 		}
10480515b88eSEitan Adler 		sbuf_printf(procbuf, "%-*.*s", namelength, namelength, (*get_userid)(pp->ki_ruid));
10490515b88eSEitan Adler 		sbuf_printf(procbuf, "%6ld ", rup->ru_nvcsw);
10500515b88eSEitan Adler 		sbuf_printf(procbuf, "%6ld ", rup->ru_nivcsw);
10510515b88eSEitan Adler 		sbuf_printf(procbuf, "%6ld ", rup->ru_inblock);
10520515b88eSEitan Adler 		sbuf_printf(procbuf, "%6ld ", rup->ru_oublock);
10530515b88eSEitan Adler 		sbuf_printf(procbuf, "%6ld ", rup->ru_majflt);
10540515b88eSEitan Adler 		sbuf_printf(procbuf, "%6ld ", p_tot);
10550515b88eSEitan Adler 		sbuf_printf(procbuf, "%6.2f%% ", s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot));
1056faac60c8SStanislav Sedov 
1057*db365663SEitan Adler 	} else {
1058*db365663SEitan Adler 		sbuf_printf(procbuf, "%5d ", (ps.thread_id) ? pp->ki_tid : pp->ki_pid);
1059*db365663SEitan Adler 		if (ps.jail) {
1060*db365663SEitan Adler 			sbuf_printf(procbuf, "%*d ", TOP_JID_LEN - 1, pp->ki_jid);
1061*db365663SEitan Adler 		}
1062*db365663SEitan Adler 		sbuf_printf(procbuf, "%-*.*s ", namelength, namelength, (*get_userid)(pp->ki_ruid));
1063*db365663SEitan Adler 
1064*db365663SEitan Adler 		if (!ps.thread) {
1065*db365663SEitan Adler 			sbuf_printf(procbuf, "%4d ", pp->ki_numthreads);
1066db6bb7fcSAlfred Perlstein 		}
106732efd263SGiorgos Keramidas 
10680515b88eSEitan Adler 		sbuf_printf(procbuf, "%3d ", pp->ki_pri.pri_level - PZERO);
10690515b88eSEitan Adler 		sbuf_printf(procbuf, "%4s", format_nice(pp));
10700515b88eSEitan Adler 		sbuf_printf(procbuf, "%6s ", format_k(PROCSIZE(pp)));
10710515b88eSEitan Adler 		sbuf_printf(procbuf, "%5s ", format_k(pagetok(pp->ki_rssize)));
1072*db365663SEitan Adler 		if (ps.swap) {
1073*db365663SEitan Adler 			sbuf_printf(procbuf, "%*s ",
1074*db365663SEitan Adler 				TOP_SWAP_LEN - 1,
1075*db365663SEitan Adler 				format_k(pagetok(ki_swap(pp))));
1076*db365663SEitan Adler 		}
10770515b88eSEitan Adler 		sbuf_printf(procbuf, "%-6.6s ", status);
1078*db365663SEitan Adler 		if (smpmode) {
1079*db365663SEitan Adler 			int cpu;
1080*db365663SEitan Adler 			if (state == SRUN && pp->ki_oncpu != NOCPU) {
1081*db365663SEitan Adler 				cpu = pp->ki_oncpu;
1082*db365663SEitan Adler 			} else {
1083*db365663SEitan Adler 				cpu = pp->ki_lastcpu;
1084*db365663SEitan Adler 			}
1085*db365663SEitan Adler 			sbuf_printf(procbuf, "%3d ", cpu);
1086*db365663SEitan Adler 		}
1087*db365663SEitan Adler 		sbuf_printf(procbuf, "%6s", format_time(cputime));
1088*db365663SEitan Adler 		sbuf_printf(procbuf, "%6.2f%% ", ps.wcpu ? 100.0 * weighted_cpu(PCTCPU(pp), pp) : 100.0 * PCTCPU(pp));
1089*db365663SEitan Adler 	}
1090*db365663SEitan Adler 	sbuf_printf(procbuf, "%.*s",
1091*db365663SEitan Adler 		screen_width > cmdlengthdelta ?
1092*db365663SEitan Adler 		screen_width - cmdlengthdelta : 0,
1093*db365663SEitan Adler 		printable(cmdbuf));
1094*db365663SEitan Adler 	free(cmdbuf);
10950515b88eSEitan Adler 	return (sbuf_data(procbuf));
1096511d9c65SJoerg Wunsch }
1097511d9c65SJoerg Wunsch 
1098970636e9SAlfred Perlstein static void
1099de916c8bSBruce Evans getsysctl(const char *name, void *ptr, size_t len)
1100511d9c65SJoerg Wunsch {
110198e53e5bSAndrew Gallatin 	size_t nlen = len;
1102970636e9SAlfred Perlstein 
110339d513ecSRobert Watson 	if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
110439d513ecSRobert Watson 		fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
110539d513ecSRobert Watson 		    strerror(errno));
110651b29cb7SRoman Bogorodskiy 		quit(TOP_EX_SYS_ERROR);
1107511d9c65SJoerg Wunsch 	}
110839d513ecSRobert Watson 	if (nlen != len) {
1109789e3877SBruce Evans 		fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1110789e3877SBruce Evans 		    name, (unsigned long)len, (unsigned long)nlen);
111151b29cb7SRoman Bogorodskiy 		quit(TOP_EX_SYS_ERROR);
1112511d9c65SJoerg Wunsch 	}
1113511d9c65SJoerg Wunsch }
1114511d9c65SJoerg Wunsch 
11158dbbff5bSBruce Evans static const char *
11168dbbff5bSBruce Evans format_nice(const struct kinfo_proc *pp)
1117de916c8bSBruce Evans {
111878b7ef01SKonstantin Belousov 	const char *fifo, *kproc;
11198dbbff5bSBruce Evans 	int rtpri;
11208dbbff5bSBruce Evans 	static char nicebuf[4 + 1];
1121de916c8bSBruce Evans 
11228dbbff5bSBruce Evans 	fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
112378b7ef01SKonstantin Belousov 	kproc = (pp->ki_flag & P_KPROC) ? "k" : "";
11248dbbff5bSBruce Evans 	switch (PRI_BASE(pp->ki_pri.pri_class)) {
11258dbbff5bSBruce Evans 	case PRI_ITHD:
11268dbbff5bSBruce Evans 		return ("-");
11278dbbff5bSBruce Evans 	case PRI_REALTIME:
1128e19249f7SBruce Evans 		/*
1129e19249f7SBruce Evans 		 * XXX: the kernel doesn't tell us the original rtprio and
1130e19249f7SBruce Evans 		 * doesn't really know what it was, so to recover it we
1131e19249f7SBruce Evans 		 * must be more chummy with the implementation than the
1132e19249f7SBruce Evans 		 * implementation is with itself.  pri_user gives a
1133e19249f7SBruce Evans 		 * constant "base" priority, but is only initialized
1134e19249f7SBruce Evans 		 * properly for user threads.  pri_native gives what the
1135e19249f7SBruce Evans 		 * kernel calls the "base" priority, but it isn't constant
1136e19249f7SBruce Evans 		 * since it is changed by priority propagation.  pri_native
1137e19249f7SBruce Evans 		 * also isn't properly initialized for all threads, but it
1138e19249f7SBruce Evans 		 * is properly initialized for kernel realtime and idletime
1139e19249f7SBruce Evans 		 * threads.  Thus we use pri_user for the base priority of
1140e19249f7SBruce Evans 		 * user threads (it is always correct) and pri_native for
1141e19249f7SBruce Evans 		 * the base priority of kernel realtime and idletime threads
1142e19249f7SBruce Evans 		 * (there is nothing better, and it is usually correct).
1143e19249f7SBruce Evans 		 *
1144e19249f7SBruce Evans 		 * The field width and thus the buffer are too small for
1145e19249f7SBruce Evans 		 * values like "kr31F", but such values shouldn't occur,
1146e19249f7SBruce Evans 		 * and if they do then the tailing "F" is not displayed.
1147e19249f7SBruce Evans 		 */
1148db57c70aSKonstantin Belousov 		rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
1149e19249f7SBruce Evans 		    pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
11508dbbff5bSBruce Evans 		snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
115178b7ef01SKonstantin Belousov 		    kproc, rtpri, fifo);
11528dbbff5bSBruce Evans 		break;
11538dbbff5bSBruce Evans 	case PRI_TIMESHARE:
1154db57c70aSKonstantin Belousov 		if (pp->ki_flag & P_KPROC)
11558dbbff5bSBruce Evans 			return ("-");
11568dbbff5bSBruce Evans 		snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
11578dbbff5bSBruce Evans 		break;
11588dbbff5bSBruce Evans 	case PRI_IDLE:
1159e19249f7SBruce Evans 		/* XXX: as above. */
1160db57c70aSKonstantin Belousov 		rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
1161e19249f7SBruce Evans 		    pp->ki_pri.pri_user) - PRI_MIN_IDLE;
11628dbbff5bSBruce Evans 		snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
116378b7ef01SKonstantin Belousov 		    kproc, rtpri, fifo);
11648dbbff5bSBruce Evans 		break;
11658dbbff5bSBruce Evans 	default:
11668dbbff5bSBruce Evans 		return ("?");
11678dbbff5bSBruce Evans 	}
1168de916c8bSBruce Evans 	return (nicebuf);
1169de916c8bSBruce Evans }
1170de916c8bSBruce Evans 
1171f3b2c2d1SWolfram Schneider /* comparison routines for qsort */
1172511d9c65SJoerg Wunsch 
1173de916c8bSBruce Evans static int
1174f6a10feaSDag-Erling Smørgrav compare_pid(const void *p1, const void *p2)
1175db6bb7fcSAlfred Perlstein {
1176db6bb7fcSAlfred Perlstein 	const struct kinfo_proc * const *pp1 = p1;
1177db6bb7fcSAlfred Perlstein 	const struct kinfo_proc * const *pp2 = p2;
1178db6bb7fcSAlfred Perlstein 
11799f8096e3SEitan Adler 	assert((*pp2)->ki_pid >= 0 && (*pp1)->ki_pid >= 0);
1180db6bb7fcSAlfred Perlstein 
1181db6bb7fcSAlfred Perlstein 	return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1182db6bb7fcSAlfred Perlstein }
1183db6bb7fcSAlfred Perlstein 
11842417d97eSJohn Baldwin static int
11852417d97eSJohn Baldwin compare_tid(const void *p1, const void *p2)
11862417d97eSJohn Baldwin {
11872417d97eSJohn Baldwin 	const struct kinfo_proc * const *pp1 = p1;
11882417d97eSJohn Baldwin 	const struct kinfo_proc * const *pp2 = p2;
11892417d97eSJohn Baldwin 
11909f8096e3SEitan Adler 	assert((*pp2)->ki_tid >= 0 && (*pp1)->ki_tid >= 0);
11912417d97eSJohn Baldwin 
11922417d97eSJohn Baldwin 	return ((*pp1)->ki_tid - (*pp2)->ki_tid);
11932417d97eSJohn Baldwin }
11942417d97eSJohn Baldwin 
1195511d9c65SJoerg Wunsch /*
1196511d9c65SJoerg Wunsch  *  proc_compare - comparison function for "qsort"
1197511d9c65SJoerg Wunsch  *	Compares the resource consumption of two processes using five
1198511d9c65SJoerg Wunsch  *	distinct keys.  The keys (in descending order of importance) are:
1199511d9c65SJoerg Wunsch  *	percent cpu, cpu ticks, state, resident set size, total virtual
1200511d9c65SJoerg Wunsch  *	memory usage.  The process states are ordered as follows (from least
1201511d9c65SJoerg Wunsch  *	to most important):  WAIT, zombie, sleep, stop, start, run.  The
1202511d9c65SJoerg Wunsch  *	array declaration below maps a process state index into a number
1203511d9c65SJoerg Wunsch  *	that reflects this ordering.
1204511d9c65SJoerg Wunsch  */
1205511d9c65SJoerg Wunsch 
1206789e3877SBruce Evans static int sorted_state[] = {
1207511d9c65SJoerg Wunsch 	0,	/* not used		*/
1208511d9c65SJoerg Wunsch 	3,	/* sleep		*/
1209511d9c65SJoerg Wunsch 	1,	/* ABANDONED (WAIT)	*/
1210511d9c65SJoerg Wunsch 	6,	/* run			*/
1211511d9c65SJoerg Wunsch 	5,	/* start		*/
1212511d9c65SJoerg Wunsch 	2,	/* zombie		*/
1213511d9c65SJoerg Wunsch 	4	/* stop			*/
1214511d9c65SJoerg Wunsch };
1215511d9c65SJoerg Wunsch 
1216f3b2c2d1SWolfram Schneider 
12174946a00bSDag-Erling Smørgrav #define ORDERKEY_PCTCPU(a, b) do { \
1218a9053954SJohn Baldwin 	double diff; \
1219bbf750fbSGiorgos Keramidas 	if (ps.wcpu) \
1220a9053954SJohn Baldwin 		diff = weighted_cpu(PCTCPU((b)), (b)) - \
1221a9053954SJohn Baldwin 		    weighted_cpu(PCTCPU((a)), (a)); \
1222bbf750fbSGiorgos Keramidas 	else \
1223a9053954SJohn Baldwin 		diff = PCTCPU((b)) - PCTCPU((a)); \
12244946a00bSDag-Erling Smørgrav 	if (diff != 0) \
12254946a00bSDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
12264946a00bSDag-Erling Smørgrav } while (0)
1227f3b2c2d1SWolfram Schneider 
12284946a00bSDag-Erling Smørgrav #define ORDERKEY_CPTICKS(a, b) do { \
1229e38035a5SDag-Erling Smørgrav 	int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
12304946a00bSDag-Erling Smørgrav 	if (diff != 0) \
12314946a00bSDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
12324946a00bSDag-Erling Smørgrav } while (0)
1233f3b2c2d1SWolfram Schneider 
12344946a00bSDag-Erling Smørgrav #define ORDERKEY_STATE(a, b) do { \
12354901ca08SEitan Adler 	int diff = sorted_state[(unsigned char)(b)->ki_stat] - sorted_state[(unsigned char)(a)->ki_stat]; \
12364946a00bSDag-Erling Smørgrav 	if (diff != 0) \
12374946a00bSDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
12384946a00bSDag-Erling Smørgrav } while (0)
1239f3b2c2d1SWolfram Schneider 
12404946a00bSDag-Erling Smørgrav #define ORDERKEY_PRIO(a, b) do { \
1241e38035a5SDag-Erling Smørgrav 	int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
12424946a00bSDag-Erling Smørgrav 	if (diff != 0) \
12434946a00bSDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
12444946a00bSDag-Erling Smørgrav } while (0)
1245f3b2c2d1SWolfram Schneider 
124632efd263SGiorgos Keramidas #define	ORDERKEY_THREADS(a, b) do { \
124732efd263SGiorgos Keramidas 	int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
124832efd263SGiorgos Keramidas 	if (diff != 0) \
124932efd263SGiorgos Keramidas 		return (diff > 0 ? 1 : -1); \
125032efd263SGiorgos Keramidas } while (0)
125132efd263SGiorgos Keramidas 
12524946a00bSDag-Erling Smørgrav #define ORDERKEY_RSSIZE(a, b) do { \
1253e38035a5SDag-Erling Smørgrav 	long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
12544946a00bSDag-Erling Smørgrav 	if (diff != 0) \
12554946a00bSDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
12564946a00bSDag-Erling Smørgrav } while (0)
1257f3b2c2d1SWolfram Schneider 
12584946a00bSDag-Erling Smørgrav #define ORDERKEY_MEM(a, b) do { \
1259e38035a5SDag-Erling Smørgrav 	long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
12604946a00bSDag-Erling Smørgrav 	if (diff != 0) \
12614946a00bSDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
12624946a00bSDag-Erling Smørgrav } while (0)
1263f3b2c2d1SWolfram Schneider 
12646000ced1SRong-En Fan #define ORDERKEY_JID(a, b) do { \
12656000ced1SRong-En Fan 	int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
12666000ced1SRong-En Fan 	if (diff != 0) \
12676000ced1SRong-En Fan 		return (diff > 0 ? 1 : -1); \
12686000ced1SRong-En Fan } while (0)
12696000ced1SRong-En Fan 
1270b6924c93SDag-Erling Smørgrav #define ORDERKEY_SWAP(a, b) do { \
1271b6924c93SDag-Erling Smørgrav 	int diff = (int)ki_swap(b) - (int)ki_swap(a); \
1272b6924c93SDag-Erling Smørgrav 	if (diff != 0) \
1273b6924c93SDag-Erling Smørgrav 		return (diff > 0 ? 1 : -1); \
1274b6924c93SDag-Erling Smørgrav } while (0)
1275b6924c93SDag-Erling Smørgrav 
1276f3b2c2d1SWolfram Schneider /* compare_cpu - the comparison function for sorting by cpu percentage */
1277f3b2c2d1SWolfram Schneider 
1278666cf873SEitan Adler static int
1279666cf873SEitan Adler compare_cpu(const void *arg1, const void *arg2)
1280511d9c65SJoerg Wunsch {
1281960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
1282960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
1283511d9c65SJoerg Wunsch 
12844946a00bSDag-Erling Smørgrav 	ORDERKEY_PCTCPU(p1, p2);
12854946a00bSDag-Erling Smørgrav 	ORDERKEY_CPTICKS(p1, p2);
12864946a00bSDag-Erling Smørgrav 	ORDERKEY_STATE(p1, p2);
12874946a00bSDag-Erling Smørgrav 	ORDERKEY_PRIO(p1, p2);
12884946a00bSDag-Erling Smørgrav 	ORDERKEY_RSSIZE(p1, p2);
12894946a00bSDag-Erling Smørgrav 	ORDERKEY_MEM(p1, p2);
1290511d9c65SJoerg Wunsch 
12914946a00bSDag-Erling Smørgrav 	return (0);
1292511d9c65SJoerg Wunsch }
1293511d9c65SJoerg Wunsch 
1294f3b2c2d1SWolfram Schneider /* compare_size - the comparison function for sorting by total memory usage */
1295f3b2c2d1SWolfram Schneider 
12969f8096e3SEitan Adler static int
1297666cf873SEitan Adler compare_size(const void *arg1, const void *arg2)
1298f3b2c2d1SWolfram Schneider {
1299960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
1300960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
1301f3b2c2d1SWolfram Schneider 
13024946a00bSDag-Erling Smørgrav 	ORDERKEY_MEM(p1, p2);
13034946a00bSDag-Erling Smørgrav 	ORDERKEY_RSSIZE(p1, p2);
13044946a00bSDag-Erling Smørgrav 	ORDERKEY_PCTCPU(p1, p2);
13054946a00bSDag-Erling Smørgrav 	ORDERKEY_CPTICKS(p1, p2);
13064946a00bSDag-Erling Smørgrav 	ORDERKEY_STATE(p1, p2);
13074946a00bSDag-Erling Smørgrav 	ORDERKEY_PRIO(p1, p2);
1308f3b2c2d1SWolfram Schneider 
13094946a00bSDag-Erling Smørgrav 	return (0);
1310f3b2c2d1SWolfram Schneider }
1311f3b2c2d1SWolfram Schneider 
1312f3b2c2d1SWolfram Schneider /* compare_res - the comparison function for sorting by resident set size */
1313f3b2c2d1SWolfram Schneider 
13149f8096e3SEitan Adler static int
1315666cf873SEitan Adler compare_res(const void *arg1, const void *arg2)
1316f3b2c2d1SWolfram Schneider {
1317960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
1318960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
1319f3b2c2d1SWolfram Schneider 
13204946a00bSDag-Erling Smørgrav 	ORDERKEY_RSSIZE(p1, p2);
13214946a00bSDag-Erling Smørgrav 	ORDERKEY_MEM(p1, p2);
13224946a00bSDag-Erling Smørgrav 	ORDERKEY_PCTCPU(p1, p2);
13234946a00bSDag-Erling Smørgrav 	ORDERKEY_CPTICKS(p1, p2);
13244946a00bSDag-Erling Smørgrav 	ORDERKEY_STATE(p1, p2);
13254946a00bSDag-Erling Smørgrav 	ORDERKEY_PRIO(p1, p2);
1326f3b2c2d1SWolfram Schneider 
13274946a00bSDag-Erling Smørgrav 	return (0);
1328f3b2c2d1SWolfram Schneider }
1329f3b2c2d1SWolfram Schneider 
1330f3b2c2d1SWolfram Schneider /* compare_time - the comparison function for sorting by total cpu time */
1331f3b2c2d1SWolfram Schneider 
13329f8096e3SEitan Adler static int
1333666cf873SEitan Adler compare_time(const void *arg1, const void *arg2)
1334f3b2c2d1SWolfram Schneider {
1335960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const  *)arg1;
1336960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *) arg2;
1337f3b2c2d1SWolfram Schneider 
13384946a00bSDag-Erling Smørgrav 	ORDERKEY_CPTICKS(p1, p2);
13394946a00bSDag-Erling Smørgrav 	ORDERKEY_PCTCPU(p1, p2);
13404946a00bSDag-Erling Smørgrav 	ORDERKEY_STATE(p1, p2);
13414946a00bSDag-Erling Smørgrav 	ORDERKEY_PRIO(p1, p2);
13424946a00bSDag-Erling Smørgrav 	ORDERKEY_RSSIZE(p1, p2);
13434946a00bSDag-Erling Smørgrav 	ORDERKEY_MEM(p1, p2);
1344f3b2c2d1SWolfram Schneider 
13454946a00bSDag-Erling Smørgrav 	return (0);
1346f3b2c2d1SWolfram Schneider }
1347f3b2c2d1SWolfram Schneider 
13484946a00bSDag-Erling Smørgrav /* compare_prio - the comparison function for sorting by priority */
1349f3b2c2d1SWolfram Schneider 
13509f8096e3SEitan Adler static int
1351666cf873SEitan Adler compare_prio(const void *arg1, const void *arg2)
1352f3b2c2d1SWolfram Schneider {
1353960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
1354960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
1355f3b2c2d1SWolfram Schneider 
13564946a00bSDag-Erling Smørgrav 	ORDERKEY_PRIO(p1, p2);
13574946a00bSDag-Erling Smørgrav 	ORDERKEY_CPTICKS(p1, p2);
13584946a00bSDag-Erling Smørgrav 	ORDERKEY_PCTCPU(p1, p2);
13594946a00bSDag-Erling Smørgrav 	ORDERKEY_STATE(p1, p2);
13604946a00bSDag-Erling Smørgrav 	ORDERKEY_RSSIZE(p1, p2);
13614946a00bSDag-Erling Smørgrav 	ORDERKEY_MEM(p1, p2);
1362f3b2c2d1SWolfram Schneider 
13634946a00bSDag-Erling Smørgrav 	return (0);
1364f3b2c2d1SWolfram Schneider }
136532efd263SGiorgos Keramidas 
136632efd263SGiorgos Keramidas /* compare_threads - the comparison function for sorting by threads */
1367666cf873SEitan Adler static int
1368666cf873SEitan Adler compare_threads(const void *arg1, const void *arg2)
136932efd263SGiorgos Keramidas {
1370960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
1371960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
137232efd263SGiorgos Keramidas 
137332efd263SGiorgos Keramidas 	ORDERKEY_THREADS(p1, p2);
137432efd263SGiorgos Keramidas 	ORDERKEY_PCTCPU(p1, p2);
137532efd263SGiorgos Keramidas 	ORDERKEY_CPTICKS(p1, p2);
137632efd263SGiorgos Keramidas 	ORDERKEY_STATE(p1, p2);
137732efd263SGiorgos Keramidas 	ORDERKEY_PRIO(p1, p2);
137832efd263SGiorgos Keramidas 	ORDERKEY_RSSIZE(p1, p2);
137932efd263SGiorgos Keramidas 	ORDERKEY_MEM(p1, p2);
138032efd263SGiorgos Keramidas 
138132efd263SGiorgos Keramidas 	return (0);
138232efd263SGiorgos Keramidas }
13836000ced1SRong-En Fan 
13846000ced1SRong-En Fan /* compare_jid - the comparison function for sorting by jid */
13856000ced1SRong-En Fan static int
13866000ced1SRong-En Fan compare_jid(const void *arg1, const void *arg2)
13876000ced1SRong-En Fan {
1388960a7f39SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
1389960a7f39SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
13906000ced1SRong-En Fan 
13916000ced1SRong-En Fan 	ORDERKEY_JID(p1, p2);
13926000ced1SRong-En Fan 	ORDERKEY_PCTCPU(p1, p2);
13936000ced1SRong-En Fan 	ORDERKEY_CPTICKS(p1, p2);
13946000ced1SRong-En Fan 	ORDERKEY_STATE(p1, p2);
13956000ced1SRong-En Fan 	ORDERKEY_PRIO(p1, p2);
13966000ced1SRong-En Fan 	ORDERKEY_RSSIZE(p1, p2);
13976000ced1SRong-En Fan 	ORDERKEY_MEM(p1, p2);
13986000ced1SRong-En Fan 
13996000ced1SRong-En Fan 	return (0);
14006000ced1SRong-En Fan }
1401b6924c93SDag-Erling Smørgrav 
1402b6924c93SDag-Erling Smørgrav /* compare_swap - the comparison function for sorting by swap */
1403b6924c93SDag-Erling Smørgrav static int
1404b6924c93SDag-Erling Smørgrav compare_swap(const void *arg1, const void *arg2)
1405b6924c93SDag-Erling Smørgrav {
14069f8096e3SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
14079f8096e3SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
1408b6924c93SDag-Erling Smørgrav 
1409b6924c93SDag-Erling Smørgrav 	ORDERKEY_SWAP(p1, p2);
1410b6924c93SDag-Erling Smørgrav 	ORDERKEY_PCTCPU(p1, p2);
1411b6924c93SDag-Erling Smørgrav 	ORDERKEY_CPTICKS(p1, p2);
1412b6924c93SDag-Erling Smørgrav 	ORDERKEY_STATE(p1, p2);
1413b6924c93SDag-Erling Smørgrav 	ORDERKEY_PRIO(p1, p2);
1414b6924c93SDag-Erling Smørgrav 	ORDERKEY_RSSIZE(p1, p2);
1415b6924c93SDag-Erling Smørgrav 	ORDERKEY_MEM(p1, p2);
1416b6924c93SDag-Erling Smørgrav 
1417b6924c93SDag-Erling Smørgrav 	return (0);
1418b6924c93SDag-Erling Smørgrav }
1419511d9c65SJoerg Wunsch 
1420789e3877SBruce Evans /* assorted comparison functions for sorting by i/o */
142126b2243aSGiorgos Keramidas 
14229f8096e3SEitan Adler static int
1423666cf873SEitan Adler compare_iototal(const void *arg1, const void *arg2)
1424db6bb7fcSAlfred Perlstein {
14259f8096e3SEitan Adler 	const struct kinfo_proc * const p1 = *(const struct kinfo_proc * const *)arg1;
14269f8096e3SEitan Adler 	const struct kinfo_proc * const p2 = *(const struct kinfo_proc * const *)arg2;
1427db6bb7fcSAlfred Perlstein 
14284946a00bSDag-Erling Smørgrav 	return (get_io_total(p2) - get_io_total(p1));
1429db6bb7fcSAlfred Perlstein }
143026b2243aSGiorgos Keramidas 
1431666cf873SEitan Adler static int
1432666cf873SEitan Adler compare_ioread(const void *arg1, const void *arg2)
143326b2243aSGiorgos Keramidas {
14349f8096e3SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
14359f8096e3SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
143626b2243aSGiorgos Keramidas 	long dummy, inp1, inp2;
143726b2243aSGiorgos Keramidas 
14385d320d4bSAlfred Perlstein 	(void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
14395d320d4bSAlfred Perlstein 	(void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
144026b2243aSGiorgos Keramidas 
144126b2243aSGiorgos Keramidas 	return (inp2 - inp1);
144226b2243aSGiorgos Keramidas }
144326b2243aSGiorgos Keramidas 
1444666cf873SEitan Adler static int
1445666cf873SEitan Adler compare_iowrite(const void *arg1, const void *arg2)
144626b2243aSGiorgos Keramidas {
14479f8096e3SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
14489f8096e3SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
144926b2243aSGiorgos Keramidas 	long dummy, oup1, oup2;
145026b2243aSGiorgos Keramidas 
14515d320d4bSAlfred Perlstein 	(void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
14525d320d4bSAlfred Perlstein 	(void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
145326b2243aSGiorgos Keramidas 
145426b2243aSGiorgos Keramidas 	return (oup2 - oup1);
145526b2243aSGiorgos Keramidas }
145626b2243aSGiorgos Keramidas 
1457666cf873SEitan Adler static int
1458666cf873SEitan Adler compare_iofault(const void *arg1, const void *arg2)
145926b2243aSGiorgos Keramidas {
14609f8096e3SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
14619f8096e3SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
146226b2243aSGiorgos Keramidas 	long dummy, flp1, flp2;
146326b2243aSGiorgos Keramidas 
14645d320d4bSAlfred Perlstein 	(void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
14655d320d4bSAlfred Perlstein 	(void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
14665d320d4bSAlfred Perlstein 
14675d320d4bSAlfred Perlstein 	return (flp2 - flp1);
14685d320d4bSAlfred Perlstein }
14695d320d4bSAlfred Perlstein 
1470666cf873SEitan Adler static int
1471666cf873SEitan Adler compare_vcsw(const void *arg1, const void *arg2)
14725d320d4bSAlfred Perlstein {
14739f8096e3SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
14749f8096e3SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
14755d320d4bSAlfred Perlstein 	long dummy, flp1, flp2;
14765d320d4bSAlfred Perlstein 
14775d320d4bSAlfred Perlstein 	(void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
14785d320d4bSAlfred Perlstein 	(void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
14795d320d4bSAlfred Perlstein 
14805d320d4bSAlfred Perlstein 	return (flp2 - flp1);
14815d320d4bSAlfred Perlstein }
14825d320d4bSAlfred Perlstein 
14839f8096e3SEitan Adler static int
1484666cf873SEitan Adler compare_ivcsw(const void *arg1, const void *arg2)
14855d320d4bSAlfred Perlstein {
14869f8096e3SEitan Adler 	const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
14879f8096e3SEitan Adler 	const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
14885d320d4bSAlfred Perlstein 	long dummy, flp1, flp2;
14895d320d4bSAlfred Perlstein 
14905d320d4bSAlfred Perlstein 	(void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
14915d320d4bSAlfred Perlstein 	(void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
149226b2243aSGiorgos Keramidas 
149326b2243aSGiorgos Keramidas 	return (flp2 - flp1);
149426b2243aSGiorgos Keramidas }
149526b2243aSGiorgos Keramidas 
14969f8096e3SEitan Adler int (*compares[])(const void *arg1, const void *arg2) = {
14979f8096e3SEitan Adler 	compare_cpu,
14989f8096e3SEitan Adler 	compare_size,
14999f8096e3SEitan Adler 	compare_res,
15009f8096e3SEitan Adler 	compare_time,
15019f8096e3SEitan Adler 	compare_prio,
15029f8096e3SEitan Adler 	compare_threads,
15039f8096e3SEitan Adler 	compare_iototal,
15049f8096e3SEitan Adler 	compare_ioread,
15059f8096e3SEitan Adler 	compare_iowrite,
15069f8096e3SEitan Adler 	compare_iofault,
15079f8096e3SEitan Adler 	compare_vcsw,
15089f8096e3SEitan Adler 	compare_ivcsw,
15099f8096e3SEitan Adler 	compare_jid,
15109f8096e3SEitan Adler 	compare_swap,
15119f8096e3SEitan Adler 	NULL
15129f8096e3SEitan Adler };
15139f8096e3SEitan Adler 
15149f8096e3SEitan Adler 
1515de916c8bSBruce Evans static int
1516f6a10feaSDag-Erling Smørgrav swapmode(int *retavail, int *retfree)
1517511d9c65SJoerg Wunsch {
15187bb42db9SMatthew Dillon 	int n;
15197bb42db9SMatthew Dillon 	struct kvm_swap swapary[1];
152024e470efSKonstantin Belousov 	static int pagesize = 0;
1521cda7a5d5SEitan Adler 	static unsigned long swap_maxpages = 0;
1522511d9c65SJoerg Wunsch 
15237bb42db9SMatthew Dillon 	*retavail = 0;
15247bb42db9SMatthew Dillon 	*retfree = 0;
1525511d9c65SJoerg Wunsch 
15267bb42db9SMatthew Dillon #define CONVERT(v)	((quad_t)(v) * pagesize / 1024)
15277bb42db9SMatthew Dillon 
15287bb42db9SMatthew Dillon 	n = kvm_getswapinfo(kd, swapary, 1, 0);
152947b370f5SMatthew Dillon 	if (n < 0 || swapary[0].ksw_total == 0)
1530511d9c65SJoerg Wunsch 		return (0);
1531511d9c65SJoerg Wunsch 
153224e470efSKonstantin Belousov 	if (pagesize == 0)
153324e470efSKonstantin Belousov 		pagesize = getpagesize();
153424e470efSKonstantin Belousov 	if (swap_maxpages == 0)
153524e470efSKonstantin Belousov 		GETSYSCTL("vm.swap_maxpages", swap_maxpages);
153624e470efSKonstantin Belousov 
153724e470efSKonstantin Belousov 	/* ksw_total contains the total size of swap all devices which may
153824e470efSKonstantin Belousov 	   exceed the maximum swap size allocatable in the system */
153924e470efSKonstantin Belousov 	if ( swapary[0].ksw_total > swap_maxpages )
154024e470efSKonstantin Belousov 		swapary[0].ksw_total = swap_maxpages;
154124e470efSKonstantin Belousov 
15427bb42db9SMatthew Dillon 	*retavail = CONVERT(swapary[0].ksw_total);
15437bb42db9SMatthew Dillon 	*retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
15447bb42db9SMatthew Dillon 
1545*db365663SEitan Adler #undef CONVERT
1546*db365663SEitan Adler 
15474946a00bSDag-Erling Smørgrav 	n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);
15487bb42db9SMatthew Dillon 	return (n);
1549511d9c65SJoerg Wunsch }
1550