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