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