ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/disk_stats.c
(Generate patch)

Comparing projects/libstatgrab/src/libstatgrab/disk_stats.c (file contents):
Revision 1.63 by tdb, Tue Apr 6 14:52:58 2004 UTC vs.
Revision 1.67 by ats, Thu Apr 8 13:44:44 2004 UTC

# Line 47 | Line 47
47  
48   #ifdef LINUX
49   #define VALID_FS_TYPES {"adfs", "affs", "befs", "bfs", "efs", "ext2", \
50 <                        "ext3", "vxfs", "hfs", "hfsplus", "hpfs", "jffs", \
51 <                        "jffs2", "minix", "msdos", "ntfs", "qnx4", "ramfs", \
52 <                        "rootfs", "reiserfs", "sysv", "v7", "udf", "ufs", \
53 <                        "umsdos", "vfat", "xfs", "jfs"}
50 >                        "ext3", "vxfs", "hfs", "hfsplus", "hpfs", "jffs", \
51 >                        "jffs2", "minix", "msdos", "ntfs", "qnx4", "ramfs", \
52 >                        "rootfs", "reiserfs", "sysv", "v7", "udf", "ufs", \
53 >                        "umsdos", "vfat", "xfs", "jfs"}
54   #endif
55  
56   #ifdef CYGWIN
# Line 66 | Line 66
66   #include <sys/dkstat.h>
67   #include <devstat.h>
68   #define VALID_FS_TYPES {"hpfs", "msdosfs", "ntfs", "udf", "ext2fs", \
69 <                        "ufs", "mfs"}
69 >                        "ufs", "mfs"}
70   #endif
71   #if defined(NETBSD) || defined(OPENBSD)
72   #include <sys/param.h>
73   #include <sys/sysctl.h>
74   #include <sys/disk.h>
75   #define VALID_FS_TYPES {"ffs", "mfs", "msdos", "lfs", "adosfs", "ext2fs", \
76 <                        "ntfs"}
76 >                        "ntfs"}
77   #endif
78  
79   static void disk_stat_init(sg_fs_stats *d) {
# Line 102 | Line 102 | static int is_valid_fs_type(const char *type) {
102  
103   sg_fs_stats *sg_get_fs_stats(int *entries){
104          VECTOR_DECLARE_STATIC(disk_stats, sg_fs_stats, 10,
105 <                              disk_stat_init, disk_stat_destroy);
105 >                              disk_stat_init, disk_stat_destroy);
106  
107          int valid_type;
108          int num_disks=0;
# Line 128 | Line 128 | sg_fs_stats *sg_get_fs_stats(int *entries){
128   #ifdef ALLBSD
129          nummnt=getmntinfo(&mp , MNT_LOCAL);
130          if (nummnt<=0){
131 +                sg_set_error(SG_ERROR_GETMNTINFO, NULL);
132                  return NULL;
133          }
134          for(;nummnt--; mp++){
# Line 136 | Line 137 | sg_fs_stats *sg_get_fs_stats(int *entries){
137  
138   #if defined(LINUX) || defined(CYGWIN)
139          if ((f=setmntent("/etc/mtab", "r" ))==NULL){
140 +                sg_set_error(SG_ERROR_SETMNTENT, NULL);
141                  return NULL;
142          }
143  
# Line 149 | Line 151 | sg_fs_stats *sg_get_fs_stats(int *entries){
151  
152   #ifdef SOLARIS
153          if ((f=fopen("/etc/mnttab", "r" ))==NULL){
154 +                sg_set_error(SG_ERROR_OPEN, "/etc/mnttab");
155                  return NULL;
156          }
157          while((getmntent(f, &mp)) == 0){
# Line 216 | Line 219 | sg_fs_stats *sg_get_fs_stats(int *entries){
219                          }
220  
221                          if (sg_update_string(&disk_ptr->fs_type, mp.mnt_fstype) < 0) {
222 <                                return NULL;
223 <                        }
222 >                                return NULL;
223 >                        }
224          
225                          if (sg_update_string(&disk_ptr->mnt_point, mp.mnt_mountp) < 0) {
226 <                                return NULL;
227 <                        }
226 >                                return NULL;
227 >                        }
228                          
229                          disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
230                          disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
# Line 238 | Line 241 | sg_fs_stats *sg_get_fs_stats(int *entries){
241          *entries=num_disks;    
242  
243          /* If this fails, there is very little i can do about it, so
244 <           I'll ignore it :) */
244 >           I'll ignore it :) */
245   #if defined(LINUX) || defined(CYGWIN)
246          endmntent(f);
247   #endif
# Line 250 | Line 253 | sg_fs_stats *sg_get_fs_stats(int *entries){
253  
254   }
255  
256 + int sg_fs_compare_device_name(const void *va, const void *vb) {
257 +        const sg_fs_stats *a = (const sg_fs_stats *)va;
258 +        const sg_fs_stats *b = (const sg_fs_stats *)vb;
259 +
260 +        return strcmp(a->device_name, b->device_name);
261 + }
262 +
263 + int sg_fs_compare_mnt_point(const void *va, const void *vb) {
264 +        const sg_fs_stats *a = (const sg_fs_stats *)va;
265 +        const sg_fs_stats *b = (const sg_fs_stats *)vb;
266 +
267 +        return strcmp(a->mnt_point, b->mnt_point);
268 + }
269 +
270   static void diskio_stat_init(sg_disk_io_stats *d) {
271          d->disk_name = NULL;
272   }
# Line 259 | Line 276 | static void diskio_stat_destroy(sg_disk_io_stats *d) {
276   }
277  
278   VECTOR_DECLARE_STATIC(diskio_stats, sg_disk_io_stats, 10,
279 <                      diskio_stat_init, diskio_stat_destroy);
279 >                      diskio_stat_init, diskio_stat_destroy);
280  
281   #ifdef LINUX
282   typedef struct {
# Line 275 | Line 292 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
292   #endif
293  
294   #ifdef SOLARIS
295 <        kstat_ctl_t *kc;
296 <        kstat_t *ksp;
295 >        kstat_ctl_t *kc;
296 >        kstat_t *ksp;
297          kstat_io_t kios;
298   #endif
299   #ifdef LINUX
# Line 327 | Line 344 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
344  
345          size = sizeof(diskcount);
346          if (sysctl(mib, MIBSIZE, &diskcount, &size, NULL, 0) < 0) {
347 +                sg_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKCOUNT");
348                  return NULL;
349          }
350  
# Line 334 | Line 352 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
352          mib[1] = HW_DISKNAMES;
353  
354          if (sysctl(mib, MIBSIZE, NULL, &size, NULL, 0) < 0) {
355 +                sg_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKNAMES");
356                  return NULL;
357          }
358  
359 <        disknames = malloc(size);
359 >        disknames = sg_malloc(size);
360          if (disknames == NULL) {
361                  return NULL;
362          }
363  
364          if (sysctl(mib, MIBSIZE, disknames, &size, NULL, 0) < 0) {
365 +                sg_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKNAMES");
366                  return NULL;
367          }
368  
369 <        dk_name = calloc(diskcount, sizeof(char *));
369 >        dk_name = sg_malloc(diskcount * sizeof(char *));
370          bufpp = disknames;
371          for (i = 0; i < diskcount && (name = strsep(&bufpp, ",")) != NULL; i++) {
372                  dk_name[i] = name;
# Line 361 | Line 381 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
381   #endif
382  
383          if (sysctl(mib, MIBSIZE, NULL, &size, NULL, 0) < 0) {
384 +                sg_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKSTATS");
385                  return NULL;
386          }
387  
# Line 370 | Line 391 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
391          num_disks = size / sizeof(struct diskstats);
392   #endif
393  
394 <        stats = malloc(size);
394 >        stats = sg_malloc(size);
395          if (stats == NULL) {
396                  return NULL;
397          }
398  
399          if (sysctl(mib, MIBSIZE, stats, &size, NULL, 0) < 0) {
400 +                sg_error(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKSTATS");
401                  return NULL;
402          }
403  
# Line 429 | Line 451 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
451  
452   #if defined(FREEBSD) || defined(DFBSD)
453          if (!stats_init) {
454 <                stats.dinfo=malloc(sizeof(struct devinfo));
454 >                stats.dinfo=sg_malloc(sizeof(struct devinfo));
455                  if(stats.dinfo==NULL) return NULL;
456                  bzero(stats.dinfo, sizeof(struct devinfo));
457                  stats_init = 1;
458          }
459   #ifdef FREEBSD5
460 <        if ((devstat_getdevs(NULL, &stats)) < 0) return NULL;
460 >        if ((devstat_getdevs(NULL, &stats)) < 0) {
461 >                sg_set_error(SG_ERROR_DEVSTAT_GETDEVS, NULL);
462 >                return NULL;
463 >        }
464          /* Not aware of a get all devices, so i said 999. If we ever
465           * find a machine with more than 999 disks, then i'll change
466           * this number :)
467           */
468 <        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;
468 >        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) {
469 >                sg_set_error(SG_ERROR_DEVSTAT_SELECTDEVS, NULL);
470 >                return NULL;
471 >        }
472   #else
473 <        if ((getdevs(&stats)) < 0) return NULL;
473 >        if ((getdevs(&stats)) < 0) {
474 >                sg_set_error(SG_ERROR_DEVSTAT_GETDEVS, NULL);
475 >                return NULL;
476 >        }
477          /* Not aware of a get all devices, so i said 999. If we ever
478           * find a machine with more than 999 disks, then i'll change
479           * this number :)
480           */
481 <        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;
481 >        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) {
482 >                sg_set_error(SG_ERROR_DEVSTAT_SELECTDEVS, NULL);
483 >                return NULL;
484 >        }
485   #endif
486  
487          for(counter=0;counter<stats.dinfo->numdevs;counter++){
# Line 477 | Line 511 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
511   #endif
512                  if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
513                  if (asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number) == -1) {
514 +                        sg_set_error(SG_ERROR_ASPRINTF, NULL);
515                          return NULL;
516                  }
517                  diskio_stats_ptr->systime=time(NULL);
# Line 488 | Line 523 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
523   #endif
524   #ifdef SOLARIS
525          if ((kc = kstat_open()) == NULL) {
526 <                return NULL;
527 <        }
526 >                sg_set_error(SG_ERROR_KSTAT_OPEN, NULL);
527 >                return NULL;
528 >        }
529  
530          for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
531 <                if (!strcmp(ksp->ks_class, "disk")) {
531 >                if (!strcmp(ksp->ks_class, "disk")) {
532  
533                          if(ksp->ks_type != KSTAT_TYPE_IO) continue;
534                          /* We dont want metadevices appearins as num_diskio */
535                          if(strcmp(ksp->ks_module, "md")==0) continue;
536 <                        if((kstat_read(kc, ksp, &kios))==-1){  
536 >                        if((kstat_read(kc, ksp, &kios))==-1){  
537                          }
538                          
539                          if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
# Line 509 | Line 545 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
545                          diskio_stats_ptr->read_bytes=kios.nread;
546                          diskio_stats_ptr->write_bytes=kios.nwritten;
547                          if (sg_update_string(&diskio_stats_ptr->disk_name,
548 <                                             sg_get_svr_from_bsd(ksp->ks_name)) < 0) {
548 >                                             sg_get_svr_from_bsd(ksp->ks_name)) < 0) {
549                                  return NULL;
550                          }
551                          diskio_stats_ptr->systime=time(NULL);
# Line 656 | Line 692 | out:
692   #endif
693  
694   #ifdef CYGWIN
695 +        sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
696          return NULL;
697   #endif
698  
# Line 666 | Line 703 | out:
703  
704   sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries){
705          VECTOR_DECLARE_STATIC(diff, sg_disk_io_stats, 1,
706 <                              diskio_stat_init, diskio_stat_destroy);
706 >                              diskio_stat_init, diskio_stat_destroy);
707          sg_disk_io_stats *src = NULL, *dest;
708          int i, j, diff_count, new_count;
709  
# Line 726 | Line 763 | sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entri
763  
764          *entries = diff_count;
765          return diff;
766 + }
767 +
768 + int sg_disk_io_compare_name(const void *va, const void *vb) {
769 +        const sg_disk_io_stats *a = (const sg_disk_io_stats *)va;
770 +        const sg_disk_io_stats *b = (const sg_disk_io_stats *)vb;
771 +
772 +        return strcmp(a->disk_name, b->disk_name);
773   }
774  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines