mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1653 lines
43 KiB
1653 lines
43 KiB
|
|
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
diskmon.c
|
|
|
|
Abstract:
|
|
|
|
This module contians the code for the disk monitor utility.
|
|
|
|
Author:
|
|
|
|
Chuck Park (chuckp) 15-Feb-1994
|
|
Mike Glass (mglass)
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <ntdddisk.h>
|
|
#include <windows.h>
|
|
|
|
#include <windowsx.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#include "dskbench.h"
|
|
|
|
CHAR TestDrv[8] = "\\\\.\\";
|
|
CHAR TestFile[MAX_PATH];
|
|
CHAR TimerText[] = "00:00:00:00";
|
|
DWORD SectorSize;
|
|
HANDLE DrvStrHandle;
|
|
|
|
HANDLE ThrdHandle;
|
|
ULONG BufferSize = 0,
|
|
IoCount = 0,
|
|
index = 0,
|
|
Seconds = 0,
|
|
Minutes = 0,
|
|
Hours = 0,
|
|
Days = 0,
|
|
ElapsedTime = 0,
|
|
NumberIOs = 0;
|
|
|
|
BOOL RunTest = FALSE;
|
|
BOOL TestFileCreated = FALSE;
|
|
BOOL KillFileCreate = FALSE;
|
|
|
|
PARAMS Params;
|
|
FILE_PARAMS TestFileParams;
|
|
|
|
HINSTANCE HInst;
|
|
HWND Gauge;
|
|
DWORD GaugeId;
|
|
|
|
//
|
|
// Thread proc. declarations
|
|
//
|
|
|
|
DWORD
|
|
ReadSequential(
|
|
PPARAMS pParams
|
|
);
|
|
|
|
DWORD
|
|
WriteSequential(
|
|
PPARAMS pParams
|
|
);
|
|
|
|
DWORD
|
|
ReadRandom(
|
|
PPARAMS pParams
|
|
);
|
|
|
|
DWORD
|
|
WriteRandom(
|
|
PPARAMS pParams
|
|
);
|
|
|
|
|
|
//
|
|
// Common util. functions
|
|
//
|
|
|
|
ULONG
|
|
GetRandomOffset(
|
|
ULONG min,
|
|
ULONG max
|
|
);
|
|
|
|
|
|
BOOL
|
|
GetSectorSize(
|
|
PDWORD SectorSize,
|
|
PCHAR DrvLetter
|
|
);
|
|
|
|
VOID
|
|
LogError(
|
|
PCHAR ErrString,
|
|
DWORD UniqueId,
|
|
DWORD ErrCode
|
|
);
|
|
|
|
|
|
VOID
|
|
Usage(
|
|
VOID
|
|
);
|
|
|
|
LPTHREAD_START_ROUTINE
|
|
TestProc[4] = {ReadSequential,
|
|
ReadRandom,
|
|
WriteSequential,
|
|
WriteRandom
|
|
};
|
|
|
|
|
|
BOOL
|
|
InitDialog (
|
|
HWND hwnd,
|
|
HWND hwndFocus,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
BOOLEAN Found = FALSE;
|
|
CHAR buffer[34];
|
|
DWORD bytes;
|
|
HWND Drives = GetDlgItem (hwnd,DRV_BOX);
|
|
PCHAR lp;
|
|
UINT i = 0,
|
|
NoDrives = 0;
|
|
|
|
srand(GetTickCount());
|
|
Button_Enable(GetDlgItem(hwnd,STOP_BUTTON), FALSE);
|
|
|
|
|
|
//
|
|
// Get attached drives, filter out non-disk drives, and fill drive box.
|
|
//
|
|
|
|
bytes = GetLogicalDriveStrings(0,NULL);
|
|
|
|
DrvStrHandle = VirtualAlloc(NULL,bytes + 1,
|
|
MEM_COMMIT | MEM_RESERVE,
|
|
PAGE_READWRITE);
|
|
|
|
GetLogicalDriveStrings( bytes, DrvStrHandle);
|
|
for (lp = DrvStrHandle;*lp; ) {
|
|
if (GetDriveType(lp) == DRIVE_FIXED) {
|
|
ComboBox_AddString(Drives,lp);
|
|
++NoDrives;
|
|
}
|
|
while(*lp++);
|
|
}
|
|
|
|
//
|
|
// Check for cmd line params passed in, and set the test drive to either
|
|
// the specified drive, or to the first in the drive list.
|
|
//
|
|
|
|
ComboBox_SetCurSel (Drives,0);
|
|
if (TestDrv[4] != '\0') {
|
|
do {
|
|
ComboBox_GetText(GetDlgItem(hwnd,DRV_BOX),buffer,4);
|
|
if (buffer[0] == TestDrv[4]) {
|
|
Found = TRUE;
|
|
} else {
|
|
if (++i >= NoDrives) {
|
|
Found = TRUE;
|
|
} else {
|
|
ComboBox_SetCurSel (Drives,i);
|
|
}
|
|
}
|
|
} while (!Found);
|
|
if (i >= NoDrives) {
|
|
|
|
//
|
|
// Couldn't find the drive, exit with a message.
|
|
//
|
|
|
|
LogError("Incorrect Drive Letter in command line.",1,0);
|
|
EndDialog(hwnd,0);
|
|
return FALSE;
|
|
}
|
|
|
|
} else {
|
|
ComboBox_SetCurSel (Drives,0);
|
|
}
|
|
|
|
//
|
|
// Get the sector size for the default selection.
|
|
//
|
|
TestDrv[4] = '\0';
|
|
ComboBox_GetText(GetDlgItem(hwnd,DRV_BOX),buffer, 4);
|
|
strcat (TestDrv,buffer);
|
|
TestDrv[6] = '\0';
|
|
GetSectorSize(&SectorSize,TestDrv);
|
|
|
|
//
|
|
// If index is 0, use defaults, otherwise set the test according to
|
|
// the cmdline passes in.
|
|
//
|
|
|
|
Button_SetCheck(GetDlgItem(hwnd,TEST_RAD_READ + (index >> 1)), TRUE);
|
|
Button_SetCheck(GetDlgItem(hwnd,VAR_RAD_SEQ + (index & 0x01)),TRUE);
|
|
|
|
//
|
|
// Set buffer size.
|
|
//
|
|
|
|
if (BufferSize == 0) {
|
|
|
|
BufferSize = 65536;
|
|
NumberIOs = FILE_SIZE / BufferSize;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Verify that buffersize is a multiple of sector size, if not adjust it.
|
|
//
|
|
|
|
if (BufferSize % SectorSize) {
|
|
BufferSize &= ~(SectorSize - 1);
|
|
}
|
|
|
|
NumberIOs = FILE_SIZE / BufferSize;
|
|
|
|
//
|
|
// Cmd line was present and has been used to config. the test. Send a message
|
|
// to the start button to get things rolling.
|
|
//
|
|
|
|
SendMessage(hwnd,WM_COMMAND,(BN_CLICKED << 16) | START_BUTTON,(LPARAM)GetDlgItem(hwnd,START_BUTTON));
|
|
}
|
|
_ultoa(BufferSize,buffer,10);
|
|
Static_SetText(GetDlgItem(hwnd,BUFFER_TEXT),buffer);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
DWORD
|
|
CreateTestFile(
|
|
PFILE_PARAMS FileParams
|
|
)
|
|
{
|
|
PCHAR index = FileParams->TestDrive;
|
|
PUCHAR buffer;
|
|
CHAR errBuf[80];
|
|
HANDLE file,port;
|
|
OVERLAPPED overlapped,*overlapped2;
|
|
DWORD bytesTransferred,bytesTransferred2,key;
|
|
BOOLEAN status;
|
|
ULONG i;
|
|
|
|
while (*index == '\\' || *index == '.') {
|
|
index++;
|
|
}
|
|
|
|
strcpy(FileParams->TestFile,index);
|
|
strcat(FileParams->TestFile,"\\test.dat");
|
|
DeleteFile(FileParams->TestFile);
|
|
|
|
buffer = VirtualAlloc(NULL,
|
|
BufferSize,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE);
|
|
|
|
if ( !buffer ) {
|
|
sprintf(errBuf,"Error allocating buffer %d\n",GetLastError());
|
|
MessageBox(NULL,errBuf,"Error",MB_ICONEXCLAMATION|MB_OK);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
file = CreateFile(FileParams->TestFile,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if ( file == INVALID_HANDLE_VALUE ) {
|
|
sprintf(errBuf,"Error opening file %s %d\n",FileParams->TestFile,GetLastError());
|
|
MessageBox(NULL,errBuf,"Error",MB_ICONEXCLAMATION|MB_OK);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
port = CreateIoCompletionPort(file,
|
|
NULL,
|
|
(DWORD)file,
|
|
0);
|
|
if ( !port ) {
|
|
sprintf(errBuf,"Error creating completion port %d\n",FileParams->TestFile,GetLastError());
|
|
MessageBox(NULL,errBuf,"Error",MB_ICONEXCLAMATION|MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
memset(&overlapped,0,sizeof(overlapped));
|
|
|
|
for (i = 0; i < NumberIOs; i++) {
|
|
|
|
//
|
|
// If user aborted file create, exit.
|
|
//
|
|
|
|
if (KillFileCreate) {
|
|
|
|
DeleteFile(FileParams->TestFile);
|
|
|
|
ExitThread(4);
|
|
return 4;
|
|
}
|
|
|
|
retryWrite:
|
|
status = WriteFile(file,
|
|
buffer,
|
|
BufferSize,
|
|
&bytesTransferred,
|
|
&overlapped);
|
|
|
|
if ( !status && GetLastError() != ERROR_IO_PENDING ) {
|
|
if (GetLastError() == ERROR_INVALID_USER_BUFFER ||
|
|
GetLastError() == ERROR_NOT_ENOUGH_QUOTA ||
|
|
GetLastError() == ERROR_NOT_ENOUGH_MEMORY) {
|
|
|
|
goto retryWrite;
|
|
}
|
|
sprintf(errBuf,"Error creating test file %d\n",GetLastError());
|
|
MessageBox(NULL,errBuf,"Error",MB_ICONEXCLAMATION|MB_OK);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
//
|
|
// Update gauge.
|
|
//
|
|
|
|
DrawMeterBar(FileParams->Window,GaugeId,i / 2,NumberIOs,FALSE);
|
|
|
|
overlapped.Offset += BufferSize;
|
|
}
|
|
|
|
for (i = 0; i < NumberIOs; i++ ) {
|
|
status = GetQueuedCompletionStatus(port,
|
|
&bytesTransferred2,
|
|
&key,
|
|
&overlapped2,
|
|
(DWORD)-1);
|
|
if ( !status ) {
|
|
sprintf(errBuf,"Error picking up completion pre-write %d\n",GetLastError());
|
|
MessageBox(NULL,errBuf,"Error",MB_ICONEXCLAMATION|MB_OK);
|
|
ExitThread(2);
|
|
return 2;
|
|
}
|
|
|
|
DrawMeterBar(FileParams->Window,GaugeId, NumberIOs / 2 + i / 2,NumberIOs,FALSE);
|
|
}
|
|
|
|
CloseHandle(port);
|
|
CloseHandle(file);
|
|
|
|
ExitThread(1);
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// Progress gauge courtesy of wesw
|
|
//
|
|
|
|
VOID
|
|
DrawMeterBar(
|
|
HWND hwnd,
|
|
DWORD ctlId,
|
|
DWORD wPartsComplete,
|
|
DWORD wPartsInJob,
|
|
BOOL fRedraw
|
|
)
|
|
{
|
|
RECT rcPrcnt;
|
|
DWORD dwColor;
|
|
SIZE size;
|
|
DWORD pct;
|
|
CHAR szPercentage[255];
|
|
HPEN hpen;
|
|
HPEN oldhpen;
|
|
HDC hDC;
|
|
RECT rcItem;
|
|
POINT pt;
|
|
|
|
|
|
wPartsComplete == 0;
|
|
|
|
hDC = GetDC( hwnd );
|
|
|
|
GetWindowRect( GetDlgItem(hwnd,ctlId), &rcItem );
|
|
|
|
pt.x = rcItem.left;
|
|
pt.y = rcItem.top;
|
|
ScreenToClient( hwnd, &pt );
|
|
rcItem.left = pt.x;
|
|
rcItem.top = pt.y;
|
|
|
|
pt.x = rcItem.right;
|
|
pt.y = rcItem.bottom;
|
|
ScreenToClient( hwnd, &pt );
|
|
rcItem.right = pt.x;
|
|
rcItem.bottom = pt.y;
|
|
|
|
hpen = CreatePen( PS_SOLID, 1, RGB(0,0,0) );
|
|
oldhpen = SelectObject( hDC, hpen );
|
|
if (fRedraw) {
|
|
Rectangle( hDC, rcItem.left, rcItem.top, rcItem.right, rcItem.bottom );
|
|
}
|
|
SelectObject( hDC, oldhpen );
|
|
DeleteObject( hpen );
|
|
rcItem.left += 2;
|
|
rcItem.top += 2;
|
|
rcItem.right -= 2;
|
|
rcItem.bottom -= 2;
|
|
|
|
//
|
|
// Set-up default foreground and background text colors.
|
|
//
|
|
SetBkColor( hDC, RGB(125,125,125) );
|
|
SetTextColor( hDC, RGB(125,58,125) );
|
|
|
|
SetTextAlign(hDC, TA_CENTER | TA_TOP);
|
|
|
|
//
|
|
// Invert the foreground and background colors.
|
|
//
|
|
dwColor = GetBkColor(hDC);
|
|
SetBkColor(hDC, SetTextColor(hDC, dwColor));
|
|
|
|
//
|
|
// calculate the percentage done
|
|
//
|
|
try {
|
|
pct = (DWORD)((float)wPartsComplete / (float)wPartsInJob * 100.0);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
pct = 0;
|
|
}
|
|
|
|
//
|
|
// Set rectangle coordinates to include only left part of the window
|
|
//
|
|
rcPrcnt.top = rcItem.top;
|
|
rcPrcnt.bottom = rcItem.bottom;
|
|
rcPrcnt.left = rcItem.left;
|
|
rcPrcnt.right = rcItem.left +
|
|
(DWORD)((float)(rcItem.right - rcItem.left) * ((float)pct / 100));
|
|
|
|
//
|
|
// Output the percentage value in the window.
|
|
// Function also paints left part of window.
|
|
//
|
|
wsprintf(szPercentage, "%d%%", pct);
|
|
GetTextExtentPoint(hDC, "X", 1, &size);
|
|
ExtTextOut( hDC,
|
|
(rcItem.right - rcItem.left) / 2,
|
|
rcItem.top + ((rcItem.bottom - rcItem.top - size.cy) / 2),
|
|
ETO_OPAQUE | ETO_CLIPPED,
|
|
&rcPrcnt,
|
|
szPercentage,
|
|
strlen(szPercentage),
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Adjust rectangle so that it includes the remaining
|
|
// percentage of the window.
|
|
//
|
|
rcPrcnt.left = rcPrcnt.right;
|
|
rcPrcnt.right = rcItem.right;
|
|
|
|
//
|
|
// Invert the foreground and background colors.
|
|
//
|
|
dwColor = GetBkColor(hDC);
|
|
SetBkColor(hDC, SetTextColor(hDC, dwColor));
|
|
|
|
//
|
|
// Output the percentage value a second time in the window.
|
|
// Function also paints right part of window.
|
|
//
|
|
ExtTextOut( hDC,
|
|
(rcItem.right - rcItem.left) / 2,
|
|
rcItem.top + ((rcItem.bottom - rcItem.top - size.cy) / 2),
|
|
ETO_OPAQUE | ETO_CLIPPED,
|
|
&rcPrcnt,
|
|
szPercentage,
|
|
strlen(szPercentage),
|
|
NULL
|
|
);
|
|
ReleaseDC( hwnd, hDC );
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
ProcessCommands(
|
|
HWND hwnd,
|
|
INT id,
|
|
HWND hwndCtl,
|
|
UINT codeNotify)
|
|
{
|
|
DWORD exitCode;
|
|
CHAR buffer[20];
|
|
ULONG tid;
|
|
ULONG units;
|
|
|
|
switch (id) {
|
|
case DRV_BOX:
|
|
if (codeNotify == CBN_KILLFOCUS) {
|
|
|
|
//
|
|
// Determine sector size of chosen drive.
|
|
//
|
|
|
|
ComboBox_GetText(GetDlgItem(hwnd,DRV_BOX),buffer, 4);
|
|
sprintf(TestDrv,"\\\\.\\");
|
|
strcat(TestDrv,buffer);
|
|
TestDrv[6] = '\0';
|
|
GetSectorSize(&SectorSize,TestDrv);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case START_BUTTON:
|
|
|
|
if (!TestFileCreated) {
|
|
|
|
//
|
|
// Create gauge window.
|
|
//
|
|
|
|
units = GetDialogBaseUnits();
|
|
|
|
Gauge = CreateWindow("static","",
|
|
WS_CHILD | WS_VISIBLE | SS_BLACKFRAME,
|
|
(INT)(10 * (units & 0xFFFF) / 4),
|
|
(INT)(60 * (units >> 16) / 8),
|
|
(INT)(150 * (units & 0xFFFF) / 4),
|
|
(INT)(12 * (units >> 16) / 8),
|
|
hwnd,
|
|
(HMENU)(26),
|
|
HInst,
|
|
NULL);
|
|
|
|
GaugeId = GetDlgCtrlID(Gauge);
|
|
|
|
TestFileParams.TestDrive = TestDrv;
|
|
TestFileParams.TestFile = TestFile;
|
|
TestFileParams.Window = hwnd;
|
|
|
|
ThrdHandle = CreateThread (NULL,0,(LPTHREAD_START_ROUTINE)CreateTestFile, &TestFileParams,CREATE_SUSPENDED,&tid);
|
|
|
|
//
|
|
// Disable controls
|
|
//
|
|
|
|
Button_Enable(GetDlgItem(hwnd,STOP_BUTTON), TRUE);
|
|
SetFocus(GetDlgItem(hwnd,STOP_BUTTON));
|
|
Button_Enable(GetDlgItem(hwnd,START_BUTTON), FALSE);
|
|
|
|
SetTimer(hwnd,TIMER_ID2,1000,(TIMERPROC)NULL);
|
|
|
|
ResumeThread(ThrdHandle);
|
|
|
|
sprintf(buffer,"CREATING TEST FILE");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_TEST), buffer);
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Determine the test drive.
|
|
//
|
|
|
|
strcpy(TestDrv,"\\\\.\\");
|
|
ComboBox_GetText(GetDlgItem(hwnd,DRV_BOX),buffer, 4);
|
|
strcat (TestDrv,buffer);
|
|
TestDrv[6] = '\0';
|
|
|
|
//
|
|
// Determine the test case.
|
|
//
|
|
|
|
index = Button_GetCheck(GetDlgItem(hwnd,TEST_RAD_WRITE));
|
|
index <<= 1;
|
|
index |= Button_GetCheck(GetDlgItem(hwnd,VAR_RAD_RAND));
|
|
|
|
//
|
|
// Update the status fields
|
|
//
|
|
|
|
sprintf(buffer,"%Lu",BufferSize);
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_BUFFER ),buffer);
|
|
sprintf(buffer,"%d",IoCount);
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_IOCOUNT), buffer);
|
|
|
|
sprintf(buffer,"%s",(index >> 1) ? "Write" : "Read");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_CASE), buffer);
|
|
|
|
sprintf(buffer,"%s",(index & 0x1) ? "Random" : "Sequential");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_CASE1), buffer);
|
|
|
|
sprintf(buffer,"RUNNING");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_TEST), buffer);
|
|
|
|
ElapsedTime = Seconds = Minutes = Hours = Days = 0;
|
|
SetTimer(hwnd,TIMER_ID,1000,(TIMERPROC)NULL);
|
|
|
|
//
|
|
// Gather parameters and launch the test.
|
|
//
|
|
|
|
Params.BufferSize = BufferSize;
|
|
Params.TargetFile = TestFile;
|
|
Params.Tcount = NumberIOs;
|
|
|
|
RunTest = TRUE;
|
|
|
|
//
|
|
// Launch the thread.
|
|
//
|
|
|
|
ThrdHandle = CreateThread (NULL,
|
|
0,
|
|
TestProc[index],
|
|
&Params,
|
|
CREATE_SUSPENDED,
|
|
&tid
|
|
);
|
|
|
|
ResumeThread(ThrdHandle);
|
|
|
|
//
|
|
// Disable controls
|
|
//
|
|
|
|
Button_Enable(GetDlgItem(hwnd,STOP_BUTTON), TRUE);
|
|
SetFocus(GetDlgItem(hwnd,STOP_BUTTON));
|
|
Button_Enable(GetDlgItem(hwnd,START_BUTTON), FALSE);
|
|
|
|
break;
|
|
|
|
case STOP_BUTTON:
|
|
|
|
if (!TestFileCreated) {
|
|
|
|
//
|
|
// Kill the test file create thread.
|
|
//
|
|
|
|
KillFileCreate = TRUE;
|
|
|
|
WaitForSingleObject(ThrdHandle,INFINITE);
|
|
|
|
//
|
|
// Redo button enable/disable/focus
|
|
//
|
|
|
|
Button_Enable(GetDlgItem(hwnd,START_BUTTON), TRUE);
|
|
Button_Enable(GetDlgItem(hwnd,STOP_BUTTON), FALSE);
|
|
|
|
SetFocus(GetDlgItem(hwnd,START_BUTTON));
|
|
|
|
KillTimer(hwnd, TIMER_ID2);
|
|
KillFileCreate = FALSE;
|
|
|
|
sprintf(buffer,"STOPPED");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_TEST), buffer);
|
|
|
|
DestroyWindow(Gauge);
|
|
UpdateWindow(hwnd);
|
|
|
|
break;
|
|
}
|
|
|
|
KillTimer(hwnd, TIMER_ID);
|
|
|
|
//
|
|
// If the thread is not running disregard it.
|
|
//
|
|
|
|
GetExitCodeThread(ThrdHandle,&exitCode);
|
|
if (exitCode == STILL_ACTIVE) {
|
|
|
|
//
|
|
// Set flag to kill the threads.
|
|
//
|
|
|
|
RunTest = FALSE;
|
|
|
|
if ((WaitForSingleObject (ThrdHandle,INFINITE)) == WAIT_FAILED) {
|
|
|
|
//
|
|
// TODO: Do something drastic.
|
|
//
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Re-enable/disable buttons
|
|
//
|
|
|
|
Button_Enable(GetDlgItem(hwnd,START_BUTTON), TRUE);
|
|
Button_Enable(GetDlgItem(hwnd,STOP_BUTTON), FALSE);
|
|
|
|
|
|
SetFocus(GetDlgItem(hwnd,START_BUTTON));
|
|
|
|
sprintf(buffer,"STOPPED");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_TEST), buffer);
|
|
|
|
|
|
break;
|
|
|
|
case QUIT_BUTTON:
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, id);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
ProcessSpinCmds(
|
|
HWND hwnd,
|
|
HWND hCtl,
|
|
UINT code,
|
|
INT position)
|
|
{
|
|
CHAR buffer[34];
|
|
|
|
|
|
if (hCtl == GetDlgItem(hwnd,SPIN_CTL)) {
|
|
|
|
//
|
|
// Get the current buffer size
|
|
//
|
|
|
|
Static_GetText(GetDlgItem(hwnd,BUFFER_TEXT),buffer,sizeof(buffer));
|
|
BufferSize = atol(buffer);
|
|
switch (code) {
|
|
case SB_PAGEDOWN:
|
|
case SB_BOTTOM:
|
|
case SB_LINEDOWN:
|
|
if ((BufferSize -= SectorSize) < SectorSize) {
|
|
BufferSize = 1048576;
|
|
}
|
|
|
|
NumberIOs = FILE_SIZE / BufferSize;
|
|
_ultoa(BufferSize,buffer,10);
|
|
Static_SetText(GetDlgItem(hwnd,BUFFER_TEXT),buffer);
|
|
break;
|
|
|
|
case SB_LINEUP:
|
|
case SB_PAGEUP:
|
|
case SB_TOP:
|
|
|
|
if ((BufferSize += SectorSize) > 1048576) {
|
|
BufferSize = SectorSize;
|
|
}
|
|
|
|
NumberIOs = FILE_SIZE / BufferSize;
|
|
_ultoa(BufferSize,buffer,10);
|
|
Static_SetText(GetDlgItem(hwnd,BUFFER_TEXT),buffer);
|
|
break;
|
|
|
|
case SB_THUMBPOSITION:
|
|
case SB_THUMBTRACK:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
FormatTime(ULONG Time)
|
|
{
|
|
|
|
++Seconds;
|
|
if (Seconds % 60 == 0) {
|
|
++Minutes;
|
|
Seconds = 0;
|
|
|
|
if(Minutes % 60 == 0) {
|
|
++Hours;
|
|
Minutes = 0;
|
|
|
|
if(Hours % 24 == 0) {
|
|
++Days;
|
|
Hours = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
sprintf(TimerText,"%02d:%02d:%02d:%02d",Days,Hours,Minutes,Seconds);
|
|
}
|
|
|
|
VOID
|
|
ProcessTimer(
|
|
HWND hwnd,
|
|
UINT id)
|
|
{
|
|
|
|
CHAR buffer[40];
|
|
|
|
if (id == TIMER_ID) {
|
|
|
|
++ElapsedTime;
|
|
FormatTime (ElapsedTime);
|
|
SetWindowText(GetDlgItem(hwnd,TIME_TEXT),TimerText);
|
|
|
|
} else if (id == TIMER_ID2) {
|
|
|
|
//
|
|
// Get status of file create thread.
|
|
//
|
|
|
|
if ( WaitForSingleObject (ThrdHandle,0) == WAIT_OBJECT_0) {
|
|
|
|
TestFileCreated = TRUE;
|
|
KillTimer(hwnd, TIMER_ID2);
|
|
|
|
DestroyWindow(Gauge);
|
|
UpdateWindow(hwnd);
|
|
|
|
//
|
|
// Redo controls
|
|
//
|
|
|
|
Button_Enable(GetDlgItem(hwnd,START_BUTTON), TRUE);
|
|
Button_Enable(GetDlgItem(hwnd,STOP_BUTTON), FALSE);
|
|
SetFocus(GetDlgItem(hwnd,START_BUTTON));
|
|
|
|
|
|
sprintf(buffer,"READY");
|
|
Static_SetText(GetDlgItem(hwnd,STATUS_TEST), buffer);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
BOOL CALLBACK
|
|
BenchDlgProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
|
|
|
|
BOOL Processed = TRUE;
|
|
|
|
switch (uMsg) {
|
|
HANDLE_MSG(hDlg, WM_INITDIALOG, InitDialog);
|
|
HANDLE_MSG(hDlg, WM_COMMAND, ProcessCommands);
|
|
HANDLE_MSG(hDlg, WM_VSCROLL, ProcessSpinCmds);
|
|
HANDLE_MSG(hDlg, WM_TIMER, ProcessTimer);
|
|
|
|
default:
|
|
Processed = FALSE;
|
|
break;
|
|
}
|
|
return Processed;
|
|
}
|
|
|
|
|
|
|
|
|
|
INT APIENTRY
|
|
WinMain(
|
|
HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR CmdLine,
|
|
INT CmdShow)
|
|
{
|
|
CHAR buffer[10];
|
|
PCHAR tmp = buffer,
|
|
cmdLinePtr,
|
|
ptr;
|
|
//
|
|
// Check for, and process cmd line.
|
|
//
|
|
|
|
HInst = hInstance;
|
|
|
|
cmdLinePtr = CmdLine;
|
|
if (*cmdLinePtr != '\0') {
|
|
|
|
while (*cmdLinePtr != '\0') {
|
|
tmp = buffer;
|
|
memset (tmp,0,sizeof(buffer));
|
|
if (*cmdLinePtr == '-') {
|
|
switch (*(cmdLinePtr + 1)) {
|
|
case 'b':
|
|
case 'B':
|
|
ptr = cmdLinePtr + 2;
|
|
while (*ptr != ' ') {
|
|
*tmp++ = *ptr++;
|
|
}
|
|
BufferSize = 1024 * atol(buffer);
|
|
cmdLinePtr = ptr;
|
|
while (*cmdLinePtr++ == ' ');
|
|
--cmdLinePtr;
|
|
break;
|
|
case 't':
|
|
case 'T':
|
|
ptr = cmdLinePtr + 2;
|
|
if (*ptr != 'r' && *ptr != 'R' && *ptr != 'w' && *ptr != 'W') {
|
|
Usage();
|
|
return 1;
|
|
}
|
|
index = (*ptr == 'R' || *ptr == 'r') ? 0 : 1;
|
|
++ptr;
|
|
|
|
if (*ptr != 's' && *ptr != 'S' && *ptr != 'r' && *ptr != 'R') {
|
|
Usage();
|
|
return 1;
|
|
}
|
|
index <<= 1;
|
|
index |= (*ptr == 'S' || *ptr == 's') ? 0 : 1;
|
|
++ptr;
|
|
cmdLinePtr = ptr;
|
|
while (*cmdLinePtr++ == ' ');
|
|
--cmdLinePtr;
|
|
break;
|
|
|
|
default:
|
|
Usage();
|
|
return 1;
|
|
}
|
|
} else if (*(cmdLinePtr + 1) == ':') {
|
|
sprintf (buffer,"%c%c%c",toupper(*cmdLinePtr),':','\\');
|
|
strcat (TestDrv,buffer);
|
|
|
|
while (*cmdLinePtr++ != ' ');
|
|
while (*cmdLinePtr++ == ' ');
|
|
|
|
--cmdLinePtr;
|
|
|
|
} else {
|
|
Usage();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
DialogBox(hInstance, MAKEINTRESOURCE(BENCH_DLG),
|
|
NULL, BenchDlgProc);
|
|
return(0);
|
|
}
|
|
|
|
|
|
DWORD
|
|
ReadSequential(
|
|
PPARAMS Params
|
|
)
|
|
{
|
|
ULONG j,
|
|
errCode,
|
|
outstandingRequests;
|
|
HANDLE file,
|
|
port;
|
|
OVERLAPPED overlapped,
|
|
*overlapped2;
|
|
DWORD bytesRead,
|
|
bytesRead2,
|
|
completionKey,
|
|
version;
|
|
BOOLEAN status;
|
|
PUCHAR buffer;
|
|
|
|
|
|
version = GetVersion() >> 16;
|
|
|
|
buffer = VirtualAlloc(NULL,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_COMMIT | MEM_RESERVE,
|
|
PAGE_READWRITE);
|
|
|
|
(ULONG)buffer &= ~(SectorSize - 1);
|
|
|
|
if ( !buffer ) {
|
|
LogError("Error allocating buffer",1,GetLastError());
|
|
ExitThread(1);
|
|
return 2;
|
|
}
|
|
|
|
while (RunTest) {
|
|
|
|
file = CreateFile(Params->TargetFile,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if ( file == INVALID_HANDLE_VALUE ) {
|
|
LogError("Error opening Target file",2,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(2);
|
|
return 2;
|
|
}
|
|
|
|
port = CreateIoCompletionPort(file,
|
|
NULL,
|
|
(DWORD)file,
|
|
0);
|
|
if ( !port ) {
|
|
LogError("Error creating completion port",3,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
memset(&overlapped,0,sizeof(overlapped));
|
|
|
|
outstandingRequests = 0;
|
|
|
|
for (j = 0; j < Params->Tcount; j++) {
|
|
do {
|
|
|
|
status = ReadFile(file,
|
|
buffer,
|
|
Params->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_NOT_ENOUGH_MEMORY) {
|
|
//
|
|
// Allow this to retry.
|
|
//
|
|
|
|
} else {
|
|
LogError("Error in ReadFile",4,errCode);
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(4);
|
|
return 4;
|
|
}
|
|
|
|
}
|
|
|
|
} while (!status);
|
|
|
|
outstandingRequests++;
|
|
overlapped.Offset += Params->BufferSize;
|
|
}
|
|
|
|
for (j = 0; j < outstandingRequests; j++) {
|
|
|
|
status = GetQueuedCompletionStatus(port,
|
|
&bytesRead2,
|
|
&completionKey,
|
|
&overlapped2,
|
|
(DWORD)-1);
|
|
|
|
if (!status) {
|
|
LogError("GetQueuedCompletionStatus error.",5,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(5);
|
|
return 5;
|
|
}
|
|
|
|
}
|
|
|
|
if (version > 612) {
|
|
CloseHandle(port);
|
|
}
|
|
|
|
CloseHandle(file);
|
|
|
|
}
|
|
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
|
|
ExitThread(0);
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
WriteSequential(
|
|
PPARAMS Params
|
|
)
|
|
{
|
|
|
|
ULONG j,
|
|
errCode,
|
|
outstandingRequests;
|
|
HANDLE file,
|
|
port;
|
|
OVERLAPPED overlapped,
|
|
*overlapped2;
|
|
DWORD bytesWrite,
|
|
bytesWrite2,
|
|
completionKey,
|
|
version;
|
|
BOOLEAN status;
|
|
PUCHAR buffer;
|
|
|
|
|
|
version = GetVersion() >> 16;
|
|
|
|
buffer = VirtualAlloc(NULL,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_COMMIT | MEM_RESERVE,
|
|
PAGE_READWRITE);
|
|
|
|
(ULONG)buffer &= ~(SectorSize - 1);
|
|
|
|
if ( !buffer ) {
|
|
LogError("Error allocating buffer",1,GetLastError());
|
|
ExitThread(1);
|
|
return 2;
|
|
}
|
|
|
|
while (RunTest) {
|
|
|
|
file = CreateFile(Params->TargetFile,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if ( file == INVALID_HANDLE_VALUE ) {
|
|
LogError("Error opening Target file",2,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(2);
|
|
return 2;
|
|
}
|
|
|
|
port = CreateIoCompletionPort(file,
|
|
NULL,
|
|
(DWORD)file,
|
|
0);
|
|
if ( !port ) {
|
|
LogError("Error creating completion port",3,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
memset(&overlapped,0,sizeof(overlapped));
|
|
|
|
outstandingRequests = 0;
|
|
|
|
for (j = 0; j < Params->Tcount; j++) {
|
|
do {
|
|
|
|
status = WriteFile(file,
|
|
buffer,
|
|
Params->BufferSize,
|
|
&bytesWrite,
|
|
&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_NOT_ENOUGH_MEMORY) {
|
|
//
|
|
// Allow this to retry.
|
|
//
|
|
|
|
} else {
|
|
LogError("Error in WriteFile",4,errCode);
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(4);
|
|
return 4;
|
|
}
|
|
|
|
}
|
|
|
|
} while (!status);
|
|
|
|
outstandingRequests++;
|
|
overlapped.Offset += Params->BufferSize;
|
|
}
|
|
|
|
for (j = 0; j < outstandingRequests; j++) {
|
|
|
|
status = GetQueuedCompletionStatus(port,
|
|
&bytesWrite2,
|
|
&completionKey,
|
|
&overlapped2,
|
|
(DWORD)-1);
|
|
|
|
if (!status) {
|
|
LogError("GetQueuedCompletionStatus error.",5,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(5);
|
|
return 5;
|
|
}
|
|
|
|
}
|
|
|
|
if (version > 612) {
|
|
CloseHandle(port);
|
|
}
|
|
|
|
CloseHandle(file);
|
|
|
|
}
|
|
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
|
|
ExitThread(0);
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
ReadRandom(
|
|
PPARAMS Params
|
|
)
|
|
{
|
|
|
|
ULONG j,
|
|
errCode,
|
|
outstandingRequests;
|
|
HANDLE file,
|
|
port;
|
|
OVERLAPPED overlapped,
|
|
*overlapped2;
|
|
DWORD bytesRead,
|
|
bytesRead2,
|
|
completionKey,
|
|
version;
|
|
BOOLEAN status;
|
|
PUCHAR buffer;
|
|
|
|
|
|
version = GetVersion() >> 16;
|
|
|
|
buffer = VirtualAlloc(NULL,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_COMMIT | MEM_RESERVE,
|
|
PAGE_READWRITE);
|
|
|
|
(ULONG)buffer &= ~(SectorSize - 1);
|
|
|
|
if ( !buffer ) {
|
|
LogError("Error allocating buffer",1,GetLastError());
|
|
ExitThread(1);
|
|
return 2;
|
|
}
|
|
|
|
while (RunTest) {
|
|
|
|
file = CreateFile(Params->TargetFile,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if ( file == INVALID_HANDLE_VALUE ) {
|
|
LogError("Error opening Target file",2,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(2);
|
|
return 2;
|
|
}
|
|
|
|
port = CreateIoCompletionPort(file,
|
|
NULL,
|
|
(DWORD)file,
|
|
0);
|
|
if ( !port ) {
|
|
LogError("Error creating completion port",3,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
memset(&overlapped,0,sizeof(overlapped));
|
|
|
|
outstandingRequests = 0;
|
|
|
|
for (j = 0; j < Params->Tcount; j++) {
|
|
do {
|
|
|
|
status = ReadFile(file,
|
|
buffer,
|
|
Params->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_NOT_ENOUGH_MEMORY) {
|
|
//
|
|
// Allow this to retry.
|
|
//
|
|
|
|
} else {
|
|
LogError("Error in ReadFile",4,errCode);
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(4);
|
|
return 4;
|
|
}
|
|
|
|
}
|
|
|
|
} while (!status);
|
|
|
|
outstandingRequests++;
|
|
overlapped.Offset = GetRandomOffset(0,FILE_SIZE - Params->BufferSize);
|
|
}
|
|
|
|
for (j = 0; j < outstandingRequests; j++) {
|
|
|
|
status = GetQueuedCompletionStatus(port,
|
|
&bytesRead2,
|
|
&completionKey,
|
|
&overlapped2,
|
|
(DWORD)-1);
|
|
|
|
if (!status) {
|
|
LogError("GetQueuedCompletionStatus error.",5,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(5);
|
|
return 5;
|
|
}
|
|
|
|
}
|
|
|
|
if (version > 612) {
|
|
CloseHandle(port);
|
|
}
|
|
|
|
CloseHandle(file);
|
|
|
|
}
|
|
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
|
|
ExitThread(0);
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
WriteRandom(
|
|
PPARAMS Params
|
|
)
|
|
{
|
|
ULONG j,
|
|
errCode,
|
|
outstandingRequests;
|
|
HANDLE file,
|
|
port;
|
|
OVERLAPPED overlapped,
|
|
*overlapped2;
|
|
DWORD bytesWrite,
|
|
bytesWrite2,
|
|
completionKey,
|
|
version;
|
|
BOOLEAN status;
|
|
PUCHAR buffer;
|
|
|
|
|
|
version = GetVersion() >> 16;
|
|
|
|
buffer = VirtualAlloc(NULL,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_COMMIT | MEM_RESERVE,
|
|
PAGE_READWRITE);
|
|
|
|
(ULONG)buffer &= ~(SectorSize - 1);
|
|
|
|
if ( !buffer ) {
|
|
LogError("Error allocating buffer",1,GetLastError());
|
|
ExitThread(1);
|
|
return 2;
|
|
}
|
|
|
|
while (RunTest) {
|
|
|
|
file = CreateFile(Params->TargetFile,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
|
|
NULL );
|
|
|
|
if ( file == INVALID_HANDLE_VALUE ) {
|
|
LogError("Error opening Target file",2,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(2);
|
|
return 2;
|
|
}
|
|
|
|
port = CreateIoCompletionPort(file,
|
|
NULL,
|
|
(DWORD)file,
|
|
0);
|
|
if ( !port ) {
|
|
LogError("Error creating completion port",3,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(3);
|
|
return 3;
|
|
}
|
|
|
|
memset(&overlapped,0,sizeof(overlapped));
|
|
|
|
outstandingRequests = 0;
|
|
|
|
for (j = 0; j < Params->Tcount; j++) {
|
|
do {
|
|
|
|
status = WriteFile(file,
|
|
buffer,
|
|
Params->BufferSize,
|
|
&bytesWrite,
|
|
&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_NOT_ENOUGH_MEMORY) {
|
|
//
|
|
// Allow this to retry.
|
|
//
|
|
|
|
} else {
|
|
LogError("Error in WriteFile",4,errCode);
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(4);
|
|
return 4;
|
|
}
|
|
|
|
}
|
|
|
|
} while (!status);
|
|
|
|
outstandingRequests++;
|
|
overlapped.Offset = GetRandomOffset(0,FILE_SIZE - Params->BufferSize);
|
|
}
|
|
|
|
for (j = 0; j < outstandingRequests; j++) {
|
|
|
|
status = GetQueuedCompletionStatus(port,
|
|
&bytesWrite2,
|
|
&completionKey,
|
|
&overlapped2,
|
|
(DWORD)-1);
|
|
|
|
if (!status) {
|
|
LogError("GetQueuedCompletionStatus error.",5,GetLastError());
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
ExitThread(5);
|
|
return 5;
|
|
}
|
|
|
|
}
|
|
|
|
if (version > 612) {
|
|
CloseHandle(port);
|
|
}
|
|
|
|
CloseHandle(file);
|
|
|
|
}
|
|
|
|
VirtualFree(buffer,
|
|
Params->BufferSize + SectorSize - 1,
|
|
MEM_DECOMMIT);
|
|
|
|
ExitThread(0);
|
|
return 0;
|
|
}
|
|
|
|
|
|
ULONG
|
|
GetRandomOffset(
|
|
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;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
LogError(
|
|
PCHAR ErrString,
|
|
DWORD UniqueId,
|
|
DWORD ErrCode
|
|
)
|
|
{
|
|
CHAR ErrBuf[80];
|
|
#if DBG
|
|
sprintf(ErrBuf,"%d: %s WinError %d",UniqueId,ErrString,ErrCode);
|
|
MessageBox(NULL,ErrBuf,"Error",MB_OK | MB_ICONEXCLAMATION);
|
|
#else
|
|
return;
|
|
#endif
|
|
|
|
}
|
|
|
|
BOOL
|
|
GetSectorSize(
|
|
PDWORD SectorSize,
|
|
PCHAR DrvLetter
|
|
)
|
|
{
|
|
DISK_GEOMETRY DiskGeometry;
|
|
DWORD BytesReturned;
|
|
HANDLE handle;
|
|
|
|
handle = CreateFile(DrvLetter,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED,
|
|
NULL
|
|
);
|
|
if (handle == INVALID_HANDLE_VALUE) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Starting offset and sectors
|
|
//
|
|
|
|
if (!DeviceIoControl (handle,
|
|
IOCTL_DISK_GET_DRIVE_GEOMETRY,
|
|
NULL,
|
|
0,
|
|
&DiskGeometry,
|
|
sizeof(DISK_GEOMETRY),
|
|
&BytesReturned,
|
|
NULL
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
*SectorSize = DiskGeometry.BytesPerSector;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID
|
|
Usage(
|
|
VOID
|
|
)
|
|
{
|
|
CHAR buffer[255];
|
|
|
|
sprintf(buffer,"\nDSKBENCH: V1.0\n\n");
|
|
strcat (buffer,"Usage: DSKBENCH\n");
|
|
strcat (buffer,"\t[Drvletter:]\n\t[-b] Buffer size in 1kb increments.\n\t[-tXX] Test specifier.");
|
|
strcat (buffer,"\n\tWhere XX is:\n\t\t'RS' - Read sequential.\n\t\t'RR' - Read Random\n\t\t");
|
|
strcat (buffer,"'WS' - Write sequential\n\t\t'WR' - Write Random\n\n");
|
|
strcat (buffer,"Example: Dskbench d: -b64 -tRS\n");
|
|
|
|
MessageBox(NULL,buffer,"Usage",MB_OK);
|
|
}
|
|
|