/*++ Copyright (c) 1998-2001 Microsoft Corporation Module Name: cache.cxx Abstract: Contains the HTTP response cache logic. Author: Michael Courage (mcourage) 17-May-1999 Revision History: --*/ #include "precomp.h" #include "cachep.h" PTRACE_LOG g_UriTraceLog; BOOLEAN g_InitUriCacheCalled; // // Global hash table // HASHTABLE g_UriCacheTable; LIST_ENTRY g_ZombieListHead; UL_URI_CACHE_CONFIG g_UriCacheConfig; UL_URI_CACHE_STATS g_UriCacheStats; UL_SPIN_LOCK g_UriCacheSpinLock; // // Scavenger stuff. // UL_SPIN_LOCK g_UriScavengerSpinLock; BOOLEAN g_UriScavengerInitialized; KDPC g_UriScavengerDpc; KTIMER g_UriScavengerTimer; KEVENT g_UriScavengerTerminationEvent; UL_WORK_ITEM g_UriScavengerWorkItem; LONG g_UriScavengerRunning; #ifdef ALLOC_PRAGMA #pragma alloc_text( INIT, UlInitializeUriCache ) #pragma alloc_text( PAGE, UlTerminateUriCache ) #pragma alloc_text( INIT, UlpInitializeScavenger ) #pragma alloc_text( PAGE, UlCheckCachePreconditions ) #pragma alloc_text( PAGE, UlCheckCacheResponseConditions ) #pragma alloc_text( PAGE, UlCheckoutUriCacheEntry ) #pragma alloc_text( PAGE, UlCheckinUriCacheEntry ) #pragma alloc_text( PAGE, UlFlushCache ) #pragma alloc_text( PAGE, UlpFlushFilterAll ) #pragma alloc_text( PAGE, UlFlushCacheByProcess ) #pragma alloc_text( PAGE, UlpFlushFilterProcess ) #pragma alloc_text( PAGE, UlFlushCacheByUri ) #pragma alloc_text( PAGE, UlpFlushUri ) #pragma alloc_text( PAGE, UlAddCacheEntry ) #pragma alloc_text( PAGE, UlpFilteredFlushUriCache ) #pragma alloc_text( PAGE, UlpAddZombie ) #pragma alloc_text( PAGE, UlpClearZombieList ) #pragma alloc_text( PAGE, UlpDestroyUriCacheEntry ) #pragma alloc_text( PAGE, UlpFlushFilterScavenger ) #pragma alloc_text( PAGE, UlpQueryTranslateHeader ) #endif // ALLOC_PRAGMA #if 0 NOT PAGEABLE -- UlpCheckTableSpace NOT PAGEABLE -- UlpCheckSpaceAndAddEntryStats NOT PAGEABLE -- UlpRemoveEntryStats NOT PAGEABLE -- UlpTerminateScavenger NOT PAGEABLE -- UlpScavengerDpcRoutine NOT PAGEABLE -- UlpSetScavengerTimer NOT PAGEABLE -- UlpScavenger #endif /***************************************************************************++ Routine Description: Performs global initialization of the URI cache. Return Value: NTSTATUS - Completion status. --***************************************************************************/ NTSTATUS UlInitializeUriCache( PUL_CONFIG pConfig ) { NTSTATUS Status = STATUS_SUCCESS; // // Sanity check. // PAGED_CODE(); ASSERT( !g_InitUriCacheCalled ); UlTrace(URI_CACHE, ("Http!UlInitializeUriCache\n")); if ( !g_InitUriCacheCalled ) { PUL_URI_CACHE_CONFIG pUriConfig = &pConfig->UriConfig; g_UriCacheConfig.EnableCache = pUriConfig->EnableCache; g_UriCacheConfig.MaxCacheUriCount = pUriConfig->MaxCacheUriCount; g_UriCacheConfig.MaxCacheMegabyteCount = min((ULONG)pConfig->LargeMemMegabytes, pUriConfig->MaxCacheMegabyteCount); // // Don't want to scavenge more than once every ten seconds. // In particular, do not want to scavenge every 0 seconds, as the // machine will become completely unresponsive. // g_UriCacheConfig.ScavengerPeriod = max(pUriConfig->ScavengerPeriod, 10); g_UriCacheConfig.MaxUriBytes = pUriConfig->MaxUriBytes; g_UriCacheConfig.HashTableBits = pUriConfig->HashTableBits; RtlZeroMemory(&g_UriCacheStats, sizeof(g_UriCacheStats)); InitializeListHead(&g_ZombieListHead); UlInitializeSpinLock( &g_UriCacheSpinLock, "g_UriCacheSpinLock" ); if (g_UriCacheConfig.EnableCache) { Status = UlInitializeResource( &g_pUlNonpagedData->UriZombieResource, "UriZombieResource", 0, UL_ZOMBIE_RESOURCE_TAG ); if (NT_SUCCESS(Status)) { Status = UlInitializeHashTable( &g_UriCacheTable, PagedPool, g_UriCacheConfig.HashTableBits ); if (NT_SUCCESS(Status)) { ASSERT(IS_VALID_HASHTABLE(&g_UriCacheTable)); CREATE_REF_TRACE_LOG( g_UriTraceLog, 2048 - REF_TRACE_OVERHEAD, 0 ); UlpInitializeScavenger(); g_InitUriCacheCalled = TRUE; } } else { UlDeleteResource(&g_pUlNonpagedData->UriZombieResource); } } else { UlTrace(URI_CACHE, ("URI Cache disabled.\n")); g_InitUriCacheCalled = TRUE; } } else { UlTrace(URI_CACHE, ("URI CACHE INITIALIZED TWICE!\n")); } return Status; } // UlInitializeUriCache /***************************************************************************++ Routine Description: Performs global termination of the URI cache. --***************************************************************************/ VOID UlTerminateUriCache( VOID ) { NTSTATUS Status; // // Sanity check. // PAGED_CODE(); UlTrace(URI_CACHE, ("Http!UlTerminateUriCache\n")); if (g_InitUriCacheCalled && g_UriCacheConfig.EnableCache) { // Must terminate the scavenger before destroying the hash table UlpTerminateScavenger(); UlTerminateHashTable(&g_UriCacheTable); Status = UlDeleteResource(&g_pUlNonpagedData->UriZombieResource); ASSERT(NT_SUCCESS(Status)); DESTROY_REF_TRACE_LOG( g_UriTraceLog ); g_UriTraceLog = NULL; } g_InitUriCacheCalled = FALSE; } // UlTerminateUriCache /***************************************************************************++ Routine Description: This routine checks a request (and its connection) to see if it's ok to serve this request from the cache. Basically we only accept simple GET requests with no conditional headers. Arguments: pHttpConn - The connection to be checked Return Value: BOOLEAN - True if it's ok to serve from cache --***************************************************************************/ BOOLEAN UlCheckCachePreconditions( PUL_INTERNAL_REQUEST pRequest, PUL_HTTP_CONNECTION pHttpConn ) { URI_PRECONDITION Precondition = URI_PRE_OK; // // Sanity check // PAGED_CODE(); ASSERT( UL_IS_VALID_HTTP_CONNECTION(pHttpConn) ); ASSERT( UL_IS_VALID_INTERNAL_REQUEST(pRequest) ); if (!g_UriCacheConfig.EnableCache) { Precondition = URI_PRE_DISABLED; } else if (pRequest->ParseState != ParseDoneState) { Precondition = URI_PRE_ENTITY_BODY; } else if (pRequest->Verb != HttpVerbGET) { Precondition = URI_PRE_VERB; } else if (HTTP_NOT_EQUAL_VERSION(pRequest->Version, 1, 1) && HTTP_NOT_EQUAL_VERSION(pRequest->Version, 1, 0)) { Precondition = URI_PRE_PROTOCOL; } // check for Translate: f (DAV) else if ( UlpQueryTranslateHeader(pRequest) ) { Precondition = URI_PRE_TRANSLATE; } // check for Authorization header else if (pRequest->HeaderValid[HttpHeaderAuthorization]) { Precondition = URI_PRE_AUTHORIZATION; } // // check for some of the If-* headers // NOTE: See UlpCheckCacheControlHeaders for handling of other If-* headers // else if (pRequest->HeaderValid[HttpHeaderIfRange]) { Precondition = URI_PRE_CONDITIONAL; } // CODEWORK: check for other evil headers else if (pRequest->HeaderValid[HttpHeaderRange]) { Precondition = URI_PRE_OTHER_HEADER; } UlTrace(URI_CACHE, ( "Http!UlCheckCachePreconditions(req = %p, httpconn = %p)\n" " OkToServeFromCache = %d, Precondition = %d\n", pRequest, pHttpConn, (URI_PRE_OK == Precondition) ? 1 : 0, Precondition )); // // update stats // if (URI_PRE_OK != Precondition) { InterlockedIncrement((PLONG) &g_UriCacheStats.MissPreconditionCount); } return (URI_PRE_OK == Precondition); } // UlCheckCachePreconditions /***************************************************************************++ Routine Description: This routine checks a response to see if it's cacheable. Basically we'll take it if: * the cache policy is right * the size is small enough * there is room in the cache * we get the response all at once Arguments: pHttpConn - The connection to be checked Return Value: BOOLEAN - True if it's ok to serve from cache --***************************************************************************/ BOOLEAN UlCheckCacheResponseConditions( PUL_INTERNAL_REQUEST pRequest, PUL_INTERNAL_RESPONSE pResponse, ULONG Flags, HTTP_CACHE_POLICY CachePolicy ) { URI_PRECONDITION Precondition = URI_PRE_OK; // // Sanity check // PAGED_CODE(); ASSERT( UL_IS_VALID_INTERNAL_REQUEST(pRequest) ); ASSERT( UL_IS_VALID_INTERNAL_RESPONSE(pResponse) ); if (pRequest->CachePreconditions == FALSE) { Precondition = URI_PRE_REQUEST; } // check policy else if (CachePolicy.Policy == HttpCachePolicyNocache) { Precondition = URI_PRE_POLICY; } // check size of response else if ((pResponse->ResponseLength - pResponse->HeaderLength) > g_UriCacheConfig.MaxUriBytes) { Precondition = URI_PRE_SIZE; } // check for full response else if (Flags & HTTP_SEND_RESPONSE_FLAG_MORE_DATA) { Precondition = URI_PRE_FRAGMENT; } // check available cache table space else if (!UlpCheckTableSpace(pResponse->ResponseLength)) { Precondition = URI_PRE_NOMEMORY; } // Check for bogus responses // BUGBUG: this check should be in ioctl.cxx else if ((pResponse->ResponseLength < 1) || (pResponse->ChunkCount < 2)) { Precondition = URI_PRE_BOGUS; } UlTrace(URI_CACHE, ( "Http!UlCheckCacheResponseConditions(pRequest = %p, pResponse = %p)\n" " OkToCache = %d, Precondition = %d\n", pRequest, pResponse, (URI_PRE_OK == Precondition), Precondition )); return (URI_PRE_OK == Precondition); } // UlCheckCacheResponseConditions /***************************************************************************++ Routine Description: This routine does a cache lookup to see if there is a valid entry corresponding to the request URI. Arguments: pRequest - The request Return Value: PUL_URI_CACHE_ENTRY - Pointer to the entry, if found. NULL otherwise. --***************************************************************************/ PUL_URI_CACHE_ENTRY UlCheckoutUriCacheEntry( PUL_INTERNAL_REQUEST pRequest ) { PUL_URI_CACHE_ENTRY pUriCacheEntry = NULL; ULONG BucketNumber; URI_KEY Key; // // Sanity check // PAGED_CODE(); // // find bucket // Key.Hash = pRequest->CookedUrl.Hash; Key.Length = pRequest->CookedUrl.Length; Key.pUri = pRequest->CookedUrl.pUrl; ASSERT(!g_UriCacheConfig.EnableCache || IS_VALID_HASHTABLE(&g_UriCacheTable)); pUriCacheEntry = UlGetFromHashTable(&g_UriCacheTable, &Key); if (pUriCacheEntry != NULL) { ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT(! pUriCacheEntry->Zombie); InterlockedIncrement((PLONG) &pUriCacheEntry->HitCount); // reset scavenger counter pUriCacheEntry->ScavengerTicks = 0; UlTrace(URI_CACHE, ( "Http!UlCheckoutUriCacheEntry(pUriCacheEntry %p, '%ls') " "refcount = %d\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, pUriCacheEntry->ReferenceCount )); // // update stats // InterlockedIncrement((PLONG) &g_UriCacheStats.HitCount); UlIncCounter(HttpGlobalCounterUriCacheHits); } else { InterlockedIncrement((PLONG) &g_UriCacheStats.MissTableCount); UlIncCounter(HttpGlobalCounterUriCacheMisses); } return pUriCacheEntry; } // UlCheckoutUriCacheEntry /***************************************************************************++ Routine Description: Decrements the refcount on a cache entry. Cleans up non-cached entries. Arguments: pUriCacheEntry - the entry to deref --***************************************************************************/ VOID UlCheckinUriCacheEntry( PUL_URI_CACHE_ENTRY pUriCacheEntry ) { LONG ReferenceCount; BOOLEAN Cached; // // Sanity check // PAGED_CODE(); ASSERT(!g_UriCacheConfig.EnableCache || IS_VALID_HASHTABLE(&g_UriCacheTable)); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); // // check to see if it was cached while we have a reference // Cached = pUriCacheEntry->Cached; // // decrement count // ReferenceCount = DEREFERENCE_URI_CACHE_ENTRY(pUriCacheEntry, CHECKIN); ASSERT(ReferenceCount >= 0); if (ReferenceCount == 0) { // CODEWORK: add this entry to the zombie list, instead of // deleting synchronously // Make sure the zombie list gets periodically purged, even // if the ScavengerPeriod is huge. // The refcount of a cached entry can be zero if the entry // was flushed from the cache while the entry was being // sent back to a client. } else { // If the reference was not marked as cached, its refcount // must now be zero ASSERT(Cached); } } // UlCheckinUriCacheEntry /***************************************************************************++ Routine Description: Removes all cache entries --***************************************************************************/ VOID UlFlushCache( VOID ) { // // sanity check // PAGED_CODE(); ASSERT(!g_UriCacheConfig.EnableCache || IS_VALID_HASHTABLE(&g_UriCacheTable)); if (g_UriCacheConfig.EnableCache) { UlTrace(URI_CACHE, ( "Http!UlFlushCache()\n" )); UlpFilteredFlushUriCache(UlpFlushFilterAll, NULL); } } // UlFlushCache /***************************************************************************++ Routine Description: A filter for UlFlushCache. Called by UlpFilteredFlushUriCache. Arguments: pUriCacheEntry - the entry to check pContext - ignored --***************************************************************************/ UL_CACHE_PREDICATE UlpFlushFilterAll( IN PUL_URI_CACHE_ENTRY pUriCacheEntry, IN PVOID pContext ) { PURI_FILTER_CONTEXT pUriFilterContext = (PURI_FILTER_CONTEXT) pContext; // // Sanity check // PAGED_CODE(); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT( pUriFilterContext != NULL && URI_FILTER_CONTEXT_POOL_TAG == pUriFilterContext->Signature && pUriFilterContext->pCallerContext == NULL ); UlTrace(URI_CACHE, ( "Http!UlpFlushFilterAll(pUriCacheEntry %p '%ls') refcount = %d\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, pUriCacheEntry->ReferenceCount)); return UlpZombifyEntry( TRUE, pUriCacheEntry, pUriFilterContext ); } // UlpFlushFilterAll /***************************************************************************++ Routine Description: Removes any cache entries that were created by the given process. Arguments: pProcess - a process that is going away --***************************************************************************/ VOID UlFlushCacheByProcess( PUL_APP_POOL_PROCESS pProcess ) { // // sanity check // PAGED_CODE(); ASSERT( IS_VALID_AP_PROCESS(pProcess) ); ASSERT(!g_UriCacheConfig.EnableCache || IS_VALID_HASHTABLE(&g_UriCacheTable)); if (g_UriCacheConfig.EnableCache) { UlTrace(URI_CACHE, ( "Http!UlFlushCacheByProcess(proc = %p)\n", pProcess )); UlpFilteredFlushUriCache(UlpFlushFilterProcess, pProcess); } } // UlFlushCacheByProcess /***************************************************************************++ Routine Description: Removes any cache entries that were created by the given process whose url has a given prefix. Arguments: pUri - the uri prefix to match against Length - length of the prefix Flags - HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE indicates a tree flush pProcess - the process that made the call --***************************************************************************/ VOID UlFlushCacheByUri( IN PWSTR pUri, IN ULONG Length, IN ULONG Flags, PUL_APP_POOL_PROCESS pProcess ) { // // sanity check // PAGED_CODE(); ASSERT( IS_VALID_AP_PROCESS(pProcess) ); ASSERT(!g_UriCacheConfig.EnableCache || IS_VALID_HASHTABLE(&g_UriCacheTable)); if (g_UriCacheConfig.EnableCache) { UlTrace(URI_CACHE, ( "Http!UlFlushCacheByUri(\n" " uri = '%S'\n" " len = %d\n" " flags = %08x\n" " proc = %p\n", pUri, Length, Flags, pProcess )); if (Flags & HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE) { // // CODEWORK: restrict the flush to the ones they actually // asked for! // UlpFilteredFlushUriCache(UlpFlushFilterProcess, pProcess); } else { UlpFlushUri( pUri, Length, pProcess ); UlpClearZombieList(); } } } // UlFlushCacheByUri /***************************************************************************++ Routine Description: Removes a single URI from the table if the name and process match an entry. Arguments: --***************************************************************************/ VOID UlpFlushUri( IN PWSTR pUri, IN ULONG Length, PUL_APP_POOL_PROCESS pProcess ) { PUL_URI_CACHE_ENTRY pUriCacheEntry = NULL; URI_KEY Key; LONG ReferenceCount; // // Sanity check // PAGED_CODE(); // // find bucket // Key.Hash = HashRandomizeBits(HashStringNoCaseW(pUri, 0)); Key.Length = Length; Key.pUri = pUri; pUriCacheEntry = UlDeleteFromHashTable(&g_UriCacheTable, &Key); if (NULL != pUriCacheEntry) { ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); UlTrace(URI_CACHE, ( "Http!UlpFlushUri(pUriCacheEntry %p '%ls') refcount = %d\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, pUriCacheEntry->ReferenceCount)); DEREFERENCE_URI_CACHE_ENTRY(pUriCacheEntry, FLUSH); // // Perfmon counters // UlIncCounter(HttpGlobalCounterTotalFlushedUris); } } // UlpFlushUri /***************************************************************************++ Routine Description: A filter for UlFlushCacheByProcess. Called by UlpFilteredFlushUriCache. Arguments: pUriCacheEntry - the entry to check pContext - pointer to the UL_APP_POOL_PROCESS that's going away --***************************************************************************/ UL_CACHE_PREDICATE UlpFlushFilterProcess( IN PUL_URI_CACHE_ENTRY pUriCacheEntry, IN PVOID pContext ) { PURI_FILTER_CONTEXT pUriFilterContext = (PURI_FILTER_CONTEXT) pContext; PUL_APP_POOL_PROCESS pProcess; // // Sanity check // PAGED_CODE(); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT( pUriFilterContext != NULL && URI_FILTER_CONTEXT_POOL_TAG == pUriFilterContext->Signature && pUriFilterContext->pCallerContext != NULL ); pProcess = (PUL_APP_POOL_PROCESS) pUriFilterContext->pCallerContext; ASSERT( IS_VALID_AP_PROCESS(pProcess) ); return UlpZombifyEntry( (pProcess == pUriCacheEntry->pProcess), pUriCacheEntry, pUriFilterContext ); } // UlpFlushFilterProcess /***************************************************************************++ Routine Description: Checks the hash table to make sure there is room for one more entry of a given size. This routine must be called with the table resource held. Arguments: EntrySize - the size in bytes of the entry to be added --***************************************************************************/ BOOLEAN UlpCheckTableSpace( IN ULONGLONG EntrySize ) { ULONG UriCount; ULONGLONG ByteCount; UriCount = g_UriCacheStats.UriCount + 1; ByteCount = g_UriCacheStats.ByteCount + EntrySize; // // CODEWORK: MaxCacheMegabyteCount of zero should mean adaptive limit, // but for now I'll take it to mean "no limit". // if (g_UriCacheConfig.MaxCacheMegabyteCount == 0) { ByteCount = 0; } // // MaxCacheUriCount of zero means no limit on number of URIs cached // if (g_UriCacheConfig.MaxCacheUriCount == 0) { UriCount = 0; } if ( UriCount <= g_UriCacheConfig.MaxCacheUriCount && ByteCount <= (g_UriCacheConfig.MaxCacheMegabyteCount << MEGABYTE_SHIFT) ) { return TRUE; } else { UlTrace(URI_CACHE, ( "Http!UlpCheckTableSpace(%d) FALSE\n" " UriCount = %d\n" " ByteCount = %I64d (%dMB)\n" " MaxCacheUriCount = %d\n" " MaxCacheMegabyteCount = %dMB\n", EntrySize, g_UriCacheStats.UriCount, g_UriCacheStats.ByteCount, g_UriCacheStats.ByteCount >> MEGABYTE_SHIFT, g_UriCacheConfig.MaxCacheUriCount, g_UriCacheConfig.MaxCacheMegabyteCount )); return FALSE; } } // UlpCheckTableSpace /***************************************************************************++ Routine Description: Tries to add a cache entry to the hash table. Arguments: pUriCacheEntry - the entry to be added --***************************************************************************/ VOID UlAddCacheEntry( PUL_URI_CACHE_ENTRY pUriCacheEntry ) { ULC_RETCODE rc = ULC_SUCCESS; // // Sanity check // PAGED_CODE(); ASSERT(!g_UriCacheConfig.EnableCache || IS_VALID_HASHTABLE(&g_UriCacheTable)); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT(! pUriCacheEntry->Zombie); pUriCacheEntry->BucketEntry.Next = NULL; pUriCacheEntry->Cached = FALSE; // First, check if still has space for storing the cache entry if (UlpCheckSpaceAndAddEntryStats(pUriCacheEntry)) { pUriCacheEntry->Cached = TRUE; // // Insert this record into the hash table // Check first to see if the key already presents // rc = UlAddToHashTable(&g_UriCacheTable, pUriCacheEntry); } UlTrace(URI_CACHE, ( "Http!UlAddCacheEntry(urientry %p '%ls') %s added to table. " "RefCount=%d, lkrc=%d.\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, pUriCacheEntry->Cached ? "was" : "was not", pUriCacheEntry->ReferenceCount, rc )); } // UlAddCacheEntry /***************************************************************************++ Routine Description: Check to see if we have space to add this cache entry and if so update cache statistics to reflect the addition of an entry. This has to be done together inside a lock. Arguments: pUriCacheEntry - entry being added --***************************************************************************/ BOOLEAN UlpCheckSpaceAndAddEntryStats( PUL_URI_CACHE_ENTRY pUriCacheEntry ) { KIRQL OldIrql; ULONG EntrySize; // // Sanity check // ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); EntrySize = pUriCacheEntry->HeaderLength + pUriCacheEntry->ContentLength; if (!pUriCacheEntry->LongTermCacheable) { // // Schedule the scavenger immediately, but only do it once // if (FALSE == InterlockedExchange(&g_UriScavengerRunning, TRUE)) { UL_QUEUE_WORK_ITEM( &g_UriScavengerWorkItem, &UlpScavenger ); } return FALSE; } UlAcquireSpinLock( &g_UriCacheSpinLock, &OldIrql ); if (UlpCheckTableSpace(EntrySize)) { g_UriCacheStats.UriCount++; g_UriCacheStats.UriAddedTotal++; g_UriCacheStats.UriCountMax = MAX( g_UriCacheStats.UriCountMax, g_UriCacheStats.UriCount ); g_UriCacheStats.ByteCount += EntrySize; g_UriCacheStats.ByteCountMax = MAX( g_UriCacheStats.ByteCountMax, g_UriCacheStats.ByteCount ); UlReleaseSpinLock( &g_UriCacheSpinLock, OldIrql ); UlTrace(URI_CACHE, ( "Http!UlpCheckSpaceAndAddEntryStats (urientry %p '%ls')\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri )); // // Perfmon counters // UlIncCounter(HttpGlobalCounterCurrentUrisCached); UlIncCounter(HttpGlobalCounterTotalUrisCached); return TRUE; } UlReleaseSpinLock( &g_UriCacheSpinLock, OldIrql ); return FALSE; } // UlpCheckSpaceAndAddEntryStats /***************************************************************************++ Routine Description: Updates cache statistics to reflect the removal of an entry Arguments: pUriCacheEntry - entry being added --***************************************************************************/ VOID UlpRemoveEntryStats( PUL_URI_CACHE_ENTRY pUriCacheEntry ) { KIRQL OldIrql; ULONG EntrySize; // // Sanity check // ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT( pUriCacheEntry->Cached ); EntrySize = pUriCacheEntry->HeaderLength + pUriCacheEntry->ContentLength; UlAcquireSpinLock( &g_UriCacheSpinLock, &OldIrql ); g_UriCacheStats.UriCount--; g_UriCacheStats.ByteCount -= EntrySize; UlReleaseSpinLock( &g_UriCacheSpinLock, OldIrql ); UlTrace(URI_CACHE, ( "Http!UlpRemoveEntryStats (urientry %p '%ls')\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri )); // // Perfmon counters // UlDecCounter(HttpGlobalCounterCurrentUrisCached); } // UlpRemoveEntryStats /***************************************************************************++ Routine Description: Helper function for the filter callbacks indirectly invoked by UlpFilteredFlushUriCache. Adds deleteable entries to a temporary list. Arguments: MustZombify - if TRUE, add entry to the private zombie list pUriCacheEntry - entry to zombify pUriFilterContext - contains private list --***************************************************************************/ UL_CACHE_PREDICATE UlpZombifyEntry( BOOLEAN MustZombify, IN PUL_URI_CACHE_ENTRY pUriCacheEntry, IN PURI_FILTER_CONTEXT pUriFilterContext ) { ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT(URI_FILTER_CONTEXT_POOL_TAG == pUriFilterContext->Signature); ASSERT(! pUriCacheEntry->Zombie); ASSERT(NULL == pUriCacheEntry->ZombieListEntry.Flink); if (MustZombify) { // // Temporarily bump the refcount up so that it won't go down // to zero when it's removed from the hash table, automatically // invoking UlpDestroyUriCacheEntry, which we are trying to defer. // pUriCacheEntry->ZombieAddReffed = TRUE; REFERENCE_URI_CACHE_ENTRY(pUriCacheEntry, ZOMBIFY); InsertTailList( &pUriFilterContext->ZombieListHead, &pUriCacheEntry->ZombieListEntry); pUriCacheEntry->Zombie = TRUE; // // reset timer so we can track how long an entry is on the list // pUriCacheEntry->ScavengerTicks = 0; ++ pUriFilterContext->ZombieCount; // now remove it from the hash table return ULC_DELETE; } // do not remove pUriCacheEntry from table return ULC_NO_ACTION; } // UlpZombifyEntry /***************************************************************************++ Routine Description: Adds a list of entries to the global zombie list, then calls UlpClearZombieList. This cleans up the list of deferred deletions built up by UlpFilteredFlushUriCache. Runs at passive level. Arguments: pWorkItem - workitem within a URI_FILTER_CONTEXT containing private list --***************************************************************************/ VOID UlpZombifyList( IN PUL_WORK_ITEM pWorkItem ) { PAGED_CODE(); ASSERT(NULL != pWorkItem); PURI_FILTER_CONTEXT pUriFilterContext = CONTAINING_RECORD(pWorkItem, URI_FILTER_CONTEXT, WorkItem); ASSERT(URI_FILTER_CONTEXT_POOL_TAG == pUriFilterContext->Signature); UlTrace(URI_CACHE, ( "http!UlpZombifyList, ctxt = %p\n", pUriFilterContext )); UlAcquireResourceExclusive(&g_pUlNonpagedData->UriZombieResource, TRUE); // // Splice the entire private list into the head of the Zombie list // ASSERT(! IsListEmpty(&pUriFilterContext->ZombieListHead)); PLIST_ENTRY pContextHead = pUriFilterContext->ZombieListHead.Flink; PLIST_ENTRY pContextTail = pUriFilterContext->ZombieListHead.Blink; PLIST_ENTRY pZombieHead = g_ZombieListHead.Flink; pContextTail->Flink = pZombieHead; pZombieHead->Blink = pContextTail; g_ZombieListHead.Flink = pContextHead; pContextHead->Blink = &g_ZombieListHead; // Update stats g_UriCacheStats.ZombieCount += pUriFilterContext->ZombieCount; g_UriCacheStats.ZombieCountMax = MAX(g_UriCacheStats.ZombieCount, g_UriCacheStats.ZombieCountMax); #if DBG PLIST_ENTRY pEntry; ULONG ZombieCount; // Walk forwards through the zombie list and check that it contains // exactly as many valid zombied UriCacheEntries as we expect. for (pEntry = g_ZombieListHead.Flink, ZombieCount = 0; pEntry != &g_ZombieListHead; pEntry = pEntry->Flink, ++ZombieCount) { PUL_URI_CACHE_ENTRY pUriCacheEntry = CONTAINING_RECORD(pEntry, UL_URI_CACHE_ENTRY, ZombieListEntry); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT(pUriCacheEntry->Zombie); ASSERT(pUriCacheEntry->ZombieAddReffed ? pUriCacheEntry->ScavengerTicks == 0 : pUriCacheEntry->ScavengerTicks > 0); ASSERT(ZombieCount < g_UriCacheStats.ZombieCount); } ASSERT(ZombieCount == g_UriCacheStats.ZombieCount); // And backwards too, like Ginger Rogers for (pEntry = g_ZombieListHead.Blink, ZombieCount = 0; pEntry != &g_ZombieListHead; pEntry = pEntry->Blink, ++ZombieCount) { PUL_URI_CACHE_ENTRY pUriCacheEntry = CONTAINING_RECORD(pEntry, UL_URI_CACHE_ENTRY, ZombieListEntry); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT(pUriCacheEntry->Zombie); ASSERT(pUriCacheEntry->ZombieAddReffed ? pUriCacheEntry->ScavengerTicks == 0 : pUriCacheEntry->ScavengerTicks > 0); ASSERT(ZombieCount < g_UriCacheStats.ZombieCount); } ASSERT(ZombieCount == g_UriCacheStats.ZombieCount); #endif // DBG UlReleaseResource(&g_pUlNonpagedData->UriZombieResource); UL_FREE_POOL_WITH_SIG(pUriFilterContext, URI_FILTER_CONTEXT_POOL_TAG); // Now purge those entries, if there are no outstanding references UlpClearZombieList(); } // UlpZombifyList /***************************************************************************++ Routine Description: Removes entries based on a caller specified filter. The caller provides a boolean function which takes a cache entry as a parameter. The function will be called with each item in the cache. The function should conclude with a call to UlpZombifyEntry, passing in whether or not the item should be deleted. See sample usage elsewhere in this file. Arguments: pFilterRoutine - A pointer to the filter function pCallerContext - a parameter to the filter function --***************************************************************************/ VOID UlpFilteredFlushUriCache( IN PUL_URI_FILTER pFilterRoutine, IN PVOID pCallerContext ) { PURI_FILTER_CONTEXT pUriFilterContext; LONG ZombieCount = 0; // // sanity check // PAGED_CODE(); ASSERT( NULL != pFilterRoutine ); // // Perfmon counters // UlIncCounter(HttpGlobalCounterUriCacheFlushes); pUriFilterContext = UL_ALLOCATE_STRUCT( NonPagedPool, URI_FILTER_CONTEXT, URI_FILTER_CONTEXT_POOL_TAG); if (pUriFilterContext == NULL) return; pUriFilterContext->Signature = URI_FILTER_CONTEXT_POOL_TAG; InitializeListHead(&pUriFilterContext->ZombieListHead); pUriFilterContext->pCallerContext = pCallerContext; pUriFilterContext->ZombieCount = 0; UlTrace(URI_CACHE, ( "Http!UlFilteredFlushUriCache(filt = %p, ctxt = %p)\n", pFilterRoutine, pUriFilterContext )); if (IS_VALID_HASHTABLE(&g_UriCacheTable)) { ZombieCount = UlFilterFlushHashTable( &g_UriCacheTable, pFilterRoutine, pUriFilterContext ); ASSERT(ZombieCount == pUriFilterContext->ZombieCount); if (0 != ZombieCount) { UlAddCounter(HttpGlobalCounterTotalFlushedUris, ZombieCount); UL_QUEUE_WORK_ITEM( &pUriFilterContext->WorkItem, UlpZombifyList ); } else { UL_FREE_POOL_WITH_SIG(pUriFilterContext, URI_FILTER_CONTEXT_POOL_TAG); } UlTrace(URI_CACHE, ( "Http!UlFilteredFlushUriCache(filt = %p, caller ctxt = %p)" " Zombified: %d\n", pFilterRoutine, pCallerContext, ZombieCount )); } } // UlpFilteredFlushUriCache /***************************************************************************++ Routine Description: Scans the zombie list for entries whose refcount has dropped to "zero". (The calling routine is generally expected to have added a reference (and set the ZombieAddReffed field within the entries), so that otherwise unreferenced entries will actually have a refcount of one. It works this way because we don't want the scavenger directly triggering calls to UlpDestroyUriCacheEntry) --***************************************************************************/ VOID UlpClearZombieList( VOID ) { ULONG ZombiesFreed = 0; ULONG ZombiesSpared = 0; PLIST_ENTRY pCurrent; LONG ReferenceCount; // // sanity check // PAGED_CODE(); UlAcquireResourceExclusive(&g_pUlNonpagedData->UriZombieResource, TRUE); pCurrent = g_ZombieListHead.Flink; while (pCurrent != &g_ZombieListHead) { PUL_URI_CACHE_ENTRY pUriCacheEntry = CONTAINING_RECORD(pCurrent, UL_URI_CACHE_ENTRY, ZombieListEntry); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT(pUriCacheEntry->Zombie); // // get next entry now, because we might destroy this one // pCurrent = pCurrent->Flink; // // ReferenceCount is modified with interlocked ops, but in // this case we know the ReferenceCount can't go up on // a Zombie, and if an entry hits one just after we look // at it, we'll just get it on the next pass // if (pUriCacheEntry->ZombieAddReffed) { bool LastRef = (pUriCacheEntry->ReferenceCount == 1); if (LastRef) { RemoveEntryList(&pUriCacheEntry->ZombieListEntry); pUriCacheEntry->ZombieListEntry.Flink = NULL; ++ ZombiesFreed; ASSERT(g_UriCacheStats.ZombieCount > 0); -- g_UriCacheStats.ZombieCount; } else { // track age of zombie ++ pUriCacheEntry->ScavengerTicks; ++ ZombiesSpared; } pUriCacheEntry->ZombieAddReffed = FALSE; DEREFERENCE_URI_CACHE_ENTRY(pUriCacheEntry, UNZOMBIFY); } else { ASSERT(pUriCacheEntry->ScavengerTicks > 0); // If we've released the zombie reference on it and it's still // on the zombie list, somebody'd better have a reference. ASSERT(pUriCacheEntry->ReferenceCount > 0); // track age of zombie ++ pUriCacheEntry->ScavengerTicks; ++ ZombiesSpared; if (pUriCacheEntry->ScavengerTicks > ZOMBIE_AGE_THRESHOLD) { UlTrace(URI_CACHE, ( "Http!UlpClearZombieList()\n" " WARNING: %p '%ls' (refs = %d) " "has been a zombie for %d ticks!\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, pUriCacheEntry->ReferenceCount, pUriCacheEntry->ScavengerTicks )); } } } ASSERT(ZombiesSpared == g_UriCacheStats.ZombieCount); ASSERT((g_UriCacheStats.ZombieCount == 0) == IsListEmpty(&g_ZombieListHead)); UlReleaseResource(&g_pUlNonpagedData->UriZombieResource); UlTrace(URI_CACHE, ( "Http!UlpClearZombieList(): Freed = %d, Remaining = %d.\n", ZombiesFreed, ZombiesSpared )); } // UlpClearZombieList /***************************************************************************++ Routine Description: Frees a URI entry to the pool. Removes references to other objects. Arguments: pTracker - Supplies the UL_READ_TRACKER to manipulate. --***************************************************************************/ VOID UlpDestroyUriCacheEntry( PUL_URI_CACHE_ENTRY pUriCacheEntry ) { // // Sanity check // PAGED_CODE(); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); // CODEWORK: real cleanup will need to release // config & process references. ASSERT(0 == pUriCacheEntry->ReferenceCount); UlTrace(URI_CACHE, ( "Http!UlpDestroyUriCacheEntry: Entry %p, '%ls', Refs=%d\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, pUriCacheEntry->ReferenceCount )); // // Release the UL_URL_CONFIG_GROUP_INFO block // UlpConfigGroupInfoRelease(&pUriCacheEntry->ConfigInfo); UlLargeMemFree(pUriCacheEntry->pResponseMdl); // // Remove from g_ZombieListHead if neccessary // if (pUriCacheEntry->ZombieListEntry.Flink != NULL) { ASSERT(pUriCacheEntry->Zombie); ASSERT(! pUriCacheEntry->ZombieAddReffed); UlAcquireResourceExclusive( &g_pUlNonpagedData->UriZombieResource, TRUE); RemoveEntryList(&pUriCacheEntry->ZombieListEntry); ASSERT(g_UriCacheStats.ZombieCount > 0); -- g_UriCacheStats.ZombieCount; UlReleaseResource(&g_pUlNonpagedData->UriZombieResource); } UL_FREE_POOL_WITH_SIG( pUriCacheEntry, UL_URI_CACHE_ENTRY_POOL_TAG ); } // UlpDestroyUriCacheEntry /***************************************************************************++ Routine Description: Initializes the cache scavenger. --***************************************************************************/ VOID UlpInitializeScavenger( VOID ) { UlTrace(URI_CACHE, ( "Http!UlpInitializeScavenger\n" )); g_UriScavengerInitialized = TRUE; g_UriScavengerRunning = FALSE; UlInitializeSpinLock( &g_UriScavengerSpinLock, "g_UriScavengerSpinLock" ); KeInitializeDpc( &g_UriScavengerDpc, // DPC object &UlpScavengerDpcRoutine, // DPC routine NULL // context ); KeInitializeTimer( &g_UriScavengerTimer ); KeInitializeEvent( &g_UriScavengerTerminationEvent, NotificationEvent, FALSE ); UlpSetScavengerTimer(); } // UlpInitializeScavenger /***************************************************************************++ Routine Description: Increments the current chunk pointer in the tracker and initializes some of the "from file" related tracker fields if necessary. Arguments: pTracker - Supplies the UL_READ_TRACKER to manipulate. --***************************************************************************/ VOID UlpTerminateScavenger( VOID ) { KIRQL oldIrql; UlTrace(URI_CACHE, ( "Http!UlpTerminateScavenger\n" )); if (g_UriScavengerInitialized) { // // Clear the "initialized" flag. If the scavenger runs soon, // it will see this flag, set the termination event, and exit // quickly. // UlAcquireSpinLock( &g_UriScavengerSpinLock, &oldIrql ); g_UriScavengerInitialized = FALSE; UlReleaseSpinLock( &g_UriScavengerSpinLock, oldIrql ); // // Cancel the scavenger timer. If the cancel fails, then the // scavenger is either running or scheduled to run soon. In // either case, wait for it to terminate. // if ( !KeCancelTimer( &g_UriScavengerTimer ) ) { KeWaitForSingleObject( (PVOID)&g_UriScavengerTerminationEvent, UserRequest, KernelMode, FALSE, NULL ); } } // // clear out anything remaining // UlpClearZombieList(); // // The EndpointDrain should have closed all connections and released // all references to cache entries // ASSERT( g_UriCacheStats.ZombieCount == 0 ); ASSERT( IsListEmpty(&g_ZombieListHead) ); } // UlpTerminateScavenger /***************************************************************************++ Routine Description: Figures out the scavenger interval in 100 ns ticks, and sets the timer. --***************************************************************************/ VOID UlpSetScavengerTimer( VOID ) { LARGE_INTEGER ScavengerInterval; // // convert seconds to 100 nanosecond intervals (x * 10^7) // negative numbers mean relative time // ScavengerInterval.QuadPart= g_UriCacheConfig.ScavengerPeriod * -C_NS_TICKS_PER_SEC; UlTrace(URI_CACHE, ( "Http!UlpSetScavengerTimer: %d seconds = %I64d 100ns ticks\n", g_UriCacheConfig.ScavengerPeriod, ScavengerInterval.QuadPart )); KeSetTimer( &g_UriScavengerTimer, ScavengerInterval, &g_UriScavengerDpc ); } // UlpSetScavengerTimer /***************************************************************************++ Routine Description: Executes every UriScavengerPeriodSeconds, or when our timer gets cancelled (on shutdown). If we're not shutting down, we run the UlpScavenger (at passive level). Arguments: I ignore all of these. --***************************************************************************/ VOID UlpScavengerDpcRoutine( IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2 ) { // UlTrace(URI_CACHE, ( // "Http!UlpScavengerDpcRoutine(...)\n" // )); UlAcquireSpinLockAtDpcLevel( &g_UriScavengerSpinLock ); if( !g_UriScavengerInitialized ) { // // We're shutting down, so signal the termination event. // KeSetEvent( &g_UriScavengerTerminationEvent, 0, FALSE ); } else { // // Do that scavenger thang. // if (FALSE == InterlockedExchange(&g_UriScavengerRunning, TRUE)) { UL_QUEUE_WORK_ITEM( &g_UriScavengerWorkItem, &UlpScavenger ); } } UlReleaseSpinLockFromDpcLevel( &g_UriScavengerSpinLock ); } // UlpScavengerDpcRoutine /***************************************************************************++ Routine Description: Looks through the cache for expired entries to put on the zombie list, and then empties out the list. Arguments: pWorkItem - ignored --***************************************************************************/ VOID UlpScavenger( IN PUL_WORK_ITEM pWorkItem ) { KIRQL oldIrql; UlTrace(URI_CACHE, ( "Http!UlpScavenger()\n" )); ASSERT( TRUE == g_UriScavengerRunning ); ASSERT( &g_UriScavengerWorkItem == pWorkItem ); if (g_UriScavengerInitialized) { UlpFilteredFlushUriCache(UlpFlushFilterScavenger, NULL); // // allow other instances of the scavenger to run // InterlockedExchange(&g_UriScavengerRunning, FALSE); } UlAcquireSpinLock(&g_UriScavengerSpinLock, &oldIrql); if (g_UriScavengerInitialized) { // // restart the timer // UlpSetScavengerTimer(); } else { KeSetEvent( &g_UriScavengerTerminationEvent, 0, FALSE ); } UlReleaseSpinLock(&g_UriScavengerSpinLock, oldIrql); } // UlpScavenger /***************************************************************************++ Routine Description: A filter for UlpScavenger. Called by UlpFilteredFlushUriCache. Arguments: pUriCacheEntry - the entry to check pContext - ignored --***************************************************************************/ UL_CACHE_PREDICATE UlpFlushFilterScavenger( IN PUL_URI_CACHE_ENTRY pUriCacheEntry, IN PVOID pContext ) { PURI_FILTER_CONTEXT pUriFilterContext = (PURI_FILTER_CONTEXT) pContext; // // Sanity check // PAGED_CODE(); ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); ASSERT( pUriFilterContext != NULL && URI_FILTER_CONTEXT_POOL_TAG == pUriFilterContext->Signature && pUriFilterContext->pCallerContext == NULL ); pUriCacheEntry->ScavengerTicks++; // // CODEWORK: need to check for expiration time as well // return UlpZombifyEntry( (pUriCacheEntry->ScavengerTicks > CACHE_ENTRY_AGE_THRESHOLD), pUriCacheEntry, pUriFilterContext ); } // UlpFlushFilterScavenger /***************************************************************************++ Routine Description: Determine if the Translate header is present AND has a value of 'F' or 'f'. Arguments: pRequest - Supplies the request to query. Return Value: BOOLEAN - TRUE if "Translate: F", FALSE otherwise --***************************************************************************/ BOOLEAN UlpQueryTranslateHeader( IN PUL_INTERNAL_REQUEST pRequest ) { BOOLEAN ret = FALSE; if ( pRequest->HeaderValid[HttpHeaderTranslate] ) { PUCHAR pValue = pRequest->Headers[HttpHeaderTranslate].pHeader; ASSERT(NULL != pValue); if ('f' == pValue[0] || 'F' == pValue[0]) { ret = TRUE; } } return ret; } // UlpQueryTranslateHeader /***************************************************************************++ Routine Description: Add a reference on a cache entry Arguments: pUriCacheEntry - the entry to addref --***************************************************************************/ LONG UlAddRefUriCacheEntry( IN PUL_URI_CACHE_ENTRY pUriCacheEntry, IN REFTRACE_ACTION Action REFERENCE_DEBUG_FORMAL_PARAMS ) { ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); LONG RefCount = InterlockedIncrement(&pUriCacheEntry->ReferenceCount); WRITE_REF_TRACE_LOG( g_UriTraceLog, Action, RefCount, pUriCacheEntry, pFileName, LineNumber ); UlTrace(URI_CACHE, ( "Http!UlAddRefUriCacheEntry: Entry %p, refcount=%d.\n", pUriCacheEntry, RefCount )); ASSERT(RefCount > 0); return RefCount; } // UlAddRefUriCacheEntry /***************************************************************************++ Routine Description: Release a reference on a cache entry Arguments: pUriCacheEntry - the entry to release --***************************************************************************/ LONG UlReleaseUriCacheEntry( IN PUL_URI_CACHE_ENTRY pUriCacheEntry, IN REFTRACE_ACTION Action REFERENCE_DEBUG_FORMAL_PARAMS ) { ASSERT( IS_VALID_URI_CACHE_ENTRY(pUriCacheEntry) ); LONG RefCount = InterlockedDecrement(&pUriCacheEntry->ReferenceCount); WRITE_REF_TRACE_LOG( g_UriTraceLog, Action, RefCount, pUriCacheEntry, pFileName, LineNumber ); UlTrace(URI_CACHE, ( "Http!UlReleaseUriCacheEntry: (pUriCacheEntry %p '%ls')" "refcount = %d\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri, RefCount )); ASSERT(RefCount >= 0); if (RefCount == 0) { if (pUriCacheEntry->Cached) UlpRemoveEntryStats(pUriCacheEntry); UlpDestroyUriCacheEntry(pUriCacheEntry); } return RefCount; } // UlReleaseUriCacheEntry /***************************************************************************++ Routine Description: UL_URI_CACHE_ENTRY pseudo-constructor. Primarily used for AddRef and tracelogging. Arguments: pUriCacheEntry - the entry to initialize Hash - Hash code of pUrl Length - Length (in bytes) of pUrl pUrl - Unicode URL to copy --***************************************************************************/ VOID UlInitCacheEntry( PUL_URI_CACHE_ENTRY pUriCacheEntry, ULONG Hash, ULONG Length, PCWSTR pUrl ) { pUriCacheEntry->Signature = UL_URI_CACHE_ENTRY_POOL_TAG; pUriCacheEntry->ReferenceCount = 0; pUriCacheEntry->HitCount = 1; pUriCacheEntry->Zombie = FALSE; pUriCacheEntry->ZombieAddReffed = FALSE; pUriCacheEntry->ZombieListEntry.Flink = NULL; pUriCacheEntry->ZombieListEntry.Blink = NULL; pUriCacheEntry->Cached = FALSE; pUriCacheEntry->ScavengerTicks = 0; pUriCacheEntry->UriKey.Hash = Hash; pUriCacheEntry->UriKey.Length = Length; pUriCacheEntry->UriKey.pUri = (PWSTR) ((PCHAR)pUriCacheEntry + ALIGN_UP(sizeof(UL_URI_CACHE_ENTRY), PVOID)); RtlCopyMemory( pUriCacheEntry->UriKey.pUri, pUrl, pUriCacheEntry->UriKey.Length + sizeof(WCHAR) ); REFERENCE_URI_CACHE_ENTRY(pUriCacheEntry, CREATE); UlTrace(URI_CACHE, ( "Http!UlInitCacheEntry (%p = '%ls')\n", pUriCacheEntry, pUriCacheEntry->UriKey.pUri )); } // UlInitCacheEntry