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 static int cmdlengthdelta;
72 /* Prototypes for top internals */
75 /* get_process_info passes back a handle. This is what it looks like: */
78 struct kinfo_proc **next_proc; /* points to next valid proc pointer */
79 int remaining; /* number of pointers remaining */
82 /* declarations for load_avg */
85 /* define what weighted cpu is. */
86 #define weighted_cpu(pct, pp) ((pp)->ki_swtime == 0 ? 0.0 : \
87 ((pct) / (1.0 - exp((pp)->ki_swtime * logcpu))))
89 /* what we consider to be process size: */
90 #define PROCSIZE(pp) ((pp)->ki_size / 1024)
92 #define RU(pp) (&(pp)->ki_rusage)
94 (RU(pp)->ru_inblock + RU(pp)->ru_oublock + RU(pp)->ru_majflt)
97 /* definitions for indices in the nlist array */
100 * These definitions control the format of the per-process area
103 static char io_header[] =
104 " PID%s %-*.*s VCSW IVCSW READ WRITE FAULT TOTAL PERCENT COMMAND";
106 #define io_Proc_format \
107 "%5d%s %-*.*s %6ld %6ld %6ld %6ld %6ld %6ld %6.2f%% %.*s"
109 static char smp_header_thr[] =
110 " PID%s %-*.*s THR PRI NICE SIZE RES STATE C TIME %6s COMMAND";
111 static char smp_header[] =
112 " PID%s %-*.*s " "PRI NICE SIZE RES STATE C TIME %6s COMMAND";
114 #define smp_Proc_format \
115 "%5d%s %-*.*s %s%3d %4s%7s %6s %-6.6s %2d%7s %5.2f%% %.*s"
117 static char up_header_thr[] =
118 " PID%s %-*.*s THR PRI NICE SIZE RES STATE TIME %6s COMMAND";
119 static char up_header[] =
120 " PID%s %-*.*s " "PRI NICE SIZE RES STATE TIME %6s COMMAND";
122 #define up_Proc_format \
123 "%5d%s %-*.*s %s%3d %4s%7s %6s %-6.6s%.0d%7s %5.2f%% %.*s"
126 /* process state names for the "STATE" column of the display */
127 /* the extra nulls in the string "run" are for adding a slash and
128 the processor number when needed */
130 char *state_abbrev[] = {
131 "", "START", "RUN\0\0\0", "SLEEP", "STOP", "ZOMB", "WAIT", "LOCK"
137 /* values that we stash away in _init and use in later routines */
139 static double logcpu;
141 /* these are retrieved from the kernel in _init */
143 static load_avg ccpu;
145 /* these are used in the get_ functions */
149 /* these are for calculating cpu state percentages */
151 static long cp_time[CPUSTATES];
152 static long cp_old[CPUSTATES];
153 static long cp_diff[CPUSTATES];
155 /* these are for detailing the process states */
157 int process_states[8];
158 char *procstatenames[] = {
159 "", " starting, ", " running, ", " sleeping, ", " stopped, ",
160 " zombie, ", " waiting, ", " lock, ",
164 /* these are for detailing the cpu states */
166 int cpu_states[CPUSTATES];
167 char *cpustatenames[] = {
168 "user", "nice", "system", "interrupt", "idle", NULL
171 /* these are for detailing the memory statistics */
174 char *memorynames[] = {
175 "K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ",
181 "K Total, ", "K MFU, ", "K MRU, ", "K Anon, ", "K Header, ", "K Other",
186 char *swapnames[] = {
187 "K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out",
192 /* these are for keeping track of the proc array */
195 static int onproc = -1;
197 static struct kinfo_proc *pbase;
198 static struct kinfo_proc **pref;
199 static struct kinfo_proc *previous_procs;
200 static struct kinfo_proc **previous_pref;
201 static int previous_proc_count = 0;
202 static int previous_proc_count_max = 0;
203 static int arc_enabled;
205 /* total number of io operations */
206 static long total_inblock;
207 static long total_oublock;
208 static long total_majflt;
210 /* these are for getting the memory statistics */
212 static int pageshift; /* log base 2 of the pagesize */
214 /* define pagetok in terms of pageshift */
216 #define pagetok(size) ((size) << pageshift)
218 /* useful externals */
223 * Sorting orders. The first element is the default.
225 char *ordernames[] = {
226 "cpu", "size", "res", "time", "pri", "threads",
227 "total", "read", "write", "fault", "vcsw", "ivcsw",
232 /* Per-cpu time states */
236 static u_long cpumask;
238 static long *pcpu_cp_time;
239 static long *pcpu_cp_old;
240 static long *pcpu_cp_diff;
241 static int *pcpu_cpu_states;
243 static int compare_jid(const void *a, const void *b);
244 static int compare_pid(const void *a, const void *b);
245 static int compare_tid(const void *a, const void *b);
246 static const char *format_nice(const struct kinfo_proc *pp);
247 static void getsysctl(const char *name, void *ptr, size_t len);
248 static int swapmode(int *retavail, int *retfree);
249 static void update_layout(void);
252 toggle_pcpustats(void)
260 /* Adjust display based on ncpus and the ARC state. */
267 y_swap = 4 + arc_enabled;
268 y_idlecursor = 5 + arc_enabled;
269 y_message = 5 + arc_enabled;
270 y_header = 6 + arc_enabled;
271 y_procs = 7 + arc_enabled;
272 Header_lines = 7 + arc_enabled;
278 y_idlecursor += ncpus - 1;
279 y_message += ncpus - 1;
280 y_header += ncpus - 1;
281 y_procs += ncpus - 1;
282 Header_lines += ncpus - 1;
287 machine_init(struct statics *statics, char do_unames)
289 int i, j, empty, pagesize;
294 size = sizeof(smpmode);
295 if ((sysctlbyname("machdep.smp_active", &smpmode, &size,
297 sysctlbyname("kern.smp.active", &smpmode, &size,
299 size != sizeof(smpmode))
302 size = sizeof(arc_size);
303 if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
304 NULL, 0) == 0 && arc_size != 0)
308 while ((pw = getpwent()) != NULL) {
309 if (strlen(pw->pw_name) > namelength)
310 namelength = strlen(pw->pw_name);
313 if (smpmode && namelength > SMPUNAMELEN)
314 namelength = SMPUNAMELEN;
315 else if (namelength > UPUNAMELEN)
316 namelength = UPUNAMELEN;
318 kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
322 GETSYSCTL("kern.ccpu", ccpu);
324 /* this is used in calculating WCPU -- calculate it ahead of time */
325 logcpu = log(loaddouble(ccpu));
332 /* get the page size and calculate pageshift from it */
333 pagesize = getpagesize();
335 while (pagesize > 1) {
340 /* we only need the amount of log(2)1024 for our conversion */
341 pageshift -= LOG1024;
343 /* fill in the statics information */
344 statics->procstate_names = procstatenames;
345 statics->cpustate_names = cpustatenames;
346 statics->memory_names = memorynames;
348 statics->arc_names = arcnames;
350 statics->arc_names = NULL;
351 statics->swap_names = swapnames;
353 statics->order_names = ordernames;
356 /* Allocate state for per-CPU stats. */
359 GETSYSCTL("kern.smp.maxcpus", maxcpu);
360 size = sizeof(long) * maxcpu * CPUSTATES;
361 times = malloc(size);
363 err(1, "malloc %zd bytes", size);
364 if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
365 err(1, "sysctlbyname kern.cp_times");
366 pcpu_cp_time = calloc(1, size);
367 maxid = (size / CPUSTATES / sizeof(long)) - 1;
368 for (i = 0; i <= maxid; i++) {
370 for (j = 0; empty && j < CPUSTATES; j++) {
371 if (times[i * CPUSTATES + j] != 0)
375 cpumask |= (1ul << i);
379 size = sizeof(long) * ncpus * CPUSTATES;
380 pcpu_cp_old = calloc(1, size);
381 pcpu_cp_diff = calloc(1, size);
382 pcpu_cpu_states = calloc(1, size);
383 statics->ncpus = ncpus;
392 format_header(char *uname_field)
394 static char Header[128];
397 switch (displaymode) {
400 * The logic of picking the right header format seems reverse
401 * here because we only want to display a THR column when
402 * "thread mode" is off (and threads are not listed as
406 (ps.thread ? smp_header : smp_header_thr) :
407 (ps.thread ? up_header : up_header_thr);
408 snprintf(Header, sizeof(Header), prehead,
409 ps.jail ? " JID" : "",
410 namelength, namelength, uname_field,
411 ps.wcpu ? "WCPU" : "CPU");
415 snprintf(Header, sizeof(Header), prehead,
416 ps.jail ? " JID" : "",
417 namelength, namelength, uname_field);
420 cmdlengthdelta = strlen(Header) - 7;
424 static int swappgsin = -1;
425 static int swappgsout = -1;
426 extern struct timeval timeout;
430 get_system_info(struct system_info *si)
433 struct loadavg sysload;
435 struct timeval boottime;
436 uint64_t arc_stat, arc_stat2;
440 /* get the CPU stats */
441 size = (maxid + 1) * CPUSTATES * sizeof(long);
442 if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
443 err(1, "sysctlbyname kern.cp_times");
444 GETSYSCTL("kern.cp_time", cp_time);
445 GETSYSCTL("vm.loadavg", sysload);
446 GETSYSCTL("kern.lastpid", lastpid);
448 /* convert load averages to doubles */
449 for (i = 0; i < 3; i++)
450 si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
452 /* convert cp_time counts to percentages */
453 for (i = j = 0; i <= maxid; i++) {
454 if ((cpumask & (1ul << i)) == 0)
456 percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
457 &pcpu_cp_time[j * CPUSTATES],
458 &pcpu_cp_old[j * CPUSTATES],
459 &pcpu_cp_diff[j * CPUSTATES]);
462 percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
464 /* sum memory & swap statistics */
466 static unsigned int swap_delay = 0;
467 static int swapavail = 0;
468 static int swapfree = 0;
469 static long bufspace = 0;
470 static int nspgsin, nspgsout;
472 GETSYSCTL("vfs.bufspace", bufspace);
473 GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
474 GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
475 GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[2]);
476 GETSYSCTL("vm.stats.vm.v_cache_count", memory_stats[3]);
477 GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
478 GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
479 GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
480 /* convert memory stats to Kbytes */
481 memory_stats[0] = pagetok(memory_stats[0]);
482 memory_stats[1] = pagetok(memory_stats[1]);
483 memory_stats[2] = pagetok(memory_stats[2]);
484 memory_stats[3] = pagetok(memory_stats[3]);
485 memory_stats[4] = bufspace / 1024;
486 memory_stats[5] = pagetok(memory_stats[5]);
487 memory_stats[6] = -1;
495 /* compute differences between old and new swap statistic */
497 swap_stats[4] = pagetok(((nspgsin - swappgsin)));
498 swap_stats[5] = pagetok(((nspgsout - swappgsout)));
502 swappgsout = nspgsout;
504 /* call CPU heavy swapmode() only for changes */
505 if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
506 swap_stats[3] = swapmode(&swapavail, &swapfree);
507 swap_stats[0] = swapavail;
508 swap_stats[1] = swapavail - swapfree;
509 swap_stats[2] = swapfree;
516 GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
517 arc_stats[0] = arc_stat >> 10;
518 GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
519 arc_stats[1] = arc_stat >> 10;
520 GETSYSCTL("vfs.zfs.mru_size", arc_stat);
521 arc_stats[2] = arc_stat >> 10;
522 GETSYSCTL("vfs.zfs.anon_size", arc_stat);
523 arc_stats[3] = arc_stat >> 10;
524 GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
525 GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
526 arc_stats[4] = arc_stat + arc_stat2 >> 10;
527 GETSYSCTL("kstat.zfs.misc.arcstats.other_size", arc_stat);
528 arc_stats[5] = arc_stat >> 10;
532 /* set arrays and strings */
534 si->cpustates = pcpu_cpu_states;
537 si->cpustates = cpu_states;
540 si->memory = memory_stats;
541 si->swap = swap_stats;
545 si->last_pid = lastpid;
551 * Print how long system has been up.
552 * (Found by looking getting "boottime" from the kernel)
555 mib[1] = KERN_BOOTTIME;
556 size = sizeof(boottime);
557 if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 &&
558 boottime.tv_sec != 0) {
559 si->boottime = boottime;
561 si->boottime.tv_sec = -1;
565 #define NOPROC ((void *)-1)
568 * We need to compare data from the old process entry with the new
570 * To facilitate doing this quickly we stash a pointer in the kinfo_proc
571 * structure to cache the mapping. We also use a negative cache pointer
572 * of NOPROC to avoid duplicate lookups.
573 * XXX: this could be done when the actual processes are fetched, we do
574 * it here out of laziness.
576 const struct kinfo_proc *
577 get_old_proc(struct kinfo_proc *pp)
579 struct kinfo_proc **oldpp, *oldp;
582 * If this is the first fetch of the kinfo_procs then we don't have
583 * any previous entries.
585 if (previous_proc_count == 0)
587 /* negative cache? */
588 if (pp->ki_udata == NOPROC)
591 if (pp->ki_udata != NULL)
592 return (pp->ki_udata);
595 * 1) look up based on pid.
596 * 2) compare process start.
597 * If we fail here, then setup a negative cache entry, otherwise
600 oldpp = bsearch(&pp, previous_pref, previous_proc_count,
601 sizeof(*previous_pref), ps.thread ? compare_tid : compare_pid);
603 pp->ki_udata = NOPROC;
607 if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
608 pp->ki_udata = NOPROC;
616 * Return the total amount of IO done in blocks in/out and faults.
617 * store the values individually in the pointers passed in.
620 get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp,
621 long *vcsw, long *ivcsw)
623 const struct kinfo_proc *oldp;
624 static struct kinfo_proc dummy;
627 oldp = get_old_proc(pp);
629 bzero(&dummy, sizeof(dummy));
632 *inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
633 *oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
634 *flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
635 *vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
636 *ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
638 (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
639 (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
640 (RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
645 * Return the total number of block in/out and faults by a process.
648 get_io_total(struct kinfo_proc *pp)
652 return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
655 static struct handle handle;
658 get_process_info(struct system_info *si, struct process_select *sel,
659 int (*compare)(const void *, const void *))
664 long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
666 struct kinfo_proc **prefp;
667 struct kinfo_proc *pp;
669 /* these are copied out of sel for speed */
678 * Save the previous process info.
680 if (previous_proc_count_max < nproc) {
681 free(previous_procs);
682 previous_procs = malloc(nproc * sizeof(*previous_procs));
684 previous_pref = malloc(nproc * sizeof(*previous_pref));
685 if (previous_procs == NULL || previous_pref == NULL) {
686 (void) fprintf(stderr, "top: Out of memory.\n");
689 previous_proc_count_max = nproc;
692 for (i = 0; i < nproc; i++)
693 previous_pref[i] = &previous_procs[i];
694 bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs));
695 qsort(previous_pref, nproc, sizeof(*previous_pref),
696 ps.thread ? compare_tid : compare_pid);
698 previous_proc_count = nproc;
700 pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
703 pref = realloc(pref, sizeof(*pref) * (onproc = nproc));
704 if (pref == NULL || pbase == NULL) {
705 (void) fprintf(stderr, "top: Out of memory.\n");
708 /* get a pointer to the states summary array */
709 si->procstates = process_states;
711 /* set up flags which define what we are going to select */
712 show_idle = sel->idle;
713 show_self = sel->self == -1;
714 show_system = sel->system;
715 show_uid = sel->uid != -1;
716 show_command = sel->command != NULL;
717 show_kidle = sel->kidle;
719 /* count up process states and get pointers to interesting procs */
725 memset((char *)process_states, 0, sizeof(process_states));
727 for (pp = pbase, i = 0; i < nproc; pp++, i++) {
729 if (pp->ki_stat == 0)
733 if (!show_self && pp->ki_pid == sel->self)
737 if (!show_system && (pp->ki_flag & P_SYSTEM))
738 /* skip system process */
741 p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
743 total_inblock += p_inblock;
744 total_oublock += p_oublock;
745 total_majflt += p_majflt;
747 process_states[pp->ki_stat]++;
749 if (pp->ki_stat == SZOMB)
753 if (!show_kidle && pp->ki_tdflags & TDF_IDLETD)
754 /* skip kernel idle process */
757 if (displaymode == DISP_CPU && !show_idle &&
758 (pp->ki_pctcpu == 0 ||
759 pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
760 /* skip idle or non-running processes */
763 if (displaymode == DISP_IO && !show_idle && p_io == 0)
764 /* skip processes that aren't doing I/O */
767 if (show_uid && pp->ki_ruid != (uid_t)sel->uid)
768 /* skip proc. that don't belong to the selected UID */
775 /* if requested, sort the "interesting" processes */
777 qsort(pref, active_procs, sizeof(*pref), compare);
779 /* remember active and total counts */
780 si->p_total = total_procs;
781 si->p_active = pref_len = active_procs;
783 /* pass back a handle */
784 handle.next_proc = pref;
785 handle.remaining = active_procs;
786 return ((caddr_t)&handle);
789 static char fmt[128]; /* static area where result is built */
792 format_next_process(caddr_t handle, char *(*get_userid)(int), int flags)
794 struct kinfo_proc *pp;
795 const struct kinfo_proc *oldp;
801 struct rusage ru, *rup;
803 char *proc_fmt, thr_buf[6], jid_buf[6];
807 /* find and remember the next proc structure */
808 hp = (struct handle *)handle;
809 pp = *(hp->next_proc++);
812 /* get the process's command name */
813 if ((pp->ki_flag & P_INMEM) == 0) {
815 * Print swapped processes as <pname>
819 len = strlen(pp->ki_comm);
820 if (len > sizeof(pp->ki_comm) - 3)
821 len = sizeof(pp->ki_comm) - 3;
822 memmove(pp->ki_comm + 1, pp->ki_comm, len);
823 pp->ki_comm[0] = '<';
824 pp->ki_comm[len + 1] = '>';
825 pp->ki_comm[len + 2] = '\0';
829 * Convert the process's runtime from microseconds to seconds. This
830 * time includes the interrupt time although that is not wanted here.
831 * ps(1) is similarly sloppy.
833 cputime = (pp->ki_runtime + 500000) / 1000000;
835 /* calculate the base for cpu percentages */
836 pct = pctdouble(pp->ki_pctcpu);
838 /* generate "STATE" field */
839 switch (state = pp->ki_stat) {
841 if (smpmode && pp->ki_oncpu != 0xff)
842 sprintf(status, "CPU%d", pp->ki_oncpu);
844 strcpy(status, "RUN");
847 if (pp->ki_kiflag & KI_LOCKBLOCK) {
848 sprintf(status, "*%.6s", pp->ki_lockname);
853 if (pp->ki_wmesg != NULL) {
854 sprintf(status, "%.6s", pp->ki_wmesg);
861 state < sizeof(state_abbrev) / sizeof(*state_abbrev))
862 sprintf(status, "%.6s", state_abbrev[state]);
864 sprintf(status, "?%5d", state);
868 cmdbuf = (char *)malloc(cmdlengthdelta + 1);
869 if (cmdbuf == NULL) {
870 warn("malloc(%d)", cmdlengthdelta + 1);
874 if (!(flags & FMT_SHOWARGS)) {
875 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
877 snprintf(cmdbuf, cmdlengthdelta, "%s{%s}", pp->ki_comm,
880 snprintf(cmdbuf, cmdlengthdelta, "%s", pp->ki_comm);
883 if (pp->ki_flag & P_SYSTEM ||
884 pp->ki_args == NULL ||
885 (args = kvm_getargv(kd, pp, cmdlengthdelta)) == NULL ||
887 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
889 snprintf(cmdbuf, cmdlengthdelta,
890 "[%s{%s}]", pp->ki_comm, pp->ki_tdname);
892 snprintf(cmdbuf, cmdlengthdelta,
893 "[%s]", pp->ki_comm);
896 char *src, *dst, *argbuf;
901 argbuflen = cmdlengthdelta * 4;
902 argbuf = (char *)malloc(argbuflen + 1);
903 if (argbuf == NULL) {
904 warn("malloc(%d)", argbuflen + 1);
911 /* Extract cmd name from argv */
912 cmd = strrchr(*args, '/');
918 for (; (src = *args++) != NULL; ) {
921 len = (argbuflen - (dst - argbuf) - 1) / 4;
923 strlen(src) < len ? strlen(src) : len,
924 VIS_NL | VIS_CSTYLE);
927 if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
928 *dst++ = ' '; /* add delimiting space */
930 if (dst != argbuf && dst[-1] == ' ')
934 if (strcmp(cmd, pp->ki_comm) != 0 ) {
935 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
937 snprintf(cmdbuf, cmdlengthdelta,
938 "%s (%s){%s}", argbuf, pp->ki_comm,
941 snprintf(cmdbuf, cmdlengthdelta,
942 "%s (%s)", argbuf, pp->ki_comm);
944 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
946 snprintf(cmdbuf, cmdlengthdelta,
947 "%s{%s}", argbuf, pp->ki_tdname);
949 strlcpy(cmdbuf, argbuf, cmdlengthdelta);
958 snprintf(jid_buf, sizeof(jid_buf), " %*d",
959 sizeof(jid_buf) - 3, pp->ki_jid);
961 if (displaymode == DISP_IO) {
962 oldp = get_old_proc(pp);
964 ru.ru_inblock = RU(pp)->ru_inblock -
965 RU(oldp)->ru_inblock;
966 ru.ru_oublock = RU(pp)->ru_oublock -
967 RU(oldp)->ru_oublock;
968 ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
969 ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
970 ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
975 p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
976 s_tot = total_inblock + total_oublock + total_majflt;
978 snprintf(fmt, sizeof(fmt), io_Proc_format,
981 namelength, namelength, (*get_userid)(pp->ki_ruid),
988 s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
989 screen_width > cmdlengthdelta ?
990 screen_width - cmdlengthdelta : 0,
998 /* format this entry */
1000 if (state == SRUN && pp->ki_oncpu != 0xff)
1003 cpu = pp->ki_lastcpu;
1006 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1010 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1011 sizeof(thr_buf) - 2, pp->ki_numthreads);
1013 snprintf(fmt, sizeof(fmt), proc_fmt,
1016 namelength, namelength, (*get_userid)(pp->ki_ruid),
1018 pp->ki_pri.pri_level - PZERO,
1020 format_k2(PROCSIZE(pp)),
1021 format_k2(pagetok(pp->ki_rssize)),
1024 format_time(cputime),
1025 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1026 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1031 /* return the result */
1036 getsysctl(const char *name, void *ptr, size_t len)
1040 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1041 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1046 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1047 name, (unsigned long)len, (unsigned long)nlen);
1053 format_nice(const struct kinfo_proc *pp)
1055 const char *fifo, *kthread;
1057 static char nicebuf[4 + 1];
1059 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1060 kthread = (pp->ki_flag & P_KTHREAD) ? "k" : "";
1061 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1066 * XXX: the kernel doesn't tell us the original rtprio and
1067 * doesn't really know what it was, so to recover it we
1068 * must be more chummy with the implementation than the
1069 * implementation is with itself. pri_user gives a
1070 * constant "base" priority, but is only initialized
1071 * properly for user threads. pri_native gives what the
1072 * kernel calls the "base" priority, but it isn't constant
1073 * since it is changed by priority propagation. pri_native
1074 * also isn't properly initialized for all threads, but it
1075 * is properly initialized for kernel realtime and idletime
1076 * threads. Thus we use pri_user for the base priority of
1077 * user threads (it is always correct) and pri_native for
1078 * the base priority of kernel realtime and idletime threads
1079 * (there is nothing better, and it is usually correct).
1081 * The field width and thus the buffer are too small for
1082 * values like "kr31F", but such values shouldn't occur,
1083 * and if they do then the tailing "F" is not displayed.
1085 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1086 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1087 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1088 kthread, rtpri, fifo);
1091 if (pp->ki_flag & P_KTHREAD)
1093 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1096 /* XXX: as above. */
1097 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1098 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1099 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1100 kthread, rtpri, fifo);
1108 /* comparison routines for qsort */
1111 compare_pid(const void *p1, const void *p2)
1113 const struct kinfo_proc * const *pp1 = p1;
1114 const struct kinfo_proc * const *pp2 = p2;
1116 if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
1119 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1123 compare_tid(const void *p1, const void *p2)
1125 const struct kinfo_proc * const *pp1 = p1;
1126 const struct kinfo_proc * const *pp2 = p2;
1128 if ((*pp2)->ki_tid < 0 || (*pp1)->ki_tid < 0)
1131 return ((*pp1)->ki_tid - (*pp2)->ki_tid);
1135 * proc_compare - comparison function for "qsort"
1136 * Compares the resource consumption of two processes using five
1137 * distinct keys. The keys (in descending order of importance) are:
1138 * percent cpu, cpu ticks, state, resident set size, total virtual
1139 * memory usage. The process states are ordered as follows (from least
1140 * to most important): WAIT, zombie, sleep, stop, start, run. The
1141 * array declaration below maps a process state index into a number
1142 * that reflects this ordering.
1145 static int sorted_state[] = {
1148 1, /* ABANDONED (WAIT) */
1156 #define ORDERKEY_PCTCPU(a, b) do { \
1159 diff = floor(1.0E6 * weighted_cpu(pctdouble((b)->ki_pctcpu), \
1161 floor(1.0E6 * weighted_cpu(pctdouble((a)->ki_pctcpu), \
1164 diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \
1166 return (diff > 0 ? 1 : -1); \
1169 #define ORDERKEY_CPTICKS(a, b) do { \
1170 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1172 return (diff > 0 ? 1 : -1); \
1175 #define ORDERKEY_STATE(a, b) do { \
1176 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1178 return (diff > 0 ? 1 : -1); \
1181 #define ORDERKEY_PRIO(a, b) do { \
1182 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1184 return (diff > 0 ? 1 : -1); \
1187 #define ORDERKEY_THREADS(a, b) do { \
1188 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1190 return (diff > 0 ? 1 : -1); \
1193 #define ORDERKEY_RSSIZE(a, b) do { \
1194 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1196 return (diff > 0 ? 1 : -1); \
1199 #define ORDERKEY_MEM(a, b) do { \
1200 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1202 return (diff > 0 ? 1 : -1); \
1205 #define ORDERKEY_JID(a, b) do { \
1206 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1208 return (diff > 0 ? 1 : -1); \
1211 /* compare_cpu - the comparison function for sorting by cpu percentage */
1215 compare_cpu(void *arg1, void *arg2)
1217 proc_compare(void *arg1, void *arg2)
1220 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1221 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1223 ORDERKEY_PCTCPU(p1, p2);
1224 ORDERKEY_CPTICKS(p1, p2);
1225 ORDERKEY_STATE(p1, p2);
1226 ORDERKEY_PRIO(p1, p2);
1227 ORDERKEY_RSSIZE(p1, p2);
1228 ORDERKEY_MEM(p1, p2);
1234 /* "cpu" compare routines */
1235 int compare_size(), compare_res(), compare_time(), compare_prio(),
1239 * "io" compare routines. Context switches aren't i/o, but are displayed
1240 * on the "io" display.
1242 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1243 compare_vcsw(), compare_ivcsw();
1245 int (*compares[])() = {
1262 /* compare_size - the comparison function for sorting by total memory usage */
1265 compare_size(void *arg1, void *arg2)
1267 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1268 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1270 ORDERKEY_MEM(p1, p2);
1271 ORDERKEY_RSSIZE(p1, p2);
1272 ORDERKEY_PCTCPU(p1, p2);
1273 ORDERKEY_CPTICKS(p1, p2);
1274 ORDERKEY_STATE(p1, p2);
1275 ORDERKEY_PRIO(p1, p2);
1280 /* compare_res - the comparison function for sorting by resident set size */
1283 compare_res(void *arg1, void *arg2)
1285 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1286 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1288 ORDERKEY_RSSIZE(p1, p2);
1289 ORDERKEY_MEM(p1, p2);
1290 ORDERKEY_PCTCPU(p1, p2);
1291 ORDERKEY_CPTICKS(p1, p2);
1292 ORDERKEY_STATE(p1, p2);
1293 ORDERKEY_PRIO(p1, p2);
1298 /* compare_time - the comparison function for sorting by total cpu time */
1301 compare_time(void *arg1, void *arg2)
1303 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1304 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1306 ORDERKEY_CPTICKS(p1, p2);
1307 ORDERKEY_PCTCPU(p1, p2);
1308 ORDERKEY_STATE(p1, p2);
1309 ORDERKEY_PRIO(p1, p2);
1310 ORDERKEY_RSSIZE(p1, p2);
1311 ORDERKEY_MEM(p1, p2);
1316 /* compare_prio - the comparison function for sorting by priority */
1319 compare_prio(void *arg1, void *arg2)
1321 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1322 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1324 ORDERKEY_PRIO(p1, p2);
1325 ORDERKEY_CPTICKS(p1, p2);
1326 ORDERKEY_PCTCPU(p1, p2);
1327 ORDERKEY_STATE(p1, p2);
1328 ORDERKEY_RSSIZE(p1, p2);
1329 ORDERKEY_MEM(p1, p2);
1334 /* compare_threads - the comparison function for sorting by threads */
1336 compare_threads(void *arg1, void *arg2)
1338 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1339 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1341 ORDERKEY_THREADS(p1, p2);
1342 ORDERKEY_PCTCPU(p1, p2);
1343 ORDERKEY_CPTICKS(p1, p2);
1344 ORDERKEY_STATE(p1, p2);
1345 ORDERKEY_PRIO(p1, p2);
1346 ORDERKEY_RSSIZE(p1, p2);
1347 ORDERKEY_MEM(p1, p2);
1352 /* compare_jid - the comparison function for sorting by jid */
1354 compare_jid(const void *arg1, const void *arg2)
1356 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1357 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1359 ORDERKEY_JID(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);
1371 /* assorted comparison functions for sorting by i/o */
1375 compare_iototal(void *arg1, void *arg2)
1377 io_compare(void *arg1, void *arg2)
1380 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1381 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1383 return (get_io_total(p2) - get_io_total(p1));
1388 compare_ioread(void *arg1, void *arg2)
1390 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1391 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1392 long dummy, inp1, inp2;
1394 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1395 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1397 return (inp2 - inp1);
1401 compare_iowrite(void *arg1, void *arg2)
1403 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1404 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1405 long dummy, oup1, oup2;
1407 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1408 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1410 return (oup2 - oup1);
1414 compare_iofault(void *arg1, void *arg2)
1416 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1417 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1418 long dummy, flp1, flp2;
1420 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1421 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1423 return (flp2 - flp1);
1427 compare_vcsw(void *arg1, void *arg2)
1429 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1430 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1431 long dummy, flp1, flp2;
1433 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
1434 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1436 return (flp2 - flp1);
1440 compare_ivcsw(void *arg1, void *arg2)
1442 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1443 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1444 long dummy, flp1, flp2;
1446 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
1447 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1449 return (flp2 - flp1);
1454 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1455 * the process does not exist.
1456 * It is EXTREMLY IMPORTANT that this function work correctly.
1457 * If top runs setuid root (as in SVR4), then this function
1458 * is the only thing that stands in the way of a serious
1459 * security problem. It validates requests for the "kill"
1460 * and "renice" commands.
1467 struct kinfo_proc **prefp;
1468 struct kinfo_proc *pp;
1472 while (--cnt >= 0) {
1474 if (pp->ki_pid == (pid_t)pid)
1475 return ((int)pp->ki_ruid);
1481 swapmode(int *retavail, int *retfree)
1484 int pagesize = getpagesize();
1485 struct kvm_swap swapary[1];
1490 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1492 n = kvm_getswapinfo(kd, swapary, 1, 0);
1493 if (n < 0 || swapary[0].ksw_total == 0)
1496 *retavail = CONVERT(swapary[0].ksw_total);
1497 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1499 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);