/*++

Copyright (c) 1996  Microsoft Corporation

Module Name:

    namcache.c

Abstract:

The following functions are provided to support name cache management in
mini-rdrs.  See namcache.h for a more complete description of how a mini-rdr
could use name caches to help eliminate trips to the server.


Author:

    David Orbits          [davidor]   9-Sep-1996

Revision History:


--*/


#include "precomp.h"
#pragma hdrstop


#include "prefix.h"

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, RxNameCacheInitialize)
#pragma alloc_text(PAGE, RxNameCacheCreateEntry)
#pragma alloc_text(PAGE, RxNameCacheFetchEntry)
#pragma alloc_text(PAGE, RxNameCacheCheckEntry)
#pragma alloc_text(PAGE, RxNameCacheActivateEntry)
#pragma alloc_text(PAGE, RxNameCacheExpireEntry)
#pragma alloc_text(PAGE, RxNameCacheFreeEntry)
#pragma alloc_text(PAGE, RxNameCacheFinalize)
#pragma alloc_text(PAGE, RxNameCacheExpireEntryWithShortName)
#endif

#define Dbg (DEBUG_TRACE_NAMECACHE)


VOID
RxNameCacheInitialize(
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN ULONG MRxNameCacheSize,
    IN ULONG MaximumEntries
    )

/*++

Routine Description:

    This routine initializes a NAME_CACHE structure.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL from which to
                          allocate the entry.

    MRxNameCacheSize    - The size in bytes of the mini-rdr portion of the name
                          cache entry.

    MaximumEntries      - The maximum number of entries that will ever be
                          allocated.  E.g. This prevents an errant program which
                          opens tons of files with bad names from chewing up
                          paged pool.

Return Value:

    None.

--*/
{

    PAGED_CODE();

    ExInitializeFastMutex(&NameCacheCtl->NameCacheLock);

    InitializeListHead(&NameCacheCtl->ActiveList);
    InitializeListHead(&NameCacheCtl->FreeList);

    NameCacheCtl->NumberActivates = 0;
    NameCacheCtl->NumberChecks = 0;
    NameCacheCtl->NumberNameHits = 0;
    NameCacheCtl->NumberNetOpsSaved = 0;
    NameCacheCtl->EntryCount = 0;
    NameCacheCtl->MaximumEntries = MaximumEntries;
    NameCacheCtl->MRxNameCacheSize = MRxNameCacheSize;

    return;
}


PNAME_CACHE
RxNameCacheCreateEntry (
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN PUNICODE_STRING Name,
    IN BOOLEAN CaseInsensitive
    )
/*++

Routine Description:

    This routine allocates and initializes a NAME_CACHE structure with the
    given name string, Lifetime (in seconds) and MRxContext.
    It returns a pointer to the name cache structure or NULL if no entry was
    available.  It is expected that the caller will then initialize any
    additional mini-rdr portion of the name cache context and then put the
    entry on the name cache active list by calling RxNameCacheActivateEntry().

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL from which to
                          allocate the entry.

    Name                - A pointer to the unicode name string to initialize the
                          the entry with.

    CaseInsensitive     - True if need case insensitive compare on name.

Return Value:

    PNAME_CACHE - returns a pointer to the newly allocated NAME_CACHE struct
                  or NULL if allocation fails.


--*/
{
    LONG i;
    PNAME_CACHE *NameCacheArray;
    PNAME_CACHE NameCache;
    ULONG NameCacheSize;

    PAGED_CODE();

    RxDbgTrace( +1, Dbg, ("RxNameCacheCreateEntry: %wZ\n", Name ));
    //
    // Grab an entry off the free list.
    //

    ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);

    if (!IsListEmpty(&NameCacheCtl->FreeList)) {
        NameCache = (PNAME_CACHE) RemoveHeadList(&NameCacheCtl->FreeList);
    } else {
        NameCache = NULL;
    }

    ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);

    if (NameCache != NULL) {
        NameCache = CONTAINING_RECORD(NameCache, NAME_CACHE, Link);
        RxDbgTrace(0, Dbg, ("took from free list\n"));

    } else {
        //
        // Didn't get an entry off the free list, allocate one.
        // Don't exceed Max but we could go over a little if multiple threads
        // are allocating.
        //
        if (NameCacheCtl->EntryCount < NameCacheCtl->MaximumEntries) {

            NameCacheSize = QuadAlign(sizeof(NAME_CACHE)) +
                            QuadAlign(NameCacheCtl->MRxNameCacheSize);
            NameCache = RxAllocatePoolWithTag(
                            PagedPool,
                            NameCacheSize,
                            RX_NAME_CACHE_POOLTAG);

            if (NameCache != NULL) {
                //
                // Init standard header fields, bump entry count & setup
                // mini-rdr context extension.
                //
                ZeroAndInitializeNodeType(
                    NameCache,
                    RDBSS_NTC_STORAGE_TYPE_UNKNOWN,
                    (NODE_BYTE_SIZE) NameCacheSize);

                InterlockedIncrement(&NameCacheCtl->EntryCount);

                NameCache->Name.Buffer = NULL;
                NameCache->Name.Length = 0;
                NameCache->Name.MaximumLength = 0;

                if (NameCacheCtl->MRxNameCacheSize > 0) {
                    NameCache->ContextExtension = (PBYTE)NameCache +
                                         QuadAlign(sizeof(NAME_CACHE));
                RxDbgTrace(0, Dbg, ("allocated new entry\n"));
                }
            }
        }

        //
        // If still no entry then bag it.
        //
        if (NameCache == NULL) {
            RxDbgTrace(-1, Dbg, ("Fail no entry allocated!\n"));
            return NULL;
        }

    }

    //
    // If name won't fit in current string, free it and allocate new string.
    //
    if (Name->Length > NameCache->Name.MaximumLength) {
        if (NameCache->Name.Buffer != NULL) {
            RxFreePool(NameCache->Name.Buffer);
        }

        if (Name->Length > 0) {
            NameCache->Name.Buffer = RxAllocatePoolWithTag(
                                         PagedPool,
                                         (ULONG) Name->Length,
                                         RX_NAME_CACHE_POOLTAG);

        } else {
            NameCache->Name.Buffer = NULL;
        }

        if (Name->Length > 0 &&
            NameCache->Name.Buffer == NULL) {
            //
            // if didn't get the storage.  Zero the string length and put entry
            // back on the free list.  Otherwise save allocation in max length.
            //
            NameCache->Name.Length = 0;
            NameCache->Name.MaximumLength = 0;

            ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);
            InsertHeadList(&NameCacheCtl->FreeList, &NameCache->Link);
            ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);

            RxDbgTrace(-1, Dbg, ("Fail no pool for name!\n"));
            return NULL;
        } else {
            NameCache->Name.MaximumLength = Name->Length;
        }
    }

    //
    // Save the name & length.  Set the case matching flag.  Set the hash field.
    //
    NameCache->Name.Length = Name->Length;
    NameCache->CaseInsensitive = CaseInsensitive;

    if (Name->Length > 0) {
        RtlMoveMemory(NameCache->Name.Buffer, Name->Buffer, Name->Length);
        NameCache->HashValue = RxTableComputeHashValue(&NameCache->Name);
    }else {
        NameCache->HashValue = 0;
    }

    RxDbgTrace(-1, Dbg, ("Success!\n"));
    return NameCache;

}


PNAME_CACHE
RxNameCacheFetchEntry (
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN PUNICODE_STRING Name
    )
/*++

Routine Description:

    This routine looks for a match in the name cache for Name.
    If found the entry is removed from the Name Cache active list and
    a pointer to the NAME_CACHE struct is returned.  Otherwise NULL is returned.
    The entry is removed to avoid problems with another thread trying to
    update the same entry or observing that it expired and putting it on the
    free list.  We could get multiple entries with the same name by different
    threads but eventually they will expire.

    If a matching entry is found no check is made for expiration.  That is left
    to the caller since it is likely the caller would want to take a special
    action.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL to scan.

    Name                - A pointer to the unicode name string to scan for.

Return Value:

    PNAME_CACHE - returns a pointer to the NAME_CACHE struct if found or NULL.

Side Effects:

    As the active list is scanned any non-matching entries that have expired are
    put on the free list.

--*/
{
    PNAME_CACHE NameCache = NULL;
    PLIST_ENTRY pListEntry;
    PLIST_ENTRY ExpiredEntry;
    ULONG HashValue;
    LARGE_INTEGER CurrentTime;

    PAGED_CODE();

    RxDbgTrace( 0, Dbg, ("RxNameCacheFetchEntry: Lookup %wZ\n", Name ));

    if (Name->Length > 0) {
        HashValue = RxTableComputeHashValue(Name);
    } else {
        HashValue = 0;
    }

    KeQueryTickCount( &CurrentTime );

    NameCacheCtl->NumberChecks += 1;
    //
    // Get the lock and scan the active list.
    //

    ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);

    pListEntry = NameCacheCtl->ActiveList.Flink;

    while (pListEntry != &NameCacheCtl->ActiveList) {

        NameCache = (PNAME_CACHE) CONTAINING_RECORD(pListEntry, NAME_CACHE, Link);
        //
        // Do initial match on the hash value and the length.  Then do full string.
        //
        if ((NameCache->HashValue == HashValue) &&
            (Name->Length == NameCache->Name.Length)) {

            if (Name->Length == 0 ||
                RtlEqualUnicodeString(
                    Name,
                    &NameCache->Name,
                    NameCache->CaseInsensitive) ) {
                //
                // Found a match.
                //
                NameCacheCtl->NumberNameHits += 1;
                break;
            }
        }
        //
        // No match. If the entry is expired, put it on the free list.
        //
        ExpiredEntry = pListEntry;
        pListEntry = pListEntry->Flink;

        if (CurrentTime.QuadPart >= NameCache->ExpireTime.QuadPart) {
            RemoveEntryList(ExpiredEntry);
            InsertHeadList(&NameCacheCtl->FreeList, ExpiredEntry);
            RxDbgTrace( 0, Dbg, ("RxNameCacheFetchEntry: Entry expired %wZ\n", &NameCache->Name ));
        }

        NameCache = NULL;
    }
    //
    // If we found something pull it off the active list and give it to caller.
    //
    if (NameCache != NULL) {
        RemoveEntryList(pListEntry);
    }

    ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);


    if (NameCache != NULL) {
        RxDbgTrace( 0, Dbg, ("RxNameCacheFetchEntry: Entry found %wZ\n", &NameCache->Name ));
    }

    return NameCache;

}


RX_NC_CHECK_STATUS
RxNameCacheCheckEntry (
    IN PNAME_CACHE NameCache,
    IN ULONG MRxContext
    )
/*++

Routine Description:

    This routine checks a name cache entry for validity.  A valid entry
    means that the lifetime has not expired and the MRxContext passes
    the equality check.

Arguments:

    NameCache           - pointer to NAME_CACHE struct to check.

    MRxContext          - A ULONG worth of mini-rdr supplied context for
                          equality checking when making a valid entry check.

Return Value:

    RX_NC_CHECK_STATUS:  RX_NC_SUCCESS - The entry is valid
                         RX_NC_TIME_EXPIRED - The Lifetime on the entry expired
                         RX_NC_MRXCTX_FAIL - The MRxContext equality test failed


--*/
{

    LARGE_INTEGER CurrentTime;

    PAGED_CODE();

    //
    // Check for Mini-rdr context equality.
    //
    if (NameCache->Context != MRxContext) {
        RxDbgTrace( 0, Dbg, ("RxNameCacheCheckEntry: MRxContext_Fail %08lx,%08lx %wZ\n",
           NameCache->Context,
           MRxContext,
           &NameCache->Name ));

        return RX_NC_MRXCTX_FAIL;
    }

    //
    // Check for lifetime expired.
    //
    KeQueryTickCount( &CurrentTime );
    if (CurrentTime.QuadPart >= NameCache->ExpireTime.QuadPart) {
        RxDbgTrace( 0, Dbg, ("RxNameCacheCheckEntry: Expired %wZ\n", &NameCache->Name ));
        return RX_NC_TIME_EXPIRED;
    }

    RxDbgTrace( 0, Dbg, ("RxNameCacheCheckEntry: Success %wZ\n", &NameCache->Name ));
    return RX_NC_SUCCESS;

}

VOID
RxNameCacheExpireEntry(
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN PNAME_CACHE NameCache
    )
/*++

Routine Description:

    This routine puts the entry on the free list.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL on which to
                          activate the entry.

    NameCache           - pointer to NAME_CACHE struct to activate.


Return Value:

    None.

Assumes:

    The name cache entry is not on either the free or active list.

--*/
{
    PAGED_CODE();

    RxDbgTrace( 0, Dbg, ("RxNameCacheExpireEntry: %wZ\n", &NameCache->Name ));

    //
    // Put the entry on free list for recycle.
    //
    ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);
    InsertHeadList(&NameCacheCtl->FreeList, &NameCache->Link);
    ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);

    //
    // Update stats.
    //
    NameCacheCtl->NumberActivates -= 1;

    return;
}


VOID
RxNameCacheExpireEntryWithShortName (
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN PUNICODE_STRING Name
    )
/*++

Routine Description:

    This routine expires all the name cache whose name prefix matches the given short file name.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL to scan.

    Name                - A pointer to the unicode name string to scan for.

Return Value:

    PNAME_CACHE - returns a pointer to the NAME_CACHE struct if found or NULL.

Side Effects:

    As the active list is scanned any non-matching entries that have expired are
    put on the free list.

--*/
{
    PNAME_CACHE NameCache = NULL;
    PLIST_ENTRY pListEntry;
    PLIST_ENTRY ExpiredEntry;
    ULONG HashValue;
    LARGE_INTEGER CurrentTime;

    PAGED_CODE();

    RxDbgTrace( 0, Dbg, ("RxNameCacheFetchEntry: Lookup %wZ\n", Name ));

    KeQueryTickCount( &CurrentTime );

    NameCacheCtl->NumberChecks += 1;
    //
    // Get the lock and scan the active list.
    //

    ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);

    pListEntry = NameCacheCtl->ActiveList.Flink;

    while (pListEntry != &NameCacheCtl->ActiveList) {
        USHORT SavedNameLength;

        NameCache = (PNAME_CACHE) CONTAINING_RECORD(pListEntry, NAME_CACHE, Link);

        ExpiredEntry = pListEntry;
        pListEntry = pListEntry->Flink;

        //
        // Do initial match on the hash value and the length.  Then do full string.
        //
        if (Name->Length <= NameCache->Name.Length) {
            SavedNameLength = NameCache->Name.Length;
            NameCache->Name.Length = Name->Length;

            if (Name->Length == 0 ||
                RtlEqualUnicodeString(
                    Name,
                    &NameCache->Name,
                    NameCache->CaseInsensitive) ) {
                //
                // Found a match.
                //
                RemoveEntryList(ExpiredEntry);
                InsertHeadList(&NameCacheCtl->FreeList, ExpiredEntry);
                RxDbgTrace( 0, Dbg, ("RxNameCacheExpireEntryWithShortName: Entry expired %wZ\n", &NameCache->Name ));

                continue;
            }

            NameCache->Name.Length = SavedNameLength;
        }
    }

    ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);
}

VOID
RxNameCacheActivateEntry (
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN PNAME_CACHE NameCache,
    IN ULONG LifeTime,
    IN ULONG MRxContext
    )
/*++

Routine Description:

    This routine takes a name cache entry and updates the expiration time and
    the mini rdr context.  It then puts the entry on the active list.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL on which to
                          activate the entry.

    NameCache           - pointer to NAME_CACHE struct to activate.

    LifeTime            - The valid lifetime of the cache entry (in seconds).
                          A lifetime of zero means leave current value unchanged.
                          This is for reactivations after a match where you
                          want the original lifetime preserved.

    MRxContext          - A ULONG worth of mini-rdr supplied context for
                          equality checking when making a valid entry check.
                          An MRxContext of zero means leave current value unchanged.
                          This is for reactivations after a match where you
                          want the original MRxContext preserved.

Return Value:

    None.

Assumes:

    The name cache entry is not on either the free or active list.

--*/
{
    LARGE_INTEGER CurrentTime;

    PAGED_CODE();

    RxDbgTrace( 0, Dbg, ("RxNameCacheActivateEntry: %wZ\n", &NameCache->Name ));
    //
    // Set new expiration time on the entry and save the mini-rdr context.
    // A lifetime of zero or a MRxContext of zero implies leave value unchanged.
    //
    if (LifeTime != 0) {
        KeQueryTickCount( &CurrentTime );
        NameCache->ExpireTime.QuadPart = CurrentTime.QuadPart +
            (LONGLONG) ((LifeTime * 10*1000*1000) / KeQueryTimeIncrement());
    }

    if (MRxContext != 0) {
        NameCache->Context = MRxContext;
    }

    //
    // Put the entry on active list.
    //
    ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);
    InsertHeadList(&NameCacheCtl->ActiveList, &NameCache->Link);
    ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);

    //
    // Update stats.
    //
    NameCacheCtl->NumberActivates += 1;

    return;
}

VOID
RxNameCacheFreeEntry (
    IN PNAME_CACHE_CONTROL NameCacheCtl,
    IN PNAME_CACHE NameCache
    )
/*++

Routine Description:

    This routine releases the storage for a name cache entry and decrements the
    count of name cache entries for this name cache.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL for the name cache.

    NameCache           - pointer to the NAME_CACHE struct to free.

Return Value:

    None.

Assumes:

    The name cache entry is not on either the free or active list.

--*/
{
    PAGED_CODE();

    RxDbgTrace( 0, Dbg, ("RxNameCacheFreeEntry: %wZ\n", &NameCache->Name ));
    //
    // Release storage for name
    //
    if (NameCache->Name.Buffer != NULL) {
        RxFreePool(NameCache->Name.Buffer);
    }
    //
    // Release storage for NAME_CACHE entry (includes context ext., if any)
    //
    RxFreePool(NameCache);

    InterlockedDecrement(&NameCacheCtl->EntryCount);


    return;
}

VOID
RxNameCacheFinalize (
    IN PNAME_CACHE_CONTROL NameCacheCtl
    )
/*++

Routine Description:

    This routine releases the storage for all the name cache entries.

Arguments:

    NameCacheCtl        - pointer to the NAME_CACHE_CONTROL for the name cache.

Return Value:

    None.


--*/
{
    PNAME_CACHE NameCache;
    PLIST_ENTRY pListEntry;

    PAGED_CODE();

    //
    // Get the lock and remove entries from the active list.
    //

    ExAcquireFastMutex(&NameCacheCtl->NameCacheLock);


    while (!IsListEmpty(&NameCacheCtl->ActiveList)) {

        pListEntry = RemoveHeadList(&NameCacheCtl->ActiveList);
        NameCache = (PNAME_CACHE) CONTAINING_RECORD(pListEntry, NAME_CACHE, Link);

        RxNameCacheFreeEntry(NameCacheCtl, NameCache);
    }
    //
    // scan free list and remove entries.
    //
    while (!IsListEmpty(&NameCacheCtl->FreeList)) {

        pListEntry = RemoveHeadList(&NameCacheCtl->FreeList);
        NameCache = (PNAME_CACHE) CONTAINING_RECORD(pListEntry, NAME_CACHE, Link);

        RxNameCacheFreeEntry(NameCacheCtl, NameCache);
    }

    ExReleaseFastMutex(&NameCacheCtl->NameCacheLock);

    //
    // At this point the entry count should be zero.  If not then there is
    // a memory leak since someone didn't call free.
    //
    ASSERT(NameCacheCtl->EntryCount == 0);

    return;

}

