lib/fsusage.c

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