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 <string.h>
#include "statgrab.h"

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

#ifdef LINUX
#include <stdio.h>
#include <sys/vfs.h>
#include <mntent.h>
#include "tools.h"
#define VALID_FS_TYPES {"ext2", "ext3", "xfs", "reiserfs", "vfat", "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;
        FILE *f;

        disk_stat_t *disk_ptr;

#ifdef SOLARIS
        struct mnttab *mp;
        struct statvfs fs;
#endif
#ifdef LINUX
        struct mntent *mp;
        struct statfs fs;
#endif

        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);
        }
#ifdef LINUX
        if ((f=setmntent("/etc/mtab", "r" ))==NULL){
                return NULL;
        }

        while((mp=getmntent(f))){
                if((statfs(mp->mnt_dir, &fs)) !=0){
                        continue;
                }       

                valid_type=0;
                for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
                        if(strcmp(mp->mnt_type, fs_types[x]) ==0){
                                valid_type=1;
                                break;
                        }
                }
#endif

#ifdef SOLARIS
        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;
                        }
                }
#endif

                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;
#ifdef LINUX
                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
                                return NULL;
                        }
                                
                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){     
                                return NULL;
                        }

                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){
                                return NULL;
                        }
                        disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
                        disk_ptr->avail = (long long)fs.f_bsize * (long long)fs.f_bavail;
                        disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_bsize * (long long)fs.f_bfree);

                        disk_ptr->total_inodes=(long long)fs.f_files;
                        disk_ptr->free_inodes=(long long)fs.f_ffree;
                        /* Linux doesn't have a "available" inodes */
                        disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
#endif

#ifdef SOLARIS
                        /* 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 would 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;
#endif
                        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;

#ifdef SOLARIS
        kstat_ctl_t *kc;
        kstat_t *ksp;
        kstat_io_t kios;
#endif
#ifdef LINUX
        FILE *f;
        char *line_ptr;
        int major, minor;
        char dev_letter;
#endif
        num_diskio=0;

#ifdef SOLARIS
        if ((kc = kstat_open()) == NULL) {
                return NULL;
        }

        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);
#endif

#ifdef LINUX
        f=fopen("/proc/stat", "r");
        if(f==NULL){
                *entries=0;
                fclose(f);
                return NULL;
        }
        if((line_ptr=f_read_line(f, "disk_io:"))==NULL){
                *entries=0;
                fclose(f);
                return NULL;
        }
        while((line_ptr=strchr(line_ptr, ' '))!=NULL){
                line_ptr++;
                if(*line_ptr=='\0'){
                        break;
                }
                if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
                        fclose(f);
                        *entries=0;
                        return NULL;
                }
                diskio_stats_ptr=diskio_stats+num_diskio;


                if((sscanf(line_ptr, "(%d,%d):(%*d, %*d, %lld, %*d, %lld)", \
                        &major, \
                        &minor, \
                        &diskio_stats_ptr->read_bytes, \
                        &diskio_stats_ptr->write_bytes))!=4) {
                                continue;
                }

                /* We read the number of blocks. Blocks are stored in 512 bytes */
                diskio_stats_ptr->read_bytes=diskio_stats_ptr->read_bytes*512;
                diskio_stats_ptr->write_bytes=diskio_stats_ptr->write_bytes*512;

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

                switch(major){
                        case 2:
                                if(minor==0){
                                        diskio_stats_ptr->disk_name=strdup("fd0");
                                }
                                break;

                        case 3: 
                                if(minor==0){
                                        diskio_stats_ptr->disk_name=strdup("hda");
                                }else{
                                        diskio_stats_ptr->disk_name=strdup("hdb");
                                }
                                break;

                        case 22:
                                if(minor==0){
                                        diskio_stats_ptr->disk_name=strdup("hdc");
                                }else{
                                        diskio_stats_ptr->disk_name=strdup("hdd");
                                }
                                break;
                        case 8:
                                dev_letter='a'+(minor/16);
                                diskio_stats_ptr->disk_name=malloc(4);
                                snprintf(diskio_stats_ptr->disk_name, 4, "sd%c", dev_letter);
                                break;
                        default:
                                /* I have no idea what it is then :) */
                                diskio_stats_ptr->disk_name=malloc(16);
                                snprintf(diskio_stats_ptr->disk_name, 16, "%d %d", major, minor);
                                break;
                }

                num_diskio++;
        }

#endif
        *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++;        

        }
        
        *entries=sizeof_diskio_stats_diff;
        return diskio_stats_diff;
}
Revision:	1.12
Committed:	Wed Mar 5 17:11:22 2003 UTC (21 years, 2 months ago) by pajs
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+5 -1 lines
Log Message:	Linux reports stupid results. Fixed to return real vaules. Side note, gkrellm is doing it wrong ;)
#	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 <string.h>
27	#include "statgrab.h"
28
29	#ifdef SOLARIS
30	#include <stdio.h>
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	#ifdef LINUX
38	#include <stdio.h>
39	#include <sys/vfs.h>
40	#include <mntent.h>
41	#include "tools.h"
42	#define VALID_FS_TYPES {"ext2", "ext3", "xfs", "reiserfs", "vfat", "tmpfs"}
43	#endif
44
45	#define START_VAL 1
46
47	char copy_string(char orig_ptr, const char *newtext){
48
49	/* Maybe free if not NULL, and strdup rather than realloc and strcpy? */
50	orig_ptr=realloc(orig_ptr, (1+strlen(newtext)));
51	if(orig_ptr==NULL){
52	return NULL;
53	}
54	strcpy(orig_ptr, newtext);
55
56	return orig_ptr;
57	}
58
59
60	void init_disk_stat(int start, int end, disk_stat_t *disk_stats){
61
62	for(disk_stats+=start; start<=end; start++){
63	disk_stats->device_name=NULL;
64	disk_stats->fs_type=NULL;
65	disk_stats->mnt_point=NULL;
66
67	disk_stats++;
68	}
69	}
70
71	disk_stat_t get_disk_stats(int entries){
72
73	static disk_stat_t *disk_stats;
74	static int watermark=-1;
75
76	char *fs_types[] = VALID_FS_TYPES;
77	int x, valid_type;
78	int num_disks=0;
79	FILE *f;
80
81	disk_stat_t *disk_ptr;
82
83	#ifdef SOLARIS
84	struct mnttab *mp;
85	struct statvfs fs;
86	#endif
87	#ifdef LINUX
88	struct mntent *mp;
89	struct statfs fs;
90	#endif
91
92	if(watermark==-1){
93	disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
94	if(disk_stats==NULL){
95	return NULL;
96	}
97	watermark=START_VAL;
98	init_disk_stat(0, watermark-1, disk_stats);
99	}
100	#ifdef LINUX
101	if ((f=setmntent("/etc/mtab", "r" ))==NULL){
102	return NULL;
103	}
104
105	while((mp=getmntent(f))){
106	if((statfs(mp->mnt_dir, &fs)) !=0){
107	continue;
108	}
109
110	valid_type=0;
111	for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
112	if(strcmp(mp->mnt_type, fs_types[x]) ==0){
113	valid_type=1;
114	break;
115	}
116	}
117	#endif
118
119	#ifdef SOLARIS
120	if ((f=fopen("/etc/mnttab", "r" ))==NULL){
121	return NULL;
122	}
123	while((getmntent(f, &mp)) == 0){
124	if ((statvfs(mp.mnt_mountp, &fs)) !=0){
125	continue;
126	}
127	valid_type=0;
128	for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
129	if(strcmp(mp.mnt_fstype, fs_types[x]) ==0){
130	valid_type=1;
131	break;
132	}
133	}
134	#endif
135
136	if(valid_type){
137	if(num_disks>watermark-1){
138	disk_ptr=disk_stats;
139	if((disk_stats=realloc(disk_stats, (watermark2 sizeof(disk_stat_t))))==NULL){
140	disk_stats=disk_ptr;
141	return NULL;
142	}
143
144	watermark=watermark*2;
145	init_disk_stat(num_disks, watermark-1, disk_stats);
146	}
147
148	disk_ptr=disk_stats+num_disks;
149	#ifdef LINUX
150	if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
151	return NULL;
152	}
153
154	if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){
155	return NULL;
156	}
157
158	if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){
159	return NULL;
160	}
161	disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
162	disk_ptr->avail = (long long)fs.f_bsize * (long long)fs.f_bavail;
163	disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_bsize * (long long)fs.f_bfree);
164
165	disk_ptr->total_inodes=(long long)fs.f_files;
166	disk_ptr->free_inodes=(long long)fs.f_ffree;
167	/* Linux doesn't have a "available" inodes */
168	disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
169	#endif
170
171	#ifdef SOLARIS
172	/* Memory leak in event of realloc failing */
173	/* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
174	* Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
175	* be upwards of a k each
176	*/
177	if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
178	return NULL;
179	}
180
181	if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){
182	return NULL;
183	}
184
185	if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){
186	return NULL;
187	}
188
189	disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
190	disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
191	disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_frsize * (long long)fs.f_bfree);
192
193	disk_ptr->total_inodes=(long long)fs.f_files;
194	disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
195	disk_ptr->free_inodes=(long long)fs.f_favail;
196	#endif
197	num_disks++;
198	}
199	}
200
201	*entries=num_disks;
202
203	/* If this fails, there is very little i can do about it, so i'll ignore it :) */
204	fclose(f);
205
206	return disk_stats;
207
208	}
209	void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){
210
211	for(diskio_stats+=start; start<end; start++){
212	diskio_stats->disk_name=NULL;
213
214	diskio_stats++;
215	}
216	}
217
218	diskio_stat_t diskio_stat_malloc(int needed_entries, int cur_entries, diskio_stat_t *diskio_stats){
219
220	if(diskio_stats==NULL){
221
222	if((diskio_stats=malloc(needed_entries * sizeof(diskio_stat_t)))==NULL){
223	return NULL;
224	}
225	diskio_stat_init(0, needed_entries, diskio_stats);
226	*cur_entries=needed_entries;
227
228	return diskio_stats;
229	}
230
231
232	if(*cur_entries<needed_entries){
233	diskio_stats=realloc(diskio_stats, (sizeof(diskio_stat_t)*needed_entries));
234	if(diskio_stats==NULL){
235	return NULL;
236	}
237	diskio_stat_init(*cur_entries, needed_entries, diskio_stats);
238	*cur_entries=needed_entries;
239	}
240
241	return diskio_stats;
242	}
243
244	static diskio_stat_t *diskio_stats=NULL;
245	static int num_diskio=0;
246
247	diskio_stat_t get_diskio_stats(int entries){
248
249	static int sizeof_diskio_stats=0;
250	diskio_stat_t *diskio_stats_ptr;
251
252	#ifdef SOLARIS
253	kstat_ctl_t *kc;
254	kstat_t *ksp;
255	kstat_io_t kios;
256	#endif
257	#ifdef LINUX
258	FILE *f;
259	char *line_ptr;
260	int major, minor;
261	char dev_letter;
262	#endif
263	num_diskio=0;
264
265	#ifdef SOLARIS
266	if ((kc = kstat_open()) == NULL) {
267	return NULL;
268	}
269
270	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
271	if (!strcmp(ksp->ks_class, "disk")) {
272
273	if(ksp->ks_type != KSTAT_TYPE_IO) continue;
274	/* We dont want metadevices appearins as num_diskio */
275	if(strcmp(ksp->ks_module, "md")==0) continue;
276	if((kstat_read(kc, ksp, &kios))==-1){
277	}
278
279	if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
280	kstat_close(kc);
281	return NULL;
282	}
283	diskio_stats_ptr=diskio_stats+num_diskio;
284
285	diskio_stats_ptr->read_bytes=kios.nread;
286
287	diskio_stats_ptr->write_bytes=kios.nwritten;
288
289	if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
290
291	diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
292	num_diskio++;
293	}
294	}
295
296	kstat_close(kc);
297	#endif
298
299	#ifdef LINUX
300	f=fopen("/proc/stat", "r");
301	if(f==NULL){
302	*entries=0;
303	fclose(f);
304	return NULL;
305	}
306	if((line_ptr=f_read_line(f, "disk_io:"))==NULL){
307	*entries=0;
308	fclose(f);
309	return NULL;
310	}
311	while((line_ptr=strchr(line_ptr, ' '))!=NULL){
312	line_ptr++;
313	if(*line_ptr=='\0'){
314	break;
315	}
316	if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
317	fclose(f);
318	*entries=0;
319	return NULL;
320	}
321	diskio_stats_ptr=diskio_stats+num_diskio;
322
323
324	if((sscanf(line_ptr, "(%d,%d):(%d, %d, %lld, %*d, %lld)", \
325	&major, \
326	&minor, \
327	&diskio_stats_ptr->read_bytes, \
328	&diskio_stats_ptr->write_bytes))!=4) {
329	continue;
330	}
331
332	/* We read the number of blocks. Blocks are stored in 512 bytes */
333	diskio_stats_ptr->read_bytes=diskio_stats_ptr->read_bytes*512;
334	diskio_stats_ptr->write_bytes=diskio_stats_ptr->write_bytes*512;
335
336	if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
337
338	switch(major){
339	case 2:
340	if(minor==0){
341	diskio_stats_ptr->disk_name=strdup("fd0");
342	}
343	break;
344
345	case 3:
346	if(minor==0){
347	diskio_stats_ptr->disk_name=strdup("hda");
348	}else{
349	diskio_stats_ptr->disk_name=strdup("hdb");
350	}
351	break;
352
353	case 22:
354	if(minor==0){
355	diskio_stats_ptr->disk_name=strdup("hdc");
356	}else{
357	diskio_stats_ptr->disk_name=strdup("hdd");
358	}
359	break;
360	case 8:
361	dev_letter='a'+(minor/16);
362	diskio_stats_ptr->disk_name=malloc(4);
363	snprintf(diskio_stats_ptr->disk_name, 4, "sd%c", dev_letter);
364	break;
365	default:
366	/* I have no idea what it is then :) */
367	diskio_stats_ptr->disk_name=malloc(16);
368	snprintf(diskio_stats_ptr->disk_name, 16, "%d %d", major, minor);
369	break;
370	}
371
372	num_diskio++;
373	}
374
375	#endif
376	*entries=num_diskio;
377
378	return diskio_stats;
379	}
380
381	diskio_stat_t get_diskio_stats_diff(int entries){
382	static diskio_stat_t *diskio_stats_diff=NULL;
383	static int sizeof_diskio_stats_diff=0;
384	diskio_stat_t diskio_stats_diff_ptr, diskio_stats_ptr;
385	int disks, x, y;
386
387	if(diskio_stats==NULL){
388	diskio_stats_ptr=get_diskio_stats(&disks);
389	*entries=disks;
390	return diskio_stats_ptr;
391	}
392
393	diskio_stats_diff=diskio_stat_malloc(num_diskio, &sizeof_diskio_stats_diff, diskio_stats_diff);
394	if(diskio_stats_diff==NULL){
395	return NULL;
396	}
397
398	diskio_stats_diff_ptr=diskio_stats_diff;
399	diskio_stats_ptr=diskio_stats;
400
401	for(disks=0;disks<num_diskio;disks++){
402	if(diskio_stats_diff_ptr->disk_name!=NULL){
403	free(diskio_stats_diff_ptr->disk_name);
404	}
405	diskio_stats_diff_ptr->disk_name=strdup(diskio_stats_ptr->disk_name);
406	diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes;
407	diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes;
408	diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime;
409
410	diskio_stats_diff_ptr++;
411	diskio_stats_ptr++;
412	}
413
414	diskio_stats_ptr=get_diskio_stats(&disks);
415	diskio_stats_diff_ptr=diskio_stats_diff;
416
417	for(x=0;x<sizeof_diskio_stats_diff;x++){
418
419	if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
420	diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
421	diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
422	diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
423	}else{
424	diskio_stats_ptr=diskio_stats;
425	for(y=0;y<disks;y++){
426	if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
427	diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
428	diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
429	diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
430
431	break;
432	}
433
434	diskio_stats_ptr++;
435	}
436	}
437
438	diskio_stats_ptr++;
439	diskio_stats_diff_ptr++;
440
441	}
442
443	*entries=sizeof_diskio_stats_diff;
444	return diskio_stats_diff;
445	}