archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/base/cluster/resdll/disks/mountpoints.c

3962 lines
106 KiB
Raw Permalink Blame History

/*++
Copyright (c) 2000 Microsoft Corporation
Module Name:
mountpoints.c
Abstract:
This module processes mount point information for the disk resource DLL.
Author:
Steve Dziok (stevedz) 15-May-2000
Environment:
User Mode
Revision History:
--*/
#define UNICODE 1
#include "disksp.h"
#include "arbitrat.h"
#include "newdisks.h"
#include "newmount.h"
#include <mountmgr.h>
#define SPACE_CHAR L' '
#define MAX_OFFSET_CHARS 80 // Maximum number of chars allowed in offset string
#define LOG_CURRENT_MODULE LOG_MODULE_DISK
extern PWCHAR GLOBALROOT_HARDDISK_PARTITION_FMT; // L"\\\\\?\\GLOBALROOT\\Device\\Harddisk%u\\Partition%u\\";
extern PWCHAR DEVICE_HARDDISK_PARTITION_FMT; // L"\\Device\\Harddisk%u\\Partition%u";
#ifndef ClusterHashGuid
//
// Hash a GUID to a ULONG value.
//
#define ClusterHashGuid(_guid) ( ((PULONG) &(_guid))[0] ^ ((PULONG) &(_guid))[1] ^ \
((PULONG) &(_guid))[2] ^ ((PULONG) &(_guid))[3] )
#endif
#define MPS_ENABLED 0x00000001
#define MPS_DELETE_INVALID_MPS 0x00000002 // Not currently used
#define MPS_NONCLUSTERED_TO_CLUSTERED_MPS 0x00000010 // Not currently used
#define MPS_KEEP_EXISTING_MPS 0x00000020 // Not currently used
#define MPS_IGNORE_MAX_VOLGUIDS 0x00000100
// Assume 32 nodes with 8 partitions per disk.
#define MAX_ALLOWED_VOLGUID_ENTRIES_PER_DISK 32 * 8
#define STOP_CLUSTER_ENUMERATIONS ERROR_INVALID_PRINTER_COMMAND
#define PHYSICAL_DISK_WSTR L"Physical Disk"
#define CHAR_TO_REPLACE 2
#define MOUNTDEV_WSZ_VOLUME_GUID_PREFIX L"\\??\\Volume{" // Forms: \??\Volume{
#define MOUNTDEV_CB_VOLUME_GUID_PREFIX 22
#define MOUNTDEV_LOOKS_LIKE_VOLUME_GUID(name, length) \
((length > MOUNTDEV_CB_VOLUME_GUID_PREFIX) && \
(!memcmp(name, MOUNTDEV_WSZ_VOLUME_GUID_PREFIX, MOUNTDEV_CB_VOLUME_GUID_PREFIX)))
#define MOUNTDEV_WSZ_ALT_VOLUME_GUID_PREFIX L"\\\\?\\Volume{" // Forms: \\?\Volume{
#define MOUNTDEV_CB_ALT_VOLUME_GUID_PREFIX 22
#define MOUNTDEV_LOOKS_LIKE_ALT_VOLUME_GUID(name, bytelength) \
((bytelength > MOUNTDEV_CB_ALT_VOLUME_GUID_PREFIX) && \
(!memcmp(name, MOUNTDEV_WSZ_ALT_VOLUME_GUID_PREFIX, MOUNTDEV_CB_ALT_VOLUME_GUID_PREFIX)))
typedef struct _SIG_INFO {
DWORD Signature;
BOOL Clustered;
} SIG_INFO, *PSIG_INFO;
typedef struct _DEPENDENCY_INFO {
DWORD SrcSignature;
DWORD TargetSignature;
BOOL DependencyCorrect;
} DEPENDENCY_INFO, *PDEPENDENCY_INFO;
typedef struct _STR_LIST {
LPWSTR MultiSzList; // REG_MULTI_SZ string
DWORD ListBytes; // Number of bytes, not number of WCHARs!
} STR_LIST, *PSTR_LIST;
DWORD
AddStrToList(
IN PDISK_RESOURCE ResourceEntry,
IN PWSTR NewStr,
IN DWORD PartitionNumber,
IN OUT PSTR_LIST StrList
);
DWORD
AssignDevice(
HANDLE MountMgrHandle,
PWCHAR MountName,
PWCHAR VolumeDevName
);
DWORD
CheckDependencies(
DWORD SrcSignature,
DWORD TargetSignature,
PBOOL DependencyCorrect
);
VOID
CheckMPsForVolume(
IN OUT PDISK_RESOURCE ResourceEntry,
IN PWSTR VolumeName
);
DWORD
CheckSignatureClustered(
DWORD Signature,
PBOOL IsClustered
);
DWORD
CreateVolGuidList(
IN OUT PDISK_RESOURCE ResourceEntry
);
DWORD
DeleteVolGuidList(
PDISK_RESOURCE ResourceEntry
);
DWORD
DependencyCallback(
RESOURCE_HANDLE hOriginal,
RESOURCE_HANDLE hResource,
PVOID lpParams
);
#if DBG
VOID
DumpDiskInfoParams(
PDISK_RESOURCE ResourceEntry
);
#endif
DWORD
EnumSigDependencies(
RESOURCE_HANDLE DependentResource,
DWORD DependsOnSignature,
PBOOL DependencyCorrect
);
DWORD
GetMountPoints(
PWSTR VolumeName,
PWSTR *VolumePaths
);
BOOL
GetOffsetFromPartNo(
DWORD PartitionNo,
PMOUNTIE_INFO Info,
PLARGE_INTEGER Offset
);
BOOL
GetPartNoFromOffset(
PLARGE_INTEGER Offset,
PMOUNTIE_INFO Info,
PDWORD PartitionNumber
);
DWORD
GetSignatureForVolume(
PDISK_RESOURCE ResourceEntry,
PWSTR Volume,
PDWORD Signature
);
DWORD
GetSignatureFromDiskInfo(
RESOURCE_HANDLE hResource,
DWORD *dwSignature
);
BOOL
IsMountPointAllowed(
PWSTR MpName,
PWSTR TargetVol,
PDISK_RESOURCE ResourceEntry
);
BOOL
MPIsDriveLetter(
IN PWSTR MountPoint
);
VOID
PrintStrList(
PDISK_RESOURCE ResourceEntry,
LPWSTR MultiSzList,
DWORD ListBytes
);
DWORD
ProcessVolGuidList(
IN OUT PDISK_RESOURCE ResourceEntry
);
static
DWORD
SetMPListThread(
LPVOID lpThreadParameter
);
DWORD
SetupVolGuids(
IN OUT PDISK_RESOURCE ResourceEntry
);
DWORD
SigInfoCallback(
RESOURCE_HANDLE hOriginal,
RESOURCE_HANDLE hResource,
PVOID lpParams
);
DWORD
ValidateListOffsets(
IN OUT PDISK_RESOURCE ResourceEntry,
IN PWSTR MasterList
);
DWORD
ValidateMountPoints(
IN OUT PDISK_RESOURCE ResourceEntry
);
DWORD
WrapClusterResourceControl(
RESOURCE_HANDLE hResource,
DWORD dwControlCode,
LPVOID *OutBuffer,
DWORD *dwBytesReturned
);
DWORD
DisksProcessMountPointInfo(
IN OUT PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
During online processing, find all mount points directed towards this volume
(identified by the ResourceEntry), and process the VolGuid list for this
volume.
If the VolGuid list exists in the cluster database, use it. Otherwise,
get the current VolGuid and add it to the VolGuid list.
VolGuid list is of the form:
SectorOffset1 VolGuid1
SectorOffset1 VolGuid2
SectorOffset1 VolGuid3
SectorOffset2 VolGuid1
SectorOffset2 VolGuid2
SectorOffset3 VolGuid1
... ...
There are three possible mount point configurations involving clustered disks (we
are not concerned about nonshared disks pointing to nonshared disks):
Source --> Target
----------------- -----------------
1. clustered disk clustered disk
2. nonclustered disk clustered disk
3. clustered disk nonclustered disk
Only configuration (1) is supported. Configurations (2) and (3) are not supported.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
ERROR_NOT_READY - MPInfo structure not yet initialized.
Win32 error code.
--*/
{
DWORD dwError = NO_ERROR;
//
// Mount point structures not initialized (i.e. critical section). Don't continue.
//
if ( !ResourceEntry->MPInfo.Initialized ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"DisksProcessMountPointInfo: Mount point information not initialized. \n" );
return ERROR_NOT_READY;
}
#if USEMOUNTPOINTS_KEY
//
// Mount point support disabled, don't do anything.
//
if ( !( ResourceEntry->DiskInfo.Params.UseMountPoints & MPS_ENABLED ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"DisksProcessMountPointInfo: Mount point processing disabled via registry \n" );
//
// Delete the VolGuid list if it exists and remove this info
// from the cluster database.
//
dwError = DeleteVolGuidList( ResourceEntry );
if ( ERROR_SHARING_PAUSED == dwError ) {
PostMPInfoIntoRegistry( ResourceEntry );
}
dwError = NO_ERROR;
return dwError;
}
#endif
//
// Check if we are currently processing mount point info. If so, exit with an error.
//
if ( InterlockedCompareExchange(
&ResourceEntry->MPInfo.MPListCreateInProcess,
1, 0 ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"DisksProcessMountPointInfo: MPList creation in process, bypassing request \n" );
return ERROR_BUSY;
}
__try {
dwError = ProcessVolGuidList( ResourceEntry );
ValidateMountPoints( ResourceEntry );
// Fall through...
#if 0
// Add code similar to this when MPs from nonclustered to clustered disks is supported.
if ( ( ResourceEntry->DiskInfo.Params.UseMountPoints & MPS_ENABLED ) &&
( ResourceEntry->DiskInfo.Params.UseMountPoints & MPS_NONCLUSTERED_TO_CLUSTERED_MPS ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"DisksProcessMountPointInfo: ProcessMPList \n" );
dwError = ProcessMPListConfig2( ResourceEntry );
#endif
} __finally {
InterlockedExchange( &ResourceEntry->MPInfo.MPListCreateInProcess, 0 );
}
return dwError;
} // DisksProcessMountPointInfo
DWORD
ProcessVolGuidList(
IN OUT PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Main routine to create a new VolGuid list or to process an existing VolGuid list.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
Win32 error code.
--*/
{
DWORD dwError = NO_ERROR;
__try {
//
// Always try to add the current VolGuid to the list.
//
dwError = CreateVolGuidList( ResourceEntry );
if ( NO_ERROR != dwError ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"ProcessVolGuidList: Stop processing VolGuid list, Create failed %1!u! \n",
dwError );
__leave;
}
//
// If the list is empty here (it shouldn't be), then exit with an error.
//
if ( !ResourceEntry->DiskInfo.Params.MPVolGuids ||
0 == ResourceEntry->DiskInfo.Params.MPVolGuidsSize ) {
dwError = ERROR_INVALID_DATA;
__leave;
}
PrintStrList( ResourceEntry,
ResourceEntry->DiskInfo.Params.MPVolGuids,
ResourceEntry->DiskInfo.Params.MPVolGuidsSize );
//
// Make sure the offsets are correct in the VolGuid list.
// Note that it is possible for the list to be deleted and
// recreated after this validation, but that is not a problem (because
// when they are recreated they will have the correct offsets).
//
dwError = ValidateListOffsets( ResourceEntry,
ResourceEntry->DiskInfo.Params.MPVolGuids );
if ( ERROR_INVALID_DATA == dwError ) {
//
// At least one of the offsets is invalid. Possibly, the partition
// layout on the disk has been changed. Delete the existing
// list, and create a new one.
//
// This code should run infrequently...
//
// The partition layout might change if ASR runs and creates new partitions
// that don't match the previous system exactly. Since NTBACKUP saves the
// cluster DB information, the mount point list will be restored but won't
// match the actual "new" partition layout. ASR will insure that all the
// mount points and VolGuids on the system are created, so we should be able
// to simply delete and recreate the mount point list.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"ProcessVolGuidList: Invalid offset in existing VolGuid list. Deleting and recreating. \n" );
DeleteVolGuidList( ResourceEntry );
dwError = CreateVolGuidList( ResourceEntry );
__leave;
} else if ( ERROR_INSUFFICIENT_BUFFER == dwError ) {
//
// The Volguid list is too large and likely corrupt. We cannot
// proceed.
//
__leave;
}
//
// For every VolGuid in the list, make sure they are assigned to the correct
// volumes on this system.
//
dwError = SetupVolGuids( ResourceEntry );
} __finally {
}
return dwError;
} // ProcessVolGuidList
DWORD
CreateVolGuidList(
IN OUT PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Add the current system VolGuid to the list. If the list is empty, create a new list.
For each partition on this disk (identified by the ResourceEntry), get the byte
offset of that partition. Get the current VolGuid for that parition, and add
it to the list. If the current VolGuid is already in the list, ignore the error.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
ERROR_INVALID_DATA - partition info in disk resource is invalid
Win32 error code.
--*/
{
PMOUNTIE_PARTITION entry;
HANDLE mountMgrHandle = INVALID_HANDLE_VALUE;
DWORD dwError = ERROR_SUCCESS;
DWORD nPartitions = MountiePartitionCount( &ResourceEntry->MountieInfo );
DWORD physicalDrive = ResourceEntry->DiskInfo.PhysicalDrive;
DWORD idx;
DWORD volumeNameLenChars; // Number of characters
DWORD newStrListLenBytes; // Number of bytes
WCHAR szGlobalDiskPartName[MAX_PATH];
WCHAR szVolumeName[MAX_PATH];
STR_LIST newStrList;
BOOL freeNewList = TRUE;
__try {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: Adding current VolGuid to list \n" );
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
ZeroMemory( szGlobalDiskPartName, sizeof(szGlobalDiskPartName) );
ZeroMemory( szVolumeName, sizeof(szVolumeName) );
ZeroMemory( &newStrList, sizeof(STR_LIST) );
dwError = DevfileOpen( &mountMgrHandle, MOUNTMGR_DEVICE_NAME );
if ( dwError != NO_ERROR ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"CreateVolGuidList: Failed to open MountMgr %1!u! \n",
dwError );
__leave;
}
newStrListLenBytes = ResourceEntry->DiskInfo.Params.MPVolGuidsSize;
if ( newStrListLenBytes ) {
newStrList.MultiSzList = LocalAlloc( LPTR, newStrListLenBytes );
if ( !(newStrList.MultiSzList) ) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"CreateVolGuidList: Failed to allocate storage for new list %1!u! \n",
dwError );
__leave;
}
//
// Copy current list to newStrList.
//
memcpy( newStrList.MultiSzList, ResourceEntry->DiskInfo.Params.MPVolGuids, newStrListLenBytes );
newStrList.ListBytes = newStrListLenBytes;
#if 0 // Useful for debugging
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: newStrListLen %1!u! \n",
newStrList.ListBytes );
PrintStrList( ResourceEntry, newStrList.MultiSzList, newStrList.ListBytes );
#endif
} else {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: Current list empty, creating new list \n" );
}
//
// Check each interesting partition. Since only "valid" partitions are
// saved in the MountieInfo structure, we will only look at those (ignoring those
// partitions that are not NTFS).
//
for ( idx = 0; idx < nPartitions; ++idx ) {
entry = MountiePartition( &ResourceEntry->MountieInfo, idx );
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: index %1!u! entry %2!x! \n", idx, entry );
#endif
if ( !entry ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"CreateVolGuidList: no partition entry for index %1!u! \n", idx );
//
// Something bad happened to our data structures.
//
dwError = ERROR_INVALID_DATA;
__leave;
}
//
// Create the device name of the form:
// \\?\GLOBALROOT\Device\HarddiskX\PartitionY\ (uses trailing backslash)
//
_snwprintf( szGlobalDiskPartName,
MAX_PATH, // Number of CHARS, not bytes
GLOBALROOT_HARDDISK_PARTITION_FMT,
physicalDrive,
entry->PartitionNumber );
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: Using name (%1!ws!) \n",
szGlobalDiskPartName );
#endif
//
// Get the current VolGuid for this partition.
//
if ( !GetVolumeNameForVolumeMountPointW( szGlobalDiskPartName,
szVolumeName,
sizeof(szVolumeName)/sizeof(WCHAR) )) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"CreateVolGuidList: GetVolumeNameForVolumeMountPoint for (%1!ws!) returned %2!u!\n",
szGlobalDiskPartName,
dwError );
// Try next partition.
continue;
}
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: Returned volume name (%1!ws!) \n",
szVolumeName );
#endif
//
// Fix current VolGuid name.
//
// GetVolumeNameForVolumeMountPoint returns name of the form:
// \\?\Volume{-GUID-}\
//
// But we need the name to be in the form:
// \??\Volume{-GUID-}
//
volumeNameLenChars = wcslen( szVolumeName );
if ( !(MOUNTDEV_LOOKS_LIKE_ALT_VOLUME_GUID( szVolumeName, volumeNameLenChars * sizeof(WCHAR) ) ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"CreateVolGuidList: Improper volume name format (%1!ws!) \n",
szVolumeName );
// Try next partition.
continue;
}
szVolumeName[1] = L'?';
if ( L'\\' == szVolumeName[volumeNameLenChars-1]) {
szVolumeName[volumeNameLenChars-1] = L'\0';
}
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: Fixed volume name (%1!ws!) \n",
szVolumeName );
#endif
//
// Add the new string to the list. If the new string is already in the list, this
// routine won't do anything and will return NO_ERROR.
//
dwError = AddStrToList( ResourceEntry,
szVolumeName,
entry->PartitionNumber,
&newStrList );
if ( NO_ERROR != dwError ) {
__leave;
}
}
//
// Optimization:
// If the new list is the same as the old list, we are done.
//
if ( newStrList.MultiSzList &&
newStrList.ListBytes &&
newStrList.ListBytes == ResourceEntry->DiskInfo.Params.MPVolGuidsSize &&
( 0 == memcmp( newStrList.MultiSzList, ResourceEntry->DiskInfo.Params.MPVolGuids, newStrListLenBytes ) ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: New list same as old list, skipping update \n" );
__leave;
}
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"CreateVolGuidList: Saving new VolGuid list \n" );
freeNewList = FALSE;
//
// The new list is different from the old list. Free the old list, update
// the ResourceEntry with the new list information, and update the cluster
// database.
//
DeleteVolGuidList( ResourceEntry );
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
ResourceEntry->DiskInfo.Params.MPVolGuids = newStrList.MultiSzList;
ResourceEntry->DiskInfo.Params.MPVolGuidsSize = newStrList.ListBytes;
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
PrintStrList( ResourceEntry,
ResourceEntry->DiskInfo.Params.MPVolGuids,
ResourceEntry->DiskInfo.Params.MPVolGuidsSize );
dwError = PostMPInfoIntoRegistry( ResourceEntry );
} __finally {
if ( INVALID_HANDLE_VALUE != mountMgrHandle ) {
CloseHandle( mountMgrHandle );
}
if ( freeNewList && newStrList.MultiSzList ) {
LocalFree( newStrList.MultiSzList );
}
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
}
return dwError;
} // CreateVolGuidList
DWORD
AddStrToList(
IN PDISK_RESOURCE ResourceEntry,
IN PWSTR NewStr,
IN DWORD PartitionNumber,
IN OUT PSTR_LIST StrList
)
/*++
Routine Description:
Add the string to the MULTI_SZ list. Convert the partition number to a byte offset
so we don't rely on partition numbers.
List format will be:
ByteOffset1 Str1
ByteOffset1 Str2
ByteOffset1 Str3
ByteOffset2 Str1
ByteOffset2 Str2
ByteOffset3 Str1
... ...
Arguments:
Return Value:
--*/
{
PWCHAR listEntry = NULL;
DWORD listEntrySizeChars;
DWORD lenChars;
DWORD newStrLenChars;
DWORD listChars;
DWORD remainingLen;
DWORD dwError = ERROR_INVALID_DATA;
LARGE_INTEGER offset;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"AddStrToList: Adding str (%1!ws!) \n", NewStr );
#endif
newStrLenChars = wcslen( NewStr );
if ( 0 == newStrLenChars ) {
//
// Something wrong with the string length.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"AddStrToList: Invalid length: NewStrLen = %1!u! \n",
newStrLenChars );
goto FnExit;
}
//
// Indicate an error unless we can allocate and copy the info
// into the list. Calculate the minimum size needed, then get
// larger buffer. This buffer is temporary and freed later.
//
listEntrySizeChars = ( newStrLenChars + // Char length of parameter string
MAX_OFFSET_CHARS + // Char length of offset string
1 + // Room to change end of offset string to space and extend it
1 ) // Unicode NULL
* 2; // Make sure buffer is large enough
listEntry = LocalAlloc( LPTR, listEntrySizeChars * sizeof(WCHAR) );
if ( !listEntry ) {
dwError = GetLastError();
goto FnExit;
}
//
// Get the offset for the specified partition.
//
if ( !GetOffsetFromPartNo( PartitionNumber,
&ResourceEntry->MountieInfo,
&offset ) ) {
//
// Can't get the offset for the specified partition.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"AddStrToList: GetOffsetFromPartNo failed \n" );
goto FnExit;
}
//
// Convert the offset into a string. Put the offset into listEntry.
//
_ui64tow( offset.QuadPart, listEntry, 16 );
lenChars = wcslen( listEntry );
if ( 0 == lenChars || lenChars >= MAX_OFFSET_CHARS ) {
//
// The length of the offset string is invalid.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"AddStrToList: Invalid offset string length = %1!u! \n",
lenChars );
goto FnExit;
}
// Format will be:
// ByteOffset1 Str1
// ByteOffset1 Str2
// ByteOffset1 Str3
// ByteOffset2 Str1
// ByteOffset2 Str2
// ByteOffset3 Str1
// ... ...
//
// Change the end of the offset string to another character. Move the end of string
// out one character. This extra space was included when we allocated the buffer.
//
listEntry[lenChars+1] = UNICODE_NULL;
listEntry[lenChars] = SPACE_CHAR;
//
// One more check. Make sure enough space remaining for adding string.
//
remainingLen = listEntrySizeChars - wcslen( listEntry ) - 1;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"AddStrToList: New string length %1!u! Remaining list entry length %2!u! \n",
newStrLenChars,
remainingLen );
#endif
if ( newStrLenChars >= remainingLen ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"AddStrToList: New string length %1!u! larger than remaining list entry length %2!u! \n",
newStrLenChars,
remainingLen );
goto FnExit;
}
//
// Put the rest of the string in list entry.
//
wcsncat( listEntry, NewStr, newStrLenChars );
//
// If the string is already in the list, skip it.
//
if ( ClRtlMultiSzScan( ResourceEntry->DiskInfo.Params.MPVolGuids, listEntry ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"AddStrToList: Skipping duplicate entry (%1!ws!) \n",
listEntry );
dwError = NO_ERROR;
goto FnExit;
}
//
// Note that ClRtlMultiSzAppend updates the number of CHARACTERS, but we
// need to have the number of BYTES in the property table. We will adjust
// this value later.
//
listChars = StrList->ListBytes / sizeof(WCHAR);
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"AddStrToList: StrList->MultiSzList at %1!x!, numBytes %2!u! \n",
StrList->MultiSzList,
StrList->ListBytes );
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"AddStrToList: Adding str entry: (%1!ws!) numChars %2!u! \n",
listEntry,
listChars );
#endif
dwError = ClRtlMultiSzAppend( &(StrList->MultiSzList),
&listChars,
listEntry );
//
// Convert the number of CHARACTERS back to bytes.
//
StrList->ListBytes = listChars * sizeof(WCHAR);
if ( ERROR_SUCCESS == dwError) {
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"AddStrToList: Added str, numBytes %1!u! numChars %2!u! \n",
StrList->ListBytes,
listChars );
#endif
} else {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"AddStrToList: Unable to append MultiSz string for (%1!ws!), failed %x \n",
NewStr,
dwError );
}
FnExit:
if ( listEntry ) {
LocalFree( listEntry );
}
return dwError;
} // AddStrToList
DWORD
SetupVolGuids(
IN OUT PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Add every VolGuid in the existing MULTI_SZ VolGuid list to the system.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
Win32 error code.
--*/
{
PWCHAR currentStr;
PWCHAR volGuid;
HANDLE mountMgrHandle = INVALID_HANDLE_VALUE;
DWORD physicalDrive = ResourceEntry->DiskInfo.PhysicalDrive;
DWORD currentStrLenChars = 0;
DWORD dwError = NO_ERROR;
DWORD partitionNo;
DWORD count;
LARGE_INTEGER offset;
WCHAR szDiskPartName[MAX_PATH];
__try {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetupVolGuids: Processing VolGuid list \n" );
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
dwError = DevfileOpen( &mountMgrHandle, MOUNTMGR_DEVICE_NAME );
if ( dwError != NO_ERROR ) {
__leave;
}
//
// Parse through the list.
//
for ( currentStr = (PWCHAR)ResourceEntry->DiskInfo.Params.MPVolGuids,
currentStrLenChars = wcslen( currentStr ) ;
currentStrLenChars ;
currentStr += currentStrLenChars + 1,
currentStrLenChars = wcslen( currentStr ) ) {
offset.QuadPart = 0;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetupVolGuids: CurrentStr (%1!ws!), numChars %2!u! \n",
currentStr,
currentStrLenChars );
#endif
//
// Convert the offset from a string to a large integer value.
//
count = swscanf( currentStr, L"%I64x ", &offset.QuadPart );
if ( 0 == count ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"SetupVolGuids: Unable to parse offset from currentStr (%1!ws!) \n",
currentStr );
continue;
}
//
// Convert the offset to a partition number.
//
if ( !GetPartNoFromOffset( &offset, &ResourceEntry->MountieInfo, &partitionNo ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"SetupVolGuids: Unable to convert offset ( %1!08X!%2!08X! ) to partition number \n",
offset.HighPart,
offset.LowPart ); // couldn't get !I64X! to work...
continue;
}
//
// Get a pointer to the VolGuid data, just after the byte offset.
//
volGuid = wcsstr( currentStr, MOUNTDEV_WSZ_VOLUME_GUID_PREFIX );
if ( !volGuid ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"SetupVolGuids: Unable to find volume string in current list entry (%1!ws) \n",
currentStr );
continue;
}
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetupVolGuids: Using VolGuid (%1!ws!) \n",
volGuid );
#endif
ZeroMemory( szDiskPartName, sizeof( szDiskPartName ) );
//
// Create the device name of the form:
// \Device\HarddiskX\PartitionY (no trailing backslash)
//
_snwprintf( szDiskPartName,
MAX_PATH, // Number of CHARS, not bytes
DEVICE_HARDDISK_PARTITION_FMT,
physicalDrive,
partitionNo );
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetupVolGuids: Using device name (%1!ws!) \n",
szDiskPartName );
#endif
dwError = AssignDevice( mountMgrHandle, volGuid, szDiskPartName );
if ( NO_ERROR != dwError &&
STATUS_OBJECT_NAME_COLLISION != dwError ) {
// Assign device will return: 0xC0000035 STATUS_OBJECT_NAME_COLLISION
// if we are setting a VolGuid that was previously set. This is not
// a problem.
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"SetupVolGuids: Unable to assign VolGuid to device, error %1!x! \n",
dwError );
// Continue processing with error...
}
dwError = STATUS_SUCCESS;
}
} __finally {
if ( INVALID_HANDLE_VALUE != mountMgrHandle ) {
CloseHandle( mountMgrHandle );
}
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
}
return dwError;
} // SetupVolGuids
DWORD
AssignDevice(
HANDLE MountMgrHandle,
PWCHAR MountName,
PWCHAR VolumeDevName
)
/*++
Routine Description:
Put the specified MountName (i.e. mount point name) into the mount manager's internal table
of mount points.
Inputs:
MountMgrHandle - Handle to the mount manager. The caller is responsible for
opening and closing this handle.
MountName - Mountpoint name of the form:
\??\Volume{-GUID-} - note prefix "\??\" and no trailing backslash.
\DosDevices\X: - works if a drive letter is not already assigned
VolumeDevName - Volume device name. Can be one of the following forms (note that case is
important). The "#" is a zero-based device number (and partition number
as appropriate).
\Device\CdRom#
\Device\Floppy#
\Device\HarddiskVolume#
\Device\Harddisk#\Partition#
Return value:
A Win32 error code.
--*/
{
PMOUNTMGR_CREATE_POINT_INPUT input;
DWORD status;
USHORT mountNameLenBytes;
USHORT volumeDevNameLenBytes;
USHORT inputlengthBytes;
if ( INVALID_HANDLE_VALUE == MountMgrHandle ) {
return ERROR_INVALID_PARAMETER;
}
mountNameLenBytes = wcslen( MountName ) * sizeof(WCHAR);
volumeDevNameLenBytes = wcslen( VolumeDevName ) * sizeof(WCHAR);
inputlengthBytes = sizeof(MOUNTMGR_CREATE_POINT_INPUT) + mountNameLenBytes + volumeDevNameLenBytes;
input = (PMOUNTMGR_CREATE_POINT_INPUT)LocalAlloc( LPTR, inputlengthBytes );
if ( !input ) {
return ERROR_NOT_ENOUGH_MEMORY;
}
input->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
input->SymbolicLinkNameLength = mountNameLenBytes;
input->DeviceNameOffset = input->SymbolicLinkNameOffset +
input->SymbolicLinkNameLength;
input->DeviceNameLength = volumeDevNameLenBytes;
RtlCopyMemory((PCHAR)input + input->SymbolicLinkNameOffset,
MountName, mountNameLenBytes);
RtlCopyMemory((PCHAR)input + input->DeviceNameOffset,
VolumeDevName, volumeDevNameLenBytes);
status = DevfileIoctl( MountMgrHandle,
IOCTL_MOUNTMGR_CREATE_POINT,
input,
inputlengthBytes,
NULL,
0,
NULL );
LocalFree( input );
return status;
} // AssignDevice
DWORD
DeleteVolGuidList(
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Delete the list from the DISK_RESOURCE structure, if it exists (free the
memmory). Also deletes the information from the cluster database.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
NO_ERROR - The list was deleted.
ERROR_NOT_READY - The mount point information was not yet initialized.
Win32 error code.
--*/
{
DWORD dwError = NO_ERROR;
//
// Mount point structures not initialized (i.e. critical section). Don't continue.
//
if ( !ResourceEntry->MPInfo.Initialized ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"DeleteVolGuidList: Mount point info not initialized. List not deleted. \n" );
dwError = ERROR_NOT_READY;
goto FnExit;
}
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
//
// If existing list, free it.
//
if ( ResourceEntry->DiskInfo.Params.MPVolGuids ) {
LocalFree( ResourceEntry->DiskInfo.Params.MPVolGuids );
ResourceEntry->DiskInfo.Params.MPVolGuidsSize = 0;
ResourceEntry->DiskInfo.Params.MPVolGuids = NULL;
dwError = ClusterRegDeleteValue( ResourceEntry->ResourceParametersKey,
CLUSREG_NAME_PHYSDISK_MPVOLGUIDS );
//
// If the update failed and the disk is not yet online, it will fail with
// ERROR_SHARING_PAUSED. Just return the error. If the caller really,
// really, really wants the cluster database cleaned up, they can
// use the PostMPInfoIntoRegistry call to create a thread to do this
// work.
if ( NO_ERROR != dwError ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"DeleteVolGuidList: Unable to delete VolGuid from cluster database %1!u! \n",
dwError );
}
}
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
FnExit:
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"DeleteVolGuidList: returns %1!u! \n",
dwError );
#endif
return dwError;
} // DeleteVolGuidList
BOOL
IsMountPointAllowed(
PWSTR MpName,
PWSTR TargetVol,
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Verify that the mount point is allowed. There are several reasons why the mount
point would not be allowed.
At this point, the source volume will be accessible. If the source were offline,
we wouldn't even know about it, and we wouldn't even get to this routine. The
fact that the source is accessible allows us to do some things differently (i.e. we
can talk to the disk if needed).
Dependencies:
If source disk S has a mount point to target disk T ( S:\tdir --> T: ), then
source S is dependent on target T and target T must be brought online before
source S is online.
Quorum drive restrictions:
Generally, the quorum drive cannot have a mount point to another disk. This
is because the quorum drive is not allowed to be dependent on another resource.
A mount point from clustered source S to quorum target Q is allowed. The
dependency requirement is that quorum drive Q must come online before
source drive S (i.e. S depends on Q).
A mount point from quorum source Q to a clustered target T is not allowed because
this would require T to be online before Q (i.e. Q depnends on T), and the
quorum drive cannot have dependencies.
A mount point from quorum source Q to a nonclustered target C is invalid.
Mount points to non-clustered disks:
These types of mountpoints should not be used.
Configurations supported:
C is a non-clustered disk.
X, Y are clustered disks, not quorum disks.
Q is quorum disk.
Source Target Status
------ ------ ------------------------------------------------------------
C --> Q Not supported. Log error to system event log.
C --> X Not supported. Log error to system event log.
X --> C Not supported. We never process non-clustered target C.
X --> Q Valid if drive X is dependent on drive Q (same group).
X --> Y Valid if drive X is dependent on drive Y (Y online first).
Q --> X Invalid. Quorum drive cannot be dependent on another resource.
Q --> C Not supported. We never process target C.
Future work:
Log event message when invalid mount point used.
Arguments:
MpName - Possible mount point. This will either be a mount point or a drive letter
(which is actually a mount point). Format can be:
x:\ [Note trailing backslash!]
x:\some-mp-name\ [Note trailing backslash!]
x:\some-dir\some-mp-name\ [Note trailing backslash!]
TargetVol - Mount point target volume name. Format:
\\?\Volume{GUID}\ [Note trailing backslash!]
ResourceEntry - Pointer to the DISK_RESOURCE structure for the target volume.
Return Value:
TRUE if the mount point is allowed.
--*/
{
DWORD srcSignature;
DWORD targetSignature = ResourceEntry->DiskInfo.Params.Signature;
DWORD quorumSignature;
DWORD dwError = NO_ERROR;
DWORD messageId = 0;
BOOL mpAllowed = TRUE;
BOOL srcSigIsClustered;
BOOL dependencyCorrect;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"IsMountPointAllowed: MP source (%1!ws!) \n",
MpName );
#endif
//
// Since the drive letter is also a mountpoint, a drive letter is valid.
//
if ( MPIsDriveLetter( MpName ) ) {
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"IsMountPointAllowed: Valid MP: MP is a drive letter \n" );
#endif
mpAllowed = TRUE;
goto FnExit;
}
//
// Get the signature of the source drive. This drive is accessible (or
// we wouldn't even have the mount point info yet) but we cannot assume it
// is a clustered drive. If this fails, we can't use the mountpoint.
//
dwError = GetSignatureForVolume( ResourceEntry, MpName, &srcSignature );
if ( NO_ERROR != dwError || !srcSignature ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"IsMountPointAllowed: Unable to get signature from volume, error %1!u! \n",
dwError );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_SIG_UNAVAILABLE;
goto FnExit;
}
//
// If source points back to target, this mount point is not allowed. Even though
// the mount point code seems to allow this, there are some strange circular
// dependencies that show up.
//
if ( srcSignature == targetSignature ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"IsMountPointAllowed: Invalid MP: Source and target volumes are the same device \n" );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_SOURCE_EQUAL_TARGET;
goto FnExit;
}
//
// If we can't enumerate the cluster disk signatures, assume that this mount
// point is not allowed.
//
dwError = CheckSignatureClustered( srcSignature, &srcSigIsClustered );
if ( NO_ERROR != dwError ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"IsMountPointAllowed: Unable to enumerate disk signatures, error %1!u! \n",
dwError );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_SIG_ENUMERATION_FAILED;
goto FnExit;
}
//
// In the future, a non-clustered source might be valid only if a special registry
// key is specified - this is not currently implemented. So even though this will
// work without us doing anything (on this one node - when the disk is moved to
// another node, the MP won't work), we will warn the user that it is invalid.
//
// The user would have to manually set these types of mountpoints on each node.
//
// C --> X - Invalid, but should work
// C --> Q - Invalid, but should work
if ( !srcSigIsClustered ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"IsMountPointAllowed: Invalid MP: Source volume is non-clustered \n" );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_SOURCE_NOT_CLUSTERED;
goto FnExit;
}
//
// At this point, the source drive is a clustered drive but we don't yet know
// what the target looks like.
//
// X --> ??
// Q --> ??
//
// Get quorum signature. If this fails, assume the mount point is not allowed.
//
dwError = GetQuorumSignature( &quorumSignature );
if ( NO_ERROR != dwError ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"IsMountPointAllowed: Unable to get quorum signature, error %1!u! \n",
dwError );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_QUORUM_SIG_UNAVAILABLE;
goto FnExit;
}
//
// If the source is the quorum drive, the mount point is not allowed because
// the quorum cannot be dependent on another disk resource. We already know
// that the source and target are different devices from an ealier check.
//
if ( quorumSignature == srcSignature ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"IsMountPointAllowed: Invalid MP: source sig %1!x! is quorum disk, target sig %2!x! is clustered \n",
srcSignature,
targetSignature );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_SOURCE_IS_QUORUM;
goto FnExit;
}
#if 0
// This config is valid only if the dependencies are correct between x and q. Fall through
// to check dependencies.
//
// If the target is the quorum drive and the source and target are different, then
// this mount point is allowed.
//
// X --> Q
if ( quorumSignature == targetSignature &&
srcSignature != targetSignature ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"IsMountPointAllowed: Valid MP: source sig %1!x! is clustered, target sig %2!x! is quorum disk \n",
srcSignature,
targetSignature );
mpAllowed = TRUE;
goto FnExit;
}
#endif
//
// We have two possibilities left:
//
// X --> Q - valid
// X --> Y - valid
//
//
// These are valid only if the dependencies are set up correctly. Y must
// be online before X, so X is dependent on Y.
//
dependencyCorrect = FALSE;
dwError = CheckDependencies( srcSignature,
targetSignature,
&dependencyCorrect );
if ( NO_ERROR != dwError ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"IsMountPointAllowed: Unable to enumerate disk dependencies, error %1!u! \n",
dwError );
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_ENUM_DISK_DEP_FAILED;
goto FnExit;
}
if ( dependencyCorrect ) {
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"IsMountPointAllowed: Valid MP: Dependencies are correct \n" );
#endif
mpAllowed = TRUE;
goto FnExit;
}
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"IsMountPointAllowed: Invalid MP: Dependencies are incorrect \n",
MpName );
//
// If we get here, the mount point is not allowed.
//
mpAllowed = FALSE;
messageId = RES_DISK_INVALID_MP_INVALID_DEPENDENCIES;
FnExit:
if ( !mpAllowed && messageId ) {
// Log event...
ClusResLogSystemEventByKey2(ResourceEntry->ResourceKey,
LOG_UNUSUAL,
messageId,
MpName,
TargetVol);
}
return mpAllowed;
} // IsMountPointAllowed
DWORD
CheckDependencies(
DWORD SrcSignature,
DWORD TargetSignature,
PBOOL DependencyCorrect
)
/*++
Routine Description:
Determine if the dependency between the source volume and target volume is set up
correctly. Since we are using the cluster APIs, they should insure that the
resources are in the same group and have dependencies set.
Arguments:
SrcSignature - Disk signature of the source volume.
TargetSignature - Disk signature of the targe volume.
DependencyCorrect - Indicates whether the dependency is set up correctly between the
source and target. If set up correctly, this will be returned
as TRUE.
Return Value:
Win32 error code.
--*/
{
DWORD dwError = NO_ERROR;
DEPENDENCY_INFO dependInfo;
ZeroMemory( &dependInfo, sizeof(DEPENDENCY_INFO) );
//
// We need to find the source's resources first.
//
dependInfo.SrcSignature = SrcSignature;
dependInfo.TargetSignature = TargetSignature;
dependInfo.DependencyCorrect = FALSE;
//
// Worst case assume that the dependency is invalid.
//
*DependencyCorrect = FALSE;
dwError = ResUtilEnumResources( NULL,
PHYSICAL_DISK_WSTR,
DependencyCallback,
&dependInfo
);
//
// STOP_CLUSTER_ENUMERATIONS is our way to indicate that the
// enumerations stopped (possibly early). Check for this return
// value and also if the DependencyCorrect flag was set to indicate
// status to the caller.
//
if ( STOP_CLUSTER_ENUMERATIONS == dwError ) {
dwError = NO_ERROR;
if ( dependInfo.DependencyCorrect ) {
*DependencyCorrect = TRUE;
}
}
return dwError;
} // CheckDependencies
DWORD
DependencyCallback(
RESOURCE_HANDLE hOriginal,
RESOURCE_HANDLE hResource,
PVOID lpParams
)
/*++
Routine Description:
For each enumerated disk resource, get the signature and see if it matches the
mount point source signature (passed in the DEPENDENCY_INFO structure). If it
does not match, return success so that the disk enumeration continues.
If the enumerated resource signature matches the mount point source signature,
then check the cluster dependencies and make sure they are correct. Once we
have had a match on the signatures, we need to return an error to stop the
disk enumeration, so we use STOP_CLUSTER_ENUMERATIONS as that special error
value.
If the cluster dependencies are acceptable, the DependencyCorrect flag will be
set to TRUE in the DEPENDENCY_INFO structure.
Arguments:
hOriginal - Handle to the original resource. Not used.
hResource - Handle to a cluster resource of type PHYSICAL_DISK.
lpParams - Pointer to DEPENDENCY_INFO structure.
Return Value:
STOP_CLUSTER_ENUMERATIONS - Special flag to stop the enumeration process.
Win32 error code.
--*/
{
PDEPENDENCY_INFO dependInfo = lpParams;
DWORD dwSignature;
DWORD dwError = NO_ERROR;
//
// Get the disk info and parse the signature from it.
//
dwError = GetSignatureFromDiskInfo( hResource, &dwSignature );
if ( NO_ERROR != dwError ) {
return dwError;
}
//
// Check if we have a resource handle to the source disk or to
// a different disk. If the resource is the source disk,
// enumerate the dependencies and make sure they are correct.
//
if ( dwSignature == dependInfo->SrcSignature ) {
dwError = EnumSigDependencies( hResource,
dependInfo->TargetSignature,
&dependInfo->DependencyCorrect );
//
// If the dependency check did not get an error, set a fake
// error to make the disk enumeration stop.
//
if ( NO_ERROR == dwError ) {
dwError = STOP_CLUSTER_ENUMERATIONS;
}
}
return dwError;
} // DependencyCallback
DWORD
EnumSigDependencies(
RESOURCE_HANDLE DependentResource,
DWORD DependsOnSignature,
PBOOL DependencyCorrect
)
/*++
Routine Description:
Check that the cluster disk dependencies are correct between the source and
target of the mount point.
To do this, we open the dependent resource and use the cluster APIs to enumerate
all the disk resources dependencies. For each dependency found, check for a
match of the DependsOnSignature. If the signatures match, the dependency is
correct and we are done. Otherwise, keep checking all the dependencies until
we exhaust the list or find a match.
Note: Dependency is brought online before the DependentResource.
Arguments:
DependentResource - Resource Handle to check all the dependencies.
DependsOnSignature - Signature of a possibly dependent disk. This disk must be
brought online before the DependentResource.
DependencyCorrect - Flag set to TRUE when the cluster dependencies between
the DependentResource and it's dependency (identified by the
DependsOnSignature) are correct.
Return Value:
Win32 error code.
--*/
{
HRESENUM resEnum = NULL;
HCLUSTER hCluster = NULL;
HRESOURCE dependsOnResource = NULL;
DWORD idx;
DWORD dwError = NO_ERROR;
DWORD enumType;
DWORD nameLen;
DWORD signature;
WCHAR enumNameW[MAX_PATH * 2];
__try {
hCluster = OpenCluster( NULL );
if ( NULL == hCluster ) {
dwError = GetLastError();
__leave;
}
//
// Open an enumerator for iterating through the resources.
//
resEnum = ClusterResourceOpenEnum( DependentResource,
CLUSTER_RESOURCE_ENUM_DEPENDS );
if ( !resEnum ) {
dwError = GetLastError();
__leave;
}
//
// Iterate through the dependencies.
//
idx = 0;
while ( TRUE ) {
nameLen = MAX_PATH;
ZeroMemory( enumNameW, sizeof(enumNameW) );
dwError = ClusterResourceEnum( resEnum,
idx,
&enumType,
enumNameW,
&nameLen );
if ( ERROR_NO_MORE_ITEMS == dwError ) {
//
// The list is exhausted. Indicate no error and leave. This
// just means we checked all the dependencies and we didn't find
// a match.
//
dwError = NO_ERROR;
__leave;
}
if ( ERROR_SUCCESS != dwError ) {
//
// Some type of error, we have to stop processing.
//
__leave;
}
//
// Now we have the name (in the form of a string) of a resource we are
// dependent on. We need to get the signature and compare to the
// signature passed in.
//
dependsOnResource = OpenClusterResource( hCluster,
enumNameW );
if ( NULL == dependsOnResource ) {
dwError = GetLastError();
__leave;
}
//
// Get the disk signature from the resources disk info.
//
dwError = GetSignatureFromDiskInfo( dependsOnResource, &signature );
//
// If the signature passed in matches the signature we are dependent on,
// then the dependency is correct. Otherwise, we have to keep looking.
//
if ( NO_ERROR == dwError && signature == DependsOnSignature ) {
*DependencyCorrect = TRUE;
dwError = NO_ERROR;
__leave;
}
//
// Look at the next enumeration resource.
//
CloseClusterResource( dependsOnResource );
dependsOnResource = NULL;
idx++;
}
} __finally {
if ( dependsOnResource ) {
CloseClusterResource( dependsOnResource );
}
if ( resEnum ) {
ClusterResourceCloseEnum( resEnum );
}
if ( hCluster ) {
CloseCluster( hCluster );
}
}
return dwError;
} // EnumSigDependencies
DWORD
CheckSignatureClustered(
DWORD Signature,
PBOOL IsClustered
)
/*++
Routine Description:
Determine if the specified disk signature belongs to a clustered disk.
Enumerates the cluster physical disks and tries to find a signature
match.
The enumeration returns STOP_CLUSTER_ENUMERATIONS when it has found
a matching signature. This special error code is to stop the disk
enumeration.
Arguments:
Signature - Disk signature to be checked.
IsClustered - Flag indicating disk is clustered. If TRUE, disk is a
clustered disk.
Return Value:
Win32 error code.
--*/
{
DWORD dwError = NO_ERROR;
SIG_INFO sigInfo;
ZeroMemory( &sigInfo, sizeof(SIG_INFO) );
sigInfo.Signature = Signature;
sigInfo.Clustered = FALSE;
*IsClustered = FALSE;
dwError = ResUtilEnumResources( NULL,
PHYSICAL_DISK_WSTR,
SigInfoCallback,
&sigInfo
);
if ( STOP_CLUSTER_ENUMERATIONS == dwError && sigInfo.Clustered ) {
dwError = NO_ERROR;
*IsClustered = TRUE;
}
return dwError;
} // CheckSignatureClustered
DWORD
SigInfoCallback(
RESOURCE_HANDLE hOriginal,
RESOURCE_HANDLE hResource,
PVOID lpParams
)
/*++
Routine Description:
For each enumerated disk resource, get the signature and see if it matches the
specified disk signature (passed in the SIG_INFO structure). If it does not
match, return success so that the disk enumeration continues.
If the enumerated resource signature matches the mount point source signature,
sets the Clustered flag in the SIG_INFO structure to TRUE.
Arguments:
hOriginal - Handle to the original resource. Not used.
hResource - Handle to a cluster resource of type PHYSICAL_DISK.
lpParams - Pointer to SIGN_INFO structure.
Return Value:
STOP_CLUSTER_ENUMERATIONS - Special flag to stop the enumeration process.
Win32 error code.
--*/
{
PSIG_INFO sigInfo = lpParams;
DWORD dwSignature;
DWORD dwError = NO_ERROR;
//
// Get the disk info and parse the signature from it.
//
dwError = GetSignatureFromDiskInfo( hResource, &dwSignature );
if ( NO_ERROR != dwError ) {
return dwError;
}
if ( dwSignature == sigInfo->Signature ) {
sigInfo->Clustered = TRUE;
//
// Return an error to stop the enumeration.
//
dwError = STOP_CLUSTER_ENUMERATIONS;
}
return dwError;
} // SigInfoCallback
DWORD
GetSignatureFromDiskInfo(
RESOURCE_HANDLE hResource,
DWORD *dwSignature
)
/*++
Routine Description:
Get the signature for the given volume from the cluster using
ClusterResourceControl.
Arguments:
hResource - Handle to a cluster resource of type PHYSICAL_DISK.
Signature - On success, the signature is returned into this pointer.
Return Value:
Win32 error code.
--*/
{
PBYTE outBuffer = NULL;
PCLUSPROP_DISK_SIGNATURE diskSignature;
DWORD dwError;
DWORD dwBytesReturned;
DWORD signature;
*dwSignature = 0;
dwError = WrapClusterResourceControl( hResource,
CLUSCTL_RESOURCE_STORAGE_GET_DISK_INFO,
&outBuffer,
&dwBytesReturned );
if ( NO_ERROR == dwError && outBuffer ) {
//
// CLUSPROP_DISK_SIGNATURE must always begin the value list returned from the
// CLUSCTL code.
//
diskSignature = (PCLUSPROP_DISK_SIGNATURE)outBuffer;
if ( diskSignature->Syntax.dw != CLUSPROP_SYNTAX_DISK_SIGNATURE ) {
//
// Invalid syntax.
//
dwError = ERROR_BAD_FORMAT;
} else if ( diskSignature->cbLength != sizeof(DWORD) ) {
//
// Invalid length.
//
dwError = ERROR_BAD_FORMAT;
} else {
//
// Return the signature.
//
*dwSignature = diskSignature->dw;
}
}
if (outBuffer) {
LocalFree(outBuffer);
}
return dwError;
} // GetSignatureFromDiskInfo
DWORD
GetSignatureForVolume(
PDISK_RESOURCE ResourceEntry,
PWSTR MpName,
PDWORD Signature
)
/*++
Routine Description:
Get the signature for the given volume. The signature is found by issuing
IOCTL_DISK_GET_DRIVE_LAYOUT_EX or IOCTL_DISK_GET_DRIVE_LAYOUT.
The volume must be online for this to work and not reserved by another node.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
MpName - Possible mount point. This will either be a mount point or a drive letter
(which is actually a mount point). Format can be:
x:\ [Note trailing backslash!]
x:\some-mp-name\ [Note trailing backslash!]
x:\some-dir\some-mp-name\ [Note trailing backslash!]
Signature - On success, the signature is returned into this pointer.
Return Value:
Win32 error code.
--*/
{
PDRIVE_LAYOUT_INFORMATION_EX layoutEx = NULL;
PDRIVE_LAYOUT_INFORMATION layout = NULL;
HANDLE handle = NULL;
DWORD bytesReturned;
DWORD dwError = NO_ERROR;
DWORD lenChars = 0;
BOOL restoreStr = FALSE;
WCHAR replaceChar;
WCHAR drive[ 64 ];
__try {
if ( !MpName || !Signature ) {
dwError = ERROR_INVALID_PARAMETER;
__leave;
}
*Signature = 0;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"GetSignatureForVolume: Checking mount point (%1!ws!) \n",
MpName );
#endif
//
// If mount point is of form x:\aaa\bbb, temporarily strip off the
// string to make it into a drive letter.
//
lenChars = wcslen( MpName );
if ( lenChars < 3 ) {
dwError = ERROR_INVALID_PARAMETER;
__leave;
}
if ( lenChars > 3 ) {
restoreStr = TRUE;
replaceChar = (WCHAR)*(MpName + CHAR_TO_REPLACE);
(WCHAR)*(MpName + CHAR_TO_REPLACE) = 0;
}
//
// Make the name into the form: \\?\x: [Note: no trailing backslash!]
//
ZeroMemory( drive, sizeof( drive ) );
wcscpy( drive, L"\\\\.\\" );
wcscat( drive, MpName );
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"GetSignatureForVolume: CreateFile using %1!ws! \n",
drive );
#endif
handle = CreateFileW( drive,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
if ( INVALID_HANDLE_VALUE == handle ) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"GetSignatureForVolume: CreateFile failed, error %1!u! \n",
dwError );
__leave;
}
//
// Try IOCTL_DISK_GET_DRIVE_LAYOUT_EX first. If it fails, try with
// IOCTL_DISK_GET_DRIVE_LAYOUT.
//
layoutEx = DoIoctlAndAllocate( handle,
IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
0,
0,
&bytesReturned );
if ( !layoutEx ) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"GetSignatureForVolume: IOCTL_DISK_GET_DRIVE_LAYOUT_EX failed, error %1!u! \n",
dwError );
//
// Try the old IOCTL...
//
layout = DoIoctlAndAllocate( handle,
IOCTL_DISK_GET_DRIVE_LAYOUT,
0,
0,
&bytesReturned );
if ( !layout ) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"GetSignatureForVolume: IOCTL_DISK_GET_DRIVE_LAYOUT failed, error %1!u! \n",
dwError );
//
// Fall through and cleanup.
//
} else {
//
// Get the signature from the returned structure and return it to
// the caller.
//
*Signature = layout->Signature;
//
// Have to set NO_ERROR here because the current value shows the
// first IOCTL that failed.
//
dwError = NO_ERROR;
}
} else {
//
// Get the signature from the returned structure and return it to
// the caller.
//
if ( PARTITION_STYLE_MBR == layoutEx->PartitionStyle ) {
*Signature = layoutEx->Mbr.Signature;
} else if ( PARTITION_STYLE_GPT == layoutEx->PartitionStyle ) {
//
// Since our signatures won't handle the GPT GUID, we have to
// simulate a signature.
//
*Signature = ClusterHashGuid(layoutEx->Gpt.DiskId);
}
}
} __finally {
if ( layoutEx ) {
free( layoutEx );
}
if ( layout ) {
free( layout );
}
if ( handle ) {
CloseHandle( handle );
}
//
// Restore string to original format.
//
if ( lenChars > 3 && restoreStr ) {
(WCHAR)*(MpName + CHAR_TO_REPLACE) = replaceChar;
}
}
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"GetSignatureForVolume: Returning signature %1!x! for mount point (%2!ws!) \n",
*Signature,
MpName );
#endif
return dwError;
} // GetSignatureForVolume
BOOL
GetOffsetFromPartNo(
DWORD PartitionNo,
PMOUNTIE_INFO Info,
PLARGE_INTEGER Offset
)
/*++
Routine Description:
Given the partition number and the drive layout, return the byte offset for the
specified partition.
Arguments:
PartitionNo - Supplies the partition number. Zero is invalid since partition zero
represents the entire disk.
Info - Pointer to MOUNTIE_INFO based on drive layout information.
Offset - Pointer to hold the returned byte offset for the partition. Space is
allocated by the caller.
Return Value:
TRUE if successful.
--*/
{
PMOUNTIE_PARTITION entry;
DWORD idx;
DWORD partitionCount;
BOOL retVal = FALSE;
if ( !PartitionNo || !Info || !Offset ) {
goto FnExit;
}
if ( 0 == Info->Volume ) {
goto FnExit;
}
#if DBG
(DiskpLogEvent)(
NULL, // ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"GetOffsetFromPartNo: partition %1!u! \n",
PartitionNo );
#endif
Offset->QuadPart = 0; // Offset of zero is invalid. This will indicate an error.
partitionCount = Info->Volume->PartitionCount;
entry = Info->Volume->Partition;
for ( idx = 0; idx < partitionCount; ++idx, ++entry) {
#if DBG
(DiskpLogEvent)(
NULL, // ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"GetOffsetFromPartNo: index %1!u! offset %2!x! \n",
idx,
entry->StartingOffset.LowPart );
#endif
if ( entry->PartitionNumber == PartitionNo ) {
Offset->QuadPart = entry->StartingOffset.QuadPart;
retVal = TRUE;
break;
}
}
FnExit:
return retVal;
} // GetOffsetFromPartNo
BOOL
GetPartNoFromOffset(
PLARGE_INTEGER Offset,
PMOUNTIE_INFO Info,
PDWORD PartitionNumber
)
/*++
Routine Description:
Given the offset and the drive layout, return the partition number for the specified offset.
Arguments:
Offset - Pointer to the byte offset.
Info - Pointer to MOUNTIE_INFO based on drive layout information.
PartitionNo - Pointer to hold the returned partition number. Space is allocated by the
caller.
Return Value:
TRUE if successful.
--*/
{
PMOUNTIE_PARTITION entry;
DWORD idx;
DWORD partitionCount;
BOOL retVal = FALSE;
if ( !Offset->QuadPart || !Info || !PartitionNumber) {
goto FnExit;
}
if ( 0 == Info->Volume ) {
goto FnExit;
}
*PartitionNumber = 0; // Partition zero is invalid. This will indicate an error.
partitionCount = Info->Volume->PartitionCount;
entry = Info->Volume->Partition;
for ( idx = 0; idx < partitionCount; ++idx, ++entry ) {
if ( entry->StartingOffset.QuadPart == Offset->QuadPart ) {
*PartitionNumber = entry->PartitionNumber;
retVal = TRUE;
break;
}
}
FnExit:
return retVal;
} // GetPartNoFromOffset
VOID
PrintStrList(
PDISK_RESOURCE ResourceEntry,
LPWSTR MultiSzList,
DWORD ListBytes
)
/*++
Routine Description:
Display the list in the cluster log.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
MultiSzList - REG_MULTI_SZ string
ListBytes - Number of bytes in MultiSzList, not number of WCHARs!
Return Value:
None.
--*/
{
PWSTR currentStr;
PWCHAR data;
LARGE_INTEGER offset;
DWORD currentStrLenChars = 0;
DWORD count;
if ( !ResourceEntry || !MultiSzList || 0 == ListBytes ) {
return;
}
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L" Offset String \n" );
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"================ ====================================== \n" );
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
currentStr = (PWCHAR)MultiSzList;
currentStrLenChars = wcslen( currentStr );
while ( currentStrLenChars ) {
data = NULL;
offset.QuadPart = 0;
//
// Convert the offset from a string to a large integer value.
//
count = swscanf( currentStr, L"%I64x ", &offset.QuadPart );
if ( 0 == count ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Error: Unable to parse offset from currentStr (%1!ws!) \n",
currentStr );
// Stop processing the list...
break;
}
//
// Data starts just after the first space.
//
data = wcschr( currentStr, SPACE_CHAR );
if ( !data || wcslen(data) < 3 ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Error: Unable to get mount point str from currentStr %1!ws! \n",
currentStr );
// Stop processing the list...
break;
}
//
// Skip past the space character. Note that the length was previously validated.
//
if ( SPACE_CHAR == *data ) {
data++;
}
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"%1!08X!%2!08X! %3!ws! \n", // couldn't get !I64X! to work...
offset.HighPart,
offset.LowPart,
data );
currentStr += currentStrLenChars + 1;
currentStrLenChars = wcslen( currentStr );
}
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"*** End of list *** \n" );
} // PrintStrList
static
DWORD
SetMPListThread(
LPVOID lpThreadParameter
)
/*++
Routine Description:
Mount point list update thread. Updates the cluster data base.
Arguments:
lpThreadParameter - stores ResourceEntry.
Return Value:
None
--*/
{
DWORD dwError;
PDISK_RESOURCE ResourceEntry = lpThreadParameter;
DWORD idx;
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: started.\n");
//
// Will die in 10 minutes if unsuccessful
//
for ( idx = 0; idx < 300; ++idx ) {
//
// Wait for either the terminate event or the timeout
//
dwError = WaitForSingleObject( DisksTerminateEvent, 2000 );
if ( WAIT_TIMEOUT == dwError ) {
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
#if DBG
DumpDiskInfoParams( ResourceEntry );
#endif
//
// Bug in ResUtilSetPropertyParameterBlock. It will update the cluster
// database with updated MULTI_SZ data, but it doesn't clear the values
// appropriately. Use ClusterRegDeleteValue to make sure the lists are
// cleared if they have been deleted.
//
if ( !ResourceEntry->DiskInfo.Params.MPVolGuids &&
0 == ResourceEntry->DiskInfo.Params.MPVolGuidsSize ) {
dwError = ClusterRegDeleteValue( ResourceEntry->ResourceParametersKey,
CLUSREG_NAME_PHYSDISK_MPVOLGUIDS );
}
//
// Timer expired. Update the cluster database.
//
dwError = ResUtilSetPropertyParameterBlock( ResourceEntry->ResourceParametersKey,
DiskResourcePrivateProperties,
NULL,
(LPBYTE) &ResourceEntry->DiskInfo.Params,
NULL,
0,
NULL );
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
if ( ERROR_SUCCESS == dwError ) {
//
// We're done.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: mount point info updated in cluster data base \n" );
break;
} else if ( ERROR_SHARING_PAUSED != dwError ) {
//
// If the drive is not yet online, we should have seen ERROR_SHARING_PAUSED. If
// we see any other error, something bad happened.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"SetMPListThread: Failed to update cluster data base, error = %1!u! \n",
dwError );
break;
}
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: Wait again for event or timeout, count %1!u! \n",
idx );
} else {
//
// The terminate event is possibly set.
//
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"SetMPListThread: WaitForSingleObject returned error = %1!u! \n",
dwError );
break;
}
}
//
// Thread ending, clear the flag.
//
InterlockedExchange( &ResourceEntry->MPInfo.MPUpdateThreadIsActive, 0 );
return(ERROR_SUCCESS);
} // SetMPListThread
DWORD
PostMPInfoIntoRegistry(
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Set the DiskResourcePrivateProperties in the cluster database. If the disk
is not yet online, create a thread to update the cluster database. The disk
might not be fully online if we are in the process of bringing the quorum disk
online and trying to update the mount point information.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
Win32 error code.
--*/
{
DWORD dwError;
//
// Update the cluster database.
//
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
#if DBG
DumpDiskInfoParams( ResourceEntry );
#endif
//
// Bug in ResUtilSetPropertyParameterBlock. It will update the cluster
// database with updated MULTI_SZ data, but it doesn't clear the values
// appropriately. Use ClusterRegDeleteValue to make sure the lists are
// cleared if they have been deleted.
//
if ( !ResourceEntry->DiskInfo.Params.MPVolGuids &&
0 == ResourceEntry->DiskInfo.Params.MPVolGuidsSize ) {
dwError = ClusterRegDeleteValue( ResourceEntry->ResourceParametersKey,
CLUSREG_NAME_PHYSDISK_MPVOLGUIDS );
}
dwError = ResUtilSetPropertyParameterBlock( ResourceEntry->ResourceParametersKey,
DiskResourcePrivateProperties,
NULL,
(LPBYTE) &ResourceEntry->DiskInfo.Params,
NULL,
0,
NULL );
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
//
// If the update failed and the disk is not yet online, it will fail with
// ERROR_SHARING_PAUSED. In this case, create a thread to update the cluster
// data base. Any other error or success should simply continue.
//
if ( ERROR_SHARING_PAUSED == dwError ) {
//
// Check if the thread is already active. If it is, exit with an error.
//
if ( InterlockedCompareExchange(
&ResourceEntry->MPInfo.MPUpdateThreadIsActive,
1, 0 ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"PostMPInfoIntoRegistry: MountPoint thread is already running \n" );
dwError = ERROR_ALREADY_EXISTS;
} else {
HANDLE thread;
DWORD threadId;
thread = CreateThread( NULL,
0,
SetMPListThread,
ResourceEntry,
0,
&threadId );
if ( NULL == thread ) {
//
// Thread creation failed. Log error, clear thread active flag,
// and return.
//
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"PostMPInfoIntoRegistry: CreateThread failed, error %1!u!\n",
dwError );
InterlockedExchange( &ResourceEntry->MPInfo.MPUpdateThreadIsActive, 0 );
} else {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"PostMPInfoIntoRegistry: Thread created \n" );
//
// Thread created. Indicate no error.
//
CloseHandle( thread );
dwError = ERROR_SUCCESS;
}
}
} else {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
( NO_ERROR == dwError ? LOG_INFORMATION : LOG_ERROR ),
L"PostMPInfoIntoRegistry: ResUtilSetPropertyParameterBlock returned %1!u! \n",
dwError );
}
return dwError;
} // PostMpInfoIntoRegistry
DWORD
WrapClusterResourceControl(
RESOURCE_HANDLE hResource,
DWORD dwControlCode,
LPVOID *OutBuffer,
DWORD *dwBytesReturned
)
/*++
Routine Description:
Wrap the call to ClusterResourceControl. This routine will allocate the
output buffer, call ClusterResourceControl, and return the address of the
output buffer to the caller.
The caller of this routine is responsible for freeing the output buffer.
Arguments:
hResource - Handle to a cluster resource of type PHYSICAL_DISK.
dwControlCode - The resource control code to be performed.
OutBuffer - Address to store the output buffer.
dwBytesReturned - Number of bytes in the allocated output buffer.
Return Value:
Win32 error code.
--*/
{
DWORD dwError;
DWORD cbOutBufferSize = MAX_PATH;
DWORD cbResultSize = MAX_PATH;
LPVOID tempOutBuffer = LocalAlloc( LPTR, cbOutBufferSize );
dwError = ClusterResourceControl( hResource,
NULL,
dwControlCode,
NULL,
0,
tempOutBuffer,
cbOutBufferSize,
&cbResultSize );
//
// Reallocation routine if buffer is too small
//
if ( ERROR_MORE_DATA == dwError )
{
LocalFree( tempOutBuffer );
cbOutBufferSize = cbResultSize;
tempOutBuffer = LocalAlloc( LPTR, cbOutBufferSize );
dwError = ClusterResourceControl( hResource,
NULL,
dwControlCode,
NULL,
0,
tempOutBuffer,
cbOutBufferSize,
&cbResultSize );
}
//
// On success, give the user the allocated buffer. The user is responsible
// for freeing this buffer. On failure, free the buffer and return a status.
//
if ( NO_ERROR == dwError ) {
*OutBuffer = tempOutBuffer;
*dwBytesReturned = cbResultSize;
} else {
*OutBuffer = NULL;
*dwBytesReturned = 0;
LocalFree( tempOutBuffer );
}
return dwError;
} // WrapClusterResourceControl
VOID
DisksMountPointCleanup(
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Cleanup everything the mount point code used.
This routine should be called in DisksClose.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
None.
--*/
{
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"DisksMountPointCleanup: Cleanup mount point information \n" );
//
// If existing MPVolGuids list, free it.
//
if ( ResourceEntry->DiskInfo.Params.MPVolGuids ) {
LocalFree( ResourceEntry->DiskInfo.Params.MPVolGuids );
ResourceEntry->DiskInfo.Params.MPVolGuidsSize = 0;
ResourceEntry->DiskInfo.Params.MPVolGuids = NULL;
}
ResourceEntry->MPInfo.Initialized = FALSE;
DeleteCriticalSection( &ResourceEntry->MPInfo.MPLock );
} // DisksMountPointCleanup
VOID
DisksMountPointInitialize(
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Prepare the mount point structures in the ResourceEntry for use.
This routine should be called in DisksOpen.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
None.
--*/
{
InitializeCriticalSection( &ResourceEntry->MPInfo.MPLock );
ResourceEntry->MPInfo.Initialized = TRUE;
InterlockedExchange( &ResourceEntry->MPInfo.MPUpdateThreadIsActive, 0 );
InterlockedExchange( &ResourceEntry->MPInfo.MPListCreateInProcess, 0 );
} // DisksMountPointInitialize
DWORD
DisksUpdateMPList(
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Validate the mount points.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
Win32 error code.
--*/
{
DWORD dwError = NO_ERROR;
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"DisksUpdateMPList: Processing PNP mountpoint notification \n" );
//
// Check if the MPList is in process of being updated. If it is, exit with an error.
//
if ( InterlockedCompareExchange(
&ResourceEntry->MPInfo.MPListCreateInProcess,
1, 0 ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"DisksUpdateMPList: Update in process, bypassing PNP notification \n" );
return ERROR_BUSY;
}
dwError = ValidateMountPoints( ResourceEntry );
InterlockedExchange( &ResourceEntry->MPInfo.MPListCreateInProcess, 0 );
return dwError;
} // DisksUpdateMPList
DWORD
DisksProcessMPControlCode(
PDISK_RESOURCE ResourceEntry,
DWORD ControlCode
)
/*++
Routine Description:
Process the disk mount point control code. Since we are in the thread
that handed us the control code (DisksResourceControl), we can't do
much except a separate thread to do the bulk of the mount point
processing.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
ControlCode - Cluster resource control for mount point processing.
Return Value:
--*/
{
HANDLE thread;
DWORD threadId;
DWORD dwError = NO_ERROR;
__try {
//
// Create a thread to update the mount point list. We don't need to
// copy the ResourceEntry as this pointer will be valid when the thread
// runs.
//
thread = CreateThread( NULL,
0,
DisksUpdateMPList,
ResourceEntry,
0,
&threadId );
if ( NULL == thread ) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"DisksProcessMPControlCode: CreateThread failed %1!u! \n",
dwError );
__leave;
}
//
// Thread created. Indicate no error.
//
CloseHandle( thread );
dwError = NO_ERROR;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"DisksProcessMPControlCode: Created thread to process control code \n" );
#endif
} __finally {
}
return dwError;
} // DisksProcessMPControlCode
DWORD
ValidateMountPoints(
IN OUT PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
For each partition on this disk, get the mountpoints directed toward this
partition. Check each mountpoint to make sure it is allowed. For those
mountpoints not allowed, write a message to system event log indicating
why it is an invalid mountpoint.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
ERROR_INVALID_DATA - Partition info stored in MountieInfo is invalid.
Win32 error code.
--*/
{
PMOUNTIE_PARTITION entry;
DWORD dwError = ERROR_SUCCESS;
DWORD nPartitions = MountiePartitionCount( &ResourceEntry->MountieInfo );
DWORD physicalDrive = ResourceEntry->DiskInfo.PhysicalDrive;
DWORD idx;
WCHAR szGlobalDiskPartName[MAX_PATH];
WCHAR szVolumeName[MAX_PATH];
ZeroMemory( szGlobalDiskPartName, sizeof(szGlobalDiskPartName) );
ZeroMemory( szVolumeName, sizeof(szVolumeName) );
//
// Check each interesting partition. Since only "valid" partitions are
// saved in the MountieInfo structure, we will only look at those (ignoring those
// partitions that are not NTFS).
//
for ( idx = 0; idx < nPartitions; ++idx ) {
entry = MountiePartition( &ResourceEntry->MountieInfo, idx );
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"ValidateMountPoints: index %1!u! entry %2!x! \n", idx, entry );
#endif
if ( !entry ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"ValidateMountPoints: no partition entry for index %1!u! \n", idx );
//
// Something bad happened to our data structures.
//
dwError = ERROR_INVALID_DATA;
break;
}
//
// Create the device name of the form:
// \\?\GLOBALROOT\Device\HarddiskX\PartitionY\ (uses trailing backslash)
//
_snwprintf( szGlobalDiskPartName,
MAX_PATH, // Number of CHARS, not bytes
GLOBALROOT_HARDDISK_PARTITION_FMT,
physicalDrive,
entry->PartitionNumber );
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"ValidateMountPoints: Using name (%1!ws!) \n",
szGlobalDiskPartName );
#endif
if ( !GetVolumeNameForVolumeMountPointW( szGlobalDiskPartName,
szVolumeName,
sizeof(szVolumeName)/sizeof(WCHAR) )) {
dwError = GetLastError();
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"ValidateMountPoints: GetVolumeNameForVolumeMountPoint for (%1!ws!) returned %2!u!\n",
szGlobalDiskPartName,
dwError );
break;
}
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"ValidateMountPoints: Returned volume name (%1!ws!) \n",
szVolumeName );
#endif
CheckMPsForVolume( ResourceEntry,
szVolumeName );
}
return dwError;
} // ValidateMountPoints
VOID
CheckMPsForVolume(
IN OUT PDISK_RESOURCE ResourceEntry,
IN PWSTR VolumeName
)
/*++
Routine Description:
For the specified volume, find all mount points directed towards this volume.
For each mountpoint, make sure it is allowed.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
VolumeName - Target volume for the mount point. Format is:
\\?\Volume{GUID}\ [Note trailing backslash!]
Return Value:
None.
--*/
{
PWSTR volumePaths = NULL;
PWSTR currentMP;
DWORD dwError;
__try {
//
// GetMountPoints will allocate a MultiSz buffer with
// all the mount points for this target volume.
//
dwError = GetMountPoints( VolumeName, &volumePaths );
if ( NO_ERROR != dwError || !volumePaths ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"CheckMPsForVolume: GetMountPoints returns %1!u! \n", dwError );
__leave;
}
//
// Loop through each mount point in the list.
//
// Each mount point will either be a mount point or a drive letter
// (which is actually a mount point). Format can be:
//
// x:\ [Note trailing backslash!]
// x:\some-mp-name\ [Note trailing backslash!]
// x:\some-dir\some-mp-name\ [Note trailing backslash!]
//
currentMP = volumePaths;
for (;;) {
IsMountPointAllowed( currentMP, VolumeName, ResourceEntry );
//
// Skip through current mount point to end of string.
//
while (*currentMP++);
//
// If next mount point is empty, the list is exhausted.
//
if (!*currentMP) {
break;
}
}
} __finally {
if ( volumePaths ) {
LocalFree( volumePaths );
}
}
} // CheckMPsForVolume
DWORD
GetMountPoints(
PWSTR VolumeName,
PWSTR *VolumePaths
)
/*++
Routine Description:
For the specified volume, find all mount points directed towards this volume.
The mount point buffer will be allocated by this routine and must be freed by
the caller.
Arguments:
VolumeName - Target volume for the mount point. Format is:
\\?\Volume{GUID}\ [Note trailing backslash!]
VolumePaths - Pointer to a MultiSz string containing all mount points directed
toward this volume. If there are no mount points, this pointer will
be set to NULL. The caller is responsible for freeing this buffer.
Return Value:
Win32 error code.
--*/
{
DWORD lenChars;
WCHAR messageBuffer[MAX_PATH];
PWSTR paths = NULL;
PWSTR currentMP;
DWORD dwError;
if ( !VolumeName || !VolumePaths ) {
return ERROR_INVALID_PARAMETER;
}
*VolumePaths = NULL;
//
// Determine the size of the buffer we need.
//
if ( !GetVolumePathNamesForVolumeName( VolumeName, NULL, 0, &lenChars ) ) {
dwError = GetLastError();
if ( ERROR_MORE_DATA != dwError ) {
return dwError;
}
}
//
// Allocate the mount point buffer.
//
paths = LocalAlloc( 0, lenChars * sizeof(WCHAR) );
if ( !paths ) {
dwError = GetLastError();
return dwError;
}
//
// Get the mount points.
//
if ( !GetVolumePathNamesForVolumeName( VolumeName, paths, lenChars, NULL ) ) {
dwError = GetLastError();
LocalFree( paths );
return dwError;
}
//
// If no mount points, free the buffer and return to the caller.
//
if ( !paths[0] ) {
LocalFree(paths);
//
// If no mount points for this volume, return no error and a NULL
// pointer to the mount point list.
//
return NO_ERROR;
}
*VolumePaths = paths;
return NO_ERROR;
} // GetMountPoints
DWORD
ValidateListOffsets(
IN OUT PDISK_RESOURCE ResourceEntry,
IN PWSTR MasterList
)
/*++
Routine Description:
Verify each entry in the list to make sure the byte offset
is valid. Also, count the number of entries to make sure
there are not too many entries saved (there should be one
VolGuid per node times the number of volumes on the disk).
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
MasterList - REG_MULTI_SZ list to be checked.
Return Value:
ERROR_INVALID_DATA - List contains at least one invalid byte offset
value, possibly more.
ERROR_INSUFFICIENT_BUFFER - List possibly corrupt as it contains too
many entries.
Win32 error code.
--*/
{
PWCHAR currentStr;
DWORD currentStrLenChars = 0;
DWORD dwError = NO_ERROR;
DWORD partitionNo;
DWORD numberOfEntries = 0;
DWORD count;
LARGE_INTEGER offset;
BOOL invalidOffset = FALSE;
EnterCriticalSection( &ResourceEntry->MPInfo.MPLock );
//
// Parse through the list.
//
for ( currentStr = (PWCHAR)MasterList,
currentStrLenChars = wcslen( currentStr ) ;
currentStrLenChars ;
currentStr += currentStrLenChars + 1,
currentStrLenChars = wcslen( currentStr ) ) {
offset.QuadPart = 0;
#if DBG
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"ValidateListOffsets: CurrentStr (%1!ws!), numChars %2!u! \n",
currentStr,
currentStrLenChars );
#endif
//
// Convert the offset from a string to a large integer value.
//
count = swscanf( currentStr, L"%I64x ", &offset.QuadPart );
if ( 0 == count ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"ValidateListOffsets: Unable to parse offset from currentStr (%1!ws!) \n",
currentStr );
numberOfEntries++;
continue;
}
//
// Convert the offset to a partition number.
//
if ( !GetPartNoFromOffset( &offset, &ResourceEntry->MountieInfo, &partitionNo ) ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"ValidateListOffsets: Unable to convert offset ( %1!08X!%2!08X! ) to partition number \n",
offset.HighPart,
offset.LowPart ); // couldn't get !I64X! to work...
invalidOffset = TRUE;
// As soon as we find an invalid partition number, we are done.
break;
}
numberOfEntries++;
}
if ( invalidOffset ) {
dwError = ERROR_INVALID_DATA;
} else if ( numberOfEntries > MAX_ALLOWED_VOLGUID_ENTRIES_PER_DISK ) {
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_WARNING,
L"ValidateListOffset: VolGuid list too large, %1!u! entries \n",
numberOfEntries );
#if USEMOUNTPOINTS_KEY
//
// See if the user wants to ignore the number of entries in VolGuid list.
//
if ( !(ResourceEntry->DiskInfo.Params.UseMountPoints & MPS_IGNORE_MAX_VOLGUIDS) ) {
//
// Log an error to system event log.
//
ClusResLogSystemEventByKey(ResourceEntry->ResourceKey,
LOG_UNUSUAL,
RES_DISK_MP_VOLGUID_LIST_EXCESSIVE );
dwError = ERROR_INSUFFICIENT_BUFFER;
}
#endif
}
LeaveCriticalSection( &ResourceEntry->MPInfo.MPLock );
return dwError;
} // ValidateListOffsets
BOOL
MPIsDriveLetter(
IN PWSTR MountPoint
)
/*++
Routine Description:
Determine if the mount point string is a drive letter. A drive letter will be
represented by a string of the form "x:\" with a length of 3.
Arguments:
MountPoint - Mount point string to be verified.
Return Value:
TRUE if the mount point string represents a drive letter.
--*/
{
DWORD lenChars;
lenChars = wcslen( MountPoint );
if ( 3 == lenChars &&
L':' == MountPoint[1] &&
L'\\' == MountPoint[2] &&
iswalpha( MountPoint[0] ) ) {
return TRUE;
}
return FALSE;
} // MPIsDriveLetter
#if DBG
//
// Debug helper routine
//
VOID
DumpDiskInfoParams(
PDISK_RESOURCE ResourceEntry
)
/*++
Routine Description:
Display in the cluster log interesting mountpoint information.
Arguments:
ResourceEntry - Pointer to the DISK_RESOURCE structure.
Return Value:
None.
--*/
{
#if 0 // Drive is not currently stored
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: Signature %1!x! Drive (%2!ws!) \n",
ResourceEntry->DiskInfo.Params.Signature,
ResourceEntry->DiskInfo.Params.Drive );
#endif
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: Signature %1!x! \n",
ResourceEntry->DiskInfo.Params.Signature );
#if USEMOUNTPOINTS_KEY
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: SkipChkdsk %1!x! ConditionalMount %2!x! UseMountPoints %3!x! \n",
ResourceEntry->DiskInfo.Params.SkipChkdsk,
ResourceEntry->DiskInfo.Params.ConditionalMount,
ResourceEntry->DiskInfo.Params.UseMountPoints );
#else
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: SkipChkdsk %1!x! ConditionalMount %2!x! \n",
ResourceEntry->DiskInfo.Params.SkipChkdsk,
ResourceEntry->DiskInfo.Params.ConditionalMount );
#endif
(DiskpLogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SetMPListThread: VolGuid list %1!x! VolGuid size %2!u! \n",
ResourceEntry->DiskInfo.Params.MPVolGuids,
ResourceEntry->DiskInfo.Params.MPVolGuidsSize );
} // DumpDiskInfoParams
#endif