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 */
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);
276 static int find_uid(uid_t needle, int *haystack);
279 find_uid(uid_t needle, int *haystack)
283 for (; i < TOP_MAX_UIDS; ++i)
284 if ((uid_t)haystack[i] == needle)
290 toggle_pcpustats(void)
298 /* Adjust display based on ncpus and the ARC state. */
306 y_swap = 4 + arc_enabled + carc_enabled;
307 y_idlecursor = 5 + arc_enabled + carc_enabled;
308 y_message = 5 + arc_enabled + carc_enabled;
309 y_header = 6 + arc_enabled + carc_enabled;
310 y_procs = 7 + arc_enabled + carc_enabled;
311 Header_lines = 7 + arc_enabled + carc_enabled;
318 y_idlecursor += ncpus - 1;
319 y_message += ncpus - 1;
320 y_header += ncpus - 1;
321 y_procs += ncpus - 1;
322 Header_lines += ncpus - 1;
327 machine_init(struct statics *statics, char do_unames)
329 int i, j, empty, pagesize;
335 size = sizeof(smpmode);
336 if ((sysctlbyname("machdep.smp_active", &smpmode, &size,
338 sysctlbyname("kern.smp.active", &smpmode, &size,
340 size != sizeof(smpmode))
343 size = sizeof(arc_size);
344 if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
345 NULL, 0) == 0 && arc_size != 0)
347 size = sizeof(carc_en);
349 sysctlbyname("vfs.zfs.compressed_arc_enabled", &carc_en, &size,
350 NULL, 0) == 0 && carc_en == 1)
354 while ((pw = getpwent()) != NULL) {
355 if (strlen(pw->pw_name) > namelength)
356 namelength = strlen(pw->pw_name);
359 if (smpmode && namelength > SMPUNAMELEN)
360 namelength = SMPUNAMELEN;
361 else if (namelength > UPUNAMELEN)
362 namelength = UPUNAMELEN;
364 kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
368 GETSYSCTL("kern.ccpu", ccpu);
370 /* this is used in calculating WCPU -- calculate it ahead of time */
371 logcpu = log(loaddouble(ccpu));
379 /* get the page size and calculate pageshift from it */
380 pagesize = getpagesize();
382 while (pagesize > 1) {
387 /* we only need the amount of log(2)1024 for our conversion */
388 pageshift -= LOG1024;
390 /* fill in the statics information */
391 statics->procstate_names = procstatenames;
392 statics->cpustate_names = cpustatenames;
393 statics->memory_names = memorynames;
395 statics->arc_names = arcnames;
397 statics->arc_names = NULL;
399 statics->carc_names = carcnames;
401 statics->carc_names = NULL;
402 statics->swap_names = swapnames;
404 statics->order_names = ordernames;
407 /* Allocate state for per-CPU stats. */
410 GETSYSCTL("kern.smp.maxcpus", maxcpu);
411 size = sizeof(long) * maxcpu * CPUSTATES;
412 times = malloc(size);
414 err(1, "malloc %zu bytes", size);
415 if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
416 err(1, "sysctlbyname kern.cp_times");
417 pcpu_cp_time = calloc(1, size);
418 maxid = (size / CPUSTATES / sizeof(long)) - 1;
419 for (i = 0; i <= maxid; i++) {
421 for (j = 0; empty && j < CPUSTATES; j++) {
422 if (times[i * CPUSTATES + j] != 0)
426 cpumask |= (1ul << i);
430 size = sizeof(long) * ncpus * CPUSTATES;
431 pcpu_cp_old = calloc(1, size);
432 pcpu_cp_diff = calloc(1, size);
433 pcpu_cpu_states = calloc(1, size);
434 statics->ncpus = ncpus;
443 format_header(char *uname_field)
445 static char Header[128];
449 jidlength = TOP_JID_LEN + 1; /* +1 for extra left space. */
454 swaplength = TOP_SWAP_LEN + 1; /* +1 for extra left space */
458 switch (displaymode) {
461 * The logic of picking the right header format seems reverse
462 * here because we only want to display a THR column when
463 * "thread mode" is off (and threads are not listed as
467 (ps.thread ? smp_header : smp_header_thr) :
468 (ps.thread ? up_header : up_header_thr);
469 snprintf(Header, sizeof(Header), prehead,
470 jidlength, ps.jail ? " JID" : "",
471 namelength, namelength, uname_field,
472 swaplength, ps.swap ? " SWAP" : "",
473 ps.wcpu ? "WCPU" : "CPU");
477 snprintf(Header, sizeof(Header), prehead,
478 jidlength, ps.jail ? " JID" : "",
479 namelength, namelength, uname_field);
482 cmdlengthdelta = strlen(Header) - 7;
486 static int swappgsin = -1;
487 static int swappgsout = -1;
488 extern struct timeval timeout;
492 get_system_info(struct system_info *si)
495 struct loadavg sysload;
497 struct timeval boottime;
498 uint64_t arc_stat, arc_stat2;
502 /* get the CPU stats */
503 size = (maxid + 1) * CPUSTATES * sizeof(long);
504 if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
505 err(1, "sysctlbyname kern.cp_times");
506 GETSYSCTL("kern.cp_time", cp_time);
507 GETSYSCTL("vm.loadavg", sysload);
508 GETSYSCTL("kern.lastpid", lastpid);
510 /* convert load averages to doubles */
511 for (i = 0; i < 3; i++)
512 si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
514 /* convert cp_time counts to percentages */
515 for (i = j = 0; i <= maxid; i++) {
516 if ((cpumask & (1ul << i)) == 0)
518 percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
519 &pcpu_cp_time[j * CPUSTATES],
520 &pcpu_cp_old[j * CPUSTATES],
521 &pcpu_cp_diff[j * CPUSTATES]);
524 percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
526 /* sum memory & swap statistics */
528 static unsigned int swap_delay = 0;
529 static int swapavail = 0;
530 static int swapfree = 0;
531 static long bufspace = 0;
532 static int nspgsin, nspgsout;
534 GETSYSCTL("vfs.bufspace", bufspace);
535 GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
536 GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
537 GETSYSCTL("vm.stats.vm.v_laundry_count", memory_stats[2]);
538 GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[3]);
539 GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
540 GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
541 GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
542 /* convert memory stats to Kbytes */
543 memory_stats[0] = pagetok(memory_stats[0]);
544 memory_stats[1] = pagetok(memory_stats[1]);
545 memory_stats[2] = pagetok(memory_stats[2]);
546 memory_stats[3] = pagetok(memory_stats[3]);
547 memory_stats[4] = bufspace / 1024;
548 memory_stats[5] = pagetok(memory_stats[5]);
549 memory_stats[6] = -1;
557 /* compute differences between old and new swap statistic */
559 swap_stats[4] = pagetok(((nspgsin - swappgsin)));
560 swap_stats[5] = pagetok(((nspgsout - swappgsout)));
564 swappgsout = nspgsout;
566 /* call CPU heavy swapmode() only for changes */
567 if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
568 swap_stats[3] = swapmode(&swapavail, &swapfree);
569 swap_stats[0] = swapavail;
570 swap_stats[1] = swapavail - swapfree;
571 swap_stats[2] = swapfree;
578 GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
579 arc_stats[0] = arc_stat >> 10;
580 GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
581 arc_stats[1] = arc_stat >> 10;
582 GETSYSCTL("vfs.zfs.mru_size", arc_stat);
583 arc_stats[2] = arc_stat >> 10;
584 GETSYSCTL("vfs.zfs.anon_size", arc_stat);
585 arc_stats[3] = arc_stat >> 10;
586 GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
587 GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
588 arc_stats[4] = arc_stat + arc_stat2 >> 10;
589 GETSYSCTL("kstat.zfs.misc.arcstats.other_size", arc_stat);
590 arc_stats[5] = arc_stat >> 10;
594 GETSYSCTL("kstat.zfs.misc.arcstats.compressed_size", arc_stat);
595 carc_stats[0] = arc_stat >> 10;
596 carc_stats[2] = arc_stat >> 10; /* For ratio */
597 GETSYSCTL("kstat.zfs.misc.arcstats.uncompressed_size", arc_stat);
598 carc_stats[1] = arc_stat >> 10;
599 si->carc = carc_stats;
602 /* set arrays and strings */
604 si->cpustates = pcpu_cpu_states;
607 si->cpustates = cpu_states;
610 si->memory = memory_stats;
611 si->swap = swap_stats;
615 si->last_pid = lastpid;
621 * Print how long system has been up.
622 * (Found by looking getting "boottime" from the kernel)
625 mib[1] = KERN_BOOTTIME;
626 size = sizeof(boottime);
627 if (sysctl(mib, nitems(mib), &boottime, &size, NULL, 0) != -1 &&
628 boottime.tv_sec != 0) {
629 si->boottime = boottime;
631 si->boottime.tv_sec = -1;
635 #define NOPROC ((void *)-1)
638 * We need to compare data from the old process entry with the new
640 * To facilitate doing this quickly we stash a pointer in the kinfo_proc
641 * structure to cache the mapping. We also use a negative cache pointer
642 * of NOPROC to avoid duplicate lookups.
643 * XXX: this could be done when the actual processes are fetched, we do
644 * it here out of laziness.
646 const struct kinfo_proc *
647 get_old_proc(struct kinfo_proc *pp)
649 struct kinfo_proc **oldpp, *oldp;
652 * If this is the first fetch of the kinfo_procs then we don't have
653 * any previous entries.
655 if (previous_proc_count == 0)
657 /* negative cache? */
658 if (pp->ki_udata == NOPROC)
661 if (pp->ki_udata != NULL)
662 return (pp->ki_udata);
665 * 1) look up based on pid.
666 * 2) compare process start.
667 * If we fail here, then setup a negative cache entry, otherwise
670 oldpp = bsearch(&pp, previous_pref, previous_proc_count,
671 sizeof(*previous_pref), ps.thread ? compare_tid : compare_pid);
673 pp->ki_udata = NOPROC;
677 if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
678 pp->ki_udata = NOPROC;
686 * Return the total amount of IO done in blocks in/out and faults.
687 * store the values individually in the pointers passed in.
690 get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp,
691 long *vcsw, long *ivcsw)
693 const struct kinfo_proc *oldp;
694 static struct kinfo_proc dummy;
697 oldp = get_old_proc(pp);
699 bzero(&dummy, sizeof(dummy));
702 *inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
703 *oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
704 *flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
705 *vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
706 *ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
708 (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
709 (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
710 (RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
715 * If there was a previous update, use the delta in ki_runtime over
716 * the previous interval to calculate pctcpu. Otherwise, fall back
717 * to using the kernel's ki_pctcpu.
720 proc_calc_pctcpu(struct kinfo_proc *pp)
722 const struct kinfo_proc *oldp;
724 if (previous_interval != 0) {
725 oldp = get_old_proc(pp);
727 return ((double)(pp->ki_runtime - oldp->ki_runtime)
728 / previous_interval);
731 * If this process/thread was created during the previous
732 * interval, charge it's total runtime to the previous
735 else if (pp->ki_start.tv_sec > previous_wall_time.tv_sec ||
736 (pp->ki_start.tv_sec == previous_wall_time.tv_sec &&
737 pp->ki_start.tv_usec >= previous_wall_time.tv_usec))
738 return ((double)pp->ki_runtime / previous_interval);
740 return (pctdouble(pp->ki_pctcpu));
744 * Return true if this process has used any CPU time since the
748 proc_used_cpu(struct kinfo_proc *pp)
750 const struct kinfo_proc *oldp;
752 oldp = get_old_proc(pp);
754 return (PCTCPU(pp) != 0);
755 return (pp->ki_runtime != oldp->ki_runtime ||
756 RU(pp)->ru_nvcsw != RU(oldp)->ru_nvcsw ||
757 RU(pp)->ru_nivcsw != RU(oldp)->ru_nivcsw);
761 * Return the total number of block in/out and faults by a process.
764 get_io_total(struct kinfo_proc *pp)
768 return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
771 static struct handle handle;
774 get_process_info(struct system_info *si, struct process_select *sel,
775 int (*compare)(const void *, const void *))
780 long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
783 struct kinfo_proc **prefp;
784 struct kinfo_proc *pp;
785 struct timespec previous_proc_uptime;
787 /* these are copied out of sel for speed */
797 * If thread state was toggled, don't cache the previous processes.
799 if (previous_thread != sel->thread)
801 previous_thread = sel->thread;
804 * Save the previous process info.
806 if (previous_proc_count_max < nproc) {
807 free(previous_procs);
808 previous_procs = malloc(nproc * sizeof(*previous_procs));
810 previous_pref = malloc(nproc * sizeof(*previous_pref));
811 if (previous_procs == NULL || previous_pref == NULL) {
812 (void) fprintf(stderr, "top: Out of memory.\n");
815 previous_proc_count_max = nproc;
818 for (i = 0; i < nproc; i++)
819 previous_pref[i] = &previous_procs[i];
820 bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs));
821 qsort(previous_pref, nproc, sizeof(*previous_pref),
822 ps.thread ? compare_tid : compare_pid);
824 previous_proc_count = nproc;
825 previous_proc_uptime = proc_uptime;
826 previous_wall_time = proc_wall_time;
827 previous_interval = 0;
829 pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
831 (void)gettimeofday(&proc_wall_time, NULL);
832 if (clock_gettime(CLOCK_UPTIME, &proc_uptime) != 0)
833 memset(&proc_uptime, 0, sizeof(proc_uptime));
834 else if (previous_proc_uptime.tv_sec != 0 &&
835 previous_proc_uptime.tv_nsec != 0) {
836 previous_interval = (proc_uptime.tv_sec -
837 previous_proc_uptime.tv_sec) * 1000000;
838 nsec = proc_uptime.tv_nsec - previous_proc_uptime.tv_nsec;
840 previous_interval -= 1000000;
843 previous_interval += nsec / 1000;
845 if (nproc > onproc) {
846 pref = realloc(pref, sizeof(*pref) * nproc);
847 pcpu = realloc(pcpu, sizeof(*pcpu) * nproc);
850 if (pref == NULL || pbase == NULL || pcpu == NULL) {
851 (void) fprintf(stderr, "top: Out of memory.\n");
854 /* get a pointer to the states summary array */
855 si->procstates = process_states;
857 /* set up flags which define what we are going to select */
858 show_idle = sel->idle;
859 show_jid = sel->jid != -1;
860 show_self = sel->self == -1;
861 show_system = sel->system;
862 show_uid = sel->uid[0] != -1;
863 show_command = sel->command != NULL;
864 show_kidle = sel->kidle;
866 /* count up process states and get pointers to interesting procs */
872 memset((char *)process_states, 0, sizeof(process_states));
874 for (pp = pbase, i = 0; i < nproc; pp++, i++) {
876 if (pp->ki_stat == 0)
880 if (!show_self && pp->ki_pid == sel->self)
884 if (!show_system && (pp->ki_flag & P_SYSTEM))
885 /* skip system process */
888 p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
890 total_inblock += p_inblock;
891 total_oublock += p_oublock;
892 total_majflt += p_majflt;
894 process_states[pp->ki_stat]++;
896 if (pp->ki_stat == SZOMB)
900 if (!show_kidle && pp->ki_tdflags & TDF_IDLETD)
901 /* skip kernel idle process */
904 PCTCPU(pp) = proc_calc_pctcpu(pp);
905 if (sel->thread && PCTCPU(pp) > 1.0)
907 if (displaymode == DISP_CPU && !show_idle &&
908 (!proc_used_cpu(pp) ||
909 pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
910 /* skip idle or non-running processes */
913 if (displaymode == DISP_IO && !show_idle && p_io == 0)
914 /* skip processes that aren't doing I/O */
917 if (show_jid && pp->ki_jid != sel->jid)
918 /* skip proc. that don't belong to the selected JID */
921 if (show_uid && !find_uid(pp->ki_ruid, sel->uid))
922 /* skip proc. that don't belong to the selected UID */
929 /* if requested, sort the "interesting" processes */
931 qsort(pref, active_procs, sizeof(*pref), compare);
933 /* remember active and total counts */
934 si->p_total = total_procs;
935 si->p_active = pref_len = active_procs;
937 /* pass back a handle */
938 handle.next_proc = pref;
939 handle.remaining = active_procs;
940 return ((caddr_t)&handle);
943 static char fmt[512]; /* static area where result is built */
946 format_next_process(caddr_t handle, char *(*get_userid)(int), int flags)
948 struct kinfo_proc *pp;
949 const struct kinfo_proc *oldp;
955 struct rusage ru, *rup;
957 char *proc_fmt, thr_buf[6];
958 char jid_buf[TOP_JID_LEN + 1], swap_buf[TOP_SWAP_LEN + 1];
961 const int cmdlen = 128;
963 /* find and remember the next proc structure */
964 hp = (struct handle *)handle;
965 pp = *(hp->next_proc++);
968 /* get the process's command name */
969 if ((pp->ki_flag & P_INMEM) == 0) {
971 * Print swapped processes as <pname>
975 len = strlen(pp->ki_comm);
976 if (len > sizeof(pp->ki_comm) - 3)
977 len = sizeof(pp->ki_comm) - 3;
978 memmove(pp->ki_comm + 1, pp->ki_comm, len);
979 pp->ki_comm[0] = '<';
980 pp->ki_comm[len + 1] = '>';
981 pp->ki_comm[len + 2] = '\0';
985 * Convert the process's runtime from microseconds to seconds. This
986 * time includes the interrupt time although that is not wanted here.
987 * ps(1) is similarly sloppy.
989 cputime = (pp->ki_runtime + 500000) / 1000000;
991 /* calculate the base for cpu percentages */
994 /* generate "STATE" field */
995 switch (state = pp->ki_stat) {
997 if (smpmode && pp->ki_oncpu != NOCPU)
998 sprintf(status, "CPU%d", pp->ki_oncpu);
1000 strcpy(status, "RUN");
1003 if (pp->ki_kiflag & KI_LOCKBLOCK) {
1004 sprintf(status, "*%.6s", pp->ki_lockname);
1009 if (pp->ki_wmesg != NULL) {
1010 sprintf(status, "%.6s", pp->ki_wmesg);
1017 state < sizeof(state_abbrev) / sizeof(*state_abbrev))
1018 sprintf(status, "%.6s", state_abbrev[state]);
1020 sprintf(status, "?%5d", state);
1024 cmdbuf = (char *)malloc(cmdlen + 1);
1025 if (cmdbuf == NULL) {
1026 warn("malloc(%d)", cmdlen + 1);
1030 if (!(flags & FMT_SHOWARGS)) {
1031 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1033 snprintf(cmdbuf, cmdlen, "%s{%s%s}", pp->ki_comm,
1034 pp->ki_tdname, pp->ki_moretdname);
1036 snprintf(cmdbuf, cmdlen, "%s", pp->ki_comm);
1039 if (pp->ki_flag & P_SYSTEM ||
1040 (args = kvm_getargv(kd, pp, cmdlen)) == NULL ||
1042 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1044 snprintf(cmdbuf, cmdlen,
1045 "[%s{%s%s}]", pp->ki_comm, pp->ki_tdname,
1048 snprintf(cmdbuf, cmdlen,
1049 "[%s]", pp->ki_comm);
1052 char *src, *dst, *argbuf;
1057 argbuflen = cmdlen * 4;
1058 argbuf = (char *)malloc(argbuflen + 1);
1059 if (argbuf == NULL) {
1060 warn("malloc(%zu)", argbuflen + 1);
1067 /* Extract cmd name from argv */
1068 cmd = strrchr(*args, '/');
1074 for (; (src = *args++) != NULL; ) {
1077 len = (argbuflen - (dst - argbuf) - 1) / 4;
1079 MIN(strlen(src), len),
1080 VIS_NL | VIS_CSTYLE);
1081 while (*dst != '\0')
1083 if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
1084 *dst++ = ' '; /* add delimiting space */
1086 if (dst != argbuf && dst[-1] == ' ')
1090 if (strcmp(cmd, pp->ki_comm) != 0) {
1091 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1093 snprintf(cmdbuf, cmdlen,
1094 "%s (%s){%s%s}", argbuf,
1095 pp->ki_comm, pp->ki_tdname,
1098 snprintf(cmdbuf, cmdlen,
1099 "%s (%s)", argbuf, pp->ki_comm);
1101 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
1103 snprintf(cmdbuf, cmdlen,
1104 "%s{%s%s}", argbuf, pp->ki_tdname,
1107 strlcpy(cmdbuf, argbuf, cmdlen);
1116 snprintf(jid_buf, sizeof(jid_buf), "%*d",
1117 jidlength - 1, pp->ki_jid);
1122 snprintf(swap_buf, sizeof(swap_buf), "%*s",
1124 format_k2(pagetok(ki_swap(pp)))); /* XXX */
1126 if (displaymode == DISP_IO) {
1127 oldp = get_old_proc(pp);
1129 ru.ru_inblock = RU(pp)->ru_inblock -
1130 RU(oldp)->ru_inblock;
1131 ru.ru_oublock = RU(pp)->ru_oublock -
1132 RU(oldp)->ru_oublock;
1133 ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
1134 ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
1135 ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
1140 p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
1141 s_tot = total_inblock + total_oublock + total_majflt;
1143 snprintf(fmt, sizeof(fmt), io_Proc_format,
1146 namelength, namelength, (*get_userid)(pp->ki_ruid),
1153 s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
1154 screen_width > cmdlengthdelta ?
1155 screen_width - cmdlengthdelta : 0,
1163 /* format this entry */
1165 if (state == SRUN && pp->ki_oncpu != NOCPU)
1168 cpu = pp->ki_lastcpu;
1171 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1175 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1176 (int)(sizeof(thr_buf) - 2), pp->ki_numthreads);
1178 snprintf(fmt, sizeof(fmt), proc_fmt,
1181 namelength, namelength, (*get_userid)(pp->ki_ruid),
1183 pp->ki_pri.pri_level - PZERO,
1185 format_k2(PROCSIZE(pp)),
1186 format_k2(pagetok(pp->ki_rssize)),
1187 swaplength, swaplength, swap_buf,
1190 format_time(cputime),
1191 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1192 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1197 /* return the result */
1202 getsysctl(const char *name, void *ptr, size_t len)
1206 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1207 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1212 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1213 name, (unsigned long)len, (unsigned long)nlen);
1219 format_nice(const struct kinfo_proc *pp)
1221 const char *fifo, *kproc;
1223 static char nicebuf[4 + 1];
1225 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1226 kproc = (pp->ki_flag & P_KPROC) ? "k" : "";
1227 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1232 * XXX: the kernel doesn't tell us the original rtprio and
1233 * doesn't really know what it was, so to recover it we
1234 * must be more chummy with the implementation than the
1235 * implementation is with itself. pri_user gives a
1236 * constant "base" priority, but is only initialized
1237 * properly for user threads. pri_native gives what the
1238 * kernel calls the "base" priority, but it isn't constant
1239 * since it is changed by priority propagation. pri_native
1240 * also isn't properly initialized for all threads, but it
1241 * is properly initialized for kernel realtime and idletime
1242 * threads. Thus we use pri_user for the base priority of
1243 * user threads (it is always correct) and pri_native for
1244 * the base priority of kernel realtime and idletime threads
1245 * (there is nothing better, and it is usually correct).
1247 * The field width and thus the buffer are too small for
1248 * values like "kr31F", but such values shouldn't occur,
1249 * and if they do then the tailing "F" is not displayed.
1251 rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
1252 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1253 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1254 kproc, rtpri, fifo);
1257 if (pp->ki_flag & P_KPROC)
1259 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1262 /* XXX: as above. */
1263 rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
1264 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1265 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1266 kproc, rtpri, fifo);
1274 /* comparison routines for qsort */
1277 compare_pid(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_pid < 0 || (*pp1)->ki_pid < 0)
1285 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1289 compare_tid(const void *p1, const void *p2)
1291 const struct kinfo_proc * const *pp1 = p1;
1292 const struct kinfo_proc * const *pp2 = p2;
1294 if ((*pp2)->ki_tid < 0 || (*pp1)->ki_tid < 0)
1297 return ((*pp1)->ki_tid - (*pp2)->ki_tid);
1301 * proc_compare - comparison function for "qsort"
1302 * Compares the resource consumption of two processes using five
1303 * distinct keys. The keys (in descending order of importance) are:
1304 * percent cpu, cpu ticks, state, resident set size, total virtual
1305 * memory usage. The process states are ordered as follows (from least
1306 * to most important): WAIT, zombie, sleep, stop, start, run. The
1307 * array declaration below maps a process state index into a number
1308 * that reflects this ordering.
1311 static int sorted_state[] = {
1314 1, /* ABANDONED (WAIT) */
1322 #define ORDERKEY_PCTCPU(a, b) do { \
1325 diff = weighted_cpu(PCTCPU((b)), (b)) - \
1326 weighted_cpu(PCTCPU((a)), (a)); \
1328 diff = PCTCPU((b)) - PCTCPU((a)); \
1330 return (diff > 0 ? 1 : -1); \
1333 #define ORDERKEY_CPTICKS(a, b) do { \
1334 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1336 return (diff > 0 ? 1 : -1); \
1339 #define ORDERKEY_STATE(a, b) do { \
1340 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1342 return (diff > 0 ? 1 : -1); \
1345 #define ORDERKEY_PRIO(a, b) do { \
1346 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1348 return (diff > 0 ? 1 : -1); \
1351 #define ORDERKEY_THREADS(a, b) do { \
1352 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1354 return (diff > 0 ? 1 : -1); \
1357 #define ORDERKEY_RSSIZE(a, b) do { \
1358 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1360 return (diff > 0 ? 1 : -1); \
1363 #define ORDERKEY_MEM(a, b) do { \
1364 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1366 return (diff > 0 ? 1 : -1); \
1369 #define ORDERKEY_JID(a, b) do { \
1370 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1372 return (diff > 0 ? 1 : -1); \
1375 #define ORDERKEY_SWAP(a, b) do { \
1376 int diff = (int)ki_swap(b) - (int)ki_swap(a); \
1378 return (diff > 0 ? 1 : -1); \
1381 /* compare_cpu - the comparison function for sorting by cpu percentage */
1385 compare_cpu(void *arg1, void *arg2)
1387 proc_compare(void *arg1, void *arg2)
1390 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1391 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1393 ORDERKEY_PCTCPU(p1, p2);
1394 ORDERKEY_CPTICKS(p1, p2);
1395 ORDERKEY_STATE(p1, p2);
1396 ORDERKEY_PRIO(p1, p2);
1397 ORDERKEY_RSSIZE(p1, p2);
1398 ORDERKEY_MEM(p1, p2);
1404 /* "cpu" compare routines */
1405 int compare_size(), compare_res(), compare_time(), compare_prio(),
1409 * "io" compare routines. Context switches aren't i/o, but are displayed
1410 * on the "io" display.
1412 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1413 compare_vcsw(), compare_ivcsw();
1415 int (*compares[])() = {
1433 /* compare_size - the comparison function for sorting by total memory usage */
1436 compare_size(void *arg1, void *arg2)
1438 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1439 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1441 ORDERKEY_MEM(p1, p2);
1442 ORDERKEY_RSSIZE(p1, p2);
1443 ORDERKEY_PCTCPU(p1, p2);
1444 ORDERKEY_CPTICKS(p1, p2);
1445 ORDERKEY_STATE(p1, p2);
1446 ORDERKEY_PRIO(p1, p2);
1451 /* compare_res - the comparison function for sorting by resident set size */
1454 compare_res(void *arg1, void *arg2)
1456 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1457 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1459 ORDERKEY_RSSIZE(p1, p2);
1460 ORDERKEY_MEM(p1, p2);
1461 ORDERKEY_PCTCPU(p1, p2);
1462 ORDERKEY_CPTICKS(p1, p2);
1463 ORDERKEY_STATE(p1, p2);
1464 ORDERKEY_PRIO(p1, p2);
1469 /* compare_time - the comparison function for sorting by total cpu time */
1472 compare_time(void *arg1, void *arg2)
1474 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1475 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1477 ORDERKEY_CPTICKS(p1, p2);
1478 ORDERKEY_PCTCPU(p1, p2);
1479 ORDERKEY_STATE(p1, p2);
1480 ORDERKEY_PRIO(p1, p2);
1481 ORDERKEY_RSSIZE(p1, p2);
1482 ORDERKEY_MEM(p1, p2);
1487 /* compare_prio - the comparison function for sorting by priority */
1490 compare_prio(void *arg1, void *arg2)
1492 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1493 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1495 ORDERKEY_PRIO(p1, p2);
1496 ORDERKEY_CPTICKS(p1, p2);
1497 ORDERKEY_PCTCPU(p1, p2);
1498 ORDERKEY_STATE(p1, p2);
1499 ORDERKEY_RSSIZE(p1, p2);
1500 ORDERKEY_MEM(p1, p2);
1505 /* compare_threads - the comparison function for sorting by threads */
1507 compare_threads(void *arg1, void *arg2)
1509 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1510 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1512 ORDERKEY_THREADS(p1, p2);
1513 ORDERKEY_PCTCPU(p1, p2);
1514 ORDERKEY_CPTICKS(p1, p2);
1515 ORDERKEY_STATE(p1, p2);
1516 ORDERKEY_PRIO(p1, p2);
1517 ORDERKEY_RSSIZE(p1, p2);
1518 ORDERKEY_MEM(p1, p2);
1523 /* compare_jid - the comparison function for sorting by jid */
1525 compare_jid(const void *arg1, const void *arg2)
1527 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1528 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1530 ORDERKEY_JID(p1, p2);
1531 ORDERKEY_PCTCPU(p1, p2);
1532 ORDERKEY_CPTICKS(p1, p2);
1533 ORDERKEY_STATE(p1, p2);
1534 ORDERKEY_PRIO(p1, p2);
1535 ORDERKEY_RSSIZE(p1, p2);
1536 ORDERKEY_MEM(p1, p2);
1541 /* compare_swap - the comparison function for sorting by swap */
1543 compare_swap(const void *arg1, const void *arg2)
1545 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1546 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1548 ORDERKEY_SWAP(p1, p2);
1549 ORDERKEY_PCTCPU(p1, p2);
1550 ORDERKEY_CPTICKS(p1, p2);
1551 ORDERKEY_STATE(p1, p2);
1552 ORDERKEY_PRIO(p1, p2);
1553 ORDERKEY_RSSIZE(p1, p2);
1554 ORDERKEY_MEM(p1, p2);
1560 /* assorted comparison functions for sorting by i/o */
1564 compare_iototal(void *arg1, void *arg2)
1566 io_compare(void *arg1, void *arg2)
1569 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1570 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1572 return (get_io_total(p2) - get_io_total(p1));
1577 compare_ioread(void *arg1, void *arg2)
1579 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1580 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1581 long dummy, inp1, inp2;
1583 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1584 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1586 return (inp2 - inp1);
1590 compare_iowrite(void *arg1, void *arg2)
1592 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1593 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1594 long dummy, oup1, oup2;
1596 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1597 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1599 return (oup2 - oup1);
1603 compare_iofault(void *arg1, void *arg2)
1605 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1606 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1607 long dummy, flp1, flp2;
1609 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1610 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1612 return (flp2 - flp1);
1616 compare_vcsw(void *arg1, void *arg2)
1618 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1619 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1620 long dummy, flp1, flp2;
1622 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
1623 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1625 return (flp2 - flp1);
1629 compare_ivcsw(void *arg1, void *arg2)
1631 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1632 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1633 long dummy, flp1, flp2;
1635 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
1636 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1638 return (flp2 - flp1);
1643 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1644 * the process does not exist.
1645 * It is EXTREMELY IMPORTANT that this function work correctly.
1646 * If top runs setuid root (as in SVR4), then this function
1647 * is the only thing that stands in the way of a serious
1648 * security problem. It validates requests for the "kill"
1649 * and "renice" commands.
1656 struct kinfo_proc **prefp;
1657 struct kinfo_proc *pp;
1661 while (--cnt >= 0) {
1663 if (pp->ki_pid == (pid_t)pid)
1664 return ((int)pp->ki_ruid);
1670 swapmode(int *retavail, int *retfree)
1673 struct kvm_swap swapary[1];
1674 static int pagesize = 0;
1675 static u_long swap_maxpages = 0;
1680 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1682 n = kvm_getswapinfo(kd, swapary, 1, 0);
1683 if (n < 0 || swapary[0].ksw_total == 0)
1687 pagesize = getpagesize();
1688 if (swap_maxpages == 0)
1689 GETSYSCTL("vm.swap_maxpages", swap_maxpages);
1691 /* ksw_total contains the total size of swap all devices which may
1692 exceed the maximum swap size allocatable in the system */
1693 if ( swapary[0].ksw_total > swap_maxpages )
1694 swapary[0].ksw_total = swap_maxpages;
1696 *retavail = CONVERT(swapary[0].ksw_total);
1697 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1699 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);