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.79 by ats, Sun Nov 7 15:06:49 2004 UTC vs.
Revision 1.82 by tdb, Wed Jul 13 13:01:24 2005 UTC

# Line 43 | Line 43
43   #if defined(LINUX) || defined(CYGWIN)
44   #include <mntent.h>
45   #include <sys/vfs.h>
46 + #include <sys/statvfs.h>
47   #endif
48  
49   #ifdef LINUX
# Line 50 | Line 51
51                          "ext3", "vxfs", "hfs", "hfsplus", "hpfs", "jffs", \
52                          "jffs2", "minix", "msdos", "ntfs", "qnx4", "ramfs", \
53                          "rootfs", "reiserfs", "sysv", "v7", "udf", "ufs", \
54 <                        "umsdos", "vfat", "xfs", "jfs"}
54 >                        "umsdos", "vfat", "xfs", "jfs", "nfs"}
55   #endif
56  
57   #ifdef CYGWIN
# Line 66 | Line 67
67   #include <sys/dkstat.h>
68   #include <devstat.h>
69   #define VALID_FS_TYPES {"hpfs", "msdosfs", "ntfs", "udf", "ext2fs", \
70 <                        "ufs", "mfs"}
70 >                        "ufs", "mfs", "nfs"}
71   #endif
72   #if defined(NETBSD) || defined(OPENBSD)
73   #include <sys/param.h>
74   #include <sys/sysctl.h>
75   #include <sys/disk.h>
76   #define VALID_FS_TYPES {"ffs", "mfs", "msdos", "lfs", "adosfs", "ext2fs", \
77 <                        "ntfs"}
77 >                        "ntfs", "nfs"}
78   #endif
79  
80   #ifdef HPUX
# Line 90 | Line 91
91   #define DISK_BATCH 30
92   #endif
93  
94 + #ifdef ALLBSD
95 + #define SG_MP_FSTYPENAME(mp) (mp)->f_fstypename
96 + #define SG_MP_DEVNAME(mp)    (mp)->f_mntfromname
97 + #define SG_MP_MOUNTP(mp)     (mp)->f_mntonname
98 + #define SG_FS_FRSIZE(fs)     (long long) (*(fs))->f_bsize
99 + #define SG_FS_BSIZE(fs)      (long long) (*(fs))->f_iosize
100 + #define SG_FS_BLOCKS(fs)     (long long) (*(fs))->f_blocks
101 + #define SG_FS_BFREE(fs)      (long long) (*(fs))->f_bfree
102 + #define SG_FS_BAVAIL(fs)     (long long) (*(fs))->f_bavail
103 + #define SG_FS_FILES(fs)      (long long) (*(fs))->f_files
104 + #define SG_FS_FFREE(fs)      (long long) (*(fs))->f_ffree
105 + #define SG_FS_FAVAIL(fs)     -1LL
106 + #endif
107 + #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
108 + #define SG_MP_FSTYPENAME(mp) (mp)->mnt_type
109 + #define SG_MP_DEVNAME(mp)    (mp)->mnt_fsname
110 + #define SG_MP_MOUNTP(mp)     (mp)->mnt_dir
111 + #define SG_FS_FRSIZE(fs)     (long long) (fs).f_frsize
112 + #define SG_FS_BSIZE(fs)      (long long) (fs).f_bsize
113 + #define SG_FS_BLOCKS(fs)     (long long) (fs).f_blocks
114 + #define SG_FS_BFREE(fs)      (long long) (fs).f_bfree
115 + #define SG_FS_BAVAIL(fs)     (long long) (fs).f_bavail
116 + #define SG_FS_FILES(fs)      (long long) (fs).f_files
117 + #define SG_FS_FFREE(fs)      (long long) (fs).f_ffree
118 + #define SG_FS_FAVAIL(fs)     (long long) (fs).f_favail
119 + #endif
120 + #ifdef SOLARIS
121 + #define SG_MP_FSTYPENAME(mp) (mp).mnt_fstype
122 + #define SG_MP_DEVNAME(mp)    (mp).mnt_special
123 + #define SG_MP_MOUNTP(mp)     (mp).mnt_mountp
124 + #define SG_FS_FRSIZE(fs)     (long long) (fs).f_frsize
125 + #define SG_FS_BSIZE(fs)      (long long) (fs).f_bsize
126 + #define SG_FS_BLOCKS(fs)     (long long) (fs).f_blocks
127 + #define SG_FS_BFREE(fs)      (long long) (fs).f_bfree
128 + #define SG_FS_BAVAIL(fs)     (long long) (fs).f_bavail
129 + #define SG_FS_FILES(fs)      (long long) (fs).f_files
130 + #define SG_FS_FFREE(fs)      (long long) (fs).f_ffree
131 + #define SG_FS_FAVAIL(fs)     (long long) (fs).f_favail
132 + #endif
133 +
134   static void disk_stat_init(sg_fs_stats *d) {
135          d->device_name = NULL;
136          d->fs_type = NULL;
# Line 118 | Line 159 | sg_fs_stats *sg_get_fs_stats(int *entries){
159          VECTOR_DECLARE_STATIC(disk_stats, sg_fs_stats, 10,
160                                disk_stat_init, disk_stat_destroy);
161  
121 –        int valid_type;
162          int num_disks=0;
163   #if defined(LINUX) || defined (SOLARIS) || defined(CYGWIN) || defined(HPUX)
164          FILE *f;
# Line 132 | Line 172 | sg_fs_stats *sg_get_fs_stats(int *entries){
172   #endif
173   #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
174          struct mntent *mp;
175 <        struct statfs fs;
175 >        struct statvfs fs;
176   #endif
177   #ifdef ALLBSD
178          int nummnt;
179   #ifdef HAVE_STATVFS
180 <        struct statvfs *mp;
180 >        struct statvfs *mp, **fs;
181   #else
182 <        struct statfs *mp;
182 >        struct statfs *mp, **fs;
183   #endif
184   #endif
185  
186   #ifdef ALLBSD
187 <        nummnt=getmntinfo(&mp , MNT_LOCAL);
187 >        nummnt=getmntinfo(&mp, MNT_WAIT);
188          if (nummnt<=0){
189                  sg_set_error_with_errno(SG_ERROR_GETMNTINFO, NULL);
190                  return NULL;
191          }
192 <        for(;nummnt--; mp++){
153 <                valid_type = is_valid_fs_type(mp->f_fstypename);
192 >        for(fs = &mp; nummnt--; (*fs)++){
193   #endif
194  
195   #if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
# Line 164 | Line 203 | sg_fs_stats *sg_get_fs_stats(int *entries){
203          }
204  
205          while((mp=getmntent(f))){
206 <                if((statfs(mp->mnt_dir, &fs)) !=0){
206 >                if((statvfs(mp->mnt_dir, &fs)) !=0){
207                          continue;
208                  }      
209  
171 –                valid_type = is_valid_fs_type(mp->mnt_type);
210   #endif
211  
212   #ifdef SOLARIS
# Line 180 | Line 218 | sg_fs_stats *sg_get_fs_stats(int *entries){
218                  if ((statvfs(mp.mnt_mountp, &fs)) !=0){
219                          continue;
220                  }
183 –                valid_type = is_valid_fs_type(mp.mnt_fstype);
221   #endif
222  
223 <                if(valid_type){
223 >                if(is_valid_fs_type(SG_MP_FSTYPENAME(mp))){
224                          if (VECTOR_RESIZE(disk_stats, num_disks + 1) < 0) {
225                                  return NULL;
226                          }
227                          disk_ptr=disk_stats+num_disks;
228  
192 – #ifdef ALLBSD
193 –                        if (sg_update_string(&disk_ptr->device_name, mp->f_mntfromname) < 0) {
194 –                                return NULL;
195 –                        }
196 –                        if (sg_update_string(&disk_ptr->fs_type, mp->f_fstypename) < 0) {
197 –                                return NULL;
198 –                        }
199 –                        if (sg_update_string(&disk_ptr->mnt_point, mp->f_mntonname) < 0) {
200 –                                return NULL;
201 –                        }
202 –
203 –                        disk_ptr->size = (long long)mp->f_bsize * (long long) mp->f_blocks;
204 –                        disk_ptr->avail = (long long)mp->f_bsize * (long long) mp->f_bavail;
205 –                        disk_ptr->used = (disk_ptr->size) - ((long long)mp->f_bsize * (long long)mp->f_bfree);
206 –
207 –                        disk_ptr->total_inodes=(long long)mp->f_files;
208 –                        disk_ptr->free_inodes=(long long)mp->f_ffree;
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) || defined(HPUX)
213 –                        if (sg_update_string(&disk_ptr->device_name, mp->mnt_fsname) < 0) {
214 –                                return NULL;
215 –                        }
216 –                                
217 –                        if (sg_update_string(&disk_ptr->fs_type, mp->mnt_type) < 0) {  
218 –                                return NULL;
219 –                        }
220 –
221 –                        if (sg_update_string(&disk_ptr->mnt_point, mp->mnt_dir) < 0) {
222 –                                return NULL;
223 –                        }
224 –                        disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
225 –                        disk_ptr->avail = (long long)fs.f_bsize * (long long)fs.f_bavail;
226 –                        disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_bsize * (long long)fs.f_bfree);
227 –
228 –                        disk_ptr->total_inodes=(long long)fs.f_files;
229 –                        disk_ptr->free_inodes=(long long)fs.f_ffree;
230 –                        /* Linux doesn't have a "available" inodes */
231 –                        disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
232 – #endif
233 –
234 – #ifdef SOLARIS
229                          /* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
230                           * Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
231                           * be upwards of a k each
232                           */
233 <                        if (sg_update_string(&disk_ptr->device_name, mp.mnt_special) < 0) {
233 >                        if (sg_update_string(&disk_ptr->device_name, SG_MP_DEVNAME(mp)) < 0) {
234                                  return NULL;
235                          }
236 <
243 <                        if (sg_update_string(&disk_ptr->fs_type, mp.mnt_fstype) < 0) {
236 >                        if (sg_update_string(&disk_ptr->fs_type, SG_MP_FSTYPENAME(mp)) < 0) {
237                                  return NULL;
238                          }
239 <        
247 <                        if (sg_update_string(&disk_ptr->mnt_point, mp.mnt_mountp) < 0) {
239 >                        if (sg_update_string(&disk_ptr->mnt_point, SG_MP_MOUNTP(mp)) < 0) {
240                                  return NULL;
241                          }
242 <                        
243 <                        disk_ptr->size = (long long)fs.f_frsize * (long long)fs.f_blocks;
244 <                        disk_ptr->avail = (long long)fs.f_frsize * (long long)fs.f_bavail;
245 <                        disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_frsize * (long long)fs.f_bfree);
246 <                
247 <                        disk_ptr->total_inodes=(long long)fs.f_files;
248 <                        disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
249 <                        disk_ptr->free_inodes=(long long)fs.f_favail;
250 < #endif
242 >
243 >                        disk_ptr->size  = SG_FS_FRSIZE(fs) * SG_FS_BLOCKS(fs);
244 >                        disk_ptr->avail = SG_FS_FRSIZE(fs) * SG_FS_BAVAIL(fs);
245 >                        disk_ptr->used  = (disk_ptr->size) - (SG_FS_FRSIZE(fs) * SG_FS_BFREE(fs));
246 >
247 >                        disk_ptr->total_inodes = SG_FS_FILES(fs);
248 >                        disk_ptr->free_inodes  = SG_FS_FFREE(fs);
249 >                        /* Linux, FreeBSD don't have a "available" inodes */
250 >                        disk_ptr->used_inodes  = disk_ptr->total_inodes - disk_ptr->free_inodes;
251 >                        disk_ptr->avail_inodes = SG_FS_FAVAIL(fs);
252 >
253 >                        disk_ptr->io_size      = SG_FS_BSIZE(fs);
254 >                        disk_ptr->block_size   = SG_FS_FRSIZE(fs);
255 >                        disk_ptr->total_blocks = SG_FS_BLOCKS(fs);
256 >                        disk_ptr->free_blocks  = SG_FS_BFREE(fs);
257 >                        disk_ptr->avail_blocks = SG_FS_BAVAIL(fs);
258 >                        disk_ptr->used_blocks  = disk_ptr->total_blocks - disk_ptr->free_blocks;
259 >
260                          num_disks++;
261                  }
262          }
# Line 338 | Line 339 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
339          int i, n;
340          time_t now;
341          const char *format;
342 +        static regex_t not_part_re, part_re;
343 +        static int re_compiled = 0;
344   #endif
345   #if defined(FREEBSD) || defined(DFBSD)
346          static struct statinfo stats;
# Line 699 | Line 702 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
702          if (f == NULL) goto out;
703          now = time(NULL);
704  
705 +        if (!re_compiled) {
706 +                if (regcomp(&part_re, "^(.*/)?[^/]*[0-9]$", REG_EXTENDED | REG_NOSUB) != 0) {
707 +                        sg_set_error(SG_ERROR_PARSE, NULL);
708 +                        goto out;
709 +                }
710 +                if (regcomp(&not_part_re, "^(.*/)?[^/0-9]+[0-9]+d[0-9]+$", REG_EXTENDED | REG_NOSUB) != 0) {
711 +                        sg_set_error(SG_ERROR_PARSE, NULL);
712 +                        goto out;
713 +                }
714 +                re_compiled = 1;
715 +        }
716 +
717          while ((line_ptr = sg_f_read_line(f, "")) != NULL) {
718                  char name[100];
704 –                char *s;
719                  long long rsect, wsect;
720  
721                  int nr = sscanf(line_ptr, format,
# Line 709 | Line 723 | sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
723                  if (nr < 3) continue;
724  
725                  /* Skip device names ending in numbers, since they're
726 <                   partitions. */
727 <                s = name;
728 <                while (*s != '\0') s++;
729 <                --s;
730 <                if (*s >= '0' && *s <= '9') continue;
726 >                   partitions, unless they match the c0d0 pattern that some
727 >                   RAID devices use. */
728 >                /* FIXME: For 2.6+, we should probably be using sysfs to detect
729 >                   this... */
730 >                if ((regexec(&part_re, name, 0, NULL, 0) == 0)
731 >                    && (regexec(&not_part_re, name, 0, NULL, 0) != 0)) {
732 >                        continue;
733 >                }
734  
735                  if (nr < 5) {
736                          has_pp_stats = 0;

Diff Legend

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