From e611b132f9b8abe35b362e5870b74bce94a1e58e Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 16 May 2020 20:51:50 -0700 Subject: initial commit --- private/ntos/cntfs/ntfsdata.h | 604 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 604 insertions(+) create mode 100644 private/ntos/cntfs/ntfsdata.h (limited to 'private/ntos/cntfs/ntfsdata.h') diff --git a/private/ntos/cntfs/ntfsdata.h b/private/ntos/cntfs/ntfsdata.h new file mode 100644 index 000000000..d4acb2b5f --- /dev/null +++ b/private/ntos/cntfs/ntfsdata.h @@ -0,0 +1,604 @@ +/*++ + +Copyright (c) 1991 Microsoft Corporation + +Module Name: + + NtfsData.h + +Abstract: + + This module declares the global data used by the Ntfs file system. + +Author: + + Gary Kimura [GaryKi] 28-Dec-1989 + +Revision History: + +--*/ + +#ifndef _NTFSDATA_ +#define _NTFSDATA_ + +// +// The following are used to determine what level of protection to attach +// to system files and attributes. +// + +extern BOOLEAN NtfsProtectSystemFiles; +extern BOOLEAN NtfsProtectSystemAttributes; + +// +// Performance statistics +// + +extern ULONG NtfsMaxDelayedCloseCount; +extern ULONG NtfsMinDelayedCloseCount; + +extern ULONG NtfsCleanCheckpoints; +extern ULONG NtfsPostRequests; + +// +// The global fsd data record +// + +extern NTFS_DATA NtfsData; + +// +// Semaphore to synchronize creation of stream files. +// + +extern FAST_MUTEX StreamFileCreationFastMutex; + +// +// A mutex and queue of NTFS MCBS that will be freed +// if we reach over a certain threshold +// + +extern FAST_MUTEX NtfsMcbFastMutex; +extern LIST_ENTRY NtfsMcbLruQueue; + +extern ULONG NtfsMcbHighWaterMark; +extern ULONG NtfsMcbLowWaterMark; +extern ULONG NtfsMcbCurrentLevel; + +extern BOOLEAN NtfsMcbCleanupInProgress; +extern WORK_QUEUE_ITEM NtfsMcbWorkItem; + +// +// The following are global large integer constants used throughout ntfs +// We declare the actual name using Ntfs prefixes to avoid any linking +// conflicts but internally in the file system we'll use smaller Li prefixes +// to denote the values. +// + +extern LARGE_INTEGER NtfsLarge0; +extern LARGE_INTEGER NtfsLarge1; + +extern LONGLONG NtfsLastAccess; + +#define Li0 (NtfsLarge0) +#define Li1 (NtfsLarge1) + +#define MAXULONGLONG (0xffffffffffffffff) +#define UNUSED_LCN ((LONGLONG)(-1)) + +// +// The following fields are used to allocate nonpaged structures +// using a lookaside list, and other fixed sized structures from a +// small cache. +// + +extern NPAGED_LOOKASIDE_LIST NtfsFileLockLookasideList; +extern NPAGED_LOOKASIDE_LIST NtfsIoContextLookasideList; +extern NPAGED_LOOKASIDE_LIST NtfsIrpContextLookasideList; +extern NPAGED_LOOKASIDE_LIST NtfsKeventLookasideList; +extern NPAGED_LOOKASIDE_LIST NtfsScbNonpagedLookasideList; +extern NPAGED_LOOKASIDE_LIST NtfsScbSnapshotLookasideList; + +extern PAGED_LOOKASIDE_LIST NtfsCcbLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsCcbDataLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsDeallocatedRecordsLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsFcbDataLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsFcbIndexLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsIndexContextLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsLcbLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsNukemLookasideList; +extern PAGED_LOOKASIDE_LIST NtfsScbDataLookasideList; + +// +// This is the string for the name of the index allocation attributes. +// + +extern UNICODE_STRING NtfsFileNameIndex; +extern WCHAR NtfsFileNameIndexName[]; + +// +// This is the string for the attribute code for index allocation. +// $INDEX_ALLOCATION. +// + +extern UNICODE_STRING NtfsIndexAllocation; + +// +// This is the string for the data attribute, $DATA. +// + +extern UNICODE_STRING NtfsDataString; + +// +// This strings are used for informational popups. +// + +extern UNICODE_STRING NtfsSystemFiles[]; + +// +// This is the '.' string to use to lookup the parent entry. +// + +extern UNICODE_STRING NtfsRootIndexString; + +// +// This is the empty string. This can be used to pass a string with +// no length. +// + +extern UNICODE_STRING NtfsEmptyString; + +// +// The following file references are used to identify system files. +// + +extern FILE_REFERENCE MftFileReference; +extern FILE_REFERENCE Mft2FileReference; +extern FILE_REFERENCE LogFileReference; +extern FILE_REFERENCE VolumeFileReference; +extern FILE_REFERENCE RootIndexFileReference; +extern FILE_REFERENCE BitmapFileReference; +extern FILE_REFERENCE FirstUserFileReference; +extern FILE_REFERENCE BootFileReference; + +// +// The global structure used to contain our fast I/O callbacks +// + +extern FAST_IO_DISPATCH NtfsFastIoDispatch; + +extern UCHAR BaadSignature[4]; +extern UCHAR IndexSignature[4]; +extern UCHAR FileSignature[4]; +extern UCHAR HoleSignature[4]; +extern UCHAR ChkdskSignature[4]; + +// +// Large Reserved Buffer Context +// + +extern ULONG NtfsReservedInUse; +extern PVOID NtfsReserved1; +extern PVOID NtfsReserved2; +extern ULONG NtfsReserved2Count; +extern PVOID NtfsReserved3; +extern PVOID NtfsReserved1Thread; +extern PVOID NtfsReserved2Thread; +extern PVOID NtfsReserved3Thread; +extern PFCB NtfsReserved12Fcb; +extern PFCB NtfsReserved3Fcb; +extern PVOID NtfsReservedBufferThread; +extern BOOLEAN NtfsBufferAllocationFailure; +extern FAST_MUTEX NtfsReservedBufferMutex; +extern ERESOURCE NtfsReservedBufferResource; +extern LARGE_INTEGER NtfsShortDelay; + +#ifdef _CAIRO_ +extern FAST_MUTEX NtfsScavengerLock; +extern PIRP_CONTEXT NtfsScavengerWorkList; +extern BOOLEAN NtfsScavengerRunning; +#endif // _CAIRO_ + +#define LARGE_BUFFER_SIZE (0x10000) + +// +// The following is the number of minutes for the last access increment +// + +#define LAST_ACCESS_INCREMENT_MINUTES (60) + +// +// Read ahead amount used for normal data files +// + +#define READ_AHEAD_GRANULARITY (0x10000) + +// +// Define maximum number of parallel Reads or Writes that will be generated +// per one request. +// + +#define NTFS_MAX_PARALLEL_IOS ((ULONG)8) + +// +// Define a symbol which states the maximum number of runs that will be +// added or deleted in one transaction per attribute. Note that the per-run +// cost of deleting a run is 8-bytes in the BITMAP_RANGE, an average of +// four bytes in the mapping array, and 16 bytes in the LCN_RANGE - for a total +// of 28-bytes. Allocations do not log an LCN_RANGE, so their per-run cost is +// 12 bytes. The worst problem is deleteing large fragmented files, where you +// must add the cost of the rest of the log records for deleting all the attributes. +// + +#define MAXIMUM_RUNS_AT_ONCE (128) + + + +// +// Turn on pseudo-asserts if NTFS_FREE_ASSERTS is defined. +// + +#if (!DBG && defined( NTFS_FREE_ASSERTS )) || defined( NTFSDBG ) +#undef ASSERT +#undef ASSERTMSG +#define ASSERT(exp) \ + ((exp) ? TRUE : \ + (DbgPrint( "%s:%d %s\n",__FILE__,__LINE__,#exp ), \ + DbgBreakPoint(), \ + TRUE)) +#define ASSERTMSG(msg,exp) \ + ((exp) ? TRUE : \ + (DbgPrint( "%s:%d %s %s\n",__FILE__,__LINE__,msg,#exp ), \ + DbgBreakPoint(), \ + TRUE)) +#endif + +// +// The following debug macros are used in ntfs and defined in this module +// +// DebugTrace( Indent, Level, (DbgPrint list) ); +// +// DebugUnwind( NonquotedString ); +// +// DebugDoit( Statement ); +// +// DbgDoit( Statement ); +// +// The following assertion macros ensure that the indicated structure +// is valid +// +// ASSERT_VCB( IN PVCB Vcb ); +// ASSERT_OPTIONAL_VCB( IN PVCB Vcb OPTIONAL ); +// +// ASSERT_FCB( IN PFCB Fcb ); +// ASSERT_OPTIONAL_FCB( IN PFCB Fcb OPTIONAL ); +// +// ASSERT_SCB( IN PSCB Scb ); +// ASSERT_OPTIONAL_SCB( IN PSCB Scb OPTIONAL ); +// +// ASSERT_CCB( IN PSCB Ccb ); +// ASSERT_OPTIONAL_CCB( IN PSCB Ccb OPTIONAL ); +// +// ASSERT_LCB( IN PLCB Lcb ); +// ASSERT_OPTIONAL_LCB( IN PLCB Lcb OPTIONAL ); +// +// ASSERT_PREFIX_ENTRY( IN PPREFIX_ENTRY PrefixEntry ); +// ASSERT_OPTIONAL_PREFIX_ENTRY( IN PPREFIX_ENTRY PrefixEntry OPTIONAL ); +// +// ASSERT_IRP_CONTEXT( IN PIRP_CONTEXT IrpContext ); +// ASSERT_OPTIONAL_IRP_CONTEXT( IN PIRP_CONTEXT IrpContext OPTIONAL ); +// +// ASSERT_IRP( IN PIRP Irp ); +// ASSERT_OPTIONAL_IRP( IN PIRP Irp OPTIONAL ); +// +// ASSERT_FILE_OBJECT( IN PFILE_OBJECT FileObject ); +// ASSERT_OPTIONAL_FILE_OBJECT( IN PFILE_OBJECT FileObject OPTIONAL ); +// +// The following macros are used to check the current thread owns +// the indicated resource +// +// ASSERT_EXCLUSIVE_RESOURCE( IN PERESOURCE Resource ); +// +// ASSERT_SHARED_RESOURCE( IN PERESOURCE Resource ); +// +// ASSERT_RESOURCE_NOT_MINE( IN PERESOURCE Resource ); +// +// The following macros are used to check whether the current thread +// owns the resoures in the given structures. +// +// ASSERT_EXCLUSIVE_FCB( IN PFCB Fcb ); +// +// ASSERT_SHARED_FCB( IN PFCB Fcb ); +// +// ASSERT_EXCLUSIVE_SCB( IN PSCB Scb ); +// +// ASSERT_SHARED_SCB( IN PSCB Scb ); +// +// The following macro is used to check that we are not trying to +// manipulate an lcn that does not exist +// +// ASSERT_LCN_RANGE( IN PVCB Vcb, IN LCN Lcn ); +// + +#ifdef NTFSDBG + +extern LONG NtfsDebugTraceLevel; +extern LONG NtfsDebugTraceIndent; +extern LONG NtfsFailCheck; + +#define DEBUG_TRACE_ERROR (0x00000001) +#define DEBUG_TRACE_QUOTA (0x00000002) +#define DEBUG_TRACE_CATCH_EXCEPTIONS (0x00000004) +#define DEBUG_TRACE_UNWIND (0x00000008) + +#define DEBUG_TRACE_CLEANUP (0x00000010) +#define DEBUG_TRACE_CLOSE (0x00000020) +#define DEBUG_TRACE_CREATE (0x00000040) +#define DEBUG_TRACE_DIRCTRL (0x00000080) + +#define DEBUG_TRACE_EA (0x00000100) +#define DEBUG_TRACE_FILEINFO (0x00000200) +#define DEBUG_TRACE_SEINFO (0x00000200) // shared with FileInfo +#define DEBUG_TRACE_FSCTRL (0x00000400) +#define DEBUG_TRACE_SHUTDOWN (0x00000400) // shared with FsCtrl +#define DEBUG_TRACE_LOCKCTRL (0x00000800) + +#define DEBUG_TRACE_READ (0x00001000) +#define DEBUG_TRACE_VOLINFO (0x00002000) +#define DEBUG_TRACE_WRITE (0x00004000) +#define DEBUG_TRACE_FLUSH (0x00008000) + +#define DEBUG_TRACE_DEVCTRL (0x00010000) +#define DEBUG_TRACE_LOGSUP (0x00020000) +#define DEBUG_TRACE_BITMPSUP (0x00040000) +#define DEBUG_TRACE_ALLOCSUP (0x00080000) + +#define DEBUG_TRACE_MFTSUP (0x00100000) +#define DEBUG_TRACE_INDEXSUP (0x00200000) +#define DEBUG_TRACE_ATTRSUP (0x00400000) +#define DEBUG_TRACE_FILOBSUP (0x00800000) + +#define DEBUG_TRACE_NAMESUP (0x01000000) +#define DEBUG_TRACE_SECURSUP (0x01000000) // shared with NameSup +#define DEBUG_TRACE_VERFYSUP (0x02000000) +#define DEBUG_TRACE_CACHESUP (0x04000000) +#define DEBUG_TRACE_PREFXSUP (0x08000000) + +#define DEBUG_TRACE_DEVIOSUP (0x10000000) +#define DEBUG_TRACE_STRUCSUP (0x20000000) +#define DEBUG_TRACE_FSP_DISPATCHER (0x40000000) +#define DEBUG_TRACE_ACLINDEX (0x80000000) + +#define DebugTrace(INDENT,LEVEL,M) { \ + LONG _i; \ + if (((LEVEL) == 0) || \ + (NtfsDebugTraceLevel & (LEVEL)) != 0) { \ + _i = (ULONG)PsGetCurrentThread(); \ + DbgPrint("%08lx:",_i); \ + if ((INDENT) < 0) { \ + NtfsDebugTraceIndent += (INDENT); \ + } \ + if (NtfsDebugTraceIndent < 0) { \ + NtfsDebugTraceIndent = 0; \ + } \ + for (_i = 0; _i < NtfsDebugTraceIndent; _i += 1) { \ + DbgPrint(" "); \ + } \ + DbgPrint M; \ + if ((INDENT) > 0) { \ + NtfsDebugTraceIndent += (INDENT); \ + } \ + } \ +} + +#define DebugUnwind(X) { \ + if (AbnormalTermination()) { \ + DebugTrace( 0, DEBUG_TRACE_UNWIND, (#X ", Abnormal termination.\n") ); \ + } \ +} + +#define DebugDoit(X) X + +// +// Perform log-file-full testing. +// + +#define FailCheck(I,S) { \ + PIRP_CONTEXT FailTopContext = (I)->TopLevelIrpContext; \ + if (FailTopContext->NextFailCount != 0) { \ + if (--FailTopContext->CurrentFailCount == 0) { \ + FailTopContext->NextFailCount++; \ + FailTopContext->CurrentFailCount = FailTopContext->NextFailCount; \ + ExRaiseStatus( S ); \ + } \ + } \ +} + +#define LogFileFullFailCheck(I) FailCheck( I, STATUS_LOG_FILE_FULL ) +// +// The following variables are used to keep track of the total amount +// of requests processed by the file system, and the number of requests +// that end up being processed by the Fsp thread. The first variable +// is incremented whenever an Irp context is created (which is always +// at the start of an Fsd entry point) and the second is incremented +// by read request. +// + +extern ULONG NtfsFsdEntryCount; +extern ULONG NtfsFspEntryCount; +extern ULONG NtfsIoCallDriverCount; + +#else + +#define DebugTrace(INDENT,LEVEL,M) {NOTHING;} +#define DebugUnwind(X) {NOTHING;} +#define DebugDoit(X) NOTHING + +#define FailCheck(I,S) +#define LogFileFullFailCheck(I) + +#endif // NTFSDBG + +// +// The following macro is for all people who compile with the DBG switch +// set, not just NTFSDBG users +// + +#ifdef NTFSDBG + +#define DbgDoit(X) {X;} + +#define ASSERT_VCB(V) { \ + ASSERT((NodeType(V) == NTFS_NTC_VCB)); \ +} + +#define ASSERT_OPTIONAL_VCB(V) { \ + ASSERT(((V) == NULL) || \ + (NodeType(V) == NTFS_NTC_VCB)); \ +} + +#define ASSERT_FCB(F) { \ + ASSERT((NodeType(F) == NTFS_NTC_FCB)); \ +} + +#define ASSERT_OPTIONAL_FCB(F) { \ + ASSERT(((F) == NULL) || \ + (NodeType(F) == NTFS_NTC_FCB)); \ +} + +#define ASSERT_SCB(S) { \ + ASSERT((NodeType(S) == NTFS_NTC_SCB_DATA) || \ + (NodeType(S) == NTFS_NTC_SCB_MFT) || \ + (NodeType(S) == NTFS_NTC_SCB_INDEX) || \ + (NodeType(S) == NTFS_NTC_SCB_ROOT_INDEX)); \ +} + +#define ASSERT_OPTIONAL_SCB(S) { \ + ASSERT(((S) == NULL) || \ + (NodeType(S) == NTFS_NTC_SCB_DATA) || \ + (NodeType(S) == NTFS_NTC_SCB_MFT) || \ + (NodeType(S) == NTFS_NTC_SCB_INDEX) || \ + (NodeType(S) == NTFS_NTC_SCB_ROOT_INDEX)); \ +} + +#define ASSERT_CCB(C) { \ + ASSERT((NodeType(C) == NTFS_NTC_CCB_DATA) || \ + (NodeType(C) == NTFS_NTC_CCB_INDEX)); \ +} + +#define ASSERT_OPTIONAL_CCB(C) { \ + ASSERT(((C) == NULL) || \ + ((NodeType(C) == NTFS_NTC_CCB_DATA) || \ + (NodeType(C) == NTFS_NTC_CCB_INDEX))); \ +} + +#define ASSERT_LCB(L) { \ + ASSERT((NodeType(L) == NTFS_NTC_LCB)); \ +} + +#define ASSERT_OPTIONAL_LCB(L) { \ + ASSERT(((L) == NULL) || \ + (NodeType(L) == NTFS_NTC_LCB)); \ +} + +#define ASSERT_PREFIX_ENTRY(P) { \ + ASSERT((NodeType(P) == NTFS_NTC_PREFIX_ENTRY)); \ +} + +#define ASSERT_OPTIONAL_PREFIX_ENTRY(P) { \ + ASSERT(((P) == NULL) || \ + (NodeType(P) == NTFS_NTC_PREFIX_ENTRY)); \ +} + +#define ASSERT_IRP_CONTEXT(I) { \ + ASSERT((NodeType(I) == NTFS_NTC_IRP_CONTEXT)); \ +} + +#define ASSERT_OPTIONAL_IRP_CONTEXT(I) { \ + ASSERT(((I) == NULL) || \ + (NodeType(I) == NTFS_NTC_IRP_CONTEXT)); \ +} + +#define ASSERT_IRP(I) { \ + ASSERT(((I)->Type == IO_TYPE_IRP)); \ +} + +#define ASSERT_OPTIONAL_IRP(I) { \ + ASSERT(((I) == NULL) || \ + ((I)->Type == IO_TYPE_IRP)); \ +} + +#define ASSERT_FILE_OBJECT(F) { \ + ASSERT(((F)->Type == IO_TYPE_FILE)); \ +} + +#define ASSERT_OPTIONAL_FILE_OBJECT(F) { \ + ASSERT(((F) == NULL) || \ + ((F)->Type == IO_TYPE_FILE)); \ +} + +#define ASSERT_EXCLUSIVE_RESOURCE(R) { \ + ASSERTMSG("ASSERT_EXCLUSIVE_RESOURCE ", ExIsResourceAcquiredExclusiveLite(R)); \ +} + +#define ASSERT_SHARED_RESOURCE(R) \ + ASSERTMSG( "ASSERT_RESOURCE_NOT_MINE ", ExIsResourceAcquiredSharedLite(R)); + +#define ASSERT_RESOURCE_NOT_MINE(R) \ + ASSERTMSG( "ASSERT_RESOURCE_NOT_MINE ", !ExIsResourceAcquiredSharedLite(R)); + +#define ASSERT_EXCLUSIVE_FCB(F) { \ + if (NtfsSegmentNumber( &(F)->FileReference ) \ + >= FIRST_USER_FILE_NUMBER) { \ + ASSERT_EXCLUSIVE_RESOURCE(F->Resource); \ + } \ +} \ + +#define ASSERT_SHARED_FCB(F) { \ + if (NtfsSegmentNumber( &(F)->FileReference ) \ + >= FIRST_USER_FILE_NUMBER) { \ + ASSERT_SHARED_RESOURCE(F->Resource); \ + } \ +} \ + +#define ASSERT_EXCLUSIVE_SCB(S) ASSERT_EXCLUSIVE_FCB(S->Fcb) + +#define ASSERT_SHARED_SCB(S) ASSERT_SHARED_FCB(S->Fcb) + +#define ASSERT_LCN_RANGE_CHECKING(V,L) { \ + ASSERTMSG("ASSERT_LCN_RANGE_CHECKING ", \ + ((V)->TotalClusters == 0) || ((L) <= (V)->TotalClusters)); \ +} + +#else + +#define DbgDoit(X) {NOTHING;} +#define ASSERT_VCB(V) {DBG_UNREFERENCED_PARAMETER(V);} +#define ASSERT_OPTIONAL_VCB(V) {DBG_UNREFERENCED_PARAMETER(V);} +#define ASSERT_FCB(F) {DBG_UNREFERENCED_PARAMETER(F);} +#define ASSERT_OPTIONAL_FCB(F) {DBG_UNREFERENCED_PARAMETER(F);} +#define ASSERT_SCB(S) {DBG_UNREFERENCED_PARAMETER(S);} +#define ASSERT_OPTIONAL_SCB(S) {DBG_UNREFERENCED_PARAMETER(S);} +#define ASSERT_CCB(C) {DBG_UNREFERENCED_PARAMETER(C);} +#define ASSERT_OPTIONAL_CCB(C) {DBG_UNREFERENCED_PARAMETER(C);} +#define ASSERT_LCB(L) {DBG_UNREFERENCED_PARAMETER(L);} +#define ASSERT_OPTIONAL_LCB(L) {DBG_UNREFERENCED_PARAMETER(L);} +#define ASSERT_PREFIX_ENTRY(P) {DBG_UNREFERENCED_PARAMETER(P);} +#define ASSERT_OPTIONAL_PREFIX_ENTRY(P) {DBG_UNREFERENCED_PARAMETER(P);} +#define ASSERT_IRP_CONTEXT(I) {DBG_UNREFERENCED_PARAMETER(I);} +#define ASSERT_OPTIONAL_IRP_CONTEXT(I) {DBG_UNREFERENCED_PARAMETER(I);} +#define ASSERT_IRP(I) {DBG_UNREFERENCED_PARAMETER(I);} +#define ASSERT_OPTIONAL_IRP(I) {DBG_UNREFERENCED_PARAMETER(I);} +#define ASSERT_FILE_OBJECT(F) {DBG_UNREFERENCED_PARAMETER(F);} +#define ASSERT_OPTIONAL_FILE_OBJECT(F) {DBG_UNREFERENCED_PARAMETER(F);} +#define ASSERT_EXCLUSIVE_RESOURCE(R) {NOTHING;} +#define ASSERT_SHARED_RESOURCE(R) {NOTHING;} +#define ASSERT_RESOURCE_NOT_MINE(R) {NOTHING;} +#define ASSERT_EXCLUSIVE_FCB(F) {NOTHING;} +#define ASSERT_SHARED_FCB(F) {NOTHING;} +#define ASSERT_EXCLUSIVE_SCB(S) {NOTHING;} +#define ASSERT_SHARED_SCB(S) {NOTHING;} +#define ASSERT_LCN_RANGE_CHECKING(V,L) {NOTHING;} + +#endif // DBG + +#endif // _NTFSDATA_ + -- cgit v1.2.3