Annotation of /trunk/mkinitrd-magellan/busybox/procps/nmeter.c
Parent Directory | Revision Log
Revision 816 -
(hide annotations)
(download)
Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
File MIME type: text/plain
File size: 19445 byte(s)
Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
File MIME type: text/plain
File size: 19445 byte(s)
-updated to busybox-1.13.4
1 | niro | 816 | /* |
2 | ** Licensed under the GPL v2, see the file LICENSE in this tarball | ||
3 | ** | ||
4 | ** Based on nanotop.c from floppyfw project | ||
5 | ** | ||
6 | ** Contact me: vda.linux@googlemail.com */ | ||
7 | |||
8 | //TODO: | ||
9 | // simplify code | ||
10 | // /proc/locks | ||
11 | // /proc/stat: | ||
12 | // disk_io: (3,0):(22272,17897,410702,4375,54750) | ||
13 | // btime 1059401962 | ||
14 | //TODO: use sysinfo libc call/syscall, if appropriate | ||
15 | // (faster than open/read/close): | ||
16 | // sysinfo({uptime=15017, loads=[5728, 15040, 16480] | ||
17 | // totalram=2107416576, freeram=211525632, sharedram=0, bufferram=157204480} | ||
18 | // totalswap=134209536, freeswap=134209536, procs=157}) | ||
19 | |||
20 | #include <time.h> | ||
21 | #include "libbb.h" | ||
22 | |||
23 | typedef unsigned long long ullong; | ||
24 | |||
25 | enum { /* Preferably use powers of 2 */ | ||
26 | PROC_MIN_FILE_SIZE = 256, | ||
27 | PROC_MAX_FILE_SIZE = 16 * 1024, | ||
28 | }; | ||
29 | |||
30 | typedef struct proc_file { | ||
31 | char *file; | ||
32 | int file_sz; | ||
33 | smallint last_gen; | ||
34 | } proc_file; | ||
35 | |||
36 | static const char *const proc_name[] = { | ||
37 | "stat", // Must match the order of proc_file's! | ||
38 | "loadavg", | ||
39 | "net/dev", | ||
40 | "meminfo", | ||
41 | "diskstats", | ||
42 | "sys/fs/file-nr" | ||
43 | }; | ||
44 | |||
45 | struct globals { | ||
46 | // Sample generation flip-flop | ||
47 | smallint gen; | ||
48 | // Linux 2.6? (otherwise assumes 2.4) | ||
49 | smallint is26; | ||
50 | // 1 if sample delay is not an integer fraction of a second | ||
51 | smallint need_seconds; | ||
52 | char *cur_outbuf; | ||
53 | const char *final_str; | ||
54 | int delta; | ||
55 | int deltanz; | ||
56 | struct timeval tv; | ||
57 | #define first_proc_file proc_stat | ||
58 | proc_file proc_stat; // Must match the order of proc_name's! | ||
59 | proc_file proc_loadavg; | ||
60 | proc_file proc_net_dev; | ||
61 | proc_file proc_meminfo; | ||
62 | proc_file proc_diskstats; | ||
63 | proc_file proc_sys_fs_filenr; | ||
64 | }; | ||
65 | #define G (*ptr_to_globals) | ||
66 | #define gen (G.gen ) | ||
67 | #define is26 (G.is26 ) | ||
68 | #define need_seconds (G.need_seconds ) | ||
69 | #define cur_outbuf (G.cur_outbuf ) | ||
70 | #define final_str (G.final_str ) | ||
71 | #define delta (G.delta ) | ||
72 | #define deltanz (G.deltanz ) | ||
73 | #define tv (G.tv ) | ||
74 | #define proc_stat (G.proc_stat ) | ||
75 | #define proc_loadavg (G.proc_loadavg ) | ||
76 | #define proc_net_dev (G.proc_net_dev ) | ||
77 | #define proc_meminfo (G.proc_meminfo ) | ||
78 | #define proc_diskstats (G.proc_diskstats ) | ||
79 | #define proc_sys_fs_filenr (G.proc_sys_fs_filenr) | ||
80 | #define INIT_G() do { \ | ||
81 | SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ | ||
82 | cur_outbuf = outbuf; \ | ||
83 | final_str = "\n"; \ | ||
84 | deltanz = delta = 1000000; \ | ||
85 | } while (0) | ||
86 | |||
87 | // We depend on this being a char[], not char* - we take sizeof() of it | ||
88 | #define outbuf bb_common_bufsiz1 | ||
89 | |||
90 | static inline void reset_outbuf(void) | ||
91 | { | ||
92 | cur_outbuf = outbuf; | ||
93 | } | ||
94 | |||
95 | static inline int outbuf_count(void) | ||
96 | { | ||
97 | return cur_outbuf - outbuf; | ||
98 | } | ||
99 | |||
100 | static void print_outbuf(void) | ||
101 | { | ||
102 | int sz = cur_outbuf - outbuf; | ||
103 | if (sz > 0) { | ||
104 | xwrite(STDOUT_FILENO, outbuf, sz); | ||
105 | cur_outbuf = outbuf; | ||
106 | } | ||
107 | } | ||
108 | |||
109 | static void put(const char *s) | ||
110 | { | ||
111 | int sz = strlen(s); | ||
112 | if (sz > outbuf + sizeof(outbuf) - cur_outbuf) | ||
113 | sz = outbuf + sizeof(outbuf) - cur_outbuf; | ||
114 | memcpy(cur_outbuf, s, sz); | ||
115 | cur_outbuf += sz; | ||
116 | } | ||
117 | |||
118 | static void put_c(char c) | ||
119 | { | ||
120 | if (cur_outbuf < outbuf + sizeof(outbuf)) | ||
121 | *cur_outbuf++ = c; | ||
122 | } | ||
123 | |||
124 | static void put_question_marks(int count) | ||
125 | { | ||
126 | while (count--) | ||
127 | put_c('?'); | ||
128 | } | ||
129 | |||
130 | static void readfile_z(proc_file *pf, const char* fname) | ||
131 | { | ||
132 | // open_read_close() will do two reads in order to be sure we are at EOF, | ||
133 | // and we don't need/want that. | ||
134 | int fd; | ||
135 | int sz, rdsz; | ||
136 | char *buf; | ||
137 | |||
138 | sz = pf->file_sz; | ||
139 | buf = pf->file; | ||
140 | if (!buf) { | ||
141 | buf = xmalloc(PROC_MIN_FILE_SIZE); | ||
142 | sz = PROC_MIN_FILE_SIZE; | ||
143 | } | ||
144 | again: | ||
145 | fd = xopen(fname, O_RDONLY); | ||
146 | buf[0] = '\0'; | ||
147 | rdsz = read(fd, buf, sz-1); | ||
148 | close(fd); | ||
149 | if (rdsz > 0) { | ||
150 | if (rdsz == sz-1 && sz < PROC_MAX_FILE_SIZE) { | ||
151 | sz *= 2; | ||
152 | buf = xrealloc(buf, sz); | ||
153 | goto again; | ||
154 | } | ||
155 | buf[rdsz] = '\0'; | ||
156 | } | ||
157 | pf->file_sz = sz; | ||
158 | pf->file = buf; | ||
159 | } | ||
160 | |||
161 | static const char* get_file(proc_file *pf) | ||
162 | { | ||
163 | if (pf->last_gen != gen) { | ||
164 | pf->last_gen = gen; | ||
165 | readfile_z(pf, proc_name[pf - &first_proc_file]); | ||
166 | } | ||
167 | return pf->file; | ||
168 | } | ||
169 | |||
170 | static ullong read_after_slash(const char *p) | ||
171 | { | ||
172 | p = strchr(p, '/'); | ||
173 | if (!p) return 0; | ||
174 | return strtoull(p+1, NULL, 10); | ||
175 | } | ||
176 | |||
177 | enum conv_type { conv_decimal, conv_slash }; | ||
178 | |||
179 | // Reads decimal values from line. Values start after key, for example: | ||
180 | // "cpu 649369 0 341297 4336769..." - key is "cpu" here. | ||
181 | // Values are stored in vec[]. arg_ptr has list of positions | ||
182 | // we are interested in: for example: 1,2,5 - we want 1st, 2nd and 5th value. | ||
183 | static int vrdval(const char* p, const char* key, | ||
184 | enum conv_type conv, ullong *vec, va_list arg_ptr) | ||
185 | { | ||
186 | int indexline; | ||
187 | int indexnext; | ||
188 | |||
189 | p = strstr(p, key); | ||
190 | if (!p) return 1; | ||
191 | |||
192 | p += strlen(key); | ||
193 | indexline = 1; | ||
194 | indexnext = va_arg(arg_ptr, int); | ||
195 | while (1) { | ||
196 | while (*p == ' ' || *p == '\t') p++; | ||
197 | if (*p == '\n' || *p == '\0') break; | ||
198 | |||
199 | if (indexline == indexnext) { // read this value | ||
200 | *vec++ = conv==conv_decimal ? | ||
201 | strtoull(p, NULL, 10) : | ||
202 | read_after_slash(p); | ||
203 | indexnext = va_arg(arg_ptr, int); | ||
204 | } | ||
205 | while (*p > ' ') p++; // skip over value | ||
206 | indexline++; | ||
207 | } | ||
208 | return 0; | ||
209 | } | ||
210 | |||
211 | // Parses files with lines like "cpu0 21727 0 15718 1813856 9461 10485 0 0": | ||
212 | // rdval(file_contents, "string_to_find", result_vector, value#, value#...) | ||
213 | // value# start with 1 | ||
214 | static int rdval(const char* p, const char* key, ullong *vec, ...) | ||
215 | { | ||
216 | va_list arg_ptr; | ||
217 | int result; | ||
218 | |||
219 | va_start(arg_ptr, vec); | ||
220 | result = vrdval(p, key, conv_decimal, vec, arg_ptr); | ||
221 | va_end(arg_ptr); | ||
222 | |||
223 | return result; | ||
224 | } | ||
225 | |||
226 | // Parses files with lines like "... ... ... 3/148 ...." | ||
227 | static int rdval_loadavg(const char* p, ullong *vec, ...) | ||
228 | { | ||
229 | va_list arg_ptr; | ||
230 | int result; | ||
231 | |||
232 | va_start(arg_ptr, vec); | ||
233 | result = vrdval(p, "", conv_slash, vec, arg_ptr); | ||
234 | va_end(arg_ptr); | ||
235 | |||
236 | return result; | ||
237 | } | ||
238 | |||
239 | // Parses /proc/diskstats | ||
240 | // 1 2 3 4 5 6(rd) 7 8 9 10(wr) 11 12 13 14 | ||
241 | // 3 0 hda 51292 14441 841783 926052 25717 79650 843256 3029804 0 148459 3956933 | ||
242 | // 3 1 hda1 0 0 0 0 <- ignore if only 4 fields | ||
243 | static int rdval_diskstats(const char* p, ullong *vec) | ||
244 | { | ||
245 | ullong rd = rd; // for compiler | ||
246 | int indexline = 0; | ||
247 | vec[0] = 0; | ||
248 | vec[1] = 0; | ||
249 | while (1) { | ||
250 | indexline++; | ||
251 | while (*p == ' ' || *p == '\t') p++; | ||
252 | if (*p == '\0') break; | ||
253 | if (*p == '\n') { | ||
254 | indexline = 0; | ||
255 | p++; | ||
256 | continue; | ||
257 | } | ||
258 | if (indexline == 6) { | ||
259 | rd = strtoull(p, NULL, 10); | ||
260 | } else if (indexline == 10) { | ||
261 | vec[0] += rd; // TODO: *sectorsize (don't know how to find out sectorsize) | ||
262 | vec[1] += strtoull(p, NULL, 10); | ||
263 | while (*p != '\n' && *p != '\0') p++; | ||
264 | continue; | ||
265 | } | ||
266 | while (*p > ' ') p++; // skip over value | ||
267 | } | ||
268 | return 0; | ||
269 | } | ||
270 | |||
271 | static void scale(ullong ul) | ||
272 | { | ||
273 | char buf[5]; | ||
274 | |||
275 | /* see http://en.wikipedia.org/wiki/Tera */ | ||
276 | smart_ulltoa4(ul, buf, " kmgtpezy"); | ||
277 | buf[4] = '\0'; | ||
278 | put(buf); | ||
279 | } | ||
280 | |||
281 | |||
282 | #define S_STAT(a) \ | ||
283 | typedef struct a { \ | ||
284 | struct s_stat *next; \ | ||
285 | void (*collect)(struct a *s); \ | ||
286 | const char *label; | ||
287 | #define S_STAT_END(a) } a; | ||
288 | |||
289 | S_STAT(s_stat) | ||
290 | S_STAT_END(s_stat) | ||
291 | |||
292 | static void collect_literal(s_stat *s UNUSED_PARAM) | ||
293 | { | ||
294 | } | ||
295 | |||
296 | static s_stat* init_literal(void) | ||
297 | { | ||
298 | s_stat *s = xzalloc(sizeof(*s)); | ||
299 | s->collect = collect_literal; | ||
300 | return (s_stat*)s; | ||
301 | } | ||
302 | |||
303 | static s_stat* init_delay(const char *param) | ||
304 | { | ||
305 | delta = strtoul(param, NULL, 0) * 1000; /* param can be "" */ | ||
306 | deltanz = delta > 0 ? delta : 1; | ||
307 | need_seconds = (1000000%deltanz) != 0; | ||
308 | return NULL; | ||
309 | } | ||
310 | |||
311 | static s_stat* init_cr(const char *param UNUSED_PARAM) | ||
312 | { | ||
313 | final_str = "\r"; | ||
314 | return (s_stat*)0; | ||
315 | } | ||
316 | |||
317 | |||
318 | // user nice system idle iowait irq softirq (last 3 only in 2.6) | ||
319 | //cpu 649369 0 341297 4336769 11640 7122 1183 | ||
320 | //cpuN 649369 0 341297 4336769 11640 7122 1183 | ||
321 | enum { CPU_FIELDCNT = 7 }; | ||
322 | S_STAT(cpu_stat) | ||
323 | ullong old[CPU_FIELDCNT]; | ||
324 | int bar_sz; | ||
325 | char *bar; | ||
326 | S_STAT_END(cpu_stat) | ||
327 | |||
328 | |||
329 | static void collect_cpu(cpu_stat *s) | ||
330 | { | ||
331 | ullong data[CPU_FIELDCNT] = { 0, 0, 0, 0, 0, 0, 0 }; | ||
332 | unsigned frac[CPU_FIELDCNT] = { 0, 0, 0, 0, 0, 0, 0 }; | ||
333 | ullong all = 0; | ||
334 | int norm_all = 0; | ||
335 | int bar_sz = s->bar_sz; | ||
336 | char *bar = s->bar; | ||
337 | int i; | ||
338 | |||
339 | if (rdval(get_file(&proc_stat), "cpu ", data, 1, 2, 3, 4, 5, 6, 7)) { | ||
340 | put_question_marks(bar_sz); | ||
341 | return; | ||
342 | } | ||
343 | |||
344 | for (i = 0; i < CPU_FIELDCNT; i++) { | ||
345 | ullong old = s->old[i]; | ||
346 | if (data[i] < old) old = data[i]; //sanitize | ||
347 | s->old[i] = data[i]; | ||
348 | all += (data[i] -= old); | ||
349 | } | ||
350 | |||
351 | if (all) { | ||
352 | for (i = 0; i < CPU_FIELDCNT; i++) { | ||
353 | ullong t = bar_sz * data[i]; | ||
354 | norm_all += data[i] = t / all; | ||
355 | frac[i] = t % all; | ||
356 | } | ||
357 | |||
358 | while (norm_all < bar_sz) { | ||
359 | unsigned max = frac[0]; | ||
360 | int pos = 0; | ||
361 | for (i = 1; i < CPU_FIELDCNT; i++) { | ||
362 | if (frac[i] > max) max = frac[i], pos = i; | ||
363 | } | ||
364 | frac[pos] = 0; //avoid bumping up same value twice | ||
365 | data[pos]++; | ||
366 | norm_all++; | ||
367 | } | ||
368 | |||
369 | memset(bar, '.', bar_sz); | ||
370 | memset(bar, 'S', data[2]); bar += data[2]; //sys | ||
371 | memset(bar, 'U', data[0]); bar += data[0]; //usr | ||
372 | memset(bar, 'N', data[1]); bar += data[1]; //nice | ||
373 | memset(bar, 'D', data[4]); bar += data[4]; //iowait | ||
374 | memset(bar, 'I', data[5]); bar += data[5]; //irq | ||
375 | memset(bar, 'i', data[6]); bar += data[6]; //softirq | ||
376 | } else { | ||
377 | memset(bar, '?', bar_sz); | ||
378 | } | ||
379 | put(s->bar); | ||
380 | } | ||
381 | |||
382 | |||
383 | static s_stat* init_cpu(const char *param) | ||
384 | { | ||
385 | int sz; | ||
386 | cpu_stat *s = xzalloc(sizeof(*s)); | ||
387 | s->collect = collect_cpu; | ||
388 | sz = strtoul(param, NULL, 0); /* param can be "" */ | ||
389 | if (sz < 10) sz = 10; | ||
390 | if (sz > 1000) sz = 1000; | ||
391 | s->bar = xzalloc(sz+1); | ||
392 | /*s->bar[sz] = '\0'; - xzalloc did it */ | ||
393 | s->bar_sz = sz; | ||
394 | return (s_stat*)s; | ||
395 | } | ||
396 | |||
397 | |||
398 | S_STAT(int_stat) | ||
399 | ullong old; | ||
400 | int no; | ||
401 | S_STAT_END(int_stat) | ||
402 | |||
403 | static void collect_int(int_stat *s) | ||
404 | { | ||
405 | ullong data[1]; | ||
406 | ullong old; | ||
407 | |||
408 | if (rdval(get_file(&proc_stat), "intr", data, s->no)) { | ||
409 | put_question_marks(4); | ||
410 | return; | ||
411 | } | ||
412 | |||
413 | old = s->old; | ||
414 | if (data[0] < old) old = data[0]; //sanitize | ||
415 | s->old = data[0]; | ||
416 | scale(data[0] - old); | ||
417 | } | ||
418 | |||
419 | static s_stat* init_int(const char *param) | ||
420 | { | ||
421 | int_stat *s = xzalloc(sizeof(*s)); | ||
422 | s->collect = collect_int; | ||
423 | if (param[0] == '\0') { | ||
424 | s->no = 1; | ||
425 | } else { | ||
426 | int n = xatoi_u(param); | ||
427 | s->no = n + 2; | ||
428 | } | ||
429 | return (s_stat*)s; | ||
430 | } | ||
431 | |||
432 | |||
433 | S_STAT(ctx_stat) | ||
434 | ullong old; | ||
435 | S_STAT_END(ctx_stat) | ||
436 | |||
437 | static void collect_ctx(ctx_stat *s) | ||
438 | { | ||
439 | ullong data[1]; | ||
440 | ullong old; | ||
441 | |||
442 | if (rdval(get_file(&proc_stat), "ctxt", data, 1)) { | ||
443 | put_question_marks(4); | ||
444 | return; | ||
445 | } | ||
446 | |||
447 | old = s->old; | ||
448 | if (data[0] < old) old = data[0]; //sanitize | ||
449 | s->old = data[0]; | ||
450 | scale(data[0] - old); | ||
451 | } | ||
452 | |||
453 | static s_stat* init_ctx(const char *param UNUSED_PARAM) | ||
454 | { | ||
455 | ctx_stat *s = xzalloc(sizeof(*s)); | ||
456 | s->collect = collect_ctx; | ||
457 | return (s_stat*)s; | ||
458 | } | ||
459 | |||
460 | |||
461 | S_STAT(blk_stat) | ||
462 | const char* lookfor; | ||
463 | ullong old[2]; | ||
464 | S_STAT_END(blk_stat) | ||
465 | |||
466 | static void collect_blk(blk_stat *s) | ||
467 | { | ||
468 | ullong data[2]; | ||
469 | int i; | ||
470 | |||
471 | if (is26) { | ||
472 | i = rdval_diskstats(get_file(&proc_diskstats), data); | ||
473 | } else { | ||
474 | i = rdval(get_file(&proc_stat), s->lookfor, data, 1, 2); | ||
475 | // Linux 2.4 reports bio in Kbytes, convert to sectors: | ||
476 | data[0] *= 2; | ||
477 | data[1] *= 2; | ||
478 | } | ||
479 | if (i) { | ||
480 | put_question_marks(9); | ||
481 | return; | ||
482 | } | ||
483 | |||
484 | for (i=0; i<2; i++) { | ||
485 | ullong old = s->old[i]; | ||
486 | if (data[i] < old) old = data[i]; //sanitize | ||
487 | s->old[i] = data[i]; | ||
488 | data[i] -= old; | ||
489 | } | ||
490 | scale(data[0]*512); // TODO: *sectorsize | ||
491 | put_c(' '); | ||
492 | scale(data[1]*512); | ||
493 | } | ||
494 | |||
495 | static s_stat* init_blk(const char *param UNUSED_PARAM) | ||
496 | { | ||
497 | blk_stat *s = xzalloc(sizeof(*s)); | ||
498 | s->collect = collect_blk; | ||
499 | s->lookfor = "page"; | ||
500 | return (s_stat*)s; | ||
501 | } | ||
502 | |||
503 | |||
504 | S_STAT(fork_stat) | ||
505 | ullong old; | ||
506 | S_STAT_END(fork_stat) | ||
507 | |||
508 | static void collect_thread_nr(fork_stat *s UNUSED_PARAM) | ||
509 | { | ||
510 | ullong data[1]; | ||
511 | |||
512 | if (rdval_loadavg(get_file(&proc_loadavg), data, 4)) { | ||
513 | put_question_marks(4); | ||
514 | return; | ||
515 | } | ||
516 | scale(data[0]); | ||
517 | } | ||
518 | |||
519 | static void collect_fork(fork_stat *s) | ||
520 | { | ||
521 | ullong data[1]; | ||
522 | ullong old; | ||
523 | |||
524 | if (rdval(get_file(&proc_stat), "processes", data, 1)) { | ||
525 | put_question_marks(4); | ||
526 | return; | ||
527 | } | ||
528 | |||
529 | old = s->old; | ||
530 | if (data[0] < old) old = data[0]; //sanitize | ||
531 | s->old = data[0]; | ||
532 | scale(data[0] - old); | ||
533 | } | ||
534 | |||
535 | static s_stat* init_fork(const char *param) | ||
536 | { | ||
537 | fork_stat *s = xzalloc(sizeof(*s)); | ||
538 | if (*param == 'n') { | ||
539 | s->collect = collect_thread_nr; | ||
540 | } else { | ||
541 | s->collect = collect_fork; | ||
542 | } | ||
543 | return (s_stat*)s; | ||
544 | } | ||
545 | |||
546 | |||
547 | S_STAT(if_stat) | ||
548 | ullong old[4]; | ||
549 | const char *device; | ||
550 | char *device_colon; | ||
551 | S_STAT_END(if_stat) | ||
552 | |||
553 | static void collect_if(if_stat *s) | ||
554 | { | ||
555 | ullong data[4]; | ||
556 | int i; | ||
557 | |||
558 | if (rdval(get_file(&proc_net_dev), s->device_colon, data, 1, 3, 9, 11)) { | ||
559 | put_question_marks(10); | ||
560 | return; | ||
561 | } | ||
562 | |||
563 | for (i=0; i<4; i++) { | ||
564 | ullong old = s->old[i]; | ||
565 | if (data[i] < old) old = data[i]; //sanitize | ||
566 | s->old[i] = data[i]; | ||
567 | data[i] -= old; | ||
568 | } | ||
569 | put_c(data[1] ? '*' : ' '); | ||
570 | scale(data[0]); | ||
571 | put_c(data[3] ? '*' : ' '); | ||
572 | scale(data[2]); | ||
573 | } | ||
574 | |||
575 | static s_stat* init_if(const char *device) | ||
576 | { | ||
577 | if_stat *s = xzalloc(sizeof(*s)); | ||
578 | |||
579 | if (!device || !device[0]) | ||
580 | bb_show_usage(); | ||
581 | s->collect = collect_if; | ||
582 | |||
583 | s->device = device; | ||
584 | s->device_colon = xasprintf("%s:", device); | ||
585 | return (s_stat*)s; | ||
586 | } | ||
587 | |||
588 | |||
589 | S_STAT(mem_stat) | ||
590 | char opt; | ||
591 | S_STAT_END(mem_stat) | ||
592 | |||
593 | // "Memory" value should not include any caches. | ||
594 | // IOW: neither "ls -laR /" nor heavy read/write activity | ||
595 | // should affect it. We'd like to also include any | ||
596 | // long-term allocated kernel-side mem, but it is hard | ||
597 | // to figure out. For now, bufs, cached & slab are | ||
598 | // counted as "free" memory | ||
599 | //2.6.16: | ||
600 | //MemTotal: 773280 kB | ||
601 | //MemFree: 25912 kB - genuinely free | ||
602 | //Buffers: 320672 kB - cache | ||
603 | //Cached: 146396 kB - cache | ||
604 | //SwapCached: 0 kB | ||
605 | //Active: 183064 kB | ||
606 | //Inactive: 356892 kB | ||
607 | //HighTotal: 0 kB | ||
608 | //HighFree: 0 kB | ||
609 | //LowTotal: 773280 kB | ||
610 | //LowFree: 25912 kB | ||
611 | //SwapTotal: 131064 kB | ||
612 | //SwapFree: 131064 kB | ||
613 | //Dirty: 48 kB | ||
614 | //Writeback: 0 kB | ||
615 | //Mapped: 96620 kB | ||
616 | //Slab: 200668 kB - takes 7 Mb on my box fresh after boot, | ||
617 | // but includes dentries and inodes | ||
618 | // (== can take arbitrary amount of mem) | ||
619 | //CommitLimit: 517704 kB | ||
620 | //Committed_AS: 236776 kB | ||
621 | //PageTables: 1248 kB | ||
622 | //VmallocTotal: 516052 kB | ||
623 | //VmallocUsed: 3852 kB | ||
624 | //VmallocChunk: 512096 kB | ||
625 | //HugePages_Total: 0 | ||
626 | //HugePages_Free: 0 | ||
627 | //Hugepagesize: 4096 kB | ||
628 | static void collect_mem(mem_stat *s) | ||
629 | { | ||
630 | ullong m_total = 0; | ||
631 | ullong m_free = 0; | ||
632 | ullong m_bufs = 0; | ||
633 | ullong m_cached = 0; | ||
634 | ullong m_slab = 0; | ||
635 | |||
636 | if (rdval(get_file(&proc_meminfo), "MemTotal:", &m_total, 1)) { | ||
637 | put_question_marks(4); | ||
638 | return; | ||
639 | } | ||
640 | if (s->opt == 't') { | ||
641 | scale(m_total << 10); | ||
642 | return; | ||
643 | } | ||
644 | |||
645 | if (rdval(proc_meminfo.file, "MemFree:", &m_free , 1) | ||
646 | || rdval(proc_meminfo.file, "Buffers:", &m_bufs , 1) | ||
647 | || rdval(proc_meminfo.file, "Cached:", &m_cached, 1) | ||
648 | || rdval(proc_meminfo.file, "Slab:", &m_slab , 1) | ||
649 | ) { | ||
650 | put_question_marks(4); | ||
651 | return; | ||
652 | } | ||
653 | |||
654 | m_free += m_bufs + m_cached + m_slab; | ||
655 | switch (s->opt) { | ||
656 | case 'f': | ||
657 | scale(m_free << 10); break; | ||
658 | default: | ||
659 | scale((m_total - m_free) << 10); break; | ||
660 | } | ||
661 | } | ||
662 | |||
663 | static s_stat* init_mem(const char *param) | ||
664 | { | ||
665 | mem_stat *s = xzalloc(sizeof(*s)); | ||
666 | s->collect = collect_mem; | ||
667 | s->opt = param[0]; | ||
668 | return (s_stat*)s; | ||
669 | } | ||
670 | |||
671 | |||
672 | S_STAT(swp_stat) | ||
673 | S_STAT_END(swp_stat) | ||
674 | |||
675 | static void collect_swp(swp_stat *s UNUSED_PARAM) | ||
676 | { | ||
677 | ullong s_total[1]; | ||
678 | ullong s_free[1]; | ||
679 | if (rdval(get_file(&proc_meminfo), "SwapTotal:", s_total, 1) | ||
680 | || rdval(proc_meminfo.file, "SwapFree:" , s_free, 1) | ||
681 | ) { | ||
682 | put_question_marks(4); | ||
683 | return; | ||
684 | } | ||
685 | scale((s_total[0]-s_free[0]) << 10); | ||
686 | } | ||
687 | |||
688 | static s_stat* init_swp(const char *param UNUSED_PARAM) | ||
689 | { | ||
690 | swp_stat *s = xzalloc(sizeof(*s)); | ||
691 | s->collect = collect_swp; | ||
692 | return (s_stat*)s; | ||
693 | } | ||
694 | |||
695 | |||
696 | S_STAT(fd_stat) | ||
697 | S_STAT_END(fd_stat) | ||
698 | |||
699 | static void collect_fd(fd_stat *s UNUSED_PARAM) | ||
700 | { | ||
701 | ullong data[2]; | ||
702 | |||
703 | if (rdval(get_file(&proc_sys_fs_filenr), "", data, 1, 2)) { | ||
704 | put_question_marks(4); | ||
705 | return; | ||
706 | } | ||
707 | |||
708 | scale(data[0] - data[1]); | ||
709 | } | ||
710 | |||
711 | static s_stat* init_fd(const char *param UNUSED_PARAM) | ||
712 | { | ||
713 | fd_stat *s = xzalloc(sizeof(*s)); | ||
714 | s->collect = collect_fd; | ||
715 | return (s_stat*)s; | ||
716 | } | ||
717 | |||
718 | |||
719 | S_STAT(time_stat) | ||
720 | int prec; | ||
721 | int scale; | ||
722 | S_STAT_END(time_stat) | ||
723 | |||
724 | static void collect_time(time_stat *s) | ||
725 | { | ||
726 | char buf[sizeof("12:34:56.123456")]; | ||
727 | struct tm* tm; | ||
728 | int us = tv.tv_usec + s->scale/2; | ||
729 | time_t t = tv.tv_sec; | ||
730 | |||
731 | if (us >= 1000000) { | ||
732 | t++; | ||
733 | us -= 1000000; | ||
734 | } | ||
735 | tm = localtime(&t); | ||
736 | |||
737 | sprintf(buf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec); | ||
738 | if (s->prec) | ||
739 | sprintf(buf+8, ".%0*d", s->prec, us / s->scale); | ||
740 | put(buf); | ||
741 | } | ||
742 | |||
743 | static s_stat* init_time(const char *param) | ||
744 | { | ||
745 | int prec; | ||
746 | time_stat *s = xzalloc(sizeof(*s)); | ||
747 | |||
748 | s->collect = collect_time; | ||
749 | prec = param[0] - '0'; | ||
750 | if (prec < 0) prec = 0; | ||
751 | else if (prec > 6) prec = 6; | ||
752 | s->prec = prec; | ||
753 | s->scale = 1; | ||
754 | while (prec++ < 6) | ||
755 | s->scale *= 10; | ||
756 | return (s_stat*)s; | ||
757 | } | ||
758 | |||
759 | static void collect_info(s_stat *s) | ||
760 | { | ||
761 | gen ^= 1; | ||
762 | while (s) { | ||
763 | put(s->label); | ||
764 | s->collect(s); | ||
765 | s = s->next; | ||
766 | } | ||
767 | } | ||
768 | |||
769 | |||
770 | typedef s_stat* init_func(const char *param); | ||
771 | |||
772 | static const char options[] ALIGN1 = "ncmsfixptbdr"; | ||
773 | static init_func *const init_functions[] = { | ||
774 | init_if, | ||
775 | init_cpu, | ||
776 | init_mem, | ||
777 | init_swp, | ||
778 | init_fd, | ||
779 | init_int, | ||
780 | init_ctx, | ||
781 | init_fork, | ||
782 | init_time, | ||
783 | init_blk, | ||
784 | init_delay, | ||
785 | init_cr | ||
786 | }; | ||
787 | |||
788 | int nmeter_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; | ||
789 | int nmeter_main(int argc, char **argv) | ||
790 | { | ||
791 | char buf[32]; | ||
792 | s_stat *first = NULL; | ||
793 | s_stat *last = NULL; | ||
794 | s_stat *s; | ||
795 | char *cur, *prev; | ||
796 | |||
797 | INIT_G(); | ||
798 | |||
799 | xchdir("/proc"); | ||
800 | |||
801 | if (argc != 2) | ||
802 | bb_show_usage(); | ||
803 | |||
804 | if (open_read_close("version", buf, sizeof(buf)-1) > 0) { | ||
805 | buf[sizeof(buf)-1] = '\0'; | ||
806 | is26 = (strstr(buf, " 2.4.") == NULL); | ||
807 | } | ||
808 | |||
809 | // Can use argv[1] directly, but this will mess up | ||
810 | // parameters as seen by e.g. ps. Making a copy... | ||
811 | cur = xstrdup(argv[1]); | ||
812 | while (1) { | ||
813 | char *param, *p; | ||
814 | prev = cur; | ||
815 | again: | ||
816 | cur = strchr(cur, '%'); | ||
817 | if (!cur) | ||
818 | break; | ||
819 | if (cur[1] == '%') { // %% | ||
820 | overlapping_strcpy(cur, cur + 1); | ||
821 | cur++; | ||
822 | goto again; | ||
823 | } | ||
824 | *cur++ = '\0'; // overwrite % | ||
825 | if (cur[0] == '[') { | ||
826 | // format: %[foptstring] | ||
827 | cur++; | ||
828 | p = strchr(options, cur[0]); | ||
829 | param = cur+1; | ||
830 | while (cur[0] != ']') { | ||
831 | if (!cur[0]) | ||
832 | bb_show_usage(); | ||
833 | cur++; | ||
834 | } | ||
835 | *cur++ = '\0'; // overwrite [ | ||
836 | } else { | ||
837 | // format: %NNNNNNf | ||
838 | param = cur; | ||
839 | while (cur[0] >= '0' && cur[0] <= '9') | ||
840 | cur++; | ||
841 | if (!cur[0]) | ||
842 | bb_show_usage(); | ||
843 | p = strchr(options, cur[0]); | ||
844 | *cur++ = '\0'; // overwrite format char | ||
845 | } | ||
846 | if (!p) | ||
847 | bb_show_usage(); | ||
848 | s = init_functions[p-options](param); | ||
849 | if (s) { | ||
850 | s->label = prev; | ||
851 | /*s->next = NULL; - all initXXX funcs use xzalloc */ | ||
852 | if (!first) | ||
853 | first = s; | ||
854 | else | ||
855 | last->next = s; | ||
856 | last = s; | ||
857 | } else { | ||
858 | // %NNNNd or %r option. remove it from string | ||
859 | strcpy(prev + strlen(prev), cur); | ||
860 | cur = prev; | ||
861 | } | ||
862 | } | ||
863 | if (prev[0]) { | ||
864 | s = init_literal(); | ||
865 | s->label = prev; | ||
866 | /*s->next = NULL; - all initXXX funcs use xzalloc */ | ||
867 | if (!first) | ||
868 | first = s; | ||
869 | else | ||
870 | last->next = s; | ||
871 | last = s; | ||
872 | } | ||
873 | |||
874 | // Generate first samples but do not print them, they're bogus | ||
875 | collect_info(first); | ||
876 | reset_outbuf(); | ||
877 | if (delta >= 0) { | ||
878 | gettimeofday(&tv, NULL); | ||
879 | usleep(delta > 1000000 ? 1000000 : delta - tv.tv_usec%deltanz); | ||
880 | } | ||
881 | |||
882 | while (1) { | ||
883 | gettimeofday(&tv, NULL); | ||
884 | collect_info(first); | ||
885 | put(final_str); | ||
886 | print_outbuf(); | ||
887 | |||
888 | // Negative delta -> no usleep at all | ||
889 | // This will hog the CPU but you can have REALLY GOOD | ||
890 | // time resolution ;) | ||
891 | // TODO: detect and avoid useless updates | ||
892 | // (like: nothing happens except time) | ||
893 | if (delta >= 0) { | ||
894 | int rem; | ||
895 | // can be commented out, will sacrifice sleep time precision a bit | ||
896 | gettimeofday(&tv, NULL); | ||
897 | if (need_seconds) | ||
898 | rem = delta - ((ullong)tv.tv_sec*1000000 + tv.tv_usec) % deltanz; | ||
899 | else | ||
900 | rem = delta - tv.tv_usec%deltanz; | ||
901 | // Sometimes kernel wakes us up just a tiny bit earlier than asked | ||
902 | // Do not go to very short sleep in this case | ||
903 | if (rem < delta/128) { | ||
904 | rem += delta; | ||
905 | } | ||
906 | usleep(rem); | ||
907 | } | ||
908 | } | ||
909 | |||
910 | /*return 0;*/ | ||
911 | } |