src/libstatgrab/disk_stats.c

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org
 * Copyright (C) 2000-2003 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 <stdio.h>
#include <stdlib.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

#ifdef LINUX
#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>
#include <sys/dkstat.h>
#include <devstat.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;        

#ifdef LINUX
typedef struct {
        int major;
        int minor;
} partition;
#endif

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;
        int has_pp_stats = 1;
        static partition *parts = NULL;
        static int alloc_parts = 0;
        int i, n;
        time_t now;
#endif
#ifdef FREEBSD
        static struct statinfo stats;
        static int stats_init = 0;
        int counter;
        struct device_selection *dev_sel = NULL;
        int n_selected, n_selections;
        long sel_gen;
        struct devstat *dev_ptr;
#endif
        num_diskio=0;

#ifdef FREEBSD
        if (!stats_init) {
                stats.dinfo=malloc(sizeof(struct devinfo));
                bzero(stats.dinfo, sizeof(struct devinfo));
                if(stats.dinfo==NULL) return NULL;
                stats_init = 1;
        }
#ifdef FREEBSD5
        if ((devstat_getdevs(NULL, &stats)) < 0) return NULL;
        /* Not aware of a get all devices, so i said 999. If we ever                                                                           * find a machine with more than 999 disks, then i'll change                                                                           * this number :)                                                                                                                      */
        if (devstat_selectdevs(&dev_sel, &n_selected, &n_selections, &sel_gen, stats.dinfo->generation, stats.dinfo->devices, stats.dinfo->numdevs, NULL, 0, NULL, 0, DS_SELECT_ONLY, 999, 1) < 0) return NULL;
#else
        if ((getdevs(&stats)) < 0) return NULL;
        /* Not aware of a get all devices, so i said 999. If we ever
         * find a machine with more than 999 disks, then i'll change
         * this number :)
         */
        if (selectdevs(&dev_sel, &n_selected, &n_selections, &sel_gen, stats.dinfo->generation, stats.dinfo->devices, stats.dinfo->numdevs, NULL, 0, NULL, 0, DS_SELECT_ONLY, 999, 1) < 0) return NULL;
#endif

        for(counter=0;counter<stats.dinfo->numdevs;counter++){
                dev_ptr=&stats.dinfo->devices[dev_sel[counter].position];

                /* Throw away devices that have done nothing, ever.. Eg "odd" 
                 * devices.. like mem, proc.. and also doesn't report floppy
                 * drives etc unless they are doing stuff :)
                 */
#ifdef FREEBSD5
                if((dev_ptr->bytes[DEVSTAT_READ]==0) && (dev_ptr->bytes[DEVSTAT_WRITE]==0)) continue;
#else
                if((dev_ptr->bytes_read==0) && (dev_ptr->bytes_written==0)) continue;
#endif
                if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
                        return NULL;
                }
                diskio_stats_ptr=diskio_stats+num_diskio;

#ifdef FREEBSD5         
                diskio_stats_ptr->read_bytes=dev_ptr->bytes[DEVSTAT_READ];
                diskio_stats_ptr->write_bytes=dev_ptr->bytes[DEVSTAT_WRITE];
#else
                diskio_stats_ptr->read_bytes=dev_ptr->bytes_read;
                diskio_stats_ptr->write_bytes=dev_ptr->bytes_written;
#endif
                if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
                asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number);
                diskio_stats_ptr->systime=time(NULL);

                num_diskio++;
        }
        free(dev_sel);

#endif
#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
        num_diskio = 0;
        n = 0;

        /* Read /proc/partitions to find what devices exist. Recent 2.4 kernels
           have statistics in here too, so we can use those directly. */

        f = fopen("/proc/partitions", "r");
        if (f == NULL) goto out;
        now = time(NULL);

        while ((line_ptr = f_read_line(f, "")) != NULL) {
                char name[20];
                char *s;
                long long rsect, wsect;

                int nr = sscanf(line_ptr,
                        " %d %d %*d %19s %*d %*d %lld %*d %*d %*d %lld",
                        &major, &minor, name, &rsect, &wsect);
                if (nr < 3) continue;
                if (nr < 5) {
                        has_pp_stats = 0;
                        rsect = 0;
                        wsect = 0;
                }

                /* Skip device names ending in numbers, since they're
                   partitions. */
                s = name;
                while (*s != '\0') s++;
                --s;
                if (*s >= '0' && *s <= '9') continue;

                diskio_stats = diskio_stat_malloc(n + 1, &sizeof_diskio_stats,
                        diskio_stats);
                if (diskio_stats == NULL) goto out;
                if (n >= alloc_parts) {
                        alloc_parts += 16;
                        parts = realloc(parts, alloc_parts * sizeof *parts);
                        if (parts == NULL) {
                                alloc_parts = 0;
                                goto out;
                        }
                }

                if (diskio_stats[n].disk_name != NULL)
                        free(diskio_stats[n].disk_name);
                diskio_stats[n].disk_name = strdup(name);
                diskio_stats[n].read_bytes = rsect * 512;
                diskio_stats[n].write_bytes = wsect * 512;
                diskio_stats[n].systime = now;
                parts[n].major = major;
                parts[n].minor = minor;

                n++;
        }

        if (!has_pp_stats) {
                /* This is an older kernel without stats in /proc/partitions.
                   Read what we can from /proc/stat instead. */

                f = fopen("/proc/stat", "r");
                if (f == NULL) goto out;
                now = time(NULL);
        
                line_ptr = f_read_line(f, "disk_io:");
                if (line_ptr == NULL) goto out;
        
                while((line_ptr=strchr(line_ptr, ' '))!=NULL){
                        long long rsect, wsect;

                        if (*++line_ptr == '\0') break;
        
                        if((sscanf(line_ptr,
                                "(%d,%d):(%*d, %*d, %lld, %*d, %lld)",
                                &major, &minor, &rsect, &wsect)) != 4) {
                                        continue;
                        }

                        /* Find the corresponding device from earlier.
                           Just to add to the fun, "minor" is actually the disk
                           number, not the device minor, so we need to figure
                           out the real minor number based on the major!
                           This list is not exhaustive; if you're running
                           an older kernel you probably don't have fancy
                           I2O hardware anyway... */
                        switch (major) {
                        case 3:
                        case 21:
                        case 22:
                        case 33:
                        case 34:
                        case 36:
                        case 56:
                        case 57:
                        case 88:
                        case 89:
                        case 90:
                        case 91:
                                minor *= 64;
                                break;
                        case 9:
                        case 43:
                                break;
                        default:
                                minor *= 16;
                                break;
                        }
                        for (i = 0; i < n; i++) {
                                if (major == parts[i].major
                                        && minor == parts[i].minor)
                                        break;
                        }
                        if (i == n) continue;

                        /* We read the number of blocks. Blocks are stored in
                           512 bytes */
                        diskio_stats[i].read_bytes = rsect * 512;
                        diskio_stats[i].write_bytes = wsect * 512;
                        diskio_stats[i].systime = now;
                }
        }

        num_diskio = n;
out:
        if (f != NULL) 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.28
Committed:	Thu Oct 9 15:22:59 2003 UTC (20 years, 7 months ago) by pajs
Content type:	text/plain
Branch:	MAIN
CVS Tags:	LIBSTATGRAB_0_6_1, LIBSTATGRAB_0_6
Changes since 1.27:	+5 -3 lines
Log Message:	Fixed a forgotten line from the patch
#	User	Rev	Content
1	pajs	1.1	/*
2			* i-scream central monitoring system
3	tdb	1.18	* http://www.i-scream.org
4			* Copyright (C) 2000-2003 i-scream
5	pajs	1.1	*
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	pajs	1.17	#include <stdio.h>
26	pajs	1.1	#include <stdlib.h>
27			#include <string.h>
28	tdb	1.7	#include "statgrab.h"
29	pajs	1.1
30			#ifdef SOLARIS
31			#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 <sys/vfs.h>
39			#include <mntent.h>
40	pajs	1.10	#include "tools.h"
41	pajs	1.9	#define VALID_FS_TYPES {"ext2", "ext3", "xfs", "reiserfs", "vfat", "tmpfs"}
42			#endif
43
44	pajs	1.16	#ifdef FREEBSD
45			#include <sys/param.h>
46			#include <sys/ucred.h>
47			#include <sys/mount.h>
48	pajs	1.17	#include <sys/dkstat.h>
49			#include <devstat.h>
50	pajs	1.16	#define VALID_FS_TYPES {"ufs", "mfs"}
51			#endif
52	pajs	1.1	#define START_VAL 1
53
54			char copy_string(char orig_ptr, const char *newtext){
55
56			/* Maybe free if not NULL, and strdup rather than realloc and strcpy? */
57			orig_ptr=realloc(orig_ptr, (1+strlen(newtext)));
58			if(orig_ptr==NULL){
59			return NULL;
60			}
61			strcpy(orig_ptr, newtext);
62
63			return orig_ptr;
64			}
65
66
67			void init_disk_stat(int start, int end, disk_stat_t *disk_stats){
68
69			for(disk_stats+=start; start<=end; start++){
70			disk_stats->device_name=NULL;
71			disk_stats->fs_type=NULL;
72			disk_stats->mnt_point=NULL;
73
74			disk_stats++;
75			}
76			}
77
78			disk_stat_t get_disk_stats(int entries){
79
80			static disk_stat_t *disk_stats;
81			static int watermark=-1;
82
83			char *fs_types[] = VALID_FS_TYPES;
84			int x, valid_type;
85			int num_disks=0;
86	pajs	1.16	#if defined(LINUX) \|\| defined (SOLARIS)
87	pajs	1.1	FILE *f;
88	pajs	1.16	#endif
89	pajs	1.1
90			disk_stat_t *disk_ptr;
91
92	pajs	1.9	#ifdef SOLARIS
93	tdb	1.13	struct mnttab mp;
94	pajs	1.9	struct statvfs fs;
95			#endif
96			#ifdef LINUX
97			struct mntent *mp;
98			struct statfs fs;
99			#endif
100	pajs	1.16	#ifdef FREEBSD
101			int nummnt;
102			struct statfs *mp;
103			#endif
104	pajs	1.9
105	pajs	1.1	if(watermark==-1){
106			disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
107			if(disk_stats==NULL){
108			return NULL;
109			}
110			watermark=START_VAL;
111			init_disk_stat(0, watermark-1, disk_stats);
112			}
113	pajs	1.16	#ifdef FREEBSD
114			nummnt=getmntinfo(&mp , MNT_LOCAL);
115			if (nummnt<=0){
116			return NULL;
117			}
118			for(;nummnt--; mp++){
119			valid_type=0;
120			for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
121			if(strcmp(mp->f_fstypename, fs_types[x]) ==0){
122			valid_type=1;
123			break;
124			}
125			}
126			#endif
127
128	pajs	1.9	#ifdef LINUX
129			if ((f=setmntent("/etc/mtab", "r" ))==NULL){
130			return NULL;
131			}
132	pajs	1.1
133	pajs	1.9	while((mp=getmntent(f))){
134			if((statfs(mp->mnt_dir, &fs)) !=0){
135			continue;
136			}
137	pajs	1.1
138	pajs	1.9	valid_type=0;
139			for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
140			if(strcmp(mp->mnt_type, fs_types[x]) ==0){
141			valid_type=1;
142			break;
143			}
144			}
145			#endif
146
147			#ifdef SOLARIS
148	pajs	1.1	if ((f=fopen("/etc/mnttab", "r" ))==NULL){
149			return NULL;
150			}
151			while((getmntent(f, &mp)) == 0){
152			if ((statvfs(mp.mnt_mountp, &fs)) !=0){
153			continue;
154			}
155			valid_type=0;
156			for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
157			if(strcmp(mp.mnt_fstype, fs_types[x]) ==0){
158			valid_type=1;
159			break;
160			}
161			}
162	pajs	1.9	#endif
163	pajs	1.1
164			if(valid_type){
165			if(num_disks>watermark-1){
166			disk_ptr=disk_stats;
167			if((disk_stats=realloc(disk_stats, (watermark2 sizeof(disk_stat_t))))==NULL){
168			disk_stats=disk_ptr;
169			return NULL;
170			}
171
172			watermark=watermark*2;
173			init_disk_stat(num_disks, watermark-1, disk_stats);
174			}
175
176			disk_ptr=disk_stats+num_disks;
177	pajs	1.16	#ifdef FREEBSD
178			if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->f_mntfromname))==NULL){
179			return NULL;
180			}
181
182			if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->f_fstypename))==NULL){
183			return NULL;
184			}
185
186			if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->f_mntonname))==NULL){
187			return NULL;
188			}
189
190			disk_ptr->size = (long long)mp->f_bsize * (long long) mp->f_blocks;
191			disk_ptr->avail = (long long)mp->f_bsize * (long long) mp->f_bavail;
192			disk_ptr->used = (disk_ptr->size) - ((long long)mp->f_bsize * (long long)mp->f_bfree);
193
194			disk_ptr->total_inodes=(long long)mp->f_files;
195			disk_ptr->free_inodes=(long long)mp->f_ffree;
196			/* Freebsd doesn't have a "available" inodes */
197			disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
198			#endif
199	pajs	1.9	#ifdef LINUX
200			if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
201			return NULL;
202			}
203
204			if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){
205			return NULL;
206			}
207
208			if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){
209			return NULL;
210			}
211			disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
212			disk_ptr->avail = (long long)fs.f_bsize * (long long)fs.f_bavail;
213			disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_bsize * (long long)fs.f_bfree);
214
215			disk_ptr->total_inodes=(long long)fs.f_files;
216			disk_ptr->free_inodes=(long long)fs.f_ffree;
217			/* Linux doesn't have a "available" inodes */
218			disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
219			#endif
220
221			#ifdef SOLARIS
222	pajs	1.1	/* Memory leak in event of realloc failing */
223			/* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
224	pajs	1.9	* Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
225			* be upwards of a k each
226			*/
227	pajs	1.1	if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
228			return NULL;
229			}
230
231			if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){
232			return NULL;
233			}
234
235			if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){
236			return NULL;
237			}
238
239			disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
240			disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
241			disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_frsize * (long long)fs.f_bfree);
242
243			disk_ptr->total_inodes=(long long)fs.f_files;
244			disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
245			disk_ptr->free_inodes=(long long)fs.f_favail;
246	pajs	1.9	#endif
247	pajs	1.1	num_disks++;
248			}
249			}
250
251			*entries=num_disks;
252
253			/* If this fails, there is very little i can do about it, so i'll ignore it :) */
254	pajs	1.16	#if defined(LINUX) \|\| defined(SOLARIS)
255	pajs	1.1	fclose(f);
256	pajs	1.16	#endif
257	pajs	1.1
258			return disk_stats;
259
260			}
261	pajs	1.4	void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){
262
263			for(diskio_stats+=start; start<end; start++){
264			diskio_stats->disk_name=NULL;
265
266			diskio_stats++;
267			}
268			}
269
270			diskio_stat_t diskio_stat_malloc(int needed_entries, int cur_entries, diskio_stat_t *diskio_stats){
271
272			if(diskio_stats==NULL){
273
274			if((diskio_stats=malloc(needed_entries * sizeof(diskio_stat_t)))==NULL){
275			return NULL;
276			}
277			diskio_stat_init(0, needed_entries, diskio_stats);
278			*cur_entries=needed_entries;
279
280			return diskio_stats;
281			}
282
283
284			if(*cur_entries<needed_entries){
285			diskio_stats=realloc(diskio_stats, (sizeof(diskio_stat_t)*needed_entries));
286			if(diskio_stats==NULL){
287			return NULL;
288			}
289			diskio_stat_init(*cur_entries, needed_entries, diskio_stats);
290			*cur_entries=needed_entries;
291			}
292
293			return diskio_stats;
294			}
295
296			static diskio_stat_t *diskio_stats=NULL;
297	pajs	1.5	static int num_diskio=0;
298	pajs	1.4
299	ats	1.20	#ifdef LINUX
300			typedef struct {
301			int major;
302			int minor;
303			} partition;
304			#endif
305
306	tdb	1.3	diskio_stat_t get_diskio_stats(int entries){
307	pajs	1.2
308	pajs	1.4	static int sizeof_diskio_stats=0;
309			diskio_stat_t *diskio_stats_ptr;
310
311	pajs	1.10	#ifdef SOLARIS
312	pajs	1.4	kstat_ctl_t *kc;
313			kstat_t *ksp;
314			kstat_io_t kios;
315	pajs	1.10	#endif
316			#ifdef LINUX
317			FILE *f;
318			char *line_ptr;
319			int major, minor;
320			char dev_letter;
321	ats	1.20	int has_pp_stats = 1;
322			static partition *parts = NULL;
323			static int alloc_parts = 0;
324			int i, n;
325			time_t now;
326	pajs	1.10	#endif
327	pajs	1.17	#ifdef FREEBSD
328	ats	1.21	static struct statinfo stats;
329			static int stats_init = 0;
330	pajs	1.17	int counter;
331			struct device_selection *dev_sel = NULL;
332			int n_selected, n_selections;
333			long sel_gen;
334			struct devstat *dev_ptr;
335			#endif
336	pajs	1.10	num_diskio=0;
337	pajs	1.4
338	pajs	1.17	#ifdef FREEBSD
339	ats	1.21	if (!stats_init) {
340			stats.dinfo=malloc(sizeof(struct devinfo));
341	tdb	1.25	bzero(stats.dinfo, sizeof(struct devinfo));
342	ats	1.21	if(stats.dinfo==NULL) return NULL;
343			stats_init = 1;
344			}
345	pajs	1.28	#ifdef FREEBSD5
346			if ((devstat_getdevs(NULL, &stats)) < 0) return NULL;
347			/* Not aware of a get all devices, so i said 999. If we ever * find a machine with more than 999 disks, then i'll change * this number :) */
348			if (devstat_selectdevs(&dev_sel, &n_selected, &n_selections, &sel_gen, stats.dinfo->generation, stats.dinfo->devices, stats.dinfo->numdevs, NULL, 0, NULL, 0, DS_SELECT_ONLY, 999, 1) < 0) return NULL;
349			#else
350	pajs	1.17	if ((getdevs(&stats)) < 0) return NULL;
351			/* Not aware of a get all devices, so i said 999. If we ever
352			* find a machine with more than 999 disks, then i'll change
353			* this number :)
354			*/
355			if (selectdevs(&dev_sel, &n_selected, &n_selections, &sel_gen, stats.dinfo->generation, stats.dinfo->devices, stats.dinfo->numdevs, NULL, 0, NULL, 0, DS_SELECT_ONLY, 999, 1) < 0) return NULL;
356	pajs	1.27	#endif
357	pajs	1.17
358			for(counter=0;counter<stats.dinfo->numdevs;counter++){
359			dev_ptr=&stats.dinfo->devices[dev_sel[counter].position];
360
361			/* Throw away devices that have done nothing, ever.. Eg "odd"
362			* devices.. like mem, proc.. and also doesn't report floppy
363			* drives etc unless they are doing stuff :)
364			*/
365	pajs	1.27	#ifdef FREEBSD5
366			if((dev_ptr->bytes[DEVSTAT_READ]==0) && (dev_ptr->bytes[DEVSTAT_WRITE]==0)) continue;
367			#else
368	pajs	1.17	if((dev_ptr->bytes_read==0) && (dev_ptr->bytes_written==0)) continue;
369	pajs	1.27	#endif
370	pajs	1.17	if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
371			return NULL;
372			}
373			diskio_stats_ptr=diskio_stats+num_diskio;
374	pajs	1.27
375			#ifdef FREEBSD5
376			diskio_stats_ptr->read_bytes=dev_ptr->bytes[DEVSTAT_READ];
377			diskio_stats_ptr->write_bytes=dev_ptr->bytes[DEVSTAT_WRITE];
378			#else
379	pajs	1.17	diskio_stats_ptr->read_bytes=dev_ptr->bytes_read;
380			diskio_stats_ptr->write_bytes=dev_ptr->bytes_written;
381	pajs	1.27	#endif
382	pajs	1.17	if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
383			asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number);
384			diskio_stats_ptr->systime=time(NULL);
385
386			num_diskio++;
387			}
388			free(dev_sel);
389
390			#endif
391	pajs	1.10	#ifdef SOLARIS
392	pajs	1.4	if ((kc = kstat_open()) == NULL) {
393			return NULL;
394			}
395
396			for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
397			if (!strcmp(ksp->ks_class, "disk")) {
398
399			if(ksp->ks_type != KSTAT_TYPE_IO) continue;
400	pajs	1.5	/* We dont want metadevices appearins as num_diskio */
401	pajs	1.4	if(strcmp(ksp->ks_module, "md")==0) continue;
402			if((kstat_read(kc, ksp, &kios))==-1){
403			}
404
405	pajs	1.5	if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
406	pajs	1.4	kstat_close(kc);
407			return NULL;
408			}
409	pajs	1.5	diskio_stats_ptr=diskio_stats+num_diskio;
410	pajs	1.4
411			diskio_stats_ptr->read_bytes=kios.nread;
412
413			diskio_stats_ptr->write_bytes=kios.nwritten;
414
415			if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
416
417	tdb	1.26	diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
418	pajs	1.14	diskio_stats_ptr->systime=time(NULL);
419	pajs	1.5	num_diskio++;
420	pajs	1.4	}
421			}
422
423			kstat_close(kc);
424	pajs	1.10	#endif
425	pajs	1.4
426	pajs	1.10	#ifdef LINUX
427	ats	1.20	num_diskio = 0;
428			n = 0;
429	pajs	1.10
430	ats	1.20	/* Read /proc/partitions to find what devices exist. Recent 2.4 kernels
431			have statistics in here too, so we can use those directly. */
432	pajs	1.10
433	ats	1.20	f = fopen("/proc/partitions", "r");
434			if (f == NULL) goto out;
435			now = time(NULL);
436
437			while ((line_ptr = f_read_line(f, "")) != NULL) {
438			char name[20];
439			char *s;
440			long long rsect, wsect;
441
442			int nr = sscanf(line_ptr,
443			" %d %d %d %19s %d %d %lld %d %d %d %lld",
444			&major, &minor, name, &rsect, &wsect);
445			if (nr < 3) continue;
446			if (nr < 5) {
447			has_pp_stats = 0;
448			rsect = 0;
449			wsect = 0;
450			}
451
452			/* Skip device names ending in numbers, since they're
453			partitions. */
454			s = name;
455			while (*s != '\0') s++;
456			--s;
457			if (s >= '0' && s <= '9') continue;
458
459			diskio_stats = diskio_stat_malloc(n + 1, &sizeof_diskio_stats,
460			diskio_stats);
461			if (diskio_stats == NULL) goto out;
462			if (n >= alloc_parts) {
463			alloc_parts += 16;
464			parts = realloc(parts, alloc_parts * sizeof *parts);
465			if (parts == NULL) {
466			alloc_parts = 0;
467			goto out;
468			}
469	pajs	1.11	}
470	pajs	1.12
471	ats	1.20	if (diskio_stats[n].disk_name != NULL)
472			free(diskio_stats[n].disk_name);
473			diskio_stats[n].disk_name = strdup(name);
474			diskio_stats[n].read_bytes = rsect * 512;
475			diskio_stats[n].write_bytes = wsect * 512;
476			diskio_stats[n].systime = now;
477			parts[n].major = major;
478			parts[n].minor = minor;
479	pajs	1.10
480	ats	1.20	n++;
481			}
482	pajs	1.10
483	ats	1.20	if (!has_pp_stats) {
484			/* This is an older kernel without stats in /proc/partitions.
485			Read what we can from /proc/stat instead. */
486
487			f = fopen("/proc/stat", "r");
488			if (f == NULL) goto out;
489			now = time(NULL);
490
491			line_ptr = f_read_line(f, "disk_io:");
492			if (line_ptr == NULL) goto out;
493
494			while((line_ptr=strchr(line_ptr, ' '))!=NULL){
495			long long rsect, wsect;
496
497			if (*++line_ptr == '\0') break;
498
499			if((sscanf(line_ptr,
500			"(%d,%d):(%d, %d, %lld, %*d, %lld)",
501			&major, &minor, &rsect, &wsect)) != 4) {
502			continue;
503			}
504	pajs	1.10
505	ats	1.20	/* Find the corresponding device from earlier.
506			Just to add to the fun, "minor" is actually the disk
507			number, not the device minor, so we need to figure
508			out the real minor number based on the major!
509			This list is not exhaustive; if you're running
510			an older kernel you probably don't have fancy
511			I2O hardware anyway... */
512			switch (major) {
513			case 3:
514			case 21:
515	pajs	1.10	case 22:
516	ats	1.20	case 33:
517			case 34:
518			case 36:
519			case 56:
520			case 57:
521			case 88:
522			case 89:
523			case 90:
524			case 91:
525			minor *= 64;
526	pajs	1.11	break;
527	ats	1.20	case 9:
528			case 43:
529	pajs	1.11	break;
530	pajs	1.10	default:
531	ats	1.20	minor *= 16;
532	pajs	1.11	break;
533	ats	1.20	}
534			for (i = 0; i < n; i++) {
535			if (major == parts[i].major
536			&& minor == parts[i].minor)
537			break;
538			}
539			if (i == n) continue;
540
541			/* We read the number of blocks. Blocks are stored in
542			512 bytes */
543			diskio_stats[i].read_bytes = rsect * 512;
544			diskio_stats[i].write_bytes = wsect * 512;
545			diskio_stats[i].systime = now;
546	pajs	1.10	}
547			}
548	pajs	1.16
549	ats	1.20	num_diskio = n;
550			out:
551			if (f != NULL) fclose(f);
552	pajs	1.10
553			#endif
554	pajs	1.5	*entries=num_diskio;
555	pajs	1.4
556			return diskio_stats;
557	pajs	1.5	}
558
559	pajs	1.6	diskio_stat_t get_diskio_stats_diff(int entries){
560	pajs	1.5	static diskio_stat_t *diskio_stats_diff=NULL;
561			static int sizeof_diskio_stats_diff=0;
562			diskio_stat_t diskio_stats_diff_ptr, diskio_stats_ptr;
563			int disks, x, y;
564
565			if(diskio_stats==NULL){
566			diskio_stats_ptr=get_diskio_stats(&disks);
567			*entries=disks;
568			return diskio_stats_ptr;
569			}
570
571			diskio_stats_diff=diskio_stat_malloc(num_diskio, &sizeof_diskio_stats_diff, diskio_stats_diff);
572			if(diskio_stats_diff==NULL){
573			return NULL;
574			}
575
576			diskio_stats_diff_ptr=diskio_stats_diff;
577			diskio_stats_ptr=diskio_stats;
578
579			for(disks=0;disks<num_diskio;disks++){
580			if(diskio_stats_diff_ptr->disk_name!=NULL){
581			free(diskio_stats_diff_ptr->disk_name);
582			}
583			diskio_stats_diff_ptr->disk_name=strdup(diskio_stats_ptr->disk_name);
584			diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes;
585			diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes;
586			diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime;
587
588			diskio_stats_diff_ptr++;
589			diskio_stats_ptr++;
590			}
591
592			diskio_stats_ptr=get_diskio_stats(&disks);
593			diskio_stats_diff_ptr=diskio_stats_diff;
594
595			for(x=0;x<sizeof_diskio_stats_diff;x++){
596
597			if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
598			diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
599			diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
600			diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
601			}else{
602			diskio_stats_ptr=diskio_stats;
603			for(y=0;y<disks;y++){
604			if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
605			diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
606			diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
607			diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
608
609			break;
610			}
611
612			diskio_stats_ptr++;
613			}
614			}
615
616			diskio_stats_ptr++;
617			diskio_stats_diff_ptr++;
618
619			}
620	pajs	1.8
621			*entries=sizeof_diskio_stats_diff;
622	pajs	1.5	return diskio_stats_diff;
623	pajs	1.2	}