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.4 by pajs, Sun Feb 23 19:24:07 2003 UTC vs.
Revision 1.9 by pajs, Tue Mar 4 12:55:14 2003 UTC

# Line 22 | Line 22
22   #include "config.h"
23   #endif
24  
25 – #include "statgrab.h"
25   #include <stdlib.h>
27 – #include <stdio.h>
28 – #include "ukcprog.h"
26   #include <string.h>
27 + #include "statgrab.h"
28  
29   #ifdef SOLARIS
30 + #include <stdio.h>
31   #include <sys/mnttab.h>
33 – #include <sys/types.h>
32   #include <sys/statvfs.h>
33   #include <kstat.h>
36 –
34   #define VALID_FS_TYPES {"ufs", "tmpfs"}
35 + #endif
36  
37 + #ifdef LINUX
38 + #include <stdio.h>
39 + #include <sys/vfs.h>
40 + #include <mntent.h>
41 + #define VALID_FS_TYPES {"ext2", "ext3", "xfs", "reiserfs", "vfat", "tmpfs"}
42   #endif
43  
44   #define START_VAL 1
# Line 71 | Line 74 | disk_stat_t *get_disk_stats(int *entries){
74  
75          char *fs_types[] = VALID_FS_TYPES;
76          int x, valid_type;
74 –
77          int num_disks=0;
76 –        struct mnttab mp;
77 –        struct statvfs fs;
78          FILE *f;
79  
80          disk_stat_t *disk_ptr;
81  
82 + #ifdef SOLARIS
83 +        struct mnttab *mp;
84 +        struct statvfs fs;
85 + #endif
86 + #ifdef LINUX
87 +        struct mntent *mp;
88 +        struct statfs fs;
89 + #endif
90 +
91          if(watermark==-1){
92                  disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
93                  if(disk_stats==NULL){
# Line 87 | Line 96 | disk_stat_t *get_disk_stats(int *entries){
96                  watermark=START_VAL;
97                  init_disk_stat(0, watermark-1, disk_stats);
98          }
99 + #ifdef LINUX
100 +        if ((f=setmntent("/etc/mtab", "r" ))==NULL){
101 +                return NULL;
102 +        }
103  
104 +        while((mp=getmntent(f))){
105 +                if((statfs(mp->mnt_dir, &fs)) !=0){
106 +                        continue;
107 +                }      
108  
109 +                valid_type=0;
110 +                for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
111 +                        if(strcmp(mp->mnt_type, fs_types[x]) ==0){
112 +                                valid_type=1;
113 +                                break;
114 +                        }
115 +                }
116 + #endif
117 +
118 + #ifdef SOLARIS
119          if ((f=fopen("/etc/mnttab", "r" ))==NULL){
120                  return NULL;
121          }
# Line 96 | Line 123 | disk_stat_t *get_disk_stats(int *entries){
123                  if ((statvfs(mp.mnt_mountp, &fs)) !=0){
124                          continue;
125                  }
99 –
126                  valid_type=0;
127                  for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
128                          if(strcmp(mp.mnt_fstype, fs_types[x]) ==0){
# Line 104 | Line 130 | disk_stat_t *get_disk_stats(int *entries){
130                                  break;
131                          }
132                  }
133 + #endif
134  
135                  if(valid_type){
136                          if(num_disks>watermark-1){
# Line 118 | Line 145 | disk_stat_t *get_disk_stats(int *entries){
145                          }
146  
147                          disk_ptr=disk_stats+num_disks;
148 <        
148 > #ifdef LINUX
149 >                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
150 >                                return NULL;
151 >                        }
152 >                                
153 >                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){    
154 >                                return NULL;
155 >                        }
156 >
157 >                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){
158 >                                return NULL;
159 >                        }
160 >                        disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
161 >                        disk_ptr->avail = (long long)fs.f_bsize * (long long)fs.f_bavail;
162 >                        disk_ptr->used = (disk_ptr->size) - ((long long)fs.f_bsize * (long long)fs.f_bfree);
163 >
164 >                        disk_ptr->total_inodes=(long long)fs.f_files;
165 >                        disk_ptr->free_inodes=(long long)fs.f_ffree;
166 >                        /* Linux doesn't have a "available" inodes */
167 >                        disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
168 > #endif
169 >
170 > #ifdef SOLARIS
171                          /* Memory leak in event of realloc failing */
172                          /* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
173 <                           Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE woul prob be upwards
174 <                           of a k each */
173 >                         * Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
174 >                         * be upwards of a k each
175 >                         */
176                          if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
177                                  return NULL;
178                          }
# Line 142 | Line 192 | disk_stat_t *get_disk_stats(int *entries){
192                          disk_ptr->total_inodes=(long long)fs.f_files;
193                          disk_ptr->used_inodes=disk_ptr->total_inodes - (long long)fs.f_ffree;
194                          disk_ptr->free_inodes=(long long)fs.f_favail;
195 <
195 > #endif
196                          num_disks++;
197                  }
198          }
# Line 155 | Line 205 | disk_stat_t *get_disk_stats(int *entries){
205          return disk_stats;
206  
207   }
208 <
208 > #ifdef SOLARIS
209   void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){
210  
211          for(diskio_stats+=start; start<end; start++){
# Line 192 | Line 242 | diskio_stat_t *diskio_stat_malloc(int needed_entries,
242   }
243  
244   static diskio_stat_t *diskio_stats=NULL;        
245 + static int num_diskio=0;        
246  
247   diskio_stat_t *get_diskio_stats(int *entries){
248  
249          static int sizeof_diskio_stats=0;
199 –        int disks=0;    
250          diskio_stat_t *diskio_stats_ptr;
251  
252          kstat_ctl_t *kc;
# Line 207 | Line 257 | diskio_stat_t *get_diskio_stats(int *entries){
257                  return NULL;
258          }
259  
260 +        num_diskio=0;
261 +
262          for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
211 –                fflush(stdout);
263                  if (!strcmp(ksp->ks_class, "disk")) {
213 –                        fflush(stdout);
264  
265                          if(ksp->ks_type != KSTAT_TYPE_IO) continue;
266 <                        /* We dont want metadevices appearins as disks */
266 >                        /* We dont want metadevices appearins as num_diskio */
267                          if(strcmp(ksp->ks_module, "md")==0) continue;
268                          if((kstat_read(kc, ksp, &kios))==-1){  
219 –                                fflush(stdout);
269                          }
270                          
271 <                        if((diskio_stats=diskio_stat_malloc(disks+1, &sizeof_diskio_stats, diskio_stats))==NULL){
271 >                        if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
272                                  kstat_close(kc);
273                                  return NULL;
274                          }
275 <                        diskio_stats_ptr=diskio_stats+disks;
275 >                        diskio_stats_ptr=diskio_stats+num_diskio;
276                          
277                          diskio_stats_ptr->read_bytes=kios.nread;
278                          
# Line 232 | Line 281 | diskio_stat_t *get_diskio_stats(int *entries){
281                          if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
282  
283                          diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
284 <                        disks++;
236 <                        fflush(stdout);
284 >                        num_diskio++;
285                  }
286          }
287  
288          kstat_close(kc);
289  
290 <        *entries=disks;
290 >        *entries=num_diskio;
291  
292          return diskio_stats;
293   }
294 +
295 + diskio_stat_t *get_diskio_stats_diff(int *entries){
296 +        static diskio_stat_t *diskio_stats_diff=NULL;
297 +        static int sizeof_diskio_stats_diff=0;
298 +        diskio_stat_t *diskio_stats_diff_ptr, *diskio_stats_ptr;
299 +        int disks, x, y;
300 +
301 +        if(diskio_stats==NULL){
302 +                diskio_stats_ptr=get_diskio_stats(&disks);
303 +                *entries=disks;
304 +                return diskio_stats_ptr;
305 +        }
306 +
307 +        diskio_stats_diff=diskio_stat_malloc(num_diskio, &sizeof_diskio_stats_diff, diskio_stats_diff);
308 +        if(diskio_stats_diff==NULL){
309 +                return NULL;
310 +        }
311 +
312 +        diskio_stats_diff_ptr=diskio_stats_diff;
313 +        diskio_stats_ptr=diskio_stats;
314 +
315 +        for(disks=0;disks<num_diskio;disks++){
316 +                if(diskio_stats_diff_ptr->disk_name!=NULL){
317 +                        free(diskio_stats_diff_ptr->disk_name);
318 +                }
319 +                diskio_stats_diff_ptr->disk_name=strdup(diskio_stats_ptr->disk_name);
320 +                diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes;
321 +                diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes;
322 +                diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime;
323 +
324 +                diskio_stats_diff_ptr++;
325 +                diskio_stats_ptr++;
326 +        }
327 +
328 +        diskio_stats_ptr=get_diskio_stats(&disks);
329 +        diskio_stats_diff_ptr=diskio_stats_diff;
330 +
331 +        for(x=0;x<sizeof_diskio_stats_diff;x++){
332 +
333 +                if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
334 +                        diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
335 +                        diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
336 +                        diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
337 +                }else{
338 +                        diskio_stats_ptr=diskio_stats;
339 +                        for(y=0;y<disks;y++){
340 +                                if((strcmp(diskio_stats_diff_ptr->disk_name, diskio_stats_ptr->disk_name))==0){
341 +                                        diskio_stats_diff_ptr->read_bytes=diskio_stats_ptr->read_bytes-diskio_stats_diff_ptr->read_bytes;
342 +                                        diskio_stats_diff_ptr->write_bytes=diskio_stats_ptr->write_bytes-diskio_stats_diff_ptr->write_bytes;
343 +                                        diskio_stats_diff_ptr->systime=diskio_stats_ptr->systime-diskio_stats_diff_ptr->systime;
344 +
345 +                                        break;
346 +                                }
347 +                                
348 +                                diskio_stats_ptr++;
349 +                        }
350 +                }
351 +
352 +                diskio_stats_ptr++;
353 +                diskio_stats_diff_ptr++;        
354 +
355 +        }
356 +        
357 +        *entries=sizeof_diskio_stats_diff;
358 +        return diskio_stats_diff;
359 + }
360 + #endif

Diff Legend

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