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.20 by pajs, Mon Jan 5 14:25:03 2004 UTC vs.
Revision 1.33 by tdb, Mon Jan 17 16:34:26 2005 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 67 | Line 69 | stats_t stats;
69		char *size_conv(long long number){
70		char type[] = {'B', 'K', 'M', 'G', 'T'};
71		int x=0;
72	+	int sign=1;
73		static char string[10];
74
75	+	if(number < 0){
76	+	sign=-1;
77	+	number=-number;
78	+	}
79	+
80		for(;x<5;x++){
81		if( (number/1024) < (100)) {
82		break;
#	Line 76 | Line 84 | char *size_conv(long long number){
84		number = (number/1024);
85		}
86
87	<	snprintf(string, 10, "%lld%c", number, type[x]);
87	>	number = number*sign;
88	>
89	>	snprintf(string, 10, "%lld%c", number, type[x]);
90		return string;
91
92		}
#	Line 150 | Line 160 | void display_headings(){
160		printw("Mem Free  :");
161
162		/* Swap */
163	<	move(6, 21);
164	<	printw("Swap Total:");
165	<	move(7, 21);
166	<	printw("Swap Used :");
167	<	move(8, 21);
168	<	printw("Swap Free :");
163	>	move(6, 21);
164	>	printw("Swap Total:");
165	>	move(7, 21);
166	>	printw("Swap Used :");
167	>	move(8, 21);
168	>	printw("Swap Free :");
169
170		/* VM */
171		move(6, 42);
#	Line 180 | Line 190 | void display_headings(){
190		printw("Write");
191
192		line = 10;
193	<	if (stats.network_stats != NULL) {
193	>	if (stats.network_io_stats != NULL) {
194		/* Network IO */
195		move(line, 42);
196		printw("Network Interface");
#	Line 188 | Line 198 | void display_headings(){
198		printw("rx");
199		move(line, 77);
200		printw("tx");
201	<	line += 2 + stats.network_entries;
201	>	line += 2 + stats.network_io_entries;
202		}
203
204		move(line, 42);
#	Line 208 | Line 218 | void display_data(){
218		int counter, line;
219		long long r,w;
220		long long rt, wt;
221	<	diskio_stat_t *diskio_stat_ptr;
222	<	network_stat_t *network_stat_ptr;
223	<	disk_stat_t *disk_stat_ptr;
221	>	sg_disk_io_stats *disk_io_stat_ptr;
222	>	sg_network_io_stats *network_stat_ptr;
223	>	sg_fs_stats *disk_stat_ptr;
224		/* Size before it will start overwriting "uptime" */
225		char hostname[15];
226		char *ptr;
227
228	<	if (stats.general_stats != NULL) {
228	>	if (stats.host_info != NULL) {
229		move(0,12);
230	<	strncpy(hostname, stats.general_stats->hostname, (sizeof(hostname) - 1));
230	>	strncpy(hostname, stats.host_info->hostname, (sizeof(hostname) - 1));
231		/* strncpy does not NULL terminate.. If only strlcpy was on all platforms :) */
232		hostname[14] = '\0';
233		ptr=strchr(hostname, '.');
#	Line 229 | Line 239 | void display_data(){
239		}
240		printw("%s", hostname);
241		move(0,36);
242	<	printw("%s", hr_uptime(stats.general_stats->uptime));
242	>	printw("%s", hr_uptime(stats.host_info->uptime));
243		epoc_time=time(NULL);
244		tm_time = localtime(&epoc_time);
245		strftime(cur_time, 20, "%Y-%m-%d %T", tm_time);
#	Line 257 | Line 267 | void display_data(){
267		printw("%6.2f%%", (stats.cpu_percents->user + stats.cpu_percents->nice));
268		}
269
270	<	if (stats.process_stats != NULL) {
270	>	if (stats.process_count != NULL) {
271		/* Process */
272		move(2, 54);
273	<	printw("%5d", stats.process_stats->running);
273	>	printw("%5d", stats.process_count->running);
274		move(2,74);
275	<	printw("%5d", stats.process_stats->zombie);
275	>	printw("%5d", stats.process_count->zombie);
276		move(3, 54);
277	<	printw("%5d", stats.process_stats->sleeping);
277	>	printw("%5d", stats.process_count->sleeping);
278		move(3, 74);
279	<	printw("%5d", stats.process_stats->total);
279	>	printw("%5d", stats.process_count->total);
280		move(4, 54);
281	<	printw("%5d", stats.process_stats->stopped);
281	>	printw("%5d", stats.process_count->stopped);
282		}
283		if (stats.user_stats != NULL) {
284		move(4,74);
#	Line 319 | Line 329 | void display_data(){
329		}
330
331		line = 11;
332	<	if (stats.diskio_stats != NULL) {
332	>	if (stats.disk_io_stats != NULL) {
333		/* Disk IO */
334	<	diskio_stat_ptr = stats.diskio_stats;
334	>	disk_io_stat_ptr = stats.disk_io_stats;
335		r=0;
336		w=0;
337	<	for(counter=0;counter<stats.diskio_entries;counter++){
337	>	for(counter=0;counter<stats.disk_io_entries;counter++){
338		move(line, 0);
339	<	printw("%s", diskio_stat_ptr->disk_name);
339	>	printw("%s", disk_io_stat_ptr->disk_name);
340		move(line, 12);
341	<	rt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->read_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->read_bytes;
341	>	rt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->read_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->read_bytes;
342		printw("%7s", size_conv(rt));
343		r+=rt;
344		move(line, 26);
345	<	wt = (diskio_stat_ptr->systime)? (diskio_stat_ptr->write_bytes/diskio_stat_ptr->systime): diskio_stat_ptr->write_bytes;
345	>	wt = (disk_io_stat_ptr->systime)? (disk_io_stat_ptr->write_bytes/disk_io_stat_ptr->systime): disk_io_stat_ptr->write_bytes;
346		printw("%7s", size_conv(wt));
347		w+=wt;
348	<	diskio_stat_ptr++;
348	>	disk_io_stat_ptr++;
349		line++;
350		}
351		line++;
#	Line 348 | Line 358 | void display_data(){
358		}
359
360		line = 11;
361	<	if (stats.network_stats != NULL) {
361	>	if (stats.network_io_stats != NULL) {
362		/* Network */
363	<	network_stat_ptr = stats.network_stats;
364	<	for(counter=0;counter<stats.network_entries;counter++){
365	<	move(line, 42);
363	>	network_stat_ptr = stats.network_io_stats;
364	>	for(counter=0;counter<stats.network_io_entries;counter++){
365	>	move(line, 42);
366		printw("%s", network_stat_ptr->interface_name);
367		move(line, 62);
368		rt = (network_stat_ptr->systime)? (network_stat_ptr->rx / network_stat_ptr->systime): network_stat_ptr->rx;
#	Line 366 | Line 376 | void display_data(){
376		line += 2;
377		}
378
379	<	if (stats.disk_stats != NULL) {
379	>	if (stats.fs_stats != NULL) {
380		/* Disk */
381	<	disk_stat_ptr = stats.disk_stats;
382	<	for(counter=0;counter<stats.disk_entries;counter++){
381	>	disk_stat_ptr = stats.fs_stats;
382	>	for(counter=0;counter<stats.fs_entries;counter++){
383		move(line, 42);
384		printw("%s", disk_stat_ptr->mnt_point);
385		move(line, 62);
386		printw("%7s", size_conv(disk_stat_ptr->avail));
387		move(line, 73);
388	<	printw("%5.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
388	>	printw("%6.2f%%", 100.00 * ((float) disk_stat_ptr->used / (float) (disk_stat_ptr->used + disk_stat_ptr->avail)));
389		disk_stat_ptr++;
390		line++;
391		}
#	Line 384 | Line 394 | void display_data(){
394		refresh();
395		}
396
397	<	void sig_winch_handler(int sig){
397	>	void sig_winch_handler(int dummy){
398		clear();
399		display_headings();
400		display_data();
401	<	signal(SIGWINCH, sig_winch_handler);
401	>	signal(SIGWINCH, sig_winch_handler);
402		}
403
404		int get_stats(){
405	<	stats.cpu_percents = cpu_percent_usage();
406	<	stats.mem_stats = get_memory_stats();
407	<	stats.swap_stats = get_swap_stats();
408	<	stats.load_stats = get_load_stats();
409	<	stats.process_stats = get_process_stats();
410	<	stats.page_stats = get_page_stats_diff();
411	<	stats.network_stats = get_network_stats_diff(&(stats.network_entries));
412	<	stats.diskio_stats = get_diskio_stats_diff(&(stats.diskio_entries));
413	<	stats.disk_stats = get_disk_stats(&(stats.disk_entries));
414	<	stats.general_stats = get_general_stats();
415	<	stats.user_stats = get_user_stats();
405	>	stats.cpu_percents = sg_get_cpu_percents();
406	>	stats.mem_stats = sg_get_mem_stats();
407	>	stats.swap_stats = sg_get_swap_stats();
408	>	stats.load_stats = sg_get_load_stats();
409	>	stats.process_count = sg_get_process_count();
410	>	stats.page_stats = sg_get_page_stats_diff();
411	>	stats.network_io_stats = sg_get_network_io_stats_diff(&(stats.network_io_entries));
412	>	stats.disk_io_stats = sg_get_disk_io_stats_diff(&(stats.disk_io_entries));
413	>	stats.fs_stats = sg_get_fs_stats(&(stats.fs_entries));
414	>	stats.host_info = sg_get_host_info();
415	>	stats.user_stats = sg_get_user_stats();
416
417		return 1;
418		}
#	Line 414 | Line 424 | void version_num(char *progname){
424		}
425
426		void usage(char *progname){
427	<	fprintf(stderr, "Usage: %s [-d delay] [-v] [-h]\n\n", progname);
428	<	fprintf(stderr, "  -d    Sets the update time in seconds\n");
427	>	fprintf(stderr, "Usage: %s [-d delay] [-v] [-h]\n\n", progname);
428	>	fprintf(stderr, "  -d    Sets the update time in seconds\n");
429		fprintf(stderr, "  -v    Prints version number\n");
430	<	fprintf(stderr, "  -h    Displays this help information.\n");
431	<	fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
432	<	exit(1);
430	>	fprintf(stderr, "  -h    Displays this help information.\n");
431	>	fprintf(stderr, "\nReport bugs to <%s>.\n", PACKAGE_BUGREPORT);
432	>	exit(1);
433		}
434
435		int main(int argc, char **argv){
436
437	<	extern char *optarg;
438	<	extern int optind;
429	<	int c;
437	>	extern char *optarg;
438	>	int c;
439
440		time_t last_update = 0;
441
#	Line 435 | Line 444 | int main(int argc, char **argv){
444		extern int errno;
445
446		int delay=2;
447	<	#ifdef ALLBSD
448	<	gid_t gid;
449	<	#endif
450	<	statgrab_init();
442	<	#ifdef ALLBSD
443	<	if((setegid(getgid())) != 0){
444	<	fprintf(stderr, "Failed to lose setgid'ness\n");
447	>
448	>	sg_init();
449	>	if(sg_drop_privileges() != 0){
450	>	fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
451		return 1;
452		}
447	–	#endif
448	–	#ifdef SOLARIS
449	–	if((seteuid(getuid())) != 0){
450	–	fprintf(stderr, "Failed to lose setuid'ness\n");
451	–	return 1;
452	–	}
453	–	#endif
453
454	<	while ((c = getopt(argc, argv, "vhd:")) != -1){
455	<	switch (c){
456	<	case 'd':
457	<	delay = atoi(optarg);
458	<	if (delay == 0){
454	>	while ((c = getopt(argc, argv, "vhd:")) != -1){
455	>	switch (c){
456	>	case 'd':
457	>	delay = atoi(optarg);
458	>	if (delay < 1){
459		fprintf(stderr, "Time must be 1 second or greater\n");
460		exit(1);
461		}
462	<	break;
462	>	break;
463		case 'v':
464		version_num(argv[0]);
465		break;
#	Line 469 | Line 468 | int main(int argc, char **argv){
468		usage(argv[0]);
469		return 1;
470		break;
471	<	}
472	<	}
471	>	}
472	>	}
473
474		signal(SIGWINCH, sig_winch_handler);
475	<	initscr();
476	<	nonl();
477	<	cbreak();
478	<	noecho();
475	>	initscr();
476	>	nonl();
477	>	cbreak();
478	>	noecho();
479		timeout(delay * 1000);
480	<	window=newwin(0, 0, 0, 0);
480	>	window=newwin(0, 0, 0, 0);
481		clear();
482
483		if(!get_stats()){

Diff Legend

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