2 * Licensed under GPLv2, see file LICENSE in this source tree.
4 * Based on nanotop.c from floppyfw project
6 * Contact me: vda.linux@googlemail.com
10 //config: bool "nmeter"
13 //config: Prints selected system stats continuously, one line per update.
15 //applet:IF_NMETER(APPLET(nmeter, BB_DIR_USR_BIN, BB_SUID_DROP))
17 //kbuild:lib-$(CONFIG_NMETER) += nmeter.o
19 //usage:#define nmeter_trivial_usage
20 //usage: "[-d MSEC] FORMAT_STRING"
21 //usage:#define nmeter_full_usage "\n\n"
22 //usage: "Monitor system in real time"
24 //usage: "\n -d MSEC Milliseconds between updates (default:1000)"
26 //usage: "\nFormat specifiers:"
27 //usage: "\n %Nc or %[cN] CPU. N - bar size (default:10)"
28 //usage: "\n (displays: S:system U:user N:niced D:iowait I:irq i:softirq)"
29 //usage: "\n %[nINTERFACE] Network INTERFACE"
30 //usage: "\n %m Allocated memory"
31 //usage: "\n %[mf] Free memory"
32 //usage: "\n %[mt] Total memory"
33 //usage: "\n %s Allocated swap"
34 //usage: "\n %f Number of used file descriptors"
35 //usage: "\n %Ni Total/specific IRQ rate"
36 //usage: "\n %x Context switch rate"
37 //usage: "\n %p Forks"
38 //usage: "\n %[pn] # of processes"
39 //usage: "\n %b Block io"
40 //usage: "\n %Nt Time (with N decimal points)"
41 //usage: "\n %r Print <cr> instead of <lf> at EOL"
47 // disk_io: (3,0):(22272,17897,410702,4375,54750)
49 //TODO: use sysinfo libc call/syscall, if appropriate
50 // (faster than open/read/close):
51 // sysinfo({uptime=15017, loads=[5728, 15040, 16480]
52 // totalram=2107416576, freeram=211525632, sharedram=0, bufferram=157204480}
53 // totalswap=134209536, freeswap=134209536, procs=157})
57 typedef unsigned long long ullong
;
59 enum { /* Preferably use powers of 2 */
60 PROC_MIN_FILE_SIZE
= 256,
61 PROC_MAX_FILE_SIZE
= 16 * 1024,
64 typedef struct proc_file
{
70 static const char *const proc_name
[] = {
71 "stat", // Must match the order of proc_file's!
80 // Sample generation flip-flop
82 // Linux 2.6? (otherwise assumes 2.4)
84 // 1 if sample delay is not an integer fraction of a second
85 smallint need_seconds
;
87 const char *final_str
;
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
;
99 #define G (*ptr_to_globals)
101 #define is26 (G.is26 )
102 #define need_seconds (G.need_seconds )
103 #define cur_outbuf (G.cur_outbuf )
104 #define final_str (G.final_str )
105 #define delta (G.delta )
106 #define deltanz (G.deltanz )
108 #define proc_stat (G.proc_stat )
109 #define proc_loadavg (G.proc_loadavg )
110 #define proc_net_dev (G.proc_net_dev )
111 #define proc_meminfo (G.proc_meminfo )
112 #define proc_diskstats (G.proc_diskstats )
113 #define proc_sys_fs_filenr (G.proc_sys_fs_filenr)
114 #define INIT_G() do { \
115 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
116 cur_outbuf = outbuf; \
118 deltanz = delta = 1000000; \
121 // We depend on this being a char[], not char* - we take sizeof() of it
122 #define outbuf bb_common_bufsiz1
124 static inline void reset_outbuf(void)
129 static inline int outbuf_count(void)
131 return cur_outbuf
- outbuf
;
134 static void print_outbuf(void)
136 int sz
= cur_outbuf
- outbuf
;
138 xwrite(STDOUT_FILENO
, outbuf
, sz
);
143 static void put(const char *s
)
146 if (sz
> outbuf
+ sizeof(outbuf
) - cur_outbuf
)
147 sz
= outbuf
+ sizeof(outbuf
) - cur_outbuf
;
148 memcpy(cur_outbuf
, s
, sz
);
152 static void put_c(char c
)
154 if (cur_outbuf
< outbuf
+ sizeof(outbuf
))
158 static void put_question_marks(int count
)
164 static void readfile_z(proc_file
*pf
, const char* fname
)
166 // open_read_close() will do two reads in order to be sure we are at EOF,
167 // and we don't need/want that.
175 buf
= xmalloc(PROC_MIN_FILE_SIZE
);
176 sz
= PROC_MIN_FILE_SIZE
;
179 fd
= xopen(fname
, O_RDONLY
);
181 rdsz
= read(fd
, buf
, sz
-1);
184 if (rdsz
== sz
-1 && sz
< PROC_MAX_FILE_SIZE
) {
186 buf
= xrealloc(buf
, sz
);
195 static const char* get_file(proc_file
*pf
)
197 if (pf
->last_gen
!= gen
) {
199 readfile_z(pf
, proc_name
[pf
- &first_proc_file
]);
204 static ullong
read_after_slash(const char *p
)
208 return strtoull(p
+1, NULL
, 10);
211 enum conv_type
{ conv_decimal
, conv_slash
};
213 // Reads decimal values from line. Values start after key, for example:
214 // "cpu 649369 0 341297 4336769..." - key is "cpu" here.
215 // Values are stored in vec[]. arg_ptr has list of positions
216 // we are interested in: for example: 1,2,5 - we want 1st, 2nd and 5th value.
217 static int vrdval(const char* p
, const char* key
,
218 enum conv_type conv
, ullong
*vec
, va_list arg_ptr
)
228 indexnext
= va_arg(arg_ptr
, int);
230 while (*p
== ' ' || *p
== '\t') p
++;
231 if (*p
== '\n' || *p
== '\0') break;
233 if (indexline
== indexnext
) { // read this value
234 *vec
++ = conv
==conv_decimal
?
235 strtoull(p
, NULL
, 10) :
237 indexnext
= va_arg(arg_ptr
, int);
239 while (*p
> ' ') p
++; // skip over value
245 // Parses files with lines like "cpu0 21727 0 15718 1813856 9461 10485 0 0":
246 // rdval(file_contents, "string_to_find", result_vector, value#, value#...)
247 // value# start with 1
248 static int rdval(const char* p
, const char* key
, ullong
*vec
, ...)
253 va_start(arg_ptr
, vec
);
254 result
= vrdval(p
, key
, conv_decimal
, vec
, arg_ptr
);
260 // Parses files with lines like "... ... ... 3/148 ...."
261 static int rdval_loadavg(const char* p
, ullong
*vec
, ...)
266 va_start(arg_ptr
, vec
);
267 result
= vrdval(p
, "", conv_slash
, vec
, arg_ptr
);
273 // Parses /proc/diskstats
274 // 1 2 3 4 5 6(rd) 7 8 9 10(wr) 11 12 13 14
275 // 3 0 hda 51292 14441 841783 926052 25717 79650 843256 3029804 0 148459 3956933
276 // 3 1 hda1 0 0 0 0 <- ignore if only 4 fields
277 // Linux 3.0 (maybe earlier) started printing full stats for hda1 too.
278 // Had to add code which skips such devices.
279 static int rdval_diskstats(const char* p
, ullong
*vec
)
282 unsigned devname_len
= 0;
289 while (*p
== ' ' || *p
== '\t')
298 if (value_idx
== 3) {
299 char *end
= strchrnul(p
, ' ');
300 /* If this a hda1-like device (same prefix as last one + digit)? */
301 if (devname_len
&& strncmp(devname
, p
, devname_len
) == 0 && isdigit(p
[devname_len
])) {
303 goto skip_line
; /* skip entire line */
305 /* It is not. Remember the name for future checks */
306 devname_len
= end
- p
;
307 if (devname_len
> sizeof(devname
)-1)
308 devname_len
= sizeof(devname
)-1;
309 strncpy(devname
, p
, devname_len
);
310 /* devname[devname_len] = '\0'; - not really needed */
313 if (value_idx
== 6) {
314 // TODO: *sectorsize (don't know how to find out sectorsize)
315 vec
[0] += strtoull(p
, NULL
, 10);
317 if (value_idx
== 10) {
318 // TODO: *sectorsize (don't know how to find out sectorsize)
319 vec
[1] += strtoull(p
, NULL
, 10);
321 while (*p
!= '\n' && *p
!= '\0')
325 while ((unsigned char)(*p
) > ' ') // skip over value
331 static void scale(ullong ul
)
335 /* see http://en.wikipedia.org/wiki/Tera */
336 smart_ulltoa4(ul
, buf
, " kmgtpezy");
344 struct s_stat *next; \
345 void (*collect)(struct a *s) FAST_FUNC; \
347 #define S_STAT_END(a) } a;
352 static void FAST_FUNC
collect_literal(s_stat
*s UNUSED_PARAM
)
356 static s_stat
* init_literal(void)
358 s_stat
*s
= xzalloc(sizeof(*s
));
359 s
->collect
= collect_literal
;
363 static s_stat
* init_delay(const char *param
)
365 delta
= strtoul(param
, NULL
, 0) * 1000; /* param can be "" */
366 deltanz
= delta
> 0 ? delta
: 1;
367 need_seconds
= (1000000%deltanz
) != 0;
371 static s_stat
* init_cr(const char *param UNUSED_PARAM
)
378 // user nice system idle iowait irq softirq (last 3 only in 2.6)
379 //cpu 649369 0 341297 4336769 11640 7122 1183
380 //cpuN 649369 0 341297 4336769 11640 7122 1183
381 enum { CPU_FIELDCNT
= 7 };
383 ullong old
[CPU_FIELDCNT
];
389 static void FAST_FUNC
collect_cpu(cpu_stat
*s
)
391 ullong data
[CPU_FIELDCNT
] = { 0, 0, 0, 0, 0, 0, 0 };
392 unsigned frac
[CPU_FIELDCNT
] = { 0, 0, 0, 0, 0, 0, 0 };
395 int bar_sz
= s
->bar_sz
;
399 if (rdval(get_file(&proc_stat
), "cpu ", data
, 1, 2, 3, 4, 5, 6, 7)) {
400 put_question_marks(bar_sz
);
404 for (i
= 0; i
< CPU_FIELDCNT
; i
++) {
405 ullong old
= s
->old
[i
];
406 if (data
[i
] < old
) old
= data
[i
]; //sanitize
408 all
+= (data
[i
] -= old
);
412 for (i
= 0; i
< CPU_FIELDCNT
; i
++) {
413 ullong t
= bar_sz
* data
[i
];
414 norm_all
+= data
[i
] = t
/ all
;
418 while (norm_all
< bar_sz
) {
419 unsigned max
= frac
[0];
421 for (i
= 1; i
< CPU_FIELDCNT
; i
++) {
422 if (frac
[i
] > max
) max
= frac
[i
], pos
= i
;
424 frac
[pos
] = 0; //avoid bumping up same value twice
429 memset(bar
, '.', bar_sz
);
430 memset(bar
, 'S', data
[2]); bar
+= data
[2]; //sys
431 memset(bar
, 'U', data
[0]); bar
+= data
[0]; //usr
432 memset(bar
, 'N', data
[1]); bar
+= data
[1]; //nice
433 memset(bar
, 'D', data
[4]); bar
+= data
[4]; //iowait
434 memset(bar
, 'I', data
[5]); bar
+= data
[5]; //irq
435 memset(bar
, 'i', data
[6]); bar
+= data
[6]; //softirq
437 memset(bar
, '?', bar_sz
);
443 static s_stat
* init_cpu(const char *param
)
446 cpu_stat
*s
= xzalloc(sizeof(*s
));
447 s
->collect
= collect_cpu
;
448 sz
= strtoul(param
, NULL
, 0); /* param can be "" */
449 if (sz
< 10) sz
= 10;
450 if (sz
> 1000) sz
= 1000;
451 s
->bar
= xzalloc(sz
+1);
452 /*s->bar[sz] = '\0'; - xzalloc did it */
463 static void FAST_FUNC
collect_int(int_stat
*s
)
468 if (rdval(get_file(&proc_stat
), "intr", data
, s
->no
)) {
469 put_question_marks(4);
474 if (data
[0] < old
) old
= data
[0]; //sanitize
476 scale(data
[0] - old
);
479 static s_stat
* init_int(const char *param
)
481 int_stat
*s
= xzalloc(sizeof(*s
));
482 s
->collect
= collect_int
;
483 if (param
[0] == '\0') {
486 int n
= xatoi_positive(param
);
497 static void FAST_FUNC
collect_ctx(ctx_stat
*s
)
502 if (rdval(get_file(&proc_stat
), "ctxt", data
, 1)) {
503 put_question_marks(4);
508 if (data
[0] < old
) old
= data
[0]; //sanitize
510 scale(data
[0] - old
);
513 static s_stat
* init_ctx(const char *param UNUSED_PARAM
)
515 ctx_stat
*s
= xzalloc(sizeof(*s
));
516 s
->collect
= collect_ctx
;
526 static void FAST_FUNC
collect_blk(blk_stat
*s
)
532 i
= rdval_diskstats(get_file(&proc_diskstats
), data
);
534 i
= rdval(get_file(&proc_stat
), s
->lookfor
, data
, 1, 2);
535 // Linux 2.4 reports bio in Kbytes, convert to sectors:
540 put_question_marks(9);
544 for (i
=0; i
<2; i
++) {
545 ullong old
= s
->old
[i
];
546 if (data
[i
] < old
) old
= data
[i
]; //sanitize
550 scale(data
[0]*512); // TODO: *sectorsize
555 static s_stat
* init_blk(const char *param UNUSED_PARAM
)
557 blk_stat
*s
= xzalloc(sizeof(*s
));
558 s
->collect
= collect_blk
;
566 S_STAT_END(fork_stat
)
568 static void FAST_FUNC
collect_thread_nr(fork_stat
*s UNUSED_PARAM
)
572 if (rdval_loadavg(get_file(&proc_loadavg
), data
, 4)) {
573 put_question_marks(4);
579 static void FAST_FUNC
collect_fork(fork_stat
*s
)
584 if (rdval(get_file(&proc_stat
), "processes", data
, 1)) {
585 put_question_marks(4);
590 if (data
[0] < old
) old
= data
[0]; //sanitize
592 scale(data
[0] - old
);
595 static s_stat
* init_fork(const char *param
)
597 fork_stat
*s
= xzalloc(sizeof(*s
));
599 s
->collect
= collect_thread_nr
;
601 s
->collect
= collect_fork
;
613 static void FAST_FUNC
collect_if(if_stat
*s
)
618 if (rdval(get_file(&proc_net_dev
), s
->device_colon
, data
, 1, 3, 9, 11)) {
619 put_question_marks(10);
623 for (i
=0; i
<4; i
++) {
624 ullong old
= s
->old
[i
];
625 if (data
[i
] < old
) old
= data
[i
]; //sanitize
629 put_c(data
[1] ? '*' : ' ');
631 put_c(data
[3] ? '*' : ' ');
635 static s_stat
* init_if(const char *device
)
637 if_stat
*s
= xzalloc(sizeof(*s
));
639 if (!device
|| !device
[0])
641 s
->collect
= collect_if
;
644 s
->device_colon
= xasprintf("%s:", device
);
653 // "Memory" value should not include any caches.
654 // IOW: neither "ls -laR /" nor heavy read/write activity
655 // should affect it. We'd like to also include any
656 // long-term allocated kernel-side mem, but it is hard
657 // to figure out. For now, bufs, cached & slab are
658 // counted as "free" memory
660 //MemTotal: 773280 kB
661 //MemFree: 25912 kB - genuinely free
662 //Buffers: 320672 kB - cache
663 //Cached: 146396 kB - cache
666 //Inactive: 356892 kB
669 //LowTotal: 773280 kB
671 //SwapTotal: 131064 kB
672 //SwapFree: 131064 kB
676 //Slab: 200668 kB - takes 7 Mb on my box fresh after boot,
677 // but includes dentries and inodes
678 // (== can take arbitrary amount of mem)
679 //CommitLimit: 517704 kB
680 //Committed_AS: 236776 kB
681 //PageTables: 1248 kB
682 //VmallocTotal: 516052 kB
683 //VmallocUsed: 3852 kB
684 //VmallocChunk: 512096 kB
687 //Hugepagesize: 4096 kB
688 static void FAST_FUNC
collect_mem(mem_stat
*s
)
696 if (rdval(get_file(&proc_meminfo
), "MemTotal:", &m_total
, 1)) {
697 put_question_marks(4);
701 scale(m_total
<< 10);
705 if (rdval(proc_meminfo
.file
, "MemFree:", &m_free
, 1)
706 || rdval(proc_meminfo
.file
, "Buffers:", &m_bufs
, 1)
707 || rdval(proc_meminfo
.file
, "Cached:", &m_cached
, 1)
708 || rdval(proc_meminfo
.file
, "Slab:", &m_slab
, 1)
710 put_question_marks(4);
714 m_free
+= m_bufs
+ m_cached
+ m_slab
;
717 scale(m_free
<< 10); break;
719 scale((m_total
- m_free
) << 10); break;
723 static s_stat
* init_mem(const char *param
)
725 mem_stat
*s
= xzalloc(sizeof(*s
));
726 s
->collect
= collect_mem
;
735 static void FAST_FUNC
collect_swp(swp_stat
*s UNUSED_PARAM
)
739 if (rdval(get_file(&proc_meminfo
), "SwapTotal:", s_total
, 1)
740 || rdval(proc_meminfo
.file
, "SwapFree:" , s_free
, 1)
742 put_question_marks(4);
745 scale((s_total
[0]-s_free
[0]) << 10);
748 static s_stat
* init_swp(const char *param UNUSED_PARAM
)
750 swp_stat
*s
= xzalloc(sizeof(*s
));
751 s
->collect
= collect_swp
;
759 static void FAST_FUNC
collect_fd(fd_stat
*s UNUSED_PARAM
)
763 if (rdval(get_file(&proc_sys_fs_filenr
), "", data
, 1, 2)) {
764 put_question_marks(4);
768 scale(data
[0] - data
[1]);
771 static s_stat
* init_fd(const char *param UNUSED_PARAM
)
773 fd_stat
*s
= xzalloc(sizeof(*s
));
774 s
->collect
= collect_fd
;
782 S_STAT_END(time_stat
)
784 static void FAST_FUNC
collect_time(time_stat
*s
)
786 char buf
[sizeof("12:34:56.123456")];
788 int us
= tv
.tv_usec
+ s
->scale
/2;
789 time_t t
= tv
.tv_sec
;
797 sprintf(buf
, "%02d:%02d:%02d", tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
799 sprintf(buf
+8, ".%0*d", s
->prec
, us
/ s
->scale
);
803 static s_stat
* init_time(const char *param
)
806 time_stat
*s
= xzalloc(sizeof(*s
));
808 s
->collect
= collect_time
;
809 prec
= param
[0] - '0';
810 if (prec
< 0) prec
= 0;
811 else if (prec
> 6) prec
= 6;
819 static void FAST_FUNC
collect_info(s_stat
*s
)
830 typedef s_stat
* init_func(const char *param
);
832 // Deprecated %NNNd is to be removed, -d MSEC supersedes it
833 static const char options
[] ALIGN1
= "ncmsfixptbdr";
834 static init_func
*const init_functions
[] = {
849 int nmeter_main(int argc
, char **argv
) MAIN_EXTERNALLY_VISIBLE
;
850 int nmeter_main(int argc UNUSED_PARAM
, char **argv
)
853 s_stat
*first
= NULL
;
863 if (open_read_close("version", buf
, sizeof(buf
)-1) > 0) {
864 buf
[sizeof(buf
)-1] = '\0';
865 is26
= (strstr(buf
, " 2.4.") == NULL
);
868 if (getopt32(argv
, "d:", &opt_d
))
875 // Can use argv[0] directly, but this will mess up
876 // parameters as seen by e.g. ps. Making a copy...
877 cur
= xstrdup(argv
[0]);
882 cur
= strchr(cur
, '%');
885 if (cur
[1] == '%') { // %%
886 overlapping_strcpy(cur
, cur
+ 1);
890 *cur
++ = '\0'; // overwrite %
892 // format: %[foptstring]
894 p
= strchr(options
, cur
[0]);
896 while (cur
[0] != ']') {
901 *cur
++ = '\0'; // overwrite [
905 while (cur
[0] >= '0' && cur
[0] <= '9')
909 p
= strchr(options
, cur
[0]);
910 *cur
++ = '\0'; // overwrite format char
914 s
= init_functions
[p
-options
](param
);
917 /*s->next = NULL; - all initXXX funcs use xzalloc */
924 // %NNNNd or %r option. remove it from string
925 strcpy(prev
+ strlen(prev
), cur
);
932 /*s->next = NULL; - all initXXX funcs use xzalloc */
940 // Generate first samples but do not print them, they're bogus
944 gettimeofday(&tv
, NULL
);
945 usleep(delta
> 1000000 ? 1000000 : delta
- tv
.tv_usec
%deltanz
);
949 gettimeofday(&tv
, NULL
);
954 // Negative delta -> no usleep at all
955 // This will hog the CPU but you can have REALLY GOOD
956 // time resolution ;)
957 // TODO: detect and avoid useless updates
958 // (like: nothing happens except time)
961 // can be commented out, will sacrifice sleep time precision a bit
962 gettimeofday(&tv
, NULL
);
964 rem
= delta
- ((ullong
)tv
.tv_sec
*1000000 + tv
.tv_usec
) % deltanz
;
966 rem
= delta
- tv
.tv_usec
%deltanz
;
967 // Sometimes kernel wakes us up just a tiny bit earlier than asked
968 // Do not go to very short sleep in this case
969 if (rem
< delta
/128) {