reactos/drivers/filesystems/ext2/src/fsctrl.c

/*************************************************************************
*
* File: fsctrl.c
*
* Module: Ext2 File System Driver (Kernel mode execution only)
*
* Description:
*	Contains code to handle the various File System Control calls.
*
* Author: Manoj Paul Joseph
*
*
*************************************************************************/



#include "ext2fsd.h"



// define the file specific bug-check id
#define			EXT2_BUG_CHECK_ID				EXT2_FILE_FILE_CONTROL
#define			DEBUG_LEVEL						(DEBUG_TRACE_FSCTRL)


NTSTATUS
Ext2MountVolume(
	IN PIRP Irp,
	IN PIO_STACK_LOCATION IrpSp );

NTSTATUS
Ext2GetPartitionInfo(
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PPARTITION_INFORMATION PartitionInformation
    );

NTSTATUS
Ext2GetDriveLayout(
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PDRIVE_LAYOUT_INFORMATION DriveLayoutInformation,
	IN int BufferSize
    );

BOOLEAN
Ext2PerformVerifyDiskRead(
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PVOID Buffer,
    IN LONGLONG Lbo,
    IN ULONG NumberOfBytesToRead
    );

NTSTATUS Ext2UserFileSystemRequest( 
	IN PIRP Irp,
	IN PIO_STACK_LOCATION IrpSp );


/*************************************************************************
*
* Function: Ext2FileSystemControl
*
* Description:
*	The I/O Manager will invoke this routine to handle a 
*   File System Control IRP
*
* Expected Interrupt Level (for execution) :
*  
*	???
*
* Arguments:
*
*    DeviceObject - Supplies the volume device object where the
*                   file exists
*
*    Irp - Supplies the Irp being processed
*
*
* Return Value:
*
*    NTSTATUS - The FSD status for the IRP
*
*************************************************************************/
NTSTATUS NTAPI
Ext2FileSystemControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
{
  
    NTSTATUS Status = STATUS_SUCCESS;
	PIO_STACK_LOCATION IrpSp;
    
	DebugTrace(DEBUG_TRACE_IRP_ENTRY,   "File System Control IRP Received...", 0);
		
	//	Ext2BreakPoint();

	FsRtlEnterFileSystem();

	ASSERT(DeviceObject);
	ASSERT(Irp);

	//
    //  Get a pointer to the current Irp stack location
    //
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
	

	if( IrpSp->MinorFunction == IRP_MN_MOUNT_VOLUME )
	{
		DebugTrace(DEBUG_TRACE_MOUNT,   "Mount Request Received...", 0);
		Status = Ext2MountVolume ( Irp, IrpSp );
		Ext2CompleteRequest( Irp, Status );
	}
	else if( IrpSp->MinorFunction == IRP_MN_USER_FS_REQUEST )
	{
		DebugTrace(DEBUG_TRACE_FSCTRL,   "IRP_MN_USER_FS_REQUEST received...", 0);
		Status = Ext2UserFileSystemRequest( Irp, IrpSp );
		Ext2CompleteRequest( Irp, Status );
	}
	else 
	{
		if( IrpSp->MinorFunction == IRP_MN_VERIFY_VOLUME )
		{
			DebugTrace(DEBUG_TRACE_FSCTRL,   "IRP_MN_VERIFY_VOLUME received...", 0);
		}
		else if( IrpSp->MinorFunction == IRP_MN_LOAD_FILE_SYSTEM )
		{
			DebugTrace(DEBUG_TRACE_FSCTRL,   "IRP_MN_LOAD_FILE_SYSTEM received...", 0);
		}
		else
		{
			DebugTrace(DEBUG_TRACE_FSCTRL,   "Unknown Minor IRP code received...", 0);
		}

		Status = STATUS_INVALID_DEVICE_REQUEST;
		Ext2CompleteRequest( Irp, Status );
	}
	
	FsRtlExitFileSystem();

    return Status;
}



/*************************************************************************
*
* Function: Ext2MountVolume()
*
* Description:
*	This routine verifies and mounts the volume; 
*	Called by FSCTRL IRP handler to attempt a 
*		volume mount.
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL 
*
*
* Arguments:
*
*    Irp - Supplies the Irp being processed
*	 IrpSp - Irp Stack Location pointer
*
* Return Value: 
*
*   NTSTATUS - The Mount status
*
*************************************************************************/
NTSTATUS
Ext2MountVolume ( 
	IN PIRP Irp,
	IN PIO_STACK_LOCATION IrpSp )
{
	
	//	Volume Parameter Block
	PVPB PtrVPB;

	//	The target device object
	PDEVICE_OBJECT TargetDeviceObject = NULL;

	// The new volume device object (to be created if partition is Ext2)
	PDEVICE_OBJECT PtrVolumeDeviceObject = NULL;
	
	//	Return Status
	NTSTATUS Status = STATUS_UNRECOGNIZED_VOLUME;

	// Number of bytes to read for Volume verification...
	unsigned long NumberOfBytesToRead = 0;
	
	//	Starting Offset for 'read'
	LONGLONG StartingOffset = 0;

	//	Boot Sector information...
	PPACKED_BOOT_SECTOR BootSector = NULL;
	
	//	Ext2 Super Block information...
	PEXT2_SUPER_BLOCK SuperBlock = NULL;

	//	Volume Control Block
	PtrExt2VCB			PtrVCB = NULL;

	//	The File Object for the root directory
	PFILE_OBJECT PtrRootFileObject = NULL;
	
	//	Flag
	int WeClearedVerifyRequiredBit;
	
	//	Used by a for loop...
	unsigned int i;
	
	//	
	LARGE_INTEGER VolumeByteOffset;

	unsigned long LogicalBlockSize = 0;

	//	Buffer Control Block
	PBCB PtrBCB = NULL;
			
	//	Cache Buffer - used for pinned access of volume...
	PVOID PtrCacheBuffer = NULL;
	
	PEXT2_GROUP_DESCRIPTOR	PtrGroupDescriptor = NULL;

	// Inititalising variables
	
	PtrVPB = IrpSp->Parameters.MountVolume.Vpb;
	TargetDeviceObject = IrpSp->Parameters.MountVolume.DeviceObject;
	
	try
	{
		//
		//	1. Reading in Volume meta data
		//

		//	Temporarily clear the DO_VERIFY_VOLUME Flag
		WeClearedVerifyRequiredBit = 0;
		if ( Ext2IsFlagOn( PtrVPB->RealDevice->Flags, DO_VERIFY_VOLUME ) ) 
		{
            Ext2ClearFlag( PtrVPB->RealDevice->Flags, DO_VERIFY_VOLUME );
            WeClearedVerifyRequiredBit = 1;
        }

		//	Allocating memory for reading in Boot Sector...
		NumberOfBytesToRead = Ext2Align( sizeof( EXT2_SUPER_BLOCK ), TargetDeviceObject->SectorSize );
		BootSector = Ext2AllocatePool( PagedPool, NumberOfBytesToRead  );
		RtlZeroMemory( BootSector, NumberOfBytesToRead );

		//	Reading in Boot Sector
		StartingOffset = 0L;
		Ext2PerformVerifyDiskRead ( TargetDeviceObject,
			BootSector, StartingOffset, NumberOfBytesToRead );

		// Reject a volume that contains fat artifacts
		
		DebugTrace(DEBUG_TRACE_MOUNT, "OEM[%s]", BootSector->Oem);
		if (BootSector->Oem[0])
		{
		    try_return();
		}

		//	Allocating memory for reading in Super Block...
		
		SuperBlock = Ext2AllocatePool( PagedPool, NumberOfBytesToRead  );
		RtlZeroMemory( SuperBlock, NumberOfBytesToRead );
		StartingOffset = 1024;

		//	Reading in the Super Block...
		Ext2PerformVerifyDiskRead ( TargetDeviceObject,
			SuperBlock, StartingOffset, NumberOfBytesToRead );

		//	Resetting the DO_VERIFY_VOLUME Flag
		if( WeClearedVerifyRequiredBit ) 
		{
			PtrVPB->RealDevice->Flags |= DO_VERIFY_VOLUME;
		}

		// Verifying the Super Block..
		if( SuperBlock->s_magic == EXT2_SUPER_MAGIC )
		{
			//
			//	Found a valid super block.
			//	No more tests for now.
			//	Assuming that this is an ext2 partition...
			//	Going ahead with mount.
			//
			DebugTrace(DEBUG_TRACE_MOUNT,   "Valid Ext2 partition detected\nMounting %s...", SuperBlock->s_volume_name);
			//
			//	2. Creating a volume device object
			//
	        if (!NT_SUCCESS( IoCreateDevice( 
					Ext2GlobalData.Ext2DriverObject,	//	(This) Driver object
					Ext2QuadAlign( sizeof(Ext2VCB) ),	//	Device Extension
                    NULL,								//	Device Name - no name ;)
                    FILE_DEVICE_DISK_FILE_SYSTEM,		//	Disk File System
                    0,									//	DeviceCharacteristics
                    FALSE,								//	Not an exclusive device
                    (PDEVICE_OBJECT *)&PtrVolumeDeviceObject)) //	The Volume Device Object
					) 
			{
	            try_return();
			}

			//	
			//  Our alignment requirement is the larger of the processor alignment requirement
			//  already in the volume device object and that in the TargetDeviceObject
			//

			if (TargetDeviceObject->AlignmentRequirement > PtrVolumeDeviceObject->AlignmentRequirement) 
			{
				PtrVolumeDeviceObject->AlignmentRequirement = TargetDeviceObject->AlignmentRequirement;
			}
			
			//
			//	Clearing the Device Initialising Flag
			//
			Ext2ClearFlag( PtrVolumeDeviceObject->Flags, DO_DEVICE_INITIALIZING);


			//
			//	Setting the Stack Size for the newly created Volume Device Object
			//
			PtrVolumeDeviceObject->StackSize = (CCHAR)(TargetDeviceObject->StackSize + 1);
			

			//
			//	3. Creating the link between Target Device Object 
			//	and the Volume Device Object via the Volume Parameter Block
			//
			PtrVPB->DeviceObject = PtrVolumeDeviceObject;
			
			//	Remembring the Volume parameters in the VPB bock
			for( i = 0; i < 16 ; i++ )
			{
				PtrVPB->VolumeLabel[i] = SuperBlock->s_volume_name[i];
				if( SuperBlock->s_volume_name[i] == 0 )
					break;
			}
			PtrVPB->VolumeLabelLength = i * 2;
			PtrVPB->SerialNumber = ((ULONG*)SuperBlock->s_uuid)[0];
				
			//
			//	4. Initialise the Volume Comtrol Block
			//
			{
				LARGE_INTEGER AllocationSize;

				AllocationSize .QuadPart = 
					( EXT2_MIN_BLOCK_SIZE << SuperBlock->s_log_block_size ) * 
					SuperBlock->s_blocks_count;

				Ext2InitializeVCB(
					PtrVolumeDeviceObject, 
					TargetDeviceObject,
					PtrVPB,
					&AllocationSize);
				PtrVCB = (PtrExt2VCB)(PtrVolumeDeviceObject->DeviceExtension);
				ASSERT( PtrVCB );
			}

			PtrVCB->InodesCount = SuperBlock->s_inodes_count;
			PtrVCB->BlocksCount = SuperBlock->s_blocks_count;
			PtrVCB->ReservedBlocksCount = SuperBlock->s_r_blocks_count;
			PtrVCB->FreeBlocksCount = SuperBlock->s_free_blocks_count;
			PtrVCB->FreeInodesCount = SuperBlock->s_free_inodes_count;
			PtrVCB->LogBlockSize = SuperBlock->s_log_block_size;
			PtrVCB->InodesPerGroup = SuperBlock->s_inodes_per_group;
			PtrVCB->BlocksPerGroup = SuperBlock->s_blocks_per_group;
			PtrVCB->NoOfGroups = ( SuperBlock->s_blocks_count - SuperBlock->s_first_data_block 
								+ SuperBlock->s_blocks_per_group - 1 ) 
								/ SuperBlock->s_blocks_per_group;
			if( SuperBlock->s_rev_level )
			{
				PtrVCB->InodeSize = SuperBlock->s_inode_size;
			}
			else
			{
				PtrVCB->InodeSize = sizeof( EXT2_INODE );
			}

			PtrVCB->PtrGroupDescriptors = Ext2AllocatePool( NonPagedPool, sizeof( Ext2GroupDescriptors ) * PtrVCB->NoOfGroups  );
			
			RtlZeroMemory( PtrVCB->PtrGroupDescriptors , sizeof( Ext2GroupDescriptors ) * PtrVCB->NoOfGroups );

			//
			//	Attempting to Read in some matadata from the Cache...
			//	using pin access...
			//
			LogicalBlockSize = EXT2_MIN_BLOCK_SIZE << PtrVCB->LogBlockSize;
	
			//
			//	Reading Group Descriptors...
			//
			if( PtrVCB->LogBlockSize )
			{
				//	First block contains the descriptors...
				VolumeByteOffset.QuadPart = LogicalBlockSize;
			}
			else
			{
				//	Second block contains the descriptors...
				VolumeByteOffset.QuadPart = LogicalBlockSize * 2;
			}

			NumberOfBytesToRead = PtrVCB->NoOfGroups * sizeof( struct ext2_group_desc );
			NumberOfBytesToRead = Ext2Align( NumberOfBytesToRead, LogicalBlockSize );

			if (!CcMapData( PtrVCB->PtrStreamFileObject,
                   &VolumeByteOffset,
                   NumberOfBytesToRead,
                   TRUE,
                   &PtrBCB,
                   &PtrCacheBuffer )) 
			{
				DebugTrace(DEBUG_TRACE_ERROR,   "Cache read failiure while reading in volume meta data", 0);
				try_return( Status = STATUS_INSUFFICIENT_RESOURCES );
			}
			else
			{
				//	
				//	Saving up Often Used Group Descriptor Information in the VCB...
				//
				unsigned int DescIndex ;

				DebugTrace(DEBUG_TRACE_MISC,   "Cache hit while reading in volume meta data", 0);
				PtrGroupDescriptor = (PEXT2_GROUP_DESCRIPTOR )PtrCacheBuffer;
				for( DescIndex = 0; DescIndex < PtrVCB->NoOfGroups; DescIndex++ )
				{
					PtrVCB->PtrGroupDescriptors[ DescIndex ].InodeTablesBlock 
						= PtrGroupDescriptor[ DescIndex ].bg_inode_table;

					PtrVCB->PtrGroupDescriptors[ DescIndex ].InodeBitmapBlock 
						= PtrGroupDescriptor[ DescIndex ].bg_inode_bitmap
						;
					PtrVCB->PtrGroupDescriptors[ DescIndex ].BlockBitmapBlock 
						= PtrGroupDescriptor[ DescIndex ].bg_block_bitmap
						;
					PtrVCB->PtrGroupDescriptors[ DescIndex ].FreeBlocksCount 
						= PtrGroupDescriptor[ DescIndex ].bg_free_blocks_count;

					PtrVCB->PtrGroupDescriptors[ DescIndex ].FreeInodesCount 
						= PtrGroupDescriptor[ DescIndex ].bg_free_inodes_count;
				}
				CcUnpinData( PtrBCB );
				PtrBCB = NULL;
			}

			//
			//	5. Creating a Root Directory FCB
			//
			PtrRootFileObject = IoCreateStreamFileObject(NULL, TargetDeviceObject );
			if( !PtrRootFileObject )
			{
				try_return();
			}
			//
			//	Associate the file stream with the Volume parameter block...
			//	I do it now
			//
			PtrRootFileObject->Vpb = PtrVCB->PtrVPB;

			PtrRootFileObject->ReadAccess = TRUE;
			PtrRootFileObject->WriteAccess = TRUE;

			{
				PtrExt2ObjectName		PtrObjectName;
				LARGE_INTEGER ZeroSize;

				PtrObjectName = Ext2AllocateObjectName();
				RtlInitUnicodeString( &PtrObjectName->ObjectName, L"\\" );
				Ext2CopyWideCharToUnicodeString( &PtrObjectName->ObjectName, L"\\" );


				ZeroSize.QuadPart = 0;
				if ( !NT_SUCCESS( Ext2CreateNewFCB( 
						&PtrVCB->PtrRootDirectoryFCB,	//	Root FCB
						ZeroSize,			//	AllocationSize,
						ZeroSize,			//	EndOfFile,
						PtrRootFileObject,		//	The Root Dircetory File Object
						PtrVCB,
						PtrObjectName  )  )  )
				{
					try_return();
				}
				

				PtrVCB->PtrRootDirectoryFCB->FCBFlags |= EXT2_FCB_DIRECTORY | EXT2_FCB_ROOT_DIRECTORY;


			}

			PtrVCB->PtrRootDirectoryFCB->DcbFcb.Dcb.PtrDirFileObject = PtrRootFileObject;
			PtrVCB->PtrRootDirectoryFCB->INodeNo = EXT2_ROOT_INO;
			PtrRootFileObject->SectionObjectPointer = &(PtrVCB->PtrRootDirectoryFCB->NTRequiredFCB.SectionObject);
			RtlInitUnicodeString( &PtrRootFileObject->FileName, L"\\" );

			Ext2InitializeFCBInodeInfo( PtrVCB->PtrRootDirectoryFCB );

			//	
			//	Initiating caching for root directory...
			//

			CcInitializeCacheMap(PtrRootFileObject, 
				(PCC_FILE_SIZES)(&(PtrVCB->PtrRootDirectoryFCB->NTRequiredFCB.CommonFCBHeader.AllocationSize)),
				TRUE,		// We will utilize pin access for directories
				&(Ext2GlobalData.CacheMgrCallBacks), // callbacks
				PtrVCB->PtrRootDirectoryFCB );		// The context used in callbacks


			//
			//	6. Update the VCB Flags
			//
			PtrVCB->VCBFlags |= EXT2_VCB_FLAGS_VOLUME_MOUNTED ;	//	| EXT2_VCB_FLAGS_VOLUME_READ_ONLY;


			//
			//	7. Mount Success
			//
			Status = STATUS_SUCCESS;
			
			{
				//
				//	This block is for testing....
				//	To be removed...

				/*
				EXT2_INODE	Inode ;
				Ext2ReadInode( PtrVCB, 100, &Inode );
				DebugTrace( DEBUG_TRACE_MISC, "Inode size= %lX [FS Ctrl]", Inode.i_size );
				Ext2DeallocInode( NULL, PtrVCB, 0xfb6 );
				*/
			}
			
			//	 ObDereferenceObject( TargetDeviceObject );
		}
		else
		{
			DebugTrace(DEBUG_TRACE_MOUNT,   "Failing mount. Partition not Ext2...", 0);
		}

		try_exit: NOTHING;
	}
	finally 
	{
		//	Freeing Allocated Memory...
		if( SuperBlock != NULL )
		{
			DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [FS Ctrl]", SuperBlock );
			ExFreePool( SuperBlock );
		}
		if( BootSector != NULL )
		{
			DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [FS Ctrl]", BootSector);
			ExFreePool( BootSector );
		}

		// start unwinding if we were unsuccessful
		if (!NT_SUCCESS( Status )) 
		{
						
		}
	}
	
	return Status;
}

/*************************************************************************
*
* Function: Ext2MountVolume()
*
* Description:
*	This routine is used for querying the partition information.
*
* Expected Interrupt Level (for execution) :
*  IRQL_PASSIVE_LEVEL 
*
* Arguments:
*
*	TargetDeviceObject - The target of the query
*	PartitionInformation - Receives the result of the query
*
* Return Value:
*
*	NTSTATUS - The return status for the operation
*
*************************************************************************/
NTSTATUS
Ext2GetPartitionInfo (
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PPARTITION_INFORMATION PartitionInformation
    )
{
    PIRP Irp;
    KEVENT *PtrEvent = NULL;
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;

    //
    //  Query the partition table
    //
	PtrEvent = ( KEVENT * )Ext2AllocatePool( NonPagedPool, Ext2QuadAlign( sizeof( KEVENT ) )  );
	



    KeInitializeEvent( PtrEvent, NotificationEvent, FALSE );
	
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_GET_PARTITION_INFO,
                                         TargetDeviceObject,
                                         NULL,
                                         0,
                                         PartitionInformation,
                                         sizeof(PARTITION_INFORMATION),
                                         FALSE,
                                         PtrEvent,
                                         &Iosb );

    if ( Irp == NULL ) 
	{
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [FS Ctrl]", PtrEvent);
		ExFreePool( PtrEvent );
		return 0;
    }

    Status = IoCallDriver( TargetDeviceObject, Irp );

    if ( Status == STATUS_PENDING ) {

        (VOID) KeWaitForSingleObject( PtrEvent,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      (PLARGE_INTEGER)NULL );

        Status = Iosb.Status;
    }
	DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [FS Ctrl]", PtrEvent);
	ExFreePool( PtrEvent );
    return Status;
}

/*************************************************************************
*
* Function: Ext2MountVolume()
*
* Description:
*	This routine is used for querying the Drive Layout Information.
*
* Expected Interrupt Level (for execution) :
*  IRQL_PASSIVE_LEVEL 
*
* Arguments:
*
*	TargetDeviceObject - The target of the query
*	PartitionInformation - Receives the result of the query
*
* Return Value:
*
*	NTSTATUS - The return status for the operation
*
*************************************************************************/
NTSTATUS Ext2GetDriveLayout (
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PDRIVE_LAYOUT_INFORMATION DriveLayoutInformation,
	IN int BufferSize
    )
{
    PIRP Irp;
    KEVENT *PtrEvent = NULL;
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;

    //
    //  Query the partition table
    //
	PtrEvent = ( KEVENT * )Ext2AllocatePool( NonPagedPool, Ext2QuadAlign( sizeof( KEVENT ) )  );
    KeInitializeEvent( PtrEvent, NotificationEvent, FALSE );
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_GET_DRIVE_LAYOUT,
                                         TargetDeviceObject,
                                         NULL,
                                         0,
                                         DriveLayoutInformation,
                                         BufferSize,
                                         FALSE,
                                         PtrEvent,
                                         &Iosb );

    if ( Irp == NULL ) 
	{
		DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [FS Ctrl]", PtrEvent);
		ExFreePool( PtrEvent );
		return 0;
    }

    Status = IoCallDriver( TargetDeviceObject, Irp );

    if ( Status == STATUS_PENDING ) {

        (VOID) KeWaitForSingleObject( PtrEvent,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      (PLARGE_INTEGER)NULL );

        Status = Iosb.Status;
    }
	DebugTrace( DEBUG_TRACE_FREE, "Freeing  = %lX [FS Ctrl]", PtrEvent);
	ExFreePool( PtrEvent );
    return Status;
}


/*************************************************************************
*
* Function: Ext2MountVolume()
*
* Description:
*	This routine is used for performing a verify read...
*
* Expected Interrupt Level (for execution) :
*  IRQL_PASSIVE_LEVEL 
*
* Arguments:
*	TargetDeviceObject - The target of the query
*	PartitionInformation - Receives the result of the query
*
* Return Value:
*	NTSTATUS - The return status for the operation
*
*************************************************************************/
BOOLEAN Ext2PerformVerifyDiskRead(
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PVOID Buffer,
    IN LONGLONG Lbo,
    IN ULONG NumberOfBytesToRead )
{
    KEVENT Event;
    PIRP Irp;
    LARGE_INTEGER ByteOffset;
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;

    //
    //  Initialize the event we're going to use
    //
    KeInitializeEvent( &Event, NotificationEvent, FALSE );

    //
    //  Build the irp for the operation
    //
    ByteOffset.QuadPart = Lbo;
    Irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ,
                                        TargetDeviceObject,
                                        Buffer,
                                        NumberOfBytesToRead,
                                        &ByteOffset,
                                        &Event,
                                        &Iosb );

    if ( Irp == NULL ) 
	{
        Status = FALSE;
    }

    Ext2SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );

    //
    //  Call the device to do the read and wait for it to finish.
    //
    Status = IoCallDriver( TargetDeviceObject, Irp );
    if (Status == STATUS_PENDING) 
	{
        (VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
        Status = Iosb.Status;
    }

    ASSERT(Status != STATUS_VERIFY_REQUIRED);

    //
    //  Special case this error code because this probably means we used
    //  the wrong sector size and we want to reject STATUS_WRONG_VOLUME.
    //

    if (Status == STATUS_INVALID_PARAMETER) 
	{

        return FALSE;
    }

    //
    //  If it doesn't succeed then either return or raise the error.
    //

    if (!NT_SUCCESS(Status)) 
	{
            return FALSE;
    }

    //
    //  And return to our caller
    //
    return TRUE;
}

/*************************************************************************
*
* Function: Ext2UserFileSystemRequest()
*
* Description:
*	This routine handles User File System Requests
*
* Expected Interrupt Level (for execution) :
*
*  IRQL_PASSIVE_LEVEL 
*
*
* Arguments:
*
*    Irp - Supplies the Irp being processed
*	 IrpSp - Irp Stack Location pointer
*
* Return Value: NT_STATUS
*
*************************************************************************/
NTSTATUS Ext2UserFileSystemRequest ( 
	IN PIRP Irp,
	IN PIO_STACK_LOCATION IrpSp )
{
    NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;
	ULONG FsControlCode;

	IrpSp = IoGetCurrentIrpStackLocation( Irp );
	
	try
	{
#ifdef _GNU_NTIFS_
		FsControlCode = ((PEXTENDED_IO_STACK_LOCATION)IrpSp)->Parameters.FileSystemControl.FsControlCode;
#else
		FsControlCode = IrpSp->Parameters.FileSystemControl.FsControlCode;
#endif

		switch ( FsControlCode ) 
		{

		case FSCTL_REQUEST_OPLOCK_LEVEL_1:
			DebugTrace(DEBUG_TRACE_FSCTRL,   "FSCTL_REQUEST_OPLOCK_LEVEL_1", 0);
			break;
		case FSCTL_REQUEST_OPLOCK_LEVEL_2:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL ", 0);
			break;
		case FSCTL_REQUEST_BATCH_OPLOCK:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_REQUEST_OPLOCK_LEVEL_2 ", 0);
			break;
		case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
			DebugTrace(DEBUG_TRACE_MISC,   " FSCTL_OPLOCK_BREAK_ACKNOWLEDGE ", 0);
			break;
		case FSCTL_OPBATCH_ACK_CLOSE_PENDING:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_OPBATCH_ACK_CLOSE_PENDING ", 0);
			break;
		case FSCTL_OPLOCK_BREAK_NOTIFY:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_OPLOCK_BREAK_NOTIFY ", 0);
			break;
		case FSCTL_OPLOCK_BREAK_ACK_NO_2:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_OPLOCK_BREAK_ACK_NO_2 ", 0);
			break;
		case FSCTL_LOCK_VOLUME:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_LOCK_VOLUME ", 0);
			break;
		case FSCTL_UNLOCK_VOLUME:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_UNLOCK_VOLUME ", 0);
			break;
		case FSCTL_DISMOUNT_VOLUME:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_DISMOUNT_VOLUME ", 0);
			break;
		case FSCTL_MARK_VOLUME_DIRTY:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_MARK_VOLUME_DIRTY ", 0);
			break;
		case FSCTL_IS_VOLUME_DIRTY:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_IS_VOLUME_DIRTY ", 0);
			break;
		case FSCTL_IS_VOLUME_MOUNTED:
			Status = Ext2VerifyVolume(Irp, IrpSp );
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_IS_VOLUME_MOUNTED ", 0);
			break;
		case FSCTL_IS_PATHNAME_VALID:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_IS_PATHNAME_VALID ", 0);
			break;
		case FSCTL_QUERY_RETRIEVAL_POINTERS:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_QUERY_RETRIEVAL_POINTERS ", 0);
			break;
		case FSCTL_QUERY_FAT_BPB:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_QUERY_FAT_BPB ", 0);
			break;
		case FSCTL_FILESYSTEM_GET_STATISTICS:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_FILESYSTEM_GET_STATISTICS ", 0);
			break;
		case FSCTL_GET_VOLUME_BITMAP:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_GET_VOLUME_BITMAP ", 0);
			break;
		case FSCTL_GET_RETRIEVAL_POINTERS:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_GET_RETRIEVAL_POINTERS ", 0);
			break;
		case FSCTL_MOVE_FILE:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_MOVE_FILE ", 0);
			break;
		case FSCTL_ALLOW_EXTENDED_DASD_IO:
			DebugTrace(DEBUG_TRACE_FSCTRL,   " FSCTL_ALLOW_EXTENDED_DASD_IO ", 0);
			break;
		default :
			DebugTrace(DEBUG_TRACE_FSCTRL,   "Unknown FSCTRL !!!", 0);

		}
	}
	finally
	{

	}
	return Status;
}



NTSTATUS NTAPI Ext2VerifyVolume (
	IN PIRP Irp,
	IN PIO_STACK_LOCATION IrpSp )
{

	PVPB PtrVPB;
	
	PtrVPB = IrpSp->Parameters.VerifyVolume.Vpb;
	if( IrpSp->FileObject )
	{
		PtrVPB = IrpSp->FileObject->Vpb;
	}
	if( !PtrVPB )
	{
		PtrVPB = IrpSp->Parameters.VerifyVolume.Vpb;
	}

	if( !PtrVPB )
	{
		return STATUS_WRONG_VOLUME;
	}


	if ( Ext2IsFlagOn( PtrVPB->RealDevice->Flags, DO_VERIFY_VOLUME ) ) 
	{
		//
		//	Not doing a verify!
		//	Just acting as if everyting is fine!
		//	THis should do for now
		//
        Ext2ClearFlag( PtrVPB->RealDevice->Flags, DO_VERIFY_VOLUME );
		
	}
	return STATUS_SUCCESS;
}