pintos-os.org Git - pspp/blob - lib/fsusage.c

   1 /* fsusage.c -- return space usage of mounted filesystems
   2    Copyright (C) 1991, 1992 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include "fsusage.h"
  25
  26 int statfs ();
  27
  28 #ifdef HAVE_SYS_PARAM_H
  29 #include <sys/param.h>
  30 #endif
  31
  32 #ifdef HAVE_SYS_MOUNT_H
  33 #include <sys/mount.h>
  34 #endif
  35
  36 #ifdef HAVE_SYS_VFS_H
  37 #include <sys/vfs.h>
  38 #endif
  39
  40 #if defined(HAVE_SYS_FILSYS_H) && !defined(_CRAY)
  41 #include <sys/filsys.h>         /* SVR2.  */
  42 #endif
  43
  44 #ifdef HAVE_FCNTL_H
  45 #include <fcntl.h>
  46 #endif
  47
  48 #ifdef HAVE_SYS_STATFS_H
  49 #include <sys/statfs.h>
  50 #endif
  51
  52 #ifdef HAVE_DUSTAT_H            /* AIX PS/2.  */
  53 #include <sys/dustat.h>
  54 #endif
  55
  56 #ifdef HAVE_SYS_STATVFS_H       /* SVR4.  */
  57 #include <sys/statvfs.h>
  58 int statvfs ();
  59 #endif
  60
  61 int safe_read ();
  62
  63 /* Return the number of TOSIZE-byte blocks used by
  64    BLOCKS FROMSIZE-byte blocks, rounding away from zero.
  65    TOSIZE must be positive.  Return -1 if FROMSIZE is not positive.  */
  66
  67 static long
  68 adjust_blocks (blocks, fromsize, tosize)
  69      long blocks;
  70      int fromsize, tosize;
  71 {
  72   if (tosize <= 0)
  73     abort ();
  74   if (fromsize <= 0)
  75     return -1;
  76
  77   if (fromsize == tosize)       /* E.g., from 512 to 512.  */
  78     return blocks;
  79   else if (fromsize > tosize)   /* E.g., from 2048 to 512.  */
  80     return blocks * (fromsize / tosize);
  81   else                          /* E.g., from 256 to 512.  */
  82     return (blocks + (blocks < 0 ? -1 : 1)) / (tosize / fromsize);
  83 }
  84
  85 /* Fill in the fields of FSP with information about space usage for
  86    the filesystem on which PATH resides.
  87    DISK is the device on which PATH is mounted, for space-getting
  88    methods that need to know it.
  89    Return 0 if successful, -1 if not. */
  90
  91 int
  92 get_fs_usage (path, disk, fsp)
  93      const char *path;
  94      const char *disk;
  95      struct fs_usage *fsp;
  96 {
  97 #if defined (STAT_STATFS3_OSF1)
  98   struct statfs fsd;
  99
 100   if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
 101     return -1;
 102 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_fsize, 512)
 103 #endif /* STAT_STATFS3_OSF1 */
 104
 105 #ifdef STAT_STATFS2_FS_DATA     /* Ultrix.  */
 106   struct fs_data fsd;
 107
 108   if (statfs (path, &fsd) != 1)
 109     return -1;
 110 #define CONVERT_BLOCKS(b) adjust_blocks ((b), 1024, 512)
 111   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.fd_req.btot);
 112   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.fd_req.bfree);
 113   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.fd_req.bfreen);
 114   fsp->fsu_files = fsd.fd_req.gtot;
 115   fsp->fsu_ffree = fsd.fd_req.gfree;
 116 #endif
 117
 118 #ifdef STAT_READ_FILSYS         /* SVR2.  */
 119 #ifndef SUPERBOFF
 120 #define SUPERBOFF (SUPERB * 512)
 121 #endif
 122   struct filsys fsd;
 123   int fd;
 124
 125   fd = open (disk, O_RDONLY);
 126   if (fd < 0)
 127     return -1;
 128   lseek (fd, (long) SUPERBOFF, 0);
 129   if (safe_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
 130     {
 131       close (fd);
 132       return -1;
 133     }
 134   close (fd);
 135 #define CONVERT_BLOCKS(b) adjust_blocks ((b), (fsd.s_type == Fs2b ? 1024 : 512), 512)
 136   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.s_fsize);
 137   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.s_tfree);
 138   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.s_tfree);
 139   fsp->fsu_files = (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1);
 140   fsp->fsu_ffree = fsd.s_tinode;
 141 #endif
 142
 143 #ifdef STAT_STATFS2_BSIZE       /* 4.3BSD, SunOS 4, HP-UX, AIX.  */
 144   struct statfs fsd;
 145
 146   if (statfs (path, &fsd) < 0)
 147     return -1;
 148
 149 #ifdef STATFS_TRUNCATES_BLOCK_COUNTS
 150   /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
 151      struct statfs are truncated to 2GB.  These conditions detect that
 152      truncation, presumably without botching the 4.1.1 case, in which
 153      the values are not truncated.  The correct counts are stored in
 154      undocumented spare fields.  */
 155   if (fsd.f_blocks == 0x1fffff && fsd.f_spare[0] > 0)
 156     {
 157       fsd.f_blocks = fsd.f_spare[0];
 158       fsd.f_bfree = fsd.f_spare[1];
 159       fsd.f_bavail = fsd.f_spare[2];
 160     }
 161 #endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
 162
 163 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_bsize, 512)
 164 #endif
 165
 166 #ifdef STAT_STATFS2_FSIZE       /* 4.4BSD.  */
 167   struct statfs fsd;
 168
 169   if (statfs (path, &fsd) < 0)
 170     return -1;
 171 #define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_fsize, 512)
 172 #endif
 173
 174 #ifdef STAT_STATFS4             /* SVR3, Dynix, Irix, AIX.  */
 175   struct statfs fsd;
 176
 177   if (statfs (path, &fsd, sizeof fsd, 0) < 0)
 178     return -1;
 179   /* Empirically, the block counts on most SVR3 and SVR3-derived
 180      systems seem to always be in terms of 512-byte blocks,
 181      no matter what value f_bsize has.  */
 182 # if _AIX
 183 #  define CONVERT_BLOCKS(b) adjust_blocks ((b), fsd.f_bsize, 512)
 184 # else
 185 #  define CONVERT_BLOCKS(b) (b)
 186 #  ifndef _SEQUENT_             /* _SEQUENT_ is DYNIX/ptx.  */
 187 #   ifndef DOLPHIN              /* DOLPHIN 3.8.alfa/7.18 has f_bavail */
 188 #    define f_bavail f_bfree
 189 #   endif
 190 #  endif
 191 # endif
 192 #endif
 193
 194 #ifdef STAT_STATVFS             /* SVR4.  */
 195   struct statvfs fsd;
 196
 197   if (statvfs (path, &fsd) < 0)
 198     return -1;
 199   /* f_frsize isn't guaranteed to be supported.  */
 200 #define CONVERT_BLOCKS(b) \
 201   adjust_blocks ((b), fsd.f_frsize ? fsd.f_frsize : fsd.f_bsize, 512)
 202 #endif
 203
 204 #if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS) /* !Ultrix && !SVR2.  */
 205   fsp->fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks);
 206   fsp->fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree);
 207   fsp->fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail);
 208   fsp->fsu_files = fsd.f_files;
 209   fsp->fsu_ffree = fsd.f_ffree;
 210 #endif
 211
 212   return 0;
 213 }
 214
 215 #if defined(_AIX) && defined(_I386)
 216 /* AIX PS/2 does not supply statfs.  */
 217
 218 int
 219 statfs (path, fsb)
 220      char *path;
 221      struct statfs *fsb;
 222 {
 223   struct stat stats;
 224   struct dustat fsd;
 225
 226   if (stat (path, &stats))
 227     return -1;
 228   if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
 229     return -1;
 230   fsb->f_type   = 0;
 231   fsb->f_bsize  = fsd.du_bsize;
 232   fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
 233   fsb->f_bfree  = fsd.du_tfree;
 234   fsb->f_bavail = fsd.du_tfree;
 235   fsb->f_files  = (fsd.du_isize - 2) * fsd.du_inopb;
 236   fsb->f_ffree  = fsd.du_tinode;
 237   fsb->f_fsid.val[0] = fsd.du_site;
 238   fsb->f_fsid.val[1] = fsd.du_pckno;
 239   return 0;
 240 }
 241 #endif /* _AIX && _I386 */