able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/diskmon/diskmon.c

1313 lines
36 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
diskmon.c
Abstract:
This module contians the code for the disk monitor utility.
Author:
Chuck Park (chuckp) 10-Feb-1994
Mike Glass (mglass)
Revision History:
--*/
#include "diskmon.h"
#include "gauge.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
PCHAR
*GetAttachedDrives(
PINT NumberDrives
);
VOID
CalcStats(
PDISK list,
BOOL initial
);
VOID
ZeroList(
PDISK list
);
VOID
WriteStatText(
VOID
);
VOID
FormatTime(
ULONG Time
);
DISK TotalDrives;
PDISK DriveList = NULL,
SelectedDrive = NULL;
HINSTANCE hInst;
HWND hDataDlg,
hMainWnd;
HMENU MenuHandle,Popup = NULL;
UINT ActiveDrives = 0;
CHAR AppName[] = "diskmon";
CHAR Title[] = "Disk Performance Monitor";
CHAR TimerText[] = "00:00:00:00";
CHAR labels[9][17] = {"BPS Read",
"BPS Write",
"Ave. BPS Read",
"Ave. BPS Write",
"Ave. BPS Xfer",
"Cur Queue",
"Ave Queue",
"Max Queue",
"Requests / Sec"
};
HWND currentDrvHandle,
totalDrvHandle,
staticHandle[18],
selectedDriveId,
TimerTextId;
INT cx,
cy;
INT Seconds,
Minutes,
Hours,
Days;
ULONG ElapsedTime = 0;
int APIENTRY WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int CmdShow
)
{
MSG msg;
HANDLE hAccelTable;
if (!hPrevInstance) {
if (!InitApplication(hInstance)) {
return (FALSE);
}
}
if (!InitInstance(hInstance, CmdShow)) {
return (FALSE);
}
hAccelTable = LoadAccelerators (hInstance, AppName);
while (GetMessage(&msg,NULL,0,0) ) {
if (!TranslateAccelerator (msg.hwnd, hAccelTable, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int)msg.wParam;
lpCmdLine;
}
BOOL InitApplication(HINSTANCE hInstance)
{
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon (hInstance, AppName);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
wc.lpszMenuName = "DiskmonMenu";
wc.lpszClassName = AppName;
if (!RegisterClass(&wc))
return FALSE;
if(!RegisterGauge(hInstance))
return FALSE;
return TRUE;
}
BOOL InitInstance(
HINSTANCE hInstance,
int CmdShow
)
{
CHAR buffer[80];
DISK_PERFORMANCE perfbuf;
DWORD BytesReturned;
HANDLE handle;
HWND hWnd;
INT height,
width;
hInst = hInstance;
cx = 70;
cy = 70;
width = 7;
height = 7;
//
//Create the main window.
//
hWnd = CreateWindow(
AppName,
Title,
WS_CAPTION | WS_SYSMENU,
20,20,
cx * width,
cy * height,
NULL,
NULL,
hInstance,
NULL
);
if (!hWnd) {
return (FALSE);
}
//
// If the IOCTL GET_DISK_PERF returns ERROR_INVALID_FUNCTION, let the user
// know that Diskperf.sys is not started.
//
handle = CreateFile("\\\\.\\PhysicalDrive0",
GENERIC_READ,
FILE_SHARE_READ
| FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (handle == INVALID_HANDLE_VALUE) {
MessageBox(NULL,"Couldn't open a drive.","Error.",
MB_ICONEXCLAMATION | MB_OK);
return FALSE;
}
if (!DeviceIoControl (handle,
IOCTL_DISK_PERFORMANCE,
NULL,
0,
&perfbuf,
sizeof(DISK_PERFORMANCE),
&BytesReturned,
NULL
)) {
if (GetLastError() == ERROR_INVALID_FUNCTION) {
sprintf(buffer,"Diskperf.sys is not started on your system.\n Start the driver and reboot.");
MessageBox(NULL,buffer,"Error",MB_ICONEXCLAMATION | MB_OK);
return FALSE;
}
}
CloseHandle(handle);
ShowWindow(hWnd, CmdShow);
UpdateWindow(hWnd);
hMainWnd = hWnd;
return TRUE;
}
LRESULT CALLBACK
WndProc(
HWND hWnd,
UINT message,
WPARAM uParam,
LPARAM lParam
)
{
CHAR buffer[20];
INT wmId,
wmEvent,
x,
y,
minValue,
maxValue,
menuIndex,
i,
j;
static HBRUSH brush;
HDC DC;
PAINTSTRUCT ps;
PDISK current;
RECT childRect;
POINT point;
switch (message) {
case WM_CREATE:
MenuHandle = GetMenu(hWnd);
brush = GetStockObject(DKGRAY_BRUSH);
x = cx / 3;
y = cy / 3;
minValue = 0;
maxValue = 5000;
//
//Create gauge windows
//
currentDrvHandle = CreateGauge (hWnd,hInst,
x,y,cx*3,cy*2,
minValue,maxValue);
x = cx * 3 + ((cx * 2) / 3) ;
totalDrvHandle = CreateGauge (hWnd,hInst,
x,y,cx*3,cy*2,
minValue,maxValue*8);
if (!currentDrvHandle || !totalDrvHandle) {
DestroyWindow(hWnd);
}
//
//Allocate and zero mem for the totaldrive structs.
//
TotalDrives.start = (PDISK_PERFORMANCE)malloc(sizeof(DISK_PERFORMANCE));
if (!TotalDrives.start){
return 1;
}
TotalDrives.current = (PDISK_PERFORMANCE)malloc(sizeof(DISK_PERFORMANCE));
if (!TotalDrives.current) {
free(TotalDrives.start);
return 1;
}
TotalDrives.previous = (PDISK_PERFORMANCE)malloc(sizeof(DISK_PERFORMANCE));
if (!TotalDrives.previous) {
free(TotalDrives.current);
free(TotalDrives.start);
return 1;
}
memset (TotalDrives.start, 0x0,sizeof(DISK_PERFORMANCE));
memset (TotalDrives.current, 0x0,sizeof(DISK_PERFORMANCE));
memset (TotalDrives.previous, 0x0,sizeof(DISK_PERFORMANCE));
TotalDrives.MaxQDepth = 0;
TotalDrives.QDepth = 0;
InvalidateRect(currentDrvHandle,NULL,TRUE);
InvalidateRect(totalDrvHandle,NULL,TRUE);
UpdateWindow(currentDrvHandle);
UpdateWindow(totalDrvHandle);
//
//Create static text controls.
//
for (j = 1;j < 3;j++ ) {
for (i = 0; i < 9 ; i++ ) {
CreateWindow("static",
labels[i],
WS_CHILD | WS_VISIBLE | SS_LEFT,
(INT)( ((cx / 3) * j) + ((j - 1) * cx * 3)),
(INT)(cy * 3 + 20 * i),
(INT)(cx * 1.7),
(INT)(cy / 3),
hWnd,
(HMENU)IntToPtr(i | j << 8),
hInst,
NULL);
}
}
for (j = 1;j < 3 ; j++ ) {
for (i = 0; i < 9 ; i++ ) {
staticHandle[i + ((j-1) * 9)] =
CreateWindow("static",
"0",
WS_CHILD | WS_VISIBLE | SS_RIGHT,
(INT)( ((cx * 2)+cx/3*(j-1) ) + ((j - 1) * cx * 3)),
(INT)(cy * 3 + 20 * i),
(INT)(cx * 1.3),
(INT)(cy / 3),
hWnd,
(HMENU)IntToPtr(i | j << 8),
hInst,
NULL);
}
}
//
//Create Selected drive id control and All drives control
//
selectedDriveId = CreateWindow("static",
"",
WS_CHILD | WS_VISIBLE | SS_LEFT,
(INT)( cx * 1.3),
(INT)(cy * 2.7),
(INT)(cx * 1.5),
(INT)(cy / 3),
hWnd,
(HMENU)(25),
hInst,
NULL);
CreateWindow("static","All Active Drives",
WS_CHILD | WS_VISIBLE | SS_LEFT,
(INT)( cx * 4.6),
(INT)(cy * 2.7),
(INT)(cx * 2.0),
(INT)(cy / 3),
hWnd,
(HMENU)(26),
hInst,
NULL);
TimerTextId = CreateWindow("static","00:00:00:00",
WS_CHILD | WS_VISIBLE | SS_LEFT,
(INT)(cx * 3),
(INT)(cy * .5),
(INT)(cx * 1.5),
(INT)(cy / 3),
hWnd,
(HMENU)(26),
hInst,
NULL);
break;
case WM_CTLCOLORSTATIC:
SetStretchBltMode((HDC)uParam,HALFTONE);
//
// Get the original brush origins
//
GetBrushOrgEx((HDC)uParam,&point);
//
// Get the extents of the child window.
//
GetWindowRect((HWND)lParam,&childRect);
//
// Set new brush origin
//
SetBrushOrgEx((HDC)uParam,childRect.left,childRect.top,&point);
//
//Set the color of text and background for the static controls
//
SetBkMode ((HDC)uParam,TRANSPARENT);
SetBkColor ((HDC)uParam,(COLORREF)PtrToUlong(brush));
SetTextColor ((HDC)uParam, RGB(255,255,255));
//
// restore the original brush origin
//
return (LRESULT)brush;
case WM_PAINT:
DC = BeginPaint (hWnd,&ps);
SetStretchBltMode(DC,BLACKONWHITE);
//RealizePalette(DC);
//
// Force repaint of the gauges.
//
InvalidateRect (currentDrvHandle,NULL,TRUE);
InvalidateRect (totalDrvHandle,NULL,TRUE);
InvalidateRect (TimerTextId,NULL,TRUE);
EndPaint (hWnd,&ps);
break;
case WM_TIMER:
++ElapsedTime;
FormatTime (ElapsedTime);
SetWindowText(TimerTextId,TimerText);
CalcStats (DriveList,FALSE);
//
//Determine currently selected drive and update
//the gauge.
//
UpdateGauge(currentDrvHandle,(INT)(SelectedDrive->AveBPS / 1000));
//
//Calc total stats and update active drives gauge.
//
UpdateGauge(totalDrvHandle,(INT)(TotalDrives.AveBPS / (1000)));
WriteStatText();
break;
case WM_COMMAND:
wmId = LOWORD(uParam);
wmEvent = HIWORD(uParam);
if (wmId >= ID_DRV0 && wmId <= ID_DRV0 + 32) {
//
//Uncheck currently selected drive.
//
CheckMenuItem (Popup,SelectedDrive->MenuId,
MF_BYPOSITION | MF_UNCHECKED);
//
//Determine which drive, make it the selected drive,
//and check it.
//
current = DriveList;
while ( current && (current->MenuId != wmId - ID_DRV0)) {
current = current->next;
}
SelectedDrive = current;
CheckMenuItem (Popup,SelectedDrive->MenuId,
MF_BYPOSITION | MF_CHECKED);
//
//Update the drive Id static control
//
SetWindowText (selectedDriveId,SelectedDrive->DrvString);
break;
}
switch (wmId) {
case IDM_VIEW:
//
// TODO: Not yet implemented.
//
break;
case IDM_RESET:
//
// Zero all disk data
//
ZeroList (DriveList);
//
// Disable reset
//
EnableMenuItem (GetMenu(hWnd),IDM_RESET,MF_GRAYED);
DrawMenuBar (hWnd);
//
// Show zero'ed info.
//
UpdateGauge(currentDrvHandle,0);
UpdateGauge(totalDrvHandle,0);
WriteStatText();
break;
case IDM_CHOOSE:
DialogBox(hInst,
"DISKDLG",
hWnd,
(DLGPROC)ConfigMonitor
);
//
//If any drives were selected, set up the remaining
//fields in the structures.
//
if (DriveList) {
//
//Delete the old "Drive" menu if it exists and
//create a new one.
//
if (Popup) {
DeleteMenu (GetMenu(hWnd),3,MF_BYPOSITION);
DrawMenuBar (hWnd);
}
Popup = CreatePopupMenu ();
menuIndex = 1;
current = DriveList;
while (current) {
//
//Open the drive
//
sprintf (buffer,"\\\\.\\");
strcat (buffer,current->DrvString);
current->handle = CreateFile(buffer,
GENERIC_READ,
FILE_SHARE_READ
| FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (current->handle == INVALID_HANDLE_VALUE) {
MessageBox(NULL,"Couldn't open a drive.","Error.",
MB_ICONEXCLAMATION | MB_OK);
DestroyWindow(hWnd);
}
//
//Allocate memory for each of the DISK_PERFORMANCE
//structures.
//
current->start =
(PDISK_PERFORMANCE) malloc(sizeof(DISK_PERFORMANCE));
current->current =
(PDISK_PERFORMANCE) malloc(sizeof(DISK_PERFORMANCE));
current->previous =
(PDISK_PERFORMANCE) malloc(sizeof(DISK_PERFORMANCE));
if (!(current->start && current->current
&& current->previous)) {
MessageBox(NULL,"Couldn't allocate memory.","Error.",
MB_ICONEXCLAMATION | MB_OK);
DestroyWindow(hWnd);
}
//
//Add to the Popup menu
//
if (menuIndex == 1) {
AppendMenu (Popup,MF_STRING | MF_BYPOSITION,
ID_DRV0 + ActiveDrives - menuIndex++,
current->DrvString);
} else {
InsertMenu (Popup,0,
MF_STRING | MF_BYPOSITION,
ID_DRV0 + ActiveDrives - menuIndex++,
current->DrvString);
}
current = current->next;
}
//
//Start with first PhysicalDrive choosen being the currently
//selected drive.
//
SelectedDrive = DriveList;
while (SelectedDrive->next) {
SelectedDrive = SelectedDrive->next;
}
AppendMenu (GetMenu(hWnd),MF_POPUP,(INT_PTR)Popup,"Dri&ve");
//
//Put check mark next to selected drive.
//
CheckMenuItem (Popup,SelectedDrive->MenuId,
MF_BYPOSITION | MF_CHECKED);
//
//Set the drive id control
//
SetWindowText (selectedDriveId,SelectedDrive->DrvString);
//
//Enable the start menu item.
//
EnableMenuItem (GetMenu(hWnd),IDM_START,MF_ENABLED);
DrawMenuBar (hWnd);
}
break;
case IDM_START:
SetTimer(hWnd,ID_TIMER,1000,(TIMERPROC)NULL);
//
//Get initial values for each drive.
//
CalcStats(DriveList,TRUE);
ModifyMenu (GetMenu(hWnd),
IDM_START,
MF_BYCOMMAND,
IDM_STOP,
"Sto&p");
EnableMenuItem (GetMenu(hWnd),IDM_CHOOSE,MF_GRAYED);
DrawMenuBar(hWnd);
break;
case IDM_STOP:
EnableMenuItem (GetMenu(hWnd),IDM_RESET,MF_ENABLED);
KillTimer(hWnd, ID_TIMER);
ModifyMenu (GetMenu(hWnd),
IDM_STOP,
MF_BYCOMMAND,
IDM_START,
"S&tart");
EnableMenuItem (GetMenu(hWnd),IDM_CHOOSE,MF_ENABLED);
DrawMenuBar(hWnd);
break;
case IDM_EXIT:
DestroyWindow (hWnd);
break;
default:
return (DefWindowProc(hWnd, message, uParam, lParam));
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return (DefWindowProc(hWnd, message, uParam, lParam));
}
return (0);
}
BOOL
CALLBACK
ConfigMonitor(
HWND hDlg,
UINT Msg,
WPARAM wParam,
LPARAM lParam
)
{
BOOL Processed = TRUE;
static INT NumberCurrentDrives = 0;
INT selectedDrvBuf[32],
i;
CHAR (*drvs)[16],
buffer[16];
PDISK drive;
switch (Msg) {
case WM_INITDIALOG:
//
// Determine the currently installed PhysicalDrives
//
(char **)drvs = GetAttachedDrives(&NumberCurrentDrives);
if (!drvs) {
break;
}
//
// Load the listbox with the installed drives.
//
for (i = 0;i < NumberCurrentDrives ;i++ ) {
SendDlgItemMessage (hDlg,ID_LB,LB_ADDSTRING,
0,(LPARAM)(LPCTSTR)drvs[i]);
}
//
// Release the strings allocated in GetAttachedDrives
//
free (drvs);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case ID_LB:
//
// Message for the drive list box.
//
if ( HIWORD(wParam) == LBN_DBLCLK || HIWORD(wParam) == LBN_SELCHANGE ) {
if (!IsWindowEnabled(GetDlgItem(hDlg,IDOK))) {
EnableWindow(GetDlgItem(hDlg,IDOK),TRUE);
} else {
if(!SendDlgItemMessage (hDlg,ID_LB,LB_GETSELCOUNT,0,0)) {
EnableWindow(GetDlgItem(hDlg,IDOK),FALSE);
}
}
}
break;
case IDOK:
//
//Poison the selection array
//
for (i = 0; i < 32; i++ ) {
selectedDrvBuf[i] = -1;
}
//
// If already configed free up all old stuff.
//
if (DriveList) {
ActiveDrives = 0;
drive = DriveList;
while (drive) {
if (drive->start) {
free (drive->start);
}
if (drive->current) {
free (drive->current);
}
if (drive->previous) {
free (drive->previous);
}
CloseHandle (drive->handle);
drive = drive->next;
}
free(DriveList);
DriveList = NULL;
}
//
//Determine which drives are selected.
//
ActiveDrives = (UINT)SendDlgItemMessage (hDlg,ID_LB,LB_GETSELITEMS,(WPARAM)NumberCurrentDrives,
(LPARAM)(LPINT)selectedDrvBuf);
for (i = 0;i < (INT)ActiveDrives ; i++ ) {
if ( selectedDrvBuf[i] != -1 && selectedDrvBuf[i] < NumberCurrentDrives) {
//
// One more check because return from GETSELITEMS is
// sometimes bogus.
//
if (!SendDlgItemMessage (hDlg,ID_LB,LB_GETSEL,(WPARAM)selectedDrvBuf[i],0)) {
MessageBox(NULL,"Bogus val from GETSELITEMS","BUG",MB_OK);
continue;
}
//
//Allocate mem. and link into DISK list.
//
if ((drive = (PDISK) malloc(sizeof(DISK)))==NULL) {
MessageBox(NULL,"Couldn't allocate memory.","Error",
MB_ICONEXCLAMATION | MB_OK);
EndDialog (hDlg,wParam);
break;
}
//
//pull out the string from the list box.
//
SendDlgItemMessage (hDlg,ID_LB,LB_GETTEXT,selectedDrvBuf[i],
(LPARAM)(LPCTSTR)buffer);
strcpy (drive->DrvString,buffer);
//
// Init rest of structure
//
drive->BytesRead = 0;
drive->BytesWritten = 0;
drive->QDepth = 0;
drive->MaxQDepth = 0;
drive->next = NULL;
drive->MenuId = i;
//
// Link into the list of selected drives
//
if ( !DriveList ) {
DriveList = drive;
} else {
drive->next = DriveList;
DriveList = drive;
}
}
}
//
//Fall through to EndDialog
//
case IDCANCEL:
EndDialog(hDlg, wParam);
break;
default:
Processed = FALSE;
break;
}
default:
Processed = FALSE;
break;
}
return(Processed);
}
PCHAR
*GetAttachedDrives(
PINT NumberDrives
)
{
BOOL ValidDrive = FALSE;
CHAR (*drivestrings)[16];
CHAR buffer[21];
HANDLE handle;
INT i = 0;
*NumberDrives = 0;
do {
//
// Try to open each disk starting with 0, if it is present,
// continue. When last is found, exit the loop.
//
ValidDrive = FALSE;
sprintf(buffer,"\\\\.\\PhysicalDrive%d",i);
handle = CreateFile(buffer,
GENERIC_READ,FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (handle != INVALID_HANDLE_VALUE) {
ValidDrive = TRUE;
++(*NumberDrives);
++i;
CloseHandle(handle);
}
} while (ValidDrive);
//
// Allocate mem for array of char strings and
// copy "PhysicalDriveX" into each.
//
drivestrings = malloc ((16 * *NumberDrives));
if (!drivestrings) {
return NULL;
}
for (i = 0;i < *NumberDrives ; i++ ) {
sprintf (drivestrings[i],"PhysicalDrive%d",i);
}
return (char **)drivestrings;
}
VOID
CalcStats(
PDISK list,
BOOL initial
)
{
BOOL retval = FALSE;
CHAR errorbuf[25];
DWORD BytesReturned;
LARGE_INTEGER liVal,
BytesRead,
BytesWritten,
curBytesRead,
curBytesWritten;
PDISK newvals = list,
curdisk = list;
UINT tmpQDepth = 0;
BytesRead.QuadPart = 0;
BytesWritten.QuadPart = 0;
TotalDrives.current->QueueDepth = 0;
TotalDrives.current->ReadCount = 0;
TotalDrives.current->WriteCount = 0;
TotalDrives.current->BytesRead.QuadPart = 0;
TotalDrives.current->BytesWritten.QuadPart = 0;
//
//Issue disk perf IOCTL on each drive in list.
//
while (curdisk) {
curBytesRead.QuadPart = 0;
*(curdisk->previous) = *(curdisk->current);
retval = DeviceIoControl (curdisk->handle,
IOCTL_DISK_PERFORMANCE,
NULL,
0,
curdisk->current,
sizeof(DISK_PERFORMANCE),
&BytesReturned,
NULL
);
if (!retval) {
sprintf(errorbuf,"IOCTL returned error %x",GetLastError());
MessageBox(NULL,errorbuf,"Error",MB_ICONEXCLAMATION | MB_OK);
break;
}
if (initial) {
*(curdisk->start) = *(curdisk->current);
*(curdisk->previous) = *(curdisk->current);
curdisk->AveBPS = 0;
curdisk->MaxBPS = 0;
} else {
//
//Calc the averages and per disk totals
//
curBytesRead.QuadPart = curdisk->current->BytesRead.QuadPart -
curdisk->previous->BytesRead.QuadPart;
curBytesWritten.QuadPart = curdisk->current->BytesWritten.QuadPart -
curdisk->previous->BytesWritten.QuadPart;
BytesRead.QuadPart = BytesRead.QuadPart + curBytesRead.QuadPart;
BytesWritten.QuadPart = BytesWritten.QuadPart + curBytesWritten.QuadPart;
liVal.QuadPart = curBytesRead.QuadPart + curBytesWritten.QuadPart;
curdisk->AveBPS = (ULONG)liVal.QuadPart;
curdisk->BytesRead += (ULONG)curBytesRead.QuadPart;
curdisk->BytesWritten += (ULONG)curBytesWritten.QuadPart;
curdisk->QDepth += curdisk->current->QueueDepth;
curdisk->MaxQDepth = (curdisk->current->QueueDepth >
curdisk->MaxQDepth) ?
curdisk->current->QueueDepth :
curdisk->MaxQDepth;
TotalDrives.QDepth += curdisk->current->QueueDepth;
TotalDrives.current->QueueDepth += curdisk->current->QueueDepth;
tmpQDepth += curdisk->current->QueueDepth;
TotalDrives.current->ReadCount += curdisk->current->ReadCount-curdisk->previous->ReadCount;
TotalDrives.current->WriteCount += curdisk->current->WriteCount - curdisk->previous->WriteCount;
TotalDrives.current->BytesRead.QuadPart = TotalDrives.current->BytesRead.QuadPart +
curBytesRead.QuadPart;
TotalDrives.current->BytesWritten.QuadPart = TotalDrives.current->BytesWritten.QuadPart +
curBytesWritten.QuadPart;
}
curdisk = curdisk->next;
}
//
// Calculate total active drive stats.
//
TotalDrives.AveBPS = (ULONG)(BytesRead.QuadPart + BytesWritten.QuadPart);
TotalDrives.previous->BytesRead.QuadPart = TotalDrives.previous->BytesRead.QuadPart +
BytesRead.QuadPart;
TotalDrives.previous->BytesWritten.QuadPart =
TotalDrives.previous->BytesWritten.QuadPart + BytesWritten.QuadPart;
TotalDrives.MaxQDepth = (TotalDrives.MaxQDepth > tmpQDepth) ?
TotalDrives.MaxQDepth : tmpQDepth;
list = newvals;
}
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
ZeroList(
PDISK list
)
{
PDISK curdrive = list;
memset (TotalDrives.start, 0x0,sizeof(DISK_PERFORMANCE));
memset (TotalDrives.current, 0x0,sizeof(DISK_PERFORMANCE));
memset (TotalDrives.previous, 0x0,sizeof(DISK_PERFORMANCE));
TotalDrives.MaxQDepth = 0;
TotalDrives.QDepth = 0;
TotalDrives.AveBPS = 0;
TotalDrives.MaxBPS = 0;
TotalDrives.BytesRead = 0;
TotalDrives.BytesWritten = 0;
while (curdrive) {
memset (curdrive->start,0x0,sizeof(DISK_PERFORMANCE));
memset (curdrive->current,0x0,sizeof(DISK_PERFORMANCE));
memset (curdrive->previous,0x0,sizeof(DISK_PERFORMANCE));
curdrive->AveBPS = 0;
curdrive->MaxBPS = 0;
curdrive->BytesRead = 0;
curdrive->BytesWritten = 0;
curdrive->QDepth = 0;
curdrive->MaxQDepth = 0;
curdrive = curdrive->next;
}
CalcStats (list,TRUE);
SelectedDrive->current->QueueDepth = 0;
Seconds = 0;
Minutes = 0;
Hours = 0;
Days = 0;
ElapsedTime = 1;
sprintf (TimerText,"00:00:00:00");
}
VOID
WriteStatText(
VOID
)
{
LARGE_INTEGER Val,BytesRead,BytesWritten;
CHAR buffer[20];
//
// BPS Read
//
BytesRead.QuadPart = SelectedDrive->current->BytesRead.QuadPart -
SelectedDrive->previous->BytesRead.QuadPart;
sprintf(buffer,"%.0Lu%Lu",BytesRead.HighPart,BytesRead.LowPart);
SetWindowText(staticHandle[0],buffer);
//
// BPS Write
//
BytesWritten.QuadPart = SelectedDrive->current->BytesWritten.QuadPart -
SelectedDrive->previous->BytesWritten.QuadPart;
sprintf(buffer,"%.0Lu%Lu",BytesWritten.HighPart,BytesWritten.LowPart);
SetWindowText(staticHandle[1],buffer);
//
// Ave. BPS Read
//
BytesRead.QuadPart = SelectedDrive->current->BytesRead.QuadPart +
SelectedDrive->start->BytesRead.QuadPart;
Val.QuadPart = BytesRead.QuadPart / ElapsedTime; // 1 10 BPS Write",
sprintf (buffer,"%.0Lu%Lu",Val.HighPart,Val.LowPart); // 2 11 Ave. BPS Read",
SetWindowText(staticHandle[2],buffer); // 3 12 Ave. BPS Write",
// 4 13 Ave. BPS Xfer",
// // 5 14 Cur Queue",
// Ave. BPS Write // 6 15 Ave Queue",
// // 7 16 Max Queue",
// 8 17 Requests / Sec"
BytesWritten.QuadPart = SelectedDrive->current->BytesWritten.QuadPart +
SelectedDrive->start->BytesWritten.QuadPart;
Val.QuadPart = BytesWritten.QuadPart / ElapsedTime;
sprintf (buffer,"%.0Lu%Lu",Val.HighPart,Val.LowPart);
SetWindowText(staticHandle[3],buffer);
//
// Ave. BPS Total
//
Val.QuadPart = (BytesRead.QuadPart + BytesWritten.QuadPart) / ElapsedTime;
sprintf (buffer,"%.0Lu%Lu",Val.HighPart,Val.LowPart);
SetWindowText (staticHandle[4],buffer);
//
// Current Queue depth
//
sprintf (buffer, "%Lu",SelectedDrive->current->QueueDepth);
SetWindowText (staticHandle[5],buffer);
//
// Ave. Queue depth
//
sprintf (buffer, "%Lu",SelectedDrive->QDepth / ElapsedTime);
SetWindowText (staticHandle[6],buffer);
//
// Max Q
//
sprintf (buffer, "%Lu",SelectedDrive->MaxQDepth);
SetWindowText (staticHandle[7],buffer);
//
// Requests / Sec
//
sprintf (buffer, "%Lu",SelectedDrive->current->ReadCount-SelectedDrive->previous->ReadCount +
SelectedDrive->current->WriteCount-SelectedDrive->previous->WriteCount);
SetWindowText (staticHandle[8],buffer);
//
// Total drives Stats
//
//
// BPS Read
//
sprintf(buffer,"%.0Lu%Lu",TotalDrives.current->BytesRead.HighPart,
TotalDrives.current->BytesRead.LowPart);
SetWindowText(staticHandle[9],buffer);
sprintf(buffer,"%.0Lu%Lu",TotalDrives.current->BytesWritten.HighPart,
TotalDrives.current->BytesWritten.LowPart);
SetWindowText(staticHandle[10],buffer);
Val.QuadPart = TotalDrives.previous->BytesRead.QuadPart / ElapsedTime;
sprintf (buffer,"%.0Lu%Lu",Val.HighPart,Val.LowPart);
SetWindowText(staticHandle[11],buffer);
Val.QuadPart = TotalDrives.previous->BytesWritten.QuadPart / ElapsedTime;
sprintf (buffer,"%.0Lu%Lu",Val.HighPart,Val.LowPart);
SetWindowText(staticHandle[12],buffer);
Val.QuadPart = (TotalDrives.previous->BytesWritten.QuadPart +
TotalDrives.previous->BytesRead.QuadPart) / ElapsedTime;
sprintf (buffer,"%.0Lu%Lu",Val.HighPart,Val.LowPart);
SetWindowText (staticHandle[13],buffer);
sprintf (buffer,"%Lu",TotalDrives.current->QueueDepth);
SetWindowText (staticHandle[14],buffer);
sprintf (buffer, "%Lu",TotalDrives.QDepth / ElapsedTime);
SetWindowText (staticHandle[15],buffer);
sprintf (buffer, "%Lu",TotalDrives.MaxQDepth);
SetWindowText (staticHandle[16],buffer);
sprintf (buffer, "%Lu",TotalDrives.current->ReadCount + TotalDrives.current->WriteCount);
SetWindowText (staticHandle[17],buffer);
}
Reference in a new issue Copy permalink