lib/fsusage.c

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