NTSTATUS
Ex2ProcessMountPoint(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_MOUNT_POINT MountPoint,
IN ULONG Length
)
{
UNICODE_STRING Link;
UNICODE_STRING Target;
WCHAR Buffer[] = L"\\DosDevices\\Global\\Z:";
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_OBJECT DeviceObject = NULL;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
if (!IsExt2FsDevice(DeviceObject)) {
status = STATUS_INVALID_PARAMETER;
__leave;
}
if (Length != sizeof(EXT2_MOUNT_POINT) ||
MountPoint->Magic != EXT2_APP_MOUNTPOINT_MAGIC) {
status = STATUS_INVALID_PARAMETER;
__leave;
}
RtlInitUnicodeString(&Link, Buffer);
Buffer[12] = MountPoint->Link[0];
switch (MountPoint->Command) {
case APP_CMD_ADD_DOS_SYMLINK:
RtlInitUnicodeString(&Target, &MountPoint->Name[0]);
status = IoCreateSymbolicLink(&Link, &Target);
break;
case APP_CMD_DEL_DOS_SYMLINK:
status = IoDeleteSymbolicLink(&Link);
break;
default:
status = STATUS_INVALID_PARAMETER;
}
} __finally {
if (!IrpContext->ExceptionInProgress) {
Ext2CompleteIrpContext(IrpContext, status);
}
}
return status;
}
NTSTATUS
Ext2ProcessUserProperty(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_VOLUME_PROPERTY3 Property,
IN ULONG Length
)
{
NTSTATUS Status = STATUS_SUCCESS;
PEXT2_VCB Vcb = NULL;
PDEVICE_OBJECT DeviceObject = NULL;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
if (Property->Magic != EXT2_VOLUME_PROPERTY_MAGIC) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = Ext2ProcessGlobalProperty(DeviceObject, Property, Length);
} else {
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
if (!((Vcb) && (Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)))) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
Status = Ext2ProcessVolumeProperty(Vcb, Property, Length);
}
if (NT_SUCCESS(Status)) {
IrpContext->Irp->IoStatus.Information = Length;
}
} __finally {
if (!IrpContext->ExceptionInProgress) {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
return Status;
}
NTSTATUS
Ext2Write (IN PEXT2_IRP_CONTEXT IrpContext)
{
NTSTATUS Status;
PEXT2_FCBVCB FcbOrVcb;
PDEVICE_OBJECT DeviceObject;
PFILE_OBJECT FileObject;
PEXT2_VCB Vcb;
BOOLEAN bCompleteRequest = TRUE;
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
__try {
if (IsFlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE)) {
Status = Ext2WriteComplete(IrpContext);
bCompleteRequest = FALSE;
} else {
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
FileObject = IrpContext->FileObject;
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
if (Vcb->Identifier.Type != EXT2VCB ||
Vcb->Identifier.Size != sizeof(EXT2_VCB) ) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
if (IsVcbReadOnly(Vcb)) {
Status = STATUS_MEDIA_WRITE_PROTECTED;
__leave;
}
if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&
Vcb->LockFile != FileObject ) {
Status = STATUS_ACCESS_DENIED;
__leave;
}
FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
if (FcbOrVcb->Identifier.Type == EXT2VCB) {
Status = Ext2WriteVolume(IrpContext);
if (!NT_SUCCESS(Status)) {
DbgBreak();
}
bCompleteRequest = FALSE;
} else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
Status = STATUS_TOO_LATE;
__leave;
}
Status = Ext2WriteFile(IrpContext);
if (!NT_SUCCESS(Status)) {
DbgBreak();
}
bCompleteRequest = FALSE;
} else {
Status = STATUS_INVALID_PARAMETER;
}
}
} __finally {
if (bCompleteRequest) {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
return Status;
}
NTSTATUS
Ext2Cleanup (IN PEXT2_IRP_CONTEXT IrpContext)
{
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status = STATUS_SUCCESS;
PEXT2_VCB Vcb;
PFILE_OBJECT FileObject;
PEXT2_FCB Fcb;
PEXT2_CCB Ccb;
PIRP Irp;
PEXT2_MCB Mcb;
BOOLEAN VcbResourceAcquired = FALSE;
BOOLEAN FcbResourceAcquired = FALSE;
BOOLEAN FcbPagingIoResourceAcquired = FALSE;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_SUCCESS;
__leave;
}
Irp = IrpContext->Irp;
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
if (!IsVcbInited(Vcb)) {
Status = STATUS_SUCCESS;
__leave;
}
FileObject = IrpContext->FileObject;
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (!Fcb || (Fcb->Identifier.Type != EXT2VCB &&
Fcb->Identifier.Type != EXT2FCB)) {
Status = STATUS_SUCCESS;
__leave;
}
Mcb = Fcb->Mcb;
Ccb = (PEXT2_CCB) FileObject->FsContext2;
if (IsFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE)) {
Status = STATUS_SUCCESS;
__leave;
}
VcbResourceAcquired =
ExAcquireResourceExclusiveLite(
&Vcb->MainResource,
IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
);
if (Fcb->Identifier.Type == EXT2VCB) {
if (IsFlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&
(Vcb->LockFile == FileObject) ) {
ClearFlag(Vcb->Flags, VCB_VOLUME_LOCKED);
Vcb->LockFile = NULL;
Ext2ClearVpbFlag(Vcb->Vpb, VPB_LOCKED);
}
if (Ccb) {
Ext2DerefXcb(&Vcb->OpenHandleCount);
Ext2DerefXcb(&Vcb->OpenVolumeCount);
}
IoRemoveShareAccess(FileObject, &Vcb->ShareAccess);
Status = STATUS_SUCCESS;
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
if (IsFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE)) {
if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED) &&
IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK) &&
!IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED) ) {
Status = Ext2FlushFile(IrpContext, Fcb, Ccb);
}
__leave;
}
if (Ccb == NULL) {
Status = STATUS_SUCCESS;
__leave;
}
if (IsDirectory(Fcb)) {
if (IsFlagOn(Ccb->Flags, CCB_DELETE_ON_CLOSE)) {
SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING);
FsRtlNotifyFullChangeDirectory(
Vcb->NotifySync,
&Vcb->NotifyList,
Ccb,
NULL,
FALSE,
FALSE,
0,
NULL,
NULL,
NULL );
}
FsRtlNotifyCleanup(Vcb->NotifySync, &Vcb->NotifyList, Ccb);
}
ExReleaseResourceLite(&Vcb->MainResource);
VcbResourceAcquired = FALSE;
FcbResourceAcquired =
ExAcquireResourceExclusiveLite(
&Fcb->MainResource,
IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
);
ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
(Ccb->Identifier.Size == sizeof(EXT2_CCB)));
Ext2DerefXcb(&Vcb->OpenHandleCount);
Ext2DerefXcb(&Fcb->OpenHandleCount);
if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;
}
if (IsDirectory(Fcb)) {
ext3_release_dir(Fcb->Inode, &Ccb->filp);
} else {
if ( IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED) &&
!IsFlagOn(Ccb->Flags, CCB_LAST_WRITE_UPDATED)) {
LARGE_INTEGER SysTime;
KeQuerySystemTime(&SysTime);
Fcb->Inode->i_atime =
Fcb->Inode->i_mtime = Ext2LinuxTime(SysTime);
Fcb->Mcb->LastAccessTime =
Fcb->Mcb->LastWriteTime = Ext2NtTime(Fcb->Inode->i_atime);
Ext2SaveInode(IrpContext, Vcb, Fcb->Inode);
Ext2NotifyReportChange(
IrpContext,
Vcb,
Fcb->Mcb,
FILE_NOTIFY_CHANGE_ATTRIBUTES |
FILE_NOTIFY_CHANGE_LAST_WRITE |
FILE_NOTIFY_CHANGE_LAST_ACCESS,
FILE_ACTION_MODIFIED );
}
FsRtlCheckOplock( &Fcb->Oplock,
Irp,
IrpContext,
NULL,
NULL );
Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
if (!IsFlagOn(FileObject->Flags, FO_CACHE_SUPPORTED)) {
Fcb->NonCachedOpenCount--;
}
if (IsFlagOn(Ccb->Flags, CCB_DELETE_ON_CLOSE)) {
SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING);
}
//
// Drop any byte range locks this process may have on the file.
//
FsRtlFastUnlockAll(
&Fcb->FileLockAnchor,
FileObject,
IoGetRequestorProcess(Irp),
NULL );
//
// If there are no byte range locks owned by other processes on the
// file the fast I/O read/write functions doesn't have to check for
// locks so we set IsFastIoPossible to FastIoIsPossible again.
//
if (!FsRtlGetNextFileLock(&Fcb->FileLockAnchor, TRUE)) {
if (Fcb->Header.IsFastIoPossible != FastIoIsPossible) {
#if EXT2_DEBUG
DEBUG(DL_INF, (": %-16.16s %-31s %wZ\n",
Ext2GetCurrentProcessName(),
"FastIoIsPossible",
&Fcb->Mcb->FullName
));
#endif
Fcb->Header.IsFastIoPossible = FastIoIsPossible;
}
}
if (Fcb->OpenHandleCount == 0 &&
(IsFlagOn(Fcb->Flags, FCB_ALLOC_IN_CREATE) ||
IsFlagOn(Fcb->Flags, FCB_ALLOC_IN_WRITE)) ) {
LARGE_INTEGER Size;
ExAcquireResourceExclusiveLite(&Fcb->PagingIoResource, TRUE);
FcbPagingIoResourceAcquired = TRUE;
Size.QuadPart = CEILING_ALIGNED(ULONGLONG,
(ULONGLONG)Fcb->Mcb->Inode.i_size,
(ULONGLONG)BLOCK_SIZE);
if (!IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
Ext2TruncateFile(IrpContext, Vcb, Fcb->Mcb, &Size);
Fcb->Header.ValidDataLength.QuadPart =
Fcb->Header.FileSize.QuadPart = Fcb->Mcb->Inode.i_size;
Fcb->Header.AllocationSize = Size;
if (CcIsFileCached(FileObject)) {
CcSetFileSizes(FileObject,
(PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
}
}
ClearLongFlag(Fcb->Flags, FCB_ALLOC_IN_CREATE|FCB_ALLOC_IN_WRITE);
ExReleaseResourceLite(&Fcb->PagingIoResource);
FcbPagingIoResourceAcquired = FALSE;
}
}
if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
if (Fcb->OpenHandleCount == 0 || (Mcb = Ccb->SymLink)) {
//
// Ext2DeleteFile will acquire these lock inside
//
if (FcbResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
FcbResourceAcquired = FALSE;
}
//
// this file is to be deleted ...
//
if (Ccb->SymLink) {
Mcb = Ccb->SymLink;
FileObject->DeletePending = FALSE;
}
Status = Ext2DeleteFile(IrpContext, Vcb, Fcb, Mcb);
if (NT_SUCCESS(Status)) {
if (IsMcbDirectory(Mcb)) {
Ext2NotifyReportChange( IrpContext, Vcb, Mcb,
FILE_NOTIFY_CHANGE_DIR_NAME,
FILE_ACTION_REMOVED );
} else {
Ext2NotifyReportChange( IrpContext, Vcb, Mcb,
FILE_NOTIFY_CHANGE_FILE_NAME,
FILE_ACTION_REMOVED );
}
}
//
// re-acquire the main resource lock
//
FcbResourceAcquired =
ExAcquireResourceExclusiveLite(
&Fcb->MainResource,
IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
);
if (CcIsFileCached(FileObject)) {
CcSetFileSizes(FileObject,
(PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
SetFlag(FileObject->Flags, FO_FILE_MODIFIED);
}
}
}
if (!IsDirectory(Fcb)) {
if ( IsFlagOn(FileObject->Flags, FO_CACHE_SUPPORTED) &&
(Fcb->NonCachedOpenCount + 1 == Fcb->ReferenceCount) &&
(Fcb->SectionObject.DataSectionObject != NULL)) {
if (!IsFlagOn(Vcb->Flags, VCB_READ_ONLY) &&
!IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED) ) {
CcFlushCache(&Fcb->SectionObject, NULL, 0, NULL);
}
if (ExAcquireResourceExclusiveLite(&(Fcb->PagingIoResource), TRUE)) {
ExReleaseResourceLite(&(Fcb->PagingIoResource));
}
CcPurgeCacheSection( &Fcb->SectionObject,
NULL,
0,
FALSE );
}
CcUninitializeCacheMap(FileObject, NULL, NULL);
}
IoRemoveShareAccess(FileObject, &Fcb->ShareAccess);
DEBUG(DL_INF, ( "Ext2Cleanup: OpenCount=%u ReferCount=%u NonCahcedCount=%xh %wZ\n",
Fcb->OpenHandleCount, Fcb->ReferenceCount, Fcb->NonCachedOpenCount, &Fcb->Mcb->FullName));
Status = STATUS_SUCCESS;
if (FileObject) {
SetFlag(FileObject->Flags, FO_CLEANUP_COMPLETE);
}
} __finally {
if (FcbPagingIoResourceAcquired) {
ExReleaseResourceLite(&Fcb->PagingIoResource);
}
if (FcbResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
}
if (VcbResourceAcquired) {
ExReleaseResourceLite(&Vcb->MainResource);
}
if (!IrpContext->ExceptionInProgress) {
if (Status == STATUS_PENDING) {
Ext2QueueRequest(IrpContext);
} else {
IrpContext->Irp->IoStatus.Status = Status;
Ext2CompleteIrpContext(IrpContext, Status);
}
}
}
return Status;
}
BOOLEAN
Ext2FastIoQueryNetworkOpenInfo (
IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
IN OUT PFILE_NETWORK_OPEN_INFORMATION PFNOI,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject
)
{
BOOLEAN bResult = FALSE;
PEXT2_FCB Fcb = NULL;
BOOLEAN FcbResourceAcquired = FALSE;
__try {
FsRtlEnterFileSystem();
if (IsExt2FsDevice(DeviceObject)) {
IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
DbgBreak();
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if EXT2_DEBUG
DEBUG(DL_INF, (
"%-31s %wZ\n",
"FASTIO_QUERY_NETWORK_OPEN_INFO",
&Fcb->Mcb->FullName
));
#endif
if (FileObject->FsContext2) {
__leave;
}
if (!IsFlagOn(Fcb->Flags, FCB_PAGE_FILE)) {
if (!ExAcquireResourceSharedLite(
&Fcb->MainResource,
Wait
)) {
__leave;
}
FcbResourceAcquired = TRUE;
}
if (IsDirectory(Fcb)) {
PFNOI->AllocationSize.QuadPart = 0;
PFNOI->EndOfFile.QuadPart = 0;
} else {
PFNOI->AllocationSize = Fcb->Header.AllocationSize;
PFNOI->EndOfFile = Fcb->Header.FileSize;
}
PFNOI->FileAttributes = Fcb->Mcb->FileAttr;
if (PFNOI->FileAttributes == 0) {
PFNOI->FileAttributes = FILE_ATTRIBUTE_NORMAL;
}
if (IsRoot(Fcb)) {
PFNOI->CreationTime =
PFNOI->LastAccessTime =
PFNOI->LastWriteTime =
PFNOI->ChangeTime = Ext2NtTime(0);
} else {
PFNOI->CreationTime = Fcb->Mcb->CreationTime;
PFNOI->LastAccessTime = Fcb->Mcb->LastAccessTime;
PFNOI->LastWriteTime = Fcb->Mcb->LastWriteTime;
PFNOI->ChangeTime = Fcb->Mcb->ChangeTime;
}
bResult = TRUE;
IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
} __finally {
if (FcbResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
}
FsRtlExitFileSystem();
}
return bResult;
}
BOOLEAN
Ext2FastIoUnlockAllByKey (
IN PFILE_OBJECT FileObject,
IN PEPROCESS Process,
IN ULONG Key,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject
)
{
BOOLEAN Status = FALSE;
PEXT2_FCB Fcb;
__try {
FsRtlEnterFileSystem();
__try {
if (IsExt2FsDevice(DeviceObject)) {
IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
DbgBreak();
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
if (IsDirectory(Fcb)) {
DbgBreak();
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
#if EXT2_DEBUG
DEBUG(DL_INF, (
"Ext2FastIoUnlockAllByKey: %s %s %wZ\n",
(PUCHAR) Process + ProcessNameOffset,
"FASTIO_UNLOCK_ALL_BY_KEY",
&Fcb->Mcb->FullName
));
DEBUG(DL_INF, (
"Ext2FastIoUnlockAllByKey: Key: %u\n",
Key
));
#endif
if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
__leave;
}
IoStatus->Status = FsRtlFastUnlockAllByKey(
&Fcb->FileLockAnchor,
FileObject,
Process,
Key,
NULL
);
IoStatus->Information = 0;
Status = TRUE;
Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
} __except (EXCEPTION_EXECUTE_HANDLER) {
IoStatus->Status = GetExceptionCode();
}
} __finally {
FsRtlExitFileSystem();
}
#if EXT2_DEBUG
if (Status == FALSE) {
DEBUG(DL_ERR, (
"Ext2FastIoUnlockAllByKey: %s %s *** Status: FALSE ***\n",
(PUCHAR) Process + ProcessNameOffset,
"FASTIO_UNLOCK_ALL_BY_KEY"
));
} else if (IoStatus->Status != STATUS_SUCCESS) {
DEBUG(DL_ERR, (
"Ext2FastIoUnlockAllByKey: %s %s *** Status: %s (%#x) ***\n",
(PUCHAR) Process + ProcessNameOffset,
"FASTIO_UNLOCK_ALL_BY_KEY",
Ext2NtStatusToString(IoStatus->Status),
IoStatus->Status
));
}
#endif
return Status;
}
BOOLEAN
Ext2FastIoCheckIfPossible (
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
IN BOOLEAN Wait,
IN ULONG LockKey,
IN BOOLEAN CheckForReadOperation,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject
)
{
BOOLEAN bPossible = FastIoIsNotPossible;
PEXT2_FCB Fcb;
PEXT2_CCB Ccb;
LARGE_INTEGER lLength;
lLength.QuadPart = Length;
__try {
FsRtlEnterFileSystem();
__try {
if (IsExt2FsDevice(DeviceObject)) {
__leave;
}
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
if (IsDirectory(Fcb)) {
__leave;
}
Ccb = (PEXT2_CCB) FileObject->FsContext2;
if (Ccb == NULL) {
__leave;
}
if (CheckForReadOperation) {
bPossible = FsRtlFastCheckLockForRead(
&Fcb->FileLockAnchor,
FileOffset,
&lLength,
LockKey,
FileObject,
PsGetCurrentProcess());
} else {
if (!(IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY) ||
IsFlagOn(Fcb->Vcb->Flags, VCB_WRITE_PROTECTED))) {
bPossible = FsRtlFastCheckLockForWrite(
&Fcb->FileLockAnchor,
FileOffset,
&lLength,
LockKey,
FileObject,
PsGetCurrentProcess());
}
}
#if EXT2_DEBUG
DEBUG(DL_INF, ("Ext2FastIIOCheckPossible: %s %s %wZ\n",
Ext2GetCurrentProcessName(),
"FASTIO_CHECK_IF_POSSIBLE",
&Fcb->Mcb->FullName
));
DEBUG(DL_INF, (
"Ext2FastIIOCheckPossible: Offset: %I64xg Length: %xh Key: %u %s %s\n",
FileOffset->QuadPart,
Length,
LockKey,
(CheckForReadOperation ? "CheckForReadOperation:" :
"CheckForWriteOperation:"),
(bPossible ? "Succeeded" : "Failed")));
#endif
} __except (EXCEPTION_EXECUTE_HANDLER) {
bPossible = FastIoIsNotPossible;
}
} __finally {
FsRtlExitFileSystem();
}
return bPossible;
}
BOOLEAN
Ext2FastIoLock (
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER Length,
IN PEPROCESS Process,
IN ULONG Key,
IN BOOLEAN FailImmediately,
IN BOOLEAN ExclusiveLock,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject
)
{
BOOLEAN Status = FALSE;
PEXT2_FCB Fcb;
__try {
FsRtlEnterFileSystem();
__try {
if (IsExt2FsDevice(DeviceObject)) {
IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
if (IsDirectory(Fcb)) {
DbgBreak();
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
#if EXT2_DEBUG
DEBUG(DL_INF, (
"Ext2FastIoLock: %s %s %wZ\n",
Ext2GetCurrentProcessName(),
"FASTIO_LOCK",
&Fcb->Mcb->FullName ));
DEBUG(DL_INF, (
"Ext2FastIoLock: Offset: %I64xh Length: %I64xh Key: %u %s%s\n",
FileOffset->QuadPart,
Length->QuadPart,
Key,
(FailImmediately ? "FailImmediately " : ""),
(ExclusiveLock ? "ExclusiveLock " : "") ));
#endif
if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
__leave;
}
Status = FsRtlFastLock(
&Fcb->FileLockAnchor,
FileObject,
FileOffset,
Length,
Process,
Key,
FailImmediately,
ExclusiveLock,
IoStatus,
NULL,
FALSE);
if (Status) {
Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
}
} __except (EXCEPTION_EXECUTE_HANDLER) {
IoStatus->Status = GetExceptionCode();
}
} __finally {
FsRtlExitFileSystem();
}
#if EXT2_DEBUG
if (Status == FALSE) {
DEBUG(DL_ERR, (
"Ext2FastIoLock: %s %s *** Status: FALSE ***\n",
(PUCHAR) Process + ProcessNameOffset,
"FASTIO_LOCK"
));
} else if (IoStatus->Status != STATUS_SUCCESS) {
DEBUG(DL_ERR, (
"Ext2FastIoLock: %s %s *** Status: %s (%#x) ***\n",
(PUCHAR) Process + ProcessNameOffset,
"FASTIO_LOCK",
Ext2NtStatusToString(IoStatus->Status),
IoStatus->Status
));
}
#endif
return Status;
}
NTSTATUS
Ext2SetVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext)
{
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
PEXT2_VCB Vcb;
PIRP Irp;
PIO_STACK_LOCATION IoStackLocation;
FS_INFORMATION_CLASS FsInformationClass;
BOOLEAN VcbResourceAcquired = FALSE;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
//
// This request is not allowed on the main device object
//
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
ASSERT(IsMounted(Vcb));
if (IsFlagOn(Vcb->Flags, VCB_READ_ONLY)) {
Status = STATUS_MEDIA_WRITE_PROTECTED;
__leave;
}
if (!ExAcquireResourceExclusiveLite(
&Vcb->MainResource, TRUE)) {
Status = STATUS_PENDING;
__leave;
}
VcbResourceAcquired = TRUE;
Ext2VerifyVcb(IrpContext, Vcb);
Irp = IrpContext->Irp;
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
//Notes: SetVolume is not defined in ntddk.h of win2k ddk,
// But it's same to QueryVolume ....
FsInformationClass =
IoStackLocation->Parameters./*SetVolume*/QueryVolume.FsInformationClass;
switch (FsInformationClass) {
case FileFsLabelInformation:
{
PFILE_FS_LABEL_INFORMATION VolLabelInfo = NULL;
ULONG VolLabelLen;
UNICODE_STRING LabelName ;
OEM_STRING OemName;
VolLabelInfo = (PFILE_FS_LABEL_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
VolLabelLen = VolLabelInfo->VolumeLabelLength;
if (VolLabelLen > (16 * sizeof(WCHAR))) {
Status = STATUS_INVALID_VOLUME_LABEL;
__leave;
}
RtlCopyMemory( Vcb->Vpb->VolumeLabel,
VolLabelInfo->VolumeLabel,
VolLabelLen );
RtlZeroMemory(Vcb->SuperBlock->s_volume_name, 16);
LabelName.Buffer = VolLabelInfo->VolumeLabel;
LabelName.MaximumLength = (USHORT)16 * sizeof(WCHAR);
LabelName.Length = (USHORT)VolLabelLen;
OemName.Buffer = SUPER_BLOCK->s_volume_name;
OemName.Length = 0;
OemName.MaximumLength = 16;
Ext2UnicodeToOEM(Vcb, &OemName, &LabelName);
Vcb->Vpb->VolumeLabelLength = (USHORT) VolLabelLen;
if (Ext2SaveSuper(IrpContext, Vcb)) {
Status = STATUS_SUCCESS;
}
Irp->IoStatus.Information = 0;
}
break;
default:
Status = STATUS_INVALID_INFO_CLASS;
}
} __finally {
if (VcbResourceAcquired) {
ExReleaseResourceLite(&Vcb->MainResource);
}
if (!IrpContext->ExceptionInProgress) {
if (Status == STATUS_PENDING) {
Ext2QueueRequest(IrpContext);
} else {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
}
return Status;
}
BOOLEAN
Ext2FastIoQueryBasicInfo (
IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_BASIC_INFORMATION Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject)
{
PEXT2_FCB Fcb = NULL;
BOOLEAN Status = FALSE;
BOOLEAN FcbMainResourceAcquired = FALSE;
__try {
FsRtlEnterFileSystem();
__try {
if (IsExt2FsDevice(DeviceObject)) {
IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if EXT2_DEBUG
DEBUG(DL_INF, (
"Ext2FastIoQueryBasicInfo: %s %s %wZ\n",
Ext2GetCurrentProcessName(),
"FASTIO_QUERY_BASIC_INFO",
&Fcb->Mcb->FullName
));
#endif
if (!IsFlagOn(Fcb->Flags, FCB_PAGE_FILE)) {
if (!ExAcquireResourceSharedLite(
&Fcb->MainResource,
Wait)) {
__leave;
}
FcbMainResourceAcquired = TRUE;
}
RtlZeroMemory(Buffer, sizeof(FILE_BASIC_INFORMATION));
/*
typedef struct _FILE_BASIC_INFORMATION {
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
ULONG FileAttributes;
} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
*/
if (IsRoot(Fcb)) {
Buffer->CreationTime = Buffer->LastAccessTime =
Buffer->LastWriteTime = Buffer->ChangeTime = Ext2NtTime(0);
} else {
Buffer->CreationTime = Fcb->Mcb->CreationTime;
Buffer->LastAccessTime = Fcb->Mcb->LastAccessTime;
Buffer->LastWriteTime = Fcb->Mcb->LastWriteTime;
Buffer->ChangeTime = Fcb->Mcb->ChangeTime;
}
Buffer->FileAttributes = Fcb->Mcb->FileAttr;
if (Buffer->FileAttributes == 0) {
Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
}
IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
IoStatus->Status = STATUS_SUCCESS;
Status = TRUE;
} __except (EXCEPTION_EXECUTE_HANDLER) {
IoStatus->Status = GetExceptionCode();
}
} __finally {
if (FcbMainResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
}
FsRtlExitFileSystem();
}
#if EXT2_DEBUG
if (Status == FALSE) {
DEBUG(DL_ERR, ("Ext2FastIoQueryBasicInfo: %s %s Status: FALSE ***\n",
Ext2GetCurrentProcessName(),
"FASTIO_QUERY_BASIC_INFO"));
} else if (IoStatus->Status != STATUS_SUCCESS) {
DEBUG(DL_ERR, (
"Ext2FastIoQueryBasicInfo: %s %s Status: %#x ***\n",
Ext2FastIoQueryBasicInfo,
"FASTIO_QUERY_BASIC_INFO",
IoStatus->Status
));
}
#endif
return Status;
}
NTSTATUS
Ex2ProcessUserPerfStat(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_QUERY_PERFSTAT QueryPerf,
IN ULONG Length
)
{
PEXT2_VCB Vcb = NULL;
PDEVICE_OBJECT DeviceObject = NULL;
BOOLEAN GlobalDataResourceAcquired = FALSE;
NTSTATUS Status = STATUS_SUCCESS;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
if (QueryPerf->Magic != EXT2_QUERY_PERFSTAT_MAGIC) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
if (QueryPerf->Command != IOCTL_APP_QUERY_PERFSTAT) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
if (Length != EXT2_QUERY_PERFSTAT_SZV1 &&
Length != EXT2_QUERY_PERFSTAT_SZV2) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
ExAcquireResourceSharedLite(&Ext2Global->Resource, TRUE);
GlobalDataResourceAcquired = TRUE;
if (Length == EXT2_QUERY_PERFSTAT_SZV2) {
QueryPerf->Flags = EXT2_QUERY_PERFSTAT_VER2;
QueryPerf->PerfStatV2 = Ext2Global->PerfStat;
} else {
memcpy(&QueryPerf->PerfStatV1.Irps[0], &Ext2Global->PerfStat.Irps[0],
FIELD_OFFSET(EXT2_PERF_STATISTICS_V1, Unit));
memcpy(&QueryPerf->PerfStatV1.Unit, &Ext2Global->PerfStat.Unit,
sizeof(EXT2_STAT_ARRAY_V1));
memcpy(&QueryPerf->PerfStatV1.Current, &Ext2Global->PerfStat.Current,
sizeof(EXT2_STAT_ARRAY_V1));
memcpy(&QueryPerf->PerfStatV1.Size, &Ext2Global->PerfStat.Size,
sizeof(EXT2_STAT_ARRAY_V1));
memcpy(&QueryPerf->PerfStatV1.Total, &Ext2Global->PerfStat.Total,
sizeof(EXT2_STAT_ARRAY_V1));
}
} else {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
if (NT_SUCCESS(Status)) {
IrpContext->Irp->IoStatus.Information = Length;
}
} __finally {
if (GlobalDataResourceAcquired) {
ExReleaseResourceLite(&Ext2Global->Resource);
}
if (!IrpContext->ExceptionInProgress) {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
return Status;
}
NTSTATUS
Ext2DeviceControlNormal (IN PEXT2_IRP_CONTEXT IrpContext)
{
PDEVICE_OBJECT DeviceObject;
BOOLEAN CompleteRequest = TRUE;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
PEXT2_VCB Vcb;
PIRP Irp;
PIO_STACK_LOCATION IrpSp;
PIO_STACK_LOCATION NextIrpSp;
PDEVICE_OBJECT TargetDeviceObject;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
CompleteRequest = TRUE;
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Irp = IrpContext->Irp;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
Vcb = (PEXT2_VCB) IrpSp->FileObject->FsContext;
if (!((Vcb) && (Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)))) {
Status = STATUS_INVALID_PARAMETER;
__leave;
}
TargetDeviceObject = Vcb->TargetDeviceObject;
//
// Pass on the IOCTL to the driver below
//
CompleteRequest = FALSE;
NextIrpSp = IoGetNextIrpStackLocation( Irp );
*NextIrpSp = *IrpSp;
IoSetCompletionRoutine(
Irp,
Ext2DeviceControlCompletion,
NULL,
FALSE,
TRUE,
TRUE );
Status = IoCallDriver(TargetDeviceObject, Irp);
} __finally {
if (!IrpContext->ExceptionInProgress) {
if (IrpContext) {
if (!CompleteRequest) {
IrpContext->Irp = NULL;
}
Ext2CompleteIrpContext(IrpContext, Status);
}
}
}
return Status;
}
NTSTATUS
Ext2PrepareToUnload (IN PEXT2_IRP_CONTEXT IrpContext)
{
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
BOOLEAN GlobalDataResourceAcquired = FALSE;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
ExAcquireResourceExclusiveLite(
&Ext2Global->Resource,
TRUE );
GlobalDataResourceAcquired = TRUE;
if (FlagOn(Ext2Global->Flags, EXT2_UNLOAD_PENDING)) {
DEBUG(DL_ERR, ( "Ext2PrepareUnload: Already ready to unload.\n"));
Status = STATUS_ACCESS_DENIED;
__leave;
}
{
PEXT2_VCB Vcb;
PLIST_ENTRY ListEntry;
ListEntry = Ext2Global->VcbList.Flink;
while (ListEntry != &(Ext2Global->VcbList)) {
Vcb = CONTAINING_RECORD(ListEntry, EXT2_VCB, Next);
ListEntry = ListEntry->Flink;
if (Vcb && (!Vcb->ReferenceCount) &&
IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
Ext2RemoveVcb(Vcb);
Ext2ClearVpbFlag(Vcb->Vpb, VPB_MOUNTED);
Ext2DestroyVcb(Vcb);
}
}
}
if (!IsListEmpty(&(Ext2Global->VcbList))) {
DEBUG(DL_ERR, ( "Ext2PrepareUnload: Mounted volumes exists.\n"));
Status = STATUS_ACCESS_DENIED;
__leave;
}
IoUnregisterFileSystem(Ext2Global->DiskdevObject);
IoUnregisterFileSystem(Ext2Global->CdromdevObject);
Ext2Global->DriverObject->DriverUnload = DriverUnload;
SetLongFlag(Ext2Global->Flags ,EXT2_UNLOAD_PENDING);
Status = STATUS_SUCCESS;
DEBUG(DL_INF, ( "Ext2PrepareToUnload: Driver is ready to unload.\n"));
} __finally {
if (GlobalDataResourceAcquired) {
ExReleaseResourceLite(&Ext2Global->Resource);
}
if (!IrpContext->ExceptionInProgress) {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
return Status;
}
NTSTATUS
Ext2Close (IN PEXT2_IRP_CONTEXT IrpContext)
{
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status = STATUS_SUCCESS;
PEXT2_VCB Vcb = NULL;
PFILE_OBJECT FileObject;
PEXT2_FCB Fcb = NULL;
PEXT2_CCB Ccb = NULL;
BOOLEAN VcbResourceAcquired = FALSE;
BOOLEAN FcbResourceAcquired = FALSE;
BOOLEAN bDeleteVcb = FALSE;
BOOLEAN bBeingClosed = FALSE;
BOOLEAN bSkipLeave = FALSE;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_SUCCESS;
Vcb = NULL;
__leave;
}
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
if (!ExAcquireResourceExclusiveLite(
&Vcb->MainResource,
TRUE )) {
DEBUG(DL_INF, ("Ext2Close: PENDING ... Vcb: %xh/%xh\n",
Vcb->OpenHandleCount, Vcb->ReferenceCount));
Status = STATUS_PENDING;
__leave;
}
VcbResourceAcquired = TRUE;
bSkipLeave = TRUE;
if (IsFlagOn(Vcb->Flags, VCB_BEING_CLOSED)) {
bBeingClosed = TRUE;
} else {
SetLongFlag(Vcb->Flags, VCB_BEING_CLOSED);
bBeingClosed = FALSE;
}
if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE)) {
FileObject = NULL;
Fcb = IrpContext->Fcb;
Ccb = IrpContext->Ccb;
} else {
FileObject = IrpContext->FileObject;
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (!Fcb) {
Status = STATUS_SUCCESS;
__leave;
}
ASSERT(Fcb != NULL);
Ccb = (PEXT2_CCB) FileObject->FsContext2;
}
DEBUG(DL_INF, ( "Ext2Close: (VCB) bBeingClosed = %d Vcb = %p ReferCount = %d\n",
bBeingClosed, Vcb, Vcb->ReferenceCount));
if (Fcb->Identifier.Type == EXT2VCB) {
if (Ccb) {
Ext2DerefXcb(&Vcb->ReferenceCount);
Ext2FreeCcb(Vcb, Ccb);
if (FileObject) {
FileObject->FsContext2 = Ccb = NULL;
}
}
Status = STATUS_SUCCESS;
__leave;
}
if ( Fcb->Identifier.Type != EXT2FCB ||
Fcb->Identifier.Size != sizeof(EXT2_FCB)) {
__leave;
}
if (!ExAcquireResourceExclusiveLite(
&Fcb->MainResource,
TRUE )) {
Status = STATUS_PENDING;
__leave;
}
FcbResourceAcquired = TRUE;
Fcb->Header.IsFastIoPossible = FastIoIsNotPossible;
if (!Ccb) {
Status = STATUS_SUCCESS;
__leave;
}
ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
(Ccb->Identifier.Size == sizeof(EXT2_CCB)));
if (IsFlagOn(Fcb->Flags, FCB_STATE_BUSY)) {
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_FILE_BUSY);
DEBUG(DL_WRN, ( "Ext2Close: busy bit set: %wZ\n", &Fcb->Mcb->FullName ));
Status = STATUS_PENDING;
__leave;
}
DEBUG(DL_INF, ( "Ext2Close: Fcb = %p OpenHandleCount= %u ReferenceCount=%u NonCachedCount=%u %wZ\n",
Fcb, Fcb->OpenHandleCount, Fcb->ReferenceCount, Fcb->NonCachedOpenCount, &Fcb->Mcb->FullName ));
if (Ccb) {
Ext2FreeCcb(Vcb, Ccb);
if (FileObject) {
FileObject->FsContext2 = Ccb = NULL;
}
}
if (0 == Ext2DerefXcb(&Fcb->ReferenceCount)) {
//
// Remove Fcb from Vcb->FcbList ...
//
if (FcbResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
FcbResourceAcquired = FALSE;
}
Ext2FreeFcb(Fcb);
if (FileObject) {
FileObject->FsContext = Fcb = NULL;
}
}
Ext2DerefXcb(&Vcb->ReferenceCount);
Status = STATUS_SUCCESS;
} __finally {
if (NT_SUCCESS(Status) && Vcb != NULL && IsVcbInited(Vcb)) {
/* for Ext2Fsd driver open/close, Vcb is NULL */
if ((!bBeingClosed) && (Vcb->ReferenceCount == 0) &&
(!IsMounted(Vcb) || IsDispending(Vcb))) {
bDeleteVcb = TRUE;
}
}
if (bSkipLeave && !bBeingClosed) {
ClearFlag(Vcb->Flags, VCB_BEING_CLOSED);
}
if (FcbResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
}
if (VcbResourceAcquired) {
ExReleaseResourceLite(&Vcb->MainResource);
}
if (!IrpContext->ExceptionInProgress) {
if (Status == STATUS_PENDING) {
Ext2QueueCloseRequest(IrpContext);
} else {
Ext2CompleteIrpContext(IrpContext, Status);
if (bDeleteVcb) {
PVPB Vpb = Vcb->Vpb;
DEBUG(DL_DBG, ( "Ext2Close: Try to free Vcb %p and Vpb %p\n",
Vcb, Vpb));
Ext2CheckDismount(IrpContext, Vcb, FALSE);
}
}
}
}
return Status;
}
NTSTATUS
Ext2Read (IN PEXT2_IRP_CONTEXT IrpContext)
{
NTSTATUS Status;
PEXT2_VCB Vcb;
PEXT2_FCBVCB FcbOrVcb;
PDEVICE_OBJECT DeviceObject;
PFILE_OBJECT FileObject;
BOOLEAN bCompleteRequest;
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
__try {
if (FlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE)) {
Status = Ext2ReadComplete(IrpContext);
bCompleteRequest = FALSE;
} else {
DeviceObject = IrpContext->DeviceObject;
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
bCompleteRequest = TRUE;
__leave;
}
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
if (Vcb->Identifier.Type != EXT2VCB ||
Vcb->Identifier.Size != sizeof(EXT2_VCB) ) {
Status = STATUS_INVALID_DEVICE_REQUEST;
bCompleteRequest = TRUE;
__leave;
}
FileObject = IrpContext->FileObject;
if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&
Vcb->LockFile != FileObject ) {
Status = STATUS_ACCESS_DENIED;
__leave;
}
FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
if (FcbOrVcb->Identifier.Type == EXT2VCB) {
Status = Ext2ReadVolume(IrpContext);
bCompleteRequest = FALSE;
} else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
Status = STATUS_TOO_LATE;
bCompleteRequest = TRUE;
__leave;
}
Status = Ext2ReadFile(IrpContext);
bCompleteRequest = FALSE;
} else {
DEBUG(DL_ERR, ( "Ext2Read: Inavlid FileObject (Vcb or Fcb corrupted)\n"));
DbgBreak();
Status = STATUS_INVALID_PARAMETER;
bCompleteRequest = TRUE;
}
}
} __finally {
if (bCompleteRequest) {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
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
)
{
BOOLEAN Status = FALSE;
PEXT2_VCB Vcb;
PEXT2_FCB Fcb;
BOOLEAN FcbMainResourceAcquired = FALSE;
__try {
FsRtlEnterFileSystem();
__try {
if (IsExt2FsDevice(DeviceObject)) {
IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Fcb = (PEXT2_FCB) FileObject->FsContext;
if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
IoStatus->Status = STATUS_INVALID_PARAMETER;
__leave;
}
ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
(Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if EXT2_DEBUG
DEBUG(DL_INF, (
"Ext2FastIoQueryStandardInfo: %s %s %wZ\n",
Ext2GetCurrentProcessName(),
"FASTIO_QUERY_STANDARD_INFO",
&Fcb->Mcb->FullName ));
#endif
Vcb = Fcb->Vcb;
if (!IsFlagOn(Fcb->Flags, FCB_PAGE_FILE)) {
if (!ExAcquireResourceSharedLite(
&Fcb->MainResource,
Wait )) {
__leave;
}
FcbMainResourceAcquired = TRUE;
}
RtlZeroMemory(Buffer, sizeof(FILE_STANDARD_INFORMATION));
/*
typedef struct _FILE_STANDARD_INFORMATION {
LARGE_INTEGER AllocationSize;
LARGE_INTEGER EndOfFile;
ULONG NumberOfLinks;
BOOLEAN DeletePending;
BOOLEAN Directory;
} FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
*/
Buffer->NumberOfLinks = Fcb->Inode->i_nlink;
Buffer->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
if (IsDirectory(Fcb)) {
Buffer->Directory = IsDirectory(Fcb);
Buffer->AllocationSize.QuadPart = 0;
Buffer->EndOfFile.QuadPart = 0;
} else {
Buffer->Directory = FALSE;
Buffer->AllocationSize = Fcb->Header.AllocationSize;
Buffer->EndOfFile = Fcb->Header.FileSize;
}
IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
IoStatus->Status = STATUS_SUCCESS;
#if EXT2_DEBUG
DEBUG(DL_INF, ( "Ext2FastIoQueryStandInfo: AllocatieonSize = %I64xh FileSize = %I64xh\n",
Buffer->AllocationSize.QuadPart, Buffer->EndOfFile.QuadPart));
#endif
Status = TRUE;
} __except (EXCEPTION_EXECUTE_HANDLER) {
IoStatus->Status = GetExceptionCode();
}
} __finally {
if (FcbMainResourceAcquired) {
ExReleaseResourceLite(&Fcb->MainResource);
}
FsRtlExitFileSystem();
}
#if EXT2_DEBUG
if (Status == FALSE) {
DEBUG(DL_INF, (
"Ext2FastIoQueryStandardInfo: %s %s Status: FALSE ***\n",
Ext2GetCurrentProcessName(),
"FASTIO_QUERY_STANDARD_INFO" ));
} else if (IoStatus->Status != STATUS_SUCCESS) {
DEBUG(DL_INF, (
"Ext2FastIoQueryStandardInfo: %s %s Status: %#x ***\n",
Ext2GetCurrentProcessName(),
"FASTIO_QUERY_STANDARD_INFO",
IoStatus->Status ));
}
#endif
return Status;
}
NTSTATUS
Ext2Flush (IN PEXT2_IRP_CONTEXT IrpContext)
{
NTSTATUS Status = STATUS_SUCCESS;
PIRP Irp = NULL;
PIO_STACK_LOCATION IrpSp = NULL;
PEXT2_VCB Vcb = NULL;
PEXT2_FCB Fcb = NULL;
PEXT2_FCBVCB FcbOrVcb = NULL;
PEXT2_CCB Ccb = NULL;
PFILE_OBJECT FileObject = NULL;
PDEVICE_OBJECT DeviceObject = NULL;
BOOLEAN MainResourceAcquired = FALSE;
__try {
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
//
// This request is not allowed on the main device object
//
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
ASSERT(IsMounted(Vcb));
if ( IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||
IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {
Status = STATUS_SUCCESS;
__leave;
}
Irp = IrpContext->Irp;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
FileObject = IrpContext->FileObject;
FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
ASSERT(FcbOrVcb != NULL);
Ccb = (PEXT2_CCB) FileObject->FsContext2;
if (Ccb == NULL) {
Status = STATUS_SUCCESS;
__leave;
}
MainResourceAcquired =
ExAcquireResourceExclusiveLite(&FcbOrVcb->MainResource,
IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
ASSERT(MainResourceAcquired);
DEBUG(DL_INF, ("Ext2Flush-pre: total mcb records=%u\n",
FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
if (FcbOrVcb->Identifier.Type == EXT2VCB) {
Ext2VerifyVcb(IrpContext, Vcb);
Status = Ext2FlushFiles(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);
if (NT_SUCCESS(Status)) {
__leave;
}
Status = Ext2FlushVolume(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);
if (NT_SUCCESS(Status) && IsFlagOn(Vcb->Volume->Flags, FO_FILE_MODIFIED)) {
ClearFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
}
} else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
Fcb = (PEXT2_FCB)(FcbOrVcb);
Status = Ext2FlushFile(IrpContext, Fcb, Ccb);
if (NT_SUCCESS(Status)) {
if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;
ClearFlag(FileObject->Flags, FO_FILE_MODIFIED);
}
}
}
DEBUG(DL_INF, ("Ext2Flush-post: total mcb records=%u\n",
FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
} __finally {
if (MainResourceAcquired) {
ExReleaseResourceLite(&FcbOrVcb->MainResource);
}
if (!IrpContext->ExceptionInProgress) {
if (Vcb && Irp && IrpSp && (!IsFlagOn(Vcb->Flags, VCB_READ_ONLY))) {
// Call the disk driver to flush the physial media.
NTSTATUS DriverStatus;
PIO_STACK_LOCATION NextIrpSp;
NextIrpSp = IoGetNextIrpStackLocation(Irp);
*NextIrpSp = *IrpSp;
IoSetCompletionRoutine( Irp,
Ext2FlushCompletionRoutine,
NULL,
TRUE,
TRUE,
TRUE );
DriverStatus = IoCallDriver(Vcb->TargetDeviceObject, Irp);
Status = (DriverStatus == STATUS_INVALID_DEVICE_REQUEST) ?
Status : DriverStatus;
IrpContext->Irp = Irp = NULL;
}
Ext2CompleteIrpContext(IrpContext, Status);
}
}
return Status;
}
NTSTATUS
Ext2QueryVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext)
{
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
PEXT2_VCB Vcb;
PIRP Irp;
PIO_STACK_LOCATION IoStackLocation;
FS_INFORMATION_CLASS FsInformationClass;
ULONG Length;
PVOID Buffer;
BOOLEAN VcbResourceAcquired = FALSE;
__try {
ASSERT(IrpContext != NULL);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
DeviceObject = IrpContext->DeviceObject;
//
// This request is not allowed on the main device object
//
if (IsExt2FsDevice(DeviceObject)) {
Status = STATUS_INVALID_DEVICE_REQUEST;
__leave;
}
Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
ASSERT(Vcb != NULL);
ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
(Vcb->Identifier.Size == sizeof(EXT2_VCB)));
if (!IsMounted(Vcb)) {
Status = STATUS_VOLUME_DISMOUNTED;
__leave;
}
if (!ExAcquireResourceSharedLite(
&Vcb->MainResource,
IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
)) {
Status = STATUS_PENDING;
__leave;
}
VcbResourceAcquired = TRUE;
Irp = IrpContext->Irp;
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
FsInformationClass =
IoStackLocation->Parameters.QueryVolume.FsInformationClass;
Length = IoStackLocation->Parameters.QueryVolume.Length;
Buffer = Irp->AssociatedIrp.SystemBuffer;
RtlZeroMemory(Buffer, Length);
switch (FsInformationClass) {
case FileFsVolumeInformation:
{
PFILE_FS_VOLUME_INFORMATION FsVolInfo;
ULONG VolumeLabelLength;
ULONG RequiredLength;
if (Length < sizeof(FILE_FS_VOLUME_INFORMATION)) {
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
FsVolInfo = (PFILE_FS_VOLUME_INFORMATION) Buffer;
FsVolInfo->VolumeCreationTime.QuadPart = 0;
FsVolInfo->VolumeSerialNumber = Vcb->Vpb->SerialNumber;
VolumeLabelLength = Vcb->Vpb->VolumeLabelLength;
FsVolInfo->VolumeLabelLength = VolumeLabelLength;
/* We don't support ObjectId */
FsVolInfo->SupportsObjects = FALSE;
RequiredLength = sizeof(FILE_FS_VOLUME_INFORMATION)
+ VolumeLabelLength - sizeof(WCHAR);
if (Length < RequiredLength) {
Irp->IoStatus.Information =
sizeof(FILE_FS_VOLUME_INFORMATION);
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
RtlCopyMemory(FsVolInfo->VolumeLabel, Vcb->Vpb->VolumeLabel, Vcb->Vpb->VolumeLabelLength);
Irp->IoStatus.Information = RequiredLength;
Status = STATUS_SUCCESS;
}
break;
case FileFsSizeInformation:
{
PFILE_FS_SIZE_INFORMATION FsSizeInfo;
if (Length < sizeof(FILE_FS_SIZE_INFORMATION)) {
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
FsSizeInfo = (PFILE_FS_SIZE_INFORMATION) Buffer;
FsSizeInfo->TotalAllocationUnits.QuadPart =
ext3_blocks_count(SUPER_BLOCK);
FsSizeInfo->AvailableAllocationUnits.QuadPart =
ext3_free_blocks_count(SUPER_BLOCK);
FsSizeInfo->SectorsPerAllocationUnit =
Vcb->BlockSize / Vcb->DiskGeometry.BytesPerSector;
FsSizeInfo->BytesPerSector =
Vcb->DiskGeometry.BytesPerSector;
Irp->IoStatus.Information = sizeof(FILE_FS_SIZE_INFORMATION);
Status = STATUS_SUCCESS;
}
break;
case FileFsDeviceInformation:
{
PFILE_FS_DEVICE_INFORMATION FsDevInfo;
if (Length < sizeof(FILE_FS_DEVICE_INFORMATION)) {
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
FsDevInfo = (PFILE_FS_DEVICE_INFORMATION) Buffer;
FsDevInfo->DeviceType =
Vcb->TargetDeviceObject->DeviceType;
if (FsDevInfo->DeviceType != FILE_DEVICE_DISK) {
DbgBreak();
}
FsDevInfo->Characteristics =
Vcb->TargetDeviceObject->Characteristics;
if (FlagOn(Vcb->Flags, VCB_READ_ONLY)) {
SetFlag( FsDevInfo->Characteristics,
FILE_READ_ONLY_DEVICE );
}
Irp->IoStatus.Information = sizeof(FILE_FS_DEVICE_INFORMATION);
Status = STATUS_SUCCESS;
}
break;
case FileFsAttributeInformation:
{
PFILE_FS_ATTRIBUTE_INFORMATION FsAttrInfo;
ULONG RequiredLength;
if (Length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION)) {
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
FsAttrInfo =
(PFILE_FS_ATTRIBUTE_INFORMATION) Buffer;
FsAttrInfo->FileSystemAttributes =
FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
FsAttrInfo->MaximumComponentNameLength = EXT2_NAME_LEN;
FsAttrInfo->FileSystemNameLength = 8;
RequiredLength = sizeof(FILE_FS_ATTRIBUTE_INFORMATION) +
8 - sizeof(WCHAR);
if (Length < RequiredLength) {
Irp->IoStatus.Information =
sizeof(FILE_FS_ATTRIBUTE_INFORMATION);
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
if (Vcb->IsExt3fs) {
RtlCopyMemory(FsAttrInfo->FileSystemName, L"EXT3\0", 10);
} else {
RtlCopyMemory(FsAttrInfo->FileSystemName, L"EXT2\0", 10);
}
Irp->IoStatus.Information = RequiredLength;
Status = STATUS_SUCCESS;
}
break;
#if (_WIN32_WINNT >= 0x0500)
case FileFsFullSizeInformation:
{
PFILE_FS_FULL_SIZE_INFORMATION PFFFSI;
if (Length < sizeof(FILE_FS_FULL_SIZE_INFORMATION)) {
Status = STATUS_BUFFER_OVERFLOW;
__leave;
}
PFFFSI = (PFILE_FS_FULL_SIZE_INFORMATION) Buffer;
/*
typedef struct _FILE_FS_FULL_SIZE_INFORMATION {
LARGE_INTEGER TotalAllocationUnits;
LARGE_INTEGER CallerAvailableAllocationUnits;
LARGE_INTEGER ActualAvailableAllocationUnits;
ULONG SectorsPerAllocationUnit;
ULONG BytesPerSector;
} FILE_FS_FULL_SIZE_INFORMATION, *PFILE_FS_FULL_SIZE_INFORMATION;
*/
{
PFFFSI->TotalAllocationUnits.QuadPart =
ext3_blocks_count(SUPER_BLOCK);
PFFFSI->CallerAvailableAllocationUnits.QuadPart =
ext3_free_blocks_count(SUPER_BLOCK);
/* - Vcb->SuperBlock->s_r_blocks_count; */
PFFFSI->ActualAvailableAllocationUnits.QuadPart =
ext3_free_blocks_count(SUPER_BLOCK);
}
PFFFSI->SectorsPerAllocationUnit =
Vcb->BlockSize / Vcb->DiskGeometry.BytesPerSector;
PFFFSI->BytesPerSector = Vcb->DiskGeometry.BytesPerSector;
Irp->IoStatus.Information = sizeof(FILE_FS_FULL_SIZE_INFORMATION);
Status = STATUS_SUCCESS;
}
break;
#endif // (_WIN32_WINNT >= 0x0500)
default:
Status = STATUS_INVALID_INFO_CLASS;
break;
}
} __finally {
if (VcbResourceAcquired) {
ExReleaseResourceLite(&Vcb->MainResource);
}
if (!IrpContext->ExceptionInProgress) {
if (Status == STATUS_PENDING) {
Ext2QueueRequest(IrpContext);
} else {
Ext2CompleteIrpContext(IrpContext, Status);
}
}
}
return Status;
}
