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