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.56 by ats, Sun Apr 4 22:18:38 2004 UTC vs.
Revision 1.60 by ats, Mon Apr 5 00:07:37 2004 UTC

# Line 31 | Line 31
31   #include <time.h>
32   #include "statgrab.h"
33   #include "vector.h"
34 + #include "tools.h"
35  
36   #ifdef SOLARIS
37   #include <sys/mnttab.h>
# Line 42 | Line 43
43   #if defined(LINUX) || defined(CYGWIN)
44   #include <mntent.h>
45   #include <sys/vfs.h>
45 – #include "tools.h"
46   #endif
47  
48   #ifdef LINUX
# Line 76 | Line 76
76                          "ntfs"}
77   #endif
78  
79 – char *copy_string(char *orig_ptr, const char *newtext){
80 –
81 –        /* Maybe free if not NULL, and strdup rather than realloc and strcpy? */
82 –        orig_ptr=realloc(orig_ptr, (1+strlen(newtext)));
83 –        if(orig_ptr==NULL){
84 –                return NULL;
85 –        }
86 –        strcpy(orig_ptr, newtext);
87 –
88 –        return orig_ptr;
89 – }
90 –
79   static void disk_stat_init(disk_stat_t *d) {
80          d->device_name = NULL;
81          d->fs_type = NULL;
# Line 177 | Line 165 | disk_stat_t *get_disk_stats(int *entries){
165                          disk_ptr=disk_stats+num_disks;
166  
167   #ifdef ALLBSD
168 <                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->f_mntfromname))==NULL){
168 >                        if (update_string(&disk_ptr->device_name, mp->f_mntfromname) == NULL) {
169                                  return NULL;
170                          }
171 <
184 <                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->f_fstypename))==NULL){
171 >                        if (update_string(&disk_ptr->fs_type, mp->f_fstypename) == NULL) {
172                                  return NULL;
173                          }
174 <
188 <                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->f_mntonname))==NULL){
174 >                        if (update_string(&disk_ptr->mnt_point, mp->f_mntonname) == NULL) {
175                                  return NULL;
176                          }
177  
# Line 199 | Line 185 | disk_stat_t *get_disk_stats(int *entries){
185                          disk_ptr->used_inodes=disk_ptr->total_inodes-disk_ptr->free_inodes;
186   #endif
187   #if defined(LINUX) || defined(CYGWIN)
188 <                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp->mnt_fsname))==NULL){
188 >                        if (update_string(&disk_ptr->device_name, mp->mnt_fsname) == NULL) {
189                                  return NULL;
190                          }
191                                  
192 <                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp->mnt_type))==NULL){    
192 >                        if (update_string(&disk_ptr->fs_type, mp->mnt_type) == NULL) {  
193                                  return NULL;
194                          }
195  
196 <                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp->mnt_dir))==NULL){
196 >                        if (update_string(&disk_ptr->mnt_point, mp->mnt_dir) == NULL) {
197                                  return NULL;
198                          }
199                          disk_ptr->size = (long long)fs.f_bsize * (long long)fs.f_blocks;
# Line 221 | Line 207 | disk_stat_t *get_disk_stats(int *entries){
207   #endif
208  
209   #ifdef SOLARIS
224 –                        /* Memory leak in event of realloc failing */
210                          /* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
211                           * Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
212                           * be upwards of a k each
213                           */
214 <                        if((disk_ptr->device_name=copy_string(disk_ptr->device_name, mp.mnt_special))==NULL){
214 >                        if (update_string(&disk_ptr->device_name, mp.mnt_special) == NULL) {
215                                  return NULL;
216                          }
217  
218 <                        if((disk_ptr->fs_type=copy_string(disk_ptr->fs_type, mp.mnt_fstype))==NULL){
218 >                        if (update_string(&disk_ptr->fs_type, mp.mnt_fstype) == NULL) {
219                                  return NULL;
220                          }
221          
222 <                        if((disk_ptr->mnt_point=copy_string(disk_ptr->mnt_point, mp.mnt_mountp))==NULL){
222 >                        if (update_string(&disk_ptr->mnt_point, mp.mnt_mountp) == NULL) {
223                                  return NULL;
224                          }
225                          
# Line 299 | Line 284 | diskio_stat_t *get_diskio_stats(int *entries){
284          char *line_ptr;
285          int major, minor;
286          int has_pp_stats = 1;
287 <        static partition *parts = NULL;
303 <        static int alloc_parts = 0;
287 >        VECTOR_DECLARE_STATIC(parts, partition, 16, NULL, NULL);
288          int i, n;
289          time_t now;
290          const char *format;
# Line 396 | Line 380 | diskio_stat_t *get_diskio_stats(int *entries){
380          }
381  
382          for (i = 0; i < num_disks; i++) {
383 +                const char *name;
384                  u_int64_t rbytes, wbytes;
385  
386   #ifdef NETBSD
# Line 422 | Line 407 | diskio_stat_t *get_diskio_stats(int *entries){
407                  
408                  diskio_stats_ptr->read_bytes = rbytes;
409                  diskio_stats_ptr->write_bytes = wbytes;
425 –                if (diskio_stats_ptr->disk_name != NULL) {
426 –                        free(diskio_stats_ptr->disk_name);
427 –                }
410   #ifdef NETBSD
411 <                diskio_stats_ptr->disk_name = strdup(stats[i].dk_name);
411 >                name = stats[i].dk_name;
412   #else
413 <                diskio_stats_ptr->disk_name = strdup(dk_name[i]);
413 >                name = dk_name[i];
414   #endif
415 +                if (update_string(&diskio_stats_ptr->disk_name, name) == NULL) {
416 +                        return NULL;
417 +                }
418                  diskio_stats_ptr->systime = time(NULL);
419          
420                  num_diskio++;  
# Line 491 | Line 476 | diskio_stat_t *get_diskio_stats(int *entries){
476                  diskio_stats_ptr->write_bytes=dev_ptr->bytes_written;
477   #endif
478                  if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
479 <                asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number);
479 >                if (asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number) == -1) {
480 >                        return NULL;
481 >                }
482                  diskio_stats_ptr->systime=time(NULL);
483  
484                  num_diskio++;
# Line 520 | Line 507 | diskio_stat_t *get_diskio_stats(int *entries){
507                          diskio_stats_ptr=diskio_stats+num_diskio;
508                          
509                          diskio_stats_ptr->read_bytes=kios.nread;
523 –                        
510                          diskio_stats_ptr->write_bytes=kios.nwritten;
511 <
512 <                        if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
513 <
514 <                        diskio_stats_ptr->disk_name=strdup((char *) get_svr_from_bsd(ksp->ks_name));
511 >                        if (update_string(&diskio_stats_ptr->disk_name,
512 >                                          get_svr_from_bsd(ksp->ks_name)) == NULL) {
513 >                                return NULL;
514 >                        }
515                          diskio_stats_ptr->systime=time(NULL);
516 +
517                          num_diskio++;
518                  }
519          }
# Line 577 | Line 564 | diskio_stat_t *get_diskio_stats(int *entries){
564                  if (VECTOR_RESIZE(diskio_stats, n + 1) < 0) {
565                          goto out;
566                  }
567 <                if (n >= alloc_parts) {
568 <                        alloc_parts += 16;
582 <                        parts = realloc(parts, alloc_parts * sizeof *parts);
583 <                        if (parts == NULL) {
584 <                                alloc_parts = 0;
585 <                                goto out;
586 <                        }
567 >                if (VECTOR_RESIZE(parts, n + 1) < 0) {
568 >                        goto out;
569                  }
570  
571 <                if (diskio_stats[n].disk_name != NULL)
572 <                        free(diskio_stats[n].disk_name);
573 <                diskio_stats[n].disk_name = strdup(name);
571 >                if (update_string(&diskio_stats[n].disk_name, name) == NULL) {
572 >                        goto out;
573 >                }
574                  diskio_stats[n].read_bytes = rsect * 512;
575                  diskio_stats[n].write_bytes = wsect * 512;
576                  diskio_stats[n].systime = now;
# Line 704 | Line 686 | diskio_stat_t *get_diskio_stats_diff(int *entries){
686                  src = &diskio_stats[i];
687                  dest = &diff[i];
688  
689 <                if (dest->disk_name != NULL) {
690 <                        free(dest->disk_name);
689 >                if (update_string(&dest->disk_name, src->disk_name) == NULL) {
690 >                        return NULL;
691                  }
710 –                dest->disk_name = strdup(src->disk_name);
692                  dest->read_bytes = src->read_bytes;
693                  dest->write_bytes = src->write_bytes;
694                  dest->systime = src->systime;

Diff Legend

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