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-2014 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 /* The FRSIZE fallback is not required in this case.  */
  94 #  undef STAT_STATFS2_FRSIZE
  95 static int statvfs_works (void) { return 1; }
  96 # else
  97 #  include <string.h> /* for strverscmp */
  98 #  include <sys/utsname.h>
  99 #  include <sys/statfs.h>
 100 #  define STAT_STATFS2_BSIZE 1
 101
 102 static int
 103 statvfs_works (void)
 104 {
 105   static int statvfs_works_cache = -1;
 106   struct utsname name;
 107   if (statvfs_works_cache < 0)
 108     statvfs_works_cache = (uname (&name) == 0
 109                            && 0 <= strverscmp (name.release, "2.6.36"));
 110   return statvfs_works_cache;
 111 }
 112 # endif
 113 #endif
 114
 115
 116 /* Fill in the fields of FSP with information about space usage for
 117    the file system on which FILE resides.
 118    DISK is the device on which FILE is mounted, for space-getting
 119    methods that need to know it.
 120    Return 0 if successful, -1 if not.  When returning -1, ensure that
 121    ERRNO is either a system error value, or zero if DISK is NULL
 122    on a system that requires a non-NULL value.  */
 123 int
 124 get_fs_usage (char const *file, char const *disk, struct fs_usage *fsp)
 125 {
 126 #ifdef STAT_STATVFS     /* POSIX, except pre-2.6.36 glibc/Linux */
 127
 128   if (statvfs_works ())
 129     {
 130       struct statvfs vfsd;
 131
 132       if (statvfs (file, &vfsd) < 0)
 133         return -1;
 134
 135       /* f_frsize isn't guaranteed to be supported.  */
 136       fsp->fsu_blocksize = (vfsd.f_frsize
 137                             ? PROPAGATE_ALL_ONES (vfsd.f_frsize)
 138                             : PROPAGATE_ALL_ONES (vfsd.f_bsize));
 139
 140       fsp->fsu_blocks = PROPAGATE_ALL_ONES (vfsd.f_blocks);
 141       fsp->fsu_bfree = PROPAGATE_ALL_ONES (vfsd.f_bfree);
 142       fsp->fsu_bavail = PROPAGATE_TOP_BIT (vfsd.f_bavail);
 143       fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (vfsd.f_bavail) != 0;
 144       fsp->fsu_files = PROPAGATE_ALL_ONES (vfsd.f_files);
 145       fsp->fsu_ffree = PROPAGATE_ALL_ONES (vfsd.f_ffree);
 146       return 0;
 147     }
 148
 149 #endif
 150
 151 #if defined STAT_STATVFS64            /* AIX */
 152
 153   struct statvfs64 fsd;
 154
 155   if (statvfs64 (file, &fsd) < 0)
 156     return -1;
 157
 158   /* f_frsize isn't guaranteed to be supported.  */
 159   fsp->fsu_blocksize = (fsd.f_frsize
 160                         ? PROPAGATE_ALL_ONES (fsd.f_frsize)
 161                         : PROPAGATE_ALL_ONES (fsd.f_bsize));
 162
 163 #elif defined STAT_STATFS2_FS_DATA      /* Ultrix */
 164
 165   struct fs_data fsd;
 166
 167   if (statfs (file, &fsd) != 1)
 168     return -1;
 169
 170   fsp->fsu_blocksize = 1024;
 171   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.fd_req.btot);
 172   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.fd_req.bfree);
 173   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.fd_req.bfreen);
 174   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.fd_req.bfreen) != 0;
 175   fsp->fsu_files = PROPAGATE_ALL_ONES (fsd.fd_req.gtot);
 176   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.fd_req.gfree);
 177
 178 #elif defined STAT_READ_FILSYS          /* SVR2 */
 179 # ifndef SUPERBOFF
 180 #  define SUPERBOFF (SUPERB * 512)
 181 # endif
 182
 183   struct filsys fsd;
 184   int fd;
 185
 186   if (! disk)
 187     {
 188       errno = 0;
 189       return -1;
 190     }
 191
 192   fd = open (disk, O_RDONLY);
 193   if (fd < 0)
 194     return -1;
 195   lseek (fd, (off_t) SUPERBOFF, 0);
 196   if (full_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
 197     {
 198       close (fd);
 199       return -1;
 200     }
 201   close (fd);
 202
 203   fsp->fsu_blocksize = (fsd.s_type == Fs2b ? 1024 : 512);
 204   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.s_fsize);
 205   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.s_tfree);
 206   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.s_tfree);
 207   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.s_tfree) != 0;
 208   fsp->fsu_files = (fsd.s_isize == -1
 209                     ? UINTMAX_MAX
 210                     : (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1));
 211   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.s_tinode);
 212
 213 #elif defined STAT_STATFS3_OSF1         /* OSF/1 */
 214
 215   struct statfs fsd;
 216
 217   if (statfs (file, &fsd, sizeof (struct statfs)) != 0)
 218     return -1;
 219
 220   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
 221
 222 #elif defined STAT_STATFS2_FRSIZE        /* 2.6 < glibc/Linux < 2.6.36 */
 223
 224   struct statfs fsd;
 225
 226   if (statfs (file, &fsd) < 0)
 227     return -1;
 228
 229   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_frsize);
 230
 231 #elif defined STAT_STATFS2_BSIZE        /* glibc/Linux < 2.6, 4.3BSD, SunOS 4, \
 232                                            Mac OS X < 10.4, FreeBSD < 5.0, \
 233                                            NetBSD < 3.0, OpenBSD < 4.4 */
 234
 235   struct statfs fsd;
 236
 237   if (statfs (file, &fsd) < 0)
 238     return -1;
 239
 240   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
 241
 242 # ifdef STATFS_TRUNCATES_BLOCK_COUNTS
 243
 244   /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
 245      struct statfs are truncated to 2GB.  These conditions detect that
 246      truncation, presumably without botching the 4.1.1 case, in which
 247      the values are not truncated.  The correct counts are stored in
 248      undocumented spare fields.  */
 249   if (fsd.f_blocks == 0x7fffffff / fsd.f_bsize && fsd.f_spare[0] > 0)
 250     {
 251       fsd.f_blocks = fsd.f_spare[0];
 252       fsd.f_bfree = fsd.f_spare[1];
 253       fsd.f_bavail = fsd.f_spare[2];
 254     }
 255 # endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
 256
 257 #elif defined STAT_STATFS2_FSIZE        /* 4.4BSD and older NetBSD */
 258
 259   struct statfs fsd;
 260
 261   if (statfs (file, &fsd) < 0)
 262     return -1;
 263
 264   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
 265
 266 #elif defined STAT_STATFS4              /* SVR3, Dynix, old Irix, old AIX, \
 267                                            Dolphin */
 268
 269 # if !_AIX && !defined _SEQUENT_ && !defined DOLPHIN
 270 #  define f_bavail f_bfree
 271 # endif
 272
 273   struct statfs fsd;
 274
 275   if (statfs (file, &fsd, sizeof fsd, 0) < 0)
 276     return -1;
 277
 278   /* Empirically, the block counts on most SVR3 and SVR3-derived
 279      systems seem to always be in terms of 512-byte blocks,
 280      no matter what value f_bsize has.  */
 281 # if _AIX || defined _CRAY
 282    fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
 283 # else
 284    fsp->fsu_blocksize = 512;
 285 # endif
 286
 287 #endif
 288
 289 #if (defined STAT_STATVFS64 || defined STAT_STATFS3_OSF1                \
 290      || defined STAT_STATFS2_FRSIZE || defined STAT_STATFS2_BSIZE       \
 291      || defined STAT_STATFS2_FSIZE || defined STAT_STATFS4)
 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 */