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
  26 int statfs ();
  27
  28 #ifdef HAVE_SYS_PARAM_H
  29 #include <sys/param.h>
  30 #endif
  31
  32 #ifdef HAVE_SYS_MOUNT_H
  33 #include <sys/mount.h>
  34 #endif
  35
  36 #ifdef HAVE_SYS_VFS_H
  37 #include <sys/vfs.h>
  38 #endif
  39
  40 #ifdef HAVE_SYS_FILSYS_H
  41 #include <sys/filsys.h>         /* SVR2.  */
  42 #endif
  43
  44 #ifdef HAVE_FCNTL_H
  45 #include <fcntl.h>
  46 #endif
  47
  48 #ifdef HAVE_SYS_STATFS_H
  49 #include <sys/statfs.h>
  50 #endif
  51
  52 #ifdef HAVE_DUSTAT_H            /* AIX PS/2.  */
  53 #include <sys/dustat.h>
  54 #endif
  55
  56 #ifdef HAVE_SYS_STATVFS_H       /* SVR4.  */
  57 #include <sys/statvfs.h>
  58 int statvfs ();
  59 #endif
  60
  61 int safe_read ();
  62
  63 /* Return the number of TOSIZE-byte blocks used by
  64    BLOCKS FROMSIZE-byte blocks, rounding away from zero.
  65    TOSIZE must be positive.  Return -1 if FROMSIZE is not positive.  */
  66
  67 static long
  68 adjust_blocks (blocks, fromsize, tosize)
  69      long blocks;
  70      int fromsize, tosize;
  71 {
  72   if (tosize <= 0)
  73     abort ();
  74   if (fromsize <= 0)
  75     return -1;
  76
  77   if (fromsize == tosize)       /* E.g., from 512 to 512.  */
  78     return blocks;
  79   else if (fromsize > tosize)   /* E.g., from 2048 to 512.  */
  80     return blocks * (fromsize / tosize);
  81   else                          /* E.g., from 256 to 512.  */
  82     return (blocks + (blocks < 0 ? -1 : 1)) / (tosize / fromsize);
  83 }
  84
  85 /* Fill in the fields of FSP with information about space usage for
  86    the filesystem on which PATH resides.
  87    DISK is the device on which PATH is mounted, for space-getting
  88    methods that need to know it.
  89    Return 0 if successful, -1 if not. */
  90
  91 int
  92 get_fs_usage (path, disk, fsp)
  93      char *path, *disk;
  94      struct fs_usage *fsp;
  95 {
  96 #if defined (STAT_STATFS3_OSF1)
  97   struct statfs fsd;
  98
  99   if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
 100     return -1;
 101 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_fsize, 512)
 102 #endif /* STAT_STATFS3_OSF1 */
 103
 104 #ifdef STAT_STATFS2_FS_DATA     /* Ultrix.  */
 105   struct fs_data fsd;
 106
 107   if (statfs (path, &fsd) != 1)
 108     return -1;
 109 #define CONVERT_BLOCKS(b) adjust_blocks ((b), 1024, 512)
 110   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.fd_req.btot);
 111   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.fd_req.bfree);
 112   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.fd_req.bfreen);
 113   fsp->fsu_files = fsd.fd_req.gtot;
 114   fsp->fsu_ffree = fsd.fd_req.gfree;
 115 #endif
 116
 117 #ifdef STAT_READ_FILSYS         /* SVR2.  */
 118 #ifndef SUPERBOFF
 119 #define SUPERBOFF (SUPERB * 512)
 120 #endif
 121   struct filsys fsd;
 122   int fd;
 123
 124   fd = open (disk, O_RDONLY);
 125   if (fd < 0)
 126     return -1;
 127   lseek (fd, (long) SUPERBOFF, 0);
 128   if (safe_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
 129     {
 130       close (fd);
 131       return -1;
 132     }
 133   close (fd);
 134 #define CONVERT_BLOCKS(b) adjust_blocks ((b), (fsd.s_type == Fs2b ? 1024 : 512), 512)
 135   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.s_fsize);
 136   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.s_tfree);
 137   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.s_tfree);
 138   fsp->fsu_files = (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1);
 139   fsp->fsu_ffree = fsd.s_tinode;
 140 #endif
 141
 142 #ifdef STAT_STATFS2_BSIZE       /* 4.3BSD, SunOS 4, HP-UX, AIX.  */
 143   struct statfs fsd;
 144
 145   if (statfs (path, &fsd) < 0)
 146     return -1;
 147
 148 #ifdef STATFS_TRUNCATES_BLOCK_COUNTS
 149   /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
 150      struct statfs are truncated to 2GB.  These conditions detect that
 151      truncation, presumably without botching the 4.1.1 case, in which
 152      the values are not truncated.  The correct counts are stored in
 153      undocumented spare fields.  */
 154   if (fsd.f_blocks == 0x1fffff && fsd.f_spare[0] > 0)
 155     {
 156       fsd.f_blocks = fsd.f_spare[0];
 157       fsd.f_bfree = fsd.f_spare[1];
 158       fsd.f_bavail = fsd.f_spare[2];
 159     }
 160 #endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
 161
 162 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_bsize, 512)
 163 #endif
 164
 165 #ifdef STAT_STATFS2_FSIZE       /* 4.4BSD.  */
 166   struct statfs fsd;
 167
 168   if (statfs (path, &fsd) < 0)
 169     return -1;
 170 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_fsize, 512)
 171 #endif
 172
 173 #ifdef STAT_STATFS4             /* SVR3, Dynix, Irix, AIX.  */
 174   struct statfs fsd;
 175
 176   if (statfs (path, &fsd, sizeof fsd, 0) < 0)
 177     return -1;
 178   /* Empirically, the block counts on most SVR3 and SVR3-derived
 179      systems seem to always be in terms of 512-byte blocks,
 180      no matter what value f_bsize has.  */
 181 # if _AIX
 182 #  define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_bsize, 512)
 183 # else
 184 #  define CONVERT_BLOCKS(b) (b)
 185 #  ifndef _SEQUENT_             /* _SEQUENT_ is DYNIX/ptx.  */
 186 #   ifndef DOLPHIN              /* DOLPHIN 3.8.alfa/7.18 has f_bavail */
 187 #    define f_bavail f_bfree
 188 #   endif
 189 #  endif
 190 # endif
 191 #endif
 192
 193 #ifdef STAT_STATVFS             /* SVR4.  */
 194   struct statvfs fsd;
 195
 196   if (statvfs (path, &fsd) < 0)
 197     return -1;
 198   /* f_frsize isn't guaranteed to be supported.  */
 199 #define CONVERT_BLOCKS(b) \
 200   adjust_blocks ((b), fsd.f_frsize ? fsd.f_frsize : fsd.f_bsize, 512)
 201 #endif
 202
 203 #if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS) /* !Ultrix && !SVR2.  */
 204   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks);
 205   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree);
 206   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail);
 207   fsp->fsu_files = fsd.f_files;
 208   fsp->fsu_ffree = fsd.f_ffree;
 209 #endif
 210
 211   return 0;
 212 }
 213
 214 #if defined(_AIX) && defined(_I386)
 215 /* AIX PS/2 does not supply statfs.  */
 216
 217 int
 218 statfs (path, fsb)
 219      char *path;
 220      struct statfs *fsb;
 221 {
 222   struct stat stats;
 223   struct dustat fsd;
 224
 225   if (stat (path, &stats))
 226     return -1;
 227   if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
 228     return -1;
 229   fsb->f_type   = 0;
 230   fsb->f_bsize  = fsd.du_bsize;
 231   fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
 232   fsb->f_bfree  = fsd.du_tfree;
 233   fsb->f_bavail = fsd.du_tfree;
 234   fsb->f_files  = (fsd.du_isize - 2) * fsd.du_inopb;
 235   fsb->f_ffree  = fsd.du_tinode;
 236   fsb->f_fsid.val[0] = fsd.du_site;
 237   fsb->f_fsid.val[1] = fsd.du_pckno;
 238   return 0;
 239 }
 240 #endif /* _AIX && _I386 */