windows-server-2003/sdktools/diskperf/diskperf.c

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    diskperf.c

Abstract:

    Program to display and/or update the current value of the Diskperf
    driver startup value

Author:

    Bob Watson (a-robw) 4 Dec 92

Revision History:

--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntconfig.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <regstr.h>  // for REGSTR_VAL_UPPERFILTERS
#include <tchar.h>
#include <locale.h>

#include "diskperf.h"    // include text string id constancts
#pragma warning(disable:4201)
#include <ntdddisk.h>
#pragma warning(pop)
#include <mountmgr.h>

LANGID WINAPI MySetThreadUILanguage(
    WORD wReserved);

#define  SWITCH_CHAR    '-' // is there a system call to get this?
#define  ENABLE_CHAR    'Y' // command will be upcased
#define  DISABLE_CHAR   'N'
#define  ENHANCED_CHAR  'E'

#define  LOCAL_CHANGE   2   // number of commands in a local change command
#define  REMOTE_CHANGE  3   // number of commands in a remote change command

//
//  note these values are arbitrarily based on the whims of the people
//  developing the disk drive drivers that belong to the "Filter" group.
//
#define  TAG_NORMAL     4   // diskperf starts AFTER ftdisk
#define  TAG_ENHANCED   2   // diskperf starts BEFORE ftdisk

#define  IRP_STACK_ENABLED  5 // size of IRP stack when diskperf is enabled
#define  IRP_STACK_DISABLED 4 // size of IRP stack when diskperf is enabled

#define  IRP_STACK_DEFAULT  8 // default IRP stack size in W2K
#define  IRP_STACK_NODISKPERF 7

#define DISKPERF_SERVICE_NAME TEXT("DiskPerf")

LPCTSTR lpwszDiskPerfKey = TEXT("SYSTEM\\CurrentControlSet\\Services\\Diskperf");
LPCTSTR lpwszIOSystemKey = TEXT("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\I/O System");
LPCTSTR lpwszOsVersionKey = TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion");
LPCTSTR lpwszBuildNumber = TEXT("CurrentBuildNumber");
LPCTSTR lpwszOsVersion = TEXT("CurrentVersion");

#define ENABLE_DISKDRIVE        0x0001
#define ENABLE_VOLUME           0x0002
#define ENABLE_PERMANENT        0x0004
#define ENABLE_PERMANENT_IOCTL  0x0008

LPCTSTR lpwszDiskDriveKey
    = TEXT("SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E967-E325-11CE-BFC1-08002BE10318}");
LPCTSTR lpwszVolumeKey
    = TEXT("SYSTEM\\CurrentControlSet\\Control\\Class\\{71A27CDD-812A-11D0-BEC7-08002BE2092F}");

LPCTSTR lpwszPartmgrKey = TEXT("SYSTEM\\CurrentControlSet\\Services\\Partmgr");
LPCTSTR lpwszEnableCounterValue = TEXT("EnableCounterForIoctl");

ULONG
OpenRegKeys(
    IN LPCTSTR lpszMachine,
    OUT PHKEY hRegistry,
    OUT PHKEY hDiskKey,
    OUT PHKEY hVolumeKey,
    OUT PHKEY hServiceKey
    );

ULONG
SetFilter(
    IN HKEY hKey,
    IN LPTSTR strFilterString,
    IN DWORD dwSize
    );

ULONG
GetFilter(
    IN HKEY hKey,
    OUT LPTSTR strFilterString,
    IN DWORD dwSize
    );

ULONG
CheckFilter(
    IN TCHAR *Buffer
    );

ULONG
GetEnableFlag(
    IN HKEY hDiskKey,
    IN HKEY hVolumeKey
    );

ULONG
AddToFilter(
    IN HKEY hKey
    );

ULONG
RemoveFromFilter(
    IN HKEY hKey
    );

void
PrintStatus(
    IN BOOL bCurrent,
    IN ULONG EnableFlag,
    IN LPCTSTR cMachineName
    );

DWORD __cdecl
Dp_wprintf(
    const wchar_t *format,
    ...
    );

DWORD __cdecl
Dp_fwprintf(
    FILE *str,
    const wchar_t *format,
    ...
   );

DWORD __cdecl
Dp_vfwprintf(
    FILE *str,
    const wchar_t *format,
    va_list argptr
   );

BOOL
IsBeyondW2K(
    IN LPCTSTR lpszMachine,
    OUT PDWORD EnableCounter);

ULONG
EnableForIoctl(
    IN LPWSTR lpszMachineName
    );

ULONG
DisableForIoctl(
    IN LPWSTR lpszMachineName,
    IN ULONG Request
    );

#if DBG
void
DbgPrintMultiSz(
    TCHAR *String,
    size_t Size
    );
#endif

#define REG_TO_DP_INDEX(reg_idx)    (DP_LOAD_STATUS_BASE + (\
    (reg_idx == SERVICE_BOOT_START) ? DP_BOOT_START : \
    (reg_idx == SERVICE_SYSTEM_START) ? DP_SYSTEM_START : \
    (reg_idx == SERVICE_AUTO_START) ? DP_AUTO_START : \
    (reg_idx == SERVICE_DEMAND_START) ? DP_DEMAND_START : \
    (reg_idx == SERVICE_DISABLED) ? DP_NEVER_START : DP_UNDEFINED))

#define MAX_MACHINE_NAME_LEN    32

// command line arguments

#define CMD_SHOW_LOCAL_STATUS   1
#define CMD_DO_COMMAND          2

#define ArgIsSystem(arg)   (*(arg) == '\\' ? TRUE : FALSE)

//
//  global buffer for help text display strings
//
#define DISP_BUFF_LEN       256
#define NUM_STRING_BUFFS      2
LPCTSTR BlankString = TEXT(" ");
LPCTSTR StartKey = TEXT("Start");
LPCTSTR TagKey = TEXT("Tag");
LPCTSTR EmptyString = TEXT("");
LPCTSTR LargeIrps = TEXT("LargeIrpStackLocations");

HINSTANCE   hMod = NULL;
DWORD   dwLastError;


LPCTSTR
GetStringResource (
    UINT    wStringId
)
{
    static TCHAR    DisplayStringBuffer[NUM_STRING_BUFFS][DISP_BUFF_LEN];
    static DWORD    dwBuffIndex;
    LPTSTR          szReturnBuffer;

    dwBuffIndex++;
    dwBuffIndex %= NUM_STRING_BUFFS;
    szReturnBuffer = (LPTSTR)&DisplayStringBuffer[dwBuffIndex][0];

    if (!hMod) {
        hMod = (HINSTANCE)GetModuleHandle(NULL); // get instance ID of this module;
    }

    if (hMod) {
        if ((LoadString(hMod, wStringId, szReturnBuffer, DISP_BUFF_LEN)) > 0) {
            return (LPCTSTR)szReturnBuffer;
        } else {
            dwLastError = GetLastError();
            return EmptyString;
        }
    } else {
        return EmptyString;
    }
}
LPCTSTR
GetFormatResource (
    UINT    wStringId
)
{
    static TCHAR   TextFormat[DISP_BUFF_LEN];

    if (!hMod) {
        hMod = (HINSTANCE)GetModuleHandle(NULL); // get instance ID of this module;
    }

    if (hMod) {
        if ((LoadString(hMod, wStringId, TextFormat, DISP_BUFF_LEN)) > 0) {
            return (LPCTSTR)&TextFormat[0];
        } else {
            dwLastError = GetLastError();
            return BlankString;
        }
    } else {
        return BlankString;
    }
}

VOID
DisplayChangeCmd (
)
{
    UINT        wID;
    TCHAR       DisplayStringBuffer[DISP_BUFF_LEN];

    if (hMod) {
        if ((LoadString(hMod, DP_TEXT_FORMAT, DisplayStringBuffer, DISP_BUFF_LEN)) > 0) {
            for (wID=DP_CMD_HELP_START; wID <= DP_CMD_HELP_END; wID++) {
                if ((LoadString(hMod, wID, DisplayStringBuffer, DISP_BUFF_LEN)) > 0) {
                    Dp_wprintf(DisplayStringBuffer);
                }
            }
        }
    }
}
VOID
DisplayCmdHelp(
)
{
    UINT        wID;
    TCHAR       DisplayStringBuffer[DISP_BUFF_LEN];

    if (hMod) {
        if ((LoadString(hMod, DP_TEXT_FORMAT, DisplayStringBuffer, DISP_BUFF_LEN)) > 0) {
            for (wID=DP_HELP_TEXT_START; wID <= DP_HELP_TEXT_END; wID++) {
                if ((LoadString(hMod, wID, DisplayStringBuffer, DISP_BUFF_LEN)) > 0) {
                    Dp_wprintf(DisplayStringBuffer);
                }
            }
        }
    }

    DisplayChangeCmd();
}

ULONG
DisplayStatus (
    LPTSTR lpszMachine
)
{
    ULONG       Status;
    HKEY        hRegistry;
    HKEY        hDiskPerfKey;
    HKEY        hDiskKey;
    HKEY        hVolumeKey;
    DWORD       dwValue, dwValueSize, dwTag;

    TCHAR       cMachineName[MAX_MACHINE_NAME_LEN];
    PTCHAR      pThisWideChar;
    PTCHAR       pThisChar;
    INT         iCharCount;
    DWORD       EnableCounter;

    pThisChar = lpszMachine;
    pThisWideChar = cMachineName;
    iCharCount = 0;

    if (pThisChar) {    // if machine is not NULL, then copy
        while (*pThisChar) {
            *pThisWideChar++ = (TCHAR)(*pThisChar++);
            if (++iCharCount >= MAX_MACHINE_NAME_LEN) break;
        }
        *pThisWideChar = 0;
    }

    if (!lpszMachine) {
        LPTSTR strThisSystem = (LPTSTR) GetStringResource(DP_THIS_SYSTEM);
        if (strThisSystem != NULL) {
            _tcsncpy(cMachineName, strThisSystem, MAX_MACHINE_NAME_LEN);
            cMachineName[MAX_MACHINE_NAME_LEN-1] = 0;
        }
    }

    if (IsBeyondW2K(lpszMachine, &EnableCounter)) {
        if (EnableCounter) {
            PrintStatus(TRUE, ENABLE_PERMANENT_IOCTL, cMachineName);
        }
        else {
            PrintStatus(TRUE, ENABLE_PERMANENT, cMachineName);
        }
        return ERROR_SUCCESS;
    }

    Status = OpenRegKeys(
                lpszMachine,
                &hRegistry,
                &hDiskKey,
                &hVolumeKey,
                &hDiskPerfKey);

    if (Status != ERROR_SUCCESS) {
#if DBG
        fprintf(stderr,
                "DisplayStatus: Cannot open HKLM on target machine: %d\n",
                Status);
#endif
        Dp_wprintf(GetFormatResource(DP_UNABLE_READ_REGISTRY));
        return Status;
    }

    dwTag = GetEnableFlag(hDiskKey, hVolumeKey);
    dwValue = (dwTag == 0) ? SERVICE_DISABLED : SERVICE_BOOT_START;
    dwValueSize = sizeof(dwValue);
    Status = RegQueryValueEx (
                hDiskPerfKey,
                StartKey,
                NULL,
                NULL,
                (LPBYTE)&dwValue,
                &dwValueSize);

    if (Status != ERROR_SUCCESS) {
        Dp_wprintf(GetFormatResource(DP_UNABLE_READ_START));
        goto DisplayStatusCleanup;
    }

    PrintStatus(TRUE, dwTag, cMachineName);

  DisplayStatusCleanup:
    RegCloseKey(hDiskKey);
    RegCloseKey(hVolumeKey);
    RegCloseKey(hDiskPerfKey);
    RegCloseKey(hRegistry);

    if (Status != ERROR_SUCCESS) {
        Dp_wprintf(GetFormatResource(DP_STATUS_FORMAT), Status);

    }
    return Status;
}

ULONG
DoChangeCommand (
    LPTSTR lpszCommand,
    LPTSTR lpszMachine
)
{
    // connect to registry on local machine with read/write access
    ULONG       Status;
    HKEY        hRegistry;
    HKEY        hDiskPerfKey;
    HKEY        hDiskKey;
    HKEY        hVolumeKey;
    DWORD       dwValue;

    TCHAR       cMachineName[MAX_MACHINE_NAME_LEN];
    PTCHAR      pThisWideChar;
    PTCHAR       pThisChar;
    INT         iCharCount;
    PTCHAR       pCmdChar;

    HKEY        hIOSystemKey;
    DWORD       dwDisposition;
    DWORD       dwIrpValue;
    ULONG       EnableRequest, DisableRequest;
    ULONG       EnableFlag, EndFlag = 0;
    BOOL        bModified, bIrpStackReg;
    LONG        nIrpStack, nIrpStackReg, nIncrement;
    DWORD       EnableCounter;

    // check command to see if it's valid

    _tcsupr (lpszCommand);

    pCmdChar = lpszCommand;
    dwValue = 0;
    EnableRequest = DisableRequest = 0;

    if (*pCmdChar++ == SWITCH_CHAR ) {
        if (!_tcscmp(pCmdChar, _T("Y")) ||
            !_tcscmp(pCmdChar, _T("YA")) ||
            !_tcscmp(pCmdChar, _T("YALL"))) {
            EnableRequest = ENABLE_DISKDRIVE | ENABLE_VOLUME;
        }
        else if (!_tcscmp(pCmdChar, _T("N")) ||
            !_tcscmp(pCmdChar, _T("NA")) ||
            !_tcscmp(pCmdChar, _T("NALL")) ) {
            DisableRequest = ENABLE_DISKDRIVE | ENABLE_VOLUME;
        }
        else if (!_tcscmp(pCmdChar, _T("YD")) ||
            !_tcscmp(pCmdChar, _T("YDISK")) ) {
            EnableRequest = ENABLE_DISKDRIVE;
        }
        else if (!_tcscmp(pCmdChar, _T("YV")) ||
            !_tcscmp(pCmdChar, _T("YVOLUME")) ) {
            EnableRequest = ENABLE_VOLUME;
        }
        else if (!_tcscmp(pCmdChar, _T("ND")) ||
            !_tcscmp(pCmdChar, _T("NDISK")) ) {
            DisableRequest = ENABLE_DISKDRIVE;
        }
        else if (!_tcscmp(pCmdChar, _T("NV")) ||
            !_tcscmp(pCmdChar, _T("NVOLUME")) ) {
            DisableRequest = ENABLE_VOLUME;
        } else {
            DisplayCmdHelp();
            return ERROR_SUCCESS;
        }
    } else {
        DisplayChangeCmd();
        return ERROR_SUCCESS;
    }

    // if command OK then convert machine to wide string for connection

    pThisChar = lpszMachine;
    pThisWideChar = cMachineName;
    iCharCount = 0;

    if (pThisChar) {
        while (*pThisChar) {
            *pThisWideChar++ = (TCHAR)(*pThisChar++);
            if (++iCharCount >= MAX_MACHINE_NAME_LEN) break;
        }
        *pThisWideChar = 0; // null terminate
    }

    if (lpszMachine == NULL) {
        LPTSTR strThisSystem = (LPTSTR) GetStringResource(DP_THIS_SYSTEM);
        if (strThisSystem != NULL) {
            _tcsncpy (cMachineName, strThisSystem, MAX_MACHINE_NAME_LEN);
            cMachineName[MAX_MACHINE_NAME_LEN-1] = 0;
        }
    }

    if (IsBeyondW2K(lpszMachine, &EnableCounter)) {
        if (EnableRequest != 0) {
            EnableForIoctl(lpszMachine);
            PrintStatus(TRUE, ENABLE_PERMANENT_IOCTL, cMachineName);
        }
        else if (DisableRequest != 0) {
            DisableForIoctl(lpszMachine, DisableRequest);
            PrintStatus(TRUE, ENABLE_PERMANENT, cMachineName);
        }
        return ERROR_SUCCESS;
    }

    // connect to registry
    Status = OpenRegKeys(
                lpszMachine,
                &hRegistry,
                &hDiskKey,
                &hVolumeKey,
                &hDiskPerfKey);

    if (Status != ERROR_SUCCESS) {
#if DBG
        fprintf(stderr,
                "DoChangeCommand: Cannot connect to registry: Status=%d\n",
                Status);
#endif
        Dp_wprintf(GetFormatResource(DP_UNABLE_READ_REGISTRY));
        return Status;
    }

    hIOSystemKey = NULL;
    nIrpStackReg = 0;
    bIrpStackReg = FALSE;       // no registry key prior to this
    Status = RegCreateKeyEx (
                hRegistry,
                lpwszIOSystemKey,
                0L, //Reserved
                NULL,
                0L, // no special options
                KEY_WRITE | KEY_READ, // desired access
                NULL, // default security
                &hIOSystemKey,
                &dwDisposition);
    if (Status != ERROR_SUCCESS) {
        if ((Status == ERROR_ALREADY_EXISTS) &&
            (dwDisposition == REG_OPENED_EXISTING_KEY)) {
            // then this key is already in the registry so this is OK
                Status = ERROR_SUCCESS;
        }
        else {
            Dp_wprintf(GetFormatResource(DP_UNABLE_READ_REGISTRY));
            goto DoChangeCommandCleanup;
        }
    }
    if ( (Status == ERROR_SUCCESS) && (dwDisposition == REG_OPENED_EXISTING_KEY)) {
            DWORD dwSize;
            dwSize = sizeof(DWORD);

            Status = RegQueryValueEx (
                        hIOSystemKey,
                        LargeIrps,
                        0L,
                        NULL,
                        (LPBYTE)&dwIrpValue,
                        &dwSize);
            if (Status == ERROR_SUCCESS) {
#if DBG
                fprintf(stderr, "Registry LargeIrpStack=%d\n", dwIrpValue);
#endif
                nIrpStackReg = dwIrpValue;
                bIrpStackReg = TRUE;
            }
    }

    EnableFlag = GetEnableFlag(hDiskKey, hVolumeKey);
#if DBG
    fprintf(stderr, "DoChangeCommand: EnableFlag is %x\n", EnableFlag);
#endif

    bModified = FALSE;

    nIncrement = 0;
    if ( (EnableRequest & ENABLE_DISKDRIVE) &&
        !(EnableFlag & ENABLE_DISKDRIVE) ) {
        // Turn on filter for disk drives
        if (AddToFilter(hDiskKey) == ERROR_SUCCESS) {
            bModified = TRUE;
            nIncrement++;
        }
    }
    if ( (EnableRequest & ENABLE_VOLUME) &&
        !(EnableFlag & ENABLE_VOLUME) ) {
        // Turn on filter for volumes
        if (AddToFilter(hVolumeKey) == ERROR_SUCCESS) {
            bModified = TRUE;
            nIncrement++;
        }
    }
    if ( (DisableRequest & ENABLE_DISKDRIVE) &&
         (EnableFlag & ENABLE_DISKDRIVE) ) {
        // Turn off filter for disk drives
        if (RemoveFromFilter(hDiskKey) == ERROR_SUCCESS) {
            bModified = TRUE;
            nIncrement--;
        }
    }
    if ( (DisableRequest & ENABLE_VOLUME) &&
         (EnableFlag & ENABLE_VOLUME) ) {
        // Turn off filter for volumes
        if (RemoveFromFilter(hVolumeKey) == ERROR_SUCCESS) {
            bModified = TRUE;
            nIncrement--;
        }
    }

    nIrpStack = 0;
    EndFlag = GetEnableFlag(hDiskKey, hVolumeKey);

    if (bModified) {    // we have modified the registry


        dwValue = (EndFlag == 0) ? SERVICE_DISABLED : SERVICE_BOOT_START;
        Status = RegSetValueEx(
                    hDiskPerfKey,
                    StartKey,
                    0L,
                    REG_DWORD,
                    (LPBYTE)&dwValue,
                    sizeof(dwValue));
        //
        // First update service registry entries
        //

        if (DisableRequest != 0) {
            nIrpStack = nIrpStackReg + nIncrement;
            if (EndFlag == 0) {
                //
                // Turn off service completely
                //
                // Set Irp stack size to original value or default
                if (nIrpStack < IRP_STACK_NODISKPERF)
                    nIrpStack = IRP_STACK_NODISKPERF;
            }
            else {  // else, there is only one stack left
                if (nIrpStack < IRP_STACK_NODISKPERF+1)
                    nIrpStack = IRP_STACK_NODISKPERF+1;
            }
        }
        else if (EnableRequest != 0) {
            nIrpStack = nIrpStackReg + nIncrement;
            //
            // Set proper Irp stack size
            //
            if (EndFlag == (ENABLE_DISKDRIVE | ENABLE_VOLUME)) {
                if (nIrpStack < IRP_STACK_NODISKPERF+2)    // a value is set
                    nIrpStack = IRP_STACK_NODISKPERF+2;
            }
            else {  // at least one is enabled
                if (nIrpStack < IRP_STACK_NODISKPERF+1)
                    nIrpStack = IRP_STACK_NODISKPERF+1;
            }
        }
    }
    else {
        //
        // No action taken. Should tell the user the state.
        //        
        PrintStatus(TRUE, EndFlag, cMachineName);
        Dp_wprintf(GetFormatResource(DP_NOCHANGE));
    }

#if DBG
    fprintf(stderr, "New LargeIrp is %d\n", nIrpStack);
#endif
    if (hIOSystemKey != NULL && Status == ERROR_SUCCESS) {
        if (bModified) {
            Status = RegSetValueEx (
                        hIOSystemKey,
                        LargeIrps,
                        0L,
                        REG_DWORD,
                        (LPBYTE)&nIrpStack,
                        sizeof(DWORD));
            if (Status == ERROR_SUCCESS) {
                PrintStatus(FALSE, EndFlag, cMachineName);
            }
            else {
                Dp_wprintf(GetFormatResource(DP_UNABLE_MODIFY_VALUE));
            }
        }
        RegCloseKey(hIOSystemKey);
    }

  DoChangeCommandCleanup:
    if (hDiskPerfKey != NULL) {
        RegCloseKey(hDiskPerfKey);
    }
    if (hDiskKey != NULL) {
        RegCloseKey(hDiskKey);
    }
    if (hVolumeKey != NULL) {
        RegCloseKey(hVolumeKey);
    }
    if (hRegistry != NULL) {
        RegCloseKey(hRegistry);
    }
    if (Status != ERROR_SUCCESS) {
        Dp_wprintf(GetFormatResource(DP_STATUS_FORMAT), Status);
    }
    return Status;
}

ULONG
OpenRegKeys(
    IN LPCTSTR lpszMachine,
    OUT PHKEY hRegistry,
    OUT PHKEY hDiskKey,
    OUT PHKEY hVolumeKey,
    OUT PHKEY hServiceKey
    )
{
    ULONG status;

    if (hRegistry == NULL)
        return ERROR_INVALID_PARAMETER;

    *hRegistry = NULL;
    status = RegConnectRegistry(
                lpszMachine,
                HKEY_LOCAL_MACHINE,
                hRegistry);
    if (status != ERROR_SUCCESS) {
        *hRegistry = NULL;
        return status;
    }
    if (*hRegistry == NULL)
        return ERROR_INVALID_PARAMETER; // Avoid PREFIX error

    if (hDiskKey) {
        *hDiskKey = NULL;
        if (status == ERROR_SUCCESS) {
            status = RegOpenKeyEx(
                        *hRegistry,
                        lpwszDiskDriveKey,
                        (DWORD) 0,
                        KEY_SET_VALUE | KEY_QUERY_VALUE,
                        hDiskKey);
        }
    }
    if (hVolumeKey) {
        *hVolumeKey = NULL;
        if (status == ERROR_SUCCESS) {
            status = RegOpenKeyEx(
                        *hRegistry,
                        lpwszVolumeKey,
                        (DWORD) 0,
                        KEY_SET_VALUE | KEY_QUERY_VALUE,
                        hVolumeKey);
        }
    }
    if (hServiceKey) {
        *hServiceKey = NULL;
        if (status == ERROR_SUCCESS) {
            status = RegOpenKeyEx(
                        *hRegistry,
                        lpwszDiskPerfKey,
                        (DWORD) 0,
                        KEY_SET_VALUE | KEY_QUERY_VALUE,
                        hServiceKey);
        }
    }
    if ( (status != ERROR_SUCCESS) && (hDiskKey != NULL) ) {
        if ((*hDiskKey != NULL) && (*hDiskKey != INVALID_HANDLE_VALUE)) {
            RegCloseKey(*hDiskKey);
        }
        *hDiskKey = NULL;
    }
    if ( (status != ERROR_SUCCESS) && (hVolumeKey != NULL) ) {
        if ((*hVolumeKey != NULL) && (*hVolumeKey != INVALID_HANDLE_VALUE)) {
            RegCloseKey(*hVolumeKey);
        }
        *hVolumeKey = NULL;
    }
    if ( (status != ERROR_SUCCESS) && (hServiceKey != NULL) ) {
        if ((*hServiceKey != NULL) && (*hServiceKey != INVALID_HANDLE_VALUE)) {
            RegCloseKey(*hServiceKey);
        }
        *hServiceKey = NULL;
    }
    //
    // hRegistry and *hRegistry cannot be NULL here
    //
    if ( (status != ERROR_SUCCESS) && (*hRegistry != INVALID_HANDLE_VALUE)) {
        RegCloseKey(*hRegistry);
        *hRegistry = NULL;
    }
    return status;
}

ULONG
SetFilter(
    IN HKEY hKey,
    IN LPTSTR strFilterString,
    IN DWORD dwSize
    )
{
    ULONG status;
    LONG len;
    DWORD dwType = REG_MULTI_SZ;

    if (hKey == NULL)
        return ERROR_BADKEY;

//
// NOTE: Assumes that strFilterString is always MAX_PATH, NULL padded
//
    len = dwSize / sizeof(TCHAR);
    if (len < 2) {
        dwSize = 2 * sizeof(TCHAR);
#if DBG
        fprintf(stderr, "SetFilter: Length %d dwSize %d\n", len, dwSize);
#endif
    }
    else {  // ensures 2 null character always
        if (strFilterString[len-1] != 0) { // no trailing null
            len += 2;
            strFilterString[len] = 0;
            strFilterString[len+1] = 0;
#if DBG
    fprintf(stderr, "SetFilter: New length(+2) %d\n", len);
#endif
        }
        else if (strFilterString[len-2] != 0) { // only one trailing null
            len += 1;
            strFilterString[len+1] = 0;
#if DBG
            fprintf(stderr, "SetFilter: New length(+1) %d\n", len);
#endif
        }
        dwSize = len * sizeof(TCHAR);
    } 
    if (len <= 2) {
        status = RegDeleteValue(hKey, REGSTR_VAL_UPPERFILTERS);
#if DBG
        fprintf(stderr, "Delete status = %d\n", status);
#endif
        return status;
    }
    status = RegSetValueEx(
                hKey,
                REGSTR_VAL_UPPERFILTERS,
                (DWORD) 0,
                dwType,
                (BYTE*)strFilterString,
                dwSize);

#if DBG
    if (status != ERROR_SUCCESS) {
        _ftprintf(stderr, _T("SetFilter: Cannot query key %s status=%d\n"),
                REGSTR_VAL_UPPERFILTERS, status);
    }
    else {
        fprintf(stderr, "SetFilter: ");
        DbgPrintMultiSz(strFilterString, dwSize);
        fprintf(stderr, "\n");
    }
#endif
    return status;
}

ULONG
GetFilter(
    IN HKEY hKey,
    OUT LPTSTR strFilterString,
    IN DWORD dwSize
    )
// Returns size of strFilterString
{
    ULONG status;

    if (hKey == NULL)
        return ERROR_BADKEY;

    status = RegQueryValueEx(
                hKey,
                REGSTR_VAL_UPPERFILTERS,
                NULL,
                NULL,
                (BYTE*)strFilterString,
                &dwSize);
    if (status != ERROR_SUCCESS) {
#if DBG
        _ftprintf(stderr, _T("GetFilter: Cannot query key %s status=%d\n"),
                REGSTR_VAL_UPPERFILTERS, status);
#endif
        return 0;
    }
#if DBG
    else {
        fprintf(stderr, "GetFilter: ");
        DbgPrintMultiSz(strFilterString, dwSize);
        fprintf(stderr, "\n");
    }
#endif
    return dwSize;
}

ULONG
CheckFilter(TCHAR *Buffer)
{
    TCHAR *string = Buffer;
    ULONG stringLength, diskperfLen, result;

    if (string == NULL)
        return 0;
    stringLength = (ULONG) _tcslen(string);

    diskperfLen = (ULONG) _tcslen(DISKPERF_SERVICE_NAME);

    result = FALSE;
    while(stringLength != 0) {

        if ((diskperfLen == stringLength) && 
            (_tcsicmp(string, DISKPERF_SERVICE_NAME) == 0)) {
#if DBG
            fprintf(stderr, 
                    "CheckFilter: string found at offset %d\n",
                    (string - Buffer));
#endif
            result = TRUE;
            break;
        }
        string += stringLength + 1;
        stringLength = (ULONG) _tcslen(string);
    }
    return result;
}

ULONG
GetEnableFlag(
    IN HKEY hDiskKey,
    IN HKEY hVolumeKey
    )
// Returns the flags indicating what is enabled
{
    ULONG bFlag = 0;
    TCHAR strFilter[MAX_PATH+1] = {0};
    DWORD dwSize;

    dwSize = sizeof(TCHAR) * (MAX_PATH+1);
    if (GetFilter(hDiskKey, strFilter, dwSize) > 0) {
        if (CheckFilter(strFilter))
            bFlag |= ENABLE_DISKDRIVE;
    }
#if DBG
    else
        fprintf(stderr, "GetEnableFlag: No filters for disk drive\n");
#endif

    dwSize = sizeof(TCHAR) * (MAX_PATH+1);
    if (GetFilter(hVolumeKey, strFilter, dwSize) > 0) {
        if (CheckFilter(strFilter))
            bFlag |= ENABLE_VOLUME;
    }
#if DBG
    else
        fprintf(stderr, "GetEnableFlag: No filters for volume\n");
#endif
    return bFlag;
}

ULONG
AddToFilter(
    IN HKEY hKey
    )
{
    TCHAR *string, buffer[MAX_PATH+1];
    ULONG dataLength;
    DWORD dwLength, dwSize;

    dwSize = sizeof(TCHAR) * MAX_PATH;
    RtlZeroMemory(buffer, dwSize + sizeof(TCHAR));
    string = buffer;

    dataLength = GetFilter(hKey, buffer, dwSize);
    dwSize = dataLength;
    if (dwSize > (sizeof(TCHAR) * MAX_PATH)) {      // just in case
        dwSize = sizeof(TCHAR) * MAX_PATH;
    }
#if DBG
    if (dataLength > 0) {
        fprintf(stderr, "AddToFilter: Original string ");
        DbgPrintMultiSz(buffer, dataLength);
        fprintf(stderr, "\n");
    }
    else fprintf(stderr, "AddToFilter: Cannot get original string\n");
#endif
    dataLength = dataLength / sizeof(TCHAR);
    if (dataLength != 0) {
        dataLength -= 1;
    }
    dwLength = (DWORD) _tcslen(DISKPERF_SERVICE_NAME);
    if (dataLength <  (MAX_PATH-dwLength-1)) {
        _tcscpy(&(string[dataLength]), DISKPERF_SERVICE_NAME);
        dwSize += (dwLength+1) * sizeof(TCHAR);
    }

#if DBG
    fprintf(stderr, "AddToFilter: New string ");
    DbgPrintMultiSz(buffer, dataLength + _tcslen(DISKPERF_SERVICE_NAME)+1);
    fprintf(stderr, "\n"); 
#endif
    return SetFilter(hKey, buffer, dwSize);
}

void
PrintStatus(
    IN BOOL bCurrent,
    IN ULONG EnableFlag,
    IN LPCTSTR cMachineName
    )
{
    DWORD       dwValue;
    TCHAR       OemDisplayStringBuffer[DISP_BUFF_LEN * 2];

    dwValue = (EnableFlag == 0) ? SERVICE_DISABLED : SERVICE_BOOT_START;
    if ((EnableFlag & ENABLE_PERMANENT) | (EnableFlag & ENABLE_PERMANENT_IOCTL)) {
        _stprintf(OemDisplayStringBuffer,
                  GetFormatResource(DP_PERMANENT_FORMAT),
                  cMachineName);
        if (EnableFlag & ENABLE_PERMANENT_IOCTL) {
            Dp_wprintf(OemDisplayStringBuffer);
            _stprintf(OemDisplayStringBuffer,
                      GetFormatResource(DP_PERMANENT_IOCTL),
                      cMachineName);
        }
        else {
            Dp_wprintf(OemDisplayStringBuffer);
            _stprintf(OemDisplayStringBuffer,
                      GetFormatResource(DP_PERMANENT_FORMAT1),
                      cMachineName);
            Dp_wprintf(OemDisplayStringBuffer);
            _stprintf(OemDisplayStringBuffer,
                      GetFormatResource(DP_PERMANENT_FORMAT2),
                      cMachineName);
        }
    }
    else  if ( (EnableFlag == (ENABLE_DISKDRIVE | ENABLE_VOLUME)) ||
               (EnableFlag == 0) ) {
        _stprintf(OemDisplayStringBuffer,
                bCurrent ?  GetFormatResource (DP_CURRENT_FORMAT1)
                         :  GetFormatResource (DP_NEW_DISKPERF_STATUS1),
                cMachineName,
                GetStringResource(REG_TO_DP_INDEX(dwValue)));
    }
    else {
        _stprintf (OemDisplayStringBuffer,
                 bCurrent ?  GetFormatResource (DP_CURRENT_FORMAT)
                          :  GetFormatResource (DP_NEW_DISKPERF_STATUS),
                 (EnableFlag  == ENABLE_DISKDRIVE) ?
                 GetStringResource(DP_PHYSICAL) :
                 GetStringResource(DP_LOGICAL),
                 cMachineName,
                 GetStringResource(REG_TO_DP_INDEX(dwValue)));
    }
    Dp_wprintf(OemDisplayStringBuffer);
}

ULONG
RemoveFromFilter(
    IN HKEY hKey
    )
{
    TCHAR *string, buffer[MAX_PATH+1];
    ULONG dataLength, stringLength, diskperfLen, found;
    ULONG removeSize;

    dataLength = sizeof(TCHAR) * (MAX_PATH+1);      // Compute size first
    RtlZeroMemory(buffer, sizeof(TCHAR) * MAX_PATH);
    dataLength = GetFilter(hKey, buffer, dataLength);
    if (dataLength == 0)
        return 0;

#if DBG
    fprintf(stderr, "RemoveFromFilter: Original string ");
    DbgPrintMultiSz(buffer, dataLength);
    fprintf(stderr, "'\n");
#endif

    string = (TCHAR *) buffer;
    dataLength -= sizeof(TCHAR);

    //
    // now, find DiskPerf from the entry to remove it
    //
    stringLength = (ULONG) _tcslen(string);

    diskperfLen = (ULONG) _tcslen(DISKPERF_SERVICE_NAME); // includes NULL
    removeSize = (diskperfLen+1) * sizeof(TCHAR);

#if DBG
    fprintf(stderr, "RemoveFromFilter: diskperfLen=%d removeSize=%d\n",
                    diskperfLen, removeSize);
#endif
    found = FALSE;
    while(stringLength != 0 && !found) {

#if DBG
        fprintf(stderr,
            "RemoveFromFilter: Loop stringLength=%d\n", stringLength);
#endif
        if (diskperfLen == stringLength) {
            if(_tcsicmp(string, DISKPERF_SERVICE_NAME) == 0) {
                //
                // found it, so we will remove it right now
                //
                if (dataLength > removeSize) {
                    RtlCopyMemory(
                        string,
                        string+stringLength+1,
                        dataLength - removeSize);
                    RtlZeroMemory(
                        (PUCHAR)(buffer) + dataLength - removeSize,
                        removeSize);
                }
                else {
                    RtlZeroMemory( buffer, removeSize);
                }
                found = TRUE;
            }
        }
        // else, try the next entry
        string += stringLength + 1;
        stringLength = (ULONG) _tcslen(string);
    }
    dataLength = dataLength + sizeof(TCHAR) - removeSize;
    if (dataLength <= MAX_PATH*sizeof(TCHAR))
        buffer[dataLength/sizeof(TCHAR)] = 0;

#if DBG
    fprintf(stderr, "RemoveFromFilter: New string ");
    DbgPrintMultiSz(buffer, dataLength);
    fprintf(stderr, "\n");
#endif
    return SetFilter(hKey, buffer, dataLength);
}




 /***
 * Dp_wprintf(format) - print formatted data
 *
 * Prints Unicode formatted string to console window using WriteConsoleW. 
 * Note: This Dp_wprintf() is used to workaround the problem in c-runtime
 * which looks up LC_CTYPE even for Unicode string.
 *
 */

DWORD __cdecl
Dp_wprintf(
    const wchar_t *format,
    ...
    )

{
    DWORD  cchWChar;

    va_list args;
    va_start( args, format );

    cchWChar = Dp_vfwprintf(stdout, format, args);

    va_end(args);

    return cchWChar;
}



 /***
 * Dp_fwprintf(stream, format) - print formatted data
 *
 * Prints Unicode formatted string to console window using WriteConsoleW. 
 * Note: This Dp_fwprintf() is used to workaround the problem in c-runtime
 * which looks up LC_CTYPE even for Unicode string.
 *
 */

DWORD __cdecl
Dp_fwprintf(
    FILE *str,
    const wchar_t *format,
    ...
   )

{
    DWORD  cchWChar;

    va_list args;
    va_start( args, format );

    cchWChar = Dp_vfwprintf(str, format, args);

    va_end(args);

    return cchWChar;
}


DWORD __cdecl
Dp_vfwprintf(
    FILE *str,
    const wchar_t *format,
    va_list argptr
   )

{
    HANDLE hOut;

    if (str == stderr) {
        hOut = GetStdHandle(STD_ERROR_HANDLE);
    }
    else {
        hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    }

    if ((GetFileType(hOut) & ~FILE_TYPE_REMOTE) == FILE_TYPE_CHAR) {
        DWORD  cchWChar;
        WCHAR  szBufferMessage[1024];

        vswprintf( szBufferMessage, format, argptr );
        cchWChar = (DWORD) wcslen(szBufferMessage);
        WriteConsoleW(hOut, szBufferMessage, cchWChar, &cchWChar, NULL);
        return cchWChar;
    }

    return vfwprintf(str, format, argptr);
}



#if DBG
void
DbgPrintMultiSz(
    TCHAR *String,
    size_t Size
    )
{
    size_t len;

#if DBG
    fprintf(stderr, "%d ", Size);
#endif
    len = _tcslen(String);
    while (len > 0) {
        _ftprintf(stderr, _T("'%s' "), String);
        String += len+1;
        len = _tcslen(String);
    }
}
#endif


void
SplitCommandLine(
    LPTSTR CommandLine,
    LPTSTR* pArgv
    )
{

    LPTSTR arg;
    int i = 0;
    arg = _tcstok( CommandLine, _T(" \t"));
    while( arg != NULL ){
        _tcscpy(pArgv[i++], arg);
        arg = _tcstok(NULL, _T(" \t"));
    }
}

int 
__cdecl main(
    int argc, 
    char **argv
    )
{
    LPTSTR *targv,*commandLine;
    ULONG  Status = ERROR_SUCCESS;
    int i;

    setlocale(LC_ALL, ".OCP");

    MySetThreadUILanguage(0);

    commandLine = (LPTSTR*)malloc( argc * sizeof(LPTSTR) );
    if (!commandLine)
        exit(1);
    for(i=0;i<argc;i++){
        commandLine[i] = (LPTSTR)malloc( (strlen(argv[i])+1) * sizeof(LPTSTR));
        if (!commandLine[i]) 
            exit(1);
    }

    SplitCommandLine( GetCommandLine(), commandLine );
    targv = commandLine;

    hMod = (HINSTANCE)GetModuleHandle(NULL); // get instance ID of this module;

    // check for command arguments
    
    if (argc == CMD_SHOW_LOCAL_STATUS) {
        Status = DisplayStatus(NULL);
    } else if (argc >= CMD_DO_COMMAND) {
        if (ArgIsSystem(targv[1])) {
            Status = DisplayStatus (targv[1]);
        } else {    // do change command
            if (argc == LOCAL_CHANGE) {
                DoChangeCommand (targv[1], NULL);
            } else if (argc == REMOTE_CHANGE) {
                DoChangeCommand(targv[1], targv[2]);
            } else {
                DisplayChangeCmd();
            }
        }
    } else {
        DisplayCmdHelp();
    }
    Dp_wprintf(_T("\n"));

    for(i=0;i<argc;i++){
        free(commandLine[i]);
        commandLine[i] = NULL;
    }
    free(commandLine);

    return 0;
}

BOOL
IsBeyondW2K(
    IN LPCTSTR lpszMachine,
    OUT PDWORD EnableCounter
    )
{
    OSVERSIONINFO OsVersion;
    HKEY hRegistry, hKey;
    TCHAR szBuildNumber[32];
    TCHAR szVersion[32];
    DWORD dwBuildNumber, dwMajor, status, dwSize;
    BOOL bRet = FALSE;

    *EnableCounter = 0;
    hRegistry = INVALID_HANDLE_VALUE;
    if (lpszMachine != NULL) {
        if (*lpszMachine != 0) {
           status = RegConnectRegistry(
                       lpszMachine,
                       HKEY_LOCAL_MACHINE,
                       &hRegistry);
            if (status != ERROR_SUCCESS)
                return FALSE;
            status = RegOpenKeyEx(
                        hRegistry,
                        lpwszOsVersionKey,
                        (DWORD) 0,
                        KEY_QUERY_VALUE,
                        &hKey);
            if (status != ERROR_SUCCESS) {
                RegCloseKey(hRegistry);
                return FALSE;
            }
            dwSize = sizeof(TCHAR) * 32;
            status = RegQueryValueEx(
                        hKey,
                        lpwszBuildNumber,
                        NULL,
                        NULL,
                        (BYTE*)szBuildNumber,
                        &dwSize);
            if (status != ERROR_SUCCESS) {
                RegCloseKey(hKey);
                RegCloseKey(hRegistry);
                return FALSE;
            }
            status = RegQueryValueEx(
                       hKey,
                       lpwszOsVersion,
                       NULL,
                       NULL,
                       (BYTE*)szVersion,
                       &dwSize);
            if (status != ERROR_SUCCESS) {
                RegCloseKey(hKey);
                RegCloseKey(hRegistry);
                return FALSE;
            }
            RegCloseKey(hKey);
            status = RegOpenKeyEx(
                        hRegistry,
                        lpwszPartmgrKey,
                        (DWORD) 0,
                        KEY_QUERY_VALUE,
                        &hKey);
            if (status == ERROR_SUCCESS) {
                *EnableCounter = 0;
                status = RegQueryValueEx(
                            hKey,
                            lpwszEnableCounterValue,
                            NULL,
                            NULL,
                            (BYTE*) EnableCounter,
                            &dwSize);
                if ((status != ERROR_SUCCESS) || (dwSize != sizeof(DWORD))) {
                    *EnableCounter = 0;
                }
                RegCloseKey(hKey);
            }
            dwBuildNumber = _ttoi(szBuildNumber);
            dwMajor = _ttoi(szVersion);
            if ((dwMajor >= 5) && (dwBuildNumber > 2195)) {
                bRet = TRUE;
                status = RegOpenKeyEx(
                            hRegistry,
                            lpwszPartmgrKey,
                            (DWORD) 0,
                            KEY_QUERY_VALUE,
                            &hKey);
                if (status == ERROR_SUCCESS) {
                    status = RegQueryValueEx(
                                hKey,
                                lpwszEnableCounterValue,
                                NULL,
                                NULL,
                                (BYTE*) EnableCounter,
                                &dwSize);
                    if ((status != ERROR_SUCCESS) || (dwSize != sizeof(DWORD))) {
                        *EnableCounter = 0;
                    }
                    RegCloseKey(hKey);
                }
            }
            if (hRegistry != INVALID_HANDLE_VALUE) {
                RegCloseKey(hRegistry);
            }
        }
    }
    else {
        OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        if (GetVersionEx(&OsVersion)) {
            if ((OsVersion.dwMajorVersion >= 5) &&
                (OsVersion.dwMinorVersion > 0) &&
                (OsVersion.dwBuildNumber > 2195))
            return TRUE;
        }
    }
    return FALSE;
}

ULONG
EnableForIoctl(
    IN LPWSTR lpszMachineName
    )
{
    DWORD status;
    HKEY hRegistry, hKey;
    DWORD dwValue = 1;

    hRegistry = NULL;

    status = RegConnectRegistry(
                lpszMachineName,
                HKEY_LOCAL_MACHINE,
                &hRegistry);
    if (status != ERROR_SUCCESS)
        return status;
    if (hRegistry == NULL)
        return ERROR_INVALID_PARAMETER;

    hKey = NULL;
    status = RegOpenKeyEx(
                hRegistry,
                lpwszPartmgrKey,
                (DWORD) 0,
                KEY_SET_VALUE | KEY_QUERY_VALUE,
                &hKey);
    if (status != ERROR_SUCCESS) {
        RegCloseKey(hRegistry);
        return status;
    }
    status = RegSetValueEx(
                hKey,
                lpwszEnableCounterValue,
                0L,
                REG_DWORD,
                (LPBYTE)&dwValue,
                sizeof(dwValue));
    RegCloseKey(hKey);
    RegCloseKey(hRegistry);
    return 0;
}

ULONG
DisableForIoctl(
    IN LPWSTR lpszMachineName,
    IN ULONG Request
    )
{
    ULONG nDisk, i;
    SYSTEM_DEVICE_INFORMATION DeviceInfo;
    NTSTATUS status;

    UNICODE_STRING UnicodeName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatus;

    WCHAR devname[MAX_PATH+1];
    PWCHAR s;

    HANDLE PartitionHandle, MountMgrHandle, VolumeHandle;
    DWORD ReturnedBytes;

    HKEY hRegistry, hKey;

    status = RegConnectRegistry(
                lpszMachineName,
                HKEY_LOCAL_MACHINE,
                &hRegistry);
    if (status != ERROR_SUCCESS)
        return status;
    if (hRegistry == NULL)
        return ERROR_INVALID_PARAMETER;

    status = RegOpenKeyEx(
                hRegistry,
                lpwszPartmgrKey,
                (DWORD) 0,
                KEY_SET_VALUE | KEY_QUERY_VALUE,
                &hKey);
    if (status != ERROR_SUCCESS) {
        RegCloseKey(hRegistry);
        return status;
    }
    RegDeleteValue(hKey, lpwszEnableCounterValue);
    RegCloseKey(hKey);
    RegCloseKey(hRegistry);

    if (!(Request & ENABLE_DISKDRIVE)) goto DisableVolume;
    status = NtQuerySystemInformation(SystemDeviceInformation, &DeviceInfo, sizeof(DeviceInfo), NULL);
    if (!NT_SUCCESS(status)) {
        return 0;
    }

    nDisk = DeviceInfo.NumberOfDisks;
    // for each physical disk
    for (i = 0; i < nDisk; i++) {

        swprintf(devname, L"\\Device\\Harddisk%d\\Partition0", i);

        RtlInitUnicodeString(&UnicodeName, devname);

        InitializeObjectAttributes(
                   &ObjectAttributes,
                   &UnicodeName,
                   OBJ_CASE_INSENSITIVE,
                   NULL,
                   NULL
                   );
        // opening a partition handle for physical drives
        status = NtOpenFile(
                &PartitionHandle,
                FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                &ObjectAttributes,
                &IoStatus,
                FILE_SHARE_READ | FILE_SHARE_WRITE,
                FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
                );

        if ( !NT_SUCCESS(status) ) {
            continue;
        }
        // sending IOCTL over to Partition Handle
        if (!DeviceIoControl(PartitionHandle,
                        IOCTL_DISK_PERFORMANCE_OFF,
                        NULL,
                        0,
                        NULL,
                        0,
                        &ReturnedBytes,
                        NULL
                        )) {
#if DBG
            printf("IOCTL failed for %ws\n", devname);
#endif
        }

        NtClose(PartitionHandle);
    }

    DisableVolume:
    if (!(Request | ENABLE_VOLUME)) {
        return 0;
    }

    MountMgrHandle = FindFirstVolumeW(devname, MAX_PATH);
    if (MountMgrHandle == NULL) {
#if DBG
        printf("Cannot find first volume\n");
#endif
        return 0;
    }
    i = (ULONG) wcslen(devname);
    if (i > 0) {
        s = (PWCHAR) &devname[i-1];
        if (*s == L'\\') {
            *s = UNICODE_NULL;
        }
    }

    VolumeHandle = CreateFile(devname, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
                        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, INVALID_HANDLE_VALUE);
    if (VolumeHandle != INVALID_HANDLE_VALUE) {
#if DBG
        printf("Opened with success\n");
#endif
        // sending IOCTL over to a volume handle
        if (!DeviceIoControl(VolumeHandle,
               IOCTL_DISK_PERFORMANCE_OFF,
               NULL,
               0,
               NULL,
               0,
               &ReturnedBytes,
               NULL
               )) {
#if DBG
            printf("IOCTL failed for %ws\n", devname);
#endif
        }
       CloseHandle(VolumeHandle);
    }

    while (FindNextVolumeW(MountMgrHandle, devname, MAX_PATH)) {
        i = (ULONG) wcslen(devname);
        if (i > 0) {
            s = (PWCHAR) &devname[i-1];
            if (*s == L'\\') {
                *s = UNICODE_NULL;
            }
        }
        else {
            continue;
        }
        VolumeHandle = CreateFile(devname, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
                            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, INVALID_HANDLE_VALUE);
        if (VolumeHandle != INVALID_HANDLE_VALUE) {
#if DBG
            printf("Opened with success\n");
#endif
            if (!DeviceIoControl(VolumeHandle,
                   IOCTL_DISK_PERFORMANCE_OFF,
                   NULL,
                   0,
                   NULL,
                   0,
                   &ReturnedBytes,
                   NULL
                   )) {
#if DBG
               printf("IOCTL failed for %ws\n", devname);
#endif
           }
           CloseHandle(VolumeHandle);
        }
    }
    FindVolumeClose(MountMgrHandle);
    return 0;
}

////////////////////////////////////////////////////////////////////////////
//
//  MySetThreadUILanguage
//
//  This routine sets the thread UI language based on the console codepage.
//
//  9-29-00    WeiWu    Created.
//  Copied from Base\Win32\Winnls so that it works in W2K as well
////////////////////////////////////////////////////////////////////////////

LANGID WINAPI MySetThreadUILanguage(
    WORD wReserved)
{
    //
    //  Cache system locale and CP info
    // 
    LCID s_lidSystem = 0;
    ULONG s_uiSysCp = 0;
    ULONG s_uiSysOEMCp = 0;

    ULONG uiUserUICp = 0;
    ULONG uiUserUIOEMCp = 0;
    WCHAR szData[16];
    UNICODE_STRING ucStr;

    LANGID lidUserUI = GetUserDefaultUILanguage();
    LCID lcidThreadOld = GetThreadLocale();

    //
    //  Set default thread locale to EN-US
    //
    //  This allow us to fall back to English UI to avoid trashed characters 
    //  when console doesn't meet the criteria of rendering native UI.
    //
    LCID lcidThread = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
    UINT uiConsoleCp = GetConsoleOutputCP();

    UNREFERENCED_PARAMETER(wReserved);

    //
    //  Make sure nobody uses it yet
    //
    ASSERT(wReserved == 0);

    //
    //  Get cached system locale and CP info.
    //
    if (!s_uiSysCp)
    {
        LCID lcidSystem = GetSystemDefaultLCID();

        if (lcidSystem)
        {
            //
            // Get ANSI CP
            //
            GetLocaleInfoW(lcidSystem, LOCALE_IDEFAULTANSICODEPAGE, szData, sizeof(szData)/sizeof(WCHAR));
            RtlInitUnicodeString(&ucStr, szData);
            RtlUnicodeStringToInteger(&ucStr, 10, &uiUserUICp);

            //
            // Get OEM CP
            //
            GetLocaleInfoW(lcidSystem, LOCALE_IDEFAULTCODEPAGE, szData, sizeof(szData)/sizeof(WCHAR));
            RtlInitUnicodeString(&ucStr, szData);
            RtlUnicodeStringToInteger(&ucStr, 10, &s_uiSysOEMCp);
            
            //
            // Cache system primary langauge
            //
            s_lidSystem = PRIMARYLANGID(LANGIDFROMLCID(lcidSystem));
        }
    }

    //
    //  Don't cache user UI language and CP info, UI language can be changed without system reboot.
    //
    if (lidUserUI)
    {
        GetLocaleInfoW(MAKELCID(lidUserUI,SORT_DEFAULT), LOCALE_IDEFAULTANSICODEPAGE, szData, sizeof(szData)/sizeof(WCHAR));
        RtlInitUnicodeString(&ucStr, szData);
        RtlUnicodeStringToInteger(&ucStr, 10, &uiUserUICp);

        GetLocaleInfoW(MAKELCID(lidUserUI,SORT_DEFAULT), LOCALE_IDEFAULTCODEPAGE, szData, sizeof(szData)/sizeof(WCHAR));
        RtlInitUnicodeString(&ucStr, szData);
        RtlUnicodeStringToInteger(&ucStr, 10, &uiUserUIOEMCp);
    }

    //
    //  Complex scripts cannot be rendered in the console, so we
    //  force the English (US) resource.
    //
    if (uiConsoleCp && 
        s_lidSystem != LANG_ARABIC && 
        s_lidSystem != LANG_HEBREW &&
        s_lidSystem != LANG_VIETNAMESE && 
        s_lidSystem != LANG_THAI)
    {
        //
        //  Use UI language for console only when console CP, system CP and UI language CP match.
        //
        if ((uiConsoleCp == s_uiSysCp || uiConsoleCp == s_uiSysOEMCp) && 
            (uiConsoleCp == uiUserUICp || uiConsoleCp == uiUserUIOEMCp))
        {
            lcidThread = MAKELCID(lidUserUI, SORT_DEFAULT);
        }
    }

    //
    //  Set the thread locale if it's different from the currently set
    //  thread locale.
    //
    if ((lcidThread != lcidThreadOld) && (!SetThreadLocale(lcidThread)))
    {
        lcidThread = lcidThreadOld;
    }

    //
    //  Return the thread locale that was set.
    //
    return (LANGIDFROMLCID(lcidThread));
}