1511d9c65SJoerg Wunsch /* 2511d9c65SJoerg Wunsch * top - a top users display for Unix 3511d9c65SJoerg Wunsch * 433d56839SNick Hibma * SYNOPSIS: For FreeBSD-2.x and later 5511d9c65SJoerg Wunsch * 6511d9c65SJoerg Wunsch * DESCRIPTION: 7511d9c65SJoerg Wunsch * Originally written for BSD4.4 system by Christos Zoulas. 8511d9c65SJoerg Wunsch * Ported to FreeBSD 2.x by Steven Wallace && Wolfram Schneider 9f3b2c2d1SWolfram Schneider * Order support hacked in from top-3.5beta6/machine/m_aix41.c 10f3b2c2d1SWolfram Schneider * by Monte Mitzelfelt (for latest top see http://www.groupsys.com/topinfo/) 11511d9c65SJoerg Wunsch * 12511d9c65SJoerg Wunsch * This is the machine-dependent module for FreeBSD 2.2 13511d9c65SJoerg Wunsch * Works for: 1433d56839SNick Hibma * FreeBSD 2.2.x, 3.x, 4.x, and probably FreeBSD 2.1.x 15511d9c65SJoerg Wunsch * 16511d9c65SJoerg Wunsch * LIBS: -lkvm 17511d9c65SJoerg Wunsch * 18511d9c65SJoerg Wunsch * AUTHOR: Christos Zoulas <christos@ee.cornell.edu> 19511d9c65SJoerg Wunsch * Steven Wallace <swallace@freebsd.org> 20511d9c65SJoerg Wunsch * Wolfram Schneider <wosch@FreeBSD.org> 2139d513ecSRobert Watson * Thomas Moestl <tmoestl@gmx.net> 22511d9c65SJoerg Wunsch * 23c3aac50fSPeter Wemm * $FreeBSD$ 24511d9c65SJoerg Wunsch */ 25511d9c65SJoerg Wunsch 26511d9c65SJoerg Wunsch #include <sys/param.h> 27511d9c65SJoerg Wunsch #include <sys/errno.h> 28511d9c65SJoerg Wunsch #include <sys/file.h> 29511d9c65SJoerg Wunsch #include <sys/proc.h> 30e5aff02fSPeter Wemm #include <sys/resource.h> 31e5aff02fSPeter Wemm #include <sys/rtprio.h> 32cd23263cSDag-Erling Smørgrav #include <sys/signal.h> 33cd23263cSDag-Erling Smørgrav #include <sys/sysctl.h> 34cd23263cSDag-Erling Smørgrav #include <sys/time.h> 35cd23263cSDag-Erling Smørgrav #include <sys/user.h> 36cd23263cSDag-Erling Smørgrav #include <sys/vmmeter.h> 37511d9c65SJoerg Wunsch 38cd23263cSDag-Erling Smørgrav #include <kvm.h> 39cd23263cSDag-Erling Smørgrav #include <math.h> 40cd23263cSDag-Erling Smørgrav #include <nlist.h> 414946a00bSDag-Erling Smørgrav #include <paths.h> 42cd23263cSDag-Erling Smørgrav #include <pwd.h> 43cd23263cSDag-Erling Smørgrav #include <stdio.h> 44511d9c65SJoerg Wunsch #include <stdlib.h> 4539d513ecSRobert Watson #include <unistd.h> 46511d9c65SJoerg Wunsch 47511d9c65SJoerg Wunsch #include "top.h" 48511d9c65SJoerg Wunsch #include "machine.h" 497f18d5d3SJohn Baldwin #include "screen.h" 5039d513ecSRobert Watson #include "utils.h" 51511d9c65SJoerg Wunsch 523f330d7dSWarner Losh static void getsysctl(char *, void *, size_t); 5339d513ecSRobert Watson 5439d513ecSRobert Watson #define GETSYSCTL(name, var) getsysctl(name, &(var), sizeof(var)) 5539d513ecSRobert Watson 563f330d7dSWarner Losh extern char* printable(char *); 573f330d7dSWarner Losh int swapmode(int *retavail, int *retfree); 5894154ff8SPeter Wemm static int smpmode; 59db6bb7fcSAlfred Perlstein enum displaymodes displaymode; 60a2aff8b2SPeter Wemm static int namelength; 617f18d5d3SJohn Baldwin static int cmdlengthdelta; 62511d9c65SJoerg Wunsch 6339d513ecSRobert Watson /* Prototypes for top internals */ 643f330d7dSWarner Losh void quit(int); 65db6bb7fcSAlfred Perlstein int compare_pid(const void *a, const void *b); 66511d9c65SJoerg Wunsch 67511d9c65SJoerg Wunsch /* get_process_info passes back a handle. This is what it looks like: */ 68511d9c65SJoerg Wunsch 69511d9c65SJoerg Wunsch struct handle 70511d9c65SJoerg Wunsch { 71511d9c65SJoerg Wunsch struct kinfo_proc **next_proc; /* points to next valid proc pointer */ 72511d9c65SJoerg Wunsch int remaining; /* number of pointers remaining */ 73511d9c65SJoerg Wunsch }; 74511d9c65SJoerg Wunsch 75511d9c65SJoerg Wunsch /* declarations for load_avg */ 76511d9c65SJoerg Wunsch #include "loadavg.h" 77511d9c65SJoerg Wunsch 78511d9c65SJoerg Wunsch /* define what weighted cpu is. */ 791f7d2501SKirk McKusick #define weighted_cpu(pct, pp) ((pp)->ki_swtime == 0 ? 0.0 : \ 801f7d2501SKirk McKusick ((pct) / (1.0 - exp((pp)->ki_swtime * logcpu)))) 81511d9c65SJoerg Wunsch 82511d9c65SJoerg Wunsch /* what we consider to be process size: */ 831f7d2501SKirk McKusick #define PROCSIZE(pp) ((pp)->ki_size / 1024) 84511d9c65SJoerg Wunsch 85db6bb7fcSAlfred Perlstein #define RU(pp) (&(pp)->ki_rusage) 86db6bb7fcSAlfred Perlstein #define RUTOT(pp) \ 87db6bb7fcSAlfred Perlstein (RU(pp)->ru_inblock + RU(pp)->ru_oublock + RU(pp)->ru_majflt) 88db6bb7fcSAlfred Perlstein 89db6bb7fcSAlfred Perlstein 90511d9c65SJoerg Wunsch /* definitions for indices in the nlist array */ 91511d9c65SJoerg Wunsch 92511d9c65SJoerg Wunsch /* 93511d9c65SJoerg Wunsch * These definitions control the format of the per-process area 94511d9c65SJoerg Wunsch */ 95511d9c65SJoerg Wunsch 96db6bb7fcSAlfred Perlstein static char io_header[] = 977fe9a86aSAlfred Perlstein " PID %-*.*s READ WRITE FAULT TOTAL PERCENT COMMAND"; 98db6bb7fcSAlfred Perlstein 99db6bb7fcSAlfred Perlstein #define io_Proc_format \ 1004946a00bSDag-Erling Smørgrav "%5d %-*.*s %6ld %6ld %6ld %6ld %6.2f%% %.*s" 101db6bb7fcSAlfred Perlstein 10294154ff8SPeter Wemm static char smp_header[] = 103a2aff8b2SPeter Wemm " PID %-*.*s PRI NICE SIZE RES STATE C TIME WCPU CPU COMMAND"; 104511d9c65SJoerg Wunsch 10594154ff8SPeter Wemm #define smp_Proc_format \ 106a28d666cSMark Murray "%5d %-*.*s %3d %4d%7s %6s %-6.6s %1x%7s %5.2f%% %5.2f%% %.*s" 107511d9c65SJoerg Wunsch 10894154ff8SPeter Wemm static char up_header[] = 109a2aff8b2SPeter Wemm " PID %-*.*s PRI NICE SIZE RES STATE TIME WCPU CPU COMMAND"; 110511d9c65SJoerg Wunsch 11194154ff8SPeter Wemm #define up_Proc_format \ 112a28d666cSMark Murray "%5d %-*.*s %3d %4d%7s %6s %-6.6s%.0d%7s %5.2f%% %5.2f%% %.*s" 113511d9c65SJoerg Wunsch 114511d9c65SJoerg Wunsch 115511d9c65SJoerg Wunsch 116511d9c65SJoerg Wunsch /* process state names for the "STATE" column of the display */ 117511d9c65SJoerg Wunsch /* the extra nulls in the string "run" are for adding a slash and 118511d9c65SJoerg Wunsch the processor number when needed */ 119511d9c65SJoerg Wunsch 120511d9c65SJoerg Wunsch char *state_abbrev[] = 121511d9c65SJoerg Wunsch { 1220d632649SJohn Baldwin "", "START", "RUN\0\0\0", "SLEEP", "STOP", "ZOMB", "WAIT", "LOCK" 123511d9c65SJoerg Wunsch }; 124511d9c65SJoerg Wunsch 125511d9c65SJoerg Wunsch 126511d9c65SJoerg Wunsch static kvm_t *kd; 127511d9c65SJoerg Wunsch 128511d9c65SJoerg Wunsch /* values that we stash away in _init and use in later routines */ 129511d9c65SJoerg Wunsch 130511d9c65SJoerg Wunsch static double logcpu; 131511d9c65SJoerg Wunsch 132511d9c65SJoerg Wunsch /* these are retrieved from the kernel in _init */ 133511d9c65SJoerg Wunsch 134511d9c65SJoerg Wunsch static load_avg ccpu; 135511d9c65SJoerg Wunsch 13639d513ecSRobert Watson /* these are used in the get_ functions */ 137511d9c65SJoerg Wunsch 13839d513ecSRobert Watson static int lastpid; 139511d9c65SJoerg Wunsch 140511d9c65SJoerg Wunsch /* these are for calculating cpu state percentages */ 141511d9c65SJoerg Wunsch 142511d9c65SJoerg Wunsch static long cp_time[CPUSTATES]; 143511d9c65SJoerg Wunsch static long cp_old[CPUSTATES]; 144511d9c65SJoerg Wunsch static long cp_diff[CPUSTATES]; 145511d9c65SJoerg Wunsch 146511d9c65SJoerg Wunsch /* these are for detailing the process states */ 147511d9c65SJoerg Wunsch 1480384fff8SJason Evans int process_states[8]; 149511d9c65SJoerg Wunsch char *procstatenames[] = { 150511d9c65SJoerg Wunsch "", " starting, ", " running, ", " sleeping, ", " stopped, ", 1510d632649SJohn Baldwin " zombie, ", " waiting, ", " lock, ", 152511d9c65SJoerg Wunsch NULL 153511d9c65SJoerg Wunsch }; 154511d9c65SJoerg Wunsch 155511d9c65SJoerg Wunsch /* these are for detailing the cpu states */ 156511d9c65SJoerg Wunsch 157511d9c65SJoerg Wunsch int cpu_states[CPUSTATES]; 158511d9c65SJoerg Wunsch char *cpustatenames[] = { 159511d9c65SJoerg Wunsch "user", "nice", "system", "interrupt", "idle", NULL 160511d9c65SJoerg Wunsch }; 161511d9c65SJoerg Wunsch 162511d9c65SJoerg Wunsch /* these are for detailing the memory statistics */ 163511d9c65SJoerg Wunsch 164511d9c65SJoerg Wunsch int memory_stats[7]; 165511d9c65SJoerg Wunsch char *memorynames[] = { 166ea9e70bfSDag-Erling Smørgrav /* 0 1 2 3 4 5 */ 167511d9c65SJoerg Wunsch "K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ", "K Free", 168511d9c65SJoerg Wunsch NULL 169511d9c65SJoerg Wunsch }; 170511d9c65SJoerg Wunsch 171511d9c65SJoerg Wunsch int swap_stats[7]; 172511d9c65SJoerg Wunsch char *swapnames[] = { 173511d9c65SJoerg Wunsch /* 0 1 2 3 4 5 */ 174511d9c65SJoerg Wunsch "K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out", 175511d9c65SJoerg Wunsch NULL 176511d9c65SJoerg Wunsch }; 177511d9c65SJoerg Wunsch 178511d9c65SJoerg Wunsch 179511d9c65SJoerg Wunsch /* these are for keeping track of the proc array */ 180511d9c65SJoerg Wunsch 181511d9c65SJoerg Wunsch static int nproc; 182511d9c65SJoerg Wunsch static int onproc = -1; 183511d9c65SJoerg Wunsch static int pref_len; 184511d9c65SJoerg Wunsch static struct kinfo_proc *pbase; 185511d9c65SJoerg Wunsch static struct kinfo_proc **pref; 186db6bb7fcSAlfred Perlstein static struct kinfo_proc *previous_procs; 187db6bb7fcSAlfred Perlstein static struct kinfo_proc **previous_pref; 188db6bb7fcSAlfred Perlstein static int previous_proc_count = 0; 189db6bb7fcSAlfred Perlstein static int previous_proc_count_max = 0; 190511d9c65SJoerg Wunsch 1917fe9a86aSAlfred Perlstein /* total number of io operations */ 1927fe9a86aSAlfred Perlstein static long total_inblock; 1937fe9a86aSAlfred Perlstein static long total_oublock; 1947fe9a86aSAlfred Perlstein static long total_majflt; 1957fe9a86aSAlfred Perlstein 196511d9c65SJoerg Wunsch /* these are for getting the memory statistics */ 197511d9c65SJoerg Wunsch 198511d9c65SJoerg Wunsch static int pageshift; /* log base 2 of the pagesize */ 199511d9c65SJoerg Wunsch 200511d9c65SJoerg Wunsch /* define pagetok in terms of pageshift */ 201511d9c65SJoerg Wunsch 202511d9c65SJoerg Wunsch #define pagetok(size) ((size) << pageshift) 203511d9c65SJoerg Wunsch 204511d9c65SJoerg Wunsch /* useful externals */ 205511d9c65SJoerg Wunsch long percentages(); 206511d9c65SJoerg Wunsch 207f3b2c2d1SWolfram Schneider #ifdef ORDER 20826b2243aSGiorgos Keramidas /* 20926b2243aSGiorgos Keramidas * Sorting orders. One vector per display mode. 21026b2243aSGiorgos Keramidas * The first element is the default for each mode. 21126b2243aSGiorgos Keramidas */ 21226b2243aSGiorgos Keramidas char *proc_ordernames[] = { 213f3b2c2d1SWolfram Schneider "cpu", "size", "res", "time", "pri", NULL 214f3b2c2d1SWolfram Schneider }; 21526b2243aSGiorgos Keramidas char *io_ordernames[] = { 21626b2243aSGiorgos Keramidas "total", "read", "write", "fault", NULL 21726b2243aSGiorgos Keramidas }; 218f3b2c2d1SWolfram Schneider #endif 219f3b2c2d1SWolfram Schneider 220511d9c65SJoerg Wunsch int 221f6a10feaSDag-Erling Smørgrav machine_init(struct statics *statics) 222511d9c65SJoerg Wunsch { 223970636e9SAlfred Perlstein int pagesize; 22498e53e5bSAndrew Gallatin size_t modelen; 225a2aff8b2SPeter Wemm struct passwd *pw; 22694154ff8SPeter Wemm 22794154ff8SPeter Wemm modelen = sizeof(smpmode); 228ed550569SPeter Wemm if ((sysctlbyname("machdep.smp_active", &smpmode, &modelen, NULL, 0) < 0 && 2292522796eSJohn Baldwin sysctlbyname("kern.smp.active", &smpmode, &modelen, NULL, 0) < 0) || 23094154ff8SPeter Wemm modelen != sizeof(smpmode)) 23194154ff8SPeter Wemm smpmode = 0; 232511d9c65SJoerg Wunsch 233a2aff8b2SPeter Wemm while ((pw = getpwent()) != NULL) { 234a2aff8b2SPeter Wemm if (strlen(pw->pw_name) > namelength) 235a2aff8b2SPeter Wemm namelength = strlen(pw->pw_name); 236a2aff8b2SPeter Wemm } 237a2aff8b2SPeter Wemm if (namelength < 8) 238a2aff8b2SPeter Wemm namelength = 8; 2399e138095SWill Andrews if (smpmode && namelength > 13) 2409e138095SWill Andrews namelength = 13; 2419e138095SWill Andrews else if (namelength > 15) 242dc7c1750SDavid Nugent namelength = 15; 243a2aff8b2SPeter Wemm 2444946a00bSDag-Erling Smørgrav kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open"); 2454946a00bSDag-Erling Smørgrav if (kd == NULL) 2464946a00bSDag-Erling Smørgrav return (-1); 247511d9c65SJoerg Wunsch 24839d513ecSRobert Watson GETSYSCTL("kern.ccpu", ccpu); 249511d9c65SJoerg Wunsch 250511d9c65SJoerg Wunsch /* this is used in calculating WCPU -- calculate it ahead of time */ 251511d9c65SJoerg Wunsch logcpu = log(loaddouble(ccpu)); 252511d9c65SJoerg Wunsch 253511d9c65SJoerg Wunsch pbase = NULL; 254511d9c65SJoerg Wunsch pref = NULL; 255511d9c65SJoerg Wunsch nproc = 0; 256511d9c65SJoerg Wunsch onproc = -1; 257511d9c65SJoerg Wunsch /* get the page size with "getpagesize" and calculate pageshift from it */ 258511d9c65SJoerg Wunsch pagesize = getpagesize(); 259511d9c65SJoerg Wunsch pageshift = 0; 2604946a00bSDag-Erling Smørgrav while (pagesize > 1) { 261511d9c65SJoerg Wunsch pageshift++; 262511d9c65SJoerg Wunsch pagesize >>= 1; 263511d9c65SJoerg Wunsch } 264511d9c65SJoerg Wunsch 265511d9c65SJoerg Wunsch /* we only need the amount of log(2)1024 for our conversion */ 266511d9c65SJoerg Wunsch pageshift -= LOG1024; 267511d9c65SJoerg Wunsch 268511d9c65SJoerg Wunsch /* fill in the statics information */ 269511d9c65SJoerg Wunsch statics->procstate_names = procstatenames; 270511d9c65SJoerg Wunsch statics->cpustate_names = cpustatenames; 271511d9c65SJoerg Wunsch statics->memory_names = memorynames; 272511d9c65SJoerg Wunsch statics->swap_names = swapnames; 273f3b2c2d1SWolfram Schneider #ifdef ORDER 27426b2243aSGiorgos Keramidas switch (displaymode) { 27526b2243aSGiorgos Keramidas case DISP_IO: 27626b2243aSGiorgos Keramidas statics->order_names = io_ordernames; 27726b2243aSGiorgos Keramidas break; 27826b2243aSGiorgos Keramidas case DISP_CPU: 27926b2243aSGiorgos Keramidas default: 28026b2243aSGiorgos Keramidas statics->order_names = proc_ordernames; 28126b2243aSGiorgos Keramidas break; 28226b2243aSGiorgos Keramidas } 283f3b2c2d1SWolfram Schneider #endif 284511d9c65SJoerg Wunsch 285511d9c65SJoerg Wunsch /* all done! */ 286511d9c65SJoerg Wunsch return (0); 287511d9c65SJoerg Wunsch } 288511d9c65SJoerg Wunsch 289970636e9SAlfred Perlstein char * 290f6a10feaSDag-Erling Smørgrav format_header(char *uname_field) 291511d9c65SJoerg Wunsch { 292a2aff8b2SPeter Wemm static char Header[128]; 293db6bb7fcSAlfred Perlstein const char *prehead; 294511d9c65SJoerg Wunsch 295db6bb7fcSAlfred Perlstein switch (displaymode) { 296db6bb7fcSAlfred Perlstein case DISP_CPU: 297db6bb7fcSAlfred Perlstein prehead = smpmode ? smp_header : up_header; 298db6bb7fcSAlfred Perlstein break; 299db6bb7fcSAlfred Perlstein case DISP_IO: 300db6bb7fcSAlfred Perlstein prehead = io_header; 301db6bb7fcSAlfred Perlstein break; 302db6bb7fcSAlfred Perlstein } 303db6bb7fcSAlfred Perlstein 304db6bb7fcSAlfred Perlstein snprintf(Header, sizeof(Header), prehead, 305a2aff8b2SPeter Wemm namelength, namelength, uname_field); 30694154ff8SPeter Wemm 3077f18d5d3SJohn Baldwin cmdlengthdelta = strlen(Header) - 7; 308511d9c65SJoerg Wunsch 309ea9e70bfSDag-Erling Smørgrav return (Header); 310511d9c65SJoerg Wunsch } 311511d9c65SJoerg Wunsch 312511d9c65SJoerg Wunsch static int swappgsin = -1; 313511d9c65SJoerg Wunsch static int swappgsout = -1; 314511d9c65SJoerg Wunsch extern struct timeval timeout; 315511d9c65SJoerg Wunsch 316511d9c65SJoerg Wunsch void 317f6a10feaSDag-Erling Smørgrav get_system_info(struct system_info *si) 318511d9c65SJoerg Wunsch { 319511d9c65SJoerg Wunsch long total; 32098e53e5bSAndrew Gallatin struct loadavg sysload; 321a2641311SDavid E. O'Brien int mib[2]; 322a2641311SDavid E. O'Brien struct timeval boottime; 323a2641311SDavid E. O'Brien size_t bt_size; 3244946a00bSDag-Erling Smørgrav int i; 325511d9c65SJoerg Wunsch 326511d9c65SJoerg Wunsch /* get the cp_time array */ 32739d513ecSRobert Watson GETSYSCTL("kern.cp_time", cp_time); 32898e53e5bSAndrew Gallatin GETSYSCTL("vm.loadavg", sysload); 32939d513ecSRobert Watson GETSYSCTL("kern.lastpid", lastpid); 330511d9c65SJoerg Wunsch 331511d9c65SJoerg Wunsch /* convert load averages to doubles */ 332511d9c65SJoerg Wunsch for (i = 0; i < 3; i++) 3334946a00bSDag-Erling Smørgrav si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale; 334511d9c65SJoerg Wunsch 335511d9c65SJoerg Wunsch /* convert cp_time counts to percentages */ 336511d9c65SJoerg Wunsch total = percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff); 337511d9c65SJoerg Wunsch 338511d9c65SJoerg Wunsch /* sum memory & swap statistics */ 339511d9c65SJoerg Wunsch { 340511d9c65SJoerg Wunsch static unsigned int swap_delay = 0; 341511d9c65SJoerg Wunsch static int swapavail = 0; 342511d9c65SJoerg Wunsch static int swapfree = 0; 343511d9c65SJoerg Wunsch static int bufspace = 0; 34439d513ecSRobert Watson static int nspgsin, nspgsout; 345511d9c65SJoerg Wunsch 34639d513ecSRobert Watson GETSYSCTL("vfs.bufspace", bufspace); 34739d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]); 34839d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]); 34939d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[2]); 35039d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_cache_count", memory_stats[3]); 35139d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]); 35239d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin); 35339d513ecSRobert Watson GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout); 354511d9c65SJoerg Wunsch /* convert memory stats to Kbytes */ 3556243f7acSThomas Moestl memory_stats[0] = pagetok(memory_stats[0]); 3566243f7acSThomas Moestl memory_stats[1] = pagetok(memory_stats[1]); 3576243f7acSThomas Moestl memory_stats[2] = pagetok(memory_stats[2]); 3586243f7acSThomas Moestl memory_stats[3] = pagetok(memory_stats[3]); 359511d9c65SJoerg Wunsch memory_stats[4] = bufspace / 1024; 3606243f7acSThomas Moestl memory_stats[5] = pagetok(memory_stats[5]); 361511d9c65SJoerg Wunsch memory_stats[6] = -1; 362511d9c65SJoerg Wunsch 363511d9c65SJoerg Wunsch /* first interval */ 364511d9c65SJoerg Wunsch if (swappgsin < 0) { 365511d9c65SJoerg Wunsch swap_stats[4] = 0; 366511d9c65SJoerg Wunsch swap_stats[5] = 0; 367511d9c65SJoerg Wunsch } 368511d9c65SJoerg Wunsch 369511d9c65SJoerg Wunsch /* compute differences between old and new swap statistic */ 370511d9c65SJoerg Wunsch else { 37139d513ecSRobert Watson swap_stats[4] = pagetok(((nspgsin - swappgsin))); 37239d513ecSRobert Watson swap_stats[5] = pagetok(((nspgsout - swappgsout))); 373511d9c65SJoerg Wunsch } 374511d9c65SJoerg Wunsch 37539d513ecSRobert Watson swappgsin = nspgsin; 37639d513ecSRobert Watson swappgsout = nspgsout; 377511d9c65SJoerg Wunsch 378511d9c65SJoerg Wunsch /* call CPU heavy swapmode() only for changes */ 379511d9c65SJoerg Wunsch if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) { 380511d9c65SJoerg Wunsch swap_stats[3] = swapmode(&swapavail, &swapfree); 381511d9c65SJoerg Wunsch swap_stats[0] = swapavail; 382511d9c65SJoerg Wunsch swap_stats[1] = swapavail - swapfree; 383511d9c65SJoerg Wunsch swap_stats[2] = swapfree; 384511d9c65SJoerg Wunsch } 385511d9c65SJoerg Wunsch swap_delay = 1; 386511d9c65SJoerg Wunsch swap_stats[6] = -1; 387511d9c65SJoerg Wunsch } 388511d9c65SJoerg Wunsch 389511d9c65SJoerg Wunsch /* set arrays and strings */ 390511d9c65SJoerg Wunsch si->cpustates = cpu_states; 391511d9c65SJoerg Wunsch si->memory = memory_stats; 392511d9c65SJoerg Wunsch si->swap = swap_stats; 393511d9c65SJoerg Wunsch 394511d9c65SJoerg Wunsch 395511d9c65SJoerg Wunsch if (lastpid > 0) { 396511d9c65SJoerg Wunsch si->last_pid = lastpid; 397511d9c65SJoerg Wunsch } else { 398511d9c65SJoerg Wunsch si->last_pid = -1; 399511d9c65SJoerg Wunsch } 400a2641311SDavid E. O'Brien 401a2641311SDavid E. O'Brien /* 402a2641311SDavid E. O'Brien * Print how long system has been up. 403a2641311SDavid E. O'Brien * (Found by looking getting "boottime" from the kernel) 404a2641311SDavid E. O'Brien */ 405a2641311SDavid E. O'Brien mib[0] = CTL_KERN; 406a2641311SDavid E. O'Brien mib[1] = KERN_BOOTTIME; 407a2641311SDavid E. O'Brien bt_size = sizeof(boottime); 408a2641311SDavid E. O'Brien if (sysctl(mib, 2, &boottime, &bt_size, NULL, 0) != -1 && 409a2641311SDavid E. O'Brien boottime.tv_sec != 0) { 410a2641311SDavid E. O'Brien si->boottime = boottime; 411a2641311SDavid E. O'Brien } else { 412a2641311SDavid E. O'Brien si->boottime.tv_sec = -1; 413a2641311SDavid E. O'Brien } 414511d9c65SJoerg Wunsch } 415511d9c65SJoerg Wunsch 41698c151d6SAlfred Perlstein #define NOPROC ((void *)-1) 41798c151d6SAlfred Perlstein 418dcd6f4bdSAlfred Perlstein /* 419dcd6f4bdSAlfred Perlstein * We need to compare data from the old process entry with the new 420dcd6f4bdSAlfred Perlstein * process entry. 421dcd6f4bdSAlfred Perlstein * To facilitate doing this quickly we stash a pointer in the kinfo_proc 422dcd6f4bdSAlfred Perlstein * structure to cache the mapping. We also use a negative cache pointer 423dcd6f4bdSAlfred Perlstein * of NOPROC to avoid duplicate lookups. 424dcd6f4bdSAlfred Perlstein * XXX: this could be done when the actual processes are fetched, we do 425dcd6f4bdSAlfred Perlstein * it here out of laziness. 426dcd6f4bdSAlfred Perlstein */ 427db6bb7fcSAlfred Perlstein const struct kinfo_proc * 428db6bb7fcSAlfred Perlstein get_old_proc(struct kinfo_proc *pp) 429db6bb7fcSAlfred Perlstein { 430db6bb7fcSAlfred Perlstein struct kinfo_proc **oldpp, *oldp; 431db6bb7fcSAlfred Perlstein 432dcd6f4bdSAlfred Perlstein /* 433dcd6f4bdSAlfred Perlstein * If this is the first fetch of the kinfo_procs then we don't have 434dcd6f4bdSAlfred Perlstein * any previous entries. 435dcd6f4bdSAlfred Perlstein */ 436db6bb7fcSAlfred Perlstein if (previous_proc_count == 0) 437db6bb7fcSAlfred Perlstein return (NULL); 438dcd6f4bdSAlfred Perlstein /* negative cache? */ 43998c151d6SAlfred Perlstein if (pp->ki_udata == NOPROC) 44098c151d6SAlfred Perlstein return (NULL); 441dcd6f4bdSAlfred Perlstein /* cached? */ 44298c151d6SAlfred Perlstein if (pp->ki_udata != NULL) 44398c151d6SAlfred Perlstein return (pp->ki_udata); 444dcd6f4bdSAlfred Perlstein /* 445dcd6f4bdSAlfred Perlstein * Not cached, 446dcd6f4bdSAlfred Perlstein * 1) look up based on pid. 447dcd6f4bdSAlfred Perlstein * 2) compare process start. 448dcd6f4bdSAlfred Perlstein * If we fail here, then setup a negative cache entry, otherwise 449dcd6f4bdSAlfred Perlstein * cache it. 450dcd6f4bdSAlfred Perlstein */ 451db6bb7fcSAlfred Perlstein oldpp = bsearch(&pp, previous_pref, previous_proc_count, 4524946a00bSDag-Erling Smørgrav sizeof(*previous_pref), compare_pid); 45398c151d6SAlfred Perlstein if (oldpp == NULL) { 45498c151d6SAlfred Perlstein pp->ki_udata = NOPROC; 455db6bb7fcSAlfred Perlstein return (NULL); 45698c151d6SAlfred Perlstein } 457db6bb7fcSAlfred Perlstein oldp = *oldpp; 45898c151d6SAlfred Perlstein if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) { 45998c151d6SAlfred Perlstein pp->ki_udata = NOPROC; 460db6bb7fcSAlfred Perlstein return (NULL); 46198c151d6SAlfred Perlstein } 46298c151d6SAlfred Perlstein pp->ki_udata = oldp; 463db6bb7fcSAlfred Perlstein return (oldp); 464db6bb7fcSAlfred Perlstein } 465db6bb7fcSAlfred Perlstein 466dcd6f4bdSAlfred Perlstein /* 467dcd6f4bdSAlfred Perlstein * Return the total amount of IO done in blocks in/out and faults. 468dcd6f4bdSAlfred Perlstein * store the values individually in the pointers passed in. 469dcd6f4bdSAlfred Perlstein */ 470db6bb7fcSAlfred Perlstein long 471f6a10feaSDag-Erling Smørgrav get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp) 472db6bb7fcSAlfred Perlstein { 473db6bb7fcSAlfred Perlstein const struct kinfo_proc *oldp; 474db6bb7fcSAlfred Perlstein static struct kinfo_proc dummy; 475db6bb7fcSAlfred Perlstein long ret; 476db6bb7fcSAlfred Perlstein 477db6bb7fcSAlfred Perlstein oldp = get_old_proc(pp); 478db6bb7fcSAlfred Perlstein if (oldp == NULL) { 479db6bb7fcSAlfred Perlstein bzero(&dummy, sizeof(dummy)); 480db6bb7fcSAlfred Perlstein oldp = &dummy; 481db6bb7fcSAlfred Perlstein } 482db6bb7fcSAlfred Perlstein 4837fe9a86aSAlfred Perlstein *inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock; 4847fe9a86aSAlfred Perlstein *oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock; 4857fe9a86aSAlfred Perlstein *flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt; 486db6bb7fcSAlfred Perlstein ret = 487db6bb7fcSAlfred Perlstein (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) + 488db6bb7fcSAlfred Perlstein (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) + 489db6bb7fcSAlfred Perlstein (RU(pp)->ru_majflt - RU(oldp)->ru_majflt); 490db6bb7fcSAlfred Perlstein return (ret); 491db6bb7fcSAlfred Perlstein } 492db6bb7fcSAlfred Perlstein 493dcd6f4bdSAlfred Perlstein /* 494dcd6f4bdSAlfred Perlstein * Return the total number of block in/out and faults by a process. 495dcd6f4bdSAlfred Perlstein */ 4967fe9a86aSAlfred Perlstein long 4977fe9a86aSAlfred Perlstein get_io_total(struct kinfo_proc *pp) 4987fe9a86aSAlfred Perlstein { 4997fe9a86aSAlfred Perlstein long dummy; 5007fe9a86aSAlfred Perlstein 5017fe9a86aSAlfred Perlstein return (get_io_stats(pp, &dummy, &dummy, &dummy)); 5027fe9a86aSAlfred Perlstein } 5037fe9a86aSAlfred Perlstein 504511d9c65SJoerg Wunsch static struct handle handle; 505511d9c65SJoerg Wunsch 506970636e9SAlfred Perlstein caddr_t 507f6a10feaSDag-Erling Smørgrav get_process_info(struct system_info *si, struct process_select *sel, 5084946a00bSDag-Erling Smørgrav int (*compare)(const void *, const void *)) 509511d9c65SJoerg Wunsch { 510970636e9SAlfred Perlstein int i; 511970636e9SAlfred Perlstein int total_procs; 5127fe9a86aSAlfred Perlstein long p_io; 5137fe9a86aSAlfred Perlstein long p_inblock, p_oublock, p_majflt; 514970636e9SAlfred Perlstein int active_procs; 515970636e9SAlfred Perlstein struct kinfo_proc **prefp; 516970636e9SAlfred Perlstein struct kinfo_proc *pp; 517cac4b14cSBrian Feldman struct kinfo_proc *prev_pp = NULL; 518511d9c65SJoerg Wunsch 519511d9c65SJoerg Wunsch /* these are copied out of sel for speed */ 520511d9c65SJoerg Wunsch int show_idle; 521e7cdb972SDag-Erling Smørgrav int show_self; 522511d9c65SJoerg Wunsch int show_system; 523511d9c65SJoerg Wunsch int show_uid; 524511d9c65SJoerg Wunsch int show_command; 525511d9c65SJoerg Wunsch 526db6bb7fcSAlfred Perlstein /* 527db6bb7fcSAlfred Perlstein * Save the previous process info. 528db6bb7fcSAlfred Perlstein */ 529db6bb7fcSAlfred Perlstein if (previous_proc_count_max < nproc) { 530db6bb7fcSAlfred Perlstein free(previous_procs); 5314946a00bSDag-Erling Smørgrav previous_procs = malloc(nproc * sizeof(*previous_procs)); 532db6bb7fcSAlfred Perlstein free(previous_pref); 5334946a00bSDag-Erling Smørgrav previous_pref = malloc(nproc * sizeof(*previous_pref)); 534db6bb7fcSAlfred Perlstein if (previous_procs == NULL || previous_pref == NULL) { 535db6bb7fcSAlfred Perlstein (void) fprintf(stderr, "top: Out of memory.\n"); 536db6bb7fcSAlfred Perlstein quit(23); 537db6bb7fcSAlfred Perlstein } 538db6bb7fcSAlfred Perlstein previous_proc_count_max = nproc; 539db6bb7fcSAlfred Perlstein } 540db6bb7fcSAlfred Perlstein if (nproc) { 541db6bb7fcSAlfred Perlstein for (i = 0; i < nproc; i++) 542db6bb7fcSAlfred Perlstein previous_pref[i] = &previous_procs[i]; 5434946a00bSDag-Erling Smørgrav bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs)); 5444946a00bSDag-Erling Smørgrav qsort(previous_pref, nproc, sizeof(*previous_pref), compare_pid); 545db6bb7fcSAlfred Perlstein } 546db6bb7fcSAlfred Perlstein previous_proc_count = nproc; 547db6bb7fcSAlfred Perlstein 548cac4b14cSBrian Feldman pbase = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc); 549511d9c65SJoerg Wunsch if (nproc > onproc) 5504946a00bSDag-Erling Smørgrav pref = realloc(pref, sizeof(*pref) * (onproc = nproc)); 551511d9c65SJoerg Wunsch if (pref == NULL || pbase == NULL) { 552511d9c65SJoerg Wunsch (void) fprintf(stderr, "top: Out of memory.\n"); 553511d9c65SJoerg Wunsch quit(23); 554511d9c65SJoerg Wunsch } 555511d9c65SJoerg Wunsch /* get a pointer to the states summary array */ 556511d9c65SJoerg Wunsch si->procstates = process_states; 557511d9c65SJoerg Wunsch 558511d9c65SJoerg Wunsch /* set up flags which define what we are going to select */ 559511d9c65SJoerg Wunsch show_idle = sel->idle; 5609b30d697SDag-Erling Smørgrav show_self = sel->self == -1; 561511d9c65SJoerg Wunsch show_system = sel->system; 562511d9c65SJoerg Wunsch show_uid = sel->uid != -1; 563511d9c65SJoerg Wunsch show_command = sel->command != NULL; 564511d9c65SJoerg Wunsch 565511d9c65SJoerg Wunsch /* count up process states and get pointers to interesting procs */ 566511d9c65SJoerg Wunsch total_procs = 0; 567511d9c65SJoerg Wunsch active_procs = 0; 5687fe9a86aSAlfred Perlstein total_inblock = 0; 5697fe9a86aSAlfred Perlstein total_oublock = 0; 5707fe9a86aSAlfred Perlstein total_majflt = 0; 571511d9c65SJoerg Wunsch memset((char *)process_states, 0, sizeof(process_states)); 572511d9c65SJoerg Wunsch prefp = pref; 5734946a00bSDag-Erling Smørgrav for (pp = pbase, i = 0; i < nproc; pp++, i++) { 5747fe9a86aSAlfred Perlstein 575d62a717dSDag-Erling Smørgrav if (pp->ki_stat == 0) 576d62a717dSDag-Erling Smørgrav /* not in use */ 577d62a717dSDag-Erling Smørgrav continue; 578d62a717dSDag-Erling Smørgrav 579d62a717dSDag-Erling Smørgrav if (!show_self && pp->ki_pid == sel->self) 580d62a717dSDag-Erling Smørgrav /* skip self */ 581d62a717dSDag-Erling Smørgrav continue; 582d62a717dSDag-Erling Smørgrav 583d62a717dSDag-Erling Smørgrav if (!show_system && (pp->ki_flag & P_SYSTEM)) 584d62a717dSDag-Erling Smørgrav /* skip system process */ 585d62a717dSDag-Erling Smørgrav continue; 586d62a717dSDag-Erling Smørgrav 5877fe9a86aSAlfred Perlstein p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt); 5887fe9a86aSAlfred Perlstein total_inblock += p_inblock; 5897fe9a86aSAlfred Perlstein total_oublock += p_oublock; 5907fe9a86aSAlfred Perlstein total_majflt += p_majflt; 591511d9c65SJoerg Wunsch total_procs++; 5924946a00bSDag-Erling Smørgrav process_states[pp->ki_stat]++; 593d62a717dSDag-Erling Smørgrav 594d62a717dSDag-Erling Smørgrav if (pp->ki_stat == SZOMB) 595d62a717dSDag-Erling Smørgrav /* skip zombies */ 596d62a717dSDag-Erling Smørgrav continue; 597d62a717dSDag-Erling Smørgrav 598d62a717dSDag-Erling Smørgrav if (displaymode == DISP_CPU && !show_idle && 599d62a717dSDag-Erling Smørgrav (pp->ki_pctcpu == 0 || pp->ki_stat != SRUN)) 600d62a717dSDag-Erling Smørgrav /* skip idle or non-running processes */ 601d62a717dSDag-Erling Smørgrav continue; 602d62a717dSDag-Erling Smørgrav 603d62a717dSDag-Erling Smørgrav if (displaymode == DISP_IO && !show_idle && p_io == 0) 604d62a717dSDag-Erling Smørgrav /* skip processes that aren't doing I/O */ 605d62a717dSDag-Erling Smørgrav continue; 606d62a717dSDag-Erling Smørgrav 607d62a717dSDag-Erling Smørgrav if (show_uid && pp->ki_ruid != (uid_t)sel->uid) 608d62a717dSDag-Erling Smørgrav /* skip processes which don't belong to the selected UID */ 609d62a717dSDag-Erling Smørgrav continue; 610d62a717dSDag-Erling Smørgrav 611cac4b14cSBrian Feldman /* 612cac4b14cSBrian Feldman * When not showing threads, take the first thread 613cac4b14cSBrian Feldman * for output and add the fields that we can from 614cac4b14cSBrian Feldman * the rest of the process's threads rather than 615cac4b14cSBrian Feldman * using the system's mostly-broken KERN_PROC_PROC. 616cac4b14cSBrian Feldman */ 6174946a00bSDag-Erling Smørgrav if (sel->thread || prev_pp == NULL || 6184946a00bSDag-Erling Smørgrav prev_pp->ki_pid != pp->ki_pid) { 619511d9c65SJoerg Wunsch *prefp++ = pp; 620511d9c65SJoerg Wunsch active_procs++; 621cac4b14cSBrian Feldman prev_pp = pp; 622cac4b14cSBrian Feldman } else { 623cac4b14cSBrian Feldman prev_pp->ki_pctcpu += pp->ki_pctcpu; 624cac4b14cSBrian Feldman } 625511d9c65SJoerg Wunsch } 626511d9c65SJoerg Wunsch 627511d9c65SJoerg Wunsch /* if requested, sort the "interesting" processes */ 628511d9c65SJoerg Wunsch if (compare != NULL) 6294946a00bSDag-Erling Smørgrav qsort(pref, active_procs, sizeof(*pref), compare); 630511d9c65SJoerg Wunsch 631511d9c65SJoerg Wunsch /* remember active and total counts */ 632511d9c65SJoerg Wunsch si->p_total = total_procs; 633511d9c65SJoerg Wunsch si->p_active = pref_len = active_procs; 634511d9c65SJoerg Wunsch 635511d9c65SJoerg Wunsch /* pass back a handle */ 636511d9c65SJoerg Wunsch handle.next_proc = pref; 637511d9c65SJoerg Wunsch handle.remaining = active_procs; 638511d9c65SJoerg Wunsch return ((caddr_t)&handle); 639511d9c65SJoerg Wunsch } 640511d9c65SJoerg Wunsch 6414946a00bSDag-Erling Smørgrav static char fmt[128]; /* static area where result is built */ 642511d9c65SJoerg Wunsch 643970636e9SAlfred Perlstein char * 6444946a00bSDag-Erling Smørgrav format_next_process(caddr_t handle, char *(*get_userid)(int)) 645511d9c65SJoerg Wunsch { 646970636e9SAlfred Perlstein struct kinfo_proc *pp; 647db6bb7fcSAlfred Perlstein const struct kinfo_proc *oldp; 648970636e9SAlfred Perlstein long cputime; 649970636e9SAlfred Perlstein double pct; 650511d9c65SJoerg Wunsch struct handle *hp; 651511d9c65SJoerg Wunsch char status[16]; 6521005b436SBill Fenner int state; 653db6bb7fcSAlfred Perlstein struct rusage ru, *rup; 6547fe9a86aSAlfred Perlstein long p_tot, s_tot; 655511d9c65SJoerg Wunsch 656511d9c65SJoerg Wunsch /* find and remember the next proc structure */ 657511d9c65SJoerg Wunsch hp = (struct handle *)handle; 658511d9c65SJoerg Wunsch pp = *(hp->next_proc++); 659511d9c65SJoerg Wunsch hp->remaining--; 660511d9c65SJoerg Wunsch 661a8224b82SBruce Evans /* get the process's command name */ 6620821b7caSJohn Baldwin if ((pp->ki_sflag & PS_INMEM) == 0) { 663511d9c65SJoerg Wunsch /* 664511d9c65SJoerg Wunsch * Print swapped processes as <pname> 665511d9c65SJoerg Wunsch */ 6664946a00bSDag-Erling Smørgrav size_t len = strlen(pp->ki_comm); 6674946a00bSDag-Erling Smørgrav if (len > sizeof(pp->ki_comm) - 3) 6684946a00bSDag-Erling Smørgrav len = sizeof(pp->ki_comm) - 3; 6694946a00bSDag-Erling Smørgrav memmove(pp->ki_comm + 1, pp->ki_comm, len); 6704946a00bSDag-Erling Smørgrav pp->ki_comm[0] = '<'; 6714946a00bSDag-Erling Smørgrav pp->ki_comm[len + 1] = '>'; 6724946a00bSDag-Erling Smørgrav pp->ki_comm[len + 2] = '\0'; 673511d9c65SJoerg Wunsch } 674511d9c65SJoerg Wunsch 675a8224b82SBruce Evans /* 676a8224b82SBruce Evans * Convert the process's runtime from microseconds to seconds. This 677a8224b82SBruce Evans * time includes the interrupt time although that is not wanted here. 678a8224b82SBruce Evans * ps(1) is similarly sloppy. 679a8224b82SBruce Evans */ 6801f7d2501SKirk McKusick cputime = (pp->ki_runtime + 500000) / 1000000; 681511d9c65SJoerg Wunsch 682511d9c65SJoerg Wunsch /* calculate the base for cpu percentages */ 6831f7d2501SKirk McKusick pct = pctdouble(pp->ki_pctcpu); 684511d9c65SJoerg Wunsch 685511d9c65SJoerg Wunsch /* generate "STATE" field */ 6861f7d2501SKirk McKusick switch (state = pp->ki_stat) { 687511d9c65SJoerg Wunsch case SRUN: 6881f7d2501SKirk McKusick if (smpmode && pp->ki_oncpu != 0xff) 6891f7d2501SKirk McKusick sprintf(status, "CPU%d", pp->ki_oncpu); 690511d9c65SJoerg Wunsch else 691511d9c65SJoerg Wunsch strcpy(status, "RUN"); 692511d9c65SJoerg Wunsch break; 6930d632649SJohn Baldwin case SLOCK: 6940d632649SJohn Baldwin if (pp->ki_kiflag & KI_LOCKBLOCK) { 6950d632649SJohn Baldwin sprintf(status, "*%.6s", pp->ki_lockname); 696089f9b7eSJohn Baldwin break; 697089f9b7eSJohn Baldwin } 698089f9b7eSJohn Baldwin /* fall through */ 699511d9c65SJoerg Wunsch case SSLEEP: 7001f7d2501SKirk McKusick if (pp->ki_wmesg != NULL) { 7011f7d2501SKirk McKusick sprintf(status, "%.6s", pp->ki_wmesg); 702511d9c65SJoerg Wunsch break; 703511d9c65SJoerg Wunsch } 70493b0017fSPhilippe Charnier /* FALLTHROUGH */ 705511d9c65SJoerg Wunsch default: 7061005b436SBill Fenner 7071005b436SBill Fenner if (state >= 0 && 7081005b436SBill Fenner state < sizeof(state_abbrev) / sizeof(*state_abbrev)) 7094946a00bSDag-Erling Smørgrav sprintf(status, "%.6s", state_abbrev[state]); 7101005b436SBill Fenner else 7111005b436SBill Fenner sprintf(status, "?%5d", state); 712511d9c65SJoerg Wunsch break; 713511d9c65SJoerg Wunsch } 714511d9c65SJoerg Wunsch 715db6bb7fcSAlfred Perlstein if (displaymode == DISP_IO) { 716db6bb7fcSAlfred Perlstein oldp = get_old_proc(pp); 717db6bb7fcSAlfred Perlstein if (oldp != NULL) { 718db6bb7fcSAlfred Perlstein ru.ru_inblock = RU(pp)->ru_inblock - RU(oldp)->ru_inblock; 719db6bb7fcSAlfred Perlstein ru.ru_oublock = RU(pp)->ru_oublock - RU(oldp)->ru_oublock; 720db6bb7fcSAlfred Perlstein ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt; 721db6bb7fcSAlfred Perlstein rup = &ru; 722db6bb7fcSAlfred Perlstein } else { 723db6bb7fcSAlfred Perlstein rup = RU(pp); 724db6bb7fcSAlfred Perlstein } 7257fe9a86aSAlfred Perlstein p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt; 7267fe9a86aSAlfred Perlstein s_tot = total_inblock + total_oublock + total_majflt; 727db6bb7fcSAlfred Perlstein 728db6bb7fcSAlfred Perlstein sprintf(fmt, io_Proc_format, 729db6bb7fcSAlfred Perlstein pp->ki_pid, 730db6bb7fcSAlfred Perlstein namelength, namelength, 731db6bb7fcSAlfred Perlstein (*get_userid)(pp->ki_ruid), 7324946a00bSDag-Erling Smørgrav rup->ru_inblock, 7334946a00bSDag-Erling Smørgrav rup->ru_oublock, 7344946a00bSDag-Erling Smørgrav rup->ru_majflt, 7354946a00bSDag-Erling Smørgrav p_tot, 7364946a00bSDag-Erling Smørgrav s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot), 737db6bb7fcSAlfred Perlstein screen_width > cmdlengthdelta ? 738db6bb7fcSAlfred Perlstein screen_width - cmdlengthdelta : 0, 739db6bb7fcSAlfred Perlstein printable(pp->ki_comm)); 740db6bb7fcSAlfred Perlstein return (fmt); 741db6bb7fcSAlfred Perlstein } 742511d9c65SJoerg Wunsch /* format this entry */ 743511d9c65SJoerg Wunsch sprintf(fmt, 74494154ff8SPeter Wemm smpmode ? smp_Proc_format : up_Proc_format, 7451f7d2501SKirk McKusick pp->ki_pid, 746a2aff8b2SPeter Wemm namelength, namelength, 7471f7d2501SKirk McKusick (*get_userid)(pp->ki_ruid), 7484c85452bSJake Burkholder pp->ki_pri.pri_level - PZERO, 749e5aff02fSPeter Wemm 750e5aff02fSPeter Wemm /* 751e5aff02fSPeter Wemm * normal time -> nice value -20 - +20 752e5aff02fSPeter Wemm * real time 0 - 31 -> nice value -52 - -21 753e5aff02fSPeter Wemm * idle time 0 - 31 -> nice value +21 - +52 754e5aff02fSPeter Wemm */ 7554c85452bSJake Burkholder (pp->ki_pri.pri_class == PRI_TIMESHARE ? 7561f7d2501SKirk McKusick pp->ki_nice - NZERO : 7574c85452bSJake Burkholder (PRI_IS_REALTIME(pp->ki_pri.pri_class) ? 7584c85452bSJake Burkholder (PRIO_MIN - 1 - (PRI_MAX_REALTIME - pp->ki_pri.pri_level)) : 7594c85452bSJake Burkholder (PRIO_MAX + 1 + pp->ki_pri.pri_level - PRI_MIN_IDLE))), 7608fbaa58aSDmitrij Tejblum format_k2(PROCSIZE(pp)), 7611f7d2501SKirk McKusick format_k2(pagetok(pp->ki_rssize)), 762511d9c65SJoerg Wunsch status, 7631f7d2501SKirk McKusick smpmode ? pp->ki_lastcpu : 0, 764511d9c65SJoerg Wunsch format_time(cputime), 765d24b5183SDoug Rabson 100.0 * weighted_cpu(pct, pp), 766d24b5183SDoug Rabson 100.0 * pct, 7677f18d5d3SJohn Baldwin screen_width > cmdlengthdelta ? 7687f18d5d3SJohn Baldwin screen_width - cmdlengthdelta : 7697f18d5d3SJohn Baldwin 0, 7701f7d2501SKirk McKusick printable(pp->ki_comm)); 771511d9c65SJoerg Wunsch 772511d9c65SJoerg Wunsch /* return the result */ 773511d9c65SJoerg Wunsch return (fmt); 774511d9c65SJoerg Wunsch } 775511d9c65SJoerg Wunsch 776970636e9SAlfred Perlstein static void 777f6a10feaSDag-Erling Smørgrav getsysctl(char *name, void *ptr, size_t len) 778511d9c65SJoerg Wunsch { 77998e53e5bSAndrew Gallatin size_t nlen = len; 780970636e9SAlfred Perlstein 78139d513ecSRobert Watson if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) { 78239d513ecSRobert Watson fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name, 78339d513ecSRobert Watson strerror(errno)); 784511d9c65SJoerg Wunsch quit(23); 785511d9c65SJoerg Wunsch } 78639d513ecSRobert Watson if (nlen != len) { 787e0038fe5SThomas Moestl fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n", name, 788e0038fe5SThomas Moestl (unsigned long)len, (unsigned long)nlen); 78939d513ecSRobert Watson quit(23); 790511d9c65SJoerg Wunsch } 791511d9c65SJoerg Wunsch } 792511d9c65SJoerg Wunsch 793f3b2c2d1SWolfram Schneider /* comparison routines for qsort */ 794511d9c65SJoerg Wunsch 795db6bb7fcSAlfred Perlstein int 796f6a10feaSDag-Erling Smørgrav compare_pid(const void *p1, const void *p2) 797db6bb7fcSAlfred Perlstein { 798db6bb7fcSAlfred Perlstein const struct kinfo_proc * const *pp1 = p1; 799db6bb7fcSAlfred Perlstein const struct kinfo_proc * const *pp2 = p2; 800db6bb7fcSAlfred Perlstein 801db6bb7fcSAlfred Perlstein if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0) 802db6bb7fcSAlfred Perlstein abort(); 803db6bb7fcSAlfred Perlstein 804db6bb7fcSAlfred Perlstein return ((*pp1)->ki_pid - (*pp2)->ki_pid); 805db6bb7fcSAlfred Perlstein } 806db6bb7fcSAlfred Perlstein 807511d9c65SJoerg Wunsch /* 808511d9c65SJoerg Wunsch * proc_compare - comparison function for "qsort" 809511d9c65SJoerg Wunsch * Compares the resource consumption of two processes using five 810511d9c65SJoerg Wunsch * distinct keys. The keys (in descending order of importance) are: 811511d9c65SJoerg Wunsch * percent cpu, cpu ticks, state, resident set size, total virtual 812511d9c65SJoerg Wunsch * memory usage. The process states are ordered as follows (from least 813511d9c65SJoerg Wunsch * to most important): WAIT, zombie, sleep, stop, start, run. The 814511d9c65SJoerg Wunsch * array declaration below maps a process state index into a number 815511d9c65SJoerg Wunsch * that reflects this ordering. 816511d9c65SJoerg Wunsch */ 817511d9c65SJoerg Wunsch 8184946a00bSDag-Erling Smørgrav static int sorted_state[] = 819511d9c65SJoerg Wunsch { 820511d9c65SJoerg Wunsch 0, /* not used */ 821511d9c65SJoerg Wunsch 3, /* sleep */ 822511d9c65SJoerg Wunsch 1, /* ABANDONED (WAIT) */ 823511d9c65SJoerg Wunsch 6, /* run */ 824511d9c65SJoerg Wunsch 5, /* start */ 825511d9c65SJoerg Wunsch 2, /* zombie */ 826511d9c65SJoerg Wunsch 4 /* stop */ 827511d9c65SJoerg Wunsch }; 828511d9c65SJoerg Wunsch 829f3b2c2d1SWolfram Schneider 8304946a00bSDag-Erling Smørgrav #define ORDERKEY_PCTCPU(a, b) do { \ 831f92a1155SDag-Erling Smørgrav long diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \ 8324946a00bSDag-Erling Smørgrav if (diff != 0) \ 8334946a00bSDag-Erling Smørgrav return (diff > 0 ? 1 : -1); \ 8344946a00bSDag-Erling Smørgrav } while (0) 835f3b2c2d1SWolfram Schneider 8364946a00bSDag-Erling Smørgrav #define ORDERKEY_CPTICKS(a, b) do { \ 837e38035a5SDag-Erling Smørgrav int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \ 8384946a00bSDag-Erling Smørgrav if (diff != 0) \ 8394946a00bSDag-Erling Smørgrav return (diff > 0 ? 1 : -1); \ 8404946a00bSDag-Erling Smørgrav } while (0) 841f3b2c2d1SWolfram Schneider 8424946a00bSDag-Erling Smørgrav #define ORDERKEY_STATE(a, b) do { \ 8434946a00bSDag-Erling Smørgrav int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \ 8444946a00bSDag-Erling Smørgrav if (diff != 0) \ 8454946a00bSDag-Erling Smørgrav return (diff > 0 ? 1 : -1); \ 8464946a00bSDag-Erling Smørgrav } while (0) 847f3b2c2d1SWolfram Schneider 8484946a00bSDag-Erling Smørgrav #define ORDERKEY_PRIO(a, b) do { \ 849e38035a5SDag-Erling Smørgrav int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \ 8504946a00bSDag-Erling Smørgrav if (diff != 0) \ 8514946a00bSDag-Erling Smørgrav return (diff > 0 ? 1 : -1); \ 8524946a00bSDag-Erling Smørgrav } while (0) 853f3b2c2d1SWolfram Schneider 8544946a00bSDag-Erling Smørgrav #define ORDERKEY_RSSIZE(a, b) do { \ 855e38035a5SDag-Erling Smørgrav long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \ 8564946a00bSDag-Erling Smørgrav if (diff != 0) \ 8574946a00bSDag-Erling Smørgrav return (diff > 0 ? 1 : -1); \ 8584946a00bSDag-Erling Smørgrav } while (0) 859f3b2c2d1SWolfram Schneider 8604946a00bSDag-Erling Smørgrav #define ORDERKEY_MEM(a, b) do { \ 861e38035a5SDag-Erling Smørgrav long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \ 8624946a00bSDag-Erling Smørgrav if (diff != 0) \ 8634946a00bSDag-Erling Smørgrav return (diff > 0 ? 1 : -1); \ 8644946a00bSDag-Erling Smørgrav } while (0) 865f3b2c2d1SWolfram Schneider 866f3b2c2d1SWolfram Schneider /* compare_cpu - the comparison function for sorting by cpu percentage */ 867f3b2c2d1SWolfram Schneider 868511d9c65SJoerg Wunsch int 869f3b2c2d1SWolfram Schneider #ifdef ORDER 8704946a00bSDag-Erling Smørgrav compare_cpu(void *arg1, void *arg2) 871f3b2c2d1SWolfram Schneider #else 8724946a00bSDag-Erling Smørgrav proc_compare(void *arg1, void *arg2) 873f3b2c2d1SWolfram Schneider #endif 874511d9c65SJoerg Wunsch { 8754946a00bSDag-Erling Smørgrav struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 8764946a00bSDag-Erling Smørgrav struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 877511d9c65SJoerg Wunsch 8784946a00bSDag-Erling Smørgrav ORDERKEY_PCTCPU(p1, p2); 8794946a00bSDag-Erling Smørgrav ORDERKEY_CPTICKS(p1, p2); 8804946a00bSDag-Erling Smørgrav ORDERKEY_STATE(p1, p2); 8814946a00bSDag-Erling Smørgrav ORDERKEY_PRIO(p1, p2); 8824946a00bSDag-Erling Smørgrav ORDERKEY_RSSIZE(p1, p2); 8834946a00bSDag-Erling Smørgrav ORDERKEY_MEM(p1, p2); 884511d9c65SJoerg Wunsch 8854946a00bSDag-Erling Smørgrav return (0); 886511d9c65SJoerg Wunsch } 887511d9c65SJoerg Wunsch 888f3b2c2d1SWolfram Schneider #ifdef ORDER 889f3b2c2d1SWolfram Schneider /* compare routines */ 890f3b2c2d1SWolfram Schneider int compare_size(), compare_res(), compare_time(), compare_prio(); 891f3b2c2d1SWolfram Schneider 892f3b2c2d1SWolfram Schneider int (*proc_compares[])() = { 893f3b2c2d1SWolfram Schneider compare_cpu, 894f3b2c2d1SWolfram Schneider compare_size, 895f3b2c2d1SWolfram Schneider compare_res, 896f3b2c2d1SWolfram Schneider compare_time, 897f3b2c2d1SWolfram Schneider compare_prio, 898f3b2c2d1SWolfram Schneider NULL 899f3b2c2d1SWolfram Schneider }; 900f3b2c2d1SWolfram Schneider 901f3b2c2d1SWolfram Schneider /* compare_size - the comparison function for sorting by total memory usage */ 902f3b2c2d1SWolfram Schneider 903f3b2c2d1SWolfram Schneider int 9044946a00bSDag-Erling Smørgrav compare_size(void *arg1, void *arg2) 905f3b2c2d1SWolfram Schneider { 9064946a00bSDag-Erling Smørgrav struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 9074946a00bSDag-Erling Smørgrav struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 908f3b2c2d1SWolfram Schneider 9094946a00bSDag-Erling Smørgrav ORDERKEY_MEM(p1, p2); 9104946a00bSDag-Erling Smørgrav ORDERKEY_RSSIZE(p1, p2); 9114946a00bSDag-Erling Smørgrav ORDERKEY_PCTCPU(p1, p2); 9124946a00bSDag-Erling Smørgrav ORDERKEY_CPTICKS(p1, p2); 9134946a00bSDag-Erling Smørgrav ORDERKEY_STATE(p1, p2); 9144946a00bSDag-Erling Smørgrav ORDERKEY_PRIO(p1, p2); 915f3b2c2d1SWolfram Schneider 9164946a00bSDag-Erling Smørgrav return (0); 917f3b2c2d1SWolfram Schneider } 918f3b2c2d1SWolfram Schneider 919f3b2c2d1SWolfram Schneider /* compare_res - the comparison function for sorting by resident set size */ 920f3b2c2d1SWolfram Schneider 921f3b2c2d1SWolfram Schneider int 9224946a00bSDag-Erling Smørgrav compare_res(void *arg1, void *arg2) 923f3b2c2d1SWolfram Schneider { 9244946a00bSDag-Erling Smørgrav struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 9254946a00bSDag-Erling Smørgrav struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 926f3b2c2d1SWolfram Schneider 9274946a00bSDag-Erling Smørgrav ORDERKEY_RSSIZE(p1, p2); 9284946a00bSDag-Erling Smørgrav ORDERKEY_MEM(p1, p2); 9294946a00bSDag-Erling Smørgrav ORDERKEY_PCTCPU(p1, p2); 9304946a00bSDag-Erling Smørgrav ORDERKEY_CPTICKS(p1, p2); 9314946a00bSDag-Erling Smørgrav ORDERKEY_STATE(p1, p2); 9324946a00bSDag-Erling Smørgrav ORDERKEY_PRIO(p1, p2); 933f3b2c2d1SWolfram Schneider 9344946a00bSDag-Erling Smørgrav return (0); 935f3b2c2d1SWolfram Schneider } 936f3b2c2d1SWolfram Schneider 937f3b2c2d1SWolfram Schneider /* compare_time - the comparison function for sorting by total cpu time */ 938f3b2c2d1SWolfram Schneider 939f3b2c2d1SWolfram Schneider int 9404946a00bSDag-Erling Smørgrav compare_time(void *arg1, void *arg2) 941f3b2c2d1SWolfram Schneider { 9424946a00bSDag-Erling Smørgrav struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 9434946a00bSDag-Erling Smørgrav struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 944f3b2c2d1SWolfram Schneider 9454946a00bSDag-Erling Smørgrav ORDERKEY_CPTICKS(p1, p2); 9464946a00bSDag-Erling Smørgrav ORDERKEY_PCTCPU(p1, p2); 9474946a00bSDag-Erling Smørgrav ORDERKEY_STATE(p1, p2); 9484946a00bSDag-Erling Smørgrav ORDERKEY_PRIO(p1, p2); 9494946a00bSDag-Erling Smørgrav ORDERKEY_RSSIZE(p1, p2); 9504946a00bSDag-Erling Smørgrav ORDERKEY_MEM(p1, p2); 951f3b2c2d1SWolfram Schneider 9524946a00bSDag-Erling Smørgrav return (0); 953f3b2c2d1SWolfram Schneider } 954f3b2c2d1SWolfram Schneider 9554946a00bSDag-Erling Smørgrav /* compare_prio - the comparison function for sorting by priority */ 956f3b2c2d1SWolfram Schneider 957f3b2c2d1SWolfram Schneider int 9584946a00bSDag-Erling Smørgrav compare_prio(void *arg1, void *arg2) 959f3b2c2d1SWolfram Schneider { 9604946a00bSDag-Erling Smørgrav struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 9614946a00bSDag-Erling Smørgrav struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 962f3b2c2d1SWolfram Schneider 9634946a00bSDag-Erling Smørgrav ORDERKEY_PRIO(p1, p2); 9644946a00bSDag-Erling Smørgrav ORDERKEY_CPTICKS(p1, p2); 9654946a00bSDag-Erling Smørgrav ORDERKEY_PCTCPU(p1, p2); 9664946a00bSDag-Erling Smørgrav ORDERKEY_STATE(p1, p2); 9674946a00bSDag-Erling Smørgrav ORDERKEY_RSSIZE(p1, p2); 9684946a00bSDag-Erling Smørgrav ORDERKEY_MEM(p1, p2); 969f3b2c2d1SWolfram Schneider 9704946a00bSDag-Erling Smørgrav return (0); 971f3b2c2d1SWolfram Schneider } 972f3b2c2d1SWolfram Schneider #endif 973511d9c65SJoerg Wunsch 97426b2243aSGiorgos Keramidas /* compare_io - the comparison function for sorting by total io */ 97526b2243aSGiorgos Keramidas 976db6bb7fcSAlfred Perlstein int 97726b2243aSGiorgos Keramidas #ifdef ORDER 97826b2243aSGiorgos Keramidas compare_iototal(void *arg1, void *arg2) 97926b2243aSGiorgos Keramidas #else 9804946a00bSDag-Erling Smørgrav io_compare(void *arg1, void *arg2) 98126b2243aSGiorgos Keramidas #endif 982db6bb7fcSAlfred Perlstein { 9834946a00bSDag-Erling Smørgrav struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 9844946a00bSDag-Erling Smørgrav struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 985db6bb7fcSAlfred Perlstein 9864946a00bSDag-Erling Smørgrav return (get_io_total(p2) - get_io_total(p1)); 987db6bb7fcSAlfred Perlstein } 98826b2243aSGiorgos Keramidas 98926b2243aSGiorgos Keramidas #ifdef ORDER 99026b2243aSGiorgos Keramidas /* io compare routines */ 99126b2243aSGiorgos Keramidas int compare_ioread(), compare_iowrite(), compare_iofault(); 99226b2243aSGiorgos Keramidas 99326b2243aSGiorgos Keramidas int (*io_compares[])() = { 99426b2243aSGiorgos Keramidas compare_iototal, 99526b2243aSGiorgos Keramidas compare_ioread, 99626b2243aSGiorgos Keramidas compare_iowrite, 99726b2243aSGiorgos Keramidas compare_iofault, 99826b2243aSGiorgos Keramidas NULL 99926b2243aSGiorgos Keramidas }; 100026b2243aSGiorgos Keramidas 100126b2243aSGiorgos Keramidas int 100226b2243aSGiorgos Keramidas compare_ioread(void *arg1, void *arg2) 100326b2243aSGiorgos Keramidas { 100426b2243aSGiorgos Keramidas struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 100526b2243aSGiorgos Keramidas struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 100626b2243aSGiorgos Keramidas long dummy, inp1, inp2; 100726b2243aSGiorgos Keramidas 100826b2243aSGiorgos Keramidas (void) get_io_stats(p1, &inp1, &dummy, &dummy); 100926b2243aSGiorgos Keramidas (void) get_io_stats(p2, &inp2, &dummy, &dummy); 101026b2243aSGiorgos Keramidas 101126b2243aSGiorgos Keramidas return (inp2 - inp1); 101226b2243aSGiorgos Keramidas } 101326b2243aSGiorgos Keramidas 101426b2243aSGiorgos Keramidas int 101526b2243aSGiorgos Keramidas compare_iowrite(void *arg1, void *arg2) 101626b2243aSGiorgos Keramidas { 101726b2243aSGiorgos Keramidas struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 101826b2243aSGiorgos Keramidas struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 101926b2243aSGiorgos Keramidas long dummy, oup1, oup2; 102026b2243aSGiorgos Keramidas 102126b2243aSGiorgos Keramidas (void) get_io_stats(p1, &dummy, &oup1, &dummy); 102226b2243aSGiorgos Keramidas (void) get_io_stats(p2, &dummy, &oup2, &dummy); 102326b2243aSGiorgos Keramidas 102426b2243aSGiorgos Keramidas return (oup2 - oup1); 102526b2243aSGiorgos Keramidas } 102626b2243aSGiorgos Keramidas 102726b2243aSGiorgos Keramidas int 102826b2243aSGiorgos Keramidas compare_iofault(void *arg1, void *arg2) 102926b2243aSGiorgos Keramidas { 103026b2243aSGiorgos Keramidas struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1; 103126b2243aSGiorgos Keramidas struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2; 103226b2243aSGiorgos Keramidas long dummy, flp1, flp2; 103326b2243aSGiorgos Keramidas 103426b2243aSGiorgos Keramidas (void) get_io_stats(p1, &dummy, &dummy, &flp1); 103526b2243aSGiorgos Keramidas (void) get_io_stats(p2, &dummy, &dummy, &flp2); 103626b2243aSGiorgos Keramidas 103726b2243aSGiorgos Keramidas return (flp2 - flp1); 103826b2243aSGiorgos Keramidas } 103926b2243aSGiorgos Keramidas 104026b2243aSGiorgos Keramidas #endif /* ORDER */ 104126b2243aSGiorgos Keramidas 1042511d9c65SJoerg Wunsch /* 1043511d9c65SJoerg Wunsch * proc_owner(pid) - returns the uid that owns process "pid", or -1 if 1044511d9c65SJoerg Wunsch * the process does not exist. 1045511d9c65SJoerg Wunsch * It is EXTREMLY IMPORTANT that this function work correctly. 1046511d9c65SJoerg Wunsch * If top runs setuid root (as in SVR4), then this function 1047511d9c65SJoerg Wunsch * is the only thing that stands in the way of a serious 1048511d9c65SJoerg Wunsch * security problem. It validates requests for the "kill" 1049511d9c65SJoerg Wunsch * and "renice" commands. 1050511d9c65SJoerg Wunsch */ 1051511d9c65SJoerg Wunsch 1052970636e9SAlfred Perlstein int 1053f6a10feaSDag-Erling Smørgrav proc_owner(int pid) 1054511d9c65SJoerg Wunsch { 1055970636e9SAlfred Perlstein int cnt; 1056970636e9SAlfred Perlstein struct kinfo_proc **prefp; 1057970636e9SAlfred Perlstein struct kinfo_proc *pp; 1058511d9c65SJoerg Wunsch 1059511d9c65SJoerg Wunsch prefp = pref; 1060511d9c65SJoerg Wunsch cnt = pref_len; 10614946a00bSDag-Erling Smørgrav while (--cnt >= 0) { 1062511d9c65SJoerg Wunsch pp = *prefp++; 10631f7d2501SKirk McKusick if (pp->ki_pid == (pid_t)pid) 10641f7d2501SKirk McKusick return ((int)pp->ki_ruid); 1065511d9c65SJoerg Wunsch } 1066511d9c65SJoerg Wunsch return (-1); 1067511d9c65SJoerg Wunsch } 1068511d9c65SJoerg Wunsch 1069511d9c65SJoerg Wunsch int 1070f6a10feaSDag-Erling Smørgrav swapmode(int *retavail, int *retfree) 1071511d9c65SJoerg Wunsch { 10727bb42db9SMatthew Dillon int n; 10737bb42db9SMatthew Dillon int pagesize = getpagesize(); 10747bb42db9SMatthew Dillon struct kvm_swap swapary[1]; 1075511d9c65SJoerg Wunsch 10767bb42db9SMatthew Dillon *retavail = 0; 10777bb42db9SMatthew Dillon *retfree = 0; 1078511d9c65SJoerg Wunsch 10797bb42db9SMatthew Dillon #define CONVERT(v) ((quad_t)(v) * pagesize / 1024) 10807bb42db9SMatthew Dillon 10817bb42db9SMatthew Dillon n = kvm_getswapinfo(kd, swapary, 1, 0); 108247b370f5SMatthew Dillon if (n < 0 || swapary[0].ksw_total == 0) 1083511d9c65SJoerg Wunsch return (0); 1084511d9c65SJoerg Wunsch 10857bb42db9SMatthew Dillon *retavail = CONVERT(swapary[0].ksw_total); 10867bb42db9SMatthew Dillon *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used); 10877bb42db9SMatthew Dillon 10884946a00bSDag-Erling Smørgrav n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total); 10897bb42db9SMatthew Dillon return (n); 1090511d9c65SJoerg Wunsch } 1091