ReactOS  0.4.15-dev-5492-g47f3a4e
profile.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS Kernel
4  * FILE: ntoskrnl/ex/profile.c
5  * PURPOSE: Support for Executive Profile Objects
6  * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
7  * Thomas Weidenmueller
8  */
9 
10 /* INCLUDES *****************************************************************/
11 
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15 
16 /* GLOBALS *******************************************************************/
17 
20 
22 {
27 };
28 
29 /* FUNCTIONS *****************************************************************/
30 
31 VOID
32 NTAPI
34 {
35  PEPROFILE Profile;
36  ULONG State;
37 
38  /* Typecast the Object */
39  Profile = ObjectBody;
40 
41  /* Check if there if the Profile was started */
42  if (Profile->LockedBufferAddress)
43  {
44  /* Stop the Profile */
45  State = KeStopProfile(Profile->ProfileObject);
46  ASSERT(State != FALSE);
47 
48  /* Unmap the Locked Buffer */
49  MmUnmapLockedPages(Profile->LockedBufferAddress, Profile->Mdl);
50  MmUnlockPages(Profile->Mdl);
51  IoFreeMdl(Profile->Mdl);
53  }
54 
55  /* Check if a Process is associated and reference it */
56  if (Profile->Process) ObDereferenceObject(Profile->Process);
57 }
58 
59 CODE_SEG("INIT")
60 BOOLEAN
61 NTAPI
63 {
64  OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
67  DPRINT("Creating Profile Object Type\n");
68 
69  /* Initialize the Mutex to lock the States */
71 
72  /* Create the Event Pair Object Type */
73  RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
74  RtlInitUnicodeString(&Name, L"Profile");
75  ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
76  ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KPROFILE);
77  ObjectTypeInitializer.GenericMapping = ExpProfileMapping;
78  ObjectTypeInitializer.PoolType = NonPagedPool;
79  ObjectTypeInitializer.DeleteProcedure = ExpDeleteProfile;
80  ObjectTypeInitializer.ValidAccessMask = PROFILE_ALL_ACCESS;
81  ObjectTypeInitializer.InvalidAttributes = OBJ_OPENLINK;
82  Status = ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &ExProfileObjectType);
83  if (!NT_SUCCESS(Status)) return FALSE;
84  return TRUE;
85 }
86 
88 NTAPI
89 NtCreateProfile(OUT PHANDLE ProfileHandle,
91  IN PVOID RangeBase,
92  IN SIZE_T RangeSize,
93  IN ULONG BucketSize,
94  IN PVOID Buffer,
96  IN KPROFILE_SOURCE ProfileSource,
98 {
99  HANDLE hProfile;
100  PEPROFILE Profile;
101  PEPROCESS pProcess;
105  ULONG Log2 = 0;
106  ULONG_PTR Segment = 0;
107  PAGED_CODE();
108 
109  /* Easy way out */
111 
112  /* Check if this is a low-memory profile */
113  if ((!BucketSize) && (RangeBase < (PVOID)(0x10000)))
114  {
115  /* Validate size */
116  if (BufferSize < sizeof(ULONG)) return STATUS_INVALID_PARAMETER_7;
117 
118  /* This will become a segmented profile object */
119  Segment = (ULONG_PTR)RangeBase;
120  RangeBase = 0;
121 
122  /* Recalculate the bucket size */
123  BucketSize = RangeSize / (BufferSize / sizeof(ULONG));
124 
125  /* Convert it to log2 */
126  BucketSize--;
127  while (BucketSize >>= 1) Log2++;
128  BucketSize += Log2 + 1;
129  }
130 
131  /* Validate bucket size */
132  if ((BucketSize > 31) || (BucketSize < 2))
133  {
134  DPRINT1("Bucket size invalid\n");
136  }
137 
138  /* Make sure that the buckets can map the range */
139  if ((RangeSize >> (BucketSize - 2)) > BufferSize)
140  {
141  DPRINT1("Bucket size too small\n");
143  }
144 
145  /* Make sure that the range isn't too gigantic */
146  if (((ULONG_PTR)RangeBase + RangeSize) < RangeSize)
147  {
148  DPRINT1("Range too big\n");
149  return STATUS_BUFFER_OVERFLOW;
150  }
151 
152  /* Check if we were called from user-mode */
153  if(PreviousMode != KernelMode)
154  {
155  /* Entry SEH */
156  _SEH2_TRY
157  {
158  /* Make sure that the handle pointer is valid */
159  ProbeForWriteHandle(ProfileHandle);
160 
161  /* Check if the buffer is valid */
163  BufferSize,
164  sizeof(ULONG));
165  }
167  {
168  /* Return the exception code */
170  }
171  _SEH2_END;
172  }
173 
174  /* Check if a process was specified */
175  if (Process)
176  {
177  /* Reference it */
181  PreviousMode,
182  (PVOID*)&pProcess,
183  NULL);
184  if (!NT_SUCCESS(Status)) return(Status);
185  }
186  else
187  {
188  /* Segmented profile objects cannot be used system-wide */
189  if (Segment) return STATUS_INVALID_PARAMETER;
190 
191  /* No process was specified, which means a System-Wide Profile */
192  pProcess = NULL;
193 
194  /* For this, we need to check the Privilege */
196  {
197  DPRINT1("NtCreateProfile: Caller requires the SeSystemProfilePrivilege privilege!\n");
199  }
200  }
201 
202  /* Create the object */
204  NULL,
205  0,
206  NULL,
207  NULL);
211  PreviousMode,
212  NULL,
213  sizeof(EPROFILE),
214  0,
215  sizeof(EPROFILE) + sizeof(KPROFILE),
216  (PVOID*)&Profile);
217  if (!NT_SUCCESS(Status))
218  {
219  /* Dereference the process object if it was specified */
220  if (pProcess) ObDereferenceObject(pProcess);
221 
222  /* Return Status */
223  return Status;
224  }
225 
226  /* Initialize it */
227  Profile->RangeBase = RangeBase;
228  Profile->RangeSize = RangeSize;
229  Profile->Buffer = Buffer;
230  Profile->BufferSize = BufferSize;
231  Profile->BucketSize = BucketSize;
232  Profile->LockedBufferAddress = NULL;
233  Profile->Segment = Segment;
234  Profile->ProfileSource = ProfileSource;
235  Profile->Affinity = Affinity;
236  Profile->Process = pProcess;
237 
238  /* Insert into the Object Tree */
239  Status = ObInsertObject ((PVOID)Profile,
240  NULL,
242  0,
243  NULL,
244  &hProfile);
245 
246  /* Check for Success */
247  if (!NT_SUCCESS(Status))
248  {
249  /* Dereference Process on failure */
250  if (pProcess) ObDereferenceObject(pProcess);
251  return Status;
252  }
253 
254  /* Enter SEH */
255  _SEH2_TRY
256  {
257  /* Copy the created handle back to the caller*/
258  *ProfileHandle = hProfile;
259  }
261  {
263  }
264  _SEH2_END;
265 
266  /* Return Status */
267  return Status;
268 }
269 
270 NTSTATUS
271 NTAPI
273  OUT PLARGE_INTEGER PerformanceFrequency OPTIONAL)
274 {
276  LARGE_INTEGER PerfFrequency;
278 
279  /* Check if we were called from user-mode */
280  if (PreviousMode != KernelMode)
281  {
282  /* Entry SEH Block */
283  _SEH2_TRY
284  {
285  /* Make sure the counter and frequency are valid */
286  ProbeForWriteLargeInteger(PerformanceCounter);
287  if (PerformanceFrequency)
288  {
289  ProbeForWriteLargeInteger(PerformanceFrequency);
290  }
291  }
293  {
294  /* Return the exception code */
296  }
297  _SEH2_END;
298  }
299 
300  /* Enter a new SEH Block */
301  _SEH2_TRY
302  {
303  /* Query the Kernel */
304  *PerformanceCounter = KeQueryPerformanceCounter(&PerfFrequency);
305 
306  /* Return Frequency if requested */
307  if (PerformanceFrequency) *PerformanceFrequency = PerfFrequency;
308  }
310  {
311  /* Get the exception code */
313  }
314  _SEH2_END;
315 
316  /* Return status to caller */
317  return Status;
318 }
319 
320 NTSTATUS
321 NTAPI
322 NtStartProfile(IN HANDLE ProfileHandle)
323 {
324  PEPROFILE Profile;
327  PVOID TempLockedBufferAddress;
329  PAGED_CODE();
330 
331  /* Get the Object */
332  Status = ObReferenceObjectByHandle(ProfileHandle,
335  PreviousMode,
336  (PVOID*)&Profile,
337  NULL);
338  if (!NT_SUCCESS(Status)) return(Status);
339 
340  /* To avoid a Race, wait on the Mutex */
342  Executive,
343  KernelMode,
344  FALSE,
345  NULL);
346 
347  /* The Profile can still be enabled though, so handle that */
348  if (Profile->LockedBufferAddress)
349  {
350  /* Release our lock, dereference and return */
352  ObDereferenceObject(Profile);
354  }
355 
356  /* Allocate a Kernel Profile Object. */
358  sizeof(*ProfileObject),
359  TAG_PROFILE);
360  if (!ProfileObject)
361  {
362  /* Out of memory, fail */
364  ObDereferenceObject(Profile);
366  }
367 
368  /* Allocate the Mdl Structure */
369  Profile->Mdl = IoAllocateMdl(Profile->Buffer, Profile->BufferSize, FALSE, FALSE, NULL);
370 
371  /* Protect this in SEH as we might raise an exception */
372  _SEH2_TRY
373  {
374  /* Probe and Lock for Write Access */
376  }
378  {
379  /* Release our lock, free the buffer, dereference and return */
381  ObDereferenceObject(Profile);
384  }
385  _SEH2_END;
386 
387  /* Map the pages */
388  TempLockedBufferAddress = MmMapLockedPages(Profile->Mdl, KernelMode);
389 
390  /* Initialize the Kernel Profile Object */
391  Profile->ProfileObject = ProfileObject;
393  &Profile->Process->Pcb,
394  Profile->RangeBase,
395  Profile->RangeSize,
396  Profile->BucketSize,
397  Profile->ProfileSource,
398  Profile->Affinity);
399 
400  /* Start the Profiling */
401  KeStartProfile(ProfileObject, TempLockedBufferAddress);
402 
403  /* Now it's safe to save this */
404  Profile->LockedBufferAddress = TempLockedBufferAddress;
405 
406  /* Release mutex, dereference and return */
408  ObDereferenceObject(Profile);
409  return STATUS_SUCCESS;
410 }
411 
412 NTSTATUS
413 NTAPI
414 NtStopProfile(IN HANDLE ProfileHandle)
415 {
416  PEPROFILE Profile;
419  PAGED_CODE();
420 
421  /* Get the Object */
422  Status = ObReferenceObjectByHandle(ProfileHandle,
425  PreviousMode,
426  (PVOID*)&Profile,
427  NULL);
428  if (!NT_SUCCESS(Status)) return(Status);
429 
430  /* Get the Mutex */
432  Executive,
433  KernelMode,
434  FALSE,
435  NULL);
436 
437  /* Make sure the Profile Object is really Started */
438  if (!Profile->LockedBufferAddress)
439  {
441  goto Exit;
442  }
443 
444  /* Stop the Profile */
445  KeStopProfile(Profile->ProfileObject);
446 
447  /* Unlock the Buffer */
448  MmUnmapLockedPages(Profile->LockedBufferAddress, Profile->Mdl);
449  MmUnlockPages(Profile->Mdl);
450  IoFreeMdl(Profile->Mdl);
451  ExFreePoolWithTag(Profile->ProfileObject, TAG_PROFILE);
452 
453  /* Clear the Locked Buffer pointer, meaning the Object is Stopped */
454  Profile->LockedBufferAddress = NULL;
455 
456 Exit:
457  /* Release Mutex, Dereference and Return */
459  ObDereferenceObject(Profile);
460  return Status;
461 }
462 
463 NTSTATUS
464 NTAPI
467 {
469  ULONG ReturnInterval;
471  PAGED_CODE();
472 
473  /* Check if we were called from user-mode */
474  if (PreviousMode != KernelMode)
475  {
476  /* Enter SEH Block */
477  _SEH2_TRY
478  {
479  /* Validate interval */
481  }
483  {
484  /* Return the exception code */
486  }
487  _SEH2_END;
488  }
489 
490  /* Query the Interval */
491  ReturnInterval = (ULONG)KeQueryIntervalProfile(ProfileSource);
492 
493  /* Enter SEH block for return */
494  _SEH2_TRY
495  {
496  /* Return the data */
497  *Interval = ReturnInterval;
498  }
500  {
501  /* Get the exception code */
503  }
504  _SEH2_END;
505 
506  /* Return Success */
507  return Status;
508 }
509 
510 NTSTATUS
511 NTAPI
514 {
515  /* Let the Kernel do the job */
517 
518  /* Nothing can go wrong */
519  return STATUS_SUCCESS;
520 }
#define ProbeForWriteUlong(Ptr)
Definition: probe.h:36
#define OBJ_OPENLINK
Definition: winternl.h:230
_SEH2_TRY
Definition: create.c:4226
KMUTEX ExpProfileMutex
Definition: profile.c:19
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
POBJECT_TYPE ExProfileObjectType
Definition: profile.c:18
#define IN
Definition: typedefs.h:39
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
NTSTATUS NTAPI ObCreateObjectType(IN PUNICODE_STRING TypeName, IN POBJECT_TYPE_INITIALIZER ObjectTypeInitializer, IN PVOID Reserved, OUT POBJECT_TYPE *ObjectType)
Definition: oblife.c:1048
LARGE_INTEGER NTAPI KeQueryPerformanceCounter(IN PLARGE_INTEGER PerformanceFreq)
Definition: timer.c:138
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define STANDARD_RIGHTS_WRITE
Definition: nt_native.h:66
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:166
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
PVOID LockedBufferAddress
Definition: extypes.h:562
#define TRUE
Definition: types.h:120
#define TAG_PROFILE
Definition: tag.h:30
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtQueryPerformanceCounter(OUT PLARGE_INTEGER PerformanceCounter, OUT PLARGE_INTEGER PerformanceFrequency OPTIONAL)
Definition: profile.c:272
_In_ ULONG _In_ ULONG State
Definition: potypes.h:516
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1435
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:3062
NTSTATUS NTAPI NtCreateProfile(OUT PHANDLE ProfileHandle, IN HANDLE Process OPTIONAL, IN PVOID RangeBase, IN SIZE_T RangeSize, IN ULONG BucketSize, IN PVOID Buffer, IN ULONG BufferSize, IN KPROFILE_SOURCE ProfileSource, IN KAFFINITY Affinity)
Definition: profile.c:89
BOOLEAN NTAPI ExpInitializeProfileImplementation(VOID)
Definition: profile.c:62
const LUID SeSystemProfilePrivilege
Definition: priv.c:30
_SEH2_END
Definition: create.c:4400
#define STANDARD_RIGHTS_EXECUTE
Definition: nt_native.h:67
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
PVOID NTAPI MmMapLockedPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode)
Definition: mdlsup.c:818
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
VOID NTAPI MmUnmapLockedPages(IN PVOID BaseAddress, IN PMDL Mdl)
Definition: mdlsup.c:837
VOID NTAPI ExpDeleteProfile(PVOID ObjectBody)
Definition: profile.c:33
struct NameRec_ * Name
Definition: cdprocs.h:459
unsigned char BOOLEAN
BOOLEAN NTAPI KeStopProfile(struct _KPROFILE *Profile)
enum _KPROFILE_SOURCE KPROFILE_SOURCE
ULONG NTAPI KeQueryIntervalProfile(KPROFILE_SOURCE ProfileSource)
NTSTATUS NTAPI NtStartProfile(IN HANDLE ProfileHandle)
Definition: profile.c:322
Definition: bufpool.h:45
_Inout_ PVOID Segment
Definition: exfuncs.h:1101
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:951
#define STATUS_INVALID_PARAMETER_7
Definition: ntstatus.h:481
DWORD Interval
Definition: netstat.c:33
VOID NTAPI KeSetIntervalProfile(ULONG Interval, KPROFILE_SOURCE ProfileSource)
Status
Definition: gdiplustypes.h:24
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
GENERIC_MAPPING ExpProfileMapping
Definition: profile.c:21
#define ASSERT(a)
Definition: mode.c:44
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
static void Exit(void)
Definition: sock.c:1331
#define ObDereferenceObject
Definition: obfuncs.h:203
_In_ ULONG _In_ ULONG _In_ ULONG _Out_ PKIRQL _Out_ PKAFFINITY Affinity
Definition: halfuncs.h:170
#define ProbeForWriteHandle(Ptr)
Definition: probe.h:43
NTSTATUS NTAPI NtSetIntervalProfile(IN ULONG Interval, IN KPROFILE_SOURCE Source)
Definition: profile.c:512
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
VOID NTAPI KeInitializeMutex(IN PKMUTEX Mutex, IN ULONG Level)
Definition: mutex.c:67
NTSTATUS NTAPI NtQueryIntervalProfile(IN KPROFILE_SOURCE ProfileSource, OUT PULONG Interval)
Definition: profile.c:465
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:454
BOOLEAN NTAPI KeStartProfile(struct _KPROFILE *Profile, PVOID Buffer)
#define STANDARD_RIGHTS_READ
Definition: nt_native.h:65
NTSTATUS NTAPI NtStopProfile(IN HANDLE ProfileHandle)
Definition: profile.c:414
VOID NTAPI KeInitializeProfile(struct _KPROFILE *Profile, struct _KPROCESS *Process, PVOID ImageBase, SIZE_T ImageSize, ULONG BucketSize, KPROFILE_SOURCE ProfileSource, KAFFINITY Affinity)
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
PKPROFILE ProfileObject
Definition: extypes.h:561
ULONG_PTR SIZE_T
Definition: typedefs.h:80
NTSTATUS NTAPI ObInsertObject(IN PVOID Object, IN PACCESS_STATE AccessState OPTIONAL, IN ACCESS_MASK DesiredAccess, IN ULONG ObjectPointerBias, OUT PVOID *NewObject OPTIONAL, OUT PHANDLE Handle)
Definition: obhandle.c:2935
LONG NTAPI ExSystemExceptionFilter(VOID)
Definition: harderr.c:349
GENERIC_MAPPING GenericMapping
Definition: obtypes.h:358
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:931
ULONG_PTR KAFFINITY
Definition: compat.h:85
PEPROCESS Process
Definition: extypes.h:555
#define STATUS_PROFILING_NOT_STOPPED
Definition: ntstatus.h:420
unsigned int * PULONG
Definition: retypes.h:1
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
BOOLEAN NTAPI SeSinglePrivilegeCheck(_In_ LUID PrivilegeValue, _In_ KPROCESSOR_MODE PreviousMode)
Checks if a single privilege is present in the context of the calling thread.
Definition: priv.c:744
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
#define OUT
Definition: typedefs.h:40
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define ULONG_PTR
Definition: config.h:101
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
#define STATUS_SUCCESS
Definition: shellext.h:65
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define DPRINT
Definition: sndvol32.h:71
#define PROFILE_ALL_ACCESS
Definition: extypes.h:131
OB_DELETE_METHOD DeleteProcedure
Definition: obtypes.h:369
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
struct _KPROFILE KPROFILE
static CODE_SEG("PAGE")
Definition: isapnp.c:1482
POBJECT_TYPE PsProcessType
Definition: process.c:20
ULONG DefaultNonPagedPoolCharge
Definition: obtypes.h:365
#define PROFILE_CONTROL
Definition: extypes.h:130
PMDL Mdl
Definition: extypes.h:563
#define ProbeForWriteLargeInteger(Ptr)
Definition: probe.h:46
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
#define STATUS_PROFILING_NOT_STARTED
Definition: ntstatus.h:419
#define PAGED_CODE()
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68