ReactOS 0.4.16-dev-747-gbc52d5f
NtQueryInformationProcess.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS API tests
3 * LICENSE: LGPLv2.1+ - See COPYING.LIB in the top level directory
4 * PURPOSE: Tests for the NtQueryInformationProcess API
5 * PROGRAMMER: Thomas Faber <thomas.faber@reactos.org>
6 * George Bișoc <george.bisoc@reactos.org>
7 */
8
9#include "precomp.h"
10#include <internal/ps_i.h>
11
13
14static
15void
17{
18#define SPIN_TIME 1000000
20 KERNEL_USER_TIMES Times1;
21 KERNEL_USER_TIMES Times2;
23 LARGE_INTEGER Time1, Time2;
24
25 /* Everything is NULL */
28 NULL,
29 0,
30 NULL);
32
33 /* Right size, invalid process */
36 NULL,
37 sizeof(KERNEL_USER_TIMES),
38 NULL);
40
41 /* Valid process, no buffer */
44 NULL,
45 0,
46 NULL);
48
49 /* Unaligned buffer, wrong size */
52 (PVOID)2,
53 0,
54 NULL);
56
57 /* Unaligned buffer, correct size */
60 (PVOID)2,
61 sizeof(KERNEL_USER_TIMES),
62 NULL);
64
65 /* Buffer too small */
68 NULL,
69 sizeof(KERNEL_USER_TIMES) - 1,
70 NULL);
72
73 /* Right buffer size but NULL pointer */
76 NULL,
77 sizeof(KERNEL_USER_TIMES),
78 NULL);
80
81 /* Buffer too large */
84 NULL,
85 sizeof(KERNEL_USER_TIMES) + 1,
86 NULL);
88
89 /* Buffer too small, ask for length */
90 Length = 0x55555555;
93 NULL,
94 sizeof(KERNEL_USER_TIMES) - 1,
95 &Length);
97 ok_dec(Length, 0x55555555);
98
99 Status = NtQuerySystemTime(&Time1);
101
102 /* Do some busy waiting to increase UserTime */
103 do
104 {
105 Status = NtQuerySystemTime(&Time2);
106 if (!NT_SUCCESS(Status))
107 {
108 ok(0, "NtQuerySystemTime failed with %lx\n", Status);
109 break;
110 }
111 } while (Time2.QuadPart - Time1.QuadPart < SPIN_TIME);
112
113 /* Valid parameters, no return length */
114 Status = NtQuerySystemTime(&Time1);
116
117 RtlFillMemory(&Times1, sizeof(Times1), 0x55);
120 &Times1,
121 sizeof(KERNEL_USER_TIMES),
122 NULL);
125 "CreateTime is %I64u, expected < %I64u\n", Times1.CreateTime.QuadPart, TestStartTime.QuadPart);
126 ok(Times1.CreateTime.QuadPart > TestStartTime.QuadPart - 100000000LL,
127 "CreateTime is %I64u, expected > %I64u\n", Times1.CreateTime.QuadPart, TestStartTime.QuadPart - 100000000LL);
128 ok(Times1.ExitTime.QuadPart == 0,
129 "ExitTime is %I64u, expected 0\n", Times1.ExitTime.QuadPart);
130 ok(Times1.KernelTime.QuadPart != 0, "KernelTime is 0\n");
132 ok(Times1.UserTime.QuadPart != 0, "UserTime is 0\n");
133
134 /* Do some busy waiting to increase UserTime */
135 do
136 {
137 Status = NtQuerySystemTime(&Time2);
138 if (!NT_SUCCESS(Status))
139 {
140 ok(0, "NtQuerySystemTime failed with %lx\n", Status);
141 break;
142 }
143 } while (Time2.QuadPart - Time1.QuadPart < SPIN_TIME);
144
145 /* Again, this time with a return length */
146 Length = 0x55555555;
147 RtlFillMemory(&Times2, sizeof(Times2), 0x55);
150 &Times2,
151 sizeof(KERNEL_USER_TIMES),
152 &Length);
155 ok(Times1.CreateTime.QuadPart == Times2.CreateTime.QuadPart,
156 "CreateTimes not equal: %I64u != %I64u\n", Times1.CreateTime.QuadPart, Times2.CreateTime.QuadPart);
157 ok(Times2.ExitTime.QuadPart == 0,
158 "ExitTime is %I64u, expected 0\n", Times2.ExitTime.QuadPart);
159 ok(Times2.KernelTime.QuadPart != 0, "KernelTime is 0\n");
160 ok(Times2.UserTime.QuadPart != 0, "UserTime is 0\n");
161
162 /* Compare the two sets of KernelTime/UserTime values */
163 Status = NtQuerySystemTime(&Time2);
165 /* Time values must have increased */
166 ok(Times2.KernelTime.QuadPart > Times1.KernelTime.QuadPart,
167 "KernelTime values inconsistent. Expected %I64u > %I64u\n", Times2.KernelTime.QuadPart, Times1.KernelTime.QuadPart);
169 ok(Times2.UserTime.QuadPart > Times1.UserTime.QuadPart,
170 "UserTime values inconsistent. Expected %I64u > %I64u\n", Times2.UserTime.QuadPart, Times1.UserTime.QuadPart);
171 /* They can't have increased by more than wall clock time difference (we only have one thread) */
173 ok(Times2.KernelTime.QuadPart - Times1.KernelTime.QuadPart < Time2.QuadPart - Time1.QuadPart,
174 "KernelTime values inconsistent. Expected %I64u - %I64u < %I64u\n",
175 Times2.KernelTime.QuadPart, Times1.KernelTime.QuadPart, Time2.QuadPart - Time1.QuadPart);
176 ok(Times2.UserTime.QuadPart - Times1.UserTime.QuadPart < Time2.QuadPart - Time1.QuadPart,
177 "UserTime values inconsistent. Expected %I64u - %I64u < %I64u\n",
178 Times2.UserTime.QuadPart, Times1.UserTime.QuadPart, Time2.QuadPart - Time1.QuadPart);
179
180 trace("KernelTime1 = %I64u\n", Times1.KernelTime.QuadPart);
181 trace("KernelTime2 = %I64u\n", Times2.KernelTime.QuadPart);
182 trace("UserTime1 = %I64u\n", Times1.UserTime.QuadPart);
183 trace("UserTime2 = %I64u\n", Times2.UserTime.QuadPart);
184
185 /* TODO: Test ExitTime on a terminated process */
186#undef SPIN_TIME
187}
188
189static
190void
192{
196
197 /* Everything is NULL */
200 NULL,
201 0,
202 NULL);
204
205 /* Right size, invalid process handle */
208 NULL,
209 sizeof(BasicInfo),
210 NULL);
212
213 /* Valid process handle, no buffer */
216 NULL,
217 0,
218 NULL);
220
221 /* Unaligned buffer, wrong size */
224 (PVOID)2,
225 0,
226 NULL);
228
229 /* Unaligned buffer, correct size */
232 (PVOID)2,
233 sizeof(BasicInfo),
234 NULL);
236
237 /* Buffer too small */
240 NULL,
241 sizeof(BasicInfo) - 1,
242 NULL);
244
245 /* Right buffer size but NULL pointer */
248 NULL,
249 sizeof(BasicInfo),
250 NULL);
252
253 /* Buffer too large */
256 NULL,
257 sizeof(BasicInfo) + 1,
258 NULL);
260
261 /* Buffer too small, ask for length */
262 Length = 0x55555555;
265 NULL,
266 sizeof(BasicInfo) - 1,
267 &Length);
269 ok_dec(Length, 0x55555555);
270
271 /* Valid parameters, no return length */
272 RtlFillMemory(&BasicInfo, sizeof(BasicInfo), 0x55);
275 &BasicInfo,
276 sizeof(BasicInfo),
277 NULL);
279
280 /* Trace the returned data (1) */
281 trace("[1] BasicInfo.ExitStatus = %lx\n", BasicInfo.ExitStatus);
282 trace("[1] BasicInfo.PebBaseAddress = %p\n", BasicInfo.PebBaseAddress);
283 trace("[1] BasicInfo.AffinityMask = %Ix\n", BasicInfo.AffinityMask);
284 trace("[1] BasicInfo.BasePriority = %ld\n", BasicInfo.BasePriority);
285 trace("[1] BasicInfo.UniqueProcessId = %Iu\n", BasicInfo.UniqueProcessId);
286 trace("[1] BasicInfo.InheritedFromUniqueProcessId = %Iu\n", BasicInfo.InheritedFromUniqueProcessId);
287
288 /* Again, this time with a return length */
289 Length = 0x55555555;
290 RtlFillMemory(&BasicInfo, sizeof(BasicInfo), 0x55);
293 &BasicInfo,
294 sizeof(BasicInfo),
295 &Length);
297 ok_dec(Length, sizeof(BasicInfo));
298
299 /* Trace the returned data (2) */
300 trace("[2] BasicInfo.ExitStatus = %lx\n", BasicInfo.ExitStatus);
301 trace("[2] BasicInfo.PebBaseAddress = %p\n", BasicInfo.PebBaseAddress);
302 trace("[2] BasicInfo.AffinityMask = %Ix\n", BasicInfo.AffinityMask);
303 trace("[2] BasicInfo.BasePriority = %ld\n", BasicInfo.BasePriority);
304 trace("[2] BasicInfo.UniqueProcessId = %Iu\n", BasicInfo.UniqueProcessId);
305 trace("[2] BasicInfo.InheritedFromUniqueProcessId = %Iu\n", BasicInfo.InheritedFromUniqueProcessId);
306}
307
308static
309void
311{
314 QUOTA_LIMITS QuotaLimits;
315
316 /* Everything is NULL */
319 NULL,
320 0,
321 NULL);
323
324 /* Right size, invalid process handle */
327 NULL,
328 sizeof(QuotaLimits),
329 NULL);
331
332 /* Valid process handle, no buffer */
335 NULL,
336 0,
337 NULL);
339
340 /* Unaligned buffer, wrong size */
343 (PVOID)2,
344 0,
345 NULL);
347
348 /* Unaligned buffer, correct size */
351 (PVOID)2,
352 sizeof(QuotaLimits),
353 NULL);
355
356 /* Buffer too small */
359 NULL,
360 sizeof(QuotaLimits) - 1,
361 NULL);
363
364 /* Right buffer size but NULL pointer */
367 NULL,
368 sizeof(QuotaLimits),
369 NULL);
371
372 /* Buffer too large */
375 NULL,
376 sizeof(QuotaLimits) + 1,
377 NULL);
379
380 /* Buffer too small, ask for length */
381 Length = 0x55555555;
384 NULL,
385 sizeof(QuotaLimits) - 1,
386 &Length);
388 ok_dec(Length, 0x55555555);
389
390 /* Valid parameters, no return length */
391 RtlFillMemory(&QuotaLimits, sizeof(QuotaLimits), 0x55);
394 &QuotaLimits,
395 sizeof(QuotaLimits),
396 NULL);
398
399 /* Trace the returned data (1) */
400 trace("[1] QuotaLimits.PagedPoolLimit = %Iu\n", QuotaLimits.PagedPoolLimit);
401 trace("[1] QuotaLimits.NonPagedPoolLimit = %Iu\n", QuotaLimits.NonPagedPoolLimit);
402 trace("[1] QuotaLimits.MinimumWorkingSetSize = %Iu\n", QuotaLimits.MinimumWorkingSetSize);
403 trace("[1] QuotaLimits.MaximumWorkingSetSize = %Iu\n", QuotaLimits.MaximumWorkingSetSize);
404 trace("[1] QuotaLimits.PagefileLimit = %Iu\n", QuotaLimits.PagefileLimit);
405 trace("[1] QuotaLimits.TimeLimit = %I64d\n", QuotaLimits.TimeLimit.QuadPart);
406
407 /* Again, this time with a return length */
408 Length = 0x55555555;
409 RtlFillMemory(&QuotaLimits, sizeof(QuotaLimits), 0x55);
412 &QuotaLimits,
413 sizeof(QuotaLimits),
414 &Length);
416 ok_dec(Length, sizeof(QuotaLimits));
417
418 /* Trace the returned data (2) */
419 trace("[2] QuotaLimits.PagedPoolLimit = %Iu\n", QuotaLimits.PagedPoolLimit);
420 trace("[2] QuotaLimits.NonPagedPoolLimit = %Iu\n", QuotaLimits.NonPagedPoolLimit);
421 trace("[2] QuotaLimits.MinimumWorkingSetSize = %Iu\n", QuotaLimits.MinimumWorkingSetSize);
422 trace("[2] QuotaLimits.MaximumWorkingSetSize = %Iu\n", QuotaLimits.MaximumWorkingSetSize);
423 trace("[2] QuotaLimits.PagefileLimit = %Iu\n", QuotaLimits.PagefileLimit);
424 trace("[2] QuotaLimits.TimeLimit = %I64d\n", QuotaLimits.TimeLimit.QuadPart);
425}
426
427static
428void
430{
433 QUOTA_LIMITS_EX QuotaLimitsEx;
434
435 /* Right size, invalid process handle */
438 NULL,
439 sizeof(QuotaLimitsEx),
440 NULL);
442
443 /* Unaligned buffer, correct size */
446 (PVOID)2,
447 sizeof(QuotaLimitsEx),
448 NULL);
450
451 /* Buffer too small */
454 NULL,
455 sizeof(QuotaLimitsEx) - 1,
456 NULL);
458
459 /* Right buffer size but NULL pointer */
462 NULL,
463 sizeof(QuotaLimitsEx),
464 NULL);
466
467 /* Buffer too large */
470 NULL,
471 sizeof(QuotaLimitsEx) + 1,
472 NULL);
474
475 /* Buffer too small, ask for length */
476 Length = 0x55555555;
479 NULL,
480 sizeof(QuotaLimitsEx) - 1,
481 &Length);
483 ok_dec(Length, 0x55555555);
484
485 /* Valid parameters, no return length */
486 RtlFillMemory(&QuotaLimitsEx, sizeof(QuotaLimitsEx), 0x55);
489 &QuotaLimitsEx,
490 sizeof(QuotaLimitsEx),
491 NULL);
493
494 /* Trace the returned data (1) */
495 trace("[1] QuotaLimitsEx.PagedPoolLimit = %Iu\n", QuotaLimitsEx.PagedPoolLimit);
496 trace("[1] QuotaLimitsEx.NonPagedPoolLimit = %Iu\n", QuotaLimitsEx.NonPagedPoolLimit);
497 trace("[1] QuotaLimitsEx.MinimumWorkingSetSize = %Iu\n", QuotaLimitsEx.MinimumWorkingSetSize);
498 trace("[1] QuotaLimitsEx.MaximumWorkingSetSize = %Iu\n", QuotaLimitsEx.MaximumWorkingSetSize);
499 trace("[1] QuotaLimitsEx.PagefileLimit = %Iu\n", QuotaLimitsEx.PagefileLimit);
500 trace("[1] QuotaLimitsEx.TimeLimit = %I64d\n", QuotaLimitsEx.TimeLimit.QuadPart);
501 //trace("[1] QuotaLimitsEx.WorkingSetLimit = %Iu\n", QuotaLimitsEx.WorkingSetLimit); // Not used on Win2k3
502 trace("[1] QuotaLimitsEx.Flags = %lx\n", QuotaLimitsEx.Flags);
503 trace("[1] QuotaLimitsEx.CpuRateLimit.RateData = %lx\n", QuotaLimitsEx.CpuRateLimit.RateData);
504
505 /* Again, this time with a return length */
506 Length = 0x55555555;
507 RtlFillMemory(&QuotaLimitsEx, sizeof(QuotaLimitsEx), 0x55);
510 &QuotaLimitsEx,
511 sizeof(QuotaLimitsEx),
512 &Length);
514 ok_dec(Length, sizeof(QuotaLimitsEx));
515
516 /* Trace the returned data (2) */
517 trace("[2] QuotaLimitsEx.PagedPoolLimit = %Iu\n", QuotaLimitsEx.PagedPoolLimit);
518 trace("[2] QuotaLimitsEx.NonPagedPoolLimit = %Iu\n", QuotaLimitsEx.NonPagedPoolLimit);
519 trace("[2] QuotaLimitsEx.MinimumWorkingSetSize = %Iu\n", QuotaLimitsEx.MinimumWorkingSetSize);
520 trace("[2] QuotaLimitsEx.MaximumWorkingSetSize = %Iu\n", QuotaLimitsEx.MaximumWorkingSetSize);
521 trace("[2] QuotaLimitsEx.PagefileLimit = %Iu\n", QuotaLimitsEx.PagefileLimit);
522 trace("[2] QuotaLimitsEx.TimeLimit = %I64d\n", QuotaLimitsEx.TimeLimit.QuadPart);
523 //trace("[2] QuotaLimitsEx.WorkingSetLimit = %Iu\n", QuotaLimitsEx.WorkingSetLimit); // Not used on Win2k3
524 trace("[2] QuotaLimitsEx.Flags = %lx\n", QuotaLimitsEx.Flags);
525 trace("[2] QuotaLimitsEx.CpuRateLimit.RateData = %lx\n", QuotaLimitsEx.CpuRateLimit.RateData);
526}
527
528static
529void
531{
533 PPROCESS_PRIORITY_CLASS ProcPriority;
534
535 /* Allocate some memory for the priority class structure */
536 ProcPriority = malloc(sizeof(PROCESS_PRIORITY_CLASS));
537 if (ProcPriority == NULL)
538 {
539 skip("Failed to allocate memory for PROCESS_PRIORITY_CLASS!\n");
540 return;
541 }
542
543 /*
544 * Initialize the PriorityClass member to ensure the test won't randomly succeed (if such data is uninitialized).
545 * Filling 85 to the data member makes sure that if the test fails continously then NtQueryInformationProcess()
546 * didn't initialize the structure with data.
547 */
548 RtlFillMemory(&ProcPriority->PriorityClass, sizeof(ProcPriority->PriorityClass), 0x55);
549
550 /* Unaligned buffer -- wrong size */
553 (PVOID)1,
554 0,
555 NULL);
557
558 /* Unaligned buffer -- correct size */
561 (PVOID)1,
563 NULL);
565
566 /* Unaligned buffer -- wrong size (but this time do with an alignment of 2) */
569 (PVOID)2,
570 0,
571 NULL);
573
574 /* Unaligned buffer -- correct size (but this time do with an alignment of 2) */
577 (PVOID)2,
579 NULL);
581
582 /* Do not care for the length but expect to return the priority class */
585 ProcPriority,
587 NULL);
589
590 /* Make sure the returned priority class is a valid number (non negative) but also it should be within the PROCESS_PRIORITY_CLASS range */
592 "Expected a valid number from priority class range but got %d\n", ProcPriority->PriorityClass);
593 free(ProcPriority);
594}
595
596static
597void
599{
601 ULONG VdmPower = 1, ReturnLength;
602
603 /* Everything is NULL */
606 NULL,
607 0,
608 NULL);
610
611 /* Given an invalid process handle */
614 &VdmPower,
615 sizeof(VdmPower),
616 NULL);
618
619 /* Don't query anything */
622 NULL,
623 sizeof(VdmPower),
624 NULL);
626
627 /* The buffer is misaligned and information length is wrong */
630 (PVOID)1,
631 0,
632 NULL);
634
635 /* The buffer is misaligned */
638 (PVOID)1,
639 sizeof(VdmPower),
640 NULL);
642
643 /* The buffer is misaligned -- try with an alignment size of 2 */
646 (PVOID)2,
647 sizeof(VdmPower),
648 NULL);
650
651 /* Query the VDM power */
654 &VdmPower,
655 sizeof(VdmPower),
656 NULL);
658 ok(VdmPower == 0 || VdmPower == 1, "The VDM power value must be within the boundary between 0 and 1, not anything else! Got %lu\n", VdmPower);
659
660 /* Same but with ReturnLength */
663 &VdmPower,
664 sizeof(VdmPower),
665 &ReturnLength);
667 ok(ReturnLength != 0, "ReturnLength shouldn't be 0!\n");
668 ok(VdmPower == 0 || VdmPower == 1, "The VDM power value must be within the boundary between 0 and 1, not anything else! Got %lu\n", VdmPower);
669
670 /* Trace the VDM power value and returned length */
671 trace("ReturnLength = %lu\n", ReturnLength);
672 trace("VdmPower = %lu\n", VdmPower);
673}
674
675static
676void
678{
679 ULONG InfoClass;
680
681 /* Iterate over the process info classes and begin the tests */
682 for (InfoClass = 0; InfoClass < _countof(PsProcessInfoClass); InfoClass++)
683 {
684 /* The buffer is misaligned */
686 InfoClass,
687 (PVOID)(ULONG_PTR)1,
688 PsProcessInfoClass[InfoClass].RequiredSizeQUERY,
690
691 /* We query an invalid buffer address */
693 InfoClass,
694 (PVOID)(ULONG_PTR)PsProcessInfoClass[InfoClass].AlignmentQUERY,
695 PsProcessInfoClass[InfoClass].RequiredSizeQUERY,
697
698 /* The information length is wrong */
700 InfoClass,
701 (PVOID)(ULONG_PTR)PsProcessInfoClass[InfoClass].AlignmentQUERY,
702 PsProcessInfoClass[InfoClass].RequiredSizeQUERY - 1,
704 }
705}
706
708{
710
711 /* Make sure that some time has passed since process creation, even if the resolution of our NtQuerySystemTime is low. */
712 Sleep(1);
713
716
724}
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
static void Test_ProcessWx86Information(void)
static void Test_ProcessQuotaLimits(void)
static void Test_ProcQueryAlignmentProbe(void)
#define SPIN_TIME
static void Test_ProcessQuotaLimitsEx(void)
static void Test_ProcessBasicInformation(void)
static LARGE_INTEGER TestStartTime
static void Test_ProcessTimes(void)
static void Test_ProcessPriorityClassAlignment(void)
#define ok_hex(expression, result)
Definition: atltest.h:94
#define trace
Definition: atltest.h:70
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define ok_dec(expression, result)
Definition: atltest.h:101
#define START_TEST(x)
Definition: atltest.h:75
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define NULL
Definition: types.h:112
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
Status
Definition: gdiplustypes.h:25
#define PROCESS_PRIORITY_CLASS_INVALID
Definition: pstypes.h:107
#define PROCESS_PRIORITY_CLASS_ABOVE_NORMAL
Definition: pstypes.h:113
@ ProcessBasicInformation
Definition: winternl.h:394
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:599
@ ProcessWx86Information
Definition: winternl.h:875
@ ProcessPriorityClass
Definition: winternl.h:874
@ ProcessQuotaLimits
Definition: winternl.h:857
@ ProcessTimes
Definition: winternl.h:860
@ QUERY
Definition: precomp.h:18
VOID QuerySetProcessValidator(_In_ ALIGNMENT_PROBE_MODE ValidationMode, _In_ ULONG InfoClassIndex, _In_ PVOID InfoPointer, _In_ ULONG InfoLength, _In_ NTSTATUS ExpectedStatus)
Definition: probelib.c:12
#define NtCurrentProcess()
Definition: nt_native.h:1657
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NTSTATUS NTAPI NtQuerySystemTime(OUT PLARGE_INTEGER SystemTime)
Definition: time.c:569
NTSTATUS NTAPI NtQueryInformationProcess(_In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _Out_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_opt_ PULONG ReturnLength)
Definition: query.c:59
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define STATUS_DATATYPE_MISALIGNMENT
Definition: ntstatus.h:183
static const INFORMATION_CLASS_INFO PsProcessInfoClass[]
Definition: ps_i.h:15
#define ros_skip_flaky
Definition: test.h:182
#define STATUS_SUCCESS
Definition: shellext.h:65
#define _countof(array)
Definition: sndvol32.h:70
LARGE_INTEGER UserTime
Definition: winternl.h:1063
LARGE_INTEGER CreateTime
Definition: winternl.h:1060
LARGE_INTEGER KernelTime
Definition: winternl.h:1062
LARGE_INTEGER ExitTime
Definition: winternl.h:1061
ULONG_PTR InheritedFromUniqueProcessId
Definition: pstypes.h:340
SIZE_T MaximumWorkingSetSize
Definition: pstypes.h:71
SIZE_T PagedPoolLimit
Definition: pstypes.h:68
SIZE_T PagefileLimit
Definition: pstypes.h:72
LARGE_INTEGER TimeLimit
Definition: pstypes.h:73
RATE_QUOTA_LIMIT CpuRateLimit
Definition: pstypes.h:79
SIZE_T NonPagedPoolLimit
Definition: pstypes.h:69
SIZE_T MinimumWorkingSetSize
Definition: pstypes.h:70
INT64 MaximumWorkingSetSize
Definition: lsa.idl:290
INT64 NonPagedPoolLimit
Definition: lsa.idl:288
LARGE_INTEGER TimeLimit
Definition: lsa.idl:292
INT64 MinimumWorkingSetSize
Definition: lsa.idl:289
INT64 PagefileLimit
Definition: lsa.idl:291
INT64 PagedPoolLimit
Definition: lsa.idl:287
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
uint32_t ULONG_PTR
Definition: typedefs.h:65
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
LONGLONG QuadPart
Definition: typedefs.h:114
ULONG RateData
Definition: pstypes.h:60