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 %zu 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, nitems(mib), &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[512]; /* 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];
820 const int cmdlen = 128;
822 /* find and remember the next proc structure */
823 hp = (struct handle *)handle;
824 pp = *(hp->next_proc++);
827 /* get the process's command name */
828 if ((pp->ki_flag & P_INMEM) == 0) {
830 * Print swapped processes as <pname>
834 len = strlen(pp->ki_comm);
835 if (len > sizeof(pp->ki_comm) - 3)
836 len = sizeof(pp->ki_comm) - 3;
837 memmove(pp->ki_comm + 1, pp->ki_comm, len);
838 pp->ki_comm[0] = '<';
839 pp->ki_comm[len + 1] = '>';
840 pp->ki_comm[len + 2] = '\0';
844 * Convert the process's runtime from microseconds to seconds. This
845 * time includes the interrupt time although that is not wanted here.
846 * ps(1) is similarly sloppy.
848 cputime = (pp->ki_runtime + 500000) / 1000000;
850 /* calculate the base for cpu percentages */
851 pct = pctdouble(pp->ki_pctcpu);
853 /* generate "STATE" field */
854 switch (state = pp->ki_stat) {
856 if (smpmode && pp->ki_oncpu != 0xff)
857 sprintf(status, "CPU%d", pp->ki_oncpu);
859 strcpy(status, "RUN");
862 if (pp->ki_kiflag & KI_LOCKBLOCK) {
863 sprintf(status, "*%.6s", pp->ki_lockname);
868 if (pp->ki_wmesg != NULL) {
869 sprintf(status, "%.6s", pp->ki_wmesg);
876 state < sizeof(state_abbrev) / sizeof(*state_abbrev))
877 sprintf(status, "%.6s", state_abbrev[state]);
879 sprintf(status, "?%5d", state);
883 cmdbuf = (char *)malloc(cmdlen + 1);
884 if (cmdbuf == NULL) {
885 warn("malloc(%d)", cmdlen + 1);
889 if (!(flags & FMT_SHOWARGS)) {
890 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
892 snprintf(cmdbuf, cmdlen, "%s{%s%s}", pp->ki_comm,
893 pp->ki_tdname, pp->ki_moretdname);
895 snprintf(cmdbuf, cmdlen, "%s", pp->ki_comm);
898 if (pp->ki_flag & P_SYSTEM ||
899 pp->ki_args == NULL ||
900 (args = kvm_getargv(kd, pp, cmdlen)) == NULL ||
902 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
904 snprintf(cmdbuf, cmdlen,
905 "[%s{%s%s}]", pp->ki_comm, pp->ki_tdname,
908 snprintf(cmdbuf, cmdlen,
909 "[%s]", pp->ki_comm);
912 char *src, *dst, *argbuf;
917 argbuflen = cmdlen * 4;
918 argbuf = (char *)malloc(argbuflen + 1);
919 if (argbuf == NULL) {
920 warn("malloc(%zu)", argbuflen + 1);
927 /* Extract cmd name from argv */
928 cmd = strrchr(*args, '/');
934 for (; (src = *args++) != NULL; ) {
937 len = (argbuflen - (dst - argbuf) - 1) / 4;
939 strlen(src) < len ? strlen(src) : len,
940 VIS_NL | VIS_CSTYLE);
943 if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
944 *dst++ = ' '; /* add delimiting space */
946 if (dst != argbuf && dst[-1] == ' ')
950 if (strcmp(cmd, pp->ki_comm) != 0) {
951 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
953 snprintf(cmdbuf, cmdlen,
954 "%s (%s){%s%s}", argbuf,
955 pp->ki_comm, pp->ki_tdname,
958 snprintf(cmdbuf, cmdlen,
959 "%s (%s)", argbuf, pp->ki_comm);
961 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
963 snprintf(cmdbuf, cmdlen,
964 "%s{%s%s}", argbuf, pp->ki_tdname,
967 strlcpy(cmdbuf, argbuf, cmdlen);
976 snprintf(jid_buf, sizeof(jid_buf), "%*d",
977 jidlength - 1, pp->ki_jid);
979 if (displaymode == DISP_IO) {
980 oldp = get_old_proc(pp);
982 ru.ru_inblock = RU(pp)->ru_inblock -
983 RU(oldp)->ru_inblock;
984 ru.ru_oublock = RU(pp)->ru_oublock -
985 RU(oldp)->ru_oublock;
986 ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
987 ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
988 ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
993 p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
994 s_tot = total_inblock + total_oublock + total_majflt;
996 snprintf(fmt, sizeof(fmt), io_Proc_format,
999 namelength, namelength, (*get_userid)(pp->ki_ruid),
1006 s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
1007 screen_width > cmdlengthdelta ?
1008 screen_width - cmdlengthdelta : 0,
1016 /* format this entry */
1018 if (state == SRUN && pp->ki_oncpu != 0xff)
1021 cpu = pp->ki_lastcpu;
1024 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1028 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1029 (int)(sizeof(thr_buf) - 2), pp->ki_numthreads);
1031 snprintf(fmt, sizeof(fmt), proc_fmt,
1034 namelength, namelength, (*get_userid)(pp->ki_ruid),
1036 pp->ki_pri.pri_level - PZERO,
1038 format_k2(PROCSIZE(pp)),
1039 format_k2(pagetok(pp->ki_rssize)),
1042 format_time(cputime),
1043 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1044 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1049 /* return the result */
1054 getsysctl(const char *name, void *ptr, size_t len)
1058 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1059 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1064 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1065 name, (unsigned long)len, (unsigned long)nlen);
1071 format_nice(const struct kinfo_proc *pp)
1073 const char *fifo, *kthread;
1075 static char nicebuf[4 + 1];
1077 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1078 kthread = (pp->ki_flag & P_KTHREAD) ? "k" : "";
1079 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1084 * XXX: the kernel doesn't tell us the original rtprio and
1085 * doesn't really know what it was, so to recover it we
1086 * must be more chummy with the implementation than the
1087 * implementation is with itself. pri_user gives a
1088 * constant "base" priority, but is only initialized
1089 * properly for user threads. pri_native gives what the
1090 * kernel calls the "base" priority, but it isn't constant
1091 * since it is changed by priority propagation. pri_native
1092 * also isn't properly initialized for all threads, but it
1093 * is properly initialized for kernel realtime and idletime
1094 * threads. Thus we use pri_user for the base priority of
1095 * user threads (it is always correct) and pri_native for
1096 * the base priority of kernel realtime and idletime threads
1097 * (there is nothing better, and it is usually correct).
1099 * The field width and thus the buffer are too small for
1100 * values like "kr31F", but such values shouldn't occur,
1101 * and if they do then the tailing "F" is not displayed.
1103 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1104 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1105 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1106 kthread, rtpri, fifo);
1109 if (pp->ki_flag & P_KTHREAD)
1111 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1114 /* XXX: as above. */
1115 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1116 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1117 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1118 kthread, rtpri, fifo);
1126 /* comparison routines for qsort */
1129 compare_pid(const void *p1, const void *p2)
1131 const struct kinfo_proc * const *pp1 = p1;
1132 const struct kinfo_proc * const *pp2 = p2;
1134 if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
1137 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1141 compare_tid(const void *p1, const void *p2)
1143 const struct kinfo_proc * const *pp1 = p1;
1144 const struct kinfo_proc * const *pp2 = p2;
1146 if ((*pp2)->ki_tid < 0 || (*pp1)->ki_tid < 0)
1149 return ((*pp1)->ki_tid - (*pp2)->ki_tid);
1153 * proc_compare - comparison function for "qsort"
1154 * Compares the resource consumption of two processes using five
1155 * distinct keys. The keys (in descending order of importance) are:
1156 * percent cpu, cpu ticks, state, resident set size, total virtual
1157 * memory usage. The process states are ordered as follows (from least
1158 * to most important): WAIT, zombie, sleep, stop, start, run. The
1159 * array declaration below maps a process state index into a number
1160 * that reflects this ordering.
1163 static int sorted_state[] = {
1166 1, /* ABANDONED (WAIT) */
1174 #define ORDERKEY_PCTCPU(a, b) do { \
1177 diff = floor(1.0E6 * weighted_cpu(pctdouble((b)->ki_pctcpu), \
1179 floor(1.0E6 * weighted_cpu(pctdouble((a)->ki_pctcpu), \
1182 diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \
1184 return (diff > 0 ? 1 : -1); \
1187 #define ORDERKEY_CPTICKS(a, b) do { \
1188 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1190 return (diff > 0 ? 1 : -1); \
1193 #define ORDERKEY_STATE(a, b) do { \
1194 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1196 return (diff > 0 ? 1 : -1); \
1199 #define ORDERKEY_PRIO(a, b) do { \
1200 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1202 return (diff > 0 ? 1 : -1); \
1205 #define ORDERKEY_THREADS(a, b) do { \
1206 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1208 return (diff > 0 ? 1 : -1); \
1211 #define ORDERKEY_RSSIZE(a, b) do { \
1212 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1214 return (diff > 0 ? 1 : -1); \
1217 #define ORDERKEY_MEM(a, b) do { \
1218 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1220 return (diff > 0 ? 1 : -1); \
1223 #define ORDERKEY_JID(a, b) do { \
1224 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1226 return (diff > 0 ? 1 : -1); \
1229 /* compare_cpu - the comparison function for sorting by cpu percentage */
1233 compare_cpu(void *arg1, void *arg2)
1235 proc_compare(void *arg1, void *arg2)
1238 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1239 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1241 ORDERKEY_PCTCPU(p1, p2);
1242 ORDERKEY_CPTICKS(p1, p2);
1243 ORDERKEY_STATE(p1, p2);
1244 ORDERKEY_PRIO(p1, p2);
1245 ORDERKEY_RSSIZE(p1, p2);
1246 ORDERKEY_MEM(p1, p2);
1252 /* "cpu" compare routines */
1253 int compare_size(), compare_res(), compare_time(), compare_prio(),
1257 * "io" compare routines. Context switches aren't i/o, but are displayed
1258 * on the "io" display.
1260 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1261 compare_vcsw(), compare_ivcsw();
1263 int (*compares[])() = {
1280 /* compare_size - the comparison function for sorting by total memory usage */
1283 compare_size(void *arg1, void *arg2)
1285 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1286 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1288 ORDERKEY_MEM(p1, p2);
1289 ORDERKEY_RSSIZE(p1, p2);
1290 ORDERKEY_PCTCPU(p1, p2);
1291 ORDERKEY_CPTICKS(p1, p2);
1292 ORDERKEY_STATE(p1, p2);
1293 ORDERKEY_PRIO(p1, p2);
1298 /* compare_res - the comparison function for sorting by resident set size */
1301 compare_res(void *arg1, void *arg2)
1303 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1304 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1306 ORDERKEY_RSSIZE(p1, p2);
1307 ORDERKEY_MEM(p1, p2);
1308 ORDERKEY_PCTCPU(p1, p2);
1309 ORDERKEY_CPTICKS(p1, p2);
1310 ORDERKEY_STATE(p1, p2);
1311 ORDERKEY_PRIO(p1, p2);
1316 /* compare_time - the comparison function for sorting by total cpu time */
1319 compare_time(void *arg1, void *arg2)
1321 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1322 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1324 ORDERKEY_CPTICKS(p1, p2);
1325 ORDERKEY_PCTCPU(p1, p2);
1326 ORDERKEY_STATE(p1, p2);
1327 ORDERKEY_PRIO(p1, p2);
1328 ORDERKEY_RSSIZE(p1, p2);
1329 ORDERKEY_MEM(p1, p2);
1334 /* compare_prio - the comparison function for sorting by priority */
1337 compare_prio(void *arg1, void *arg2)
1339 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1340 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1342 ORDERKEY_PRIO(p1, p2);
1343 ORDERKEY_CPTICKS(p1, p2);
1344 ORDERKEY_PCTCPU(p1, p2);
1345 ORDERKEY_STATE(p1, p2);
1346 ORDERKEY_RSSIZE(p1, p2);
1347 ORDERKEY_MEM(p1, p2);
1352 /* compare_threads - the comparison function for sorting by threads */
1354 compare_threads(void *arg1, void *arg2)
1356 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1357 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1359 ORDERKEY_THREADS(p1, p2);
1360 ORDERKEY_PCTCPU(p1, p2);
1361 ORDERKEY_CPTICKS(p1, p2);
1362 ORDERKEY_STATE(p1, p2);
1363 ORDERKEY_PRIO(p1, p2);
1364 ORDERKEY_RSSIZE(p1, p2);
1365 ORDERKEY_MEM(p1, p2);
1370 /* compare_jid - the comparison function for sorting by jid */
1372 compare_jid(const void *arg1, const void *arg2)
1374 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1375 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1377 ORDERKEY_JID(p1, p2);
1378 ORDERKEY_PCTCPU(p1, p2);
1379 ORDERKEY_CPTICKS(p1, p2);
1380 ORDERKEY_STATE(p1, p2);
1381 ORDERKEY_PRIO(p1, p2);
1382 ORDERKEY_RSSIZE(p1, p2);
1383 ORDERKEY_MEM(p1, p2);
1389 /* assorted comparison functions for sorting by i/o */
1393 compare_iototal(void *arg1, void *arg2)
1395 io_compare(void *arg1, void *arg2)
1398 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1399 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1401 return (get_io_total(p2) - get_io_total(p1));
1406 compare_ioread(void *arg1, void *arg2)
1408 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1409 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1410 long dummy, inp1, inp2;
1412 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1413 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1415 return (inp2 - inp1);
1419 compare_iowrite(void *arg1, void *arg2)
1421 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1422 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1423 long dummy, oup1, oup2;
1425 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1426 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1428 return (oup2 - oup1);
1432 compare_iofault(void *arg1, void *arg2)
1434 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1435 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1436 long dummy, flp1, flp2;
1438 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1439 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1441 return (flp2 - flp1);
1445 compare_vcsw(void *arg1, void *arg2)
1447 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1448 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1449 long dummy, flp1, flp2;
1451 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
1452 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1454 return (flp2 - flp1);
1458 compare_ivcsw(void *arg1, void *arg2)
1460 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1461 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1462 long dummy, flp1, flp2;
1464 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
1465 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1467 return (flp2 - flp1);
1472 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1473 * the process does not exist.
1474 * It is EXTREMELY IMPORTANT that this function work correctly.
1475 * If top runs setuid root (as in SVR4), then this function
1476 * is the only thing that stands in the way of a serious
1477 * security problem. It validates requests for the "kill"
1478 * and "renice" commands.
1485 struct kinfo_proc **prefp;
1486 struct kinfo_proc *pp;
1490 while (--cnt >= 0) {
1492 if (pp->ki_pid == (pid_t)pid)
1493 return ((int)pp->ki_ruid);
1499 swapmode(int *retavail, int *retfree)
1502 int pagesize = getpagesize();
1503 struct kvm_swap swapary[1];
1508 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1510 n = kvm_getswapinfo(kd, swapary, 1, 0);
1511 if (n < 0 || swapary[0].ksw_total == 0)
1514 *retavail = CONVERT(swapary[0].ksw_total);
1515 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1517 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);