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.16 by ats, Fri Nov 7 18:28:05 2003 UTC vs.
Revision 1.31 by tdb, Sat Nov 6 19:02:21 2004 UTC

#	Line 1 | Line 1
1		/*
2	<	* i-scream central monitoring system
2	>	* i-scream libstatgrab
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 150 | Line 152 | void display_headings(){
152		printw("Mem Free  :");
153
154		/* Swap */
155	<	move(6, 21);
156	<	printw("Swap Total:");
157	<	move(7, 21);
158	<	printw("Swap Used :");
159	<	move(8, 21);
160	<	printw("Swap Free :");
155	>	move(6, 21);
156	>	printw("Swap Total:");
157	>	move(7, 21);
158	>	printw("Swap Used :");
159	>	move(8, 21);
160	>	printw("Swap Free :");
161
162		/* VM */
163		move(6, 42);
#	Line 180 | Line 182 | void display_headings(){
182		printw("Write");
183
184		line = 10;
185	<	if (stats.network_stats != NULL) {
185	>	if (stats.network_io_stats != NULL) {
186		/* Network IO */
187		move(line, 42);
188		printw("Network Interface");
#	Line 188 | Line 190 | void display_headings(){
190		printw("rx");
191		move(line, 77);
192		printw("tx");
193	<	line += 2 + stats.network_entries;
193	>	line += 2 + stats.network_io_entries;
194		}
195
196		move(line, 42);
#	Line 208 | Line 210 | void display_data(){
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	<	if (stats.general_stats != NULL) {
220	>	if (stats.host_info != NULL) {
221		move(0,12);
222	<	strncpy(hostname, stats.general_stats->hostname, (sizeof(hostname) - 1));
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, '.');
#	Line 229 | Line 231 | void display_data(){
231		}
232		printw("%s", hostname);
233		move(0,36);
234	<	printw("%s", hr_uptime(stats.general_stats->uptime));
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);
#	Line 257 | Line 259 | void display_data(){
259		printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
260		}
261
262	<	if (stats.process_stats != NULL) {
262	>	if (stats.process_count != NULL) {
263		/* Process */
264		move(2, 54);
265	<	printw("%5d", stats.process_stats->running);
265	>	printw("%5d", stats.process_count->running);
266		move(2,74);
267	<	printw("%5d", stats.process_stats->zombie);
267	>	printw("%5d", stats.process_count->zombie);
268		move(3, 54);
269	<	printw("%5d", stats.process_stats->sleeping);
269	>	printw("%5d", stats.process_count->sleeping);
270		move(3, 74);
271	<	printw("%5d", stats.process_stats->total);
271	>	printw("%5d", stats.process_count->total);
272		move(4, 54);
273	<	printw("%5d", stats.process_stats->stopped);
273	>	printw("%5d", stats.process_count->stopped);
274		}
275		if (stats.user_stats != NULL) {
276		move(4,74);
#	Line 319 | Line 321 | void display_data(){
321		}
322
323		line = 11;
324	<	if (stats.diskio_stats != NULL) {
324	>	if (stats.disk_io_stats != NULL) {
325		/* Disk IO */
326	<	diskio_stat_ptr = stats.diskio_stats;
326	>	disk_io_stat_ptr = stats.disk_io_stats;
327		r=0;
328		w=0;
329	<	for(counter=0;counter<stats.diskio_entries;counter++){
329	>	for(counter=0;counter<stats.disk_io_entries;counter++){
330		move(line, 0);
331	<	printw("%s", diskio_stat_ptr->disk_name);
331	>	printw("%s", disk_io_stat_ptr->disk_name);
332		move(line, 12);
333	<	rt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->read_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->read_bytes;
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 = (diskio_stat_ptr->systime)? (diskio_stat_ptr->write_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->write_bytes;
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	<	diskio_stat_ptr++;
340	>	disk_io_stat_ptr++;
341		line++;
342		}
343		line++;
#	Line 348 | Line 350 | void display_data(){
350		}
351
352		line = 11;
353	<	if (stats.network_stats != NULL) {
353	>	if (stats.network_io_stats != NULL) {
354		/* Network */
355	<	network_stat_ptr = stats.network_stats;
356	<	for(counter=0;counter<stats.network_entries;counter++){
357	<	move(line, 42);
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;
#	Line 366 | Line 368 | void display_data(){
368		line += 2;
369		}
370
371	<	if (stats.disk_stats != NULL) {
371	>	if (stats.fs_stats != NULL) {
372		/* Disk */
373	<	disk_stat_ptr = stats.disk_stats;
374	<	for(counter=0;counter<stats.disk_entries;counter++){
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)));
380	>	printw("%6.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
381		disk_stat_ptr++;
382		line++;
383		}
#	Line 384 | Line 386 | void display_data(){
386		refresh();
387		}
388
389	<	void sig_winch_handler(int sig){
389	>	void sig_winch_handler(){
390		clear();
391		display_headings();
392		display_data();
393	<	signal(SIGWINCH, sig_winch_handler);
393	>	signal(SIGWINCH, sig_winch_handler);
394		}
395
396		int get_stats(){
397	<	stats.cpu_percents = cpu_percent_usage();
398	<	stats.mem_stats = get_memory_stats();
399	<	stats.swap_stats = get_swap_stats();
400	<	stats.load_stats = get_load_stats();
401	<	stats.process_stats = get_process_stats();
402	<	stats.page_stats = get_page_stats_diff();
403	<	stats.network_stats = get_network_stats_diff(&(stats.network_entries));
404	<	stats.diskio_stats = get_diskio_stats_diff(&(stats.diskio_entries));
405	<	stats.disk_stats = get_disk_stats(&(stats.disk_entries));
406	<	stats.general_stats = get_general_stats();
407	<	stats.user_stats = get_user_stats();
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;
410		}
#	Line 414 | Line 416 | void version_num(char *progname){
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");
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);
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;
430	<	extern int optind;
429	<	int c;
429	>	extern char *optarg;
430	>	int c;
431
432	+	time_t last_update = 0;
433	+
434		WINDOW *window;
435
436		extern int errno;
437
438		int delay=2;
439	<	#ifdef ALLBSD
440	<	gid_t gid;
441	<	#endif
442	<	statgrab_init();
440	<	#ifdef ALLBSD
441	<	if((setegid(getgid())) != 0){
442	<	fprintf(stderr, "Failed to lose setgid'ness\n");
439	>
440	>	sg_init();
441	>	if(sg_drop_privileges() != 0){
442	>	fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
443		return 1;
444		}
445	–	#endif
445
446	<	while ((c = getopt(argc, argv, "vhd:")) != -1){
447	<	switch (c){
448	<	case 'd':
449	<	delay = atoi(optarg);
450	<	if (delay == 0){
446	>	while ((c = getopt(argc, argv, "vhd:")) != -1){
447	>	switch (c){
448	>	case 'd':
449	>	delay = atoi(optarg);
450	>	if (delay < 1){
451		fprintf(stderr, "Time must be 1 second or greater\n");
452		exit(1);
453		}
454	<	delay--;
456	<	break;
454	>	break;
455		case 'v':
456		version_num(argv[0]);
457		break;
#	Line 462 | Line 460 | int main(int argc, char **argv){
460		usage(argv[0]);
461		return 1;
462		break;
463	<
464	<	}
467	<	}
463	>	}
464	>	}
465
466		signal(SIGWINCH, sig_winch_handler);
467	<	initscr();
468	<	nonl();
469	<	cbreak();
470	<	noecho();
467	>	initscr();
468	>	nonl();
469	>	cbreak();
470	>	noecho();
471		timeout(delay * 1000);
472	<	window=newwin(0, 0, 0, 0);
472	>	window=newwin(0, 0, 0, 0);
473		clear();
474
475		if(!get_stats()){
#	Line 484 | Line 481 | int main(int argc, char **argv){
481		display_headings();
482
483		for(;;){
484	+	time_t now;
485		int ch = getch();
486	+
487		if (ch == 'q'){
488	<	endwin();
490	<	return 0;
488	>	break;
489		}
490
491	<	get_stats();
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
500		display_data();
496	–
497	–	/* To keep the numbers slightly accurate we do not want them updating more
498	–	* frequently than once a second.
499	–	*/
500	–	sleep(1);
501		}
502
503		endwin();

Diff Legend

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