src/libstatgrab/disk_stats.c

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org.uk
 * Copyright (C) 2000-2002 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "statgrab.h"

#ifdef SOLARIS
#include <sys/mnttab.h>
#include <sys/statvfs.h>
#include <kstat.h>
#define VALID_FS_TYPES {"ufs", "tmpfs"}
#endif

#define START_VAL 1

char *copy_string(char *orig_ptr, const char *newtext){

        /* Maybe free if not NULL, and strdup rather than realloc and strcpy? */
        orig_ptr=realloc(orig_ptr, (1+strlen(newtext)));
        if(orig_ptr==NULL){
                return NULL;
        }
        strcpy(orig_ptr, newtext);

        return orig_ptr;
}


void init_disk_stat(int start, int end, disk_stat_t *disk_stats){

        for(disk_stats+=start; start<=end; start++){
                disk_stats->device_name=NULL;
                disk_stats->fs_type=NULL;
                disk_stats->mnt_point=NULL;
                
                disk_stats++;
        }
}

disk_stat_t *get_disk_stats(int *entries){

        static disk_stat_t *disk_stats;
        static int watermark=-1;

        char *fs_types[] = VALID_FS_TYPES;
        int x, valid_type;

        int num_disks=0;
        struct mnttab mp;
        struct statvfs fs;
        FILE *f;

        disk_stat_t *disk_ptr;

        if(watermark==-1){
                disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
                if(disk_stats==NULL){
                        return NULL;
                }
                watermark=START_VAL;
                init_disk_stat(0, watermark-1, disk_stats);
        }


        if ((f=fopen("/etc/mnttab", "r" ))==NULL){
                return NULL;
        }
        while((getmntent(f, &mp)) == 0){
                if ((statvfs(mp.mnt_mountp, &fs)) !=0){
                        continue;
                }

                valid_type=0;
                for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
                        if(strcmp(mp.mnt_fstype, fs_types[x]) ==0){
                                valid_type=1;
                                break;
                        }
                }

                if(valid_type){
                        if(num_disks>watermark-1){
                                disk_ptr=disk_stats;
                                if((disk_stats=realloc(disk_stats, (watermark*2 * sizeof(disk_stat_t))))==NULL){
                                        disk_stats=disk_ptr;
                                        return NULL;
                                }

                                watermark=watermark*2;
                                init_disk_stat(num_disks, watermark-1, disk_stats);
                        }

                        disk_ptr=disk_stats+num_disks;
        
                        /* Memory leak in event of realloc failing */
                        /* Maybe make this char[bigenough] and do strncpy's and put a null in the end? 
                           Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE woul prob be upwards
                           of a k each */
                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
                                return NULL;
                        }

                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){
                                return NULL;
                        }
        
                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){
                                return NULL;
                        }
                        
                        disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
                        disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
                        disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_frsize * (long long)fs.f_bfree);
                
                        disk_ptr->total_inodes=(long long)fs.f_files;
                        disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
                        disk_ptr->free_inodes=(long long)fs.f_favail;

                        num_disks++;
                }
        }

        *entries=num_disks;     

        /* If this fails, there is very little i can do about it, so i'll ignore it :) */
        fclose(f);

        return disk_stats;

}

void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){

        for(diskio_stats+=start; start<end; start++){
                diskio_stats->disk_name=NULL;
                
                diskio_stats++;
        }
}

diskio_stat_t *diskio_stat_malloc(int needed_entries, int *cur_entries, diskio_stat_t *diskio_stats){

        if(diskio_stats==NULL){

                if((diskio_stats=malloc(needed_entries * sizeof(diskio_stat_t)))==NULL){
                        return NULL;
                }
                diskio_stat_init(0, needed_entries, diskio_stats);
                *cur_entries=needed_entries;

                return diskio_stats;
        }


        if(*cur_entries<needed_entries){
                diskio_stats=realloc(diskio_stats, (sizeof(diskio_stat_t)*needed_entries));
                if(diskio_stats==NULL){
                        return NULL;
                }
                diskio_stat_init(*cur_entries, needed_entries, diskio_stats);
                *cur_entries=needed_entries;
        }

        return diskio_stats;
}

static diskio_stat_t *diskio_stats=NULL;        
static int num_diskio=0;        

diskio_stat_t *get_diskio_stats(int *entries){

        static int sizeof_diskio_stats=0;
        diskio_stat_t *diskio_stats_ptr;

        kstat_ctl_t *kc;
        kstat_t *ksp;
        kstat_io_t kios;

        if ((kc = kstat_open()) == NULL) {
                return NULL;
        }

        num_diskio=0;

        for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
                if (!strcmp(ksp->ks_class, "disk")) {

                        if(ksp->ks_type != KSTAT_TYPE_IO) continue;
                        /* We dont want metadevices appearins as num_diskio */
                        if(strcmp(ksp->ks_module, "md")==0) continue;
                        if((kstat_read(kc, ksp, &kios))==-1){   
                        }
                        
                        if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
                                kstat_close(kc);
                                return NULL;
                        }
                        diskio_stats_ptr=diskio_stats+num_diskio;
                        
                        diskio_stats_ptr->read_bytes=kios.nread;
                        
                        diskio_stats_ptr->write_bytes=kios.nwritten;

                        if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);

                        diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
                        num_diskio++;
                }
        }

        kstat_close(kc);

        *entries=num_diskio;

        return diskio_stats;
}

diskio_stat_t *get_diskio_stats_diff(int *entries){
        static diskio_stat_t *diskio_stats_diff=NULL;
        static int sizeof_diskio_stats_diff=0;
        diskio_stat_t *diskio_stats_diff_ptr, *diskio_stats_ptr;
        int disks, x, y;

        if(diskio_stats==NULL){
                diskio_stats_ptr=get_diskio_stats(&disks);
                *entries=disks;
                return diskio_stats_ptr;
        }

        diskio_stats_diff=diskio_stat_malloc(num_diskio, &sizeof_diskio_stats_diff, diskio_stats_diff);
        if(diskio_stats_diff==NULL){
                return NULL;
        }

        diskio_stats_diff_ptr=diskio_stats_diff;
        diskio_stats_ptr=diskio_stats;

        for(disks=0;disks<num_diskio;disks++){
                if(diskio_stats_diff_ptr->disk_name!=NULL){
                        free(diskio_stats_diff_ptr->disk_name);
                }
                diskio_stats_diff_ptr->disk_name=strdup(diskio_stats_ptr->disk_name);
                diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes;
                diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes;
                diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime;

                diskio_stats_diff_ptr++;
                diskio_stats_ptr++;
        }

        diskio_stats_ptr=get_diskio_stats(&disks);
        diskio_stats_diff_ptr=diskio_stats_diff;

        for(x=0;x<sizeof_diskio_stats_diff;x++){

                if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
                        diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
                        diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
                        diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
                }else{
                        diskio_stats_ptr=diskio_stats;
                        for(y=0;y<disks;y++){
                                if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
                                        diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
                                        diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
                                        diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;

                                        break;
                                }
                                
                                diskio_stats_ptr++;
                        }
                }

                diskio_stats_ptr++;
                diskio_stats_diff_ptr++;        

        }

        return diskio_stats_diff;
}
Revision:	1.7
Committed:	Fri Feb 28 22:59:35 2003 UTC (21 years, 2 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+1 -5 lines
Log Message:	Tidy up of configure script, and includes.
#	Content
1	/*
2	* i-scream central monitoring system
3	* http://www.i-scream.org.uk
4	* Copyright (C) 2000-2002 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
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
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
21	#ifdef HAVE_CONFIG_H
22	#include "config.h"
23	#endif
24
25	#include <stdlib.h>
26	#include <stdio.h>
27	#include <string.h>
28	#include "statgrab.h"
29
30	#ifdef SOLARIS
31	#include <sys/mnttab.h>
32	#include <sys/statvfs.h>
33	#include <kstat.h>
34	#define VALID_FS_TYPES {"ufs", "tmpfs"}
35	#endif
36
37	#define START_VAL 1
38
39	char copy_string(char orig_ptr, const char *newtext){
40
41	/* Maybe free if not NULL, and strdup rather than realloc and strcpy? */
42	orig_ptr=realloc(orig_ptr, (1+strlen(newtext)));
43	if(orig_ptr==NULL){
44	return NULL;
45	}
46	strcpy(orig_ptr, newtext);
47
48	return orig_ptr;
49	}
50
51
52	void init_disk_stat(int start, int end, disk_stat_t *disk_stats){
53
54	for(disk_stats+=start; start<=end; start++){
55	disk_stats->device_name=NULL;
56	disk_stats->fs_type=NULL;
57	disk_stats->mnt_point=NULL;
58
59	disk_stats++;
60	}
61	}
62
63	disk_stat_t get_disk_stats(int entries){
64
65	static disk_stat_t *disk_stats;
66	static int watermark=-1;
67
68	char *fs_types[] = VALID_FS_TYPES;
69	int x, valid_type;
70
71	int num_disks=0;
72	struct mnttab mp;
73	struct statvfs fs;
74	FILE *f;
75
76	disk_stat_t *disk_ptr;
77
78	if(watermark==-1){
79	disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
80	if(disk_stats==NULL){
81	return NULL;
82	}
83	watermark=START_VAL;
84	init_disk_stat(0, watermark-1, disk_stats);
85	}
86
87
88	if ((f=fopen("/etc/mnttab", "r" ))==NULL){
89	return NULL;
90	}
91	while((getmntent(f, &mp)) == 0){
92	if ((statvfs(mp.mnt_mountp, &fs)) !=0){
93	continue;
94	}
95
96	valid_type=0;
97	for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
98	if(strcmp(mp.mnt_fstype, fs_types[x]) ==0){
99	valid_type=1;
100	break;
101	}
102	}
103
104	if(valid_type){
105	if(num_disks>watermark-1){
106	disk_ptr=disk_stats;
107	if((disk_stats=realloc(disk_stats, (watermark2 sizeof(disk_stat_t))))==NULL){
108	disk_stats=disk_ptr;
109	return NULL;
110	}
111
112	watermark=watermark*2;
113	init_disk_stat(num_disks, watermark-1, disk_stats);
114	}
115
116	disk_ptr=disk_stats+num_disks;
117
118	/* Memory leak in event of realloc failing */
119	/* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
120	Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE woul prob be upwards
121	of a k each */
122	if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
123	return NULL;
124	}
125
126	if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){
127	return NULL;
128	}
129
130	if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){
131	return NULL;
132	}
133
134	disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
135	disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
136	disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_frsize * (long long)fs.f_bfree);
137
138	disk_ptr->total_inodes=(long long)fs.f_files;
139	disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
140	disk_ptr->free_inodes=(long long)fs.f_favail;
141
142	num_disks++;
143	}
144	}
145
146	*entries=num_disks;
147
148	/* If this fails, there is very little i can do about it, so i'll ignore it :) */
149	fclose(f);
150
151	return disk_stats;
152
153	}
154
155	void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){
156
157	for(diskio_stats+=start; start<end; start++){
158	diskio_stats->disk_name=NULL;
159
160	diskio_stats++;
161	}
162	}
163
164	diskio_stat_t diskio_stat_malloc(int needed_entries, int cur_entries, diskio_stat_t *diskio_stats){
165
166	if(diskio_stats==NULL){
167
168	if((diskio_stats=malloc(needed_entries * sizeof(diskio_stat_t)))==NULL){
169	return NULL;
170	}
171	diskio_stat_init(0, needed_entries, diskio_stats);
172	*cur_entries=needed_entries;
173
174	return diskio_stats;
175	}
176
177
178	if(*cur_entries<needed_entries){
179	diskio_stats=realloc(diskio_stats, (sizeof(diskio_stat_t)*needed_entries));
180	if(diskio_stats==NULL){
181	return NULL;
182	}
183	diskio_stat_init(*cur_entries, needed_entries, diskio_stats);
184	*cur_entries=needed_entries;
185	}
186
187	return diskio_stats;
188	}
189
190	static diskio_stat_t *diskio_stats=NULL;
191	static int num_diskio=0;
192
193	diskio_stat_t get_diskio_stats(int entries){
194
195	static int sizeof_diskio_stats=0;
196	diskio_stat_t *diskio_stats_ptr;
197
198	kstat_ctl_t *kc;
199	kstat_t *ksp;
200	kstat_io_t kios;
201
202	if ((kc = kstat_open()) == NULL) {
203	return NULL;
204	}
205
206	num_diskio=0;
207
208	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
209	if (!strcmp(ksp->ks_class, "disk")) {
210
211	if(ksp->ks_type != KSTAT_TYPE_IO) continue;
212	/* We dont want metadevices appearins as num_diskio */
213	if(strcmp(ksp->ks_module, "md")==0) continue;
214	if((kstat_read(kc, ksp, &kios))==-1){
215	}
216
217	if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
218	kstat_close(kc);
219	return NULL;
220	}
221	diskio_stats_ptr=diskio_stats+num_diskio;
222
223	diskio_stats_ptr->read_bytes=kios.nread;
224
225	diskio_stats_ptr->write_bytes=kios.nwritten;
226
227	if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
228
229	diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
230	num_diskio++;
231	}
232	}
233
234	kstat_close(kc);
235
236	*entries=num_diskio;
237
238	return diskio_stats;
239	}
240
241	diskio_stat_t get_diskio_stats_diff(int entries){
242	static diskio_stat_t *diskio_stats_diff=NULL;
243	static int sizeof_diskio_stats_diff=0;
244	diskio_stat_t diskio_stats_diff_ptr, diskio_stats_ptr;
245	int disks, x, y;
246
247	if(diskio_stats==NULL){
248	diskio_stats_ptr=get_diskio_stats(&disks);
249	*entries=disks;
250	return diskio_stats_ptr;
251	}
252
253	diskio_stats_diff=diskio_stat_malloc(num_diskio, &sizeof_diskio_stats_diff, diskio_stats_diff);
254	if(diskio_stats_diff==NULL){
255	return NULL;
256	}
257
258	diskio_stats_diff_ptr=diskio_stats_diff;
259	diskio_stats_ptr=diskio_stats;
260
261	for(disks=0;disks<num_diskio;disks++){
262	if(diskio_stats_diff_ptr->disk_name!=NULL){
263	free(diskio_stats_diff_ptr->disk_name);
264	}
265	diskio_stats_diff_ptr->disk_name=strdup(diskio_stats_ptr->disk_name);
266	diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes;
267	diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes;
268	diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime;
269
270	diskio_stats_diff_ptr++;
271	diskio_stats_ptr++;
272	}
273
274	diskio_stats_ptr=get_diskio_stats(&disks);
275	diskio_stats_diff_ptr=diskio_stats_diff;
276
277	for(x=0;x<sizeof_diskio_stats_diff;x++){
278
279	if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
280	diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
281	diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
282	diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
283	}else{
284	diskio_stats_ptr=diskio_stats;
285	for(y=0;y<disks;y++){
286	if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
287	diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
288	diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
289	diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
290
291	break;
292	}
293
294	diskio_stats_ptr++;
295	}
296	}
297
298	diskio_stats_ptr++;
299	diskio_stats_diff_ptr++;
300
301	}
302
303	return diskio_stats_diff;
304	}