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 */
998 proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
1002 snprintf(thr_buf, sizeof(thr_buf), "%*d ",
1003 sizeof(thr_buf) - 2, pp->ki_numthreads);
1005 snprintf(fmt, sizeof(fmt), proc_fmt,
1008 namelength, namelength, (*get_userid)(pp->ki_ruid),
1010 pp->ki_pri.pri_level - PZERO,
1012 format_k2(PROCSIZE(pp)),
1013 format_k2(pagetok(pp->ki_rssize)),
1015 smpmode ? pp->ki_lastcpu : 0,
1016 format_time(cputime),
1017 ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
1018 screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
1023 /* return the result */
1028 getsysctl(const char *name, void *ptr, size_t len)
1032 if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
1033 fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
1038 fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
1039 name, (unsigned long)len, (unsigned long)nlen);
1045 format_nice(const struct kinfo_proc *pp)
1047 const char *fifo, *kthread;
1049 static char nicebuf[4 + 1];
1051 fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
1052 kthread = (pp->ki_flag & P_KTHREAD) ? "k" : "";
1053 switch (PRI_BASE(pp->ki_pri.pri_class)) {
1058 * XXX: the kernel doesn't tell us the original rtprio and
1059 * doesn't really know what it was, so to recover it we
1060 * must be more chummy with the implementation than the
1061 * implementation is with itself. pri_user gives a
1062 * constant "base" priority, but is only initialized
1063 * properly for user threads. pri_native gives what the
1064 * kernel calls the "base" priority, but it isn't constant
1065 * since it is changed by priority propagation. pri_native
1066 * also isn't properly initialized for all threads, but it
1067 * is properly initialized for kernel realtime and idletime
1068 * threads. Thus we use pri_user for the base priority of
1069 * user threads (it is always correct) and pri_native for
1070 * the base priority of kernel realtime and idletime threads
1071 * (there is nothing better, and it is usually correct).
1073 * The field width and thus the buffer are too small for
1074 * values like "kr31F", but such values shouldn't occur,
1075 * and if they do then the tailing "F" is not displayed.
1077 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1078 pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
1079 snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
1080 kthread, rtpri, fifo);
1083 if (pp->ki_flag & P_KTHREAD)
1085 snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
1088 /* XXX: as above. */
1089 rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
1090 pp->ki_pri.pri_user) - PRI_MIN_IDLE;
1091 snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
1092 kthread, rtpri, fifo);
1100 /* comparison routines for qsort */
1103 compare_pid(const void *p1, const void *p2)
1105 const struct kinfo_proc * const *pp1 = p1;
1106 const struct kinfo_proc * const *pp2 = p2;
1108 if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
1111 return ((*pp1)->ki_pid - (*pp2)->ki_pid);
1115 * proc_compare - comparison function for "qsort"
1116 * Compares the resource consumption of two processes using five
1117 * distinct keys. The keys (in descending order of importance) are:
1118 * percent cpu, cpu ticks, state, resident set size, total virtual
1119 * memory usage. The process states are ordered as follows (from least
1120 * to most important): WAIT, zombie, sleep, stop, start, run. The
1121 * array declaration below maps a process state index into a number
1122 * that reflects this ordering.
1125 static int sorted_state[] = {
1128 1, /* ABANDONED (WAIT) */
1136 #define ORDERKEY_PCTCPU(a, b) do { \
1139 diff = floor(1.0E6 * weighted_cpu(pctdouble((b)->ki_pctcpu), \
1141 floor(1.0E6 * weighted_cpu(pctdouble((a)->ki_pctcpu), \
1144 diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \
1146 return (diff > 0 ? 1 : -1); \
1149 #define ORDERKEY_CPTICKS(a, b) do { \
1150 int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
1152 return (diff > 0 ? 1 : -1); \
1155 #define ORDERKEY_STATE(a, b) do { \
1156 int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
1158 return (diff > 0 ? 1 : -1); \
1161 #define ORDERKEY_PRIO(a, b) do { \
1162 int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
1164 return (diff > 0 ? 1 : -1); \
1167 #define ORDERKEY_THREADS(a, b) do { \
1168 int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
1170 return (diff > 0 ? 1 : -1); \
1173 #define ORDERKEY_RSSIZE(a, b) do { \
1174 long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
1176 return (diff > 0 ? 1 : -1); \
1179 #define ORDERKEY_MEM(a, b) do { \
1180 long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
1182 return (diff > 0 ? 1 : -1); \
1185 #define ORDERKEY_JID(a, b) do { \
1186 int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
1188 return (diff > 0 ? 1 : -1); \
1191 /* compare_cpu - the comparison function for sorting by cpu percentage */
1195 compare_cpu(void *arg1, void *arg2)
1197 proc_compare(void *arg1, void *arg2)
1200 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1201 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1203 ORDERKEY_PCTCPU(p1, p2);
1204 ORDERKEY_CPTICKS(p1, p2);
1205 ORDERKEY_STATE(p1, p2);
1206 ORDERKEY_PRIO(p1, p2);
1207 ORDERKEY_RSSIZE(p1, p2);
1208 ORDERKEY_MEM(p1, p2);
1214 /* "cpu" compare routines */
1215 int compare_size(), compare_res(), compare_time(), compare_prio(),
1219 * "io" compare routines. Context switches aren't i/o, but are displayed
1220 * on the "io" display.
1222 int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
1223 compare_vcsw(), compare_ivcsw();
1225 int (*compares[])() = {
1242 /* compare_size - the comparison function for sorting by total memory usage */
1245 compare_size(void *arg1, void *arg2)
1247 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1248 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1250 ORDERKEY_MEM(p1, p2);
1251 ORDERKEY_RSSIZE(p1, p2);
1252 ORDERKEY_PCTCPU(p1, p2);
1253 ORDERKEY_CPTICKS(p1, p2);
1254 ORDERKEY_STATE(p1, p2);
1255 ORDERKEY_PRIO(p1, p2);
1260 /* compare_res - the comparison function for sorting by resident set size */
1263 compare_res(void *arg1, void *arg2)
1265 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1266 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1268 ORDERKEY_RSSIZE(p1, p2);
1269 ORDERKEY_MEM(p1, p2);
1270 ORDERKEY_PCTCPU(p1, p2);
1271 ORDERKEY_CPTICKS(p1, p2);
1272 ORDERKEY_STATE(p1, p2);
1273 ORDERKEY_PRIO(p1, p2);
1278 /* compare_time - the comparison function for sorting by total cpu time */
1281 compare_time(void *arg1, void *arg2)
1283 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1284 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1286 ORDERKEY_CPTICKS(p1, p2);
1287 ORDERKEY_PCTCPU(p1, p2);
1288 ORDERKEY_STATE(p1, p2);
1289 ORDERKEY_PRIO(p1, p2);
1290 ORDERKEY_RSSIZE(p1, p2);
1291 ORDERKEY_MEM(p1, p2);
1296 /* compare_prio - the comparison function for sorting by priority */
1299 compare_prio(void *arg1, void *arg2)
1301 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1302 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1304 ORDERKEY_PRIO(p1, p2);
1305 ORDERKEY_CPTICKS(p1, p2);
1306 ORDERKEY_PCTCPU(p1, p2);
1307 ORDERKEY_STATE(p1, p2);
1308 ORDERKEY_RSSIZE(p1, p2);
1309 ORDERKEY_MEM(p1, p2);
1314 /* compare_threads - the comparison function for sorting by threads */
1316 compare_threads(void *arg1, void *arg2)
1318 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1319 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1321 ORDERKEY_THREADS(p1, p2);
1322 ORDERKEY_PCTCPU(p1, p2);
1323 ORDERKEY_CPTICKS(p1, p2);
1324 ORDERKEY_STATE(p1, p2);
1325 ORDERKEY_PRIO(p1, p2);
1326 ORDERKEY_RSSIZE(p1, p2);
1327 ORDERKEY_MEM(p1, p2);
1332 /* compare_jid - the comparison function for sorting by jid */
1334 compare_jid(const void *arg1, const void *arg2)
1336 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1337 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1339 ORDERKEY_JID(p1, p2);
1340 ORDERKEY_PCTCPU(p1, p2);
1341 ORDERKEY_CPTICKS(p1, p2);
1342 ORDERKEY_STATE(p1, p2);
1343 ORDERKEY_PRIO(p1, p2);
1344 ORDERKEY_RSSIZE(p1, p2);
1345 ORDERKEY_MEM(p1, p2);
1351 /* assorted comparison functions for sorting by i/o */
1355 compare_iototal(void *arg1, void *arg2)
1357 io_compare(void *arg1, void *arg2)
1360 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1361 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1363 return (get_io_total(p2) - get_io_total(p1));
1368 compare_ioread(void *arg1, void *arg2)
1370 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1371 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1372 long dummy, inp1, inp2;
1374 (void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
1375 (void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
1377 return (inp2 - inp1);
1381 compare_iowrite(void *arg1, void *arg2)
1383 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1384 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1385 long dummy, oup1, oup2;
1387 (void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
1388 (void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
1390 return (oup2 - oup1);
1394 compare_iofault(void *arg1, void *arg2)
1396 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1397 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1398 long dummy, flp1, flp2;
1400 (void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
1401 (void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
1403 return (flp2 - flp1);
1407 compare_vcsw(void *arg1, void *arg2)
1409 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1410 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1411 long dummy, flp1, flp2;
1413 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
1414 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
1416 return (flp2 - flp1);
1420 compare_ivcsw(void *arg1, void *arg2)
1422 struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
1423 struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
1424 long dummy, flp1, flp2;
1426 (void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
1427 (void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
1429 return (flp2 - flp1);
1434 * proc_owner(pid) - returns the uid that owns process "pid", or -1 if
1435 * the process does not exist.
1436 * It is EXTREMLY IMPORTANT that this function work correctly.
1437 * If top runs setuid root (as in SVR4), then this function
1438 * is the only thing that stands in the way of a serious
1439 * security problem. It validates requests for the "kill"
1440 * and "renice" commands.
1447 struct kinfo_proc **prefp;
1448 struct kinfo_proc *pp;
1452 while (--cnt >= 0) {
1454 if (pp->ki_pid == (pid_t)pid)
1455 return ((int)pp->ki_ruid);
1461 swapmode(int *retavail, int *retfree)
1464 int pagesize = getpagesize();
1465 struct kvm_swap swapary[1];
1470 #define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
1472 n = kvm_getswapinfo(kd, swapary, 1, 0);
1473 if (n < 0 || swapary[0].ksw_total == 0)
1476 *retavail = CONVERT(swapary[0].ksw_total);
1477 *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
1479 n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);