lib/fsusage.c

   1 /* fsusage.c -- return space usage of mounted filesystems
   2    Copyright (C) 1991, 1992 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include "fsusage.h"
  25 #include "safe-stat.h"
  26
  27 int statfs ();
  28
  29 #ifdef HAVE_SYS_PARAM_H
  30 #include <sys/param.h>
  31 #endif
  32
  33 #ifdef HAVE_SYS_MOUNT_H
  34 #include <sys/mount.h>
  35 #endif
  36
  37 #ifdef HAVE_SYS_VFS_H
  38 #include <sys/vfs.h>
  39 #endif
  40
  41 #ifdef HAVE_SYS_FILSYS_H
  42 #include <sys/filsys.h>         /* SVR2.  */
  43 #endif
  44
  45 #ifdef HAVE_FCNTL_H
  46 #include <fcntl.h>
  47 #endif
  48
  49 #ifdef HAVE_SYS_STATFS_H
  50 #include <sys/statfs.h>
  51 #endif
  52
  53 #ifdef HAVE_DUSTAT_H            /* AIX PS/2.  */
  54 #include <sys/dustat.h>
  55 #endif
  56
  57 #ifdef HAVE_SYS_STATVFS_H       /* SVR4.  */
  58 #include <sys/statvfs.h>
  59 int statvfs ();
  60 #endif
  61
  62 /* Return the number of TOSIZE-byte blocks used by
  63    BLOCKS FROMSIZE-byte blocks, rounding away from zero.
  64    TOSIZE must be positive.  Return -1 if FROMSIZE is not positive.  */
  65
  66 static long
  67 adjust_blocks (blocks, fromsize, tosize)
  68      long blocks;
  69      int fromsize, tosize;
  70 {
  71   if (tosize <= 0)
  72     abort ();
  73   if (fromsize <= 0)
  74     return -1;
  75
  76   if (fromsize == tosize)       /* E.g., from 512 to 512.  */
  77     return blocks;
  78   else if (fromsize > tosize)   /* E.g., from 2048 to 512.  */
  79     return blocks * (fromsize / tosize);
  80   else                          /* E.g., from 256 to 512.  */
  81     return (blocks + (blocks < 0 ? -1 : 1)) / (tosize / fromsize);
  82 }
  83
  84 /* Fill in the fields of FSP with information about space usage for
  85    the filesystem on which PATH resides.
  86    DISK is the device on which PATH is mounted, for space-getting
  87    methods that need to know it.
  88    Return 0 if successful, -1 if not. */
  89
  90 int
  91 get_fs_usage (path, disk, fsp)
  92      char *path, *disk;
  93      struct fs_usage *fsp;
  94 {
  95 #if defined (STAT_STATFS3_OSF1)
  96   struct statfs fsd;
  97
  98   if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
  99     return -1;
 100 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_fsize, 512)
 101 #endif /* STAT_STATFS3_OSF1 */
 102
 103 #ifdef STAT_STATFS2_FS_DATA     /* Ultrix.  */
 104   struct fs_data fsd;
 105
 106   if (statfs (path, &fsd) != 1)
 107     return -1;
 108 #define CONVERT_BLOCKS(b) adjust_blocks ((b), 1024, 512)
 109   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.fd_req.btot);
 110   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.fd_req.bfree);
 111   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.fd_req.bfreen);
 112   fsp->fsu_files = fsd.fd_req.gtot;
 113   fsp->fsu_ffree = fsd.fd_req.gfree;
 114 #endif
 115
 116 #ifdef STAT_READ_FILSYS         /* SVR2.  */
 117 #ifndef SUPERBOFF
 118 #define SUPERBOFF (SUPERB * 512)
 119 #endif
 120   struct filsys fsd;
 121   int fd;
 122
 123   fd = open (disk, O_RDONLY);
 124   if (fd < 0)
 125     return -1;
 126   lseek (fd, (long) SUPERBOFF, 0);
 127   if (read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
 128     {
 129       close (fd);
 130       return -1;
 131     }
 132   close (fd);
 133 #define CONVERT_BLOCKS(b) adjust_blocks ((b), (fsd.s_type == Fs2b ? 1024 : 512), 512)
 134   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.s_fsize);
 135   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.s_tfree);
 136   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.s_tfree);
 137   fsp->fsu_files = (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1);
 138   fsp->fsu_ffree = fsd.s_tinode;
 139 #endif
 140
 141 #ifdef STAT_STATFS2_BSIZE       /* 4.3BSD, SunOS 4, HP-UX, AIX.  */
 142   struct statfs fsd;
 143
 144   if (statfs (path, &fsd) < 0)
 145     return -1;
 146 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_bsize, 512)
 147 #endif
 148
 149 #ifdef STAT_STATFS2_FSIZE       /* 4.4BSD.  */
 150   struct statfs fsd;
 151
 152   if (statfs (path, &fsd) < 0)
 153     return -1;
 154 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_fsize, 512)
 155 #endif
 156
 157 #ifdef STAT_STATFS4             /* SVR3, Dynix, Irix, AIX.  */
 158   struct statfs fsd;
 159
 160   if (statfs (path, &fsd, sizeof fsd, 0) < 0)
 161     return -1;
 162   /* Empirically, the block counts on most SVR3 and SVR3-derived
 163      systems seem to always be in terms of 512-byte blocks,
 164      no matter what value f_bsize has.  */
 165 # if _AIX
 166 #  define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_bsize, 512)
 167 # else
 168 #  define CONVERT_BLOCKS(b) (b)
 169 #  ifndef _SEQUENT_             /* _SEQUENT_ is DYNIX/ptx.  */
 170 #   ifndef DOLPHIN              /* DOLPHIN 3.8.alfa/7.18 has f_bavail */
 171 #    define f_bavail f_bfree
 172 #   endif
 173 #  endif
 174 # endif
 175 #endif
 176
 177 #ifdef STAT_STATVFS             /* SVR4.  */
 178   struct statvfs fsd;
 179
 180   if (statvfs (path, &fsd) < 0)
 181     return -1;
 182   /* f_frsize isn't guaranteed to be supported.  */
 183 #define CONVERT_BLOCKS(b) \
 184   adjust_blocks ((b), fsd.f_frsize ? fsd.f_frsize : fsd.f_bsize, 512)
 185 #endif
 186
 187 #if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS) /* !Ultrix && !SVR2.  */
 188   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks);
 189   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree);
 190   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail);
 191   fsp->fsu_files = fsd.f_files;
 192   fsp->fsu_ffree = fsd.f_ffree;
 193 #endif
 194
 195   return 0;
 196 }
 197
 198 #if defined(_AIX) && defined(_I386)
 199 /* AIX PS/2 does not supply statfs.  */
 200
 201 int
 202 statfs (path, fsb)
 203      char *path;
 204      struct statfs *fsb;
 205 {
 206   struct stat stats;
 207   struct dustat fsd;
 208
 209   if (SAFE_STAT (path, &stats))
 210     return -1;
 211   if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
 212     return -1;
 213   fsb->f_type   = 0;
 214   fsb->f_bsize  = fsd.du_bsize;
 215   fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
 216   fsb->f_bfree  = fsd.du_tfree;
 217   fsb->f_bavail = fsd.du_tfree;
 218   fsb->f_files  = (fsd.du_isize - 2) * fsd.du_inopb;
 219   fsb->f_ffree  = fsd.du_tinode;
 220   fsb->f_fsid.val[0] = fsd.du_site;
 221   fsb->f_fsid.val[1] = fsd.du_pckno;
 222   return 0;
 223 }
 224 #endif /* _AIX && _I386 */