ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/saidar/saidar.c
Revision: 1.1
Committed: Thu Oct 9 15:57:05 2003 UTC (21 years ago) by pajs
Content type: text/plain
Branch: MAIN
Log Message: 
First release of saidar. This version works on all platforms, using ncurses
fine. Bugs exist when linked against the solaris curses. (E.g. if while
running saidar you hammer a key repeatedly, the screen no longer updates.
This only happens with the solaris curses however)

Saidar takes a single optional flag, "-d" and an argument of the delay in
seconds. e.g.

saidar -d 1

Will update the screen once a second (the fastest allowed update time). The
default update it every 3 seconds. However, if you press any other key, it
will update immidiately (unless its less than 1 second, in which case it will
update at the earlist available time)

File Contents

# User Rev Content
1 pajs 1.1 #include <stdio.h>
2     #include <string.h>
3     #include <sys/ioctl.h>
4     #include <unistd.h>
5     #include <stdlib.h>
6     #include <sys/termios.h>
7     #include <signal.h>
8     #include <errno.h>
9     #include <statgrab.h>
10     #include <sys/times.h>
11     #include <limits.h>
12     #include <time.h>
13     #include <curses.h>
14    
15     typedef struct{
16     cpu_percent_t *cpu_percents;
17     mem_stat_t *mem_stats;
18     swap_stat_t *swap_stats;
19     load_stat_t *load_stats;
20     process_stat_t *process_stats;
21     page_stat_t *page_stats;
22    
23     network_stat_t *network_stats;
24     int network_entries;
25    
26     diskio_stat_t *diskio_stats;
27     int diskio_entries;
28    
29     disk_stat_t *disk_stats;
30     int disk_entries;
31    
32     general_stat_t *general_stats;
33     user_stat_t *user_stats;
34     }stats_t;
35    
36     stats_t stats;
37    
38     char *size_conv(long long number){
39     char type[] = {'B', 'K', 'M', 'G', 'T'};
40     int x=0;
41     static char string[10];
42    
43     for(;x<5;x++){
44     if( (number/1024) < (100)) {
45     break;
46     }
47     number = (number/1024);
48     }
49    
50     snprintf(string, 10, "%lld%c", number, type[x]);
51     return string;
52    
53     }
54    
55     char *hr_uptime(time_t time){
56     int day = 0, hour = 0, min = 0;
57     static char uptime_str[25];
58     int sec = (int) time;
59    
60     day = sec / (24*60*60);
61     sec = sec % (24*60*60);
62     hour = sec / (60*60);
63     sec = sec % (60*60);
64     min = sec / 60;
65     sec = sec % 60;
66    
67     if(day){
68     snprintf(uptime_str, 25, "%dd %02d:%02d:%02d", day, hour, min, sec);
69     }else{
70     snprintf(uptime_str, 25, "%02d:%02d:%02d", hour, min, sec);
71     }
72     return uptime_str;
73     }
74    
75     void display_headings(){
76     move(0,0);
77     printw("Hostname :");
78     move(0,27);
79     printw("Uptime : ");
80     move(0,54);
81     printw("Date : ");
82    
83     /* Load */
84     move(2,0);
85     printw("Load 1 :");
86     move(3,0);
87     printw("Load 5 :");
88     move(4,0);
89     printw("Load 15 :");
90    
91     /* CPU */
92     move(2,21);
93     printw("CPU Idle :");
94     move(3,21);
95     printw("CPU System:");
96     move(4,21);
97     printw("CPU User :");
98    
99     /* Process */
100     move(2, 42);
101     printw("Running :");
102     move(3, 42);
103     printw("Sleeping :");
104     move(4, 42);
105     printw("Stopped :");
106     move(2, 62);
107     printw("Zombie :");
108     move(3, 62);
109     printw("Total :");
110     move(4, 62);
111     printw("No. Users :");
112    
113     /* Mem */
114     move(6, 0);
115     printw("Mem Total :");
116     move(7, 0);
117     printw("Mem Used :");
118     move(8, 0);
119     printw("Mem Free :");
120    
121     /* Swap */
122     move(6, 21);
123     printw("Swap Total:");
124     move(7, 21);
125     printw("Swap Used :");
126     move(8, 21);
127     printw("Swap Free :");
128    
129     /* VM */
130     move(6, 42);
131     printw("Mem Used :");
132     move(7, 42);
133     printw("Swap Used :");
134     move(8, 42);
135     printw("Total Used:");
136    
137     /* Paging */
138     move(6, 62);
139     printw("Paging in :");
140     move(7, 62);
141     printw("Paging out:");
142    
143     /* Disk IO */
144     move(10,0);
145     printw("Disk Name");
146     move(10,15);
147     printw("Read");
148     move(10,28);
149     printw("Write");
150    
151     /* Network IO */
152     move(10, 42);
153     printw("Network Interface");
154     move(10, 67);
155     printw("rx");
156     move(10,77);
157     printw("tx");
158    
159     move(12+stats.network_entries, 42);
160     printw("Mount Point");
161     move(12+stats.network_entries, 65);
162     printw("Free");
163     move(12+stats.network_entries, 75);
164     printw("Used");
165    
166     refresh();
167     }
168    
169     void display_data(){
170     char cur_time[20];
171     struct tm *tm_time;
172     time_t epoc_time;
173     int counter;
174     long long r,w;
175     long long rt, wt;
176     diskio_stat_t *diskio_stat_ptr;
177     network_stat_t *network_stat_ptr;
178     disk_stat_t *disk_stat_ptr;
179    
180     move(0,12);
181     printw("%s", stats.general_stats->hostname);
182     move(0,36);
183     printw("%s", hr_uptime(stats.general_stats->uptime));
184     epoc_time=time(NULL);
185     tm_time = localtime(&epoc_time);
186     strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
187     move(0,61);
188     printw("%s", cur_time);
189    
190     /* Load */
191     move(2,12);
192     printw("%6.2f", stats.load_stats->min1);
193     move(3,12);
194     printw("%6.2f", stats.load_stats->min5);
195     move(4,12);
196     printw("%6.2f", stats.load_stats->min15);
197    
198     /* CPU */
199     move(2,33);
200     printw("%6.2f%%", stats.cpu_percents->idle);
201     move(3,33);
202     printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
203     move(4,33);
204     printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
205    
206     /* Process */
207     move(2, 54);
208     printw("%5d", stats.process_stats->running);
209     move(2,74);
210     printw("%5d", stats.process_stats->zombie);
211     move(3, 54);
212     printw("%5d", stats.process_stats->sleeping);
213     move(3, 74);
214     printw("%5d", stats.process_stats->total);
215     move(4, 54);
216     printw("%5d", stats.process_stats->stopped);
217     move(4,74);
218     printw("%5d", stats.user_stats->num_entries);
219    
220     /* Mem */
221    
222     move(6, 12);
223     printw("%7s", size_conv(stats.mem_stats->total));
224     move(7, 12);
225     printw("%7s", size_conv(stats.mem_stats->used));
226     move(8, 12);
227     printw("%7s", size_conv(stats.mem_stats->free));
228    
229     /* Swap */
230     move(6, 32);
231     printw("%8s", size_conv(stats.swap_stats->total));
232     move(7, 32);
233     printw("%8s", size_conv(stats.swap_stats->used));
234     move(8, 32);
235     printw("%8s", size_conv(stats.swap_stats->free));
236    
237     /* VM */
238     move(6, 54);
239     printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total));
240     move(7, 54);
241     printw("%5.2f%%", (100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total));
242     move(8, 54);
243     printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
244    
245     /* Paging */
246     move(6, 74);
247     printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
248     move(7, 74);
249     printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
250    
251     /* Disk IO */
252     diskio_stat_ptr = stats.diskio_stats;
253     r=0;
254     w=0;
255     for(counter=0;counter<stats.diskio_entries;counter++){
256     move(11+counter, 0);
257     printw("%s", diskio_stat_ptr->disk_name);
258     move(11+counter, 12);
259     rt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->read_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->read_bytes;
260     printw("%7s", size_conv(rt));
261     r+=rt;
262     move(11+counter, 26);
263     wt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->write_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->write_bytes;
264     printw("%7s", size_conv(wt));
265     w+=wt;
266     diskio_stat_ptr++;
267     }
268     move(12+counter, 0);
269     printw("Total");
270     move(12+counter, 12);
271     printw("%7s", size_conv(r));
272     move(12+counter, 26);
273     printw("%7s", size_conv(w));
274    
275     /* Network */
276     network_stat_ptr = stats.network_stats;
277     for(counter=0;counter<stats.network_entries;counter++){
278     move(11+counter, 42);
279     printw("%s", network_stat_ptr->interface_name);
280     move(11+counter, 62);
281     rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
282     printw("%7s", size_conv(rt));
283     move(11+counter, 72);
284     wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
285     printw("%7s", size_conv(wt));
286     network_stat_ptr++;
287     }
288    
289     disk_stat_ptr = stats.disk_stats;
290     for(counter=0;counter<stats.disk_entries;counter++){
291     move(13+stats.network_entries+counter, 42);
292     printw("%s", disk_stat_ptr->mnt_point);
293     move(13+stats.network_entries+counter, 62);
294     printw("%7s", size_conv(disk_stat_ptr->avail));
295     move(13+stats.network_entries+counter, 73);
296     printw("%5.2f%%", 100.00 * ((float)disk_stat_ptr->used / (float)disk_stat_ptr->size));
297     disk_stat_ptr++;
298     }
299    
300     refresh();
301     }
302    
303     void sig_winch_handler(int sig){
304     clear();
305     display_headings();
306     display_data();
307     signal(SIGWINCH, sig_winch_handler);
308     }
309    
310     int get_stats(){
311     if((stats.cpu_percents = cpu_percent_usage()) == NULL) return 0;
312     if((stats.mem_stats = get_memory_stats()) == NULL) return 0;
313     if((stats.swap_stats = get_swap_stats()) == NULL) return 0;
314     if((stats.load_stats = get_load_stats()) == NULL) return 0;
315     if((stats.process_stats = get_process_stats()) == NULL) return 0;
316     if((stats.page_stats = get_page_stats_diff()) == NULL) return 0;
317     if((stats.network_stats = get_network_stats_diff(&(stats.network_entries))) == NULL) return 0;
318     if((stats.diskio_stats = get_diskio_stats_diff(&(stats.diskio_entries))) == NULL) return 0;
319     if((stats.disk_stats = get_disk_stats(&(stats.disk_entries))) == NULL) return 0;
320     if((stats.general_stats = get_general_stats()) == NULL) return 0;
321     if((stats.user_stats = get_user_stats()) == NULL) return 0;
322    
323     return 1;
324     }
325    
326     int main(int argc, char **argv){
327    
328     extern char *optarg;
329     extern int optind;
330     int c;
331    
332     WINDOW *window;
333    
334     int stdin_fileno;
335     fd_set infds;
336     struct timeval timeout;
337    
338     extern int errno;
339     char ch;
340    
341     int delay=2;
342    
343     while ((c = getopt(argc, argv, "d:")) != EOF){
344     switch (c){
345     case 'd':
346     delay = atoi(optarg);
347     if (delay == 0){
348     fprintf(stderr, "Time must be 1 second or greater\n");
349     exit(1);
350     }
351     delay--;
352     break;
353     }
354     }
355    
356     signal(SIGWINCH, sig_winch_handler);
357     initscr();
358     nonl();
359     cbreak();
360     noecho();
361     window=newwin(0, 0, 0, 0);
362     clear();
363    
364     if(!get_stats()){
365     fprintf(stderr, "Failed to get all the stats. Please check correct permissions\n");
366     endwin();
367     return 1;
368     }
369    
370     display_headings();
371     stdin_fileno=fileno(stdin);
372    
373     for(;;){
374    
375     FD_ZERO(&infds);
376     FD_SET(stdin_fileno, &infds);
377     timeout.tv_sec = delay;
378     timeout.tv_usec = 0;
379    
380     if((select((stdin_fileno+1), &infds, NULL, NULL, &timeout)) == -1){
381     if(errno!=EINTR){
382     perror("select failed");
383     exit(1);
384     }
385     }
386    
387     if(FD_ISSET(stdin_fileno, &infds)){
388     ch=getch();
389     if (ch == 'q'){
390     endwin();
391     return 0;
392     }
393     }
394    
395     get_stats();
396    
397     display_data();
398    
399     /* To keep the numbers slightly accurate we do not want them updating more
400     * frequently than once a second.
401     */
402     sleep(1);
403    
404     }
405    
406    
407    
408     endwin();
409     return 0;
410     }