13be6ef06SEitan Adler /* 23be6ef06SEitan Adler * This program may be freely redistributed, 33be6ef06SEitan Adler * but this entire comment MUST remain intact. 43be6ef06SEitan Adler * 53be6ef06SEitan Adler * Copyright (c) 1984, 1989, William LeFebvre, Rice University 63be6ef06SEitan Adler * Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University 73be6ef06SEitan Adler * 83be6ef06SEitan Adler * $FreeBSD$ 93be6ef06SEitan Adler */ 103be6ef06SEitan Adler 113be6ef06SEitan Adler /* 123be6ef06SEitan Adler * This file contains various handy utilities used by top. 133be6ef06SEitan Adler */ 143be6ef06SEitan Adler 153be6ef06SEitan Adler #include "top.h" 16a5ca08edSEitan Adler #include "utils.h" 17caee4883SEitan Adler 18caee4883SEitan Adler #include <stdlib.h> 19caee4883SEitan Adler #include <stdio.h> 20caee4883SEitan Adler #include <string.h> 213be6ef06SEitan Adler 22b3c88c28SEitan Adler int 2366b3f031SEitan Adler atoiwi(const char *str) 243be6ef06SEitan Adler { 2598c299e0SEitan Adler int len; 263be6ef06SEitan Adler 273be6ef06SEitan Adler len = strlen(str); 283be6ef06SEitan Adler if (len != 0) 293be6ef06SEitan Adler { 303be6ef06SEitan Adler if (strncmp(str, "infinity", len) == 0 || 313be6ef06SEitan Adler strncmp(str, "all", len) == 0 || 323be6ef06SEitan Adler strncmp(str, "maximum", len) == 0) 333be6ef06SEitan Adler { 343be6ef06SEitan Adler return(Infinity); 353be6ef06SEitan Adler } 363be6ef06SEitan Adler else if (str[0] == '-') 373be6ef06SEitan Adler { 383be6ef06SEitan Adler return(Invalid); 393be6ef06SEitan Adler } 403be6ef06SEitan Adler else 413be6ef06SEitan Adler { 423be6ef06SEitan Adler return(atoi(str)); 433be6ef06SEitan Adler } 443be6ef06SEitan Adler } 453be6ef06SEitan Adler return(0); 463be6ef06SEitan Adler } 473be6ef06SEitan Adler 483be6ef06SEitan Adler /* 493be6ef06SEitan Adler * itoa - convert integer (decimal) to ascii string for positive numbers 503be6ef06SEitan Adler * only (we don't bother with negative numbers since we know we 513be6ef06SEitan Adler * don't use them). 523be6ef06SEitan Adler */ 533be6ef06SEitan Adler 543be6ef06SEitan Adler /* 553be6ef06SEitan Adler * How do we know that 16 will suffice? 563be6ef06SEitan Adler * Because the biggest number that we will 573be6ef06SEitan Adler * ever convert will be 2^32-1, which is 10 583be6ef06SEitan Adler * digits. 593be6ef06SEitan Adler */ 603be6ef06SEitan Adler _Static_assert(sizeof(int) <= 4, "buffer too small for this sized int"); 613be6ef06SEitan Adler 6219789395SEitan Adler char *itoa(unsigned int val) 633be6ef06SEitan Adler { 6498c299e0SEitan Adler char *ptr; 653be6ef06SEitan Adler static char buffer[16]; /* result is built here */ 663be6ef06SEitan Adler /* 16 is sufficient since the largest number 673be6ef06SEitan Adler we will ever convert will be 2^32-1, 683be6ef06SEitan Adler which is 10 digits. */ 693be6ef06SEitan Adler 703be6ef06SEitan Adler ptr = buffer + sizeof(buffer); 713be6ef06SEitan Adler *--ptr = '\0'; 723be6ef06SEitan Adler if (val == 0) 733be6ef06SEitan Adler { 743be6ef06SEitan Adler *--ptr = '0'; 753be6ef06SEitan Adler } 763be6ef06SEitan Adler else while (val != 0) 773be6ef06SEitan Adler { 783be6ef06SEitan Adler *--ptr = (val % 10) + '0'; 793be6ef06SEitan Adler val /= 10; 803be6ef06SEitan Adler } 813be6ef06SEitan Adler return(ptr); 823be6ef06SEitan Adler } 833be6ef06SEitan Adler 843be6ef06SEitan Adler /* 853be6ef06SEitan Adler * itoa7(val) - like itoa, except the number is right justified in a 7 863be6ef06SEitan Adler * character field. This code is a duplication of itoa instead of 873be6ef06SEitan Adler * a front end to a more general routine for efficiency. 883be6ef06SEitan Adler */ 893be6ef06SEitan Adler 9019789395SEitan Adler char *itoa7(unsigned int val) 913be6ef06SEitan Adler { 9298c299e0SEitan Adler char *ptr; 933be6ef06SEitan Adler static char buffer[16]; /* result is built here */ 943be6ef06SEitan Adler /* 16 is sufficient since the largest number 953be6ef06SEitan Adler we will ever convert will be 2^32-1, 963be6ef06SEitan Adler which is 10 digits. */ 973be6ef06SEitan Adler 983be6ef06SEitan Adler ptr = buffer + sizeof(buffer); 993be6ef06SEitan Adler *--ptr = '\0'; 1003be6ef06SEitan Adler if (val == 0) 1013be6ef06SEitan Adler { 1023be6ef06SEitan Adler *--ptr = '0'; 1033be6ef06SEitan Adler } 1043be6ef06SEitan Adler else while (val != 0) 1053be6ef06SEitan Adler { 1063be6ef06SEitan Adler *--ptr = (val % 10) + '0'; 1073be6ef06SEitan Adler val /= 10; 1083be6ef06SEitan Adler } 1093be6ef06SEitan Adler while (ptr > buffer + sizeof(buffer) - 7) 1103be6ef06SEitan Adler { 1113be6ef06SEitan Adler *--ptr = ' '; 1123be6ef06SEitan Adler } 1133be6ef06SEitan Adler return(ptr); 1143be6ef06SEitan Adler } 1153be6ef06SEitan Adler 1163be6ef06SEitan Adler /* 1173be6ef06SEitan Adler * digits(val) - return number of decimal digits in val. Only works for 1183be6ef06SEitan Adler * positive numbers. If val <= 0 then digits(val) == 0. 1193be6ef06SEitan Adler */ 1203be6ef06SEitan Adler 121f6234b51SEitan Adler int digits(int val) 1223be6ef06SEitan Adler { 12398c299e0SEitan Adler int cnt = 0; 1243be6ef06SEitan Adler 1253be6ef06SEitan Adler while (val > 0) 1263be6ef06SEitan Adler { 1273be6ef06SEitan Adler cnt++; 1283be6ef06SEitan Adler val /= 10; 1293be6ef06SEitan Adler } 1303be6ef06SEitan Adler return(cnt); 1313be6ef06SEitan Adler } 1323be6ef06SEitan Adler 1333be6ef06SEitan Adler /* 1343be6ef06SEitan Adler * strecpy(to, from) - copy string "from" into "to" and return a pointer 1353be6ef06SEitan Adler * to the END of the string "to". 1363be6ef06SEitan Adler */ 1373be6ef06SEitan Adler 138b3c88c28SEitan Adler char * 13966b3f031SEitan Adler strecpy(char *to, const char *from) 1403be6ef06SEitan Adler { 1413be6ef06SEitan Adler while ((*to++ = *from++) != '\0'); 1423be6ef06SEitan Adler return(--to); 1433be6ef06SEitan Adler } 1443be6ef06SEitan Adler 1453be6ef06SEitan Adler /* 1463be6ef06SEitan Adler * string_index(string, array) - find string in array and return index 1473be6ef06SEitan Adler */ 1483be6ef06SEitan Adler 149f6234b51SEitan Adler int 15066b3f031SEitan Adler string_index(const char *string, char *array[]) 1513be6ef06SEitan Adler { 152f6234b51SEitan Adler size_t i = 0; 1533be6ef06SEitan Adler 1543be6ef06SEitan Adler while (*array != NULL) 1553be6ef06SEitan Adler { 1563be6ef06SEitan Adler if (strcmp(string, *array) == 0) 1573be6ef06SEitan Adler { 1583be6ef06SEitan Adler return(i); 1593be6ef06SEitan Adler } 1603be6ef06SEitan Adler array++; 1613be6ef06SEitan Adler i++; 1623be6ef06SEitan Adler } 1633be6ef06SEitan Adler return(-1); 1643be6ef06SEitan Adler } 1653be6ef06SEitan Adler 1663be6ef06SEitan Adler /* 1673be6ef06SEitan Adler * argparse(line, cntp) - parse arguments in string "line", separating them 1683be6ef06SEitan Adler * out into an argv-like array, and setting *cntp to the number of 1693be6ef06SEitan Adler * arguments encountered. This is a simple parser that doesn't understand 1703be6ef06SEitan Adler * squat about quotes. 1713be6ef06SEitan Adler */ 1723be6ef06SEitan Adler 17366b3f031SEitan Adler char ** 17466b3f031SEitan Adler argparse(char *line, int *cntp) 1753be6ef06SEitan Adler { 17666b3f031SEitan Adler const char *from; 17798c299e0SEitan Adler char *to; 17898c299e0SEitan Adler int cnt; 17998c299e0SEitan Adler int ch; 1803be6ef06SEitan Adler int length; 1813be6ef06SEitan Adler int lastch; 18298c299e0SEitan Adler char **argv; 1833be6ef06SEitan Adler char **argarray; 1843be6ef06SEitan Adler char *args; 1853be6ef06SEitan Adler 1863be6ef06SEitan Adler /* unfortunately, the only real way to do this is to go thru the 1873be6ef06SEitan Adler input string twice. */ 1883be6ef06SEitan Adler 1893be6ef06SEitan Adler /* step thru the string counting the white space sections */ 1903be6ef06SEitan Adler from = line; 1913be6ef06SEitan Adler lastch = cnt = length = 0; 1923be6ef06SEitan Adler while ((ch = *from++) != '\0') 1933be6ef06SEitan Adler { 1943be6ef06SEitan Adler length++; 1953be6ef06SEitan Adler if (ch == ' ' && lastch != ' ') 1963be6ef06SEitan Adler { 1973be6ef06SEitan Adler cnt++; 1983be6ef06SEitan Adler } 1993be6ef06SEitan Adler lastch = ch; 2003be6ef06SEitan Adler } 2013be6ef06SEitan Adler 2023be6ef06SEitan Adler /* add three to the count: one for the initial "dummy" argument, 2033be6ef06SEitan Adler one for the last argument and one for NULL */ 2043be6ef06SEitan Adler cnt += 3; 2053be6ef06SEitan Adler 2063be6ef06SEitan Adler /* allocate a char * array to hold the pointers */ 207f6234b51SEitan Adler argarray = malloc(cnt * sizeof(char *)); 2083be6ef06SEitan Adler 2093be6ef06SEitan Adler /* allocate another array to hold the strings themselves */ 210f6234b51SEitan Adler args = malloc(length+2); 2113be6ef06SEitan Adler 2123be6ef06SEitan Adler /* initialization for main loop */ 2133be6ef06SEitan Adler from = line; 2143be6ef06SEitan Adler to = args; 2153be6ef06SEitan Adler argv = argarray; 2163be6ef06SEitan Adler lastch = '\0'; 2173be6ef06SEitan Adler 2183be6ef06SEitan Adler /* create a dummy argument to keep getopt happy */ 2193be6ef06SEitan Adler *argv++ = to; 2203be6ef06SEitan Adler *to++ = '\0'; 2213be6ef06SEitan Adler cnt = 2; 2223be6ef06SEitan Adler 2233be6ef06SEitan Adler /* now build argv while copying characters */ 2243be6ef06SEitan Adler *argv++ = to; 2253be6ef06SEitan Adler while ((ch = *from++) != '\0') 2263be6ef06SEitan Adler { 2273be6ef06SEitan Adler if (ch != ' ') 2283be6ef06SEitan Adler { 2293be6ef06SEitan Adler if (lastch == ' ') 2303be6ef06SEitan Adler { 2313be6ef06SEitan Adler *to++ = '\0'; 2323be6ef06SEitan Adler *argv++ = to; 2333be6ef06SEitan Adler cnt++; 2343be6ef06SEitan Adler } 2353be6ef06SEitan Adler *to++ = ch; 2363be6ef06SEitan Adler } 2373be6ef06SEitan Adler lastch = ch; 2383be6ef06SEitan Adler } 2393be6ef06SEitan Adler *to++ = '\0'; 2403be6ef06SEitan Adler 2413be6ef06SEitan Adler /* set cntp and return the allocated array */ 2423be6ef06SEitan Adler *cntp = cnt; 2433be6ef06SEitan Adler return(argarray); 2443be6ef06SEitan Adler } 2453be6ef06SEitan Adler 2463be6ef06SEitan Adler /* 2473be6ef06SEitan Adler * percentages(cnt, out, new, old, diffs) - calculate percentage change 2483be6ef06SEitan Adler * between array "old" and "new", putting the percentages i "out". 2493be6ef06SEitan Adler * "cnt" is size of each array and "diffs" is used for scratch space. 2503be6ef06SEitan Adler * The array "old" is updated on each call. 2513be6ef06SEitan Adler * The routine assumes modulo arithmetic. This function is especially 252f6234b51SEitan Adler * useful on for calculating cpu state percentages. 2533be6ef06SEitan Adler */ 2543be6ef06SEitan Adler 255f6234b51SEitan Adler long 256f6234b51SEitan Adler percentages(int cnt, int *out, long *new, long *old, long *diffs) 2573be6ef06SEitan Adler { 25898c299e0SEitan Adler int i; 25998c299e0SEitan Adler long change; 26098c299e0SEitan Adler long total_change; 26198c299e0SEitan Adler long *dp; 2623be6ef06SEitan Adler long half_total; 2633be6ef06SEitan Adler 2643be6ef06SEitan Adler /* initialization */ 2653be6ef06SEitan Adler total_change = 0; 2663be6ef06SEitan Adler dp = diffs; 2673be6ef06SEitan Adler 2683be6ef06SEitan Adler /* calculate changes for each state and the overall change */ 2693be6ef06SEitan Adler for (i = 0; i < cnt; i++) 2703be6ef06SEitan Adler { 2713be6ef06SEitan Adler if ((change = *new - *old) < 0) 2723be6ef06SEitan Adler { 2733be6ef06SEitan Adler /* this only happens when the counter wraps */ 2743be6ef06SEitan Adler change = (int) 2753be6ef06SEitan Adler ((unsigned long)*new-(unsigned long)*old); 2763be6ef06SEitan Adler } 2773be6ef06SEitan Adler total_change += (*dp++ = change); 2783be6ef06SEitan Adler *old++ = *new++; 2793be6ef06SEitan Adler } 2803be6ef06SEitan Adler 2813be6ef06SEitan Adler /* avoid divide by zero potential */ 2823be6ef06SEitan Adler if (total_change == 0) 2833be6ef06SEitan Adler { 2843be6ef06SEitan Adler total_change = 1; 2853be6ef06SEitan Adler } 2863be6ef06SEitan Adler 2873be6ef06SEitan Adler /* calculate percentages based on overall change, rounding up */ 2883be6ef06SEitan Adler half_total = total_change / 2l; 2893be6ef06SEitan Adler 2903be6ef06SEitan Adler /* Do not divide by 0. Causes Floating point exception */ 2913be6ef06SEitan Adler if(total_change) { 2923be6ef06SEitan Adler for (i = 0; i < cnt; i++) 2933be6ef06SEitan Adler { 2943be6ef06SEitan Adler *out++ = (int)((*diffs++ * 1000 + half_total) / total_change); 2953be6ef06SEitan Adler } 2963be6ef06SEitan Adler } 2973be6ef06SEitan Adler 2983be6ef06SEitan Adler /* return the total in case the caller wants to use it */ 2993be6ef06SEitan Adler return(total_change); 3003be6ef06SEitan Adler } 3013be6ef06SEitan Adler 3023be6ef06SEitan Adler /* format_time(seconds) - format number of seconds into a suitable 3033be6ef06SEitan Adler * display that will fit within 6 characters. Note that this 3043be6ef06SEitan Adler * routine builds its string in a static area. If it needs 3053be6ef06SEitan Adler * to be called more than once without overwriting previous data, 3063be6ef06SEitan Adler * then we will need to adopt a technique similar to the 3073be6ef06SEitan Adler * one used for format_k. 3083be6ef06SEitan Adler */ 3093be6ef06SEitan Adler 3103be6ef06SEitan Adler /* Explanation: 3113be6ef06SEitan Adler We want to keep the output within 6 characters. For low values we use 3123be6ef06SEitan Adler the format mm:ss. For values that exceed 999:59, we switch to a format 3133be6ef06SEitan Adler that displays hours and fractions: hhh.tH. For values that exceed 3143be6ef06SEitan Adler 999.9, we use hhhh.t and drop the "H" designator. For values that 3153be6ef06SEitan Adler exceed 9999.9, we use "???". 3163be6ef06SEitan Adler */ 3173be6ef06SEitan Adler 318f6234b51SEitan Adler char * 319f6234b51SEitan Adler format_time(long seconds) 3203be6ef06SEitan Adler { 3213be6ef06SEitan Adler static char result[10]; 3223be6ef06SEitan Adler 3233be6ef06SEitan Adler /* sanity protection */ 3243be6ef06SEitan Adler if (seconds < 0 || seconds > (99999l * 360l)) 3253be6ef06SEitan Adler { 3263be6ef06SEitan Adler strcpy(result, " ???"); 3273be6ef06SEitan Adler } 3283be6ef06SEitan Adler else if (seconds >= (1000l * 60l)) 3293be6ef06SEitan Adler { 3303be6ef06SEitan Adler /* alternate (slow) method displaying hours and tenths */ 3313be6ef06SEitan Adler sprintf(result, "%5.1fH", (double)seconds / (double)(60l * 60l)); 3323be6ef06SEitan Adler 3333be6ef06SEitan Adler /* It is possible that the sprintf took more than 6 characters. 3343be6ef06SEitan Adler If so, then the "H" appears as result[6]. If not, then there 3353be6ef06SEitan Adler is a \0 in result[6]. Either way, it is safe to step on. 3363be6ef06SEitan Adler */ 3373be6ef06SEitan Adler result[6] = '\0'; 3383be6ef06SEitan Adler } 3393be6ef06SEitan Adler else 3403be6ef06SEitan Adler { 3413be6ef06SEitan Adler /* standard method produces MMM:SS */ 3423be6ef06SEitan Adler /* we avoid printf as must as possible to make this quick */ 3433be6ef06SEitan Adler sprintf(result, "%3ld:%02ld", 3443be6ef06SEitan Adler (long)(seconds / 60), (long)(seconds % 60)); 3453be6ef06SEitan Adler } 3463be6ef06SEitan Adler return(result); 3473be6ef06SEitan Adler } 3483be6ef06SEitan Adler 3493be6ef06SEitan Adler /* 3503be6ef06SEitan Adler * format_k(amt) - format a kilobyte memory value, returning a string 3513be6ef06SEitan Adler * suitable for display. Returns a pointer to a static 3523be6ef06SEitan Adler * area that changes each call. "amt" is converted to a 3533be6ef06SEitan Adler * string with a trailing "K". If "amt" is 10000 or greater, 3543be6ef06SEitan Adler * then it is formatted as megabytes (rounded) with a 3553be6ef06SEitan Adler * trailing "M". 3563be6ef06SEitan Adler */ 3573be6ef06SEitan Adler 3583be6ef06SEitan Adler /* 3593be6ef06SEitan Adler * Compromise time. We need to return a string, but we don't want the 3603be6ef06SEitan Adler * caller to have to worry about freeing a dynamically allocated string. 3613be6ef06SEitan Adler * Unfortunately, we can't just return a pointer to a static area as one 3623be6ef06SEitan Adler * of the common uses of this function is in a large call to sprintf where 3633be6ef06SEitan Adler * it might get invoked several times. Our compromise is to maintain an 3643be6ef06SEitan Adler * array of strings and cycle thru them with each invocation. We make the 3653be6ef06SEitan Adler * array large enough to handle the above mentioned case. The constant 3663be6ef06SEitan Adler * NUM_STRINGS defines the number of strings in this array: we can tolerate 3673be6ef06SEitan Adler * up to NUM_STRINGS calls before we start overwriting old information. 3683be6ef06SEitan Adler * Keeping NUM_STRINGS a power of two will allow an intelligent optimizer 3693be6ef06SEitan Adler * to convert the modulo operation into something quicker. What a hack! 3703be6ef06SEitan Adler */ 3713be6ef06SEitan Adler 3723be6ef06SEitan Adler #define NUM_STRINGS 8 3733be6ef06SEitan Adler 3749aeb8f99SEitan Adler char *format_k(int amt) 3753be6ef06SEitan Adler { 3763be6ef06SEitan Adler static char retarray[NUM_STRINGS][16]; 3773be6ef06SEitan Adler static int index = 0; 37898c299e0SEitan Adler char *p; 37998c299e0SEitan Adler char *ret; 38098c299e0SEitan Adler char tag = 'K'; 3813be6ef06SEitan Adler 3823be6ef06SEitan Adler p = ret = retarray[index]; 3833be6ef06SEitan Adler index = (index + 1) % NUM_STRINGS; 3843be6ef06SEitan Adler 3853be6ef06SEitan Adler if (amt >= 10000) 3863be6ef06SEitan Adler { 3873be6ef06SEitan Adler amt = (amt + 512) / 1024; 3883be6ef06SEitan Adler tag = 'M'; 3893be6ef06SEitan Adler if (amt >= 10000) 3903be6ef06SEitan Adler { 3913be6ef06SEitan Adler amt = (amt + 512) / 1024; 3923be6ef06SEitan Adler tag = 'G'; 3933be6ef06SEitan Adler } 3943be6ef06SEitan Adler } 3953be6ef06SEitan Adler 3963be6ef06SEitan Adler p = strecpy(p, itoa(amt)); 3973be6ef06SEitan Adler *p++ = tag; 3983be6ef06SEitan Adler *p = '\0'; 3993be6ef06SEitan Adler 4003be6ef06SEitan Adler return(ret); 4013be6ef06SEitan Adler } 4023be6ef06SEitan Adler 403a5ca08edSEitan Adler char * 404a5ca08edSEitan Adler format_k2(unsigned long long amt) 4053be6ef06SEitan Adler { 4063be6ef06SEitan Adler static char retarray[NUM_STRINGS][16]; 4073be6ef06SEitan Adler static int index = 0; 40898c299e0SEitan Adler char *p; 40998c299e0SEitan Adler char *ret; 41098c299e0SEitan Adler char tag = 'K'; 4113be6ef06SEitan Adler 4123be6ef06SEitan Adler p = ret = retarray[index]; 4133be6ef06SEitan Adler index = (index + 1) % NUM_STRINGS; 4143be6ef06SEitan Adler 4153be6ef06SEitan Adler if (amt >= 100000) 4163be6ef06SEitan Adler { 4173be6ef06SEitan Adler amt = (amt + 512) / 1024; 4183be6ef06SEitan Adler tag = 'M'; 4193be6ef06SEitan Adler if (amt >= 100000) 4203be6ef06SEitan Adler { 4213be6ef06SEitan Adler amt = (amt + 512) / 1024; 4223be6ef06SEitan Adler tag = 'G'; 4233be6ef06SEitan Adler } 4243be6ef06SEitan Adler } 4253be6ef06SEitan Adler 4263be6ef06SEitan Adler p = strecpy(p, itoa((int)amt)); 4273be6ef06SEitan Adler *p++ = tag; 4283be6ef06SEitan Adler *p = '\0'; 4293be6ef06SEitan Adler 4303be6ef06SEitan Adler return(ret); 4313be6ef06SEitan Adler } 432