mirror of
https://github.com/reactos/reactos.git
synced 2024-08-26 05:08:39 +00:00
1577 lines
37 KiB
C
1577 lines
37 KiB
C
/*++
|
||
|
||
Copyright (c) 1989-2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
FatData.c
|
||
|
||
Abstract:
|
||
|
||
This module declares the global data used by the Fat file system.
|
||
|
||
|
||
--*/
|
||
|
||
#include "fatprocs.h"
|
||
|
||
//
|
||
// The Bug check file id for this module
|
||
//
|
||
|
||
#define BugCheckFileId (FAT_BUG_CHECK_FATDATA)
|
||
|
||
//
|
||
// The debug trace level
|
||
//
|
||
|
||
#define Dbg (DEBUG_TRACE_CATCH_EXCEPTIONS)
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
|
||
#if DBG
|
||
#ifdef _MSC_VER
|
||
#pragma alloc_text(PAGE, FatBugCheckExceptionFilter)
|
||
#endif
|
||
#endif
|
||
|
||
#pragma alloc_text(PAGE, FatCompleteRequest_Real)
|
||
#pragma alloc_text(PAGE, FatFastIoCheckIfPossible)
|
||
#pragma alloc_text(PAGE, FatFastQueryBasicInfo)
|
||
#pragma alloc_text(PAGE, FatFastQueryNetworkOpenInfo)
|
||
#pragma alloc_text(PAGE, FatFastQueryStdInfo)
|
||
#pragma alloc_text(PAGE, FatIsIrpTopLevel)
|
||
#pragma alloc_text(PAGE, FatPopUpFileCorrupt)
|
||
#pragma alloc_text(PAGE, FatProcessException)
|
||
#endif
|
||
|
||
|
||
//
|
||
// The global fsd data record, and zero large integer
|
||
//
|
||
|
||
#ifdef _MSC_VER
|
||
#pragma prefast( suppress:22112, "only applies to user mode processes" )
|
||
#endif
|
||
FAT_DATA FatData;
|
||
|
||
PDEVICE_OBJECT FatDiskFileSystemDeviceObject;
|
||
PDEVICE_OBJECT FatCdromFileSystemDeviceObject;
|
||
|
||
#ifndef __REACTOS__
|
||
LARGE_INTEGER FatLargeZero = {0,0};
|
||
LARGE_INTEGER FatMaxLarge = {MAXULONG,MAXLONG};
|
||
#else
|
||
LARGE_INTEGER FatLargeZero = {{0,0}};
|
||
LARGE_INTEGER FatMaxLarge = {{MAXULONG,MAXLONG}};
|
||
#endif
|
||
|
||
#ifndef __REACTOS__
|
||
LARGE_INTEGER Fat30Milliseconds = {(ULONG)(-30 * 1000 * 10), -1};
|
||
LARGE_INTEGER Fat100Milliseconds = {(ULONG)(-30 * 1000 * 10), -1};
|
||
LARGE_INTEGER FatOneDay = {0x2a69c000, 0xc9};
|
||
LARGE_INTEGER FatJanOne1980 = {0xe1d58000,0x01a8e79f};
|
||
LARGE_INTEGER FatDecThirtyOne1979 = {0xb76bc000,0x01a8e6d6};
|
||
#else
|
||
LARGE_INTEGER Fat30Milliseconds = {{(ULONG)(-30 * 1000 * 10), -1}};
|
||
LARGE_INTEGER Fat100Milliseconds = {{(ULONG)(-30 * 1000 * 10), -1}};
|
||
LARGE_INTEGER FatOneDay = {{0x2a69c000, 0xc9}};
|
||
LARGE_INTEGER FatJanOne1980 = {{0xe1d58000,0x01a8e79f}};
|
||
LARGE_INTEGER FatDecThirtyOne1979 = {{0xb76bc000,0x01a8e6d6}};
|
||
#endif
|
||
|
||
FAT_TIME_STAMP FatTimeJanOne1980 = {{0,0,0},{1,1,0}};
|
||
|
||
#ifndef __REACTOS__
|
||
LARGE_INTEGER FatMagic10000 = {0xe219652c, 0xd1b71758};
|
||
LARGE_INTEGER FatMagic86400000 = {0xfa67b90e, 0xc6d750eb};
|
||
#else
|
||
LARGE_INTEGER FatMagic10000 = {{0xe219652c, 0xd1b71758}};
|
||
LARGE_INTEGER FatMagic86400000 = {{0xfa67b90e, 0xc6d750eb}};
|
||
#endif
|
||
|
||
#ifdef _MSC_VER
|
||
#pragma prefast( suppress:22112, "only applies to user mode processes" )
|
||
#endif
|
||
FAST_IO_DISPATCH FatFastIoDispatch;
|
||
|
||
//
|
||
// Our lookaside lists.
|
||
//
|
||
|
||
NPAGED_LOOKASIDE_LIST FatIrpContextLookasideList;
|
||
NPAGED_LOOKASIDE_LIST FatNonPagedFcbLookasideList;
|
||
NPAGED_LOOKASIDE_LIST FatEResourceLookasideList;
|
||
|
||
SLIST_HEADER FatCloseContextSList;
|
||
|
||
//
|
||
// Synchronization for the close queue
|
||
//
|
||
|
||
FAST_MUTEX FatCloseQueueMutex;
|
||
|
||
//
|
||
// Reserve MDL for paging file operations.
|
||
//
|
||
|
||
#ifndef __REACTOS__
|
||
PMDL FatReserveMdl = NULL;
|
||
#else
|
||
volatile PMDL FatReserveMdl = NULL;
|
||
#endif
|
||
KEVENT FatReserveEvent;
|
||
|
||
//
|
||
// Global disk accounting state, enabled or disabled
|
||
//
|
||
|
||
LOGICAL FatDiskAccountingEnabled = FALSE;
|
||
|
||
|
||
#ifdef FASTFATDBG
|
||
|
||
LONG FatDebugTraceLevel = 0x00000009;
|
||
LONG FatDebugTraceIndent = 0;
|
||
|
||
ULONG FatFsdEntryCount = 0;
|
||
ULONG FatFspEntryCount = 0;
|
||
ULONG FatIoCallDriverCount = 0;
|
||
|
||
LONG FatPerformanceTimerLevel = 0x00000000;
|
||
|
||
ULONG FatTotalTicks[32] = { 0 };
|
||
|
||
//
|
||
// I need this because C can't support conditional compilation within
|
||
// a macro.
|
||
//
|
||
|
||
PVOID FatNull = NULL;
|
||
|
||
#endif // FASTFATDBG
|
||
|
||
#if DBG
|
||
|
||
BOOLEAN FatTestRaisedStatus = FALSE;
|
||
|
||
NTSTATUS FatBreakOnInterestingIoCompletion = STATUS_SUCCESS;
|
||
NTSTATUS FatBreakOnInterestingExceptionStatus = 0;
|
||
NTSTATUS FatBreakOnInterestingIrpCompletion = 0;
|
||
|
||
#endif
|
||
|
||
|
||
#if DBG
|
||
ULONG
|
||
FatBugCheckExceptionFilter (
|
||
IN PEXCEPTION_POINTERS ExceptionPointer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
An exception filter which acts as an assert that the exception should
|
||
never occur.
|
||
|
||
This is only valid on debug builds, we don't want the overhead on retail.
|
||
|
||
Arguments:
|
||
|
||
ExceptionPointers - The result of GetExceptionInformation() in the context
|
||
of the exception.
|
||
|
||
Return Value:
|
||
|
||
Bugchecks.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE();
|
||
|
||
FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
|
||
(ULONG_PTR)ExceptionPointer->ContextRecord,
|
||
(ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
|
||
|
||
// return EXCEPTION_EXECUTE_HANDLER; // unreachable code
|
||
}
|
||
#endif
|
||
|
||
|
||
ULONG
|
||
FatExceptionFilter (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PEXCEPTION_POINTERS ExceptionPointer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is used to decide if we should or should not handle
|
||
an exception status that is being raised. It inserts the status
|
||
into the IrpContext and either indicates that we should handle
|
||
the exception or bug check the system.
|
||
|
||
Arguments:
|
||
|
||
ExceptionPointers - The result of GetExceptionInformation() in the context
|
||
of the exception.
|
||
|
||
Return Value:
|
||
|
||
ULONG - returns EXCEPTION_EXECUTE_HANDLER or bugchecks
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS ExceptionCode;
|
||
|
||
ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
|
||
DebugTrace(0, DEBUG_TRACE_UNWIND, "FatExceptionFilter %X\n", ExceptionCode);
|
||
DebugDump("FatExceptionFilter\n", Dbg, NULL );
|
||
|
||
#ifdef DBG
|
||
|
||
if( FatBreakOnInterestingExceptionStatus != 0 && ExceptionCode == FatBreakOnInterestingExceptionStatus ) {
|
||
DbgBreakPoint();
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// If the exception is STATUS_IN_PAGE_ERROR, get the I/O error code
|
||
// from the exception record.
|
||
//
|
||
|
||
if (ExceptionCode == STATUS_IN_PAGE_ERROR) {
|
||
if (ExceptionPointer->ExceptionRecord->NumberParameters >= 3) {
|
||
ExceptionCode = (NTSTATUS)ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
|
||
}
|
||
}
|
||
|
||
//
|
||
// If there is not an irp context, we must have had insufficient resources.
|
||
//
|
||
|
||
if ( !ARGUMENT_PRESENT( IrpContext ) ) {
|
||
|
||
if (!FsRtlIsNtstatusExpected( ExceptionCode )) {
|
||
|
||
#ifdef _MSC_VER
|
||
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
|
||
#endif
|
||
FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
|
||
(ULONG_PTR)ExceptionPointer->ContextRecord,
|
||
(ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
|
||
}
|
||
|
||
return EXCEPTION_EXECUTE_HANDLER;
|
||
}
|
||
|
||
//
|
||
// For the purposes of processing this exception, let's mark this
|
||
// request as being able to wait and disable write through if we
|
||
// aren't posting it.
|
||
//
|
||
|
||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
|
||
if ( (ExceptionCode != STATUS_CANT_WAIT) &&
|
||
(ExceptionCode != STATUS_VERIFY_REQUIRED) ) {
|
||
|
||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
|
||
}
|
||
|
||
if ( IrpContext->ExceptionStatus == 0 ) {
|
||
|
||
if (FsRtlIsNtstatusExpected( ExceptionCode )) {
|
||
|
||
IrpContext->ExceptionStatus = ExceptionCode;
|
||
|
||
return EXCEPTION_EXECUTE_HANDLER;
|
||
|
||
} else {
|
||
|
||
#ifdef _MSC_VER
|
||
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
|
||
#endif
|
||
FatBugCheck( (ULONG_PTR)ExceptionPointer->ExceptionRecord,
|
||
(ULONG_PTR)ExceptionPointer->ContextRecord,
|
||
(ULONG_PTR)ExceptionPointer->ExceptionRecord->ExceptionAddress );
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// We raised this code explicitly ourselves, so it had better be
|
||
// expected.
|
||
//
|
||
|
||
NT_ASSERT( IrpContext->ExceptionStatus == ExceptionCode );
|
||
NT_ASSERT( FsRtlIsNtstatusExpected( ExceptionCode ) );
|
||
}
|
||
|
||
return EXCEPTION_EXECUTE_HANDLER;
|
||
}
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
NTSTATUS
|
||
FatProcessException (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PIRP Irp,
|
||
IN NTSTATUS ExceptionCode
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine process an exception. It either completes the request
|
||
with the saved exception status or it sends it off to IoRaiseHardError()
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp being processed
|
||
|
||
ExceptionCode - Supplies the normalized exception status being handled
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Returns the results of either posting the Irp or the
|
||
saved completion status.
|
||
|
||
--*/
|
||
|
||
{
|
||
PVCB Vcb;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
FAT_VOLUME_STATE TransitionState = VolumeDirty;
|
||
ULONG SavedFlags = 0;
|
||
|
||
PAGED_CODE();
|
||
|
||
DebugTrace(0, Dbg, "FatProcessException\n", 0);
|
||
|
||
//
|
||
// If there is not an irp context, we must have had insufficient resources.
|
||
//
|
||
|
||
if ( !ARGUMENT_PRESENT( IrpContext ) ) {
|
||
|
||
FatCompleteRequest( FatNull, Irp, ExceptionCode );
|
||
|
||
return ExceptionCode;
|
||
}
|
||
|
||
//
|
||
// Get the real exception status from IrpContext->ExceptionStatus, and
|
||
// reset it.
|
||
//
|
||
|
||
ExceptionCode = IrpContext->ExceptionStatus;
|
||
FatResetExceptionState( IrpContext );
|
||
|
||
//
|
||
// If this is an Mdl write request, then take care of the Mdl
|
||
// here so that things get cleaned up properly. Cc now leaves
|
||
// the MDL in place so a filesystem can retry after clearing an
|
||
// internal condition (FAT does not).
|
||
//
|
||
|
||
if ((IrpContext->MajorFunction == IRP_MJ_WRITE) &&
|
||
(FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE_MDL ) == IRP_MN_COMPLETE_MDL) &&
|
||
(Irp->MdlAddress != NULL)) {
|
||
|
||
PIO_STACK_LOCATION LocalIrpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
CcMdlWriteAbort( LocalIrpSp->FileObject, Irp->MdlAddress );
|
||
Irp->MdlAddress = NULL;
|
||
}
|
||
|
||
//
|
||
// If we are going to post the request, we may have to lock down the
|
||
// user's buffer, so do it here in a try except so that we failed the
|
||
// request if the LockPages fails.
|
||
//
|
||
// Also unpin any repinned Bcbs, protected by the try {} except {} filter.
|
||
//
|
||
|
||
_SEH2_TRY {
|
||
|
||
SavedFlags = IrpContext->Flags;
|
||
|
||
//
|
||
// Make sure we don't try to write through Bcbs
|
||
//
|
||
|
||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH);
|
||
|
||
FatUnpinRepinnedBcbs( IrpContext );
|
||
|
||
IrpContext->Flags = SavedFlags;
|
||
|
||
//
|
||
// If we will have to post the request, do it here. Note
|
||
// that the last thing FatPrePostIrp() does is mark the Irp pending,
|
||
// so it is critical that we actually return PENDING. Nothing
|
||
// from this point to return can fail, so we are OK.
|
||
//
|
||
// We cannot do a verify operations at APC level because we
|
||
// have to wait for Io operations to complete.
|
||
//
|
||
|
||
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL) &&
|
||
#if (NTDDI_VERSION >= NTDDI_VISTA)
|
||
(((ExceptionCode == STATUS_VERIFY_REQUIRED) && KeAreAllApcsDisabled()) ||
|
||
#else
|
||
(((ExceptionCode == STATUS_VERIFY_REQUIRED) && (KeGetCurrentIrql() >= APC_LEVEL)) ||
|
||
#endif
|
||
(ExceptionCode == STATUS_CANT_WAIT))) {
|
||
|
||
ExceptionCode = FatFsdPostRequest( IrpContext, Irp );
|
||
}
|
||
|
||
} _SEH2_EXCEPT( FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() ) ) {
|
||
|
||
ExceptionCode = IrpContext->ExceptionStatus;
|
||
IrpContext->ExceptionStatus = 0;
|
||
|
||
IrpContext->Flags = SavedFlags;
|
||
} _SEH2_END;
|
||
|
||
//
|
||
// If we posted the request, just return here.
|
||
//
|
||
|
||
if (ExceptionCode == STATUS_PENDING) {
|
||
|
||
return ExceptionCode;
|
||
}
|
||
|
||
Irp->IoStatus.Status = ExceptionCode;
|
||
|
||
|
||
//
|
||
// If this request is not a "top-level" irp, just complete it.
|
||
//
|
||
|
||
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL)) {
|
||
|
||
//
|
||
// If there is a cache operation above us, commute verify
|
||
// to a lock conflict. This will cause retries so that
|
||
// we have a chance of getting through without needing
|
||
// to return an unaesthetic error for the operation.
|
||
//
|
||
|
||
if (IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP &&
|
||
ExceptionCode == STATUS_VERIFY_REQUIRED) {
|
||
|
||
ExceptionCode = STATUS_FILE_LOCK_CONFLICT;
|
||
}
|
||
|
||
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
|
||
|
||
return ExceptionCode;
|
||
}
|
||
|
||
if (IoIsErrorUserInduced(ExceptionCode)) {
|
||
|
||
//
|
||
// Check for the various error conditions that can be caused by,
|
||
// and possibly resolved by the user.
|
||
//
|
||
|
||
if (ExceptionCode == STATUS_VERIFY_REQUIRED) {
|
||
|
||
PDEVICE_OBJECT Device = NULL;
|
||
|
||
DebugTrace(0, Dbg, "Perform Verify Operation\n", 0);
|
||
|
||
//
|
||
// Now we are at the top level file system entry point.
|
||
//
|
||
// Grab the device to verify from the thread local storage
|
||
// and stick it in the information field for transportation
|
||
// to the fsp. We also clear the field at this time.
|
||
//
|
||
|
||
Device = IoGetDeviceToVerify( Irp->Tail.Overlay.Thread );
|
||
IoSetDeviceToVerify( Irp->Tail.Overlay.Thread, NULL );
|
||
|
||
if ( Device == NULL ) {
|
||
|
||
Device = IoGetDeviceToVerify( PsGetCurrentThread() );
|
||
IoSetDeviceToVerify( PsGetCurrentThread(), NULL );
|
||
|
||
NT_ASSERT( Device != NULL );
|
||
}
|
||
|
||
//
|
||
// It turns out some storage drivers really do set invalid non-NULL device
|
||
// objects to verify.
|
||
//
|
||
// To work around this, completely ignore the device to verify in the thread,
|
||
// and just use our real device object instead.
|
||
//
|
||
|
||
if (IrpContext->Vcb) {
|
||
|
||
Device = IrpContext->Vcb->Vpb->RealDevice;
|
||
|
||
} else {
|
||
|
||
//
|
||
// For FSCTLs, IrpContext->Vcb may not be populated, so get the IrpContext->RealDevice instead
|
||
//
|
||
|
||
Device = IrpContext->RealDevice;
|
||
}
|
||
|
||
//
|
||
// Let's not BugCheck just because the device to verify is somehow still NULL.
|
||
//
|
||
|
||
if (Device == NULL) {
|
||
|
||
ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR;
|
||
|
||
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
|
||
|
||
return ExceptionCode;
|
||
}
|
||
|
||
//
|
||
// FatPerformVerify() will do the right thing with the Irp.
|
||
|
||
return FatPerformVerify( IrpContext, Irp, Device );
|
||
}
|
||
|
||
//
|
||
// The other user induced conditions generate an error unless
|
||
// they have been disabled for this request.
|
||
//
|
||
|
||
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS)) {
|
||
|
||
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
|
||
|
||
return ExceptionCode;
|
||
|
||
} else {
|
||
|
||
//
|
||
// Generate a pop-up
|
||
//
|
||
|
||
PDEVICE_OBJECT RealDevice = NULL;
|
||
PVPB Vpb;
|
||
PETHREAD Thread;
|
||
|
||
if (IoGetCurrentIrpStackLocation(Irp)->FileObject != NULL) {
|
||
|
||
Vpb = IoGetCurrentIrpStackLocation(Irp)->FileObject->Vpb;
|
||
|
||
} else {
|
||
|
||
Vpb = NULL;
|
||
}
|
||
|
||
//
|
||
// The device to verify is either in my thread local storage
|
||
// or that of the thread that owns the Irp.
|
||
//
|
||
|
||
Thread = Irp->Tail.Overlay.Thread;
|
||
RealDevice = IoGetDeviceToVerify( Thread );
|
||
|
||
if ( RealDevice == NULL ) {
|
||
|
||
Thread = PsGetCurrentThread();
|
||
RealDevice = IoGetDeviceToVerify( Thread );
|
||
|
||
NT_ASSERT( RealDevice != NULL );
|
||
}
|
||
|
||
//
|
||
// It turns out some storage drivers really do set invalid non-NULL device
|
||
// objects to verify.
|
||
//
|
||
// To work around this, completely ignore the device to verify in the thread,
|
||
// and just use our real device object instead.
|
||
//
|
||
|
||
if (IrpContext->Vcb) {
|
||
|
||
RealDevice = IrpContext->Vcb->Vpb->RealDevice;
|
||
|
||
} else {
|
||
|
||
//
|
||
// For FSCTLs, IrpContext->Vcb may not be populated, so get the IrpContext->RealDevice instead
|
||
//
|
||
|
||
RealDevice = IrpContext->RealDevice;
|
||
}
|
||
|
||
//
|
||
// Let's not BugCheck just because the device to verify is somehow still NULL.
|
||
//
|
||
|
||
if (RealDevice == NULL) {
|
||
|
||
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
|
||
|
||
return ExceptionCode;
|
||
}
|
||
|
||
//
|
||
// This routine actually causes the pop-up. It usually
|
||
// does this by queuing an APC to the callers thread,
|
||
// but in some cases it will complete the request immediately,
|
||
// so it is very important to IoMarkIrpPending() first.
|
||
//
|
||
|
||
IoMarkIrpPending( Irp );
|
||
IoRaiseHardError( Irp, Vpb, RealDevice );
|
||
|
||
//
|
||
// We will be handing control back to the caller here, so
|
||
// reset the saved device object.
|
||
//
|
||
|
||
IoSetDeviceToVerify( Thread, NULL );
|
||
|
||
//
|
||
// The Irp will be completed by Io or resubmitted. In either
|
||
// case we must clean up the IrpContext here.
|
||
//
|
||
|
||
FatDeleteIrpContext( IrpContext );
|
||
return STATUS_PENDING;
|
||
}
|
||
}
|
||
|
||
//
|
||
// This is just a run of the mill error. If is a STATUS that we
|
||
// raised ourselves, and the information would be use for the
|
||
// user, raise an informational pop-up.
|
||
//
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
Vcb = IrpContext->Vcb;
|
||
|
||
//
|
||
// Now, if the Vcb is unknown to us this means that the error was raised
|
||
// in the process of a mount and before we even had a chance to build
|
||
// a full Vcb - and was really handled there.
|
||
//
|
||
|
||
if (Vcb != NULL) {
|
||
|
||
if ( !FatDeviceIsFatFsdo( IrpSp->DeviceObject) &&
|
||
!NT_SUCCESS(ExceptionCode) &&
|
||
!FsRtlIsTotalDeviceFailure(ExceptionCode) ) {
|
||
|
||
TransitionState = VolumeDirtyWithSurfaceTest;
|
||
}
|
||
|
||
//
|
||
// If this was a STATUS_FILE_CORRUPT or similar error indicating some
|
||
// nastiness out on the media, then mark the volume permanently dirty.
|
||
//
|
||
|
||
if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS) &&
|
||
( TransitionState == VolumeDirtyWithSurfaceTest ||
|
||
(ExceptionCode == STATUS_FILE_CORRUPT_ERROR) ||
|
||
(ExceptionCode == STATUS_DISK_CORRUPT_ERROR) ||
|
||
(ExceptionCode == STATUS_EA_CORRUPT_ERROR) ||
|
||
(ExceptionCode == STATUS_INVALID_EA_NAME) ||
|
||
(ExceptionCode == STATUS_EA_LIST_INCONSISTENT) ||
|
||
(ExceptionCode == STATUS_NO_EAS_ON_FILE) )) {
|
||
|
||
NT_ASSERT( NodeType(Vcb) == FAT_NTC_VCB );
|
||
NT_ASSERT( !FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL));
|
||
|
||
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY );
|
||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
|
||
//
|
||
// Do the "dirty" work, ignoring any error. We need to take the Vcb here
|
||
// to synchronize against the verify path tearing things down, since
|
||
// we dropped all synchronization when backing up due to the exception.
|
||
//
|
||
|
||
FatAcquireExclusiveVcbNoOpCheck( IrpContext, Vcb);
|
||
|
||
_SEH2_TRY {
|
||
|
||
if (VcbGood == Vcb->VcbCondition) {
|
||
|
||
FatMarkVolume( IrpContext, Vcb, TransitionState );
|
||
}
|
||
}
|
||
_SEH2_EXCEPT( FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() ) ) {
|
||
|
||
NOTHING;
|
||
} _SEH2_END;
|
||
|
||
FatReleaseVcb( IrpContext, Vcb);
|
||
}
|
||
}
|
||
|
||
FatCompleteRequest( IrpContext, Irp, ExceptionCode );
|
||
|
||
return ExceptionCode;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatCompleteRequest_Real (
|
||
IN PIRP_CONTEXT IrpContext OPTIONAL,
|
||
IN PIRP Irp OPTIONAL,
|
||
IN NTSTATUS Status
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine completes a Irp
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp being processed
|
||
|
||
Status - Supplies the status to complete the Irp with
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE();
|
||
|
||
#if DBG
|
||
if ( (FatBreakOnInterestingIrpCompletion != 0) && (Status == FatBreakOnInterestingIrpCompletion) ) {
|
||
DbgBreakPoint();
|
||
}
|
||
|
||
#endif
|
||
|
||
//
|
||
// If we have an Irp Context then unpin all of the repinned bcbs
|
||
// we might have collected.
|
||
//
|
||
|
||
if (IrpContext != NULL) {
|
||
|
||
NT_ASSERT( IrpContext->Repinned.Bcb[0] == NULL );
|
||
|
||
FatUnpinRepinnedBcbs( IrpContext );
|
||
}
|
||
|
||
//
|
||
// Delete the Irp context before completing the IRP so if
|
||
// we run into some of the asserts, we can still backtrack
|
||
// through the IRP.
|
||
//
|
||
|
||
if (IrpContext != NULL) {
|
||
|
||
FatDeleteIrpContext( IrpContext );
|
||
}
|
||
|
||
//
|
||
// 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;
|
||
}
|
||
|
||
BOOLEAN
|
||
FatIsIrpTopLevel (
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine detects if an Irp is the Top level requestor, ie. if it os OK
|
||
to do a verify or pop-up now. If TRUE is returned, then no file system
|
||
resources are held above us.
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the Irp being processed
|
||
|
||
Status - Supplies the status to complete the Irp with
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE();
|
||
|
||
if ( IoGetTopLevelIrp() == NULL ) {
|
||
|
||
IoSetTopLevelIrp( Irp );
|
||
|
||
return TRUE;
|
||
|
||
} else {
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
_Function_class_(FAST_IO_CHECK_IF_POSSIBLE)
|
||
BOOLEAN
|
||
NTAPI
|
||
FatFastIoCheckIfPossible (
|
||
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
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine checks if fast i/o is possible for a read/write operation
|
||
|
||
Arguments:
|
||
|
||
FileObject - Supplies the file object used in the query
|
||
|
||
FileOffset - Supplies the starting byte offset for the read/write operation
|
||
|
||
Length - Supplies the length, in bytes, of the read/write operation
|
||
|
||
Wait - Indicates if we can wait
|
||
|
||
LockKey - Supplies the lock key
|
||
|
||
CheckForReadOperation - Indicates if this is a check for a read or write
|
||
operation
|
||
|
||
IoStatus - Receives the status of the operation if our return value is
|
||
FastIoReturnError
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if fast I/O is possible and FALSE if the caller needs
|
||
to take the long route.
|
||
|
||
--*/
|
||
|
||
{
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PCCB Ccb;
|
||
|
||
LARGE_INTEGER LargeLength;
|
||
|
||
PAGED_CODE();
|
||
|
||
UNREFERENCED_PARAMETER( DeviceObject );
|
||
UNREFERENCED_PARAMETER( IoStatus );
|
||
UNREFERENCED_PARAMETER( Wait );
|
||
//
|
||
// Decode the file object to get our fcb, the only one we want
|
||
// to deal with is a UserFileOpen
|
||
//
|
||
|
||
if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
LargeLength.QuadPart = Length;
|
||
|
||
//
|
||
// Based on whether this is a read or write operation we call
|
||
// fsrtl check for read/write
|
||
//
|
||
|
||
if (CheckForReadOperation) {
|
||
|
||
if (FsRtlFastCheckLockForRead( &Fcb->Specific.Fcb.FileLock,
|
||
FileOffset,
|
||
&LargeLength,
|
||
LockKey,
|
||
FileObject,
|
||
PsGetCurrentProcess() )) {
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
} else {
|
||
|
||
|
||
//
|
||
// Also check for a write-protected volume here.
|
||
//
|
||
|
||
if (!FlagOn(Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED) &&
|
||
FsRtlFastCheckLockForWrite( &Fcb->Specific.Fcb.FileLock,
|
||
FileOffset,
|
||
&LargeLength,
|
||
LockKey,
|
||
FileObject,
|
||
PsGetCurrentProcess() )) {
|
||
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
_Function_class_(FAST_IO_QUERY_BASIC_INFO)
|
||
BOOLEAN
|
||
NTAPI
|
||
FatFastQueryBasicInfo (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN BOOLEAN Wait,
|
||
IN OUT PFILE_BASIC_INFORMATION Buffer,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is for the fast query call for basic file information.
|
||
|
||
Arguments:
|
||
|
||
FileObject - Supplies the file object used in this operation
|
||
|
||
Wait - Indicates if we are allowed to wait for the information
|
||
|
||
Buffer - Supplies the output buffer to receive the basic information
|
||
|
||
IoStatus - Receives the final status of the operation
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if the operation succeeded and FALSE if the caller
|
||
needs to take the long route.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOLEAN Results = FALSE;
|
||
IRP_CONTEXT IrpContext;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PCCB Ccb;
|
||
|
||
BOOLEAN FcbAcquired = FALSE;
|
||
|
||
PAGED_CODE();
|
||
UNREFERENCED_PARAMETER( DeviceObject );
|
||
|
||
//
|
||
// Prepare the dummy irp context
|
||
//
|
||
|
||
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
|
||
IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
|
||
IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
|
||
|
||
if (Wait) {
|
||
|
||
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
|
||
} else {
|
||
|
||
ClearFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
}
|
||
|
||
//
|
||
// Determine the type of open for the input file object and only accept
|
||
// the user file or directory open
|
||
//
|
||
|
||
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
|
||
|
||
if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
|
||
|
||
return Results;
|
||
}
|
||
|
||
FsRtlEnterFileSystem();
|
||
|
||
//
|
||
// Get access to the Fcb but only if it is not the paging file
|
||
//
|
||
|
||
if (!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
|
||
|
||
if (!ExAcquireResourceSharedLite( Fcb->Header.Resource, Wait )) {
|
||
|
||
FsRtlExitFileSystem();
|
||
return Results;
|
||
}
|
||
|
||
FcbAcquired = TRUE;
|
||
}
|
||
|
||
_SEH2_TRY {
|
||
|
||
//
|
||
// If the Fcb is not in a good state, return FALSE.
|
||
//
|
||
|
||
if (Fcb->FcbCondition != FcbGood) {
|
||
|
||
try_return( Results );
|
||
}
|
||
|
||
Buffer->FileAttributes = 0;
|
||
|
||
//
|
||
// If the fcb is not the root dcb then we will fill in the
|
||
// buffer otherwise it is all setup for us.
|
||
//
|
||
|
||
if (NodeType(Fcb) != FAT_NTC_ROOT_DCB) {
|
||
|
||
//
|
||
// Extract the data and fill in the non zero fields of the output
|
||
// buffer
|
||
//
|
||
|
||
Buffer->LastWriteTime = Fcb->LastWriteTime;
|
||
Buffer->CreationTime = Fcb->CreationTime;
|
||
Buffer->LastAccessTime = Fcb->LastAccessTime;
|
||
|
||
//
|
||
// Zero out the field we don't support.
|
||
//
|
||
|
||
Buffer->ChangeTime.QuadPart = 0;
|
||
Buffer->FileAttributes = Fcb->DirentFatFlags;
|
||
|
||
} else {
|
||
|
||
Buffer->LastWriteTime.QuadPart = 0;
|
||
Buffer->CreationTime.QuadPart = 0;
|
||
Buffer->LastAccessTime.QuadPart = 0;
|
||
Buffer->ChangeTime.QuadPart = 0;
|
||
|
||
Buffer->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
||
}
|
||
|
||
|
||
//
|
||
// If the temporary flag is set, then set it in the buffer.
|
||
//
|
||
|
||
if (FlagOn( Fcb->FcbState, FCB_STATE_TEMPORARY )) {
|
||
|
||
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
|
||
}
|
||
|
||
//
|
||
// If no attributes were set, set the normal bit.
|
||
//
|
||
|
||
if (Buffer->FileAttributes == 0) {
|
||
|
||
Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
||
}
|
||
|
||
IoStatus->Status = STATUS_SUCCESS;
|
||
IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
|
||
|
||
Results = TRUE;
|
||
|
||
try_exit: NOTHING;
|
||
} _SEH2_FINALLY {
|
||
|
||
if (FcbAcquired) { ExReleaseResourceLite( Fcb->Header.Resource ); }
|
||
|
||
FsRtlExitFileSystem();
|
||
} _SEH2_END;
|
||
|
||
//
|
||
// And return to our caller
|
||
//
|
||
|
||
return Results;
|
||
}
|
||
|
||
|
||
_Function_class_(FAST_IO_QUERY_STANDARD_INFO)
|
||
BOOLEAN
|
||
NTAPI
|
||
FatFastQueryStdInfo (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN BOOLEAN Wait,
|
||
IN OUT PFILE_STANDARD_INFORMATION Buffer,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is for the fast query call for standard file information.
|
||
|
||
Arguments:
|
||
|
||
FileObject - Supplies the file object used in this operation
|
||
|
||
Wait - Indicates if we are allowed to wait for the information
|
||
|
||
Buffer - Supplies the output buffer to receive the basic information
|
||
|
||
IoStatus - Receives the final status of the operation
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if the operation succeeded and FALSE if the caller
|
||
needs to take the long route.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOLEAN Results = FALSE;
|
||
IRP_CONTEXT IrpContext;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PCCB Ccb;
|
||
|
||
BOOLEAN FcbAcquired = FALSE;
|
||
|
||
PAGED_CODE();
|
||
|
||
UNREFERENCED_PARAMETER( DeviceObject );
|
||
|
||
//
|
||
// Prepare the dummy irp context
|
||
//
|
||
|
||
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
|
||
IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
|
||
IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
|
||
|
||
if (Wait) {
|
||
|
||
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
|
||
} else {
|
||
|
||
ClearFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
}
|
||
|
||
//
|
||
// Determine the type of open for the input file object and only accept
|
||
// the user file or directory open
|
||
//
|
||
|
||
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
|
||
|
||
if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
|
||
|
||
return Results;
|
||
}
|
||
|
||
//
|
||
// Get access to the Fcb but only if it is not the paging file
|
||
//
|
||
|
||
FsRtlEnterFileSystem();
|
||
|
||
if (!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
|
||
|
||
if (!ExAcquireResourceSharedLite( Fcb->Header.Resource, Wait )) {
|
||
|
||
FsRtlExitFileSystem();
|
||
return Results;
|
||
}
|
||
|
||
FcbAcquired = TRUE;
|
||
}
|
||
|
||
_SEH2_TRY {
|
||
|
||
//
|
||
// If the Fcb is not in a good state, return FALSE.
|
||
//
|
||
|
||
if (Fcb->FcbCondition != FcbGood) {
|
||
|
||
try_return( Results );
|
||
}
|
||
|
||
Buffer->NumberOfLinks = 1;
|
||
Buffer->DeletePending = BooleanFlagOn( Fcb->FcbState, FCB_STATE_DELETE_ON_CLOSE );
|
||
|
||
//
|
||
// Case on whether this is a file or a directory, and extract
|
||
// the information and fill in the fcb/dcb specific parts
|
||
// of the output buffer.
|
||
//
|
||
|
||
if (NodeType(Fcb) == FAT_NTC_FCB) {
|
||
|
||
//
|
||
// If we don't alread know the allocation size, we cannot look
|
||
// it up in the fast path.
|
||
//
|
||
|
||
if (Fcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) {
|
||
|
||
try_return( Results );
|
||
}
|
||
|
||
Buffer->AllocationSize = Fcb->Header.AllocationSize;
|
||
Buffer->EndOfFile = Fcb->Header.FileSize;
|
||
|
||
Buffer->Directory = FALSE;
|
||
|
||
} else {
|
||
|
||
Buffer->AllocationSize = FatLargeZero;
|
||
Buffer->EndOfFile = FatLargeZero;
|
||
|
||
Buffer->Directory = TRUE;
|
||
}
|
||
|
||
IoStatus->Status = STATUS_SUCCESS;
|
||
IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
|
||
|
||
Results = TRUE;
|
||
|
||
try_exit: NOTHING;
|
||
} _SEH2_FINALLY {
|
||
|
||
if (FcbAcquired) { ExReleaseResourceLite( Fcb->Header.Resource ); }
|
||
|
||
FsRtlExitFileSystem();
|
||
} _SEH2_END;
|
||
|
||
//
|
||
// And return to our caller
|
||
//
|
||
|
||
return Results;
|
||
}
|
||
|
||
|
||
_Function_class_(FAST_IO_QUERY_NETWORK_OPEN_INFO)
|
||
BOOLEAN
|
||
NTAPI
|
||
FatFastQueryNetworkOpenInfo (
|
||
IN PFILE_OBJECT FileObject,
|
||
IN BOOLEAN Wait,
|
||
IN OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
|
||
OUT PIO_STATUS_BLOCK IoStatus,
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is for the fast query call for network open information.
|
||
|
||
Arguments:
|
||
|
||
FileObject - Supplies the file object used in this operation
|
||
|
||
Wait - Indicates if we are allowed to wait for the information
|
||
|
||
Buffer - Supplies the output buffer to receive the information
|
||
|
||
IoStatus - Receives the final status of the operation
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if the operation succeeded and FALSE if the caller
|
||
needs to take the long route.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOLEAN Results = FALSE;
|
||
IRP_CONTEXT IrpContext;
|
||
|
||
TYPE_OF_OPEN TypeOfOpen;
|
||
PVCB Vcb;
|
||
PFCB Fcb;
|
||
PCCB Ccb;
|
||
|
||
BOOLEAN FcbAcquired = FALSE;
|
||
|
||
PAGED_CODE();
|
||
|
||
UNREFERENCED_PARAMETER( DeviceObject );
|
||
|
||
//
|
||
// Prepare the dummy irp context
|
||
//
|
||
|
||
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
|
||
IrpContext.NodeTypeCode = FAT_NTC_IRP_CONTEXT;
|
||
IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
|
||
|
||
if (Wait) {
|
||
|
||
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
|
||
} else {
|
||
|
||
ClearFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
|
||
}
|
||
|
||
//
|
||
// Determine the type of open for the input file object and only accept
|
||
// the user file or directory open
|
||
//
|
||
|
||
TypeOfOpen = FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb );
|
||
|
||
if ((TypeOfOpen != UserFileOpen) && (TypeOfOpen != UserDirectoryOpen)) {
|
||
|
||
return Results;
|
||
}
|
||
|
||
FsRtlEnterFileSystem();
|
||
|
||
//
|
||
// Get access to the Fcb but only if it is not the paging file
|
||
//
|
||
|
||
if (!FlagOn( Fcb->FcbState, FCB_STATE_PAGING_FILE )) {
|
||
|
||
if (!ExAcquireResourceSharedLite( Fcb->Header.Resource, Wait )) {
|
||
|
||
FsRtlExitFileSystem();
|
||
return Results;
|
||
}
|
||
|
||
FcbAcquired = TRUE;
|
||
}
|
||
|
||
_SEH2_TRY {
|
||
|
||
//
|
||
// If the Fcb is not in a good state, return FALSE.
|
||
//
|
||
|
||
if (Fcb->FcbCondition != FcbGood) {
|
||
|
||
try_return( Results );
|
||
}
|
||
|
||
//
|
||
// Extract the data and fill in the non zero fields of the output
|
||
// buffer
|
||
//
|
||
|
||
//
|
||
// Default the field we don't support to a reasonable value.
|
||
//
|
||
|
||
ExLocalTimeToSystemTime( &FatJanOne1980,
|
||
&Buffer->ChangeTime );
|
||
|
||
Buffer->FileAttributes = Fcb->DirentFatFlags;
|
||
|
||
if (Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB) {
|
||
|
||
//
|
||
// Reuse the default for the root dir.
|
||
//
|
||
|
||
Buffer->CreationTime =
|
||
Buffer->LastAccessTime =
|
||
Buffer->LastWriteTime = Buffer->ChangeTime;
|
||
|
||
} else {
|
||
|
||
Buffer->LastWriteTime = Fcb->LastWriteTime;
|
||
Buffer->CreationTime = Fcb->CreationTime;
|
||
Buffer->LastAccessTime = Fcb->LastAccessTime;
|
||
|
||
}
|
||
|
||
//
|
||
// If the temporary flag is set, then set it in the buffer.
|
||
//
|
||
|
||
if (FlagOn( Fcb->FcbState, FCB_STATE_TEMPORARY )) {
|
||
|
||
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// If no attributes were set, set the normal bit.
|
||
//
|
||
|
||
if (Buffer->FileAttributes == 0) {
|
||
|
||
Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
||
}
|
||
|
||
if (NodeType(Fcb) == FAT_NTC_FCB) {
|
||
|
||
//
|
||
// If we don't already know the allocation size, we cannot
|
||
// lock it up in the fast path.
|
||
//
|
||
|
||
if (Fcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) {
|
||
|
||
try_return( Results );
|
||
}
|
||
|
||
Buffer->AllocationSize = Fcb->Header.AllocationSize;
|
||
Buffer->EndOfFile = Fcb->Header.FileSize;
|
||
|
||
} else {
|
||
|
||
Buffer->AllocationSize = FatLargeZero;
|
||
Buffer->EndOfFile = FatLargeZero;
|
||
}
|
||
|
||
IoStatus->Status = STATUS_SUCCESS;
|
||
IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
|
||
|
||
Results = TRUE;
|
||
|
||
try_exit: NOTHING;
|
||
} _SEH2_FINALLY {
|
||
|
||
if (FcbAcquired) { ExReleaseResourceLite( Fcb->Header.Resource ); }
|
||
|
||
FsRtlExitFileSystem();
|
||
} _SEH2_END;
|
||
|
||
//
|
||
// And return to our caller
|
||
//
|
||
|
||
return Results;
|
||
}
|
||
|
||
_Requires_lock_held_(_Global_critical_region_)
|
||
VOID
|
||
FatPopUpFileCorrupt (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
The Following routine makes an informational popup that the file
|
||
is corrupt.
|
||
|
||
Arguments:
|
||
|
||
Fcb - The file that is corrupt.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
PKTHREAD Thread;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Disable the popup on the root directory. It is important not
|
||
// to generate them on objects which are part of the mount process.
|
||
//
|
||
|
||
if (NodeType(Fcb) == FAT_NTC_ROOT_DCB) {
|
||
|
||
return;
|
||
}
|
||
|
||
//
|
||
// Got to grab the full filename now.
|
||
//
|
||
|
||
if (Fcb->FullFileName.Buffer == NULL) {
|
||
|
||
FatSetFullFileNameInFcb( IrpContext, Fcb );
|
||
}
|
||
|
||
//
|
||
// We never want to block a system thread waiting for the user to
|
||
// press OK.
|
||
//
|
||
|
||
if (IoIsSystemThread(IrpContext->OriginatingIrp->Tail.Overlay.Thread)) {
|
||
|
||
Thread = NULL;
|
||
|
||
} else {
|
||
|
||
#ifndef __REACTOS__
|
||
Thread = IrpContext->OriginatingIrp->Tail.Overlay.Thread;
|
||
#else
|
||
Thread = (PKTHREAD)IrpContext->OriginatingIrp->Tail.Overlay.Thread;
|
||
#endif
|
||
}
|
||
|
||
IoRaiseInformationalHardError( STATUS_FILE_CORRUPT_ERROR,
|
||
&Fcb->FullFileName,
|
||
Thread);
|
||
}
|
||
|