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.
2311 lines
61 KiB
2311 lines
61 KiB
/*++
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
pnp
|
|
|
|
Abstract:
|
|
|
|
This module processes disk related PnP notifications
|
|
and tries to adjust partitions and drive letter information
|
|
accordingly.
|
|
|
|
Author:
|
|
|
|
Gor Nishanov (gorn) 21-Dec-1998
|
|
|
|
Environment:
|
|
|
|
User Mode
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#define UNICODE 1
|
|
#define INITGUID 1
|
|
#include <nt.h>
|
|
#include <ntdef.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
|
|
#include <dbt.h>
|
|
#include <devioctl.h>
|
|
#include <devguid.h>
|
|
#include <ioevent.h>
|
|
#include <stdio.h>
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <mountmgr.h>
|
|
#include <pnpmgr.h>
|
|
#include <setupapi.h>
|
|
|
|
//#include <windows.h>
|
|
|
|
#include "disksp.h"
|
|
#include "newmount.h"
|
|
#include "newdisks.h"
|
|
|
|
#define LOG_CURRENT_MODULE LOG_MODULE_DISK
|
|
|
|
static HWND DummyWindow = 0;
|
|
static BOOL PnPInitialized = FALSE;
|
|
static HANDLE NotificationWatcherThreadHandle;
|
|
|
|
static HANDLE PnpInterfacesRegistered;
|
|
|
|
static LONG VolumeListUpdateInProcess = 0;
|
|
|
|
RTL_RESOURCE PnpVolumeLock;
|
|
RTL_RESOURCE PnpWaitingListLock;
|
|
|
|
WCHAR g_DiskResource[] = L"rtPhysical Disk";
|
|
#define RESOURCE_TYPE ((RESOURCE_HANDLE)g_DiskResource)
|
|
|
|
extern PWCHAR GLOBALROOT_HARDDISK_PARTITION_FMT; // L"\\\\\?\\GLOBALROOT\\Device\\Harddisk%u\\Partition%u\\";
|
|
|
|
LIST_ENTRY WaitingDisks;
|
|
|
|
typedef struct _WAITING_DISK {
|
|
LIST_ENTRY ListEntry;
|
|
PDISK_RESOURCE ResourceEntry;
|
|
HANDLE Event;
|
|
DWORD Signature;
|
|
ULONG PartitionCount;
|
|
} WAITING_DISK, *PWAITING_DISK;
|
|
|
|
#define AcquireShared( _res_lock ) \
|
|
RtlAcquireResourceShared( _res_lock, TRUE );
|
|
|
|
#define ReleaseShared( _res_lock ) \
|
|
RtlReleaseResource( _res_lock );
|
|
|
|
#define AcquireExclusive( _res_lock ) \
|
|
RtlAcquireResourceExclusive( _res_lock, TRUE );
|
|
|
|
#define ReleaseExclusive( _res_lock ) \
|
|
RtlReleaseResource( _res_lock );
|
|
|
|
|
|
DWORD
|
|
NotificationWatcherThread(
|
|
IN LPVOID
|
|
);
|
|
|
|
VOID
|
|
ProcessMountPointChange(
|
|
HDEVNOTIFY devNotify
|
|
);
|
|
|
|
PWAITING_DISK
|
|
FindWaitingDisk(
|
|
DWORD Signature
|
|
);
|
|
|
|
DWORD
|
|
GetVolName(
|
|
PWCHAR Name,
|
|
PWCHAR *VolGuid
|
|
);
|
|
|
|
DWORD
|
|
StartNotificationWatcherThread(
|
|
VOID)
|
|
{
|
|
DWORD status = ERROR_SUCCESS;
|
|
HANDLE thread;
|
|
|
|
if ( InterlockedCompareExchange(&PnPInitialized, TRUE, FALSE) ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_WARNING,
|
|
L"[PnP] PnP was already initialized.\n",
|
|
status );
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
PnpInterfacesRegistered = NULL;
|
|
PnpInterfacesRegistered = CreateEvent( NULL, // security attributes
|
|
TRUE, // manual reset
|
|
FALSE, // initial state nonsignaled
|
|
NULL ); // event name
|
|
|
|
if ( NULL == PnpInterfacesRegistered ) {
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_WARNING,
|
|
L"[PnP] Unable to create event for PnP interface registration. \n",
|
|
status );
|
|
status = ERROR_SUCCESS;
|
|
}
|
|
|
|
thread =
|
|
CreateThread( NULL, // security attributes
|
|
0, // stack_size = default
|
|
NotificationWatcherThread,
|
|
(LPVOID)0, // no parameters
|
|
0, // runs immediately
|
|
0 ); // don't need thread id
|
|
if(thread == NULL) {
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] StartNotificationWatcherThread failed, error: %1!u!. \n",
|
|
status );
|
|
} else {
|
|
|
|
if ( NULL != PnpInterfacesRegistered ) {
|
|
|
|
//
|
|
// Before returning to caller, make sure all PnP interfaces
|
|
// are registered.
|
|
//
|
|
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Waiting for PnP interface registration to complete.\n" );
|
|
|
|
status = WaitForSingleObject( PnpInterfacesRegistered, 30 * 1000 );
|
|
|
|
if ( WAIT_TIMEOUT == status ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] PnP interface registration failed to complete in time, error: %1!u! \n",
|
|
status );
|
|
}
|
|
|
|
CloseHandle( PnpInterfacesRegistered );
|
|
PnpInterfacesRegistered = NULL;
|
|
|
|
status = ERROR_SUCCESS;
|
|
}
|
|
|
|
}
|
|
NotificationWatcherThreadHandle = thread;
|
|
|
|
return status;
|
|
}
|
|
|
|
VOID
|
|
StopNotificationWatcher(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handler for console control events
|
|
|
|
Arguments:
|
|
|
|
dwCtrlType - Indicates the console event to handle.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the event was handled, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HANDLE localHandle = NotificationWatcherThreadHandle;
|
|
if (DummyWindow) {
|
|
PostMessage(DummyWindow, WM_QUIT, 0, 0);
|
|
if (localHandle) {
|
|
WaitForSingleObject(localHandle, 10 * 1000);
|
|
CloseHandle(localHandle);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define WM_WatchDisk (WM_USER + 1)
|
|
#define WM_StopWatchingDisk (WM_USER + 2)
|
|
|
|
VOID
|
|
WatchDisk(
|
|
IN PDISK_RESOURCE ResourceEntry
|
|
)
|
|
{
|
|
if (DummyWindow) {
|
|
PostMessage(DummyWindow, WM_WatchDisk, 0, (LPARAM)ResourceEntry);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
StopWatchingDisk(
|
|
IN PDISK_RESOURCE ResourceEntry
|
|
)
|
|
{
|
|
if (DummyWindow) {
|
|
SendMessage(DummyWindow, WM_StopWatchingDisk, 0, (LPARAM)ResourceEntry);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
VOID
|
|
MyUnregisterDeviceNotification(HDEVNOTIFY hNotify)
|
|
{
|
|
#if DBG
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Unregistering device notification - HDEVNOTIFY %1!x! \n",
|
|
hNotify );
|
|
#endif
|
|
|
|
UnregisterDeviceNotification( hNotify );
|
|
}
|
|
|
|
HDEVNOTIFY
|
|
MyRegisterDeviceNotification(
|
|
IN HANDLE hRecipient,
|
|
IN LPVOID NotificationFilter,
|
|
IN DWORD Flags
|
|
)
|
|
{
|
|
|
|
#if DBG
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Registering device notification - Recipient %1!x! Flags %2!x! \n",
|
|
hRecipient,
|
|
Flags );
|
|
#endif
|
|
|
|
return RegisterDeviceNotification( hRecipient,
|
|
NotificationFilter,
|
|
Flags
|
|
);
|
|
}
|
|
|
|
DWORD
|
|
RegisterDeviceHandle(
|
|
IN HANDLE wnd,
|
|
IN HANDLE device,
|
|
OUT HDEVNOTIFY *devNotify)
|
|
{
|
|
DEV_BROADCAST_HANDLE DbtHandle;
|
|
DWORD status = ERROR_SUCCESS;
|
|
*devNotify = 0;
|
|
|
|
ZeroMemory(&DbtHandle,sizeof(DEV_BROADCAST_HANDLE));
|
|
|
|
DbtHandle.dbch_size = sizeof(DEV_BROADCAST_HANDLE);
|
|
DbtHandle.dbch_devicetype = DBT_DEVTYP_HANDLE;
|
|
DbtHandle.dbch_handle = device;
|
|
|
|
|
|
*devNotify = MyRegisterDeviceNotification(
|
|
(HANDLE)wnd,
|
|
&DbtHandle,
|
|
DEVICE_NOTIFY_WINDOW_HANDLE
|
|
);
|
|
if (!*devNotify) {
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] DBT_DEVTYP_HANDLE failed, error %1!u!\n",
|
|
status );
|
|
}
|
|
return status;
|
|
}
|
|
|
|
DWORD
|
|
RegisterDeviceInterface(
|
|
IN HANDLE wnd,
|
|
IN const GUID * guid,
|
|
OUT HDEVNOTIFY *devNotify)
|
|
{
|
|
DEV_BROADCAST_DEVICEINTERFACE filter;
|
|
DWORD status = ERROR_SUCCESS;
|
|
*devNotify = 0;
|
|
|
|
ZeroMemory(&filter, sizeof(filter));
|
|
filter.dbcc_size = sizeof(filter);
|
|
filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
|
|
CopyMemory(&filter.dbcc_classguid, guid, sizeof(filter.dbcc_classguid));
|
|
|
|
*devNotify = MyRegisterDeviceNotification(
|
|
(HANDLE)wnd,
|
|
&filter,
|
|
DEVICE_NOTIFY_WINDOW_HANDLE
|
|
);
|
|
if (!*devNotify) {
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] DBT_DEVTYP_DEVICEINTERFACE failed, error %1!u!\n",
|
|
status );
|
|
}
|
|
return status;
|
|
}
|
|
|
|
///////////// Forward Declarations /////////////////
|
|
typedef struct _VOLUME *PVOLUME;
|
|
|
|
VOID
|
|
PokeDiskResource(
|
|
PVOLUME vol
|
|
);
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Updates ClusterRegistry info if necessary
|
|
|
|
Arguments:
|
|
|
|
Volume of interest (used only to get the disk signature)
|
|
Updates a per disk basis
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
GetVolumeInfo(
|
|
PVOLUME Vol,
|
|
PHANDLE FileHandle
|
|
);
|
|
|
|
|
|
///////////// End Forward Declarations /////////////
|
|
|
|
|
|
////////////// Notification List Management //////////////////////////////
|
|
//
|
|
// We maintain a list of all volumes we are getting PnP notifications for
|
|
//
|
|
// PVOLUME FindVolume(HDEVNOTIFY Key);
|
|
// VOID DestroyVolume(PVOLUME vol);
|
|
// VOID RemoveVolume(HDEVNOTIFY devNotify);
|
|
// VOID AddVolume(PWCHAR Name)
|
|
//
|
|
LIST_ENTRY VolumeList;
|
|
|
|
typedef struct _VOLUME {
|
|
LIST_ENTRY ListEntry;
|
|
HDEVNOTIFY DevNotify;
|
|
DWORD Signature;
|
|
LARGE_INTEGER PartOffset;
|
|
LARGE_INTEGER PartLength;
|
|
ULONG PartNo;
|
|
BYTE PartitionType;
|
|
UCHAR DriveLetter;
|
|
WCHAR Name[1];
|
|
} VOLUME;
|
|
|
|
|
|
PVOLUME
|
|
FindVolume(HDEVNOTIFY Key)
|
|
{
|
|
PLIST_ENTRY entry;
|
|
for ( entry = VolumeList.Flink;
|
|
entry != &VolumeList;
|
|
entry = entry->Flink
|
|
)
|
|
{
|
|
PVOLUME vol = CONTAINING_RECORD(
|
|
entry,
|
|
VOLUME,
|
|
ListEntry
|
|
);
|
|
|
|
if (vol->DevNotify == Key) {
|
|
return(vol);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
VOID
|
|
DestroyVolume(
|
|
PVOLUME vol)
|
|
{
|
|
// (DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
// L"Destroying entry for %1!s!\n", vol->Name);
|
|
MyUnregisterDeviceNotification(vol->DevNotify);
|
|
LocalFree(vol);
|
|
}
|
|
|
|
VOID
|
|
RemoveVolume(HDEVNOTIFY devNotify)
|
|
{
|
|
PVOLUME vol = NULL;
|
|
|
|
// Use a lock here as the online thread might be parsing the volume list.
|
|
|
|
AcquireExclusive( &PnpVolumeLock );
|
|
|
|
vol = FindVolume( devNotify );
|
|
if (!vol) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] RemoveVolume: devNotify %1!d! is not in the list\n", devNotify);
|
|
ReleaseExclusive( &PnpVolumeLock );
|
|
return;
|
|
}
|
|
|
|
PokeDiskResource(vol);
|
|
|
|
RemoveEntryList(&vol->ListEntry);
|
|
ReleaseExclusive( &PnpVolumeLock );
|
|
DestroyVolume(vol);
|
|
}
|
|
|
|
|
|
VOID
|
|
AddVolume(
|
|
PWCHAR Name
|
|
)
|
|
{
|
|
PWAITING_DISK waitDisk;
|
|
PLIST_ENTRY entry;
|
|
PVOLUME volList;
|
|
PVOLUME vol = NULL;
|
|
PWCHAR volGuid = NULL;
|
|
|
|
DWORD status;
|
|
DWORD signature;
|
|
|
|
INT len;
|
|
|
|
HANDLE fileHandle;
|
|
|
|
BOOL duplicateEntry;
|
|
BOOL keepVolume = FALSE;
|
|
|
|
//
|
|
// Convert name to VolGuid name. If name is already a VolGuid
|
|
// name, the correct name will be returned. GetVolName will
|
|
// always return a name with a trailing backslash.
|
|
//
|
|
|
|
status = GetVolName( Name, &volGuid );
|
|
|
|
if ( ERROR_SUCCESS != status || !volGuid ) {
|
|
goto FnExit;
|
|
}
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: Attempting to add volume %1!s!\n", volGuid );
|
|
|
|
len = wcslen(volGuid);
|
|
vol = LocalAlloc(LPTR, sizeof(VOLUME) + len * sizeof(WCHAR));
|
|
|
|
if ( NULL == vol ) {
|
|
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_ERROR,
|
|
L"[PnP] AddVolume: can't alloc VOL+%1!d!, error %2!u!\n", len, status );
|
|
|
|
goto FnExit;
|
|
}
|
|
|
|
ZeroMemory( vol, sizeof(VOLUME) + len * sizeof(WCHAR) );
|
|
wcscpy(vol->Name, volGuid);
|
|
|
|
//
|
|
// Skip CDROM devices. This requires a trailing backslash and
|
|
// prefix \\?\.
|
|
//
|
|
|
|
if ( DRIVE_CDROM == GetDriveType( vol->Name ) ) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: Skipping CDROM volume %1!s!\n", vol->Name );
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Skip floppy devices. This requires a trailing backslash and
|
|
// prefix \\?\.
|
|
//
|
|
|
|
if ( DRIVE_REMOVABLE == GetDriveType( vol->Name ) ) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: Skipping floppy volume %1!s!\n", vol->Name );
|
|
goto FnExit;
|
|
}
|
|
|
|
if (len > 0 && vol->Name[len-1] == L'\\')
|
|
{
|
|
// remove trailing backslash
|
|
vol->Name[len-1] = 0;
|
|
}
|
|
|
|
if (len > 2 && vol->Name[0] == L'\\' && vol->Name[1] == L'\\') {
|
|
// Convert to NT file name
|
|
vol->Name[1] = L'?';
|
|
}
|
|
|
|
//
|
|
// Make sure the volume isn't already in the list. If so,
|
|
// skip it.
|
|
//
|
|
|
|
duplicateEntry = FALSE;
|
|
AcquireShared( &PnpVolumeLock );
|
|
|
|
len = wcslen( vol->Name );
|
|
for ( entry = VolumeList.Flink;
|
|
entry != &VolumeList;
|
|
entry = entry->Flink
|
|
)
|
|
{
|
|
volList = CONTAINING_RECORD( entry,
|
|
VOLUME,
|
|
ListEntry
|
|
);
|
|
|
|
if ( ( len == wcslen( volList->Name) ) &&
|
|
( 0 == _wcsnicmp( vol->Name, volList->Name, len ) ) ) {
|
|
|
|
duplicateEntry = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ReleaseShared( &PnpVolumeLock );
|
|
|
|
if ( duplicateEntry ) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: Skipping duplicate volume %1!s!\n", vol->Name );
|
|
goto FnExit;
|
|
}
|
|
|
|
status = GetVolumeInfo( vol, &fileHandle );
|
|
|
|
//
|
|
// We might have a clustered disk now, but we can't read the
|
|
// partition info or drive layout because the disk is reserved
|
|
// by another node.
|
|
//
|
|
// If the disk is reserved by another node, we typically see
|
|
// this returned:
|
|
// 170 ERROR_BUSY
|
|
// If the disk is offline, we can see this:
|
|
// 2 ERROR_FILE_NOT_FOUND
|
|
//
|
|
// About all we know for sure is that if this is a non-fixed device,
|
|
// ERROR_INVALID_FUNCTION will be returned. For now, skip these
|
|
// devices and track any other volumes coming through.
|
|
//
|
|
|
|
if ( ERROR_INVALID_FUNCTION == status ) {
|
|
|
|
if ( INVALID_HANDLE_VALUE != fileHandle) {
|
|
DevfileClose( fileHandle );
|
|
}
|
|
|
|
// Change this from LOG_ERROR to LOG_INFORMATION. This thread gets
|
|
// notified when non-fixed disks arrive (i.e. floppy), so logging
|
|
// an error for a floppy disk is misleading.
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: Skipping volume %1!ws! \n",
|
|
vol->Name);
|
|
|
|
goto FnExit;
|
|
}
|
|
|
|
if ( INVALID_HANDLE_VALUE == fileHandle ) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_WARNING,
|
|
L"[PnP] AddVolume: Unable to get volume handle (%1!ws!), error %2!u!\n",
|
|
vol->Name, status);
|
|
|
|
goto FnExit;
|
|
}
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: adding volume %1!s!\n", vol->Name );
|
|
|
|
status = RegisterDeviceHandle(DummyWindow, fileHandle, &vol->DevNotify);
|
|
DevfileClose( fileHandle );
|
|
|
|
if (status != ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_ERROR,
|
|
L"[PnP] AddVolume: RDN(%1!ws!), error %2!u!\n",
|
|
vol->Name,
|
|
status);
|
|
goto FnExit;
|
|
}
|
|
|
|
GetAssignedLetter(vol->Name, &vol->DriveLetter);
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: %1!s! '%2!c!', %3!d! (%4!u!)\n",
|
|
Name, (vol->DriveLetter)?vol->DriveLetter:' ', vol->PartitionType, vol->DevNotify);
|
|
|
|
// Use a lock here as the online thread might be parsing the volume list.
|
|
|
|
// As soon as the volume is added to the list, another thread could come
|
|
// through and remove it. Save the signature to a local variable so
|
|
// we can check the waiting list.
|
|
|
|
signature = vol->Signature;
|
|
keepVolume = TRUE;
|
|
AcquireExclusive( &PnpVolumeLock );
|
|
InsertTailList(&VolumeList, &vol->ListEntry);
|
|
ReleaseExclusive( &PnpVolumeLock );
|
|
|
|
AcquireShared( &PnpWaitingListLock );
|
|
waitDisk = FindWaitingDisk( signature );
|
|
if ( waitDisk ) {
|
|
|
|
//
|
|
// We have a waiting disk that matches this volume signature.
|
|
// Now see if all the volumes are in the volume list.
|
|
//
|
|
|
|
if ( IsDiskInPnpVolumeList( waitDisk->ResourceEntry, FALSE ) ) {
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: All volumes present, signal event for signature %1!x!\n",
|
|
signature );
|
|
|
|
//
|
|
// All volumes present, signal the event.
|
|
//
|
|
|
|
SetEvent( waitDisk->Event );
|
|
|
|
} else {
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: All volumes not ready for signature %1!x!\n",
|
|
signature );
|
|
}
|
|
} else {
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] AddVolume: Online request not queued for signature %1!x!\n",
|
|
signature );
|
|
|
|
}
|
|
|
|
ReleaseShared( &PnpWaitingListLock );
|
|
|
|
FnExit:
|
|
|
|
if ( volGuid ) {
|
|
LocalFree( volGuid );
|
|
}
|
|
|
|
if ( !keepVolume && vol ) {
|
|
LocalFree( vol );
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
GetVolName(
|
|
PWCHAR Name,
|
|
PWCHAR *VolGuid
|
|
)
|
|
{
|
|
PWCHAR volName = NULL;
|
|
PWCHAR tempName = NULL;
|
|
|
|
DWORD volNameLenBytes;
|
|
DWORD tempNameLenBytes;
|
|
DWORD nameLen;
|
|
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
|
|
if ( VolGuid ) {
|
|
*VolGuid = NULL;
|
|
}
|
|
|
|
#if DBG
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] GetVolName: Name %1!s!\n", Name );
|
|
#endif
|
|
|
|
nameLen = wcslen( Name );
|
|
|
|
//
|
|
// Create a buffer with room for a backslash.
|
|
//
|
|
|
|
tempNameLenBytes = ( nameLen * sizeof(WCHAR) ) + sizeof(UNICODE_NULL) + sizeof(WCHAR);
|
|
|
|
|
|
tempName = LocalAlloc( LPTR, tempNameLenBytes );
|
|
|
|
if ( !tempName ) {
|
|
dwError = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_WARNING,
|
|
L"[PnP] GetVolName: LocalAlloc for tempName failed, error %1!d! \n",
|
|
dwError );
|
|
goto FnExit;
|
|
}
|
|
|
|
wcsncpy( tempName, Name, nameLen );
|
|
|
|
//
|
|
// Add trailing backslash.
|
|
//
|
|
|
|
if ( nameLen > 0 && tempName[nameLen-1] != L'\\' ) {
|
|
//
|
|
// This is safe because temporary buffer is larger than
|
|
// original buffer.
|
|
//
|
|
tempName[nameLen] = L'\\';
|
|
}
|
|
|
|
#if DBG
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] GetVolName: tempName %1!s!\n", tempName );
|
|
#endif
|
|
|
|
volNameLenBytes = MAX_PATH * sizeof(WCHAR);
|
|
volName = LocalAlloc( LPTR, volNameLenBytes );
|
|
|
|
if ( !volName ) {
|
|
dwError = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_WARNING,
|
|
L"[PnP] GetVolName: LocalAlloc for volName failed, error %1!d! \n",
|
|
dwError );
|
|
goto FnExit;
|
|
}
|
|
|
|
if ( !GetVolumeNameForVolumeMountPointW( tempName,
|
|
volName,
|
|
volNameLenBytes / sizeof(WCHAR) ) ) {
|
|
dwError = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_WARNING,
|
|
L"[PnP] GetVolName: GetVolumeNameForVolumeMountPoint failed, error %1!d! \n",
|
|
dwError );
|
|
goto FnExit;
|
|
}
|
|
|
|
if ( VolGuid ) {
|
|
*VolGuid = volName;
|
|
}
|
|
|
|
FnExit:
|
|
|
|
if ( dwError != ERROR_SUCCESS && volName ) {
|
|
LocalFree( volName );
|
|
}
|
|
|
|
if ( tempName ) {
|
|
LocalFree( tempName );
|
|
}
|
|
|
|
#if DBG
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] GetVolName: returns error %1!d!\n", dwError );
|
|
#endif
|
|
|
|
return dwError;
|
|
|
|
} // GetVolName
|
|
|
|
|
|
///////////////////// VolumeManagement code ends //////////////////////////////////////////
|
|
|
|
//////////////////// WatchedDiskTable //////////////////////
|
|
//
|
|
// We maintain a table of disks that are currently online
|
|
// and under cluster control. Any PnP notification
|
|
// coming for the volumes belonging to these disks,
|
|
// need to be processed and cluster registry might need
|
|
// to be updated
|
|
//
|
|
PDISK_RESOURCE WatchedDiskTable[MAX_DISKS] = {0};
|
|
INT WatchedDiskCount = 0;
|
|
|
|
INT
|
|
FindDisk(DWORD Signature)
|
|
{
|
|
INT i;
|
|
|
|
if ( !Signature ) {
|
|
return -1;
|
|
}
|
|
|
|
for(i = 0; i < WatchedDiskCount; ++i) {
|
|
if (WatchedDiskTable[i]->DiskInfo.Params.Signature == Signature) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
VOID
|
|
RemoveDisk(
|
|
PDISK_RESOURCE ResourceEntry
|
|
)
|
|
{
|
|
INT i = FindDisk(ResourceEntry->DiskInfo.Params.Signature);
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_INFORMATION,
|
|
L"[PnP] Stop watching disk %1!x!\n",
|
|
ResourceEntry->DiskInfo.Params.Signature );
|
|
|
|
if (i < 0) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_WARNING,
|
|
L"[PnP] RemoveDisk: disk %1!x! not found\n",
|
|
ResourceEntry->DiskInfo.Params.Signature);
|
|
return;
|
|
}
|
|
--WatchedDiskCount;
|
|
if (WatchedDiskCount > 0) {
|
|
WatchedDiskTable[i] = WatchedDiskTable[WatchedDiskCount];
|
|
}
|
|
}
|
|
|
|
VOID
|
|
MarkMatchingPartition(
|
|
PVOLUME Volume,
|
|
PDRIVE_LAYOUT_INFORMATION driveLayout)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds a partition in DRIVE_LAYOUT_INFORMATION corresponding to
|
|
the Volume in question and marks it.
|
|
This routine is used in the code that verifies that there is a
|
|
volume in the VolumeList for every recognized partition on the disk.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
PPARTITION_INFORMATION p = driveLayout->PartitionEntry;
|
|
PPARTITION_INFORMATION end = p + driveLayout->PartitionCount;
|
|
|
|
for(;p < end; ++p)
|
|
{
|
|
if(p->RecognizedPartition &&
|
|
p->StartingOffset.QuadPart == Volume->PartOffset.QuadPart &&
|
|
p->PartitionLength.QuadPart == Volume->PartLength.QuadPart)
|
|
{
|
|
p->PartitionType = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
AddDisk(
|
|
PDISK_RESOURCE ResourceEntry
|
|
)
|
|
{
|
|
INT i = FindDisk(ResourceEntry->DiskInfo.Params.Signature);
|
|
PDRIVE_LAYOUT_INFORMATION driveLayout;
|
|
HANDLE fileHandle;
|
|
WCHAR deviceName[MAX_PATH];
|
|
PLIST_ENTRY entry;
|
|
BOOL success;
|
|
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_INFORMATION,
|
|
L"[PnP] Start watching disk %1!x!\n",
|
|
ResourceEntry->DiskInfo.Params.Signature );
|
|
|
|
if (i >= 0) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_ERROR,
|
|
L"[PnP] AddDisk: disk %1!x! is already being watched\n",
|
|
ResourceEntry->DiskInfo.Params.Signature);
|
|
return;
|
|
}
|
|
if (WatchedDiskCount >= MAX_DISKS) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_ERROR,
|
|
L"[PnP] AddDisk: Disk limit is reached\n");
|
|
return;
|
|
}
|
|
WatchedDiskTable[WatchedDiskCount++] = ResourceEntry;
|
|
|
|
// Now we need to verify that we are watching for changes on every //
|
|
// recognized partition on this drive //
|
|
|
|
wsprintf( deviceName, L"\\\\.\\PhysicalDrive%d", ResourceEntry->DiskInfo.PhysicalDrive );
|
|
fileHandle = CreateFile(deviceName+0,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
if (fileHandle == INVALID_HANDLE_VALUE) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_WARNING,
|
|
L"[PnP] AddDisk: Can't open %1!s!\n", deviceName);
|
|
return;
|
|
}
|
|
|
|
success = ClRtlGetDriveLayoutTable(fileHandle, &driveLayout, 0);
|
|
CloseHandle( fileHandle );
|
|
|
|
if ( !success ) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_ERROR,
|
|
L"[PnP] AddDisk: Error performing GetDriveLayout; error %1!d!\n",
|
|
GetLastError() );
|
|
return;
|
|
}
|
|
|
|
// Clear PartitionType field. We will be using it to mark partions
|
|
// which are in the our list of watched volumes
|
|
|
|
for (i = 0; i < (INT)driveLayout->PartitionCount; ++i) {
|
|
driveLayout->PartitionEntry[i].PartitionType = 0;
|
|
}
|
|
|
|
// Walk the list of all volumes and mark if this volume is in the partition table //
|
|
for ( entry = VolumeList.Flink;
|
|
entry != &VolumeList;
|
|
entry = entry->Flink
|
|
)
|
|
{
|
|
PVOLUME vol = CONTAINING_RECORD(
|
|
entry,
|
|
VOLUME,
|
|
ListEntry
|
|
);
|
|
|
|
if (vol->Signature == driveLayout->Signature) {
|
|
MarkMatchingPartition(vol, driveLayout);
|
|
}
|
|
}
|
|
|
|
// Now all partitions that are in our list is marked
|
|
// We need to add all unmarked partitions to the list
|
|
|
|
for (i = 0; i < (INT)driveLayout->PartitionCount; ++i) {
|
|
if (driveLayout->PartitionEntry[i].PartitionType == 0
|
|
&& driveLayout->PartitionEntry[i].RecognizedPartition
|
|
)
|
|
{
|
|
swprintf( deviceName, GLOBALROOT_HARDDISK_PARTITION_FMT,
|
|
ResourceEntry->DiskInfo.PhysicalDrive,
|
|
driveLayout->PartitionEntry[i].PartitionNumber);
|
|
AddVolume( deviceName );
|
|
}
|
|
}
|
|
|
|
LocalFree( driveLayout );
|
|
}
|
|
//////////////////// WatchedDiskTable management end //////////////////////
|
|
|
|
|
|
|
|
void PokeDiskResource(
|
|
PVOLUME vol)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Updates ClusterRegistry info if necessary
|
|
|
|
Arguments:
|
|
|
|
Volume of interest (used only to get the disk signature)
|
|
Updates a per disk basis
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
INT i = FindDisk(vol->Signature);
|
|
PDISK_RESOURCE ResourceEntry;
|
|
MOUNTIE_INFO Info;
|
|
HANDLE fileHandle;
|
|
DWORD status;
|
|
PVOID OldMountieVolume;
|
|
WCHAR deviceName[MAX_PATH];
|
|
|
|
if(i == -1) {
|
|
return;
|
|
}
|
|
|
|
ResourceEntry = WatchedDiskTable[i];
|
|
if( ResourceEntry->MountieInfo.UpdateThreadIsActive ) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_WARNING,
|
|
L"[PnP] PokeDiskResource: ClusApi is read only. PnP request ignored\n");
|
|
return;
|
|
}
|
|
|
|
ZeroMemory( &Info, sizeof(Info) );
|
|
|
|
wsprintf( deviceName, L"\\\\.\\PhysicalDrive%d", ResourceEntry->DiskInfo.PhysicalDrive );
|
|
fileHandle = CreateFile(deviceName+0,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
if (fileHandle == INVALID_HANDLE_VALUE) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_WARNING,
|
|
L"[PnP] PokeDiskResource: Can't open %1!s!\n", deviceName);
|
|
return;
|
|
}
|
|
|
|
status = MountieRecreateVolumeInfoFromHandle(
|
|
fileHandle,
|
|
ResourceEntry->MountieInfo.HarddiskNo,
|
|
0,
|
|
&Info);
|
|
CloseHandle(fileHandle);
|
|
|
|
if (status != ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_WARNING,
|
|
L"[PnP] PokeDiskResource: Can't read partition table, error %1!d!\n", status);
|
|
return;
|
|
}
|
|
|
|
MountiePrint(&Info, ResourceEntry->ResourceHandle);
|
|
|
|
status = VolumesReady(&Info, ResourceEntry);
|
|
|
|
if ( status != ERROR_SUCCESS ) {
|
|
(DiskpLogEvent)(ResourceEntry->ResourceHandle, LOG_WARNING,
|
|
L"[PnP] PokeDiskResource: Volumes not ready, error %1!d!\n", status);
|
|
MountieCleanup(&Info);
|
|
return;
|
|
}
|
|
|
|
MountieVerify(&Info, ResourceEntry, TRUE);
|
|
|
|
ResourceEntry->MountieInfo.DriveLetters = Info.DriveLetters;
|
|
OldMountieVolume = InterlockedExchangePointer(&ResourceEntry->MountieInfo.Volume, Info.Volume);
|
|
Info.Volume = OldMountieVolume;
|
|
ResourceEntry->MountieInfo.NeedsUpdate = Info.NeedsUpdate;
|
|
ResourceEntry->MountieInfo.VolumeStructSize = Info.VolumeStructSize;
|
|
|
|
MountiePrint(&ResourceEntry->MountieInfo, ResourceEntry->ResourceHandle);
|
|
MountieUpdate(&ResourceEntry->MountieInfo, ResourceEntry);
|
|
|
|
MountieCleanup(&Info);
|
|
}
|
|
|
|
//
|
|
// [HACKHACK] Currently, there is not polically correct way
|
|
// for the resource to learn whether it is a quorum resource or not
|
|
//
|
|
DWORD
|
|
GetQuorumSignature(
|
|
OUT PDWORD QuorumSignature)
|
|
{
|
|
WCHAR buf[MAX_PATH];
|
|
WCHAR guid[ sizeof(GUID) * 3 + 1];
|
|
// 2 character per byte + 1, in case somebody will put a dash //
|
|
// between every byte //
|
|
|
|
DWORD BufSize;
|
|
DWORD Status;
|
|
DWORD Type;
|
|
HKEY Key;
|
|
|
|
lstrcpy(buf, CLUSREG_KEYNAME_CLUSTER);
|
|
lstrcat(buf, L"\\");
|
|
lstrcat(buf, CLUSREG_KEYNAME_QUORUM);
|
|
|
|
Status = RegOpenKey( HKEY_LOCAL_MACHINE, buf, &Key );
|
|
if (Status != ERROR_SUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
BufSize = sizeof(guid);
|
|
Status = RegQueryValueExW(Key,
|
|
CLUSREG_NAME_QUORUM_RESOURCE,
|
|
0,
|
|
&Type,
|
|
(LPBYTE)guid,
|
|
&BufSize );
|
|
RegCloseKey( Key );
|
|
if (Status != ERROR_SUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Now, we got a quorum resource guid.
|
|
// Let's try to open this resource and read its parameters.
|
|
//
|
|
|
|
lstrcpy(buf, CLUSREG_KEYNAME_CLUSTER);
|
|
lstrcat(buf, L"\\");
|
|
lstrcat(buf, CLUSREG_KEYNAME_RESOURCES);
|
|
lstrcat(buf, L"\\");
|
|
lstrcat(buf, guid);
|
|
lstrcat(buf, L"\\");
|
|
lstrcat(buf, CLUSREG_KEYNAME_PARAMETERS);
|
|
|
|
Status = RegOpenKey( HKEY_LOCAL_MACHINE,
|
|
buf,
|
|
&Key );
|
|
if (Status != ERROR_SUCCESS) {
|
|
return Status;
|
|
}
|
|
BufSize = sizeof(DWORD);
|
|
Status = RegQueryValueExW(Key,
|
|
CLUSREG_NAME_PHYSDISK_SIGNATURE,
|
|
0,
|
|
&Type,
|
|
(LPBYTE)QuorumSignature,
|
|
&BufSize );
|
|
if (Status != ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_ERROR,
|
|
L"[PnP] DriveLetterChange: failed to open Path = %1!ws!\n", buf);
|
|
}
|
|
|
|
RegCloseKey(Key);
|
|
return Status;
|
|
}
|
|
|
|
DWORD
|
|
CheckQuorumLetterChange(
|
|
HDEVNOTIFY devNotify,
|
|
UCHAR Old,
|
|
UCHAR New,
|
|
DWORD Signature)
|
|
{
|
|
static HDEVNOTIFY QuorumDevNotify = 0;
|
|
static UCHAR StoredDriveLetter = 0;
|
|
DWORD status;
|
|
UCHAR QuorumDriveLetter;
|
|
LPWSTR QuorumPath;
|
|
DWORD QuorumSignature;
|
|
|
|
//
|
|
// If we are not watching the disk this volume is on, do nothing
|
|
//
|
|
if ( FindDisk(Signature) == -1) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
status = GetQuorumSignature(&QuorumSignature);
|
|
if (status != ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_ERROR,
|
|
L"[PnP] DriveLetterChange: Unable to query quorum drive signature, status %1!u!\n", status);
|
|
QuorumDevNotify = 0;
|
|
StoredDriveLetter = 0;
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Not a quorum disk. Ignore this notification
|
|
//
|
|
if ( QuorumSignature != Signature ) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
status = DiskspGetQuorumPath(&QuorumPath);
|
|
if (status != ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_ERROR,
|
|
L"[PnP] DriveLetterChange: Unable to query quorum drive letter, status %1!u!\n", status);
|
|
QuorumDevNotify = 0;
|
|
StoredDriveLetter = 0;
|
|
return status;
|
|
}
|
|
QuorumDriveLetter = (UCHAR) QuorumPath[0];
|
|
|
|
if (QuorumDriveLetter == Old) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] DriveLetterChange: Quorum drive letter %1!c! is being changed\n", QuorumDriveLetter);
|
|
QuorumDevNotify = devNotify;
|
|
StoredDriveLetter = QuorumDriveLetter;
|
|
}
|
|
|
|
if (New && QuorumDevNotify == devNotify
|
|
&& QuorumDriveLetter != New
|
|
&& QuorumDriveLetter == StoredDriveLetter)
|
|
{
|
|
WCHAR szOld[2] = {QuorumDriveLetter, 0};
|
|
WCHAR szNew[2] = {New, 0};
|
|
|
|
ClusterLogEvent2(
|
|
LOG_UNUSUAL, LOG_CURRENT_MODULE,
|
|
__FILE__, __LINE__,
|
|
RES_DISK_PNP_CHANGING_QUORUM,
|
|
0, NULL,
|
|
szOld, szNew);
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] DriveLetterChange: Quorum drive letter changed from %1!c! to %2!c!\n",
|
|
QuorumDriveLetter, New);
|
|
QuorumPath[0] = New;
|
|
status = DiskspSetQuorumPath(QuorumPath);
|
|
if (status != ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_SEVERE,
|
|
L"[PnP] DriveLetterChange: Unable to update QuorumPath (%1!c!: => %2!c!:), status %3!u!\n",
|
|
QuorumDriveLetter, New, status);
|
|
}
|
|
}
|
|
|
|
LocalFree(QuorumPath);
|
|
return status;
|
|
}
|
|
|
|
VOID
|
|
ProcessDriveLetterChange( HDEVNOTIFY devNotify )
|
|
{
|
|
PVOLUME vol = FindVolume(devNotify);
|
|
UCHAR ch;
|
|
if (!vol) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] DriveLetterChange: devNotify %1!d! is not in the list\n", devNotify);
|
|
return;
|
|
}
|
|
GetAssignedLetter(vol->Name, &ch);
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] DriveLetterChange: %1!c! => %2!c!\n",
|
|
NICE_DRIVE_LETTER(vol->DriveLetter),
|
|
NICE_DRIVE_LETTER(ch)
|
|
);
|
|
if (vol->PartitionType == PARTITION_IFS
|
|
&& vol->DriveLetter != ch)
|
|
{
|
|
CheckQuorumLetterChange(devNotify, vol->DriveLetter, ch, vol->Signature);
|
|
PokeDiskResource(vol);
|
|
}
|
|
vol->DriveLetter = ch;
|
|
}
|
|
|
|
VOID
|
|
ProcessVolumeInfoChange( HDEVNOTIFY devNotify )
|
|
{
|
|
PVOLUME vol = FindVolume(devNotify);
|
|
BOOL success;
|
|
HANDLE fileHandle = NULL;
|
|
PARTITION_INFORMATION partInfo;
|
|
DWORD bytesReturned;
|
|
NTSTATUS ntStatus;
|
|
|
|
if (!vol) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] VolumeInfoChange: devNotify %1!d! is not in the list\n", devNotify);
|
|
return;
|
|
}
|
|
ntStatus = DevfileOpen(&fileHandle, vol->Name);
|
|
if ( !NT_SUCCESS(ntStatus) || !fileHandle ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] VolumeInfoChange: Can't open %1!ws!, error %2!X!.\n",
|
|
vol->Name, ntStatus);
|
|
return;
|
|
}
|
|
|
|
success = DeviceIoControl( fileHandle,
|
|
IOCTL_DISK_GET_PARTITION_INFO,
|
|
NULL,
|
|
0,
|
|
&partInfo,
|
|
sizeof(PARTITION_INFORMATION),
|
|
&bytesReturned,
|
|
FALSE );
|
|
|
|
DevfileClose( fileHandle );
|
|
if (!success) {
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_ERROR,
|
|
L"[PnP] VolumeInfoChange: Error performing GetPartitionInfo; error %1!d!\n",
|
|
GetLastError());
|
|
return;
|
|
}
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] VolumeInfoChange: partType %1!d! => %2!d!\n",
|
|
vol->PartitionType,
|
|
partInfo.PartitionType
|
|
);
|
|
if (vol->PartitionType != partInfo.PartitionType
|
|
&& (partInfo.PartitionType == PARTITION_IFS
|
|
|| vol->PartitionType == PARTITION_IFS) )
|
|
{
|
|
PokeDiskResource(vol);
|
|
}
|
|
vol->PartitionType = partInfo.PartitionType;
|
|
}
|
|
|
|
//////////////////////////// WindowProc /////////////////////////////////////
|
|
|
|
#ifndef PDEV_BROADCAST_HEADER
|
|
typedef struct _DEV_BROADCAST_HEADER * PDEV_BROADCAST_HEADER;
|
|
#endif
|
|
|
|
|
|
LRESULT CALLBACK TestWndProc(
|
|
HWND hwnd, // handle to window
|
|
UINT uMsg, // message identifier
|
|
WPARAM wParam, // first message parameter
|
|
LPARAM lParam // second message parameter
|
|
) {
|
|
if (uMsg == WM_WatchDisk) {
|
|
PDISK_RESOURCE p = (PDISK_RESOURCE)lParam;
|
|
if (p) {
|
|
AddDisk(p);
|
|
}
|
|
return TRUE;
|
|
}
|
|
if (uMsg == WM_StopWatchingDisk) {
|
|
PDISK_RESOURCE p = (PDISK_RESOURCE)lParam;
|
|
if (p) {
|
|
RemoveDisk(p);
|
|
}
|
|
return TRUE;
|
|
}
|
|
if (uMsg != WM_DEVICECHANGE) {
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
if (!lParam) {
|
|
return TRUE;
|
|
}
|
|
#if DBG
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Event %1!x! received\n",
|
|
wParam );
|
|
#endif
|
|
switch( ((PDEV_BROADCAST_HEADER)lParam)->dbcd_devicetype )
|
|
{
|
|
case DBT_DEVTYP_DEVICEINTERFACE:
|
|
{
|
|
PDEV_BROADCAST_DEVICEINTERFACE p = (PDEV_BROADCAST_DEVICEINTERFACE)lParam;
|
|
if (wParam == DBT_DEVICEARRIVAL &&
|
|
IsEqualGUID(&p->dbcc_classguid, &GUID_IO_VOLUME_DEVICE_INTERFACE)
|
|
)
|
|
{
|
|
AddVolume( p->dbcc_name );
|
|
}
|
|
break;
|
|
}
|
|
case DBT_DEVTYP_HANDLE:
|
|
{
|
|
PDEV_BROADCAST_HANDLE p = (PDEV_BROADCAST_HANDLE)lParam;
|
|
if (wParam == DBT_DEVICEREMOVECOMPLETE) {
|
|
RemoveVolume(p->dbch_hdevnotify);
|
|
} else if (wParam == DBT_CUSTOMEVENT) {
|
|
PVOLUME Vol = 0;
|
|
PWCHAR guidName = 0;
|
|
LPDWORD dw = (LPDWORD)&p->dbch_eventguid;
|
|
|
|
Vol = FindVolume( p->dbch_hdevnotify );
|
|
|
|
if ( IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_NAME_CHANGE) )
|
|
{
|
|
// Update disk info.
|
|
GetVolumeInfo( Vol, NULL );
|
|
|
|
ProcessDriveLetterChange( p->dbch_hdevnotify );
|
|
ProcessMountPointChange( p->dbch_hdevnotify );
|
|
guidName = L"GUID_IO_VOLUME_NAME_CHANGE";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_CHANGE) )
|
|
{
|
|
// Update disk info.
|
|
GetVolumeInfo( Vol, NULL );
|
|
|
|
ProcessVolumeInfoChange( p->dbch_hdevnotify );
|
|
ProcessMountPointChange( p->dbch_hdevnotify );
|
|
guidName = L"GUID_IO_VOLUME_CHANGE";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_LOCK) )
|
|
{
|
|
guidName = L"GUID_IO_VOLUME_LOCK";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_UNLOCK) )
|
|
{
|
|
guidName = L"GUID_IO_VOLUME_UNLOCK";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_MOUNT) )
|
|
{
|
|
// ProcessDriveLetterChange( p->dbch_hdevnotify );
|
|
guidName = L"GUID_IO_VOLUME_MOUNT";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_DISMOUNT) )
|
|
{
|
|
guidName = L"GUID_IO_VOLUME_DISMOUNT";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_LOCK_FAILED) )
|
|
{
|
|
guidName = L"GUID_IO_VOLUME_LOCK_FAILED";
|
|
}
|
|
else if (IsEqualGUID(&p->dbch_eventguid, &GUID_IO_VOLUME_DISMOUNT_FAILED) )
|
|
{
|
|
guidName = L"GUID_IO_VOLUME_DISMOUNT_FAILED";
|
|
}
|
|
if (guidName) {
|
|
if (Vol) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Event %1!s! for %2!c! (Partition%3!d!) received.\n",
|
|
guidName, NICE_DRIVE_LETTER(Vol->DriveLetter), Vol->PartNo );
|
|
} else {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Event %1!s! for %2!d! received\n",
|
|
guidName, p->dbch_hdevnotify );
|
|
}
|
|
} else {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Event %2!x! %3!x! %4!x! %5!x! for %1!d! received\n",
|
|
p->dbch_hdevnotify, dw[0], dw[1], dw[2], dw[3] );
|
|
}
|
|
}
|
|
//#endif
|
|
break;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
AddVolumes()
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerate all known volumes and register for the notifications on these volumes
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PSP_DEVICE_INTERFACE_DETAIL_DATA pDiDetail = NULL;
|
|
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
DWORD count;
|
|
DWORD sizeDiDetail;
|
|
|
|
LONG oldValue;
|
|
|
|
BOOL result;
|
|
|
|
HDEVINFO hdevInfo;
|
|
|
|
SP_DEVICE_INTERFACE_DATA devInterfaceData;
|
|
SP_DEVINFO_DATA devInfoData;
|
|
|
|
//
|
|
// If this routine is currently running, the old value will be 1. If so,
|
|
// we don't need to run again. This call will set the flag to 1 if it is 0.
|
|
//
|
|
|
|
oldValue = InterlockedCompareExchange( &VolumeListUpdateInProcess,
|
|
1,
|
|
0 );
|
|
|
|
if ( 1 == oldValue ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] AddVolumes: Volume list update in process, skipping update \n" );
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Get a device interface set which includes all volume devices
|
|
// present on the machine. VolumeClassGuid is a predefined GUID that
|
|
// will return all volume-type device interfaces
|
|
//
|
|
|
|
hdevInfo = SetupDiGetClassDevs( &VolumeClassGuid,
|
|
NULL,
|
|
NULL,
|
|
DIGCF_PRESENT | DIGCF_DEVICEINTERFACE );
|
|
|
|
if ( !hdevInfo ) {
|
|
dwError = GetLastError();
|
|
goto FnExit;
|
|
}
|
|
|
|
ZeroMemory( &devInterfaceData, sizeof( SP_DEVICE_INTERFACE_DATA) );
|
|
|
|
//
|
|
// Iterate over all devices interfaces in the set
|
|
//
|
|
|
|
for ( count = 0; ; count++ ) {
|
|
|
|
// must set size first
|
|
devInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
|
|
|
|
//
|
|
// Retrieve the device interface data for each device interface
|
|
//
|
|
|
|
result = SetupDiEnumDeviceInterfaces( hdevInfo,
|
|
NULL,
|
|
&VolumeClassGuid,
|
|
count,
|
|
&devInterfaceData );
|
|
|
|
if ( !result ) {
|
|
|
|
//
|
|
// If we retrieved the last item, break
|
|
//
|
|
|
|
dwError = GetLastError();
|
|
|
|
if ( ERROR_NO_MORE_ITEMS == dwError ) {
|
|
dwError = ERROR_SUCCESS;
|
|
break;
|
|
|
|
}
|
|
|
|
//
|
|
// Some other error occurred. Stop processing.
|
|
//
|
|
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Get the required buffer-size for the device path. Note that
|
|
// this call is expected to fail with insufficient buffer error.
|
|
//
|
|
|
|
result = SetupDiGetDeviceInterfaceDetail( hdevInfo,
|
|
&devInterfaceData,
|
|
NULL,
|
|
0,
|
|
&sizeDiDetail,
|
|
NULL
|
|
);
|
|
|
|
if ( !result ) {
|
|
|
|
dwError = GetLastError();
|
|
|
|
//
|
|
// If a value other than "insufficient buffer" is returned,
|
|
// we have to skip this device.
|
|
//
|
|
|
|
if ( ERROR_INSUFFICIENT_BUFFER != dwError ) {
|
|
continue;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// The call should have failed since we're getting the
|
|
// required buffer size. If it doesn't fail, something bad
|
|
// happened.
|
|
//
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Allocate memory for the device interface detail.
|
|
//
|
|
|
|
pDiDetail = LocalAlloc( LPTR, sizeDiDetail );
|
|
|
|
if ( !pDiDetail ) {
|
|
dwError = GetLastError();
|
|
goto FnExit;
|
|
}
|
|
|
|
// must set the struct's size member
|
|
|
|
pDiDetail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
|
|
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
|
|
//
|
|
// Finally, retrieve the device interface detail info.
|
|
//
|
|
|
|
result = SetupDiGetDeviceInterfaceDetail( hdevInfo,
|
|
&devInterfaceData,
|
|
pDiDetail,
|
|
sizeDiDetail,
|
|
NULL,
|
|
&devInfoData
|
|
);
|
|
|
|
if ( !result ) {
|
|
|
|
dwError = GetLastError();
|
|
|
|
//
|
|
// Shouldn't fail, if it does, try the next device.
|
|
//
|
|
|
|
continue;
|
|
}
|
|
|
|
#if DBG
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] AddVolumes: Found volume %1!ws! \n",
|
|
pDiDetail->DevicePath );
|
|
#endif
|
|
|
|
AddVolume( pDiDetail->DevicePath );
|
|
|
|
LocalFree( pDiDetail );
|
|
pDiDetail = NULL;
|
|
|
|
}
|
|
|
|
FnExit:
|
|
|
|
//
|
|
// If old update value was zero, then it is now 1. Reset it to
|
|
// zero so another update can take place if needed.
|
|
//
|
|
|
|
if ( 0 == oldValue ) {
|
|
InterlockedExchange( &VolumeListUpdateInProcess, 0 );
|
|
}
|
|
|
|
if ( pDiDetail ) {
|
|
LocalFree( pDiDetail );
|
|
}
|
|
|
|
#if DBG
|
|
if ( ERROR_SUCCESS != dwError ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_WARNING,
|
|
L"[PnP] AddVolumes: returns error %1!d! \n",
|
|
dwError );
|
|
}
|
|
#endif
|
|
|
|
} // AddVolumes
|
|
|
|
|
|
DWORD
|
|
GetVolumeInfo(
|
|
PVOLUME Vol,
|
|
PHANDLE FileHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get drive layout info and partition info for the specified volume.
|
|
|
|
Arguments:
|
|
|
|
Vol - Pointer to PVOLUME structure. Caller is responsible for allocating
|
|
and freeing.
|
|
|
|
FileHandle - Returned handle to volume. Caller is responsible for closing.
|
|
This parameter is optional. If not specified by the user,
|
|
the volume handle will be closed by this routine.
|
|
|
|
Return Value:
|
|
|
|
Win32 error value.
|
|
|
|
--*/
|
|
{
|
|
PARTITION_INFORMATION partInfo;
|
|
PDRIVE_LAYOUT_INFORMATION driveLayout;
|
|
|
|
DWORD status = ERROR_SUCCESS;
|
|
DWORD bytesReturned;
|
|
NTSTATUS ntStatus;
|
|
|
|
HANDLE hFile = NULL;
|
|
|
|
BOOL success;
|
|
|
|
//
|
|
// If no VOL parameter specified or the signature is already set,
|
|
// we don't need to update the volume information.
|
|
//
|
|
if ( !Vol || Vol->Signature ) {
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ( FileHandle ) {
|
|
*FileHandle = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_INFORMATION,
|
|
L"[PnP] GetVolumeInfo: Updating info for %1!s!\n", Vol->Name );
|
|
|
|
ntStatus = DevfileOpen(&hFile, Vol->Name);
|
|
if ( !NT_SUCCESS(ntStatus) ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] GetVolumeInfo: error opening %1!ws!, error %2!X!.\n",
|
|
Vol->Name, ntStatus);
|
|
|
|
return RtlNtStatusToDosError(ntStatus);
|
|
}
|
|
|
|
success = DeviceIoControl( hFile,
|
|
IOCTL_DISK_GET_PARTITION_INFO,
|
|
NULL,
|
|
0,
|
|
&partInfo,
|
|
sizeof(PARTITION_INFORMATION),
|
|
&bytesReturned,
|
|
FALSE );
|
|
|
|
if (!success) {
|
|
|
|
status = GetLastError();
|
|
|
|
// Change this from LOG_ERROR to LOG_WARNING. This thread gets
|
|
// notified when non-fixed disks arrive (i.e. floppy), so logging
|
|
// an error for a floppy disk is misleading.
|
|
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_WARNING,
|
|
L"[PnP] GetVolumeInfo: GetPartitionInfo(%1!ws!), error %2!u!\n",
|
|
Vol->Name, status);
|
|
|
|
goto FnExit;
|
|
}
|
|
|
|
Vol->PartOffset = partInfo.StartingOffset;
|
|
Vol->PartLength = partInfo.PartitionLength;
|
|
Vol->PartNo = partInfo.PartitionNumber;
|
|
Vol->PartitionType = partInfo.PartitionType;
|
|
|
|
success = ClRtlGetDriveLayoutTable(hFile, &driveLayout, 0);
|
|
|
|
if ( !success ) {
|
|
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(RESOURCE_TYPE, LOG_WARNING,
|
|
L"[PnP] GetVolumeInfo: GetDriveLayout(%1!ws!) error %2!u!\n",
|
|
Vol->Name,
|
|
status );
|
|
|
|
goto FnExit;
|
|
}
|
|
|
|
Vol->Signature = driveLayout->Signature;
|
|
|
|
LocalFree(driveLayout);
|
|
|
|
GetAssignedLetter(Vol->Name, &Vol->DriveLetter);
|
|
|
|
FnExit:
|
|
|
|
if ( FileHandle ) {
|
|
*FileHandle = hFile;
|
|
} else {
|
|
DevfileClose( hFile );
|
|
}
|
|
|
|
return status;
|
|
|
|
} // UpdateVolumeInfo
|
|
|
|
|
|
DWORD
|
|
NotificationWatcherThread(
|
|
IN LPVOID unused
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates window. Process messages until WM_QUIT is received
|
|
|
|
Arguments:
|
|
|
|
unused
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
|
|
{
|
|
WNDCLASSEX cl;
|
|
ATOM classAtom;
|
|
DWORD status = ERROR_SUCCESS;
|
|
static WCHAR* clsname = L"RESDLL!DISKS!MESSAGEWND";
|
|
HDEVNOTIFY devNotify = 0;
|
|
MSG msg;
|
|
|
|
try {
|
|
|
|
SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
InitializeListHead( &VolumeList );
|
|
InitializeListHead( &WaitingDisks );
|
|
|
|
ZeroMemory( &cl, sizeof(cl) );
|
|
|
|
cl.cbSize = sizeof(cl);
|
|
cl.lpfnWndProc = TestWndProc;
|
|
cl.lpszClassName = clsname;
|
|
|
|
classAtom = RegisterClassEx( &cl );
|
|
if (classAtom == 0) {
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] Failed to register window class, error %1!u!.\n", status );
|
|
return status;
|
|
}
|
|
|
|
DummyWindow = CreateWindowEx(
|
|
0, // extended window style
|
|
clsname, // pointer to registered class name
|
|
L"ClusterDiskPnPWatcher",// pointer to window name
|
|
0, // window style
|
|
0, // horizontal position of window
|
|
0, // vertical position of window
|
|
0, // window width
|
|
0, // window height
|
|
HWND_MESSAGE, // handle to parent or owner window
|
|
0, // handle to menu, or child-window identifier
|
|
0, // handle to application instance (ignored on NT)
|
|
NULL // pointer to window-creation data
|
|
);
|
|
if (DummyWindow == 0) {
|
|
status = GetLastError();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] Failed to create message window, error %u.\n", status );
|
|
UnregisterClass( clsname , 0);
|
|
return status;
|
|
}
|
|
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] PnP window created successfully.\n");
|
|
|
|
//
|
|
// Call AddVolumes after registering for device arrival notification.
|
|
//
|
|
status = RegisterDeviceInterface(DummyWindow, &MOUNTDEV_MOUNTED_DEVICE_GUID, &devNotify);
|
|
AddVolumes();
|
|
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] PnP interface registration complete.\n");
|
|
|
|
if ( NULL != PnpInterfacesRegistered ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] Setting PnP interface registration event.\n");
|
|
SetEvent( PnpInterfacesRegistered );
|
|
}
|
|
|
|
if (status == ERROR_SUCCESS) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] NotifierThread is waiting for messages.\n");
|
|
while(GetMessage(&msg, 0, 0, 0)) {
|
|
if (msg.message == WM_QUIT) {
|
|
break;
|
|
}
|
|
DispatchMessage(&msg);
|
|
}
|
|
MyUnregisterDeviceNotification( devNotify );
|
|
#if 0
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] NotifierThread is shutting down.\n");
|
|
#endif
|
|
} else {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] Unable to register for MOUNTDEV_MOUNTED_DEVICE_GUID, error %1!u!.\n", status );
|
|
}
|
|
|
|
DestroyWindow( DummyWindow );
|
|
DummyWindow = 0;
|
|
UnregisterClass( clsname , 0 );
|
|
|
|
// Use a lock here as the online thread might be parsing the volume list.
|
|
AcquireExclusive( &PnpVolumeLock );
|
|
while ( !IsListEmpty(&VolumeList) ) {
|
|
PLIST_ENTRY listEntry;
|
|
PVOLUME vol;
|
|
listEntry = RemoveHeadList(&VolumeList);
|
|
vol = CONTAINING_RECORD( listEntry,
|
|
VOLUME,
|
|
ListEntry );
|
|
DestroyVolume(vol);
|
|
}
|
|
ReleaseExclusive( &PnpVolumeLock );
|
|
#if 0
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] PnpThread: Volumes destroyed.\n");
|
|
#endif
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// We can leave without this thread
|
|
//
|
|
status = GetExceptionCode();
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] PnpThread: Exception caught, error %1!u!.\n", status );
|
|
}
|
|
|
|
InterlockedCompareExchange(&PnPInitialized, FALSE, TRUE);
|
|
return status;
|
|
}
|
|
|
|
|
|
VOID
|
|
ProcessMountPointChange(
|
|
HDEVNOTIFY devNotify
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Updates mount point info in the cluster registry.
|
|
|
|
Arguments:
|
|
|
|
devNotify - Handle to the device notification.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PDISK_RESOURCE resourceEntry;
|
|
PVOLUME vol;
|
|
INT idx;
|
|
|
|
//
|
|
// Get the volume for the device notification.
|
|
//
|
|
|
|
vol = FindVolume( devNotify );
|
|
|
|
if ( !vol ) {
|
|
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] ProcessMountPointChange: devNotify %1!d! is not in the list \n",
|
|
devNotify );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Search the WatchedDiskTable to find a disk that matches the signature.
|
|
// The return value is the index into the WatchedDiskTable.
|
|
//
|
|
|
|
idx = FindDisk( vol->Signature );
|
|
if ( idx == -1 ) {
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_INFORMATION,
|
|
L"[PnP] ProcessMountPointChange: Unable to find disk for signature %1!x! \n",
|
|
vol->Signature );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the ResourceEntry for the disk.
|
|
//
|
|
|
|
resourceEntry = WatchedDiskTable[idx];
|
|
|
|
if ( !resourceEntry ) {
|
|
|
|
(DiskpLogEvent)(
|
|
RESOURCE_TYPE,
|
|
LOG_ERROR,
|
|
L"[PnP] ProcessMountPointChange: Unable to get ResourceEntry for signature %1!x! \n",
|
|
vol->Signature );
|
|
return;
|
|
}
|
|
|
|
DisksUpdateMPList( resourceEntry );
|
|
|
|
} // ProcessMountPointChange
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
DWORD
|
|
QueueWaitForVolumeEvent(
|
|
HANDLE Event,
|
|
PDISK_RESOURCE ResourceEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queues a request to watch for particular volume arrivals.
|
|
The event will be signaled only when all volumes are
|
|
available on the system.
|
|
|
|
Arguments:
|
|
|
|
Event - event to be signaled when all volumes for the specified
|
|
disk are available.
|
|
|
|
ResourceEntry - A pointer to the DISK_RESOURCE block for this resource.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS - request queued.
|
|
|
|
Win32 error on failure.
|
|
|
|
--*/
|
|
{
|
|
PWAITING_DISK waitDisk;
|
|
PMOUNTIE_VOLUME mountVol = ResourceEntry->MountieInfo.Volume;
|
|
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
|
|
waitDisk = LocalAlloc( LPTR, sizeof(WAITING_DISK) );
|
|
|
|
if ( !waitDisk ) {
|
|
dwError = GetLastError();
|
|
(DiskpLogEvent)(
|
|
ResourceEntry->ResourceHandle,
|
|
LOG_ERROR,
|
|
L"[PnP] QueueWaitForVolumeEvent: can't allocate storage for disk entry. Error %1!u! \n",
|
|
dwError );
|
|
goto FnExit;
|
|
}
|
|
|
|
waitDisk->ResourceEntry = ResourceEntry;
|
|
waitDisk->Event = Event;
|
|
waitDisk->Signature = mountVol->Signature;
|
|
waitDisk->PartitionCount = mountVol->PartitionCount;
|
|
|
|
AcquireExclusive( &PnpWaitingListLock );
|
|
InsertHeadList( &WaitingDisks, &waitDisk->ListEntry );
|
|
ReleaseExclusive( &PnpWaitingListLock );
|
|
|
|
FnExit:
|
|
|
|
return dwError;
|
|
|
|
} // QueueWaitForVolumeEvent
|
|
|
|
|
|
BOOL
|
|
IsDiskInPnpVolumeList(
|
|
PDISK_RESOURCE ResourceEntry,
|
|
BOOL UpdateVolumeList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Checks all the volumes currently known by the PnP thread and see if
|
|
all volumes for the specified disk are recognized.
|
|
|
|
Arguments:
|
|
|
|
ResourceEntry - A pointer to the DISK_RESOURCE block for this resource.
|
|
|
|
UpdateVolumeList - TRUE means call AddVolumes to make sure all volumes
|
|
are in the volume list.
|
|
|
|
Return Value:
|
|
|
|
TRUE - If all volumes for the specified disk are available on the system.
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY entry;
|
|
PVOLUME vol = 0;
|
|
PMOUNTIE_VOLUME mountVol = ResourceEntry->MountieInfo.Volume;
|
|
|
|
DWORD partitionCount = 0;
|
|
|
|
BOOL retVal = FALSE;
|
|
|
|
if ( UpdateVolumeList ) {
|
|
|
|
//
|
|
// This call shouldn't be required. However, sometimes we can't find
|
|
// find volumes that should be available. So we need to walk through
|
|
// the pnp list again.
|
|
//
|
|
AddVolumes();
|
|
}
|
|
|
|
AcquireExclusive( &PnpVolumeLock );
|
|
|
|
for ( entry = VolumeList.Flink;
|
|
entry != &VolumeList;
|
|
entry = entry->Flink
|
|
)
|
|
{
|
|
vol = CONTAINING_RECORD(
|
|
entry,
|
|
VOLUME,
|
|
ListEntry
|
|
);
|
|
|
|
GetVolumeInfo( vol, NULL );
|
|
|
|
if ( vol->Signature == mountVol->Signature ) {
|
|
partitionCount++;
|
|
}
|
|
}
|
|
|
|
ReleaseExclusive( &PnpVolumeLock );
|
|
|
|
//
|
|
// Might be some non-NTFS partitions on the disk, so if there
|
|
// are more volumes than partitions, we are good.
|
|
//
|
|
|
|
return ( ( partitionCount >= mountVol->PartitionCount ) ? TRUE : FALSE ) ;
|
|
|
|
} // IsDiskInPnpVolumeList
|
|
|
|
|
|
PWAITING_DISK
|
|
FindWaitingDisk(
|
|
DWORD Signature
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find the entry in the waiting list for the specified disk
|
|
signature.
|
|
|
|
The caller will hold the critical section.
|
|
|
|
Arguments:
|
|
|
|
Signature - Disk signature of the entry to be removed.
|
|
|
|
Return Value:
|
|
|
|
Pointer to a WAITING_DISK entry for the disk.
|
|
|
|
NULL if entry not found.
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY entry;
|
|
PWAITING_DISK waitDisk = NULL;
|
|
|
|
if ( !Signature ) {
|
|
goto FnExit;
|
|
}
|
|
|
|
for ( entry = WaitingDisks.Flink;
|
|
entry != &WaitingDisks;
|
|
entry = entry->Flink
|
|
)
|
|
{
|
|
waitDisk = CONTAINING_RECORD( entry,
|
|
WAITING_DISK,
|
|
ListEntry
|
|
);
|
|
|
|
if ( waitDisk->Signature == Signature ) {
|
|
goto FnExit;
|
|
}
|
|
|
|
waitDisk = 0;
|
|
}
|
|
|
|
FnExit:
|
|
|
|
return waitDisk;
|
|
|
|
} // FindWaitingDisk
|
|
|
|
|
|
DWORD
|
|
RemoveWaitForVolumeEvent(
|
|
PDISK_RESOURCE ResourceEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Remove from the disk waiting list the entry for the specified disk.
|
|
|
|
Arguments:
|
|
|
|
ResourceEntry - A pointer to the DISK_RESOURCE block for this resource.
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PWAITING_DISK waitDisk = NULL;
|
|
PMOUNTIE_VOLUME mountVol = ResourceEntry->MountieInfo.Volume;
|
|
|
|
AcquireExclusive( &PnpWaitingListLock );
|
|
|
|
waitDisk = FindWaitingDisk( mountVol->Signature );
|
|
|
|
if ( !waitDisk ) {
|
|
(DiskpLogEvent)(
|
|
ResourceEntry->ResourceHandle,
|
|
LOG_INFORMATION,
|
|
L"[PnP] RemoveWaitForVolumeEvent: can't locate waiting volume in list \n" );
|
|
ReleaseExclusive( &PnpWaitingListLock );
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
RemoveEntryList( &waitDisk->ListEntry );
|
|
ReleaseExclusive( &PnpWaitingListLock );
|
|
|
|
LocalFree( waitDisk );
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
} // RemoveWaitForVolumeEvent
|
|
|
|
|