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