1 /*- 2 * Copyright (c) 1980, 1992, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)pigs.c 8.2 (Berkeley) 9/23/93 34 * 35 * $DragonFly: src/usr.bin/systat/pigs.c,v 1.16 2008/11/10 04:59:45 swildner Exp $ 36 */ 37 38 /* 39 * Pigs display from Bill Reeves at Lucasfilm 40 */ 41 42 #define _KERNEL_STRUCTURES 43 #include <sys/param.h> 44 #include <sys/time.h> 45 #include <sys/user.h> 46 #include <sys/sysctl.h> 47 48 #include <curses.h> 49 #include <err.h> 50 #include <kinfo.h> 51 #include <math.h> 52 #include <nlist.h> 53 #include <pwd.h> 54 #include <stdlib.h> 55 56 #include "systat.h" 57 #include "extern.h" 58 59 int compar(const void *, const void *); 60 61 static int nproc; 62 static struct p_times { 63 float pt_pctcpu; 64 struct kinfo_proc *pt_kp; 65 } *pt; 66 67 struct kinfo_cputime old_cp_time; 68 static long fscale; 69 static double lccpu; 70 71 WINDOW * 72 openpigs(void) 73 { 74 return (subwin(stdscr, LINES-5-1, 0, 5, 0)); 75 } 76 77 void 78 closepigs(WINDOW *w) 79 { 80 if (w == NULL) 81 return; 82 wclear(w); 83 wrefresh(w); 84 delwin(w); 85 } 86 87 88 void 89 showpigs(void) 90 { 91 int i, j, y, k; 92 float total; 93 int factor; 94 const char *uname, *pname; 95 char pidname[30]; 96 97 if (pt == NULL) 98 return; 99 /* Accumulate the percent of cpu per user. */ 100 total = 0.0; 101 for (i = 0; i <= nproc; i++) { 102 /* Accumulate the percentage. */ 103 total += pt[i].pt_pctcpu; 104 } 105 106 if (total < 1.0) 107 total = 1.0; 108 factor = 50.0/total; 109 110 qsort(pt, nproc + 1, sizeof (struct p_times), compar); 111 y = 1; 112 i = nproc + 1; 113 if (i > wnd->_maxy-1) 114 i = wnd->_maxy-1; 115 for (k = 0; i > 0; i--, y++, k++) { 116 if (pt[k].pt_pctcpu <= 0.01 && 117 (pt[k].pt_kp == NULL || 118 pt[k].pt_kp->kp_lwp.kl_slptime > 1) 119 ) { 120 --y; 121 continue; 122 } 123 if (pt[k].pt_kp == NULL) { 124 uname = ""; 125 pname = "<idle>"; 126 } else { 127 uname = user_from_uid(pt[k].pt_kp->kp_uid, 0); 128 pname = pt[k].pt_kp->kp_comm; 129 } 130 wmove(wnd, y, 0); 131 wclrtoeol(wnd); 132 mvwaddstr(wnd, y, 0, uname); 133 snprintf(pidname, sizeof(pidname), "%10.10s", pname); 134 mvwaddstr(wnd, y, 9, pidname); 135 wmove(wnd, y, 20); 136 for (j = pt[k].pt_pctcpu*factor + 0.5; j > 0; j--) 137 waddch(wnd, 'X'); 138 } 139 wmove(wnd, y, 0); wclrtobot(wnd); 140 } 141 142 static struct nlist namelist[] = { 143 #define X_FIRST 0 144 #define X_FSCALE 0 145 { .n_name = "_fscale" }, 146 147 { .n_name = "" } 148 }; 149 150 int 151 initpigs(void) 152 { 153 int ccpu; 154 155 if (namelist[X_FIRST].n_type == 0) { 156 if (kvm_nlist(kd, namelist)) { 157 nlisterr(namelist); 158 return(0); 159 } 160 if (namelist[X_FIRST].n_type == 0) { 161 error("namelist failed"); 162 return(0); 163 } 164 } 165 if (kinfo_get_sched_cputime(&old_cp_time)) 166 err(1, "kinfo_get_sched_cputime"); 167 if (kinfo_get_sched_ccpu(&ccpu)) 168 err(1, "kinfo_get_sched_ccpu"); 169 170 NREAD(X_FSCALE, &fscale, LONG); 171 lccpu = log((double) ccpu / fscale); 172 173 return(1); 174 } 175 176 void 177 fetchpigs(void) 178 { 179 int i; 180 float ftime; 181 float *pctp; 182 struct kinfo_proc *kpp, *pp; 183 struct kinfo_cputime cp_time, diff_cp_time; 184 double t; 185 static int lastnproc = 0; 186 187 if (namelist[X_FIRST].n_type == 0) 188 return; 189 if ((kpp = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc)) == NULL) { 190 error("%s", kvm_geterr(kd)); 191 if (pt) 192 free(pt); 193 return; 194 } 195 if (nproc > lastnproc) { 196 free(pt); 197 if ((pt = 198 malloc((nproc + 1) * sizeof(struct p_times))) == NULL) { 199 error("Out of memory"); 200 die(0); 201 } 202 } 203 lastnproc = nproc; 204 /* 205 * calculate %cpu for each proc 206 */ 207 for (i = 0; i < nproc; i++) { 208 pt[i].pt_kp = &kpp[i]; 209 pp = &kpp[i]; 210 pctp = &pt[i].pt_pctcpu; 211 ftime = pp->kp_swtime; 212 if (ftime == 0 || (pp->kp_flags & P_SWAPPEDOUT)) 213 *pctp = 0; 214 else 215 *pctp = ((double) pp->kp_lwp.kl_pctcpu / 216 fscale) / (1.0 - exp(ftime * lccpu)); 217 } 218 /* 219 * and for the imaginary "idle" process 220 */ 221 if (kinfo_get_sched_cputime(&cp_time)) 222 err(1, "kinfo_get_sched_cputime"); 223 diff_cp_time.cp_user = cp_time.cp_user - old_cp_time.cp_user; 224 diff_cp_time.cp_nice = cp_time.cp_nice - old_cp_time.cp_nice; 225 diff_cp_time.cp_sys = cp_time.cp_sys - old_cp_time.cp_sys; 226 diff_cp_time.cp_intr = cp_time.cp_intr - old_cp_time.cp_intr; 227 diff_cp_time.cp_idle = cp_time.cp_idle - old_cp_time.cp_idle; 228 old_cp_time = cp_time; 229 t = diff_cp_time.cp_user + diff_cp_time.cp_nice + 230 diff_cp_time.cp_sys + diff_cp_time.cp_intr + 231 diff_cp_time.cp_idle; 232 if (t == 0.0) 233 t = 1.0; 234 pt[nproc].pt_kp = NULL; 235 pt[nproc].pt_pctcpu = diff_cp_time.cp_idle / t; 236 } 237 238 void 239 labelpigs(void) 240 { 241 wmove(wnd, 0, 0); 242 wclrtoeol(wnd); 243 mvwaddstr(wnd, 0, 20, 244 "/0 /10 /20 /30 /40 /50 /60 /70 /80 /90 /100"); 245 } 246 247 int 248 compar(const void *a, const void *b) 249 { 250 const struct p_times *pta = (const struct p_times *)a; 251 const struct p_times *ptb = (const struct p_times *)b; 252 float d; 253 254 /* 255 * Check overall cpu percentage first. 256 */ 257 d = pta->pt_pctcpu - ptb->pt_pctcpu; 258 if (d > 0.10) 259 return(-1); /* a is better */ 260 else if (d < -0.10) 261 return(1); /* b is better */ 262 263 if (pta->pt_kp == NULL && ptb->pt_kp == NULL) 264 return(0); 265 if (ptb->pt_kp == NULL) 266 return(-1); /* a is better */ 267 if (pta->pt_kp == NULL) 268 return(1); /* b is better */ 269 /* 270 * Then check sleep times and run status. 271 */ 272 if (pta->pt_kp->kp_lwp.kl_slptime < ptb->pt_kp->kp_lwp.kl_slptime) 273 return(-1); 274 if (pta->pt_kp->kp_lwp.kl_slptime > ptb->pt_kp->kp_lwp.kl_slptime) 275 return(1); 276 277 /* 278 * Runnability 279 */ 280 if (pta->pt_kp->kp_lwp.kl_stat != ptb->pt_kp->kp_lwp.kl_stat) { 281 if (pta->pt_kp->kp_lwp.kl_stat == LSRUN) 282 return(-1); 283 if (ptb->pt_kp->kp_lwp.kl_stat == LSRUN) 284 return(1); 285 } 286 return(0); 287 } 288