mirror of https://github.com/tongzx/nt5src
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.
1691 lines
48 KiB
1691 lines
48 KiB
/*++
|
|
|
|
Copyright (c) Microsoft Corporation, 2000
|
|
|
|
Module Name :
|
|
|
|
diskprop.c
|
|
|
|
Abstract :
|
|
|
|
Implementation of the Disk Property Page
|
|
|
|
Revision History :
|
|
|
|
--*/
|
|
|
|
#include "propp.h"
|
|
#include "diskprop.h"
|
|
#include "scsiprop.h"
|
|
#include "volprop.h"
|
|
|
|
//==========================================================================
|
|
// Local Constants
|
|
//==========================================================================
|
|
#define DISKCIPRIVATEDATA_NO_REBOOT_REQUIRED 0x4
|
|
|
|
//==========================================================================
|
|
// Local Function Prototypes
|
|
//==========================================================================
|
|
|
|
const DWORD DiskHelpIDs[]=
|
|
{
|
|
IDC_DISK_POLICY_WRITE_CACHE, idh_devmgr_disk_write_cache_enabled,
|
|
0, 0
|
|
};
|
|
|
|
typedef struct _DISK_PAGE_DATA {
|
|
|
|
BOOL IsVolume;
|
|
HDEVINFO DeviceInfoSet;
|
|
PSP_DEVINFO_DATA DeviceInfoData;
|
|
|
|
//
|
|
// This field represents whether disk
|
|
// level write caching may be modified
|
|
//
|
|
BOOL IsCachingPolicy;
|
|
|
|
BOOL OrigWriteCacheSetting;
|
|
BOOL CurrWriteCacheSetting;
|
|
DISK_WRITE_CACHE_STATE WriteCacheState;
|
|
|
|
DWORD DefaultRemovalPolicy;
|
|
DWORD CurrentRemovalPolicy;
|
|
STORAGE_HOTPLUG_INFO HotplugInfo;
|
|
|
|
//
|
|
// This field is set when the device stack
|
|
// is being torn down which happens during
|
|
// a removal policy change
|
|
//
|
|
BOOL IsBusy;
|
|
|
|
LPGUID DevClassGuid; // used only for the root page
|
|
|
|
} DISK_PAGE_DATA, *PDISK_PAGE_DATA;
|
|
|
|
|
|
BOOL
|
|
IsUserAdmin(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns TRUE if the caller's process is a
|
|
member of the Administrators local group.
|
|
|
|
Caller is NOT expected to be impersonating anyone and IS
|
|
expected to be able to open their own process and process
|
|
token.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE - Caller has Administrators local group.
|
|
|
|
FALSE - Caller does not have Administrators local group.
|
|
|
|
--*/
|
|
|
|
{
|
|
HANDLE Token;
|
|
DWORD BytesRequired;
|
|
PTOKEN_GROUPS Groups;
|
|
BOOL b;
|
|
DWORD i;
|
|
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
|
|
PSID AdministratorsGroup;
|
|
|
|
//
|
|
// Open the process token.
|
|
//
|
|
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&Token)) {
|
|
return(FALSE);
|
|
}
|
|
|
|
b = FALSE;
|
|
Groups = NULL;
|
|
|
|
//
|
|
// Get group information.
|
|
//
|
|
if(!GetTokenInformation(Token,TokenGroups,NULL,0,&BytesRequired)
|
|
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
|
|
&& (Groups = (PTOKEN_GROUPS)LocalAlloc(LMEM_FIXED,BytesRequired))
|
|
&& GetTokenInformation(Token,TokenGroups,Groups,BytesRequired,&BytesRequired)) {
|
|
|
|
b = AllocateAndInitializeSid(
|
|
&NtAuthority,
|
|
2,
|
|
SECURITY_BUILTIN_DOMAIN_RID,
|
|
DOMAIN_ALIAS_RID_ADMINS,
|
|
0, 0, 0, 0, 0, 0,
|
|
&AdministratorsGroup
|
|
);
|
|
|
|
if(b) {
|
|
|
|
//
|
|
// See if the user has the administrator group.
|
|
//
|
|
b = FALSE;
|
|
for(i=0; i<Groups->GroupCount; i++) {
|
|
if(EqualSid(Groups->Groups[i].Sid,AdministratorsGroup)) {
|
|
b = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
FreeSid(AdministratorsGroup);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clean up and return.
|
|
//
|
|
|
|
if(Groups) {
|
|
LocalFree(Groups);
|
|
}
|
|
|
|
CloseHandle(Token);
|
|
|
|
return(b);
|
|
}
|
|
|
|
INT_PTR
|
|
DiskDialogProc(
|
|
HWND Dialog,
|
|
UINT Message,
|
|
WPARAM WParam,
|
|
LPARAM LParam
|
|
);
|
|
|
|
BOOL
|
|
DiskDialogCallback(
|
|
HWND Dialog,
|
|
UINT Message,
|
|
LPPROPSHEETPAGE Page
|
|
);
|
|
|
|
BOOL
|
|
CommonPropPageProvider(
|
|
PSP_PROPSHEETPAGE_REQUEST Request,
|
|
LPFNADDPROPSHEETPAGE AddPageRoutine,
|
|
LPARAM AddPageContext,
|
|
LPGUID DevClassGuid
|
|
);
|
|
|
|
BOOL CALLBACK
|
|
VolumePropPageProvider(
|
|
PSP_PROPSHEETPAGE_REQUEST Request,
|
|
LPFNADDPROPSHEETPAGE AddPageRoutine,
|
|
LPARAM AddPageContext
|
|
)
|
|
{
|
|
BOOL result;
|
|
|
|
if(Request->cbSize != sizeof(SP_PROPSHEETPAGE_REQUEST)) {
|
|
return FALSE;
|
|
}
|
|
|
|
switch(Request->PageRequested) {
|
|
|
|
case SPPSR_ENUM_ADV_DEVICE_PROPERTIES: {
|
|
result = TRUE;
|
|
break;
|
|
}
|
|
|
|
case SPPSR_ENUM_BASIC_DEVICE_PROPERTIES: {
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Since there's nothing else on the page, don't show the page
|
|
// Remove the statement to use this page, e.g. when we want to allow
|
|
// the user to select volumes to turn on/off
|
|
//
|
|
result = FALSE;
|
|
|
|
if(result) {
|
|
result = CommonPropPageProvider(
|
|
Request,
|
|
AddPageRoutine,
|
|
AddPageContext,
|
|
(LPGUID) &GUID_DEVCLASS_VOLUME);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
BOOL
|
|
CommonPropPageProvider(
|
|
PSP_PROPSHEETPAGE_REQUEST Request,
|
|
LPFNADDPROPSHEETPAGE AddPageRoutine,
|
|
LPARAM AddPageContext,
|
|
LPGUID DevClassGuid
|
|
)
|
|
{
|
|
PDISK_PAGE_DATA data;
|
|
PROPSHEETPAGE page;
|
|
HPROPSHEETPAGE pageHandle;
|
|
BOOL result = TRUE;
|
|
HKEY hDeviceKey;
|
|
BOOL IsVolume = FALSE;
|
|
TCHAR buf[MAX_PATH];
|
|
|
|
//
|
|
// Make sure that we're actually opening a device
|
|
//
|
|
hDeviceKey = SetupDiOpenDevRegKey(Request->DeviceInfoSet,
|
|
Request->DeviceInfoData,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DEV,
|
|
KEY_ALL_ACCESS);
|
|
|
|
if (INVALID_HANDLE_VALUE == hDeviceKey) {
|
|
IsVolume = TRUE;
|
|
}
|
|
RegCloseKey(hDeviceKey);
|
|
|
|
//
|
|
// Since there's nothing else on the page, don't show the page
|
|
// Remove the statement to use this page, e.g. when we want to allow
|
|
// the user to select volumes to turn on/off
|
|
//
|
|
if (IsVolume)
|
|
return FALSE;
|
|
|
|
//
|
|
// At this point we've determined that this is a request for pages we
|
|
// provide. Instantiate the pages and call the AddPage routine to put
|
|
// them install them.
|
|
//
|
|
|
|
if (!IsUserAdmin()) {
|
|
return FALSE;
|
|
}
|
|
data = LocalAlloc(0, sizeof(DISK_PAGE_DATA));
|
|
|
|
if(data == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
data->DeviceInfoSet = Request->DeviceInfoSet;
|
|
data->DeviceInfoData = Request->DeviceInfoData;
|
|
data->DevClassGuid = DevClassGuid;
|
|
data->IsVolume = IsVolume;
|
|
|
|
memset(&page, 0, sizeof(PROPSHEETPAGE));
|
|
|
|
page.dwSize = sizeof(PROPSHEETPAGE);
|
|
page.dwFlags = PSP_USECALLBACK;
|
|
if (IsVolume) {
|
|
LoadString(ModuleInstance, IDS_ADVANCED, buf, MAX_PATH);
|
|
page.pszTitle = buf;
|
|
page.dwFlags |= PSP_USETITLE;
|
|
}
|
|
page.hInstance = ModuleInstance;
|
|
page.pszTemplate = MAKEINTRESOURCE(ID_DISK_PROPPAGE);
|
|
page.pfnDlgProc = DiskDialogProc;
|
|
page.pfnCallback = DiskDialogCallback;
|
|
|
|
page.lParam = (LPARAM) data;
|
|
|
|
pageHandle = CreatePropertySheetPage(&page);
|
|
|
|
if(pageHandle == FALSE) {
|
|
return FALSE;
|
|
}
|
|
|
|
result = AddPageRoutine(pageHandle, AddPageContext);
|
|
|
|
if(result) {
|
|
ScsiPropPageProvider(Request, AddPageRoutine, AddPageContext);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
VOID
|
|
AttemptToSuppressDiskInstallReboot(
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Because disks are listed as "critical devices" (i.e., they're in the
|
|
critical device database), they get bootstrapped by PnP during boot. Thus,
|
|
by the time we're installing a disk in user-mode, it's most likely already
|
|
on-line (unless the disk has some problem). Unfortunately, if the disk is
|
|
the boot device, we won't be able to dynamically affect the changes (if
|
|
any) to tear the stack down and bring it back up with any new settings,
|
|
drivers, etc. This causes problems for OEM Preinstall scenarios where the
|
|
target machines have different disks than the source machine used to create
|
|
the preinstall image. If we simply perform our default behavior, then
|
|
the user's experience would be to unbox their brand new machine, boot for
|
|
the first time and go through OOBE, and then be greeted upon login with a
|
|
reboot prompt!
|
|
|
|
To fix this, we've defined a private [DDInstall] section INF flag (specific
|
|
to INFs of class "DiskDrive") that indicates we can forego the reboot if
|
|
certain criteria are met. Those criteria are:
|
|
|
|
1. No files were modified as a result of this device's installation
|
|
(determined by checking the devinfo element's
|
|
DI_FLAGSEX_RESTART_DEVICE_ONLY flag, which the device installer uses to
|
|
track whether such file modifications have occurred).
|
|
|
|
2. The INF used to install this device is signed.
|
|
|
|
3. The INF driver node has a DiskCiPrivateData = <int> entry in its
|
|
[DDInstall] section that has bit 2 (0x4) set. Note that this setting
|
|
is intentionally obfuscated because we don't want third parties trying
|
|
to use this, as they won't understand the ramifications or
|
|
requirements, and will more than likely get this wrong (trading an
|
|
annoying but harmless reboot requirement into a much more severe
|
|
stability issue).
|
|
|
|
This routine makes the above checks, and if it is found that the reboot can
|
|
be suppressed, it clears the DI_NEEDRESTART and DI_NEEDREBOOT flags from
|
|
the devinfo element's device install parameters.
|
|
|
|
Arguments:
|
|
|
|
DeviceInfoSet - Supplies the device information set.
|
|
|
|
DeviceInfoData - Supplies the device information element that has just
|
|
been successfully installed (via SetupDiInstallDevice).
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
PSP_DRVINFO_DATA DriverInfoData = NULL;
|
|
PSP_DRVINFO_DETAIL_DATA DriverInfoDetailData = NULL;
|
|
PSP_INF_SIGNER_INFO InfSignerInfo = NULL;
|
|
HINF hInf;
|
|
TCHAR InfSectionWithExt[255]; // max section name length is 255 chars
|
|
INFCONTEXT InfContext;
|
|
INT Flags;
|
|
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
|
|
if(!SetupDiGetDeviceInstallParams(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
&DeviceInstallParams)) {
|
|
//
|
|
// Couldn't retrieve the device install params--this should never
|
|
// happen.
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
if(!(DeviceInstallParams.Flags & (DI_NEEDRESTART | DI_NEEDREBOOT))) {
|
|
//
|
|
// The device doesn't require a reboot (must not be the boot device!)
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
if(!(DeviceInstallParams.FlagsEx & DI_FLAGSEX_RESTART_DEVICE_ONLY)) {
|
|
//
|
|
// Since this flag isn't set, this indicates that the device installer
|
|
// modified one or more files as part of this device's installation.
|
|
// Thus, it isn't safe for us to suppress the reboot request.
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// OK, we have a device that needs a reboot, and no files were modified
|
|
// during its installation. Now check the INF to see if it's signed.
|
|
// (Note: the SP_DRVINFO_DATA, SP_DRVINFO_DETAIL_DATA, and
|
|
// SP_INF_SIGNER_INFO structures are rather large, so we allocate them
|
|
// instead of using lots of stack space.)
|
|
//
|
|
DriverInfoData = LocalAlloc(0, sizeof(SP_DRVINFO_DATA));
|
|
if(DriverInfoData) {
|
|
DriverInfoData->cbSize = sizeof(SP_DRVINFO_DATA);
|
|
} else {
|
|
goto clean0;
|
|
}
|
|
|
|
if(!SetupDiGetSelectedDriver(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
DriverInfoData)) {
|
|
//
|
|
// We must be installing the NULL driver (which is unlikely)...
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
DriverInfoDetailData = LocalAlloc(0, sizeof(SP_DRVINFO_DETAIL_DATA));
|
|
|
|
if(DriverInfoDetailData) {
|
|
DriverInfoDetailData->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
} else {
|
|
goto clean0;
|
|
}
|
|
|
|
if(!SetupDiGetDriverInfoDetail(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
DriverInfoData,
|
|
DriverInfoDetailData,
|
|
sizeof(SP_DRVINFO_DETAIL_DATA),
|
|
NULL)
|
|
&& (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
|
|
|
|
//
|
|
// Failed to retrieve driver info details--should never happen.
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
InfSignerInfo = LocalAlloc(0, sizeof(SP_INF_SIGNER_INFO));
|
|
if(InfSignerInfo) {
|
|
InfSignerInfo->cbSize = sizeof(SP_INF_SIGNER_INFO);
|
|
} else {
|
|
goto clean0;
|
|
}
|
|
|
|
if(!SetupVerifyInfFile(DriverInfoDetailData->InfFileName,
|
|
NULL,
|
|
InfSignerInfo)) {
|
|
//
|
|
// INF isn't signed--we wouldn't trust its "no reboot required" flag,
|
|
// even if it had one.
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// INF is signed--let's open it up and see if it specifes the "no reboot
|
|
// required" flag in it's (decorated) DDInstall section...
|
|
//
|
|
hInf = SetupOpenInfFile(DriverInfoDetailData->InfFileName,
|
|
NULL,
|
|
INF_STYLE_WIN4,
|
|
NULL
|
|
);
|
|
|
|
if(hInf == INVALID_HANDLE_VALUE) {
|
|
//
|
|
// Failed to open the INF. This is incredibly odd, since we just got
|
|
// through validating the INF's digital signature...
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
if(!SetupDiGetActualSectionToInstall(hInf,
|
|
DriverInfoDetailData->SectionName,
|
|
InfSectionWithExt,
|
|
sizeof(InfSectionWithExt) / sizeof(TCHAR),
|
|
NULL,
|
|
NULL)
|
|
|| !SetupFindFirstLine(hInf,
|
|
InfSectionWithExt,
|
|
TEXT("DiskCiPrivateData"),
|
|
&InfContext)
|
|
|| !SetupGetIntField(&InfContext, 1, &Flags)) {
|
|
|
|
Flags = 0;
|
|
}
|
|
|
|
SetupCloseInfFile(hInf);
|
|
|
|
if(Flags & DISKCIPRIVATEDATA_NO_REBOOT_REQUIRED) {
|
|
//
|
|
// This signed INF is vouching for the fact that no reboot is
|
|
// required for full functionality of this disk. Thus, we'll
|
|
// clear the DI_NEEDRESTART and DI_NEEDREBOOT flags, so that
|
|
// the user won't be prompted to reboot. Note that during the
|
|
// default handling routine (SetupDiInstallDevice), a non-fatal
|
|
// problem was set on the devnode indicating that a reboot is
|
|
// needed. This will not result in a yellow-bang in DevMgr,
|
|
// but you would see text in the device status field indicating
|
|
// a reboot is needed if you go into the General tab of the
|
|
// device's property sheet.
|
|
//
|
|
CLEAR_FLAG(DeviceInstallParams.Flags, DI_NEEDRESTART);
|
|
CLEAR_FLAG(DeviceInstallParams.Flags, DI_NEEDREBOOT);
|
|
|
|
SetupDiSetDeviceInstallParams(DeviceInfoSet,
|
|
DeviceInfoData,
|
|
&DeviceInstallParams
|
|
);
|
|
}
|
|
|
|
clean0:
|
|
|
|
if(DriverInfoData) {
|
|
LocalFree(DriverInfoData);
|
|
}
|
|
if(DriverInfoDetailData) {
|
|
LocalFree(DriverInfoDetailData);
|
|
}
|
|
if(InfSignerInfo) {
|
|
LocalFree(InfSignerInfo);
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
DiskClassInstaller(
|
|
IN DI_FUNCTION InstallFunction,
|
|
IN HDEVINFO DeviceInfoSet,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the class installer function for disk drive.
|
|
|
|
Arguments:
|
|
|
|
InstallFunction - Supplies the install function.
|
|
|
|
DeviceInfoSet - Supplies the device info set.
|
|
|
|
DeviceInfoData - Supplies the device info data.
|
|
|
|
Return Value:
|
|
|
|
If this function successfully completed the requested action, the return
|
|
value is NO_ERROR.
|
|
|
|
If the default behavior is to be performed for the requested action, the
|
|
return value is ERROR_DI_DO_DEFAULT.
|
|
|
|
If an error occurred while attempting to perform the requested action, a
|
|
Win32 error code is returned.
|
|
|
|
--*/
|
|
|
|
{
|
|
PROPSHEETPAGE page;
|
|
|
|
switch (InstallFunction)
|
|
{
|
|
case DIF_INSTALLDEVICE:
|
|
{
|
|
//
|
|
// Let the default action occur to get the device installed.
|
|
//
|
|
if(!SetupDiInstallDevice(DeviceInfoSet, DeviceInfoData)) {
|
|
//
|
|
// Failed to install the device--just return the error reported
|
|
//
|
|
return GetLastError();
|
|
}
|
|
|
|
//
|
|
// Default device install action succeeded, now check for reboot
|
|
// requirement and suppress it, if possible.
|
|
//
|
|
AttemptToSuppressDiskInstallReboot(DeviceInfoSet, DeviceInfoData);
|
|
|
|
//
|
|
// Regardless of whether we successfully suppressed the reboot, we
|
|
// still report success, because the install went fine.
|
|
//
|
|
return NO_ERROR;
|
|
}
|
|
|
|
case DIF_ADDPROPERTYPAGE_ADVANCED:
|
|
case DIF_ADDREMOTEPROPERTYPAGE_ADVANCED:
|
|
{
|
|
//
|
|
// get the current class install parameters for the device
|
|
//
|
|
SP_ADDPROPERTYPAGE_DATA AddPropertyPageData;
|
|
|
|
//
|
|
// DeviceInfoSet is NULL if setup is requesting property pages for the
|
|
// device setup class. We don't want to do anything in this case.
|
|
//
|
|
if (DeviceInfoData==NULL)
|
|
return ERROR_DI_DO_DEFAULT;
|
|
|
|
ZeroMemory(&AddPropertyPageData, sizeof(SP_ADDPROPERTYPAGE_DATA));
|
|
AddPropertyPageData.ClassInstallHeader.cbSize =
|
|
sizeof(SP_CLASSINSTALL_HEADER);
|
|
|
|
if (SetupDiGetClassInstallParams(DeviceInfoSet, DeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&AddPropertyPageData,
|
|
sizeof(SP_ADDPROPERTYPAGE_DATA), NULL ))
|
|
{
|
|
PDISK_PAGE_DATA pDiskPageData;
|
|
PVOLUME_PAGE_DATA pVolumePageData;
|
|
HPROPSHEETPAGE pageHandle;
|
|
PROPSHEETPAGE page;
|
|
BOOL isScsi;
|
|
|
|
//
|
|
// Ensure that the maximum number of dynamic pages for the device
|
|
// has not yet been met
|
|
//
|
|
if (AddPropertyPageData.NumDynamicPages >=
|
|
MAX_INSTALLWIZARD_DYNAPAGES)
|
|
return NO_ERROR;
|
|
|
|
if (InstallFunction==DIF_ADDPROPERTYPAGE_ADVANCED)
|
|
{
|
|
//
|
|
// Add disk property page
|
|
//
|
|
pDiskPageData = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(DISK_PAGE_DATA));
|
|
if (pDiskPageData)
|
|
{
|
|
//
|
|
// Save DeviceInfoSet and DeviceInfoData
|
|
//
|
|
pDiskPageData->DeviceInfoSet = DeviceInfoSet;
|
|
pDiskPageData->DeviceInfoData = DeviceInfoData;
|
|
pDiskPageData->DevClassGuid =
|
|
(LPGUID) &GUID_DEVCLASS_DISKDRIVE;
|
|
pDiskPageData->IsVolume = FALSE;
|
|
|
|
memset(&page, 0, sizeof(PROPSHEETPAGE));
|
|
|
|
//
|
|
// Create disk property sheet page
|
|
//
|
|
page.dwSize = sizeof(PROPSHEETPAGE);
|
|
page.dwFlags = PSP_USECALLBACK;
|
|
page.hInstance = ModuleInstance;
|
|
page.pszTemplate = MAKEINTRESOURCE(ID_DISK_PROPPAGE);
|
|
page.pfnDlgProc = DiskDialogProc;
|
|
page.pfnCallback = DiskDialogCallback;
|
|
|
|
page.lParam = (LPARAM) pDiskPageData;
|
|
|
|
pageHandle = CreatePropertySheetPage(&page);
|
|
if(!pageHandle)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pDiskPageData);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Add the new page to the list of dynamic property
|
|
// sheets
|
|
//
|
|
AddPropertyPageData.DynamicPages[
|
|
AddPropertyPageData.NumDynamicPages++] = pageHandle;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Add volume property page
|
|
//
|
|
if ( AddPropertyPageData.NumDynamicPages >=
|
|
MAX_INSTALLWIZARD_DYNAPAGES )
|
|
{
|
|
SetupDiSetClassInstallParams(DeviceInfoSet, DeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&AddPropertyPageData,
|
|
sizeof(SP_ADDPROPERTYPAGE_DATA));
|
|
return NO_ERROR;
|
|
}
|
|
|
|
if (IsUserAdmin())
|
|
pVolumePageData = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(VOLUME_PAGE_DATA));
|
|
else
|
|
pVolumePageData = NULL;
|
|
|
|
if (pVolumePageData)
|
|
{
|
|
HMODULE LdmModule;
|
|
SP_DEVINFO_LIST_DETAIL_DATA DeviceInfoSetDetailData;
|
|
//
|
|
// Save DeviceInfoSet and DeviceInfoData
|
|
//
|
|
pVolumePageData->DeviceInfoSet = DeviceInfoSet;
|
|
pVolumePageData->DeviceInfoData = DeviceInfoData;
|
|
|
|
//
|
|
// Create volume property sheet page
|
|
//
|
|
memset(&page, 0, sizeof(PROPSHEETPAGE));
|
|
|
|
page.dwSize = sizeof(PROPSHEETPAGE);
|
|
page.dwFlags = PSP_USECALLBACK;
|
|
page.hInstance = ModuleInstance;
|
|
page.pszTemplate = MAKEINTRESOURCE(ID_VOLUME_PROPPAGE);
|
|
page.pfnDlgProc = VolumeDialogProc;
|
|
page.pfnCallback = VolumeDialogCallback;
|
|
|
|
page.lParam = (LPARAM) pVolumePageData;
|
|
|
|
pageHandle = CreatePropertySheetPage(&page);
|
|
if(!pageHandle)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pVolumePageData);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Add the new page to the list of dynamic property
|
|
// sheets
|
|
//
|
|
AddPropertyPageData.DynamicPages[
|
|
AddPropertyPageData.NumDynamicPages++]=pageHandle;
|
|
|
|
//
|
|
// Check if the property page is pulled up from disk manager.
|
|
//
|
|
pVolumePageData->bInvokedByDiskmgr = FALSE;
|
|
LdmModule = GetModuleHandle(TEXT("dmdskmgr"));
|
|
if ( LdmModule )
|
|
{
|
|
IS_REQUEST_PENDING pfnIsRequestPending;
|
|
pfnIsRequestPending = (IS_REQUEST_PENDING)
|
|
GetProcAddress(LdmModule, "IsRequestPending");
|
|
if (pfnIsRequestPending)
|
|
{
|
|
if ((*pfnIsRequestPending)())
|
|
pVolumePageData->bInvokedByDiskmgr = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (InstallFunction==DIF_ADDPROPERTYPAGE_ADVANCED)
|
|
{
|
|
//
|
|
// Add Scsi property page data
|
|
//
|
|
if ( AddPropertyPageData.NumDynamicPages >=
|
|
MAX_INSTALLWIZARD_DYNAPAGES )
|
|
{
|
|
SetupDiSetClassInstallParams(DeviceInfoSet, DeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&AddPropertyPageData,
|
|
sizeof(SP_ADDPROPERTYPAGE_DATA));
|
|
return NO_ERROR;
|
|
}
|
|
|
|
isScsi = ScsiCheckDriveType( DeviceInfoSet, DeviceInfoData);
|
|
|
|
if (isScsi) {
|
|
|
|
PSCSI_PAGE_DATA pScsiPageData;
|
|
|
|
pScsiPageData = HeapAlloc(GetProcessHeap(),
|
|
0,
|
|
sizeof(SCSI_PAGE_DATA));
|
|
|
|
if(pScsiPageData == NULL) {
|
|
SetupDiSetClassInstallParams(DeviceInfoSet, DeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&AddPropertyPageData,
|
|
sizeof(SP_ADDPROPERTYPAGE_DATA));
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Create scsi property sheet page
|
|
//
|
|
pScsiPageData->DeviceInfoSet = DeviceInfoSet;
|
|
pScsiPageData->DeviceInfoData = DeviceInfoData;
|
|
|
|
memset(&page, 0, sizeof(PROPSHEETPAGE));
|
|
page.dwSize = sizeof(PROPSHEETPAGE);
|
|
page.dwFlags = PSP_USECALLBACK;
|
|
page.hInstance = ModuleInstance;
|
|
page.pszTemplate = MAKEINTRESOURCE(ID_SCSI_PROPPAGE);
|
|
page.pfnDlgProc = ScsiDialogProc;
|
|
page.pfnCallback = ScsiDialogCallback;
|
|
|
|
page.lParam = (LPARAM) pScsiPageData;
|
|
|
|
pageHandle = CreatePropertySheetPage(&page);
|
|
|
|
if(pageHandle == NULL) {
|
|
HeapFree(GetProcessHeap(), 0, pScsiPageData);
|
|
SetupDiSetClassInstallParams(DeviceInfoSet, DeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&AddPropertyPageData,
|
|
sizeof(SP_ADDPROPERTYPAGE_DATA));
|
|
return FALSE;
|
|
}
|
|
|
|
AddPropertyPageData.DynamicPages[
|
|
AddPropertyPageData.NumDynamicPages++] = pageHandle;
|
|
|
|
}
|
|
}
|
|
|
|
SetupDiSetClassInstallParams(DeviceInfoSet, DeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&AddPropertyPageData,
|
|
sizeof(SP_ADDPROPERTYPAGE_DATA));
|
|
}
|
|
return NO_ERROR;
|
|
} // case DIF_ADDPROPERTYPAGE_ADVANCED
|
|
}
|
|
return ERROR_DI_DO_DEFAULT;
|
|
}
|
|
|
|
|
|
HANDLE
|
|
GetHandleForDisk(LPTSTR DeviceName)
|
|
{
|
|
HANDLE h = INVALID_HANDLE_VALUE;
|
|
int i = 0;
|
|
BOOL success = FALSE;
|
|
TCHAR buf[MAX_PATH];
|
|
TCHAR fakeDeviceName[MAX_PATH];
|
|
|
|
h = CreateFile(DeviceName,
|
|
GENERIC_WRITE | GENERIC_READ,
|
|
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
|
|
if (h != INVALID_HANDLE_VALUE)
|
|
return h;
|
|
|
|
while (!success && i < 10) {
|
|
|
|
wsprintf(buf, _T("DISK_FAKE_DEVICE_%d_"), i++);
|
|
success = DefineDosDevice(DDD_RAW_TARGET_PATH,
|
|
buf,
|
|
DeviceName);
|
|
if (success) {
|
|
_tcscpy(fakeDeviceName, _T("\\\\.\\"));
|
|
_tcscat(fakeDeviceName, buf);
|
|
h = CreateFile(fakeDeviceName,
|
|
GENERIC_WRITE | GENERIC_READ,
|
|
FILE_SHARE_WRITE | FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
DefineDosDevice(DDD_REMOVE_DEFINITION,
|
|
buf,
|
|
NULL);
|
|
}
|
|
|
|
}
|
|
|
|
return h;
|
|
}
|
|
|
|
|
|
UINT
|
|
GetCachingPolicy(PDISK_PAGE_DATA data)
|
|
{
|
|
HANDLE hDisk;
|
|
DISK_CACHE_INFORMATION cacheInfo;
|
|
TCHAR buf[MAX_PATH];
|
|
DWORD len = MAX_PATH;
|
|
CONFIGRET cr;
|
|
|
|
cr = CM_Get_DevNode_Registry_Property(data->DeviceInfoData->DevInst,
|
|
CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME,
|
|
NULL,
|
|
buf,
|
|
&len,
|
|
0);
|
|
if (cr != CR_SUCCESS) {
|
|
|
|
return ERROR_GEN_FAILURE;
|
|
}
|
|
|
|
if (INVALID_HANDLE_VALUE == (hDisk = GetHandleForDisk(buf))) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Get cache info - IOCTL_DISK_GET_CACHE_INFORMATION
|
|
//
|
|
if (!DeviceIoControl(hDisk,
|
|
IOCTL_DISK_GET_CACHE_INFORMATION,
|
|
NULL,
|
|
0,
|
|
&cacheInfo,
|
|
sizeof(DISK_CACHE_INFORMATION),
|
|
&len,
|
|
NULL)) {
|
|
|
|
CloseHandle(hDisk);
|
|
return GetLastError();
|
|
}
|
|
|
|
//
|
|
// Get write cache state - IOCTL_DISK_GET_WRITE_CACHE_STATE
|
|
//
|
|
if (!DeviceIoControl(hDisk,
|
|
IOCTL_DISK_GET_WRITE_CACHE_STATE,
|
|
NULL,
|
|
0,
|
|
&data->WriteCacheState,
|
|
sizeof(DISK_WRITE_CACHE_STATE),
|
|
&len,
|
|
NULL)) {
|
|
|
|
CloseHandle(hDisk);
|
|
return GetLastError();
|
|
}
|
|
|
|
data->OrigWriteCacheSetting = cacheInfo.WriteCacheEnabled;
|
|
data->CurrWriteCacheSetting = cacheInfo.WriteCacheEnabled;
|
|
|
|
CloseHandle(hDisk);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
VOID
|
|
UpdateCachingPolicy(HWND HWnd, PDISK_PAGE_DATA data)
|
|
{
|
|
if (!data->IsCachingPolicy)
|
|
{
|
|
//
|
|
// The caching policy cannot be modified
|
|
//
|
|
return;
|
|
}
|
|
|
|
if (data->CurrentRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL)
|
|
{
|
|
//
|
|
// This policy requires that no caching be done at any
|
|
// level. Uncheck and gray out the write cache setting
|
|
//
|
|
CheckDlgButton(HWnd, IDC_DISK_POLICY_WRITE_CACHE, 0);
|
|
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE), FALSE);
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE_MESG), FALSE);
|
|
|
|
data->CurrWriteCacheSetting = FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This policy allows for caching to be done at any level
|
|
//
|
|
CheckDlgButton(HWnd, IDC_DISK_POLICY_WRITE_CACHE, 1);
|
|
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE), TRUE);
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE_MESG), TRUE);
|
|
|
|
data->CurrWriteCacheSetting = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
UINT
|
|
SetCachingPolicy(PDISK_PAGE_DATA data)
|
|
{
|
|
HANDLE hDisk;
|
|
DISK_CACHE_INFORMATION cacheInfo;
|
|
TCHAR buf[MAX_PATH];
|
|
DWORD len = MAX_PATH;
|
|
CONFIGRET cr;
|
|
|
|
cr = CM_Get_DevNode_Registry_Property(data->DeviceInfoData->DevInst,
|
|
CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME,
|
|
NULL,
|
|
buf,
|
|
&len,
|
|
0);
|
|
if (cr != CR_SUCCESS) {
|
|
|
|
return ERROR_GEN_FAILURE;
|
|
}
|
|
|
|
if (INVALID_HANDLE_VALUE == (hDisk = GetHandleForDisk(buf))) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Get cache info - IOCTL_DISK_GET_CACHE_INFORMATION
|
|
//
|
|
if (!DeviceIoControl(hDisk,
|
|
IOCTL_DISK_GET_CACHE_INFORMATION,
|
|
NULL,
|
|
0,
|
|
&cacheInfo,
|
|
sizeof(DISK_CACHE_INFORMATION),
|
|
&len,
|
|
NULL)) {
|
|
|
|
CloseHandle(hDisk);
|
|
return GetLastError();
|
|
}
|
|
|
|
cacheInfo.WriteCacheEnabled = (BOOLEAN)data->CurrWriteCacheSetting;
|
|
|
|
//
|
|
// Set cache info - IOCTL_DISK_SET_CACHE_INFORMATION
|
|
//
|
|
if (!DeviceIoControl(hDisk,
|
|
IOCTL_DISK_SET_CACHE_INFORMATION,
|
|
&cacheInfo,
|
|
sizeof(DISK_CACHE_INFORMATION),
|
|
NULL,
|
|
0,
|
|
&len,
|
|
NULL)) {
|
|
|
|
CloseHandle(hDisk);
|
|
return GetLastError();
|
|
}
|
|
|
|
data->OrigWriteCacheSetting = data->CurrWriteCacheSetting;
|
|
|
|
CloseHandle(hDisk);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
UINT
|
|
GetRemovalPolicy(PDISK_PAGE_DATA data)
|
|
{
|
|
HANDLE hDisk;
|
|
TCHAR buf[MAX_PATH];
|
|
DWORD len = MAX_PATH;
|
|
CONFIGRET cr;
|
|
|
|
if (!SetupDiGetDeviceRegistryProperty(data->DeviceInfoSet,
|
|
data->DeviceInfoData,
|
|
SPDRP_REMOVAL_POLICY,
|
|
0,
|
|
(PBYTE)&data->DefaultRemovalPolicy,
|
|
sizeof(DWORD),
|
|
NULL))
|
|
{
|
|
return GetLastError();
|
|
}
|
|
|
|
cr = CM_Get_DevNode_Registry_Property(data->DeviceInfoData->DevInst,
|
|
CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME,
|
|
NULL,
|
|
buf,
|
|
&len,
|
|
0);
|
|
if (cr != CR_SUCCESS) {
|
|
|
|
return ERROR_GEN_FAILURE;
|
|
}
|
|
|
|
if (INVALID_HANDLE_VALUE == (hDisk = GetHandleForDisk(buf))) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Get hotplug info - IOCTL_STORAGE_GET_HOTPLUG_INFO
|
|
//
|
|
if (!DeviceIoControl(hDisk,
|
|
IOCTL_STORAGE_GET_HOTPLUG_INFO,
|
|
NULL,
|
|
0,
|
|
&data->HotplugInfo,
|
|
sizeof(STORAGE_HOTPLUG_INFO),
|
|
&len,
|
|
NULL)) {
|
|
|
|
CloseHandle(hDisk);
|
|
return GetLastError();
|
|
}
|
|
|
|
data->CurrentRemovalPolicy = (data->HotplugInfo.DeviceHotplug) ? CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL : CM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVAL;
|
|
|
|
CloseHandle(hDisk);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
DWORD WINAPI
|
|
UtilpRestartDeviceWr(PDISK_PAGE_DATA data)
|
|
{
|
|
UtilpRestartDevice(data->DeviceInfoSet, data->DeviceInfoData);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
VOID
|
|
UtilpRestartDeviceEx(HWND HWnd, PDISK_PAGE_DATA data)
|
|
{
|
|
HANDLE hThread = NULL;
|
|
MSG msg;
|
|
|
|
//
|
|
// Temporary workaround to prevent the user from
|
|
// making any more changes and giving the effect
|
|
// that something is happening
|
|
//
|
|
EnableWindow(GetDlgItem(GetParent(HWnd), IDOK), FALSE);
|
|
EnableWindow(GetDlgItem(GetParent(HWnd), IDCANCEL), FALSE);
|
|
|
|
data->IsBusy = TRUE;
|
|
|
|
//
|
|
// Call this utility on a seperate thread
|
|
//
|
|
hThread = CreateThread(NULL, 0, UtilpRestartDeviceWr, (LPVOID)data, 0, NULL);
|
|
|
|
if (!hThread)
|
|
{
|
|
return;
|
|
}
|
|
|
|
while (1)
|
|
{
|
|
if (MsgWaitForMultipleObjects(1, &hThread, FALSE, INFINITE, QS_ALLINPUT) != (WAIT_OBJECT_0 + 1))
|
|
{
|
|
break;
|
|
}
|
|
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if (!PropSheet_IsDialogMessage(HWnd, &msg))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseHandle(hThread);
|
|
|
|
data->IsBusy = FALSE;
|
|
|
|
EnableWindow(GetDlgItem(GetParent(HWnd), IDOK), TRUE);
|
|
EnableWindow(GetDlgItem(GetParent(HWnd), IDCANCEL), TRUE);
|
|
}
|
|
|
|
|
|
UINT
|
|
SetRemovalPolicy(HWND HWnd, PDISK_PAGE_DATA data)
|
|
{
|
|
HANDLE hDisk;
|
|
TCHAR buf[MAX_PATH];
|
|
DWORD len = MAX_PATH;
|
|
CONFIGRET cr;
|
|
|
|
cr = CM_Get_DevNode_Registry_Property(data->DeviceInfoData->DevInst,
|
|
CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME,
|
|
NULL,
|
|
buf,
|
|
&len,
|
|
0);
|
|
if (cr != CR_SUCCESS) {
|
|
|
|
return ERROR_GEN_FAILURE;
|
|
}
|
|
|
|
if (INVALID_HANDLE_VALUE == (hDisk = GetHandleForDisk(buf))) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
data->HotplugInfo.DeviceHotplug = (data->CurrentRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL) ? TRUE : FALSE;
|
|
|
|
//
|
|
// Set hotplug info - IOCTL_STORAGE_SET_HOTPLUG_INFO
|
|
//
|
|
|
|
if (!DeviceIoControl(hDisk,
|
|
IOCTL_STORAGE_SET_HOTPLUG_INFO,
|
|
&data->HotplugInfo,
|
|
sizeof(STORAGE_HOTPLUG_INFO),
|
|
NULL,
|
|
0,
|
|
&len,
|
|
NULL)) {
|
|
|
|
CloseHandle(hDisk);
|
|
return GetLastError();
|
|
}
|
|
|
|
CloseHandle(hDisk);
|
|
|
|
UtilpRestartDeviceEx(HWnd, data);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DiskOnInitDialog(HWND HWnd, HWND HWndFocus, LPARAM LParam)
|
|
{
|
|
PDISK_PAGE_DATA diskData = (PDISK_PAGE_DATA) GetWindowLongPtr(HWnd, DWLP_USER);
|
|
LPPROPSHEETPAGE page = (LPPROPSHEETPAGE) LParam;
|
|
|
|
diskData = (PDISK_PAGE_DATA) page->lParam;
|
|
|
|
DebugPrint((1, "DiskDialogProc: WM_INITDIALOG %#08lx %#08lx\n", HWndFocus, LParam));
|
|
|
|
if (diskData->IsVolume) {
|
|
|
|
//
|
|
// We should never come in here because the
|
|
// DiskClassInstaller does not put this up
|
|
//
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_GROUP), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_SURPRISE), SW_HIDE);
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_SURPRISE_MESG), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY), SW_HIDE);
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MESG), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE), SW_HIDE);
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE_MESG), SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
UINT status;
|
|
|
|
//
|
|
// Initially assume that the device does not have a surprise removal policy
|
|
//
|
|
CheckRadioButton(HWnd, IDC_DISK_POLICY_SURPRISE, IDC_DISK_POLICY_ORDERLY, IDC_DISK_POLICY_ORDERLY);
|
|
|
|
diskData->IsBusy = FALSE;
|
|
|
|
//
|
|
// Obtain the Caching Policy
|
|
//
|
|
status = GetCachingPolicy(diskData);
|
|
|
|
if (status == ERROR_SUCCESS)
|
|
{
|
|
diskData->IsCachingPolicy = TRUE;
|
|
|
|
CheckDlgButton(HWnd, IDC_DISK_POLICY_WRITE_CACHE, diskData->OrigWriteCacheSetting);
|
|
|
|
if (diskData->WriteCacheState != DiskWriteCacheNormal)
|
|
{
|
|
//
|
|
// The write cache option on this device cannot be modified
|
|
// This is either by design or required by the file system
|
|
//
|
|
TCHAR szMesg[MAX_PATH];
|
|
|
|
diskData->IsCachingPolicy = FALSE;
|
|
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE), FALSE);
|
|
|
|
if (diskData->WriteCacheState == DiskWriteCacheForceDisable)
|
|
{
|
|
//
|
|
// Write cache has been disabled to protect data integrity
|
|
//
|
|
if (diskData->OrigWriteCacheSetting == TRUE)
|
|
{
|
|
//
|
|
// Load the warning icon
|
|
//
|
|
HICON hIcon = LoadImage(ModuleInstance,
|
|
MAKEINTRESOURCE(IDI_DISK_POLICY_WARNING),
|
|
IMAGE_ICON,
|
|
GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
LR_SHARED);
|
|
|
|
SendDlgItemMessage(HWnd, IDC_DISK_POLICY_WRITE_CACHE_ICON, STM_SETICON, (WPARAM)hIcon, 0);
|
|
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE_ICON), SW_SHOW);
|
|
|
|
//
|
|
// The request to force disable write cache may
|
|
// have failed. Put up the big bad warning sign
|
|
//
|
|
LoadString(ModuleInstance, IDS_DISK_POLICY_WRITE_CACHE_MSG2, szMesg, MAX_PATH);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Put up an informational tip
|
|
//
|
|
LoadString(ModuleInstance, IDS_DISK_POLICY_WRITE_CACHE_MSG1, szMesg, MAX_PATH);
|
|
}
|
|
}
|
|
else if (diskData->WriteCacheState == DiskWriteCacheDisableNotSupported)
|
|
{
|
|
//
|
|
// This device does not allow for the write cache to be disabled
|
|
//
|
|
LoadString(ModuleInstance, IDS_DISK_POLICY_WRITE_CACHE_MSG2, szMesg, MAX_PATH);
|
|
}
|
|
|
|
SetDlgItemText(HWnd, IDC_DISK_POLICY_WRITE_CACHE_MESG, szMesg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Either we could not open a handle to the device
|
|
// or this device does not support write caching
|
|
//
|
|
diskData->IsCachingPolicy = FALSE;
|
|
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE), SW_HIDE);
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_WRITE_CACHE_MESG), SW_HIDE);
|
|
}
|
|
|
|
//
|
|
// Obtain the Removal Policy
|
|
//
|
|
status = GetRemovalPolicy(diskData);
|
|
|
|
if (status == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Check to see if the drive is removable
|
|
//
|
|
if ((diskData->DefaultRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVAL) ||
|
|
(diskData->DefaultRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL))
|
|
{
|
|
if (diskData->CurrentRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL)
|
|
{
|
|
CheckRadioButton(HWnd, IDC_DISK_POLICY_SURPRISE, IDC_DISK_POLICY_ORDERLY, IDC_DISK_POLICY_SURPRISE);
|
|
|
|
UpdateCachingPolicy(HWnd, diskData);
|
|
}
|
|
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_DEFAULT), SW_SHOW);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The removal policy on fixed disks cannot be modified
|
|
//
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_SURPRISE), FALSE);
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_SURPRISE_MESG), FALSE);
|
|
|
|
//
|
|
// Replace the SysLink with static text
|
|
//
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MESG), SW_HIDE);
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MSGD), SW_SHOW);
|
|
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY), FALSE);
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MSGD), FALSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We could not obtain a removal policy
|
|
//
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_SURPRISE), FALSE);
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_SURPRISE_MESG), FALSE);
|
|
|
|
//
|
|
// Replace the SysLink with static text
|
|
//
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MESG), SW_HIDE);
|
|
ShowWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MSGD), SW_SHOW);
|
|
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY), FALSE);
|
|
EnableWindow(GetDlgItem(HWnd, IDC_DISK_POLICY_ORDERLY_MSGD), FALSE);
|
|
}
|
|
}
|
|
|
|
SetWindowLongPtr(HWnd, DWLP_USER, (LONG_PTR) diskData);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
DiskOnCommand(HWND HWnd, int id, HWND HWndCtl, UINT codeNotify)
|
|
{
|
|
PDISK_PAGE_DATA diskData = (PDISK_PAGE_DATA) GetWindowLongPtr(HWnd, DWLP_USER);
|
|
|
|
switch (id)
|
|
{
|
|
case IDC_DISK_POLICY_SURPRISE:
|
|
{
|
|
diskData->CurrentRemovalPolicy = CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL;
|
|
|
|
UpdateCachingPolicy(HWnd, diskData);
|
|
|
|
PropSheet_Changed(GetParent(HWnd), HWnd);
|
|
|
|
break;
|
|
}
|
|
|
|
case IDC_DISK_POLICY_ORDERLY:
|
|
{
|
|
diskData->CurrentRemovalPolicy = CM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVAL;
|
|
|
|
UpdateCachingPolicy(HWnd, diskData);
|
|
|
|
PropSheet_Changed(GetParent(HWnd), HWnd);
|
|
|
|
break;
|
|
}
|
|
|
|
case IDC_DISK_POLICY_WRITE_CACHE:
|
|
{
|
|
diskData->CurrWriteCacheSetting = !diskData->CurrWriteCacheSetting;
|
|
|
|
PropSheet_Changed(GetParent(HWnd), HWnd);
|
|
|
|
break;
|
|
}
|
|
|
|
case IDC_DISK_POLICY_DEFAULT:
|
|
{
|
|
if (diskData->CurrentRemovalPolicy != diskData->DefaultRemovalPolicy)
|
|
{
|
|
diskData->CurrentRemovalPolicy = diskData->DefaultRemovalPolicy;
|
|
|
|
if (diskData->CurrentRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVAL)
|
|
{
|
|
CheckRadioButton(HWnd, IDC_DISK_POLICY_SURPRISE, IDC_DISK_POLICY_ORDERLY, IDC_DISK_POLICY_ORDERLY);
|
|
}
|
|
else
|
|
{
|
|
CheckRadioButton(HWnd, IDC_DISK_POLICY_SURPRISE, IDC_DISK_POLICY_ORDERLY, IDC_DISK_POLICY_SURPRISE);
|
|
}
|
|
|
|
UpdateCachingPolicy(HWnd, diskData);
|
|
}
|
|
|
|
PropSheet_Changed(GetParent(HWnd), HWnd);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LRESULT
|
|
DiskOnNotify(HWND HWnd, int HWndFocus, LPNMHDR lpNMHdr)
|
|
{
|
|
PDISK_PAGE_DATA diskData = (PDISK_PAGE_DATA) GetWindowLongPtr(HWnd, DWLP_USER);
|
|
|
|
switch (lpNMHdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
{
|
|
//
|
|
// Save away the current setting as the original so
|
|
// we don't try to apply again unless it is changed
|
|
//
|
|
|
|
if (!diskData->IsVolume)
|
|
{
|
|
UINT status;
|
|
|
|
if (diskData->IsCachingPolicy)
|
|
{
|
|
if (diskData->CurrWriteCacheSetting != diskData->OrigWriteCacheSetting)
|
|
{
|
|
status = SetCachingPolicy(diskData);
|
|
}
|
|
}
|
|
|
|
if (((diskData->CurrentRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_ORDERLY_REMOVAL) && (diskData->HotplugInfo.DeviceHotplug == TRUE)) ||
|
|
((diskData->CurrentRemovalPolicy == CM_REMOVAL_POLICY_EXPECT_SURPRISE_REMOVAL) && (diskData->HotplugInfo.DeviceHotplug == FALSE)))
|
|
{
|
|
status = SetRemovalPolicy(HWnd, diskData);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case NM_RETURN:
|
|
case NM_CLICK:
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
LoadString(ModuleInstance, IDS_DISK_POLICY_HOTPLUG, szPath, MAX_PATH);
|
|
|
|
ShellExecute(NULL, _T("open"), _T("RUNDLL32.EXE"), szPath, NULL, SW_SHOWNORMAL);
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
DiskContextMenu(
|
|
HWND HwndControl,
|
|
WORD Xpos,
|
|
WORD Ypos
|
|
)
|
|
{
|
|
WinHelp(HwndControl,
|
|
_T("devmgr.hlp"),
|
|
HELP_CONTEXTMENU,
|
|
(ULONG_PTR) DiskHelpIDs);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
DiskHelp(
|
|
HWND ParentHwnd,
|
|
LPHELPINFO HelpInfo
|
|
)
|
|
{
|
|
if (HelpInfo->iContextType == HELPINFO_WINDOW) {
|
|
|
|
WinHelp((HWND) HelpInfo->hItemHandle,
|
|
_T("devmgr.hlp"),
|
|
HELP_WM_HELP,
|
|
(ULONG_PTR) DiskHelpIDs);
|
|
}
|
|
}
|
|
|
|
|
|
INT_PTR
|
|
DiskDialogProc(
|
|
HWND hWnd,
|
|
UINT Message,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
switch(Message)
|
|
{
|
|
HANDLE_MSG(hWnd, WM_INITDIALOG, DiskOnInitDialog);
|
|
HANDLE_MSG(hWnd, WM_COMMAND, DiskOnCommand);
|
|
HANDLE_MSG(hWnd, WM_NOTIFY, DiskOnNotify);
|
|
|
|
case WM_SETCURSOR:
|
|
{
|
|
//
|
|
// Temporary workaround to prevent the user from
|
|
// making any more changes and giving the effect
|
|
// that something is happening
|
|
//
|
|
PDISK_PAGE_DATA diskData = (PDISK_PAGE_DATA) GetWindowLongPtr(hWnd, DWLP_USER);
|
|
|
|
if (diskData->IsBusy)
|
|
{
|
|
SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
SetWindowLongPtr(hWnd, DWLP_MSGRESULT, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
case WM_CONTEXTMENU:
|
|
DiskContextMenu((HWND)wParam, LOWORD(lParam), HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_HELP:
|
|
DiskHelp(hWnd, (LPHELPINFO)lParam);
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DiskDialogCallback(
|
|
HWND HWnd,
|
|
UINT Message,
|
|
LPPROPSHEETPAGE Page
|
|
)
|
|
{
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#if DBG
|
|
|
|
#include <stdio.h> // for _vsnprintf
|
|
ULONG PropDebug = 0;
|
|
UCHAR PropBuffer[DEBUG_BUFFER_LENGTH];
|
|
|
|
|
|
VOID
|
|
PropDebugPrint(
|
|
ULONG DebugPrintLevel,
|
|
PCHAR DebugMessage,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Debug print for properties pages - stolen from classpnp\class.c
|
|
|
|
Arguments:
|
|
|
|
Debug print level between 0 and 3, with 3 being the most verbose.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, DebugMessage);
|
|
|
|
|
|
if ((DebugPrintLevel <= (PropDebug & 0x0000ffff)) ||
|
|
((1 << (DebugPrintLevel + 15)) & PropDebug)) {
|
|
|
|
_vsnprintf(PropBuffer, DEBUG_BUFFER_LENGTH, DebugMessage, ap);
|
|
|
|
DbgPrint(PropBuffer);
|
|
}
|
|
|
|
va_end(ap);
|
|
|
|
} // end PropDebugPrint()
|
|
|
|
#else
|
|
|
|
//
|
|
// PropDebugPrint stub
|
|
//
|
|
|
|
VOID
|
|
PropDebugPrint(
|
|
ULONG DebugPrintLevel,
|
|
PCHAR DebugMessage,
|
|
...
|
|
)
|
|
{
|
|
}
|
|
|
|
#endif // DBG
|