ext2/src/misc.c

/*************************************************************************
*
* File: misc.c
*
* Module: Ext2 File System Driver (Kernel mode execution only)
*
* Description:
*	This file contains some miscellaneous support routines.
*
* Author: Manoj Paul Joseph
*
*
*************************************************************************/

#include			"ext2fsd.h"

// define the file specific bug-check id
#define			EXT2_BUG_CHECK_ID				EXT2_FILE_MISC

#define			DEBUG_LEVEL						( DEBUG_TRACE_MISC )

/*************************************************************************
*
* Function: Ext2InitializeZones()
*
* Description:
*	Allocates some memory for global zones used to allocate FSD structures.
*	Either all memory will be allocated or we will back out gracefully.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: STATUS_SUCCESS/Error
*
*************************************************************************/
NTSTATUS NTAPI Ext2InitializeZones(
void)
{
	NTSTATUS			RC = STATUS_SUCCESS;
	uint32				SizeOfZone = Ext2GlobalData.DefaultZoneSizeInNumStructs;
	uint32				SizeOfObjectNameZone = 0;
	uint32				SizeOfCCBZone = 0;
	uint32				SizeOfFCBZone = 0;
	uint32				SizeOfByteLockZone = 0;
	uint32				SizeOfIrpContextZone = 0;

	try {

		// initialize the spinlock protecting the zones
		KeInitializeSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock));

		// determine memory requirements
		switch (MmQuerySystemSize()) {
		case MmSmallSystem:
			// this is just for illustration purposes. I will multiply
			//	number of structures with some arbitrary amount depending
			//	upon available memory in the system ... You should choose a
			// more intelligent method suitable to your memory consumption
			// and the amount of memory available.
			SizeOfObjectNameZone = (2 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2ObjectName))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfCCBZone = (2 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2CCB))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfFCBZone = (2 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2FCB))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfByteLockZone = (2 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2FileLockInfo))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfIrpContextZone = (2 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2IrpContext))) + sizeof(ZONE_SEGMENT_HEADER);
			break;
		case MmMediumSystem:
			SizeOfObjectNameZone = (4 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2ObjectName))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfCCBZone = (4 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2CCB))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfFCBZone = (4 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2FCB))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfByteLockZone = (4 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2FileLockInfo))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfIrpContextZone = (4 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2IrpContext))) + sizeof(ZONE_SEGMENT_HEADER);
			break;
		case MmLargeSystem:
			SizeOfObjectNameZone = (8 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2ObjectName))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfCCBZone = (8 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2CCB))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfFCBZone = (8 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2FCB))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfByteLockZone = (8 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2FileLockInfo))) + sizeof(ZONE_SEGMENT_HEADER);
			SizeOfIrpContextZone = (8 * SizeOfZone * Ext2QuadAlign(sizeof(Ext2IrpContext))) + sizeof(ZONE_SEGMENT_HEADER);
			break;
		}

		// typical NT methodology (at least until *someone* exposed the "difference" between a server and workstation ;-)
		if (MmIsThisAnNtAsSystem()) {
			SizeOfObjectNameZone *= EXT2_NTAS_MULTIPLE;
			SizeOfCCBZone *= EXT2_NTAS_MULTIPLE;
			SizeOfFCBZone *= EXT2_NTAS_MULTIPLE;
			SizeOfByteLockZone *= EXT2_NTAS_MULTIPLE;
			SizeOfIrpContextZone *= EXT2_NTAS_MULTIPLE;
		}

		// allocate memory for each of the zones and initialize the	zones ...
		if (!(Ext2GlobalData.ObjectNameZone = Ext2AllocatePool(NonPagedPool, SizeOfObjectNameZone ))) {
			RC = STATUS_INSUFFICIENT_RESOURCES;
			try_return();
		}

		if (!(Ext2GlobalData.CCBZone = Ext2AllocatePool(NonPagedPool, SizeOfCCBZone ))) {
			RC = STATUS_INSUFFICIENT_RESOURCES;
			try_return();
		}

		if (!(Ext2GlobalData.FCBZone = Ext2AllocatePool(NonPagedPool, SizeOfFCBZone ))) {
			RC = STATUS_INSUFFICIENT_RESOURCES;
			try_return();
		}

		if (!(Ext2GlobalData.ByteLockZone = Ext2AllocatePool(NonPagedPool, SizeOfByteLockZone ))) {
			RC = STATUS_INSUFFICIENT_RESOURCES;
			try_return();
		}

		if (!(Ext2GlobalData.IrpContextZone = Ext2AllocatePool(NonPagedPool, SizeOfIrpContextZone ))) {
			RC = STATUS_INSUFFICIENT_RESOURCES;
			try_return();
		}

		// initialize each of the zone headers ...
		if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.ObjectNameZoneHeader),
					Ext2QuadAlign(sizeof(Ext2ObjectName)),
					Ext2GlobalData.ObjectNameZone, SizeOfObjectNameZone))) {
			// failed the initialization, leave ...
			try_return();
		}

		if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.CCBZoneHeader),
					Ext2QuadAlign(sizeof(Ext2CCB)),
					Ext2GlobalData.CCBZone,
					SizeOfCCBZone))) {
			// failed the initialization, leave ...
			try_return();
		}

		if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.FCBZoneHeader),
					Ext2QuadAlign(sizeof(Ext2FCB)),
					Ext2GlobalData.FCBZone,
					SizeOfFCBZone))) {
			// failed the initialization, leave ...
			try_return();
		}

		if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.ByteLockZoneHeader),
					Ext2QuadAlign(sizeof(Ext2FileLockInfo)),
					Ext2GlobalData.ByteLockZone,
					SizeOfByteLockZone))) {
			// failed the initialization, leave ...
			try_return();
		}

		if (!NT_SUCCESS(RC = ExInitializeZone(&(Ext2GlobalData.IrpContextZoneHeader),
					Ext2QuadAlign(sizeof(Ext2IrpContext)),
					Ext2GlobalData.IrpContextZone,
					SizeOfIrpContextZone))) {
			// failed the initialization, leave ...
			try_return();
		}

		try_exit:	NOTHING;

	} finally {
		if (!NT_SUCCESS(RC)) {
			// invoke the destroy routine now ...
			Ext2DestroyZones();
		} else {
			// mark the fact that we have allocated zones ...
			Ext2SetFlag(Ext2GlobalData.Ext2Flags, EXT2_DATA_FLAGS_ZONES_INITIALIZED);
		}
	}

	return(RC);
}


/*************************************************************************
*
* Function: Ext2DestroyZones()
*
* Description:
*	Free up the previously allocated memory. NEVER do this once the
*	driver has been successfully loaded.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2DestroyZones(
void)
{
	try {
		// free up each of the pools
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", Ext2GlobalData.ObjectNameZone);
		ExFreePool(Ext2GlobalData.ObjectNameZone);

		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", Ext2GlobalData.CCBZone);
		ExFreePool(Ext2GlobalData.CCBZone);

		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", Ext2GlobalData.FCBZone);
		ExFreePool(Ext2GlobalData.FCBZone);

		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", Ext2GlobalData.ByteLockZone);
		ExFreePool(Ext2GlobalData.ByteLockZone);

		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", Ext2GlobalData.IrpContextZone);
		ExFreePool(Ext2GlobalData.IrpContextZone);
	}
	finally
	{
		Ext2ClearFlag(Ext2GlobalData.Ext2Flags, EXT2_DATA_FLAGS_ZONES_INITIALIZED);
	}

	return;
}


/*************************************************************************
*
* Function: Ext2IsIrpTopLevel()
*
* Description:
*	Helps the FSD determine who the "top level" caller is for this
*	request. A request can originate directly from a user process
*	(in which case, the "top level" will be NULL when this routine
*	is invoked), OR the user may have originated either from the NT
*	Cache Manager/VMM ("top level" may be set), or this could be a
*	recursion into our code in which we would have set the "top level"
*	field the last time around.
*
* Expected Interrupt Level (for execution) :
*
*  whatever level a particular dispatch routine is invoked at.
*
* Return Value: TRUE/FALSE (TRUE if top level was NULL when routine invoked)
*
*************************************************************************/
BOOLEAN NTAPI Ext2IsIrpTopLevel(
PIRP			Irp)			// the IRP sent to our dispatch routine
{
	BOOLEAN			ReturnCode = FALSE;

	if (IoGetTopLevelIrp() == NULL)
	{
 		// OK, so we can set ourselves to become the "top level" component
		IoSetTopLevelIrp( Irp );
		ReturnCode = TRUE;
	}

	return(ReturnCode);
}


/*************************************************************************
*
* Function: Ext2ExceptionFilter()
*
* Description:
*	This routines allows the driver to determine whether the exception
*	is an "allowed" exception i.e. one we should not-so-quietly consume
*	ourselves, or one which should be propagated onwards in which case
*	we will most likely bring down the machine.
*
*	This routine employs the services of FsRtlIsNtstatusExpected(). This
*	routine returns a BOOLEAN result. A RC of FALSE will cause us to return
*	EXCEPTION_CONTINUE_SEARCH which will probably cause a panic.
*	The FsRtl.. routine returns FALSE iff exception values are (currently) :
*		STATUS_DATATYPE_MISALIGNMENT	||	STATUS_ACCESS_VIOLATION	||
*		STATUS_ILLEGAL_INSTRUCTION	||	STATUS_INSTRUCTION_MISALIGNMENT
*
* Expected Interrupt Level (for execution) :
*
*  ?
*
* Return Value: EXCEPTION_EXECUTE_HANDLER/EXECEPTION_CONTINUE_SEARCH
*
*************************************************************************/
long NTAPI Ext2ExceptionFilter(
PtrExt2IrpContext			PtrIrpContext,
PEXCEPTION_POINTERS			PtrExceptionPointers )
{
	long							ReturnCode = EXCEPTION_EXECUTE_HANDLER;
	NTSTATUS						ExceptionCode = STATUS_SUCCESS;

	// figure out the exception code
	ExceptionCode = PtrExceptionPointers->ExceptionRecord->ExceptionCode;

	if ((ExceptionCode == STATUS_IN_PAGE_ERROR) && (PtrExceptionPointers->ExceptionRecord->NumberParameters >= 3))
	{
		ExceptionCode = PtrExceptionPointers->ExceptionRecord->ExceptionInformation[2];
	}

	if (PtrIrpContext)
	{
		PtrIrpContext->SavedExceptionCode = ExceptionCode;
		Ext2SetFlag(PtrIrpContext->IrpContextFlags, EXT2_IRP_CONTEXT_EXCEPTION);
	}

	// check if we should propagate this exception or not
	if (!(FsRtlIsNtstatusExpected(ExceptionCode)))
	{
		// we are not ok, propagate this exception.
		//	NOTE: we will bring down the machine ...
		ReturnCode = EXCEPTION_CONTINUE_SEARCH;

		// better free up the IrpContext now ...
		if (PtrIrpContext)
		{
			Ext2ReleaseIrpContext(PtrIrpContext);
		}
	}

	// if you wish to perform some special processing when
	//	not propagating the exception, set up the state for
	//	special processing now ...

	// return the appropriate code
	return(ReturnCode);
}

/*************************************************************************
*
* Function: Ext2ExceptionHandler()
*
* Description:
*	One of the routines in the FSD or in the modules we invoked encountered
*	an exception. We have decided that we will "handle" the exception.
*	Therefore we will prevent the machine from a panic ...
*	You can do pretty much anything you choose to in your commercial
*	driver at this point to ensure a graceful exit. In the sample
*	driver, I will simply free up the IrpContext (if any), set the
*	error code in the IRP and complete the IRP at this time ...
*
* Expected Interrupt Level (for execution) :
*
*  ?
*
* Return Value: Error code
*
*************************************************************************/
NTSTATUS NTAPI Ext2ExceptionHandler(
PtrExt2IrpContext				PtrIrpContext,
PIRP								Irp)
{
	NTSTATUS						RC;

	ASSERT(Irp);

	if (PtrIrpContext)
	{
		RC = PtrIrpContext->SavedExceptionCode;
		// Free irp context here
		Ext2ReleaseIrpContext(PtrIrpContext);
	}
	else
	{
		// must be insufficient resources ...?
		RC = STATUS_INSUFFICIENT_RESOURCES;
	}

	// set the error code in the IRP
	Irp->IoStatus.Status = RC;
	Irp->IoStatus.Information = 0;

	// complete the IRP
	IoCompleteRequest(Irp, IO_NO_INCREMENT);

	return(RC);
}

/*************************************************************************
*
* Function: Ext2LogEvent()
*
* Description:
*	Log a message in the NT Event Log. This is a rather simplistic log
*	methodology since you can potentially utilize the event log to
*	provide a lot of information to the user (and you should too!)
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2LogEvent(
NTSTATUS					Ext2EventLogId,		// the Ext2 private message id
NTSTATUS					RC)						// any NT error code we wish to log ...
{
	try
	{

		// Implement a call to IoAllocateErrorLogEntry() followed by a call
		// to IoWriteErrorLogEntry(). You should note that the call to IoWriteErrorLogEntry()
		// will free memory for the entry once the write completes (which in actuality
		// is an asynchronous operation).

	}
	except (EXCEPTION_EXECUTE_HANDLER)
	{
		// nothing really we can do here, just do not wish to crash ...
		NOTHING;
	}

	return;
}

/*************************************************************************
*
* Function: Ext2AllocateObjectName()
*
* Description:
*	Allocate a new ObjectName structure to represent an open on-disk object.
*	Also initialize the ObjectName structure to NULL.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the ObjectName structure OR NULL.
*
*************************************************************************/
PtrExt2ObjectName NTAPI Ext2AllocateObjectName(
void)
{
	PtrExt2ObjectName			PtrObjectName = NULL;
	BOOLEAN						AllocatedFromZone = TRUE;
	//KIRQL							CurrentIrql;
/*
	// first, try to allocate out of the zone
	KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
	if (!ExIsFullZone(&(Ext2GlobalData.ObjectNameZoneHeader))) {
		// we have enough memory
		PtrObjectName = (PtrExt2ObjectName)ExAllocateFromZone(&(Ext2GlobalData.ObjectNameZoneHeader));

		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	} else {
		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);

		// if we failed to obtain from the zone, get it directly from the VMM
*/
		PtrObjectName = (PtrExt2ObjectName)Ext2AllocatePool(NonPagedPool, Ext2QuadAlign(sizeof(Ext2ObjectName)) );
		AllocatedFromZone = FALSE;
/*
	}
*/
	// if we could not obtain the required memory, bug-check.
	//	Do NOT do this in your commercial driver, instead handle the error gracefully ...
	if (!PtrObjectName)
	{
		Ext2Panic(STATUS_INSUFFICIENT_RESOURCES, Ext2QuadAlign(sizeof(Ext2ObjectName)), 0);
	}

	// zero out the allocated memory block
	RtlZeroMemory( PtrObjectName, Ext2QuadAlign(sizeof(Ext2ObjectName)) );

	// set up some fields ...
	PtrObjectName->NodeIdentifier.NodeType	= EXT2_NODE_TYPE_OBJECT_NAME;
	PtrObjectName->NodeIdentifier.NodeSize	= Ext2QuadAlign(sizeof(Ext2ObjectName));


	if (!AllocatedFromZone)
	{
		Ext2SetFlag(PtrObjectName->ObjectNameFlags, EXT2_OB_NAME_NOT_FROM_ZONE);
	}

	return(PtrObjectName);
}


/*************************************************************************
*
* Function: Ext2ReleaseObjectName()
*
* Description:
*	Deallocate a previously allocated structure.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2ReleaseObjectName(
PtrExt2ObjectName				PtrObjectName)
{
#ifdef USE_ZONES
	KIRQL							CurrentIrql;
#endif

	ASSERT(PtrObjectName);
	PtrObjectName->NodeIdentifier.NodeType = EXT2_NODE_TYPE_FREED;
#ifdef USE_ZONES

	// give back memory either to the zone or to the VMM
	if (!(PtrObjectName->ObjectNameFlags & EXT2_OB_NAME_NOT_FROM_ZONE))
	{
		// back to the zone
		KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
		ExFreeToZone(&(Ext2GlobalData.ObjectNameZoneHeader), PtrObjectName);
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
#endif

	Ext2DeallocateUnicodeString( & PtrObjectName->ObjectName );

	DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrObjectName);
	ExFreePool(PtrObjectName);

#ifdef USE_ZONES
	}
#endif
	return;
}

/*************************************************************************
*
* Function: Ext2AllocateCCB()
*
* Description:
*	Allocate a new CCB structure to represent an open on-disk object.
*	Also initialize the CCB structure to NULL.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the CCB structure OR NULL.
*
*************************************************************************/
PtrExt2CCB NTAPI Ext2AllocateCCB(
void)
{
	PtrExt2CCB					PtrCCB = NULL;
	BOOLEAN						AllocatedFromZone = TRUE;
#ifdef USE_ZONES
	KIRQL							CurrentIrql;
#endif


#ifdef USE_ZONES
   // first, try to allocate out of the zone
	KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
	if (!ExIsFullZone(&(Ext2GlobalData.CCBZoneHeader)))
	{
		// we have enough memory
		PtrCCB = (PtrExt2CCB)ExAllocateFromZone(&(Ext2GlobalData.CCBZoneHeader));

		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
		// if we failed to obtain from the zone, get it directly from the VMM
#endif

		PtrCCB = (PtrExt2CCB)Ext2AllocatePool(NonPagedPool, Ext2QuadAlign(sizeof(Ext2CCB)) );
		AllocatedFromZone = FALSE;

#ifdef USE_ZONES
	}
#endif

	// if we could not obtain the required memory, bug-check.
	//	Do NOT do this in your commercial driver, instead handle the error gracefully ...
	if (!PtrCCB)
	{
		Ext2Panic(STATUS_INSUFFICIENT_RESOURCES, Ext2QuadAlign(sizeof(Ext2CCB)), 0);
	}

	// zero out the allocated memory block
	RtlZeroMemory(PtrCCB, Ext2QuadAlign(sizeof(Ext2CCB)));

	// set up some fields ...
	PtrCCB->NodeIdentifier.NodeType	= EXT2_NODE_TYPE_CCB;
	PtrCCB->NodeIdentifier.NodeSize	= Ext2QuadAlign(sizeof(Ext2CCB));


	if (!AllocatedFromZone)
	{
		Ext2SetFlag(PtrCCB->CCBFlags, EXT2_CCB_NOT_FROM_ZONE);
	}

	return(PtrCCB);
}

/*************************************************************************
*
* Function: Ext2ReleaseCCB()
*
* Description:
*	Deallocate a previously allocated structure.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2ReleaseCCB(
PtrExt2CCB						PtrCCB)
{
#ifdef USE_ZONES
	KIRQL							CurrentIrql;
#endif

	ASSERT( PtrCCB );
	if(PtrCCB->NodeIdentifier.NodeType != EXT2_NODE_TYPE_CCB)
	{
		Ext2Panic( PtrCCB, PtrCCB->NodeIdentifier.NodeType, EXT2_NODE_TYPE_CCB )	;
	}

	Ext2DeallocateUnicodeString( &PtrCCB->DirectorySearchPattern );
	Ext2DeallocateUnicodeString( &PtrCCB->AbsolutePathName );
	Ext2DeallocateUnicodeString( &PtrCCB->RenameLinkTargetFileName );


#ifdef USE_ZONES

	// give back memory either to the zone or to the VMM
	if (!(PtrCCB->CCBFlags & EXT2_CCB_NOT_FROM_ZONE))
	{
		// back to the zone
		KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
		ExFreeToZone(&(Ext2GlobalData.CCBZoneHeader), PtrCCB);
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
#endif
		PtrCCB->NodeIdentifier.NodeType = EXT2_NODE_TYPE_FREED;
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrCCB);
		ExFreePool(PtrCCB);

#ifdef USE_ZONES
	}
#endif

	return;
}

/*************************************************************************
*
* Function: Ext2AllocateFCB()
*
* Description:
*	Allocate a new FCB structure to represent an open on-disk object.
*	Also initialize the FCB structure to NULL.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the FCB structure OR NULL.
*
*************************************************************************/
PtrExt2FCB NTAPI Ext2AllocateFCB(
void)
{
	PtrExt2FCB					PtrFCB = NULL;
	BOOLEAN						AllocatedFromZone = TRUE;
#ifdef USE_ZONES
	KIRQL						CurrentIrql;
#endif

	// first, try to allocate out of the zone
#ifdef USE_ZONES

	KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
	if (!ExIsFullZone(&(Ext2GlobalData.FCBZoneHeader))) {
		// we have enough memory
		PtrFCB = (PtrExt2FCB)ExAllocateFromZone(&(Ext2GlobalData.FCBZoneHeader));

		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	} else {
		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
#endif
		// if we failed to obtain from the zone, get it directly from the VMM
		PtrFCB = (PtrExt2FCB)Ext2AllocatePool(NonPagedPool, Ext2QuadAlign(sizeof(Ext2FCB)) );
		AllocatedFromZone = FALSE;

#ifdef USE_ZONES
	}
#endif

	// if we could not obtain the required memory, bug-check.
	//	Do NOT do this in your commercial driver, instead handle the error gracefully ...
	if (!PtrFCB)
	{
		Ext2Panic(STATUS_INSUFFICIENT_RESOURCES, Ext2QuadAlign(sizeof(Ext2FCB)), 0);
	}

	// zero out the allocated memory block
	RtlZeroMemory(PtrFCB, Ext2QuadAlign(sizeof(Ext2FCB)));

	// set up some fields ...
	PtrFCB->NodeIdentifier.NodeType	= EXT2_NODE_TYPE_FCB;
	PtrFCB->NodeIdentifier.NodeSize	= Ext2QuadAlign(sizeof(Ext2FCB));


	if (!AllocatedFromZone)
	{
		Ext2SetFlag(PtrFCB->FCBFlags, EXT2_FCB_NOT_FROM_ZONE);
	}

	return(PtrFCB);
}


/*************************************************************************
*
* Function: Ext2CreateNewFCB()
*
* Description:
*	We want to create a new FCB. We will also create a new CCB (presumably)
*	later. Simply allocate a new FCB structure and initialize fields
*	appropriately.
*	This function also takes the file size values that the caller must
*	have obtained and	will set the file size fields appropriately in the
*	CommonFCBHeader.
*	Finally, this routine will initialize the FileObject structure passed
*	in to this function. If you decide to fail the call later, remember
*	to uninitialize the fields.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the FCB structure OR NULL.
*
*************************************************************************/
NTSTATUS NTAPI Ext2CreateNewFCB(
PtrExt2FCB				*ReturnedFCB,
LARGE_INTEGER			AllocationSize,
LARGE_INTEGER			EndOfFile,
PFILE_OBJECT			PtrFileObject,
PtrExt2VCB				PtrVCB,
PtrExt2ObjectName		PtrObjectName)
{
	NTSTATUS							RC = STATUS_SUCCESS;

	PtrExt2FCB						PtrFCB = NULL;
	PtrExt2NTRequiredFCB			PtrReqdFCB = NULL;
	PFSRTL_COMMON_FCB_HEADER	PtrCommonFCBHeader = NULL;

	ASSERT( PtrVCB );

	try
	{
		if( !PtrFileObject )
		{
			PtrFCB = Ext2GetUsedFCB( PtrVCB );

		}
		else
		{
			// Obtain a new FCB structure.
			// The function Ext2AllocateFCB() will obtain a new structure either
			// from a zone or from memory requested directly from the VMM.
			PtrFCB = Ext2AllocateFCB();
		}
		if (!PtrFCB)
		{
			// Assume lack of memory.
			try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
		}

		// Initialize fields required to interface with the NT Cache Manager.
		// Note that the returned structure has already been zeroed. This means
		// that the SectionObject structure has been zeroed which is a
		// requirement for newly created FCB structures.
		PtrReqdFCB = &(PtrFCB->NTRequiredFCB);

		// Initialize the MainResource and PagingIoResource structures now.
		ExInitializeResourceLite(&(PtrReqdFCB->MainResource));
		Ext2SetFlag(PtrFCB->FCBFlags, EXT2_INITIALIZED_MAIN_RESOURCE);

		ExInitializeResourceLite(&(PtrReqdFCB->PagingIoResource));
		Ext2SetFlag(PtrFCB->FCBFlags, EXT2_INITIALIZED_PAGING_IO_RESOURCE);

		// Start initializing the fields contained in the CommonFCBHeader.
		PtrCommonFCBHeader = &(PtrReqdFCB->CommonFCBHeader);

		// Disallow fast-IO for now.
		PtrCommonFCBHeader->IsFastIoPossible = FastIoIsNotPossible;

		// Initialize the MainResource and PagingIoResource pointers in
		// the CommonFCBHeader structure to point to the ERESOURCE structures we
		// have allocated and already initialized above.
		PtrCommonFCBHeader->Resource = &(PtrReqdFCB->MainResource);
		PtrCommonFCBHeader->PagingIoResource = &(PtrReqdFCB->PagingIoResource);

		// Ignore the Flags field in the CommonFCBHeader for now. Part 3
		// of the book describes it in greater detail.

		// Initialize the file size values here.
		PtrCommonFCBHeader->AllocationSize = AllocationSize;
		PtrCommonFCBHeader->FileSize = EndOfFile;

		// The following will disable ValidDataLength support. However, your
		// FSD may choose to support this concept.
		PtrCommonFCBHeader->ValidDataLength.LowPart = 0xFFFFFFFF;
		PtrCommonFCBHeader->ValidDataLength.HighPart = 0x7FFFFFFF;

		//	Initialize other fields for the FCB here ...
		PtrFCB->PtrVCB = PtrVCB;

		// caller MUST ensure that VCB has been acquired exclusively
		InsertTailList(&(PtrVCB->FCBListHead), &(PtrFCB->NextFCB));


		InitializeListHead(&(PtrFCB->CCBListHead));

		// Initialize fields contained in the file object now.
		if( PtrFileObject )
		{
			PtrFileObject->PrivateCacheMap = NULL;
			// Note that we could have just as well taken the value of PtrReqdFCB
			// directly below. The bottom line however is that the FsContext
			// field must point to a FSRTL_COMMON_FCB_HEADER structure.
			PtrFileObject->FsContext = (void *)(PtrCommonFCBHeader);
			PtrFileObject->SectionObjectPointer = &(PtrFCB->NTRequiredFCB.SectionObject) ;
		}

		//	Initialising the object name...
		PtrFCB->FCBName = PtrObjectName;

		//	Returning the FCB...
		*ReturnedFCB = PtrFCB;
		try_exit:	NOTHING;
	}

	finally
	{

	}

	return(RC);
}


/*************************************************************************
*
* Function: Ext2ReleaseFCB()
*
* Description:
*	Deallocate a previously allocated structure.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2ReleaseFCB(
PtrExt2FCB						PtrFCB)
{
	//KIRQL							CurrentIrql;

	AssertFCB( PtrFCB );

	if( PtrFCB->NodeIdentifier.NodeType != EXT2_NODE_TYPE_FCB )
	{
		Ext2Panic( PtrFCB, PtrFCB->NodeIdentifier.NodeType, EXT2_NODE_TYPE_FCB )	;
	}


	PtrFCB->NodeIdentifier.NodeType = EXT2_NODE_TYPE_FREED;

	/*
	  // give back memory either to the zone or to the VMM
	if (!(PtrFCB->FCBFlags & EXT2_FCB_NOT_FROM_ZONE))
	{
		// back to the zone
		KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
		ExFreeToZone(&(Ext2GlobalData.FCBZoneHeader), PtrFCB);
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
	*/

	ExDeleteResourceLite( &PtrFCB->NTRequiredFCB.MainResource );
	ExDeleteResourceLite( &PtrFCB->NTRequiredFCB.PagingIoResource );

	RemoveEntryList(&(PtrFCB->NextFCB));

	if( PtrFCB->FCBName )
	{
		Ext2ReleaseObjectName( PtrFCB->FCBName );
	}

	DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrFCB);
	ExFreePool(PtrFCB);

	/*
	}
	*/

	return;
}

/*************************************************************************
*
* Function: Ext2AllocateByteLocks()
*
* Description:
*	Allocate a new byte range lock structure and initialize it to NULL.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the Ext2ByteLocks structure OR NULL.
*
*************************************************************************/
PtrExt2FileLockInfo NTAPI Ext2AllocateByteLocks(
void)
{
	PtrExt2FileLockInfo		PtrByteLocks = NULL;
	BOOLEAN						AllocatedFromZone = TRUE;
   KIRQL							CurrentIrql;

	// first, try to allocate out of the zone
	KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
	if (!ExIsFullZone(&(Ext2GlobalData.ByteLockZoneHeader)))
	{
		// we have enough memory
		PtrByteLocks = (PtrExt2FileLockInfo)ExAllocateFromZone(&(Ext2GlobalData.ByteLockZoneHeader));

		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);

		// if we failed to obtain from the zone, get it directly from the VMM
		PtrByteLocks = (PtrExt2FileLockInfo)Ext2AllocatePool(NonPagedPool, Ext2QuadAlign(sizeof(Ext2FileLockInfo)) );
		AllocatedFromZone = FALSE;
	}

	// if we could not obtain the required memory, bug-check.
	//	Do NOT do this in your commercial driver, instead handle the error gracefully ...
	if (!PtrByteLocks)
	{
		Ext2Panic(STATUS_INSUFFICIENT_RESOURCES, Ext2QuadAlign(sizeof(Ext2FileLockInfo)), 0);
	}

	// zero out the allocated memory block
	RtlZeroMemory(PtrByteLocks, Ext2QuadAlign(sizeof(PtrExt2FileLockInfo)));

	if (!AllocatedFromZone)
	{
		Ext2SetFlag(PtrByteLocks->FileLockFlags, EXT2_BYTE_LOCK_NOT_FROM_ZONE);
	}

	return(PtrByteLocks);
}

/*************************************************************************
*
* Function: Ext2ReleaseByteLocks()
*
* Description:
*	Deallocate a previously allocated structure.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2ReleaseByteLocks(
PtrExt2FileLockInfo					PtrByteLocks)
{
	KIRQL							CurrentIrql;

	ASSERT(PtrByteLocks);

	// give back memory either to the zone or to the VMM
	if (!(PtrByteLocks->FileLockFlags & EXT2_BYTE_LOCK_NOT_FROM_ZONE)) {
		// back to the zone
		KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
      ExFreeToZone(&(Ext2GlobalData.ByteLockZoneHeader), PtrByteLocks);
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrByteLocks);
		ExFreePool(PtrByteLocks);
	}

	return;
}


/*************************************************************************
*
* Function: Ext2AllocateIrpContext()
*
* Description:
*	The sample FSD creates an IRP context for each request received. This
*	routine simply allocates (and initializes to NULL) a Ext2IrpContext
*	structure.
*	Most of the fields in the context structure are then initialized here.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the IrpContext structure OR NULL.
*
*************************************************************************/
PtrExt2IrpContext NTAPI Ext2AllocateIrpContext(
PIRP					Irp,
PDEVICE_OBJECT		PtrTargetDeviceObject)
{
	PtrExt2IrpContext			PtrIrpContext = NULL;
	BOOLEAN						AllocatedFromZone = TRUE;
	//KIRQL							CurrentIrql;
	PIO_STACK_LOCATION		PtrIoStackLocation = NULL;

	/*
	//	Allocation from zone not done at present...

	// first, try to allocate out of the zone
	KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
	if (!ExIsFullZone(&(Ext2GlobalData.IrpContextZoneHeader))) {
		// we have enough memory
		PtrIrpContext = (PtrExt2IrpContext)ExAllocateFromZone(&(Ext2GlobalData.IrpContextZoneHeader));

		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	} else {
		// release the spinlock
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);


		// if we failed to obtain from the zone, get it directly from the VMM
		PtrIrpContext = (PtrExt2IrpContext)Ext2AllocatePool(NonPagedPool, Ext2QuadAlign(sizeof(Ext2IrpContext)) );
        AllocatedFromZone = FALSE;
	}

	//No Zone handling for now
	*/

	PtrIrpContext = (PtrExt2IrpContext)Ext2AllocatePool(NonPagedPool, Ext2QuadAlign(sizeof(Ext2IrpContext)) );
    AllocatedFromZone = FALSE;

	// if we could not obtain the required memory, bug-check.
	//	Do NOT do this in your commercial driver, instead handle	the error gracefully ...
	if (!PtrIrpContext)
	{
		Ext2Panic(STATUS_INSUFFICIENT_RESOURCES, Ext2QuadAlign(sizeof(Ext2IrpContext)), 0);
	}

	// zero out the allocated memory block
	RtlZeroMemory(PtrIrpContext, Ext2QuadAlign(sizeof(Ext2IrpContext)));

	// set up some fields ...
	PtrIrpContext->NodeIdentifier.NodeType	= EXT2_NODE_TYPE_IRP_CONTEXT;
	PtrIrpContext->NodeIdentifier.NodeSize	= Ext2QuadAlign(sizeof(Ext2IrpContext));


	PtrIrpContext->Irp = Irp;
	PtrIrpContext->TargetDeviceObject = PtrTargetDeviceObject;

	// copy over some fields from the IRP and set appropriate flag values
	if (Irp)
	{
		PtrIoStackLocation = IoGetCurrentIrpStackLocation(Irp);
		ASSERT(PtrIoStackLocation);

		PtrIrpContext->MajorFunction = PtrIoStackLocation->MajorFunction;
		PtrIrpContext->MinorFunction = PtrIoStackLocation->MinorFunction;

		// Often, a FSD cannot honor a request for asynchronous processing
		// of certain critical requests. For example, a "close" request on
		// a file object can typically never be deferred. Therefore, do not
		// be surprised if sometimes your FSD (just like all other FSD
		// implementations on the Windows NT system) has to override the flag
		// below.
		if( PtrIoStackLocation->FileObject )
		{
			if (IoIsOperationSynchronous(Irp) )
			{
				Ext2SetFlag(PtrIrpContext->IrpContextFlags, EXT2_IRP_CONTEXT_CAN_BLOCK);
			}
		}
		else
		{
			Ext2SetFlag(PtrIrpContext->IrpContextFlags, EXT2_IRP_CONTEXT_CAN_BLOCK);
		}
	}

	if (!AllocatedFromZone)
	{
		Ext2SetFlag(PtrIrpContext->IrpContextFlags, EXT2_IRP_CONTEXT_NOT_FROM_ZONE);
	}

	// Are we top-level ? This information is used by the dispatching code
	// later (and also by the FSD dispatch routine)
	if (IoGetTopLevelIrp() != Irp)
	{
		// We are not top-level. Note this fact in the context structure
		Ext2SetFlag(PtrIrpContext->IrpContextFlags, EXT2_IRP_CONTEXT_NOT_TOP_LEVEL);
	}

	InitializeListHead( &PtrIrpContext->SavedBCBsListHead );

	return(PtrIrpContext);
}


/*************************************************************************
*
* Function: Ext2ReleaseIrpContext()
*
* Description:
*	Deallocate a previously allocated structure.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2ReleaseIrpContext(
PtrExt2IrpContext					PtrIrpContext)
{
	KIRQL							CurrentIrql;

	ASSERT(PtrIrpContext);

	//	Flush the saved BCBs...
	Ext2FlushSavedBCBs( PtrIrpContext );

	// give back memory either to the zone or to the VMM
	if (!(PtrIrpContext->IrpContextFlags & EXT2_IRP_CONTEXT_NOT_FROM_ZONE))
	{
		// back to the zone
		KeAcquireSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), &CurrentIrql);
		ExFreeToZone(&(Ext2GlobalData.IrpContextZoneHeader), PtrIrpContext);
		KeReleaseSpinLock(&(Ext2GlobalData.ZoneAllocationSpinLock), CurrentIrql);
	}
	else
	{
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrIrpContext);
		ExFreePool(PtrIrpContext);
	}

	return;
}

/*************************************************************************
*
* Function: Ext2PostRequest()
*
* Description:
*	Queue up a request for deferred processing (in the context of a system
*	worker thread). The caller must have locked the user buffer (if required)
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: STATUS_PENDING
*
*************************************************************************/
NTSTATUS NTAPI Ext2PostRequest(
PtrExt2IrpContext			PtrIrpContext,
PIRP							PtrIrp)
{
	NTSTATUS			RC = STATUS_PENDING;

	DebugTrace(DEBUG_TRACE_ASYNC, " === Asynchronous request. Deferring processing", 0);

	// mark the IRP pending
	IoMarkIrpPending(PtrIrp);

	// queue up the request
	ExInterlockedInsertTailList(
		&Ext2GlobalData.ThreadQueue.ThreadQueueListHead,
		&PtrIrpContext->ThreadQueueListEntry,
		&Ext2GlobalData.ThreadQueue.SpinLock );

	KeSetEvent( &Ext2GlobalData.ThreadQueue.QueueEvent, 0, FALSE );


/*****************		not using system worker threads		*****************
	ExInitializeWorkItem(&(PtrIrpContext->WorkQueueItem), Ext2CommonDispatch, PtrIrpContext);
	ExQueueWorkItem( &( PtrIrpContext->WorkQueueItem ), DelayedWorkQueue );
	//	CriticalWorkQueue
*****************************************************************************/

	// return status pending
	return(RC);
}


/*************************************************************************
*
* Function: Ext2CommonDispatch()
*
* Description:
*	The common dispatch routine invoked in the context of a system worker
*	thread. All we do here is pretty much case off the major function
*	code and invoke the appropriate FSD dispatch routine for further
*	processing.
*
* Expected Interrupt Level (for execution) :
*
*	IRQL PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2CommonDispatch(
			void		*Context )	// actually an IRPContext structure
{
	NTSTATUS						RC = STATUS_SUCCESS;
	PtrExt2IrpContext			PtrIrpContext = NULL;
	PIRP							PtrIrp = NULL;

	// The context must be a pointer to an IrpContext structure
	PtrIrpContext = (PtrExt2IrpContext)Context;
	ASSERT(PtrIrpContext);

	// Assert that the Context is legitimate
	if ((PtrIrpContext->NodeIdentifier.NodeType != EXT2_NODE_TYPE_IRP_CONTEXT) || (PtrIrpContext->NodeIdentifier.NodeSize != Ext2QuadAlign(sizeof(Ext2IrpContext))))
	{
		// This does not look good
		Ext2Panic(EXT2_ERROR_INTERNAL_ERROR, PtrIrpContext->NodeIdentifier.NodeType, PtrIrpContext->NodeIdentifier.NodeSize);
	}

	//	Get a pointer to the IRP structure
	PtrIrp = PtrIrpContext->Irp;
	ASSERT(PtrIrp);

	// Now, check if the FSD was top level when the IRP was originally invoked
	// and set the thread context (for the worker thread) appropriately
	if (PtrIrpContext->IrpContextFlags & EXT2_IRP_CONTEXT_NOT_TOP_LEVEL)
	{
		// The FSD is not top level for the original request
		// Set a constant value in TLS to reflect this fact
		IoSetTopLevelIrp((PIRP)FSRTL_FSP_TOP_LEVEL_IRP);
	}

	// Since the FSD routine will now be invoked in the context of this worker
	// thread, we should inform the FSD that it is perfectly OK to block in
	// the context of this thread
	Ext2SetFlag(PtrIrpContext->IrpContextFlags, EXT2_IRP_CONTEXT_CAN_BLOCK);

	FsRtlEnterFileSystem();

	try
	{

		// Pre-processing has been completed; check the Major Function code value
		// either in the IrpContext (copied from the IRP), or directly from the
		//	IRP itself (we will need a pointer to the stack location to do that),
		//	Then, switch based on the value on the Major Function code
		switch (PtrIrpContext->MajorFunction)
		{
		case IRP_MJ_CREATE:
			// Invoke the common create routine
			DebugTrace(DEBUG_TRACE_ASYNC,   " === Serviceing IRP_MJ_CREATE request asynchronously .", 0);
			(void)Ext2CommonCreate(PtrIrpContext, PtrIrp, FALSE);
			break;
		case IRP_MJ_READ:
			// Invoke the common read routine
			DebugTrace(DEBUG_TRACE_ASYNC,   " === Serviceing IRP_MJ_READ request asynchronously .", 0);
			(void)Ext2CommonRead(PtrIrpContext, PtrIrp, FALSE);
			break;
		case IRP_MJ_WRITE:
			// Invoke the common write routine
			DebugTrace(DEBUG_TRACE_ASYNC,   " === Serviceing IRP_MJ_WRITE request asynchronously .", 0);
			(void)Ext2CommonWrite(PtrIrpContext, PtrIrp );
			break;

		case IRP_MJ_CLEANUP:
			// Invoke the common read routine
			DebugTrace(DEBUG_TRACE_ASYNC,   " === Serviceing IRP_MJ_CLEANUP request asynchronously .", 0);
			(void)Ext2CommonCleanup(PtrIrpContext, PtrIrp, FALSE);
			break;
		case IRP_MJ_CLOSE:
			// Invoke the common read routine
			DebugTrace(DEBUG_TRACE_ASYNC,   " === Serviceing IRP_MJ_CLOSE request asynchronously .", 0);
			(void)Ext2CommonClose ( PtrIrpContext, PtrIrp, FALSE );
			break;

		// Continue with the remaining possible dispatch routines below ...
		default:
			// This is the case where we have an invalid major function
			DebugTrace(DEBUG_TRACE_ASYNC,   " === Serviceing asynchronous request. \nUnable to recoganise the IRP!!! How can this be!!!", 0);
			PtrIrp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST;
			PtrIrp->IoStatus.Information = 0;

			Ext2BreakPoint();

			IoCompleteRequest(PtrIrp, IO_NO_INCREMENT);
			break;
		}
	}
	except (Ext2ExceptionFilter(PtrIrpContext, GetExceptionInformation()))
	{
		RC = Ext2ExceptionHandler(PtrIrpContext, PtrIrp);
		Ext2LogEvent(EXT2_ERROR_INTERNAL_ERROR, RC);
	}

	// Enable preemption
	FsRtlExitFileSystem();

	// Ensure that the "top-level" field is cleared
	IoSetTopLevelIrp(NULL);

	PsTerminateSystemThread( RC );


	return;
}

/*************************************************************************
*
* Function: Ext2InitializeVCB()
*
* Description:
*	Perform the initialization for a VCB structure.
*
* Expected Interrupt Level (for execution) :
*
*	IRQL PASSIVE_LEVEL
*
* Return Value: None
*
*************************************************************************/
void NTAPI Ext2InitializeVCB(
PDEVICE_OBJECT			PtrVolumeDeviceObject,
PDEVICE_OBJECT			PtrTargetDeviceObject,
PVPB					PtrVPB,
PLARGE_INTEGER			AllocationSize )
{
	NTSTATUS				RC = STATUS_SUCCESS;
	PtrExt2VCB			PtrVCB = NULL;
	BOOLEAN				VCBResourceInitialized = FALSE;

	PtrVCB = (PtrExt2VCB)(PtrVolumeDeviceObject->DeviceExtension);

	// Zero it out (typically this has already been done by the I/O
	// Manager but it does not hurt to do it again)!
	RtlZeroMemory(PtrVCB, sizeof(Ext2VCB));

	// Initialize the signature fields
	PtrVCB->NodeIdentifier.NodeType = EXT2_NODE_TYPE_VCB;
	PtrVCB->NodeIdentifier.NodeSize = sizeof(Ext2VCB);

	// Initialize the ERESOURCE objects.
	RC = ExInitializeResourceLite(&(PtrVCB->VCBResource));
	RC = ExInitializeResourceLite(&(PtrVCB->PagingIoResource));

	ASSERT(NT_SUCCESS(RC));
	VCBResourceInitialized = TRUE;

	PtrVCB->TargetDeviceObject = PtrTargetDeviceObject;

	PtrVCB->VCBDeviceObject = PtrVolumeDeviceObject;

	PtrVCB->PtrVPB = PtrVPB;

	// Initialize the list anchor (head) for some lists in this VCB.
	InitializeListHead(&(PtrVCB->FCBListHead));
	InitializeListHead(&(PtrVCB->NextNotifyIRP));
	InitializeListHead(&(PtrVCB->VolumeOpenListHead));
	InitializeListHead(&(PtrVCB->ClosableFCBs.ClosableFCBListHead));
	PtrVCB->ClosableFCBs.Count = 0;

	// Initialize the notify IRP list mutex
	KeInitializeMutex(&(PtrVCB->NotifyIRPMutex), 0);

	// Set the initial file size values appropriately. Note that your FSD may
	// wish to guess at the initial amount of information you would like to
	// read from the disk until you have really determined that this a valid
	// logical volume (on disk) that you wish to mount.
	PtrVCB->CommonVCBHeader.AllocationSize.QuadPart = AllocationSize->QuadPart;

	PtrVCB->CommonVCBHeader.FileSize.QuadPart = AllocationSize->QuadPart;
	// You typically do not want to bother with valid data length callbacks
	// from the Cache Manager for the file stream opened for volume metadata
	// information
	PtrVCB->CommonVCBHeader.ValidDataLength.LowPart = 0xFFFFFFFF;
	PtrVCB->CommonVCBHeader.ValidDataLength.HighPart = 0x7FFFFFFF;

	PtrVCB->CommonVCBHeader.IsFastIoPossible = FastIoIsNotPossible;

	PtrVCB->CommonVCBHeader.Resource = &(PtrVCB->VCBResource);
	PtrVCB->CommonVCBHeader.PagingIoResource = &(PtrVCB->PagingIoResource);

	// Create a stream file object for this volume.
	PtrVCB->PtrStreamFileObject = IoCreateStreamFileObject(NULL,
												PtrVCB->PtrVPB->RealDevice);
	ASSERT(PtrVCB->PtrStreamFileObject);

	// Initialize some important fields in the newly created file object.
	PtrVCB->PtrStreamFileObject->FsContext = (void *)(&PtrVCB->CommonVCBHeader);
	PtrVCB->PtrStreamFileObject->FsContext2 = NULL;
	PtrVCB->PtrStreamFileObject->SectionObjectPointer = &(PtrVCB->SectionObject);

	PtrVCB->PtrStreamFileObject->Vpb = PtrVPB;
	PtrVCB->PtrStreamFileObject->ReadAccess = TRUE;
	PtrVCB->PtrStreamFileObject->WriteAccess = TRUE;

	// Link this chap onto the global linked list of all VCB structures.
	DebugTrace(DEBUG_TRACE_MISC,   "*** Attempting to acquire Global Resource Exclusively [FileInfo]", 0);
	ExAcquireResourceExclusiveLite(&(Ext2GlobalData.GlobalDataResource), TRUE);
	InsertTailList(&(Ext2GlobalData.NextVCB), &(PtrVCB->NextVCB));
	DebugTrace(DEBUG_TRACE_MISC,   "*** Global Resource Acquired [FileInfo]", 0);


	// Initialize caching for the stream file object.
	CcInitializeCacheMap(PtrVCB->PtrStreamFileObject, (PCC_FILE_SIZES)(&(PtrVCB->CommonVCBHeader.AllocationSize)),
								TRUE,		// We will use pinned access.
								&(Ext2GlobalData.CacheMgrCallBacks), PtrVCB );


	Ext2ReleaseResource(&(Ext2GlobalData.GlobalDataResource));
	DebugTrace(DEBUG_TRACE_MISC,   "*** Global Resource Released[FileInfo]", 0);

	// Mark the fact that this VCB structure is initialized.
	Ext2SetFlag(PtrVCB->VCBFlags, EXT2_VCB_FLAGS_VCB_INITIALIZED);
	PtrVCB->PtrGroupDescriptors = NULL;
	PtrVCB->NoOfGroups = 0;
	return;
}


/*************************************************************************
*
* Function: Ext2CompleteRequest()
*
* Description:
*	This routine completes a Irp.
*
* Expected Interrupt Level (for execution) :
*
*   ???
*
* Arguments:
*
*   Irp - Supplies the Irp being processed
*
*   Status - Supplies the status to complete the Irp with
*
* Return Value: none
*
*************************************************************************/
void NTAPI Ext2CompleteRequest(
    IN PIRP Irp OPTIONAL,
    IN NTSTATUS Status
    )
{
	//
    //  If we have an Irp then complete the irp.
    //

    if (Irp != NULL)
	{

        //
        //  We got an error, so zero out the information field before
        //  completing the request if this was an input operation.
        //  Otherwise IopCompleteRequest will try to copy to the user's buffer.
        //

        if ( NT_ERROR(Status) &&
             FlagOn(Irp->Flags, IRP_INPUT_OPERATION) ) {

            Irp->IoStatus.Information = 0;
        }

        Irp->IoStatus.Status = Status;

        IoCompleteRequest( Irp, IO_DISK_INCREMENT );
    }
    return;
}


/*************************************************************************
*
* Function: Ext2CreateNewCCB()
*
* Description:
*	We want to create a new CCB.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: A pointer to the CCB structure OR NULL.
*
*************************************************************************/
NTSTATUS NTAPI Ext2CreateNewCCB(
	PtrExt2CCB				*ReturnedCCB,
	PtrExt2FCB				PtrFCB,
	PFILE_OBJECT			PtrFileObject )
{
	PtrExt2CCB  PtrCCB;
	NTSTATUS RC = STATUS_SUCCESS;

	try
	{

		PtrCCB = Ext2AllocateCCB();
		if (!PtrFCB)
		{
			// Assume lack of memory.
			try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
		}
		PtrCCB->PtrFCB = PtrFCB;

		PtrCCB->PtrFileObject = PtrFileObject;
		PtrCCB->CurrentByteOffset.QuadPart = 0;

		if( PtrFCB->ClosableFCBs.OnClosableFCBList )
		{
			//	This FCB was on the Closable List...
			//	Taking it off the list...
			//
			RemoveEntryList( &PtrFCB->ClosableFCBs.ClosableFCBList );
			PtrFCB->ClosableFCBs.OnClosableFCBList = FALSE;
			PtrFCB->PtrVCB->ClosableFCBs.Count --;
		}

		InterlockedIncrement( &PtrFCB->ReferenceCount );
		InterlockedIncrement( &PtrFCB->OpenHandleCount );

		InsertTailList( &( PtrFCB->CCBListHead ), &(PtrCCB->NextCCB));

		*ReturnedCCB = PtrCCB;
		try_exit:	NOTHING;
	}
	finally
	{

	}

	return(RC);
}


/*************************************************************************
*
* Function: Ext2DenyAccess()
*
* Description:
*	We want to deny access to an IRP
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL
*
* Return Value: NTSTATUS - STATUS_ACCESS_DENIED (always)
*
*************************************************************************/
NTSTATUS NTAPI Ext2DenyAccess( IN PIRP Irp )
{
    ASSERT( Irp );

	//	Just return Access Denied
	Irp->IoStatus.Information = 0;
	Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
	IoCompleteRequest( Irp, IO_DISK_INCREMENT );

	DebugTrace(DEBUG_TRACE_MISC,   "DENYING ACCESS (this will do for now!)...", 0);

	return STATUS_ACCESS_DENIED;
}


/*************************************************************************
*
* Function: Ext2GetFCB_CCB_VCB_FromFileObject()
*
* Description:
*	This routine retrieves the FCB, CCB and VCB from the File Object...
*
* Expected Interrupt Level (for execution) :
*
*  ?
*
* Return Value: NTSTATUS - STATUS_SUCCESS(always)
*
*************************************************************************/
NTSTATUS NTAPI Ext2GetFCB_CCB_VCB_FromFileObject (
	IN PFILE_OBJECT			PtrFileObject,
	OUT PtrExt2FCB				*PPtrFCB,
	OUT PtrExt2CCB				*PPtrCCB,
	OUT PtrExt2VCB				*PPtrVCB	)
{
		(*PPtrCCB) = (PtrExt2CCB)(PtrFileObject->FsContext2);
		if( *PPtrCCB )
		{
			ASSERT((*PPtrCCB)->NodeIdentifier.NodeType == EXT2_NODE_TYPE_CCB);
			(*PPtrFCB) = (*PPtrCCB)->PtrFCB;

			ASSERT((*PPtrFCB));

			if ((*PPtrFCB)->NodeIdentifier.NodeType == EXT2_NODE_TYPE_VCB)
			{
				(*PPtrVCB) = (PtrExt2VCB)(*PPtrFCB);
				AssertVCB( (*PPtrVCB) );

				//	No FCB
				(*PPtrFCB) = NULL;
				//found a VCB
			}
			else
			{
				AssertFCB( (*PPtrFCB) );
				(*PPtrVCB) = (*PPtrFCB)->PtrVCB;
				AssertVCB( (*PPtrVCB) );

			}
		}
		else
		{
			//	PtrFileObject->FsContext points to NTRequiredFCB
			(*PPtrFCB) = CONTAINING_RECORD( PtrFileObject->FsContext, Ext2FCB, NTRequiredFCB );
			ASSERT((*PPtrFCB));
			//(*PPtrFCB) = PtrFileObject->FsContext;

			if ((*PPtrFCB)->NodeIdentifier.NodeType == EXT2_NODE_TYPE_FCB)
			{
				//	Making sure I got it right...
				AssertFCB( *PPtrFCB );
				(*PPtrVCB) = (*PPtrFCB)->PtrVCB;
				AssertVCB( *PPtrVCB );
			}
			else
			{
				//	This should be a VCB

				(*PPtrVCB) = CONTAINING_RECORD( PtrFileObject->FsContext, Ext2VCB, CommonVCBHeader );
				AssertVCB( *PPtrVCB );

				//	No FCB
				(*PPtrFCB) = NULL;
				//found a VCB
			}

		}
	return STATUS_SUCCESS;
}


void NTAPI Ext2CopyUnicodeString( PUNICODE_STRING  PtrDestinationString, PUNICODE_STRING PtrSourceString )
{
	int Count;
	//	Allcating space for Destination...
	PtrDestinationString->Length = PtrSourceString->Length;
	PtrDestinationString->MaximumLength = Ext2QuadAlign( PtrSourceString->Length + 2 );
	PtrDestinationString->Buffer = Ext2AllocatePool( NonPagedPool, PtrDestinationString->MaximumLength );

	//	RtlCopyUnicodeString( PtrDestinationString, PtrSourceString );

	for( Count = 0 ; Count < (PtrSourceString->Length/2) ; Count++ )
	{
		PtrDestinationString->Buffer[Count] = PtrSourceString->Buffer[Count];
	}
	PtrDestinationString->Buffer[Count] = 0;

}

void NTAPI Ext2CopyWideCharToUnicodeString(
	PUNICODE_STRING  PtrDestinationString,
	PCWSTR PtrSourceString )
{

	int Count;

	//	Determining length...
	for( Count = 0 ; PtrSourceString[Count] != 0 ; Count++ );

	//	Allcating space for Destination...
	PtrDestinationString->Length = Count * 2;
	PtrDestinationString->MaximumLength = Ext2QuadAlign( Count * 2 + 2 );
	PtrDestinationString->Buffer = Ext2AllocatePool( NonPagedPool, PtrDestinationString->MaximumLength  );

	//	Copying the string over...
	for( Count = 0 ; ; Count++ )
	{
		PtrDestinationString->Buffer[Count] = PtrSourceString[Count];
		if( PtrSourceString[Count] == 0 )
			break;
	}
}


void NTAPI Ext2CopyCharToUnicodeString(
	PUNICODE_STRING  PtrDestinationString,
	PCSTR PtrSourceString,
	USHORT SourceStringLength )
{
	int Count;
	//	Allcating space for Destination...
	PtrDestinationString->Length = SourceStringLength * 2;
	PtrDestinationString->MaximumLength = Ext2QuadAlign( SourceStringLength * 2 + 2 );
	PtrDestinationString->Buffer = Ext2AllocatePool( NonPagedPool, PtrDestinationString->MaximumLength  );

	//	Copying the string over...
	for( Count = 0 ; Count < SourceStringLength ; Count++ )
	{
		PtrDestinationString->Buffer[Count] = PtrSourceString[Count];
	}
	PtrDestinationString->Buffer[Count] = 0;

}

void NTAPI Ext2CopyZCharToUnicodeString( PUNICODE_STRING  PtrDestinationString, PCSTR PtrSourceString )
{

	int Count;

	//	Determining length...
	for( Count = 0 ; PtrSourceString[Count] != 0 ; Count++ );

	//	Allcating space for Destination...
	PtrDestinationString->Length = Count * 2;
	PtrDestinationString->MaximumLength = Ext2QuadAlign( Count * 2 + 2 );
	PtrDestinationString->Buffer = Ext2AllocatePool( NonPagedPool, PtrDestinationString->MaximumLength  );

	//	Copying the string over...
	for( Count = 0 ; ; Count++ )
	{
		PtrDestinationString->Buffer[Count] = PtrSourceString[Count];
		if( PtrSourceString[Count] == 0 )
			break;
	}
}

void NTAPI Ext2ZerooutUnicodeString( PUNICODE_STRING PtrUnicodeString )
{
	PtrUnicodeString->Length = 0;
	PtrUnicodeString->MaximumLength =0;
	PtrUnicodeString->Buffer = 0;
}

void NTAPI Ext2DeallocateUnicodeString( PUNICODE_STRING PtrUnicodeString )
{
	if( PtrUnicodeString && PtrUnicodeString->Buffer )
	{
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrUnicodeString->Buffer );
		ExFreePool( PtrUnicodeString->Buffer );
	}
	PtrUnicodeString->Length = 0;
	PtrUnicodeString->MaximumLength =0;
	PtrUnicodeString->Buffer = 0;
}

PtrExt2FCB NTAPI Ext2GetUsedFCB(
	PtrExt2VCB	PtrVCB )
{

	BOOLEAN			AllocatedFromZone = FALSE;
	PLIST_ENTRY		PtrEntry = NULL;
	PtrExt2FCB		PtrFCB = NULL;

	ASSERT( PtrVCB );
	if( PtrVCB->ClosableFCBs.Count < EXT2_MAXCLOSABLE_FCBS_LL )
	{
		//
		//	Too few Closable FCBs
		//	Will not reuse any FCBs
		//	Allocating a new one
		//
		return Ext2AllocateFCB();
	}
	//
	//	Obtaining a used FCB...
	//

	//	Retrieving the first entry in the closable FCB list...

	PtrEntry = RemoveHeadList( &PtrVCB->ClosableFCBs.ClosableFCBListHead );

	PtrFCB = CONTAINING_RECORD( PtrEntry, Ext2FCB, ClosableFCBs.ClosableFCBList );

	//	Remembering if the FCB was allocated from the Zone...
	AllocatedFromZone = Ext2IsFlagOn( PtrFCB->FCBFlags, EXT2_FCB_NOT_FROM_ZONE );

	//
	//	Close this FCB
	//
	if( !Ext2CloseClosableFCB( PtrFCB ) )
	{
		//	Couldn't close the FCB!!
		//
		InsertHeadList( &PtrVCB->ClosableFCBs.ClosableFCBListHead,
			&PtrFCB->ClosableFCBs.ClosableFCBList );
		return Ext2AllocateFCB();
	}

	PtrVCB->ClosableFCBs.Count--;
	DebugTrace( DEBUG_TRACE_SPECIAL, "Count = %ld [Ext2GetUsedFCB]", PtrVCB->ClosableFCBs.Count );

	//
	//	Getting the FCB ready for reuse by
	//	zeroing it out...
	//
	RtlZeroMemory(PtrFCB, Ext2QuadAlign(sizeof(Ext2FCB)));

	// set up some fields ...
	PtrFCB->NodeIdentifier.NodeType	= EXT2_NODE_TYPE_FCB;
	PtrFCB->NodeIdentifier.NodeSize	= Ext2QuadAlign(sizeof(Ext2FCB));


	if (!AllocatedFromZone)
	{
		Ext2SetFlag(PtrFCB->FCBFlags, EXT2_FCB_NOT_FROM_ZONE);
	}

	return PtrFCB;
}

BOOLEAN NTAPI Ext2CloseClosableFCB(
	PtrExt2FCB		PtrFCB)
{
	KIRQL			Irql = 0;
	PFILE_OBJECT	PtrFileObject = NULL;

	AssertFCB( PtrFCB );

	//	Attempting to acquire the FCB Exclusively...
	if(! ExAcquireResourceExclusiveLite( &(PtrFCB->NTRequiredFCB.MainResource ), FALSE ) )
	{
		Ext2BreakPoint();
		return  FALSE;
	}

	Irql = KeGetCurrentIrql( );

	if( PtrFCB->ReferenceCount )
	{
		//	How the hell can this happen!!!
		Ext2BreakPoint();
	}
	if( PtrFCB->OpenHandleCount )
	{
		//	How the hell can this happen!!!
		Ext2BreakPoint();
	}

	//	Deleting entry from VCB's FCB list...
	RemoveEntryList( &PtrFCB->NextFCB );

	PtrFCB->NodeIdentifier.NodeType = EXT2_NODE_TYPE_FREED;

	PtrFileObject = PtrFCB->DcbFcb.Dcb.PtrDirFileObject;

	if ( PtrFileObject )
	{
		//
		//	Clear the Cache Map...
		//
		if( PtrFileObject->PrivateCacheMap != NULL)
		{
			IO_STATUS_BLOCK Status;
			DebugTrace( DEBUG_TRACE_SPECIAL, ">>.........Flushing cache.........<<", 0 );
			CcFlushCache( PtrFileObject->SectionObjectPointer, NULL, 0, &Status );
			CcUninitializeCacheMap( PtrFileObject, NULL, NULL );
		}
		//
		//	The File Object is no longer required...
		//	Close it by dereferenceing it!!!
		//
		PtrFileObject->FsContext	= NULL;
		PtrFileObject->FsContext2	= NULL;
		ObDereferenceObject( PtrFileObject );

		PtrFCB->DcbFcb.Dcb.PtrDirFileObject = NULL;
		PtrFileObject = NULL;
	}

	//	Uninitialize the Resources...
	ExDeleteResourceLite( &PtrFCB->NTRequiredFCB.MainResource );
	ExDeleteResourceLite( &PtrFCB->NTRequiredFCB.PagingIoResource );

	//
	//	Releasing the FCB Name Object...
	//
	if( PtrFCB->FCBName )
	{
		DebugTrace( DEBUG_TRACE_SPECIAL, "Reusing FCB - File Name %S", PtrFCB->FCBName->ObjectName.Buffer );
		Ext2ReleaseObjectName( PtrFCB->FCBName );
	}
	else
	{
		DebugTrace( DEBUG_TRACE_SPECIAL, "Reusing FCB - File Name *Unknown*", 0 );
	}
	return TRUE;
}


BOOLEAN NTAPI Ext2SaveBCB(
	PtrExt2IrpContext	PtrIrpContext,
	PBCB				PtrBCB,
	PFILE_OBJECT		PtrFileObject)
{
	PEXT2_SAVED_BCBS	PtrSavedBCB;
	PLIST_ENTRY			PtrEntry = NULL;

	if( !PtrIrpContext )
	{
		//
		//	NULL passed instead of the IRP Context
		//	This call should be ignored...
		//
		return TRUE;
	}

	if( !AssertBCB( PtrBCB ) )
	{
		DebugTrace( DEBUG_TRACE_MISC, "Not saving BCB!!! [Ext2SaveBCB]", 0 );
		return FALSE;
	}


	DebugTrace( DEBUG_TRACE_SPECIAL, "Saving BCB [Ext2SaveBCB]", 0 );

	//	Has the BCB been saved already?
	for( PtrEntry = PtrIrpContext->SavedBCBsListHead.Flink;
			PtrEntry != &PtrIrpContext->SavedBCBsListHead;
			PtrEntry = PtrEntry->Flink )
	{
		PtrSavedBCB = CONTAINING_RECORD( PtrEntry, EXT2_SAVED_BCBS, SavedBCBsListEntry );
		ASSERT( PtrSavedBCB );
		if( PtrSavedBCB->PtrBCB == PtrBCB )
		{

			//	A BCB for this file has already been saved for flushing...
			//	Won't resave this one...
			return TRUE;
		}
	}


	//	Reference the BCB
	CcRepinBcb( PtrBCB );

	//	Now allocate a EXT2_SAVED_BCBS
	PtrSavedBCB = Ext2AllocatePool( NonPagedPool,
					Ext2QuadAlign( sizeof( EXT2_SAVED_BCBS ) )  );
	if( !PtrSavedBCB )
		return FALSE;
	PtrSavedBCB->NodeIdentifier.NodeSize = sizeof( EXT2_SAVED_BCBS );
	PtrSavedBCB->NodeIdentifier.NodeType = EXT2_NODE_TYPE_SAVED_BCB;

	PtrSavedBCB->PtrBCB = PtrBCB;
	//	PtrSavedBCB->PtrFileObject = PtrFileObject;

	//	Now save it in the IRP Context
	InsertHeadList( &PtrIrpContext->SavedBCBsListHead, &PtrSavedBCB->SavedBCBsListEntry );

	PtrIrpContext->SavedCount++;
	//	Return success...
	return TRUE;

}


BOOLEAN NTAPI Ext2FlushSavedBCBs(
	PtrExt2IrpContext	PtrIrpContext )
{

	PLIST_ENTRY			PtrEntry = NULL;
	PEXT2_SAVED_BCBS	PtrSavedBCB = NULL;
	IO_STATUS_BLOCK		Status;
	BOOLEAN				RC = TRUE;

	if( !IsListEmpty( &PtrIrpContext->SavedBCBsListHead ) )
	{
		DebugTrace( DEBUG_TRACE_SPECIAL, "Flushing cache... - Ext2FlushSavedBCBs", 0 );
	}
	while( !IsListEmpty( &PtrIrpContext->SavedBCBsListHead ) )
 	{

		PtrEntry = RemoveTailList( &PtrIrpContext->SavedBCBsListHead );
		if( !PtrEntry )
		{
			//	No more entries left...
			break;
		}

		//	Get the Saved BCB
		PtrSavedBCB = CONTAINING_RECORD( PtrEntry, EXT2_SAVED_BCBS, SavedBCBsListEntry );
		if( PtrSavedBCB->NodeIdentifier.NodeType != EXT2_NODE_TYPE_SAVED_BCB )
		{
			//	Something is wrong...
			Ext2BreakPoint();
			return FALSE;
		}

		if( !AssertBCB( PtrSavedBCB->PtrBCB ) )
		{
			//	This BCB shouldn't have been saved in the first place...
			DebugTrace( DEBUG_TRACE_ERROR, "Unable to flush BCB - Skipping!!! [Ext2SaveBCB]", 0 );
			continue;
		}

		//	Unpin and Flush the cache...
		CcUnpinRepinnedBcb( PtrSavedBCB->PtrBCB, TRUE, &Status );

		if( !NT_SUCCESS( Status.Status ) )
		{
			//	Failure in flushing...
			DebugTrace( DEBUG_TRACE_SPECIAL, "Failure flushing cache - Ext2FlushSavedBCBs", 0 );
			RC = FALSE;
		}

		//	Release the Saved BCB
		PtrSavedBCB->NodeIdentifier.NodeType = EXT2_NODE_TYPE_INVALID;

		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [misc]", PtrSavedBCB );
		ExFreePool( PtrSavedBCB );
		PtrSavedBCB = NULL;
		PtrIrpContext->SavedCount--;
	}

	return RC;
}

BOOLEAN NTAPI AssertBCB( PBCB	PtrBCB )
{
	PFILE_OBJECT		PtrFileObject = NULL;

	/*
	 * This routine is simplified version of the original
	 * AssertBCB and doesn't make any assumptions about
	 * the layout of undocumented BCB structure.
	 * -- Filip Navara, 18/08/2004
	 */

		PtrFileObject = CcGetFileObjectFromBcb ( PtrBCB );
		if( !PtrFileObject )
		{
			Ext2BreakPoint();
			return FALSE;
		}
		else
		{
			return TRUE;
		}
	}


ULONG NTAPI Ext2Align( ULONG NumberToBeAligned, ULONG Alignment )
{
	if( Alignment & ( Alignment - 1 ) )
	{
		//
		//	Alignment not a power of 2
		//	Just returning
		//
		return NumberToBeAligned;
	}
	if( ( NumberToBeAligned & ( Alignment - 1 ) ) != 0 )
	{
		NumberToBeAligned = NumberToBeAligned + Alignment;
		NumberToBeAligned = NumberToBeAligned & ( ~ (Alignment-1) );
	}
	return NumberToBeAligned;
}

LONGLONG NTAPI Ext2Align64( LONGLONG NumberToBeAligned, LONGLONG Alignment )
{
	if( Alignment & ( Alignment - 1 ) )
	{
		//
		//	Alignment not a power of 2
		//	Just returning
		//
		return NumberToBeAligned;
	}
	if( ( NumberToBeAligned & ( Alignment - 1 ) ) != 0 )
	{
		NumberToBeAligned = NumberToBeAligned + Alignment;
		NumberToBeAligned = NumberToBeAligned & ( ~ (Alignment-1) );
	}
	return NumberToBeAligned;
}


ULONG NTAPI Ext2GetCurrentTime()
{
	LARGE_INTEGER  CurrentTime;
	ULONG Time;
	KeQuerySystemTime( &CurrentTime );
	Time = (ULONG) ( (CurrentTime.QuadPart - Ext2GlobalData.TimeDiff.QuadPart) / 10000000 );
	return Time;
}