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 */
73 static int cmdlengthdelta;
75 /* Prototypes for top internals */
78 /* get_process_info passes back a handle. This is what it looks like: */
81 struct kinfo_proc **next_proc; /* points to next valid proc pointer */
82 int remaining; /* number of pointers remaining */
85 /* declarations for load_avg */
88 /* define what weighted cpu is. */
89 #define weighted_cpu(pct, pp) ((pp)->ki_swtime == 0 ? 0.0 : \
90 ((pct) / (1.0 - exp((pp)->ki_swtime * logcpu))))
92 /* what we consider to be process size: */
93 #define PROCSIZE(pp) ((pp)->ki_size / 1024)
95 #define RU(pp) (&(pp)->ki_rusage)
97 (RU(pp)->ru_inblock + RU(pp)->ru_oublock + RU(pp)->ru_majflt)
100 /* definitions for indices in the nlist array */
103 * These definitions control the format of the per-process area
106 static char io_header[] =
107 " PID%*s %-*.*s VCSW IVCSW READ WRITE FAULT TOTAL PERCENT COMMAND";
109 #define io_Proc_format \
110 "%5d%*s %-*.*s %6ld %6ld %6ld %6ld %6ld %6ld %6.2f%% %.*s"
112 static char smp_header_thr[] =
113 " PID%*s %-*.*s THR PRI NICE SIZE RES STATE C TIME %7s COMMAND";
114 static char smp_header[] =
115 " PID%*s %-*.*s " "PRI NICE SIZE RES STATE C TIME %7s COMMAND";
117 #define smp_Proc_format \
118 "%5d%*s %-*.*s %s%3d %4s%7s %6s %-6.6s %2d%7s %6.2f%% %.*s"
120 static char up_header_thr[] =
121 " PID%*s %-*.*s THR PRI NICE SIZE RES STATE TIME %7s COMMAND";
122 static char up_header[] =
123 " PID%*s %-*.*s " "PRI NICE SIZE RES STATE TIME %7s COMMAND";
125 #define up_Proc_format \
126 "%5d%*s %-*.*s %s%3d %4s%7s %6s %-6.6s%.0d%7s %6.2f%% %.*s"
129 /* process state names for the "STATE" column of the display */
130 /* the extra nulls in the string "run" are for adding a slash and
131 the processor number when needed */
133 char *state_abbrev[] = {
134 "", "START", "RUN\0\0\0", "SLEEP", "STOP", "ZOMB", "WAIT", "LOCK"
140 /* values that we stash away in _init and use in later routines */
142 static double logcpu;
144 /* these are retrieved from the kernel in _init */
146 static load_avg ccpu;
148 /* these are used in the get_ functions */
152 /* these are for calculating cpu state percentages */
154 static long cp_time[CPUSTATES];
155 static long cp_old[CPUSTATES];
156 static long cp_diff[CPUSTATES];
158 /* these are for detailing the process states */
160 int process_states[8];
161 char *procstatenames[] = {
162 "", " starting, ", " running, ", " sleeping, ", " stopped, ",
163 " zombie, ", " waiting, ", " lock, ",
167 /* these are for detailing the cpu states */
169 int cpu_states[CPUSTATES];
170 char *cpustatenames[] = {
171 "user", "nice", "system", "interrupt", "idle", NULL
174 /* these are for detailing the memory statistics */
177 char *memorynames[] = {
178 "K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ",
184 "K Total, ", "K MFU, ", "K MRU, ", "K Anon, ", "K Header, ", "K Other",
189 char *swapnames[] = {
190 "K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out",
195 /* these are for keeping track of the proc array */
198 static int onproc = -1;
200 static struct kinfo_proc *pbase;
201 static struct kinfo_proc **pref;
202 static struct kinfo_proc *previous_procs;
203 static struct kinfo_proc **previous_pref;
204 static int previous_proc_count = 0;
205 static int previous_proc_count_max = 0;
206 static int arc_enabled;
208 /* total number of io operations */
209 static long total_inblock;
210 static long total_oublock;
211 static long total_majflt;
213 /* these are for getting the memory statistics */
215 static int pageshift; /* log base 2 of the pagesize */
217 /* define pagetok in terms of pageshift */
219 #define pagetok(size) ((size) << pageshift)
221 /* useful externals */
226 * Sorting orders. The first element is the default.
228 char *ordernames[] = {
229 "cpu", "size", "res", "time", "pri", "threads",
230 "total", "read", "write", "fault", "vcsw", "ivcsw",
235 /* Per-cpu time states */
239 static u_long cpumask;
241 static long *pcpu_cp_time;
242 static long *pcpu_cp_old;
243 static long *pcpu_cp_diff;
244 static int *pcpu_cpu_states;
246 static int compare_jid(const void *a, const void *b);
247 static int compare_pid(const void *a, const void *b);
248 static int compare_tid(const void *a, const void *b);
249 static const char *format_nice(const struct kinfo_proc *pp);
250 static void getsysctl(const char *name, void *ptr, size_t len);
251 static int swapmode(int *retavail, int *retfree);
252 static void update_layout(void);
255 toggle_pcpustats(void)
263 /* Adjust display based on ncpus and the ARC state. */
270 y_swap = 4 + arc_enabled;
271 y_idlecursor = 5 + arc_enabled;
272 y_message = 5 + arc_enabled;
273 y_header = 6 + arc_enabled;
274 y_procs = 7 + arc_enabled;
275 Header_lines = 7 + arc_enabled;
281 y_idlecursor += ncpus - 1;
282 y_message += ncpus - 1;
283 y_header += ncpus - 1;
284 y_procs += ncpus - 1;
285 Header_lines += ncpus - 1;
290 machine_init(struct statics *statics, char do_unames)
292 int i, j, empty, pagesize;
297 size = sizeof(smpmode);
298 if ((sysctlbyname("machdep.smp_active", &smpmode, &size,
300 sysctlbyname("kern.smp.active", &smpmode, &size,
302 size != sizeof(smpmode))
305 size = sizeof(arc_size);
306 if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
307 NULL, 0) == 0 && arc_size != 0)
311 while ((pw = getpwent()) != NULL) {
312 if (strlen(pw->pw_name) > namelength)
313 namelength = strlen(pw->pw_name);
316 if (smpmode && namelength > SMPUNAMELEN)
317 namelength = SMPUNAMELEN;
318 else if (namelength > UPUNAMELEN)
319 namelength = UPUNAMELEN;
321 kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
325 GETSYSCTL("kern.ccpu", ccpu);
327 /* this is used in calculating WCPU -- calculate it ahead of time */
328 logcpu = log(loaddouble(ccpu));
335 /* get the page size and calculate pageshift from it */
336 pagesize = getpagesize();
338 while (pagesize > 1) {
343 /* we only need the amount of log(2)1024 for our conversion */
344 pageshift -= LOG1024;
346 /* fill in the statics information */
347 statics->procstate_names = procstatenames;
348 statics->cpustate_names = cpustatenames;
349 statics->memory_names = memorynames;
351 statics->arc_names = arcnames;
353 statics->arc_names = NULL;
354 statics->swap_names = swapnames;
356 statics->order_names = ordernames;
359 /* Allocate state for per-CPU stats. */
362 GETSYSCTL("kern.smp.maxcpus", maxcpu);
363 size = sizeof(long) * maxcpu * CPUSTATES;
364 times = malloc(size);
366 err(1, "malloc %zd bytes", size);
367 if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
368 err(1, "sysctlbyname kern.cp_times");
369 pcpu_cp_time = calloc(1, size);
370 maxid = (size / CPUSTATES / sizeof(long)) - 1;
371 for (i = 0; i <= maxid; i++) {
373 for (j = 0; empty && j < CPUSTATES; j++) {
374 if (times[i * CPUSTATES + j] != 0)
378 cpumask |= (1ul << i);
382 size = sizeof(long) * ncpus * CPUSTATES;
383 pcpu_cp_old = calloc(1, size);
384 pcpu_cp_diff = calloc(1, size);
385 pcpu_cpu_states = calloc(1, size);
386 statics->ncpus = ncpus;
395 format_header(char *uname_field)
397 static char Header[128];
401 jidlength = TOP_JID_LEN + 1; /* +1 for extra left space. */
405 switch (displaymode) {
408 * The logic of picking the right header format seems reverse
409 * here because we only want to display a THR column when
410 * "thread mode" is off (and threads are not listed as
414 (ps.thread ? smp_header : smp_header_thr) :
415 (ps.thread ? up_header : up_header_thr);
416 snprintf(Header, sizeof(Header), prehead,
417 jidlength, ps.jail ? " JID" : "",
418 namelength, namelength, uname_field,
419 ps.wcpu ? "WCPU" : "CPU");
423 snprintf(Header, sizeof(Header), prehead,
424 jidlength, ps.jail ? " JID" : "",
425 namelength, namelength, uname_field);
428 cmdlengthdelta = strlen(Header) - 7;
432 static int swappgsin = -1;
433 static int swappgsout = -1;
434 extern struct timeval timeout;
438 get_system_info(struct system_info *si)
441 struct loadavg sysload;
443 struct timeval boottime;
444 uint64_t arc_stat, arc_stat2;
448 /* get the CPU stats */
449 size = (maxid + 1) * CPUSTATES * sizeof(long);
450 if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
451 err(1, "sysctlbyname kern.cp_times");
452 GETSYSCTL("kern.cp_time", cp_time);
453 GETSYSCTL("vm.loadavg", sysload);
454 GETSYSCTL("kern.lastpid", lastpid);
456 /* convert load averages to doubles */
457 for (i = 0; i < 3; i++)
458 si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
460 /* convert cp_time counts to percentages */
461 for (i = j = 0; i <= maxid; i++) {
462 if ((cpumask & (1ul << i)) == 0)
464 percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
465 &pcpu_cp_time[j * CPUSTATES],
466 &pcpu_cp_old[j * CPUSTATES],
467 &pcpu_cp_diff[j * CPUSTATES]);
470 percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
472 /* sum memory & swap statistics */
474 static unsigned int swap_delay = 0;
475 static int swapavail = 0;
476 static int swapfree = 0;
477 static long bufspace = 0;
478 static int nspgsin, nspgsout;
480 GETSYSCTL("vfs.bufspace", bufspace);
481 GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
482 GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
483 GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[2]);
484 GETSYSCTL("vm.stats.vm.v_cache_count", memory_stats[3]);
485 GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
486 GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
487 GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
488 /* convert memory stats to Kbytes */
489 memory_stats[0] = pagetok(memory_stats[0]);
490 memory_stats[1] = pagetok(memory_stats[1]);
491 memory_stats[2] = pagetok(memory_stats[2]);
492 memory_stats[3] = pagetok(memory_stats[3]);
493 memory_stats[4] = bufspace / 1024;
494 memory_stats[5] = pagetok(memory_stats[5]);
495 memory_stats[6] = -1;
503 /* compute differences between old and new swap statistic */
505 swap_stats[4] = pagetok(((nspgsin - swappgsin)));
506 swap_stats[5] = pagetok(((nspgsout - swappgsout)));
510 swappgsout = nspgsout;
512 /* call CPU heavy swapmode() only for changes */
513 if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
514 swap_stats[3] = swapmode(&swapavail, &swapfree);
515 swap_stats[0] = swapavail;
516 swap_stats[1] = swapavail - swapfree;
517 swap_stats[2] = swapfree;
524 GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
525 arc_stats[0] = arc_stat >> 10;
526 GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
527 arc_stats[1] = arc_stat >> 10;
528 GETSYSCTL("vfs.zfs.mru_size", arc_stat);
529 arc_stats[2] = arc_stat >> 10;
530 GETSYSCTL("vfs.zfs.anon_size", arc_stat);
531 arc_stats[3] = arc_stat >> 10;
532 GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
533 GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
534 arc_stats[4] = arc_stat + arc_stat2 >> 10;
535 GETSYSCTL("kstat.zfs.misc.arcstats.other_size", arc_stat);
536 arc_stats[5] = arc_stat >> 10;
540 /* set arrays and strings */
542 si->cpustates = pcpu_cpu_states;
545 si->cpustates = cpu_states;
548 si->memory = memory_stats;
549 si->swap = swap_stats;
553 si->last_pid = lastpid;
559 * Print how long system has been up.
560 * (Found by looking getting "boottime" from the kernel)
563 mib[1] = KERN_BOOTTIME;
564 size = sizeof(boottime);
565 if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 &&
566 boottime.tv_sec != 0) {
567 si->boottime = boottime;
569 si->boottime.tv_sec = -1;
573 #define NOPROC ((void *)-1)
576 * We need to compare data from the old process entry with the new
578 * To facilitate doing this quickly we stash a pointer in the kinfo_proc
579 * structure to cache the mapping. We also use a negative cache pointer
580 * of NOPROC to avoid duplicate lookups.
581 * XXX: this could be done when the actual processes are fetched, we do
582 * it here out of laziness.
584 const struct kinfo_proc *
585 get_old_proc(struct kinfo_proc *pp)
587 struct kinfo_proc **oldpp, *oldp;
590 * If this is the first fetch of the kinfo_procs then we don't have
591 * any previous entries.
593 if (previous_proc_count == 0)
595 /* negative cache? */
596 if (pp->ki_udata == NOPROC)
599 if (pp->ki_udata != NULL)
600 return (pp->ki_udata);
603 * 1) look up based on pid.
604 * 2) compare process start.
605 * If we fail here, then setup a negative cache entry, otherwise
608 oldpp = bsearch(&pp, previous_pref, previous_proc_count,
609 sizeof(*previous_pref), ps.thread ? compare_tid : compare_pid);
611 pp->ki_udata = NOPROC;
615 if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
616 pp->ki_udata = NOPROC;
624 * Return the total amount of IO done in blocks in/out and faults.
625 * store the values individually in the pointers passed in.
628 get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp,
629 long *vcsw, long *ivcsw)
631 const struct kinfo_proc *oldp;
632 static struct kinfo_proc dummy;
635 oldp = get_old_proc(pp);
637 bzero(&dummy, sizeof(dummy));
640 *inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
641 *oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
642 *flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
643 *vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
644 *ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
646 (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
647 (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
648 (RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
653 * Return the total number of block in/out and faults by a process.
656 get_io_total(struct kinfo_proc *pp)
660 return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
663 static struct handle handle;
666 get_process_info(struct system_info *si, struct process_select *sel,
667 int (*compare)(const void *, const void *))
672 long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
674 struct kinfo_proc **prefp;
675 struct kinfo_proc *pp;
677 /* these are copied out of sel for speed */
687 * Save the previous process info.
689 if (previous_proc_count_max < nproc) {
690 free(previous_procs);
691 previous_procs = malloc(nproc * sizeof(*previous_procs));
693 previous_pref = malloc(nproc * sizeof(*previous_pref));
694 if (previous_procs == NULL || previous_pref == NULL) {
695 (void) fprintf(stderr, "top: Out of memory.\n");
698 previous_proc_count_max = nproc;
701 for (i = 0; i < nproc; i++)
702 previous_pref[i] = &previous_procs[i];
703 bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs));
704 qsort(previous_pref, nproc, sizeof(*previous_pref),
705 ps.thread ? compare_tid : compare_pid);
707 previous_proc_count = nproc;
709 pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
712 pref = realloc(pref, sizeof(*pref) * (onproc = nproc));
713 if (pref == NULL || pbase == NULL) {
714 (void) fprintf(stderr, "top: Out of memory.\n");
717 /* get a pointer to the states summary array */
718 si->procstates = process_states;
720 /* set up flags which define what we are going to select */
721 show_idle = sel->idle;
722 show_jid = sel->jid != -1;
723 show_self = sel->self == -1;
724 show_system = sel->system;
725 show_uid = sel->uid != -1;
726 show_command = sel->command != NULL;
727 show_kidle = sel->kidle;
729 /* count up process states and get pointers to interesting procs */
735 memset((char *)process_states, 0, sizeof(process_states));
737 for (pp = pbase, i = 0; i < nproc; pp++, i++) {
739 if (pp->ki_stat == 0)
743 if (!show_self && pp->ki_pid == sel->self)
747 if (!show_system && (pp->ki_flag & P_SYSTEM))
748 /* skip system process */
751 p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
753 total_inblock += p_inblock;
754 total_oublock += p_oublock;
755 total_majflt += p_majflt;
757 process_states[pp->ki_stat]++;
759 if (pp->ki_stat == SZOMB)
763 if (!show_kidle && pp->ki_tdflags & TDF_IDLETD)
764 /* skip kernel idle process */
767 if (displaymode == DISP_CPU && !show_idle &&
768 (pp->ki_pctcpu == 0 ||
769 pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
770 /* skip idle or non-running processes */
773 if (displaymode == DISP_IO && !show_idle && p_io == 0)
774 /* skip processes that aren't doing I/O */
777 if (show_jid && pp->ki_jid != sel->jid)
778 /* skip proc. that don't belong to the selected JID */
781 if (show_uid && pp->ki_ruid != (uid_t)sel->uid)
782 /* skip proc. that don't belong to the selected UID */
789 /* if requested, sort the "interesting" processes */
791 qsort(pref, active_procs, sizeof(*pref), compare);
793 /* remember active and total counts */
794 si->p_total = total_procs;
795 si->p_active = pref_len = active_procs;
797 /* pass back a handle */
798 handle.next_proc = pref;
799 handle.remaining = active_procs;
800 return ((caddr_t)&handle);
803 static char fmt[128]; /* static area where result is built */
806 format_next_process(caddr_t handle, char *(*get_userid)(int), int flags)
808 struct kinfo_proc *pp;
809 const struct kinfo_proc *oldp;
815 struct rusage ru, *rup;
817 char *proc_fmt, thr_buf[6], jid_buf[TOP_JID_LEN + 1];
821 /* find and remember the next proc structure */
822 hp = (struct handle *)handle;
823 pp = *(hp->next_proc++);
826 /* get the process's command name */
827 if ((pp->ki_flag & P_INMEM) == 0) {
829 * Print swapped processes as <pname>
833 len = strlen(pp->ki_comm);
834 if (len > sizeof(pp->ki_comm) - 3)
835 len = sizeof(pp->ki_comm) - 3;
836 memmove(pp->ki_comm + 1, pp->ki_comm, len);
837 pp->ki_comm[0] = '<';
838 pp->ki_comm[len + 1] = '>';
839 pp->ki_comm[len + 2] = '\0';
843 * Convert the process's runtime from microseconds to seconds. This
844 * time includes the interrupt time although that is not wanted here.
845 * ps(1) is similarly sloppy.
847 cputime = (pp->ki_runtime + 500000) / 1000000;
849 /* calculate the base for cpu percentages */
850 pct = pctdouble(pp->ki_pctcpu);
852 /* generate "STATE" field */
853 switch (state = pp->ki_stat) {
855 if (smpmode && pp->ki_oncpu != 0xff)
856 sprintf(status, "CPU%d", pp->ki_oncpu);
858 strcpy(status, "RUN");
861 if (pp->ki_kiflag & KI_LOCKBLOCK) {
862 sprintf(status, "*%.6s", pp->ki_lockname);
867 if (pp->ki_wmesg != NULL) {
868 sprintf(status, "%.6s", pp->ki_wmesg);
875 state < sizeof(state_abbrev) / sizeof(*state_abbrev))
876 sprintf(status, "%.6s", state_abbrev[state]);
878 sprintf(status, "?%5d", state);
882 cmdbuf = (char *)malloc(cmdlengthdelta + 1);
883 if (cmdbuf == NULL) {
884 warn("malloc(%d)", cmdlengthdelta + 1);
888 if (!(flags & FMT_SHOWARGS)) {
889 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
891 snprintf(cmdbuf, cmdlengthdelta, "%s{%s}", pp->ki_comm,
894 snprintf(cmdbuf, cmdlengthdelta, "%s", pp->ki_comm);
897 if (pp->ki_flag & P_SYSTEM ||
898 pp->ki_args == NULL ||
899 (args = kvm_getargv(kd, pp, cmdlengthdelta)) == NULL ||
901 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
903 snprintf(cmdbuf, cmdlengthdelta,
904 "[%s{%s}]", pp->ki_comm, pp->ki_tdname);
906 snprintf(cmdbuf, cmdlengthdelta,
907 "[%s]", pp->ki_comm);
910 char *src, *dst, *argbuf;
915 argbuflen = cmdlengthdelta * 4;
916 argbuf = (char *)malloc(argbuflen + 1);
917 if (argbuf == NULL) {
918 warn("malloc(%d)", argbuflen + 1);
925 /* Extract cmd name from argv */
926 cmd = strrchr(*args, '/');
932 for (; (src = *args++) != NULL; ) {
935 len = (argbuflen - (dst - argbuf) - 1) / 4;
937 strlen(src) < len ? strlen(src) : len,
938 VIS_NL | VIS_CSTYLE);
941 if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
942 *dst++ = ' '; /* add delimiting space */
944 if (dst != argbuf && dst[-1] == ' ')
948 if (strcmp(cmd, pp->ki_comm) != 0 ) {
949 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
951 snprintf(cmdbuf, cmdlengthdelta,
952 "%s (%s){%s}", argbuf, pp->ki_comm,
955 snprintf(cmdbuf, cmdlengthdelta,
956 "%s (%s)", argbuf, pp->ki_comm);
958 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
960 snprintf(cmdbuf, cmdlengthdelta,
961 "%s{%s}", argbuf, pp->ki_tdname);
963 strlcpy(cmdbuf, argbuf, cmdlengthdelta);
972 snprintf(jid_buf, sizeof(jid_buf), "%*d",
973 jidlength - 1, pp->ki_jid);
975 if (displaymode == DISP_IO) {
976 oldp = get_old_proc(pp);
978 ru.ru_inblock = RU(pp)->ru_inblock -
979 RU(oldp)->ru_inblock;
980 ru.ru_oublock = RU(pp)->ru_oublock -
981 RU(oldp)->ru_oublock;
982 ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
983 ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
984 ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
989 p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
990 s_tot = total_inblock + total_oublock + total_majflt;
992 snprintf(fmt, sizeof(fmt), io_Proc_format,
995 namelength, namelength, (*get_userid)(pp->ki_ruid),
1002 s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
1003 screen_width > cmdlengthdelta ?
1004 screen_width - cmdlengthdelta : 0,
1012 /* format this entry */
1014 if (state == SRUN && pp->ki_oncpu != 0xff)
1017 cpu = pp->ki_lastcpu;
1020 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1024 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1025 sizeof(thr_buf) - 2, pp->ki_numthreads);
1027 snprintf(fmt, sizeof(fmt), proc_fmt,
1030 namelength, namelength, (*get_userid)(pp->ki_ruid),
1032 pp->ki_pri.pri_level - PZERO,
1034 format_k2(PROCSIZE(pp)),
1035 format_k2(pagetok(pp->ki_rssize)),
1038 format_time(cputime),
1039 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1040 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1045 /* return the result */
1050 getsysctl(const char *name, void *ptr, size_t len)
1054 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1055 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1060 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1061 name, (unsigned long)len, (unsigned long)nlen);
1067 format_nice(const struct kinfo_proc *pp)
1069 const char *fifo, *kthread;
1071 static char nicebuf[4 + 1];
1073 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1074 kthread = (pp->ki_flag & P_KTHREAD) ? "k" : "";
1075 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1080 * XXX: the kernel doesn't tell us the original rtprio and
1081 * doesn't really know what it was, so to recover it we
1082 * must be more chummy with the implementation than the
1083 * implementation is with itself. pri_user gives a
1084 * constant "base" priority, but is only initialized
1085 * properly for user threads. pri_native gives what the
1086 * kernel calls the "base" priority, but it isn't constant
1087 * since it is changed by priority propagation. pri_native
1088 * also isn't properly initialized for all threads, but it
1089 * is properly initialized for kernel realtime and idletime
1090 * threads. Thus we use pri_user for the base priority of
1091 * user threads (it is always correct) and pri_native for
1092 * the base priority of kernel realtime and idletime threads
1093 * (there is nothing better, and it is usually correct).
1095 * The field width and thus the buffer are too small for
1096 * values like "kr31F", but such values shouldn't occur,
1097 * and if they do then the tailing "F" is not displayed.
1099 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1100 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1101 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1102 kthread, rtpri, fifo);
1105 if (pp->ki_flag & P_KTHREAD)
1107 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1110 /* XXX: as above. */
1111 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1112 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1113 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1114 kthread, rtpri, fifo);
1122 /* comparison routines for qsort */
1125 compare_pid(const void *p1, const void *p2)
1127 const struct kinfo_proc * const *pp1 = p1;
1128 const struct kinfo_proc * const *pp2 = p2;
1130 if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
1133 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1137 compare_tid(const void *p1, const void *p2)
1139 const struct kinfo_proc * const *pp1 = p1;
1140 const struct kinfo_proc * const *pp2 = p2;
1142 if ((*pp2)->ki_tid < 0 || (*pp1)->ki_tid < 0)
1145 return ((*pp1)->ki_tid - (*pp2)->ki_tid);
1149 * proc_compare - comparison function for "qsort"
1150 * Compares the resource consumption of two processes using five
1151 * distinct keys. The keys (in descending order of importance) are:
1152 * percent cpu, cpu ticks, state, resident set size, total virtual
1153 * memory usage. The process states are ordered as follows (from least
1154 * to most important): WAIT, zombie, sleep, stop, start, run. The
1155 * array declaration below maps a process state index into a number
1156 * that reflects this ordering.
1159 static int sorted_state[] = {
1162 1, /* ABANDONED (WAIT) */
1170 #define ORDERKEY_PCTCPU(a, b) do { \
1173 diff = floor(1.0E6 * weighted_cpu(pctdouble((b)->ki_pctcpu), \
1175 floor(1.0E6 * weighted_cpu(pctdouble((a)->ki_pctcpu), \
1178 diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \
1180 return (diff > 0 ? 1 : -1); \
1183 #define ORDERKEY_CPTICKS(a, b) do { \
1184 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1186 return (diff > 0 ? 1 : -1); \
1189 #define ORDERKEY_STATE(a, b) do { \
1190 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1192 return (diff > 0 ? 1 : -1); \
1195 #define ORDERKEY_PRIO(a, b) do { \
1196 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1198 return (diff > 0 ? 1 : -1); \
1201 #define ORDERKEY_THREADS(a, b) do { \
1202 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1204 return (diff > 0 ? 1 : -1); \
1207 #define ORDERKEY_RSSIZE(a, b) do { \
1208 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1210 return (diff > 0 ? 1 : -1); \
1213 #define ORDERKEY_MEM(a, b) do { \
1214 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1216 return (diff > 0 ? 1 : -1); \
1219 #define ORDERKEY_JID(a, b) do { \
1220 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1222 return (diff > 0 ? 1 : -1); \
1225 /* compare_cpu - the comparison function for sorting by cpu percentage */
1229 compare_cpu(void *arg1, void *arg2)
1231 proc_compare(void *arg1, void *arg2)
1234 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1235 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1237 ORDERKEY_PCTCPU(p1, p2);
1238 ORDERKEY_CPTICKS(p1, p2);
1239 ORDERKEY_STATE(p1, p2);
1240 ORDERKEY_PRIO(p1, p2);
1241 ORDERKEY_RSSIZE(p1, p2);
1242 ORDERKEY_MEM(p1, p2);
1248 /* "cpu" compare routines */
1249 int compare_size(), compare_res(), compare_time(), compare_prio(),
1253 * "io" compare routines. Context switches aren't i/o, but are displayed
1254 * on the "io" display.
1256 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1257 compare_vcsw(), compare_ivcsw();
1259 int (*compares[])() = {
1276 /* compare_size - the comparison function for sorting by total memory usage */
1279 compare_size(void *arg1, void *arg2)
1281 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1282 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1284 ORDERKEY_MEM(p1, p2);
1285 ORDERKEY_RSSIZE(p1, p2);
1286 ORDERKEY_PCTCPU(p1, p2);
1287 ORDERKEY_CPTICKS(p1, p2);
1288 ORDERKEY_STATE(p1, p2);
1289 ORDERKEY_PRIO(p1, p2);
1294 /* compare_res - the comparison function for sorting by resident set size */
1297 compare_res(void *arg1, void *arg2)
1299 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1300 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1302 ORDERKEY_RSSIZE(p1, p2);
1303 ORDERKEY_MEM(p1, p2);
1304 ORDERKEY_PCTCPU(p1, p2);
1305 ORDERKEY_CPTICKS(p1, p2);
1306 ORDERKEY_STATE(p1, p2);
1307 ORDERKEY_PRIO(p1, p2);
1312 /* compare_time - the comparison function for sorting by total cpu time */
1315 compare_time(void *arg1, void *arg2)
1317 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1318 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1320 ORDERKEY_CPTICKS(p1, p2);
1321 ORDERKEY_PCTCPU(p1, p2);
1322 ORDERKEY_STATE(p1, p2);
1323 ORDERKEY_PRIO(p1, p2);
1324 ORDERKEY_RSSIZE(p1, p2);
1325 ORDERKEY_MEM(p1, p2);
1330 /* compare_prio - the comparison function for sorting by priority */
1333 compare_prio(void *arg1, void *arg2)
1335 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1336 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1338 ORDERKEY_PRIO(p1, p2);
1339 ORDERKEY_CPTICKS(p1, p2);
1340 ORDERKEY_PCTCPU(p1, p2);
1341 ORDERKEY_STATE(p1, p2);
1342 ORDERKEY_RSSIZE(p1, p2);
1343 ORDERKEY_MEM(p1, p2);
1348 /* compare_threads - the comparison function for sorting by threads */
1350 compare_threads(void *arg1, void *arg2)
1352 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1353 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1355 ORDERKEY_THREADS(p1, p2);
1356 ORDERKEY_PCTCPU(p1, p2);
1357 ORDERKEY_CPTICKS(p1, p2);
1358 ORDERKEY_STATE(p1, p2);
1359 ORDERKEY_PRIO(p1, p2);
1360 ORDERKEY_RSSIZE(p1, p2);
1361 ORDERKEY_MEM(p1, p2);
1366 /* compare_jid - the comparison function for sorting by jid */
1368 compare_jid(const void *arg1, const void *arg2)
1370 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1371 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1373 ORDERKEY_JID(p1, p2);
1374 ORDERKEY_PCTCPU(p1, p2);
1375 ORDERKEY_CPTICKS(p1, p2);
1376 ORDERKEY_STATE(p1, p2);
1377 ORDERKEY_PRIO(p1, p2);
1378 ORDERKEY_RSSIZE(p1, p2);
1379 ORDERKEY_MEM(p1, p2);
1385 /* assorted comparison functions for sorting by i/o */
1389 compare_iototal(void *arg1, void *arg2)
1391 io_compare(void *arg1, void *arg2)
1394 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1395 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1397 return (get_io_total(p2) - get_io_total(p1));
1402 compare_ioread(void *arg1, void *arg2)
1404 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1405 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1406 long dummy, inp1, inp2;
1408 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1409 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1411 return (inp2 - inp1);
1415 compare_iowrite(void *arg1, void *arg2)
1417 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1418 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1419 long dummy, oup1, oup2;
1421 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1422 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1424 return (oup2 - oup1);
1428 compare_iofault(void *arg1, void *arg2)
1430 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1431 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1432 long dummy, flp1, flp2;
1434 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1435 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1437 return (flp2 - flp1);
1441 compare_vcsw(void *arg1, void *arg2)
1443 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1444 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1445 long dummy, flp1, flp2;
1447 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
1448 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1450 return (flp2 - flp1);
1454 compare_ivcsw(void *arg1, void *arg2)
1456 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1457 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1458 long dummy, flp1, flp2;
1460 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
1461 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1463 return (flp2 - flp1);
1468 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1469 * the process does not exist.
1470 * It is EXTREMLY IMPORTANT that this function work correctly.
1471 * If top runs setuid root (as in SVR4), then this function
1472 * is the only thing that stands in the way of a serious
1473 * security problem. It validates requests for the "kill"
1474 * and "renice" commands.
1481 struct kinfo_proc **prefp;
1482 struct kinfo_proc *pp;
1486 while (--cnt >= 0) {
1488 if (pp->ki_pid == (pid_t)pid)
1489 return ((int)pp->ki_ruid);
1495 swapmode(int *retavail, int *retfree)
1498 int pagesize = getpagesize();
1499 struct kvm_swap swapary[1];
1504 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1506 n = kvm_getswapinfo(kd, swapary, 1, 0);
1507 if (n < 0 || swapary[0].ksw_total == 0)
1510 *retavail = CONVERT(swapary[0].ksw_total);
1511 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1513 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);