lib/fsusage.c

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