2 * top - a top users display for Unix
4 * SYNOPSIS: For FreeBSD-2.x and later
7 * Originally written for BSD4.4 system by Christos Zoulas.
8 * Ported to FreeBSD 2.x by Steven Wallace && Wolfram Schneider
9 * Order support hacked in from top-3.5beta6/machine/m_aix41.c
10 * by Monte Mitzelfelt (for latest top see http://www.groupsys.com/topinfo/)
12 * This is the machine-dependent module for FreeBSD 2.2
14 * FreeBSD 2.2.x, 3.x, 4.x, and probably FreeBSD 2.1.x
18 * AUTHOR: Christos Zoulas <christos@ee.cornell.edu>
19 * Steven Wallace <swallace@freebsd.org>
20 * Wolfram Schneider <wosch@FreeBSD.org>
21 * Thomas Moestl <tmoestl@gmx.net>
26 #include <sys/param.h>
27 #include <sys/errno.h>
30 #include <sys/resource.h>
31 #include <sys/rtprio.h>
32 #include <sys/signal.h>
33 #include <sys/sysctl.h>
36 #include <sys/vmmeter.h>
57 #define GETSYSCTL(name, var) getsysctl(name, &(var), sizeof(var))
58 #define SMPUNAMELEN 13
61 extern struct process_select ps;
62 extern char* printable(char *);
64 enum displaymodes displaymode;
65 #ifdef TOP_USERNAME_LEN
66 static int namelength = TOP_USERNAME_LEN;
68 static int namelength = 8;
70 /* TOP_JID_LEN based on max of 999999 */
72 #define TOP_SWAP_LEN 6
74 static int swaplength;
75 static int cmdlengthdelta;
77 /* Prototypes for top internals */
80 /* get_process_info passes back a handle. This is what it looks like: */
83 struct kinfo_proc **next_proc; /* points to next valid proc pointer */
84 int remaining; /* number of pointers remaining */
87 /* declarations for load_avg */
90 /* define what weighted cpu is. */
91 #define weighted_cpu(pct, pp) ((pp)->ki_swtime == 0 ? 0.0 : \
92 ((pct) / (1.0 - exp((pp)->ki_swtime * logcpu))))
94 /* what we consider to be process size: */
95 #define PROCSIZE(pp) ((pp)->ki_size / 1024)
97 #define RU(pp) (&(pp)->ki_rusage)
99 (RU(pp)->ru_inblock + RU(pp)->ru_oublock + RU(pp)->ru_majflt)
101 #define PCTCPU(pp) (pcpu[pp - pbase])
103 /* definitions for indices in the nlist array */
106 * These definitions control the format of the per-process area
109 static char io_header[] =
110 " PID%*s %-*.*s VCSW IVCSW READ WRITE FAULT TOTAL PERCENT COMMAND";
112 #define io_Proc_format \
113 "%5d%*s %-*.*s %6ld %6ld %6ld %6ld %6ld %6ld %6.2f%% %.*s"
115 static char smp_header_thr[] =
116 " PID%*s %-*.*s THR PRI NICE SIZE RES%*s STATE C TIME %7s COMMAND";
117 static char smp_header[] =
118 " PID%*s %-*.*s " "PRI NICE SIZE RES%*s STATE C TIME %7s COMMAND";
120 #define smp_Proc_format \
121 "%5d%*s %-*.*s %s%3d %4s%7s %6s%*.*s %-6.6s %2d%7s %6.2f%% %.*s"
123 static char up_header_thr[] =
124 " PID%*s %-*.*s THR PRI NICE SIZE RES%*s STATE TIME %7s COMMAND";
125 static char up_header[] =
126 " PID%*s %-*.*s " "PRI NICE SIZE RES%*s STATE TIME %7s COMMAND";
128 #define up_Proc_format \
129 "%5d%*s %-*.*s %s%3d %4s%7s %6s%*.*s %-6.6s%.0d%7s %6.2f%% %.*s"
132 /* process state names for the "STATE" column of the display */
133 /* the extra nulls in the string "run" are for adding a slash and
134 the processor number when needed */
136 char *state_abbrev[] = {
137 "", "START", "RUN\0\0\0", "SLEEP", "STOP", "ZOMB", "WAIT", "LOCK"
143 /* values that we stash away in _init and use in later routines */
145 static double logcpu;
147 /* these are retrieved from the kernel in _init */
149 static load_avg ccpu;
151 /* these are used in the get_ functions */
155 /* these are for calculating cpu state percentages */
157 static long cp_time[CPUSTATES];
158 static long cp_old[CPUSTATES];
159 static long cp_diff[CPUSTATES];
161 /* these are for detailing the process states */
163 int process_states[8];
164 char *procstatenames[] = {
165 "", " starting, ", " running, ", " sleeping, ", " stopped, ",
166 " zombie, ", " waiting, ", " lock, ",
170 /* these are for detailing the cpu states */
172 int cpu_states[CPUSTATES];
173 char *cpustatenames[] = {
174 "user", "nice", "system", "interrupt", "idle", NULL
177 /* these are for detailing the memory statistics */
180 char *memorynames[] = {
181 "K Active, ", "K Inact, ", "K Laundry, ", "K Wired, ", "K Buf, ",
187 "K Total, ", "K MFU, ", "K MRU, ", "K Anon, ", "K Header, ", "K Other",
192 char *carcnames[] = {
193 "K Compressed, ", "K Uncompressed, ", ":1 Ratio, ",
198 char *swapnames[] = {
199 "K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out",
204 /* these are for keeping track of the proc array */
207 static int onproc = -1;
209 static struct kinfo_proc *pbase;
210 static struct kinfo_proc **pref;
211 static struct kinfo_proc *previous_procs;
212 static struct kinfo_proc **previous_pref;
213 static int previous_proc_count = 0;
214 static int previous_proc_count_max = 0;
215 static int previous_thread;
217 /* data used for recalculating pctcpu */
219 static struct timespec proc_uptime;
220 static struct timeval proc_wall_time;
221 static struct timeval previous_wall_time;
222 static uint64_t previous_interval = 0;
224 /* total number of io operations */
225 static long total_inblock;
226 static long total_oublock;
227 static long total_majflt;
229 /* these are for getting the memory statistics */
231 static int arc_enabled;
232 static int carc_enabled;
233 static int pageshift; /* log base 2 of the pagesize */
235 /* define pagetok in terms of pageshift */
237 #define pagetok(size) ((size) << pageshift)
240 #define ki_swap(kip) \
241 ((kip)->ki_swrss > (kip)->ki_rssize ? (kip)->ki_swrss - (kip)->ki_rssize : 0)
243 /* useful externals */
244 long percentages(int cnt, int *out, long *new, long *old, long *diffs);
248 * Sorting orders. The first element is the default.
250 char *ordernames[] = {
251 "cpu", "size", "res", "time", "pri", "threads",
252 "total", "read", "write", "fault", "vcsw", "ivcsw",
253 "jid", "swap", "pid", NULL
257 /* Per-cpu time states */
261 static u_long cpumask;
263 static long *pcpu_cp_time;
264 static long *pcpu_cp_old;
265 static long *pcpu_cp_diff;
266 static int *pcpu_cpu_states;
268 static int compare_swap(const void *a, const void *b);
269 static int compare_jid(const void *a, const void *b);
270 static int compare_pid(const void *a, const void *b);
271 static int compare_tid(const void *a, const void *b);
272 static const char *format_nice(const struct kinfo_proc *pp);
273 static void getsysctl(const char *name, void *ptr, size_t len);
274 static int swapmode(int *retavail, int *retfree);
275 static void update_layout(void);
278 toggle_pcpustats(void)
286 /* Adjust display based on ncpus and the ARC state. */
294 y_swap = 4 + arc_enabled + carc_enabled;
295 y_idlecursor = 5 + arc_enabled + carc_enabled;
296 y_message = 5 + arc_enabled + carc_enabled;
297 y_header = 6 + arc_enabled + carc_enabled;
298 y_procs = 7 + arc_enabled + carc_enabled;
299 Header_lines = 7 + arc_enabled + carc_enabled;
306 y_idlecursor += ncpus - 1;
307 y_message += ncpus - 1;
308 y_header += ncpus - 1;
309 y_procs += ncpus - 1;
310 Header_lines += ncpus - 1;
315 machine_init(struct statics *statics, char do_unames)
317 int i, j, empty, pagesize;
323 size = sizeof(smpmode);
324 if ((sysctlbyname("machdep.smp_active", &smpmode, &size,
326 sysctlbyname("kern.smp.active", &smpmode, &size,
328 size != sizeof(smpmode))
331 size = sizeof(carc_en);
332 if (sysctlbyname("vfs.zfs.compressed_arc_enabled", &carc_en, &size,
333 NULL, 0) == 0 && carc_en == 1)
335 size = sizeof(arc_size);
336 if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
337 NULL, 0) == 0 && arc_size != 0)
341 while ((pw = getpwent()) != NULL) {
342 if (strlen(pw->pw_name) > namelength)
343 namelength = strlen(pw->pw_name);
346 if (smpmode && namelength > SMPUNAMELEN)
347 namelength = SMPUNAMELEN;
348 else if (namelength > UPUNAMELEN)
349 namelength = UPUNAMELEN;
351 kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
355 GETSYSCTL("kern.ccpu", ccpu);
357 /* this is used in calculating WCPU -- calculate it ahead of time */
358 logcpu = log(loaddouble(ccpu));
366 /* get the page size and calculate pageshift from it */
367 pagesize = getpagesize();
369 while (pagesize > 1) {
374 /* we only need the amount of log(2)1024 for our conversion */
375 pageshift -= LOG1024;
377 /* fill in the statics information */
378 statics->procstate_names = procstatenames;
379 statics->cpustate_names = cpustatenames;
380 statics->memory_names = memorynames;
382 statics->arc_names = arcnames;
384 statics->arc_names = NULL;
386 statics->carc_names = carcnames;
388 statics->carc_names = NULL;
389 statics->swap_names = swapnames;
391 statics->order_names = ordernames;
394 /* Allocate state for per-CPU stats. */
397 GETSYSCTL("kern.smp.maxcpus", maxcpu);
398 size = sizeof(long) * maxcpu * CPUSTATES;
399 times = malloc(size);
401 err(1, "malloc %zu bytes", size);
402 if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
403 err(1, "sysctlbyname kern.cp_times");
404 pcpu_cp_time = calloc(1, size);
405 maxid = (size / CPUSTATES / sizeof(long)) - 1;
406 for (i = 0; i <= maxid; i++) {
408 for (j = 0; empty && j < CPUSTATES; j++) {
409 if (times[i * CPUSTATES + j] != 0)
413 cpumask |= (1ul << i);
417 size = sizeof(long) * ncpus * CPUSTATES;
418 pcpu_cp_old = calloc(1, size);
419 pcpu_cp_diff = calloc(1, size);
420 pcpu_cpu_states = calloc(1, size);
421 statics->ncpus = ncpus;
430 format_header(char *uname_field)
432 static char Header[128];
436 jidlength = TOP_JID_LEN + 1; /* +1 for extra left space. */
441 swaplength = TOP_SWAP_LEN + 1; /* +1 for extra left space */
445 switch (displaymode) {
448 * The logic of picking the right header format seems reverse
449 * here because we only want to display a THR column when
450 * "thread mode" is off (and threads are not listed as
454 (ps.thread ? smp_header : smp_header_thr) :
455 (ps.thread ? up_header : up_header_thr);
456 snprintf(Header, sizeof(Header), prehead,
457 jidlength, ps.jail ? " JID" : "",
458 namelength, namelength, uname_field,
459 swaplength, ps.swap ? " SWAP" : "",
460 ps.wcpu ? "WCPU" : "CPU");
464 snprintf(Header, sizeof(Header), prehead,
465 jidlength, ps.jail ? " JID" : "",
466 namelength, namelength, uname_field);
469 cmdlengthdelta = strlen(Header) - 7;
473 static int swappgsin = -1;
474 static int swappgsout = -1;
475 extern struct timeval timeout;
479 get_system_info(struct system_info *si)
482 struct loadavg sysload;
484 struct timeval boottime;
485 uint64_t arc_stat, arc_stat2;
489 /* get the CPU stats */
490 size = (maxid + 1) * CPUSTATES * sizeof(long);
491 if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
492 err(1, "sysctlbyname kern.cp_times");
493 GETSYSCTL("kern.cp_time", cp_time);
494 GETSYSCTL("vm.loadavg", sysload);
495 GETSYSCTL("kern.lastpid", lastpid);
497 /* convert load averages to doubles */
498 for (i = 0; i < 3; i++)
499 si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
501 /* convert cp_time counts to percentages */
502 for (i = j = 0; i <= maxid; i++) {
503 if ((cpumask & (1ul << i)) == 0)
505 percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
506 &pcpu_cp_time[j * CPUSTATES],
507 &pcpu_cp_old[j * CPUSTATES],
508 &pcpu_cp_diff[j * CPUSTATES]);
511 percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
513 /* sum memory & swap statistics */
515 static unsigned int swap_delay = 0;
516 static int swapavail = 0;
517 static int swapfree = 0;
518 static long bufspace = 0;
519 static uint64_t nspgsin, nspgsout;
521 GETSYSCTL("vfs.bufspace", bufspace);
522 GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
523 GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
524 GETSYSCTL("vm.stats.vm.v_laundry_count", memory_stats[2]);
525 GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[3]);
526 GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
527 GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
528 GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
529 /* convert memory stats to Kbytes */
530 memory_stats[0] = pagetok(memory_stats[0]);
531 memory_stats[1] = pagetok(memory_stats[1]);
532 memory_stats[2] = pagetok(memory_stats[2]);
533 memory_stats[3] = pagetok(memory_stats[3]);
534 memory_stats[4] = bufspace / 1024;
535 memory_stats[5] = pagetok(memory_stats[5]);
536 memory_stats[6] = -1;
544 /* compute differences between old and new swap statistic */
546 swap_stats[4] = pagetok(((nspgsin - swappgsin)));
547 swap_stats[5] = pagetok(((nspgsout - swappgsout)));
551 swappgsout = nspgsout;
553 /* call CPU heavy swapmode() only for changes */
554 if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
555 swap_stats[3] = swapmode(&swapavail, &swapfree);
556 swap_stats[0] = swapavail;
557 swap_stats[1] = swapavail - swapfree;
558 swap_stats[2] = swapfree;
565 GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
566 arc_stats[0] = arc_stat >> 10;
567 GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
568 arc_stats[1] = arc_stat >> 10;
569 GETSYSCTL("vfs.zfs.mru_size", arc_stat);
570 arc_stats[2] = arc_stat >> 10;
571 GETSYSCTL("vfs.zfs.anon_size", arc_stat);
572 arc_stats[3] = arc_stat >> 10;
573 GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
574 GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
575 arc_stats[4] = arc_stat + arc_stat2 >> 10;
576 GETSYSCTL("kstat.zfs.misc.arcstats.other_size", arc_stat);
577 arc_stats[5] = arc_stat >> 10;
581 GETSYSCTL("kstat.zfs.misc.arcstats.compressed_size", arc_stat);
582 carc_stats[0] = arc_stat >> 10;
583 carc_stats[2] = arc_stat >> 10; /* For ratio */
584 GETSYSCTL("kstat.zfs.misc.arcstats.uncompressed_size", arc_stat);
585 carc_stats[1] = arc_stat >> 10;
586 si->carc = carc_stats;
589 /* set arrays and strings */
591 si->cpustates = pcpu_cpu_states;
594 si->cpustates = cpu_states;
597 si->memory = memory_stats;
598 si->swap = swap_stats;
602 si->last_pid = lastpid;
608 * Print how long system has been up.
609 * (Found by looking getting "boottime" from the kernel)
612 mib[1] = KERN_BOOTTIME;
613 size = sizeof(boottime);
614 if (sysctl(mib, nitems(mib), &boottime, &size, NULL, 0) != -1 &&
615 boottime.tv_sec != 0) {
616 si->boottime = boottime;
618 si->boottime.tv_sec = -1;
622 #define NOPROC ((void *)-1)
625 * We need to compare data from the old process entry with the new
627 * To facilitate doing this quickly we stash a pointer in the kinfo_proc
628 * structure to cache the mapping. We also use a negative cache pointer
629 * of NOPROC to avoid duplicate lookups.
630 * XXX: this could be done when the actual processes are fetched, we do
631 * it here out of laziness.
633 const struct kinfo_proc *
634 get_old_proc(struct kinfo_proc *pp)
636 struct kinfo_proc **oldpp, *oldp;
639 * If this is the first fetch of the kinfo_procs then we don't have
640 * any previous entries.
642 if (previous_proc_count == 0)
644 /* negative cache? */
645 if (pp->ki_udata == NOPROC)
648 if (pp->ki_udata != NULL)
649 return (pp->ki_udata);
652 * 1) look up based on pid.
653 * 2) compare process start.
654 * If we fail here, then setup a negative cache entry, otherwise
657 oldpp = bsearch(&pp, previous_pref, previous_proc_count,
658 sizeof(*previous_pref), ps.thread ? compare_tid : compare_pid);
660 pp->ki_udata = NOPROC;
664 if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
665 pp->ki_udata = NOPROC;
673 * Return the total amount of IO done in blocks in/out and faults.
674 * store the values individually in the pointers passed in.
677 get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp,
678 long *vcsw, long *ivcsw)
680 const struct kinfo_proc *oldp;
681 static struct kinfo_proc dummy;
684 oldp = get_old_proc(pp);
686 bzero(&dummy, sizeof(dummy));
689 *inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
690 *oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
691 *flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
692 *vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
693 *ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
695 (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
696 (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
697 (RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
702 * If there was a previous update, use the delta in ki_runtime over
703 * the previous interval to calculate pctcpu. Otherwise, fall back
704 * to using the kernel's ki_pctcpu.
707 proc_calc_pctcpu(struct kinfo_proc *pp)
709 const struct kinfo_proc *oldp;
711 if (previous_interval != 0) {
712 oldp = get_old_proc(pp);
714 return ((double)(pp->ki_runtime - oldp->ki_runtime)
715 / previous_interval);
718 * If this process/thread was created during the previous
719 * interval, charge it's total runtime to the previous
722 else if (pp->ki_start.tv_sec > previous_wall_time.tv_sec ||
723 (pp->ki_start.tv_sec == previous_wall_time.tv_sec &&
724 pp->ki_start.tv_usec >= previous_wall_time.tv_usec))
725 return ((double)pp->ki_runtime / previous_interval);
727 return (pctdouble(pp->ki_pctcpu));
731 * Return true if this process has used any CPU time since the
735 proc_used_cpu(struct kinfo_proc *pp)
737 const struct kinfo_proc *oldp;
739 oldp = get_old_proc(pp);
741 return (PCTCPU(pp) != 0);
742 return (pp->ki_runtime != oldp->ki_runtime ||
743 RU(pp)->ru_nvcsw != RU(oldp)->ru_nvcsw ||
744 RU(pp)->ru_nivcsw != RU(oldp)->ru_nivcsw);
748 * Return the total number of block in/out and faults by a process.
751 get_io_total(struct kinfo_proc *pp)
755 return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
758 static struct handle handle;
761 get_process_info(struct system_info *si, struct process_select *sel,
762 int (*compare)(const void *, const void *))
767 long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
770 struct kinfo_proc **prefp;
771 struct kinfo_proc *pp;
772 struct timespec previous_proc_uptime;
774 /* these are copied out of sel for speed */
784 * If thread state was toggled, don't cache the previous processes.
786 if (previous_thread != sel->thread)
788 previous_thread = sel->thread;
791 * Save the previous process info.
793 if (previous_proc_count_max < nproc) {
794 free(previous_procs);
795 previous_procs = malloc(nproc * sizeof(*previous_procs));
797 previous_pref = malloc(nproc * sizeof(*previous_pref));
798 if (previous_procs == NULL || previous_pref == NULL) {
799 (void) fprintf(stderr, "top: Out of memory.\n");
802 previous_proc_count_max = nproc;
805 for (i = 0; i < nproc; i++)
806 previous_pref[i] = &previous_procs[i];
807 bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs));
808 qsort(previous_pref, nproc, sizeof(*previous_pref),
809 ps.thread ? compare_tid : compare_pid);
811 previous_proc_count = nproc;
812 previous_proc_uptime = proc_uptime;
813 previous_wall_time = proc_wall_time;
814 previous_interval = 0;
816 pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
818 (void)gettimeofday(&proc_wall_time, NULL);
819 if (clock_gettime(CLOCK_UPTIME, &proc_uptime) != 0)
820 memset(&proc_uptime, 0, sizeof(proc_uptime));
821 else if (previous_proc_uptime.tv_sec != 0 &&
822 previous_proc_uptime.tv_nsec != 0) {
823 previous_interval = (proc_uptime.tv_sec -
824 previous_proc_uptime.tv_sec) * 1000000;
825 nsec = proc_uptime.tv_nsec - previous_proc_uptime.tv_nsec;
827 previous_interval -= 1000000;
830 previous_interval += nsec / 1000;
832 if (nproc > onproc) {
833 pref = realloc(pref, sizeof(*pref) * nproc);
834 pcpu = realloc(pcpu, sizeof(*pcpu) * nproc);
837 if (pref == NULL || pbase == NULL || pcpu == NULL) {
838 (void) fprintf(stderr, "top: Out of memory.\n");
841 /* get a pointer to the states summary array */
842 si->procstates = process_states;
844 /* set up flags which define what we are going to select */
845 show_idle = sel->idle;
846 show_jid = sel->jid != -1;
847 show_self = sel->self == -1;
848 show_system = sel->system;
849 show_uid = sel->uid != -1;
850 show_command = sel->command != NULL;
851 show_kidle = sel->kidle;
853 /* count up process states and get pointers to interesting procs */
859 memset((char *)process_states, 0, sizeof(process_states));
861 for (pp = pbase, i = 0; i < nproc; pp++, i++) {
863 if (pp->ki_stat == 0)
867 if (!show_self && pp->ki_pid == sel->self)
871 if (!show_system && (pp->ki_flag & P_SYSTEM))
872 /* skip system process */
875 p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
877 total_inblock += p_inblock;
878 total_oublock += p_oublock;
879 total_majflt += p_majflt;
881 process_states[pp->ki_stat]++;
883 if (pp->ki_stat == SZOMB)
887 if (!show_kidle && pp->ki_tdflags & TDF_IDLETD)
888 /* skip kernel idle process */
891 PCTCPU(pp) = proc_calc_pctcpu(pp);
892 if (sel->thread && PCTCPU(pp) > 1.0)
894 if (displaymode == DISP_CPU && !show_idle &&
895 (!proc_used_cpu(pp) ||
896 pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
897 /* skip idle or non-running processes */
900 if (displaymode == DISP_IO && !show_idle && p_io == 0)
901 /* skip processes that aren't doing I/O */
904 if (show_jid && pp->ki_jid != sel->jid)
905 /* skip proc. that don't belong to the selected JID */
908 if (show_uid && pp->ki_ruid != (uid_t)sel->uid)
909 /* skip proc. that don't belong to the selected UID */
916 /* if requested, sort the "interesting" processes */
918 qsort(pref, active_procs, sizeof(*pref), compare);
920 /* remember active and total counts */
921 si->p_total = total_procs;
922 si->p_active = pref_len = active_procs;
924 /* pass back a handle */
925 handle.next_proc = pref;
926 handle.remaining = active_procs;
927 return ((caddr_t)&handle);
930 static char fmt[512]; /* static area where result is built */
933 format_next_process(caddr_t handle, char *(*get_userid)(int), int flags)
935 struct kinfo_proc *pp;
936 const struct kinfo_proc *oldp;
942 struct rusage ru, *rup;
944 char *proc_fmt, thr_buf[6];
945 char jid_buf[TOP_JID_LEN + 1], swap_buf[TOP_SWAP_LEN + 1];
948 const int cmdlen = 128;
950 /* find and remember the next proc structure */
951 hp = (struct handle *)handle;
952 pp = *(hp->next_proc++);
955 /* get the process's command name */
956 if ((pp->ki_flag & P_INMEM) == 0) {
958 * Print swapped processes as <pname>
962 len = strlen(pp->ki_comm);
963 if (len > sizeof(pp->ki_comm) - 3)
964 len = sizeof(pp->ki_comm) - 3;
965 memmove(pp->ki_comm + 1, pp->ki_comm, len);
966 pp->ki_comm[0] = '<';
967 pp->ki_comm[len + 1] = '>';
968 pp->ki_comm[len + 2] = '\0';
972 * Convert the process's runtime from microseconds to seconds. This
973 * time includes the interrupt time although that is not wanted here.
974 * ps(1) is similarly sloppy.
976 cputime = (pp->ki_runtime + 500000) / 1000000;
978 /* calculate the base for cpu percentages */
981 /* generate "STATE" field */
982 switch (state = pp->ki_stat) {
984 if (smpmode && pp->ki_oncpu != NOCPU)
985 sprintf(status, "CPU%d", pp->ki_oncpu);
987 strcpy(status, "RUN");
990 if (pp->ki_kiflag & KI_LOCKBLOCK) {
991 sprintf(status, "*%.6s", pp->ki_lockname);
996 if (pp->ki_wmesg != NULL) {
997 sprintf(status, "%.6s", pp->ki_wmesg);
1004 state < sizeof(state_abbrev) / sizeof(*state_abbrev))
1005 sprintf(status, "%.6s", state_abbrev[state]);
1007 sprintf(status, "?%5d", state);
1011 cmdbuf = (char *)malloc(cmdlen + 1);
1012 if (cmdbuf == NULL) {
1013 warn("malloc(%d)", cmdlen + 1);
1017 if (!(flags & FMT_SHOWARGS)) {
1018 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1020 snprintf(cmdbuf, cmdlen, "%s{%s%s}", pp->ki_comm,
1021 pp->ki_tdname, pp->ki_moretdname);
1023 snprintf(cmdbuf, cmdlen, "%s", pp->ki_comm);
1026 if (pp->ki_flag & P_SYSTEM ||
1027 pp->ki_args == NULL ||
1028 (args = kvm_getargv(kd, pp, cmdlen)) == NULL ||
1030 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1032 snprintf(cmdbuf, cmdlen,
1033 "[%s{%s%s}]", pp->ki_comm, pp->ki_tdname,
1036 snprintf(cmdbuf, cmdlen,
1037 "[%s]", pp->ki_comm);
1040 char *src, *dst, *argbuf;
1045 argbuflen = cmdlen * 4;
1046 argbuf = (char *)malloc(argbuflen + 1);
1047 if (argbuf == NULL) {
1048 warn("malloc(%zu)", argbuflen + 1);
1055 /* Extract cmd name from argv */
1056 cmd = strrchr(*args, '/');
1062 for (; (src = *args++) != NULL; ) {
1065 len = (argbuflen - (dst - argbuf) - 1) / 4;
1067 MIN(strlen(src), len),
1068 VIS_NL | VIS_CSTYLE);
1069 while (*dst != '\0')
1071 if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
1072 *dst++ = ' '; /* add delimiting space */
1074 if (dst != argbuf && dst[-1] == ' ')
1078 if (strcmp(cmd, pp->ki_comm) != 0) {
1079 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1081 snprintf(cmdbuf, cmdlen,
1082 "%s (%s){%s%s}", argbuf,
1083 pp->ki_comm, pp->ki_tdname,
1086 snprintf(cmdbuf, cmdlen,
1087 "%s (%s)", argbuf, pp->ki_comm);
1089 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1091 snprintf(cmdbuf, cmdlen,
1092 "%s{%s%s}", argbuf, pp->ki_tdname,
1095 strlcpy(cmdbuf, argbuf, cmdlen);
1104 snprintf(jid_buf, sizeof(jid_buf), "%*d",
1105 jidlength - 1, pp->ki_jid);
1110 snprintf(swap_buf, sizeof(swap_buf), "%*s",
1112 format_k2(pagetok(ki_swap(pp)))); /* XXX */
1114 if (displaymode == DISP_IO) {
1115 oldp = get_old_proc(pp);
1117 ru.ru_inblock = RU(pp)->ru_inblock -
1118 RU(oldp)->ru_inblock;
1119 ru.ru_oublock = RU(pp)->ru_oublock -
1120 RU(oldp)->ru_oublock;
1121 ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
1122 ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
1123 ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
1128 p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
1129 s_tot = total_inblock + total_oublock + total_majflt;
1131 snprintf(fmt, sizeof(fmt), io_Proc_format,
1134 namelength, namelength, (*get_userid)(pp->ki_ruid),
1141 s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
1142 screen_width > cmdlengthdelta ?
1143 screen_width - cmdlengthdelta : 0,
1151 /* format this entry */
1153 if (state == SRUN && pp->ki_oncpu != NOCPU)
1156 cpu = pp->ki_lastcpu;
1159 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1163 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1164 (int)(sizeof(thr_buf) - 2), pp->ki_numthreads);
1166 snprintf(fmt, sizeof(fmt), proc_fmt,
1169 namelength, namelength, (*get_userid)(pp->ki_ruid),
1171 pp->ki_pri.pri_level - PZERO,
1173 format_k2(PROCSIZE(pp)),
1174 format_k2(pagetok(pp->ki_rssize)),
1175 swaplength, swaplength, swap_buf,
1178 format_time(cputime),
1179 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1180 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1185 /* return the result */
1190 getsysctl(const char *name, void *ptr, size_t len)
1194 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1195 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1200 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1201 name, (unsigned long)len, (unsigned long)nlen);
1207 format_nice(const struct kinfo_proc *pp)
1209 const char *fifo, *kproc;
1211 static char nicebuf[4 + 1];
1213 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1214 kproc = (pp->ki_flag & P_KPROC) ? "k" : "";
1215 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1220 * XXX: the kernel doesn't tell us the original rtprio and
1221 * doesn't really know what it was, so to recover it we
1222 * must be more chummy with the implementation than the
1223 * implementation is with itself. pri_user gives a
1224 * constant "base" priority, but is only initialized
1225 * properly for user threads. pri_native gives what the
1226 * kernel calls the "base" priority, but it isn't constant
1227 * since it is changed by priority propagation. pri_native
1228 * also isn't properly initialized for all threads, but it
1229 * is properly initialized for kernel realtime and idletime
1230 * threads. Thus we use pri_user for the base priority of
1231 * user threads (it is always correct) and pri_native for
1232 * the base priority of kernel realtime and idletime threads
1233 * (there is nothing better, and it is usually correct).
1235 * The field width and thus the buffer are too small for
1236 * values like "kr31F", but such values shouldn't occur,
1237 * and if they do then the tailing "F" is not displayed.
1239 rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
1240 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1241 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1242 kproc, rtpri, fifo);
1245 if (pp->ki_flag & P_KPROC)
1247 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1250 /* XXX: as above. */
1251 rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
1252 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1253 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1254 kproc, rtpri, fifo);
1262 /* comparison routines for qsort */
1265 compare_pid(const void *p1, const void *p2)
1267 const struct kinfo_proc * const *pp1 = p1;
1268 const struct kinfo_proc * const *pp2 = p2;
1270 if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
1273 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1277 compare_tid(const void *p1, const void *p2)
1279 const struct kinfo_proc * const *pp1 = p1;
1280 const struct kinfo_proc * const *pp2 = p2;
1282 if ((*pp2)->ki_tid < 0 || (*pp1)->ki_tid < 0)
1285 return ((*pp1)->ki_tid - (*pp2)->ki_tid);
1289 * proc_compare - comparison function for "qsort"
1290 * Compares the resource consumption of two processes using five
1291 * distinct keys. The keys (in descending order of importance) are:
1292 * percent cpu, cpu ticks, state, resident set size, total virtual
1293 * memory usage. The process states are ordered as follows (from least
1294 * to most important): WAIT, zombie, sleep, stop, start, run. The
1295 * array declaration below maps a process state index into a number
1296 * that reflects this ordering.
1299 static int sorted_state[] = {
1302 1, /* ABANDONED (WAIT) */
1310 #define ORDERKEY_PCTCPU(a, b) do { \
1313 diff = weighted_cpu(PCTCPU((b)), (b)) - \
1314 weighted_cpu(PCTCPU((a)), (a)); \
1316 diff = PCTCPU((b)) - PCTCPU((a)); \
1318 return (diff > 0 ? 1 : -1); \
1321 #define ORDERKEY_CPTICKS(a, b) do { \
1322 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1324 return (diff > 0 ? 1 : -1); \
1327 #define ORDERKEY_STATE(a, b) do { \
1328 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1330 return (diff > 0 ? 1 : -1); \
1333 #define ORDERKEY_PRIO(a, b) do { \
1334 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1336 return (diff > 0 ? 1 : -1); \
1339 #define ORDERKEY_THREADS(a, b) do { \
1340 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1342 return (diff > 0 ? 1 : -1); \
1345 #define ORDERKEY_RSSIZE(a, b) do { \
1346 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1348 return (diff > 0 ? 1 : -1); \
1351 #define ORDERKEY_MEM(a, b) do { \
1352 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1354 return (diff > 0 ? 1 : -1); \
1357 #define ORDERKEY_JID(a, b) do { \
1358 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1360 return (diff > 0 ? 1 : -1); \
1363 #define ORDERKEY_SWAP(a, b) do { \
1364 int diff = (int)ki_swap(b) - (int)ki_swap(a); \
1366 return (diff > 0 ? 1 : -1); \
1369 /* compare_cpu - the comparison function for sorting by cpu percentage */
1373 compare_cpu(void *arg1, void *arg2)
1375 proc_compare(void *arg1, void *arg2)
1378 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1379 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1381 ORDERKEY_PCTCPU(p1, p2);
1382 ORDERKEY_CPTICKS(p1, p2);
1383 ORDERKEY_STATE(p1, p2);
1384 ORDERKEY_PRIO(p1, p2);
1385 ORDERKEY_RSSIZE(p1, p2);
1386 ORDERKEY_MEM(p1, p2);
1392 /* "cpu" compare routines */
1393 int compare_size(), compare_res(), compare_time(), compare_prio(),
1397 * "io" compare routines. Context switches aren't i/o, but are displayed
1398 * on the "io" display.
1400 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1401 compare_vcsw(), compare_ivcsw();
1403 int (*compares[])() = {
1421 /* compare_size - the comparison function for sorting by total memory usage */
1424 compare_size(void *arg1, void *arg2)
1426 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1427 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1429 ORDERKEY_MEM(p1, p2);
1430 ORDERKEY_RSSIZE(p1, p2);
1431 ORDERKEY_PCTCPU(p1, p2);
1432 ORDERKEY_CPTICKS(p1, p2);
1433 ORDERKEY_STATE(p1, p2);
1434 ORDERKEY_PRIO(p1, p2);
1439 /* compare_res - the comparison function for sorting by resident set size */
1442 compare_res(void *arg1, void *arg2)
1444 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1445 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1447 ORDERKEY_RSSIZE(p1, p2);
1448 ORDERKEY_MEM(p1, p2);
1449 ORDERKEY_PCTCPU(p1, p2);
1450 ORDERKEY_CPTICKS(p1, p2);
1451 ORDERKEY_STATE(p1, p2);
1452 ORDERKEY_PRIO(p1, p2);
1457 /* compare_time - the comparison function for sorting by total cpu time */
1460 compare_time(void *arg1, void *arg2)
1462 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1463 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1465 ORDERKEY_CPTICKS(p1, p2);
1466 ORDERKEY_PCTCPU(p1, p2);
1467 ORDERKEY_STATE(p1, p2);
1468 ORDERKEY_PRIO(p1, p2);
1469 ORDERKEY_RSSIZE(p1, p2);
1470 ORDERKEY_MEM(p1, p2);
1475 /* compare_prio - the comparison function for sorting by priority */
1478 compare_prio(void *arg1, void *arg2)
1480 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1481 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1483 ORDERKEY_PRIO(p1, p2);
1484 ORDERKEY_CPTICKS(p1, p2);
1485 ORDERKEY_PCTCPU(p1, p2);
1486 ORDERKEY_STATE(p1, p2);
1487 ORDERKEY_RSSIZE(p1, p2);
1488 ORDERKEY_MEM(p1, p2);
1493 /* compare_threads - the comparison function for sorting by threads */
1495 compare_threads(void *arg1, void *arg2)
1497 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1498 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1500 ORDERKEY_THREADS(p1, p2);
1501 ORDERKEY_PCTCPU(p1, p2);
1502 ORDERKEY_CPTICKS(p1, p2);
1503 ORDERKEY_STATE(p1, p2);
1504 ORDERKEY_PRIO(p1, p2);
1505 ORDERKEY_RSSIZE(p1, p2);
1506 ORDERKEY_MEM(p1, p2);
1511 /* compare_jid - the comparison function for sorting by jid */
1513 compare_jid(const void *arg1, const void *arg2)
1515 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1516 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1518 ORDERKEY_JID(p1, p2);
1519 ORDERKEY_PCTCPU(p1, p2);
1520 ORDERKEY_CPTICKS(p1, p2);
1521 ORDERKEY_STATE(p1, p2);
1522 ORDERKEY_PRIO(p1, p2);
1523 ORDERKEY_RSSIZE(p1, p2);
1524 ORDERKEY_MEM(p1, p2);
1529 /* compare_swap - the comparison function for sorting by swap */
1531 compare_swap(const void *arg1, const void *arg2)
1533 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1534 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1536 ORDERKEY_SWAP(p1, p2);
1537 ORDERKEY_PCTCPU(p1, p2);
1538 ORDERKEY_CPTICKS(p1, p2);
1539 ORDERKEY_STATE(p1, p2);
1540 ORDERKEY_PRIO(p1, p2);
1541 ORDERKEY_RSSIZE(p1, p2);
1542 ORDERKEY_MEM(p1, p2);
1548 /* assorted comparison functions for sorting by i/o */
1552 compare_iototal(void *arg1, void *arg2)
1554 io_compare(void *arg1, void *arg2)
1557 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1558 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1560 return (get_io_total(p2) - get_io_total(p1));
1565 compare_ioread(void *arg1, void *arg2)
1567 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1568 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1569 long dummy, inp1, inp2;
1571 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1572 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1574 return (inp2 - inp1);
1578 compare_iowrite(void *arg1, void *arg2)
1580 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1581 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1582 long dummy, oup1, oup2;
1584 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1585 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1587 return (oup2 - oup1);
1591 compare_iofault(void *arg1, void *arg2)
1593 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1594 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1595 long dummy, flp1, flp2;
1597 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1598 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1600 return (flp2 - flp1);
1604 compare_vcsw(void *arg1, void *arg2)
1606 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1607 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1608 long dummy, flp1, flp2;
1610 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
1611 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1613 return (flp2 - flp1);
1617 compare_ivcsw(void *arg1, void *arg2)
1619 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1620 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1621 long dummy, flp1, flp2;
1623 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
1624 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1626 return (flp2 - flp1);
1631 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1632 * the process does not exist.
1633 * It is EXTREMELY IMPORTANT that this function work correctly.
1634 * If top runs setuid root (as in SVR4), then this function
1635 * is the only thing that stands in the way of a serious
1636 * security problem. It validates requests for the "kill"
1637 * and "renice" commands.
1644 struct kinfo_proc **prefp;
1645 struct kinfo_proc *pp;
1649 while (--cnt >= 0) {
1651 if (pp->ki_pid == (pid_t)pid)
1652 return ((int)pp->ki_ruid);
1658 swapmode(int *retavail, int *retfree)
1661 int pagesize = getpagesize();
1662 struct kvm_swap swapary[1];
1667 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1669 n = kvm_getswapinfo(kd, swapary, 1, 0);
1670 if (n < 0 || swapary[0].ksw_total == 0)
1673 *retavail = CONVERT(swapary[0].ksw_total);
1674 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1676 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);