ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/saidar/saidar.c

Comparing projects/libstatgrab/src/saidar/saidar.c (file contents):
Revision 1.2 by tdb, Thu Oct 9 16:00:31 2003 UTC vs.
Revision 1.27 by ats, Mon Apr 5 15:40:17 2004 UTC

#	Line 1 | Line 1
1		/*
2		* i-scream central monitoring system
3		* http://www.i-scream.org
4	<	* Copyright (C) 2000-2002 i-scream
4	>	* Copyright (C) 2000-2004 i-scream
5		*
6		* This program is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU General Public License
#	Line 16 | Line 16
16		* You should have received a copy of the GNU General Public License
17		* along with this program; if not, write to the Free Software
18		* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19	+	*
20	+	* $Id$
21		*/
22
23		#ifdef HAVE_CONFIG_H
#	Line 42 | Line 44
44		#endif
45
46		typedef struct{
47	<	cpu_percent_t *cpu_percents;
48	<	mem_stat_t *mem_stats;
49	<	swap_stat_t *swap_stats;
50	<	load_stat_t *load_stats;
51	<	process_stat_t *process_stats;
52	<	page_stat_t *page_stats;
47	>	sg_cpu_percents *cpu_percents;
48	>	sg_mem_stats *mem_stats;
49	>	sg_swap_stats *swap_stats;
50	>	sg_load_stats *load_stats;
51	>	sg_process_count *process_count;
52	>	sg_page_stats *page_stats;
53
54	<	network_stat_t *network_stats;
55	<	int network_entries;
54	>	sg_network_io_stats *network_io_stats;
55	>	int network_io_entries;
56
57	<	diskio_stat_t *diskio_stats;
58	<	int diskio_entries;
57	>	sg_disk_io_stats *disk_io_stats;
58	>	int disk_io_entries;
59
60	<	disk_stat_t *disk_stats;
61	<	int disk_entries;
60	>	sg_fs_stats *fs_stats;
61	>	int fs_entries;
62
63	<	general_stat_t *general_stats;
64	<	user_stat_t *user_stats;
63	>	sg_host_info *host_info;
64	>	sg_user_stats *user_stats;
65		}stats_t;
66
67		stats_t stats;
#	Line 102 | Line 104 | char *hr_uptime(time_t time){
104		}
105
106		void display_headings(){
107	+	int line;
108	+
109		move(0,0);
110		printw("Hostname  :");
111		move(0,27);
#	Line 177 | Line 181 | void display_headings(){
181		move(10,28);
182		printw("Write");
183
184	<	/* Network IO */
185	<	move(10, 42);
186	<	printw("Network Interface");
187	<	move(10, 67);
188	<	printw("rx");
189	<	move(10,77);
190	<	printw("tx");
184	>	line = 10;
185	>	if (stats.network_io_stats != NULL) {
186	>	/* Network IO */
187	>	move(line, 42);
188	>	printw("Network Interface");
189	>	move(line, 67);
190	>	printw("rx");
191	>	move(line, 77);
192	>	printw("tx");
193	>	line += 2 + stats.network_io_entries;
194	>	}
195
196	<	move(12+stats.network_entries, 42);
196	>	move(line, 42);
197		printw("Mount Point");
198	<	move(12+stats.network_entries, 65);
198	>	move(line, 65);
199		printw("Free");
200	<	move(12+stats.network_entries, 75);
200	>	move(line, 75);
201		printw("Used");
202
203		refresh();
#	Line 199 | Line 207 | void display_data(){
207		char cur_time[20];
208		struct tm *tm_time;
209		time_t epoc_time;
210	<	int counter;
210	>	int counter, line;
211		long long r,w;
212		long long rt, wt;
213	<	diskio_stat_t *diskio_stat_ptr;
214	<	network_stat_t *network_stat_ptr;
215	<	disk_stat_t *disk_stat_ptr;
213	>	sg_disk_io_stats *disk_io_stat_ptr;
214	>	sg_network_io_stats *network_stat_ptr;
215	>	sg_fs_stats *disk_stat_ptr;
216	>	/* Size before it will start overwriting "uptime" */
217	>	char hostname[15];
218	>	char *ptr;
219
220	<	move(0,12);
221	<	printw("%s", stats.general_stats->hostname);
222	<	move(0,36);
223	<	printw("%s", hr_uptime(stats.general_stats->uptime));
224	<	epoc_time=time(NULL);
225	<	tm_time = localtime(&epoc_time);
226	<	strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
227	<	move(0,61);
228	<	printw("%s", cur_time);
220	>	if (stats.host_info != NULL) {
221	>	move(0,12);
222	>	strncpy(hostname, stats.host_info->hostname, (sizeof(hostname) - 1));
223	>	/* strncpy does not NULL terminate.. If only strlcpy was on all platforms :) */
224	>	hostname[14] = '\0';
225	>	ptr=strchr(hostname, '.');
226	>	/* Some hosts give back a FQDN for hostname. To avoid this, we'll
227	>	* just blank out everything after the first "."
228	>	*/
229	>	if (ptr != NULL){
230	>	*ptr = '\0';
231	>	}
232	>	printw("%s", hostname);
233	>	move(0,36);
234	>	printw("%s", hr_uptime(stats.host_info->uptime));
235	>	epoc_time=time(NULL);
236	>	tm_time = localtime(&epoc_time);
237	>	strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
238	>	move(0,61);
239	>	printw("%s", cur_time);
240	>	}
241
242	<	/* Load */
243	<	move(2,12);
244	<	printw("%6.2f", stats.load_stats->min1);
245	<	move(3,12);
246	<	printw("%6.2f", stats.load_stats->min5);
247	<	move(4,12);
248	<	printw("%6.2f", stats.load_stats->min15);
242	>	if (stats.load_stats != NULL) {
243	>	/* Load */
244	>	move(2,12);
245	>	printw("%6.2f", stats.load_stats->min1);
246	>	move(3,12);
247	>	printw("%6.2f", stats.load_stats->min5);
248	>	move(4,12);
249	>	printw("%6.2f", stats.load_stats->min15);
250	>	}
251
252	<	/* CPU */
253	<	move(2,33);
254	<	printw("%6.2f%%", stats.cpu_percents->idle);
255	<	move(3,33);
256	<	printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
257	<	move(4,33);
258	<	printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
252	>	if (stats.cpu_percents != NULL) {
253	>	/* CPU */
254	>	move(2,33);
255	>	printw("%6.2f%%", stats.cpu_percents->idle);
256	>	move(3,33);
257	>	printw("%6.2f%%", (stats.cpu_percents->kernel + stats.cpu_percents->iowait + stats.cpu_percents->swap));
258	>	move(4,33);
259	>	printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
260	>	}
261
262	<	/* Process */
263	<	move(2, 54);
264	<	printw("%5d", stats.process_stats->running);
265	<	move(2,74);
266	<	printw("%5d", stats.process_stats->zombie);
267	<	move(3, 54);
268	<	printw("%5d", stats.process_stats->sleeping);
269	<	move(3, 74);
270	<	printw("%5d", stats.process_stats->total);
271	<	move(4, 54);
272	<	printw("%5d", stats.process_stats->stopped);
273	<	move(4,74);
274	<	printw("%5d", stats.user_stats->num_entries);
262	>	if (stats.process_count != NULL) {
263	>	/* Process */
264	>	move(2, 54);
265	>	printw("%5d", stats.process_count->running);
266	>	move(2,74);
267	>	printw("%5d", stats.process_count->zombie);
268	>	move(3, 54);
269	>	printw("%5d", stats.process_count->sleeping);
270	>	move(3, 74);
271	>	printw("%5d", stats.process_count->total);
272	>	move(4, 54);
273	>	printw("%5d", stats.process_count->stopped);
274	>	}
275	>	if (stats.user_stats != NULL) {
276	>	move(4,74);
277	>	printw("%5d", stats.user_stats->num_entries);
278	>	}
279
280	<	/* Mem */
281	<
282	<	move(6, 12);
283	<	printw("%7s", size_conv(stats.mem_stats->total));
284	<	move(7, 12);
285	<	printw("%7s", size_conv(stats.mem_stats->used));
286	<	move(8, 12);
287	<	printw("%7s", size_conv(stats.mem_stats->free));
280	>	if (stats.mem_stats != NULL) {
281	>	/* Mem */
282	>	move(6, 12);
283	>	printw("%7s", size_conv(stats.mem_stats->total));
284	>	move(7, 12);
285	>	printw("%7s", size_conv(stats.mem_stats->used));
286	>	move(8, 12);
287	>	printw("%7s", size_conv(stats.mem_stats->free));
288	>	}
289
290	<	/* Swap */
291	<	move(6, 32);
292	<	printw("%8s", size_conv(stats.swap_stats->total));
293	<	move(7, 32);
294	<	printw("%8s", size_conv(stats.swap_stats->used));
295	<	move(8, 32);
296	<	printw("%8s", size_conv(stats.swap_stats->free));
290	>	if (stats.swap_stats != NULL) {
291	>	/* Swap */
292	>	move(6, 32);
293	>	printw("%8s", size_conv(stats.swap_stats->total));
294	>	move(7, 32);
295	>	printw("%8s", size_conv(stats.swap_stats->used));
296	>	move(8, 32);
297	>	printw("%8s", size_conv(stats.swap_stats->free));
298	>	}
299
300		/* VM */
301	<	move(6, 54);
302	<	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total));
303	<	move(7, 54);
304	<	printw("%5.2f%%", (100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total));
305	<	move(8, 54);
306	<	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
301	>	if (stats.mem_stats != NULL && stats.mem_stats->total != 0) {
302	>	move(6, 54);
303	>	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used)/stats.mem_stats->total));
304	>	}
305	>	if (stats.swap_stats != NULL && stats.swap_stats->total != 0) {
306	>	move(7, 54);
307	>	printw("%5.2f%%", (100.00 * (float)(stats.swap_stats->used)/stats.swap_stats->total));
308	>	}
309	>	if (stats.mem_stats != NULL && stats.swap_stats != NULL &&
310	>	stats.mem_stats->total != 0 && stats.swap_stats->total != 0) {
311	>	move(8, 54);
312	>	printw("%5.2f%%", (100.00 * (float)(stats.mem_stats->used+stats.swap_stats->used)/(stats.mem_stats->total+stats.swap_stats->total)));
313	>	}
314
315	<	/* Paging */
316	<	move(6, 74);
317	<	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
318	<	move(7, 74);
319	<	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
315	>	if (stats.page_stats != NULL) {
316	>	/* Paging */
317	>	move(6, 74);
318	>	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pagein / stats.page_stats->systime): stats.page_stats->pages_pagein);
319	>	move(7, 74);
320	>	printw("%5d", (stats.page_stats->systime)? (stats.page_stats->pages_pageout / stats.page_stats->systime) : stats.page_stats->pages_pageout);
321	>	}
322
323	<	/* Disk IO */
324	<	diskio_stat_ptr = stats.diskio_stats;
325	<	r=0;
326	<	w=0;
327	<	for(counter=0;counter<stats.diskio_entries;counter++){
328	<	move(11+counter, 0);
329	<	printw("%s", diskio_stat_ptr->disk_name);
330	<	move(11+counter, 12);
331	<	rt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->read_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->read_bytes;
332	<	printw("%7s", size_conv(rt));
333	<	r+=rt;
334	<	move(11+counter, 26);
335	<	wt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->write_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->write_bytes;
336	<	printw("%7s", size_conv(wt));
337	<	w+=wt;
338	<	diskio_stat_ptr++;
323	>	line = 11;
324	>	if (stats.disk_io_stats != NULL) {
325	>	/* Disk IO */
326	>	disk_io_stat_ptr = stats.disk_io_stats;
327	>	r=0;
328	>	w=0;
329	>	for(counter=0;counter<stats.disk_io_entries;counter++){
330	>	move(line, 0);
331	>	printw("%s", disk_io_stat_ptr->disk_name);
332	>	move(line, 12);
333	>	rt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->read_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->read_bytes;
334	>	printw("%7s", size_conv(rt));
335	>	r+=rt;
336	>	move(line, 26);
337	>	wt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->write_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->write_bytes;
338	>	printw("%7s", size_conv(wt));
339	>	w+=wt;
340	>	disk_io_stat_ptr++;
341	>	line++;
342	>	}
343	>	line++;
344	>	move(line, 0);
345	>	printw("Total");
346	>	move(line, 12);
347	>	printw("%7s", size_conv(r));
348	>	move(line, 26);
349	>	printw("%7s", size_conv(w));
350		}
297	–	move(12+counter, 0);
298	–	printw("Total");
299	–	move(12+counter, 12);
300	–	printw("%7s", size_conv(r));
301	–	move(12+counter, 26);
302	–	printw("%7s", size_conv(w));
351
352	<	/* Network */
353	<	network_stat_ptr = stats.network_stats;
354	<	for(counter=0;counter<stats.network_entries;counter++){
355	<	move(11+counter, 42);
356	<	printw("%s", network_stat_ptr->interface_name);
357	<	move(11+counter, 62);
358	<	rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
359	<	printw("%7s", size_conv(rt));
360	<	move(11+counter, 72);
361	<	wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
362	<	printw("%7s", size_conv(wt));
363	<	network_stat_ptr++;
352	>	line = 11;
353	>	if (stats.network_io_stats != NULL) {
354	>	/* Network */
355	>	network_stat_ptr = stats.network_io_stats;
356	>	for(counter=0;counter<stats.network_io_entries;counter++){
357	>	move(line, 42);
358	>	printw("%s", network_stat_ptr->interface_name);
359	>	move(line, 62);
360	>	rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
361	>	printw("%7s", size_conv(rt));
362	>	move(line, 72);
363	>	wt = (network_stat_ptr->systime)? (network_stat_ptr->tx / network_stat_ptr->systime): network_stat_ptr->tx;
364	>	printw("%7s", size_conv(wt));
365	>	network_stat_ptr++;
366	>	line++;
367	>	}
368	>	line += 2;
369		}
370
371	<	disk_stat_ptr = stats.disk_stats;
372	<	for(counter=0;counter<stats.disk_entries;counter++){
373	<	move(13+stats.network_entries+counter, 42);
374	<	printw("%s", disk_stat_ptr->mnt_point);
375	<	move(13+stats.network_entries+counter, 62);
376	<	printw("%7s", size_conv(disk_stat_ptr->avail));
377	<	move(13+stats.network_entries+counter, 73);
378	<	printw("%5.2f%%", 100.00 * ((float)disk_stat_ptr->used / (float)disk_stat_ptr->size));
379	<	disk_stat_ptr++;
371	>	if (stats.fs_stats != NULL) {
372	>	/* Disk */
373	>	disk_stat_ptr = stats.fs_stats;
374	>	for(counter=0;counter<stats.fs_entries;counter++){
375	>	move(line, 42);
376	>	printw("%s", disk_stat_ptr->mnt_point);
377	>	move(line, 62);
378	>	printw("%7s", size_conv(disk_stat_ptr->avail));
379	>	move(line, 73);
380	>	printw("%5.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
381	>	disk_stat_ptr++;
382	>	line++;
383	>	}
384		}
385
386		refresh();
#	Line 337 | Line 394 | void sig_winch_handler(int sig){
394		}
395
396		int get_stats(){
397	<	if((stats.cpu_percents = cpu_percent_usage()) == NULL) return 0;
398	<	if((stats.mem_stats = get_memory_stats()) == NULL) return 0;
399	<	if((stats.swap_stats = get_swap_stats()) == NULL) return 0;
400	<	if((stats.load_stats = get_load_stats()) == NULL) return 0;
401	<	if((stats.process_stats = get_process_stats()) == NULL) return 0;
402	<	if((stats.page_stats = get_page_stats_diff()) == NULL) return 0;
403	<	if((stats.network_stats = get_network_stats_diff(&(stats.network_entries))) == NULL) return 0;
404	<	if((stats.diskio_stats = get_diskio_stats_diff(&(stats.diskio_entries))) == NULL) return 0;
405	<	if((stats.disk_stats = get_disk_stats(&(stats.disk_entries))) == NULL) return 0;
406	<	if((stats.general_stats = get_general_stats()) == NULL) return 0;
407	<	if((stats.user_stats = get_user_stats()) == NULL) return 0;
397	>	stats.cpu_percents = sg_get_cpu_percents();
398	>	stats.mem_stats = sg_get_mem_stats();
399	>	stats.swap_stats = sg_get_swap_stats();
400	>	stats.load_stats = sg_get_load_stats();
401	>	stats.process_count = sg_get_process_count();
402	>	stats.page_stats = sg_get_page_stats_diff();
403	>	stats.network_io_stats = sg_get_network_io_stats_diff(&(stats.network_io_entries));
404	>	stats.disk_io_stats = sg_get_disk_io_stats_diff(&(stats.disk_io_entries));
405	>	stats.fs_stats = sg_get_fs_stats(&(stats.fs_entries));
406	>	stats.host_info = sg_get_host_info();
407	>	stats.user_stats = sg_get_user_stats();
408
409	<	return 1;
409	>	return 1;
410		}
411
412	+	void version_num(char *progname){
413	+	fprintf(stderr, "%s version %s\n", progname, PACKAGE_VERSION);
414	+	fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
415	+	exit(1);
416	+	}
417	+
418	+	void usage(char *progname){
419	+	fprintf(stderr, "Usage: %s [-d delay] [-v] [-h]\n\n", progname);
420	+	fprintf(stderr, "  -d    Sets the update time in seconds\n");
421	+	fprintf(stderr, "  -v    Prints version number\n");
422	+	fprintf(stderr, "  -h    Displays this help information.\n");
423	+	fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
424	+	exit(1);
425	+	}
426	+
427		int main(int argc, char **argv){
428
429		extern char *optarg;
358	–	extern int optind;
430		int c;
431
432	+	time_t last_update = 0;
433	+
434		WINDOW *window;
435
363	–	int stdin_fileno;
364	–	fd_set infds;
365	–	struct timeval timeout;
366	–
436		extern int errno;
368	–	char ch;
437
438		int delay=2;
439
440	<	while ((c = getopt(argc, argv, "d:")) != EOF){
440	>	sg_init();
441	>	if(sg_drop_privileges() != 0){
442	>	fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
443	>	return 1;
444	>	}
445	>
446	>	while ((c = getopt(argc, argv, "vhd:")) != -1){
447		switch (c){
448		case 'd':
449		delay = atoi(optarg);
450	<	if (delay == 0){
450	>	if (delay < 1){
451		fprintf(stderr, "Time must be 1 second or greater\n");
452		exit(1);
453		}
380	–	delay--;
454		break;
455	+	case 'v':
456	+	version_num(argv[0]);
457	+	break;
458	+	case 'h':
459	+	default:
460	+	usage(argv[0]);
461	+	return 1;
462	+	break;
463		}
464		}
465
#	Line 387 | Line 468 | int main(int argc, char **argv){
468		nonl();
469		cbreak();
470		noecho();
471	+	timeout(delay * 1000);
472		window=newwin(0, 0, 0, 0);
473		clear();
474
#	Line 397 | Line 479 | int main(int argc, char **argv){
479		}
480
481		display_headings();
400	–	stdin_fileno=fileno(stdin);
482
483		for(;;){
484	+	time_t now;
485	+	int ch = getch();
486
487	<	FD_ZERO(&infds);
488	<	FD_SET(stdin_fileno, &infds);
406	<	timeout.tv_sec = delay;
407	<	timeout.tv_usec = 0;
408	<
409	<	if((select((stdin_fileno+1), &infds, NULL, NULL, &timeout)) == -1){
410	<	if(errno!=EINTR){
411	<	perror("select failed");
412	<	exit(1);
413	<	}
487	>	if (ch == 'q'){
488	>	break;
489		}
490
491	<	if(FD_ISSET(stdin_fileno, &infds)){
492	<	ch=getch();
493	<	if (ch == 'q'){
494	<	endwin();
495	<	return 0;
496	<	}
491	>	/* To keep the numbers slightly accurate we do not want them
492	>	* updating more frequently than once a second.
493	>	*/
494	>	now = time(NULL);
495	>	if ((now - last_update) >= 1) {
496	>	get_stats();
497		}
498	+	last_update = now;
499
424	–	get_stats();
425	–
500		display_data();
427	–
428	–	/* To keep the numbers slightly accurate we do not want them updating more
429	–	* frequently than once a second.
430	–	*/
431	–	sleep(1);
432	–
501		}
434	–
435	–
502
503		endwin();
504		return 0;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines