#include "precomp.h"
#include <ntddvol.h>


#define _ALLOC_TAG 'kdqw'

#define IOCTL_STORAGE_BASE FILE_DEVICE_MASS_STORAGE
#define IOCTL_STORAGE_QUERY_PROPERTY                CTL_CODE(IOCTL_STORAGE_BASE, 0x0500, METHOD_BUFFERED, FILE_ANY_ACCESS)

//
// struct 
//

typedef enum _STORAGE_QUERY_TYPE {
	PropertyStandardQuery = 0,
	PropertyExistsQuery,
	PropertyMaskQuery,
	PropertyQueryMaxDefined
} STORAGE_QUERY_TYPE, * PSTORAGE_QUERY_TYPE;

typedef enum _STORAGE_PROPERTY_ID {
	StorageDeviceProperty = 0,
	StorageAdapterProperty,
	StorageDeviceIdProperty,
	StorageDeviceUniqueIdProperty,
	StorageDeviceWriteCacheProperty,
	StorageMiniportProperty,
	StorageAccessAlignmentProperty,
	StorageDeviceSeekPenaltyProperty,
	StorageDeviceTrimProperty,
	StorageDeviceWriteAggregationProperty
} STORAGE_PROPERTY_ID, * PSTORAGE_PROPERTY_ID;


typedef enum _STORAGE_BUS_TYPE {
	BusTypeUnknown = 0x00,
	BusTypeScsi,
	BusTypeAtapi,
	BusTypeAta,
	BusType1394,
	BusTypeSsa,
	BusTypeFibre,
	BusTypeUsb,
	BusTypeRAID,
	BusTypeiScsi,
	BusTypeSas,
	BusTypeSata,
	BusTypeSd,
	BusTypeMmc,
	BusTypeVirtual,
	BusTypeFileBackedVirtual,
	BusTypeMax,
	BusTypeMaxReserved = 0x7F
} STORAGE_BUS_TYPE, * PSTORAGE_BUS_TYPE;


typedef unsigned char BYTE;

typedef struct _STORAGE_PROPERTY_QUERY {

	STORAGE_PROPERTY_ID PropertyId;
	STORAGE_QUERY_TYPE QueryType;
	unsigned char AdditionalParameters[1];

} STORAGE_PROPERTY_QUERY, * PSTORAGE_PROPERTY_QUERY;


typedef struct _STORAGE_DEVICE_DESCRIPTOR {

	DWORD Version;
	DWORD Size;
	BYTE  DeviceType;
	BYTE  DeviceTypeModifier;
	BOOLEAN RemovableMedia;
	BOOLEAN CommandQueueing;
	DWORD VendorIdOffset;
	DWORD ProductIdOffset;
	DWORD ProductRevisionOffset;
	DWORD SerialNumberOffset;
	STORAGE_BUS_TYPE BusType;
	DWORD RawPropertiesLength;
	BYTE  RawDeviceProperties[1];

} STORAGE_DEVICE_DESCRIPTOR, * PSTORAGE_DEVICE_DESCRIPTOR;


NTSTATUS
GetPhysicalDiskDeviceObject(
	__in PDEVICE_OBJECT VolumeDeviceObject,
	__out PDEVICE_OBJECT* PhysicalDiskDeviceObject
)
{
	NTSTATUS status;
	PIRP Irp;
	KEVENT Event;
	IO_STATUS_BLOCK Iosb;
	PVOLUME_DISK_EXTENTS pDiskExtents = NULL;
	// 넉넉하게 4개 정도의 Extent 공간 확보
	ULONG extentsSize = sizeof(VOLUME_DISK_EXTENTS) + (sizeof(DISK_EXTENT) * 4);
	UNICODE_STRING physicalDiskName;
	WCHAR nameBuffer[64] = { 0 };
	PFILE_OBJECT pFileObject = NULL;
	PDEVICE_OBJECT pDevObj = NULL;

	*PhysicalDiskDeviceObject = NULL;

	// 1. 메모리 할당
	pDiskExtents = (PVOLUME_DISK_EXTENTS)ExAllocatePoolWithTag(NonPagedPool, extentsSize, 'dExt');
	if (!pDiskExtents) return STATUS_INSUFFICIENT_RESOURCES;

	// 메모리 초기화 (중요)
	RtlZeroMemory(pDiskExtents, extentsSize);

	KeInitializeEvent(&Event, NotificationEvent, FALSE);
	Irp = IoBuildDeviceIoControlRequest(
		IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
		VolumeDeviceObject,
		NULL, 0,
		pDiskExtents, extentsSize,
		FALSE, &Event, &Iosb
	);

	if (!Irp) {
		ExFreePoolWithTag(pDiskExtents, 'dExt');
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	status = IoCallDriver(VolumeDeviceObject, Irp);
	if (status == STATUS_PENDING) {
		KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
		status = Iosb.Status;
	}

	if (!NT_SUCCESS(status)) {
		ExFreePoolWithTag(pDiskExtents, 'dExt');
		return status;
	}

	// [BSOD 방지 핵심] Extents 개수 확인!
	if (pDiskExtents->NumberOfDiskExtents == 0)
	{
		KLogEx(DEBUG_TRACE_INFO, "No Disk Extents found.\n");
		ExFreePoolWithTag(pDiskExtents, 'dExt');
		return STATUS_UNSUCCESSFUL;
	}

	__try
	{
		// 2. 물리 디스크 이름 생성
		ULONG diskNumber = pDiskExtents->Extents[0].DiskNumber;

		// 안전한 문자열 함수 사용
		if (!NT_SUCCESS(RtlStringCbPrintfW(nameBuffer, sizeof(nameBuffer), L"\\Device\\Harddisk%u\\DR0", diskNumber)))
		{
			status = STATUS_BUFFER_OVERFLOW;
			__leave;
		}

		RtlInitUnicodeString(&physicalDiskName, nameBuffer);

		KLogEx(DEBUG_TRACE_INFO, "Trying to open: %S\n", nameBuffer);

		// 3. 디바이스 포인터 획득 (가장 위험한 구간)
		// InstanceSetup에서 이 호출이 위험할 수 있으므로 실패 시 즉시 빠져나옴
		status = IoGetDeviceObjectPointer(
			&physicalDiskName,
			FILE_READ_ATTRIBUTES, // 권한 최소화
			&pFileObject,
			&pDevObj
		);

		if (NT_SUCCESS(status))
		{
			ObReferenceObject(pDevObj); // 디바이스 객체 참조
			ObDereferenceObject(pFileObject); // 파일 객체 닫기
			*PhysicalDiskDeviceObject = pDevObj;
		}
		else
		{
			KLogEx(DEBUG_TRACE_ERROR, "IoGetDeviceObjectPointer Failed: 0x%x\n", status);
		}
	}
	__except (EXCEPTION_EXECUTE_HANDLER)
	{
		KLogEx(DEBUG_TRACE_ERROR, "Exception in GetPhysicalDiskDeviceObject\n");
		status = STATUS_UNHANDLED_EXCEPTION;
	}

	ExFreePoolWithTag(pDiskExtents, 'dExt');
	return status;
}

NTSTATUS
QueryDeviceProperty(
	__in PDEVICE_OBJECT pDevice,
	__in DEVICE_REGISTRY_PROPERTY DevProperty,
	__out PVOID* ppBuffer,
	__out PULONG pResultLength
)
{

	NTSTATUS status;
	PVOID pBuffer = NULL;
	ULONG BufferSize = 0;

	ASSERT(ARGUMENT_PRESENT(pDevice));

	// sskim - 171122 Added.
	// FltGetDiskDeviceObject로 구한 pDevice는 PDO여서 Verifier에서 터짐 (FDO로 가져오게 추가)
	//pDevice = IoGetDeviceAttachmentBaseRef(pDevice);

	status = IoGetDeviceProperty(
		pDevice,
		DevProperty,
		BufferSize,
		NULL,
		&BufferSize
	);

	if (NT_SUCCESS(status))
	{
		return STATUS_NOT_SUPPORTED;
	}

	while (status == STATUS_BUFFER_TOO_SMALL)
	{
		pBuffer = ExAllocatePoolWithTag(PagedPool, BufferSize, _ALLOC_TAG);
		if (!pBuffer)
		{
			return STATUS_NO_MEMORY;
		}

		status = IoGetDeviceProperty(
			pDevice,
			DevProperty,
			BufferSize,
			pBuffer,
			&BufferSize
		);

		if (NT_SUCCESS(status))
		{
			*ppBuffer = pBuffer;
			*pResultLength = BufferSize;
			return status;
		}

		ExFreePool(pBuffer);
		pBuffer = NULL;
	}

	ASSERT(!pBuffer);

	return status;
}

//#define QUERY_BUFFER_SIZE 0x2000
//NTSTATUS SafeSetVolumContextParam(PUCHAR pucDest, DWORD dwSize, PUCHAR pucSrc, DWORD dwOffset)
//{
//	int size = 0;
//	PCHAR pszName = NULL;
//
//	if (dwOffset == 0)
//		return STATUS_UNSUCCESSFUL;
//
//	if (dwOffset >= dwSize)
//		return STATUS_UNSUCCESSFUL;
//
//	if (dwOffset >= (QUERY_BUFFER_SIZE - 10))
//		return STATUS_UNSUCCESSFUL;
//
//	pszName = (char*)GetPtr(pucSrc, dwOffset);
//	size = (int)strlen(pszName);
//
//	KLogEx(DEBUG_TRACE_INFO, "SafeSetVolumContextParam, size(%d)\n", size);
//
//	if (size > VOLUME_DESCRIPTION_LENGTH)
//	{
//		size = VOLUME_DESCRIPTION_LENGTH - 1;
//	}
//
//	RtlCopyMemory(pucDest, pszName, size);
//	return STATUS_SUCCESS;
//}


// 매크로 정의 (없다면 추가 필요)
#ifndef QUERY_BUFFER_SIZE
#define QUERY_BUFFER_SIZE 0x2000
#endif

// 안전한 포인터 계산 및 복사 함수 (대문자 변환 포함)
NTSTATUS SafeSetVolumContextParam(
	__in PUCHAR pucDest,        // 대상 버퍼 (Context 내 변수)
	__in ULONG  ulSrcTotalSize, // 원본 전체 버퍼 크기 (pDesc->Size)
	__in PUCHAR pucSrcBase,     // 원본 버퍼 시작 주소 (pDesc)
	__in ULONG  ulOffset        // 문자열 오프셋
)
{
	ULONG i = 0;
	PCHAR pSrcStr = NULL;

	// 1. 오프셋 유효성 검사
	// 오프셋이 0이거나, 원본 버퍼 크기를 벗어나면 실패
	if (ulOffset == 0 || ulOffset >= ulSrcTotalSize)
	{
		// 정보가 없는 경우이므로 에러보다는 단순히 NULL 처리하고 성공 리턴
		if (pucDest) pucDest[0] = 0;
		return STATUS_SUCCESS;
	}

	// 2. 문자열 시작 포인터 계산
	pSrcStr = (PCHAR)(pucSrcBase + ulOffset);

	// 3. 문자열 복사 및 대문자 변환 루프
	// 조건: 
	// A. 대상 버퍼 크기(VOLUME_DESCRIPTION_LENGTH - 1)를 넘지 않을 것
	// B. 원본 버퍼 끝(pucSrcBase + ulSrcTotalSize)을 넘지 않을 것 (Memory Access Violation 방지)
	// C. NULL 문자를 만날 때까지

	for (i = 0; i < VOLUME_DESCRIPTION_LENGTH - 1; i++)
	{
		// 원본 버퍼 범위 체크 (Overflow 방지)
		if ((ULONG_PTR)(pSrcStr + i) >= (ULONG_PTR)(pucSrcBase + ulSrcTotalSize))
			break;

		// 원본 문자열 끝(NULL) 체크
		if (pSrcStr[i] == 0)
			break;

		// [요청하신 기능] 대문자로 변환하여 복사
		pucDest[i] = RtlUpperChar(pSrcStr[i]);
	}

	// 4. NULL Termination 보장
	pucDest[i] = 0;

	KLogEx(DEBUG_TRACE_INFO, "Copied Length(%d), Content(%s)\n", i, pucDest);

	return STATUS_SUCCESS;
}

typedef struct _STORAGE_DEVICE_ID_DESCRIPTOR {
	ULONG Version;
	ULONG Size;
	ULONG NumberOfIdentifiers;
	UCHAR Identifiers[1]; // 가변 길이 문자열 배열
} STORAGE_DEVICE_ID_DESCRIPTOR, * PSTORAGE_DEVICE_ID_DESCRIPTOR;

NTSTATUS
GetStorageDeviceId(
	__in PDEVICE_OBJECT DeviceObject,
	__out PWCHAR* OutInstanceId
)
{
	NTSTATUS status = STATUS_SUCCESS;
	PIRP Irp;
	KEVENT Event;
	IO_STATUS_BLOCK Iosb;
	STORAGE_PROPERTY_QUERY PropQuery = { 0 };
	PSTORAGE_DEVICE_ID_DESCRIPTOR pDesc = NULL;
	PVOID QueryBuffer = NULL;
	ULONG QuerySize = 1024; // 넉넉하게 잡음

	*OutInstanceId = NULL;

	// 1. 메모리 할당
	QueryBuffer = ExAllocatePoolWithTag(PagedPool, QuerySize, 'StoI');
	if (!QueryBuffer) return STATUS_INSUFFICIENT_RESOURCES;

	RtlZeroMemory(QueryBuffer, QuerySize);

	// 2. 쿼리 설정: StorageDeviceIdProperty (중요!)
	PropQuery.PropertyId = StorageDeviceIdProperty; // enum 값: 2
	PropQuery.QueryType = PropertyStandardQuery;

	KeInitializeEvent(&Event, NotificationEvent, FALSE);

	// 3. IRP 생성 및 전송
	Irp = IoBuildDeviceIoControlRequest(
		IOCTL_STORAGE_QUERY_PROPERTY,
		DeviceObject,
		&PropQuery,
		sizeof(PropQuery),
		QueryBuffer,
		QuerySize,
		FALSE,
		&Event,
		&Iosb
	);

	if (!Irp)
	{
		ExFreePoolWithTag(QueryBuffer, 'StoI');
		return STATUS_INSUFFICIENT_RESOURCES;
	}

	status = IoCallDriver(DeviceObject, Irp);

	if (status == STATUS_PENDING)
	{
		KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
		status = Iosb.Status;
	}

	// 4. 결과 파싱
	if (NT_SUCCESS(status) && Iosb.Information > sizeof(STORAGE_DEVICE_ID_DESCRIPTOR))
	{
		pDesc = (PSTORAGE_DEVICE_ID_DESCRIPTOR)QueryBuffer;

		if (pDesc->NumberOfIdentifiers > 0)
		{
			// Identifiers는 Null로 구분된 ANSI 문자열들의 배열입니다.
			// 첫 번째 문자열이 보통 가장 구체적인 PnP ID (Hardware ID)입니다.
			PCHAR pAnsiId = (PCHAR)pDesc->Identifiers;

			// ANSI String -> Unicode String 변환 필요
			ANSI_STRING ansiStr;
			UNICODE_STRING uniStr;

			RtlInitAnsiString(&ansiStr, pAnsiId);

			status = RtlAnsiStringToUnicodeString(&uniStr, &ansiStr, TRUE); // TRUE: Allocate Memory

			if (NT_SUCCESS(status))
			{
				// 호출자에게 전달 (호출자가 나중에 ExFreePool 해야 함)
				// RtlAnsiStringToUnicodeString이 할당한 버퍼는 PagedPool입니다.
				// 여기서는 호출자가 편하게 쓰도록 새 버퍼에 복사하거나, uniStr.Buffer를 그대로 줍니다.

				// 안전하게 복사본을 만들어 리턴 (NonPagedPool 권장 시)
				ULONG uniSize = uniStr.Length + sizeof(WCHAR);
				PWCHAR pResult = ExAllocatePoolWithTag(NonPagedPool, uniSize, 'IDst');

				if (pResult)
				{
					RtlZeroMemory(pResult, uniSize);
					RtlCopyMemory(pResult, uniStr.Buffer, uniStr.Length);
					*OutInstanceId = pResult;
				}

				RtlFreeUnicodeString(&uniStr); // 임시 변환 버퍼 해제
			}
		}
	}

	ExFreePoolWithTag(QueryBuffer, 'StoI');
	return status;
}


NTSTATUS
GetStorageProperty(
	__in PDEVICE_OBJECT device_object,
	__in PVOLUME_CONTEXT pVolumeContext
)
{
	PIRP Irp;
	KEVENT Event;
	NTSTATUS status = STATUS_SUCCESS;
	IO_STATUS_BLOCK Iosb;
	STORAGE_PROPERTY_QUERY PropQuery = { 0, };
	PVOID QueryBuffer = NULL;
	ULONG QuerySize = QUERY_BUFFER_SIZE;
	PSTORAGE_DEVICE_DESCRIPTOR pDesc;
	
	//ULONG size = 0;

	__try
	{
		QueryBuffer = ExAllocatePoolWithTag(PagedPool, QuerySize, _ALLOC_TAG);
		if (!QueryBuffer)
		{
			status = STATUS_INSUFFICIENT_RESOURCES;
			__leave;
		}

		RtlZeroMemory(&PropQuery, sizeof(PropQuery));
		RtlZeroMemory(QueryBuffer, QuerySize);
		PropQuery.PropertyId = StorageDeviceProperty;
		PropQuery.QueryType = PropertyStandardQuery;

		KeInitializeEvent(&Event, NotificationEvent, FALSE);

		Irp = IoBuildDeviceIoControlRequest(
			IOCTL_STORAGE_QUERY_PROPERTY,
			device_object,
			&PropQuery,
			sizeof(PropQuery),
			QueryBuffer,
			QuerySize,
			FALSE,
			&Event,
			&Iosb
		);

		if (!Irp)
		{
			status = STATUS_INSUFFICIENT_RESOURCES;
			__leave;
		}

		status = IoCallDriver(device_object, Irp);

		if (status == STATUS_PENDING)
		{
			KeWaitForSingleObject(
				&Event,
				Executive,
				KernelMode,
				FALSE,
				(PLARGE_INTEGER)NULL
			);

			status = Iosb.Status;
		}

		if (!NT_SUCCESS(status))
		{
			__leave;
		}

		if (Iosb.Information < sizeof(STORAGE_DEVICE_DESCRIPTOR))
		{
			status = STATUS_UNSUCCESSFUL;
			__leave;
		}

		pDesc = (PSTORAGE_DEVICE_DESCRIPTOR)QueryBuffer;
		if (!pDesc)
			__leave;

		if (pDesc->Size > Iosb.Information)
		{
			if (pDesc->Size > QuerySize) pDesc->Size = (ULONG)Iosb.Information;
		}

		KLogEx(DEBUG_TRACE_INFO, "Version(%x),Size(%x),DeviceType(%x),DeviceTypeModifier(%x)\n", pDesc->Version, pDesc->Size, pDesc->DeviceType, pDesc->DeviceTypeModifier);
		KLogEx(DEBUG_TRACE_INFO, "bustype(%d),Removal(%d),vidoffset(%x),pidoffset(%x)\n", pDesc->BusType, pDesc->RemovableMedia, pDesc->VendorIdOffset, pDesc->ProductIdOffset);
		KLogEx(DEBUG_TRACE_INFO, "ProductRevisionOffset(%d),SerialNumberOffset(%d)\n", pDesc->ProductRevisionOffset, pDesc->SerialNumberOffset);

		pVolumeContext->bustype = pDesc->BusType;
		SafeSetVolumContextParam(pVolumeContext->vendorid, pDesc->Size, (PUCHAR)pDesc, pDesc->VendorIdOffset);
		SafeSetVolumContextParam(pVolumeContext->productid, pDesc->Size, (PUCHAR)pDesc, pDesc->ProductIdOffset);
		SafeSetVolumContextParam(pVolumeContext->productrevisionlevel, pDesc->Size, (PUCHAR)pDesc, pDesc->ProductRevisionOffset);
		SafeSetVolumContextParam(pVolumeContext->vendorspecific, pDesc->Size, (PUCHAR)pDesc, pDesc->SerialNumberOffset);
	}
	__finally
	{
		if (QueryBuffer)
		{
			ExFreePoolWithTag(QueryBuffer, _ALLOC_TAG);
			QueryBuffer = NULL;
		}
	}

	return status;
}

NTSTATUS
GetVolumeProperties(
	__in PCFLT_RELATED_OBJECTS FltObjects,
	__in PVOLUME_CONTEXT pVolumeContext
)
{

	NTSTATUS status = STATUS_SUCCESS;
	PDEVICE_OBJECT pDevice = NULL;
	PVOID pBuffer = NULL;
	ULONG PropertySize = 0;
	PWCHAR pDeviceId = NULL;
	PDEVICE_OBJECT physicalDeviceObject = NULL;

	ASSERT(ARGUMENT_PRESENT(pVolumeContext));

	__try
	{
		/*status = FltGetDiskDeviceObject(FltObjects->Volume, &pDevice);
		if (!NT_SUCCESS(status))
		{
			pDevice = NULL;
			__leave;
		}*/

		status = GetPhysicalDiskDeviceObject((PDEVICE_OBJECT)FltObjects->Volume, &pDevice);

		status = GetStorageProperty(pDevice, pVolumeContext);
		status = QueryDeviceProperty(pDevice, DevicePropertyRemovalPolicy, &pBuffer, &PropertySize);
		
		if (NT_SUCCESS(status))
		{
			PDEVICE_REMOVAL_POLICY pRemovalPolicy = (PDEVICE_REMOVAL_POLICY)pBuffer;
			pVolumeContext->removalpolicy = *pRemovalPolicy;
			//pVolumeContext->device_object = pDevice;
			KLogEx(DEBUG_TRACE_INFO, " REMOVAL_POLICY pDevice(%p),removalpolicy(%d)\n", pDevice, pVolumeContext->removalpolicy);
			ExFreePoolWithTag(pBuffer, _ALLOC_TAG);
			pBuffer = NULL;
		}
		else
		{
			KLogEx(DEBUG_TRACE_INFO, "Query DevicePropertyRemovalPolicy Failed 0x%x\n", status);
		}

		status = QueryDeviceProperty(pDevice, DevicePropertyHardwareID, &pBuffer, &PropertySize);
		if (NT_SUCCESS(status))
		{
			KLogEx(DEBUG_TRACE_INFO, "[PnP] Hardware ID: %S\n", pBuffer);
			ExFreePoolWithTag(pBuffer, _ALLOC_TAG);
			pBuffer = NULL;
		}
		else
		{
			KLogEx(DEBUG_TRACE_INFO, "Query DevicePropertyHardwareID Failed 0x%x\n", status);
		}

		status = GetStorageDeviceId(pDevice, &pDeviceId);
		if (NT_SUCCESS(status) && pDeviceId != NULL)
		{
			KLogEx(DEBUG_TRACE_INFO, "Found Device ID: %S\n", pDeviceId);

			// 결과 예시: "USB\VID_346D&PID_5678&REV_0100"
			// 여기서 문자열 파싱하여 정책 적용

			ExFreePoolWithTag(pDeviceId, 'IDst');
		}
		else
		{
			KLogEx(DEBUG_TRACE_INFO, "[IOCTL] Failed 0x%x. Trying PnP Query...\n", status);

			// =================================================================
			// 시도 2: PnP 방식 (PDO에게 요청) - HardwareID / InstanceID
			// =================================================================
			// IOCTL을 처리하는 FDO의 가장 밑바닥(PDO)을 구합니다.
			physicalDeviceObject = IoGetDeviceAttachmentBaseRef(pDevice);

			if (physicalDeviceObject)
			{
				// PnP 쿼리는 PDO에게 해야 합니다.
				// DevicePropertyHardwareID (리스트) 또는 DevicePropertyInstanceID (단일) 시도
				PWCHAR pHardwareId = NULL;

				// 보통 HardwareID가 가장 확실하게 정보(VID/PID)를 줍니다.
				// HardwareID는 MULTI_SZ 형식이므로 첫 번째 문자열만 쓰면 됩니다.
				status = QueryDeviceProperty(physicalDeviceObject, DevicePropertyHardwareID, &pHardwareId, &PropertySize);

				if (NT_SUCCESS(status) && pHardwareId)
				{
					KLogEx(DEBUG_TRACE_INFO, "[PnP] Hardware ID: %S\n", pHardwareId);
					ExFreePoolWithTag(pHardwareId, _ALLOC_TAG);
				}
				else
				{
					KLogEx(DEBUG_TRACE_INFO, "[PnP] Query DevicePropertyHardwareID Failed 0x%x\n", status);
				}

				ObDereferenceObject(physicalDeviceObject);
			}
		}

		status = STATUS_SUCCESS;
	}
	__finally
	{
		if (pDevice)
			ObDereferenceObject(pDevice);
	}

	return status;
}