1 /* fsusage.c -- return space usage of mounted filesystems
3 Copyright (C) 1991, 1992, 1996, 1998, 1999, 2002, 2003 Free
4 Software Foundation, Inc.
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.
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.
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. */
20 #if HAVE_CONFIG_H
21 # include <config.h>
22 #endif
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
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include "fsusage.h"
39 #include <limits.h>
41 #if HAVE_SYS_PARAM_H
42 # include <sys/param.h>
43 #endif
45 #if HAVE_SYS_MOUNT_H
46 # include <sys/mount.h>
47 #endif
49 #if HAVE_SYS_VFS_H
50 # include <sys/vfs.h>
51 #endif
53 #if HAVE_SYS_FS_S5PARAM_H /* Fujitsu UXP/V */
54 # include <sys/fs/s5param.h>
55 #endif
57 #if defined HAVE_SYS_FILSYS_H && !defined _CRAY
58 # include <sys/filsys.h> /* SVR2 */
59 #endif
61 #if HAVE_FCNTL_H
62 # include <fcntl.h>
63 #endif
65 #if HAVE_SYS_STATFS_H
66 # include <sys/statfs.h>
67 #endif
69 #if HAVE_DUSTAT_H /* AIX PS/2 */
70 # include <sys/dustat.h>
71 #endif
73 #if HAVE_SYS_STATVFS_H /* SVR4 */
74 # include <sys/statvfs.h>
75 int statvfs ();
76 #endif
78 #include "full-read.h"
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))
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)))
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))
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
116 struct statfs fsd;
118 if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
119 return -1;
121 fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
123 #endif /* STAT_STATFS3_OSF1 */
125 #ifdef STAT_STATFS2_FS_DATA /* Ultrix */
127 struct fs_data fsd;
129 if (statfs (path, &fsd) != 1)
130 return -1;
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);
140 #endif /* STAT_STATFS2_FS_DATA */
142 #ifdef STAT_READ_FILSYS /* SVR2 */
143 # ifndef SUPERBOFF
144 # define SUPERBOFF (SUPERB * 512)
145 # endif
147 struct filsys fsd;
148 int fd;
150 if (! disk)
151 {
152 errno = 0;
153 return -1;
154 }
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);
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);
177 #endif /* STAT_READ_FILSYS */
179 #ifdef STAT_STATFS2_BSIZE /* 4.3BSD, SunOS 4, HP-UX, AIX */
181 struct statfs fsd;
183 if (statfs (path, &fsd) < 0)
184 return -1;
186 fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_bsize);
188 # ifdef STATFS_TRUNCATES_BLOCK_COUNTS
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 */
203 #endif /* STAT_STATFS2_BSIZE */
205 #ifdef STAT_STATFS2_FSIZE /* 4.4BSD */
207 struct statfs fsd;
209 if (statfs (path, &fsd) < 0)
210 return -1;
212 fsp->fsu_blocksize = PROPAGATE_ALL_ONES (fsd.f_fsize);
214 #endif /* STAT_STATFS2_FSIZE */
216 #ifdef STAT_STATFS4 /* SVR3, Dynix, Irix, AIX */
218 # if !_AIX && !defined _SEQUENT_ && !defined DOLPHIN
219 # define f_bavail f_bfree
220 # endif
222 struct statfs fsd;
224 if (statfs (path, &fsd, sizeof fsd, 0) < 0)
225 return -1;
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
236 #endif /* STAT_STATFS4 */
238 #ifdef STAT_STATVFS /* SVR4 */
240 struct statvfs fsd;
242 if (statvfs (path, &fsd) < 0)
243 return -1;
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));
250 #endif /* STAT_STATVFS */
252 #if !defined STAT_STATFS2_FS_DATA && !defined STAT_READ_FILSYS
253 /* !Ultrix && !SVR2 */
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);
262 #endif /* not STAT_STATFS2_FS_DATA && not STAT_READ_FILSYS */
264 return 0;
265 }
267 #if defined _AIX && defined _I386
268 /* AIX PS/2 does not supply statfs. */
270 int
271 statfs (char *path, struct statfs *fsb)
272 {
273 struct stat stats;
274 struct dustat fsd;
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 }
292 #endif /* _AIX && _I386 */