ReactOS 0.4.16-dev-1890-gbb7a613
query.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ps/query.c
5 * PURPOSE: Process Manager: Thread/Process Query/Set Information
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Thomas Weidenmueller (w3seek@reactos.org)
8 * Eric Kohl
9 */
10
11/* INCLUDES ******************************************************************/
12
13#include <ntoskrnl.h>
14#define NDEBUG
15#include <debug.h>
16
17/* Debugging Level */
18ULONG PspTraceLevel = 0;
19
20/* PRIVATE FUNCTIONS *********************************************************/
21
22NTSTATUS
23NTAPI
24PsReferenceProcessFilePointer(IN PEPROCESS Process,
25 OUT PFILE_OBJECT *FileObject)
26{
27 PSECTION Section;
28 PAGED_CODE();
29
30 /* Lock the process */
31 if (!ExAcquireRundownProtection(&Process->RundownProtect))
32 {
33 return STATUS_PROCESS_IS_TERMINATING;
34 }
35
36 /* Get the section */
37 Section = Process->SectionObject;
38 if (Section)
39 {
40 /* Get the file object and reference it */
41 *FileObject = MmGetFileObjectForSection((PVOID)Section);
42 ObReferenceObject(*FileObject);
43 }
44
45 /* Release the protection */
46 ExReleaseRundownProtection(&Process->RundownProtect);
47
48 /* Return status */
49 return Section ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
50}
51
52/* PUBLIC FUNCTIONS **********************************************************/
53
54/*
55 * @implemented
56 */
57NTSTATUS
58NTAPI
59NtQueryInformationProcess(
60 _In_ HANDLE ProcessHandle,
61 _In_ PROCESSINFOCLASS ProcessInformationClass,
62 _Out_ PVOID ProcessInformation,
63 _In_ ULONG ProcessInformationLength,
64 _Out_opt_ PULONG ReturnLength)
65{
66 PEPROCESS Process;
67 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
68 NTSTATUS Status;
69 ULONG Length = 0;
70
71 PAGED_CODE();
72
73 /* Validate the information class */
74 Status = DefaultQueryInfoBufferCheck(ProcessInformationClass,
75 PsProcessInfoClass,
76 RTL_NUMBER_OF(PsProcessInfoClass),
77 ICIF_PROBE_READ,
78 ProcessInformation,
79 ProcessInformationLength,
80 ReturnLength,
81 NULL,
82 PreviousMode);
83 if (!NT_SUCCESS(Status))
84 {
85 DPRINT1("NtQueryInformationProcess(ProcessInformationClass: %lu): Class validation failed! (Status: 0x%lx)\n",
86 ProcessInformationClass, Status);
87 return Status;
88 }
89
90 if (((ProcessInformationClass == ProcessCookie) ||
91 (ProcessInformationClass == ProcessImageInformation)) &&
92 (ProcessHandle != NtCurrentProcess()))
93 {
94 /*
95 * Retrieving the process cookie is only allowed for the calling process
96 * itself! XP only allows NtCurrentProcess() as process handles even if
97 * a real handle actually represents the current process.
98 */
99 return STATUS_INVALID_PARAMETER;
100 }
101
102 /* Check the information class */
103 switch (ProcessInformationClass)
104 {
105 /* Basic process information */
106 case ProcessBasicInformation:
107 {
108 PPROCESS_BASIC_INFORMATION ProcessBasicInfo = (PPROCESS_BASIC_INFORMATION)ProcessInformation;
109
110 if (ProcessInformationLength != sizeof(PROCESS_BASIC_INFORMATION))
111 {
112 Status = STATUS_INFO_LENGTH_MISMATCH;
113 break;
114 }
115
116 /* Set the return length */
117 Length = sizeof(PROCESS_BASIC_INFORMATION);
118
119 /* Reference the process */
120 Status = ObReferenceObjectByHandle(ProcessHandle,
121 PROCESS_QUERY_INFORMATION,
122 PsProcessType,
123 PreviousMode,
124 (PVOID*)&Process,
125 NULL);
126 if (!NT_SUCCESS(Status)) break;
127
128 /* Protect writes with SEH */
129 _SEH2_TRY
130 {
131 /* Write all the information from the EPROCESS/KPROCESS */
132 ProcessBasicInfo->ExitStatus = Process->ExitStatus;
133 ProcessBasicInfo->PebBaseAddress = Process->Peb;
134 ProcessBasicInfo->AffinityMask = Process->Pcb.Affinity;
135 ProcessBasicInfo->UniqueProcessId = (ULONG_PTR)Process->
136 UniqueProcessId;
137 ProcessBasicInfo->InheritedFromUniqueProcessId =
138 (ULONG_PTR)Process->InheritedFromUniqueProcessId;
139 ProcessBasicInfo->BasePriority = Process->Pcb.BasePriority;
140
141 }
142 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
143 {
144 /* Get exception code */
145 Status = _SEH2_GetExceptionCode();
146 }
147 _SEH2_END;
148
149 /* Dereference the process */
150 ObDereferenceObject(Process);
151 break;
152 }
153
154 /* Process quota limits */
155 case ProcessQuotaLimits:
156 {
157 QUOTA_LIMITS_EX QuotaLimits;
158 BOOLEAN Extended;
159
160 if (ProcessInformationLength != sizeof(QUOTA_LIMITS) &&
161 ProcessInformationLength != sizeof(QUOTA_LIMITS_EX))
162 {
163 Status = STATUS_INFO_LENGTH_MISMATCH;
164 break;
165 }
166
167 /* Set the return length */
168 Length = ProcessInformationLength;
169 Extended = (Length == sizeof(QUOTA_LIMITS_EX));
170
171 /* Reference the process */
172 Status = ObReferenceObjectByHandle(ProcessHandle,
173 PROCESS_QUERY_INFORMATION,
174 PsProcessType,
175 PreviousMode,
176 (PVOID*)&Process,
177 NULL);
178 if (!NT_SUCCESS(Status)) break;
179
180 /* Indicate success */
181 Status = STATUS_SUCCESS;
182
183 RtlZeroMemory(&QuotaLimits, sizeof(QuotaLimits));
184
185 /* Get max/min working set sizes */
186 QuotaLimits.MaximumWorkingSetSize =
187 Process->Vm.MaximumWorkingSetSize << PAGE_SHIFT;
188 QuotaLimits.MinimumWorkingSetSize =
189 Process->Vm.MinimumWorkingSetSize << PAGE_SHIFT;
190
191 /* Get default time limits */
192 QuotaLimits.TimeLimit.QuadPart = -1LL;
193
194 /* Is quota block a default one? */
195 if (Process->QuotaBlock == &PspDefaultQuotaBlock)
196 {
197 /* Get default pools and pagefile limits */
198 QuotaLimits.PagedPoolLimit = (SIZE_T)-1;
199 QuotaLimits.NonPagedPoolLimit = (SIZE_T)-1;
200 QuotaLimits.PagefileLimit = (SIZE_T)-1;
201 }
202 else
203 {
204 /* Get limits from non-default quota block */
205 QuotaLimits.PagedPoolLimit =
206 Process->QuotaBlock->QuotaEntry[PsPagedPool].Limit;
207 QuotaLimits.NonPagedPoolLimit =
208 Process->QuotaBlock->QuotaEntry[PsNonPagedPool].Limit;
209 QuotaLimits.PagefileLimit =
210 Process->QuotaBlock->QuotaEntry[PsPageFile].Limit;
211 }
212
213 /* Get additional information, if needed */
214 if (Extended)
215 {
216 QuotaLimits.Flags |= (Process->Vm.Flags.MaximumWorkingSetHard ?
217 QUOTA_LIMITS_HARDWS_MAX_ENABLE : QUOTA_LIMITS_HARDWS_MAX_DISABLE);
218 QuotaLimits.Flags |= (Process->Vm.Flags.MinimumWorkingSetHard ?
219 QUOTA_LIMITS_HARDWS_MIN_ENABLE : QUOTA_LIMITS_HARDWS_MIN_DISABLE);
220
221 /* FIXME: Get the correct information */
222 //QuotaLimits.WorkingSetLimit = (SIZE_T)-1; // Not used on Win2k3, it is set to 0
223 QuotaLimits.CpuRateLimit.RateData = 0;
224 }
225
226 /* Protect writes with SEH */
227 _SEH2_TRY
228 {
229 RtlCopyMemory(ProcessInformation, &QuotaLimits, Length);
230 }
231 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
232 {
233 /* Get exception code */
234 Status = _SEH2_GetExceptionCode();
235 }
236 _SEH2_END;
237
238 /* Dereference the process */
239 ObDereferenceObject(Process);
240 break;
241 }
242
243 case ProcessIoCounters:
244 {
245 PIO_COUNTERS IoCounters = (PIO_COUNTERS)ProcessInformation;
246 PROCESS_VALUES ProcessValues;
247
248 if (ProcessInformationLength != sizeof(IO_COUNTERS))
249 {
250 Status = STATUS_INFO_LENGTH_MISMATCH;
251 break;
252 }
253
254 Length = sizeof(IO_COUNTERS);
255
256 /* Reference the process */
257 Status = ObReferenceObjectByHandle(ProcessHandle,
258 PROCESS_QUERY_INFORMATION,
259 PsProcessType,
260 PreviousMode,
261 (PVOID*)&Process,
262 NULL);
263 if (!NT_SUCCESS(Status)) break;
264
265 /* Query IO counters from the process */
266 KeQueryValuesProcess(&Process->Pcb, &ProcessValues);
267
268 _SEH2_TRY
269 {
270 RtlCopyMemory(IoCounters, &ProcessValues.IoInfo, sizeof(IO_COUNTERS));
271 }
272 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
273 {
274 /* Ignore exception */
275 }
276 _SEH2_END;
277
278 /* Set status to success in any case */
279 Status = STATUS_SUCCESS;
280
281 /* Dereference the process */
282 ObDereferenceObject(Process);
283 break;
284 }
285
286 /* Timing */
287 case ProcessTimes:
288 {
289 PKERNEL_USER_TIMES ProcessTime = (PKERNEL_USER_TIMES)ProcessInformation;
290 ULONG UserTime, KernelTime;
291
292 /* Set the return length */
293 if (ProcessInformationLength != sizeof(KERNEL_USER_TIMES))
294 {
295 Status = STATUS_INFO_LENGTH_MISMATCH;
296 break;
297 }
298
299 Length = sizeof(KERNEL_USER_TIMES);
300
301 /* Reference the process */
302 Status = ObReferenceObjectByHandle(ProcessHandle,
303 PROCESS_QUERY_INFORMATION,
304 PsProcessType,
305 PreviousMode,
306 (PVOID*)&Process,
307 NULL);
308 if (!NT_SUCCESS(Status)) break;
309
310 /* Protect writes with SEH */
311 _SEH2_TRY
312 {
313 /* Copy time information from EPROCESS/KPROCESS */
314 KernelTime = KeQueryRuntimeProcess(&Process->Pcb, &UserTime);
315 ProcessTime->CreateTime = Process->CreateTime;
316 ProcessTime->UserTime.QuadPart = (LONGLONG)UserTime * KeMaximumIncrement;
317 ProcessTime->KernelTime.QuadPart = (LONGLONG)KernelTime * KeMaximumIncrement;
318 ProcessTime->ExitTime = Process->ExitTime;
319 }
320 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
321 {
322 /* Get exception code */
323 Status = _SEH2_GetExceptionCode();
324 }
325 _SEH2_END;
326
327 /* Dereference the process */
328 ObDereferenceObject(Process);
329 break;
330 }
331
332 /* Process Debug Port */
333 case ProcessDebugPort:
334
335 if (ProcessInformationLength != sizeof(HANDLE))
336 {
337 Status = STATUS_INFO_LENGTH_MISMATCH;
338 break;
339 }
340
341 /* Set the return length */
342 Length = sizeof(HANDLE);
343
344 /* Reference the process */
345 Status = ObReferenceObjectByHandle(ProcessHandle,
346 PROCESS_QUERY_INFORMATION,
347 PsProcessType,
348 PreviousMode,
349 (PVOID*)&Process,
350 NULL);
351 if (!NT_SUCCESS(Status)) break;
352
353 /* Protect write with SEH */
354 _SEH2_TRY
355 {
356 /* Return whether or not we have a debug port */
357 *(PHANDLE)ProcessInformation = (Process->DebugPort ?
358 (HANDLE)-1 : NULL);
359 }
360 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
361 {
362 /* Get exception code */
363 Status = _SEH2_GetExceptionCode();
364 }
365 _SEH2_END;
366
367 /* Dereference the process */
368 ObDereferenceObject(Process);
369 break;
370
371 case ProcessHandleCount:
372 {
373 ULONG HandleCount;
374
375 if (ProcessInformationLength != sizeof(ULONG))
376 {
377 Status = STATUS_INFO_LENGTH_MISMATCH;
378 break;
379 }
380
381 /* Set the return length*/
382 Length = sizeof(ULONG);
383
384 /* Reference the process */
385 Status = ObReferenceObjectByHandle(ProcessHandle,
386 PROCESS_QUERY_INFORMATION,
387 PsProcessType,
388 PreviousMode,
389 (PVOID*)&Process,
390 NULL);
391 if (!NT_SUCCESS(Status)) break;
392
393 /* Count the number of handles this process has */
394 HandleCount = ObGetProcessHandleCount(Process);
395
396 /* Protect write in SEH */
397 _SEH2_TRY
398 {
399 /* Return the count of handles */
400 *(PULONG)ProcessInformation = HandleCount;
401 }
402 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
403 {
404 /* Get the exception code */
405 Status = _SEH2_GetExceptionCode();
406 }
407 _SEH2_END;
408
409 /* Dereference the process */
410 ObDereferenceObject(Process);
411 break;
412 }
413
414 /* Session ID for the process */
415 case ProcessSessionInformation:
416 {
417 PPROCESS_SESSION_INFORMATION SessionInfo = (PPROCESS_SESSION_INFORMATION)ProcessInformation;
418
419 if (ProcessInformationLength != sizeof(PROCESS_SESSION_INFORMATION))
420 {
421 Status = STATUS_INFO_LENGTH_MISMATCH;
422 break;
423 }
424
425 /* Set the return length*/
426 Length = sizeof(PROCESS_SESSION_INFORMATION);
427
428 /* Reference the process */
429 Status = ObReferenceObjectByHandle(ProcessHandle,
430 PROCESS_QUERY_INFORMATION,
431 PsProcessType,
432 PreviousMode,
433 (PVOID*)&Process,
434 NULL);
435 if (!NT_SUCCESS(Status)) break;
436
437 /* Enter SEH for write safety */
438 _SEH2_TRY
439 {
440 /* Write back the Session ID */
441 SessionInfo->SessionId = PsGetProcessSessionId(Process);
442 }
443 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
444 {
445 /* Get the exception code */
446 Status = _SEH2_GetExceptionCode();
447 }
448 _SEH2_END;
449
450 /* Dereference the process */
451 ObDereferenceObject(Process);
452 break;
453 }
454
455 /* Virtual Memory Statistics */
456 case ProcessVmCounters:
457 {
458 PVM_COUNTERS VmCounters = (PVM_COUNTERS)ProcessInformation;
459
460 /* Validate the input length */
461 if ((ProcessInformationLength != sizeof(VM_COUNTERS)) &&
462 (ProcessInformationLength != sizeof(VM_COUNTERS_EX)))
463 {
464 Status = STATUS_INFO_LENGTH_MISMATCH;
465 break;
466 }
467
468 /* Reference the process */
469 Status = ObReferenceObjectByHandle(ProcessHandle,
470 PROCESS_QUERY_INFORMATION,
471 PsProcessType,
472 PreviousMode,
473 (PVOID*)&Process,
474 NULL);
475 if (!NT_SUCCESS(Status)) break;
476
477 /* Enter SEH for write safety */
478 _SEH2_TRY
479 {
480 /* Return data from EPROCESS */
481 VmCounters->PeakVirtualSize = Process->PeakVirtualSize;
482 VmCounters->VirtualSize = Process->VirtualSize;
483 VmCounters->PageFaultCount = Process->Vm.PageFaultCount;
484 VmCounters->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
485 VmCounters->WorkingSetSize = Process->Vm.WorkingSetSize;
486 VmCounters->QuotaPeakPagedPoolUsage = Process->QuotaPeak[PsPagedPool];
487 VmCounters->QuotaPagedPoolUsage = Process->QuotaUsage[PsPagedPool];
488 VmCounters->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[PsNonPagedPool];
489 VmCounters->QuotaNonPagedPoolUsage = Process->QuotaUsage[PsNonPagedPool];
490 VmCounters->PagefileUsage = Process->QuotaUsage[PsPageFile] << PAGE_SHIFT;
491 VmCounters->PeakPagefileUsage = Process->QuotaPeak[PsPageFile] << PAGE_SHIFT;
492 //VmCounters->PrivateUsage = Process->CommitCharge << PAGE_SHIFT;
493 //
494
495 /* Set the return length */
496 Length = ProcessInformationLength;
497 }
498 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
499 {
500 /* Get the exception code */
501 Status = _SEH2_GetExceptionCode();
502 }
503 _SEH2_END;
504
505 /* Dereference the process */
506 ObDereferenceObject(Process);
507 break;
508 }
509
510 /* Hard Error Processing Mode */
511 case ProcessDefaultHardErrorMode:
512
513 if (ProcessInformationLength != sizeof(ULONG))
514 {
515 Status = STATUS_INFO_LENGTH_MISMATCH;
516 break;
517 }
518
519 /* Set the return length*/
520 Length = sizeof(ULONG);
521
522 /* Reference the process */
523 Status = ObReferenceObjectByHandle(ProcessHandle,
524 PROCESS_QUERY_INFORMATION,
525 PsProcessType,
526 PreviousMode,
527 (PVOID*)&Process,
528 NULL);
529 if (!NT_SUCCESS(Status)) break;
530
531 /* Enter SEH for writing back data */
532 _SEH2_TRY
533 {
534 /* Write the current processing mode */
535 *(PULONG)ProcessInformation = Process->
536 DefaultHardErrorProcessing;
537 }
538 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
539 {
540 /* Get the exception code */
541 Status = _SEH2_GetExceptionCode();
542 }
543 _SEH2_END;
544
545 /* Dereference the process */
546 ObDereferenceObject(Process);
547 break;
548
549 /* Priority Boosting status */
550 case ProcessPriorityBoost:
551
552 if (ProcessInformationLength != sizeof(ULONG))
553 {
554 Status = STATUS_INFO_LENGTH_MISMATCH;
555 break;
556 }
557
558 /* Set the return length */
559 Length = sizeof(ULONG);
560
561 /* Reference the process */
562 Status = ObReferenceObjectByHandle(ProcessHandle,
563 PROCESS_QUERY_INFORMATION,
564 PsProcessType,
565 PreviousMode,
566 (PVOID*)&Process,
567 NULL);
568 if (!NT_SUCCESS(Status)) break;
569
570 /* Enter SEH for writing back data */
571 _SEH2_TRY
572 {
573 /* Return boost status */
574 *(PULONG)ProcessInformation = Process->Pcb.DisableBoost ?
575 TRUE : FALSE;
576 }
577 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
578 {
579 /* Get the exception code */
580 Status = _SEH2_GetExceptionCode();
581 }
582 _SEH2_END;
583
584 /* Dereference the process */
585 ObDereferenceObject(Process);
586 break;
587
588 /* DOS Device Map */
589 case ProcessDeviceMap:
590 {
591 ULONG Flags;
592
593 if (ProcessInformationLength == sizeof(PROCESS_DEVICEMAP_INFORMATION_EX))
594 {
595 /* Protect read in SEH */
596 _SEH2_TRY
597 {
598 PPROCESS_DEVICEMAP_INFORMATION_EX DeviceMapEx = ProcessInformation;
599
600 Flags = DeviceMapEx->Flags;
601 }
602 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
603 {
604 /* Get the exception code */
605 Status = _SEH2_GetExceptionCode();
606 _SEH2_YIELD(break);
607 }
608 _SEH2_END;
609
610 /* Only one flag is supported and it needs LUID mappings */
611 if ((Flags & ~PROCESS_LUID_DOSDEVICES_ONLY) != 0 ||
612 !ObIsLUIDDeviceMapsEnabled())
613 {
614 Status = STATUS_INVALID_PARAMETER;
615 break;
616 }
617 }
618 else
619 {
620 /* This has to be the size of the Query union field for x64 compatibility! */
621 if (ProcessInformationLength != RTL_FIELD_SIZE(PROCESS_DEVICEMAP_INFORMATION, Query))
622 {
623 Status = STATUS_INFO_LENGTH_MISMATCH;
624 break;
625 }
626
627 /* No flags for standard call */
628 Flags = 0;
629 }
630
631 /* Set the return length */
632 Length = ProcessInformationLength;
633
634 /* Reference the process */
635 Status = ObReferenceObjectByHandle(ProcessHandle,
636 PROCESS_QUERY_INFORMATION,
637 PsProcessType,
638 PreviousMode,
639 (PVOID*)&Process,
640 NULL);
641 if (!NT_SUCCESS(Status)) break;
642
643 /* Query the device map information */
644 Status = ObQueryDeviceMapInformation(Process,
645 ProcessInformation,
646 Flags);
647
648 /* Dereference the process */
649 ObDereferenceObject(Process);
650 break;
651 }
652
653 /* Priority class */
654 case ProcessPriorityClass:
655 {
656 PPROCESS_PRIORITY_CLASS PsPriorityClass = (PPROCESS_PRIORITY_CLASS)ProcessInformation;
657
658 if (ProcessInformationLength != sizeof(PROCESS_PRIORITY_CLASS))
659 {
660 Status = STATUS_INFO_LENGTH_MISMATCH;
661 break;
662 }
663
664 /* Set the return length*/
665 Length = sizeof(PROCESS_PRIORITY_CLASS);
666
667 /* Reference the process */
668 Status = ObReferenceObjectByHandle(ProcessHandle,
669 PROCESS_QUERY_INFORMATION,
670 PsProcessType,
671 PreviousMode,
672 (PVOID*)&Process,
673 NULL);
674 if (!NT_SUCCESS(Status)) break;
675
676 /* Enter SEH for writing back data */
677 _SEH2_TRY
678 {
679 /* Return current priority class */
680 PsPriorityClass->PriorityClass = Process->PriorityClass;
681 PsPriorityClass->Foreground = FALSE;
682 }
683 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
684 {
685 /* Get the exception code */
686 Status = _SEH2_GetExceptionCode();
687 }
688 _SEH2_END;
689
690 /* Dereference the process */
691 ObDereferenceObject(Process);
692 break;
693 }
694
695 case ProcessImageFileName:
696 {
697 PUNICODE_STRING ImageName;
698
699 /* Reference the process */
700 Status = ObReferenceObjectByHandle(ProcessHandle,
701 PROCESS_QUERY_INFORMATION,
702 PsProcessType,
703 PreviousMode,
704 (PVOID*)&Process,
705 NULL);
706 if (!NT_SUCCESS(Status)) break;
707
708 /* Get the image path */
709 Status = SeLocateProcessImageName(Process, &ImageName);
710 if (NT_SUCCESS(Status))
711 {
712 /* Set the return length */
713 Length = ImageName->MaximumLength +
714 sizeof(OBJECT_NAME_INFORMATION);
715
716 /* Make sure it's large enough */
717 if (Length <= ProcessInformationLength)
718 {
719 /* Enter SEH to protect write */
720 _SEH2_TRY
721 {
722 /* Copy it */
723 RtlCopyMemory(ProcessInformation,
724 ImageName,
725 Length);
726
727 /* Update pointer */
728 ((PUNICODE_STRING)ProcessInformation)->Buffer =
729 (PWSTR)((PUNICODE_STRING)ProcessInformation + 1);
730 }
731 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
732 {
733 /* Get the exception code */
734 Status = _SEH2_GetExceptionCode();
735 }
736 _SEH2_END;
737 }
738 else
739 {
740 /* Buffer too small */
741 Status = STATUS_INFO_LENGTH_MISMATCH;
742 }
743
744 /* Free the image path */
745 ExFreePoolWithTag(ImageName, TAG_SEPA);
746 }
747 /* Dereference the process */
748 ObDereferenceObject(Process);
749 break;
750 }
751
752#if (NTDDI_VERSION >= NTDDI_VISTA) || (DLL_EXPORT_VERSION >= _WIN32_WINNT_VISTA)
753 case ProcessImageFileNameWin32:
754 {
755 PFILE_OBJECT FileObject;
756 POBJECT_NAME_INFORMATION ObjectNameInformation;
757
758 /* Reference the process */
759 Status = ObReferenceObjectByHandle(ProcessHandle,
760 PROCESS_QUERY_INFORMATION, // FIXME: Use PROCESS_QUERY_LIMITED_INFORMATION if implemented
761 PsProcessType,
762 PreviousMode,
763 (PVOID*)&Process,
764 NULL);
765 if (!NT_SUCCESS(Status))
766 {
767 break;
768 }
769
770 /* Get the image path */
771 Status = PsReferenceProcessFilePointer(Process, &FileObject);
772 ObDereferenceObject(Process);
773 if (!NT_SUCCESS(Status))
774 {
775 break;
776 }
777 Status = IoQueryFileDosDeviceName(FileObject, &ObjectNameInformation);
778 ObDereferenceObject(FileObject);
779 if (!NT_SUCCESS(Status))
780 {
781 break;
782 }
783
784 /* Determine return length and output */
785 Length = sizeof(UNICODE_STRING) + ObjectNameInformation->Name.MaximumLength;
786 if (Length <= ProcessInformationLength)
787 {
788 _SEH2_TRY
789 {
790 PUNICODE_STRING ImageName = (PUNICODE_STRING)ProcessInformation;
791 ImageName->Length = ObjectNameInformation->Name.Length;
792 ImageName->MaximumLength = ObjectNameInformation->Name.MaximumLength;
793 if (ObjectNameInformation->Name.MaximumLength)
794 {
795 ImageName->Buffer = (PWSTR)(ImageName + 1);
796 RtlCopyMemory(ImageName->Buffer,
797 ObjectNameInformation->Name.Buffer,
798 ObjectNameInformation->Name.MaximumLength);
799 }
800 else
801 {
802 ASSERT(ImageName->Length == 0);
803 ImageName->Buffer = NULL;
804 }
805 }
806 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
807 {
808 Status = _SEH2_GetExceptionCode();
809 }
810 _SEH2_END;
811 }
812 else
813 {
814 Status = STATUS_INFO_LENGTH_MISMATCH;
815 }
816 ExFreePool(ObjectNameInformation);
817
818 break;
819 }
820#endif /* (NTDDI_VERSION >= NTDDI_VISTA) || (DLL_EXPORT_VERSION >= _WIN32_WINNT_VISTA) */
821
822 case ProcessDebugFlags:
823
824 if (ProcessInformationLength != sizeof(ULONG))
825 {
826 Status = STATUS_INFO_LENGTH_MISMATCH;
827 break;
828 }
829
830 /* Set the return length*/
831 Length = sizeof(ULONG);
832
833 /* Reference the process */
834 Status = ObReferenceObjectByHandle(ProcessHandle,
835 PROCESS_QUERY_INFORMATION,
836 PsProcessType,
837 PreviousMode,
838 (PVOID*)&Process,
839 NULL);
840 if (!NT_SUCCESS(Status)) break;
841
842 /* Enter SEH for writing back data */
843 _SEH2_TRY
844 {
845 /* Return the debug flag state */
846 *(PULONG)ProcessInformation = Process->NoDebugInherit ? 0 : 1;
847 }
848 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
849 {
850 /* Get the exception code */
851 Status = _SEH2_GetExceptionCode();
852 }
853 _SEH2_END;
854
855 /* Dereference the process */
856 ObDereferenceObject(Process);
857 break;
858
859 case ProcessBreakOnTermination:
860
861 if (ProcessInformationLength != sizeof(ULONG))
862 {
863 Status = STATUS_INFO_LENGTH_MISMATCH;
864 break;
865 }
866
867 /* Set the return length */
868 Length = sizeof(ULONG);
869
870 /* Reference the process */
871 Status = ObReferenceObjectByHandle(ProcessHandle,
872 PROCESS_QUERY_INFORMATION,
873 PsProcessType,
874 PreviousMode,
875 (PVOID*)&Process,
876 NULL);
877 if (!NT_SUCCESS(Status)) break;
878
879 /* Enter SEH for writing back data */
880 _SEH2_TRY
881 {
882 /* Return the BreakOnTermination state */
883 *(PULONG)ProcessInformation = Process->BreakOnTermination;
884 }
885 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
886 {
887 /* Get the exception code */
888 Status = _SEH2_GetExceptionCode();
889 }
890 _SEH2_END;
891
892 /* Dereference the process */
893 ObDereferenceObject(Process);
894 break;
895
896 /* Per-process security cookie */
897 case ProcessCookie:
898 {
899 ULONG Cookie;
900
901 if (ProcessInformationLength != sizeof(ULONG))
902 {
903 /* Length size wrong, bail out */
904 Status = STATUS_INFO_LENGTH_MISMATCH;
905 break;
906 }
907
908 /* Get the current process and cookie */
909 Process = PsGetCurrentProcess();
910 Cookie = Process->Cookie;
911 if (!Cookie)
912 {
913 LARGE_INTEGER SystemTime;
914 ULONG NewCookie;
915 PKPRCB Prcb;
916
917 /* Generate a new cookie */
918 KeQuerySystemTime(&SystemTime);
919 Prcb = KeGetCurrentPrcb();
920 NewCookie = Prcb->KeSystemCalls ^ Prcb->InterruptTime ^
921 SystemTime.u.LowPart ^ SystemTime.u.HighPart;
922
923 /* Set the new cookie or return the current one */
924 Cookie = InterlockedCompareExchange((LONG*)&Process->Cookie,
925 NewCookie,
926 Cookie);
927 if (!Cookie) Cookie = NewCookie;
928
929 /* Set the return length */
930 Length = sizeof(ULONG);
931 }
932
933 /* Indicate success */
934 Status = STATUS_SUCCESS;
935
936 /* Enter SEH to protect write */
937 _SEH2_TRY
938 {
939 /* Write back the cookie */
940 *(PULONG)ProcessInformation = Cookie;
941 }
942 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
943 {
944 /* Get the exception code */
945 Status = _SEH2_GetExceptionCode();
946 }
947 _SEH2_END;
948 break;
949 }
950
951 case ProcessImageInformation:
952
953 if (ProcessInformationLength != sizeof(SECTION_IMAGE_INFORMATION))
954 {
955 /* Break out */
956 Status = STATUS_INFO_LENGTH_MISMATCH;
957 break;
958 }
959
960 /* Set the length required and validate it */
961 Length = sizeof(SECTION_IMAGE_INFORMATION);
962
963 /* Indicate success */
964 Status = STATUS_SUCCESS;
965
966 /* Enter SEH to protect write */
967 _SEH2_TRY
968 {
969 MmGetImageInformation((PSECTION_IMAGE_INFORMATION)ProcessInformation);
970 }
971 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
972 {
973 /* Get the exception code */
974 Status = _SEH2_GetExceptionCode();
975 }
976 _SEH2_END;
977 break;
978
979 case ProcessDebugObjectHandle:
980 {
981 HANDLE DebugPort = NULL;
982
983 if (ProcessInformationLength != sizeof(HANDLE))
984 {
985 Status = STATUS_INFO_LENGTH_MISMATCH;
986 break;
987 }
988
989 /* Set the return length */
990 Length = sizeof(HANDLE);
991
992 /* Reference the process */
993 Status = ObReferenceObjectByHandle(ProcessHandle,
994 PROCESS_QUERY_INFORMATION,
995 PsProcessType,
996 PreviousMode,
997 (PVOID*)&Process,
998 NULL);
999 if (!NT_SUCCESS(Status)) break;
1000
1001 /* Get the debug port. Continue even if this fails. */
1002 Status = DbgkOpenProcessDebugPort(Process, PreviousMode, &DebugPort);
1003
1004 /* Let go of the process */
1005 ObDereferenceObject(Process);
1006
1007 /* Protect write in SEH */
1008 _SEH2_TRY
1009 {
1010 /* Return debug port's handle */
1011 *(PHANDLE)ProcessInformation = DebugPort;
1012 }
1013 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1014 {
1015 if (DebugPort)
1016 ObCloseHandle(DebugPort, PreviousMode);
1017
1018 /* Get the exception code.
1019 * Note: This overwrites any previous failure status. */
1020 Status = _SEH2_GetExceptionCode();
1021 }
1022 _SEH2_END;
1023 break;
1024 }
1025
1026 case ProcessHandleTracing:
1027 DPRINT1("Handle tracing not implemented: %lu\n", ProcessInformationClass);
1028 Status = STATUS_NOT_IMPLEMENTED;
1029 break;
1030
1031 case ProcessLUIDDeviceMapsEnabled:
1032
1033 if (ProcessInformationLength != sizeof(ULONG))
1034 {
1035 Status = STATUS_INFO_LENGTH_MISMATCH;
1036 break;
1037 }
1038
1039 /* Set the return length */
1040 Length = sizeof(ULONG);
1041
1042 /* Indicate success */
1043 Status = STATUS_SUCCESS;
1044
1045 /* Protect write in SEH */
1046 _SEH2_TRY
1047 {
1048 /* Query Ob */
1049 *(PULONG)ProcessInformation = ObIsLUIDDeviceMapsEnabled();
1050 }
1051 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1052 {
1053 /* Get the exception code */
1054 Status = _SEH2_GetExceptionCode();
1055 }
1056 _SEH2_END;
1057 break;
1058
1059 case ProcessWx86Information:
1060
1061 if (ProcessInformationLength != sizeof(ULONG))
1062 {
1063 Status = STATUS_INFO_LENGTH_MISMATCH;
1064 break;
1065 }
1066
1067 /* Set the return length */
1068 Length = sizeof(ULONG);
1069
1070 /* Reference the process */
1071 Status = ObReferenceObjectByHandle(ProcessHandle,
1072 PROCESS_QUERY_INFORMATION,
1073 PsProcessType,
1074 PreviousMode,
1075 (PVOID*)&Process,
1076 NULL);
1077 if (!NT_SUCCESS(Status)) break;
1078
1079 /* Protect write in SEH */
1080 _SEH2_TRY
1081 {
1082 /* Return if the flag is set */
1083 *(PULONG)ProcessInformation = (ULONG)Process->VdmAllowed;
1084 }
1085 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1086 {
1087 /* Get the exception code */
1088 Status = _SEH2_GetExceptionCode();
1089 }
1090 _SEH2_END;
1091
1092 /* Dereference the process */
1093 ObDereferenceObject(Process);
1094 break;
1095
1096 case ProcessWow64Information:
1097 {
1098 ULONG_PTR Wow64 = 0;
1099
1100 if (ProcessInformationLength != sizeof(ULONG_PTR))
1101 {
1102 Status = STATUS_INFO_LENGTH_MISMATCH;
1103 break;
1104 }
1105
1106 /* Set the return length */
1107 Length = sizeof(ULONG_PTR);
1108
1109 /* Reference the process */
1110 Status = ObReferenceObjectByHandle(ProcessHandle,
1111 PROCESS_QUERY_INFORMATION,
1112 PsProcessType,
1113 PreviousMode,
1114 (PVOID*)&Process,
1115 NULL);
1116 if (!NT_SUCCESS(Status)) break;
1117
1118#ifdef _WIN64
1119 /* Make sure the process isn't dying */
1120 if (ExAcquireRundownProtection(&Process->RundownProtect))
1121 {
1122 /* Get the WOW64 process structure */
1123 Wow64 = (ULONG_PTR)Process->Wow64Process;
1124 /* Release the lock */
1125 ExReleaseRundownProtection(&Process->RundownProtect);
1126 }
1127#endif
1128
1129 /* Dereference the process */
1130 ObDereferenceObject(Process);
1131
1132 /* Protect write with SEH */
1133 _SEH2_TRY
1134 {
1135 /* Return the Wow64 process information */
1136 *(PULONG_PTR)ProcessInformation = Wow64;
1137 }
1138 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1139 {
1140 /* Get exception code */
1141 Status = _SEH2_GetExceptionCode();
1142 }
1143 _SEH2_END;
1144 break;
1145 }
1146
1147 case ProcessExecuteFlags:
1148 {
1149 ULONG ExecuteOptions = 0;
1150
1151 if (ProcessInformationLength != sizeof(ULONG))
1152 {
1153 Status = STATUS_INFO_LENGTH_MISMATCH;
1154 break;
1155 }
1156
1157 /* Set the return length */
1158 Length = sizeof(ULONG);
1159
1160 if (ProcessHandle != NtCurrentProcess())
1161 {
1162 Status = STATUS_INVALID_PARAMETER;
1163 break;
1164 }
1165
1166 /* Get the options */
1167 Status = MmGetExecuteOptions(&ExecuteOptions);
1168 if (NT_SUCCESS(Status))
1169 {
1170 /* Protect write with SEH */
1171 _SEH2_TRY
1172 {
1173 /* Return them */
1174 *(PULONG)ProcessInformation = ExecuteOptions;
1175 }
1176 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1177 {
1178 /* Get exception code */
1179 Status = _SEH2_GetExceptionCode();
1180 }
1181 _SEH2_END;
1182 }
1183 break;
1184 }
1185
1186 case ProcessLdtInformation:
1187 DPRINT1("VDM/16-bit not implemented: %lu\n", ProcessInformationClass);
1188 Status = STATUS_NOT_IMPLEMENTED;
1189 break;
1190
1191 case ProcessWorkingSetWatch:
1192 DPRINT1("WS Watch not implemented: %lu\n", ProcessInformationClass);
1193 Status = STATUS_NOT_IMPLEMENTED;
1194 break;
1195
1196 case ProcessPooledUsageAndLimits:
1197 DPRINT1("Pool limits not implemented: %lu\n", ProcessInformationClass);
1198 Status = STATUS_NOT_IMPLEMENTED;
1199 break;
1200
1201 /* Not supported by Server 2003 */
1202 default:
1203 DPRINT1("Unsupported info class: %lu\n", ProcessInformationClass);
1204 Status = STATUS_INVALID_INFO_CLASS;
1205 }
1206
1207 /* Check if caller wants the return length and if there is one */
1208 if (ReturnLength != NULL && Length != 0)
1209 {
1210 /* Protect write with SEH */
1211 _SEH2_TRY
1212 {
1213 *ReturnLength = Length;
1214 }
1215 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1216 {
1217 /* Get exception code.
1218 * Note: This overwrites any previous failure status. */
1219 Status = _SEH2_GetExceptionCode();
1220 }
1221 _SEH2_END;
1222 }
1223
1224 return Status;
1225}
1226
1227/*
1228 * @implemented
1229 */
1230NTSTATUS
1231NTAPI
1232NtSetInformationProcess(IN HANDLE ProcessHandle,
1233 IN PROCESSINFOCLASS ProcessInformationClass,
1234 IN PVOID ProcessInformation,
1235 IN ULONG ProcessInformationLength)
1236{
1237 PEPROCESS Process;
1238 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
1239 ACCESS_MASK Access;
1240 NTSTATUS Status;
1241 HANDLE PortHandle = NULL;
1242 HANDLE TokenHandle = NULL;
1243 HANDLE DirectoryHandle = NULL;
1244 PROCESS_SESSION_INFORMATION SessionInfo = {0};
1245 PROCESS_PRIORITY_CLASS PriorityClass = {0};
1246 PROCESS_FOREGROUND_BACKGROUND Foreground = {0};
1247 PVOID ExceptionPort;
1248 ULONG Break;
1249 KAFFINITY ValidAffinity, Affinity = 0;
1250 KPRIORITY BasePriority = 0;
1251 UCHAR MemoryPriority = 0;
1252 BOOLEAN DisableBoost = 0;
1253 ULONG DefaultHardErrorMode = 0;
1254 ULONG DebugFlags = 0, EnableFixup = 0, Boost = 0;
1255 ULONG NoExecute = 0, VdmPower = 0;
1256 BOOLEAN HasPrivilege;
1257 PLIST_ENTRY Next;
1258 PETHREAD Thread;
1259 PAGED_CODE();
1260
1261 /* Validate the information class */
1262 Status = DefaultSetInfoBufferCheck(ProcessInformationClass,
1263 PsProcessInfoClass,
1264 RTL_NUMBER_OF(PsProcessInfoClass),
1265 ProcessInformation,
1266 ProcessInformationLength,
1267 PreviousMode);
1268 if (!NT_SUCCESS(Status))
1269 {
1270 DPRINT1("NtSetInformationProcess(ProcessInformationClass: %lu): Class validation failed! (Status: 0x%lx)\n",
1271 ProcessInformationClass, Status);
1272 return Status;
1273 }
1274
1275 /* Check what class this is */
1276 Access = PROCESS_SET_INFORMATION;
1277 if (ProcessInformationClass == ProcessSessionInformation)
1278 {
1279 /* Setting the Session ID needs a special mask */
1280 Access |= PROCESS_SET_SESSIONID;
1281 }
1282 else if (ProcessInformationClass == ProcessExceptionPort)
1283 {
1284 /* Setting the exception port needs a special mask */
1285 Access |= PROCESS_SUSPEND_RESUME;
1286 }
1287
1288 /* Reference the process */
1289 Status = ObReferenceObjectByHandle(ProcessHandle,
1290 Access,
1291 PsProcessType,
1292 PreviousMode,
1293 (PVOID*)&Process,
1294 NULL);
1295 if (!NT_SUCCESS(Status)) return Status;
1296
1297 /* Check what kind of information class this is */
1298 switch (ProcessInformationClass)
1299 {
1300 case ProcessWx86Information:
1301
1302 /* Check buffer length */
1303 if (ProcessInformationLength != sizeof(ULONG))
1304 {
1305 Status = STATUS_INFO_LENGTH_MISMATCH;
1306 break;
1307 }
1308
1309 /* Use SEH for capture */
1310 _SEH2_TRY
1311 {
1312 /* Capture the boolean */
1313 VdmPower = *(PULONG)ProcessInformation;
1314 }
1315 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1316 {
1317 /* Get the exception code */
1318 Status = _SEH2_GetExceptionCode();
1319 _SEH2_YIELD(break);
1320 }
1321 _SEH2_END;
1322
1323 /* Getting VDM powers requires the SeTcbPrivilege */
1324 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
1325 {
1326 /* We don't hold the privilege, bail out */
1327 Status = STATUS_PRIVILEGE_NOT_HELD;
1328 DPRINT1("Need TCB privilege\n");
1329 break;
1330 }
1331
1332 /* Set or clear the flag */
1333 if (VdmPower)
1334 {
1335 PspSetProcessFlag(Process, PSF_VDM_ALLOWED_BIT);
1336 }
1337 else
1338 {
1339 PspClearProcessFlag(Process, PSF_VDM_ALLOWED_BIT);
1340 }
1341 break;
1342
1343 /* Error/Exception Port */
1344 case ProcessExceptionPort:
1345
1346 /* Check buffer length */
1347 if (ProcessInformationLength != sizeof(HANDLE))
1348 {
1349 Status = STATUS_INFO_LENGTH_MISMATCH;
1350 break;
1351 }
1352
1353 /* Use SEH for capture */
1354 _SEH2_TRY
1355 {
1356 /* Capture the handle */
1357 PortHandle = *(PHANDLE)ProcessInformation;
1358 }
1359 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1360 {
1361 /* Get the exception code */
1362 Status = _SEH2_GetExceptionCode();
1363 _SEH2_YIELD(break);
1364 }
1365 _SEH2_END;
1366
1367 /* Setting the error port requires the SeTcbPrivilege */
1368 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
1369 {
1370 /* We don't hold the privilege, bail out */
1371 Status = STATUS_PRIVILEGE_NOT_HELD;
1372 break;
1373 }
1374
1375 /* Get the LPC Port */
1376 Status = ObReferenceObjectByHandle(PortHandle,
1377 0,
1378 LpcPortObjectType,
1379 PreviousMode,
1380 (PVOID)&ExceptionPort,
1381 NULL);
1382 if (!NT_SUCCESS(Status)) break;
1383
1384 /* Change the pointer */
1385 if (InterlockedCompareExchangePointer(&Process->ExceptionPort,
1386 ExceptionPort,
1387 NULL))
1388 {
1389 /* We already had one, fail */
1390 ObDereferenceObject(ExceptionPort);
1391 Status = STATUS_PORT_ALREADY_SET;
1392 }
1393 break;
1394
1395 /* Security Token */
1396 case ProcessAccessToken:
1397
1398 /* Check buffer length */
1399 if (ProcessInformationLength != sizeof(PROCESS_ACCESS_TOKEN))
1400 {
1401 Status = STATUS_INFO_LENGTH_MISMATCH;
1402 break;
1403 }
1404
1405 /* Use SEH for capture */
1406 _SEH2_TRY
1407 {
1408 /* Save the token handle */
1409 TokenHandle = ((PPROCESS_ACCESS_TOKEN)ProcessInformation)->
1410 Token;
1411 }
1412 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1413 {
1414 /* Get the exception code */
1415 Status = _SEH2_GetExceptionCode();
1416 _SEH2_YIELD(break);
1417 }
1418 _SEH2_END;
1419
1420 /* Assign the actual token */
1421 Status = PspSetPrimaryToken(Process, TokenHandle, NULL);
1422 break;
1423
1424 /* Hard error processing */
1425 case ProcessDefaultHardErrorMode:
1426
1427 /* Check buffer length */
1428 if (ProcessInformationLength != sizeof(ULONG))
1429 {
1430 Status = STATUS_INFO_LENGTH_MISMATCH;
1431 break;
1432 }
1433
1434 /* Enter SEH for direct buffer read */
1435 _SEH2_TRY
1436 {
1437 DefaultHardErrorMode = *(PULONG)ProcessInformation;
1438 }
1439 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1440 {
1441 /* Get exception code */
1442 Status = _SEH2_GetExceptionCode();
1443 _SEH2_YIELD(break);
1444 }
1445 _SEH2_END;
1446
1447 /* Set the mode */
1448 Process->DefaultHardErrorProcessing = DefaultHardErrorMode;
1449
1450 /* Call Ke for the update */
1451 if (DefaultHardErrorMode & SEM_NOALIGNMENTFAULTEXCEPT)
1452 {
1453 KeSetAutoAlignmentProcess(&Process->Pcb, TRUE);
1454 }
1455 else
1456 {
1457 KeSetAutoAlignmentProcess(&Process->Pcb, FALSE);
1458 }
1459 Status = STATUS_SUCCESS;
1460 break;
1461
1462 /* Session ID */
1463 case ProcessSessionInformation:
1464
1465 /* Check buffer length */
1466 if (ProcessInformationLength != sizeof(PROCESS_SESSION_INFORMATION))
1467 {
1468 Status = STATUS_INFO_LENGTH_MISMATCH;
1469 break;
1470 }
1471
1472 /* Enter SEH for capture */
1473 _SEH2_TRY
1474 {
1475 /* Capture the caller's buffer */
1476 SessionInfo = *(PPROCESS_SESSION_INFORMATION)ProcessInformation;
1477 }
1478 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1479 {
1480 /* Get the exception code */
1481 Status = _SEH2_GetExceptionCode();
1482 _SEH2_YIELD(break);
1483 }
1484 _SEH2_END;
1485
1486 /* Setting the session id requires the SeTcbPrivilege */
1487 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
1488 {
1489 /* We don't hold the privilege, bail out */
1490 Status = STATUS_PRIVILEGE_NOT_HELD;
1491 break;
1492 }
1493
1494#if 0 // OLD AND DEPRECATED CODE!!!!
1495
1496 /* FIXME - update the session id for the process token */
1497 //Status = PsLockProcess(Process, FALSE);
1498 if (!NT_SUCCESS(Status)) break;
1499
1500 /* Write the session ID in the EPROCESS */
1501 Process->Session = UlongToPtr(SessionInfo.SessionId); // HACK!!!
1502
1503 /* Check if the process also has a PEB */
1504 if (Process->Peb)
1505 {
1506 /*
1507 * Attach to the process to make sure we're in the right
1508 * context to access the PEB structure
1509 */
1510 KeAttachProcess(&Process->Pcb);
1511
1512 /* Enter SEH for write to user-mode PEB */
1513 _SEH2_TRY
1514 {
1515 /* Write the session ID */
1516 Process->Peb->SessionId = SessionInfo.SessionId;
1517 }
1518 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1519 {
1520 /* Get exception code */
1521 Status = _SEH2_GetExceptionCode();
1522 }
1523 _SEH2_END;
1524
1525 /* Detach from the process */
1526 KeDetachProcess();
1527 }
1528
1529 /* Unlock the process */
1530 //PsUnlockProcess(Process);
1531
1532#endif
1533
1534 /*
1535 * Since we cannot change the session ID of the given
1536 * process anymore because it is set once and for all
1537 * at process creation time and because it is stored
1538 * inside the Process->Session structure managed by MM,
1539 * we fake changing it: we just return success if the
1540 * user-defined value is the same as the session ID of
1541 * the process, and otherwise we fail.
1542 */
1543 if (SessionInfo.SessionId == PsGetProcessSessionId(Process))
1544 {
1545 Status = STATUS_SUCCESS;
1546 }
1547 else
1548 {
1549 Status = STATUS_ACCESS_DENIED;
1550 }
1551
1552 break;
1553
1554 case ProcessPriorityClass:
1555
1556 /* Check buffer length */
1557 if (ProcessInformationLength != sizeof(PROCESS_PRIORITY_CLASS))
1558 {
1559 Status = STATUS_INFO_LENGTH_MISMATCH;
1560 break;
1561 }
1562
1563 /* Enter SEH for capture */
1564 _SEH2_TRY
1565 {
1566 /* Capture the caller's buffer */
1567 PriorityClass = *(PPROCESS_PRIORITY_CLASS)ProcessInformation;
1568 }
1569 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1570 {
1571 /* Return the exception code */
1572 Status = _SEH2_GetExceptionCode();
1573 _SEH2_YIELD(break);
1574 }
1575 _SEH2_END;
1576
1577 /* Check for invalid PriorityClass value */
1578 if (PriorityClass.PriorityClass > PROCESS_PRIORITY_CLASS_ABOVE_NORMAL)
1579 {
1580 Status = STATUS_INVALID_PARAMETER;
1581 break;
1582 }
1583
1584 if ((PriorityClass.PriorityClass != Process->PriorityClass) &&
1585 (PriorityClass.PriorityClass == PROCESS_PRIORITY_CLASS_REALTIME))
1586 {
1587 /* Check the privilege */
1588 HasPrivilege = SeCheckPrivilegedObject(SeIncreaseBasePriorityPrivilege,
1589 ProcessHandle,
1590 PROCESS_SET_INFORMATION,
1591 PreviousMode);
1592 if (!HasPrivilege)
1593 {
1594 ObDereferenceObject(Process);
1595 DPRINT1("Privilege to change priority to realtime lacking\n");
1596 return STATUS_PRIVILEGE_NOT_HELD;
1597 }
1598 }
1599
1600 /* Check if we have a job */
1601 if (Process->Job)
1602 {
1603 DPRINT1("Jobs not yet supported\n");
1604 }
1605
1606 /* Set process priority class */
1607 Process->PriorityClass = PriorityClass.PriorityClass;
1608
1609 /* Set process priority mode (foreground or background) */
1610 PsSetProcessPriorityByClass(Process,
1611 PriorityClass.Foreground ?
1612 PsProcessPriorityForeground :
1613 PsProcessPriorityBackground);
1614 Status = STATUS_SUCCESS;
1615 break;
1616
1617 case ProcessForegroundInformation:
1618
1619 /* Check buffer length */
1620 if (ProcessInformationLength != sizeof(PROCESS_FOREGROUND_BACKGROUND))
1621 {
1622 Status = STATUS_INFO_LENGTH_MISMATCH;
1623 break;
1624 }
1625
1626 /* Enter SEH for capture */
1627 _SEH2_TRY
1628 {
1629 /* Capture the caller's buffer */
1630 Foreground = *(PPROCESS_FOREGROUND_BACKGROUND)ProcessInformation;
1631 }
1632 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1633 {
1634 /* Return the exception code */
1635 Status = _SEH2_GetExceptionCode();
1636 _SEH2_YIELD(break);
1637 }
1638 _SEH2_END;
1639
1640 /* Set process priority mode (foreground or background) */
1641 PsSetProcessPriorityByClass(Process,
1642 Foreground.Foreground ?
1643 PsProcessPriorityForeground :
1644 PsProcessPriorityBackground);
1645 Status = STATUS_SUCCESS;
1646 break;
1647
1648 case ProcessBasePriority:
1649
1650 /* Validate input length */
1651 if (ProcessInformationLength != sizeof(KPRIORITY))
1652 {
1653 Status = STATUS_INFO_LENGTH_MISMATCH;
1654 break;
1655 }
1656
1657 /* Enter SEH for direct buffer read */
1658 _SEH2_TRY
1659 {
1660 BasePriority = *(KPRIORITY*)ProcessInformation;
1661 }
1662 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1663 {
1664 /* Get exception code */
1665 Break = 0;
1666 Status = _SEH2_GetExceptionCode();
1667 _SEH2_YIELD(break);
1668 }
1669 _SEH2_END;
1670
1671 /* Extract the memory priority out of there */
1672 if (BasePriority & 0x80000000)
1673 {
1674 MemoryPriority = MEMORY_PRIORITY_FOREGROUND;
1675 BasePriority &= ~0x80000000;
1676 }
1677 else
1678 {
1679 MemoryPriority = MEMORY_PRIORITY_BACKGROUND;
1680 }
1681
1682 /* Validate the number */
1683 if ((BasePriority > HIGH_PRIORITY) || (BasePriority <= LOW_PRIORITY))
1684 {
1685 ObDereferenceObject(Process);
1686 return STATUS_INVALID_PARAMETER;
1687 }
1688
1689 /* Check if the new base is higher */
1690 if (BasePriority > Process->Pcb.BasePriority)
1691 {
1692 HasPrivilege = SeCheckPrivilegedObject(SeIncreaseBasePriorityPrivilege,
1693 ProcessHandle,
1694 PROCESS_SET_INFORMATION,
1695 PreviousMode);
1696 if (!HasPrivilege)
1697 {
1698 ObDereferenceObject(Process);
1699 DPRINT1("Privilege to change priority from %lx to %lx lacking\n", Process->Pcb.BasePriority, BasePriority);
1700 return STATUS_PRIVILEGE_NOT_HELD;
1701 }
1702 }
1703
1704 /* Call Ke */
1705 KeSetPriorityAndQuantumProcess(&Process->Pcb, BasePriority, 0);
1706
1707 /* Now set the memory priority */
1708 MmSetMemoryPriorityProcess(Process, MemoryPriority);
1709 Status = STATUS_SUCCESS;
1710 break;
1711
1712 case ProcessRaisePriority:
1713
1714 /* Validate input length */
1715 if (ProcessInformationLength != sizeof(ULONG))
1716 {
1717 Status = STATUS_INFO_LENGTH_MISMATCH;
1718 break;
1719 }
1720
1721 /* Enter SEH for direct buffer read */
1722 _SEH2_TRY
1723 {
1724 Boost = *(PULONG)ProcessInformation;
1725 }
1726 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1727 {
1728 /* Get exception code */
1729 Break = 0;
1730 Status = _SEH2_GetExceptionCode();
1731 _SEH2_YIELD(break);
1732 }
1733 _SEH2_END;
1734
1735 /* Make sure the process isn't dying */
1736 if (ExAcquireRundownProtection(&Process->RundownProtect))
1737 {
1738 /* Lock it */
1739 KeEnterCriticalRegion();
1740 ExAcquirePushLockShared(&Process->ProcessLock);
1741
1742 /* Loop the threads */
1743 for (Next = Process->ThreadListHead.Flink;
1744 Next != &Process->ThreadListHead;
1745 Next = Next->Flink)
1746 {
1747 /* Call Ke for the thread */
1748 Thread = CONTAINING_RECORD(Next, ETHREAD, ThreadListEntry);
1749 KeBoostPriorityThread(&Thread->Tcb, Boost);
1750 }
1751
1752 /* Release the lock and rundown */
1753 ExReleasePushLockShared(&Process->ProcessLock);
1754 KeLeaveCriticalRegion();
1755 ExReleaseRundownProtection(&Process->RundownProtect);
1756
1757 /* Set success code */
1758 Status = STATUS_SUCCESS;
1759 }
1760 else
1761 {
1762 /* Avoid race conditions */
1763 Status = STATUS_PROCESS_IS_TERMINATING;
1764 }
1765 break;
1766
1767 case ProcessBreakOnTermination:
1768
1769 /* Check buffer length */
1770 if (ProcessInformationLength != sizeof(ULONG))
1771 {
1772 Status = STATUS_INFO_LENGTH_MISMATCH;
1773 break;
1774 }
1775
1776 /* Enter SEH for direct buffer read */
1777 _SEH2_TRY
1778 {
1779 Break = *(PULONG)ProcessInformation;
1780 }
1781 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1782 {
1783 /* Get exception code */
1784 Break = 0;
1785 Status = _SEH2_GetExceptionCode();
1786 _SEH2_YIELD(break);
1787 }
1788 _SEH2_END;
1789
1790 /* Setting 'break on termination' requires the SeDebugPrivilege */
1791 if (!SeSinglePrivilegeCheck(SeDebugPrivilege, PreviousMode))
1792 {
1793 /* We don't hold the privilege, bail out */
1794 Status = STATUS_PRIVILEGE_NOT_HELD;
1795 break;
1796 }
1797
1798 /* Set or clear the flag */
1799 if (Break)
1800 {
1801 PspSetProcessFlag(Process, PSF_BREAK_ON_TERMINATION_BIT);
1802 }
1803 else
1804 {
1805 PspClearProcessFlag(Process, PSF_BREAK_ON_TERMINATION_BIT);
1806 }
1807
1808 break;
1809
1810 case ProcessAffinityMask:
1811
1812 /* Check buffer length */
1813 if (ProcessInformationLength != sizeof(KAFFINITY))
1814 {
1815 Status = STATUS_INFO_LENGTH_MISMATCH;
1816 break;
1817 }
1818
1819 /* Enter SEH for direct buffer read */
1820 _SEH2_TRY
1821 {
1822 Affinity = *(PKAFFINITY)ProcessInformation;
1823 }
1824 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1825 {
1826 /* Get exception code */
1827 Break = 0;
1828 Status = _SEH2_GetExceptionCode();
1829 _SEH2_YIELD(break);
1830 }
1831 _SEH2_END;
1832
1833 /* Make sure it's valid for the CPUs present */
1834 ValidAffinity = Affinity & KeActiveProcessors;
1835 if (!Affinity || (ValidAffinity != Affinity))
1836 {
1837 Status = STATUS_INVALID_PARAMETER;
1838 break;
1839 }
1840
1841 /* Check if it's within job affinity limits */
1842 if (Process->Job)
1843 {
1844 /* Not yet implemented */
1845 UNIMPLEMENTED;
1846 Status = STATUS_NOT_IMPLEMENTED;
1847 break;
1848 }
1849
1850 /* Make sure the process isn't dying */
1851 if (ExAcquireRundownProtection(&Process->RundownProtect))
1852 {
1853 /* Lock it */
1854 KeEnterCriticalRegion();
1855 ExAcquirePushLockShared(&Process->ProcessLock);
1856
1857 /* Call Ke to do the work */
1858 KeSetAffinityProcess(&Process->Pcb, ValidAffinity);
1859
1860 /* Release the lock and rundown */
1861 ExReleasePushLockShared(&Process->ProcessLock);
1862 KeLeaveCriticalRegion();
1863 ExReleaseRundownProtection(&Process->RundownProtect);
1864
1865 /* Set success code */
1866 Status = STATUS_SUCCESS;
1867 }
1868 else
1869 {
1870 /* Avoid race conditions */
1871 Status = STATUS_PROCESS_IS_TERMINATING;
1872 }
1873 break;
1874
1875 /* Priority Boosting status */
1876 case ProcessPriorityBoost:
1877
1878 /* Validate input length */
1879 if (ProcessInformationLength != sizeof(ULONG))
1880 {
1881 Status = STATUS_INFO_LENGTH_MISMATCH;
1882 break;
1883 }
1884
1885 /* Enter SEH for direct buffer read */
1886 _SEH2_TRY
1887 {
1888 DisableBoost = *(PBOOLEAN)ProcessInformation;
1889 }
1890 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1891 {
1892 /* Get exception code */
1893 Break = 0;
1894 Status = _SEH2_GetExceptionCode();
1895 _SEH2_YIELD(break);
1896 }
1897 _SEH2_END;
1898
1899 /* Make sure the process isn't dying */
1900 if (ExAcquireRundownProtection(&Process->RundownProtect))
1901 {
1902 /* Lock it */
1903 KeEnterCriticalRegion();
1904 ExAcquirePushLockShared(&Process->ProcessLock);
1905
1906 /* Call Ke to do the work */
1907 KeSetDisableBoostProcess(&Process->Pcb, DisableBoost);
1908
1909 /* Loop the threads too */
1910 for (Next = Process->ThreadListHead.Flink;
1911 Next != &Process->ThreadListHead;
1912 Next = Next->Flink)
1913 {
1914 /* Call Ke for the thread */
1915 Thread = CONTAINING_RECORD(Next, ETHREAD, ThreadListEntry);
1916 KeSetDisableBoostThread(&Thread->Tcb, DisableBoost);
1917 }
1918
1919 /* Release the lock and rundown */
1920 ExReleasePushLockShared(&Process->ProcessLock);
1921 KeLeaveCriticalRegion();
1922 ExReleaseRundownProtection(&Process->RundownProtect);
1923
1924 /* Set success code */
1925 Status = STATUS_SUCCESS;
1926 }
1927 else
1928 {
1929 /* Avoid race conditions */
1930 Status = STATUS_PROCESS_IS_TERMINATING;
1931 }
1932 break;
1933
1934 case ProcessDebugFlags:
1935
1936 /* Check buffer length */
1937 if (ProcessInformationLength != sizeof(ULONG))
1938 {
1939 Status = STATUS_INFO_LENGTH_MISMATCH;
1940 break;
1941 }
1942
1943 /* Enter SEH for direct buffer read */
1944 _SEH2_TRY
1945 {
1946 DebugFlags = *(PULONG)ProcessInformation;
1947 }
1948 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1949 {
1950 /* Get exception code */
1951 Status = _SEH2_GetExceptionCode();
1952 _SEH2_YIELD(break);
1953 }
1954 _SEH2_END;
1955
1956 /* Set the mode */
1957 if (DebugFlags & ~1)
1958 {
1959 Status = STATUS_INVALID_PARAMETER;
1960 }
1961 else
1962 {
1963 if (DebugFlags & 1)
1964 {
1965 PspClearProcessFlag(Process, PSF_NO_DEBUG_INHERIT_BIT);
1966 }
1967 else
1968 {
1969 PspSetProcessFlag(Process, PSF_NO_DEBUG_INHERIT_BIT);
1970 }
1971 }
1972
1973 /* Done */
1974 Status = STATUS_SUCCESS;
1975 break;
1976
1977 case ProcessEnableAlignmentFaultFixup:
1978
1979 /* Check buffer length */
1980 if (ProcessInformationLength != sizeof(BOOLEAN))
1981 {
1982 Status = STATUS_INFO_LENGTH_MISMATCH;
1983 break;
1984 }
1985
1986 /* Enter SEH for direct buffer read */
1987 _SEH2_TRY
1988 {
1989 EnableFixup = *(PULONG)ProcessInformation;
1990 }
1991 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1992 {
1993 /* Get exception code */
1994 Status = _SEH2_GetExceptionCode();
1995 _SEH2_YIELD(break);
1996 }
1997 _SEH2_END;
1998
1999 /* Set the mode */
2000 if (EnableFixup)
2001 {
2002 Process->DefaultHardErrorProcessing |= SEM_NOALIGNMENTFAULTEXCEPT;
2003 }
2004 else
2005 {
2006 Process->DefaultHardErrorProcessing &= ~SEM_NOALIGNMENTFAULTEXCEPT;
2007 }
2008
2009 /* Call Ke for the update */
2010 KeSetAutoAlignmentProcess(&Process->Pcb, FALSE);
2011 Status = STATUS_SUCCESS;
2012 break;
2013
2014 case ProcessUserModeIOPL:
2015
2016 /* Only TCB can do this */
2017 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
2018 {
2019 /* We don't hold the privilege, bail out */
2020 DPRINT1("Need TCB to set IOPL\n");
2021 Status = STATUS_PRIVILEGE_NOT_HELD;
2022 break;
2023 }
2024
2025 /* Only supported on x86 */
2026#if defined (_X86_)
2027 Ke386SetIOPL();
2028#elif defined(_M_AMD64)
2029 /* On x64 this function isn't implemented.
2030 On Windows 2003 it returns success.
2031 On Vista+ it returns STATUS_NOT_IMPLEMENTED. */
2032 if ((ExGetPreviousMode() != KernelMode) &&
2033 (RtlRosGetAppcompatVersion() > _WIN32_WINNT_WS03))
2034 {
2035 Status = STATUS_NOT_IMPLEMENTED;
2036 }
2037#else
2038 Status = STATUS_NOT_IMPLEMENTED;
2039#endif
2040 /* Done */
2041 break;
2042
2043 case ProcessExecuteFlags:
2044
2045 /* Check buffer length */
2046 if (ProcessInformationLength != sizeof(ULONG))
2047 {
2048 Status = STATUS_INFO_LENGTH_MISMATCH;
2049 break;
2050 }
2051
2052 if (ProcessHandle != NtCurrentProcess())
2053 {
2054 Status = STATUS_INVALID_PARAMETER;
2055 break;
2056 }
2057
2058 /* Enter SEH for direct buffer read */
2059 _SEH2_TRY
2060 {
2061 NoExecute = *(PULONG)ProcessInformation;
2062 }
2063 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2064 {
2065 /* Get exception code */
2066 Status = _SEH2_GetExceptionCode();
2067 _SEH2_YIELD(break);
2068 }
2069 _SEH2_END;
2070
2071 /* Call Mm for the update */
2072 Status = MmSetExecuteOptions(NoExecute);
2073 break;
2074
2075 case ProcessDeviceMap:
2076
2077 /* Check buffer length */
2078 if (ProcessInformationLength != sizeof(HANDLE))
2079 {
2080 Status = STATUS_INFO_LENGTH_MISMATCH;
2081 break;
2082 }
2083
2084 /* Use SEH for capture */
2085 _SEH2_TRY
2086 {
2087 /* Capture the handle */
2088 DirectoryHandle = *(PHANDLE)ProcessInformation;
2089 }
2090 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2091 {
2092 /* Get the exception code */
2093 Status = _SEH2_GetExceptionCode();
2094 _SEH2_YIELD(break);
2095 }
2096 _SEH2_END;
2097
2098 /* Call Ob to set the device map */
2099 Status = ObSetDeviceMap(Process, DirectoryHandle);
2100 break;
2101
2102
2103 /* We currently don't implement any of these */
2104 case ProcessLdtInformation:
2105 case ProcessLdtSize:
2106 case ProcessIoPortHandlers:
2107 DPRINT1("VDM/16-bit Request not implemented: %lu\n", ProcessInformationClass);
2108 Status = STATUS_NOT_IMPLEMENTED;
2109 break;
2110
2111 case ProcessQuotaLimits:
2112
2113 Status = PspSetQuotaLimits(Process,
2114 1,
2115 ProcessInformation,
2116 ProcessInformationLength,
2117 PreviousMode);
2118 break;
2119
2120 case ProcessWorkingSetWatch:
2121 DPRINT1("WS watch not implemented\n");
2122 Status = STATUS_NOT_IMPLEMENTED;
2123 break;
2124
2125 case ProcessHandleTracing:
2126 DPRINT1("Handle tracing not implemented\n");
2127 Status = STATUS_NOT_IMPLEMENTED;
2128 break;
2129
2130 /* Anything else is invalid */
2131 default:
2132 DPRINT1("Invalid Server 2003 Info Class: %lu\n", ProcessInformationClass);
2133 Status = STATUS_INVALID_INFO_CLASS;
2134 }
2135
2136 /* Dereference and return status */
2137 ObDereferenceObject(Process);
2138 return Status;
2139}
2140
2141/*
2142 * @implemented
2143 */
2144NTSTATUS
2145NTAPI
2146NtSetInformationThread(IN HANDLE ThreadHandle,
2147 IN THREADINFOCLASS ThreadInformationClass,
2148 IN PVOID ThreadInformation,
2149 IN ULONG ThreadInformationLength)
2150{
2151 PETHREAD Thread;
2152 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
2153 NTSTATUS Status;
2154 HANDLE TokenHandle = NULL;
2155 KPRIORITY Priority = 0;
2156 KAFFINITY Affinity = 0, CombinedAffinity;
2157 PVOID Address = NULL;
2158 PEPROCESS Process;
2159 ULONG_PTR DisableBoost = 0;
2160 ULONG_PTR IdealProcessor = 0;
2161 ULONG_PTR Break = 0;
2162 PTEB Teb;
2163 ULONG_PTR TlsIndex = 0;
2164 PVOID *ExpansionSlots;
2165 PETHREAD ProcThread;
2166 BOOLEAN HasPrivilege;
2167 PAGED_CODE();
2168
2169 /* Validate the information class */
2170 Status = DefaultSetInfoBufferCheck(ThreadInformationClass,
2171 PsThreadInfoClass,
2172 RTL_NUMBER_OF(PsThreadInfoClass),
2173 ThreadInformation,
2174 ThreadInformationLength,
2175 PreviousMode);
2176 if (!NT_SUCCESS(Status))
2177 {
2178 DPRINT1("NtSetInformationThread(ThreadInformationClass: %lu): Class validation failed! (Status: 0x%lx)\n",
2179 ThreadInformationClass, Status);
2180 return Status;
2181 }
2182
2183 /* Check what kind of information class this is */
2184 switch (ThreadInformationClass)
2185 {
2186 /* Thread priority */
2187 case ThreadPriority:
2188
2189 /* Check buffer length */
2190 if (ThreadInformationLength != sizeof(KPRIORITY))
2191 {
2192 Status = STATUS_INFO_LENGTH_MISMATCH;
2193 break;
2194 }
2195
2196 /* Use SEH for capture */
2197 _SEH2_TRY
2198 {
2199 /* Get the priority */
2200 Priority = *(PLONG)ThreadInformation;
2201 }
2202 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2203 {
2204 /* Get the exception code */
2205 Status = _SEH2_GetExceptionCode();
2206 _SEH2_YIELD(break);
2207 }
2208 _SEH2_END;
2209
2210 /* Validate it */
2211 if ((Priority > HIGH_PRIORITY) ||
2212 (Priority <= LOW_PRIORITY))
2213 {
2214 /* Fail */
2215 Status = STATUS_INVALID_PARAMETER;
2216 break;
2217 }
2218
2219 /* Check for the required privilege */
2220 if (Priority >= LOW_REALTIME_PRIORITY)
2221 {
2222 HasPrivilege = SeCheckPrivilegedObject(SeIncreaseBasePriorityPrivilege,
2223 ThreadHandle,
2224 THREAD_SET_INFORMATION,
2225 PreviousMode);
2226 if (!HasPrivilege)
2227 {
2228 DPRINT1("Privilege to change priority to %lx lacking\n", Priority);
2229 return STATUS_PRIVILEGE_NOT_HELD;
2230 }
2231 }
2232
2233 /* Reference the thread */
2234 Status = ObReferenceObjectByHandle(ThreadHandle,
2235 THREAD_SET_INFORMATION,
2236 PsThreadType,
2237 PreviousMode,
2238 (PVOID*)&Thread,
2239 NULL);
2240 if (!NT_SUCCESS(Status))
2241 break;
2242
2243 /* Set the priority */
2244 KeSetPriorityThread(&Thread->Tcb, Priority);
2245
2246 /* Dereference the thread */
2247 ObDereferenceObject(Thread);
2248 break;
2249
2250 case ThreadBasePriority:
2251
2252 /* Check buffer length */
2253 if (ThreadInformationLength != sizeof(LONG))
2254 {
2255 Status = STATUS_INFO_LENGTH_MISMATCH;
2256 break;
2257 }
2258
2259 /* Use SEH for capture */
2260 _SEH2_TRY
2261 {
2262 /* Get the priority */
2263 Priority = *(PLONG)ThreadInformation;
2264 }
2265 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2266 {
2267 /* Get the exception code */
2268 Status = _SEH2_GetExceptionCode();
2269 _SEH2_YIELD(break);
2270 }
2271 _SEH2_END;
2272
2273 /* Validate it */
2274 if ((Priority > THREAD_BASE_PRIORITY_MAX) ||
2275 (Priority < THREAD_BASE_PRIORITY_MIN))
2276 {
2277 /* These ones are OK */
2278 if ((Priority != THREAD_BASE_PRIORITY_LOWRT + 1) &&
2279 (Priority != THREAD_BASE_PRIORITY_IDLE - 1))
2280 {
2281 /* Check if the process is real time */
2282 if (PsGetCurrentProcess()->PriorityClass !=
2283 PROCESS_PRIORITY_CLASS_REALTIME)
2284 {
2285 /* It isn't, fail */
2286 Status = STATUS_INVALID_PARAMETER;
2287 break;
2288 }
2289 }
2290 }
2291
2292 /* Reference the thread */
2293 Status = ObReferenceObjectByHandle(ThreadHandle,
2294 THREAD_SET_INFORMATION,
2295 PsThreadType,
2296 PreviousMode,
2297 (PVOID*)&Thread,
2298 NULL);
2299 if (!NT_SUCCESS(Status))
2300 break;
2301
2302 /* Set the base priority */
2303 KeSetBasePriorityThread(&Thread->Tcb, Priority);
2304
2305 /* Dereference the thread */
2306 ObDereferenceObject(Thread);
2307 break;
2308
2309 case ThreadAffinityMask:
2310
2311 /* Check buffer length */
2312 if (ThreadInformationLength != sizeof(ULONG_PTR))
2313 {
2314 Status = STATUS_INFO_LENGTH_MISMATCH;
2315 break;
2316 }
2317
2318 /* Use SEH for capture */
2319 _SEH2_TRY
2320 {
2321 /* Get the priority */
2322 Affinity = *(PULONG_PTR)ThreadInformation;
2323 }
2324 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2325 {
2326 /* Get the exception code */
2327 Status = _SEH2_GetExceptionCode();
2328 _SEH2_YIELD(break);
2329 }
2330 _SEH2_END;
2331
2332 /* Validate it */
2333 if (!Affinity)
2334 {
2335 /* Fail */
2336 Status = STATUS_INVALID_PARAMETER;
2337 break;
2338 }
2339
2340 /* Reference the thread */
2341 Status = ObReferenceObjectByHandle(ThreadHandle,
2342 THREAD_SET_INFORMATION,
2343 PsThreadType,
2344 PreviousMode,
2345 (PVOID*)&Thread,
2346 NULL);
2347 if (!NT_SUCCESS(Status))
2348 break;
2349
2350 /* Get the process */
2351 Process = Thread->ThreadsProcess;
2352
2353 /* Try to acquire rundown */
2354 if (ExAcquireRundownProtection(&Process->RundownProtect))
2355 {
2356 /* Lock it */
2357 KeEnterCriticalRegion();
2358 ExAcquirePushLockShared(&Process->ProcessLock);
2359
2360 /* Combine masks */
2361 CombinedAffinity = Affinity & Process->Pcb.Affinity;
2362 if (CombinedAffinity != Affinity)
2363 {
2364 /* Fail */
2365 Status = STATUS_INVALID_PARAMETER;
2366 }
2367 else
2368 {
2369 /* Set the affinity */
2370 KeSetAffinityThread(&Thread->Tcb, CombinedAffinity);
2371 }
2372
2373 /* Release the lock and rundown */
2374 ExReleasePushLockShared(&Process->ProcessLock);
2375 KeLeaveCriticalRegion();
2376 ExReleaseRundownProtection(&Process->RundownProtect);
2377 }
2378 else
2379 {
2380 /* Too late */
2381 Status = STATUS_PROCESS_IS_TERMINATING;
2382 }
2383
2384 /* Dereference the thread */
2385 ObDereferenceObject(Thread);
2386 break;
2387
2388 case ThreadImpersonationToken:
2389
2390 /* Check buffer length */
2391 if (ThreadInformationLength != sizeof(HANDLE))
2392 {
2393 Status = STATUS_INFO_LENGTH_MISMATCH;
2394 break;
2395 }
2396
2397 /* Use SEH for capture */
2398 _SEH2_TRY
2399 {
2400 /* Save the token handle */
2401 TokenHandle = *(PHANDLE)ThreadInformation;
2402 }
2403 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2404 {
2405 /* Get the exception code */
2406 Status = _SEH2_GetExceptionCode();
2407 _SEH2_YIELD(break);
2408 }
2409 _SEH2_END;
2410
2411 /* Reference the thread */
2412 Status = ObReferenceObjectByHandle(ThreadHandle,
2413 THREAD_SET_THREAD_TOKEN,
2414 PsThreadType,
2415 PreviousMode,
2416 (PVOID*)&Thread,
2417 NULL);
2418 if (!NT_SUCCESS(Status))
2419 break;
2420
2421 /* Assign the actual token */
2422 Status = PsAssignImpersonationToken(Thread, TokenHandle);
2423
2424 /* Dereference the thread */
2425 ObDereferenceObject(Thread);
2426 break;
2427
2428 case ThreadQuerySetWin32StartAddress:
2429
2430 /* Check buffer length */
2431 if (ThreadInformationLength != sizeof(ULONG_PTR))
2432 {
2433 Status = STATUS_INFO_LENGTH_MISMATCH;
2434 break;
2435 }
2436
2437 /* Use SEH for capture */
2438 _SEH2_TRY
2439 {
2440 /* Get the priority */
2441 Address = *(PVOID*)ThreadInformation;
2442 }
2443 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2444 {
2445 /* Get the exception code */
2446 Status = _SEH2_GetExceptionCode();
2447 _SEH2_YIELD(break);
2448 }
2449 _SEH2_END;
2450
2451 /* Reference the thread */
2452 Status = ObReferenceObjectByHandle(ThreadHandle,
2453 THREAD_SET_INFORMATION,
2454 PsThreadType,
2455 PreviousMode,
2456 (PVOID*)&Thread,
2457 NULL);
2458 if (!NT_SUCCESS(Status))
2459 break;
2460
2461 /* Set the address */
2462 Thread->Win32StartAddress = Address;
2463
2464 /* Dereference the thread */
2465 ObDereferenceObject(Thread);
2466 break;
2467
2468 case ThreadIdealProcessor:
2469
2470 /* Check buffer length */
2471 if (ThreadInformationLength != sizeof(ULONG_PTR))
2472 {
2473 Status = STATUS_INFO_LENGTH_MISMATCH;
2474 break;
2475 }
2476
2477 /* Use SEH for capture */
2478 _SEH2_TRY
2479 {
2480 /* Get the priority */
2481 IdealProcessor = *(PULONG_PTR)ThreadInformation;
2482 }
2483 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2484 {
2485 /* Get the exception code */
2486 Status = _SEH2_GetExceptionCode();
2487 _SEH2_YIELD(break);
2488 }
2489 _SEH2_END;
2490
2491 /* Validate it */
2492 if (IdealProcessor > MAXIMUM_PROCESSORS)
2493 {
2494 /* Fail */
2495 Status = STATUS_INVALID_PARAMETER;
2496 break;
2497 }
2498
2499 /* Reference the thread */
2500 Status = ObReferenceObjectByHandle(ThreadHandle,
2501 THREAD_SET_INFORMATION,
2502 PsThreadType,
2503 PreviousMode,
2504 (PVOID*)&Thread,
2505 NULL);
2506 if (!NT_SUCCESS(Status))
2507 break;
2508
2509 /* Set the ideal */
2510 Status = KeSetIdealProcessorThread(&Thread->Tcb,
2511 (CCHAR)IdealProcessor);
2512
2513 /* Get the TEB and protect the thread */
2514 Teb = Thread->Tcb.Teb;
2515 if ((Teb) && (ExAcquireRundownProtection(&Thread->RundownProtect)))
2516 {
2517 /* Save the ideal processor */
2518 Teb->IdealProcessor = Thread->Tcb.IdealProcessor;
2519
2520 /* Release rundown protection */
2521 ExReleaseRundownProtection(&Thread->RundownProtect);
2522 }
2523
2524 /* Dereference the thread */
2525 ObDereferenceObject(Thread);
2526 break;
2527
2528 case ThreadPriorityBoost:
2529
2530 /* Check buffer length */
2531 if (ThreadInformationLength != sizeof(ULONG_PTR))
2532 {
2533 Status = STATUS_INFO_LENGTH_MISMATCH;
2534 break;
2535 }
2536
2537 /* Use SEH for capture */
2538 _SEH2_TRY
2539 {
2540 /* Get the priority */
2541 DisableBoost = *(PULONG_PTR)ThreadInformation;
2542 }
2543 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2544 {
2545 /* Get the exception code */
2546 Status = _SEH2_GetExceptionCode();
2547 _SEH2_YIELD(break);
2548 }
2549 _SEH2_END;
2550
2551 /* Reference the thread */
2552 Status = ObReferenceObjectByHandle(ThreadHandle,
2553 THREAD_SET_INFORMATION,
2554 PsThreadType,
2555 PreviousMode,
2556 (PVOID*)&Thread,
2557 NULL);
2558 if (!NT_SUCCESS(Status))
2559 break;
2560
2561 /* Call the kernel */
2562 KeSetDisableBoostThread(&Thread->Tcb, (BOOLEAN)DisableBoost);
2563
2564 /* Dereference the thread */
2565 ObDereferenceObject(Thread);
2566 break;
2567
2568 case ThreadZeroTlsCell:
2569
2570 /* Check buffer length */
2571 if (ThreadInformationLength != sizeof(ULONG))
2572 {
2573 Status = STATUS_INFO_LENGTH_MISMATCH;
2574 break;
2575 }
2576
2577 /* Use SEH for capture */
2578 _SEH2_TRY
2579 {
2580 /* Get the priority */
2581 TlsIndex = *(PULONG)ThreadInformation;
2582 }
2583 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2584 {
2585 /* Get the exception code */
2586 Status = _SEH2_GetExceptionCode();
2587 _SEH2_YIELD(break);
2588 }
2589 _SEH2_END;
2590
2591 /* Reference the thread */
2592 Status = ObReferenceObjectByHandle(ThreadHandle,
2593 THREAD_SET_INFORMATION,
2594 PsThreadType,
2595 PreviousMode,
2596 (PVOID*)&Thread,
2597 NULL);
2598 if (!NT_SUCCESS(Status))
2599 break;
2600
2601 /* This is only valid for the current thread */
2602 if (Thread != PsGetCurrentThread())
2603 {
2604 /* Fail */
2605 Status = STATUS_INVALID_PARAMETER;
2606 ObDereferenceObject(Thread);
2607 break;
2608 }
2609
2610 /* Get the process */
2611 Process = Thread->ThreadsProcess;
2612
2613 /* Loop the threads */
2614 ProcThread = PsGetNextProcessThread(Process, NULL);
2615 while (ProcThread)
2616 {
2617 /* Acquire rundown */
2618 if (ExAcquireRundownProtection(&ProcThread->RundownProtect))
2619 {
2620 /* Get the TEB */
2621 Teb = ProcThread->Tcb.Teb;
2622 if (Teb)
2623 {
2624 /* Check if we're in the expansion range */
2625 if (TlsIndex > TLS_MINIMUM_AVAILABLE - 1)
2626 {
2627 if (TlsIndex < (TLS_MINIMUM_AVAILABLE +
2628 TLS_EXPANSION_SLOTS) - 1)
2629 {
2630 /* Check if we have expansion slots */
2631 ExpansionSlots = Teb->TlsExpansionSlots;
2632 if (ExpansionSlots)
2633 {
2634 /* Clear the index */
2635 ExpansionSlots[TlsIndex - TLS_MINIMUM_AVAILABLE] = 0;
2636 }
2637 }
2638 }
2639 else
2640 {
2641 /* Clear the index */
2642 Teb->TlsSlots[TlsIndex] = NULL;
2643 }
2644 }
2645
2646 /* Release rundown */
2647 ExReleaseRundownProtection(&ProcThread->RundownProtect);
2648 }
2649
2650 /* Go to the next thread */
2651 ProcThread = PsGetNextProcessThread(Process, ProcThread);
2652 }
2653
2654 /* Dereference the thread */
2655 ObDereferenceObject(Thread);
2656 break;
2657
2658 case ThreadBreakOnTermination:
2659
2660 /* Check buffer length */
2661 if (ThreadInformationLength != sizeof(ULONG))
2662 {
2663 Status = STATUS_INFO_LENGTH_MISMATCH;
2664 break;
2665 }
2666
2667 /* Enter SEH for direct buffer read */
2668 _SEH2_TRY
2669 {
2670 Break = *(PULONG)ThreadInformation;
2671 }
2672 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2673 {
2674 /* Get exception code */
2675 Break = 0;
2676 Status = _SEH2_GetExceptionCode();
2677 _SEH2_YIELD(break);
2678 }
2679 _SEH2_END;
2680
2681 /* Setting 'break on termination' requires the SeDebugPrivilege */
2682 if (!SeSinglePrivilegeCheck(SeDebugPrivilege, PreviousMode))
2683 {
2684 /* We don't hold the privilege, bail out */
2685 Status = STATUS_PRIVILEGE_NOT_HELD;
2686 break;
2687 }
2688
2689 /* Reference the thread */
2690 Status = ObReferenceObjectByHandle(ThreadHandle,
2691 THREAD_SET_INFORMATION,
2692 PsThreadType,
2693 PreviousMode,
2694 (PVOID*)&Thread,
2695 NULL);
2696 if (!NT_SUCCESS(Status))
2697 break;
2698
2699 /* Set or clear the flag */
2700 if (Break)
2701 {
2702 PspSetCrossThreadFlag(Thread, CT_BREAK_ON_TERMINATION_BIT);
2703 }
2704 else
2705 {
2706 PspClearCrossThreadFlag(Thread, CT_BREAK_ON_TERMINATION_BIT);
2707 }
2708
2709 /* Dereference the thread */
2710 ObDereferenceObject(Thread);
2711 break;
2712
2713 case ThreadHideFromDebugger:
2714
2715 /* Check buffer length */
2716 if (ThreadInformationLength != 0)
2717 {
2718 Status = STATUS_INFO_LENGTH_MISMATCH;
2719 break;
2720 }
2721
2722 /* Reference the thread */
2723 Status = ObReferenceObjectByHandle(ThreadHandle,
2724 THREAD_SET_INFORMATION,
2725 PsThreadType,
2726 PreviousMode,
2727 (PVOID*)&Thread,
2728 NULL);
2729 if (!NT_SUCCESS(Status))
2730 break;
2731
2732 /* Set the flag */
2733 PspSetCrossThreadFlag(Thread, CT_HIDE_FROM_DEBUGGER_BIT);
2734
2735 /* Dereference the thread */
2736 ObDereferenceObject(Thread);
2737 break;
2738
2739 /* Anything else */
2740 default:
2741 /* Not yet implemented */
2742 DPRINT1("Not implemented: %lu\n", ThreadInformationClass);
2743 Status = STATUS_NOT_IMPLEMENTED;
2744 }
2745
2746 return Status;
2747}
2748
2749/*
2750 * @implemented
2751 */
2752NTSTATUS
2753NTAPI
2754NtQueryInformationThread(IN HANDLE ThreadHandle,
2755 IN THREADINFOCLASS ThreadInformationClass,
2756 OUT PVOID ThreadInformation,
2757 IN ULONG ThreadInformationLength,
2758 OUT PULONG ReturnLength OPTIONAL)
2759{
2760 PETHREAD Thread;
2761 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
2762 NTSTATUS Status;
2763 ULONG Access;
2764 ULONG Length = 0;
2765 PTHREAD_BASIC_INFORMATION ThreadBasicInfo =
2766 (PTHREAD_BASIC_INFORMATION)ThreadInformation;
2767 PKERNEL_USER_TIMES ThreadTime = (PKERNEL_USER_TIMES)ThreadInformation;
2768 KIRQL OldIrql;
2769 ULONG ThreadTerminated;
2770 PAGED_CODE();
2771
2772 /* Validate the information class */
2773 Status = DefaultQueryInfoBufferCheck(ThreadInformationClass,
2774 PsThreadInfoClass,
2775 RTL_NUMBER_OF(PsThreadInfoClass),
2776 ICIF_PROBE_READ,
2777 ThreadInformation,
2778 ThreadInformationLength,
2779 ReturnLength,
2780 NULL,
2781 PreviousMode);
2782 if (!NT_SUCCESS(Status))
2783 {
2784 DPRINT1("NtQueryInformationThread(ThreadInformationClass: %lu): Class validation failed! (Status: 0x%lx)\n",
2785 ThreadInformationClass, Status);
2786 return Status;
2787 }
2788
2789 /* Check what class this is */
2790 Access = THREAD_QUERY_INFORMATION;
2791
2792 /* Check what kind of information class this is */
2793 switch (ThreadInformationClass)
2794 {
2795 /* Basic thread information */
2796 case ThreadBasicInformation:
2797
2798 /* Set the return length */
2799 Length = sizeof(THREAD_BASIC_INFORMATION);
2800
2801 if (ThreadInformationLength != Length)
2802 {
2803 Status = STATUS_INFO_LENGTH_MISMATCH;
2804 break;
2805 }
2806
2807 /* Reference the thread */
2808 Status = ObReferenceObjectByHandle(ThreadHandle,
2809 Access,
2810 PsThreadType,
2811 PreviousMode,
2812 (PVOID*)&Thread,
2813 NULL);
2814 if (!NT_SUCCESS(Status))
2815 break;
2816
2817 /* Protect writes with SEH */
2818 _SEH2_TRY
2819 {
2820 /* Write all the information from the ETHREAD/KTHREAD */
2821 ThreadBasicInfo->ExitStatus = Thread->ExitStatus;
2822 ThreadBasicInfo->TebBaseAddress = (PVOID)Thread->Tcb.Teb;
2823 ThreadBasicInfo->ClientId = Thread->Cid;
2824 ThreadBasicInfo->AffinityMask = Thread->Tcb.Affinity;
2825 ThreadBasicInfo->Priority = Thread->Tcb.Priority;
2826 ThreadBasicInfo->BasePriority = KeQueryBasePriorityThread(&Thread->Tcb);
2827 }
2828 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2829 {
2830 /* Get exception code */
2831 Status = _SEH2_GetExceptionCode();
2832 }
2833 _SEH2_END;
2834
2835 /* Dereference the thread */
2836 ObDereferenceObject(Thread);
2837 break;
2838
2839 /* Thread time information */
2840 case ThreadTimes:
2841
2842 /* Set the return length */
2843 Length = sizeof(KERNEL_USER_TIMES);
2844
2845 if (ThreadInformationLength != Length)
2846 {
2847 Status = STATUS_INFO_LENGTH_MISMATCH;
2848 break;
2849 }
2850
2851 /* Reference the thread */
2852 Status = ObReferenceObjectByHandle(ThreadHandle,
2853 Access,
2854 PsThreadType,
2855 PreviousMode,
2856 (PVOID*)&Thread,
2857 NULL);
2858 if (!NT_SUCCESS(Status))
2859 break;
2860
2861 /* Protect writes with SEH */
2862 _SEH2_TRY
2863 {
2864 /* Copy time information from ETHREAD/KTHREAD */
2865 ThreadTime->KernelTime.QuadPart = Thread->Tcb.KernelTime * KeMaximumIncrement;
2866 ThreadTime->UserTime.QuadPart = Thread->Tcb.UserTime * KeMaximumIncrement;
2867 ThreadTime->CreateTime = Thread->CreateTime;
2868
2869 /* Exit time is in a union and only valid on actual exit! */
2870 if (KeReadStateThread(&Thread->Tcb))
2871 {
2872 ThreadTime->ExitTime = Thread->ExitTime;
2873 }
2874 else
2875 {
2876 ThreadTime->ExitTime.QuadPart = 0;
2877 }
2878 }
2879 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2880 {
2881 /* Get exception code */
2882 Status = _SEH2_GetExceptionCode();
2883 }
2884 _SEH2_END;
2885
2886 /* Dereference the thread */
2887 ObDereferenceObject(Thread);
2888 break;
2889
2890 case ThreadQuerySetWin32StartAddress:
2891
2892 /* Set the return length*/
2893 Length = sizeof(PVOID);
2894
2895 if (ThreadInformationLength != Length)
2896 {
2897 Status = STATUS_INFO_LENGTH_MISMATCH;
2898 break;
2899 }
2900
2901 /* Reference the thread */
2902 Status = ObReferenceObjectByHandle(ThreadHandle,
2903 Access,
2904 PsThreadType,
2905 PreviousMode,
2906 (PVOID*)&Thread,
2907 NULL);
2908 if (!NT_SUCCESS(Status))
2909 break;
2910
2911 /* Protect write with SEH */
2912 _SEH2_TRY
2913 {
2914 /* Return the Win32 Start Address */
2915 *(PVOID*)ThreadInformation = Thread->Win32StartAddress;
2916 }
2917 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2918 {
2919 /* Get exception code */
2920 Status = _SEH2_GetExceptionCode();
2921 }
2922 _SEH2_END;
2923
2924 /* Dereference the thread */
2925 ObDereferenceObject(Thread);
2926 break;
2927
2928 case ThreadPerformanceCount:
2929
2930 /* Set the return length*/
2931 Length = sizeof(LARGE_INTEGER);
2932
2933 if (ThreadInformationLength != Length)
2934 {
2935 Status = STATUS_INFO_LENGTH_MISMATCH;
2936 break;
2937 }
2938
2939 /* Reference the thread */
2940 Status = ObReferenceObjectByHandle(ThreadHandle,
2941 Access,
2942 PsThreadType,
2943 PreviousMode,
2944 (PVOID*)&Thread,
2945 NULL);
2946 if (!NT_SUCCESS(Status))
2947 break;
2948
2949 /* Protect write with SEH */
2950 _SEH2_TRY
2951 {
2952 /* FIXME */
2953 (*(PLARGE_INTEGER)ThreadInformation).QuadPart = 0;
2954 }
2955 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2956 {
2957 /* Get exception code */
2958 Status = _SEH2_GetExceptionCode();
2959 }
2960 _SEH2_END;
2961
2962 /* Dereference the thread */
2963 ObDereferenceObject(Thread);
2964 break;
2965
2966 case ThreadAmILastThread:
2967
2968 /* Set the return length*/
2969 Length = sizeof(ULONG);
2970
2971 if (ThreadInformationLength != Length)
2972 {
2973 Status = STATUS_INFO_LENGTH_MISMATCH;
2974 break;
2975 }
2976
2977 /* Reference the thread */
2978 Status = ObReferenceObjectByHandle(ThreadHandle,
2979 Access,
2980 PsThreadType,
2981 PreviousMode,
2982 (PVOID*)&Thread,
2983 NULL);
2984 if (!NT_SUCCESS(Status))
2985 break;
2986
2987 /* Protect write with SEH */
2988 _SEH2_TRY
2989 {
2990 /* Return whether or not we are the last thread */
2991 *(PULONG)ThreadInformation = ((Thread->ThreadsProcess->
2992 ThreadListHead.Flink->Flink ==
2993 &Thread->ThreadsProcess->
2994 ThreadListHead) ?
2995 TRUE : FALSE);
2996 }
2997 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2998 {
2999 /* Get exception code */
3000 Status = _SEH2_GetExceptionCode();
3001 }
3002 _SEH2_END;
3003
3004 /* Dereference the thread */
3005 ObDereferenceObject(Thread);
3006 break;
3007
3008 case ThreadIsIoPending:
3009
3010 /* Set the return length*/
3011 Length = sizeof(ULONG);
3012
3013 if (ThreadInformationLength != Length)
3014 {
3015 Status = STATUS_INFO_LENGTH_MISMATCH;
3016 break;
3017 }
3018
3019 /* Reference the thread */
3020 Status = ObReferenceObjectByHandle(ThreadHandle,
3021 Access,
3022 PsThreadType,
3023 PreviousMode,
3024 (PVOID*)&Thread,
3025 NULL);
3026 if (!NT_SUCCESS(Status))
3027 break;
3028
3029 /* Raise the IRQL to protect the IRP list */
3030 KeRaiseIrql(APC_LEVEL, &OldIrql);
3031
3032 /* Protect write with SEH */
3033 _SEH2_TRY
3034 {
3035 /* Check if the IRP list is empty or not */
3036 *(PULONG)ThreadInformation = !IsListEmpty(&Thread->IrpList);
3037 }
3038 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3039 {
3040 /* Get exception code */
3041 Status = _SEH2_GetExceptionCode();
3042 }
3043 _SEH2_END;
3044
3045 /* Lower IRQL back */
3046 KeLowerIrql(OldIrql);
3047
3048 /* Dereference the thread */
3049 ObDereferenceObject(Thread);
3050 break;
3051
3052 /* LDT and GDT information */
3053 case ThreadDescriptorTableEntry:
3054
3055#if defined(_X86_)
3056 /* Reference the thread */
3057 Status = ObReferenceObjectByHandle(ThreadHandle,
3058 Access,
3059 PsThreadType,
3060 PreviousMode,
3061 (PVOID*)&Thread,
3062 NULL);
3063 if (!NT_SUCCESS(Status))
3064 break;
3065
3066 /* Call the worker routine */
3067 Status = PspQueryDescriptorThread(Thread,
3068 ThreadInformation,
3069 ThreadInformationLength,
3070 ReturnLength);
3071
3072 /* Dereference the thread */
3073 ObDereferenceObject(Thread);
3074#else
3075 /* Only implemented on x86 */
3076 Status = STATUS_NOT_IMPLEMENTED;
3077#endif
3078 break;
3079
3080 case ThreadPriorityBoost:
3081
3082 /* Set the return length*/
3083 Length = sizeof(ULONG);
3084
3085 if (ThreadInformationLength != Length)
3086 {
3087 Status = STATUS_INFO_LENGTH_MISMATCH;
3088 break;
3089 }
3090
3091 /* Reference the thread */
3092 Status = ObReferenceObjectByHandle(ThreadHandle,
3093 Access,
3094 PsThreadType,
3095 PreviousMode,
3096 (PVOID*)&Thread,
3097 NULL);
3098 if (!NT_SUCCESS(Status))
3099 break;
3100
3101 _SEH2_TRY
3102 {
3103 *(PULONG)ThreadInformation = Thread->Tcb.DisableBoost ? 1 : 0;
3104 }
3105 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3106 {
3107 Status = _SEH2_GetExceptionCode();
3108 }
3109 _SEH2_END;
3110
3111 /* Dereference the thread */
3112 ObDereferenceObject(Thread);
3113 break;
3114
3115 case ThreadBreakOnTermination:
3116
3117 /* Set the return length */
3118 Length = sizeof(ULONG);
3119
3120 if (ThreadInformationLength != Length)
3121 {
3122 Status = STATUS_INFO_LENGTH_MISMATCH;
3123 break;
3124 }
3125
3126 /* Reference the thread */
3127 Status = ObReferenceObjectByHandle(ThreadHandle,
3128 Access,
3129 PsThreadType,
3130 PreviousMode,
3131 (PVOID*)&Thread,
3132 NULL);
3133 if (!NT_SUCCESS(Status))
3134 break;
3135
3136 _SEH2_TRY
3137 {
3138 *(PULONG)ThreadInformation = Thread->BreakOnTermination;
3139 }
3140 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3141 {
3142 Status = _SEH2_GetExceptionCode();
3143 }
3144 _SEH2_END;
3145
3146 /* Dereference the thread */
3147 ObDereferenceObject(Thread);
3148 break;
3149
3150 case ThreadIsTerminated:
3151
3152 /* Set the return length*/
3153 Length = sizeof(ThreadTerminated);
3154
3155 if (ThreadInformationLength != Length)
3156 {
3157 Status = STATUS_INFO_LENGTH_MISMATCH;
3158 break;
3159 }
3160
3161 /* Reference the thread */
3162 Status = ObReferenceObjectByHandle(ThreadHandle,
3163 Access,
3164 PsThreadType,
3165 PreviousMode,
3166 (PVOID*)&Thread,
3167 NULL);
3168 if (!NT_SUCCESS(Status))
3169 break;
3170
3171 ThreadTerminated = PsIsThreadTerminating(Thread);
3172
3173 _SEH2_TRY
3174 {
3175 *(PULONG)ThreadInformation = ThreadTerminated ? 1 : 0;
3176 }
3177 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3178 {
3179 Status = _SEH2_GetExceptionCode();
3180 }
3181 _SEH2_END;
3182
3183 /* Dereference the thread */
3184 ObDereferenceObject(Thread);
3185 break;
3186
3187 /* Anything else */
3188 default:
3189 /* Not yet implemented */
3190 DPRINT1("Not implemented: %lu\n", ThreadInformationClass);
3191 Status = STATUS_NOT_IMPLEMENTED;
3192 }
3193
3194 /* Protect write with SEH */
3195 _SEH2_TRY
3196 {
3197 /* Check if caller wanted return length */
3198 if (ReturnLength) *ReturnLength = Length;
3199 }
3200 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
3201 {
3202 /* Get exception code */
3203 Status = _SEH2_GetExceptionCode();
3204 }
3205 _SEH2_END;
3206
3207 return Status;
3208}
3209
3210/* EOF */
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_EvalMethod.c:87
STATUS_PRIVILEGE_NOT_HELD
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
ObjectNameInformation
@ ObjectNameInformation
Definition: DriverTester.h:55
ReturnLength
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG ReturnLength
Definition: KdSystemDebugControl.c:34
PreviousMode
_In_ PVOID _In_ ULONG _Out_ PVOID _In_ ULONG _Inout_ PULONG _In_ KPROCESSOR_MODE PreviousMode
Definition: KdSystemDebugControl.c:35
DirectoryHandle
static HANDLE DirectoryHandle
Definition: ObType.c:48
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
RTL_NUMBER_OF
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
DPRINT1
#define DPRINT1
Definition: precomp.h:8
Query
BOOL Query(LPCTSTR *ServiceArgs, DWORD ArgCount, BOOL bExtended)
Definition: query.c:292
PKAFFINITY
KAFFINITY * PKAFFINITY
Definition: basetsd.h:189
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
ProcessDebugPort
@ ProcessDebugPort
Definition: cicbase.cpp:64
ProcessBreakOnTermination
@ ProcessBreakOnTermination
Definition: cicbase.cpp:67
ProcessBasicInformation
@ ProcessBasicInformation
Definition: cicbase.cpp:63
ProcessWow64Information
@ ProcessWow64Information
Definition: cicbase.cpp:65
ProcessImageFileName
@ ProcessImageFileName
Definition: cicbase.cpp:66
PROCESSINFOCLASS
enum _PROCESSINFOCLASS PROCESSINFOCLASS
Definition: loader.c:63
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
DbgkOpenProcessDebugPort
NTSTATUS NTAPI DbgkOpenProcessDebugPort(IN PEPROCESS Process, IN KPROCESSOR_MODE PreviousMode, OUT HANDLE *DebugHandle)
Definition: dbgkobj.c:1526
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
THREAD_BASIC_INFORMATION
struct _THREAD_BASIC_INFORMATION THREAD_BASIC_INFORMATION
KAFFINITY
ULONG_PTR KAFFINITY
Definition: compat.h:85
ThreadDescriptorTableEntry
@ ThreadDescriptorTableEntry
Definition: compat.h:941
ThreadAmILastThread
@ ThreadAmILastThread
Definition: compat.h:947
ThreadTimes
@ ThreadTimes
Definition: compat.h:936
ThreadPriority
@ ThreadPriority
Definition: compat.h:937
ThreadIdealProcessor
@ ThreadIdealProcessor
Definition: compat.h:948
ThreadQuerySetWin32StartAddress
@ ThreadQuerySetWin32StartAddress
Definition: compat.h:944
ThreadIsTerminated
@ ThreadIsTerminated
Definition: compat.h:955
ThreadBreakOnTermination
@ ThreadBreakOnTermination
Definition: compat.h:953
ThreadImpersonationToken
@ ThreadImpersonationToken
Definition: compat.h:940
ThreadAffinityMask
@ ThreadAffinityMask
Definition: compat.h:939
ThreadBasePriority
@ ThreadBasePriority
Definition: compat.h:938
ThreadBasicInformation
@ ThreadBasicInformation
Definition: compat.h:935
ThreadPriorityBoost
@ ThreadPriorityBoost
Definition: compat.h:949
ThreadPerformanceCount
@ ThreadPerformanceCount
Definition: compat.h:946
ThreadIsIoPending
@ ThreadIsIoPending
Definition: compat.h:951
ThreadZeroTlsCell
@ ThreadZeroTlsCell
Definition: compat.h:945
ThreadHideFromDebugger
@ ThreadHideFromDebugger
Definition: compat.h:952
THREADINFOCLASS
enum _THREADINFOCLASS THREADINFOCLASS
Definition: thread.c:101
PTHREAD_BASIC_INFORMATION
struct _THREAD_BASIC_INFORMATION * PTHREAD_BASIC_INFORMATION
KPRIORITY
LONG KPRIORITY
Definition: compat.h:803
UlongToPtr
#define UlongToPtr(u)
Definition: config.h:106
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
PUNICODE_STRING
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
IsListEmpty
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
PsGetCurrentThread
#define PsGetCurrentThread()
Definition: env_spec_w32.h:81
KeRaiseIrql
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
APC_LEVEL
#define APC_LEVEL
Definition: env_spec_w32.h:695
KeLowerIrql
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
PAGE_SHIFT
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
KeQuerySystemTime
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
UNICODE_STRING
struct _UNICODE_STRING UNICODE_STRING
ExReleaseRundownProtection
#define ExReleaseRundownProtection
Definition: ex.h:139
ExGetPreviousMode
#define ExGetPreviousMode
Definition: ex.h:143
ExAcquirePushLockShared
FORCEINLINE VOID ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1108
ExReleasePushLockShared
FORCEINLINE VOID ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1216
ExAcquireRundownProtection
#define ExAcquireRundownProtection
Definition: ex.h:138
MAXIMUM_PROCESSORS
#define MAXIMUM_PROCESSORS
Definition: rwlock.h:5
Thread
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
Process
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
Status
Status
Definition: gdiplustypes.h:25
ICIF_PROBE_READ
#define ICIF_PROBE_READ
Definition: icif.h:25
PROCESS_SUSPEND_RESUME
#define PROCESS_SUSPEND_RESUME
Definition: pstypes.h:168
PROCESS_PRIORITY_CLASS
struct _PROCESS_PRIORITY_CLASS PROCESS_PRIORITY_CLASS
PROCESS_QUERY_INFORMATION
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:167
THREAD_SET_THREAD_TOKEN
#define THREAD_SET_THREAD_TOKEN
Definition: pstypes.h:151
THREAD_BASE_PRIORITY_LOWRT
#define THREAD_BASE_PRIORITY_LOWRT
Definition: pstypes.h:183
PPROCESS_PRIORITY_CLASS
struct _PROCESS_PRIORITY_CLASS * PPROCESS_PRIORITY_CLASS
THREAD_QUERY_INFORMATION
#define THREAD_QUERY_INFORMATION
Definition: pstypes.h:150
PROCESS_PRIORITY_CLASS_ABOVE_NORMAL
#define PROCESS_PRIORITY_CLASS_ABOVE_NORMAL
Definition: pstypes.h:113
PSF_NO_DEBUG_INHERIT_BIT
#define PSF_NO_DEBUG_INHERIT_BIT
Definition: pstypes.h:275
CT_HIDE_FROM_DEBUGGER_BIT
#define CT_HIDE_FROM_DEBUGGER_BIT
Definition: pstypes.h:241
THREAD_BASE_PRIORITY_MIN
#define THREAD_BASE_PRIORITY_MIN
Definition: pstypes.h:185
PROCESS_SET_SESSIONID
#define PROCESS_SET_SESSIONID
Definition: pstypes.h:160
THREAD_BASE_PRIORITY_MAX
#define THREAD_BASE_PRIORITY_MAX
Definition: pstypes.h:184
PsProcessPriorityForeground
@ PsProcessPriorityForeground
Definition: pstypes.h:422
PsProcessPriorityBackground
@ PsProcessPriorityBackground
Definition: pstypes.h:423
THREAD_BASE_PRIORITY_IDLE
#define THREAD_BASE_PRIORITY_IDLE
Definition: pstypes.h:186
PROCESS_SET_INFORMATION
#define PROCESS_SET_INFORMATION
Definition: pstypes.h:166
PSF_VDM_ALLOWED_BIT
#define PSF_VDM_ALLOWED_BIT
Definition: pstypes.h:297
TLS_EXPANSION_SLOTS
#define TLS_EXPANSION_SLOTS
Definition: pstypes.h:311
PROCESS_PRIORITY_CLASS_REALTIME
#define PROCESS_PRIORITY_CLASS_REALTIME
Definition: pstypes.h:111
CT_BREAK_ON_TERMINATION_BIT
#define CT_BREAK_ON_TERMINATION_BIT
Definition: pstypes.h:245
PsNonPagedPool
@ PsNonPagedPool
Definition: pstypes.h:1067
PsPageFile
@ PsPageFile
Definition: pstypes.h:1069
PsPagedPool
@ PsPagedPool
Definition: pstypes.h:1068
PPROCESS_FOREGROUND_BACKGROUND
struct _PROCESS_FOREGROUND_BACKGROUND * PPROCESS_FOREGROUND_BACKGROUND
MEMORY_PRIORITY_BACKGROUND
#define MEMORY_PRIORITY_BACKGROUND
Definition: pstypes.h:125
PSF_BREAK_ON_TERMINATION_BIT
#define PSF_BREAK_ON_TERMINATION_BIT
Definition: pstypes.h:286
MEMORY_PRIORITY_FOREGROUND
#define MEMORY_PRIORITY_FOREGROUND
Definition: pstypes.h:127
PPROCESS_BASIC_INFORMATION
struct _PROCESS_BASIC_INFORMATION * PPROCESS_BASIC_INFORMATION
PROCESS_BASIC_INFORMATION
struct _PROCESS_BASIC_INFORMATION PROCESS_BASIC_INFORMATION
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
KERNEL_USER_TIMES
struct _KERNEL_USER_TIMES KERNEL_USER_TIMES
PKERNEL_USER_TIMES
struct _KERNEL_USER_TIMES * PKERNEL_USER_TIMES
ProcessLUIDDeviceMapsEnabled
@ ProcessLUIDDeviceMapsEnabled
Definition: winternl.h:1910
ProcessWx86Information
@ ProcessWx86Information
Definition: winternl.h:1901
ProcessDebugFlags
@ ProcessDebugFlags
Definition: winternl.h:1913
ProcessSessionInformation
@ ProcessSessionInformation
Definition: winternl.h:1906
ProcessAffinityMask
@ ProcessAffinityMask
Definition: winternl.h:1903
ProcessIoPortHandlers
@ ProcessIoPortHandlers
Definition: winternl.h:1895
ProcessRaisePriority
@ ProcessRaisePriority
Definition: winternl.h:1888
ProcessVmCounters
@ ProcessVmCounters
Definition: winternl.h:1885
ProcessPriorityClass
@ ProcessPriorityClass
Definition: winternl.h:1900
ProcessPriorityBoost
@ ProcessPriorityBoost
Definition: winternl.h:1904
ProcessImageInformation
@ ProcessImageInformation
Definition: winternl.h:1919
ProcessExecuteFlags
@ ProcessExecuteFlags
Definition: winternl.h:1916
ProcessCookie
@ ProcessCookie
Definition: winternl.h:1918
ProcessPooledUsageAndLimits
@ ProcessPooledUsageAndLimits
Definition: winternl.h:1896
ProcessLdtSize
@ ProcessLdtSize
Definition: winternl.h:1893
ProcessIoCounters
@ ProcessIoCounters
Definition: winternl.h:1884
ProcessImageFileNameWin32
@ ProcessImageFileNameWin32
Definition: winternl.h:1925
ProcessDefaultHardErrorMode
@ ProcessDefaultHardErrorMode
Definition: winternl.h:1894
ProcessEnableAlignmentFaultFixup
@ ProcessEnableAlignmentFaultFixup
Definition: winternl.h:1899
ProcessDeviceMap
@ ProcessDeviceMap
Definition: winternl.h:1905
ProcessBasePriority
@ ProcessBasePriority
Definition: winternl.h:1887
ProcessQuotaLimits
@ ProcessQuotaLimits
Definition: winternl.h:1883
ProcessAccessToken
@ ProcessAccessToken
Definition: winternl.h:1891
ProcessHandleTracing
@ ProcessHandleTracing
Definition: winternl.h:1914
ProcessForegroundInformation
@ ProcessForegroundInformation
Definition: winternl.h:1907
ProcessTimes
@ ProcessTimes
Definition: winternl.h:1886
ProcessDebugObjectHandle
@ ProcessDebugObjectHandle
Definition: winternl.h:1912
ProcessExceptionPort
@ ProcessExceptionPort
Definition: winternl.h:1890
ProcessWorkingSetWatch
@ ProcessWorkingSetWatch
Definition: winternl.h:1897
ProcessLdtInformation
@ ProcessLdtInformation
Definition: winternl.h:1892
ProcessHandleCount
@ ProcessHandleCount
Definition: winternl.h:1902
ProcessUserModeIOPL
@ ProcessUserModeIOPL
Definition: winternl.h:1898
PVM_COUNTERS
struct _VM_COUNTERS * PVM_COUNTERS
VM_COUNTERS_EX
struct _VM_COUNTERS_EX VM_COUNTERS_EX
QUOTA_LIMITS_HARDWS_MIN_DISABLE
#define QUOTA_LIMITS_HARDWS_MIN_DISABLE
PROCESS_LUID_DOSDEVICES_ONLY
#define PROCESS_LUID_DOSDEVICES_ONLY
Definition: pstypes.h:228
IO_COUNTERS
struct _IO_COUNTERS IO_COUNTERS
PROCESS_SESSION_INFORMATION
struct _PROCESS_SESSION_INFORMATION PROCESS_SESSION_INFORMATION
PPROCESS_SESSION_INFORMATION
struct _PROCESS_SESSION_INFORMATION * PPROCESS_SESSION_INFORMATION
LOW_PRIORITY
#define LOW_PRIORITY
QUOTA_LIMITS_HARDWS_MAX_DISABLE
#define QUOTA_LIMITS_HARDWS_MAX_DISABLE
QUOTA_LIMITS_EX
struct _QUOTA_LIMITS_EX QUOTA_LIMITS_EX
QUOTA_LIMITS_HARDWS_MAX_ENABLE
#define QUOTA_LIMITS_HARDWS_MAX_ENABLE
QUOTA_LIMITS_HARDWS_MIN_ENABLE
#define QUOTA_LIMITS_HARDWS_MIN_ENABLE
LOW_REALTIME_PRIORITY
#define LOW_REALTIME_PRIORITY
HIGH_PRIORITY
#define HIGH_PRIORITY
PIO_COUNTERS
struct _IO_COUNTERS * PIO_COUNTERS
InterlockedCompareExchangePointer
#define InterlockedCompareExchangePointer
Definition: interlocked.h:144
InterlockedCompareExchange
#define InterlockedCompareExchange
Definition: interlocked.h:119
ThreadListHead
static LIST_ENTRY ThreadListHead
Definition: sys_arch.c:6
RTL_FIELD_SIZE
#define RTL_FIELD_SIZE(type, field)
Definition: kdb_expr.c:86
KeLeaveCriticalRegion
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
KeEnterCriticalRegion
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
if
if(dx< 0)
Definition: linetemp.h:194
LpcPortObjectType
POBJECT_TYPE LpcPortObjectType
Definition: port.c:17
ASSERT
#define ASSERT(a)
Definition: mode.c:44
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
ImageName
static const char * ImageName
Definition: image.c:34
KeGetCurrentPrcb
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1187
KernelMode
#define KernelMode
Definition: asm.h:38
ProcessHandle
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
SECTION_IMAGE_INFORMATION
struct _SECTION_IMAGE_INFORMATION SECTION_IMAGE_INFORMATION
TokenHandle
_In_ ACCESS_MASK _In_ ULONG _Out_ PHANDLE TokenHandle
Definition: psfuncs.h:726
ThreadInformationLength
_In_ THREADINFOCLASS _In_ ULONG ThreadInformationLength
Definition: psfuncs.h:843
ThreadInformationClass
_In_ THREADINFOCLASS ThreadInformationClass
Definition: psfuncs.h:840
SEM_NOALIGNMENTFAULTEXCEPT
#define SEM_NOALIGNMENTFAULTEXCEPT
Definition: rtltypes.h:71
_Out_opt_
#define _Out_opt_
Definition: no_sal2.h:214
_Out_
#define _Out_
Definition: no_sal2.h:160
_In_
#define _In_
Definition: no_sal2.h:158
ACCESS_MASK
ULONG ACCESS_MASK
Definition: nt_native.h:40
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1660
OBJECT_NAME_INFORMATION
struct _OBJECT_NAME_INFORMATION OBJECT_NAME_INFORMATION
THREAD_SET_INFORMATION
#define THREAD_SET_INFORMATION
Definition: nt_native.h:1340
PPROCESS_ACCESS_TOKEN
struct _PROCESS_ACCESS_TOKEN * PPROCESS_ACCESS_TOKEN
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
KeQueryBasePriorityThread
LONG NTAPI KeQueryBasePriorityThread(IN PKTHREAD Thread)
Definition: thrdobj.c:52
KeQueryRuntimeProcess
ULONG NTAPI KeQueryRuntimeProcess(IN PKPROCESS Process, OUT PULONG UserTime)
Definition: procobj.c:860
KeSetAffinityProcess
KAFFINITY NTAPI KeSetAffinityProcess(IN PKPROCESS Process, IN KAFFINITY Affinity)
Definition: procobj.c:265
KeActiveProcessors
KAFFINITY KeActiveProcessors
Definition: processor.c:16
Ke386SetIOPL
VOID NTAPI Ke386SetIOPL(VOID)
Definition: v86vdm.c:595
KeQueryValuesProcess
VOID NTAPI KeQueryValuesProcess(IN PKPROCESS Process, PPROCESS_VALUES Values)
Definition: procobj.c:525
KeSetDisableBoostProcess
BOOLEAN NTAPI KeSetDisableBoostProcess(IN PKPROCESS Process, IN BOOLEAN Disable)
Definition: procobj.c:331
KeSetDisableBoostThread
BOOLEAN NTAPI KeSetDisableBoostThread(IN OUT PKTHREAD Thread, IN BOOLEAN Disable)
Definition: thrdobj.c:86
KeReadStateThread
BOOLEAN NTAPI KeReadStateThread(IN PKTHREAD Thread)
Definition: thrdobj.c:42
KeSetAutoAlignmentProcess
BOOLEAN NTAPI KeSetAutoAlignmentProcess(IN PKPROCESS Process, IN BOOLEAN Enable)
Definition: procobj.c:313
KeBoostPriorityThread
VOID NTAPI KeBoostPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Increment)
Definition: thrdobj.c:220
KeSetPriorityAndQuantumProcess
KPRIORITY NTAPI KeSetPriorityAndQuantumProcess(IN PKPROCESS Process, IN KPRIORITY Priority, IN UCHAR Quantum OPTIONAL)
Definition: procobj.c:349
MmGetFileObjectForSection
PFILE_OBJECT NTAPI MmGetFileObjectForSection(IN PVOID Section)
Definition: section.c:1540
MmGetImageInformation
VOID NTAPI MmGetImageInformation(OUT PSECTION_IMAGE_INFORMATION ImageInformation)
Definition: section.c:1617
MmSetExecuteOptions
NTSTATUS NTAPI MmSetExecuteOptions(IN ULONG ExecuteOptions)
Definition: pagfault.c:2695
MmSetMemoryPriorityProcess
NTSTATUS NTAPI MmSetMemoryPriorityProcess(IN PEPROCESS Process, IN UCHAR MemoryPriority)
Definition: procsup.c:487
MmGetExecuteOptions
NTSTATUS NTAPI MmGetExecuteOptions(IN PULONG ExecuteOptions)
Definition: pagfault.c:2653
DefaultQueryInfoBufferCheck
static __inline NTSTATUS DefaultQueryInfoBufferCheck(_In_ ULONG Class, _In_ const INFORMATION_CLASS_INFO *ClassList, _In_ ULONG ClassListEntries, _In_ ULONG Flags, _In_opt_ PVOID Buffer, _In_ ULONG BufferLength, _In_opt_ PULONG ReturnLength, _In_opt_ PULONG_PTR ReturnLengthPtr, _In_ KPROCESSOR_MODE PreviousMode)
Probe helper that validates the provided parameters whenever a NtQuery*** system call is invoked from...
Definition: probe.h:219
DefaultSetInfoBufferCheck
static __inline NTSTATUS DefaultSetInfoBufferCheck(_In_ ULONG Class, _In_ const INFORMATION_CLASS_INFO *ClassList, _In_ ULONG ClassListEntries, _In_ PVOID Buffer, _In_ ULONG BufferLength, _In_ KPROCESSOR_MODE PreviousMode)
Probe helper that validates the provided parameters whenever a NtSet*** system call is invoked from u...
Definition: probe.h:70
SeDebugPrivilege
const LUID SeDebugPrivilege
Definition: priv.c:39
SeCheckPrivilegedObject
BOOLEAN NTAPI SeCheckPrivilegedObject(_In_ LUID PrivilegeValue, _In_ HANDLE ObjectHandle, _In_ ACCESS_MASK DesiredAccess, _In_ KPROCESSOR_MODE PreviousMode)
Checks a privileged object if such object has the specific privilege submitted by the caller.
Definition: priv.c:803
SeTcbPrivilege
const LUID SeTcbPrivilege
Definition: priv.c:26
SeIncreaseBasePriorityPrivilege
const LUID SeIncreaseBasePriorityPrivilege
Definition: priv.c:33
IoQueryFileDosDeviceName
NTSTATUS NTAPI IoQueryFileDosDeviceName(IN PFILE_OBJECT FileObject, OUT POBJECT_NAME_INFORMATION *ObjectNameInformation)
Definition: file.c:3664
KeMaximumIncrement
ULONG KeMaximumIncrement
Definition: clock.c:20
PsProcessType
POBJECT_TYPE PsProcessType
Definition: process.c:20
PsGetProcessSessionId
ULONG NTAPI PsGetProcessSessionId(IN PEPROCESS Process)
Definition: process.c:1163
PsSetProcessPriorityByClass
VOID NTAPI PsSetProcessPriorityByClass(IN PEPROCESS Process, IN PSPROCESSPRIORITYMODE Type)
Definition: process.c:1325
NtQueryInformationThread
NTSTATUS NTAPI NtQueryInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, OUT PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: query.c:2754
PspTraceLevel
ULONG PspTraceLevel
Definition: query.c:18
PsReferenceProcessFilePointer
NTSTATUS NTAPI PsReferenceProcessFilePointer(IN PEPROCESS Process, OUT PFILE_OBJECT *FileObject)
Definition: query.c:24
NtSetInformationProcess
NTSTATUS NTAPI NtSetInformationProcess(IN HANDLE ProcessHandle, IN PROCESSINFOCLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength)
Definition: query.c:1232
NtSetInformationThread
NTSTATUS NTAPI NtSetInformationThread(IN HANDLE ThreadHandle, IN THREADINFOCLASS ThreadInformationClass, IN PVOID ThreadInformation, IN ULONG ThreadInformationLength)
Definition: query.c:2146
NtQueryInformationProcess
NTSTATUS NTAPI NtQueryInformationProcess(_In_ HANDLE ProcessHandle, _In_ PROCESSINFOCLASS ProcessInformationClass, _Out_ PVOID ProcessInformation, _In_ ULONG ProcessInformationLength, _Out_opt_ PULONG ReturnLength)
Definition: query.c:59
PsAssignImpersonationToken
NTSTATUS NTAPI PsAssignImpersonationToken(IN PETHREAD Thread, IN HANDLE TokenHandle)
Definition: security.c:502
PsThreadType
POBJECT_TYPE PsThreadType
Definition: thread.c:20
PsIsThreadTerminating
BOOLEAN NTAPI PsIsThreadTerminating(IN PETHREAD Thread)
Definition: thread.c:868
SeLocateProcessImageName
NTSTATUS NTAPI SeLocateProcessImageName(_In_ PEPROCESS Process, _Out_ PUNICODE_STRING *ProcessImageName)
Finds the process image name of a specific process.
Definition: audit.c:199
SeSinglePrivilegeCheck
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
PHANDLE
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
STATUS_PROCESS_IS_TERMINATING
#define STATUS_PROCESS_IS_TERMINATING
Definition: ntstatus.h:596
STATUS_INVALID_INFO_CLASS
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:333
STATUS_PORT_ALREADY_SET
#define STATUS_PORT_ALREADY_SET
Definition: ntstatus.h:402
ObGetProcessHandleCount
ULONG NTAPI ObGetProcessHandleCount(IN PEPROCESS Process)
Definition: obhandle.c:56
ObSetDeviceMap
NTSTATUS NTAPI ObSetDeviceMap(IN PEPROCESS Process, IN HANDLE DirectoryHandle)
Definition: devicemap.c:24
ObIsLUIDDeviceMapsEnabled
ULONG NTAPI ObIsLUIDDeviceMapsEnabled(VOID)
Definition: devicemap.c:662
ObQueryDeviceMapInformation
NTSTATUS NTAPI ObQueryDeviceMapInformation(_In_opt_ PEPROCESS Process, _Out_ PPROCESS_DEVICEMAP_INFORMATION DeviceMapInfo, _In_ ULONG Flags)
Definition: devicemap.c:539
ObCloseHandle
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
ObReferenceObjectByHandle
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
LONG
long LONG
Definition: pedump.c:60
Address
static WCHAR Address[46]
Definition: ping.c:68
KeDetachProcess
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:621
KeAttachProcess
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:582
PspSetPrimaryToken
NTSTATUS NTAPI PspSetPrimaryToken(IN PEPROCESS Process, IN HANDLE TokenHandle OPTIONAL, IN PACCESS_TOKEN Token OPTIONAL)
Definition: security.c:215
PspSetQuotaLimits
NTSTATUS NTAPI PspSetQuotaLimits(_In_ PEPROCESS Process, _In_ ULONG Unused, _In_ PVOID QuotaLimits, _In_ ULONG QuotaLimitsLength, _In_ KPROCESSOR_MODE PreviousMode)
This function adjusts the working set limits of a process and sets up new quota limits when necessary...
Definition: quota.c:1045
PsGetNextProcessThread
PETHREAD NTAPI PsGetNextProcessThread(IN PEPROCESS Process, IN PETHREAD Thread OPTIONAL)
Definition: process.c:75
PspDefaultQuotaBlock
EPROCESS_QUOTA_BLOCK PspDefaultQuotaBlock
Definition: quota.c:16
PsThreadInfoClass
static const INFORMATION_CLASS_INFO PsThreadInfoClass[]
Definition: ps_i.h:362
PsProcessInfoClass
static const INFORMATION_CLASS_INFO PsProcessInfoClass[]
Definition: ps_i.h:15
PspSetCrossThreadFlag
#define PspSetCrossThreadFlag(Thread, Flag)
Definition: ps_x.h:25
PspClearCrossThreadFlag
#define PspClearCrossThreadFlag(Thread, Flag)
Definition: ps_x.h:27
PspClearProcessFlag
#define PspClearProcessFlag(Process, Flag)
Definition: ps_x.h:35
PspSetProcessFlag
#define PspSetProcessFlag(Process, Flag)
Definition: ps_x.h:33
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71
_SEH2_YIELD
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:184
PspQueryDescriptorThread
NTSTATUS NTAPI PspQueryDescriptorThread(IN PETHREAD Thread, IN PVOID ThreadInformation, IN ULONG ThreadInformationLength, OUT PULONG ReturnLength OPTIONAL)
Definition: psldt.c:43
_WIN32_WINNT_WS03
#define _WIN32_WINNT_WS03
Definition: sdkddkver.h:23
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
Next
STDMETHOD() Next(THIS_ ULONG celt, IAssociationElement *pElement, ULONG *pceltFetched) PURE
OPTIONAL
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
TLS_MINIMUM_AVAILABLE
#define TLS_MINIMUM_AVAILABLE
Definition: ntddk_ex.h:236
_EPROCESS
Definition: pstypes.h:1307
_ETHREAD
Definition: pstypes.h:1148
_ETHREAD::ExitTime
LARGE_INTEGER ExitTime
Definition: pstypes.h:1153
_ETHREAD::ExitStatus
NTSTATUS ExitStatus
Definition: pstypes.h:1159
_ETHREAD::Tcb
KTHREAD Tcb
Definition: pstypes.h:1149
_ETHREAD::RundownProtect
EX_RUNDOWN_REF RundownProtect
Definition: pstypes.h:1205
_ETHREAD::Win32StartAddress
PVOID Win32StartAddress
Definition: pstypes.h:1198
_ETHREAD::Cid
CLIENT_ID Cid
Definition: pstypes.h:1174
_ETHREAD::IrpList
LIST_ENTRY IrpList
Definition: pstypes.h:1190
_ETHREAD::CreateTime
LARGE_INTEGER CreateTime
Definition: pstypes.h:1150
_ETHREAD::BreakOnTermination
ULONG BreakOnTermination
Definition: pstypes.h:1230
_IO_COUNTERS
Definition: pstypes.h:82
_KERNEL_USER_TIMES
Definition: winternl.h:2373
_KERNEL_USER_TIMES::UserTime
LARGE_INTEGER UserTime
Definition: winternl.h:2377
_KERNEL_USER_TIMES::CreateTime
LARGE_INTEGER CreateTime
Definition: winternl.h:2374
_KERNEL_USER_TIMES::KernelTime
LARGE_INTEGER KernelTime
Definition: winternl.h:2376
_KERNEL_USER_TIMES::ExitTime
LARGE_INTEGER ExitTime
Definition: winternl.h:2375
_KPRCB
Definition: ketypes.h:654
_KPRCB::InterruptTime
ULONG InterruptTime
Definition: ketypes.h:834
_KPRCB::KeSystemCalls
ULONG KeSystemCalls
Definition: ketypes.h:745
_KTHREAD::Affinity
GROUP_AFFINITY Affinity
Definition: ketypes.h:2066
_KTHREAD::IdealProcessor
ULONG IdealProcessor
Definition: ketypes.h:2072
_KTHREAD::DisableBoost
ULONG DisableBoost
Definition: ketypes.h:1853
_KTHREAD::Priority
SCHAR Priority
Definition: ketypes.h:1910
_KTHREAD::Teb
PVOID Teb
Definition: ketypes.h:1935
_KTHREAD::KernelTime
ULONG KernelTime
Definition: ketypes.h:2115
_KTHREAD::UserTime
ULONG UserTime
Definition: ketypes.h:2131
_LIST_ENTRY
Definition: typedefs.h:120
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_OBJECT_NAME_INFORMATION
Definition: nt_native.h:1272
_PROCESS_ACCESS_TOKEN
Definition: ntddk.h:9
_PROCESS_BASIC_INFORMATION
Definition: winternl.h:404
_PROCESS_BASIC_INFORMATION::PebBaseAddress
PPEB PebBaseAddress
Definition: winternl.h:406
_PROCESS_BASIC_INFORMATION::AffinityMask
ULONG_PTR AffinityMask
Definition: pstypes.h:359
_PROCESS_BASIC_INFORMATION::InheritedFromUniqueProcessId
ULONG_PTR InheritedFromUniqueProcessId
Definition: pstypes.h:362
_PROCESS_BASIC_INFORMATION::ExitStatus
NTSTATUS ExitStatus
Definition: pstypes.h:357
_PROCESS_BASIC_INFORMATION::BasePriority
KPRIORITY BasePriority
Definition: pstypes.h:360
_PROCESS_BASIC_INFORMATION::UniqueProcessId
ULONG_PTR UniqueProcessId
Definition: winternl.h:408
_PROCESS_DEVICEMAP_INFORMATION_EX
Definition: pstypes.h:392
_PROCESS_DEVICEMAP_INFORMATION_EX::Flags
ULONG Flags
Definition: pstypes.h:402
_PROCESS_DEVICEMAP_INFORMATION
Definition: pstypes.h:380
_PROCESS_FOREGROUND_BACKGROUND
Definition: pstypes.h:1010
_PROCESS_FOREGROUND_BACKGROUND::Foreground
BOOLEAN Foreground
Definition: pstypes.h:1011
_PROCESS_PRIORITY_CLASS
Definition: pstypes.h:1001
_PROCESS_PRIORITY_CLASS::PriorityClass
UCHAR PriorityClass
Definition: pstypes.h:1003
_PROCESS_PRIORITY_CLASS::Foreground
BOOLEAN Foreground
Definition: pstypes.h:1002
_PROCESS_SESSION_INFORMATION
Definition: pstypes.h:405
_PROCESS_VALUES
Definition: ke.h:45
_PROCESS_VALUES::IoInfo
IO_COUNTERS IoInfo
Definition: ke.h:48
_QUOTA_LIMITS_EX
Definition: pstypes.h:67
_QUOTA_LIMITS_EX::MaximumWorkingSetSize
SIZE_T MaximumWorkingSetSize
Definition: pstypes.h:71
_QUOTA_LIMITS_EX::PagedPoolLimit
SIZE_T PagedPoolLimit
Definition: pstypes.h:68
_QUOTA_LIMITS_EX::PagefileLimit
SIZE_T PagefileLimit
Definition: pstypes.h:72
_QUOTA_LIMITS_EX::Flags
ULONG Flags
Definition: pstypes.h:78
_QUOTA_LIMITS_EX::TimeLimit
LARGE_INTEGER TimeLimit
Definition: pstypes.h:73
_QUOTA_LIMITS_EX::CpuRateLimit
RATE_QUOTA_LIMIT CpuRateLimit
Definition: pstypes.h:79
_QUOTA_LIMITS_EX::NonPagedPoolLimit
SIZE_T NonPagedPoolLimit
Definition: pstypes.h:69
_QUOTA_LIMITS_EX::MinimumWorkingSetSize
SIZE_T MinimumWorkingSetSize
Definition: pstypes.h:70
_QUOTA_LIMITS
Definition: lsa.idl:286
_SECTION_IMAGE_INFORMATION
Definition: mmtypes.h:340
_SECTION
Definition: mmtypes.h:810
_SessionInfo
Definition: mmdrv.h:130
_TEB
Definition: compat.h:836
_TEB::TlsExpansionSlots
PVOID * TlsExpansionSlots
Definition: compat.h:894
_TEB::TlsSlots
PVOID TlsSlots[64]
Definition: compat.h:879
_THREAD_BASIC_INFORMATION
Definition: compat.h:926
_THREAD_BASIC_INFORMATION::ClientId
CLIENT_ID ClientId
Definition: compat.h:929
_THREAD_BASIC_INFORMATION::Priority
KPRIORITY Priority
Definition: compat.h:931
_THREAD_BASIC_INFORMATION::BasePriority
KPRIORITY BasePriority
Definition: compat.h:932
_THREAD_BASIC_INFORMATION::ExitStatus
NTSTATUS ExitStatus
Definition: compat.h:927
_THREAD_BASIC_INFORMATION::TebBaseAddress
PVOID TebBaseAddress
Definition: compat.h:928
_THREAD_BASIC_INFORMATION::AffinityMask
KAFFINITY AffinityMask
Definition: compat.h:930
_UNICODE_STRING
Definition: env_spec_w32.h:368
_VM_COUNTERS
Definition: winternl.h:3130
_VM_COUNTERS::PeakWorkingSetSize
SIZE_T PeakWorkingSetSize
Definition: winternl.h:3134
_VM_COUNTERS::PeakPagefileUsage
SIZE_T PeakPagefileUsage
Definition: winternl.h:3141
_VM_COUNTERS::PageFaultCount
ULONG PageFaultCount
Definition: winternl.h:3133
_VM_COUNTERS::QuotaPagedPoolUsage
SIZE_T QuotaPagedPoolUsage
Definition: winternl.h:3137
_VM_COUNTERS::QuotaPeakPagedPoolUsage
SIZE_T QuotaPeakPagedPoolUsage
Definition: winternl.h:3136
_VM_COUNTERS::QuotaPeakNonPagedPoolUsage
SIZE_T QuotaPeakNonPagedPoolUsage
Definition: winternl.h:3138
_VM_COUNTERS::PeakVirtualSize
SIZE_T PeakVirtualSize
Definition: winternl.h:3131
_VM_COUNTERS::VirtualSize
SIZE_T VirtualSize
Definition: winternl.h:3132
_VM_COUNTERS::QuotaNonPagedPoolUsage
SIZE_T QuotaNonPagedPoolUsage
Definition: winternl.h:3139
_VM_COUNTERS::WorkingSetSize
SIZE_T WorkingSetSize
Definition: winternl.h:3135
_VM_COUNTERS::PagefileUsage
SIZE_T PagefileUsage
Definition: winternl.h:3140
TAG_SEPA
#define TAG_SEPA
Definition: tag.h:155
KeSetIdealProcessorThread
UCHAR NTAPI KeSetIdealProcessorThread(IN PKTHREAD Thread, IN UCHAR Processor)
Definition: thrdobj.c:1066
KeSetBasePriorityThread
LONG NTAPI KeSetBasePriorityThread(IN PKTHREAD Thread, IN LONG Increment)
Definition: thrdobj.c:1157
KeSetPriorityThread
KPRIORITY NTAPI KeSetPriorityThread(IN PKTHREAD Thread, IN KPRIORITY Priority)
Definition: thrdobj.c:1300
KeSetAffinityThread
KAFFINITY NTAPI KeSetAffinityThread(IN PKTHREAD Thread, IN KAFFINITY Affinity)
Definition: thrdobj.c:1276
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56
PULONG_PTR
uint32_t * PULONG_PTR
Definition: typedefs.h:65
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
PBOOLEAN
unsigned char * PBOOLEAN
Definition: typedefs.h:53
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68
NTAPI
#define NTAPI
Definition: typedefs.h:36
LARGE_INTEGER
union _LARGE_INTEGER LARGE_INTEGER
PVOID
void * PVOID
Definition: typedefs.h:50
HANDLE
PVOID HANDLE
Definition: typedefs.h:73
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
IN
#define IN
Definition: typedefs.h:39
PLONG
int32_t * PLONG
Definition: typedefs.h:58
PLARGE_INTEGER
union _LARGE_INTEGER * PLARGE_INTEGER
Definition: file.c:85
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONG
uint32_t ULONG
Definition: typedefs.h:59
OUT
#define OUT
Definition: typedefs.h:40
CCHAR
char CCHAR
Definition: typedefs.h:51
STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
STATUS_INFO_LENGTH_MISMATCH
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
_LARGE_INTEGER::u
struct _LARGE_INTEGER::@2475 u
_RATE_QUOTA_LIMIT::RateData
ULONG RateData
Definition: pstypes.h:60
FileObject
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
Priority
_In_ WDFINTERRUPT _In_ WDF_INTERRUPT_POLICY _In_ WDF_INTERRUPT_PRIORITY Priority
Definition: wdfinterrupt.h:655
HasPrivilege
BOOLEAN HasPrivilege(IN PPRIVILEGE_SET Privilege)
Definition: shutdown.c:92
TlsIndex
#define TlsIndex
Definition: ws2_32p.h:277
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
Cookie
_In_opt_ PVOID _Out_ PLARGE_INTEGER Cookie
Definition: cmfuncs.h:14
Affinity
_In_ ULONG _In_ ULONG _In_ ULONG _Out_ PKIRQL _Out_ PKAFFINITY Affinity
Definition: halfuncs.h:174
PFILE_OBJECT
* PFILE_OBJECT
Definition: iotypes.h:1998
UserTime
_Out_ PULONG UserTime
Definition: kefuncs.h:759
OldIrql
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
KPROCESSOR_MODE
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
ObDereferenceObject
#define ObDereferenceObject
Definition: obfuncs.h:203
ObReferenceObject
#define ObReferenceObject
Definition: obfuncs.h:204
PsGetCurrentProcess
#define PsGetCurrentProcess
Definition: psfuncs.h:17
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181