|
|
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
yapt.c
Abstract:
This module contains the code for the Yet Another Performance Tool utility.
Author:
Chuck Park (chuckp) 07-Oct-1994
Revision History:
--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <assert.h>
#include "yapt.h"
//
// Test proc. declarations
//
BOOLEANReadSequential( ULONG Iterations );
BOOLEANWriteSequential( ULONG Iterations );
BOOLEANReadRandom( ULONG Iterations );
BOOLEANWriteRandom( ULONG Iterations );
//
// Common util. functions
//
BOOLEANCreateTestFile( );
ULONGGetRandomOffset( ULONG min, ULONG max );
BOOLGetSectorSize( PDWORD SectorSize, PCHAR DrvLetter );
VOIDLogError( PCHAR ErrString, DWORD UniqueId, DWORD ErrCode );
BOOLEANParseCmdLine( INT Argc, CHAR *Argv[] );
BOOLEANValidateOption( CHAR Switch, CHAR *Value );
VOIDVerifyFileName( IN CHAR *FileName );
VOIDUsage( VOID );
VOID__cdeclLog( ULONG LogLevel, PCHAR String, ... );
DWORDYaptSetFileCompression( IN HANDLE FileHandle, IN USHORT CompressionFormat );
//
// Default parameters
//
#define DEFAULT_BUFFER_SIZE 65536
#define DEFAULT_FILE_SIZE (20*1024*1024);
ULONG SectorSize = 512;ULONG BufferSize = DEFAULT_BUFFER_SIZE;ULONG FileSize = DEFAULT_FILE_SIZE;UCHAR FileName[MAX_PATH] = "test.dat";UCHAR Test = READ;UCHAR Access = SEQ;ULONG Verbose = 0;ULONG Iterations = 10;UCHAR ReuseFile = TRUE;UCHAR Yes = FALSE;BOOLEAN ReadOnly = FALSE;
INT_cdecl main ( INT Argc, CHAR *Argv[] ){ UCHAR testCase;
//
// Parse cmd line
//
if (!ParseCmdLine(Argc,Argv)) { return 1; }
//
// Create the test file
//
if (!CreateTestFile()) { return 2; }
//
// Call appropriate test routine.
//
testCase = (Test << 1) | Access; switch (testCase) { case 0:
if (!ReadSequential(Iterations)) { return 3; } break;
case 1:
//
// Read random
//
if (!ReadRandom(Iterations)) { return 3; }
break;
case 2:
if (!WriteSequential(Iterations)) { return 3; }
break;
case 3:
//
// Write random
//
if (!WriteRandom(Iterations)) { return 3; }
break;
default: printf("Invalid test case\n"); return 3; }
return 0;
}
BOOLEANCreateTestFile( VOID ){ PUCHAR buffer; HANDLE port = INVALID_HANDLE_VALUE; HANDLE fileHandle; OVERLAPPED overlapped,*overlapped2; DWORD bytesTransferred,bytesTransferred2; DWORD_PTR key; ULONG numberWrites; BOOL status; ULONG i;
DWORD currentSize;
buffer = VirtualAlloc(NULL, DEFAULT_BUFFER_SIZE, MEM_COMMIT, PAGE_READWRITE);
if ( !buffer ) { printf("Error allocating buffer %x\n",GetLastError()); return FALSE; }
if(ReuseFile) {
fileHandle = CreateFile(FileName, ReadOnly ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE), 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL);
if(fileHandle != INVALID_HANDLE_VALUE) {
Log(1, "Using existing test file %s\n", FileName); goto InitializeTestFile;
} else {
Log(1, "Error %d opening existing test file\n", GetLastError()); }
} else {
DeleteFile(FileName);
}
fileHandle = CreateFile(FileName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL);
InitializeTestFile:
if ( fileHandle == INVALID_HANDLE_VALUE ) { printf("Error opening file %s %d\n",FileName,GetLastError()); return FALSE; }
currentSize = GetFileSize(fileHandle, NULL);
if(currentSize >= FileSize) {
goto EndCreateTestFile;
} else if(ReadOnly) {
FileSize = currentSize; goto EndCreateTestFile; }
//
// Uncompress the file - compressed files will always do cached I/O even
// if you tell them not to. If this fails assume it's because the
// underlying file system doesn't handle compression.
//
Log(1, "Trying to decompress %s\n", FileName);
YaptSetFileCompression(fileHandle, COMPRESSION_FORMAT_NONE);
port = CreateIoCompletionPort(fileHandle, NULL, (DWORD_PTR)fileHandle, 0); if ( !port ) { printf("Error creating completion port %d\n",GetLastError()); return FALSE; }
Log(1,"Creating test file %s",FileName);
memset(&overlapped, 0, sizeof(overlapped));
numberWrites = FileSize / BufferSize;
for (i = 0; i < numberWrites; i++) {
retryWrite: status = WriteFile(fileHandle, buffer, BufferSize, &bytesTransferred, &overlapped);
if ( !status && GetLastError() != ERROR_IO_PENDING ) { if (GetLastError() == ERROR_INVALID_USER_BUFFER || GetLastError() == ERROR_NOT_ENOUGH_QUOTA || GetLastError() == ERROR_WORKING_SET_QUOTA || GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
goto retryWrite; } printf("Error creating test file %x\n",GetLastError()); return FALSE; }
Log(2,"."); overlapped.Offset += BufferSize; }
for (i = 0; i < numberWrites; i++ ) { status = GetQueuedCompletionStatus(port, &bytesTransferred2, &key, &overlapped2, (DWORD)-1); if ( !status ) { printf("Error on completion during test file create %x\n",GetLastError()); return FALSE; } }
Log(1,".. Complete.\n\n");
EndCreateTestFile:
if(port != INVALID_HANDLE_VALUE) CloseHandle(port); if(fileHandle != INVALID_HANDLE_VALUE) CloseHandle(fileHandle);
VirtualFree(buffer, DEFAULT_BUFFER_SIZE, MEM_DECOMMIT);
return TRUE;}
BOOLEANReadSequential( ULONG Iterations ){ ULONG j, outstandingRequests, remaining = Iterations; ULONG start,end; DOUBLE testTime,thruPut = 0.0,seconds = 0; HANDLE file, port; OVERLAPPED overlapped, *overlapped2; DWORD bytesRead, bytesRead2, errCode, version; DWORD_PTR completionKey; BOOL status; PUCHAR buffer;
printf("Starting Sequential Reads of %d Meg file, using %d K I/O size\n", FileSize / 1024*1024, BufferSize / 1024);
version = GetVersion() >> 16;
buffer = VirtualAlloc(NULL, BufferSize + SectorSize - 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
(ULONG_PTR)buffer &= ~((ULONG_PTR)SectorSize - 1);
if ( !buffer ) { Log(0,"Error allocating buffer: %x\n",GetLastError()); return FALSE; }
file = CreateFile(FileName, ReadOnly ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE), 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL );
if ( file == INVALID_HANDLE_VALUE ) { Log(0,"Error opening Target file: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
port = CreateIoCompletionPort(file, NULL, (DWORD_PTR)file, 0); if ( !port ) { Log(0,"Error creating completion port: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
while (remaining--) {
start = GetTickCount();
memset(&overlapped,0,sizeof(overlapped));
outstandingRequests = 0;
for (j = 0; j < FileSize / BufferSize; j++) { do {
status = ReadFile(file, buffer, BufferSize, &bytesRead, &overlapped);
errCode = GetLastError();
if (!status) { if (errCode == ERROR_IO_PENDING) { break; } else if (errCode == ERROR_NOT_ENOUGH_QUOTA || errCode == ERROR_INVALID_USER_BUFFER || errCode == ERROR_WORKING_SET_QUOTA || errCode == ERROR_NOT_ENOUGH_MEMORY) { //
// Allow this to retry.
//
} else { Log(0,"Error in ReadFile: %x\n",errCode); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
} while (!status);
outstandingRequests++; overlapped.Offset += BufferSize; }
for (j = 0; j < outstandingRequests; j++) {
status = GetQueuedCompletionStatus(port, &bytesRead2, &completionKey, &overlapped2, (DWORD)-1);
if (!status) { Log(0,"GetQueuedCompletionStatus error: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
end = GetTickCount(); testTime = end - start; testTime /= 1000.0; seconds += testTime; Log(1,"Iteration %2d -> %4.3f MB/S\n",Iterations - remaining,(FileSize / testTime)/(1024*1024)); }
CloseHandle(port); CloseHandle(file);
thruPut = FileSize * Iterations / seconds; printf("\nAverage Throughput %4.3f MB/S\n",thruPut/(1024*1024));
VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT);
return TRUE;}
BOOLEANReadRandom( ULONG Iterations ){ ULONG j, outstandingRequests, remaining = Iterations; ULONG start,end; DOUBLE testTime,thruPut = 0.0,seconds = 0; HANDLE file, port; OVERLAPPED overlapped, *overlapped2; DWORD bytesRead, bytesRead2, errCode, version; DWORD_PTR completionKey; BOOL status; PUCHAR buffer;
ULONG min = FileSize,max = 0;
printf("Starting Random Reads of %d Meg file, using %d K I/O size\n", FileSize / 1024*1024, BufferSize / 1024);
version = GetVersion() >> 16; srand((unsigned)time(NULL));
buffer = VirtualAlloc(NULL, BufferSize + SectorSize - 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
(ULONG_PTR)buffer &= ~((ULONG_PTR)SectorSize - 1);
if ( !buffer ) { Log(0,"Error allocating buffer: %x\n",GetLastError()); return FALSE; }
file = CreateFile(FileName, ReadOnly ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE), 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL );
if ( file == INVALID_HANDLE_VALUE ) { Log(0,"Error opening Target file: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
port = CreateIoCompletionPort(file, NULL, (DWORD_PTR)file, 0); if ( !port ) { Log(0,"Error creating completion port: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
while (remaining--) {
start = GetTickCount();
memset(&overlapped,0,sizeof(overlapped));
outstandingRequests = 0;
for (j = 0; j < FileSize / BufferSize; j++) { do {
status = ReadFile(file, buffer, BufferSize, &bytesRead, &overlapped);
errCode = GetLastError();
if (!status) { if (errCode == ERROR_IO_PENDING) { break; } else if (errCode == ERROR_NOT_ENOUGH_QUOTA || errCode == ERROR_INVALID_USER_BUFFER || errCode == ERROR_WORKING_SET_QUOTA || errCode == ERROR_NOT_ENOUGH_MEMORY) { //
// Allow this to retry.
//
} else { Log(0,"Error in ReadFile: %x\n",errCode); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
} while (!status);
outstandingRequests++; overlapped.Offset = GetRandomOffset(0,FileSize - BufferSize); if (overlapped.Offset > max) { max = overlapped.Offset; } if (overlapped.Offset < min) { min = overlapped.Offset; } }
for (j = 0; j < outstandingRequests; j++) {
status = GetQueuedCompletionStatus(port, &bytesRead2, &completionKey, &overlapped2, (DWORD)-1);
if (!status) { Log(0,"GetQueuedCompletionStatus error: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
end = GetTickCount(); testTime = end - start; testTime /= 1000.0; seconds += testTime; Log(1,"Iteration %2d -> %4.3f MB/S\n",Iterations - remaining,(FileSize / testTime)/(1024*1024));
}
CloseHandle(port); CloseHandle(file);
thruPut = FileSize * Iterations / seconds; printf("\nAverage Throughput %4.3f MB/S\n",thruPut/(1024*1024)); Log(2,"Min = %Lu, Max = %Lu, FileSize = %Lu\n",min,max,FileSize);
VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT);
return TRUE;}
BOOLEANWriteSequential( ULONG Iterations ){ ULONG j, outstandingRequests, remaining = Iterations; ULONG start,end; DOUBLE testTime,thruPut = 0.0,seconds = 0; HANDLE file, port; OVERLAPPED overlapped, *overlapped2; DWORD bytesWritten, bytesWritten2, errCode, version; DWORD_PTR completionKey; BOOL status; PUCHAR buffer;
if(ReadOnly) { printf("Can't run write tests on a read only file\n"); return FALSE; }
printf("Starting Sequential Writes of %d Meg file, using %d K I/O size\n", FileSize / 1024*1024, BufferSize / 1024);
version = GetVersion() >> 16;
buffer = VirtualAlloc(NULL, BufferSize + SectorSize - 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
(ULONG_PTR)buffer &= ~((ULONG_PTR)SectorSize - 1);
if ( !buffer ) { Log(0,"Error allocating buffer: %x\n",GetLastError()); return FALSE; }
file = CreateFile(FileName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL );
if ( file == INVALID_HANDLE_VALUE ) { Log(0,"Error opening Target file: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
port = CreateIoCompletionPort(file, NULL, (DWORD_PTR)file, 0); if ( !port ) { Log(0,"Error creating completion port: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
while (remaining--) {
start = GetTickCount();
memset(&overlapped,0,sizeof(overlapped));
outstandingRequests = 0;
for (j = 0; j < FileSize / BufferSize; j++) { do {
status = WriteFile(file, buffer, BufferSize, &bytesWritten, &overlapped);
errCode = GetLastError();
if (!status) { if (errCode == ERROR_IO_PENDING) { break; } else if (errCode == ERROR_NOT_ENOUGH_QUOTA || errCode == ERROR_INVALID_USER_BUFFER || errCode == ERROR_WORKING_SET_QUOTA || errCode == ERROR_NOT_ENOUGH_MEMORY) { //
// Allow this to retry.
//
} else { Log(0,"Error in WriteFile: %x\n",errCode); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
} while (!status);
outstandingRequests++; overlapped.Offset += BufferSize; }
for (j = 0; j < outstandingRequests; j++) {
status = GetQueuedCompletionStatus(port, &bytesWritten2, &completionKey, &overlapped2, (DWORD)-1);
if (!status) { Log(0,"GetQueuedCompletionStatus error: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
end = GetTickCount(); testTime = end - start; testTime /= 1000.0; seconds += testTime; Log(1,"Iteration %2d -> %4.3f MB/S\n",Iterations - remaining,(FileSize / testTime)/(1024*1024));
}
CloseHandle(port); CloseHandle(file);
thruPut = FileSize * Iterations / seconds; printf("\nAverage Throughput %4.3f MB/S\n",thruPut/(1024*1024));
VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT);
return TRUE;}
BOOLEANWriteRandom( ULONG Iterations ){ ULONG j, outstandingRequests, remaining = Iterations; ULONG start,end; DOUBLE testTime,thruPut = 0.0,seconds = 0; HANDLE file, port; OVERLAPPED overlapped, *overlapped2; DWORD bytesWritten, bytesWritten2, errCode, version; DWORD_PTR completionKey; BOOL status; PUCHAR buffer; ULONG min = FileSize,max = 0;
if(ReadOnly) { printf("Can't run write tests on a read only file\n"); return FALSE; }
printf("Starting Random Writes of %d Meg file, using %d K I/O size\n", FileSize / 1024*1024, BufferSize / 1024);
version = GetVersion() >> 16;
buffer = VirtualAlloc(NULL, BufferSize + SectorSize - 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
(ULONG_PTR)buffer &= ~((ULONG_PTR)SectorSize - 1);
if ( !buffer ) { Log(0,"Error allocating buffer: %x\n",GetLastError()); return FALSE; }
file = CreateFile(FileName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, NULL );
if ( file == INVALID_HANDLE_VALUE ) { Log(0,"Error opening Target file: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
port = CreateIoCompletionPort(file, NULL, (DWORD_PTR)file, 0); if ( !port ) { Log(0,"Error creating completion port: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
while (remaining--) {
start = GetTickCount();
memset(&overlapped,0,sizeof(overlapped));
outstandingRequests = 0;
for (j = 0; j < FileSize / BufferSize; j++) { do {
status = WriteFile(file, buffer, BufferSize, &bytesWritten, &overlapped);
errCode = GetLastError();
if (!status) { if (errCode == ERROR_IO_PENDING) { break; } else if (errCode == ERROR_NOT_ENOUGH_QUOTA || errCode == ERROR_INVALID_USER_BUFFER || errCode == ERROR_WORKING_SET_QUOTA || errCode == ERROR_NOT_ENOUGH_MEMORY) { //
// Allow this to retry.
//
} else { Log(0,"Error in WriteFile: %x\n",errCode); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
} while (!status);
outstandingRequests++; overlapped.Offset = GetRandomOffset(0,FileSize - BufferSize); if (overlapped.Offset > max) { max = overlapped.Offset; } if (overlapped.Offset < min) { min = overlapped.Offset; } }
for (j = 0; j < outstandingRequests; j++) {
status = GetQueuedCompletionStatus(port, &bytesWritten2, &completionKey, &overlapped2, (DWORD)-1);
if (!status) { Log(0,"GetQueuedCompletionStatus error: %x\n",GetLastError()); VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT); return FALSE; }
}
end = GetTickCount(); testTime = end - start; testTime /= 1000.0; seconds += testTime; Log(1,"Iteration %2d -> %4.3f MB/S\n",Iterations - remaining,(FileSize / testTime)/(1024*1024));
}
CloseHandle(port); CloseHandle(file);
thruPut = FileSize * Iterations / seconds; printf("\nAverage Throughput %4.3f MB/S\n",thruPut/(1024*1024)); Log(2,"Min = %Lu, Max = %Lu, FileSize = %Lu\n",min,max,FileSize);
VirtualFree(buffer, BufferSize + SectorSize - 1, MEM_DECOMMIT);
return TRUE;}
ULONGGetRandomOffset( ULONG min, ULONG max ){
INT base = rand(); ULONG retval = ((max - min) / RAND_MAX) * base; retval += SectorSize - 1; retval &= ~(SectorSize - 1); if (retval < min) { return min; } else if (retval > max ){ return max & ~(SectorSize - 1); } else{ return retval; }
}
BOOLEANParseCmdLine( INT Argc, CHAR *Argv[] ){
INT i; CHAR *switches = " ,-"; CHAR swtch,*value,*str; BOOLEAN gotSwitch = FALSE;
if (Argc <= 1) {
//
// Using defaults
//
return TRUE; }
for (i = 1; i < Argc; i++) { str = Argv[i]; value = strtok(str, switches); if (gotSwitch) { if (!ValidateOption(swtch,value)) { Usage(); return FALSE; } else { gotSwitch = FALSE; } } else { gotSwitch = TRUE; swtch = value[0]; if (value[1] || swtch == '?') { Usage(); return FALSE; } } } if (gotSwitch) {
Usage(); return FALSE; } else { return TRUE; }
}
BOOLEANValidateOption( CHAR Switch, CHAR *Value ){ Switch = (CHAR)toupper(Switch); switch (Switch) {
case 'F':
VerifyFileName(Value); strcpy(FileName,Value); break;
case 'T': if (_stricmp(Value,"READ")==0) { Test = READ; } else if (_stricmp(Value,"WRITE")==0) { Test = WRITE; } else { return FALSE; }
break;
case 'A':
if (_strnicmp(Value,"SEQ",3)==0) { Access = SEQ; } else if (_strnicmp(Value,"RAND",4)==0) { Access = RAND; } else { return FALSE; }
break;
case 'B': BufferSize = atol(Value);
//
// TODO:Adjust buffersize to multiple of a sector and #of K.
//
BufferSize *= 1024; break;
case 'S':
FileSize = atol(Value);
//
// TODO: Adjust filesize to multiple of buffersize and #of Meg.
//
FileSize *= 1024*1024; break;
case 'V':
Verbose = atol(Value); break;
case 'I':
Iterations = atol(Value); break;
case 'R':
if(tolower(Value[0]) == 'y') { ReuseFile = TRUE; } else { ReuseFile = FALSE; }
break;
case 'O':
if(tolower(Value[0]) == 'y') { ReadOnly = TRUE; } else { ReadOnly = FALSE; }
break;
default: return FALSE; } return TRUE;}
VOIDUsage( VOID ){
fprintf(stderr,"usage: YAPT (Yet another performance tool)\n" " -f [filename]\n" " -t [Test:Read,Write]\n" " -a [Access Mode:Seq or Random]\n" " -b [buffer size in KB]\n" " -s [filesize]\n" " -i [Iterations]\n" " -v [Verbosity: 0-2]\n" " -r [Reuse test file: yes, no]\n" " -o [Read Only: yes, no]\n" );}
VOID__cdeclLog( ULONG LogLevel, PCHAR String, ... ){
CHAR Buffer[256];
va_list argp; va_start(argp, String);
if (LogLevel <= Verbose) { vsprintf(Buffer, String, argp); printf("%s",Buffer); }
va_end(argp);}
DWORDYaptSetFileCompression( IN HANDLE FileHandle, IN USHORT CompressionFormat )
{ DWORD bytesReturned;
assert(FileHandle != INVALID_HANDLE_VALUE);
if(!DeviceIoControl( FileHandle, FSCTL_SET_COMPRESSION, &CompressionFormat, sizeof(CompressionFormat), NULL, 0, &bytesReturned, NULL)) {
}
return GetLastError();}
VOIDVerifyFileName( IN CHAR *FileName )
{ CHAR input[32];
if(Yes) return;
if(((FileName[0] == '\\') || (FileName[0] == '/')) && ((FileName[1] == '\\') || (FileName[1] == '/')) && ((FileName[2] == '.') || (FileName[2] == '?')) && ((FileName[3] == '\\') || (FileName[3] == '/'))) {
printf("\n\t%s looks like a raw device\n" "\tdo you want to continue? ", FileName);
fflush(stdout);
if(fgets(input, 32, stdin) == NULL) {
printf("\nQuitting\n"); exit(-1); }
if(tolower(input[0]) != 'y') {
printf("\nNegative response - quitting\n"); exit(-1); }
}
return;}
|
