// uses statfs
BOOL GetDiskFreeSpaceEx(
LPCTSTR lpDirectoryName,
PULARGE_INTEGER lpFreeBytesAvailable,
PULARGE_INTEGER lpTotalNumberOfBytes,
PULARGE_INTEGER lpTotalNumberOfFreeBytes
)
{
#if defined(__ANDROID__)
struct statfs fsInfo;
// is 64-bit on android
if (statfs(CSpecialProtocol::TranslatePath(lpDirectoryName), &fsInfo) != 0)
return false;
#else
struct statfs64 fsInfo;
if (statfs64(CSpecialProtocol::TranslatePath(lpDirectoryName), &fsInfo) != 0)
return false;
#endif
if (lpFreeBytesAvailable)
lpFreeBytesAvailable->QuadPart = (ULONGLONG)fsInfo.f_bavail * (ULONGLONG)fsInfo.f_bsize;
if (lpTotalNumberOfBytes)
lpTotalNumberOfBytes->QuadPart = (ULONGLONG)fsInfo.f_blocks * (ULONGLONG)fsInfo.f_bsize;
if (lpTotalNumberOfFreeBytes)
lpTotalNumberOfFreeBytes->QuadPart = (ULONGLONG)fsInfo.f_bfree * (ULONGLONG)fsInfo.f_bsize;
return true;
}
int statvfs64 (const char *file, struct statvfs64 *buf)
{
struct statfs64 fsbuf;
struct stat64 st;
#if !defined __UCLIBC_LINUX_SPECIFIC__
int ret;
struct statvfs buf32;
ret = statvfs (file, &buf32);
if (ret == 0) {
fsbuf.f_bsize = buf32.f_bsize;
fsbuf.f_frsize = buf32.f_frsize;
fsbuf.f_blocks = buf32.f_blocks;
fsbuf.f_bfree = buf32.f_bfree;
fsbuf.f_bavail = buf32.f_bavail;
fsbuf.f_files = buf32.f_files;
fsbuf.f_ffree = buf32.f_ffree;
if (sizeof (fsbuf.f_fsid) == sizeof(buf32.f_fsid))
memcpy (&fsbuf.f_fsid, &buf32.f_fsid, sizeof(fsbuf.f_fsid));
/* and if not, then you could approximate or whatever.. */
fsbuf.f_namelen = buf32.f_namemax;
} else
return ret;
#else
/* Get as much information as possible from the system. */
if (statfs64 (file, &fsbuf) < 0)
return -1;
#endif
#define STAT(st) stat (file, st)
#include "internal_statvfs.c"
/* We signal success if the statfs call succeeded. */
return 0;
}
/* We define this function standalone, rather than in terms of
* hugetlbfs_test_path() so that we can use it without -lhugetlbfs for
* testing PRELOAD */
int test_addr_huge(void *p)
{
char name[256];
char *dirend;
int ret;
struct statfs64 sb;
ret = read_maps((unsigned long)p, name);
if (ret < 0)
return ret;
if (ret == 0) {
verbose_printf("Couldn't find address %p in /proc/self/maps\n",
p);
return -1;
}
/* looks like a filename? */
if (name[0] != '/')
return 0;
/* Truncate the filename portion */
dirend = strrchr(name, '/');
if (dirend && dirend > name) {
*dirend = '\0';
}
ret = statfs64(name, &sb);
if (ret)
return -1;
return (sb.f_type == HUGETLBFS_MAGIC);
}
int do_statfs(char *root, long *bsize_out, long long *blocks_out,
long long *bfree_out, long long *bavail_out,
long long *files_out, long long *ffree_out,
void *fsid_out, int fsid_size, long *namelen_out)
{
struct statfs64 buf;
int err;
err = statfs64(root, &buf);
if (err < 0)
return -errno;
*bsize_out = buf.f_bsize;
*blocks_out = buf.f_blocks;
*bfree_out = buf.f_bfree;
*bavail_out = buf.f_bavail;
*files_out = buf.f_files;
*ffree_out = buf.f_ffree;
memcpy(fsid_out, &buf.f_fsid,
sizeof(buf.f_fsid) > fsid_size ? fsid_size :
sizeof(buf.f_fsid));
*namelen_out = buf.f_namelen;
return 0;
}
int do_statfs(char *root, long *bsize_out, long long *blocks_out,
long long *bfree_out, long long *bavail_out,
long long *files_out, long long *ffree_out,
void *fsid_out, int fsid_size, long *namelen_out,
long *spare_out)
{
struct statfs64 buf;
int err;
err = statfs64(root, &buf);
if(err < 0) return(-errno);
*bsize_out = buf.f_bsize;
*blocks_out = buf.f_blocks;
*bfree_out = buf.f_bfree;
*bavail_out = buf.f_bavail;
*files_out = buf.f_files;
*ffree_out = buf.f_ffree;
memcpy(fsid_out, &buf.f_fsid,
sizeof(buf.f_fsid) > fsid_size ? fsid_size :
sizeof(buf.f_fsid));
*namelen_out = buf.f_namelen;
spare_out[0] = buf.f_spare[0];
spare_out[1] = buf.f_spare[1];
spare_out[2] = buf.f_spare[2];
spare_out[3] = buf.f_spare[3];
spare_out[4] = buf.f_spare[4];
return(0);
}
// uses statfs
int GetDiskFreeSpaceEx(
LPCTSTR lpDirectoryName,
PULARGE_INTEGER lpFreeBytesAvailable,
PULARGE_INTEGER lpTotalNumberOfBytes,
PULARGE_INTEGER lpTotalNumberOfFreeBytes
)
{
#if defined(TARGET_ANDROID) || defined(TARGET_DARWIN)
struct statfs fsInfo;
// is 64-bit on android and darwin (10.6SDK + any iOS)
if (statfs(CSpecialProtocol::TranslatePath(lpDirectoryName).c_str(), &fsInfo) != 0)
return false;
#else
struct statfs64 fsInfo;
if (statfs64(CSpecialProtocol::TranslatePath(lpDirectoryName).c_str(), &fsInfo) != 0)
return false;
#endif
if (lpFreeBytesAvailable)
lpFreeBytesAvailable->QuadPart = (uint64_t)fsInfo.f_bavail * (uint64_t)fsInfo.f_bsize;
if (lpTotalNumberOfBytes)
lpTotalNumberOfBytes->QuadPart = (uint64_t)fsInfo.f_blocks * (uint64_t)fsInfo.f_bsize;
if (lpTotalNumberOfFreeBytes)
lpTotalNumberOfFreeBytes->QuadPart = (uint64_t)fsInfo.f_bfree * (uint64_t)fsInfo.f_bsize;
return true;
}
static INT64_T chirp_fs_local_statfs(const char *path, struct chirp_statfs *info)
{
PREAMBLE("statfs(`%s', %p)", path, info);
RESOLVE(path)
struct statfs64 linfo;
rc = statfs64(path, &linfo);
if (rc == 0)
COPY_STATFS_LOCAL_TO_CHIRP(*info, linfo);
PROLOGUE
}
static void
validate_export(nfs_export *exp)
{
/* Check that the given export point is potentially exportable.
* We just give warnings here, don't cause anything to fail.
* If a path doesn't exist, or is not a dir or file, give an warning
* otherwise trial-export to '-test-client-' and check for failure.
*/
struct stat stb;
char *path = exp->m_export.e_path;
struct statfs64 stf;
int fs_has_fsid = 0;
if (stat(path, &stb) < 0) {
xlog(L_ERROR, "Failed to stat %s: %m", path);
return;
}
if (!S_ISDIR(stb.st_mode) && !S_ISREG(stb.st_mode)) {
xlog(L_ERROR, "%s is neither a directory nor a file. "
"Remote access will fail", path);
return;
}
if (!can_test())
return;
if (!statfs64(path, &stf) &&
(stf.f_fsid.__val[0] || stf.f_fsid.__val[1]))
fs_has_fsid = 1;
if ((exp->m_export.e_flags & NFSEXP_FSID) || exp->m_export.e_uuid ||
fs_has_fsid) {
if ( !test_export(path, 1)) {
xlog(L_ERROR, "%s does not support NFS export", path);
return;
}
} else if ( ! test_export(path, 0)) {
if (test_export(path, 1))
xlog(L_ERROR, "%s requires fsid= for NFS export", path);
else
xlog(L_ERROR, "%s does not support NFS export", path);
return;
}
}
// Return the page size for hugetlbfs mount point, or 0 if anything goes wrong:
// e.g., mount point doesn't exist, mount point isn't hugetlbfs.
static size_t get_hugepage_size(const char* path) {
#ifdef __linux__
struct statfs64 sb;
if (statfs64(path, &sb) == 0) {
// Magic number defined in Linux kernel: include/uapi/linux/magic.h
auto constexpr HUGETLBFS_MAGIC = 0x958458f6;
if (sb.f_type == HUGETLBFS_MAGIC) {
return sb.f_bsize;
} else {
snprintf(s_errorMsg, maxErrorMsgLen,
"path %s isn't mounted as hugetlbfs", path);
}
} else {
snprintf(s_errorMsg, maxErrorMsgLen,
"statfs64() for %s failed: ", path);
record_err_msg();
}
#endif
return 0;
}
static INT64_T chirp_fs_local_statfs(const char *path, struct chirp_statfs *buf)
{
struct statfs64 info;
int result;
result = statfs64(path, &info);
if(result == 0) {
memset(buf, 0, sizeof(*buf));
#ifdef CCTOOLS_OPSYS_SUNOS
buf->f_type = info.f_fsid;
buf->f_bsize = info.f_frsize;
#else
buf->f_type = info.f_type;
buf->f_bsize = info.f_bsize;
#endif
buf->f_blocks = info.f_blocks;
buf->f_bavail = info.f_bavail;
buf->f_bfree = info.f_bfree;
buf->f_files = info.f_files;
buf->f_ffree = info.f_ffree;
}
return result;
}
// uses statfs
BOOL GetDiskFreeSpaceEx(
LPCTSTR lpDirectoryName,
PULARGE_INTEGER lpFreeBytesAvailable,
PULARGE_INTEGER lpTotalNumberOfBytes,
PULARGE_INTEGER lpTotalNumberOfFreeBytes
)
{
struct statfs64 fsInfo;
if (statfs64(CSpecialProtocol::TranslatePath(lpDirectoryName), &fsInfo) != 0)
return false;
if (lpFreeBytesAvailable)
lpFreeBytesAvailable->QuadPart = (ULONGLONG)fsInfo.f_bavail * (ULONGLONG)fsInfo.f_bsize;
if (lpTotalNumberOfBytes)
lpTotalNumberOfBytes->QuadPart = (ULONGLONG)fsInfo.f_blocks * (ULONGLONG)fsInfo.f_bsize;
if (lpTotalNumberOfFreeBytes)
lpTotalNumberOfFreeBytes->QuadPart = (ULONGLONG)fsInfo.f_bfree * (ULONGLONG)fsInfo.f_bsize;
return true;
}
int64 FSSys::GetFileSystemFreeSpace( FSPath& path, int* err )
{
#if defined( __linux__ ) && !defined( __APPLE__ )
struct statfs64 s;
if ( statfs64( path.GetUtf8(), &s ) == -1 )
{
SetError( err, errno );
return -1;
}
#else
// FreeBSD and probably other systems have 64 bit support in regular statfs
struct statfs s;
if ( statfs( path.GetUtf8(), &s ) == -1 )
{
SetError( err, errno );
return -1;
}
#endif
return ( int64 )( s.f_bfree ) * ( int64 )( s.f_bsize );
}
// uses statfs
BOOL GetDiskFreeSpaceEx(
LPCTSTR lpDirectoryName,
PULARGE_INTEGER lpFreeBytesAvailable,
PULARGE_INTEGER lpTotalNumberOfBytes,
PULARGE_INTEGER lpTotalNumberOfFreeBytes
)
{
struct statfs64 fsInfo;
if (statfs64(_P(lpDirectoryName), &fsInfo) != 0)
return false;
if (lpFreeBytesAvailable)
lpFreeBytesAvailable->QuadPart = fsInfo.f_bavail * fsInfo.f_bsize;
if (lpTotalNumberOfBytes)
lpTotalNumberOfBytes->QuadPart = fsInfo.f_blocks * fsInfo.f_bsize;
if (lpTotalNumberOfFreeBytes)
lpTotalNumberOfFreeBytes->QuadPart = fsInfo.f_bfree * fsInfo.f_bsize;
return true;
}
int using_system_hpage_size(const char *mount)
{
struct statfs64 sb;
int err;
long meminfo_size, mount_size;
if (!mount)
FAIL("using_system_hpage_size: hugetlbfs is not mounted\n");
err = statfs64(mount, &sb);
if (err)
FAIL("statfs64: %s\n", strerror(errno));
meminfo_size = read_meminfo("Hugepagesize:");
if (meminfo_size < 0)
FAIL("using_system_hpage_size: Failed to read /proc/meminfo\n");
mount_size = sb.f_bsize / 1024; /* Compare to meminfo in kB */
if (mount_size == meminfo_size)
return 1;
else
return 0;
}
TEST(sys_vfs, statfs64) {
struct statfs64 sb;
ASSERT_EQ(0, statfs64("/proc", &sb));
Check(sb);
}
/*
* is_ext4() - Whether on an ext4 filesystem.
*
* @file: the file's name.
*/
static int is_ext4(const char *file, char *devname)
{
int maxlen = 0;
int len, ret;
FILE *fp = NULL;
char *mnt_type = NULL;
/* Refer to /etc/mtab */
const char *mtab = MOUNTED;
char file_path[PATH_MAX + 1];
struct mntent *mnt = NULL;
struct statfs64 fsbuf;
/* Get full path */
if (realpath(file, file_path) == NULL) {
perror("Couldn't get full path");
PRINT_FILE_NAME(file);
return -1;
}
if (statfs64(file_path, &fsbuf) < 0) {
perror("Failed to get filesystem information");
PRINT_FILE_NAME(file);
return -1;
}
if (fsbuf.f_type != EXT4_SUPER_MAGIC) {
PRINT_ERR_MSG(NGMSG_EXT4);
return -1;
}
fp = setmntent(mtab, "r");
if (fp == NULL) {
perror("Couldn't access /etc/mtab");
return -1;
}
while ((mnt = getmntent(fp)) != NULL) {
if (mnt->mnt_fsname[0] != '/')
continue;
len = strlen(mnt->mnt_dir);
ret = memcmp(file_path, mnt->mnt_dir, len);
if (ret != 0)
continue;
if (maxlen >= len)
continue;
maxlen = len;
mnt_type = realloc(mnt_type, strlen(mnt->mnt_type) + 1);
if (mnt_type == NULL) {
endmntent(fp);
return -1;
}
memset(mnt_type, 0, strlen(mnt->mnt_type) + 1);
strncpy(mnt_type, mnt->mnt_type, strlen(mnt->mnt_type));
strncpy(lost_found_dir, mnt->mnt_dir, PATH_MAX);
strncpy(devname, mnt->mnt_fsname, strlen(mnt->mnt_fsname) + 1);
}
endmntent(fp);
if (mnt_type && strcmp(mnt_type, FS_EXT4) == 0) {
FREE(mnt_type);
return 0;
} else {
FREE(mnt_type);
PRINT_ERR_MSG(NGMSG_EXT4);
return -1;
}
}
/* stat the filesystem and print what we find */
void do_statfs(char *filename, int terse)
{
struct statfs64 statfsbuf;
if (statfs64(filename, &statfsbuf) == -1) {
perror(filename);
return;
}
if (terse != 0) {
//#ifdef __USE_FILE_OFFSET64
printf("%s %X %X %u %u %I64u %I64u %I64u %u %I64u %I64u\n",
//#else
// printf("%s %X %X %d %X %ld %ld %ld %d %ld %ld\n",
//#endif
filename,
statfsbuf.f_fsid.__val[0],
statfsbuf.f_fsid.__val[1],
// statfsbuf.f_fsid,
statfsbuf.f_namelen,
statfsbuf.f_type,
statfsbuf.f_blocks,
statfsbuf.f_bfree,
statfsbuf.f_bavail,
statfsbuf.f_bsize,
statfsbuf.f_files,
statfsbuf.f_ffree);
return;
}
printf(" File: \"%s\"\n", filename);
#ifdef __USE_FILE_OFFSET64
printf(" ID: %-8X %-8X Namelen: %-7ld Type: ", statfsbuf.f_fsid.__val[0], statfsbuf.f_fsid.__val[1], statfsbuf.f_namelen);
// printf(" ID: %+17Lu", statfsbuf.f_fsid);
// printf(" (%+12LX)", statfsbuf.f_fsid);
// printf(" Namelen: %+12Lu Type: ", statfsbuf.f_namelen);
#else
printf(" ID: %-8X %-8X Namelen: %-7d Type: ", statfsbuf.f_fsid.__val[0], statfsbuf.f_fsid.__val[1], statfsbuf.f_namelen);
// printf(" ID: %+17Lu", statfsbuf.f_fsid);
// printf(" (%+12LX)", statfsbuf.f_fsid);
// printf(" Namelen: %+12u Type: ", statfsbuf.f_namelen);
#endif
switch (statfsbuf.f_type) {
case AFFS_SUPER_MAGIC:
printf("AFFS\n");
break;
case EXT_SUPER_MAGIC:
printf("EXT\n");
break;
case EXT2_OLD_SUPER_MAGIC:
printf("EXT2\n");
break;
case EXT2_SUPER_MAGIC:
printf("EXT2\n");
break;
case HPFS_SUPER_MAGIC:
printf("HPFS\n");
break;
case ISOFS_SUPER_MAGIC:
printf("ISOFS\n");
break;
case MINIX_SUPER_MAGIC:
printf("MINIX\n");
case MINIX_SUPER_MAGIC2:
printf("MINIX (30 char.)\n");
break;
case MINIX2_SUPER_MAGIC:
printf("MINIX V2\n");
break;
case MINIX2_SUPER_MAGIC2:
printf("MINIX V2 (30 char.)\n");
break;
case CDFS_SUPER_MAGIC:
printf("CDFS\n");
break;
case FAT_SUPER_MAGIC:
printf("FAT\n");
break;
case FAT32_SUPER_MAGIC:
printf("FAT32\n");
break;
case MSDOS_SUPER_MAGIC:
printf("MSDOS\n");
break;
case NCP_SUPER_MAGIC:
printf("NOVELL\n");
break;
case NFS_SUPER_MAGIC:
printf("NFS\n");
break;
case PROC_SUPER_MAGIC:
printf("PROC\n");
break;
case SMB_SUPER_MAGIC:
printf("SMB\n");
break;
case XENIX_SUPER_MAGIC:
printf("XENIX\n");
break;
case SYSV4_SUPER_MAGIC:
printf("SYSV4\n");
break;
case SYSV2_SUPER_MAGIC:
printf("SYSV2\n");
break;
case COH_SUPER_MAGIC:
printf("COH\n");
break;
case UFS_MAGIC:
printf("UFS\n");
break;
case _XIAFS_SUPER_MAGIC:
printf("XIA\n");
break;
case NTFS_SUPER_MAGIC:
printf("NTFS\n");
break;
default:
#ifdef __USE_FILE_OFFSET64
printf("UNKNOWN (0X%lX)\n", statfsbuf.f_type);
#else
printf("UNKNOWN (0X%X)\n", statfsbuf.f_type);
#endif
}
//#ifdef __USE_FILE_OFFSET64
printf("Blocks: Total: %10I64u Free: %10I64u Available: %10I64u Size: %u\n", statfsbuf.f_blocks, statfsbuf.f_bfree, statfsbuf.f_bavail, statfsbuf.f_bsize);
printf("Inodes: Total: %10I64u Free: %10I64u\n", statfsbuf.f_files, statfsbuf.f_ffree);
//#else
// printf("Blocks: Total: %+10lu Free: %+10lu Available: %+10lu Size: %u\n", statfsbuf.f_blocks, statfsbuf.f_bfree, statfsbuf.f_bavail, statfsbuf.f_bsize);
// printf("Inodes: Total: %+10lu Free: %+10lu\n", statfsbuf.f_files, statfsbuf.f_ffree);
//#endif
}
