lib/fsusage.c

   1 /* fsusage.c -- return space usage of mounted file systems
   2
   3    Copyright (C) 1991, 1992, 1996, 1998, 1999, 2002, 2003, 2004, 2005, 2006
   4    Free Software 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 2, or (at your option)
   9    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, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 #include <config.h>
  21
  22 #include "fsusage.h"
  23
  24 #include <limits.h>
  25 #include <sys/types.h>
  26
  27 #if STAT_STATVFS                /* POSIX 1003.1-2001 (and later) with XSI */
  28 # include <sys/statvfs.h>
  29 #else
  30 /* Don't include backward-compatibility files unless they're needed.
  31    Eventually we'd like to remove all this cruft.  */
  32 # include <fcntl.h>
  33 # include <unistd.h>
  34 # include <sys/stat.h>
  35 # if HAVE_SYS_PARAM_H
  36 #  include <sys/param.h>
  37 # endif
  38 # if HAVE_SYS_MOUNT_H
  39 #  include <sys/mount.h>
  40 # endif
  41 # if HAVE_SYS_VFS_H
  42 #  include <sys/vfs.h>
  43 # endif
  44 # if HAVE_SYS_FS_S5PARAM_H      /* Fujitsu UXP/V */
  45 #  include <sys/fs/s5param.h>
  46 # endif
  47 # if defined HAVE_SYS_FILSYS_H && !defined _CRAY
  48 #  include <sys/filsys.h>       /* SVR2 */
  49 # endif
  50 # if HAVE_SYS_STATFS_H
  51 #  include <sys/statfs.h>
  52 # endif
  53 # if HAVE_DUSTAT_H              /* AIX PS/2 */
  54 #  include <sys/dustat.h>
  55 # endif
  56 # include "full-read.h"
  57 #endif
  58
  59 /* Many space usage primitives use all 1 bits to denote a value that is
  60    not applicable or unknown.  Propagate this information by returning
  61    a uintmax_t value that is all 1 bits if X is all 1 bits, even if X
  62    is unsigned and narrower than uintmax_t.  */
  63 #define PROPAGATE_ALL_ONES(x) \
  64   ((sizeof (x) < sizeof (uintmax_t) \
  65     && (~ (x) == (sizeof (x) < sizeof (int) \
  66                   ? - (1 << (sizeof (x) * CHAR_BIT)) \
  67                   : 0))) \
  68    ? UINTMAX_MAX : (x))
  69
  70 /* Extract the top bit of X as an uintmax_t value.  */
  71 #define EXTRACT_TOP_BIT(x) ((x) \
  72                             & ((uintmax_t) 1 << (sizeof (x) * CHAR_BIT - 1)))
  73
  74 /* If a value is negative, many space usage primitives store it into an
  75    integer variable by assignment, even if the variable's type is unsigned.
  76    So, if a space usage variable X's top bit is set, convert X to the
  77    uintmax_t value V such that (- (uintmax_t) V) is the negative of
  78    the original value.  If X's top bit is clear, just yield X.
  79    Use PROPAGATE_TOP_BIT if the original value might be negative;
  80    otherwise, use PROPAGATE_ALL_ONES.  */
  81 #define PROPAGATE_TOP_BIT(x) ((x) | ~ (EXTRACT_TOP_BIT (x) - 1))
  82
  83 /* Fill in the fields of FSP with information about space usage for
  84    the file system on which FILE resides.
  85    DISK is the device on which FILE is mounted, for space-getting
  86    methods that need to know it.
  87    Return 0 if successful, -1 if not.  When returning -1, ensure that
  88    ERRNO is either a system error value, or zero if DISK is NULL
  89    on a system that requires a non-NULL value.  */
  90 int
  91 get_fs_usage (char const *file, char const *disk, struct fs_usage *fsp)
  92 {
  93 #if defined STAT_STATVFS                /* POSIX */
  94
  95   struct statvfs fsd;
  96
  97   if (statvfs (file, &fsd) < 0)
  98     return -1;
  99
 100   /* f_frsize isn't guaranteed to be supported.  */
 101   fsp->fsu_blocksize = (fsd.f_frsize
 102                         ? PROPAGATE_ALL_ONES (fsd.f_frsize)
 103                         : PROPAGATE_ALL_ONES (fsd.f_bsize));
 104
 105 #elif defined STAT_STATFS2_FS_DATA      /* Ultrix */
 106
 107   struct fs_data fsd;
 108
 109   if (statfs (file, &fsd) != 1)
 110     return -1;
 111
 112   fsp->fsu_blocksize = 1024;
 113   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.fd_req.btot);
 114   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.fd_req.bfree);
 115   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.fd_req.bfreen);
 116   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.fd_req.bfreen) != 0;
 117   fsp->fsu_files = PROPAGATE_ALL_ONES (fsd.fd_req.gtot);
 118   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.fd_req.gfree);
 119
 120 #elif defined STAT_READ_FILSYS          /* SVR2 */
 121 # ifndef SUPERBOFF
 122 #  define SUPERBOFF (SUPERB * 512)
 123 # endif
 124
 125   struct filsys fsd;
 126   int fd;
 127
 128   if (! disk)
 129     {
 130       errno = 0;
 131       return -1;
 132     }
 133
 134   fd = open (disk, O_RDONLY);
 135   if (fd < 0)
 136     return -1;
 137   lseek (fd, (off_t) SUPERBOFF, 0);
 138   if (full_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
 139     {
 140       close (fd);
 141       return -1;
 142     }
 143   close (fd);
 144
 145   fsp->fsu_blocksize = (fsd.s_type == Fs2b ? 1024 : 512);
 146   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.s_fsize);
 147   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.s_tfree);
 148   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.s_tfree);
 149   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.s_tfree) != 0;
 150   fsp->fsu_files = (fsd.s_isize == -1
 151                     ? UINTMAX_MAX
 152                     : (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1));
 153   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.s_tinode);
 154
 155 #elif defined STAT_STATFS3_OSF1
 156
 157   struct statfs fsd;
 158
 159   if (statfs (file, &fsd, sizeof (struct statfs)) != 0)
 160     return -1;
 161
 162   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
 163
 164 #elif defined STAT_STATFS2_BSIZE        /* 4.3BSD, SunOS 4, HP-UX, AIX */
 165
 166   struct statfs fsd;
 167
 168   if (statfs (file, &fsd) < 0)
 169     return -1;
 170
 171   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
 172
 173 # ifdef STATFS_TRUNCATES_BLOCK_COUNTS
 174
 175   /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
 176      struct statfs are truncated to 2GB.  These conditions detect that
 177      truncation, presumably without botching the 4.1.1 case, in which
 178      the values are not truncated.  The correct counts are stored in
 179      undocumented spare fields.  */
 180   if (fsd.f_blocks == 0x7fffffff / fsd.f_bsize && fsd.f_spare[0] > 0)
 181     {
 182       fsd.f_blocks = fsd.f_spare[0];
 183       fsd.f_bfree = fsd.f_spare[1];
 184       fsd.f_bavail = fsd.f_spare[2];
 185     }
 186 # endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
 187
 188 #elif defined STAT_STATFS2_FSIZE        /* 4.4BSD */
 189
 190   struct statfs fsd;
 191
 192   if (statfs (file, &fsd) < 0)
 193     return -1;
 194
 195   fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
 196
 197 #elif defined STAT_STATFS4              /* SVR3, Dynix, Irix, AIX */
 198
 199 # if !_AIX && !defined _SEQUENT_ && !defined DOLPHIN
 200 #  define f_bavail f_bfree
 201 # endif
 202
 203   struct statfs fsd;
 204
 205   if (statfs (file, &fsd, sizeof fsd, 0) < 0)
 206     return -1;
 207
 208   /* Empirically, the block counts on most SVR3 and SVR3-derived
 209      systems seem to always be in terms of 512-byte blocks,
 210      no matter what value f_bsize has.  */
 211 # if _AIX || defined _CRAY
 212    fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
 213 # else
 214    fsp->fsu_blocksize = 512;
 215 # endif
 216
 217 #endif
 218
 219 #if (defined STAT_STATVFS \
 220      || (!defined STAT_STATFS2_FS_DATA && !defined STAT_READ_FILSYS))
 221
 222   fsp->fsu_blocks = PROPAGATE_ALL_ONES (fsd.f_blocks);
 223   fsp->fsu_bfree = PROPAGATE_ALL_ONES (fsd.f_bfree);
 224   fsp->fsu_bavail = PROPAGATE_TOP_BIT (fsd.f_bavail);
 225   fsp->fsu_bavail_top_bit_set = EXTRACT_TOP_BIT (fsd.f_bavail) != 0;
 226   fsp->fsu_files = PROPAGATE_ALL_ONES (fsd.f_files);
 227   fsp->fsu_ffree = PROPAGATE_ALL_ONES (fsd.f_ffree);
 228
 229 #endif
 230
 231   return 0;
 232 }
 233
 234 #if defined _AIX && defined _I386
 235 /* AIX PS/2 does not supply statfs.  */
 236
 237 int
 238 statfs (char *file, struct statfs *fsb)
 239 {
 240   struct stat stats;
 241   struct dustat fsd;
 242
 243   if (stat (file, &stats) != 0)
 244     return -1;
 245   if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
 246     return -1;
 247   fsb->f_type   = 0;
 248   fsb->f_bsize  = fsd.du_bsize;
 249   fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
 250   fsb->f_bfree  = fsd.du_tfree;
 251   fsb->f_bavail = fsd.du_tfree;
 252   fsb->f_files  = (fsd.du_isize - 2) * fsd.du_inopb;
 253   fsb->f_ffree  = fsd.du_tinode;
 254   fsb->f_fsid.val[0] = fsd.du_site;
 255   fsb->f_fsid.val[1] = fsd.du_pckno;
 256   return 0;
 257 }
 258
 259 #endif /* _AIX && _I386 */