Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/ntos/cntfs/ntfsdata.c
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

2608 lines
68 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
NtfsData.c
Abstract:
This module declares the global data used by the Ntfs file system.
Author:
Gary Kimura [GaryKi] 21-May-1991
Revision History:
--*/
#include "NtfsProc.h"
//
// The Bug check file id for this module
//
#define BugCheckFileId (NTFS_BUG_CHECK_NTFSDATA)
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_CATCH_EXCEPTIONS)
//
// Define a tag for general pool allocations from this module
//
#undef MODULE_POOL_TAG
#define MODULE_POOL_TAG ('NFtN')
#define CollectExceptionStats(VCB,EXCEPTION_CODE) { \
if ((VCB) != NULL) { \
PFILESYSTEM_STATISTICS FsStat = &(VCB)->Statistics[KeGetCurrentProcessorNumber()]; \
if ((EXCEPTION_CODE) == STATUS_LOG_FILE_FULL) { \
FsStat->Ntfs.LogFileFullExceptions += 1; \
} else { \
FsStat->Ntfs.OtherExceptions += 1; \
} \
} \
}
//
// The global fsd data record
//
NTFS_DATA NtfsData;
//
// Semaphore to synchronize creation of stream files.
//
FAST_MUTEX StreamFileCreationFastMutex;
//
// A mutex and queue of NTFS MCBS that will be freed
// if we reach over a certain threshold
//
FAST_MUTEX NtfsMcbFastMutex;
LIST_ENTRY NtfsMcbLruQueue;
ULONG NtfsMcbHighWaterMark;
ULONG NtfsMcbLowWaterMark;
ULONG NtfsMcbCurrentLevel;
BOOLEAN NtfsMcbCleanupInProgress;
WORK_QUEUE_ITEM NtfsMcbWorkItem;
//
// The global large integer constants
//
LARGE_INTEGER NtfsLarge0 = {0x00000000,0x00000000};
LARGE_INTEGER NtfsLarge1 = {0x00000001,0x00000000};
LONGLONG NtfsLastAccess;
//
// The following fields are used to allocate nonpaged structures
// using a lookaside list, and other fixed sized structures from a
// small cache.
//
NPAGED_LOOKASIDE_LIST NtfsFileLockLookasideList;
NPAGED_LOOKASIDE_LIST NtfsIoContextLookasideList;
NPAGED_LOOKASIDE_LIST NtfsIrpContextLookasideList;
NPAGED_LOOKASIDE_LIST NtfsKeventLookasideList;
NPAGED_LOOKASIDE_LIST NtfsScbNonpagedLookasideList;
NPAGED_LOOKASIDE_LIST NtfsScbSnapshotLookasideList;
PAGED_LOOKASIDE_LIST NtfsCcbLookasideList;
PAGED_LOOKASIDE_LIST NtfsCcbDataLookasideList;
PAGED_LOOKASIDE_LIST NtfsDeallocatedRecordsLookasideList;
PAGED_LOOKASIDE_LIST NtfsFcbDataLookasideList;
PAGED_LOOKASIDE_LIST NtfsFcbIndexLookasideList;
PAGED_LOOKASIDE_LIST NtfsIndexContextLookasideList;
PAGED_LOOKASIDE_LIST NtfsLcbLookasideList;
PAGED_LOOKASIDE_LIST NtfsNukemLookasideList;
PAGED_LOOKASIDE_LIST NtfsScbDataLookasideList;
//
// Useful constant Unicode strings.
//
//
// This is the string for the name of the index allocation attributes.
//
UNICODE_STRING NtfsFileNameIndex;
WCHAR NtfsFileNameIndexName[] = { '$', 'I','0' + $FILE_NAME/0x10, '0' + $FILE_NAME%0x10, '\0' };
//
// This is the string for the attribute code for index allocation.
// $INDEX_ALLOCATION.
//
UNICODE_STRING NtfsIndexAllocation =
CONSTANT_UNICODE_STRING( L"$INDEX_ALLOCATION" );
//
// This is the string for the data attribute, $DATA.
//
UNICODE_STRING NtfsDataString =
CONSTANT_UNICODE_STRING( L"$DATA" );
//
// This strings are used for informational popups.
//
UNICODE_STRING NtfsSystemFiles[] = {
CONSTANT_UNICODE_STRING( L"\\$Mft" ),
CONSTANT_UNICODE_STRING( L"\\$MftMirr" ),
CONSTANT_UNICODE_STRING( L"\\$LogFile" ),
CONSTANT_UNICODE_STRING( L"\\$Volume" ),
CONSTANT_UNICODE_STRING( L"\\$AttrDef" ),
CONSTANT_UNICODE_STRING( L"\\" ),
CONSTANT_UNICODE_STRING( L"\\$BitMap" ),
CONSTANT_UNICODE_STRING( L"\\$Boot" ),
CONSTANT_UNICODE_STRING( L"\\$BadClus" ),
CONSTANT_UNICODE_STRING( L"\\$Quota" ),
CONSTANT_UNICODE_STRING( L"\\$UpCase" ),
};
UNICODE_STRING NtfsUnknownFile =
CONSTANT_UNICODE_STRING( L"\\????" );
UNICODE_STRING NtfsRootIndexString =
CONSTANT_UNICODE_STRING( L"." );
//
// This is the empty string. This can be used to pass a string with
// no length.
//
UNICODE_STRING NtfsEmptyString = { 0, 0, NULL };
//
// The following file references are used to identify system files.
//
FILE_REFERENCE MftFileReference = { MASTER_FILE_TABLE_NUMBER, 0, MASTER_FILE_TABLE_NUMBER };
FILE_REFERENCE Mft2FileReference = { MASTER_FILE_TABLE2_NUMBER, 0, MASTER_FILE_TABLE2_NUMBER };
FILE_REFERENCE LogFileReference = { LOG_FILE_NUMBER, 0, LOG_FILE_NUMBER };
FILE_REFERENCE VolumeFileReference = { VOLUME_DASD_NUMBER, 0, VOLUME_DASD_NUMBER };
FILE_REFERENCE RootIndexFileReference = { ROOT_FILE_NAME_INDEX_NUMBER, 0, ROOT_FILE_NAME_INDEX_NUMBER };
FILE_REFERENCE BitmapFileReference = { BIT_MAP_FILE_NUMBER, 0, BIT_MAP_FILE_NUMBER };
FILE_REFERENCE FirstUserFileReference = { FIRST_USER_FILE_NUMBER, 0, 0 };
FILE_REFERENCE BootFileReference = { BOOT_FILE_NUMBER, 0, BOOT_FILE_NUMBER };
//
// The following are used to determine what level of protection to attach
// to system files and attributes.
//
BOOLEAN NtfsProtectSystemFiles = TRUE;
BOOLEAN NtfsProtectSystemAttributes = TRUE;
//
// FsRtl fast I/O call backs
//
FAST_IO_DISPATCH NtfsFastIoDispatch;
#ifdef NTFSDBG
LONG NtfsDebugTraceLevel = DEBUG_TRACE_ERROR;
LONG NtfsDebugTraceIndent = 0;
LONG NtfsFailCheck = 0;
ULONG NtfsFsdEntryCount = 0;
ULONG NtfsFspEntryCount = 0;
ULONG NtfsIoCallDriverCount = 0;
#endif // NTFSDBG
//
// Performance statistics
//
ULONG NtfsMaxDelayedCloseCount;
ULONG NtfsMinDelayedCloseCount;
ULONG NtfsCleanCheckpoints = 0;
ULONG NtfsPostRequests = 0;
UCHAR BaadSignature[4] = {'B', 'A', 'A', 'D'};
UCHAR IndexSignature[4] = {'I', 'N', 'D', 'X'};
UCHAR FileSignature[4] = {'F', 'I', 'L', 'E'};
UCHAR HoleSignature[4] = {'H', 'O', 'L', 'E'};
UCHAR ChkdskSignature[4] = {'C', 'H', 'K', 'D'};
//
// Large Reserved Buffer Context
//
ULONG NtfsReservedInUse = 0;
PVOID NtfsReserved1 = NULL;
PVOID NtfsReserved2 = NULL;
ULONG NtfsReserved2Count = 0;
PVOID NtfsReserved3 = NULL;
PVOID NtfsReserved1Thread = NULL;
PVOID NtfsReserved2Thread = NULL;
PVOID NtfsReserved3Thread = NULL;
PFCB NtfsReserved12Fcb = NULL;
PFCB NtfsReserved3Fcb = NULL;
PVOID NtfsReservedBufferThread = NULL;
BOOLEAN NtfsBufferAllocationFailure = FALSE;
FAST_MUTEX NtfsReservedBufferMutex;
ERESOURCE NtfsReservedBufferResource;
LARGE_INTEGER NtfsShortDelay = {(ULONG)-100000, -1}; // 10 milliseconds
#ifdef _CAIRO_
FAST_MUTEX NtfsScavengerLock;
PIRP_CONTEXT NtfsScavengerWorkList;
BOOLEAN NtfsScavengerRunning;
#endif // _CAIRO_
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NtfsFastIoCheckIfPossible)
#pragma alloc_text(PAGE, NtfsFastQueryBasicInfo)
#pragma alloc_text(PAGE, NtfsFastQueryStdInfo)
#pragma alloc_text(PAGE, NtfsFastQueryNetworkOpenInfo)
#ifdef _CAIRO_
#pragma alloc_text(PAGE, NtfsFastIoQueryCompressionInfo)
#pragma alloc_text(PAGE, NtfsFastIoQueryCompressedSize)
#endif _CAIRO_
#endif
//
// Internal support routines
//
LONG
NtfsProcessExceptionFilter (
IN PEXCEPTION_POINTERS ExceptionPointer
)
{
UNREFERENCED_PARAMETER( ExceptionPointer );
ASSERT( NT_SUCCESS( ExceptionPointer->ExceptionRecord->ExceptionCode ));
return EXCEPTION_EXECUTE_HANDLER;
}
ULONG
NtfsRaiseStatusFunction (
IN PIRP_CONTEXT IrpContext,
IN NTSTATUS Status
)
/*++
Routine Description:
This routine is only required by the NtfsDecodeFileObject macro. It is
a function wrapper around NtfsRaiseStatus.
Arguments:
Status - Status to raise
Return Value:
0 - but no one will see it!
--*/
{
NtfsRaiseStatus( IrpContext, Status, NULL, NULL );
return 0;
}
VOID
NtfsRaiseStatus (
IN PIRP_CONTEXT IrpContext,
IN NTSTATUS Status,
IN PFILE_REFERENCE FileReference OPTIONAL,
IN PFCB Fcb OPTIONAL
)
{
//
// If the caller is declaring corruption, then let's mark the
// the volume corrupt appropriately, and maybe generate a popup.
//
if (Status == STATUS_DISK_CORRUPT_ERROR) {
NtfsPostVcbIsCorrupt( IrpContext, Status, FileReference, Fcb );
} else if ((Status == STATUS_FILE_CORRUPT_ERROR) ||
(Status == STATUS_EA_CORRUPT_ERROR)) {
NtfsPostVcbIsCorrupt( IrpContext, Status, FileReference, Fcb );
}
//
// Set a flag to indicate that we raised this status code and store
// it in the IrpContext.
//
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_RAISED_STATUS );
if (NT_SUCCESS( IrpContext->ExceptionStatus )) {
//
// If this is a paging io request and we got a Quota Exceeded error
// then translate the status to FILE_LOCK_CONFLICT so that this
// is a retryable condition.
//
if ((Status == STATUS_QUOTA_EXCEEDED) &&
(IrpContext->OriginatingIrp != NULL) &&
(FlagOn( IrpContext->OriginatingIrp->Flags, IRP_PAGING_IO ))) {
Status = STATUS_FILE_LOCK_CONFLICT;
}
IrpContext->ExceptionStatus = Status;
}
//
// Now finally raise the status, and make sure we do not come back.
//
ExRaiseStatus( IrpContext->ExceptionStatus );
}
LONG
NtfsExceptionFilter (
IN PIRP_CONTEXT IrpContext OPTIONAL,
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:
ExceptionPointer - Supplies the exception record to being checked.
Return Value:
ULONG - returns EXCEPTION_EXECUTE_HANDLER or bugchecks
--*/
{
NTSTATUS ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
DebugTrace( 0, DEBUG_TRACE_UNWIND, ("NtfsExceptionFilter %X\n", ExceptionCode) );
//
// If the exception is an in page error, then get the real I/O error code
// from the exception record
//
if ((ExceptionCode == STATUS_IN_PAGE_ERROR) &&
(ExceptionPointer->ExceptionRecord->NumberParameters >= 3)) {
ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
//
// If we got FILE_LOCK_CONFLICT from a paging request then change it
// to STATUS_CANT_WAIT. This means that we couldn't wait for a
// reserved buffer or some other retryable condition. In the write
// case the correct error is already in the IrpContext. The read
// case doesn't pass the error back via the top-level irp context
// however.
//
if (ExceptionCode == STATUS_FILE_LOCK_CONFLICT) {
ExceptionCode = STATUS_CANT_WAIT;
}
}
//
// If there is not an irp context, we must have had insufficient resources
//
if (!ARGUMENT_PRESENT(IrpContext)) {
//
// Check whether this is a fatal error and bug check if so.
// Typically the only error is insufficient resources but
// it is possible that pool has been corrupted.
//
if (!FsRtlIsNtstatusExpected( ExceptionCode )) {
NtfsBugCheck( (ULONG)ExceptionPointer->ExceptionRecord,
(ULONG)ExceptionPointer->ContextRecord,
(ULONG)ExceptionPointer->ExceptionRecord->ExceptionAddress );
}
return EXCEPTION_EXECUTE_HANDLER;
}
#ifdef NTFS_RESTART
ASSERT( (ExceptionCode != STATUS_FILE_CORRUPT_ERROR) &&
(ExceptionCode != STATUS_DISK_CORRUPT_ERROR) );
#endif
//
// When processing any exceptions we always can wait. Remember the
// current state of the wait flag so we can restore while processing
// the exception.
//
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST );
}
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
//
// If someone got STATUS_LOG_FILE_FULL or STATUS_CANT_WAIT, let's
// handle that. Note any other error that also happens will
// probably not go away and will just reoccur. If it does go
// away, that's ok too.
//
if (IrpContext->TopLevelIrpContext == IrpContext) {
if ((IrpContext->ExceptionStatus == STATUS_LOG_FILE_FULL) ||
(IrpContext->ExceptionStatus == STATUS_CANT_WAIT)) {
ExceptionCode = IrpContext->ExceptionStatus;
}
}
//
// If we didn't raise this status code then we need to check if
// we should handle this exception.
//
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_RAISED_STATUS )) {
if (FsRtlIsNtstatusExpected( ExceptionCode )) {
//
// If we got an allocation failure doing paging Io then convert
// this to FILE_LOCK_CONFLICT.
//
if ((ExceptionCode == STATUS_QUOTA_EXCEEDED) &&
(IrpContext->OriginatingIrp != NULL) &&
(FlagOn( IrpContext->OriginatingIrp->Flags, IRP_PAGING_IO ))) {
ExceptionCode = STATUS_FILE_LOCK_CONFLICT;
}
IrpContext->ExceptionStatus = ExceptionCode;
} else {
NtfsBugCheck( (ULONG)ExceptionPointer->ExceptionRecord,
(ULONG)ExceptionPointer->ContextRecord,
(ULONG)ExceptionPointer->ExceptionRecord->ExceptionAddress );
}
} else {
//
// We raised this code explicitly ourselves, so it had better be
// expected.
//
ASSERT( ExceptionCode == IrpContext->ExceptionStatus );
ASSERT( FsRtlIsNtstatusExpected( ExceptionCode ) );
}
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_RAISED_STATUS );
//
// If the exception code is log file full, then remember the current
// RestartAreaLsn in the Vcb, so we can see if we are the ones to flush
// the log file later. Note, this does not have to be synchronized,
// because we are just using it to arbitrate who must do the flush, but
// eventually someone will anyway.
//
if (ExceptionCode == STATUS_LOG_FILE_FULL) {
IrpContext->TopLevelIrpContext->LastRestartArea = IrpContext->Vcb->LastRestartArea;
}
return EXCEPTION_EXECUTE_HANDLER;
}
NTSTATUS
NtfsProcessException (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp OPTIONAL,
IN NTSTATUS ExceptionCode
)
/*++
Routine Description:
This routine process an exception. It either completes the request
with the saved exception status or it sends the request off to the Fsp
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.
--*/
{
BOOLEAN TopLevelRequest;
PIRP_CONTEXT PostIrpContext = NULL;
BOOLEAN Retry = FALSE;
BOOLEAN ReleaseBitmap = FALSE;
ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
ASSERT_OPTIONAL_IRP( Irp );
DebugTrace( 0, Dbg, ("NtfsProcessException\n") );
//
// If there is not an irp context, we must have had insufficient resources
//
if (IrpContext == NULL) {
if (ARGUMENT_PRESENT( Irp )) {
NtfsCompleteRequest( NULL, &Irp, ExceptionCode );
}
return ExceptionCode;
}
//
// Get the real exception status from the Irp Context.
//
ExceptionCode = IrpContext->ExceptionStatus;
//
// All errors which could possibly have started a transaction must go
// through here. Abort the transaction.
//
//
// Increment the appropriate performance counters.
//
CollectExceptionStats( IrpContext->Vcb, ExceptionCode );
try {
//
// If this is an Mdl write request, then take care of the Mdl
// here so that things get cleaned up properly, and in the
// case of log file full we will just create a new Mdl. By
// getting rid of this Mdl now, the pages will not be locked
// if we try to truncate the file while restoring snapshots.
//
if ((IrpContext->MajorFunction == IRP_MJ_WRITE) &&
FlagOn(IrpContext->MinorFunction, IRP_MN_MDL) &&
(Irp->MdlAddress != NULL)) {
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
CcMdlWriteComplete( IrpSp->FileObject,
&IrpSp->Parameters.Write.ByteOffset,
Irp->MdlAddress );
Irp->MdlAddress = NULL;
}
//
// On a failed mount this value will be NULL. Don't perform the
// abort in that case or we will fail when looking at the Vcb
// in the Irp COntext.
//
if (IrpContext->Vcb != NULL) {
//
// To make sure that we can access all of our streams correctly,
// we first restore all of the higher sizes before aborting the
// transaction. Then we restore all of the lower sizes after
// the abort, so that all Scbs are finally restored.
//
NtfsRestoreScbSnapshots( IrpContext, TRUE );
//
// If we modified the volume bitmap during this transaction we
// want to acquire it and hold it throughout the abort process.
// Otherwise this abort could constantly be setting the rescan
// bitmap flag at the same time as some interleaved transaction
// is performing bitmap operations and we will thrash performing
// bitmap scans.
//
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_MODIFIED_BITMAP ) &&
(IrpContext->TransactionId != 0)) {
//
// Acquire the resource and remember we need to release it.
//
ExAcquireResourceExclusive( IrpContext->Vcb->BitmapScb->Header.Resource,
TRUE );
//
// Restore the free cluster count in the Vcb.
//
IrpContext->Vcb->FreeClusters -= IrpContext->FreeClusterChange;
ReleaseBitmap = TRUE;
}
NtfsAbortTransaction( IrpContext, IrpContext->Vcb, NULL );
if (ReleaseBitmap) {
ExReleaseResource( IrpContext->Vcb->BitmapScb->Header.Resource );
ReleaseBitmap = FALSE;
}
NtfsRestoreScbSnapshots( IrpContext, FALSE );
NtfsAcquireCheckpoint( IrpContext, IrpContext->Vcb );
SetFlag( IrpContext->Vcb->MftDefragState, VCB_MFT_DEFRAG_ENABLED );
NtfsReleaseCheckpoint( IrpContext, IrpContext->Vcb );
}
//
// Exceptions at this point are pretty bad, we failed to undo everything.
//
} except(NtfsProcessExceptionFilter( GetExceptionInformation() )) {
PSCB_SNAPSHOT ScbSnapshot;
PSCB NextScb;
//
// If we get an exception doing this then things are in really bad
// shape but we still don't want to bugcheck the system so we
// need to protect ourselves
//
try {
NtfsPostVcbIsCorrupt( IrpContext, 0, NULL, NULL );
} except(NtfsProcessExceptionFilter( GetExceptionInformation() )) {
NOTHING;
}
if (ReleaseBitmap) {
//
// Since we had an unexpected failure and we know that
// we have modified the bitmap we need to do a complete
// scan to accurately know the free cluster count.
//
SetFlag( IrpContext->Vcb->VcbState, VCB_STATE_RELOAD_FREE_CLUSTERS );
ExReleaseResource( IrpContext->Vcb->BitmapScb->Header.Resource );
ReleaseBitmap = FALSE;
}
//
// We have taken all the steps possible to cleanup the current
// transaction and it has failed. Any of the Scb's involved in
// this transaction could now be out of ssync with the on-disk
// structures. We can't go to disk to restore this so we will
// clean up the in-memory structures as best we can so that the
// system won't crash.
//
// We will go through the Scb snapshot list and knock down the
// sizes to the lower of the two values. We will also truncate
// the Mcb to that allocation. If this is a normal data stream
// we will actually empty the Mcb.
//
ScbSnapshot = &IrpContext->ScbSnapshot;
//
// There is no snapshot data to restore if the Flink is still NULL.
//
if (ScbSnapshot->SnapshotLinks.Flink != NULL) {
//
// Loop to retore first the Scb data from the snapshot in the
// IrpContext, and then 0 or more additional snapshots linked
// to the IrpContext.
//
do {
NextScb = ScbSnapshot->Scb;
if (NextScb == NULL) {
ScbSnapshot = (PSCB_SNAPSHOT)ScbSnapshot->SnapshotLinks.Flink;
continue;
}
//
// Go through each of the sizes and use the lower value.
//
if (ScbSnapshot->AllocationSize < NextScb->Header.AllocationSize.QuadPart) {
NextScb->Header.AllocationSize.QuadPart = ScbSnapshot->AllocationSize;
}
if (FlagOn(NextScb->Header.AllocationSize.LowPart, 1)) {
NextScb->Header.AllocationSize.LowPart -= 1;
SetFlag(NextScb->ScbState, SCB_STATE_ATTRIBUTE_RESIDENT);
} else {
ClearFlag(NextScb->ScbState, SCB_STATE_ATTRIBUTE_RESIDENT);
}
//
// Update the FastIoField.
//
NtfsAcquireFsrtlHeader( NextScb );
NextScb->Header.IsFastIoPossible = NtfsIsFastIoPossible( NextScb );
NtfsReleaseFsrtlHeader( NextScb );
if (ScbSnapshot->FileSize < NextScb->Header.FileSize.QuadPart) {
NextScb->Header.FileSize.QuadPart = ScbSnapshot->FileSize;
}
if (ScbSnapshot->ValidDataLength < NextScb->Header.ValidDataLength.QuadPart) {
NextScb->Header.ValidDataLength.QuadPart = ScbSnapshot->ValidDataLength;
}
//
// Truncate the Mcb to 0 for user data streams and to the
// allocation size for other streams.
//
if (NtfsIsTypeCodeUserData( NextScb->AttributeTypeCode ) &&
!FlagOn( NextScb->Fcb->FcbState, FCB_STATE_PAGING_FILE ) &&
(NtfsSegmentNumber( &NextScb->Fcb->FileReference ) >= FIRST_USER_FILE_NUMBER)) {
NtfsUnloadNtfsMcbRange( &NextScb->Mcb, (LONGLONG) 0, MAXLONGLONG, FALSE, FALSE );
} else {
NtfsUnloadNtfsMcbRange( &NextScb->Mcb,
Int64ShraMod32(NextScb->Header.AllocationSize.QuadPart, NextScb->Vcb->ClusterShift),
MAXLONGLONG,
FALSE,
FALSE );
}
ScbSnapshot = (PSCB_SNAPSHOT)ScbSnapshot->SnapshotLinks.Flink;
} while (ScbSnapshot != &IrpContext->ScbSnapshot);
}
//ASSERTMSG( "***Failed to abort transaction, volume is corrupt", FALSE );
//
// Clear the transaction Id in the IrpContext to make sure we don't
// try to write any log records in the complete request.
//
IrpContext->TransactionId = 0;
}
//
// If this isn't the top-level request then make sure to pass the real
// error back to the top level.
//
if (IrpContext != IrpContext->TopLevelIrpContext) {
//
// Make sure this error is returned to the top level guy.
// If the status is FILE_LOCK_CONFLICT then we are using this
// value to stop some lower level request. Convert it to
// STATUS_CANT_WAIT so the top-level request will retry.
//
if (NT_SUCCESS( IrpContext->TopLevelIrpContext->ExceptionStatus )) {
if (ExceptionCode == STATUS_FILE_LOCK_CONFLICT) {
IrpContext->TopLevelIrpContext->ExceptionStatus = STATUS_CANT_WAIT;
} else {
IrpContext->TopLevelIrpContext->ExceptionStatus = ExceptionCode;
}
}
}
//
// If the status is cant wait then send the request off to the fsp.
//
TopLevelRequest = NtfsIsTopLevelRequest( IrpContext );
//
// We want to look at the LOG_FILE_FULL or CANT_WAIT cases and consider
// if we want to post the request. We only post requests at the top
// level.
//
if (ExceptionCode == STATUS_LOG_FILE_FULL ||
ExceptionCode == STATUS_CANT_WAIT) {
if (ARGUMENT_PRESENT( Irp )) {
//
// If we are top level, we will either post it or retry.
//
if (TopLevelRequest) {
//
// See if we are supposed to post the request.
//
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST )) {
PostIrpContext = IrpContext;
//
// Otherwise we will retry this request in the original thread.
//
} else {
Retry = TRUE;
}
//
// Otherwise we will complete the request, see if there is any
// related processing to do.
//
} else {
//
// We are the top level Ntfs call. If we are processing a
// LOG_FILE_FULL condition then there may be no one above us
// who can do the checkpoint. Go ahead and fire off a dummy
// request. Do an unsafe test on the flag since it won't hurt
// to generate an occasional additional request.
//
if ((ExceptionCode == STATUS_LOG_FILE_FULL) &&
(IrpContext->TopLevelIrpContext == IrpContext) &&
!FlagOn( IrpContext->Vcb->CheckpointFlags, VCB_DUMMY_CHECKPOINT_POSTED )) {
//
// Create a dummy IrpContext but protect this request with
// a try-except to catch any allocation failures.
//
try {
PostIrpContext = NtfsCreateIrpContext( NULL, TRUE );
PostIrpContext->Vcb = IrpContext->Vcb;
PostIrpContext->LastRestartArea = PostIrpContext->Vcb->LastRestartArea;
NtfsAcquireCheckpoint( IrpContext, IrpContext->Vcb );
SetFlag( IrpContext->Vcb->CheckpointFlags, VCB_DUMMY_CHECKPOINT_POSTED );
NtfsReleaseCheckpoint( IrpContext, IrpContext->Vcb );
} except( EXCEPTION_EXECUTE_HANDLER ) {
NOTHING;
}
}
//
// If this is a paging write and we are not the top level
// request then we need to return STATUS_FILE_LOCk_CONFLICT
// to make MM happy (and keep the pages dirty) and to
// prevent this request from retrying the request.
//
ExceptionCode = STATUS_FILE_LOCK_CONFLICT;
}
}
}
if (PostIrpContext) {
NTSTATUS PostStatus;
//
// Clear the current error code.
//
PostIrpContext->ExceptionStatus = 0;
//
// We need a try-except in case the Lock buffer call fails.
//
try {
PostStatus = NtfsPostRequest( PostIrpContext, PostIrpContext->OriginatingIrp );
//
// If we posted the original request we don't have any
// completion work to do.
//
if (PostIrpContext == IrpContext) {
Irp = NULL;
IrpContext = NULL;
ExceptionCode = PostStatus;
}
} except (EXCEPTION_EXECUTE_HANDLER) {
//
// If we don't have an error in the IrpContext then
// generate a generic IO error. We can't use the
// original status code if either LOG_FILE_FULL or
// CANT_WAIT. We would complete the Irp yet retry the
// request.
//
if (IrpContext == PostIrpContext) {
if (PostIrpContext->ExceptionStatus == 0) {
if ((ExceptionCode == STATUS_LOG_FILE_FULL) ||
(ExceptionCode == STATUS_CANT_WAIT)) {
ExceptionCode = STATUS_UNEXPECTED_IO_ERROR;
}
} else {
ExceptionCode = PostIrpContext->ExceptionStatus;
}
}
}
}
//
// We have the Irp. We either need to complete this request or allow
// the top level thread to retry.
//
if (ARGUMENT_PRESENT(Irp)) {
//
// If this is a top level Ntfs request and we still have the Irp
// it means we will be retrying the request. In that case
// mark the Irp Context so it doesn't go away.
//
if (Retry) {
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_DONT_DELETE );
NtfsCompleteRequest( &IrpContext, NULL, ExceptionCode );
//
// Clear the status code in the Irp Context.
//
IrpContext->ExceptionStatus = 0;
} else {
NtfsCompleteRequest( &IrpContext, &Irp, ExceptionCode );
}
} else if (IrpContext != NULL) {
NtfsCompleteRequest( &IrpContext, NULL, ExceptionCode );
}
return ExceptionCode;
}
VOID
NtfsCompleteRequest (
IN OUT PIRP_CONTEXT *IrpContext OPTIONAL,
IN OUT PIRP *Irp OPTIONAL,
IN NTSTATUS Status
)
/*++
Routine Description:
This routine completes an IRP and deallocates the IrpContext
Arguments:
Irp - Supplies the Irp being processed
Status - Supplies the status to complete the Irp with
Return Value:
None.
--*/
{
//
// If we have an Irp Context then unpin all of the repinned bcbs
// we might have collected, and delete the Irp context. Delete Irp
// Context will zero out our pointer for us.
//
if (ARGUMENT_PRESENT(IrpContext)) {
ASSERT_IRP_CONTEXT( *IrpContext );
if ((*IrpContext)->TransactionId != 0) {
NtfsCommitCurrentTransaction( *IrpContext );
}
(*IrpContext)->ExceptionStatus = Status;
//
// Always store the status in the top level Irp Context unless
// there is already an error code.
//
if (NT_SUCCESS( (*IrpContext)->TopLevelIrpContext->ExceptionStatus )) {
(*IrpContext)->TopLevelIrpContext->ExceptionStatus = Status;
}
NtfsDeleteIrpContext( IrpContext );
}
//
// If we have an Irp then complete the irp.
//
if (ARGUMENT_PRESENT( Irp )) {
PIO_STACK_LOCATION IrpSp;
ASSERT_IRP( *Irp );
if (NT_ERROR( Status ) &&
FlagOn( (*Irp)->Flags, IRP_INPUT_OPERATION )) {
(*Irp)->IoStatus.Information = 0;
}
IrpSp = IoGetCurrentIrpStackLocation( *Irp );
(*Irp)->IoStatus.Status = Status;
IoCompleteRequest( *Irp, IO_DISK_INCREMENT );
//
// Zero out our input pointer
//
*Irp = NULL;
}
return;
}
BOOLEAN
NtfsFastIoCheckIfPossible (
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
--*/
{
PSCB Scb;
LARGE_INTEGER LargeLength;
UNREFERENCED_PARAMETER( DeviceObject );
UNREFERENCED_PARAMETER( IoStatus );
UNREFERENCED_PARAMETER( Wait );
PAGED_CODE();
//
// Decode the file object to get our fcb, the only one we want
// to deal with is a UserFileOpen
//
if ((Scb = NtfsFastDecodeUserFileOpen( FileObject )) == NULL) {
return FALSE;
}
LargeLength = RtlConvertUlongToLargeInteger( Length );
//
// Based on whether this is a read or write operation we call
// fsrtl check for read/write
//
if (CheckForReadOperation) {
if (Scb->ScbType.Data.FileLock == NULL
|| FsRtlFastCheckLockForRead( Scb->ScbType.Data.FileLock,
FileOffset,
&LargeLength,
LockKey,
FileObject,
PsGetCurrentProcess() )) {
return TRUE;
}
} else {
if ((Scb->ScbType.Data.FileLock == NULL
|| FsRtlFastCheckLockForWrite( Scb->ScbType.Data.FileLock,
FileOffset,
&LargeLength,
LockKey,
FileObject,
PsGetCurrentProcess() ))
&&
(!FlagOn( Scb->AttributeFlags, ATTRIBUTE_FLAG_COMPRESSION_MASK ) ||
NtfsReserveClusters( NULL, Scb, FileOffset->QuadPart, Length))) {
return TRUE;
}
}
return FALSE;
}
BOOLEAN
NtfsFastQueryBasicInfo (
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 is successful 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;
PSCB Scb;
PCCB Ccb;
BOOLEAN FcbAcquired = FALSE;
UNREFERENCED_PARAMETER( DeviceObject );
PAGED_CODE();
//
// Prepare the dummy irp context
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = NTFS_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. The callee really
// ignores the irp context for us.
//
TypeOfOpen = NtfsDecodeFileObject( &IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, FALSE );
FsRtlEnterFileSystem();
try {
if (ExAcquireResourceShared( Fcb->Resource, Wait )) {
FcbAcquired = TRUE;
if (FlagOn( Fcb->FcbState, FCB_STATE_FILE_DELETED ) ||
!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {
try_return( NOTHING );
}
} else {
try_return( NOTHING );
}
switch (TypeOfOpen) {
case UserFileOpen:
#ifdef _CAIRO_
case UserPropertySetOpen:
#endif // _CAIRO_
case UserDirectoryOpen:
case StreamFileOpen:
//
// Fill in the basic information fields
//
Buffer->CreationTime.QuadPart = Fcb->Info.CreationTime;
Buffer->LastWriteTime.QuadPart = Fcb->Info.LastModificationTime;
Buffer->ChangeTime.QuadPart = Fcb->Info.LastChangeTime;
Buffer->LastAccessTime.QuadPart = Fcb->CurrentLastAccess;
Buffer->FileAttributes = Fcb->Info.FileAttributes;
ClearFlag( Buffer->FileAttributes,
~FILE_ATTRIBUTE_VALID_FLAGS
| FILE_ATTRIBUTE_TEMPORARY );
if (IsDirectory( &Fcb->Info )) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY );
}
//
// If this is not the main stream on the file then use the stream based
// compressed bit.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_OPEN_AS_FILE )) {
if (Scb->CompressionUnit != 0) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_COMPRESSED );
} else {
ClearFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_COMPRESSED );
}
}
//
// Set the temporary flag if set in the Scb.
//
if (FlagOn( Scb->ScbState, SCB_STATE_TEMPORARY )) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
}
//
// If there are no flags set then explicitly set the NORMAL flag.
//
if (Buffer->FileAttributes == 0) {
Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
}
Results = TRUE;
IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
IoStatus->Status = STATUS_SUCCESS;
break;
default:
NOTHING;
}
try_exit: NOTHING;
} finally {
if (FcbAcquired) { ExReleaseResource( Fcb->Resource ); }
FsRtlExitFileSystem();
}
//
// Return to our caller
//
return Results;
}
BOOLEAN
NtfsFastQueryStdInfo (
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 is successful 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;
PSCB Scb;
PCCB Ccb;
BOOLEAN FcbAcquired = FALSE;
BOOLEAN FsRtlHeaderLocked = FALSE;
UNREFERENCED_PARAMETER( DeviceObject );
PAGED_CODE();
//
// Prepare the dummy irp context
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = NTFS_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. The callee really
// ignores the irp context for us.
//
TypeOfOpen = NtfsDecodeFileObject( &IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, FALSE );
FsRtlEnterFileSystem();
try {
switch (TypeOfOpen) {
case UserFileOpen:
#ifdef _CAIRO_
case UserPropertySetOpen:
#endif // _CAIRO_
case UserDirectoryOpen:
case StreamFileOpen:
if (Scb->Header.PagingIoResource != NULL) {
ExAcquireResourceShared( Scb->Header.PagingIoResource, TRUE );
}
FsRtlLockFsRtlHeader( &Scb->Header );
FsRtlHeaderLocked = TRUE;
if (ExAcquireResourceShared( Fcb->Resource, Wait )) {
FcbAcquired = TRUE;
if (FlagOn( Fcb->FcbState, FCB_STATE_FILE_DELETED ) ||
!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED )) {
try_return( NOTHING );
}
} else {
try_return( NOTHING );
}
//
// Fill in the standard information fields. If the
// Scb is not initialized then take the long route
//
if (!FlagOn( Scb->ScbState, SCB_STATE_HEADER_INITIALIZED) &&
(Scb->AttributeTypeCode != $INDEX_ALLOCATION)) {
NOTHING;
} else {
Buffer->AllocationSize.QuadPart = Scb->TotalAllocated;
Buffer->EndOfFile = Scb->Header.FileSize;
Buffer->NumberOfLinks = Fcb->LinkCount;
if (Ccb != NULL) {
if (FlagOn(Ccb->Flags, CCB_FLAG_OPEN_AS_FILE)) {
if (Scb->Fcb->LinkCount == 0 ||
(Ccb->Lcb != NULL &&
FlagOn( Ccb->Lcb->LcbState, LCB_STATE_DELETE_ON_CLOSE ))) {
Buffer->DeletePending = TRUE;
}
} else {
Buffer->DeletePending = BooleanFlagOn( Scb->ScbState, SCB_STATE_DELETE_ON_CLOSE );
}
}
Buffer->Directory = BooleanIsDirectory( &Fcb->Info );
IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
IoStatus->Status = STATUS_SUCCESS;
Results = TRUE;
}
break;
default:
NOTHING;
}
try_exit: NOTHING;
} finally {
if (FcbAcquired) { ExReleaseResource( Fcb->Resource ); }
if (FsRtlHeaderLocked) {
FsRtlUnlockFsRtlHeader( &Scb->Header );
if (Scb->Header.PagingIoResource != NULL) {
ExReleaseResource( Scb->Header.PagingIoResource );
}
}
FsRtlExitFileSystem();
}
//
// And return to our caller
//
return Results;
}
BOOLEAN
NtfsFastQueryNetworkOpenInfo (
IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
This routine is for the fast query network open call.
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 is successful 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;
PSCB Scb;
PCCB Ccb;
BOOLEAN FcbAcquired = FALSE;
UNREFERENCED_PARAMETER( DeviceObject );
PAGED_CODE();
//
// Prepare the dummy irp context
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = NTFS_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. The callee really
// ignores the irp context for us.
//
TypeOfOpen = NtfsDecodeFileObject( &IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, FALSE );
FsRtlEnterFileSystem();
try {
if (ExAcquireResourceShared( Fcb->Resource, Wait )) {
FcbAcquired = TRUE;
if (FlagOn( Fcb->FcbState, FCB_STATE_FILE_DELETED ) ||
!FlagOn( Vcb->VcbState, VCB_STATE_VOLUME_MOUNTED ) ||
(!FlagOn( Scb->ScbState, SCB_STATE_HEADER_INITIALIZED) &&
(Scb->AttributeTypeCode != $INDEX_ALLOCATION))) {
try_return( NOTHING );
}
} else {
try_return( NOTHING );
}
switch (TypeOfOpen) {
case UserFileOpen:
#ifdef _CAIRO_
case UserPropertySetOpen:
#endif // _CAIRO_
case UserDirectoryOpen:
case StreamFileOpen:
//
// Fill in the basic information fields
//
Buffer->CreationTime.QuadPart = Fcb->Info.CreationTime;
Buffer->LastWriteTime.QuadPart = Fcb->Info.LastModificationTime;
Buffer->ChangeTime.QuadPart = Fcb->Info.LastChangeTime;
Buffer->LastAccessTime.QuadPart = Fcb->CurrentLastAccess;
Buffer->FileAttributes = Fcb->Info.FileAttributes;
ClearFlag( Buffer->FileAttributes,
~FILE_ATTRIBUTE_VALID_FLAGS | FILE_ATTRIBUTE_TEMPORARY );
if (Scb->AttributeTypeCode == $INDEX_ALLOCATION) {
if (IsDirectory( &Fcb->Info )) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_DIRECTORY );
//
// If this is not the main stream then copy the compression
// value from this Scb.
//
} else if (FlagOn( Scb->AttributeFlags, ATTRIBUTE_FLAG_COMPRESSION_MASK )) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_COMPRESSED );
} else {
ClearFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_COMPRESSED );
}
Buffer->AllocationSize.QuadPart =
Buffer->EndOfFile.QuadPart = 0;
//
// Return a non-zero size only for data streams.
//
} else {
Buffer->AllocationSize.QuadPart = Scb->TotalAllocated;
Buffer->EndOfFile = Scb->Header.FileSize;
//
// If not the unnamed data stream then use the Scb
// compression value.
//
if (!FlagOn( Scb->ScbState, SCB_STATE_UNNAMED_DATA )) {
if (FlagOn( Scb->AttributeFlags, ATTRIBUTE_FLAG_COMPRESSION_MASK )) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_COMPRESSED );
} else {
ClearFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_COMPRESSED );
}
}
}
//
// Set the temporary flag if set in the Scb.
//
if (FlagOn( Scb->ScbState, SCB_STATE_TEMPORARY )) {
SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
}
//
// If there are no flags set then explicitly set the NORMAL flag.
//
if (Buffer->FileAttributes == 0) {
Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
}
IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);
IoStatus->Status = STATUS_SUCCESS;
Results = TRUE;
break;
default:
NOTHING;
}
try_exit: NOTHING;
} finally {
if (FcbAcquired) { ExReleaseResource( Fcb->Resource ); }
FsRtlExitFileSystem();
}
//
// And return to our caller
//
return Results;
}
#ifdef _CAIRO_
VOID
NtfsFastIoQueryCompressionInfo (
IN PFILE_OBJECT FileObject,
OUT PFILE_COMPRESSION_INFORMATION Buffer,
OUT PIO_STATUS_BLOCK IoStatus
)
/*++
Routine Description:
This routine is a fast call for returning the comprssion information
for a file. It assumes that the caller has an exception handler and
will treat exceptions as an error. Therefore, this routine only uses
a finally clause to cleanup any resources, and it does not worry about
returning errors in the IoStatus.
Arguments:
FileObject - FileObject for the file on which the compressed information
is desired.
Buffer - Buffer to receive the compressed data information (as defined
in ntioapi.h)
IoStatus - Returns STATUS_SUCCESS and the size of the information being
returned.
Return Value:
None
--*/
{
IRP_CONTEXT IrpContext;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
BOOLEAN ScbAcquired = FALSE;
PAGED_CODE();
//
// Prepare the dummy irp context
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = NTFS_NTC_IRP_CONTEXT;
IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
//
// Assume success (otherwise caller should see the exception)
//
IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = sizeof(FILE_COMPRESSION_INFORMATION);
//
// Determine the type of open for the input file object. The callee really
// ignores the irp context for us.
//
TypeOfOpen = NtfsDecodeFileObject( &IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, FALSE);
FsRtlEnterFileSystem();
try {
NtfsAcquireSharedScb( &IrpContext, Scb );
ScbAcquired = TRUE;
//
// Now return the compressed data information.
//
Buffer->CompressedFileSize.QuadPart = Scb->TotalAllocated;
Buffer->CompressionFormat = (USHORT)(Scb->AttributeFlags & ATTRIBUTE_FLAG_COMPRESSION_MASK);
if (Buffer->CompressionFormat != 0) {
Buffer->CompressionFormat += 1;
}
Buffer->CompressionUnitShift = (UCHAR)(Scb->CompressionUnitShift + Vcb->ClusterShift);
Buffer->ChunkShift = NTFS_CHUNK_SHIFT;
Buffer->ClusterShift = (UCHAR)Vcb->ClusterShift;
Buffer->Reserved[0] = Buffer->Reserved[1] = Buffer->Reserved[2] = 0;
} finally {
if (ScbAcquired) {NtfsReleaseScb( &IrpContext, Scb );}
FsRtlExitFileSystem();
}
}
VOID
NtfsFastIoQueryCompressedSize (
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
OUT PULONG CompressedSize
)
/*++
Routine Description:
This routine is a fast call for returning the the size of a specified
compression unit. It assumes that the caller has an exception handler and
will treat exceptions as an error. Therefore, this routine does not even
have a finally clause, since it does not acquire any resources directly.
Arguments:
FileObject - FileObject for the file on which the compressed information
is desired.
FileOffset - FileOffset for a compression unit for which the allocated size
is desired.
CompressedSize - Returns the allocated size of the compression unit.
Return Value:
None
--*/
{
IRP_CONTEXT IrpContext;
TYPE_OF_OPEN TypeOfOpen;
PVCB Vcb;
PFCB Fcb;
PSCB Scb;
PCCB Ccb;
VCN Vcn;
LCN Lcn;
LONGLONG SizeInBytes;
LONGLONG ClusterCount = 0;
PAGED_CODE();
//
// Prepare the dummy irp context
//
RtlZeroMemory( &IrpContext, sizeof(IRP_CONTEXT) );
IrpContext.NodeTypeCode = NTFS_NTC_IRP_CONTEXT;
IrpContext.NodeByteSize = sizeof(IRP_CONTEXT);
SetFlag(IrpContext.Flags, IRP_CONTEXT_FLAG_WAIT);
//
// Determine the type of open for the input file object. The callee really
// ignores the irp context for us.
//
TypeOfOpen = NtfsDecodeFileObject( &IrpContext, FileObject, &Vcb, &Fcb, &Scb, &Ccb, FALSE);
IrpContext.Vcb = Vcb;
ASSERT(Scb->CompressionUnit != 0);
ASSERT((FileOffset->QuadPart & (Scb->CompressionUnit - 1)) == 0);
//
// Calculate the Vcn the caller wants, and initialize our output.
//
Vcn = LlClustersFromBytes( Vcb, FileOffset->QuadPart );
*CompressedSize = 0;
//
// Loop as long as we are looking up allocated Vcns.
//
while (NtfsLookupAllocation(&IrpContext, Scb, Vcn, &Lcn, &ClusterCount, NULL, NULL)) {
SizeInBytes = LlBytesFromClusters( Vcb, ClusterCount );
//
// If this allocated run goes beyond the end of the compresion unit, then
// we know it is fully allocated.
//
if ((SizeInBytes + *CompressedSize) > Scb->CompressionUnit) {
*CompressedSize = Scb->CompressionUnit;
break;
}
*CompressedSize += (ULONG)SizeInBytes;
Vcn += ClusterCount;
}
}
#endif _CAIRO_
VOID
NtfsRaiseInformationHardError (
IN PIRP_CONTEXT IrpContext,
IN NTSTATUS Status,
IN PFILE_REFERENCE FileReference OPTIONAL,
IN PFCB Fcb OPTIONAL
)
/*++
Routine Description:
This routine is used to generate a popup in the event a corrupt file
or disk is encountered. The main purpose of the routine is to find
a name to pass to the popup package. If there is no Fcb we will take
the volume name out of the Vcb. If the Fcb has an Lcb in its Lcb list,
we will construct the name by walking backwards through the Lcb's.
If the Fcb has no Lcb but represents a system file, we will return
a default system string. If the Fcb represents a user file, but we
have no Lcb, we will use the name in the file object for the current
request.
Arguments:
Status - Error status.
FileReference - File reference being accessed in Mft when error occurred.
Fcb - If specified, this is the Fcb being used when the error was encountered.
Return Value:
None.
--*/
{
FCB_TABLE_ELEMENT Key;
PFCB_TABLE_ELEMENT Entry = NULL;
PKTHREAD Thread;
UNICODE_STRING Name;
ULONG NameLength;
PFILE_OBJECT FileObject;
WCHAR *NewBuffer;
PIRP Irp = NULL;
PIO_STACK_LOCATION IrpSp;
//
// Return if there is no originating Irp, for example when originating
// from NtfsPerformHotFix.
//
if (IrpContext->OriginatingIrp == NULL) {
return;
}
if (IrpContext->OriginatingIrp->Type == IO_TYPE_IRP) {
Irp = IrpContext->OriginatingIrp;
IrpSp = IoGetCurrentIrpStackLocation( IrpContext->OriginatingIrp );
FileObject = IrpSp->FileObject;
} else {
return;
}
NewBuffer = NULL;
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// If the Fcb isn't specified and the file reference is, then
// try to get the Fcb from the Fcb table.
//
if (!ARGUMENT_PRESENT( Fcb )
&& ARGUMENT_PRESENT( FileReference )) {
Key.FileReference = *FileReference;
NtfsAcquireFcbTable( IrpContext, IrpContext->Vcb );
Entry = RtlLookupElementGenericTable( &IrpContext->Vcb->FcbTable,
&Key );
NtfsReleaseFcbTable( IrpContext, IrpContext->Vcb );
if (Entry != NULL) {
Fcb = Entry->Fcb;
}
}
if (Irp == NULL ||
IoIsSystemThread( IrpContext->OriginatingIrp->Tail.Overlay.Thread )) {
Thread = NULL;
} else {
Thread = (PKTHREAD)IrpContext->OriginatingIrp->Tail.Overlay.Thread;
}
//
// If there is no Fcb and no file reference we use the name in the
// Vpb for the volume. If there is a file reference then assume
// the error occurred in a system file.
//
if (!ARGUMENT_PRESENT( Fcb )) {
if (!ARGUMENT_PRESENT( FileReference )) {
Name.MaximumLength = Name.Length = IrpContext->Vcb->Vpb->VolumeLabelLength;
Name.Buffer = (PWCHAR) IrpContext->Vcb->Vpb->VolumeLabel;
} else if (NtfsSegmentNumber( FileReference ) <= UPCASE_TABLE_NUMBER) {
Name = NtfsSystemFiles[NtfsSegmentNumber( FileReference )];
} else {
Name = NtfsSystemFiles[0];
}
//
// If the name has an Lcb, we contruct a name with a chain of Lcb's.
//
} else if (!IsListEmpty( &Fcb->LcbQueue )) {
BOOLEAN LeadingBackslash;
//
// Get the length of the list.
//
NameLength = NtfsLookupNameLengthViaLcb( Fcb, &LeadingBackslash );
//
// We now know the length of the name. Allocate and fill this buffer.
//
NewBuffer = NtfsAllocatePool(PagedPool, NameLength );
Name.MaximumLength = Name.Length = (USHORT) NameLength;
Name.Buffer = NewBuffer;
//
// Now insert the name.
//
NtfsFileNameViaLcb( Fcb, NewBuffer, NameLength, NameLength );
//
// Check if this is a system file.
//
} else if (NtfsSegmentNumber( &Fcb->FileReference ) < FIRST_USER_FILE_NUMBER) {
if (NtfsSegmentNumber( &Fcb->FileReference ) <= UPCASE_TABLE_NUMBER) {
Name = NtfsSystemFiles[NtfsSegmentNumber( &Fcb->FileReference )];
} else {
Name = NtfsSystemFiles[0];
}
//
// In this case we contruct a name out of the file objects in the
// Originating Irp. If there is no file object or file object buffer
// we generate an unknown file message.
//
} else if (FileObject == NULL
|| (IrpContext->MajorFunction == IRP_MJ_CREATE
&& BooleanFlagOn( IrpSp->Parameters.Create.Options, FILE_OPEN_BY_FILE_ID ))
|| (FileObject->FileName.Length == 0
&& (FileObject->RelatedFileObject == NULL
|| IrpContext->MajorFunction != IRP_MJ_CREATE))) {
Name = NtfsUnknownFile;
//
// If there is a valid name in the file object we use that.
//
} else if ((FileObject->FileName.MaximumLength != 0) &&
(FileObject->FileName.Length != 0) &&
(FileObject->FileName.Buffer[0] == L'\\')) {
Name = FileObject->FileName;
//
// We have to construct the name.
//
} else {
if ((FileObject->FileName.MaximumLength != 0) &&
(FileObject->FileName.Length != 0)) {
NameLength = FileObject->FileName.Length;
if (((PFILE_OBJECT) FileObject->RelatedFileObject)->FileName.Length != 2) {
NameLength += 2;
}
} else {
NameLength = 0;
}
NameLength += ((PFILE_OBJECT) FileObject->RelatedFileObject)->FileName.Length;
NewBuffer = NtfsAllocatePool(PagedPool, NameLength );
Name.MaximumLength = Name.Length = (USHORT) NameLength;
Name.Buffer = NewBuffer;
if (FileObject->FileName.Length != 0) {
NameLength -= FileObject->FileName.Length;
RtlCopyMemory( Add2Ptr( NewBuffer, NameLength ),
FileObject->FileName.Buffer,
FileObject->FileName.Length );
NameLength -= sizeof( WCHAR );
*((PWCHAR) Add2Ptr( NewBuffer, NameLength )) = L'\\';
}
if (NameLength != 0) {
FileObject = (PFILE_OBJECT) FileObject->RelatedFileObject;
RtlCopyMemory( NewBuffer,
FileObject->FileName.Buffer,
FileObject->FileName.Length );
}
}
//
// Now generate a popup.
//
IoRaiseInformationalHardError( Status, &Name, Thread );
} finally {
if (NewBuffer != NULL) {
NtfsFreePool( NewBuffer );
}
}
return;
}
PTOP_LEVEL_CONTEXT
NtfsSetTopLevelIrp (
IN PTOP_LEVEL_CONTEXT TopLevelContext,
IN BOOLEAN ForceTopLevel,
IN BOOLEAN SetTopLevel
)
/*++
Routine Description:
This routine is called to set up the top level context in the thread local
storage. Ntfs always puts its own context in this location and restores
the previous value on exit. This routine will determine if this request is
top level and top level ntfs. It will return a pointer to the top level ntfs
context stored in the thread local storage on return.
Arguments:
TopLevelContext - This is the local top level context for our caller.
ForceTopLevel - Always use the input top level context.
SetTopLevel - Only applies if the ForceTopLevel value is TRUE. Indicates
if we should make this look like the top level request.
Return Value:
PTOP_LEVEL_CONTEXT - Pointer to the top level ntfs context for this thread.
It may be the same as passed in by the caller. In that case the fields
will be initialized.
--*/
{
PTOP_LEVEL_CONTEXT CurrentTopLevelContext;
ULONG StackBottom;
ULONG StackTop;
BOOLEAN TopLevelRequest = TRUE;
BOOLEAN TopLevelNtfs = TRUE;
BOOLEAN ValidCurrentTopLevel = FALSE;
//
// Get the current value out of the thread local storage. If it is a zero
// value or not a pointer to a valid ntfs top level context or a valid
// Fsrtl value then we are the top level request.
//
CurrentTopLevelContext = NtfsGetTopLevelContext();
//
// Check if this is a valid Ntfs top level context.
//
IoGetStackLimits( &StackTop, &StackBottom);
if (((ULONG) CurrentTopLevelContext <= StackBottom - sizeof( TOP_LEVEL_CONTEXT )) &&
((ULONG) CurrentTopLevelContext >= StackTop) &&
!FlagOn( (ULONG) CurrentTopLevelContext, 0x3 ) &&
(CurrentTopLevelContext->Ntfs == 0x5346544e)) {
ValidCurrentTopLevel = TRUE;
}
//
// If we are to force this request to be top level then set the
// TopLevelRequest flag according to the SetTopLevel input.
//
if (ForceTopLevel) {
TopLevelRequest = SetTopLevel;
//
// If the value is NULL then we are top level everything.
//
} else if (CurrentTopLevelContext == NULL) {
NOTHING;
//
// If this has one of the Fsrtl magic numbers then we were called from
// either the fast io path or the mm paging io path.
//
} else if ((ULONG) CurrentTopLevelContext <= FSRTL_MAX_TOP_LEVEL_IRP_FLAG) {
TopLevelRequest = FALSE;
} else if (ValidCurrentTopLevel &&
!FlagOn( CurrentTopLevelContext->TopLevelIrpContext->Flags,
IRP_CONTEXT_FLAG_CALL_SELF )) {
TopLevelRequest = FALSE;
TopLevelNtfs = FALSE;
}
//
// If we are the top level ntfs then initialize the caller's structure
// and store it in the thread local storage.
//
if (TopLevelNtfs) {
TopLevelContext->Ntfs = 0x5346544e;
TopLevelContext->SavedTopLevelIrp = (PIRP) CurrentTopLevelContext;
TopLevelContext->TopLevelIrpContext = NULL;
TopLevelContext->TopLevelRequest = TopLevelRequest;
if (ValidCurrentTopLevel) {
TopLevelContext->VboBeingHotFixed = CurrentTopLevelContext->VboBeingHotFixed;
TopLevelContext->ScbBeingHotFixed = CurrentTopLevelContext->ScbBeingHotFixed;
TopLevelContext->ValidSavedTopLevel = TRUE;
TopLevelContext->OverflowReadThread = CurrentTopLevelContext->OverflowReadThread;
} else {
TopLevelContext->VboBeingHotFixed = 0;
TopLevelContext->ScbBeingHotFixed = NULL;
TopLevelContext->ValidSavedTopLevel = FALSE;
TopLevelContext->OverflowReadThread = FALSE;
}
IoSetTopLevelIrp( (PIRP) TopLevelContext );
return TopLevelContext;
}
return CurrentTopLevelContext;
}
#ifdef NTFS_CHECK_BITMAP
BOOLEAN NtfsForceBitmapBugcheck = FALSE;
BOOLEAN NtfsDisableBitmapCheck = FALSE;
VOID
NtfsBadBitmapCopy (
IN PIRP_CONTEXT IrpContext,
IN ULONG BadBit,
IN ULONG Length
)
{
if (!NtfsDisableBitmapCheck) {
DbgPrint("%s:%d %s\n",__FILE__,__LINE__,"Invalid bitmap");
DbgBreakPoint();
if (!NtfsDisableBitmapCheck && NtfsForceBitmapBugcheck) {
KeBugCheckEx( NTFS_FILE_SYSTEM, (ULONG) IrpContext, BadBit, Length, 0 );
}
}
return;
}
BOOLEAN
NtfsCheckBitmap (
IN PVCB Vcb,
IN ULONG Lcn,
IN ULONG Count,
IN BOOLEAN Set
)
{
ULONG BitmapPage;
ULONG LastBitmapPage;
ULONG BitOffset;
ULONG BitsThisPage;
BOOLEAN Valid = FALSE;
BitmapPage = Lcn / (PAGE_SIZE * 8);
LastBitmapPage = (Lcn + Count + (PAGE_SIZE * 8) - 1) / (PAGE_SIZE * 8);
BitOffset = Lcn & ((PAGE_SIZE * 8) - 1);
if (LastBitmapPage > Vcb->BitmapPages) {
return Valid;
}
do {
BitsThisPage = Count;
if (BitOffset + Count > (PAGE_SIZE * 8)) {
BitsThisPage = (PAGE_SIZE * 8) - BitOffset;
}
if (Set) {
Valid = RtlAreBitsSet( Vcb->BitmapCopy + BitmapPage,
BitOffset,
BitsThisPage );
} else {
Valid = RtlAreBitsClear( Vcb->BitmapCopy + BitmapPage,
BitOffset,
BitsThisPage );
}
BitOffset = 0;
Count -= BitsThisPage;
BitmapPage += 1;
} while (Valid && (BitmapPage < LastBitmapPage));
if (Count != 0) {
Valid = FALSE;
}
return Valid;
}
#endif
//
// Debugging support routines used for pool verification. Alas, this works only
// on checked X86.
//
#if DBG && i386 && defined (NTFSPOOLCHECK)
//
// Number of backtrace items retrieved on X86
#define BACKTRACE_DEPTH 8
typedef struct _BACKTRACE
{
ULONG State;
ULONG Pad;
PVOID Allocate[BACKTRACE_DEPTH];
PVOID Free[BACKTRACE_DEPTH];
} BACKTRACE, *PBACKTRACE;
#define STATE_ALLOCATED 'M'
#define STATE_LOOKASIDE 'J'
#define STATE_FREE 'Z'
//
// WARNING! The following depends on pool allocations being either
// 0 mod PAGE_SIZE (for large blocks)
// or 8 mod 0x20 (for all other requests)
//
#define PAGE_ALIGNED(pv) (((ULONG)(pv) & (PAGE_SIZE - 1)) == 0)
#define IsKernelPoolBlock(pv) (PAGE_ALIGNED(pv) || (((ULONG)(pv) % 0x20) == 8))
PVOID
NtfsDebugAllocatePoolWithTagNoRaise (
POOL_TYPE Pool,
ULONG Length,
ULONG Tag)
{
ULONG Ignore;
PBACKTRACE BackTrace =
ExAllocatePoolWithTag( Pool, Length + sizeof (BACKTRACE), Tag );
if (PAGE_ALIGNED(BackTrace))
{
return BackTrace;
}
RtlZeroMemory( BackTrace, sizeof (BACKTRACE) );
RtlCaptureStackBackTrace( 0, BACKTRACE_DEPTH, BackTrace->Allocate, &Ignore );
BackTrace->State = STATE_ALLOCATED;
return BackTrace + 1;
}
PVOID
NtfsDebugAllocatePoolWithTag (
POOL_TYPE Pool,
ULONG Length,
ULONG Tag)
{
ULONG Ignore;
PBACKTRACE BackTrace =
FsRtlAllocatePoolWithTag( Pool, Length + sizeof (BACKTRACE), Tag );
if (PAGE_ALIGNED(BackTrace))
{
return BackTrace;
}
RtlZeroMemory( BackTrace, sizeof (BACKTRACE) );
RtlCaptureStackBackTrace( 0, BACKTRACE_DEPTH, BackTrace->Allocate, &Ignore );
BackTrace->State = STATE_ALLOCATED;
return BackTrace + 1;
}
VOID
NtfsDebugFreePool (
PVOID pv)
{
if (IsKernelPoolBlock( pv ))
{
ExFreePool( pv );
}
else
{
ULONG Ignore;
PBACKTRACE BackTrace = (PBACKTRACE)pv - 1;
if (BackTrace->State != STATE_ALLOCATED)
{
DbgBreakPoint( );
}
RtlCaptureStackBackTrace( 0, BACKTRACE_DEPTH, BackTrace->Free, &Ignore );
BackTrace->State = STATE_FREE;
ExFreePool( BackTrace );
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink