Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

exp.h File Reference

#include "ntos.h"
#include "zwapi.h"
#include "wdbgexts.h"
#include "ntdbg.h"
#include "ki.h"
#include "stdio.h"
#include "pool.h"

Go to the source code of this file.

Classes

struct  EXP_INITIALIZE_GLOBAL_CALLBACKS
struct  _EXP_LICENSE_INFO

Defines

#define NOEXTAPI

Typedefs

typedef _EXP_LICENSE_INFO EXP_LICENSE_INFO
typedef _EXP_LICENSE_INFO * PEXP_LICENSE_INFO

Functions

BOOLEAN ExpWorkerInitialization (VOID)
BOOLEAN ExpEventInitialization (VOID)
BOOLEAN ExpEventPairInitialization (VOID)
BOOLEAN ExpMutantInitialization (VOID)
BOOLEAN ExpSemaphoreInitialization (VOID)
BOOLEAN ExpTimerInitialization (VOID)
BOOLEAN ExpWin32Initialization (VOID)
BOOLEAN ExpResourceInitialization (VOID)
PVOID ExpCheckForResource (IN PVOID p, IN ULONG Size)
BOOLEAN ExpInitSystemPhase0 (VOID)
BOOLEAN ExpInitSystemPhase1 (VOID)
BOOLEAN ExpProfileInitialization ()
BOOLEAN ExpUuidInitialization ()
VOID ExpProfileDelete (IN PVOID Object)
BOOLEAN ExpInitializeCallbacks (VOID)
BOOLEAN ExpSysEventInitialization (VOID)
VOID ExpCheckSystemInfoWork (IN PVOID Context)
VOID ExInitSystemPhase2 (VOID)
VOID ExpCheckSystemInformation (PVOID Context, PVOID InformationClass, PVOID Argument2)
VOID ExpTimeZoneWork (IN PVOID Context)
VOID ExpTimeRefreshDpcRoutine (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
VOID ExpTimeRefreshWork (IN PVOID Context)
VOID ExpTimeZoneDpcRoutine (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
VOID ExInitializeTimeRefresh (VOID)
VOID ExpExpirationThread (IN PVOID StartContext)
ULONG ExpComputeTickCountMultiplier (IN ULONG TimeIncrement)
BOOLEAN ExpWatchProductTypeInitialization (VOID)
VOID ExpWatchProductTypeWork (IN PVOID Context)
VOID ExpWatchLicenseInfoWork (IN PVOID Context)
VOID ExpWatchSystemPrefixWork (IN PVOID Context)
VOID ExpWatchExpirationDataWork (IN PVOID Context)
PVOID ExpCheckForWorker (IN PVOID p, IN ULONG Size)

Variables

ULONG ExpNtExpirationData [3]
BOOLEAN ExpSetupModeDetected
LARGE_INTEGER ExpSetupSystemPrefix
HANDLE ExpSetupKey
BOOLEAN ExpSystemPrefixValid
WCHAR ExpWstrCallback []
EXP_INITIALIZE_GLOBAL_CALLBACKS ExpInitializeCallback []
FAST_MUTEX ExpEnvironmentLock
NPAGED_LOOKASIDE_LIST ExpSmallPagedPoolLookasideLists [POOL_SMALL_LISTS]
NPAGED_LOOKASIDE_LIST ExpSmallNPagedPoolLookasideLists [POOL_SMALL_LISTS]
LIST_ENTRY ExNPagedLookasideListHead
KSPIN_LOCK ExNPagedLookasideLock
LIST_ENTRY ExPagedLookasideListHead
KSPIN_LOCK ExPagedLookasideLock
LIST_ENTRY ExPoolLookasideListHead

Define Documentation

#define NOEXTAPI
 

Definition at line 31 of file exp.h.

Typedef Documentation

typedef struct _EXP_LICENSE_INFO EXP_LICENSE_INFO
 

typedef struct _EXP_LICENSE_INFO * PEXP_LICENSE_INFO
 

Function Documentation

VOID ExInitializeTimeRefresh (  VOID   ) 
 

VOID ExInitSystemPhase2 (  VOID   ) 
 

PVOID ExpCheckForResource (  IN PVOID  p,
IN ULONG  Size
) 
 

Definition at line 2894 of file ex/resource.c.

References DbgPrint, ExpResourceSpinLock, ExpSystemResourcesList, KeNumberProcessors, NULL, Resource, and Size.

Referenced by ExFreePoolSanityChecks(), and MmUnloadSystemImage(). 

02899 {
02900 
02901     KIRQL OldIrql;
02902     PLIST_ENTRY Head, Next;
02903     PERESOURCE Resource;
02904     PCHAR BeginBlock;
02905     PCHAR EndBlock;
02906 
02907     //
02908     // This can cause a deadlock on MP machines.
02909     //
02910 
02911     if (KeNumberProcessors > 1) {
02912         return NULL;
02913     }
02914 
02915     BeginBlock = (PCHAR)p;
02916     EndBlock = (PCHAR)p + Size;
02917 
02918     ExAcquireSpinLock( &ExpResourceSpinLock, &OldIrql );
02919     Head = &ExpSystemResourcesList;
02920     Next = Head->Flink;
02921     while (Next != Head) {
02922         Resource = CONTAINING_RECORD( Next,
02923                                       ERESOURCE,
02924                                       SystemResourcesList
02925                                     );
02926 
02927         if ((PCHAR)Resource >= BeginBlock && (PCHAR)Resource < EndBlock) {
02928             DbgPrint( "EX: ExFreePool( %lx, %lx ) contains an ERESOURCE structure that has not been ExDeleteResourced\n",
02929                       p, Size
02930                     );
02931             DbgBreakPoint();
02932             ExReleaseSpinLock( &ExpResourceSpinLock, OldIrql );
02933             return (PVOID)Resource;
02934         }
02935 
02936         Next = Next->Flink;
02937     }
02938 
02939     ExReleaseSpinLock( &ExpResourceSpinLock, OldIrql );
02940     return NULL;
02941 }

PVOID ExpCheckForWorker (  IN PVOID  p,
IN ULONG  Size
) 
 

Definition at line 1097 of file worker.c.

References CriticalWorkQueue, _KQUEUE::EntryListHead, ExWorkerQueue, KeBugCheckEx(), KiLockDispatcherDatabase, KiUnlockDispatcherDatabase(), MaximumWorkQueue, NULL, Size, WORK_QUEUE_TYPE, and _EX_WORK_QUEUE::WorkerQueue. 

01102 {
01103     KIRQL OldIrql;
01104     PLIST_ENTRY Entry;
01105     PCHAR BeginBlock;
01106     PCHAR EndBlock;
01107     WORK_QUEUE_TYPE wqt;
01108 
01109     BeginBlock = (PCHAR)p;
01110     EndBlock = (PCHAR)p + Size;
01111 
01112     KiLockDispatcherDatabase (&OldIrql);
01113     for (wqt = CriticalWorkQueue; wqt < MaximumWorkQueue; wqt++) {
01114         for (Entry = (PLIST_ENTRY) ExWorkerQueue[wqt].WorkerQueue.EntryListHead.Flink;
01115              Entry && (Entry != (PLIST_ENTRY) &ExWorkerQueue[wqt].WorkerQueue.EntryListHead);
01116              Entry = Entry->Flink) {
01117            if (((PCHAR) Entry >= BeginBlock) && ((PCHAR) Entry < EndBlock)) {
01118               KeBugCheckEx(WORKER_INVALID,
01119                            0x0,
01120                            (ULONG_PTR)Entry,
01121                            (ULONG_PTR)BeginBlock,
01122                            (ULONG_PTR)EndBlock);
01123  
01124            }
01125         }
01126     }
01127     KiUnlockDispatcherDatabase (OldIrql);
01128 
01129     return NULL;
01130 }

VOID ExpCheckSystemInformation (  PVOID  Context,
PVOID  InformationClass,
PVOID  Argument2
) 
 

VOID ExpCheckSystemInfoWork (  IN PVOID  Context  ) 
 

ULONG ExpComputeTickCountMultiplier (  IN ULONG  TimeIncrement  ) 
 

BOOLEAN ExpEventInitialization (  VOID   ) 
 

BOOLEAN ExpEventPairInitialization (  VOID   ) 
 

VOID ExpExpirationThread (  IN PVOID  StartContext  ) 
 

BOOLEAN ExpInitializeCallbacks (  VOID   ) 
 

BOOLEAN ExpInitSystemPhase0 (  VOID   ) 
 

BOOLEAN ExpInitSystemPhase1 (  VOID   ) 
 

BOOLEAN ExpMutantInitialization (  VOID   ) 
 

VOID ExpProfileDelete (  IN PVOID  Object  ) 
 

Definition at line 145 of file ex/profile.c.

References ASSERT, ExFreePool(), FALSE, KeStopProfile(), _EPROFILE::LockedBufferAddress, _EPROFILE::Mdl, MmUnlockPages(), MmUnmapLockedPages(), NULL, ObDereferenceObject, PEPROFILE, _EPROFILE::Process, and _EPROFILE::ProfileObject.

Referenced by ExpProfileInitialization(). 

00151                    :
00152 
00153 
00154     This routine is called by the object management procedures whenever
00155     the last reference to a profile object has been removed.  This routine
00156     stops profiling, returns locked buffers and pages, dereferences the
00157     specified process and returns.
00158 
00159 Arguments:
00160 
00161     Object - a pointer to the body of the profile object.
00162 
00163 Return Value:
00164 
00165     None.
00166 
00167 --*/
00168 
00169 {
00170     PEPROFILE Profile;
00171     BOOLEAN   State;
00172     PEPROCESS ProcessAddress;
00173 
00174     Profile = (PEPROFILE)Object;
00175 
00176     if (Profile->LockedBufferAddress != NULL) {
00177 
00178         //
00179         // Stop profiling and unlock the buffers and deallocate pool.
00180         //
00181 
00182         State = KeStopProfile (Profile->ProfileObject);
00183         ASSERT (State != FALSE);
00184 
00185         MmUnmapLockedPages (Profile->LockedBufferAddress, Profile->Mdl);
00186         MmUnlockPages (Profile->Mdl);
00187         ExFreePool (Profile->ProfileObject);
00188     }
00189 
00190     if (Profile->Process != NULL) {
00191         ProcessAddress = CONTAINING_RECORD(Profile->Process, EPROCESS, Pcb);
00192         ObDereferenceObject ((PVOID)ProcessAddress);
00193     }
00194 
00195     return;
00196 }

BOOLEAN ExpProfileInitialization (   ) 
 

Definition at line 79 of file ex/profile.c.

References ExpProfileDelete(), ExpProfileMapping, ExpProfileStateMutex, ExProfileObjectType, KeInitializeMutex(), L, MUTEX_LEVEL_EX_PROFILE, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, ObCreateObjectType(), RtlInitUnicodeString(), and Status. 

00084                    :
00085 
00086     This function creates the profile object type descriptor at system
00087     initialization and stores the address of the object type descriptor
00088     in global storage.
00089 
00090 Arguments:
00091 
00092     None.
00093 
00094 Return Value:
00095 
00096     A value of TRUE is returned if the profile object type descriptor is
00097     successfully initialized. Otherwise a value of FALSE is returned.
00098 
00099 --*/
00100 
00101 {
00102 
00103     OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
00104     NTSTATUS Status;
00105     UNICODE_STRING TypeName;
00106 
00107     //
00108     // Initialize mutex for synchronizing start and stop operations.
00109     //
00110 
00111     KeInitializeMutex (&ExpProfileStateMutex, MUTEX_LEVEL_EX_PROFILE);
00112 
00113     //
00114     // Initialize string descriptor.
00115     //
00116 
00117     RtlInitUnicodeString(&TypeName, L"Profile");
00118 
00119     //
00120     // Create event object type descriptor.
00121     //
00122 
00123     RtlZeroMemory(&ObjectTypeInitializer,sizeof(ObjectTypeInitializer));
00124     ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
00125     ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
00126     ObjectTypeInitializer.PoolType = NonPagedPool;
00127     ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(EPROFILE);
00128     ObjectTypeInitializer.ValidAccessMask = PROFILE_ALL_ACCESS;
00129     ObjectTypeInitializer.DeleteProcedure = ExpProfileDelete;
00130     ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
00131 
00132     Status = ObCreateObjectType(&TypeName,
00133                                 &ObjectTypeInitializer,
00134                                 (PSECURITY_DESCRIPTOR)NULL,
00135                                 &ExProfileObjectType);
00136 
00137     //
00138     // If the event object type descriptor was successfully created, then
00139     // return a value of TRUE. Otherwise return a value of FALSE.
00140     //
00141 
00142     return (BOOLEAN)(NT_SUCCESS(Status));
00143 }
VOID

BOOLEAN ExpResourceInitialization (  VOID   ) 
 

Definition at line 150 of file ex/resource.c.

References _RESOURCE_PERFORMANCE_DATA::ActiveResourceCount, _RESOURCE_PERFORMANCE_DATA::ExclusiveAcquire, ExpResourceSpinLock, ExpSystemResourcesList, ExpTimeout, _RESOURCE_PERFORMANCE_DATA::HashTable, Index, KeInitializeSpinLock(), _RESOURCE_PERFORMANCE_DATA::MaximumTableExpand, _RESOURCE_PERFORMANCE_DATA::OwnerTableExpands, RESOURCE_HASH_TABLE_SIZE, _RESOURCE_PERFORMANCE_DATA::SharedFirstLevel, _RESOURCE_PERFORMANCE_DATA::SharedSecondLevel, _RESOURCE_PERFORMANCE_DATA::StarveFirstLevel, _RESOURCE_PERFORMANCE_DATA::StarveSecondLevel, _RESOURCE_PERFORMANCE_DATA::TotalResourceCount, TRUE, and _RESOURCE_PERFORMANCE_DATA::WaitForExclusive. 

00156                    :
00157 
00158     This function initializes global data during system initialization.
00159 
00160 Arguments:
00161 
00162     None.
00163 
00164 Return Value:
00165 
00166     BOOLEAN - TRUE
00167 
00168 --*/
00169 
00170 {
00171 
00172     ULONG Index;
00173 
00174     //
00175     // Initialize resource timeout value, the system resource listhead,
00176     // and the resource spinlock.
00177     //
00178 
00179     ExpTimeout.QuadPart = Int32x32To64(4 * 1000, -10000);
00180     InitializeListHead(&ExpSystemResourcesList);
00181     KeInitializeSpinLock(&ExpResourceSpinLock);
00182 
00183     //
00184     // Initialize resource performance data.
00185     //
00186 
00187 #if defined(_COLLECT_RESOURCE_DATA_)
00188 
00189     ExpResourcePerformanceData.ActiveResourceCount = 0;
00190     ExpResourcePerformanceData.TotalResourceCount = 0;
00191     ExpResourcePerformanceData.ExclusiveAcquire = 0;
00192     ExpResourcePerformanceData.SharedFirstLevel = 0;
00193     ExpResourcePerformanceData.SharedSecondLevel = 0;
00194     ExpResourcePerformanceData.StarveFirstLevel = 0;
00195     ExpResourcePerformanceData.StarveSecondLevel = 0;
00196     ExpResourcePerformanceData.WaitForExclusive = 0;
00197     ExpResourcePerformanceData.OwnerTableExpands = 0;
00198     ExpResourcePerformanceData.MaximumTableExpand = 0;
00199     for (Index = 0; Index < RESOURCE_HASH_TABLE_SIZE; Index += 1) {
00200         InitializeListHead(&ExpResourcePerformanceData.HashTable[Index]);
00201     }
00202 
00203 #endif
00204 
00205     return TRUE;
00206 }

BOOLEAN ExpSemaphoreInitialization (  VOID   ) 
 

BOOLEAN ExpSysEventInitialization (  VOID   ) 
 

VOID ExpTimeRefreshDpcRoutine (  IN PKDPC  Dpc,
IN PVOID  DeferredContext,
IN PVOID  SystemArgument1,
IN PVOID  SystemArgument2
) 
 

VOID ExpTimeRefreshWork (  IN PVOID  Context  ) 
 

BOOLEAN ExpTimerInitialization (  VOID   ) 
 

VOID ExpTimeZoneDpcRoutine (  IN PKDPC  Dpc,
IN PVOID  DeferredContext,
IN PVOID  SystemArgument1,
IN PVOID  SystemArgument2
) 
 

VOID ExpTimeZoneWork (  IN PVOID  Context  ) 
 

BOOLEAN ExpUuidInitialization (   ) 
 

VOID ExpWatchExpirationDataWork (  IN PVOID  Context  )  [static]
 

VOID ExpWatchLicenseInfoWork (  IN PVOID  Context  )  [static]
 

BOOLEAN ExpWatchProductTypeInitialization (  VOID   )  [static]
 

VOID ExpWatchProductTypeWork (  IN PVOID  Context  )  [static]
 

VOID ExpWatchSystemPrefixWork (  IN PVOID  Context  )  [static]
 

BOOLEAN ExpWin32Initialization (  VOID   ) 
 

BOOLEAN ExpWorkerInitialization (  VOID   ) 
 

Definition at line 220 of file worker.c.

References CriticalWorkQueue, DelayedWorkQueue, ExCriticalWorkerThreads, ExDelayedWorkerThreads, ExpAdditionalCriticalWorkerThreads, ExpAdditionalDelayedWorkerThreads, ExpCreateWorkerThread(), ExpWorkerThreadBalanceManager(), ExThreadSetManagerEvent, ExWorkerQueue, FALSE, HyperCriticalWorkQueue, Index, KeInitializeEvent, KeInitializeQueue(), L, LARGE_NUMBER_OF_THREADS, _EX_WORK_QUEUE::MakeThreadsAsNecessary, MAX_ADDITIONAL_THREADS, MaximumWorkQueue, MEDIUM_NUMBER_OF_THREADS, MmIsThisAnNtAsSystem(), MmLargeSystem, MmMediumSystem, MmNumberOfPhysicalPages, MmQuerySystemSize(), MmSmallSystem, NT_SUCCESS, NTSTATUS(), NULL, ObjectAttributes, PAGE_SIZE, PsCreateSystemThread(), SMALL_NUMBER_OF_THREADS, Status, TRUE, and WORK_QUEUE_TYPE. 

00224 {
00225 
00226     ULONG Index;
00227     OBJECT_ATTRIBUTES ObjectAttributes;
00228     ULONG NumberOfDelayedThreads;
00229     ULONG NumberOfCriticalThreads;
00230     NTSTATUS Status;
00231     HANDLE Thread;
00232     BOOLEAN NtAs;
00233     WORK_QUEUE_TYPE WorkQueueType;
00234 
00235     //
00236     // Set the number of worker threads based on the system size.
00237     //
00238 
00239     NtAs = MmIsThisAnNtAsSystem();
00240     switch (MmQuerySystemSize()) {
00241     case MmSmallSystem:
00242         NumberOfDelayedThreads = MEDIUM_NUMBER_OF_THREADS;
00243         if (MmNumberOfPhysicalPages > ((12*1024*1024)/PAGE_SIZE) ) {
00244             NumberOfCriticalThreads = MEDIUM_NUMBER_OF_THREADS;
00245         } else {
00246             NumberOfCriticalThreads = SMALL_NUMBER_OF_THREADS;
00247         }
00248         break;
00249 
00250     case MmMediumSystem:
00251         NumberOfDelayedThreads = MEDIUM_NUMBER_OF_THREADS;
00252         NumberOfCriticalThreads = MEDIUM_NUMBER_OF_THREADS;
00253         if ( NtAs ) {
00254             NumberOfCriticalThreads += MEDIUM_NUMBER_OF_THREADS;
00255             }
00256         break;
00257 
00258     case MmLargeSystem:
00259         NumberOfDelayedThreads = MEDIUM_NUMBER_OF_THREADS;
00260         NumberOfCriticalThreads = LARGE_NUMBER_OF_THREADS;
00261         if ( NtAs ) {
00262             NumberOfCriticalThreads += LARGE_NUMBER_OF_THREADS;
00263             }
00264         break;
00265 
00266     default:
00267         NumberOfDelayedThreads = SMALL_NUMBER_OF_THREADS;
00268         NumberOfCriticalThreads = SMALL_NUMBER_OF_THREADS;
00269     }
00270 
00271 
00272     //
00273     // Initialize the work Queue objects.
00274     //
00275 
00276     if ( ExpAdditionalCriticalWorkerThreads > MAX_ADDITIONAL_THREADS ) {
00277         ExpAdditionalCriticalWorkerThreads = MAX_ADDITIONAL_THREADS;
00278         }
00279 
00280     if ( ExpAdditionalDelayedWorkerThreads > MAX_ADDITIONAL_THREADS ) {
00281         ExpAdditionalDelayedWorkerThreads = MAX_ADDITIONAL_THREADS;
00282         }
00283 
00284     //
00285     // Initialize the ExWorkerQueue[] array.
00286     // 
00287 
00288     for (WorkQueueType = 0; WorkQueueType < MaximumWorkQueue; WorkQueueType++) {
00289 
00290         RtlZeroMemory(&ExWorkerQueue[WorkQueueType],
00291                       sizeof(EX_WORK_QUEUE));
00292 
00293         KeInitializeQueue(&ExWorkerQueue[WorkQueueType].WorkerQueue, 0);
00294     }
00295 
00296     //
00297     // We only create dynamic threads for the critical work queue (note
00298     // this doesn't apply to dynamic threads created to break deadlocks.)
00299     //
00300     // The rationale is this: folks who use the delayed work queue are
00301     // not time critical, and the hypercritical queue is used rarely
00302     // by folks who are non-blocking.
00303     //
00304 
00305     ExWorkerQueue[CriticalWorkQueue].MakeThreadsAsNecessary = TRUE;
00306 
00307     //
00308     // Initialize the global thread set manager event.
00309     //
00310 
00311     KeInitializeEvent(&ExThreadSetManagerEvent,
00312                       SynchronizationEvent,
00313                       FALSE);
00314 
00315     //
00316     // Create the desired number of executive worker threads for each
00317     // of the work queues.
00318     //
00319 
00320     InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
00321 
00322     //
00323     // Create any builtin critical and delayed worker threads.
00324     //
00325 
00326     for (Index = 0; Index < (NumberOfCriticalThreads + ExpAdditionalCriticalWorkerThreads); Index += 1) {
00327 
00328         //
00329         // Create a worker thread to service the critical work queue.
00330         //
00331 
00332         Status = ExpCreateWorkerThread( CriticalWorkQueue, FALSE );
00333         if (!NT_SUCCESS(Status)) {
00334             break;
00335         }
00336         ExCriticalWorkerThreads++;
00337     }
00338 
00339 
00340     for (Index = 0; Index < (NumberOfDelayedThreads + ExpAdditionalDelayedWorkerThreads); Index += 1) {
00341 
00342         //
00343         // Create a worker thread to service the delayed work queue.
00344         //
00345 
00346         Status = ExpCreateWorkerThread( DelayedWorkQueue, FALSE );
00347         if (!NT_SUCCESS(Status)) {
00348             break;
00349         }
00350 
00351         ExDelayedWorkerThreads++;
00352     }
00353 
00354     Status = ExpCreateWorkerThread( HyperCriticalWorkQueue, FALSE );
00355 
00356     //
00357     // Create the worker thread set manager thread.
00358     //
00359 
00360     Status = PsCreateSystemThread(&Thread,
00361                                   THREAD_ALL_ACCESS,
00362                                   &ObjectAttributes,
00363                                   0L,
00364                                   NULL,
00365                                   ExpWorkerThreadBalanceManager,
00366                                   NULL);
00367     if (NT_SUCCESS(Status)) {
00368         ZwClose( Thread );
00369     }
00370 
00371     return (BOOLEAN)NT_SUCCESS(Status);
00372 }

Variable Documentation

LIST_ENTRY ExNPagedLookasideListHead
 

Definition at line 262 of file exp.h.

Referenced by ExAdjustLookasideDepth(), ExInitializeNPagedLookasideList(), and ExpGetLookasideInformation().

KSPIN_LOCK ExNPagedLookasideLock
 

Definition at line 263 of file exp.h.

Referenced by ExAdjustLookasideDepth(), ExDeleteNPagedLookasideList(), ExInitializeNPagedLookasideList(), and ExpGetLookasideInformation().

LIST_ENTRY ExPagedLookasideListHead
 

Definition at line 264 of file exp.h.

Referenced by ExAdjustLookasideDepth(), ExInitializePagedLookasideList(), and ExpGetLookasideInformation().

KSPIN_LOCK ExPagedLookasideLock
 

Definition at line 265 of file exp.h.

Referenced by ExAdjustLookasideDepth(), ExDeletePagedLookasideList(), ExInitializePagedLookasideList(), and ExpGetLookasideInformation().

FAST_MUTEX ExpEnvironmentLock
 

Definition at line 257 of file exp.h.

Referenced by NtQuerySystemEnvironmentValue(), and NtSetSystemEnvironmentValue().

EXP_INITIALIZE_GLOBAL_CALLBACKS ExpInitializeCallback[]
 

Definition at line 254 of file exp.h.

Referenced by ExpInitializeCallbacks().

ULONG ExpNtExpirationData[3]
 

Definition at line 236 of file exp.h.

LIST_ENTRY ExPoolLookasideListHead
 

Definition at line 266 of file exp.h.

Referenced by ExAdjustLookasideDepth(), ExpGetLookasideInformation(), and ExQueryPoolUsage().

HANDLE ExpSetupKey
 

Definition at line 239 of file exp.h.

BOOLEAN ExpSetupModeDetected
 

Definition at line 237 of file exp.h.

LARGE_INTEGER ExpSetupSystemPrefix
 

Definition at line 238 of file exp.h.

NPAGED_LOOKASIDE_LIST ExpSmallNPagedPoolLookasideLists[POOL_SMALL_LISTS]
 

Definition at line 260 of file exp.h.

NPAGED_LOOKASIDE_LIST ExpSmallPagedPoolLookasideLists[POOL_SMALL_LISTS]
 

Definition at line 259 of file exp.h.

BOOLEAN ExpSystemPrefixValid
 

Definition at line 240 of file exp.h.

WCHAR ExpWstrCallback[]
 

Definition at line 253 of file exp.h.

Referenced by ExpInitializeCallbacks().

Generated on Sat May 15 19:43:36 2004 for test by doxygen 1.3.7