--- projects/libstatgrab/src/libstatgrab/disk_stats.c 2004/01/21 23:46:54 1.50 +++ projects/libstatgrab/src/libstatgrab/disk_stats.c 2004/06/20 20:32:24 1.70 @@ -1,5 +1,5 @@ /* - * i-scream central monitoring system + * i-scream libstatgrab * http://www.i-scream.org * Copyright (C) 2000-2004 i-scream * @@ -18,7 +18,7 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307 USA * - * $Id: disk_stats.c,v 1.50 2004/01/21 23:46:54 ats Exp $ + * $Id: disk_stats.c,v 1.70 2004/06/20 20:32:24 tdb Exp $ */ #ifdef HAVE_CONFIG_H @@ -30,6 +30,8 @@ #include #include #include "statgrab.h" +#include "vector.h" +#include "tools.h" #ifdef SOLARIS #include @@ -41,15 +43,14 @@ #if defined(LINUX) || defined(CYGWIN) #include #include -#include "tools.h" #endif #ifdef LINUX #define VALID_FS_TYPES {"adfs", "affs", "befs", "bfs", "efs", "ext2", \ - "ext3", "vxfs", "hfs", "hfsplus", "hpfs", "jffs", \ - "jffs2", "minix", "msdos", "ntfs", "qnx4", "ramfs", \ - "rootfs", "reiserfs", "sysv", "v7", "udf", "ufs", \ - "umsdos", "vfat", "xfs", "jfs"} + "ext3", "vxfs", "hfs", "hfsplus", "hpfs", "jffs", \ + "jffs2", "minix", "msdos", "ntfs", "qnx4", "ramfs", \ + "rootfs", "reiserfs", "sysv", "v7", "udf", "ufs", \ + "umsdos", "vfat", "xfs", "jfs"} #endif #ifdef CYGWIN @@ -61,47 +62,33 @@ #include #include #endif -#ifdef FREEBSD +#if defined(FREEBSD) || defined(DFBSD) #include #include #define VALID_FS_TYPES {"hpfs", "msdosfs", "ntfs", "udf", "ext2fs", \ - "ufs", "mfs"} + "ufs", "mfs"} #endif -#ifdef NETBSD +#if defined(NETBSD) || defined(OPENBSD) #include #include #include #define VALID_FS_TYPES {"ffs", "mfs", "msdos", "lfs", "adosfs", "ext2fs", \ - "ntfs"} + "ntfs"} #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; +static void disk_stat_init(sg_fs_stats *d) { + d->device_name = NULL; + d->fs_type = NULL; + d->mnt_point = NULL; } - -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++; - } +static void disk_stat_destroy(sg_fs_stats *d) { + free(d->device_name); + free(d->fs_type); + free(d->mnt_point); } -int is_valid_fs_type(const char *type) { +static int is_valid_fs_type(const char *type) { const char *types[] = VALID_FS_TYPES; int i; @@ -113,18 +100,17 @@ int is_valid_fs_type(const char *type) { return 0; } -disk_stat_t *get_disk_stats(int *entries){ +sg_fs_stats *sg_get_fs_stats(int *entries){ + VECTOR_DECLARE_STATIC(disk_stats, sg_fs_stats, 10, + disk_stat_init, disk_stat_destroy); - static disk_stat_t *disk_stats; - static int watermark=-1; - int valid_type; int num_disks=0; #if defined(LINUX) || defined (SOLARIS) || defined(CYGWIN) FILE *f; #endif - disk_stat_t *disk_ptr; + sg_fs_stats *disk_ptr; #ifdef SOLARIS struct mnttab mp; @@ -136,20 +122,17 @@ disk_stat_t *get_disk_stats(int *entries){ #endif #ifdef ALLBSD int nummnt; +#ifdef HAVE_STATVFS + struct statvfs *mp; +#else struct statfs *mp; #endif +#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 ALLBSD nummnt=getmntinfo(&mp , MNT_LOCAL); if (nummnt<=0){ + sg_set_error(SG_ERROR_GETMNTINFO, NULL); return NULL; } for(;nummnt--; mp++){ @@ -158,6 +141,7 @@ disk_stat_t *get_disk_stats(int *entries){ #if defined(LINUX) || defined(CYGWIN) if ((f=setmntent("/etc/mtab", "r" ))==NULL){ + sg_set_error(SG_ERROR_SETMNTENT, NULL); return NULL; } @@ -171,6 +155,7 @@ disk_stat_t *get_disk_stats(int *entries){ #ifdef SOLARIS if ((f=fopen("/etc/mnttab", "r" ))==NULL){ + sg_set_error(SG_ERROR_OPEN, "/etc/mnttab"); return NULL; } while((getmntent(f, &mp)) == 0){ @@ -181,28 +166,19 @@ disk_stat_t *get_disk_stats(int *entries){ #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); + if (VECTOR_RESIZE(disk_stats, num_disks + 1) < 0) { + return NULL; } - disk_ptr=disk_stats+num_disks; + #ifdef ALLBSD - if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->f_mntfromname))==NULL){ + if (sg_update_string(&disk_ptr->device_name, mp->f_mntfromname) < 0) { return NULL; } - - if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->f_fstypename))==NULL){ + if (sg_update_string(&disk_ptr->fs_type, mp->f_fstypename) < 0) { return NULL; } - - if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->f_mntonname))==NULL){ + if (sg_update_string(&disk_ptr->mnt_point, mp->f_mntonname) < 0) { return NULL; } @@ -216,15 +192,15 @@ disk_stat_t *get_disk_stats(int *entries){ disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes; #endif #if defined(LINUX) || defined(CYGWIN) - if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){ + if (sg_update_string(&disk_ptr->device_name, mp->mnt_fsname) < 0) { return NULL; } - if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){ + if (sg_update_string(&disk_ptr->fs_type, mp->mnt_type) < 0) { return NULL; } - if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){ + if (sg_update_string(&disk_ptr->mnt_point, mp->mnt_dir) < 0) { return NULL; } disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks; @@ -238,22 +214,21 @@ disk_stat_t *get_disk_stats(int *entries){ #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){ + if (sg_update_string(&disk_ptr->device_name, mp.mnt_special) < 0) { return NULL; } - if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){ - return NULL; - } + if (sg_update_string(&disk_ptr->fs_type, mp.mnt_fstype) < 0) { + return NULL; + } - if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){ - return NULL; - } + if (sg_update_string(&disk_ptr->mnt_point, mp.mnt_mountp) < 0) { + 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; @@ -270,7 +245,7 @@ disk_stat_t *get_disk_stats(int *entries){ *entries=num_disks; /* If this fails, there is very little i can do about it, so - I'll ignore it :) */ + I'll ignore it :) */ #if defined(LINUX) || defined(CYGWIN) endmntent(f); #endif @@ -281,43 +256,31 @@ disk_stat_t *get_disk_stats(int *entries){ return disk_stats; } -void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){ - for(diskio_stats+=start; startdisk_name=NULL; - - diskio_stats++; - } +int sg_fs_compare_device_name(const void *va, const void *vb) { + const sg_fs_stats *a = (const sg_fs_stats *)va; + const sg_fs_stats *b = (const sg_fs_stats *)vb; + + return strcmp(a->device_name, b->device_name); } -diskio_stat_t *diskio_stat_malloc(int needed_entries, int *cur_entries, diskio_stat_t *diskio_stats){ +int sg_fs_compare_mnt_point(const void *va, const void *vb) { + const sg_fs_stats *a = (const sg_fs_stats *)va; + const sg_fs_stats *b = (const sg_fs_stats *)vb; - if(diskio_stats==NULL){ + return strcmp(a->mnt_point, b->mnt_point); +} - 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; +static void diskio_stat_init(sg_disk_io_stats *d) { + d->disk_name = NULL; +} - return diskio_stats; - } - - - if(*cur_entriesdisk_name); } -static diskio_stat_t *diskio_stats=NULL; -static int num_diskio=0; +VECTOR_DECLARE_STATIC(diskio_stats, sg_disk_io_stats, 10, + diskio_stat_init, diskio_stat_destroy); #ifdef LINUX typedef struct { @@ -326,16 +289,15 @@ typedef struct { } partition; #endif -diskio_stat_t *get_diskio_stats(int *entries){ - - static int sizeof_diskio_stats=0; +sg_disk_io_stats *sg_get_disk_io_stats(int *entries){ + int num_diskio; #ifndef LINUX - diskio_stat_t *diskio_stats_ptr; + sg_disk_io_stats *diskio_stats_ptr; #endif #ifdef SOLARIS - kstat_ctl_t *kc; - kstat_t *ksp; + kstat_ctl_t *kc; + kstat_t *ksp; kstat_io_t kios; #endif #ifdef LINUX @@ -343,13 +305,12 @@ diskio_stat_t *get_diskio_stats(int *entries){ char *line_ptr; int major, minor; int has_pp_stats = 1; - static partition *parts = NULL; - static int alloc_parts = 0; + VECTOR_DECLARE_STATIC(parts, partition, 16, NULL, NULL); int i, n; time_t now; const char *format; #endif -#ifdef FREEBSD +#if defined(FREEBSD) || defined(DFBSD) static struct statinfo stats; static int stats_init = 0; int counter; @@ -360,91 +321,177 @@ diskio_stat_t *get_diskio_stats(int *entries){ #endif #ifdef NETBSD struct disk_sysctl *stats; +#endif +#ifdef OPENBSD + int diskcount; + char *disknames, *name, *bufpp; + char **dk_name; + struct diskstats *stats; +#endif +#ifdef NETBSD +#define MIBSIZE 3 +#endif +#ifdef OPENBSD +#define MIBSIZE 2 +#endif +#if defined(NETBSD) || defined(OPENBSD) int num_disks, i; - int mib[3]; + int mib[MIBSIZE]; size_t size; #endif num_diskio=0; -#ifdef NETBSD +#ifdef OPENBSD mib[0] = CTL_HW; + mib[1] = HW_DISKCOUNT; + + size = sizeof(diskcount); + if (sysctl(mib, MIBSIZE, &diskcount, &size, NULL, 0) < 0) { + sg_set_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKCOUNT"); + return NULL; + } + + mib[0] = CTL_HW; + mib[1] = HW_DISKNAMES; + + if (sysctl(mib, MIBSIZE, NULL, &size, NULL, 0) < 0) { + sg_set_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKNAMES"); + return NULL; + } + + disknames = sg_malloc(size); + if (disknames == NULL) { + return NULL; + } + + if (sysctl(mib, MIBSIZE, disknames, &size, NULL, 0) < 0) { + sg_set_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKNAMES"); + return NULL; + } + + dk_name = sg_malloc(diskcount * sizeof(char *)); + bufpp = disknames; + for (i = 0; i < diskcount && (name = strsep(&bufpp, ",")) != NULL; i++) { + dk_name[i] = name; + } +#endif + +#if defined(NETBSD) || defined(OPENBSD) + mib[0] = CTL_HW; mib[1] = HW_DISKSTATS; +#ifdef NETBSD mib[2] = sizeof(struct disk_sysctl); +#endif - if (sysctl(mib, 3, NULL, &size, NULL, 0) < 0) { + if (sysctl(mib, MIBSIZE, NULL, &size, NULL, 0) < 0) { + sg_set_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKSTATS"); return NULL; } + +#ifdef NETBSD num_disks = size / sizeof(struct disk_sysctl); +#else + num_disks = size / sizeof(struct diskstats); +#endif - stats = malloc(size); + stats = sg_malloc(size); if (stats == NULL) { return NULL; } - if (sysctl(mib, 3, stats, &size, NULL, 0) < 0) { + if (sysctl(mib, MIBSIZE, stats, &size, NULL, 0) < 0) { + sg_set_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKSTATS"); return NULL; } for (i = 0; i < num_disks; i++) { + const char *name; u_int64_t rbytes, wbytes; +#ifdef NETBSD #ifdef HAVE_DK_RBYTES rbytes = stats[i].dk_rbytes; wbytes = stats[i].dk_wbytes; #else - /* Before 1.7, NetBSD merged reads and writes. */ + /* Before 2.0, NetBSD merged reads and writes. */ rbytes = wbytes = stats[i].dk_bytes; #endif +#else +#ifdef HAVE_DS_RBYTES + rbytes = stats[i].ds_rbytes; + wbytes = stats[i].ds_wbytes; +#else + /* Before 3.5, OpenBSD merged reads and writes */ + rbytes = wbytes = stats[i].ds_bytes; +#endif +#endif /* Don't keep stats for disks that have never been used. */ if (rbytes == 0 && wbytes == 0) { continue; } - diskio_stats = diskio_stat_malloc(num_diskio + 1, - &sizeof_diskio_stats, - diskio_stats); - if (diskio_stats == NULL) { + if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) { return NULL; } diskio_stats_ptr = diskio_stats + num_diskio; diskio_stats_ptr->read_bytes = rbytes; diskio_stats_ptr->write_bytes = wbytes; - if (diskio_stats_ptr->disk_name != NULL) { - free(diskio_stats_ptr->disk_name); +#ifdef NETBSD + name = stats[i].dk_name; +#else + name = dk_name[i]; +#endif + if (sg_update_string(&diskio_stats_ptr->disk_name, name) < 0) { + return NULL; } - diskio_stats_ptr->disk_name = strdup(stats[i].dk_name); diskio_stats_ptr->systime = time(NULL); num_diskio++; } free(stats); +#ifdef OPENBSD + free(dk_name); + free(disknames); #endif +#endif -#ifdef FREEBSD +#if defined(FREEBSD) || defined(DFBSD) if (!stats_init) { - stats.dinfo=malloc(sizeof(struct devinfo)); + stats.dinfo=sg_malloc(sizeof(struct devinfo)); if(stats.dinfo==NULL) return NULL; bzero(stats.dinfo, sizeof(struct devinfo)); stats_init = 1; } #ifdef FREEBSD5 - if ((devstat_getdevs(NULL, &stats)) < 0) return NULL; + if ((devstat_getdevs(NULL, &stats)) < 0) { + sg_set_error(SG_ERROR_DEVSTAT_GETDEVS, NULL); + 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; + 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) { + sg_set_error(SG_ERROR_DEVSTAT_SELECTDEVS, NULL); + return NULL; + } #else - if ((getdevs(&stats)) < 0) return NULL; + if ((getdevs(&stats)) < 0) { + sg_set_error(SG_ERROR_DEVSTAT_GETDEVS, NULL); + 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; + 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) { + sg_set_error(SG_ERROR_DEVSTAT_SELECTDEVS, NULL); + return NULL; + } #endif for(counter=0;counternumdevs;counter++){ @@ -459,7 +506,8 @@ diskio_stat_t *get_diskio_stats(int *entries){ #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){ + + if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) { return NULL; } diskio_stats_ptr=diskio_stats+num_diskio; @@ -472,7 +520,10 @@ diskio_stat_t *get_diskio_stats(int *entries){ 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); + if (asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number) == -1) { + sg_set_error(SG_ERROR_ASPRINTF, NULL); + return NULL; + } diskio_stats_ptr->systime=time(NULL); num_diskio++; @@ -482,32 +533,33 @@ diskio_stat_t *get_diskio_stats(int *entries){ #endif #ifdef SOLARIS if ((kc = kstat_open()) == NULL) { - return NULL; - } + sg_set_error(SG_ERROR_KSTAT_OPEN, NULL); + return NULL; + } for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { - if (!strcmp(ksp->ks_class, "disk")) { + 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((kstat_read(kc, ksp, &kios))==-1){ } - if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){ + if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) { 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((char *) get_svr_from_bsd(ksp->ks_name)); + if (sg_update_string(&diskio_stats_ptr->disk_name, + sg_get_svr_from_bsd(ksp->ks_name)) < 0) { + return NULL; + } diskio_stats_ptr->systime=time(NULL); + num_diskio++; } } @@ -525,16 +577,16 @@ diskio_stat_t *get_diskio_stats(int *entries){ the same format. */ f = fopen("/proc/diskstats", "r"); - format = " %d %d %19s %*d %*d %lld %*d %*d %*d %lld"; + format = " %d %d %99s %*d %*d %lld %*d %*d %*d %lld"; if (f == NULL) { f = fopen("/proc/partitions", "r"); - format = " %d %d %*d %19s %*d %*d %lld %*d %*d %*d %lld"; + format = " %d %d %*d %99s %*d %*d %lld %*d %*d %*d %lld"; } if (f == NULL) goto out; now = time(NULL); - while ((line_ptr = f_read_line(f, "")) != NULL) { - char name[20]; + while ((line_ptr = sg_f_read_line(f, "")) != NULL) { + char name[100]; char *s; long long rsect, wsect; @@ -555,21 +607,16 @@ diskio_stat_t *get_diskio_stats(int *entries){ wsect = 0; } - 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 (VECTOR_RESIZE(diskio_stats, n + 1) < 0) { + goto out; } + if (VECTOR_RESIZE(parts, n + 1) < 0) { + goto out; + } - if (diskio_stats[n].disk_name != NULL) - free(diskio_stats[n].disk_name); - diskio_stats[n].disk_name = strdup(name); + if (sg_update_string(&diskio_stats[n].disk_name, name) < 0) { + goto out; + } diskio_stats[n].read_bytes = rsect * 512; diskio_stats[n].write_bytes = wsect * 512; diskio_stats[n].systime = now; @@ -591,7 +638,7 @@ diskio_stat_t *get_diskio_stats(int *entries){ if (f == NULL) goto out; now = time(NULL); - line_ptr = f_read_line(f, "disk_io:"); + line_ptr = sg_f_read_line(f, "disk_io:"); if (line_ptr == NULL) goto out; while((line_ptr=strchr(line_ptr, ' '))!=NULL){ @@ -655,6 +702,7 @@ out: #endif #ifdef CYGWIN + sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin"); return NULL; #endif @@ -663,20 +711,20 @@ out: return diskio_stats; } -diskio_stat_t *get_diskio_stats_diff(int *entries){ - static diskio_stat_t *diff = NULL; - static int diff_count = 0; - diskio_stat_t *src, *dest; - int i, j, new_count; +sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries){ + VECTOR_DECLARE_STATIC(diff, sg_disk_io_stats, 1, + diskio_stat_init, diskio_stat_destroy); + sg_disk_io_stats *src = NULL, *dest; + int i, j, diff_count, new_count; if (diskio_stats == NULL) { /* No previous stats, so we can't calculate a difference. */ - return get_diskio_stats(entries); + return sg_get_disk_io_stats(entries); } /* Resize the results array to match the previous stats. */ - diff = diskio_stat_malloc(num_diskio, &diff_count, diff); - if (diff == NULL) { + diff_count = VECTOR_SIZE(diskio_stats); + if (VECTOR_RESIZE(diff, diff_count) < 0) { return NULL; } @@ -685,17 +733,16 @@ diskio_stat_t *get_diskio_stats_diff(int *entries){ src = &diskio_stats[i]; dest = &diff[i]; - if (dest->disk_name != NULL) { - free(dest->disk_name); + if (sg_update_string(&dest->disk_name, src->disk_name) < 0) { + return NULL; } - dest->disk_name = strdup(src->disk_name); dest->read_bytes = src->read_bytes; dest->write_bytes = src->write_bytes; dest->systime = src->systime; } /* Get a new set of stats. */ - if (get_diskio_stats(&new_count) == NULL) { + if (sg_get_disk_io_stats(&new_count) == NULL) { return NULL; } @@ -726,5 +773,12 @@ diskio_stat_t *get_diskio_stats_diff(int *entries){ *entries = diff_count; return diff; +} + +int sg_disk_io_compare_name(const void *va, const void *vb) { + const sg_disk_io_stats *a = (const sg_disk_io_stats *)va; + const sg_disk_io_stats *b = (const sg_disk_io_stats *)vb; + + return strcmp(a->disk_name, b->disk_name); }