This graph shows which files directly or indirectly include this file:

Classes
struct	_REAL_NOTIFY_SYNC

struct	_NOTIFY_CHANGE

struct	_INT_MAPPING

Macros
#define	_FSRTL_DEBUG_ 0x00

#define	FSRTL_FASTIO_DEBUG 0x01

#define	FSRTL_OPLOCK_DEBUG 0x02

#define	FSRTL_TUNNEL_DEBUG 0x04

#define	FSRTL_MCB_DEBUG 0x08

#define	FSRTL_NAME_DEBUG 0x10

#define	FSRTL_NOTIFY_DEBUG 0x20

#define	FSRTL_FILELOCK_DEBUG 0x40

#define	FSRTL_UNC_DEBUG 0x80

#define	FSRTL_FILTER_DEBUG 0x100

#define	FSRTL_CONTEXT_DEBUG 0x200

#define	FSTRACE(x, ...) DPRINT(__VA_ARGS__)

#define	FSRTL_MAX_RESOURCES 16

#define	MAXIMUM_PAIR_COUNT 15

#define	WATCH_TREE 0x01

#define	NOTIFY_IMMEDIATELY 0x02

#define	CLEANUP_IN_PROCESS 0x04

#define	NOTIFY_LATER 0x08

#define	WATCH_ROOT 0x10

#define	DELETE_IN_PROCESS 0x20

Typedefs
typedef struct _REAL_NOTIFY_SYNC	REAL_NOTIFY_SYNC

typedef struct _REAL_NOTIFY_SYNC *	PREAL_NOTIFY_SYNC

typedef struct _NOTIFY_CHANGE	NOTIFY_CHANGE

typedef struct _NOTIFY_CHANGE *	PNOTIFY_CHANGE

typedef struct _INT_MAPPING	INT_MAPPING

typedef struct _INT_MAPPING *	PINT_MAPPING

Functions
VOID NTAPI	FsRtlInitializeLargeMcbs (VOID)

VOID NTAPI	FsRtlInitializeTunnels (VOID)

VOID NTAPI	FsRtlPTeardownPerFileObjectContexts (IN PFILE_OBJECT FileObject)

BOOLEAN NTAPI	FsRtlInitSystem (VOID)

NTSTATUS NTAPI	FsRtlAcquireToCreateMappedSection (_In_ PFILE_OBJECT FileObject, _In_ ULONG SectionPageProtection)

VOID NTAPI	FsRtlReleaseFileForCcFlush (IN PFILE_OBJECT FileObject)

NTSTATUS NTAPI	FsRtlAcquireFileForCcFlushEx (IN PFILE_OBJECT FileObject)

_Check_return_ NTSTATUS NTAPI	FsRtlAcquireFileForModWriteEx (_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER EndingOffset, _Outptr_result_maybenull_ PERESOURCE *ResourceToRelease)
	Lock a file object before flushing pages to disk. To be called by the Modified Page Writer (MPW)

VOID NTAPI	FsRtlReleaseFileForModWrite (IN PFILE_OBJECT FileObject, IN PERESOURCE ResourceToRelease)

Variables
PERESOURCE	FsRtlPagingIoResources

PAGED_LOOKASIDE_LIST	FsRtlFileLockLookasideList

Macro Definition Documentation

◆ _FSRTL_DEBUG_

#define _FSRTL_DEBUG_ 0x00

Definition at line 12 of file fsrtl.h.

◆ CLEANUP_IN_PROCESS

#define CLEANUP_IN_PROCESS 0x04

Definition at line 57 of file fsrtl.h.

◆ DELETE_IN_PROCESS

#define DELETE_IN_PROCESS 0x20

Definition at line 60 of file fsrtl.h.

◆ FSRTL_CONTEXT_DEBUG

#define FSRTL_CONTEXT_DEBUG 0x200

Definition at line 26 of file fsrtl.h.

◆ FSRTL_FASTIO_DEBUG

#define FSRTL_FASTIO_DEBUG 0x01

Definition at line 17 of file fsrtl.h.

◆ FSRTL_FILELOCK_DEBUG

#define FSRTL_FILELOCK_DEBUG 0x40

Definition at line 23 of file fsrtl.h.

◆ FSRTL_FILTER_DEBUG

#define FSRTL_FILTER_DEBUG 0x100

Definition at line 25 of file fsrtl.h.

◆ FSRTL_MAX_RESOURCES

#define FSRTL_MAX_RESOURCES 16

Definition at line 45 of file fsrtl.h.

◆ FSRTL_MCB_DEBUG

#define FSRTL_MCB_DEBUG 0x08

Definition at line 20 of file fsrtl.h.

◆ FSRTL_NAME_DEBUG

#define FSRTL_NAME_DEBUG 0x10

Definition at line 21 of file fsrtl.h.

◆ FSRTL_NOTIFY_DEBUG

#define FSRTL_NOTIFY_DEBUG 0x20

Definition at line 22 of file fsrtl.h.

◆ FSRTL_OPLOCK_DEBUG

#define FSRTL_OPLOCK_DEBUG 0x02

Definition at line 18 of file fsrtl.h.

◆ FSRTL_TUNNEL_DEBUG

#define FSRTL_TUNNEL_DEBUG 0x04

Definition at line 19 of file fsrtl.h.

◆ FSRTL_UNC_DEBUG

#define FSRTL_UNC_DEBUG 0x80

Definition at line 24 of file fsrtl.h.

◆ FSTRACE

#define FSTRACE	(	x,
		...
	)	DPRINT(__VA_ARGS__)

Definition at line 39 of file fsrtl.h.

◆ MAXIMUM_PAIR_COUNT

#define MAXIMUM_PAIR_COUNT 15

Definition at line 50 of file fsrtl.h.

◆ NOTIFY_IMMEDIATELY

#define NOTIFY_IMMEDIATELY 0x02

Definition at line 56 of file fsrtl.h.

◆ NOTIFY_LATER

#define NOTIFY_LATER 0x08

Definition at line 58 of file fsrtl.h.

◆ WATCH_ROOT

#define WATCH_ROOT 0x10

Definition at line 59 of file fsrtl.h.

◆ WATCH_TREE

#define WATCH_TREE 0x01

Definition at line 55 of file fsrtl.h.

Typedef Documentation

◆ INT_MAPPING

typedef struct _INT_MAPPING INT_MAPPING

◆ NOTIFY_CHANGE

typedef struct _NOTIFY_CHANGE NOTIFY_CHANGE

◆ PINT_MAPPING

typedef struct _INT_MAPPING * PINT_MAPPING

◆ PNOTIFY_CHANGE

typedef struct _NOTIFY_CHANGE * PNOTIFY_CHANGE

◆ PREAL_NOTIFY_SYNC

typedef struct _REAL_NOTIFY_SYNC * PREAL_NOTIFY_SYNC

◆ REAL_NOTIFY_SYNC

typedef struct _REAL_NOTIFY_SYNC REAL_NOTIFY_SYNC

Function Documentation

◆ FsRtlAcquireFileForCcFlushEx()

NTSTATUS NTAPI FsRtlAcquireFileForCcFlushEx ( IN PFILE_OBJECT FileObject )

Definition at line 1692 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    NTSTATUS Status;
 
    /* Get the Base File System (Volume) and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Get master FsRtl lock */
    FsRtlEnterFileSystem();
 
    /* Check if Fast Calls are supported, and check AcquireForCcFlush */
    if (FastDispatch &&
        FastDispatch->AcquireForCcFlush)
    {
        /* Call the AcquireForCcFlush FastIo handler */
        Status = FastDispatch->AcquireForCcFlush(FileObject, BaseDeviceObject);
 
        /* Return either success or inability to wait.
           In case of other failure - fall through */
        if (NT_SUCCESS(Status))
            return Status;
 
        if (Status == STATUS_CANT_WAIT)
        {
            DPRINT1("STATUS_CANT_WAIT\n");
            FsRtlExitFileSystem();
            return Status;
        }
    }
 
    /* No FastIo handler (or it failed). Acquire Main resource */
    if (FcbHeader->Resource)
    {
        /* Acquire it - either shared if it's already acquired
            or exclusively if we are the first */
        if (ExIsResourceAcquiredSharedLite(FcbHeader->Resource))
            ExAcquireResourceSharedLite(FcbHeader->Resource, TRUE);
        else
            ExAcquireResourceExclusiveLite(FcbHeader->Resource, TRUE);
    }
 
    /* Also acquire its PagingIO resource */
    if (FcbHeader->PagingIoResource)
        ExAcquireResourceSharedLite(FcbHeader->PagingIoResource, TRUE);
 
    return STATUS_SUCCESS;
}

Referenced by CcRosFlushVacb(), and FsRtlAcquireFileForCcFlush().

◆ FsRtlAcquireFileForModWriteEx()

_Check_return_ NTSTATUS NTAPI FsRtlAcquireFileForModWriteEx	(	_In_ PFILE_OBJECT	FileObject,
		_In_ PLARGE_INTEGER	EndingOffset,
		_Outptr_result_maybenull_ PERESOURCE *	ResourceToRelease
	)

Lock a file object before flushing pages to disk. To be called by the Modified Page Writer (MPW)

Parameters

FileObject	- The file object to lock
EndingOffset	- The end offset of the write to be done
ResourceToRelease	- Pointer receiving the resource to release after the write

Returns: Relevant NTSTATUS value

Definition at line 1852 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    PERESOURCE ResourceToAcquire = NULL;
    BOOLEAN Exclusive;
    BOOLEAN Result;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Get Device Object and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported, and check AcquireForModWrite */
    if (FastDispatch &&
        FastDispatch->AcquireForModWrite)
    {
        /* Call the AcquireForModWrite FastIo handler */
        Status = FastDispatch->AcquireForModWrite(FileObject,
                                                  EndingOffset,
                                                  ResourceToRelease,
                                                  BaseDeviceObject);
 
        /* Return either success or inability to wait.
           In case of other failure - fall through */
        if (Status == STATUS_SUCCESS ||
            Status == STATUS_CANT_WAIT)
        {
            return Status;
        }
    }
 
    /* Check what and how we should acquire */
    Exclusive = FsRtlpGetResourceForModWrite(FcbHeader, EndingOffset, &ResourceToAcquire);
 
    /* Acquire the resource and loop until we're sure we got this right. */
    while (TRUE)
    {
        BOOLEAN OldExclusive;
        PERESOURCE OldResourceToAcquire;
 
        if (ResourceToAcquire == NULL)
        {
            /* 
             * There's nothing to acquire, we can simply return success
             */
 
            break;
        }
 
        if (Exclusive)
        {
            Result = ExAcquireResourceExclusiveLite(ResourceToAcquire, FALSE);
        }
        else
        {
            Result = ExAcquireSharedWaitForExclusive(ResourceToAcquire, FALSE);
        }
 
        if (!Result)
        {
            return STATUS_CANT_WAIT;
        }
 
        /* Does this still hold true? */
        OldExclusive = Exclusive;
        OldResourceToAcquire = ResourceToAcquire;
        Exclusive = FsRtlpGetResourceForModWrite(FcbHeader, EndingOffset, &ResourceToAcquire);
 
        if ((OldExclusive == Exclusive) && (OldResourceToAcquire == ResourceToAcquire))
        {
            /* We're good */
            break;
        }
 
        /* Can we fix this situation? */
        if ((OldResourceToAcquire == ResourceToAcquire) && !Exclusive)
        {
            /* We can easily do so */
            ExConvertExclusiveToSharedLite(ResourceToAcquire);
            break;
        }
 
        /* Things have changed since we acquired the lock. Start again */
        ExReleaseResourceLite(OldResourceToAcquire);
    }
 
    /* If we're here, this means that we succeeded */
    *ResourceToRelease = ResourceToAcquire;
    return STATUS_SUCCESS;
}

◆ FsRtlAcquireToCreateMappedSection()

NTSTATUS NTAPI FsRtlAcquireToCreateMappedSection	(	_In_ PFILE_OBJECT	FileObject,
		_In_ ULONG	SectionPageProtection
	)

Definition at line 1647 of file fastio.c.

{
    PAGED_CODE();
 
    return FsRtlAcquireFileExclusiveCommon(FileObject, SyncTypeCreateSection, SectionPageProtection);
}

Referenced by MmCreateArm3Section(), and MmCreateSection().

◆ FsRtlInitializeLargeMcbs()

VOID NTAPI FsRtlInitializeLargeMcbs ( VOID )

Definition at line 479 of file largemcb.c.

{
    /* Initialize the list for the MCB */
    ExInitializePagedLookasideList(&FsRtlFirstMappingLookasideList,
                                   NULL,
                                   NULL,
                                   POOL_RAISE_IF_ALLOCATION_FAILURE,
                                   sizeof(LARGE_MCB_MAPPING),
                                   IFS_POOL_TAG,
                                   0); /* FIXME: Should be 4 */
 
    /* Initialize the list for the guarded mutex */
    ExInitializeNPagedLookasideList(&FsRtlFastMutexLookasideList,
                                    NULL,
                                    NULL,
                                    POOL_RAISE_IF_ALLOCATION_FAILURE,
                                    sizeof(KGUARDED_MUTEX),
                                    IFS_POOL_TAG,
                                    0); /* FIXME: Should be 32 */
}

Referenced by FsRtlInitSystem().

◆ FsRtlInitializeTunnels()

VOID NTAPI FsRtlInitializeTunnels ( VOID )

Definition at line 200 of file tunnel.c.

{
    ULONG TunnelEntries;
    UNICODE_STRING MaximumTunnelEntryAgeInSeconds = RTL_CONSTANT_STRING(L"MaximumTunnelEntryAgeInSeconds");
    UNICODE_STRING MaximumTunnelEntries = RTL_CONSTANT_STRING( L"MaximumTunnelEntries");
 
    /* check for nt */
    if (MmIsThisAnNtAsSystem())
    {
        /* default */
        TunnelMaxEntries = 1024;
    }
 
    /* check for custom override of max entries*/
    FsRtlGetTunnelParameterValue(&MaximumTunnelEntries, &TunnelMaxEntries);
 
    /* check for custom override of age*/
    FsRtlGetTunnelParameterValue(&MaximumTunnelEntryAgeInSeconds, &TunnelMaxAge);
 
    if (!TunnelMaxAge)
    {
        /* no age means no entries */
        TunnelMaxEntries = 0;
    }
 
    /* get max entries */
    TunnelEntries = TunnelMaxEntries;
 
    /* convert to ticks */
    TunnelMaxAge *= 10000000;
 
    if(TunnelMaxEntries <= 65535)
    {
        /* use max 256 entries */
        TunnelEntries = TunnelMaxEntries / 16;
    }
 
    if(!TunnelEntries && TunnelMaxEntries )
    {
        /* max tunnel entries was too small */
        TunnelEntries = TunnelMaxEntries + 1;
    }
 
    if (TunnelEntries > 0xFFFF)
    {
        /* max entries is 256 */
        TunnelEntries = 256;
    }
 
    /* initialize look aside list */
    ExInitializePagedLookasideList(&TunnelLookasideList, NULL, NULL, 0, DEFAULT_ENTRY_SIZE, 'TunL', TunnelEntries);
}

Referenced by FsRtlInitSystem().

◆ FsRtlInitSystem()

BOOLEAN NTAPI FsRtlInitSystem ( VOID )

Definition at line 161 of file fsrtlpc.c.

{
    ULONG i;
 
    /* Initialize the list for granted locks */
    ExInitializePagedLookasideList(&FsRtlFileLockLookasideList,
                                   NULL,
                                   NULL,
                                   0,
                                   sizeof(FILE_LOCK),
                                   IFS_POOL_TAG,
                                   0);
 
    FsRtlInitializeTunnels();
    FsRtlInitializeLargeMcbs();
    KeInitializeSemaphore(&FsRtlpUncSemaphore, 1, MAXLONG);
 
    /* Allocate the Resource Buffer */
    FsRtlPagingIoResources = FsRtlAllocatePoolWithTag(NonPagedPool,
                                                      FSRTL_MAX_RESOURCES *
                                                      sizeof(ERESOURCE),
                                                      'eRsF');
 
    /* Initialize the Resources */
    for (i = 0; i < FSRTL_MAX_RESOURCES; i++)
    {
        ExInitializeResource(&FsRtlPagingIoResources[i]);
    }
 
    return NT_SUCCESS(FsRtlInitializeWorkerThread());
}

Referenced by Phase1InitializationDiscard().

◆ FsRtlPTeardownPerFileObjectContexts()

VOID NTAPI FsRtlPTeardownPerFileObjectContexts ( IN PFILE_OBJECT FileObject )

Definition at line 28 of file filtrctx.c.

{
    PFILE_OBJECT_FILTER_CONTEXTS FOContext = NULL;
 
    ASSERT(FileObject);
 
    if (!(FOContext = IoGetFileObjectFilterContext(FileObject)))
    {
        return;
    }
 
    ASSERT(IoChangeFileObjectFilterContext(FileObject, FOContext, FALSE) == STATUS_SUCCESS);
    ASSERT(IsListEmpty(&(FOContext->FilterContexts)));
 
    ExFreePoolWithTag(FOContext, 'FOCX');
}

Referenced by IopDeleteFile().

◆ FsRtlReleaseFileForCcFlush()

VOID NTAPI FsRtlReleaseFileForCcFlush ( IN PFILE_OBJECT FileObject )

Definition at line 1765 of file fastio.c.

{
    PFSRTL_COMMON_FCB_HEADER FcbHeader;
    PDEVICE_OBJECT DeviceObject, BaseDeviceObject;
    PFAST_IO_DISPATCH FastDispatch;
    NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;
 
    /* Get Device Object and Fast Calls */
    FcbHeader = (PFSRTL_COMMON_FCB_HEADER)FileObject->FsContext;
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    BaseDeviceObject = IoGetBaseFileSystemDeviceObject(FileObject);
    FastDispatch = DeviceObject->DriverObject->FastIoDispatch;
 
    /* Check if Fast Calls are supported, and check ReleaseForCcFlush */
    if (FastDispatch &&
        FastDispatch->ReleaseForCcFlush)
    {
        /* Call the ReleaseForCcFlush FastIo handler */
        Status = FastDispatch->ReleaseForCcFlush(FileObject, BaseDeviceObject);
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* No FastIo handler (or it failed). Release PagingIO resource and
           then Main resource */
        if (FcbHeader->PagingIoResource) ExReleaseResourceLite(FcbHeader->PagingIoResource);
        if (FcbHeader->Resource) ExReleaseResourceLite(FcbHeader->Resource);
    }
 
    /* Release master FsRtl lock */
    FsRtlExitFileSystem();
}

Referenced by CcRosFlushVacb().

◆ FsRtlReleaseFileForModWrite()

VOID NTAPI FsRtlReleaseFileForModWrite	(	IN PFILE_OBJECT	FileObject,
		IN PERESOURCE	ResourceToRelease
	)

Variable Documentation

◆ FsRtlFileLockLookasideList

PAGED_LOOKASIDE_LIST FsRtlFileLockLookasideList

extern

Definition at line 17 of file filelock.c.

Referenced by FsRtlAllocateFileLock(), FsRtlFreeFileLock(), and FsRtlInitSystem().

◆ FsRtlPagingIoResources

PERESOURCE FsRtlPagingIoResources