1 /* 2 * This program may be freely redistributed, 3 * but this entire comment MUST remain intact. 4 * 5 * Copyright (c) 2018, Eitan Adler 6 * Copyright (c) 1984, 1989, William LeFebvre, Rice University 7 * Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University 8 */ 9 10 /* 11 * This file contains various handy utilities used by top. 12 */ 13 14 #include "top.h" 15 #include "utils.h" 16 17 #include <sys/param.h> 18 #include <sys/sysctl.h> 19 #include <sys/user.h> 20 21 #include <libutil.h> 22 #include <stdlib.h> 23 #include <stdio.h> 24 #include <string.h> 25 #include <fcntl.h> 26 #include <paths.h> 27 #include <kvm.h> 28 29 int 30 atoiwi(const char *str) 31 { 32 size_t len; 33 34 len = strlen(str); 35 if (len != 0) 36 { 37 if (strncmp(str, "infinity", len) == 0 || 38 strncmp(str, "all", len) == 0 || 39 strncmp(str, "maximum", len) == 0) 40 { 41 return(Infinity); 42 } 43 else if (str[0] == '-') 44 { 45 return(Invalid); 46 } 47 else 48 { 49 return((int)strtol(str, NULL, 10)); 50 } 51 } 52 return(0); 53 } 54 55 /* 56 * itoa - convert integer (decimal) to ascii string for positive numbers 57 * only (we don't bother with negative numbers since we know we 58 * don't use them). 59 */ 60 61 /* 62 * How do we know that 16 will suffice? 63 * Because the biggest number that we will 64 * ever convert will be 2^32-1, which is 10 65 * digits. 66 */ 67 _Static_assert(sizeof(int) <= 4, "buffer too small for this sized int"); 68 69 char * 70 itoa(unsigned int val) 71 { 72 static char buffer[16]; /* result is built here */ 73 /* 16 is sufficient since the largest number 74 we will ever convert will be 2^32-1, 75 which is 10 digits. */ 76 77 sprintf(buffer, "%u", val); 78 return (buffer); 79 } 80 81 /* 82 * itoa7(val) - like itoa, except the number is right justified in a 7 83 * character field. This code is a duplication of itoa instead of 84 * a front end to a more general routine for efficiency. 85 */ 86 87 char * 88 itoa7(int val) 89 { 90 static char buffer[16]; /* result is built here */ 91 /* 16 is sufficient since the largest number 92 we will ever convert will be 2^32-1, 93 which is 10 digits. */ 94 95 sprintf(buffer, "%6u", val); 96 return (buffer); 97 } 98 99 /* 100 * digits(val) - return number of decimal digits in val. Only works for 101 * non-negative numbers. 102 */ 103 104 int __pure2 105 digits(int val) 106 { 107 int cnt = 0; 108 if (val == 0) { 109 return 1; 110 } 111 112 while (val > 0) { 113 cnt++; 114 val /= 10; 115 } 116 return(cnt); 117 } 118 119 /* 120 * argparse(line, cntp) - parse arguments in string "line", separating them 121 * out into an argv-like array, and setting *cntp to the number of 122 * arguments encountered. This is a simple parser that doesn't understand 123 * squat about quotes. 124 */ 125 126 const char ** 127 argparse(char *line, int *cntp) 128 { 129 const char **ap; 130 static const char *argv[1024] = {0}; 131 132 *cntp = 1; 133 ap = &argv[1]; 134 while ((*ap = strsep(&line, " ")) != NULL) { 135 if (**ap != '\0') { 136 (*cntp)++; 137 if (*cntp >= (int)nitems(argv)) { 138 break; 139 } 140 ap++; 141 } 142 } 143 return (argv); 144 } 145 146 /* 147 * percentages(cnt, out, new, old, diffs) - calculate percentage change 148 * between array "old" and "new", putting the percentages i "out". 149 * "cnt" is size of each array and "diffs" is used for scratch space. 150 * The array "old" is updated on each call. 151 * The routine assumes modulo arithmetic. This function is especially 152 * useful on for calculating cpu state percentages. 153 */ 154 155 long 156 percentages(int cnt, int *out, long *new, long *old, long *diffs) 157 { 158 int i; 159 long change; 160 long total_change; 161 long *dp; 162 long half_total; 163 164 /* initialization */ 165 total_change = 0; 166 dp = diffs; 167 168 /* calculate changes for each state and the overall change */ 169 for (i = 0; i < cnt; i++) 170 { 171 if ((change = *new - *old) < 0) 172 { 173 /* this only happens when the counter wraps */ 174 change = (int) 175 ((unsigned long)*new-(unsigned long)*old); 176 } 177 total_change += (*dp++ = change); 178 *old++ = *new++; 179 } 180 181 /* avoid divide by zero potential */ 182 if (total_change == 0) 183 { 184 total_change = 1; 185 } 186 187 /* calculate percentages based on overall change, rounding up */ 188 half_total = total_change / 2l; 189 190 for (i = 0; i < cnt; i++) 191 { 192 *out++ = (int)((*diffs++ * 1000 + half_total) / total_change); 193 } 194 195 /* return the total in case the caller wants to use it */ 196 return(total_change); 197 } 198 199 /* format_time(seconds) - format number of seconds into a suitable 200 * display that will fit within 6 characters. Note that this 201 * routine builds its string in a static area. If it needs 202 * to be called more than once without overwriting previous data, 203 * then we will need to adopt a technique similar to the 204 * one used for format_k. 205 */ 206 207 /* Explanation: 208 We want to keep the output within 6 characters. For low values we use 209 the format mm:ss. For values that exceed 999:59, we switch to a format 210 that displays hours and fractions: hhh.tH. For values that exceed 211 999.9, we use hhhh.t and drop the "H" designator. For values that 212 exceed 9999.9, we use "???". 213 */ 214 215 const char * 216 format_time(long seconds) 217 { 218 static char result[10]; 219 220 /* sanity protection */ 221 if (seconds < 0 || seconds > (99999l * 360l)) 222 { 223 strcpy(result, " ???"); 224 } 225 else if (seconds >= (1000l * 60l)) 226 { 227 /* alternate (slow) method displaying hours and tenths */ 228 sprintf(result, "%5.1fH", (double)seconds / (double)(60l * 60l)); 229 230 /* It is possible that the sprintf took more than 6 characters. 231 If so, then the "H" appears as result[6]. If not, then there 232 is a \0 in result[6]. Either way, it is safe to step on. 233 */ 234 result[6] = '\0'; 235 } 236 else 237 { 238 /* standard method produces MMM:SS */ 239 sprintf(result, "%3ld:%02ld", 240 seconds / 60l, seconds % 60l); 241 } 242 return(result); 243 } 244 245 /* 246 * format_k(amt) - format a kilobyte memory value, returning a string 247 * suitable for display. Returns a pointer to a static 248 * area that changes each call. "amt" is converted to a fixed 249 * size humanize_number call 250 */ 251 252 /* 253 * Compromise time. We need to return a string, but we don't want the 254 * caller to have to worry about freeing a dynamically allocated string. 255 * Unfortunately, we can't just return a pointer to a static area as one 256 * of the common uses of this function is in a large call to sprintf where 257 * it might get invoked several times. Our compromise is to maintain an 258 * array of strings and cycle thru them with each invocation. We make the 259 * array large enough to handle the above mentioned case. The constant 260 * NUM_STRINGS defines the number of strings in this array: we can tolerate 261 * up to NUM_STRINGS calls before we start overwriting old information. 262 * Keeping NUM_STRINGS a power of two will allow an intelligent optimizer 263 * to convert the modulo operation into something quicker. What a hack! 264 */ 265 266 #define NUM_STRINGS 8 267 268 char * 269 format_k(int64_t amt) 270 { 271 static char retarray[NUM_STRINGS][16]; 272 static int index_ = 0; 273 char *ret; 274 275 ret = retarray[index_]; 276 index_ = (index_ + 1) % NUM_STRINGS; 277 humanize_number(ret, 6, amt * 1024, "", HN_AUTOSCALE, HN_NOSPACE | 278 HN_B); 279 return (ret); 280 } 281 282 int 283 find_pid(pid_t pid) 284 { 285 kvm_t *kd = NULL; 286 struct kinfo_proc *pbase = NULL; 287 int nproc; 288 int ret = 0; 289 290 kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL); 291 if (kd == NULL) { 292 fprintf(stderr, "top: kvm_open() failed.\n"); 293 quit(TOP_EX_SYS_ERROR); 294 } 295 296 pbase = kvm_getprocs(kd, KERN_PROC_PID, pid, &nproc); 297 if (pbase == NULL) { 298 goto done; 299 } 300 301 if ((nproc == 1) && (pbase->ki_pid == pid)) { 302 ret = 1; 303 } 304 305 done: 306 kvm_close(kd); 307 return ret; 308 } 309