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

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

        }
        
        *entries=sizeof_diskio_stats_diff;
        return diskio_stats_diff;
}
#endif
Revision:	1.9
Committed:	Tue Mar 4 12:55:14 2003 UTC (21 years, 2 months ago) by pajs
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+65 -10 lines
Log Message:	disk_stats for linux. Does not do diskio stats yet.
#	User	Rev	Content
1	pajs	1.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	tdb	1.7	#include "statgrab.h"
28	pajs	1.1
29			#ifdef SOLARIS
30	pajs	1.9	#include <stdio.h>
31	pajs	1.1	#include <sys/mnttab.h>
32			#include <sys/statvfs.h>
33	pajs	1.4	#include <kstat.h>
34	pajs	1.1	#define VALID_FS_TYPES {"ufs", "tmpfs"}
35			#endif
36
37	pajs	1.9	#ifdef LINUX
38			#include <stdio.h>
39			#include <sys/vfs.h>
40			#include <mntent.h>
41			#define VALID_FS_TYPES {"ext2", "ext3", "xfs", "reiserfs", "vfat", "tmpfs"}
42			#endif
43
44	pajs	1.1	#define START_VAL 1
45
46			char copy_string(char orig_ptr, const char *newtext){
47
48			/* Maybe free if not NULL, and strdup rather than realloc and strcpy? */
49			orig_ptr=realloc(orig_ptr, (1+strlen(newtext)));
50			if(orig_ptr==NULL){
51			return NULL;
52			}
53			strcpy(orig_ptr, newtext);
54
55			return orig_ptr;
56			}
57
58
59			void init_disk_stat(int start, int end, disk_stat_t *disk_stats){
60
61			for(disk_stats+=start; start<=end; start++){
62			disk_stats->device_name=NULL;
63			disk_stats->fs_type=NULL;
64			disk_stats->mnt_point=NULL;
65
66			disk_stats++;
67			}
68			}
69
70			disk_stat_t get_disk_stats(int entries){
71
72			static disk_stat_t *disk_stats;
73			static int watermark=-1;
74
75			char *fs_types[] = VALID_FS_TYPES;
76			int x, valid_type;
77			int num_disks=0;
78			FILE *f;
79
80			disk_stat_t *disk_ptr;
81
82	pajs	1.9	#ifdef SOLARIS
83			struct mnttab *mp;
84			struct statvfs fs;
85			#endif
86			#ifdef LINUX
87			struct mntent *mp;
88			struct statfs fs;
89			#endif
90
91	pajs	1.1	if(watermark==-1){
92			disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
93			if(disk_stats==NULL){
94			return NULL;
95			}
96			watermark=START_VAL;
97			init_disk_stat(0, watermark-1, disk_stats);
98			}
99	pajs	1.9	#ifdef LINUX
100			if ((f=setmntent("/etc/mtab", "r" ))==NULL){
101			return NULL;
102			}
103	pajs	1.1
104	pajs	1.9	while((mp=getmntent(f))){
105			if((statfs(mp->mnt_dir, &fs)) !=0){
106			continue;
107			}
108	pajs	1.1
109	pajs	1.9	valid_type=0;
110			for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
111			if(strcmp(mp->mnt_type, fs_types[x]) ==0){
112			valid_type=1;
113			break;
114			}
115			}
116			#endif
117
118			#ifdef SOLARIS
119	pajs	1.1	if ((f=fopen("/etc/mnttab", "r" ))==NULL){
120			return NULL;
121			}
122			while((getmntent(f, &mp)) == 0){
123			if ((statvfs(mp.mnt_mountp, &fs)) !=0){
124			continue;
125			}
126			valid_type=0;
127			for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
128			if(strcmp(mp.mnt_fstype, fs_types[x]) ==0){
129			valid_type=1;
130			break;
131			}
132			}
133	pajs	1.9	#endif
134	pajs	1.1
135			if(valid_type){
136			if(num_disks>watermark-1){
137			disk_ptr=disk_stats;
138			if((disk_stats=realloc(disk_stats, (watermark2 sizeof(disk_stat_t))))==NULL){
139			disk_stats=disk_ptr;
140			return NULL;
141			}
142
143			watermark=watermark*2;
144			init_disk_stat(num_disks, watermark-1, disk_stats);
145			}
146
147			disk_ptr=disk_stats+num_disks;
148	pajs	1.9	#ifdef LINUX
149			if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
150			return NULL;
151			}
152
153			if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){
154			return NULL;
155			}
156
157			if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){
158			return NULL;
159			}
160			disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
161			disk_ptr->avail = (long long)fs.f_bsize * (long long)fs.f_bavail;
162			disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_bsize * (long long)fs.f_bfree);
163
164			disk_ptr->total_inodes=(long long)fs.f_files;
165			disk_ptr->free_inodes=(long long)fs.f_ffree;
166			/* Linux doesn't have a "available" inodes */
167			disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
168			#endif
169
170			#ifdef SOLARIS
171	pajs	1.1	/* Memory leak in event of realloc failing */
172			/* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
173	pajs	1.9	* Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
174			* be upwards of a k each
175			*/
176	pajs	1.1	if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
177			return NULL;
178			}
179
180			if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){
181			return NULL;
182			}
183
184			if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){
185			return NULL;
186			}
187
188			disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
189			disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
190			disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_frsize * (long long)fs.f_bfree);
191
192			disk_ptr->total_inodes=(long long)fs.f_files;
193			disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
194			disk_ptr->free_inodes=(long long)fs.f_favail;
195	pajs	1.9	#endif
196	pajs	1.1	num_disks++;
197			}
198			}
199
200			*entries=num_disks;
201
202			/* If this fails, there is very little i can do about it, so i'll ignore it :) */
203			fclose(f);
204
205			return disk_stats;
206
207			}
208	pajs	1.9	#ifdef SOLARIS
209	pajs	1.4	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	pajs	1.5	static int num_diskio=0;
246	pajs	1.4
247	tdb	1.3	diskio_stat_t get_diskio_stats(int entries){
248	pajs	1.2
249	pajs	1.4	static int sizeof_diskio_stats=0;
250			diskio_stat_t *diskio_stats_ptr;
251
252			kstat_ctl_t *kc;
253			kstat_t *ksp;
254			kstat_io_t kios;
255
256			if ((kc = kstat_open()) == NULL) {
257			return NULL;
258			}
259
260	pajs	1.5	num_diskio=0;
261
262	pajs	1.4	for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
263			if (!strcmp(ksp->ks_class, "disk")) {
264
265			if(ksp->ks_type != KSTAT_TYPE_IO) continue;
266	pajs	1.5	/* We dont want metadevices appearins as num_diskio */
267	pajs	1.4	if(strcmp(ksp->ks_module, "md")==0) continue;
268			if((kstat_read(kc, ksp, &kios))==-1){
269			}
270
271	pajs	1.5	if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
272	pajs	1.4	kstat_close(kc);
273			return NULL;
274			}
275	pajs	1.5	diskio_stats_ptr=diskio_stats+num_diskio;
276	pajs	1.4
277			diskio_stats_ptr->read_bytes=kios.nread;
278
279			diskio_stats_ptr->write_bytes=kios.nwritten;
280
281			if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
282
283			diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
284	pajs	1.5	num_diskio++;
285	pajs	1.4	}
286			}
287
288			kstat_close(kc);
289
290	pajs	1.5	*entries=num_diskio;
291	pajs	1.4
292			return diskio_stats;
293	pajs	1.5	}
294
295	pajs	1.6	diskio_stat_t get_diskio_stats_diff(int entries){
296	pajs	1.5	static diskio_stat_t *diskio_stats_diff=NULL;
297			static int sizeof_diskio_stats_diff=0;
298			diskio_stat_t diskio_stats_diff_ptr, diskio_stats_ptr;
299			int disks, x, y;
300
301			if(diskio_stats==NULL){
302			diskio_stats_ptr=get_diskio_stats(&disks);
303			*entries=disks;
304			return diskio_stats_ptr;
305			}
306
307			diskio_stats_diff=diskio_stat_malloc(num_diskio, &sizeof_diskio_stats_diff, diskio_stats_diff);
308			if(diskio_stats_diff==NULL){
309			return NULL;
310			}
311
312			diskio_stats_diff_ptr=diskio_stats_diff;
313			diskio_stats_ptr=diskio_stats;
314
315			for(disks=0;disks<num_diskio;disks++){
316			if(diskio_stats_diff_ptr->disk_name!=NULL){
317			free(diskio_stats_diff_ptr->disk_name);
318			}
319			diskio_stats_diff_ptr->disk_name=strdup(diskio_stats_ptr->disk_name);
320			diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes;
321			diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes;
322			diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime;
323
324			diskio_stats_diff_ptr++;
325			diskio_stats_ptr++;
326			}
327
328			diskio_stats_ptr=get_diskio_stats(&disks);
329			diskio_stats_diff_ptr=diskio_stats_diff;
330
331			for(x=0;x<sizeof_diskio_stats_diff;x++){
332
333			if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
334			diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
335			diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
336			diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
337			}else{
338			diskio_stats_ptr=diskio_stats;
339			for(y=0;y<disks;y++){
340			if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
341			diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
342			diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
343			diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
344
345			break;
346			}
347
348			diskio_stats_ptr++;
349			}
350			}
351
352			diskio_stats_ptr++;
353			diskio_stats_diff_ptr++;
354
355			}
356	pajs	1.8
357			*entries=sizeof_diskio_stats_diff;
358	pajs	1.5	return diskio_stats_diff;
359	pajs	1.2	}
360	pajs	1.9	#endif