test: exp.h File Reference

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