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.9 by pajs, Tue Mar 4 12:55:14 2003 UTC vs.
Revision 1.16 by pajs, Fri Apr 4 14:25:26 2003 UTC

# Line 38 | Line 38
38   #include <stdio.h>
39   #include <sys/vfs.h>
40   #include <mntent.h>
41 + #include "tools.h"
42   #define VALID_FS_TYPES {"ext2", "ext3", "xfs", "reiserfs", "vfat", "tmpfs"}
43   #endif
44  
45 + #ifdef FREEBSD
46 + #include <sys/param.h>
47 + #include <sys/ucred.h>
48 + #include <sys/mount.h>
49 + #define VALID_FS_TYPES {"ufs", "mfs"}
50 + #endif
51   #define START_VAL 1
52  
53   char *copy_string(char *orig_ptr, const char *newtext){
# Line 75 | Line 82 | disk_stat_t *get_disk_stats(int *entries){
82          char *fs_types[] = VALID_FS_TYPES;
83          int x, valid_type;
84          int num_disks=0;
85 + #if defined(LINUX) || defined (SOLARIS)
86          FILE *f;
87 + #endif
88  
89          disk_stat_t *disk_ptr;
90  
91   #ifdef SOLARIS
92 <        struct mnttab *mp;
92 >        struct mnttab mp;
93          struct statvfs fs;
94   #endif
95   #ifdef LINUX
96          struct mntent *mp;
97          struct statfs fs;
98   #endif
99 + #ifdef FREEBSD
100 +        int nummnt;
101 +        struct statfs *mp;
102 + #endif
103  
104          if(watermark==-1){
105                  disk_stats=malloc(START_VAL * sizeof(disk_stat_t));
# Line 96 | Line 109 | disk_stat_t *get_disk_stats(int *entries){
109                  watermark=START_VAL;
110                  init_disk_stat(0, watermark-1, disk_stats);
111          }
112 + #ifdef FREEBSD
113 +        nummnt=getmntinfo(&mp , MNT_LOCAL);
114 +        if (nummnt<=0){
115 +                return NULL;
116 +        }
117 +        for(;nummnt--; mp++){
118 +                valid_type=0;
119 +                for(x=0;x<((sizeof(fs_types))/(sizeof(char*)));x++){
120 +                        if(strcmp(mp->f_fstypename, fs_types[x]) ==0){
121 +                                valid_type=1;
122 +                                break;
123 +                        }
124 +                }
125 + #endif
126 +
127   #ifdef LINUX
128          if ((f=setmntent("/etc/mtab", "r" ))==NULL){
129                  return NULL;
# Line 145 | Line 173 | disk_stat_t *get_disk_stats(int *entries){
173                          }
174  
175                          disk_ptr=disk_stats+num_disks;
176 + #ifdef FREEBSD
177 +                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->f_mntfromname))==NULL){
178 +                                return NULL;
179 +                        }
180 +
181 +                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->f_fstypename))==NULL){
182 +                                return NULL;
183 +                        }
184 +
185 +                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->f_mntonname))==NULL){
186 +                                return NULL;
187 +                        }
188 +
189 +                        disk_ptr->size = (long long)mp->f_bsize * (long long) mp->f_blocks;
190 +                        disk_ptr->avail = (long long)mp->f_bsize * (long long) mp->f_bavail;
191 +                        disk_ptr->used = (disk_ptr->size) - ((long long)mp->f_bsize * (long long)mp->f_bfree);
192 +
193 +                        disk_ptr->total_inodes=(long long)mp->f_files;
194 +                        disk_ptr->free_inodes=(long long)mp->f_ffree;
195 +                        /* Freebsd doesn't have a "available" inodes */
196 +                        disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
197 + #endif
198   #ifdef LINUX
199                          if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
200                                  return NULL;
# Line 200 | Line 250 | disk_stat_t *get_disk_stats(int *entries){
250          *entries=num_disks;    
251  
252          /* If this fails, there is very little i can do about it, so i'll ignore it :) */
253 + #if defined(LINUX) || defined(SOLARIS)
254          fclose(f);
255 + #endif
256  
257          return disk_stats;
258  
259   }
208 – #ifdef SOLARIS
260   void diskio_stat_init(int start, int end, diskio_stat_t *diskio_stats){
261  
262          for(diskio_stats+=start; start<end; start++){
# Line 249 | Line 300 | diskio_stat_t *get_diskio_stats(int *entries){
300          static int sizeof_diskio_stats=0;
301          diskio_stat_t *diskio_stats_ptr;
302  
303 + #ifdef SOLARIS
304          kstat_ctl_t *kc;
305          kstat_t *ksp;
306          kstat_io_t kios;
307 + #endif
308 + #ifdef LINUX
309 +        FILE *f;
310 +        char *line_ptr;
311 +        int major, minor;
312 +        char dev_letter;
313 + #endif
314 +        num_diskio=0;
315  
316 + #ifdef SOLARIS
317          if ((kc = kstat_open()) == NULL) {
318                  return NULL;
319          }
320  
260 –        num_diskio=0;
261 –
321          for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
322                  if (!strcmp(ksp->ks_class, "disk")) {
323  
# Line 281 | Line 340 | diskio_stat_t *get_diskio_stats(int *entries){
340                          if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
341  
342                          diskio_stats_ptr->disk_name=strdup(ksp->ks_name);
343 +                        diskio_stats_ptr->systime=time(NULL);
344                          num_diskio++;
345                  }
346          }
347  
348          kstat_close(kc);
349 + #endif
350  
351 + #ifdef LINUX
352 +        f=fopen("/proc/stat", "r");
353 +        if(f==NULL){
354 +                *entries=0;
355 +                fclose(f);
356 +                return NULL;
357 +        }
358 +        if((line_ptr=f_read_line(f, "disk_io:"))==NULL){
359 +                *entries=0;
360 +                fclose(f);
361 +                return NULL;
362 +        }
363 +        while((line_ptr=strchr(line_ptr, ' '))!=NULL){
364 +                line_ptr++;
365 +                if(*line_ptr=='\0'){
366 +                        break;
367 +                }
368 +                if((diskio_stats=diskio_stat_malloc(num_diskio+1, &sizeof_diskio_stats, diskio_stats))==NULL){
369 +                        fclose(f);
370 +                        *entries=0;
371 +                        return NULL;
372 +                }
373 +                diskio_stats_ptr=diskio_stats+num_diskio;
374 +
375 +
376 +                if((sscanf(line_ptr, "(%d,%d):(%*d, %*d, %lld, %*d, %lld)", \
377 +                        &major, \
378 +                        &minor, \
379 +                        &diskio_stats_ptr->read_bytes, \
380 +                        &diskio_stats_ptr->write_bytes))!=4) {
381 +                                continue;
382 +                }
383 +
384 +                /* We read the number of blocks. Blocks are stored in 512 bytes */
385 +                diskio_stats_ptr->read_bytes=diskio_stats_ptr->read_bytes*512;
386 +                diskio_stats_ptr->write_bytes=diskio_stats_ptr->write_bytes*512;
387 +
388 +                if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
389 +
390 +                switch(major){
391 +                        case 2:
392 +                                if(minor==0){
393 +                                        diskio_stats_ptr->disk_name=strdup("fd0");
394 +                                }
395 +                                break;
396 +
397 +                        case 3:
398 +                                if(minor==0){
399 +                                        diskio_stats_ptr->disk_name=strdup("hda");
400 +                                }else{
401 +                                        diskio_stats_ptr->disk_name=strdup("hdb");
402 +                                }
403 +                                break;
404 +
405 +                        case 22:
406 +                                if(minor==0){
407 +                                        diskio_stats_ptr->disk_name=strdup("hdc");
408 +                                }else{
409 +                                        diskio_stats_ptr->disk_name=strdup("hdd");
410 +                                }
411 +                                break;
412 +                        case 8:
413 +                                dev_letter='a'+(minor/16);
414 +                                diskio_stats_ptr->disk_name=malloc(4);
415 +                                snprintf(diskio_stats_ptr->disk_name, 4, "sd%c", dev_letter);
416 +                                break;
417 +                        default:
418 +                                /* I have no idea what it is then :) */
419 +                                diskio_stats_ptr->disk_name=malloc(16);
420 +                                snprintf(diskio_stats_ptr->disk_name, 16, "%d %d", major, minor);
421 +                                break;
422 +                }
423 +
424 +                diskio_stats_ptr->systime=time(NULL);
425 +                num_diskio++;
426 +        }
427 +
428 +        fclose(f);
429 +
430 + #endif
431          *entries=num_diskio;
432  
433          return diskio_stats;
# Line 357 | Line 498 | diskio_stat_t *get_diskio_stats_diff(int *entries){
498          *entries=sizeof_diskio_stats_diff;
499          return diskio_stats_diff;
500   }
360 – #endif

Diff Legend

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