![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsusage.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to fsusage.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /* fsusage.c -- return space usage of mounted filesystems
2: Copyright (C) 1991, 1992, 1996 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: #include "sysconfig.h"
19:
20: #include <sys/types.h>
21:
22: #ifdef HAVE_SYS_STAT_H
23: #include <sys/stat.h>
24: #endif
25:
26: #include "fsusage.h"
27:
28: /* Return the number of TOSIZE-byte blocks used by
29: BLOCKS FROMSIZE-byte blocks, rounding away from zero.
30: TOSIZE must be positive. Return -1 if FROMSIZE is not positive. */
31:
32: static long
33: adjust_blocks (blocks, fromsize, tosize)
34: long blocks;
35: int fromsize, tosize;
36: {
37: if (tosize <= 0)
38: abort ();
39: if (fromsize <= 0)
40: return -1;
41:
42: if (fromsize == tosize) /* e.g., from 512 to 512 */
43: return blocks;
44: else if (fromsize > tosize) /* e.g., from 2048 to 512 */
45: return blocks * (fromsize / tosize);
46: else /* e.g., from 256 to 512 */
47: return (blocks + (blocks < 0 ? -1 : 1)) / (tosize / fromsize);
48: }
49:
50: #ifdef _WIN32
51:
52: #include <windows.h>
53:
54: int
55: get_fs_usage (path, disk, fsp)
56: const char *path;
57: const char *disk;
58: struct fs_usage *fsp;
59: {
60: char buf1[1024];
61: char buf2[1024];
62: DWORD SectorsPerCluster;
63: DWORD BytesPerSector;
64: DWORD NumberOfFreeClusters;
65: DWORD TotalNumberOfClusters;
66:
67: fname_atow (path, buf1, sizeof buf1);
68:
69: GetFullPathName (buf1, sizeof buf2, buf2, NULL);
70:
71: buf2[3] = 0;
72:
73: if (!GetDiskFreeSpace (buf2, &SectorsPerCluster, &BytesPerSector,
74: &NumberOfFreeClusters, &TotalNumberOfClusters))
75: {
76: /* lasterror = GetLastError ();*/
77: return -1;
78: }
79:
80: BytesPerSector *= SectorsPerCluster;
81: fsp->fsu_blocks = adjust_blocks (TotalNumberOfClusters, BytesPerSector, 512);
82: fsp->fsu_bavail = adjust_blocks (NumberOfFreeClusters, BytesPerSector, 512);
83:
84: return 0;
85: }
86:
87: #else /* ! _WIN32 */
88:
89: int statfs ();
90:
91: #if HAVE_UNISTD_H
92: # include <unistd.h>
93: #endif
94:
95: #if HAVE_SYS_PARAM_H
96: # include <sys/param.h>
97: #endif
98:
99: #if HAVE_SYS_MOUNT_H
100: # include <sys/mount.h>
101: #endif
102:
103: #if HAVE_SYS_VFS_H
104: # include <sys/vfs.h>
105: #endif
106:
107: #if HAVE_SYS_FS_S5PARAM_H /* Fujitsu UXP/V */
108: # include <sys/fs/s5param.h>
109: #endif
110:
111: #if defined (HAVE_SYS_FILSYS_H) && !defined (_CRAY)
112: # include <sys/filsys.h> /* SVR2 */
113: #endif
114:
115: #if HAVE_FCNTL_H
116: # include <fcntl.h>
117: #endif
118:
119: #if HAVE_SYS_STATFS_H
120: # include <sys/statfs.h>
121: #endif
122:
123: #if HAVE_DUSTAT_H /* AIX PS/2 */
124: # include <sys/dustat.h>
125: #endif
126:
127: #if HAVE_SYS_STATVFS_H /* SVR4 */
128: # include <sys/statvfs.h>
129: int statvfs ();
130: #endif
131:
132: /* Read LEN bytes at PTR from descriptor DESC, retrying if interrupted.
133: Return the actual number of bytes read, zero for EOF, or negative
134: for an error. */
135:
136: int
137: safe_read (desc, ptr, len)
138: int desc;
139: char *ptr;
140: int len;
141: {
142: int n_chars;
143:
144: if (len <= 0)
145: return len;
146:
147: #ifdef EINTR
148: do
149: {
150: n_chars = read (desc, ptr, len);
151: }
152: while (n_chars < 0 && errno == EINTR);
153: #else
154: n_chars = read (desc, ptr, len);
155: #endif
156:
157: return n_chars;
158: }
159:
160: /* Fill in the fields of FSP with information about space usage for
161: the filesystem on which PATH resides.
162: DISK is the device on which PATH is mounted, for space-getting
163: methods that need to know it.
164: Return 0 if successful, -1 if not. When returning -1, ensure that
165: ERRNO is either a system error value, or zero if DISK is NULL
166: on a system that requires a non-NULL value. */
167: int
168: get_fs_usage (path, disk, fsp)
169: const char *path;
170: const char *disk;
171: struct fs_usage *fsp;
172: {
173: #ifdef STAT_STATFS3_OSF1
174: # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_fsize, 512)
175:
176: struct statfs fsd;
177:
178: if (statfs (path, &fsd, sizeof (struct statfs)) != 0)
179: return -1;
180:
181: #endif /* STAT_STATFS3_OSF1 */
182:
183: #ifdef STAT_STATFS2_FS_DATA /* Ultrix */
184: # define CONVERT_BLOCKS(B) adjust_blocks ((B), 1024, 512)
185:
186: struct fs_data fsd;
187:
188: if (statfs (path, &fsd) != 1)
189: return -1;
190: fsp->fsu_blocks = CONVERT_BLOCKS (fsd.fd_req.btot);
191: fsp->fsu_bfree = CONVERT_BLOCKS (fsd.fd_req.bfree);
192: fsp->fsu_bavail = CONVERT_BLOCKS (fsd.fd_req.bfreen);
193: fsp->fsu_files = fsd.fd_req.gtot;
194: fsp->fsu_ffree = fsd.fd_req.gfree;
195:
196: #endif /* STAT_STATFS2_FS_DATA */
197:
198: #ifdef STAT_READ_FILSYS /* SVR2 */
199: # ifndef SUPERBOFF
200: # define SUPERBOFF (SUPERB * 512)
201: # endif
202: # define CONVERT_BLOCKS(B) \
203: adjust_blocks ((B), (fsd.s_type == Fs2b ? 1024 : 512), 512)
204:
205: struct filsys fsd;
206: int fd;
207:
208: if (! disk)
209: {
210: errno = 0;
211: return -1;
212: }
213:
214: fd = open (disk, O_RDONLY);
215: if (fd < 0)
216: return -1;
217: lseek (fd, (long) SUPERBOFF, 0);
218: if (safe_read (fd, (char *) &fsd, sizeof fsd) != sizeof fsd)
219: {
220: close (fd);
221: return -1;
222: }
223: close (fd);
224: fsp->fsu_blocks = CONVERT_BLOCKS (fsd.s_fsize);
225: fsp->fsu_bfree = CONVERT_BLOCKS (fsd.s_tfree);
226: fsp->fsu_bavail = CONVERT_BLOCKS (fsd.s_tfree);
227: fsp->fsu_files = (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1);
228: fsp->fsu_ffree = fsd.s_tinode;
229:
230: #endif /* STAT_READ_FILSYS */
231:
232: #ifdef STAT_STATFS2_BSIZE /* 4.3BSD, SunOS 4, HP-UX, AIX */
233: # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_bsize, 512)
234:
235: struct statfs fsd;
236:
237: if (statfs (path, &fsd) < 0)
238: return -1;
239:
240: # ifdef STATFS_TRUNCATES_BLOCK_COUNTS
241:
242: /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the
243: struct statfs are truncated to 2GB. These conditions detect that
244: truncation, presumably without botching the 4.1.1 case, in which
245: the values are not truncated. The correct counts are stored in
246: undocumented spare fields. */
247: if (fsd.f_blocks == 0x1fffff && fsd.f_spare[0] > 0)
248: {
249: fsd.f_blocks = fsd.f_spare[0];
250: fsd.f_bfree = fsd.f_spare[1];
251: fsd.f_bavail = fsd.f_spare[2];
252: }
253: # endif /* STATFS_TRUNCATES_BLOCK_COUNTS */
254:
255: #endif /* STAT_STATFS2_BSIZE */
256:
257: #ifdef STAT_STATFS2_FSIZE /* 4.4BSD */
258: # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_fsize, 512)
259:
260: struct statfs fsd;
261:
262: if (statfs (path, &fsd) < 0)
263: return -1;
264:
265: #endif /* STAT_STATFS2_FSIZE */
266:
267: #ifdef STAT_STATFS4 /* SVR3, Dynix, Irix, AIX */
268: # if _AIX || defined(_CRAY)
269: # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_bsize, 512)
270: # ifdef _CRAY
271: # define f_bavail f_bfree
272: # endif
273: # else
274: # define CONVERT_BLOCKS(B) (B)
275: # ifndef _SEQUENT_ /* _SEQUENT_ is DYNIX/ptx */
276: # ifndef DOLPHIN /* DOLPHIN 3.8.alfa/7.18 has f_bavail */
277: # define f_bavail f_bfree
278: # endif
279: # endif
280: # endif
281:
282: struct statfs fsd;
283:
284: if (statfs (path, &fsd, sizeof fsd, 0) < 0)
285: return -1;
286: /* Empirically, the block counts on most SVR3 and SVR3-derived
287: systems seem to always be in terms of 512-byte blocks,
288: no matter what value f_bsize has. */
289:
290: #endif /* STAT_STATFS4 */
291:
292: #ifdef STAT_STATVFS /* SVR4 */
293: # define CONVERT_BLOCKS(B) \
294: adjust_blocks ((B), fsd.f_frsize ? fsd.f_frsize : fsd.f_bsize, 512)
295:
296: struct statvfs fsd;
297:
298: if (statvfs (path, &fsd) < 0)
299: return -1;
300: /* f_frsize isn't guaranteed to be supported. */
301:
302: #endif /* STAT_STATVFS */
303:
304: #if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS)
305: /* !Ultrix && !SVR2 */
306:
307: fsp->fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks);
308: fsp->fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree);
309: fsp->fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail);
310: fsp->fsu_files = fsd.f_files;
311: fsp->fsu_ffree = fsd.f_ffree;
312:
313: #endif /* not STAT_STATFS2_FS_DATA && not STAT_READ_FILSYS */
314:
315: return 0;
316: }
317:
318: #if defined(_AIX) && defined(_I386)
319: /* AIX PS/2 does not supply statfs. */
320:
321: int
322: statfs (path, fsb)
323: char *path;
324: struct statfs *fsb;
325: {
326: struct stat stats;
327: struct dustat fsd;
328:
329: if (stat (path, &stats))
330: return -1;
331: if (dustat (stats.st_dev, 0, &fsd, sizeof (fsd)))
332: return -1;
333: fsb->f_type = 0;
334: fsb->f_bsize = fsd.du_bsize;
335: fsb->f_blocks = fsd.du_fsize - fsd.du_isize;
336: fsb->f_bfree = fsd.du_tfree;
337: fsb->f_bavail = fsd.du_tfree;
338: fsb->f_files = (fsd.du_isize - 2) * fsd.du_inopb;
339: fsb->f_ffree = fsd.du_tinode;
340: fsb->f_fsid.val[0] = fsd.du_site;
341: fsb->f_fsid.val[1] = fsd.du_pckno;
342: return 0;
343: }
344:
345: #endif /* _AIX && _I386 */
346:
347: #endif /* ! _WIN32 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.