lib/fsusage.c

   1 /* fsusage.c -- return space usage of mounted filesystems
   2    Copyright (C) 1991, 1992, 1996, 1998, 1999 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 Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #if HAVE_CONFIG_H
  19 # include <config.h>
  20 #endif
  21
  22 #if HAVE_INTTYPES_H
  23 # include <inttypes.h>
  24 #else
  25 # if HAVE_STDINT_H
  26 #  include <stdint.h>
  27 # endif
  28 #endif
  29 #ifndef UINTMAX_MAX
  30 # define UINTMAX_MAX ((uintmax_t) -1)
  31 #endif
  32
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include "fsusage.h"
  36
  37 #if HAVE_LIMITS_H
  38 # include <limits.h>
  39 #endif
  40 #ifndef CHAR_BIT
  41 # define CHAR_BIT 8
  42 #endif
  43
  44 int statfs ();
  45
  46 #if HAVE_SYS_PARAM_H
  47 # include <sys/param.h>
  48 #endif
  49
  50 #if HAVE_SYS_MOUNT_H
  51 # include <sys/mount.h>
  52 #endif
  53
  54 #if HAVE_SYS_VFS_H
  55 # include <sys/vfs.h>
  56 #endif
  57
  58 #if HAVE_SYS_FS_S5PARAM_H       /* Fujitsu UXP/V */
  59 # include <sys/fs/s5param.h>
  60 #endif
  61
  62 #if defined (HAVE_SYS_FILSYS_H) && !defined (_CRAY)
  63 # include <sys/filsys.h>        /* SVR2 */
  64 #endif
  65
  66 #if HAVE_FCNTL_H
  67 # include <fcntl.h>
  68 #endif
  69
  70 #if HAVE_SYS_STATFS_H
  71 # include <sys/statfs.h>
  72 #endif
  73
  74 #if HAVE_DUSTAT_H               /* AIX PS/2 */
  75 # include <sys/dustat.h>
  76 #endif
  77
  78 #if HAVE_SYS_STATVFS_H          /* SVR4 */
  79 # include <sys/statvfs.h>
  80 int statvfs ();
  81 #endif
  82
  83 /* Many space usage primitives use all 1 bits to denote a value that is
  84    not applicable or unknown.  Propagate this information by returning
  85    a uintmax_t value that is all 1 bits if X is all 1 bits, even if X
  86    is unsigned and narrower than uintmax_t.  */
  87 #define PROPAGATE_ALL_ONES(x) \
  88   ((sizeof (x) < sizeof (uintmax_t) \
  89     && (~ (x) == (sizeof (x) < sizeof (int) \
  90                   ? - (1 << (sizeof (x) * CHAR_BIT)) \
  91                   : 0))) \
  92    ? UINTMAX_MAX : (x))
  93
  94 /* Extract the top bit of X as an uintmax_t value.  */
  95 #define EXTRACT_TOP_BIT(x) ((x) \
  96                             & ((uintmax_t) 1 << (sizeof (x) * CHAR_BIT - 1)))
  97
  98 /* If a value is negative, many space usage primitives store it into an
  99    integer variable by assignment, even if the variable's type is unsigned.
 100    So, if a space usage variable X's top bit is set, convert X to the
 101    uintmax_t value V such that (- (uintmax_t) V) is the negative of
 102    the original value.  If X's top bit is clear, just yield X.
 103    Use PROPAGATE_TOP_BIT if the original value might be negative;
 104    otherwise, use PROPAGATE_ALL_ONES.  */
 105 #define PROPAGATE_TOP_BIT(x) ((x) | ~ (EXTRACT_TOP_BIT (x) - 1))
 106
 107 int safe_read ();
 108
 109 /* Fill in the fields of FSP with information about space usage for
 110    the filesystem on which PATH resides.
 111    DISK is the device on which PATH is mounted, for space-getting
 112    methods that need to know it.
 113    Return 0 if successful, -1 if not.  When returning -1, ensure that
 114    ERRNO is either a system error value, or zero if DISK is NULL
 115    on a system that requires a non-NULL value.  */
 116 int
 117 get_fs_usage (const char *path, const char *disk, struct fs_usage *fsp)
 118 {
 119 #ifdef STAT_STATFS3_OSF1
 120
 121   struct statfs fsd;
 122
 123   if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
 124     return -1;
 125
 126   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
 127
 128 #endif /* STAT_STATFS3_OSF1 */
 129
 130 #ifdef STAT_STATFS2_FS_DATA     /* Ultrix */
 131
 132   struct fs_data fsd;
 133
 134   if (statfs (path, &fsd) != 1)
 135     return -1;
 136
 137   fsp->fsu_blocksize = 1024;
 138   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.fd_req.btot);
 139   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.fd_req.bfree);
 140   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.fd_req.bfreen);
 141   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.fd_req.bfreen) != 0;
 142   fsp->fsu_files = PROPAGATE_ALL_ONES (fsd.fd_req.gtot);
 143   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.fd_req.gfree);
 144
 145 #endif /* STAT_STATFS2_FS_DATA */
 146
 147 #ifdef STAT_READ_FILSYS         /* SVR2 */
 148 # ifndef SUPERBOFF
 149 #  define SUPERBOFF (SUPERB * 512)
 150 # endif
 151
 152   struct filsys fsd;
 153   int fd;
 154
 155   if (! disk)
 156     {
 157       errno = 0;
 158       return -1;
 159     }
 160
 161   fd = open (disk, O_RDONLY);
 162   if (fd < 0)
 163     return -1;
 164   lseek (fd, (off_t) SUPERBOFF, 0);
 165   if (safe_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
 166     {
 167       close (fd);
 168       return -1;
 169     }
 170   close (fd);
 171
 172   fsp->fsu_blocksize = (fsd.s_type == Fs2b ? 1024 : 512);
 173   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.s_fsize);
 174   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.s_tfree);
 175   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.s_tfree);
 176   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.s_tfree) != 0;
 177   fsp->fsu_files = (fsd.s_isize == -1
 178                     ? UINTMAX_MAX
 179                     : (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1));
 180   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.s_tinode);
 181
 182 #endif /* STAT_READ_FILSYS */
 183
 184 #ifdef STAT_STATFS2_BSIZE       /* 4.3BSD, SunOS 4, HP-UX, AIX */
 185
 186   struct statfs fsd;
 187
 188   if (statfs (path, &fsd) < 0)
 189     return -1;
 190
 191   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
 192
 193 # ifdef STATFS_TRUNCATES_BLOCK_COUNTS
 194
 195   /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
 196      struct statfs are truncated to 2GB.  These conditions detect that
 197      truncation, presumably without botching the 4.1.1 case, in which
 198      the values are not truncated.  The correct counts are stored in
 199      undocumented spare fields.  */
 200   if (fsd.f_blocks == 0x7fffffff / fsd.f_bsize && fsd.f_spare[0] > 0)
 201     {
 202       fsd.f_blocks = fsd.f_spare[0];
 203       fsd.f_bfree = fsd.f_spare[1];
 204       fsd.f_bavail = fsd.f_spare[2];
 205     }
 206 # endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
 207
 208 #endif /* STAT_STATFS2_BSIZE */
 209
 210 #ifdef STAT_STATFS2_FSIZE       /* 4.4BSD */
 211
 212   struct statfs fsd;
 213
 214   if (statfs (path, &fsd) < 0)
 215     return -1;
 216
 217   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
 218
 219 #endif /* STAT_STATFS2_FSIZE */
 220
 221 #ifdef STAT_STATFS4             /* SVR3, Dynix, Irix, AIX */
 222
 223 # if !_AIX && !defined _SEQUENT_ && !defined DOLPHIN
 224 #  define f_bavail f_bfree
 225 # endif
 226
 227   struct statfs fsd;
 228
 229   if (statfs (path, &fsd, sizeof fsd, 0) < 0)
 230     return -1;
 231
 232   /* Empirically, the block counts on most SVR3 and SVR3-derived
 233      systems seem to always be in terms of 512-byte blocks,
 234      no matter what value f_bsize has.  */
 235 # if _AIX || defined(_CRAY)
 236    fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
 237 # else
 238    fsp->fsu_blocksize = 512;
 239 # endif
 240
 241 #endif /* STAT_STATFS4 */
 242
 243 #ifdef STAT_STATVFS             /* SVR4 */
 244
 245   struct statvfs fsd;
 246
 247   if (statvfs (path, &fsd) < 0)
 248     return -1;
 249
 250   /* f_frsize isn't guaranteed to be supported.  */
 251   fsp->fsu_blocksize = (fsd.f_frsize
 252                         ? PROPAGATE_ALL_ONES (fsd.f_frsize)
 253                         : PROPAGATE_ALL_ONES (fsd.f_bsize));
 254
 255 #endif /* STAT_STATVFS */
 256
 257 #if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS)
 258                                 /* !Ultrix && !SVR2 */
 259
 260   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.f_blocks);
 261   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.f_bfree);
 262   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.f_bavail);
 263   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.f_bavail) != 0;
 264   fsp->fsu_files = PROPAGATE_ALL_ONES (fsd.f_files);
 265   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.f_ffree);
 266
 267 #endif /* not STAT_STATFS2_FS_DATA && not STAT_READ_FILSYS */
 268
 269   return 0;
 270 }
 271
 272 #if defined(_AIX) && defined(_I386)
 273 /* AIX PS/2 does not supply statfs.  */
 274
 275 int
 276 statfs (char *path, struct statfs *fsb)
 277 {
 278   struct stat stats;
 279   struct dustat fsd;
 280
 281   if (stat (path, &stats))
 282     return -1;
 283   if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
 284     return -1;
 285   fsb->f_type   = 0;
 286   fsb->f_bsize  = fsd.du_bsize;
 287   fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
 288   fsb->f_bfree  = fsd.du_tfree;
 289   fsb->f_bavail = fsd.du_tfree;
 290   fsb->f_files  = (fsd.du_isize - 2) * fsd.du_inopb;
 291   fsb->f_ffree  = fsd.du_tinode;
 292   fsb->f_fsid.val[0] = fsd.du_site;
 293   fsb->f_fsid.val[1] = fsd.du_pckno;
 294   return 0;
 295 }
 296
 297 #endif /* _AIX && _I386 */