ReactOS  0.4.15-dev-3187-ge372f2b
fxpool.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  FX_POOL_HEADER
 
struct  FX_POOL
 

Macros

#define FX_POOL_HEADER_SIZE   FIELD_OFFSET(FX_POOL_HEADER, AllocationStart)
 

Typedefs

typedef FX_POOL_HEADERPFX_POOL_HEADER
 
typedef FX_POOLPFX_POOL
 
typedef FX_POOL_TRACKER * PFX_POOL_TRACKER
 

Functions

struct DECLSPEC_ALIGN (MEMORY_ALLOCATION_ALIGNMENT) FX_POOL_TRACKER
 
_Must_inspect_result_ NTSTATUS FxPoolInitialize (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
 
VOID FxPoolDestroy (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
 
_Must_inspect_result_ PWDF_DRIVER_GLOBALS FxAllocateDriverGlobals (VOID)
 
VOID FxFreeDriverGlobals (__in PWDF_DRIVER_GLOBALS DriverGlobals)
 
BOOLEAN FxIsPagedPoolType (__in POOL_TYPE Type)
 
PVOID FxPoolAllocator (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool, __in POOL_TYPE Type, __in SIZE_T Size, __in ULONG Tag, __in PVOID CallersAddress)
 
void FxPoolFree (__in_xcount(ptr is at an offset from AllocationStart) PVOID ptr)
 
NTSTATUS FxPoolDump (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
 
_Must_inspect_result_ NTSTATUS FxPoolPackageInitialize (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
 
VOID FxPoolPackageDestroy (__in PFX_DRIVER_GLOBALS FxDriverGlobals)
 

Macro Definition Documentation

◆ FX_POOL_HEADER_SIZE

#define FX_POOL_HEADER_SIZE   FIELD_OFFSET(FX_POOL_HEADER, AllocationStart)

Definition at line 53 of file fxpool.h.

Typedef Documentation

◆ PFX_POOL

typedef FX_POOL* PFX_POOL

Definition at line 85 of file fxpool.h.

◆ PFX_POOL_HEADER

Definition at line 51 of file fxpool.h.

◆ PFX_POOL_TRACKER

typedef FX_POOL_TRACKER* PFX_POOL_TRACKER

Definition at line 107 of file fxpool.h.

Function Documentation

◆ DECLSPEC_ALIGN()

struct DECLSPEC_ALIGN ( MEMORY_ALLOCATION_ALIGNMENT  )

Definition at line 100 of file fxpool.h.

100  {
102  PFX_POOL Pool;
103  ULONG Tag;
104  SIZE_T Size;
106  PVOID CallersAddress;
107 };
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
static int Link(const char **args)
Definition: vfdcmd.c:2414
Definition: fxpool.h:63
INT POOL_TYPE
Definition: typedefs.h:78
Definition: bufpool.h:50
Definition: typedefs.h:119
_Must_inspect_result_ _In_ WDFDEVICE _In_ BOOLEAN _In_opt_ PVOID Tag
Definition: wdfdevice.h:4061
ULONG_PTR SIZE_T
Definition: typedefs.h:80
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3810
unsigned int ULONG
Definition: retypes.h:1

◆ FxAllocateDriverGlobals()

_Must_inspect_result_ PWDF_DRIVER_GLOBALS FxAllocateDriverGlobals ( VOID  )

Definition at line 1052 of file globals.cpp.

1055 {
1057  // KIRQL irql;
1058  NTSTATUS status;
1059 
1062 
1063  if (pFxDriverGlobals == NULL) {
1064  return NULL;
1065  }
1066 
1067  *pFxDriverGlobals = {};
1068 
1069  pFxDriverGlobals->Refcnt = 1;
1070 
1072 #if (FX_CORE_MODE==FX_CORE_USER_MODE)
1073  if (!NT_SUCCESS(status)) {
1075  return NULL;
1076  }
1077 #else
1079 #endif
1080 
1081  //
1082  // Initialize this new FxDriverGlobals structure.
1083  //
1084 #ifndef __REACTOS__
1089 #endif
1090 
1097 
1098  //
1099  // Verifier settings. Off by default.
1100  //
1102 
1103  //
1104  // By default don't apply latest-version restricted verifier checks
1105  // to downlevel version drivers.
1106  //
1108 
1109  //
1110  // Verbose is separate knob
1111  //
1113 
1114  //
1115  // Do not parent queue presented requests.
1116  // This performance optimization is on by default.
1117  //
1119 
1120  //
1121  // Enhanced verifier options. Off by default
1122  //
1124 
1125  //
1126  // If FxVerifierDbgBreakOnError is true, WaitForSignal interrupts the
1127  // execution of the system after waiting for the specified number
1128  // of seconds. Developer will have an opportunity to validate the state
1129  // of the driver when breakpoint is hit. Developer can continue to wait
1130  // by entering 'g' in the debugger.
1131  //
1133 
1134  //
1135  // Timeout used by the wake interrupt ISR in WaitForSignal to catch
1136  // scenarios where the interrupt ISR is blocked because the device stack
1137  // is taking too long to power up
1138  //
1140 
1141  //
1142  // Minidump log related settings.
1143  //
1145 
1146 #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
1147  // pFxDriverGlobals->FxTrackDriverForMiniDumpLog = TRUE;
1150 #else
1153 #endif
1154 
1155 #if (FX_CORE_MODE==FX_CORE_KERNEL_MODE)
1156  //
1157  // Minidump driver info related settings.
1158  //
1160 #endif
1161 
1162  //
1163  // By default disable the support for device simulation framework (DSF).
1164  //
1166 
1167  //
1168  // Allocate a telemetry context if a telemetry client is enabled, for any level/keyword.
1169  //
1171 #ifdef EVENT_TRACING // __REACTOS__
1172  if (TraceLoggingProviderEnabled(g_TelemetryProvider, 0 ,0)) {
1174  }
1175 #endif
1176 
1177  return &pFxDriverGlobals->Public;
1178 }
BOOLEAN FxTrackDriverForMiniDumpLog
Definition: fxglobals.h:483
MxEvent DestroyEvent
Definition: fxglobals.h:351
BOOLEAN FxRequestParentOptimizationOn
Definition: fxglobals.h:467
BOOLEAN FxVerboseOn
Definition: fxglobals.h:462
#define TRUE
Definition: types.h:120
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
VOID SetVerifierState(__in BOOLEAN State)
Definition: fxglobals.h:236
LONG NTSTATUS
Definition: precomp.h:26
LONG WdfVerifierAllocateFailCount
Definition: fxglobals.h:362
ULONG DbgWaitForWakeInterruptIsrTimeoutInSec
Definition: fxglobals.h:534
KIRQL irql
Definition: wave.h:1
FxDriverGlobalsDebugExtension * DebugExtension
Definition: fxglobals.h:376
BOOLEAN IsUserModeDriver
Definition: fxglobals.h:488
static __inline VOID MxFreePool(__in PVOID Ptr)
Definition: mxmemorykm.h:41
CHECK_RETURN_IF_USER_MODE __inline NTSTATUS Initialize(__in EVENT_TYPE Type, __in BOOLEAN InitialState)
Definition: mxeventkm.h:55
LIST_ENTRY Linkage
Definition: fxglobals.h:339
#define FALSE
Definition: types.h:117
static __inline PVOID MxAllocatePoolWithTag(__in POOL_TYPE PoolType, __in SIZE_T NumberOfBytes, __in ULONG Tag)
Definition: mxmemorykm.h:30
FxDriver * Driver
Definition: fxglobals.h:374
ULONG FxEnhancedVerifierOptions
Definition: fxglobals.h:518
#define FX_TAG
Definition: fxmacros.hpp:155
DECLSPEC_SELECTANY const ULONG_PTR FxHandleValueMask
PFX_DRIVER_GLOBALS pFxDriverGlobals
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID AllocAndInitializeTelemetryContext(_In_ PFX_TELEMETRY_CONTEXT *TelemetryContext)
PFX_TELEMETRY_CONTEXT TelemetryContext
Definition: fxglobals.h:540
ULONG FxVerifierDbgWaitForSignalTimeoutInSec
Definition: fxglobals.h:527
FxLibraryGlobalsType FxLibraryGlobals
Definition: globals.cpp:95
FxLibraryGlobalsType * LibraryGlobals
Definition: fxglobals.h:378
#define NULL
Definition: types.h:112
BOOLEAN FxVerifyDownlevel
Definition: fxglobals.h:426
unsigned int ULONG
Definition: retypes.h:1
ULONG_PTR WdfHandleMask
Definition: fxglobals.h:356
static SERVICE_STATUS status
Definition: service.c:31
struct _FX_DRIVER_GLOBALS * PFX_DRIVER_GLOBALS
Definition: fxforward.hpp:7
ULONG BugCheckDriverInfoIndex
Definition: fxglobals.h:506
BOOLEAN FxForceLogsInMiniDump
Definition: fxglobals.h:477
LIST_ENTRY FxDriverGlobalsList
Definition: fxglobals.h:774
MxLockNoDynam FxDriverGlobalsListLock
Definition: fxglobals.h:772
Definition: ps.c:97

Referenced by FxLibraryCommonRegisterClient(), and RosInitWdf().

◆ FxFreeDriverGlobals()

VOID FxFreeDriverGlobals ( __in PWDF_DRIVER_GLOBALS  DriverGlobals)

Definition at line 1181 of file globals.cpp.

1184 {
1186  KIRQL irql;
1187 
1189 
1194 
1196 
1198 
1202  }
1203 
1205 
1208  }
1209 
1210  //
1211  // Cleanup event b/c d'tor is not called for MxAllocatePoolWithTag.
1212  //
1214 
1218  }
1219 
1221 }
__inline VOID Uninitialize()
Definition: mxeventkm.h:146
MxEvent DestroyEvent
Definition: fxglobals.h:351
FxObjectDebugInfo * ObjectDebugInfo
Definition: fxglobals.h:118
VOID FxFreeAllocatedMdlsDebugInfo(__in FxDriverGlobalsDebugExtension *DebugExtension)
Definition: globalskm.cpp:20
KIRQL irql
Definition: wave.h:1
FxDriverGlobalsDebugExtension * DebugExtension
Definition: fxglobals.h:376
DriverGlobals
static __inline VOID MxFreePool(__in PVOID Ptr)
Definition: mxmemorykm.h:41
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
UCHAR KIRQL
Definition: env_spec_w32.h:591
LIST_ENTRY Linkage
Definition: fxglobals.h:339
PFX_DRIVER_GLOBALS pFxDriverGlobals
__inline VOID Uninitialize()
Definition: mxlockkm.h:104
PFX_TELEMETRY_CONTEXT TelemetryContext
Definition: fxglobals.h:540
FxLibraryGlobalsType FxLibraryGlobals
Definition: globals.cpp:95
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define NULL
Definition: types.h:112
__inline PFX_DRIVER_GLOBALS GetFxDriverGlobals(__in PWDF_DRIVER_GLOBALS DriverGlobals)
Definition: fxglobals.h:597
MxLockNoDynam FxDriverGlobalsListLock
Definition: fxglobals.h:772

Referenced by FxLibraryCommonUnregisterClient().

◆ FxIsPagedPoolType()

BOOLEAN FxIsPagedPoolType ( __in POOL_TYPE  Type)

Definition at line 43 of file wdfpool.cpp.

60 {
61  //
62  // Cleaner than doing (Type & 0x01)
63  //
64  switch( Type & (~POOL_COLD_ALLOCATION) ) {
65  case PagedPool:
67  return TRUE;
68 
69  default:
70  return FALSE;
71  }
72 }
#define TRUE
Definition: types.h:120
#define POOL_COLD_ALLOCATION
#define FALSE
Definition: types.h:117
Type
Definition: Type.h:6

Referenced by FxMemoryBufferFromPool::_Create(), FxMemoryObject::_Create(), FxPoolAllocator(), FxPoolFree(), and FxMemoryBuffer::operator new().

◆ FxPoolAllocator()

PVOID FxPoolAllocator ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals,
__in PFX_POOL  Pool,
__in POOL_TYPE  Type,
__in SIZE_T  Size,
__in ULONG  Tag,
__in PVOID  CallersAddress 
)

Definition at line 76 of file wdfpool.cpp.

125 {
126  PVOID ptr;
127  PCHAR pTrueBase;
128  PFX_POOL_TRACKER pTracker;
131  SIZE_T allocationSize;
132 
133 
134  ptr = NULL;
135 
136  //
137  // Allocations of a zero request size are invalid.
138  //
139  // Besides, with a zero request size, special pool could place us
140  // at the end of a page, and adding our header would give us a page
141  // aligned address, which is ambiguous with large allocations.
142  //
143  if (Size == 0) {
145  "Invalid Allocation Size of 0 requested");
146  FxVerifierDbgBreakPoint(FxDriverGlobals);
147  return NULL;
148  }
149 
150  if (FxDriverGlobals->IsPoolTrackingOn()) {
151 
152  if (FxDriverGlobals->FxVerifierOn &&
153  (FxDriverGlobals->WdfVerifierAllocateFailCount != -1L)) {
154 
155  //
156  // If the registry key VerifierAllocateFailCount is set, all allocations
157  // after the specified count are failed.
158  //
159  // This is a brutal test, but also ensures the framework can cleanup
160  // under low memory conditions as well.
161  //
162  if (FxDriverGlobals->WdfVerifierAllocateFailCount == 0) {
164  "Allocation Fail Count exceeded");
165  return NULL;
166  }
167 
168  // Decrement the count
169  InterlockedDecrement(&FxDriverGlobals->WdfVerifierAllocateFailCount);
170  }
171 
172  //
173  // (Kernel mode only) PAGE_SIZE or greater allocations can not have our
174  // header since this would break the system allocators contract
175  // that PAGE_SIZE or greater allocations start on a whole page boundary
176  //
177 
178  //
179  // For allocations less than a page size that will not fit with our
180  // header, we round up to a non-tracked whole page allocation so
181  // we don't burn two pages for this boundary condition.
182  //
183 
184  // This if is the same as
185  // Size + sizeof(FX_POOL_TRACKER) + FX_POOL_HEADER_SIZE >= PAGE_SIZE
186  // BUT with no integer overflow
187  if (Mx::IsKM() &&
188  (Size >= PAGE_SIZE - sizeof(FX_POOL_TRACKER) - FX_POOL_HEADER_SIZE)
189  ) {
190 
191  //
192  // Ensure that we ask for at least a page to ensure the
193  // allocation starts on a whole page.
194  //
195  if (Size < PAGE_SIZE) {
196  Size = PAGE_SIZE;
197  }
198 
200 
201  //
202  // The current system allocator returns paged aligned memory
203  // in this case, which we rely on to detect whether our header
204  // is present or not in FxPoolFree
205  //
206  ASSERT(((ULONG_PTR)ptr & (PAGE_SIZE-1)) == 0);
207  }
208  else {
209 
210  status = RtlSIZETAdd(Size,
211  sizeof(FX_POOL_TRACKER) + FX_POOL_HEADER_SIZE,
212  &allocationSize);
213 
214  if (!NT_SUCCESS(status)) {
216  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
217  "overflow: allocation tracker (%d) + header (%d) + pool "
218  "request (%I64d)", sizeof(FX_POOL_TRACKER),
220 
221  return NULL;
222  }
223 
225  Type,
226  allocationSize,
227  Tag
228  );
229 
230  if (pTrueBase == NULL) {
231  return NULL;
232  }
233 
234  pTracker = (PFX_POOL_TRACKER) pTrueBase;
235  pHeader = WDF_PTR_ADD_OFFSET_TYPE(pTrueBase,
236  sizeof(FX_POOL_TRACKER),
238  pHeader->Base = pTrueBase;
239  pHeader->FxDriverGlobals = FxDriverGlobals;
240 
241  //
242  // Adjust the pointer to what we return to the driver
243  //
244  ptr = &pHeader->AllocationStart[0];
245 
246  //
247  // Ensure the pointer we are returning is aligned on the proper
248  // boundary.
249  //
251 
252  //
253  // Ensure the pointer is still not page aligned after
254  // our adjustment. Otherwise the pool free code will
255  // get confused and call ExFreePool on the wrong ptr.
256  //
257  if (Mx::IsKM()) {
258  ASSERT(((ULONG_PTR)ptr & (PAGE_SIZE-1)) != 0 );
259  }
260 
261  //
262  // We must separate paged and non-paged pool since
263  // the lock held differs as to whether we can accept
264  // page faults and block in the allocator.
265  //
266  if (FxIsPagedPoolType(Type)) {
267  //
268  // Format and insert the Tracker in the PagedHeader list.
269  //
271  pTracker,
272  Size,
273  Tag,
274  Caller);
275  }
276  else {
277  //
278  // Format and insert the Tracker in the NonPagedHeader list.
279  //
281  pTracker,
282  Size,
283  Tag,
284  Caller);
285  }
286  }
287  }
288  else {
289  //
290  // No pool tracking...
291  //
292 
293  if ((Size < PAGE_SIZE) || Mx::IsUM())
294  {
295  //
296  // (Kernel mode only) See if adding our header promotes us past a
297  // page boundary
298  //
299  status = RtlSIZETAdd(Size,
301  &allocationSize);
302 
303  if (!NT_SUCCESS(status)) {
305  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPOOL,
306  "overflow: header + pool request (%I64d)", Size);
307 
308  return NULL;
309  }
310 
311  }
312  else {
313  //
314  // Is the raw request for alloc >= PAGE_SIZE ? Then just use it.
315  //
316  allocationSize = Size;
317  }
318 
319  //
320  // Is cooked size for alloc >= PAGE_SIZE ? Then just do it.
321  //
322  if (allocationSize >= PAGE_SIZE && Mx::IsKM())
323  {
324  //
325  // Important to use allocationSize so that we get a page aligned
326  // allocation so that we know to just free the memory pointer as is
327  // when it is freed.
328  //
329  ptr = MxMemory::MxAllocatePoolWithTag(Type, allocationSize, Tag);
330  ASSERT(((ULONG_PTR)ptr & (PAGE_SIZE-1)) == 0);
331  }
332  else {
334  allocationSize,
335  Tag);
336 
337  if (pTrueBase != NULL) {
338 
339  pHeader = (PFX_POOL_HEADER) pTrueBase;
340  pHeader->Base = pTrueBase;
341  pHeader->FxDriverGlobals = FxDriverGlobals;
342 
343  ptr = &pHeader->AllocationStart[0];
344 
345  if (Mx::IsKM()) {
346  //
347  // Ensure the pointer is still not page aligned after
348  // our adjustment. Otherwise the pool free code will
349  // get confused and call ExFreePool on the wrong ptr.
350  //
351  ASSERT( ((ULONG_PTR)ptr & (PAGE_SIZE-1)) != 0 );
352  }
353  }
354  }
355  }
356 
357  return ptr;
358 }
signed char * PCHAR
Definition: retypes.h:7
#define TRACINGPOOL
Definition: dbgtrace.h:62
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN FxIsPagedPoolType(__in POOL_TYPE Type)
Definition: wdfpool.cpp:43
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
VOID __inline FxPoolInsertNonPagedAllocateTracker(__in PFX_POOL Pool, __in PFX_POOL_TRACKER Tracker, __in SIZE_T Size, __in ULONG Tag, __in PVOID Caller)
uint32_t ULONG_PTR
Definition: typedefs.h:65
static __inline PVOID MxAllocatePoolWithTag(__in POOL_TYPE PoolType, __in SIZE_T NumberOfBytes, __in ULONG Tag)
Definition: mxmemorykm.h:30
static PVOID ptr
Definition: dispmode.c:27
FxContextHeader * pHeader
Definition: handleapi.cpp:604
#define PCHAR
Definition: match.c:90
static __inline BOOLEAN IsUM()
Definition: mxgeneralkm.h:45
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Definition: bufpool.h:50
Type
Definition: Type.h:6
FX_POOL_HEADER * PFX_POOL_HEADER
Definition: fxpool.h:51
static const WCHAR L[]
Definition: oid.c:1250
#define InterlockedDecrement
Definition: armddk.h:52
#define PAGE_SIZE
Definition: env_spec_w32.h:49
_Must_inspect_result_ _In_ WDFDEVICE _In_ BOOLEAN _In_opt_ PVOID Tag
Definition: wdfdevice.h:4061
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
ULONG_PTR SIZE_T
Definition: typedefs.h:80
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define NULL
Definition: types.h:112
VOID __inline FxPoolInsertPagedAllocateTracker(__in PFX_POOL Pool, __in PFX_POOL_TRACKER Tracker, __in SIZE_T Size, __in ULONG Tag, __in PVOID Caller)
static __inline BOOLEAN IsKM()
Definition: mxgeneralkm.h:53
static SERVICE_STATUS status
Definition: service.c:31
#define MEMORY_ALLOCATION_ALIGNMENT
Definition: ntbasedef.h:90
FX_POOL_TRACKER * PFX_POOL_TRACKER
Definition: fxpool.h:107
FxVerifierDbgBreakPoint(pFxDriverGlobals)
#define FX_POOL_HEADER_SIZE
Definition: fxpool.h:53
#define WDF_PTR_ADD_OFFSET_TYPE(_ptr, _offset, _type)
Definition: wdfcore.h:141
Definition: ps.c:97

◆ FxPoolDestroy()

VOID FxPoolDestroy ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals,
__in PFX_POOL  Pool 
)

Definition at line 627 of file wdfpool.cpp.

643 {
645  "Destroying Pool 0x%p", Pool);
646 
647  if (FxDriverGlobals->IsPoolTrackingOn()) {
648  FxPoolDump(FxDriverGlobals, Pool);
649 
650 #if FX_CORE_MODE==FX_CORE_KERNEL_MODE
651  FxMdlDump(FxDriverGlobals);
652 #endif
653  //
654  // We don't automatically free memory items since we don't
655  // know what they contain, and who is still referencing them.
656  //
657  }
658 
659  Pool->PagedLock.Uninitialize();
660  Pool->NonPagedLock.Uninitialize();
661 
662  return;
663 }
#define TRACINGPOOL
Definition: dbgtrace.h:62
VOID FxMdlDump(__in PFX_DRIVER_GLOBALS FxDriverGlobals)
Definition: wdfpoolkm.cpp:239
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
Definition: bufpool.h:50
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
NTSTATUS FxPoolDump(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
Definition: wdfpool.cpp:459

Referenced by FxPoolPackageDestroy().

◆ FxPoolDump()

NTSTATUS FxPoolDump ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals,
__in PFX_POOL  Pool 
)

Definition at line 459 of file wdfpool.cpp.

478 {
479  PFX_POOL_TRACKER pTracker;
481  KIRQL oldIrql;
482  BOOLEAN leak;
483 
484  //
485  // Dump usage information
486  //
488  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
489  "FxPoolDump: "
490  "NonPagedBytes %I64d, PagedBytes %I64d, "
491  "NonPagedAllocations %d, PagedAllocations %d,"
492  "PeakNonPagedBytes %I64d, PeakPagedBytes %I64d,"
493  "FxPoolDump: PeakNonPagedAllocations %d, PeakPagedAllocations %d",
494  Pool->NonPagedBytes, Pool->PagedBytes,
495  Pool->NonPagedAllocations, Pool->PagedAllocations,
496  Pool->PeakNonPagedBytes, Pool->PeakPagedBytes,
497  Pool->PeakNonPagedAllocations, Pool->PeakPagedAllocations
498  );
499 
500  leak = FALSE;
501 
502  //
503  // Check paged pool for leaks
504  //
505  Pool->PagedLock.Acquire();
506 
507  for (ple = Pool->PagedHead.Flink; ple != &Pool->PagedHead; ple = ple->Flink) {
508  pTracker = CONTAINING_RECORD(ple, FX_POOL_TRACKER, Link);
509 
510  // Leaker
511  leak = TRUE;
512 
514  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
515  "FX_POOL 0x%p leaked paged memory alloc 0x%p (tracking block %p)",
516  Pool, pTracker + 1, pTracker);
517  }
518 
519  Pool->PagedLock.Release();
520 
521  //
522  // Check non-paged pool for leaks
523  //
524 
525  Pool->NonPagedLock.Acquire(&oldIrql);
526 
527  for (ple = Pool->NonPagedHead.Flink;
528  ple != &Pool->NonPagedHead;
529  ple = ple->Flink) {
530  pTracker = CONTAINING_RECORD(ple, FX_POOL_TRACKER, Link );
531 
532  // Leaker
533  leak = TRUE;
534 
536  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
537  "FX_POOL 0x%p leaked non-paged memory alloc 0x%p (tracking block %p)",
538  Pool, pTracker+1, pTracker);
539  }
540 
541  Pool->NonPagedLock.Release(oldIrql);
542 
543  if (leak) {
544  FxVerifierDbgBreakPoint(FxDriverGlobals);
545  return STATUS_MORE_ENTRIES;
546  }
547  else {
548  return STATUS_SUCCESS;
549  }
550 }
#define TRUE
Definition: types.h:120
static int Link(const char **args)
Definition: vfdcmd.c:2414
PSINGLE_LIST_ENTRY ple
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define FALSE
Definition: types.h:117
unsigned char BOOLEAN
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define TRACINGDEVICE
Definition: dbgtrace.h:58
Definition: bufpool.h:50
Definition: typedefs.h:119
#define STATUS_MORE_ENTRIES
Definition: udferr_usr.h:124
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define STATUS_SUCCESS
Definition: shellext.h:65
FX_POOL_TRACKER * PFX_POOL_TRACKER
Definition: fxpool.h:107
FxVerifierDbgBreakPoint(pFxDriverGlobals)

Referenced by FxPoolDestroy().

◆ FxPoolFree()

void FxPoolFree ( __in_xcount(ptr is at an offset from AllocationStart) PVOID  ptr)

Definition at line 361 of file wdfpool.cpp.

386 {
388  PVOID pTrueBase;
389  PFX_POOL_TRACKER pTracker;
390 
391  //
392  // Null pointers are always bad
393  //
394  if( ptr == NULL ) {
395  ASSERTMSG("NULL pointer freed\n", FALSE);
398  (ULONG_PTR)NULL,
400  (ULONG_PTR)NULL
401  );
402  }
403 
404  //
405  // (Kernel mode only) If ptr is aligned on page boundry (indicates
406  // it was > PAGE_SIZE allocation)
407  // then there will be no common header...just free the memory without
408  // further processing.
409  //
410  if( Mx::IsKM() && ( ((ULONG_PTR)ptr & (PAGE_SIZE-1)) == 0 ) ) {
412  return;
413  }
414 
415  //
416  // Ensure the pointer we are returning is aligned on the proper
417  // boundary.
418  //
420 
421  //
422  // Dereference the Common header which all <PAGE_SIZE allcations will have.
423  //
424  pHeader = CONTAINING_RECORD(ptr, FX_POOL_HEADER, AllocationStart);
425  pTrueBase = pHeader->Base;
426 
427  //
428  // If PoolTracker is on then Base must point to it's header.
429  // This is currently the only option for this area...may change later.
430  //
431  if (pHeader->FxDriverGlobals->IsPoolTrackingOn()) {
432 
433  pTracker = (PFX_POOL_TRACKER) pTrueBase;
434 
435  if (FxIsPagedPoolType(pTracker->PoolType)) {
436  //
437  // Decommission this Paged Allocation tracker
438  //
440  }
441  else {
442  //
443  // Decommission this NonPaged Allocation tracker
444  //
446  }
447 
448  //
449  // Scrub the pool to zeros to catch destructed objects
450  // by NULL'ing the v-table ptr
451  //
452  RtlZeroMemory(pTracker, pTracker->Size + sizeof(FX_POOL_TRACKER));
453  }
454 
455  MxMemory::MxFreePool(pTrueBase);
456 }
BOOLEAN FxIsPagedPoolType(__in POOL_TYPE Type)
Definition: wdfpool.cpp:43
VOID __inline FxPoolRemoveNonPagedAllocateTracker(__in PFX_POOL_TRACKER Tracker)
VOID __inline FxPoolRemovePagedAllocateTracker(__in PFX_POOL_TRACKER Tracker)
uint32_t ULONG_PTR
Definition: typedefs.h:65
static __inline VOID MxFreePool(__in PVOID Ptr)
Definition: mxmemorykm.h:41
#define FALSE
Definition: types.h:117
#define ASSERTMSG(msg, exp)
Definition: nt_native.h:431
static PVOID ptr
Definition: dispmode.c:27
FxContextHeader * pHeader
Definition: handleapi.cpp:604
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define ASSERT(a)
Definition: mode.c:44
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define NULL
Definition: types.h:112
static DECLSPEC_NORETURN VOID MxBugCheckEx(__in ULONG BugCheckCode, __in ULONG_PTR BugCheckParameter1, __in ULONG_PTR BugCheckParameter2, __in ULONG_PTR BugCheckParameter3, __in ULONG_PTR BugCheckParameter4)
Definition: mxgeneralkm.h:133
void * _ReturnAddress(void)
static __inline BOOLEAN IsKM()
Definition: mxgeneralkm.h:53
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define WDF_VIOLATION
Definition: mx.h:37
#define MEMORY_ALLOCATION_ALIGNMENT
Definition: ntbasedef.h:90
FX_POOL_TRACKER * PFX_POOL_TRACKER
Definition: fxpool.h:107

Referenced by AddEventHooksWdfDeviceCreate(), AddEventHooksWdfIoQueueCreate(), FxUsbDeviceStringContext::AllocateDescriptor(), FxUsbInterface::CleanUpAndDelete(), FxIoTargetRemoveOpenParams::Clear(), FxIoContext::ClearBuffer(), FxDevice::CreateSymbolicLink(), FxDevice::DeleteSymbolicLink(), FxDevice::Destroy(), FxIoQueue::Dispose(), FxIoTarget::FormatIoctlRequest(), FxIoTarget::FormatIoRequest(), FxVerifierLock::FreeThreadTable(), FxDuplicateUnicodeString(), FxGetDevicePropertyString(), FxObjectAllocateContext(), GetImageName(), FxUsbDevice::GetString(), FxUsbInterface::MakeAndConfigurePipes(), FxIoTargetRemote::Open(), FxStump::operator delete(), FxCallback::operator delete(), FxDeviceText::operator delete(), FxRelatedDeviceList::operator delete(), FxObject::operator delete(), FxStump::operator delete[](), FxObject::ProcessDestroy(), FxUsbDevice::SelectConfig(), FxUsbDevice::SelectConfigDescriptor(), FxUsbDevice::SelectConfigInterfaces(), FxUsbDevice::SelectConfigMulti(), FxUsbDevice::SelectConfigSingle(), FxUsbInterface::SelectSetting(), FxUsbInterface::SelectSettingByDescriptor(), FxUsbInterface::SelectSettingByIndex(), FxIoContext::SetBufferAndLength(), VfAddContextToHandle(), FxAutoString::~FxAutoString(), FxDevice::~FxDevice(), FxDeviceInterface::~FxDeviceInterface(), FxDeviceText::~FxDeviceText(), FxDriver::~FxDriver(), FxPagedObject::~FxPagedObject(), FxPkgPdo::~FxPkgPdo(), FxQueryInterface::~FxQueryInterface(), FxString::~FxString(), FxUsbDevice::~FxUsbDevice(), FxUsbDeviceStringContext::~FxUsbDeviceStringContext(), FxUsbInterface::~FxUsbInterface(), and FxIrpPreprocessInfo::Info::~Info().

◆ FxPoolInitialize()

_Must_inspect_result_ NTSTATUS FxPoolInitialize ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals,
__in PFX_POOL  Pool 
)

Definition at line 554 of file wdfpool.cpp.

570 {
572 
574  "Initializing Pool 0x%p, Tracking %d",
575  Pool, FxDriverGlobals->IsPoolTrackingOn());
576 
577  Pool->NonPagedLock.Initialize();
578 
579  InitializeListHead( &Pool->NonPagedHead );
580 
581  status = Pool->PagedLock.Initialize();
582  if (!NT_SUCCESS(status)) {
584  "Initializing paged lock failed for Pool 0x%p, "
585  "status %!STATUS!",
586  Pool, status);
587  goto exit;
588  }
589 
590  InitializeListHead( &Pool->PagedHead );
591 
592  // Pool usage information
593  Pool->NonPagedBytes = 0;
594  Pool->PagedBytes = 0;
595 
596  Pool->NonPagedAllocations = 0;
597  Pool->PagedAllocations = 0;
598 
599  Pool->PeakNonPagedBytes = 0;
600  Pool->PeakPagedBytes = 0;
601 
602  Pool->PeakNonPagedAllocations = 0;
603  Pool->PeakPagedAllocations = 0;
604 
605 exit:
606  if (!NT_SUCCESS(status)) {
607  //
608  // We disable pool tracking if we could not initialize the locks needed
609  //
610  // If we don't do this we would need another flag to make FxPoolDestroy
611  // not access the locks
612  //
613  FxDriverGlobals->FxPoolTrackingOn = FALSE;
614  }
615 
616  //
617  // FxPoolDestroy will always be called even if we fail FxPoolInitialize
618  //
619  // FxPoolDestroy will uninitialize locks both in success and failure
620  // cases
621  //
622 
623  return status;
624 }
#define TRACINGPOOL
Definition: dbgtrace.h:62
LONG NTSTATUS
Definition: precomp.h:26
#define FALSE
Definition: types.h:117
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Definition: bufpool.h:50
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
#define STATUS_SUCCESS
Definition: shellext.h:65
void exit(int exitcode)
Definition: _exit.c:33
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by FxPoolPackageInitialize().

◆ FxPoolPackageDestroy()

VOID FxPoolPackageDestroy ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals)

Definition at line 689 of file wdfpool.cpp.

706 {
707  FxPoolDestroy(FxDriverGlobals, &FxDriverGlobals->FxPoolFrameworks);
708  return;
709 }
VOID FxPoolDestroy(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
Definition: wdfpool.cpp:627

Referenced by FxDestroy().

◆ FxPoolPackageInitialize()

_Must_inspect_result_ NTSTATUS FxPoolPackageInitialize ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals)

Definition at line 667 of file wdfpool.cpp.

684 {
685  return FxPoolInitialize(FxDriverGlobals, &FxDriverGlobals->FxPoolFrameworks);
686 }
_Must_inspect_result_ NTSTATUS FxPoolInitialize(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PFX_POOL Pool)
Definition: wdfpool.cpp:554

Referenced by FxInitialize().