lib/fsusage.c

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