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