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.72 by ats, Sun Jul 18 21:30:11 2004 UTC vs.
Revision 1.80 by tdb, Thu Feb 24 12:34:45 2005 UTC

# Line 50 | Line 50
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"}
53 >                        "umsdos", "vfat", "xfs", "jfs", "nfs"}
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", "nfs"}
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", "nfs"}
77   #endif
78  
79 + #ifdef HPUX
80 + #include <sys/param.h>
81 + #include <sys/pstat.h>
82 + #include <sys/types.h>
83 + #include <sys/stat.h>
84 + #include <sys/vfs.h>
85 + #include <mntent.h>
86 + #include <dirent.h>
87 + #include <stdio.h>
88 + #include <time.h>
89 + #define VALID_FS_TYPES {"vxfs", "hfs"}
90 + #define DISK_BATCH 30
91 + #endif
92 +
93   static void disk_stat_init(sg_fs_stats *d) {
94          d->device_name = NULL;
95          d->fs_type = NULL;
# Line 92 | Line 106 | static int is_valid_fs_type(const char *type) {
106          const char *types[] = VALID_FS_TYPES;
107          int i;
108  
109 <        for (i = 0; i < (sizeof types / sizeof *types); i++) {
109 >        for (i = 0; i < (int) (sizeof types / sizeof *types); i++) {
110                  if (strcmp(types[i], type) == 0) {
111                          return 1;
112                  }
# Line 106 | Line 120 | sg_fs_stats *sg_get_fs_stats(int *entries){
120  
121          int valid_type;
122          int num_disks=0;
123 < #if defined(LINUX) || defined (SOLARIS) || defined(CYGWIN)
123 > #if defined(LINUX) || defined (SOLARIS) || defined(CYGWIN) || defined(HPUX)
124          FILE *f;
125   #endif
126  
# Line 116 | Line 130 | sg_fs_stats *sg_get_fs_stats(int *entries){
130          struct mnttab mp;
131          struct statvfs fs;
132   #endif
133 < #if defined(LINUX) || defined(CYGWIN)
133 > #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
134          struct mntent *mp;
135          struct statfs fs;
136   #endif
# Line 130 | Line 144 | sg_fs_stats *sg_get_fs_stats(int *entries){
144   #endif
145  
146   #ifdef ALLBSD
147 <        nummnt=getmntinfo(&mp , MNT_LOCAL);
147 >        nummnt=getmntinfo(&mp, MNT_WAIT);
148          if (nummnt<=0){
149                  sg_set_error_with_errno(SG_ERROR_GETMNTINFO, NULL);
150                  return NULL;
# Line 139 | Line 153 | sg_fs_stats *sg_get_fs_stats(int *entries){
153                  valid_type = is_valid_fs_type(mp->f_fstypename);
154   #endif
155  
156 < #if defined(LINUX) || defined(CYGWIN)
156 > #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
157 > #ifdef MNT_MNTTAB
158 >        if ((f=setmntent(MNT_MNTTAB, "r" ))==NULL){
159 > #else
160          if ((f=setmntent("/etc/mtab", "r" ))==NULL){
161 + #endif
162                  sg_set_error(SG_ERROR_SETMNTENT, NULL);
163                  return NULL;
164          }
# Line 191 | Line 209 | sg_fs_stats *sg_get_fs_stats(int *entries){
209                          /* Freebsd doesn't have a "available" inodes */
210                          disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
211   #endif
212 < #if defined(LINUX) || defined(CYGWIN)
212 > #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
213                          if (sg_update_string(&disk_ptr->device_name, mp->mnt_fsname) < 0) {
214                                  return NULL;
215                          }
# Line 246 | Line 264 | sg_fs_stats *sg_get_fs_stats(int *entries){
264  
265          /* If this fails, there is very little i can do about it, so
266             I'll ignore it :) */
267 < #if defined(LINUX) || defined(CYGWIN)
267 > #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
268          endmntent(f);
269   #endif
270   #if defined(SOLARIS)
# Line 295 | Line 313 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
313          sg_disk_io_stats *diskio_stats_ptr;
314   #endif
315  
316 + #ifdef HPUX
317 +        long long rbytes = 0, wbytes = 0;
318 +        struct dirent *dinfo = NULL;
319 +        struct stat lstatinfo;
320 +        struct pst_diskinfo pstat_diskinfo[DISK_BATCH];
321 +        char fullpathbuf[1024] = {0};
322 +        dev_t diskid;
323 +        DIR *dh = NULL;
324 +        int diskidx = 0;
325 +        int num, i;
326 + #endif
327   #ifdef SOLARIS
328          kstat_ctl_t *kc;
329          kstat_t *ksp;
# Line 342 | Line 371 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
371  
372          num_diskio=0;
373  
374 + #ifdef HPUX
375 +        while (1) {
376 +                num = pstat_getdisk(pstat_diskinfo, sizeof pstat_diskinfo[0],
377 +                                    DISK_BATCH, diskidx);
378 +                if (num == -1) {
379 +                        sg_set_error_with_errno(SG_ERROR_PSTAT,
380 +                                                "pstat_getdisk");
381 +                        return NULL;
382 +                } else if (num == 0) {
383 +                        break;
384 +                }
385 +
386 +                for (i = 0; i < num; i++) {
387 +                        struct pst_diskinfo *di = &pstat_diskinfo[i];
388 +
389 +                        /* Skip "disabled" disks. */
390 +                        if (di->psd_status == 0) {
391 +                                continue;
392 +                        }
393 +        
394 +                        /* We can't seperate the reads from the writes, we'll
395 +                         * just give the same to each. (This value is in
396 +                         * 64-byte chunks according to the pstat header file,
397 +                         * and can wrap to be negative.)
398 +                         */
399 +                        rbytes = wbytes = ((unsigned long) di->psd_dkwds) * 64LL;
400 +        
401 +                        /* Skip unused disks. */
402 +                        if (rbytes == 0 && wbytes == 0) {
403 +                                continue;
404 +                        }
405 +        
406 +                        if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
407 +                                return NULL;
408 +                        }
409 +        
410 +                        diskio_stats_ptr = diskio_stats + num_diskio;
411 +        
412 +                        diskio_stats_ptr->read_bytes = rbytes;
413 +                        diskio_stats_ptr->write_bytes = wbytes;
414 +        
415 +                        diskio_stats_ptr->systime = time(NULL);
416 +        
417 +                        num_diskio++;
418 +        
419 +                        /* FIXME This should use a static cache, like the Linux
420 +                         * code below. */
421 +                        if (diskio_stats_ptr->disk_name == NULL) {
422 +                                dh = opendir("/dev/dsk");
423 +                                if (dh == NULL) {
424 +                                        continue;
425 +                                }
426 +        
427 +                                diskid = (di->psd_dev.psd_major << 24) | di->psd_dev.psd_minor;
428 +                                while (1) {
429 +                                        dinfo = readdir(dh);
430 +                                        if (dinfo == NULL) {
431 +                                                break;
432 +                                        }
433 +                                        snprintf(fullpathbuf, sizeof(fullpathbuf), "/dev/dsk/%s", dinfo->d_name);
434 +                                        if (lstat(fullpathbuf, &lstatinfo) < 0) {
435 +                                                continue;
436 +                                        }
437 +        
438 +                                        if (lstatinfo.st_rdev == diskid) {
439 +                                                if (sg_update_string(&diskio_stats_ptr->disk_name, dinfo->d_name) < 0) {
440 +                                                        return NULL;
441 +                                                }
442 +                                                break;
443 +                                        }
444 +                                }
445 +                                closedir(dh);
446 +        
447 +                                if (diskio_stats_ptr->disk_name == NULL) {
448 +                                        if (sg_update_string(&diskio_stats_ptr->disk_name, di->psd_hw_path.psh_name) < 0) {
449 +                                                return NULL;
450 +                                        }
451 +                                }
452 +                        }
453 +                }
454 +                diskidx = pstat_diskinfo[num - 1].psd_idx + 1;
455 +        }
456 + #endif
457   #ifdef OPENBSD
458          mib[0] = CTL_HW;
459          mib[1] = HW_DISKCOUNT;

Diff Legend

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