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

#ifdef FREEBSD
#include <sys/param.h>
#include <sys/ucred.h>
#include <sys/mount.h>
#define VALID_FS_TYPES {"ufs", "mfs"}
#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;
#if defined(LINUX) || defined (SOLARIS)
        FILE *f;
#endif

        disk_stat_t *disk_ptr;

#ifdef SOLARIS
        struct mnttab mp;
        struct statvfs fs;
#endif
#ifdef LINUX
        struct mntent *mp;
        struct statfs fs;
#endif
#ifdef FREEBSD
        int nummnt;
        struct statfs *mp;
#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 FREEBSD
        nummnt=getmntinfo(&mp , MNT_LOCAL);
        if (nummnt<=0){
                return NULL;
        }
        for(;nummnt--; mp++){
                valid_type=0;
                for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
                        if(strcmp(mp->f_fstypename, fs_types[x]) ==0){
                                valid_type=1;
                                break;
                        }
                }
#endif

#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 FREEBSD
                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->f_mntfromname))==NULL){
                                return NULL;
                        }

                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->f_fstypename))==NULL){
                                return NULL;
                        }

                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->f_mntonname))==NULL){
                                return NULL;
                        }

                        disk_ptr->size = (long long)mp->f_bsize * (long long) mp->f_blocks;
                        disk_ptr->avail = (long long)mp->f_bsize * (long long) mp->f_bavail;
                        disk_ptr->used = (disk_ptr->size) - ((long long)mp->f_bsize * (long long)mp->f_bfree);

                        disk_ptr->total_inodes=(long long)mp->f_files;
                        disk_ptr->free_inodes=(long long)mp->f_ffree;
                        /* Freebsd doesn't have a "available" inodes */
                        disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
#endif
#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 :) */
#if defined(LINUX) || defined(SOLARIS)
        fclose(f);
#endif

        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);
                        diskio_stats_ptr->systime=time(NULL);
                        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;
                }

                diskio_stats_ptr->systime=time(NULL);
                num_diskio++;
        }

        fclose(f);

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