📄 ext2fs.c

📁 ext2 file system driver for win nt
💻 C
📖 第 1 页 / 共 5 页
字号:
				Status = TRUE;
				__leave;
			}
#if DBG			
			KdPrint((
				DRIVER_NAME ": %-16.16s %-31s %s\n",
				ProcessId->ImageFileName,
				"FASTIO_UNLOCK_ALL_BY_KEY",
				Fcb->DbgFileName
				));
#endif			
			KdPrint((
				DRIVER_NAME ": Key: %u\n",
				Key
				));
			
			FsRtlEnterFileSystem();
			
			IoStatus->Status = FsRtlFastUnlockAllByKey(
				&Fcb->FileLockAnchor,
				FileObject,
				ProcessId,
				Key,
				NULL
				);  
			
			IoStatus->Information = 0;
			
			Status =  TRUE;
		}

		__except (EXCEPTION_EXECUTE_HANDLER)
		{
			IoStatus->Status = GetExceptionCode();
			Status = TRUE;
		}
	}

	__finally
	{
		FsRtlExitFileSystem();
	}
	
	if (Status == FALSE)
	{
		KdPrint((
			DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
			ProcessId->ImageFileName,
			"FASTIO_UNLOCK_ALL_BY_KEY"
			));
	}
	else if (IoStatus->Status != STATUS_SUCCESS)
	{
		KdPrint((
			DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
			ProcessId->ImageFileName,
			"FASTIO_UNLOCK_ALL_BY_KEY",
			Ext2NtStatusToString(IoStatus->Status),
			IoStatus->Status
			));
	}
	
	return Status;
}


BOOLEAN
Ext2FastIoQueryNetworkOpenInfo (
	 IN PFILE_OBJECT                     FileObject,
	 IN BOOLEAN                          Wait,
	 OUT PFILE_NETWORK_OPEN_INFORMATION  Buffer,
	 OUT PIO_STATUS_BLOCK                IoStatus,
	 IN PDEVICE_OBJECT                   DeviceObject )
{
	BOOLEAN     Status = FALSE;
	PEXT2_FCB   Fcb;
	BOOLEAN     FcbMainResourceAcquired = FALSE;
	
	PAGED_CODE();
	
	__try
		
		
	{
		__try
		{
			if (DeviceObject == Ext2Global->DeviceObject)
			{
				IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
				Status = TRUE;
				__leave;
			}
			
			Fcb = (PEXT2_FCB) FileObject->FsContext;
			
			ASSERT(Fcb != NULL);
			
			if (Fcb->Identifier.Type == VCB)
			{
				IoStatus->Status = STATUS_INVALID_PARAMETER;
				Status = TRUE;
				__leave;
			}
			
			ASSERT((Fcb->Identifier.Type == FCB) &&
				(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if DBG			
			KdPrint((
				DRIVER_NAME ": %-16.16s %-31s %s\n",
				PsGetCurrentProcess()->ImageFileName,
				"FASTIO_QUERY_NETWORK_OPEN_INFO",
				Fcb->DbgFileName
				));
#endif			
			FsRtlEnterFileSystem();
			
			if (!ExAcquireResourceSharedLite(
				&Fcb->MainResource,
				Wait
				))
			{
				Status = FALSE;
				__leave;
			}
			
			FcbMainResourceAcquired = TRUE;
			
			RtlZeroMemory(Buffer, sizeof(FILE_NETWORK_OPEN_INFORMATION));
			
			/*
			typedef struct _FILE_NETWORK_OPEN_INFORMATION {
			LARGE_INTEGER   CreationTime;
			LARGE_INTEGER   LastAccessTime;
			LARGE_INTEGER   LastWriteTime;
			LARGE_INTEGER   ChangeTime;
			LARGE_INTEGER   AllocationSize;
			LARGE_INTEGER   EndOfFile;
			ULONG           FileAttributes;
			} FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
			*/
			
			Buffer->CreationTime = Ext2SysTime(Fcb->ext2_inode->i_ctime + TIMEZONE);
			Buffer->LastAccessTime = Ext2SysTime(Fcb->ext2_inode->i_atime + TIMEZONE);
			Buffer->LastWriteTime = Ext2SysTime(Fcb->ext2_inode->i_mtime + TIMEZONE);
			Buffer->ChangeTime = Ext2SysTime(Fcb->ext2_inode->i_mtime + TIMEZONE);
			Buffer->FileAttributes = Fcb->FileAttributes;
			Buffer->AllocationSize.QuadPart =
				Fcb->ext2_inode->i_size;
			Buffer->EndOfFile.QuadPart =
				Fcb->ext2_inode->i_size;			
			
			Buffer->FileAttributes = Fcb->FileAttributes;
			
			IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
			
			IoStatus->Status = STATUS_SUCCESS;
			
			Status =  TRUE;
		}
		__except (EXCEPTION_EXECUTE_HANDLER)
		{
			IoStatus->Status = GetExceptionCode();
			Status = TRUE;
		}
	}
	__finally
	{
		if (FcbMainResourceAcquired)
		{
			ExReleaseResourceForThreadLite(
				&Fcb->MainResource,
				ExGetCurrentResourceThread()
				);
		}
		
		FsRtlExitFileSystem();
	}
	
	
	
	if (Status == FALSE)
	{
		KdPrint((
			DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
			PsGetCurrentProcess()->ImageFileName,
			"FASTIO_QUERY_NETWORK_OPEN_INFO"
			));
	}
	else if (IoStatus->Status != STATUS_SUCCESS)
	{
		KdPrint((
			DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
			PsGetCurrentProcess()->ImageFileName,
			"FASTIO_QUERY_NETWORK_OPEN_INFO",
			Ext2NtStatusToString(IoStatus->Status),
			IoStatus->Status
			));
	}
	
	return Status;
}


NTSTATUS
Ext2LockControl (IN PEXT2_IRP_CONTEXT IrpContext)
{
	PDEVICE_OBJECT  DeviceObject;
	BOOLEAN         CompleteRequest;
	NTSTATUS        Status = STATUS_UNSUCCESSFUL;
	PFILE_OBJECT    FileObject;
	PEXT2_FCB       Fcb;
	PIRP            Irp;
	
	PAGED_CODE();
	
	__try
	{
		ASSERT(IrpContext != NULL);
		
		ASSERT((IrpContext->Identifier.Type == ICX) &&
			(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
		
		DeviceObject = IrpContext->DeviceObject;
		
		if (DeviceObject == Ext2Global->DeviceObject)
		{
			CompleteRequest = TRUE;
			Status = STATUS_INVALID_DEVICE_REQUEST;
			__leave;
		}
		
		FileObject = IrpContext->FileObject;
		
		Fcb = (PEXT2_FCB) FileObject->FsContext;
		
		ASSERT(Fcb != NULL);
		
		if (Fcb->Identifier.Type == VCB)
		{
			CompleteRequest = TRUE;
			Status = STATUS_INVALID_PARAMETER;
			__leave;
		}
		
		ASSERT((Fcb->Identifier.Type == FCB) &&
			(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
		
		if (Fcb->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		{
			CompleteRequest = TRUE;
			Status = STATUS_INVALID_PARAMETER;
			__leave;
		}
		
		Irp = IrpContext->Irp;
		
		//
		// While the file has any byte range locks we set IsFastIoPossible to
		// FastIoIsQuestionable so that the FastIoCheckIfPossible function is
		// called to check the locks for any fast I/O read/write operation.
		//
		if (Fcb->CommonFCBHeader.IsFastIoPossible != FastIoIsQuestionable)
		{
#if DBG
			KdPrint((
				DRIVER_NAME ": %-16.16s %-31s %s\n",
				PsGetCurrentProcess()->ImageFileName,
				"FastIoIsQuestionable",
				Fcb->DbgFileName
				));
#endif			
			Fcb->CommonFCBHeader.IsFastIoPossible = FastIoIsQuestionable;
		}
		
		//
		// FsRtlProcessFileLock acquires FileObject->FsContext->Resource while
		// modifying the file locks and calls IoCompleteRequest when it's done.
		//
		
		CompleteRequest = FALSE;
		
		Status = FsRtlProcessFileLock(
			&Fcb->FileLockAnchor,
			Irp,
			NULL		);
		
		if (Status != STATUS_SUCCESS)
		{
			KdPrint((
				DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
				PsGetCurrentProcess()->ImageFileName,
				"IRP_MJ_LOCK_CONTROL",
				Ext2NtStatusToString(Status),
				Status			));
		}
	}

	__finally
	{
		if (!IrpContext->ExceptionInProgress)
		{
			if (CompleteRequest)
			{
				IrpContext->Irp->IoStatus.Status = Status;
				
				Ext2CompleteRequest(
					IrpContext->Irp,
					(CCHAR)
					(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT)
					);
			}
			
			Ext2FreeIrpContext(IrpContext);
		}
	}
	
	return Status;
}


/*
BOOLEAN
Ext2FastIoQueryStandardInfo (IN PFILE_OBJECT                 FileObject,
			     IN BOOLEAN                      Wait,
			     OUT PFILE_STANDARD_INFORMATION  Buffer,
			     OUT PIO_STATUS_BLOCK            IoStatus,
			     IN PDEVICE_OBJECT               DeviceObject)
{
	PEXT2_FCB Fcb;
	
	PAGED_CODE();
	
	if (DeviceObject == Ext2Global->DeviceObject)
	{
		return FALSE;
	}
	
	Fcb = (PEXT2_FCB) FileObject->FsContext;
	
	ASSERT(Fcb != NULL);
	
	if (Fcb->Identifier.Type == VCB)
	{
		return FALSE;
	}
	
	ASSERT((Fcb->Identifier.Type == FCB) &&
		(Fcb->Identifier.Size == sizeof(EXT2_FCB)));

	FsRtlEnterFileSystem();
	
	if (!ExAcquireResourceSharedLite(
		&Fcb->MainResource,
		Wait
		))
	{
		FsRtlExitFileSystem();
		return FALSE;
	}
	
	RtlZeroMemory(Buffer, sizeof(FILE_STANDARD_INFORMATION));
	Buffer->AllocationSize.QuadPart = Fcb->ext2_inode->i_size;
	Buffer->EndOfFile.QuadPart = Fcb->ext2_inode->i_size;
	Buffer->NumberOfLinks = Fcb->ext2_inode->i_links_count;
	
#ifndef EXT2_RO
	Buffer->DeletePending = Fcb->DeletePending;
#else
	Buffer->DeletePending = FALSE;
#endif
	
	if (Fcb->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
	{
		Buffer->Directory = TRUE;
	}
	else
	{
		Buffer->Directory = FALSE;
	}
	
	IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
	IoStatus->Status = STATUS_SUCCESS;
	ExReleaseResourceForThreadLite(
		&Fcb->MainResource,
		ExGetCurrentResourceThread());
	FsRtlExitFileSystem();

	return TRUE;
}

BOOLEAN
Ext2FastIoQueryNetworkOpenInfo (IN PFILE_OBJECT                     FileObject,
				IN BOOLEAN                          Wait,
				OUT PFILE_NETWORK_OPEN_INFORMATION  Buffer,
				OUT PIO_STATUS_BLOCK                IoStatus,
				IN PDEVICE_OBJECT                   DeviceObject)
{
	PEXT2_FCB Fcb;
	
	PAGED_CODE();
	
	if (DeviceObject == Ext2Global->DeviceObject)
	{
		return FALSE;
	}
	
	Fcb = (PEXT2_FCB) FileObject->FsContext;
	
	ASSERT(Fcb != NULL);
	
	if (Fcb->Identifier.Type == VCB)
	{
		return FALSE;
	}
	
	ASSERT((Fcb->Identifier.Type == FCB) &&
		(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
	FsRtlEnterFileSystem();
	
	if (!ExAcquireResourceSharedLite(
		&Fcb->MainResource, Wait ))
	{
		FsRtlExitFileSystem();
		return FALSE;
	}
	
	RtlZeroMemory(Buffer, sizeof(FILE_NETWORK_OPEN_INFORMATION));
	Buffer->CreationTime = Ext2SysTime(Fcb->ext2_inode->i_ctime + TIMEZONE);
	Buffer->LastAccessTime = Ext2SysTime(Fcb->ext2_inode->i_atime + TIMEZONE);
	Buffer->LastWriteTime = Ext2SysTime(Fcb->ext2_inode->i_mtime + TIMEZONE);
	Buffer->ChangeTime = Ext2SysTime(Fcb->ext2_inode->i_mtime + TIMEZONE);
	Buffer->AllocationSize.QuadPart = Fcb->ext2_inode->i_size;
	Buffer->EndOfFile.QuadPart = Fcb->ext2_inode->i_size;
	Buffer->FileAttributes = Fcb->FileAttributes;
	IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
	IoStatus->Status = STATUS_SUCCESS;
	ExReleaseResourceForThreadLite(
		&Fcb->MainResource,
		ExGetCurrentResourceThread());
	
	FsRtlExitFileSystem();
	
	return TRUE;
}

*/


BOOLEAN
Ext2AcquireForLazyWrite (IN PVOID    Context,
			 IN BOOLEAN  Wait)
{
	//
	// On a readonly filesystem this function still has to exist but it
	// doesn't need to do anything.
	
	PEXT2_FCB    Fcb;
#ifndef EXT2_RO
	BOOLEAN     Status;
#endif
	
	PAGED_CODE();
	
	Fcb = (PEXT2_FCB) Context;
	
	ASSERT(Fcb != NULL);
	
	ASSERT((Fcb->Identifier.Type == FCB) &&
		(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
	
#ifdef EXT2_RO
	return TRUE;
#else
	if (ExAcquireResourceExclusiveLite(
		&Fcb->MainResource,Wait)) {
		Status = TRUE;
	} else {
		Status = FALSE;
	}
	
	return Status;
#endif
}

VOID
Ext2ReleaseFromLazyWrite (IN PVOID Context)
{
	//
	// On a readonly filesystem this function still has to exist but it
	// doesn't need to do anything.
	PEXT2_FCB Fcb;
	
	PAGED_CODE();
	
	Fcb = (PEXT2_FCB) Context;
	
	ASSERT(Fcb != NULL);
	
	ASSERT((Fcb->Identifier.Type == FCB) &&
		(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
	
#ifdef EXT2_RO
	return;
#else
	
	ExReleaseResourceForThreadLite(
		&Fcb->MainResource,
		ExGetCurrentResourceThread());
#endif
}

BOOLEAN
Ext2AcquireForReadAhead (IN PVOID    Context,
			 IN BOOLEAN  Wait)
{
	PEXT2_FCB    Fcb;
	BOOLEAN     Status;
	
	PAGED_CODE();
	
	Fcb = (PEXT2_FCB) Context;
	
	ASSERT(Fcb != NULL);
	
	ASSERT((Fcb->Identifier.Type == FCB) &&
		(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
	
	if (ExAcquireResourceSharedLite(
		&Fcb->MainResource, Wait))
	{
		Status = TRUE;
	}
	else
	{
		Status = FALSE;
	}
	
	return Status;
}

VOID
Ext2ReleaseFromReadAhead (IN PVOID Context)
{
	PEXT2_FCB Fcb;
	
	PAGED_CODE();
	
	Fcb = (PEXT2_FCB) Context;
	
	ASSERT(Fcb != NULL);
	
	ASSERT((Fcb->Identifier.Type == FCB) &&
		(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
	
	ExReleaseResourceForThreadLite(
		&Fcb->MainResource,
		ExGetCurrentResourceThread());
}


NTSTATUS
Ext2Close (IN PEXT2_IRP_CONTEXT IrpContext)
{
	PDEVICE_OBJECT  DeviceObject;
	NTSTATUS        Status = STATUS_SUCCESS;
	PEXT2_VCB       Vcb;
	BOOLEAN         VcbResourceAcquired = FALSE;
	PFILE_OBJECT    FileObject;
	PEXT2_FCB       Fcb;
	BOOLEAN         FcbResourceAcquired = FALSE;
	PEXT2_CCB       Ccb;
	BOOLEAN         FreeVcb = FALSE;

	__try
	{
		ASSERT(IrpContext != NULL);
		
		ASSERT((IrpContext->Identifier.Type == ICX) &&
			(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
		
		DeviceObject = IrpContext->DeviceObject;

		if (DeviceObject == Ext2Global->DeviceObject)
		{
			Status = STATUS_SUCCESS;
			__leave;
		}
		
		Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
		
		ASSERT(Vcb != NULL);
		
		ASSERT((Vcb->Identifier.Type == VCB) &&
			(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
		
		if (!ExAcquireResourceExclusiveLite(
			&Vcb->MainResource,
			IrpContext->IsSynchronous ))
		{
			KdPrint(("Ext2Close: PENDING ... Vcb: %xh/%xh\n", Vcb->OpenFileHandleCount, Vcb->ReferenceCount));
			Status = STATUS_PENDING;
			__leave;
		}
		
		VcbResourceAcquired = TRUE;
		
		FileObject = IrpContext->FileObject;
		
		Fcb = (PEXT2_FCB) FileObject->FsContext;
		
		ASSERT(Fcb != NULL);
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -