diff --git a/usr.bin/top/m_dragonfly.c b/usr.bin/top/m_dragonfly.c index 4ee538b..b92e523 100644 --- a/usr.bin/top/m_dragonfly.c +++ b/usr.bin/top/m_dragonfly.c @@ -1,26 +1,26 @@ /* * top - a top users display for Unix - * + * * SYNOPSIS: For DragonFly 2.x and later - * - * DESCRIPTION: - * Originally written for BSD4.4 system by Christos Zoulas. - * Ported to FreeBSD 2.x by Steven Wallace && Wolfram Schneider - * Order support hacked in from top-3.5beta6/machine/m_aix41.c - * by Monte Mitzelfelt (for latest top see http://www.groupsys.com/topinfo/) - * - * This is the machine-dependent module for DragonFly 2.5.1 - * Should work for: - * DragonFly 2.x and above - * + * + * DESCRIPTION: Originally written for BSD4.4 system by Christos Zoulas. Ported + * to FreeBSD 2.x by Steven Wallace && Wolfram Schneider Order support hacked + * in from top-3.5beta6/machine/m_aix41.c by Monte Mitzelfelt (for latest top + * see http://www.groupsys.com/topinfo/) + * + * This is the machine-dependent module for DragonFly 2.5.1 Should work for: + * DragonFly 2.x and above + * * LIBS: -lkvm - * + * * AUTHOR: Jan Lentfer - * This module has been put together from different sources and is based on the - * work of many other people, e.g. Matthew Dillon, Simon Schubert, Jordan Gordeev. - * + * This module has been put together from different sources and is based on + * the work of many other people, e.g. Matthew Dillon, Simon Schubert, + * Jordan Gordeev. + * * $FreeBSD: src/usr.bin/top/machine.c,v 1.29.2.2 2001/07/31 20:27:05 tmm Exp $ - * $DragonFly: src/usr.bin/top/machine.c,v 1.26 2008/10/16 01:52:33 swildner Exp $ + * $DragonFly: src/usr.bin/top/machine.c,v 1.26 2008/10/16 01:52:33 swildner + * Exp $ */ @@ -50,7 +50,7 @@ #include #include -#include /* for changes in kernel structures */ +#include /* for changes in kernel structures */ #include #include @@ -60,10 +60,6 @@ #include "screen.h" #include "utils.h" -#if 0 -static int check_nlist(struct nlist *); -static int getkval(unsigned long, int *, int, char *); -#endif int swapmode(int *retavail, int *retfree); static int smpmode; static int namelength; @@ -71,18 +67,16 @@ static int cmdlength; int n_cpus = 0; -/* - * needs to be a global symbol, so wrapper can be - * modified accordingly. +/* + * needs to be a global symbol, so wrapper can be modified accordingly. */ static int show_threads = 0; /* get_process_info passes back a handle. This is what it looks like: */ -struct handle -{ - struct kinfo_proc **next_proc; /* points to next valid proc pointer */ - int remaining; /* number of pointers remaining */ +struct handle { + struct kinfo_proc **next_proc; /* points to next valid proc pointer */ + int remaining; /* number of pointers remaining */ }; /* declarations for load_avg */ @@ -100,17 +94,17 @@ struct handle #define PROCSIZE(pp) (VP((pp), map_size) / 1024) /* - * These definitions control the format of the per-process area + * These definitions control the format of the per-process area */ static char smp_header[] = - " PID %-*.*s PRI NICE SIZE RES STATE C TIME WCPU CPU COMMAND"; +" PID %-*.*s PRI NICE SIZE RES STATE C TIME WCPU CPU COMMAND"; #define smp_Proc_format \ "%5d %-*.*s %3d %3d%7s %6s %-6.6s %1x%7s %5.2f%% %5.2f%% %.*s" static char up_header[] = - " PID %-*.*s PRI NICE SIZE RES STATE TIME WCPU CPU COMMAND"; +" PID %-*.*s PRI NICE SIZE RES STATE TIME WCPU CPU COMMAND"; #define up_Proc_format \ "%5d %-*.*s %3d %3d%7s %6s %-6.6s%.0d%7s %5.2f%% %5.2f%% %.*s" @@ -118,12 +112,13 @@ static char up_header[] = /* process state names for the "STATE" column of the display */ -/* the extra nulls in the string "run" are for adding a slash and - the processor number when needed */ +/* + * the extra nulls in the string "run" are for adding a slash and the + * processor number when needed + */ -const char *state_abbrev[] = -{ - "", "RUN\0\0\0", "STOP", "SLEEP", +const char *state_abbrev[] = { + "", "RUN\0\0\0", "STOP", "SLEEP", }; @@ -144,31 +139,31 @@ static struct kinfo_cputime *cp_time, *cp_old; int process_states[6]; char *procstatenames[] = { - "", " starting, ", " running, ", " sleeping, ", " stopped, ", - " zombie, ", - NULL + "", " starting, ", " running, ", " sleeping, ", " stopped, ", + " zombie, ", + NULL }; /* these are for detailing the cpu states */ #define CPU_STATES 5 int *cpu_states; char *cpustatenames[CPU_STATES + 1] = { - "user", "nice", "system", "interrupt", "idle", NULL + "user", "nice", "system", "interrupt", "idle", NULL }; /* these are for detailing the memory statistics */ long memory_stats[7]; char *memorynames[] = { - "K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ", "K Free", - NULL + "K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ", "K Free", + NULL }; long swap_stats[7]; char *swapnames[] = { -/* 0 1 2 3 4 5 */ - "K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out", - NULL + /* 0 1 2 3 4 5 */ + "K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out", + NULL }; @@ -190,13 +185,13 @@ static int pageshift; /* log base 2 of the pagesize */ /* sorting orders. first is default */ char *ordernames[] = { - "cpu", "size", "res", "time", "pri", "thr", NULL + "cpu", "size", "res", "time", "pri", "thr", NULL }; /* compare routines */ int proc_compare(), compare_size(), compare_res(), compare_time(), compare_prio(), compare_thr(); -int (*proc_compares[])() = { +int (*proc_compares[]) () = { proc_compare, compare_size, compare_res, @@ -207,134 +202,132 @@ int (*proc_compares[])() = { static void cputime_percentages(int out[CPU_STATES], struct kinfo_cputime *new, - struct kinfo_cputime *old) + struct kinfo_cputime *old) { - struct kinfo_cputime diffs; + struct kinfo_cputime diffs; uint64_t total_change, half_total; - /* initialization */ + /* initialization */ total_change = 0; - diffs.cp_user = new->cp_user - old->cp_user; + diffs.cp_user = new->cp_user - old->cp_user; diffs.cp_nice = new->cp_nice - old->cp_nice; diffs.cp_sys = new->cp_sys - old->cp_sys; - diffs.cp_intr = new->cp_intr - old->cp_intr; - diffs.cp_idle = new->cp_idle - old->cp_idle; + diffs.cp_intr = new->cp_intr - old->cp_intr; + diffs.cp_idle = new->cp_idle - old->cp_idle; total_change = diffs.cp_user + diffs.cp_nice + diffs.cp_sys + - diffs.cp_intr + diffs.cp_idle; - old->cp_user = new->cp_user; - old->cp_nice = new->cp_nice; - old->cp_sys = new->cp_sys; - old->cp_intr = new->cp_intr; + diffs.cp_intr + diffs.cp_idle; + old->cp_user = new->cp_user; + old->cp_nice = new->cp_nice; + old->cp_sys = new->cp_sys; + old->cp_intr = new->cp_intr; old->cp_idle = new->cp_idle; - /* avoid divide by zero potential */ + /* avoid divide by zero potential */ if (total_change == 0) total_change = 1; /* calculate percentages based on overall change, rounding up */ - half_total = total_change >> 1; + half_total = total_change >> 1; out[0] = ((diffs.cp_user * 1000LL + half_total) / total_change); - out[1] = ((diffs.cp_nice * 1000LL + half_total) / total_change); + out[1] = ((diffs.cp_nice * 1000LL + half_total) / total_change); out[2] = ((diffs.cp_sys * 1000LL + half_total) / total_change); - out[3] = ((diffs.cp_intr * 1000LL + half_total) / total_change); + out[3] = ((diffs.cp_intr * 1000LL + half_total) / total_change); out[4] = ((diffs.cp_idle * 1000LL + half_total) / total_change); } int machine_init(struct statics *statics) { - int pagesize; - size_t modelen; - struct passwd *pw; + int pagesize; + size_t modelen; + struct passwd *pw; struct timeval boottime; - if (n_cpus < 1) { - if (kinfo_get_cpus(&n_cpus)) - err(1, "kinfo_get_cpus failed"); - } - + if (n_cpus < 1) { + if (kinfo_get_cpus(&n_cpus)) + err(1, "kinfo_get_cpus failed"); + } /* get boot time */ modelen = sizeof(boottime); if (sysctlbyname("kern.boottime", &boottime, &modelen, NULL, 0) == -1) { - /* we have no boottime to report */ boottime.tv_sec = -1; } + modelen = sizeof(smpmode); + if ((sysctlbyname("machdep.smp_active", &smpmode, &modelen, NULL, 0) < 0 && + sysctlbyname("smp.smp_active", &smpmode, &modelen, NULL, 0) < 0) || + modelen != sizeof(smpmode)) + smpmode = 0; + + while ((pw = getpwent()) != NULL) { + if ((int)strlen(pw->pw_name) > namelength) + namelength = strlen(pw->pw_name); + } + if (namelength < 8) + namelength = 8; + if (smpmode && namelength > 13) + namelength = 13; + else if (namelength > 15) + namelength = 15; + + if ((kd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open")) == NULL) + return -1; + + if (kinfo_get_sched_ccpu(&ccpu)) { + fprintf(stderr, "top: kinfo_get_sched_ccpu failed\n"); + return (-1); + } + /* this is used in calculating WCPU -- calculate it ahead of time */ + logcpu = log(loaddouble(ccpu)); + + pbase = NULL; + pref = NULL; + nproc = 0; + onproc = -1; + /* + * get the page size with "getpagesize" and calculate pageshift from + * it + */ + pagesize = getpagesize(); + pageshift = 0; + while (pagesize > 1) { + pageshift++; + pagesize >>= 1; + } + + /* we only need the amount of log(2)1024 for our conversion */ + pageshift -= LOG1024; + + /* fill in the statics information */ + statics->procstate_names = procstatenames; + statics->cpustate_names = cpustatenames; + statics->memory_names = memorynames; + statics->boottime = boottime.tv_sec; + statics->swap_names = swapnames; + statics->order_names = ordernames; - modelen = sizeof(smpmode); - if ((sysctlbyname("machdep.smp_active", &smpmode, &modelen, NULL, 0) < 0 && - sysctlbyname("smp.smp_active", &smpmode, &modelen, NULL, 0) < 0) || - modelen != sizeof(smpmode)) - smpmode = 0; - - while ((pw = getpwent()) != NULL) { - if ((int)strlen(pw->pw_name) > namelength) - namelength = strlen(pw->pw_name); - } - if (namelength < 8) - namelength = 8; - if (smpmode && namelength > 13) - namelength = 13; - else if (namelength > 15) - namelength = 15; - - if ((kd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open")) == NULL) - return -1; - - if (kinfo_get_sched_ccpu(&ccpu)) { - fprintf(stderr, "top: kinfo_get_sched_ccpu failed\n"); - return(-1); - } - - /* this is used in calculating WCPU -- calculate it ahead of time */ - logcpu = log(loaddouble(ccpu)); - - pbase = NULL; - pref = NULL; - nproc = 0; - onproc = -1; - /* get the page size with "getpagesize" and calculate pageshift from it */ - pagesize = getpagesize(); - pageshift = 0; - while (pagesize > 1) - { - pageshift++; - pagesize >>= 1; - } - - /* we only need the amount of log(2)1024 for our conversion */ - pageshift -= LOG1024; - - /* fill in the statics information */ - statics->procstate_names = procstatenames; - statics->cpustate_names = cpustatenames; - statics->memory_names = memorynames; - statics->boottime = boottime.tv_sec; - statics->swap_names = swapnames; - statics->order_names = ordernames; - - /* all done! */ - return(0); + /* all done! */ + return (0); } char * format_header(char *uname_field) { - static char Header[128]; + static char Header[128]; - snprintf(Header, sizeof(Header), smpmode ? smp_header : up_header, - namelength, namelength, uname_field); + snprintf(Header, sizeof(Header), smpmode ? smp_header : up_header, + namelength, namelength, uname_field); - if (screen_width <= 79) - cmdlength = 80; - else - cmdlength = 89; + if (screen_width <= 79) + cmdlength = 80; + else + cmdlength = 89; - cmdlength = cmdlength - strlen(Header) + 6; + cmdlength = cmdlength - strlen(Header) + 6; - return Header; + return Header; } static int swappgsin = -1; @@ -344,294 +337,288 @@ extern struct timeval timeout; void get_system_info(struct system_info *si) { - size_t len; - int cpu; - - if (cpu_states == NULL) { - cpu_states = malloc(sizeof(*cpu_states) * CPU_STATES * n_cpus); - if (cpu_states == NULL) - err(1, "malloc"); - bzero(cpu_states, sizeof(*cpu_states) * CPU_STATES * n_cpus); - } - if (cp_time == NULL) { - cp_time = malloc(2 * n_cpus * sizeof(cp_time[0])); - if (cp_time == NULL) - err(1, "cp_time"); - cp_old = cp_time + n_cpus; - - len = n_cpus * sizeof(cp_old[0]); - bzero(cp_time, len); - if (sysctlbyname("kern.cputime", cp_old, &len, NULL, 0)) - err(1, "kern.cputime"); - } - - len = n_cpus * sizeof(cp_time[0]); - bzero(cp_time, len); - if (sysctlbyname("kern.cputime", cp_time, &len, NULL, 0)) - err(1, "kern.cputime"); - - getloadavg(si->load_avg, 3); - - lastpid = 0; - - /* convert cp_time counts to percentages */ - for (cpu = 0; cpu < n_cpus; ++cpu) { - cputime_percentages(cpu_states + cpu * CPU_STATES, - &cp_time[cpu], &cp_old[cpu]); - } - - /* sum memory & swap statistics */ - { - struct vmmeter vmm; - struct vmstats vms; - size_t vms_size = sizeof(vms); - size_t vmm_size = sizeof(vmm); - static unsigned int swap_delay = 0; - static int swapavail = 0; - static int swapfree = 0; - static int bufspace = 0; - - if (sysctlbyname("vm.vmstats", &vms, &vms_size, NULL, 0)) - err(1, "sysctlbyname: vm.vmstats"); - - if (sysctlbyname("vm.vmmeter", &vmm, &vmm_size, NULL, 0)) - err(1, "sysctlbyname: vm.vmmeter"); - - if (kinfo_get_vfs_bufspace(&bufspace)) - err(1, "kinfo_get_vfs_bufspace"); - - /* convert memory stats to Kbytes */ - memory_stats[0] = pagetok(vms.v_active_count); - memory_stats[1] = pagetok(vms.v_inactive_count); - memory_stats[2] = pagetok(vms.v_wire_count); - memory_stats[3] = pagetok(vms.v_cache_count); - memory_stats[4] = bufspace / 1024; - memory_stats[5] = pagetok(vms.v_free_count); - memory_stats[6] = -1; - - /* first interval */ - if (swappgsin < 0) { - swap_stats[4] = 0; - swap_stats[5] = 0; - } - - /* compute differences between old and new swap statistic */ - else { - swap_stats[4] = pagetok(((vmm.v_swappgsin - swappgsin))); - swap_stats[5] = pagetok(((vmm.v_swappgsout - swappgsout))); + size_t len; + int cpu; + + if (cpu_states == NULL) { + cpu_states = malloc(sizeof(*cpu_states) * CPU_STATES * n_cpus); + if (cpu_states == NULL) + err(1, "malloc"); + bzero(cpu_states, sizeof(*cpu_states) * CPU_STATES * n_cpus); + } + if (cp_time == NULL) { + cp_time = malloc(2 * n_cpus * sizeof(cp_time[0])); + if (cp_time == NULL) + err(1, "cp_time"); + cp_old = cp_time + n_cpus; + + len = n_cpus * sizeof(cp_old[0]); + bzero(cp_time, len); + if (sysctlbyname("kern.cputime", cp_old, &len, NULL, 0)) + err(1, "kern.cputime"); } + len = n_cpus * sizeof(cp_time[0]); + bzero(cp_time, len); + if (sysctlbyname("kern.cputime", cp_time, &len, NULL, 0)) + err(1, "kern.cputime"); - swappgsin = vmm.v_swappgsin; - swappgsout = vmm.v_swappgsout; + getloadavg(si->load_avg, 3); - /* call CPU heavy swapmode() only for changes */ - if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) { - swap_stats[3] = swapmode(&swapavail, &swapfree); - swap_stats[0] = swapavail; - swap_stats[1] = swapavail - swapfree; - swap_stats[2] = swapfree; + lastpid = 0; + + /* convert cp_time counts to percentages */ + for (cpu = 0; cpu < n_cpus; ++cpu) { + cputime_percentages(cpu_states + cpu * CPU_STATES, + &cp_time[cpu], &cp_old[cpu]); } - swap_delay = 1; - swap_stats[6] = -1; - } - /* set arrays and strings */ - si->cpustates = cpu_states; - si->memory = memory_stats; - si->swap = swap_stats; + /* sum memory & swap statistics */ + { + struct vmmeter vmm; + struct vmstats vms; + size_t vms_size = sizeof(vms); + size_t vmm_size = sizeof(vmm); + static unsigned int swap_delay = 0; + static int swapavail = 0; + static int swapfree = 0; + static int bufspace = 0; + + if (sysctlbyname("vm.vmstats", &vms, &vms_size, NULL, 0)) + err(1, "sysctlbyname: vm.vmstats"); + + if (sysctlbyname("vm.vmmeter", &vmm, &vmm_size, NULL, 0)) + err(1, "sysctlbyname: vm.vmmeter"); + + if (kinfo_get_vfs_bufspace(&bufspace)) + err(1, "kinfo_get_vfs_bufspace"); + + /* convert memory stats to Kbytes */ + memory_stats[0] = pagetok(vms.v_active_count); + memory_stats[1] = pagetok(vms.v_inactive_count); + memory_stats[2] = pagetok(vms.v_wire_count); + memory_stats[3] = pagetok(vms.v_cache_count); + memory_stats[4] = bufspace / 1024; + memory_stats[5] = pagetok(vms.v_free_count); + memory_stats[6] = -1; + + /* first interval */ + if (swappgsin < 0) { + swap_stats[4] = 0; + swap_stats[5] = 0; + } + /* compute differences between old and new swap statistic */ + else { + swap_stats[4] = pagetok(((vmm.v_swappgsin - swappgsin))); + swap_stats[5] = pagetok(((vmm.v_swappgsout - swappgsout))); + } + + swappgsin = vmm.v_swappgsin; + swappgsout = vmm.v_swappgsout; + + /* call CPU heavy swapmode() only for changes */ + if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) { + swap_stats[3] = swapmode(&swapavail, &swapfree); + swap_stats[0] = swapavail; + swap_stats[1] = swapavail - swapfree; + swap_stats[2] = swapfree; + } + swap_delay = 1; + swap_stats[6] = -1; + } + + /* set arrays and strings */ + si->cpustates = cpu_states; + si->memory = memory_stats; + si->swap = swap_stats; - if(lastpid > 0) { - si->last_pid = lastpid; - } else { - si->last_pid = -1; - } + if (lastpid > 0) { + si->last_pid = lastpid; + } else { + si->last_pid = -1; + } } static struct handle handle; -caddr_t get_process_info(struct system_info *si, struct process_select *sel, +caddr_t +get_process_info(struct system_info *si, struct process_select *sel, int compare_index) { - int i; - int total_procs; - int active_procs; - struct kinfo_proc **prefp; - struct kinfo_proc *pp; - - /* these are copied out of sel for speed */ - int show_idle; - int show_system; - int show_uid; - - - pbase = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc); - if (nproc > onproc) - pref = (struct kinfo_proc **) realloc(pref, sizeof(struct kinfo_proc *) - * (onproc = nproc)); - if (pref == NULL || pbase == NULL) { - (void) fprintf(stderr, "top: Out of memory.\n"); - quit(23); - } - /* get a pointer to the states summary array */ - si->procstates = process_states; - - /* set up flags which define what we are going to select */ - show_idle = sel->idle; - show_system = sel->system; - show_uid = sel->uid != -1; - - /* count up process states and get pointers to interesting procs */ - total_procs = 0; - active_procs = 0; - memset((char *)process_states, 0, sizeof(process_states)); - prefp = pref; - for (pp = pbase, i = 0; i < nproc; pp++, i++) - { - /* - * Place pointers to each valid proc structure in pref[]. - * Process slots that are actually in use have a non-zero - * status field. Processes with P_SYSTEM set are system - * processes---these get ignored unless show_sysprocs is set. - */ - if ((show_threads && (LP(pp, pid) == -1)) || - (show_system || ((PP(pp, flags) & P_SYSTEM) == 0))) - { - total_procs++; - process_states[(unsigned char) PP(pp, stat)]++; - if ((show_threads && (LP(pp, pid) == -1)) || - (show_idle || (LP(pp, pctcpu) != 0) || - (LP(pp, stat) == LSRUN)) && - (!show_uid || PP(pp, ruid) == (uid_t)sel->uid)) - { - *prefp++ = pp; - active_procs++; - } + int i; + int total_procs; + int active_procs; + struct kinfo_proc **prefp; + struct kinfo_proc *pp; + + /* these are copied out of sel for speed */ + int show_idle; + int show_system; + int show_uid; + + + pbase = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc); + if (nproc > onproc) + pref = (struct kinfo_proc **)realloc(pref, sizeof(struct kinfo_proc *) + * (onproc = nproc)); + if (pref == NULL || pbase == NULL) { + (void)fprintf(stderr, "top: Out of memory.\n"); + quit(23); + } + /* get a pointer to the states summary array */ + si->procstates = process_states; + + /* set up flags which define what we are going to select */ + show_idle = sel->idle; + show_system = sel->system; + show_uid = sel->uid != -1; + + /* count up process states and get pointers to interesting procs */ + total_procs = 0; + active_procs = 0; + memset((char *)process_states, 0, sizeof(process_states)); + prefp = pref; + for (pp = pbase, i = 0; i < nproc; pp++, i++) { + /* + * Place pointers to each valid proc structure in pref[]. + * Process slots that are actually in use have a non-zero + * status field. Processes with P_SYSTEM set are system + * processes---these get ignored unless show_sysprocs is set. + */ + if ((show_threads && (LP(pp, pid) == -1)) || + (show_system || ((PP(pp, flags) & P_SYSTEM) == 0))) { + total_procs++; + process_states[(unsigned char)PP(pp, stat)]++; + if ((show_threads && (LP(pp, pid) == -1)) || + (show_idle || (LP(pp, pctcpu) != 0) || + (LP(pp, stat) == LSRUN)) && + (!show_uid || PP(pp, ruid) == (uid_t) sel->uid)) { + *prefp++ = pp; + active_procs++; + } + } } - } qsort((char *)pref, active_procs, sizeof(struct kinfo_proc *), - proc_compares[compare_index]); + proc_compares[compare_index]); - /* remember active and total counts */ - si->p_total = total_procs; - si->p_active = pref_len = active_procs; + /* remember active and total counts */ + si->p_total = total_procs; + si->p_active = pref_len = active_procs; - /* pass back a handle */ - handle.next_proc = pref; - handle.remaining = active_procs; - return((caddr_t)&handle); + /* pass back a handle */ + handle.next_proc = pref; + handle.remaining = active_procs; + return ((caddr_t) & handle); } -char fmt[128]; /* static area where result is built */ +char fmt[128]; /* static area where result is built */ char * -format_next_process(caddr_t xhandle, char *(*get_userid)(int)) +format_next_process(caddr_t xhandle, char *(*get_userid) (int)) { - struct kinfo_proc *pp; - long cputime; - double pct; - struct handle *hp; - char status[16]; - char const *wrapper; - int state; - int xnice; - - /* find and remember the next proc structure */ - hp = (struct handle *)xhandle; - pp = *(hp->next_proc++); - hp->remaining--; - - /* set the wrapper for the process/thread name */ - if ((PP(pp, flags) & P_SWAPPEDOUT)) - wrapper = "[]"; /* swapped process [pname] */ - else if (((PP(pp, flags) & P_SYSTEM) != 0) && (LP(pp, pid) > 0)) - wrapper = "()"; /* system process (pname) */ - else if (show_threads && (LP(pp, pid) == -1)) - wrapper = "<>"; /* pure kernel threads */ - else - wrapper = NULL; - - /* get the process's command name */ - if (wrapper != NULL) { - char *comm = PP(pp, comm); + struct kinfo_proc *pp; + long cputime; + double pct; + struct handle *hp; + char status[16]; + char const *wrapper; + int state; + int xnice; + + /* find and remember the next proc structure */ + hp = (struct handle *)xhandle; + pp = *(hp->next_proc++); + hp->remaining--; + + /* set the wrapper for the process/thread name */ + if ((PP(pp, flags) & P_SWAPPEDOUT)) + wrapper = "[]"; /* swapped process [pname] */ + else if (((PP(pp, flags) & P_SYSTEM) != 0) && (LP(pp, pid) > 0)) + wrapper = "()"; /* system process (pname) */ + else if (show_threads && (LP(pp, pid) == -1)) + wrapper = "<>"; /* pure kernel threads */ + else + wrapper = NULL; + + /* get the process's command name */ + if (wrapper != NULL) { + char *comm = PP(pp, comm); #define COMSIZ sizeof(PP(pp, comm)) - char buf[COMSIZ]; - (void) strncpy(buf, comm, COMSIZ); - comm[0] = wrapper[0]; - (void) strncpy(&comm[1], buf, COMSIZ - 2); - comm[COMSIZ - 2] = '\0'; - (void) strncat(comm, &wrapper[1], COMSIZ - 1); - comm[COMSIZ - 1] = '\0'; - } - - /* - * Convert the process's runtime from microseconds to seconds. This - * time includes the interrupt time although that is not wanted here. - * ps(1) is similarly sloppy. - */ - cputime = (LP(pp, uticks) + LP(pp, sticks)) / 1000000; - - /* calculate the base for cpu percentages */ - pct = pctdouble(LP(pp, pctcpu)); - - /* generate "STATE" field */ - switch (state = LP(pp, stat)) { + char buf[COMSIZ]; + (void)strncpy(buf, comm, COMSIZ); + comm[0] = wrapper[0]; + (void)strncpy(&comm[1], buf, COMSIZ - 2); + comm[COMSIZ - 2] = '\0'; + (void)strncat(comm, &wrapper[1], COMSIZ - 1); + comm[COMSIZ - 1] = '\0'; + } + /* + * Convert the process's runtime from microseconds to seconds. This + * time includes the interrupt time although that is not wanted here. + * ps(1) is similarly sloppy. + */ + cputime = (LP(pp, uticks) + LP(pp, sticks)) / 1000000; + + /* calculate the base for cpu percentages */ + pct = pctdouble(LP(pp, pctcpu)); + + /* generate "STATE" field */ + switch (state = LP(pp, stat)) { case LSRUN: - if (smpmode && LP(pp, tdflags) & TDF_RUNNING) - sprintf(status, "CPU%d", LP(pp, cpuid)); - else - strcpy(status, "RUN"); - break; + if (smpmode && LP(pp, tdflags) & TDF_RUNNING) + sprintf(status, "CPU%d", LP(pp, cpuid)); + else + strcpy(status, "RUN"); + break; case LSSLEEP: - if (LP(pp, wmesg) != NULL) { - sprintf(status, "%.6s", LP(pp, wmesg)); + if (LP(pp, wmesg) != NULL) { + sprintf(status, "%.6s", LP(pp, wmesg)); + break; + } + /* fall through */ + default: + + if (state >= 0 && + (unsigned)state < sizeof(state_abbrev) / sizeof(*state_abbrev)) + sprintf(status, "%.6s", state_abbrev[(unsigned char)state]); + else + sprintf(status, "?%5d", state); + break; + } + + if (PP(pp, stat) == SZOMB) + strcpy(status, "ZOMB"); + + /* + * idle time 0 - 31 -> nice value +21 - +52 normal time -> nice + * value -20 - +20 real time 0 - 31 -> nice value -52 - -21 thread + * 0 - 31 -> nice value -53 - + */ + switch (LP(pp, rtprio.type)) { + case RTP_PRIO_REALTIME: + xnice = PRIO_MIN - 1 - RTP_PRIO_MAX + LP(pp, rtprio.prio); + break; + case RTP_PRIO_IDLE: + xnice = PRIO_MAX + 1 + LP(pp, rtprio.prio); + break; + case RTP_PRIO_THREAD: + xnice = PRIO_MIN - 1 - RTP_PRIO_MAX - LP(pp, rtprio.prio); break; - } - /* fall through */ default: + xnice = PP(pp, nice); + break; + } - if (state >= 0 && - (unsigned)state < sizeof(state_abbrev) / sizeof(*state_abbrev)) - sprintf(status, "%.6s", state_abbrev[(unsigned char) state]); - else - sprintf(status, "?%5d", state); - break; - } - - if (PP(pp, stat) == SZOMB) - strcpy(status, "ZOMB"); - - /* - * idle time 0 - 31 -> nice value +21 - +52 - * normal time -> nice value -20 - +20 - * real time 0 - 31 -> nice value -52 - -21 - * thread 0 - 31 -> nice value -53 - - */ - switch(LP(pp, rtprio.type)) { - case RTP_PRIO_REALTIME: - xnice = PRIO_MIN - 1 - RTP_PRIO_MAX + LP(pp, rtprio.prio); - break; - case RTP_PRIO_IDLE: - xnice = PRIO_MAX + 1 + LP(pp, rtprio.prio); - break; - case RTP_PRIO_THREAD: - xnice = PRIO_MIN - 1 - RTP_PRIO_MAX - LP(pp, rtprio.prio); - break; - default: - xnice = PP(pp, nice); - break; - } - - /* format this entry */ - snprintf(fmt, sizeof(fmt), + /* format this entry */ + snprintf(fmt, sizeof(fmt), smpmode ? smp_Proc_format : up_Proc_format, (int)PP(pp, pid), namelength, namelength, get_userid(PP(pp, ruid)), (int)((show_threads && (LP(pp, pid) == -1)) ? - LP(pp, tdprio) : LP(pp, prio)), + LP(pp, tdprio) : LP(pp, prio)), (int)xnice, format_k(PROCSIZE(pp)), format_k(pagetok(VP(pp, rssize))), @@ -643,66 +630,33 @@ format_next_process(caddr_t xhandle, char *(*get_userid)(int)) cmdlength, printable(PP(pp, comm))); - /* return the result */ - return(fmt); + /* return the result */ + return (fmt); } -#if 0 -/* - * check_nlist(nlst) - checks the nlist to see if any symbols were not - * found. For every symbol that was not found, a one-line - * message is printed to stderr. The routine returns the - * number of symbols NOT found. - */ -static int -check_nlist(struct nlist *nlst) -{ - int i; - - /* check to see if we got ALL the symbols we requested */ - /* this will write one line to stderr for every symbol not found */ - - i = 0; - while (nlst->n_name != NULL) - { - if (nlst->n_type == 0) - { - /* this one wasn't found */ - (void) fprintf(stderr, "kernel: no symbol named `%s'\n", - nlst->n_name); - i = 1; - } - nlst++; - } - - return(i); -} -#endif - /* comparison routines for qsort */ /* - * proc_compare - comparison function for "qsort" - * Compares the resource consumption of two processes using five - * distinct keys. The keys (in descending order of importance) are: - * percent cpu, cpu ticks, state, resident set size, total virtual - * memory usage. The process states are ordered as follows (from least - * to most important): WAIT, zombie, sleep, stop, start, run. The - * array declaration below maps a process state index into a number - * that reflects this ordering. + * proc_compare - comparison function for "qsort" Compares the resource + * consumption of two processes using five distinct keys. The keys (in + * descending order of importance) are: percent cpu, cpu ticks, state, + * resident set size, total virtual memory usage. The process states are + * ordered as follows (from least to most important): WAIT, zombie, sleep, + * stop, start, run. The array declaration below maps a process state index + * into a number that reflects this ordering. */ static unsigned char sorted_state[] = { - 0, /* not used */ - 3, /* sleep */ - 1, /* ABANDONED (WAIT) */ - 6, /* run */ - 5, /* start */ - 2, /* zombie */ - 4 /* stop */ + 0, /* not used */ + 3, /* sleep */ + 1, /* ABANDONED (WAIT) */ + 6, /* run */ + 5, /* start */ + 2, /* zombie */ + 4 /* stop */ }; - + #define ORDERKEY_PCTCPU \ if (lresult = (long) LP(p2, pctcpu) - (long) LP(p1, pctcpu), \ @@ -728,7 +682,7 @@ static unsigned char sorted_state[] = if ((result = LP(p2, tdprio) - LP(p1, tdprio)) == 0) #define ORDERKEY_RSSIZE \ - if ((result = VP(p2, rssize) - VP(p1, rssize)) == 0) + if ((result = VP(p2, rssize) - VP(p1, rssize)) == 0) #define ORDERKEY_MEM \ if ( (result = PROCSIZE(p2) - PROCSIZE(p1)) == 0 ) @@ -738,26 +692,27 @@ static unsigned char sorted_state[] = int proc_compare(const void *arg1, const void *arg2) { - const struct proc *const*pp1 = arg1; - const struct proc *const*pp2 = arg2; - const struct kinfo_proc *p1; - const struct kinfo_proc *p2; - int result; - pctcpu lresult; - - /* remove one level of indirection */ - p1 = *(const struct kinfo_proc *const *) pp1; - p2 = *(const struct kinfo_proc *const *) pp2; - - ORDERKEY_PCTCPU - ORDERKEY_CPTICKS - ORDERKEY_STATE - ORDERKEY_PRIO - ORDERKEY_RSSIZE - ORDERKEY_MEM - {} - - return(result); + const struct proc *const *pp1 = arg1; + const struct proc *const *pp2 = arg2; + const struct kinfo_proc *p1; + const struct kinfo_proc *p2; + int result; + pctcpu lresult; + + /* remove one level of indirection */ + p1 = *(const struct kinfo_proc *const *)pp1; + p2 = *(const struct kinfo_proc *const *)pp2; + + ORDERKEY_PCTCPU + ORDERKEY_CPTICKS + ORDERKEY_STATE + ORDERKEY_PRIO + ORDERKEY_RSSIZE + ORDERKEY_MEM + { + } + + return (result); } /* compare_size - the comparison function for sorting by total memory usage */ @@ -765,26 +720,27 @@ proc_compare(const void *arg1, const void *arg2) int compare_size(const void *arg1, const void *arg2) { - struct proc *const *pp1 = arg1; - struct proc *const *pp2 = arg2; - struct kinfo_proc *p1; - struct kinfo_proc *p2; - int result; - pctcpu lresult; - - /* remove one level of indirection */ - p1 = *(struct kinfo_proc *const*) pp1; - p2 = *(struct kinfo_proc *const*) pp2; - - ORDERKEY_MEM - ORDERKEY_RSSIZE - ORDERKEY_PCTCPU - ORDERKEY_CPTICKS - ORDERKEY_STATE - ORDERKEY_PRIO - {} - - return(result); + struct proc *const *pp1 = arg1; + struct proc *const *pp2 = arg2; + struct kinfo_proc *p1; + struct kinfo_proc *p2; + int result; + pctcpu lresult; + + /* remove one level of indirection */ + p1 = *(struct kinfo_proc *const *)pp1; + p2 = *(struct kinfo_proc *const *)pp2; + + ORDERKEY_MEM + ORDERKEY_RSSIZE + ORDERKEY_PCTCPU + ORDERKEY_CPTICKS + ORDERKEY_STATE + ORDERKEY_PRIO + { + } + + return (result); } /* compare_res - the comparison function for sorting by resident set size */ @@ -792,26 +748,27 @@ compare_size(const void *arg1, const void *arg2) int compare_res(const void *arg1, const void *arg2) { - struct proc *const *pp1 = arg1; - struct proc *const *pp2 = arg2; - struct kinfo_proc *p1; - struct kinfo_proc *p2; - int result; - pctcpu lresult; - - /* remove one level of indirection */ - p1 = *(struct kinfo_proc *const*) pp1; - p2 = *(struct kinfo_proc *const*) pp2; - - ORDERKEY_RSSIZE - ORDERKEY_MEM - ORDERKEY_PCTCPU - ORDERKEY_CPTICKS - ORDERKEY_STATE - ORDERKEY_PRIO - {} - - return(result); + struct proc *const *pp1 = arg1; + struct proc *const *pp2 = arg2; + struct kinfo_proc *p1; + struct kinfo_proc *p2; + int result; + pctcpu lresult; + + /* remove one level of indirection */ + p1 = *(struct kinfo_proc *const *)pp1; + p2 = *(struct kinfo_proc *const *)pp2; + + ORDERKEY_RSSIZE + ORDERKEY_MEM + ORDERKEY_PCTCPU + ORDERKEY_CPTICKS + ORDERKEY_STATE + ORDERKEY_PRIO + { + } + + return (result); } /* compare_time - the comparison function for sorting by total cpu time */ @@ -819,119 +776,115 @@ compare_res(const void *arg1, const void *arg2) int compare_time(const void *arg1, const void *arg2) { - struct proc *const *pp1 = arg1; - struct proc *const *pp2 = arg2; - const struct kinfo_proc *p1; - const struct kinfo_proc *p2; - int result; - pctcpu lresult; - - /* remove one level of indirection */ - p1 = *(struct kinfo_proc *const*) pp1; - p2 = *(struct kinfo_proc *const*) pp2; - - ORDERKEY_CPTICKS - ORDERKEY_PCTCPU - ORDERKEY_KTHREADS - ORDERKEY_KTHREADS_PRIO - ORDERKEY_STATE - ORDERKEY_PRIO - ORDERKEY_RSSIZE - ORDERKEY_MEM - {} - - return(result); - } - + struct proc *const *pp1 = arg1; + struct proc *const *pp2 = arg2; + const struct kinfo_proc *p1; + const struct kinfo_proc *p2; + int result; + pctcpu lresult; + + /* remove one level of indirection */ + p1 = *(struct kinfo_proc *const *)pp1; + p2 = *(struct kinfo_proc *const *)pp2; + + ORDERKEY_CPTICKS + ORDERKEY_PCTCPU + ORDERKEY_KTHREADS + ORDERKEY_KTHREADS_PRIO + ORDERKEY_STATE + ORDERKEY_PRIO + ORDERKEY_RSSIZE + ORDERKEY_MEM + {} + + return (result); +} + /* compare_prio - the comparison function for sorting by cpu percentage */ int compare_prio(const void *arg1, const void *arg2) { - struct proc *const *pp1 = arg1; - struct proc *const *pp2 = arg2; - const struct kinfo_proc *p1; - const struct kinfo_proc *p2; - int result; - pctcpu lresult; - - /* remove one level of indirection */ - p1 = *(struct kinfo_proc *const*) pp1; - p2 = *(struct kinfo_proc *const*) pp2; - - ORDERKEY_KTHREADS - ORDERKEY_KTHREADS_PRIO - ORDERKEY_PRIO - ORDERKEY_CPTICKS - ORDERKEY_PCTCPU - ORDERKEY_STATE - ORDERKEY_RSSIZE - ORDERKEY_MEM - {} - - return(result); + struct proc *const *pp1 = arg1; + struct proc *const *pp2 = arg2; + const struct kinfo_proc *p1; + const struct kinfo_proc *p2; + int result; + pctcpu lresult; + + /* remove one level of indirection */ + p1 = *(struct kinfo_proc *const *)pp1; + p2 = *(struct kinfo_proc *const *)pp2; + + ORDERKEY_KTHREADS + ORDERKEY_KTHREADS_PRIO + ORDERKEY_PRIO + ORDERKEY_CPTICKS + ORDERKEY_PCTCPU + ORDERKEY_STATE + ORDERKEY_RSSIZE + ORDERKEY_MEM + {} + + return (result); } int compare_thr(const void *arg1, const void *arg2) { - struct proc *const *pp1 = arg1; - struct proc *const *pp2 = arg2; - const struct kinfo_proc *p1; - const struct kinfo_proc *p2; - int result; - pctcpu lresult; - - /* remove one level of indirection */ - p1 = *(struct kinfo_proc *const*) pp1; - p2 = *(struct kinfo_proc *const*) pp2; - - ORDERKEY_KTHREADS - ORDERKEY_KTHREADS_PRIO - ORDERKEY_CPTICKS - ORDERKEY_PCTCPU - ORDERKEY_STATE - ORDERKEY_RSSIZE - ORDERKEY_MEM - {} - - return(result); + struct proc *const *pp1 = arg1; + struct proc *const *pp2 = arg2; + const struct kinfo_proc *p1; + const struct kinfo_proc *p2; + int result; + pctcpu lresult; + + /* remove one level of indirection */ + p1 = *(struct kinfo_proc *const *)pp1; + p2 = *(struct kinfo_proc *const *)pp2; + + ORDERKEY_KTHREADS + ORDERKEY_KTHREADS_PRIO + ORDERKEY_CPTICKS + ORDERKEY_PCTCPU + ORDERKEY_STATE + ORDERKEY_RSSIZE + ORDERKEY_MEM + {} + + return (result); } /* - * proc_owner(pid) - returns the uid that owns process "pid", or -1 if - * the process does not exist. - * It is EXTREMLY IMPORTANT that this function work correctly. - * If top runs setuid root (as in SVR4), then this function - * is the only thing that stands in the way of a serious - * security problem. It validates requests for the "kill" - * and "renice" commands. + * proc_owner(pid) - returns the uid that owns process "pid", or -1 if the + * process does not exist. It is EXTREMLY IMPORTANT that this function work + * correctly. If top runs setuid root (as in SVR4), then this function is the + * only thing that stands in the way of a serious security problem. It + * validates requests for the "kill" and "renice" commands. */ int proc_owner(int pid) { - int xcnt; - struct kinfo_proc **prefp; - struct kinfo_proc *pp; - - prefp = pref; - xcnt = pref_len; - while (--xcnt >= 0) - { - pp = *prefp++; - if (PP(pp, pid) == (pid_t)pid) - { - return((int)PP(pp, ruid)); + int xcnt; + struct kinfo_proc **prefp; + struct kinfo_proc *pp; + + prefp = pref; + xcnt = pref_len; + while (--xcnt >= 0) { + pp = *prefp++; + if (PP(pp, pid) == (pid_t) pid) { + return ((int)PP(pp, ruid)); + } } - } - return(-1); + return (-1); } /* - * swapmode is based on a program called swapinfo written - * by Kevin Lahey . + * swapmode is based on a program called swapinfo written by Kevin Lahey + * . */ int swapmode(int *retavail, int *retfree) @@ -947,12 +900,12 @@ swapmode(int *retavail, int *retfree) n = kvm_getswapinfo(kd, swapary, 1, 0); if (n < 0 || swapary[0].ksw_total == 0) - return(0); + return (0); *retavail = CONVERT(swapary[0].ksw_total); *retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used); n = (int)((double)swapary[0].ksw_used * 100.0 / (double)swapary[0].ksw_total); - return(n); + return (n); }