cmemorylockerimpdrvnt.cpp

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CMemoryLockerImpDrvNT.cpp,v 1.4 2002/08/06 20:09:31 dallen Exp $
____________________________________________________________________________*/

#include "pgpCLassesCOnfig.h"

#include "UDebug.h"
#include "CMemoryLockerImpDrvNT.h"

_USING_PGP

// Types

struct PGP::LockedMemInfo : public CListableObject<LockedMemInfo>
{
	const void	*pMem;			// original memory block
	const void	*pMappedMem;	// block mapped to linear memory
	PGPUInt32	sizeMem;		// size of memory block

	PMDL	pMdl;
};


// Class CMemoryLockerImpDrvNT member functions

CMemoryLockerImpDrvNT::CMemoryLockerImpDrvNT()
{
	Status() = mLMIAllocator.Status();

	if (Status().IsntError())
		Status() = mLMIListLock.Status();
}

CComboError 
CMemoryLockerImpDrvNT::LockMemory(
	const void	*pMem, 
	PGPUInt32	sizeMem, 
	void		**ppMappedMem)
{
	CComboError		error;

	LockedMemInfo	*pLMI;
	error = mLMIAllocator.Allocate(pLMI);

	if (error.IsntError())
	{
		PMDL	pMdl;

		// Get a MDL to describe the memory.
		if (IsNull(pMdl = IoAllocateMdl(const_cast<void *>(pMem), sizeMem, 
			FALSE, FALSE, NULL)))
		{
			error.pgpErr = kPGPError_MemoryOpFailed;
		}

		if (error.IsntError())
		{
			pLMI->pMem		= pMem;
			pLMI->sizeMem	= sizeMem;
			pLMI->pMdl		= pMdl;

			// Try to lock down the memory.
			__try 
			{
				MmProbeAndLockPages(pLMI->pMdl, KernelMode, IoModifyAccess);
			} 
			__except(EXCEPTION_EXECUTE_HANDLER) 
			{
				error.pgpErr = kPGPError_MemoryOpFailed;
			}

			// Map the memory if asked and keep track of it.
			if (error.IsntError())
			{
				if (IsntNull(ppMappedMem))
				{
				#if	(_WIN32_WINNT >= 0x0500)

					pLMI->pMappedMem = *ppMappedMem = 
							MmGetSystemAddressForMdlSafe(pMdl, 
							NormalPagePriority);

					if (IsNull(pLMI->pMappedMem))
						error.pgpErr = kPGPError_MemoryOpFailed;

				#else	// _WIN32_WINNT < 0x5000

					pLMI->pMappedMem = *ppMappedMem = 
						MmGetSystemAddressForMdl(pMdl);

				#endif	// _WIN32_WINNT >= 0x5000
				}
				else
				{
					pLMI->pMappedMem = NULL;
				}
			}

			if (error.IsntError())
			{
				mLMIListLock.StartWriting();
				mLMIList.AddHead(pLMI);
				mLMIListLock.StopWriting();
			}

			if (error.IsError())
				IoFreeMdl(pMdl);
		}

		if (error.IsError())
			mLMIAllocator.Free(pLMI);
	}

	return error;
}

CComboError 
CMemoryLockerImpDrvNT::UnlockMemory(const void *pMem)
{
	CComboError		error;
	LockedMemInfo	*pLMI;
	PGPBoolean		foundMemInfo	= FALSE;

	mLMIListLock.StartWriting();

	pLMI = mLMIList.Head();

	// Find the info structure for this memory.
	while (IsntNull(pLMI))
	{
		// Check BOTH original user address and mapped system address.
		if ((pLMI->pMem == pMem) || (pLMI->pMappedMem == pMem))
		{
			foundMemInfo = TRUE;
			break;
		}
		else
		{
			pLMI = mLMIList.Next(pLMI);
		}
	}

	if (!foundMemInfo)
		error.pgpErr = kPGPError_BadParams;

	// Unlock the memory and free the list entry.
	if (error.IsntError())
	{
		MmUnlockPages(pLMI->pMdl);
		IoFreeMdl(pLMI->pMdl);

		mLMIList.Remove(pLMI);
		mLMIAllocator.Free(pLMI);
	}

	mLMIListLock.StopWriting();

	return error;
}

void 
CMemoryLockerImpDrvNT::Shutdown()
{
	mLMIListLock.StartWriting();

	while (mLMIList.Count() > 0)
	{
		LockedMemInfo	*pLMI	= mLMIList.Remove(mLMIList.Head());

		UDebug::DebugOut("PGPdisk: CMemoryLockerImpDrvNT::"
			"~CMemoryLockerImpDrvNT: Mapped memory being forcibly "
			"unmapped.");

		MmUnlockPages(pLMI->pMdl);
		IoFreeMdl(pLMI->pMdl);

		mLMIAllocator.Free(pLMI);
	}

	mLMIListLock.StopWriting();
}