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