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 const char *format_nice(const struct kinfo_proc *pp);
246 static void getsysctl(const char *name, void *ptr, size_t len);
247 static int swapmode(int *retavail, int *retfree);
248 static void update_layout(void);
251 toggle_pcpustats(void)
259 /* Adjust display based on ncpus and the ARC state. */
266 y_swap = 4 + arc_enabled;
267 y_idlecursor = 5 + arc_enabled;
268 y_message = 5 + arc_enabled;
269 y_header = 6 + arc_enabled;
270 y_procs = 7 + arc_enabled;
271 Header_lines = 7 + arc_enabled;
277 y_idlecursor += ncpus - 1;
278 y_message += ncpus - 1;
279 y_header += ncpus - 1;
280 y_procs += ncpus - 1;
281 Header_lines += ncpus - 1;
286 machine_init(struct statics *statics, char do_unames)
288 int i, j, empty, pagesize;
293 size = sizeof(smpmode);
294 if ((sysctlbyname("machdep.smp_active", &smpmode, &size,
296 sysctlbyname("kern.smp.active", &smpmode, &size,
298 size != sizeof(smpmode))
301 size = sizeof(arc_size);
302 if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
303 NULL, 0) == 0 && arc_size != 0)
307 while ((pw = getpwent()) != NULL) {
308 if (strlen(pw->pw_name) > namelength)
309 namelength = strlen(pw->pw_name);
312 if (smpmode && namelength > SMPUNAMELEN)
313 namelength = SMPUNAMELEN;
314 else if (namelength > UPUNAMELEN)
315 namelength = UPUNAMELEN;
317 kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
321 GETSYSCTL("kern.ccpu", ccpu);
323 /* this is used in calculating WCPU -- calculate it ahead of time */
324 logcpu = log(loaddouble(ccpu));
331 /* get the page size and calculate pageshift from it */
332 pagesize = getpagesize();
334 while (pagesize > 1) {
339 /* we only need the amount of log(2)1024 for our conversion */
340 pageshift -= LOG1024;
342 /* fill in the statics information */
343 statics->procstate_names = procstatenames;
344 statics->cpustate_names = cpustatenames;
345 statics->memory_names = memorynames;
347 statics->arc_names = arcnames;
349 statics->arc_names = NULL;
350 statics->swap_names = swapnames;
352 statics->order_names = ordernames;
355 /* Allocate state for per-CPU stats. */
358 GETSYSCTL("kern.smp.maxcpus", maxcpu);
359 size = sizeof(long) * maxcpu * CPUSTATES;
360 times = malloc(size);
362 err(1, "malloc %zd bytes", size);
363 if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
364 err(1, "sysctlbyname kern.cp_times");
365 pcpu_cp_time = calloc(1, size);
366 maxid = (size / CPUSTATES / sizeof(long)) - 1;
367 for (i = 0; i <= maxid; i++) {
369 for (j = 0; empty && j < CPUSTATES; j++) {
370 if (times[i * CPUSTATES + j] != 0)
374 cpumask |= (1ul << i);
378 size = sizeof(long) * ncpus * CPUSTATES;
379 pcpu_cp_old = calloc(1, size);
380 pcpu_cp_diff = calloc(1, size);
381 pcpu_cpu_states = calloc(1, size);
382 statics->ncpus = ncpus;
391 format_header(char *uname_field)
393 static char Header[128];
396 switch (displaymode) {
399 * The logic of picking the right header format seems reverse
400 * here because we only want to display a THR column when
401 * "thread mode" is off (and threads are not listed as
405 (ps.thread ? smp_header : smp_header_thr) :
406 (ps.thread ? up_header : up_header_thr);
407 snprintf(Header, sizeof(Header), prehead,
408 ps.jail ? " JID" : "",
409 namelength, namelength, uname_field,
410 ps.wcpu ? "WCPU" : "CPU");
414 snprintf(Header, sizeof(Header), prehead,
415 ps.jail ? " JID" : "",
416 namelength, namelength, uname_field);
419 cmdlengthdelta = strlen(Header) - 7;
423 static int swappgsin = -1;
424 static int swappgsout = -1;
425 extern struct timeval timeout;
429 get_system_info(struct system_info *si)
432 struct loadavg sysload;
434 struct timeval boottime;
435 uint64_t arc_stat, arc_stat2;
439 /* get the CPU stats */
440 size = (maxid + 1) * CPUSTATES * sizeof(long);
441 if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
442 err(1, "sysctlbyname kern.cp_times");
443 GETSYSCTL("kern.cp_time", cp_time);
444 GETSYSCTL("vm.loadavg", sysload);
445 GETSYSCTL("kern.lastpid", lastpid);
447 /* convert load averages to doubles */
448 for (i = 0; i < 3; i++)
449 si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
451 /* convert cp_time counts to percentages */
452 for (i = j = 0; i <= maxid; i++) {
453 if ((cpumask & (1ul << i)) == 0)
455 percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
456 &pcpu_cp_time[j * CPUSTATES],
457 &pcpu_cp_old[j * CPUSTATES],
458 &pcpu_cp_diff[j * CPUSTATES]);
461 percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
463 /* sum memory & swap statistics */
465 static unsigned int swap_delay = 0;
466 static int swapavail = 0;
467 static int swapfree = 0;
468 static long bufspace = 0;
469 static int nspgsin, nspgsout;
471 GETSYSCTL("vfs.bufspace", bufspace);
472 GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
473 GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
474 GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[2]);
475 GETSYSCTL("vm.stats.vm.v_cache_count", memory_stats[3]);
476 GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
477 GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
478 GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
479 /* convert memory stats to Kbytes */
480 memory_stats[0] = pagetok(memory_stats[0]);
481 memory_stats[1] = pagetok(memory_stats[1]);
482 memory_stats[2] = pagetok(memory_stats[2]);
483 memory_stats[3] = pagetok(memory_stats[3]);
484 memory_stats[4] = bufspace / 1024;
485 memory_stats[5] = pagetok(memory_stats[5]);
486 memory_stats[6] = -1;
494 /* compute differences between old and new swap statistic */
496 swap_stats[4] = pagetok(((nspgsin - swappgsin)));
497 swap_stats[5] = pagetok(((nspgsout - swappgsout)));
501 swappgsout = nspgsout;
503 /* call CPU heavy swapmode() only for changes */
504 if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
505 swap_stats[3] = swapmode(&swapavail, &swapfree);
506 swap_stats[0] = swapavail;
507 swap_stats[1] = swapavail - swapfree;
508 swap_stats[2] = swapfree;
515 GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
516 arc_stats[0] = arc_stat >> 10;
517 GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
518 arc_stats[1] = arc_stat >> 10;
519 GETSYSCTL("vfs.zfs.mru_size", arc_stat);
520 arc_stats[2] = arc_stat >> 10;
521 GETSYSCTL("vfs.zfs.anon_size", arc_stat);
522 arc_stats[3] = arc_stat >> 10;
523 GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
524 GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
525 arc_stats[4] = arc_stat + arc_stat2 >> 10;
526 GETSYSCTL("kstat.zfs.misc.arcstats.other_size", arc_stat);
527 arc_stats[5] = arc_stat >> 10;
531 /* set arrays and strings */
533 si->cpustates = pcpu_cpu_states;
536 si->cpustates = cpu_states;
539 si->memory = memory_stats;
540 si->swap = swap_stats;
544 si->last_pid = lastpid;
550 * Print how long system has been up.
551 * (Found by looking getting "boottime" from the kernel)
554 mib[1] = KERN_BOOTTIME;
555 size = sizeof(boottime);
556 if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 &&
557 boottime.tv_sec != 0) {
558 si->boottime = boottime;
560 si->boottime.tv_sec = -1;
564 #define NOPROC ((void *)-1)
567 * We need to compare data from the old process entry with the new
569 * To facilitate doing this quickly we stash a pointer in the kinfo_proc
570 * structure to cache the mapping. We also use a negative cache pointer
571 * of NOPROC to avoid duplicate lookups.
572 * XXX: this could be done when the actual processes are fetched, we do
573 * it here out of laziness.
575 const struct kinfo_proc *
576 get_old_proc(struct kinfo_proc *pp)
578 struct kinfo_proc **oldpp, *oldp;
581 * If this is the first fetch of the kinfo_procs then we don't have
582 * any previous entries.
584 if (previous_proc_count == 0)
586 /* negative cache? */
587 if (pp->ki_udata == NOPROC)
590 if (pp->ki_udata != NULL)
591 return (pp->ki_udata);
594 * 1) look up based on pid.
595 * 2) compare process start.
596 * If we fail here, then setup a negative cache entry, otherwise
599 oldpp = bsearch(&pp, previous_pref, previous_proc_count,
600 sizeof(*previous_pref), compare_pid);
602 pp->ki_udata = NOPROC;
606 if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
607 pp->ki_udata = NOPROC;
615 * Return the total amount of IO done in blocks in/out and faults.
616 * store the values individually in the pointers passed in.
619 get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp,
620 long *vcsw, long *ivcsw)
622 const struct kinfo_proc *oldp;
623 static struct kinfo_proc dummy;
626 oldp = get_old_proc(pp);
628 bzero(&dummy, sizeof(dummy));
631 *inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
632 *oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
633 *flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
634 *vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
635 *ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
637 (RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
638 (RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
639 (RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
644 * Return the total number of block in/out and faults by a process.
647 get_io_total(struct kinfo_proc *pp)
651 return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
654 static struct handle handle;
657 get_process_info(struct system_info *si, struct process_select *sel,
658 int (*compare)(const void *, const void *))
663 long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
665 struct kinfo_proc **prefp;
666 struct kinfo_proc *pp;
668 /* these are copied out of sel for speed */
677 * Save the previous process info.
679 if (previous_proc_count_max < nproc) {
680 free(previous_procs);
681 previous_procs = malloc(nproc * sizeof(*previous_procs));
683 previous_pref = malloc(nproc * sizeof(*previous_pref));
684 if (previous_procs == NULL || previous_pref == NULL) {
685 (void) fprintf(stderr, "top: Out of memory.\n");
688 previous_proc_count_max = nproc;
691 for (i = 0; i < nproc; i++)
692 previous_pref[i] = &previous_procs[i];
693 bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs));
694 qsort(previous_pref, nproc, sizeof(*previous_pref),
697 previous_proc_count = nproc;
699 pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
702 pref = realloc(pref, sizeof(*pref) * (onproc = nproc));
703 if (pref == NULL || pbase == NULL) {
704 (void) fprintf(stderr, "top: Out of memory.\n");
707 /* get a pointer to the states summary array */
708 si->procstates = process_states;
710 /* set up flags which define what we are going to select */
711 show_idle = sel->idle;
712 show_self = sel->self == -1;
713 show_system = sel->system;
714 show_uid = sel->uid != -1;
715 show_command = sel->command != NULL;
716 show_kidle = sel->kidle;
718 /* count up process states and get pointers to interesting procs */
724 memset((char *)process_states, 0, sizeof(process_states));
726 for (pp = pbase, i = 0; i < nproc; pp++, i++) {
728 if (pp->ki_stat == 0)
732 if (!show_self && pp->ki_pid == sel->self)
736 if (!show_system && (pp->ki_flag & P_SYSTEM))
737 /* skip system process */
740 p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
742 total_inblock += p_inblock;
743 total_oublock += p_oublock;
744 total_majflt += p_majflt;
746 process_states[pp->ki_stat]++;
748 if (pp->ki_stat == SZOMB)
752 if (!show_kidle && pp->ki_tdflags & TDF_IDLETD)
753 /* skip kernel idle process */
756 if (displaymode == DISP_CPU && !show_idle &&
757 (pp->ki_pctcpu == 0 ||
758 pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
759 /* skip idle or non-running processes */
762 if (displaymode == DISP_IO && !show_idle && p_io == 0)
763 /* skip processes that aren't doing I/O */
766 if (show_uid && pp->ki_ruid != (uid_t)sel->uid)
767 /* skip proc. that don't belong to the selected UID */
774 /* if requested, sort the "interesting" processes */
776 qsort(pref, active_procs, sizeof(*pref), compare);
778 /* remember active and total counts */
779 si->p_total = total_procs;
780 si->p_active = pref_len = active_procs;
782 /* pass back a handle */
783 handle.next_proc = pref;
784 handle.remaining = active_procs;
785 return ((caddr_t)&handle);
788 static char fmt[128]; /* static area where result is built */
791 format_next_process(caddr_t handle, char *(*get_userid)(int), int flags)
793 struct kinfo_proc *pp;
794 const struct kinfo_proc *oldp;
800 struct rusage ru, *rup;
802 char *proc_fmt, thr_buf[6], jid_buf[6];
806 /* find and remember the next proc structure */
807 hp = (struct handle *)handle;
808 pp = *(hp->next_proc++);
811 /* get the process's command name */
812 if ((pp->ki_flag & P_INMEM) == 0) {
814 * Print swapped processes as <pname>
818 len = strlen(pp->ki_comm);
819 if (len > sizeof(pp->ki_comm) - 3)
820 len = sizeof(pp->ki_comm) - 3;
821 memmove(pp->ki_comm + 1, pp->ki_comm, len);
822 pp->ki_comm[0] = '<';
823 pp->ki_comm[len + 1] = '>';
824 pp->ki_comm[len + 2] = '\0';
828 * Convert the process's runtime from microseconds to seconds. This
829 * time includes the interrupt time although that is not wanted here.
830 * ps(1) is similarly sloppy.
832 cputime = (pp->ki_runtime + 500000) / 1000000;
834 /* calculate the base for cpu percentages */
835 pct = pctdouble(pp->ki_pctcpu);
837 /* generate "STATE" field */
838 switch (state = pp->ki_stat) {
840 if (smpmode && pp->ki_oncpu != 0xff)
841 sprintf(status, "CPU%d", pp->ki_oncpu);
843 strcpy(status, "RUN");
846 if (pp->ki_kiflag & KI_LOCKBLOCK) {
847 sprintf(status, "*%.6s", pp->ki_lockname);
852 if (pp->ki_wmesg != NULL) {
853 sprintf(status, "%.6s", pp->ki_wmesg);
860 state < sizeof(state_abbrev) / sizeof(*state_abbrev))
861 sprintf(status, "%.6s", state_abbrev[state]);
863 sprintf(status, "?%5d", state);
867 cmdbuf = (char *)malloc(cmdlengthdelta + 1);
868 if (cmdbuf == NULL) {
869 warn("malloc(%d)", cmdlengthdelta + 1);
873 if (!(flags & FMT_SHOWARGS)) {
874 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
876 snprintf(cmdbuf, cmdlengthdelta, "%s{%s}", pp->ki_comm,
879 snprintf(cmdbuf, cmdlengthdelta, "%s", pp->ki_comm);
882 if (pp->ki_flag & P_SYSTEM ||
883 pp->ki_args == NULL ||
884 (args = kvm_getargv(kd, pp, cmdlengthdelta)) == NULL ||
886 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
888 snprintf(cmdbuf, cmdlengthdelta,
889 "[%s{%s}]", pp->ki_comm, pp->ki_ocomm);
891 snprintf(cmdbuf, cmdlengthdelta,
892 "[%s]", pp->ki_comm);
895 char *src, *dst, *argbuf;
900 argbuflen = cmdlengthdelta * 4;
901 argbuf = (char *)malloc(argbuflen + 1);
902 if (argbuf == NULL) {
903 warn("malloc(%d)", argbuflen + 1);
910 /* Extract cmd name from argv */
911 cmd = strrchr(*args, '/');
917 for (; (src = *args++) != NULL; ) {
920 len = (argbuflen - (dst - argbuf) - 1) / 4;
922 strlen(src) < len ? strlen(src) : len,
923 VIS_NL | VIS_CSTYLE);
926 if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
927 *dst++ = ' '; /* add delimiting space */
929 if (dst != argbuf && dst[-1] == ' ')
933 if (strcmp(cmd, pp->ki_comm) != 0 ) {
934 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
936 snprintf(cmdbuf, cmdlengthdelta,
937 "%s (%s){%s}", argbuf, pp->ki_comm,
940 snprintf(cmdbuf, cmdlengthdelta,
941 "%s (%s)", argbuf, pp->ki_comm);
943 if (ps.thread && pp->ki_flag & P_HADTHREADS &&
945 snprintf(cmdbuf, cmdlengthdelta,
946 "%s{%s}", argbuf, pp->ki_ocomm);
948 strlcpy(cmdbuf, argbuf, cmdlengthdelta);
957 snprintf(jid_buf, sizeof(jid_buf), " %*d",
958 sizeof(jid_buf) - 3, pp->ki_jid);
960 if (displaymode == DISP_IO) {
961 oldp = get_old_proc(pp);
963 ru.ru_inblock = RU(pp)->ru_inblock -
964 RU(oldp)->ru_inblock;
965 ru.ru_oublock = RU(pp)->ru_oublock -
966 RU(oldp)->ru_oublock;
967 ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
968 ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
969 ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
974 p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
975 s_tot = total_inblock + total_oublock + total_majflt;
977 snprintf(fmt, sizeof(fmt), io_Proc_format,
980 namelength, namelength, (*get_userid)(pp->ki_ruid),
987 s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
988 screen_width > cmdlengthdelta ?
989 screen_width - cmdlengthdelta : 0,
997 /* format this entry */
999 if (state == SRUN && pp->ki_oncpu != 0xff)
1002 cpu = pp->ki_lastcpu;
1005 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1009 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1010 sizeof(thr_buf) - 2, pp->ki_numthreads);
1012 snprintf(fmt, sizeof(fmt), proc_fmt,
1015 namelength, namelength, (*get_userid)(pp->ki_ruid),
1017 pp->ki_pri.pri_level - PZERO,
1019 format_k2(PROCSIZE(pp)),
1020 format_k2(pagetok(pp->ki_rssize)),
1023 format_time(cputime),
1024 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1025 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1030 /* return the result */
1035 getsysctl(const char *name, void *ptr, size_t len)
1039 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1040 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1045 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1046 name, (unsigned long)len, (unsigned long)nlen);
1052 format_nice(const struct kinfo_proc *pp)
1054 const char *fifo, *kthread;
1056 static char nicebuf[4 + 1];
1058 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1059 kthread = (pp->ki_flag & P_KTHREAD) ? "k" : "";
1060 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1065 * XXX: the kernel doesn't tell us the original rtprio and
1066 * doesn't really know what it was, so to recover it we
1067 * must be more chummy with the implementation than the
1068 * implementation is with itself. pri_user gives a
1069 * constant "base" priority, but is only initialized
1070 * properly for user threads. pri_native gives what the
1071 * kernel calls the "base" priority, but it isn't constant
1072 * since it is changed by priority propagation. pri_native
1073 * also isn't properly initialized for all threads, but it
1074 * is properly initialized for kernel realtime and idletime
1075 * threads. Thus we use pri_user for the base priority of
1076 * user threads (it is always correct) and pri_native for
1077 * the base priority of kernel realtime and idletime threads
1078 * (there is nothing better, and it is usually correct).
1080 * The field width and thus the buffer are too small for
1081 * values like "kr31F", but such values shouldn't occur,
1082 * and if they do then the tailing "F" is not displayed.
1084 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1085 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1086 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1087 kthread, rtpri, fifo);
1090 if (pp->ki_flag & P_KTHREAD)
1092 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1095 /* XXX: as above. */
1096 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1097 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1098 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1099 kthread, rtpri, fifo);
1107 /* comparison routines for qsort */
1110 compare_pid(const void *p1, const void *p2)
1112 const struct kinfo_proc * const *pp1 = p1;
1113 const struct kinfo_proc * const *pp2 = p2;
1115 if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
1118 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1122 * proc_compare - comparison function for "qsort"
1123 * Compares the resource consumption of two processes using five
1124 * distinct keys. The keys (in descending order of importance) are:
1125 * percent cpu, cpu ticks, state, resident set size, total virtual
1126 * memory usage. The process states are ordered as follows (from least
1127 * to most important): WAIT, zombie, sleep, stop, start, run. The
1128 * array declaration below maps a process state index into a number
1129 * that reflects this ordering.
1132 static int sorted_state[] = {
1135 1, /* ABANDONED (WAIT) */
1143 #define ORDERKEY_PCTCPU(a, b) do { \
1146 diff = floor(1.0E6 * weighted_cpu(pctdouble((b)->ki_pctcpu), \
1148 floor(1.0E6 * weighted_cpu(pctdouble((a)->ki_pctcpu), \
1151 diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \
1153 return (diff > 0 ? 1 : -1); \
1156 #define ORDERKEY_CPTICKS(a, b) do { \
1157 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1159 return (diff > 0 ? 1 : -1); \
1162 #define ORDERKEY_STATE(a, b) do { \
1163 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1165 return (diff > 0 ? 1 : -1); \
1168 #define ORDERKEY_PRIO(a, b) do { \
1169 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1171 return (diff > 0 ? 1 : -1); \
1174 #define ORDERKEY_THREADS(a, b) do { \
1175 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1177 return (diff > 0 ? 1 : -1); \
1180 #define ORDERKEY_RSSIZE(a, b) do { \
1181 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1183 return (diff > 0 ? 1 : -1); \
1186 #define ORDERKEY_MEM(a, b) do { \
1187 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1189 return (diff > 0 ? 1 : -1); \
1192 #define ORDERKEY_JID(a, b) do { \
1193 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1195 return (diff > 0 ? 1 : -1); \
1198 /* compare_cpu - the comparison function for sorting by cpu percentage */
1202 compare_cpu(void *arg1, void *arg2)
1204 proc_compare(void *arg1, void *arg2)
1207 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1208 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1210 ORDERKEY_PCTCPU(p1, p2);
1211 ORDERKEY_CPTICKS(p1, p2);
1212 ORDERKEY_STATE(p1, p2);
1213 ORDERKEY_PRIO(p1, p2);
1214 ORDERKEY_RSSIZE(p1, p2);
1215 ORDERKEY_MEM(p1, p2);
1221 /* "cpu" compare routines */
1222 int compare_size(), compare_res(), compare_time(), compare_prio(),
1226 * "io" compare routines. Context switches aren't i/o, but are displayed
1227 * on the "io" display.
1229 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1230 compare_vcsw(), compare_ivcsw();
1232 int (*compares[])() = {
1249 /* compare_size - the comparison function for sorting by total memory usage */
1252 compare_size(void *arg1, void *arg2)
1254 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1255 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1257 ORDERKEY_MEM(p1, p2);
1258 ORDERKEY_RSSIZE(p1, p2);
1259 ORDERKEY_PCTCPU(p1, p2);
1260 ORDERKEY_CPTICKS(p1, p2);
1261 ORDERKEY_STATE(p1, p2);
1262 ORDERKEY_PRIO(p1, p2);
1267 /* compare_res - the comparison function for sorting by resident set size */
1270 compare_res(void *arg1, void *arg2)
1272 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1273 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1275 ORDERKEY_RSSIZE(p1, p2);
1276 ORDERKEY_MEM(p1, p2);
1277 ORDERKEY_PCTCPU(p1, p2);
1278 ORDERKEY_CPTICKS(p1, p2);
1279 ORDERKEY_STATE(p1, p2);
1280 ORDERKEY_PRIO(p1, p2);
1285 /* compare_time - the comparison function for sorting by total cpu time */
1288 compare_time(void *arg1, void *arg2)
1290 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1291 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1293 ORDERKEY_CPTICKS(p1, p2);
1294 ORDERKEY_PCTCPU(p1, p2);
1295 ORDERKEY_STATE(p1, p2);
1296 ORDERKEY_PRIO(p1, p2);
1297 ORDERKEY_RSSIZE(p1, p2);
1298 ORDERKEY_MEM(p1, p2);
1303 /* compare_prio - the comparison function for sorting by priority */
1306 compare_prio(void *arg1, void *arg2)
1308 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1309 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1311 ORDERKEY_PRIO(p1, p2);
1312 ORDERKEY_CPTICKS(p1, p2);
1313 ORDERKEY_PCTCPU(p1, p2);
1314 ORDERKEY_STATE(p1, p2);
1315 ORDERKEY_RSSIZE(p1, p2);
1316 ORDERKEY_MEM(p1, p2);
1321 /* compare_threads - the comparison function for sorting by threads */
1323 compare_threads(void *arg1, void *arg2)
1325 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1326 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1328 ORDERKEY_THREADS(p1, p2);
1329 ORDERKEY_PCTCPU(p1, p2);
1330 ORDERKEY_CPTICKS(p1, p2);
1331 ORDERKEY_STATE(p1, p2);
1332 ORDERKEY_PRIO(p1, p2);
1333 ORDERKEY_RSSIZE(p1, p2);
1334 ORDERKEY_MEM(p1, p2);
1339 /* compare_jid - the comparison function for sorting by jid */
1341 compare_jid(const void *arg1, const void *arg2)
1343 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1344 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1346 ORDERKEY_JID(p1, p2);
1347 ORDERKEY_PCTCPU(p1, p2);
1348 ORDERKEY_CPTICKS(p1, p2);
1349 ORDERKEY_STATE(p1, p2);
1350 ORDERKEY_PRIO(p1, p2);
1351 ORDERKEY_RSSIZE(p1, p2);
1352 ORDERKEY_MEM(p1, p2);
1358 /* assorted comparison functions for sorting by i/o */
1362 compare_iototal(void *arg1, void *arg2)
1364 io_compare(void *arg1, void *arg2)
1367 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1368 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1370 return (get_io_total(p2) - get_io_total(p1));
1375 compare_ioread(void *arg1, void *arg2)
1377 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1378 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1379 long dummy, inp1, inp2;
1381 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1382 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1384 return (inp2 - inp1);
1388 compare_iowrite(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, oup1, oup2;
1394 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1395 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1397 return (oup2 - oup1);
1401 compare_iofault(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, flp1, flp2;
1407 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1408 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1410 return (flp2 - flp1);
1414 compare_vcsw(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, &dummy, &flp1, &dummy);
1421 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1423 return (flp2 - flp1);
1427 compare_ivcsw(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, &dummy, &flp1);
1434 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1436 return (flp2 - flp1);
1441 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1442 * the process does not exist.
1443 * It is EXTREMLY IMPORTANT that this function work correctly.
1444 * If top runs setuid root (as in SVR4), then this function
1445 * is the only thing that stands in the way of a serious
1446 * security problem. It validates requests for the "kill"
1447 * and "renice" commands.
1454 struct kinfo_proc **prefp;
1455 struct kinfo_proc *pp;
1459 while (--cnt >= 0) {
1461 if (pp->ki_pid == (pid_t)pid)
1462 return ((int)pp->ki_ruid);
1468 swapmode(int *retavail, int *retfree)
1471 int pagesize = getpagesize();
1472 struct kvm_swap swapary[1];
1477 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1479 n = kvm_getswapinfo(kd, swapary, 1, 0);
1480 if (n < 0 || swapary[0].ksw_total == 0)
1483 *retavail = CONVERT(swapary[0].ksw_total);
1484 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1486 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);