/***********************************************************************
* GetDiskFreeSpace (KERNEL.422)
*/
BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
return GetDiskFreeSpaceA( root, cluster_sectors, sector_bytes,
free_clusters, total_clusters );
}
/*
* @implemented
*/
unsigned int _getdiskfree(unsigned int _drive, struct _diskfree_t* _diskspace)
{
char RootPathName[10];
RootPathName[0] = toupper(_drive +'@');
RootPathName[1] = ':';
RootPathName[2] = '\\';
RootPathName[3] = 0;
if (_diskspace == NULL)
return 0;
if (!GetDiskFreeSpaceA(RootPathName,(LPDWORD)&_diskspace->sectors_per_cluster,(LPDWORD)&_diskspace->bytes_per_sector,
(LPDWORD )&_diskspace->avail_clusters,(LPDWORD )&_diskspace->total_clusters))
return 0;
return _diskspace->avail_clusters;
}
sint64 VDGetDiskFreeSpace(const wchar_t *path) {
typedef BOOL (WINAPI *tpGetDiskFreeSpaceExA)(LPCSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailable, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
typedef BOOL (WINAPI *tpGetDiskFreeSpaceExW)(LPCWSTR lpDirectoryName, PULARGE_INTEGER lpFreeBytesAvailable, PULARGE_INTEGER lpTotalNumberOfBytes, PULARGE_INTEGER lpTotalNumberOfFreeBytes);
static bool sbChecked = false;
static tpGetDiskFreeSpaceExA spGetDiskFreeSpaceExA;
static tpGetDiskFreeSpaceExW spGetDiskFreeSpaceExW;
if (!sbChecked) {
HMODULE hmodKernel = GetModuleHandle("kernel32.dll");
spGetDiskFreeSpaceExA = (tpGetDiskFreeSpaceExA)GetProcAddress(hmodKernel, "GetDiskFreeSpaceExA");
spGetDiskFreeSpaceExW = (tpGetDiskFreeSpaceExW)GetProcAddress(hmodKernel, "GetDiskFreeSpaceExW");
sbChecked = true;
}
if (spGetDiskFreeSpaceExA) {
BOOL success;
uint64 freeClient, totalBytes, totalFreeBytes;
VDStringW directoryName(path);
if (!directoryName.empty()) {
wchar_t c = directoryName[directoryName.length()-1];
if (c != L'/' && c != L'\\')
directoryName += L'\\';
}
if ((LONG)GetVersion() < 0)
success = spGetDiskFreeSpaceExA(VDTextWToA(directoryName).c_str(), (PULARGE_INTEGER)&freeClient, (PULARGE_INTEGER)&totalBytes, (PULARGE_INTEGER)&totalFreeBytes);
else
success = spGetDiskFreeSpaceExW(directoryName.c_str(), (PULARGE_INTEGER)&freeClient, (PULARGE_INTEGER)&totalBytes, (PULARGE_INTEGER)&totalFreeBytes);
return success ? (sint64)freeClient : -1;
} else {
DWORD sectorsPerCluster, bytesPerSector, freeClusters, totalClusters;
BOOL success;
VDStringW rootPath(VDFileGetRootPath(path));
if ((LONG)GetVersion() < 0)
success = GetDiskFreeSpaceA(rootPath.empty() ? NULL : VDTextWToA(rootPath).c_str(), §orsPerCluster, &bytesPerSector, &freeClusters, &totalClusters);
else
success = GetDiskFreeSpaceW(rootPath.empty() ? NULL : rootPath.c_str(), §orsPerCluster, &bytesPerSector, &freeClusters, &totalClusters);
return success ? (sint64)((uint64)sectorsPerCluster * bytesPerSector * freeClusters) : -1;
}
}
//===============================================================================================
// FUNCTION: _AllocReadWriteBuffer
// PURPOSE: Allocate read/write buffers for this file
//
static BOOL AllocReadWriteBuffer(ATF_FILEINFO *pATF, DWORD dwDesiredAccess)
{
WPTRASSERT(pATF);
// init all settings:
pATF->lBufSize = 0L;
pATF->lPos = 0L;
pATF->lBufReadLimit = 0L;
pATF->pszBuf = NULL;
pATF->bRead = TRUE;
// if querying only:
if (dwDesiredAccess == 0)
return TRUE;
#if defined(_MSC_VER)
char szRootDir[_MAX_DRIVE+2];
if (_GetRootDir(pATF->pszFileName, szRootDir, sizeof(szRootDir)))
{
DWORD dwSectorsPerCluster = 0;
DWORD dwBytesPerSector = 0;
DWORD dwNumberOfFreeClusters = 0;
DWORD dwTotalNumberOfClusters = 0;
GetDiskFreeSpaceA(szRootDir, &dwSectorsPerCluster, &dwBytesPerSector,
&dwNumberOfFreeClusters, &dwTotalNumberOfClusters);
pATF->lBufSize = min((dwSectorsPerCluster * dwBytesPerSector), (long)ATF_MAX_BUFFER_SIZE);
ASSERT(pATF->lBufSize > 0);
}
else
pATF->lBufSize = ATF_MAX_BUFFER_SIZE;
#else
pATF->lBufSize = ATF_MAX_BUFFER_SIZE;
#endif
// Allocate one more than the size for zero termination.
pATF->pszBuf = (char *)calloc(pATF->lBufSize+1, sizeof(char));
if (pATF->pszBuf == NULL)
{
pATF->lBufSize = 0L;
return FALSE;
}
pATF->lPos = pATF->lBufSize; // empty read buffer
pATF->lBufReadLimit = pATF->lBufSize;
return TRUE;
}
unsigned int getFreeDiskSpace(const IBK::Path& dir) {
#if defined(_WIN32)
DWORD sectorsPerCluster;
DWORD bytesPerSector;
DWORD freeClusters;
DWORD totalClusters;
std::string drive = dir.drive();
drive += "\\";
//get disk space for current drive
bool success = (GetDiskFreeSpaceA(
drive.c_str(), //current drive
§orsPerCluster, //sectors per cluster
&bytesPerSector, //bytes per sector
&freeClusters, //free clusters
&totalClusters //total clusters
) == 1);
if(!success) {
return 0;
}
unsigned int kBPerCluster = bytesPerSector * sectorsPerCluster / 1024;
return kBPerCluster * freeClusters / 1024;
#else
struct statvfs fs;
int returnCode = 0;
returnCode = statvfs( dir.absolutePath().c_str(), &fs );
if (returnCode == 0)
return fs.f_bsize * fs.f_bfree / 1024;
/// \todo error code handling
return 0;
#endif
}
JNIEXPORT jlong
JNICALL Java_us_temerity_pipeline_NativeFileSys_freeDiskSpaceNative
(
JNIEnv *env,
jclass cls,
jstring jpath /* IN: the file/directory used to determine the file system */
)
{
/* exception initialization */
char msg[2048];
jclass IOException = env->FindClass("java/io/IOException");
if(IOException == 0) {
errno = EINVAL;
perror("NativeFileSys.freeDiskSpaceNative(), unable to lookup \"java/lang/IOException\"");
return -1;
}
/* repackage the arguments */
const char* path = env->GetStringUTFChars(jpath, 0);
if((path == NULL) || (strlen(path) == 0)) {
env->ThrowNew(IOException,"empty path argument");
return -1;
}
/* lookup the free disk space */
{
DWORD sectPerClust, bytesPerSect, freeClust, totalClust;
if(!GetDiskFreeSpaceA(path, §PerClust, &bytesPerSect, &freeClust, &totalClust)) {
sprintf(msg, "cannot determine free disk space for (%s)", path);
env->ReleaseStringUTFChars(jpath, path);
env->ThrowNew(IOException, msg);
return -1;
}
env->ReleaseStringUTFChars(jpath, path);
return ((jlong) freeClust) * ((jlong) sectPerClust) * ((jlong) bytesPerSect);
}
}
void ShowVolume(char* VolumeName, int flgShowDevName, int flgVerbose, int flgUnit, int flgGauge, int flgRemoveable, uint64_t* AllTotalSize, uint64_t* AllFreeSize) {
DWORD Error = ERROR_SUCCESS;
DWORD CharCount = 0;
char tmp[MAX_PATH] = "";
char DeviceName[MAX_PATH] = "";
char* VolumeTypeName = 0;
UINT VolumeType = 0;
size_t Index = 0;
DWORD SectorsPerCluster = 0;
DWORD BytesPerSector = 0;
DWORD NumberOfFreeClusters = 0;
DWORD TotalNumberOfClusters= 0;
uint64_t TotalSize = 0;
uint64_t FreeSize = 0;
UINT flgIsRealFloppy = 0;
double den = 0.0f;
double percent = 0.0f;
strcpy(tmp, VolumeName);
VolumeType = GetDriveTypeA(tmp);
switch(VolumeType) {
case 0:
VolumeTypeName = "(Unknown)";
break;
case 1:
VolumeTypeName = "(invalid root path)";
break;
case 2:
VolumeTypeName = "(Removable)";
break;
case 3:
VolumeTypeName = "(Fixed)";
break;
case 4:
VolumeTypeName = "(Remote)";
break;
case 5:
VolumeTypeName = "(CD-ROM)";
break;
case 6:
VolumeTypeName = "(RAM Disk)";
break;
}
if(!flgVerbose && !IsTargetDrive(VolumeType,7,0)) return;
// get free space information
if(IsTargetDrive(VolumeType,flgRemoveable,flgIsRealFloppy)) {
GetDiskFreeSpaceA(tmp, &SectorsPerCluster, &BytesPerSector, &NumberOfFreeClusters, &TotalNumberOfClusters);
FreeSize = TotalSize = SectorsPerCluster;
FreeSize *= BytesPerSector;
TotalSize *= BytesPerSector;
FreeSize *= NumberOfFreeClusters;
TotalSize *= TotalNumberOfClusters;
if(VolumeType == 3) {
*AllTotalSize += TotalSize;
*AllFreeSize += FreeSize;
}
den = TotalSize;
percent = FreeSize;
percent /= den;
percent *= 100;
}
if(flgVerbose) {
printf("\nFound a device: %s", DeviceName);
printf("\nVolume name: %s %s", tmp, VolumeTypeName);
printf("\nPaths:");
}
else if(flgGauge) {
DrawGauge(36,(int)percent,!IsTargetDrive(VolumeType,flgRemoveable,flgIsRealFloppy)|!TotalSize);
}
if (!flgShowDevName)
printf(" %s", tmp);
if(IsTargetDrive(VolumeType,flgRemoveable,flgIsRealFloppy)) {
// VolumeName is reused here
strcpy(tmp, ComputerUnits(FreeSize, flgUnit));
// DeviceName is reused here
if(TotalSize)
sprintf(DeviceName, "%.2f", percent);
else
strcpy(DeviceName, "--");
printf(" (%s / %s) %s%%", tmp, ComputerUnits(TotalSize, flgUnit), DeviceName);
}
if(!flgVerbose) {
if(VolumeType != 3) printf(" %s", VolumeTypeName);
}
printf("\n");
}
static void test_GetDiskFreeSpaceA(void)
{
BOOL ret;
DWORD sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters;
char drive[] = "?:\\";
DWORD logical_drives;
ret = GetDiskFreeSpaceA(NULL, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceA error %d\n", GetLastError());
ret = GetDiskFreeSpaceA("", §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND || GetLastError() == ERROR_INVALID_NAME),
"GetDiskFreeSpaceA(\"\"): ret=%d GetLastError=%d\n",
ret, GetLastError());
ret = GetDiskFreeSpaceA("\\", §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceA error %d\n", GetLastError());
ret = GetDiskFreeSpaceA("/", §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceA error %d\n", GetLastError());
logical_drives = GetLogicalDrives();
ok(logical_drives != 0, "GetLogicalDrives error %d\n", GetLastError());
for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++)
{
UINT drivetype = GetDriveTypeA(drive);
/* Skip floppy drives because NT pops up a MessageBox if no
* floppy is present
*/
if (drivetype != DRIVE_REMOVABLE && drivetype != DRIVE_NO_ROOT_DIR)
{
ret = GetDiskFreeSpaceA(drive, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (!(logical_drives & 1))
ok(!ret && (GetLastError() == ERROR_PATH_NOT_FOUND || GetLastError() == ERROR_INVALID_DRIVE),
"GetDiskFreeSpaceA(%s): ret=%d GetLastError=%d\n",
drive, ret, GetLastError());
else
{
ok(ret ||
GetLastError() == ERROR_NOT_READY ||
GetLastError() == ERROR_INVALID_FUNCTION ||
GetLastError() == ERROR_INVALID_DRIVE ||
GetLastError() == ERROR_PATH_NOT_FOUND ||
GetLastError() == ERROR_REQUEST_ABORTED ||
GetLastError() == ERROR_NETNAME_DELETED ||
GetLastError() == ERROR_UNRECOGNIZED_VOLUME,
"GetDiskFreeSpaceA(%s): ret=%d GetLastError=%d\n",
drive, ret, GetLastError());
if( GetVersion() & 0x80000000)
/* win3.0 thru winME */
ok( total_clusters <= 65535,
"total clusters is %d > 65535\n", total_clusters);
else if (pGetDiskFreeSpaceExA) {
/* NT, 2k, XP : GetDiskFreeSpace should be accurate */
ULARGE_INTEGER totEx, tot, d;
tot.QuadPart = sectors_per_cluster;
tot.QuadPart = (tot.QuadPart * bytes_per_sector) * total_clusters;
ret = pGetDiskFreeSpaceExA( drive, &d, &totEx, NULL);
ok( ret ||
GetLastError() == ERROR_NOT_READY ||
GetLastError() == ERROR_INVALID_FUNCTION ||
GetLastError() == ERROR_PATH_NOT_FOUND ||
GetLastError() == ERROR_REQUEST_ABORTED ||
GetLastError() == ERROR_NETNAME_DELETED ||
GetLastError() == ERROR_UNRECOGNIZED_VOLUME,
"GetDiskFreeSpaceExA( %s ) failed. GetLastError=%d\n", drive, GetLastError());
ok( bytes_per_sector == 0 || /* empty cd rom drive */
totEx.QuadPart <= tot.QuadPart,
"GetDiskFreeSpaceA should report at least as much bytes on disk %s as GetDiskFreeSpaceExA\n", drive);
}
}
}
logical_drives >>= 1;
}
}
/**
* @author Prof. A Olowofoyeku (The African Chief)
* @author Frank Heckenbach
* @see http://gd.tuwien.ac.at/gnu/mingw/os-hacks.h
*/
int statfs(const char *path, struct statfs *buf)
{
HINSTANCE h;
FARPROC f;
char tmp[MAX_PATH], resolved_path[MAX_PATH];
int retval = 0;
errno = 0;
realpath(path, resolved_path);
if(!resolved_path)
retval = -1;
else
{
/* check whether GetDiskFreeSpaceExA is supported */
h = LoadLibraryA("kernel32.dll");
if(h)
f = GetProcAddress(h, "GetDiskFreeSpaceExA");
else
f = NULL;
if(f)
{
ULARGE_INTEGER bytes_free, bytes_total, bytes_free2;
if(!f(resolved_path, &bytes_free2, &bytes_total, &bytes_free))
{
errno = ENOENT;
retval = -1;
}
else
{
buf->f_bsize = FAKED_BLOCK_SIZE;
buf->f_bfree = (bytes_free.QuadPart) / FAKED_BLOCK_SIZE;
buf->f_files = buf->f_blocks =
(bytes_total.QuadPart) / FAKED_BLOCK_SIZE;
buf->f_ffree = buf->f_bavail =
(bytes_free2.QuadPart) / FAKED_BLOCK_SIZE;
}
}
else
{
DWORD sectors_per_cluster, bytes_per_sector;
if(h)
FreeLibrary(h);
if(!GetDiskFreeSpaceA(resolved_path, §ors_per_cluster,
&bytes_per_sector, &buf->f_bavail,
&buf->f_blocks))
{
errno = ENOENT;
retval = -1;
}
else
{
buf->f_bsize = sectors_per_cluster * bytes_per_sector;
buf->f_files = buf->f_blocks;
buf->f_ffree = buf->f_bavail;
buf->f_bfree = buf->f_bavail;
}
}
if(h)
FreeLibrary(h);
}
/* get the FS volume information */
if(strspn(":", resolved_path) > 0)
resolved_path[3] = '\0'; /* we want only the root */
if(GetVolumeInformation
(resolved_path, NULL, 0, &buf->f_fsid, &buf->f_namelen, NULL, tmp,
MAX_PATH))
{
if(strcasecmp("NTFS", tmp) == 0)
{
buf->f_type = NTFS_SUPER_MAGIC;
}
else
{
buf->f_type = MSDOS_SUPER_MAGIC;
}
}
else
{
errno = ENOENT;
retval = -1;
}
return retval;
}
int
opal_path_df(const char *path,
uint64_t *out_avail)
{
#if !defined(__WINDOWS__)
int rc = -1;
int trials = 5;
int err = 0;
#if defined(__SVR4) && defined(__sun)
struct statvfs buf;
#elif defined(__linux__) || defined (__BSD) || \
(defined(__APPLE__) && defined(__MACH__))
struct statfs buf;
#endif
if (NULL == path || NULL == out_avail) {
return OPAL_ERROR;
}
*out_avail = 0;
do {
#if defined(__SVR4) && defined(__sun)
rc = statvfs(path, &buf);
#elif defined(__linux__) || defined (__BSD) || \
(defined(__APPLE__) && defined(__MACH__))
rc = statfs(path, &buf);
#endif
err = errno;
} while (-1 == rc && ESTALE == err && (--trials > 0));
if (-1 == rc) {
OPAL_OUTPUT_VERBOSE((10, 2, "opal_path_df: stat(v)fs on "
"path: %s failed with errno: %d (%s)\n",
path, err, strerror(err)));
return OPAL_ERROR;
}
/* now set the amount of free space available on path */
/* sometimes buf.f_bavail is negative */
*out_avail = buf.f_bsize * ((int)buf.f_bavail < 0 ? 0 : buf.f_bavail);
OPAL_OUTPUT_VERBOSE((10, 2, "opal_path_df: stat(v)fs states "
"path: %s has %"PRIu64 " B of free space.",
path, *out_avail));
return OPAL_SUCCESS;
#else /* defined __WINDOWS__ */
*out_avail = 0;
if (!GetDiskFreeSpaceEx(NULL, (PULARGE_INTEGER)out_avail, NULL, NULL)) {
DWORD dwSectorsPerCluster = 0, dwBytesPerSector = 0;
DWORD dwFreeClusters = 0, dwTotalClusters = 0;
if (!GetDiskFreeSpaceA(NULL, &dwSectorsPerCluster,
&dwBytesPerSector, &dwFreeClusters, &dwTotalClusters)) {
OPAL_OUTPUT_VERBOSE((10, 2, "opal_path_df: GetDiskFreeSpaceA on "
"path: %s failed with errno: %d (%s)\n",
path, err, strerror(err)));
return OPAL_ERROR;
}
*out_avail = dwFreeClusters * dwSectorsPerCluster * dwBytesPerSector;
}
OPAL_OUTPUT_VERBOSE((10, 2, "opal_path_df: stat(v)fs states "
"path: %s has %"PRIu64 " B of free space.",
path, *out_avail));
return OPAL_SUCCESS;
#endif /* !defined(__WINDOWS__) */
}
int64 GetFreeDisk(const char *Name)
{
#ifdef _WIN_ALL
char Root[NM];
GetPathRoot(Name,Root);
typedef BOOL (WINAPI *GETDISKFREESPACEEX)(
LPCSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER
);
static __thread GETDISKFREESPACEEX pGetDiskFreeSpaceEx=NULL;
if (pGetDiskFreeSpaceEx==NULL)
{
HMODULE hKernel=GetModuleHandleW(L"kernel32.dll");
if (hKernel!=NULL)
pGetDiskFreeSpaceEx=(GETDISKFREESPACEEX)GetProcAddress(hKernel,"GetDiskFreeSpaceExA");
}
if (pGetDiskFreeSpaceEx!=NULL)
{
GetFilePath(Name,Root,ASIZE(Root));
ULARGE_INTEGER uiTotalSize,uiTotalFree,uiUserFree;
uiUserFree.u.LowPart=uiUserFree.u.HighPart=0;
if (pGetDiskFreeSpaceEx(*Root ? Root:NULL,&uiUserFree,&uiTotalSize,&uiTotalFree) &&
uiUserFree.u.HighPart<=uiTotalFree.u.HighPart)
return(INT32TO64(uiUserFree.u.HighPart,uiUserFree.u.LowPart));
}
// We are here if we failed to load GetDiskFreeSpaceExA.
DWORD SectorsPerCluster,BytesPerSector,FreeClusters,TotalClusters;
if (!GetDiskFreeSpaceA(*Root ? Root:NULL,&SectorsPerCluster,&BytesPerSector,&FreeClusters,&TotalClusters))
return(1457664);
int64 FreeSize=SectorsPerCluster*BytesPerSector;
FreeSize=FreeSize*FreeClusters;
return(FreeSize);
#elif defined(_BEOS)
char Root[NM];
GetFilePath(Name,Root,ASIZE(Root));
dev_t Dev=dev_for_path(*Root ? Root:".");
if (Dev<0)
return(1457664);
fs_info Info;
if (fs_stat_dev(Dev,&Info)!=0)
return(1457664);
int64 FreeSize=Info.block_size;
FreeSize=FreeSize*Info.free_blocks;
return(FreeSize);
#elif defined(_UNIX)
return(1457664);
#elif defined(_EMX)
int Drive=IsDiskLetter(Name) ? etoupper(Name[0])-'A'+1:0;
#ifndef _DJGPP
if (_osmode == OS2_MODE)
{
FSALLOCATE fsa;
if (DosQueryFSInfo(Drive,1,&fsa,sizeof(fsa))!=0)
return(1457664);
int64 FreeSize=fsa.cSectorUnit*fsa.cbSector;
FreeSize=FreeSize*fsa.cUnitAvail;
return(FreeSize);
}
else
#endif
{
union REGS regs,outregs;
memset(®s,0,sizeof(regs));
regs.h.ah=0x36;
regs.h.dl=Drive;
#ifdef _DJGPP
int86 (0x21,®s,&outregs);
#else
_int86 (0x21,®s,&outregs);
#endif
if (outregs.x.ax==0xffff)
return(1457664);
int64 FreeSize=outregs.x.ax*outregs.x.cx;
FreeSize=FreeSize*outregs.x.bx;
return(FreeSize);
}
#else
#define DISABLEAUTODETECT
return(1457664);
#endif
}
