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