1 /* $OpenBSD: utils.c,v 1.29 2018/09/22 17:10:28 millert Exp $ */ 2 3 /* 4 * Top users/processes display for Unix 5 * Version 3 6 * 7 * Copyright (c) 1984, 1989, William LeFebvre, Rice University 8 * Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR OR HIS EMPLOYER BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 /* 32 * This file contains various handy utilities used by top. 33 */ 34 35 #include <sys/types.h> 36 #include <sys/sysctl.h> 37 #include <err.h> 38 #include <stdio.h> 39 #include <string.h> 40 #include <stdlib.h> 41 #include <stdint.h> 42 #include <limits.h> 43 44 #include "top.h" 45 #include "machine.h" 46 #include "utils.h" 47 48 int 49 atoiwi(char *str) 50 { 51 size_t len; 52 const char *errstr; 53 int i; 54 55 len = strlen(str); 56 if (len != 0) { 57 if (strncmp(str, "infinity", len) == 0 || 58 strncmp(str, "all", len) == 0 || 59 strncmp(str, "maximum", len) == 0) { 60 return (Infinity); 61 } 62 i = (int)strtonum(str, 0, INT_MAX, &errstr); 63 if (errstr) { 64 return (Invalid); 65 } else 66 return (i); 67 } 68 return (0); 69 } 70 71 /* 72 * itoa - convert integer (decimal) to ascii string. 73 */ 74 char * 75 itoa(int val) 76 { 77 static char buffer[16]; /* result is built here */ 78 79 /* 80 * 16 is sufficient since the largest number we will ever convert 81 * will be 2^32-1, which is 10 digits. 82 */ 83 (void)snprintf(buffer, sizeof(buffer), "%d", val); 84 return (buffer); 85 } 86 87 /* 88 * format_uid(uid) - like itoa, except for uid_t and the number is right 89 * justified in a 6 character field to match uname_field in top.c. 90 */ 91 const char * 92 format_uid(uid_t uid, int nouser) 93 { 94 static char buffer[16]; /* result is built here */ 95 96 /* 97 * 16 is sufficient since the largest uid we will ever convert 98 * will be 2^32-1, which is 10 digits. 99 */ 100 (void)snprintf(buffer, sizeof(buffer), "%6u", uid); 101 return (buffer); 102 } 103 104 /* 105 * string_index(string, array) - find string in array and return index 106 */ 107 int 108 string_index(char *string, char **array) 109 { 110 int i = 0; 111 112 while (*array != NULL) { 113 if (strncmp(string, *array, strlen(string)) == 0) 114 return (i); 115 array++; 116 i++; 117 } 118 return (-1); 119 } 120 121 /* 122 * argparse(line, cntp) - parse arguments in string "line", separating them 123 * out into an argv-like array, and setting *cntp to the number of 124 * arguments encountered. This is a simple parser that doesn't understand 125 * squat about quotes. 126 */ 127 char ** 128 argparse(char *line, int *cntp) 129 { 130 char **argv, **argarray, *args, *from, *to; 131 int cnt, ch, length, lastch; 132 133 /* 134 * unfortunately, the only real way to do this is to go thru the 135 * input string twice. 136 */ 137 138 /* step thru the string counting the white space sections */ 139 from = line; 140 lastch = cnt = length = 0; 141 while ((ch = *from++) != '\0') { 142 length++; 143 if (ch == ' ' && lastch != ' ') 144 cnt++; 145 lastch = ch; 146 } 147 148 /* 149 * add three to the count: one for the initial "dummy" argument, one 150 * for the last argument and one for NULL 151 */ 152 cnt += 3; 153 154 /* allocate a char * array to hold the pointers */ 155 if ((argarray = calloc(cnt, sizeof(char *))) == NULL) 156 err(1, NULL); 157 158 /* allocate another array to hold the strings themselves */ 159 if ((args = malloc(length + 2)) == NULL) 160 err(1, NULL); 161 162 /* initialization for main loop */ 163 from = line; 164 to = args; 165 argv = argarray; 166 lastch = '\0'; 167 168 /* create a dummy argument to keep getopt happy */ 169 *argv++ = to; 170 *to++ = '\0'; 171 cnt = 2; 172 173 /* now build argv while copying characters */ 174 *argv++ = to; 175 while ((ch = *from++) != '\0') { 176 if (ch != ' ') { 177 if (lastch == ' ') { 178 *to++ = '\0'; 179 *argv++ = to; 180 cnt++; 181 } 182 *to++ = ch; 183 } 184 lastch = ch; 185 } 186 *to++ = '\0'; 187 188 /* set cntp and return the allocated array */ 189 *cntp = cnt; 190 return (argarray); 191 } 192 193 /* 194 * percentages(cnt, out, new, old, diffs) - calculate percentage change 195 * between array "old" and "new", putting the percentages in "out". 196 * "cnt" is size of each array and "diffs" is used for scratch space. 197 * The array "old" is updated on each call. 198 * The routine assumes modulo arithmetic. This function is especially 199 * useful on BSD machines for calculating cpu state percentages. 200 */ 201 int 202 percentages(int cnt, int64_t *out, int64_t *new, int64_t *old, int64_t *diffs) 203 { 204 int64_t change, total_change, *dp, half_total; 205 int i; 206 207 /* initialization */ 208 total_change = 0; 209 dp = diffs; 210 211 /* calculate changes for each state and the overall change */ 212 for (i = 0; i < cnt; i++) { 213 if ((change = *new - *old) < 0) { 214 /* this only happens when the counter wraps */ 215 change = INT64_MAX - *old + *new; 216 } 217 total_change += (*dp++ = change); 218 *old++ = *new++; 219 } 220 221 /* avoid divide by zero potential */ 222 if (total_change == 0) 223 total_change = 1; 224 225 /* calculate percentages based on overall change, rounding up */ 226 half_total = total_change / 2l; 227 for (i = 0; i < cnt; i++) 228 *out++ = ((*diffs++ * 1000 + half_total) / total_change); 229 230 /* return the total in case the caller wants to use it */ 231 return (total_change); 232 } 233 234 /* 235 * format_time(seconds) - format number of seconds into a suitable display 236 * that will fit within 6 characters. Note that this routine builds its 237 * string in a static area. If it needs to be called more than once without 238 * overwriting previous data, then we will need to adopt a technique similar 239 * to the one used for format_k. 240 */ 241 242 /* 243 * Explanation: We want to keep the output within 6 characters. For low 244 * values we use the format mm:ss. For values that exceed 999:59, we switch 245 * to a format that displays hours and fractions: hhh.tH. For values that 246 * exceed 999.9, we use hhhh.t and drop the "H" designator. For values that 247 * exceed 9999.9, we use "???". 248 */ 249 250 char * 251 format_time(time_t seconds) 252 { 253 static char result[10]; 254 255 /* sanity protection */ 256 if (seconds < 0 || seconds > (99999l * 360l)) { 257 strlcpy(result, " ???", sizeof result); 258 } else if (seconds >= (1000l * 60l)) { 259 /* alternate (slow) method displaying hours and tenths */ 260 snprintf(result, sizeof(result), "%5.1fH", 261 (double) seconds / (double) (60l * 60l)); 262 263 /* 264 * It is possible that the snprintf took more than 6 265 * characters. If so, then the "H" appears as result[6]. If 266 * not, then there is a \0 in result[6]. Either way, it is 267 * safe to step on. 268 */ 269 result[6] = '\0'; 270 } else { 271 /* standard method produces MMM:SS */ 272 /* we avoid printf as must as possible to make this quick */ 273 snprintf(result, sizeof(result), "%3d:%02d", (int)seconds / 60, 274 (int)seconds % 60); 275 } 276 return (result); 277 } 278 279 /* 280 * format_k(amt) - format a kilobyte memory value, returning a string 281 * suitable for display. Returns a pointer to a static 282 * area that changes each call. "amt" is converted to a 283 * string with a trailing "K". If "amt" is 10000 or greater, 284 * then it is formatted as megabytes (rounded) with a 285 * trailing "M". 286 */ 287 288 /* 289 * Compromise time. We need to return a string, but we don't want the 290 * caller to have to worry about freeing a dynamically allocated string. 291 * Unfortunately, we can't just return a pointer to a static area as one 292 * of the common uses of this function is in a large call to snprintf where 293 * it might get invoked several times. Our compromise is to maintain an 294 * array of strings and cycle thru them with each invocation. We make the 295 * array large enough to handle the above mentioned case. The constant 296 * NUM_STRINGS defines the number of strings in this array: we can tolerate 297 * up to NUM_STRINGS calls before we start overwriting old information. 298 * Keeping NUM_STRINGS a power of two will allow an intelligent optimizer 299 * to convert the modulo operation into something quicker. What a hack! 300 */ 301 302 #define NUM_STRINGS 8 303 304 char * 305 format_k(int amt) 306 { 307 static char retarray[NUM_STRINGS][16]; 308 static int idx = 0; 309 char *ret, tag = 'K'; 310 311 ret = retarray[idx]; 312 idx = (idx + 1) % NUM_STRINGS; 313 314 if (amt >= 10000) { 315 amt = (amt + 512) / 1024; 316 tag = 'M'; 317 if (amt >= 10000) { 318 amt = (amt + 512) / 1024; 319 tag = 'G'; 320 } 321 } 322 snprintf(ret, sizeof(retarray[0]), "%d%c", amt, tag); 323 return (ret); 324 } 325 326 int 327 find_pid(pid_t pid) 328 { 329 struct kinfo_proc *pbase, *cur; 330 int nproc; 331 332 if ((pbase = getprocs(KERN_PROC_KTHREAD, 0, &nproc)) == NULL) 333 quit(23); 334 335 for (cur = pbase; cur < &pbase[nproc]; cur++) 336 if (cur->p_pid == pid) 337 return 1; 338 return 0; 339 } 340