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")[0] = '\0';
343 struct s_stat *next; \
344 void (*collect)(struct a *s) FAST_FUNC; \
346 #define S_STAT_END(a) } a;
351 static void FAST_FUNC
collect_literal(s_stat
*s UNUSED_PARAM
)
355 static s_stat
* init_literal(void)
357 s_stat
*s
= xzalloc(sizeof(*s
));
358 s
->collect
= collect_literal
;
362 static s_stat
* init_delay(const char *param
)
364 delta
= strtoul(param
, NULL
, 0) * 1000; /* param can be "" */
365 deltanz
= delta
> 0 ? delta
: 1;
366 need_seconds
= (1000000%deltanz
) != 0;
370 static s_stat
* init_cr(const char *param UNUSED_PARAM
)
377 // user nice system idle iowait irq softirq (last 3 only in 2.6)
378 //cpu 649369 0 341297 4336769 11640 7122 1183
379 //cpuN 649369 0 341297 4336769 11640 7122 1183
380 enum { CPU_FIELDCNT
= 7 };
382 ullong old
[CPU_FIELDCNT
];
388 static void FAST_FUNC
collect_cpu(cpu_stat
*s
)
390 ullong data
[CPU_FIELDCNT
] = { 0, 0, 0, 0, 0, 0, 0 };
391 unsigned frac
[CPU_FIELDCNT
] = { 0, 0, 0, 0, 0, 0, 0 };
394 int bar_sz
= s
->bar_sz
;
398 if (rdval(get_file(&proc_stat
), "cpu ", data
, 1, 2, 3, 4, 5, 6, 7)) {
399 put_question_marks(bar_sz
);
403 for (i
= 0; i
< CPU_FIELDCNT
; i
++) {
404 ullong old
= s
->old
[i
];
405 if (data
[i
] < old
) old
= data
[i
]; //sanitize
407 all
+= (data
[i
] -= old
);
411 for (i
= 0; i
< CPU_FIELDCNT
; i
++) {
412 ullong t
= bar_sz
* data
[i
];
413 norm_all
+= data
[i
] = t
/ all
;
417 while (norm_all
< bar_sz
) {
418 unsigned max
= frac
[0];
420 for (i
= 1; i
< CPU_FIELDCNT
; i
++) {
421 if (frac
[i
] > max
) max
= frac
[i
], pos
= i
;
423 frac
[pos
] = 0; //avoid bumping up same value twice
428 memset(bar
, '.', bar_sz
);
429 memset(bar
, 'S', data
[2]); bar
+= data
[2]; //sys
430 memset(bar
, 'U', data
[0]); bar
+= data
[0]; //usr
431 memset(bar
, 'N', data
[1]); bar
+= data
[1]; //nice
432 memset(bar
, 'D', data
[4]); bar
+= data
[4]; //iowait
433 memset(bar
, 'I', data
[5]); bar
+= data
[5]; //irq
434 memset(bar
, 'i', data
[6]); bar
+= data
[6]; //softirq
436 memset(bar
, '?', bar_sz
);
442 static s_stat
* init_cpu(const char *param
)
445 cpu_stat
*s
= xzalloc(sizeof(*s
));
446 s
->collect
= collect_cpu
;
447 sz
= strtoul(param
, NULL
, 0); /* param can be "" */
448 if (sz
< 10) sz
= 10;
449 if (sz
> 1000) sz
= 1000;
450 s
->bar
= xzalloc(sz
+1);
451 /*s->bar[sz] = '\0'; - xzalloc did it */
462 static void FAST_FUNC
collect_int(int_stat
*s
)
467 if (rdval(get_file(&proc_stat
), "intr", data
, s
->no
)) {
468 put_question_marks(4);
473 if (data
[0] < old
) old
= data
[0]; //sanitize
475 scale(data
[0] - old
);
478 static s_stat
* init_int(const char *param
)
480 int_stat
*s
= xzalloc(sizeof(*s
));
481 s
->collect
= collect_int
;
482 if (param
[0] == '\0') {
485 int n
= xatoi_positive(param
);
496 static void FAST_FUNC
collect_ctx(ctx_stat
*s
)
501 if (rdval(get_file(&proc_stat
), "ctxt", data
, 1)) {
502 put_question_marks(4);
507 if (data
[0] < old
) old
= data
[0]; //sanitize
509 scale(data
[0] - old
);
512 static s_stat
* init_ctx(const char *param UNUSED_PARAM
)
514 ctx_stat
*s
= xzalloc(sizeof(*s
));
515 s
->collect
= collect_ctx
;
525 static void FAST_FUNC
collect_blk(blk_stat
*s
)
531 i
= rdval_diskstats(get_file(&proc_diskstats
), data
);
533 i
= rdval(get_file(&proc_stat
), s
->lookfor
, data
, 1, 2);
534 // Linux 2.4 reports bio in Kbytes, convert to sectors:
539 put_question_marks(9);
543 for (i
=0; i
<2; i
++) {
544 ullong old
= s
->old
[i
];
545 if (data
[i
] < old
) old
= data
[i
]; //sanitize
549 scale(data
[0]*512); // TODO: *sectorsize
554 static s_stat
* init_blk(const char *param UNUSED_PARAM
)
556 blk_stat
*s
= xzalloc(sizeof(*s
));
557 s
->collect
= collect_blk
;
565 S_STAT_END(fork_stat
)
567 static void FAST_FUNC
collect_thread_nr(fork_stat
*s UNUSED_PARAM
)
571 if (rdval_loadavg(get_file(&proc_loadavg
), data
, 4)) {
572 put_question_marks(4);
578 static void FAST_FUNC
collect_fork(fork_stat
*s
)
583 if (rdval(get_file(&proc_stat
), "processes", data
, 1)) {
584 put_question_marks(4);
589 if (data
[0] < old
) old
= data
[0]; //sanitize
591 scale(data
[0] - old
);
594 static s_stat
* init_fork(const char *param
)
596 fork_stat
*s
= xzalloc(sizeof(*s
));
598 s
->collect
= collect_thread_nr
;
600 s
->collect
= collect_fork
;
612 static void FAST_FUNC
collect_if(if_stat
*s
)
617 if (rdval(get_file(&proc_net_dev
), s
->device_colon
, data
, 1, 3, 9, 11)) {
618 put_question_marks(10);
622 for (i
=0; i
<4; i
++) {
623 ullong old
= s
->old
[i
];
624 if (data
[i
] < old
) old
= data
[i
]; //sanitize
628 put_c(data
[1] ? '*' : ' ');
630 put_c(data
[3] ? '*' : ' ');
634 static s_stat
* init_if(const char *device
)
636 if_stat
*s
= xzalloc(sizeof(*s
));
638 if (!device
|| !device
[0])
640 s
->collect
= collect_if
;
643 s
->device_colon
= xasprintf("%s:", device
);
652 // "Memory" value should not include any caches.
653 // IOW: neither "ls -laR /" nor heavy read/write activity
654 // should affect it. We'd like to also include any
655 // long-term allocated kernel-side mem, but it is hard
656 // to figure out. For now, bufs, cached & slab are
657 // counted as "free" memory
659 //MemTotal: 773280 kB
660 //MemFree: 25912 kB - genuinely free
661 //Buffers: 320672 kB - cache
662 //Cached: 146396 kB - cache
665 //Inactive: 356892 kB
668 //LowTotal: 773280 kB
670 //SwapTotal: 131064 kB
671 //SwapFree: 131064 kB
675 //Slab: 200668 kB - takes 7 Mb on my box fresh after boot,
676 // but includes dentries and inodes
677 // (== can take arbitrary amount of mem)
678 //CommitLimit: 517704 kB
679 //Committed_AS: 236776 kB
680 //PageTables: 1248 kB
681 //VmallocTotal: 516052 kB
682 //VmallocUsed: 3852 kB
683 //VmallocChunk: 512096 kB
686 //Hugepagesize: 4096 kB
687 static void FAST_FUNC
collect_mem(mem_stat
*s
)
695 if (rdval(get_file(&proc_meminfo
), "MemTotal:", &m_total
, 1)) {
696 put_question_marks(4);
700 scale(m_total
<< 10);
704 if (rdval(proc_meminfo
.file
, "MemFree:", &m_free
, 1)
705 || rdval(proc_meminfo
.file
, "Buffers:", &m_bufs
, 1)
706 || rdval(proc_meminfo
.file
, "Cached:", &m_cached
, 1)
707 || rdval(proc_meminfo
.file
, "Slab:", &m_slab
, 1)
709 put_question_marks(4);
713 m_free
+= m_bufs
+ m_cached
+ m_slab
;
716 scale(m_free
<< 10); break;
718 scale((m_total
- m_free
) << 10); break;
722 static s_stat
* init_mem(const char *param
)
724 mem_stat
*s
= xzalloc(sizeof(*s
));
725 s
->collect
= collect_mem
;
734 static void FAST_FUNC
collect_swp(swp_stat
*s UNUSED_PARAM
)
738 if (rdval(get_file(&proc_meminfo
), "SwapTotal:", s_total
, 1)
739 || rdval(proc_meminfo
.file
, "SwapFree:" , s_free
, 1)
741 put_question_marks(4);
744 scale((s_total
[0]-s_free
[0]) << 10);
747 static s_stat
* init_swp(const char *param UNUSED_PARAM
)
749 swp_stat
*s
= xzalloc(sizeof(*s
));
750 s
->collect
= collect_swp
;
758 static void FAST_FUNC
collect_fd(fd_stat
*s UNUSED_PARAM
)
762 if (rdval(get_file(&proc_sys_fs_filenr
), "", data
, 1, 2)) {
763 put_question_marks(4);
767 scale(data
[0] - data
[1]);
770 static s_stat
* init_fd(const char *param UNUSED_PARAM
)
772 fd_stat
*s
= xzalloc(sizeof(*s
));
773 s
->collect
= collect_fd
;
781 S_STAT_END(time_stat
)
783 static void FAST_FUNC
collect_time(time_stat
*s
)
785 char buf
[sizeof("12:34:56.123456")];
787 int us
= tv
.tv_usec
+ s
->scale
/2;
788 time_t t
= tv
.tv_sec
;
796 sprintf(buf
, "%02d:%02d:%02d", tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
798 sprintf(buf
+8, ".%0*d", s
->prec
, us
/ s
->scale
);
802 static s_stat
* init_time(const char *param
)
805 time_stat
*s
= xzalloc(sizeof(*s
));
807 s
->collect
= collect_time
;
808 prec
= param
[0] - '0';
809 if (prec
< 0) prec
= 0;
810 else if (prec
> 6) prec
= 6;
818 static void FAST_FUNC
collect_info(s_stat
*s
)
829 typedef s_stat
* init_func(const char *param
);
831 // Deprecated %NNNd is to be removed, -d MSEC supersedes it
832 static const char options
[] ALIGN1
= "ncmsfixptbdr";
833 static init_func
*const init_functions
[] = {
848 int nmeter_main(int argc
, char **argv
) MAIN_EXTERNALLY_VISIBLE
;
849 int nmeter_main(int argc UNUSED_PARAM
, char **argv
)
852 s_stat
*first
= NULL
;
862 if (open_read_close("version", buf
, sizeof(buf
)-1) > 0) {
863 buf
[sizeof(buf
)-1] = '\0';
864 is26
= (strstr(buf
, " 2.4.") == NULL
);
867 if (getopt32(argv
, "d:", &opt_d
))
874 // Can use argv[0] directly, but this will mess up
875 // parameters as seen by e.g. ps. Making a copy...
876 cur
= xstrdup(argv
[0]);
881 cur
= strchr(cur
, '%');
884 if (cur
[1] == '%') { // %%
885 overlapping_strcpy(cur
, cur
+ 1);
889 *cur
++ = '\0'; // overwrite %
891 // format: %[foptstring]
893 p
= strchr(options
, cur
[0]);
895 while (cur
[0] != ']') {
900 *cur
++ = '\0'; // overwrite [
904 while (cur
[0] >= '0' && cur
[0] <= '9')
908 p
= strchr(options
, cur
[0]);
909 *cur
++ = '\0'; // overwrite format char
913 s
= init_functions
[p
-options
](param
);
916 /*s->next = NULL; - all initXXX funcs use xzalloc */
923 // %NNNNd or %r option. remove it from string
924 strcpy(prev
+ strlen(prev
), cur
);
931 /*s->next = NULL; - all initXXX funcs use xzalloc */
939 // Generate first samples but do not print them, they're bogus
943 gettimeofday(&tv
, NULL
);
944 usleep(delta
> 1000000 ? 1000000 : delta
- tv
.tv_usec
%deltanz
);
948 gettimeofday(&tv
, NULL
);
953 // Negative delta -> no usleep at all
954 // This will hog the CPU but you can have REALLY GOOD
955 // time resolution ;)
956 // TODO: detect and avoid useless updates
957 // (like: nothing happens except time)
960 // can be commented out, will sacrifice sleep time precision a bit
961 gettimeofday(&tv
, NULL
);
963 rem
= delta
- ((ullong
)tv
.tv_sec
*1000000 + tv
.tv_usec
) % deltanz
;
965 rem
= delta
- tv
.tv_usec
%deltanz
;
966 // Sometimes kernel wakes us up just a tiny bit earlier than asked
967 // Do not go to very short sleep in this case
968 if (rem
< delta
/128) {