#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for tunnel.c:

Classes
struct	TUNNEL_NODE_ENTRY

Macros
#define	NDEBUG

#define	DEFAULT_EXTRA_SIZE (72)

#define	DEFAULT_ENTRY_SIZE (sizeof(TUNNEL_NODE_ENTRY) + DEFAULT_EXTRA_SIZE)

#define	TUNNEL_FLAG_POOL 0x2

#define	TUNNEL_FLAG_KEY_SHORT_NAME 0x1

Typedefs
typedef struct TUNNEL_NODE_ENTRY *	PTUNNEL_NODE_ENTRY

Functions
VOID	FsRtlFreeTunnelNode (IN PTUNNEL_NODE_ENTRY CurEntry, IN PLIST_ENTRY PoolList OPTIONAL)

VOID	FsRtlRemoveNodeFromTunnel (IN PTUNNEL Cache, IN PTUNNEL_NODE_ENTRY CurEntry, IN PLIST_ENTRY PoolList, OUT PBOOLEAN Rebalance)

VOID	FsRtlPruneTunnelCache (IN PTUNNEL Cache, IN PLIST_ENTRY PoolList)

VOID	FsRtlGetTunnelParameterValue (IN PUNICODE_STRING ParameterName, OUT PULONG Value)

VOID NTAPI	FsRtlInitializeTunnels (VOID)

LONG	FsRtlCompareNodeAndKey (IN PTUNNEL_NODE_ENTRY CurEntry, IN ULONGLONG DirectoryKey, IN PUNICODE_STRING KeyString)

VOID	FsRtlEmptyFreePoolList (IN PLIST_ENTRY PoolList)

VOID NTAPI	FsRtlAddToTunnelCache (IN PTUNNEL Cache, IN ULONGLONG DirectoryKey, IN PUNICODE_STRING ShortName, IN PUNICODE_STRING LongName, IN BOOLEAN KeyByShortName, IN ULONG DataLength, IN PVOID Data)

VOID NTAPI	FsRtlDeleteKeyFromTunnelCache (IN PTUNNEL Cache, IN ULONGLONG DirectoryKey)

VOID NTAPI	FsRtlDeleteTunnelCache (IN PTUNNEL Cache)

BOOLEAN NTAPI	FsRtlFindInTunnelCache (IN PTUNNEL Cache, IN ULONGLONG DirectoryKey, IN PUNICODE_STRING Name, OUT PUNICODE_STRING ShortName, OUT PUNICODE_STRING LongName, IN OUT PULONG DataLength, OUT PVOID Data)

VOID NTAPI	FsRtlInitializeTunnelCache (IN PTUNNEL Cache)

Variables
ULONG	TunnelMaxEntries = 256

ULONG	TunnelMaxAge = 15

PAGED_LOOKASIDE_LIST	TunnelLookasideList

Macro Definition Documentation

◆ DEFAULT_ENTRY_SIZE

#define DEFAULT_ENTRY_SIZE (sizeof(TUNNEL_NODE_ENTRY) + DEFAULT_EXTRA_SIZE)

Definition at line 33 of file tunnel.c.

◆ DEFAULT_EXTRA_SIZE

#define DEFAULT_EXTRA_SIZE (72)

Definition at line 32 of file tunnel.c.

◆ NDEBUG

#define NDEBUG

Definition at line 13 of file tunnel.c.

◆ TUNNEL_FLAG_KEY_SHORT_NAME

#define TUNNEL_FLAG_KEY_SHORT_NAME 0x1

Definition at line 36 of file tunnel.c.

◆ TUNNEL_FLAG_POOL

#define TUNNEL_FLAG_POOL 0x2

Definition at line 35 of file tunnel.c.

Typedef Documentation

◆ PTUNNEL_NODE_ENTRY

typedef struct TUNNEL_NODE_ENTRY * PTUNNEL_NODE_ENTRY

Function Documentation

◆ FsRtlAddToTunnelCache()

VOID NTAPI FsRtlAddToTunnelCache	(	IN PTUNNEL	Cache,
		IN ULONGLONG	DirectoryKey,
		IN PUNICODE_STRING	ShortName,
		IN PUNICODE_STRING	LongName,
		IN BOOLEAN	KeyByShortName,
		IN ULONG	DataLength,
		IN PVOID	Data
	)

Definition at line 342 of file tunnel.c.

{
    PTUNNEL_NODE_ENTRY NodeEntry = NULL;
    PRTL_SPLAY_LINKS CurEntry, LastEntry;
    ULONG Length;
    LONG Result = 0;
    BOOLEAN AllocatedFromPool = FALSE;
    PUNICODE_STRING KeyString;
    LIST_ENTRY PoolList;
 
    PAGED_CODE();
 
    /* check if tunnel cache is enabled */
    if (!TunnelMaxEntries)
    {
        /* entries are disabled */
        return;
    }
 
    /* initialize free pool list */
    InitializeListHead(&PoolList);
 
    /* calculate node length */
    Length = sizeof(TUNNEL_NODE_ENTRY);
 
    /* add data size */
    Length += DataLength;
 
    if (ShortName)
    {
        /* add short name length */
        Length += ShortName->Length;
    }
 
    if (LongName)
    {
        /* add short name length */
        Length += LongName->Length;
    }
 
    if (Length <= DEFAULT_ENTRY_SIZE)
    {
        /* get standard entry */
        NodeEntry = ExAllocateFromPagedLookasideList(&TunnelLookasideList);
    }
 
    if (NodeEntry == NULL)
    {
        /* bigger than default entry or allocation failed */
        NodeEntry = ExAllocatePool(PagedPool | POOL_COLD_ALLOCATION, Length);
        /* check for success */
        if (NodeEntry == NULL)
        {
             /* out of memory */
             return;
        }
 
        AllocatedFromPool = TRUE;
    }
 
    /* acquire lock */
    ExAcquireFastMutex(&Cache->Mutex);
 
    /* now search cache for existing entries */
    CurEntry = Cache->Cache;
 
    /* check which key should be used for search */
    KeyString = (KeyByShortName ? ShortName : LongName);
 
    /* initialize last entry */
    LastEntry = NULL;
 
    while(CurEntry)
    {
        /* compare current node */
        Result = FsRtlCompareNodeAndKey((PTUNNEL_NODE_ENTRY)CurEntry, DirectoryKey, KeyString);
 
        /* backup last entry */
        LastEntry = CurEntry;
 
        if (Result > 0)
        {
            /* current directory key is bigger */
            CurEntry = CurEntry->LeftChild;
        }
        else
        {
            if (Result == 0)
            {
                /* found equal entry */
                break;
            }
 
            /* current directory key is smaller */
            CurEntry = CurEntry->RightChild;
        }
    }
 
    /* initialize node entry */
    RtlInitializeSplayLinks(&NodeEntry->SplayInfo);
 
    if (CurEntry != NULL)
    {
         /* found existing item */
         if (CurEntry->LeftChild)
         {
             /* update parent */
             RtlInsertAsLeftChild(NodeEntry, CurEntry->LeftChild);
         }
 
         if (CurEntry->RightChild)
         {
             /* update parent */
             RtlInsertAsRightChild(NodeEntry, CurEntry->RightChild);
         }
 
         if (CurEntry->Parent == CurEntry)
         {
              /* cur entry was root */
              Cache->Cache = (struct _RTL_SPLAY_LINKS*)NodeEntry;
         }
         else
         {
              /* update parent node */
              if (RtlIsLeftChild(CurEntry))
              {
                  RtlInsertAsLeftChild(RtlParent(CurEntry), NodeEntry);
              }
              else
              {
                  RtlInsertAsRightChild(RtlParent(CurEntry), NodeEntry);
              }
         }
 
         /* remove entry */
         RemoveEntryList(&((PTUNNEL_NODE_ENTRY)CurEntry)->TimerQueueEntry);
 
         /* free node entry */
         FsRtlFreeTunnelNode((PTUNNEL_NODE_ENTRY)CurEntry, &PoolList);
 
         /* decrement node count */
         Cache->NumEntries--;
    }
    else
    {
        if (LastEntry == NULL)
        {
            /* first entry in tunnel cache */
            Cache->Cache = (struct _RTL_SPLAY_LINKS*)NodeEntry;
        }
        else
        {
            if (Result > 0)
            {
                /* new left node */
                RtlInsertAsLeftChild(LastEntry, NodeEntry);
            }
            else
            {
                /* new right node */
                RtlInsertAsRightChild(LastEntry, NodeEntry);
            }
        }
    }
 
    /* initialize entry */
    KeQuerySystemTime(&NodeEntry->Time);
 
    NodeEntry->DirectoryKey = DirectoryKey;
    NodeEntry->Flags = (AllocatedFromPool ? TUNNEL_FLAG_POOL : 0x0);
    NodeEntry->Flags |= (KeyByShortName ? TUNNEL_FLAG_KEY_SHORT_NAME : 0x0);
 
    if (ShortName)
    {
        /* copy short name */
        NodeEntry->ShortName.Length = ShortName->Length;
        NodeEntry->ShortName.MaximumLength = ShortName->Length;
        NodeEntry->ShortName.Buffer = (LPWSTR)((ULONG_PTR)NodeEntry + sizeof(TUNNEL_NODE_ENTRY));
 
        RtlMoveMemory(NodeEntry->ShortName.Buffer, ShortName->Buffer, ShortName->Length);
    }
    else
    {
        NodeEntry->ShortName.Length = NodeEntry->ShortName.MaximumLength = 0;
        NodeEntry->ShortName.Buffer = NULL;
    }
 
    if (LongName)
    {
        /* copy long name */
        NodeEntry->LongName.Length = LongName->Length;
        NodeEntry->LongName.MaximumLength = LongName->Length;
        NodeEntry->LongName.Buffer = (LPWSTR)((ULONG_PTR)NodeEntry + sizeof(TUNNEL_NODE_ENTRY) + NodeEntry->ShortName.Length);
 
        RtlMoveMemory(NodeEntry->LongName.Buffer, LongName->Buffer, LongName->Length);
    }
    else
    {
        NodeEntry->LongName.Length = NodeEntry->LongName.MaximumLength = 0;
        NodeEntry->LongName.Buffer = NULL;
    }
 
     NodeEntry->DataLength = DataLength;
     NodeEntry->Data = (PVOID)((ULONG_PTR)NodeEntry + sizeof(TUNNEL_NODE_ENTRY) + NodeEntry->ShortName.Length + NodeEntry->LongName.Length);
     RtlMoveMemory(NodeEntry->Data, Data, DataLength);
 
     /* increment node count */
     Cache->NumEntries++;
 
     /* insert into list */
     InsertTailList(&Cache->TimerQueue, &NodeEntry->TimerQueueEntry);
 
     /* prune cache */
     FsRtlPruneTunnelCache(Cache, &PoolList);
 
     /* release lock */
     ExReleaseFastMutex(&Cache->Mutex);
 
     /* free pool list */
     FsRtlEmptyFreePoolList(&PoolList);
}

Referenced by DuplicatesTest(), FatTunnelFcbOrDcb(), and TestFsRtlAddToTunnelCache().

◆ FsRtlCompareNodeAndKey()

LONG FsRtlCompareNodeAndKey	(	IN PTUNNEL_NODE_ENTRY	CurEntry,
		IN ULONGLONG	DirectoryKey,
		IN PUNICODE_STRING	KeyString
	)

Definition at line 254 of file tunnel.c.

{
    PUNICODE_STRING String;
    LONG Ret;
 
    if (DirectoryKey > CurEntry->DirectoryKey)
    {
        Ret = 1;
    }
    else if (DirectoryKey < CurEntry->DirectoryKey)
    {
        Ret = -1;
    }
    else
    {
        if (CurEntry->Flags & TUNNEL_FLAG_KEY_SHORT_NAME)
        {
            /* use short name as key */
            String = &CurEntry->ShortName;
        }
        else
        {
            /* use long name as key */
            String = &CurEntry->LongName;
        }
 
        Ret = RtlCompareUnicodeString(KeyString, String, TRUE);
    }
 
    return Ret;
}

Referenced by FsRtlAddToTunnelCache(), and FsRtlFindInTunnelCache().

◆ FsRtlDeleteKeyFromTunnelCache()

VOID NTAPI FsRtlDeleteKeyFromTunnelCache	(	IN PTUNNEL	Cache,
		IN ULONGLONG	DirectoryKey
	)

Definition at line 589 of file tunnel.c.

{
    BOOLEAN Rebalance = TRUE;
    LIST_ENTRY PoolList;
    PTUNNEL_NODE_ENTRY CurNode;
    PRTL_SPLAY_LINKS CurEntry, LastEntry = NULL, Successors;
 
    PAGED_CODE();
 
    /* check if tunnel cache is enabled */
    if (!TunnelMaxEntries)
    {
        /* entries are disabled */
        return;
    }
 
    /* initialize free pool list */
    InitializeListHead(&PoolList);
 
    /* acquire lock */
    ExAcquireFastMutex(&Cache->Mutex);
 
    /* Look for the entry */
    CurEntry = Cache->Cache;
    while (CurEntry)
    {
        CurNode = CONTAINING_RECORD(CurEntry, TUNNEL_NODE_ENTRY, SplayInfo);
 
        if (CurNode->DirectoryKey > DirectoryKey)
        {
            /* current directory key is bigger */
            CurEntry = CurEntry->LeftChild;
        }
        else if (CurNode->DirectoryKey < DirectoryKey)
        {
            /* if we have already found one suitable, break */
            if (LastEntry != NULL)
            {
                break;
            }
 
            /* current directory key is smaller */
            CurEntry = CurEntry->RightChild;
        }
        else
        {
            /* save and look for another */
            LastEntry = CurEntry;
            CurEntry = CurEntry->LeftChild;
        }
    }
 
    /* was it found? */
    if (LastEntry == NULL)
    {
        /* release tunnel lock */
        ExReleaseFastMutex(&Cache->Mutex);
 
        return;
    }
 
    /* delete any matching key */
    do
    {
        CurNode = CONTAINING_RECORD(LastEntry, TUNNEL_NODE_ENTRY, SplayInfo);
 
        Successors = RtlRealSuccessor(LastEntry);
        if (CurNode->DirectoryKey != DirectoryKey)
        {
            break;
        }
 
        /* remove from tunnel */
        FsRtlRemoveNodeFromTunnel(Cache, CurNode, &PoolList, &Rebalance);
        LastEntry = Successors;
    }
    while (LastEntry != NULL);
 
    /* release tunnel lock */
    ExReleaseFastMutex(&Cache->Mutex);
 
    /* free pool */
    FsRtlEmptyFreePoolList(&PoolList);
}

Referenced by DuplicatesTest(), FatTunnelFcbOrDcb(), and TestFsRtlDeleteKeyFromTunnelCache().

◆ FsRtlDeleteTunnelCache()

VOID NTAPI FsRtlDeleteTunnelCache ( IN PTUNNEL Cache )

Definition at line 691 of file tunnel.c.

{
    PLIST_ENTRY Entry, NextEntry;
    PTUNNEL_NODE_ENTRY CurEntry;
 
    PAGED_CODE();
 
    /* check if tunnel cache is enabled */
    if (!TunnelMaxEntries)
    {
        /* entries are disabled */
        return;
    }
 
    /* free all entries */
    Entry = Cache->TimerQueue.Flink;
 
    while(Entry != &Cache->TimerQueue)
    {
        /* get node entry */
        CurEntry = CONTAINING_RECORD(Entry, TUNNEL_NODE_ENTRY, TimerQueueEntry);
 
        /* get next entry */
         NextEntry = Entry->Flink;
 
        /* remove entry from list */
        RemoveEntryList(&CurEntry->TimerQueueEntry);
 
        /* free entry */
        FsRtlFreeTunnelNode(CurEntry, NULL);
 
        /* move to next entry */
        Entry = NextEntry;
    }
 
    /* reset object */
    Cache->Cache = NULL;
    Cache->NumEntries = 0;
    InitializeListHead(&Cache->TimerQueue);
}

Referenced by DuplicatesTest(), FatDeleteVcb(), and START_TEST().

◆ FsRtlEmptyFreePoolList()

VOID FsRtlEmptyFreePoolList ( IN PLIST_ENTRY PoolList )

Definition at line 290 of file tunnel.c.

{
    PLIST_ENTRY CurEntry;
    PTUNNEL_NODE_ENTRY CurNode;
 
    /* loop over all the entry */
    while (!IsListEmpty(PoolList))
    {
        /* and free them, one by one */
        CurEntry = RemoveHeadList(PoolList);
        CurNode = CONTAINING_RECORD(CurEntry, TUNNEL_NODE_ENTRY, TimerQueueEntry);
        FsRtlFreeTunnelNode(CurNode, 0);
    }
}

Referenced by FsRtlAddToTunnelCache(), FsRtlDeleteKeyFromTunnelCache(), and FsRtlFindInTunnelCache().

◆ FsRtlFindInTunnelCache()

BOOLEAN NTAPI FsRtlFindInTunnelCache	(	IN PTUNNEL	Cache,
		IN ULONGLONG	DirectoryKey,
		IN PUNICODE_STRING	Name,
		OUT PUNICODE_STRING	ShortName,
		OUT PUNICODE_STRING	LongName,
		IN OUT PULONG	DataLength,
		OUT PVOID	Data
	)

Definition at line 766 of file tunnel.c.

{
    BOOLEAN Ret = FALSE;
    PTUNNEL_NODE_ENTRY CurEntry;
    LIST_ENTRY PoolList;
    //NTSTATUS Status;
    LONG Result;
 
    PAGED_CODE();
 
    /* check if tunnel cache is enabled */
    if (!TunnelMaxEntries)
    {
        /* entries are disabled */
        return FALSE;
    }
 
    /* initialize free pool list */
    InitializeListHead(&PoolList);
 
    /* acquire tunnel lock */
    ExAcquireFastMutex(&Cache->Mutex);
 
    /* prune old entries */
    FsRtlPruneTunnelCache(Cache, &PoolList);
 
    /* now search cache for existing entries */
    CurEntry = (PTUNNEL_NODE_ENTRY)Cache->Cache;
 
    while(CurEntry)
    {
        /* compare current node */
        Result = FsRtlCompareNodeAndKey(CurEntry, DirectoryKey, Name);
 
        if (Result > 0)
        {
            /* current directory key is bigger */
            CurEntry = (PTUNNEL_NODE_ENTRY)CurEntry->SplayInfo.LeftChild;
        }
        else
        {
            if (Result == 0)
            {
                /* found equal entry */
                break;
            }
 
            /* current directory key is smaller */
            CurEntry = (PTUNNEL_NODE_ENTRY)CurEntry->SplayInfo.RightChild;
        }
    }
 
    if (CurEntry != NULL)
    {
        _SEH2_TRY
        {
            /* copy short name */
            RtlCopyUnicodeString(ShortName, &CurEntry->ShortName);
 
            /* check size */
            if (LongName->MaximumLength < CurEntry->LongName.Length)
            {
                /* buffer is too small */
                LongName->Buffer = ExAllocatePool(PagedPool, CurEntry->LongName.Length);
                if (LongName->Buffer)
                {
                    LongName->Length = CurEntry->LongName.Length;
                    LongName->MaximumLength = CurEntry->LongName.MaximumLength;
                    RtlMoveMemory(LongName->Buffer, CurEntry->LongName.Buffer, CurEntry->LongName.Length);
                }
            }
            else
            {
                /* buffer is big enough */
                RtlCopyUnicodeString(LongName, &CurEntry->LongName);
            }
 
            /* copy data */
            RtlMoveMemory(Data, CurEntry->Data, CurEntry->DataLength);
 
            /* store size */
            *DataLength = CurEntry->DataLength;
 
            /* done */
            Ret = TRUE;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Get the status */
            //Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
 
    }
 
    /* release tunnel lock */
    ExReleaseFastMutex(&Cache->Mutex);
 
    /* free pool */
    FsRtlEmptyFreePoolList(&PoolList);
 
    return Ret;
}

Referenced by DuplicatesTest(), FatSetRenameInfo(), and TestFsRtlFindInTunnelCache().

◆ FsRtlFreeTunnelNode()

VOID FsRtlFreeTunnelNode	(	IN PTUNNEL_NODE_ENTRY	CurEntry,
		IN PLIST_ENTRY PoolList	OPTIONAL
	)

Definition at line 39 of file tunnel.c.

{
    if (PoolList)
    {
        /* divert the linked list entry, it's not required anymore, but we need it */
        InsertHeadList(PoolList, &CurEntry->TimerQueueEntry);
        return;
    }
 
    if (CurEntry->Flags & TUNNEL_FLAG_POOL)
        ExFreePool(CurEntry);
    else
        ExFreeToPagedLookasideList(&TunnelLookasideList, CurEntry);
}

Referenced by FsRtlAddToTunnelCache(), FsRtlDeleteTunnelCache(), FsRtlEmptyFreePoolList(), and FsRtlRemoveNodeFromTunnel().

◆ FsRtlGetTunnelParameterValue()

VOID FsRtlGetTunnelParameterValue	(	IN PUNICODE_STRING	ParameterName,
		OUT PULONG	Value
	)

Definition at line 135 of file tunnel.c.

{
    UNICODE_STRING Root = RTL_CONSTANT_STRING(L"Registry\\Machine\\System\\CurrentControlSet\\Control\\FileSystem");
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hKey;
    NTSTATUS Status;
    ULONG Length;
    PKEY_VALUE_FULL_INFORMATION Info;
 
    /* initialize object attributes */
    InitializeObjectAttributes(&ObjectAttributes, &Root, OBJ_CASE_INSENSITIVE, NULL, NULL);
 
    /* open registry key */
    Status = ZwOpenKey(&hKey, KEY_READ, &ObjectAttributes);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed to open key */
        return;
    }
 
    /* query value size */
    Status = ZwQueryValueKey(hKey, ParameterName, KeyValueFullInformation, NULL, 0, &Length);
 
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        /* failed to query size */
        ZwClose(hKey);
        return;
    }
 
    /* allocate buffer */
    Info = ExAllocatePool(PagedPool, Length);
 
    if (!Info)
    {
         /* out of memory */
        ZwClose(hKey);
        return;
    }
 
    /* query value */
    Status = ZwQueryValueKey(hKey, ParameterName, KeyValueFullInformation, NULL, 0, &Length);
 
    if (NT_SUCCESS(Status))
    {
        if (Info->DataLength)
        {
            /* store result */
            *Value = (ULONG)((ULONG_PTR)Info + Info->DataOffset);
        }
    }
 
    /* free buffer */
    ExFreePool(Info);
 
    /* close key */
    ZwClose(hKey);
}

Referenced by FsRtlInitializeTunnels().

◆ FsRtlInitializeTunnelCache()

VOID NTAPI FsRtlInitializeTunnelCache ( IN PTUNNEL Cache )

Definition at line 892 of file tunnel.c.

{
    PAGED_CODE();
 
    /* initialize mutex */
    ExInitializeFastMutex(&Cache->Mutex);
 
    /* initialize node tree */
    Cache->Cache = NULL;
 
    /* initialize timer list */
    InitializeListHead(&Cache->TimerQueue);
 
    /* initialize node count */
    Cache->NumEntries = 0;
}

Referenced by _Requires_lock_held_(), DuplicatesTest(), and TestFsRtlInitializeTunnelCache().

◆ 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().

◆ FsRtlPruneTunnelCache()

VOID FsRtlPruneTunnelCache	(	IN PTUNNEL	Cache,
		IN PLIST_ENTRY	PoolList
	)

Definition at line 86 of file tunnel.c.

{
    PLIST_ENTRY Entry, NextEntry;
    PTUNNEL_NODE_ENTRY CurEntry;
    LARGE_INTEGER CurTime, OldTime;
    BOOLEAN Rebalance = TRUE;
    PAGED_CODE();
 
    /* query time */
    KeQuerySystemTime(&CurTime);
 
    /* subtract maximum node age */
    OldTime.QuadPart = CurTime.QuadPart - TunnelMaxAge;
 
    /* free all entries */
    Entry = Cache->TimerQueue.Flink;
 
    while(Entry != &Cache->TimerQueue)
    {
        /* get node entry */
        CurEntry = CONTAINING_RECORD(Entry, TUNNEL_NODE_ENTRY, TimerQueueEntry);
 
        /* get next entry */
         NextEntry = Entry->Flink;
 
        /* prune if expired OR if in advance in time */
        if (CurEntry->Time.QuadPart < OldTime.QuadPart ||
            CurEntry->Time.QuadPart > CurTime.QuadPart)
        {
            FsRtlRemoveNodeFromTunnel(Cache, CurEntry, PoolList, &Rebalance);
        }
 
        /* move to next entry */
        Entry = NextEntry;
    }
 
    /* If we have too many entries */
    while (Cache->NumEntries > TunnelMaxEntries)
    {
        ASSERT(!IsListEmpty(&Cache->TimerQueue));
        CurEntry = CONTAINING_RECORD(Cache->TimerQueue.Flink, TUNNEL_NODE_ENTRY, TimerQueueEntry);
        FsRtlRemoveNodeFromTunnel(Cache, CurEntry, PoolList, &Rebalance);
    }
}

Referenced by FsRtlAddToTunnelCache(), and FsRtlFindInTunnelCache().

◆ FsRtlRemoveNodeFromTunnel()

VOID FsRtlRemoveNodeFromTunnel	(	IN PTUNNEL	Cache,
		IN PTUNNEL_NODE_ENTRY	CurEntry,
		IN PLIST_ENTRY	PoolList,
		OUT PBOOLEAN	Rebalance
	)

Definition at line 57 of file tunnel.c.

{
    /* delete entry and rebalance if required */
    if (Rebalance && *Rebalance)
    {
        Cache->Cache = RtlDelete(&CurEntry->SplayInfo);
        /* reset */
        *Rebalance = FALSE;
    }
    else
    {
        RtlDeleteNoSplay(&CurEntry->SplayInfo, &Cache->Cache);
    }
 
    /* remove entry */
    RemoveEntryList(&CurEntry->TimerQueueEntry);
 
    /* free node entry */
    FsRtlFreeTunnelNode(CurEntry, PoolList);
 
    /* decrement node count */
    Cache->NumEntries--;
}

Referenced by FsRtlDeleteKeyFromTunnelCache(), and FsRtlPruneTunnelCache().

Variable Documentation

◆ TunnelLookasideList

PAGED_LOOKASIDE_LIST TunnelLookasideList

Definition at line 30 of file tunnel.c.

Referenced by FsRtlAddToTunnelCache(), FsRtlFreeTunnelNode(), and FsRtlInitializeTunnels().

◆ TunnelMaxAge

ULONG TunnelMaxAge = 15

Definition at line 29 of file tunnel.c.

Referenced by FsRtlInitializeTunnels(), and FsRtlPruneTunnelCache().

◆ TunnelMaxEntries

ULONG TunnelMaxEntries = 256

Definition at line 28 of file tunnel.c.

Referenced by FsRtlAddToTunnelCache(), FsRtlDeleteKeyFromTunnelCache(), FsRtlDeleteTunnelCache(), FsRtlFindInTunnelCache(), FsRtlInitializeTunnels(), and FsRtlPruneTunnelCache().

Classes

Macros

Typedefs

Functions

Variables