static int get_fs_usage(char *path, long *l_total, long *l_avail) { struct statfs fsd; /* 4.3BSD, SunOS 4, HP-UX, AIX. */ unsigned long fsu_blocks, fsu_bfree, fsu_bavail; *l_total = *l_avail = 0; if (statfs(path, &fsd) < 0) return -1; fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks); fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree); fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail); *l_avail = getuid() ? fsu_bavail/2 : fsu_bfree/2; *l_total = fsu_blocks/2; return 0; }
/* this does all of the system specific guff to get the free disk space. It is derived from code in the GNU fileutils package, but has been considerably mangled for use here results are returned in *dfree and *dsize, in 512 byte units */ int sys_fsusage(const char *path, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize, SMB_BIG_UINT *bsize) { #ifdef STAT_STATFS3_OSF1 #define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_fsize, (SMB_BIG_UINT)512) struct statfs fsd; if (statfs (path, &fsd, sizeof (struct statfs)) != 0) return -1; #endif /* STAT_STATFS3_OSF1 */ #ifdef STAT_STATFS2_FS_DATA /* Ultrix */ #define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)1024, (SMB_BIG_UINT)512) struct fs_data fsd; if (statfs (path, &fsd) != 1) return -1; (*dsize) = CONVERT_BLOCKS (fsd.fd_req.btot); (*dfree) = CONVERT_BLOCKS (fsd.fd_req.bfreen); #endif /* STAT_STATFS2_FS_DATA */ #ifdef STAT_STATFS2_BSIZE /* 4.3BSD, SunOS 4, HP-UX, AIX */ #define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_bsize, (SMB_BIG_UINT)512) struct statfs fsd; if (statfs (path, &fsd) < 0) return -1; #ifdef STATFS_TRUNCATES_BLOCK_COUNTS /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the struct statfs are truncated to 2GB. These conditions detect that truncation, presumably without botching the 4.1.1 case, in which the values are not truncated. The correct counts are stored in undocumented spare fields. */ if (fsd.f_blocks == 0x1fffff && fsd.f_spare[0] > 0) { fsd.f_blocks = fsd.f_spare[0]; fsd.f_bfree = fsd.f_spare[1]; fsd.f_bavail = fsd.f_spare[2]; } #endif /* STATFS_TRUNCATES_BLOCK_COUNTS */ #endif /* STAT_STATFS2_BSIZE */ #ifdef STAT_STATFS2_FSIZE /* 4.4BSD */ #define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_fsize, (SMB_BIG_UINT)512) struct statfs fsd; if (statfs (path, &fsd) < 0) return -1; #endif /* STAT_STATFS2_FSIZE */ #ifdef STAT_STATFS4 /* SVR3, Dynix, Irix, AIX */ # if _AIX || defined(_CRAY) # define CONVERT_BLOCKS(B) adjust_blocks ((SMB_BIG_UINT)(B), (SMB_BIG_UINT)fsd.f_bsize, (SMB_BIG_UINT)512) # ifdef _CRAY # define f_bavail f_bfree # endif # else # define CONVERT_BLOCKS(B) ((SMB_BIG_UINT)B) # ifndef _SEQUENT_ /* _SEQUENT_ is DYNIX/ptx */ # ifndef DOLPHIN /* DOLPHIN 3.8.alfa/7.18 has f_bavail */ # define f_bavail f_bfree # endif # endif # endif struct statfs fsd; if (statfs (path, &fsd, sizeof fsd, 0) < 0) return -1; /* Empirically, the block counts on most SVR3 and SVR3-derived systems seem to always be in terms of 512-byte blocks, no matter what value f_bsize has. */ #endif /* STAT_STATFS4 */ #if defined(STAT_STATVFS) || defined(STAT_STATVFS64) /* SVR4 */ # define CONVERT_BLOCKS(B) \ adjust_blocks ((SMB_BIG_UINT)(B), fsd.f_frsize ? (SMB_BIG_UINT)fsd.f_frsize : (SMB_BIG_UINT)fsd.f_bsize, (SMB_BIG_UINT)fsd.f_bsize) #ifdef STAT_STATVFS64 struct statvfs64 fsd; if (statvfs64(path, &fsd) < 0) return -1; #else struct statvfs fsd; if (statvfs(path, &fsd) < 0) return -1; #endif /* f_frsize isn't guaranteed to be supported. */ #endif /* STAT_STATVFS */ #ifndef CONVERT_BLOCKS /* we don't have any dfree code! */ return -1; #else #if !defined(STAT_STATFS2_FS_DATA) /* !Ultrix */ (*bsize) = fsd.f_bsize; (*dsize) = CONVERT_BLOCKS (fsd.f_blocks); (*dfree) = CONVERT_BLOCKS (fsd.f_bavail); #endif /* not STAT_STATFS2_FS_DATA */ #endif return 0; }
int get_fs_usage (const TCHAR *path, const TCHAR *disk, struct fs_usage *fsp) { #ifdef FSUAE // FIXME: if net play only return get_fs_usage_fake(path, disk, fsp); #else #ifdef STAT_STATFS3_OSF1 # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_fsize, 512) struct statfs fsd; if (statfs (path, &fsd, sizeof (struct statfs)) != 0) return -1; #endif /* STAT_STATFS3_OSF1 */ #ifdef STAT_STATFS2_FS_DATA /* Ultrix */ # define CONVERT_BLOCKS(B) adjust_blocks ((B), 1024, 512) struct fs_data fsd; if (statfs (path, &fsd) != 1) return -1; fsp->fsu_blocks = CONVERT_BLOCKS (fsd.fd_req.btot); fsp->fsu_bfree = CONVERT_BLOCKS (fsd.fd_req.bfree); fsp->fsu_bavail = CONVERT_BLOCKS (fsd.fd_req.bfreen); fsp->fsu_files = fsd.fd_req.gtot; fsp->fsu_ffree = fsd.fd_req.gfree; #endif /* STAT_STATFS2_FS_DATA */ #ifdef STAT_READ_FILSYS /* SVR2 */ # ifndef SUPERBOFF # define SUPERBOFF (SUPERB * 512) # endif # define CONVERT_BLOCKS(B) \ adjust_blocks ((B), (fsd.s_type == Fs2b ? 1024 : 512), 512) struct filsys fsd; int fd; if (! disk) { errno = 0; return -1; } fd = open (disk, O_RDONLY); if (fd < 0) return -1; lseek (fd, (long) SUPERBOFF, 0); if (safe_read (fd, (TCHAR *) &fsd, sizeof fsd) != sizeof fsd) { close (fd); return -1; } close (fd); fsp->fsu_blocks = CONVERT_BLOCKS (fsd.s_fsize); fsp->fsu_bfree = CONVERT_BLOCKS (fsd.s_tfree); fsp->fsu_bavail = CONVERT_BLOCKS (fsd.s_tfree); fsp->fsu_files = (fsd.s_isize - 2) * INOPB * (fsd.s_type == Fs2b ? 2 : 1); fsp->fsu_ffree = fsd.s_tinode; #endif /* STAT_READ_FILSYS */ #ifdef STAT_STATFS2_BSIZE /* 4.3BSD, SunOS 4, HP-UX, AIX */ # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_bsize, 512) struct statfs fsd; if (statfs (path, &fsd) < 0) return -1; # ifdef STATFS_TRUNCATES_BLOCK_COUNTS /* In SunOS 4.1.2, 4.1.3, and 4.1.3_U1, the block counts in the struct statfs are truncated to 2GB. These conditions detect that truncation, presumably without botching the 4.1.1 case, in which the values are not truncated. The correct counts are stored in undocumented spare fields. */ if (fsd.f_blocks == 0x1fffff && fsd.f_spare[0] > 0) { fsd.f_blocks = fsd.f_spare[0]; fsd.f_bfree = fsd.f_spare[1]; fsd.f_bavail = fsd.f_spare[2]; } # endif /* STATFS_TRUNCATES_BLOCK_COUNTS */ #endif /* STAT_STATFS2_BSIZE */ #ifdef STAT_STATFS2_FSIZE /* 4.4BSD */ # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_fsize, 512) struct statfs fsd; if (statfs (path, &fsd) < 0) return -1; #endif /* STAT_STATFS2_FSIZE */ #ifdef STAT_STATFS4 /* SVR3, Dynix, Irix, AIX */ # if _AIX || defined(_CRAY) # define CONVERT_BLOCKS(B) adjust_blocks ((B), fsd.f_bsize, 512) # ifdef _CRAY # define f_bavail f_bfree # endif # else # define CONVERT_BLOCKS(B) (B) # ifndef _SEQUENT_ /* _SEQUENT_ is DYNIX/ptx */ # ifndef DOLPHIN /* DOLPHIN 3.8.alfa/7.18 has f_bavail */ # define f_bavail f_bfree # endif # endif # endif struct statfs fsd; if (statfs (path, &fsd, sizeof fsd, 0) < 0) return -1; /* Empirically, the block counts on most SVR3 and SVR3-derived systems seem to always be in terms of 512-byte blocks, no matter what value f_bsize has. */ #endif /* STAT_STATFS4 */ #ifdef STAT_STATVFS /* SVR4 */ # define CONVERT_BLOCKS(B) \ adjust_blocks ((B), fsd.f_frsize ? fsd.f_frsize : fsd.f_bsize, 512) struct statvfs fsd; if (statvfs (path, &fsd) < 0) return -1; /* f_frsize isn't guaranteed to be supported. */ #endif /* STAT_STATVFS */ #if !defined(STAT_STATFS2_FS_DATA) && !defined(STAT_READ_FILSYS) /* !Ultrix && !SVR2 */ fsp->fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks); fsp->fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree); fsp->fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail); fsp->fsu_files = fsd.f_files; fsp->fsu_ffree = fsd.f_ffree; #endif /* not STAT_STATFS2_FS_DATA && not STAT_READ_FILSYS */ return 0; #endif // FSUAE }