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