ReactOS  0.4.15-dev-5142-g967f5b9
sysinfo.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS kernel
4  * FILE: ntoskrnl/ex/sysinfo.c
5  * PURPOSE: System information functions
6  *
7  * PROGRAMMERS: David Welch (welch@mcmail.com)
8  * Aleksey Bragin (aleksey@reactos.org)
9  */
10 
11 /* INCLUDES *****************************************************************/
12 
13 #include <ntoskrnl.h>
14 #include <wmidata.h>
15 #include <wmistr.h>
16 #define NDEBUG
17 #include <debug.h>
18 
19 /* The maximum size of an environment value (in bytes) */
20 #define MAX_ENVVAL_SIZE 1024
21 
22 #define SIG_ACPI 0x41435049
23 #define SIG_FIRM 0x4649524D
24 #define SIG_RSMB 0x52534D42
25 
28 
32 
36  IN PLDR_DATA_TABLE_ENTRY LdrEntry,
38 {
39  PCHAR p;
42 
43  /* Fill it out */
44  ModuleInfo->MappedBase = NULL;
45  ModuleInfo->ImageBase = LdrEntry->DllBase;
46  ModuleInfo->ImageSize = LdrEntry->SizeOfImage;
47  ModuleInfo->Flags = LdrEntry->Flags;
48  ModuleInfo->LoadCount = LdrEntry->LoadCount;
49  ModuleInfo->LoadOrderIndex = (USHORT)ModuleCount;
50  ModuleInfo->InitOrderIndex = 0;
51 
52  /* Setup name */
53  RtlInitEmptyAnsiString(&ModuleName,
55  sizeof(ModuleInfo->FullPathName));
56 
57  /* Convert it */
59  &LdrEntry->FullDllName,
60  FALSE);
62  {
63  /* Calculate offset to name */
64  p = ModuleName.Buffer + ModuleName.Length;
65  while ((p > ModuleName.Buffer) && (*--p))
66  {
67  /* Check if we found the separator */
68  if (*p == OBJ_NAME_PATH_SEPARATOR)
69  {
70  /* We did, break out */
71  p++;
72  break;
73  }
74  }
75 
76  /* Set the offset */
77  ModuleInfo->OffsetToFileName = (USHORT)(p - ModuleName.Buffer);
78  }
79  else
80  {
81  /* Return empty name */
83  ModuleInfo->OffsetToFileName = 0;
84  }
85 
86  return Status;
87 }
88 
90 NTAPI
92  IN PLIST_ENTRY UserModeList,
93  OUT PRTL_PROCESS_MODULES Modules,
94  IN ULONG Length,
96 {
100  PLDR_DATA_TABLE_ENTRY LdrEntry;
101  ULONG ModuleCount = 0;
102  PLIST_ENTRY NextEntry;
103 
104  /* Setup defaults */
106  ModuleInfo = &Modules->Modules[0];
107 
108  /* Loop the kernel list */
109  NextEntry = KernelModeList->Flink;
110  while (NextEntry != KernelModeList)
111  {
112  /* Get the entry */
113  LdrEntry = CONTAINING_RECORD(NextEntry,
115  InLoadOrderLinks);
116 
117  /* Update size and check if we can manage one more entry */
119  if (Length >= RequiredLength)
120  {
122  LdrEntry,
123  ModuleInfo);
124 
125  /* Go to the next module */
126  ModuleInfo++;
127  }
128  else
129  {
130  /* Set error code */
132  }
133 
134  /* Update count and move to next entry */
135  ModuleCount++;
136  NextEntry = NextEntry->Flink;
137  }
138 
139  /* Check if caller also wanted user modules */
140  if (UserModeList)
141  {
142  NextEntry = UserModeList->Flink;
143  while (NextEntry != UserModeList)
144  {
145  /* Get the entry */
146  LdrEntry = CONTAINING_RECORD(NextEntry,
148  InLoadOrderLinks);
149 
150  /* Update size and check if we can manage one more entry */
152  if (Length >= RequiredLength)
153  {
155  LdrEntry,
156  ModuleInfo);
157 
158  /* Go to the next module */
159  ModuleInfo++;
160  }
161  else
162  {
163  /* Set error code */
165  }
166 
167  /* Update count and move to next entry */
168  ModuleCount++;
169  NextEntry = NextEntry->Flink;
170  }
171  }
172 
173  /* Update return length */
175 
176  /* Validate the length again */
177  if (Length >= FIELD_OFFSET(RTL_PROCESS_MODULES, Modules))
178  {
179  /* Set the final count */
180  Modules->NumberOfModules = ModuleCount;
181  }
182  else
183  {
184  /* Otherwise, we failed */
186  }
187 
188  /* Done */
189  return Status;
190 }
191 
192 VOID
193 NTAPI
195 {
198 }
199 
200 NTSTATUS
201 NTAPI
204  ULONG Length,
207  PVOID *MappedSystemVa,
208  PMDL *OutMdl)
209 {
210  PMDL Mdl;
211  PAGED_CODE();
212 
213  *MappedSystemVa = NULL;
214  *OutMdl = NULL;
215 
216  /* Allocate an MDL for the buffer */
218  if (Mdl == NULL)
219  {
221  }
222 
223  /* Enter SEH for probing */
224  _SEH2_TRY
225  {
227  }
229  {
232  }
233  _SEH2_END;
234 
235  /* Return the safe kernel mode buffer */
237  if (*MappedSystemVa == NULL)
238  {
241  }
242 
243  /* Return the MDL */
244  *OutMdl = Mdl;
245  return STATUS_SUCCESS;
246 }
247 
248 NTSTATUS
249 NTAPI
252  _Out_ ULONG * OutSize,
254 {
256  PVOID DataBlockObject;
257  PWNODE_ALL_DATA AllData;
258  ULONG WMIBufSize;
259 
260  ASSERT(OutSize != NULL);
261  *OutSize = 0;
262 
263  /* Open the data block object for the SMBIOS table */
266  &DataBlockObject);
267  if (!NT_SUCCESS(Status))
268  {
269  DPRINT1("IoWMIOpenBlock failed: 0x%08lx\n", Status);
270  return Status;
271  }
272 
273  /* Query the required buffer size */
274  WMIBufSize = 0;
275  Status = IoWMIQueryAllData(DataBlockObject, &WMIBufSize, NULL);
276  if (!NT_SUCCESS(Status))
277  {
278  DPRINT1("IoWMIOpenBlock failed: 0x%08lx\n", Status);
279  return Status;
280  }
281 
282  AllData = ExAllocatePoolWithTag(PagedPool, WMIBufSize, 'itfS');
283  if (AllData == NULL)
284  {
285  DPRINT1("Failed to allocate %lu bytes for SMBIOS tables\n", WMIBufSize);
287  }
288 
289  /* Query the buffer data */
290  Status = IoWMIQueryAllData(DataBlockObject, &WMIBufSize, AllData);
291  if (!NT_SUCCESS(Status))
292  {
293  DPRINT1("IoWMIOpenBlock failed: 0x%08lx\n", Status);
294  ExFreePoolWithTag(AllData, 'itfS');
295  return Status;
296  }
297 
299  *OutSize = AllData->FixedInstanceSize;
300  if (Buffer != NULL)
301  {
302  if (BufferSize >= *OutSize)
303  {
304  RtlMoveMemory(Buffer, AllData + 1, *OutSize);
305  }
306  else
307  {
309  }
310  }
311 
312  /* Free the buffer */
313  ExFreePoolWithTag(AllData, 'itfS');
314  return Status;
315 }
316 
317 /* FUNCTIONS *****************************************************************/
318 
319 /*
320  * @implemented
321  */
322 VOID
323 NTAPI
325 {
326  PKPRCB Prcb;
327  ULONG TotalTime;
328  ULONGLONG ScaledIdle;
329 
330  Prcb = KeGetCurrentPrcb();
331 
332  ScaledIdle = (ULONGLONG)Prcb->IdleThread->KernelTime * 100;
333  TotalTime = Prcb->KernelTime + Prcb->UserTime;
334  if (TotalTime != 0)
335  *CpuUsage = (ULONG)(100 - (ScaledIdle / TotalTime));
336  else
337  *CpuUsage = 0;
338 }
339 
340 /*
341  * @implemented
342  */
343 VOID
344 NTAPI
346  PULONG TotalCpuTime,
347  PULONG ProcessorNumber)
348 {
349  PKPRCB Prcb;
350 
351  Prcb = KeGetCurrentPrcb();
352 
353  *ThreadKernelTime = Prcb->KernelTime + Prcb->UserTime;
354  *TotalCpuTime = Prcb->CurrentThread->KernelTime;
355  *ProcessorNumber = KeGetCurrentProcessorNumber();
356 }
357 
358 /*
359  * @implemented
360  */
361 BOOLEAN
362 NTAPI
364 {
365  /* Quick check to see if it exists at all */
366  if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return(FALSE);
367 
368  /* Return our support for it */
369  return(SharedUserData->ProcessorFeatures[ProcessorFeature]);
370 }
371 
372 /*
373  * @implemented
374  */
375 BOOLEAN
376 NTAPI
378 {
379  if (SuiteType == Personal) return TRUE;
380  return FALSE;
381 }
382 
383 NTSTATUS
384 NTAPI
386  OUT PWSTR ValueBuffer,
387  IN ULONG ValueBufferLength,
389 {
390  ANSI_STRING AName;
391  UNICODE_STRING WName;
393  PCH AnsiValueBuffer;
394  ANSI_STRING AValue;
395  UNICODE_STRING WValue;
398  PAGED_CODE();
399 
400  /* Check if the call came from user mode */
402  if (PreviousMode != KernelMode)
403  {
404  _SEH2_TRY
405  {
406  /* Probe the input and output buffers */
407  ProbeForRead(VariableName, sizeof(UNICODE_STRING), sizeof(ULONG));
408  ProbeForWrite(ValueBuffer, ValueBufferLength, sizeof(WCHAR));
410  }
412  {
413  /* Return the exception code */
415  }
416  _SEH2_END;
417  }
418 
419  /* According to NTInternals the SeSystemEnvironmentName privilege is required! */
421  {
422  DPRINT1("NtQuerySystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
424  }
425 
426  /* Copy the name to kernel space if necessary */
427  Status = ProbeAndCaptureUnicodeString(&WName, PreviousMode, VariableName);
428  if (!NT_SUCCESS(Status)) return Status;
429 
430  /* Convert the name to ANSI and release the captured UNICODE string */
431  Status = RtlUnicodeStringToAnsiString(&AName, &WName, TRUE);
433  if (!NT_SUCCESS(Status)) return Status;
434 
435  /* Allocate a buffer for the ANSI environment variable */
436  AnsiValueBuffer = ExAllocatePoolWithTag(NonPagedPool, MAX_ENVVAL_SIZE, 'rvnE');
437  if (AnsiValueBuffer == NULL)
438  {
439  RtlFreeAnsiString(&AName);
441  }
442 
443  /* Get the environment variable and free the ANSI name */
446  AnsiValueBuffer);
447  RtlFreeAnsiString(&AName);
448 
449  /* Check if we had success */
450  if (Result == ESUCCESS)
451  {
452  /* Copy the result back to the caller. */
453  _SEH2_TRY
454  {
455  /* Initialize ANSI string from the result */
456  RtlInitAnsiString(&AValue, AnsiValueBuffer);
457 
458  /* Initialize a UNICODE string from the callers buffer */
459  RtlInitEmptyUnicodeString(&WValue, ValueBuffer, (USHORT)ValueBufferLength);
460 
461  /* Convert the result to UNICODE */
462  Status = RtlAnsiStringToUnicodeString(&WValue, &AValue, FALSE);
463 
464  if (ReturnLength != NULL)
465  *ReturnLength = WValue.Length;
466  }
468  {
470  }
471  _SEH2_END;
472  }
473  else
474  {
476  }
477 
478  /* Free the allocated ANSI value buffer */
479  ExFreePoolWithTag(AnsiValueBuffer, 'rvnE');
480 
481  return Status;
482 }
483 
484 
485 NTSTATUS
486 NTAPI
489 {
490  UNICODE_STRING CapturedName, CapturedValue;
491  ANSI_STRING AName, AValue;
494 
495  PAGED_CODE();
496 
498 
499  /*
500  * Copy the strings to kernel space if necessary
501  */
502  Status = ProbeAndCaptureUnicodeString(&CapturedName,
503  PreviousMode,
504  VariableName);
505  if (NT_SUCCESS(Status))
506  {
507  Status = ProbeAndCaptureUnicodeString(&CapturedValue,
508  PreviousMode,
509  Value);
510  if (NT_SUCCESS(Status))
511  {
512  /*
513  * according to ntinternals the SeSystemEnvironmentName privilege is required!
514  */
516  PreviousMode))
517  {
518  /*
519  * convert the strings to ANSI
520  */
522  &CapturedName,
523  TRUE);
524  if (NT_SUCCESS(Status))
525  {
527  &CapturedValue,
528  TRUE);
529  if (NT_SUCCESS(Status))
530  {
532  AValue.Buffer);
533 
535  }
536  }
537  }
538  else
539  {
540  DPRINT1("NtSetSystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
542  }
543 
544  ReleaseCapturedUnicodeString(&CapturedValue,
545  PreviousMode);
546  }
547 
548  ReleaseCapturedUnicodeString(&CapturedName,
549  PreviousMode);
550  }
551 
552  return Status;
553 }
554 
555 NTSTATUS
556 NTAPI
558  IN PVOID Buffer,
560 {
562  return STATUS_NOT_IMPLEMENTED;
563 }
564 
565 NTSTATUS
566 NTAPI
568  IN LPGUID VendorGuid,
569  IN PVOID Value,
572 {
574  return STATUS_NOT_IMPLEMENTED;
575 }
576 
577 NTSTATUS
578 NTAPI
580  IN LPGUID VendorGuid,
581  IN PVOID Value,
584 {
586  return STATUS_NOT_IMPLEMENTED;
587 }
588 
589 /* --- Query/Set System Information --- */
590 
591 /*
592  * NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
593  * so the stack is popped only in one place on x86 platform.
594  */
595 #define QSI_USE(n) QSI##n
596 #define QSI_DEF(n) \
597 static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
598 
599 #define SSI_USE(n) SSI##n
600 #define SSI_DEF(n) \
601 static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
602 
603 VOID
604 NTAPI
605 ExQueryPoolUsage(OUT PULONG PagedPoolPages,
606  OUT PULONG NonPagedPoolPages,
607  OUT PULONG PagedPoolAllocs,
608  OUT PULONG PagedPoolFrees,
609  OUT PULONG PagedPoolLookasideHits,
610  OUT PULONG NonPagedPoolAllocs,
611  OUT PULONG NonPagedPoolFrees,
612  OUT PULONG NonPagedPoolLookasideHits);
613 
614 /* Class 0 - Basic Information */
616 {
619 
620  *ReqSize = sizeof(SYSTEM_BASIC_INFORMATION);
621 
622  /* Check user buffer's size */
623  if (Size != sizeof(SYSTEM_BASIC_INFORMATION))
624  {
626  }
627 
628  RtlZeroMemory(Sbi, Size);
629  Sbi->Reserved = 0;
631  Sbi->PageSize = PAGE_SIZE;
635  Sbi->AllocationGranularity = MM_VIRTMEM_GRANULARITY; /* hard coded on Intel? */
636  Sbi->MinimumUserModeAddress = 0x10000; /* Top of 64k */
640 
641  return STATUS_SUCCESS;
642 }
643 
644 /* Class 1 - Processor Information */
646 {
649 
650  *ReqSize = sizeof(SYSTEM_PROCESSOR_INFORMATION);
651 
652  /* Check user buffer's size */
653  if (Size < sizeof(SYSTEM_PROCESSOR_INFORMATION))
654  {
656  }
660 #if (NTDDI_VERSION < NTDDI_WIN8)
661  Spi->Reserved = 0;
662 #else
663  Spi->MaximumProcessors = 0;
664 #endif
666 
667  DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
668  Spi->ProcessorLevel, Spi->ProcessorRevision);
669 
670  return STATUS_SUCCESS;
671 }
672 
673 /* Class 2 - Performance Information */
675 {
676  LONG i;
677  ULONG IdleUser, IdleKernel;
678  PKPRCB Prcb;
681 
683 
684  *ReqSize = sizeof(SYSTEM_PERFORMANCE_INFORMATION);
685 
686  /* Check user buffer's size */
687  if (Size < sizeof(SYSTEM_PERFORMANCE_INFORMATION))
688  {
690  }
691 
693 
694  IdleKernel = KeQueryRuntimeProcess(&TheIdleProcess->Pcb, &IdleUser);
702  for (i = 0; i < KeNumberProcessors; i ++)
703  {
704  Prcb = KiProcessorBlock[i];
705  if (Prcb)
706  {
713  }
714  }
715 
717 
719  /*
720  * Add up the full system total + pagefile.
721  * All this make Taskmgr happy but not sure it is the right numbers.
722  * This too, fixes some of GlobalMemoryStatusEx numbers.
723  */
725 
727  Spi->PageFaultCount = 0; /* FIXME */
728  Spi->CopyOnWriteCount = 0; /* FIXME */
729  Spi->TransitionCount = 0; /* FIXME */
730  Spi->CacheTransitionCount = 0; /* FIXME */
731  Spi->DemandZeroCount = 0; /* FIXME */
732  Spi->PageReadCount = 0; /* FIXME */
733  Spi->PageReadIoCount = 0; /* FIXME */
734  Spi->CacheReadCount = 0; /* FIXME */
735  Spi->CacheIoCount = 0; /* FIXME */
736  Spi->DirtyPagesWriteCount = 0; /* FIXME */
737  Spi->DirtyWriteIoCount = 0; /* FIXME */
738  Spi->MappedPagesWriteCount = 0; /* FIXME */
739  Spi->MappedWriteIoCount = 0; /* FIXME */
740 
741  Spi->PagedPoolPages = 0;
742  Spi->NonPagedPoolPages = 0;
743  Spi->PagedPoolAllocs = 0;
744  Spi->PagedPoolFrees = 0;
745  Spi->PagedPoolLookasideHits = 0;
746  Spi->NonPagedPoolAllocs = 0;
747  Spi->NonPagedPoolFrees = 0;
748  Spi->NonPagedPoolLookasideHits = 0;
750  &Spi->NonPagedPoolPages,
751  &Spi->PagedPoolAllocs,
752  &Spi->PagedPoolFrees,
754  &Spi->NonPagedPoolAllocs,
755  &Spi->NonPagedPoolFrees,
757  Spi->FreeSystemPtes = 0; /* FIXME */
758 
759  Spi->ResidentSystemCodePage = 0; /* FIXME */
760 
761  Spi->TotalSystemDriverPages = 0; /* FIXME */
762  Spi->Spare3Count = 0; /* FIXME */
763 
765  Spi->ResidentPagedPoolPage = 0; /* FIXME */
766 
767  Spi->ResidentSystemDriverPage = 0; /* FIXME */
768  Spi->CcFastReadNoWait = 0; /* FIXME */
769  Spi->CcFastReadWait = 0; /* FIXME */
770  Spi->CcFastReadResourceMiss = 0; /* FIXME */
771  Spi->CcFastReadNotPossible = 0; /* FIXME */
772 
773  Spi->CcFastMdlReadNoWait = 0; /* FIXME */
774  Spi->CcFastMdlReadWait = 0; /* FIXME */
775  Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
776  Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
777 
780  Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
781  Spi->CcMapDataWaitMiss = 0; /* FIXME */
782 
786  Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
787  Spi->CcPinReadWaitMiss = 0; /* FIXME */
788  Spi->CcCopyReadNoWait = 0; /* FIXME */
789  Spi->CcCopyReadWait = 0; /* FIXME */
790  Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
791  Spi->CcCopyReadWaitMiss = 0; /* FIXME */
792 
793  Spi->CcMdlReadNoWait = 0; /* FIXME */
794  Spi->CcMdlReadWait = 0; /* FIXME */
795  Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
796  Spi->CcMdlReadWaitMiss = 0; /* FIXME */
797  Spi->CcReadAheadIos = 0; /* FIXME */
801  Spi->CcDataPages = CcDataPages;
802 
803  Spi->ContextSwitches = 0;
804  Spi->FirstLevelTbFills = 0;
805  Spi->SecondLevelTbFills = 0;
806  Spi->SystemCalls = 0;
807  for (i = 0; i < KeNumberProcessors; i ++)
808  {
809  Prcb = KiProcessorBlock[i];
810  if (Prcb)
811  {
813  Spi->FirstLevelTbFills += Prcb->KeFirstLevelTbFills;
814  Spi->SecondLevelTbFills += Prcb->KeSecondLevelTbFills;
815  Spi->SystemCalls += Prcb->KeSystemCalls;
816  }
817  }
818 
819  return STATUS_SUCCESS;
820 }
821 
822 /* Class 3 - Time Of Day Information */
824 {
826  LARGE_INTEGER CurrentTime;
827 
828  /* Set amount of written information to 0 */
829  *ReqSize = 0;
830 
831  /* Check user buffer's size */
832  if (Size > sizeof(SYSTEM_TIMEOFDAY_INFORMATION))
833  {
835  }
836 
837  /* Get current time */
838  KeQuerySystemTime(&CurrentTime);
839 
840  /* Zero local buffer */
842 
843  /* Fill local time structure */
844  Sti.BootTime= KeBootTime;
845  Sti.CurrentTime = CurrentTime;
848  Sti.Reserved = 0;
849 
850  /* Copy as much as requested by caller */
851  RtlCopyMemory(Buffer, &Sti, Size);
852 
853  /* Set amount of information we copied */
854  *ReqSize = Size;
855 
856  return STATUS_SUCCESS;
857 }
858 
859 /* Class 4 - Path Information (DEPRECATED) */
861 {
862  /*
863  * Since NT 3.51, this information class is trivially implemented.
864  * The path to the NT directory is now stored in KUSER_SHARED_DATA
865  * as the NtSystemRoot member.
866  * Windows Checked builds show the following message and break to
867  * the debugger before failing the function as not implemented.
868  */
869 #if DBG
870  DPRINT1("EX: SystemPathInformation now available via SharedUserData\n");
871  // DbgBreakPoint(); // Not needed in ReactOS.
872 #endif
873  return STATUS_NOT_IMPLEMENTED;
874 }
875 
876 /* Class 5 - Process Information */
878 {
879  PSYSTEM_PROCESS_INFORMATION SpiCurrent;
881  PEPROCESS Process = NULL, SystemProcess;
882  PETHREAD CurrentThread;
884  ULONG CurrentSize;
885  USHORT ImageNameMaximumLength; // image name length in bytes
886  USHORT ImageNameLength;
887  PLIST_ENTRY CurrentEntry;
888  ULONG TotalSize = 0, ThreadsCount;
889  ULONG TotalUser, TotalKernel;
890  PUCHAR Current;
892  PUNICODE_STRING TempProcessImageName;
893  _SEH2_VOLATILE PUNICODE_STRING ProcessImageName = NULL;
894  PWCHAR szSrc;
895  BOOLEAN Overflow = FALSE;
896 
897  _SEH2_TRY
898  {
899  /* scan the process list */
900 
903 
904  *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
905 
906  /* Check for overflow */
907  if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
908  {
909  Overflow = TRUE;
910  }
911 
912  /* Zero user's buffer */
913  if (!Overflow) RtlZeroMemory(Spi, Size);
914 
915  SystemProcess = PsIdleProcess;
916  Process = SystemProcess;
917  Current = (PUCHAR) Spi;
918 
919  do
920  {
921  SpiCurrent = (PSYSTEM_PROCESS_INFORMATION) Current;
922 
923  /* Lock the Process */
925  ExAcquirePushLockShared(&Process->ProcessLock);
926 
927  if ((Process->ProcessExiting) &&
928  (Process->Pcb.Header.SignalState) &&
929  !(Process->ActiveThreads) &&
930  (IsListEmpty(&Process->Pcb.ThreadListHead)))
931  {
932  DPRINT1("Process %p (%s:%p) is a zombie\n",
933  Process, Process->ImageFileName, Process->UniqueProcessId);
934  CurrentSize = 0;
935  ImageNameMaximumLength = 0;
936 
937  /* Unlock the Process */
938  ExReleasePushLockShared(&Process->ProcessLock);
940  goto Skip;
941  }
942 
943  ThreadsCount = 0;
944  CurrentEntry = Process->Pcb.ThreadListHead.Flink;
945  while (CurrentEntry != &Process->Pcb.ThreadListHead)
946  {
947  ThreadsCount++;
948  CurrentEntry = CurrentEntry->Flink;
949  }
950 
951  // size of the structure for every process
952  CurrentSize = sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION) * ThreadsCount;
953  ImageNameLength = 0;
954  Status = SeLocateProcessImageName(Process, &TempProcessImageName);
955  ProcessImageName = TempProcessImageName;
956  szSrc = NULL;
957  if (NT_SUCCESS(Status) && (ProcessImageName->Length > 0))
958  {
959  szSrc = (PWCHAR)((PCHAR)ProcessImageName->Buffer + ProcessImageName->Length);
960  /* Loop the file name*/
961  while (szSrc > ProcessImageName->Buffer)
962  {
963  /* Make sure this isn't a backslash */
964  if (*--szSrc == OBJ_NAME_PATH_SEPARATOR)
965  {
966  szSrc++;
967  break;
968  }
969  else
970  {
971  ImageNameLength += sizeof(WCHAR);
972  }
973  }
974  }
975  if (!ImageNameLength && Process != PsIdleProcess)
976  {
977  ImageNameLength = (USHORT)strlen(Process->ImageFileName) * sizeof(WCHAR);
978  }
979 
980  /* Round up the image name length as NT does */
981  if (ImageNameLength > 0)
982  ImageNameMaximumLength = ROUND_UP(ImageNameLength + sizeof(WCHAR), 8);
983  else
984  ImageNameMaximumLength = 0;
985 
986  TotalSize += CurrentSize + ImageNameMaximumLength;
987 
988  /* Check for overflow */
989  if (TotalSize > Size)
990  {
991  Overflow = TRUE;
992  }
993 
994  /* Fill system information */
995  if (!Overflow)
996  {
997  SpiCurrent->NextEntryOffset = CurrentSize + ImageNameMaximumLength; // relative offset to the beginning of the next structure
998  SpiCurrent->NumberOfThreads = ThreadsCount;
999  SpiCurrent->CreateTime = Process->CreateTime;
1000  SpiCurrent->ImageName.Length = ImageNameLength;
1001  SpiCurrent->ImageName.MaximumLength = ImageNameMaximumLength;
1002  SpiCurrent->ImageName.Buffer = (void*)(Current + CurrentSize);
1003 
1004  /* Copy name to the end of the struct */
1005  if(Process != PsIdleProcess)
1006  {
1007  if (szSrc)
1008  {
1009  RtlCopyMemory(SpiCurrent->ImageName.Buffer, szSrc, SpiCurrent->ImageName.Length);
1010  }
1011  else
1012  {
1013  RtlInitAnsiString(&ImageName, Process->ImageFileName);
1015  if (!NT_SUCCESS(Status))
1016  {
1017  SpiCurrent->ImageName.Length = 0;
1018  }
1019  }
1020  }
1021  else
1022  {
1023  RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
1024  }
1025 
1026  SpiCurrent->BasePriority = Process->Pcb.BasePriority;
1027  SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
1028  SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
1029 
1030  /* PsIdleProcess shares its handle table with PsInitialSystemProcess,
1031  * so return the handle count for System only, not Idle one. */
1033 
1034  SpiCurrent->PeakVirtualSize = Process->PeakVirtualSize;
1035  SpiCurrent->VirtualSize = Process->VirtualSize;
1036  SpiCurrent->PageFaultCount = Process->Vm.PageFaultCount;
1037  SpiCurrent->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
1038  SpiCurrent->WorkingSetSize = Process->Vm.WorkingSetSize;
1039  SpiCurrent->QuotaPeakPagedPoolUsage = Process->QuotaPeak[PsPagedPool];
1040  SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[PsPagedPool];
1041  SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[PsNonPagedPool];
1042  SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[PsNonPagedPool];
1043  SpiCurrent->PagefileUsage = Process->QuotaUsage[PsPageFile];
1044  SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[PsPageFile];
1045  SpiCurrent->PrivatePageCount = Process->CommitCharge;
1046  ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCurrent + 1);
1047 
1048  CurrentEntry = Process->Pcb.ThreadListHead.Flink;
1049  while (CurrentEntry != &Process->Pcb.ThreadListHead)
1050  {
1051  CurrentThread = CONTAINING_RECORD(CurrentEntry, ETHREAD, Tcb.ThreadListEntry);
1052 
1053  ThreadInfo->KernelTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.KernelTime, KeMaximumIncrement);
1054  ThreadInfo->UserTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.UserTime, KeMaximumIncrement);
1055  ThreadInfo->CreateTime.QuadPart = CurrentThread->CreateTime.QuadPart;
1056  ThreadInfo->WaitTime = CurrentThread->Tcb.WaitTime;
1057  ThreadInfo->StartAddress = (PVOID) CurrentThread->StartAddress;
1058  ThreadInfo->ClientId = CurrentThread->Cid;
1059  ThreadInfo->Priority = CurrentThread->Tcb.Priority;
1060  ThreadInfo->BasePriority = CurrentThread->Tcb.BasePriority;
1061  ThreadInfo->ContextSwitches = CurrentThread->Tcb.ContextSwitches;
1062  ThreadInfo->ThreadState = CurrentThread->Tcb.State;
1063  ThreadInfo->WaitReason = CurrentThread->Tcb.WaitReason;
1064 
1065  ThreadInfo++;
1066  CurrentEntry = CurrentEntry->Flink;
1067  }
1068 
1069  /* Query total user/kernel times of a process */
1070  TotalKernel = KeQueryRuntimeProcess(&Process->Pcb, &TotalUser);
1071  SpiCurrent->UserTime.QuadPart = UInt32x32To64(TotalUser, KeMaximumIncrement);
1072  SpiCurrent->KernelTime.QuadPart = UInt32x32To64(TotalKernel, KeMaximumIncrement);
1073  }
1074 
1075  if (ProcessImageName)
1076  {
1077  /* Release the memory allocated by SeLocateProcessImageName */
1078  ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
1079  ProcessImageName = NULL;
1080  }
1081 
1082  /* Unlock the Process */
1083  ExReleasePushLockShared(&Process->ProcessLock);
1085 
1086  /* Handle idle process entry */
1087 Skip:
1088  if (Process == PsIdleProcess) Process = NULL;
1089 
1091  ThreadsCount = 0;
1092  if ((Process == SystemProcess) || (Process == NULL))
1093  {
1094  if (!Overflow)
1095  SpiCurrent->NextEntryOffset = 0;
1096  break;
1097  }
1098  else
1099  Current += CurrentSize + ImageNameMaximumLength;
1100  } while ((Process != SystemProcess) && (Process != NULL));
1101 
1102  if(Process != NULL)
1105  }
1107  {
1108  if(Process != NULL)
1110  if (ProcessImageName)
1111  {
1112  /* Release the memory allocated by SeLocateProcessImageName */
1113  ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
1114  }
1115 
1117  }
1118  _SEH2_END
1119 
1120  if (Overflow)
1122 
1123  *ReqSize = TotalSize;
1124  return Status;
1125 }
1126 
1127 /* Class 6 - Call Count Information */
1129 {
1130  /* FIXME */
1131  DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
1132  return STATUS_NOT_IMPLEMENTED;
1133 }
1134 
1135 /* Class 7 - Device Information */
1137 {
1140  PCONFIGURATION_INFORMATION ConfigInfo;
1141 
1142  *ReqSize = sizeof(SYSTEM_DEVICE_INFORMATION);
1143 
1144  /* Check user buffer's size */
1145  if (Size < sizeof(SYSTEM_DEVICE_INFORMATION))
1146  {
1148  }
1149 
1150  ConfigInfo = IoGetConfigurationInformation();
1151 
1152  Sdi->NumberOfDisks = ConfigInfo->DiskCount;
1153  Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
1154  Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
1155  Sdi->NumberOfTapes = ConfigInfo->TapeCount;
1156  Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
1157  Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
1158 
1159  return STATUS_SUCCESS;
1160 }
1161 
1162 /* Class 8 - Processor Performance Information */
1164 {
1167 
1168  LONG i;
1169  ULONG TotalTime;
1170  PKPRCB Prcb;
1171 
1173 
1174  /* Check user buffer's size */
1175  if (Size < *ReqSize)
1176  {
1178  }
1179 
1180  for (i = 0; i < KeNumberProcessors; i++)
1181  {
1182  /* Get the PRCB on this processor */
1183  Prcb = KiProcessorBlock[i];
1184 
1185  /* Calculate total user and kernel times */
1186  TotalTime = Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime;
1192  Spi->InterruptCount = Prcb->InterruptCount;
1193  Spi++;
1194  }
1195 
1196  return STATUS_SUCCESS;
1197 }
1198 
1199 /* Class 9 - Flags Information */
1201 {
1202 #if (NTDDI_VERSION >= NTDDI_VISTA)
1203  *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1204 #endif
1205 
1206  if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1207  {
1209  }
1210 
1212 #if (NTDDI_VERSION < NTDDI_VISTA)
1213  *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1214 #endif
1215 
1216  return STATUS_SUCCESS;
1217 }
1218 
1220 {
1221  if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1222  {
1224  }
1225 
1227  {
1228 #if (NTDDI_VERSION < NTDDI_WIN7)
1229  return STATUS_ACCESS_VIOLATION;
1230 #else
1231  return STATUS_ACCESS_DENIED;
1232 #endif
1233  }
1234 
1236  return STATUS_SUCCESS;
1237 }
1238 
1239 /* Class 10 - Call Time Information */
1241 {
1242  /* FIXME */
1243  DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
1244  return STATUS_NOT_IMPLEMENTED;
1245 }
1246 
1247 /* Class 11 - Module Information */
1249 {
1250  NTSTATUS Status;
1251 
1252  /* Acquire system module list lock */
1255 
1256  /* Call the generic handler with the system module list */
1260  Size,
1261  ReqSize);
1262 
1263  /* Release list lock and return status */
1266  return Status;
1267 }
1268 
1269 /* Class 12 - Locks Information */
1271 {
1272  /* FIXME */
1273  DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
1274  return STATUS_NOT_IMPLEMENTED;
1275 }
1276 
1277 /* Class 13 - Stack Trace Information */
1279 {
1280  /* FIXME */
1281  DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
1282  return STATUS_NOT_IMPLEMENTED;
1283 }
1284 
1285 /* Class 14 - Paged Pool Information */
1287 {
1288  /* FIXME */
1289  DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
1290  return STATUS_NOT_IMPLEMENTED;
1291 }
1292 
1293 /* Class 15 - Non Paged Pool Information */
1295 {
1296  /* FIXME */
1297  DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
1298  return STATUS_NOT_IMPLEMENTED;
1299 }
1300 
1301 /* Class 16 - Handle Information */
1303 {
1305  PLIST_ENTRY NextTableEntry;
1307  PHANDLE_TABLE_ENTRY HandleTableEntry;
1308  EXHANDLE Handle;
1309  ULONG Index = 0;
1310  NTSTATUS Status;
1311  PMDL Mdl;
1312  PAGED_CODE();
1313 
1314  DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1315 
1316  /* Set initial required buffer size */
1317  *ReqSize = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handles);
1318 
1319  /* Check user's buffer size */
1320  if (Size < *ReqSize)
1321  {
1323  }
1324 
1325  /* We need to lock down the memory */
1327  Size,
1329  IoWriteAccess,
1331  &Mdl);
1332  if (!NT_SUCCESS(Status))
1333  {
1334  DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
1335  return Status;
1336  }
1337 
1338  /* Reset of count of handles */
1339  HandleInformation->NumberOfHandles = 0;
1340 
1341  /* Enter a critical region */
1343 
1344  /* Acquire the handle table lock */
1346 
1347  /* Enumerate all system handles */
1348  for (NextTableEntry = HandleTableListHead.Flink;
1349  NextTableEntry != &HandleTableListHead;
1350  NextTableEntry = NextTableEntry->Flink)
1351  {
1352  /* Get current handle table */
1353  HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
1354 
1355  /* Set the initial value and loop the entries */
1356  Handle.Value = 0;
1357  while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
1358  {
1359  /* Validate the entry */
1360  if ((HandleTableEntry->Object) &&
1361  (HandleTableEntry->NextFreeTableEntry != -2))
1362  {
1363  /* Increase of count of handles */
1364  ++HandleInformation->NumberOfHandles;
1365 
1366  /* Lock the entry */
1367  if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
1368  {
1369  /* Increase required buffer size */
1370  *ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO);
1371 
1372  /* Check user's buffer size */
1373  if (*ReqSize > Size)
1374  {
1376  }
1377  else
1378  {
1379  POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
1380 
1381  /* Filling handle information */
1382  HandleInformation->Handles[Index].UniqueProcessId =
1383  (USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
1384 
1385  HandleInformation->Handles[Index].CreatorBackTraceIndex = 0;
1386 
1387 #if 0 /* FIXME!!! Type field currupted */
1388  HandleInformation->Handles[Index].ObjectTypeIndex =
1389  (UCHAR) ObjectHeader->Type->Index;
1390 #else
1391  HandleInformation->Handles[Index].ObjectTypeIndex = 0;
1392 #endif
1393 
1394  HandleInformation->Handles[Index].HandleAttributes =
1395  HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
1396 
1397  HandleInformation->Handles[Index].HandleValue =
1398  (USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
1399 
1400  HandleInformation->Handles[Index].Object = &ObjectHeader->Body;
1401 
1402  HandleInformation->Handles[Index].GrantedAccess =
1403  HandleTableEntry->GrantedAccess;
1404 
1405  ++Index;
1406  }
1407 
1408  /* Unlock it */
1409  ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
1410  }
1411  }
1412 
1413  /* Go to the next entry */
1414  Handle.Value += sizeof(HANDLE);
1415  }
1416  }
1417 
1418  /* Release the lock */
1420 
1421  /* Leave the critical region */
1423 
1424  /* Release the locked user buffer */
1426 
1427  return Status;
1428 }
1429 
1430 /* Class 17 - Information */
1432 {
1433  /* FIXME */
1434  DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1435  return STATUS_NOT_IMPLEMENTED;
1436 }
1437 
1438 /* Class 18 - Information */
1440 {
1441  UNICODE_STRING FileName; /* FIXME */
1443 
1444  if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
1445  {
1446  * ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
1448  }
1449 
1450  RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1451 
1452  /* FIXME */
1453  Spfi->NextEntryOffset = 0;
1454 
1456  Spfi->TotalInUse = MiUsedSwapPages;
1457  Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1458  Spfi->PageFileName = FileName;
1459  return STATUS_SUCCESS;
1460 }
1461 
1462 /* Class 19 - Vdm Instemul Information */
1464 {
1465  /* FIXME */
1466  DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1467  return STATUS_NOT_IMPLEMENTED;
1468 }
1469 
1470 /* Class 20 - Vdm Bop Information */
1472 {
1473  /* FIXME */
1474  DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1475  return STATUS_NOT_IMPLEMENTED;
1476 }
1477 
1478 /* Class 21 - File Cache Information */
1480 {
1482 
1483  *ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
1484 
1485  if (Size < *ReqSize)
1486  {
1488  }
1489 
1491 
1492  /* Return the Byte size not the page size. */
1493  Sci->CurrentSize = MiMemoryConsumers[MC_USER].PagesUsed; /* FIXME */
1494  Sci->PeakSize = MiMemoryConsumers[MC_USER].PagesUsed; /* FIXME */
1495  /* Taskmgr multiplies this one by page size right away */
1497  /* system working set and standby pages. */
1498  Sci->PageFaultCount = 0; /* FIXME */
1499  Sci->MinimumWorkingSet = 0; /* FIXME */
1500  Sci->MaximumWorkingSet = 0; /* FIXME */
1501 
1502  return STATUS_SUCCESS;
1503 }
1504 
1506 {
1507  if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1508  {
1510  }
1511  /* FIXME */
1512  DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1513  return STATUS_NOT_IMPLEMENTED;
1514 }
1515 
1516 /* Class 22 - Pool Tag Information */
1518 {
1520  return ExGetPoolTagInfo(Buffer, Size, ReqSize);
1521 }
1522 
1523 /* Class 23 - Interrupt Information for all processors */
1525 {
1526  PKPRCB Prcb;
1527  LONG i;
1528  ULONG ti;
1530 
1532  {
1534  }
1535 
1536  ti = KeQueryTimeIncrement();
1537 
1538  for (i = 0; i < KeNumberProcessors; i++)
1539  {
1540  Prcb = KiProcessorBlock[i];
1542  sii->DpcCount = Prcb->DpcData[0].DpcCount;
1543  sii->DpcRate = Prcb->DpcRequestRate;
1544  sii->TimeIncrement = ti;
1545  sii->DpcBypassCount = 0;
1546  sii->ApcBypassCount = 0;
1547  sii++;
1548  }
1549 
1550  return STATUS_SUCCESS;
1551 }
1552 
1553 /* Class 24 - DPC Behaviour Information */
1555 {
1557 
1558  if (Size < sizeof(SYSTEM_DPC_BEHAVIOR_INFORMATION))
1559  {
1561  }
1562 
1566  sdbi->IdealDpcRate = KiIdealDpcRate;
1567 
1568  return STATUS_SUCCESS;
1569 }
1570 
1572 {
1573  /* FIXME */
1574  DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1575  return STATUS_NOT_IMPLEMENTED;
1576 }
1577 
1578 /* Class 25 - Full Memory Information */
1580 {
1581  PULONG Spi = (PULONG) Buffer;
1582 
1584 
1585  *ReqSize = sizeof(ULONG);
1586 
1587  if (sizeof(ULONG) != Size)
1588  {
1590  }
1591 
1592  DPRINT("SystemFullMemoryInformation\n");
1593 
1595 
1596  DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
1600  MiUsedSwapPages);
1601 
1603 
1604  return STATUS_SUCCESS;
1605 }
1606 
1607 /* Class 26 - Load Image */
1609 {
1612  PVOID ImageBase;
1613  PVOID SectionPointer;
1614  ULONG_PTR EntryPoint;
1615  NTSTATUS Status;
1616  ULONG DirSize;
1617  PIMAGE_NT_HEADERS NtHeader;
1618 
1619  /* Validate size */
1620  if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1621  {
1622  /* Incorrect buffer length, fail */
1624  }
1625 
1626  /* Only kernel mode can call this function */
1628 
1629  /* Load the driver */
1630  ImageName = DriverInfo->DriverName;
1632  NULL,
1633  NULL,
1634  0,
1635  &SectionPointer,
1636  &ImageBase);
1637  if (!NT_SUCCESS(Status)) return Status;
1638 
1639  /* Return the export pointer */
1640  DriverInfo->ExportSectionPointer =
1641  RtlImageDirectoryEntryToData(ImageBase,
1642  TRUE,
1644  &DirSize);
1645 
1646  /* Get the entrypoint */
1647  NtHeader = RtlImageNtHeader(ImageBase);
1648  EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1649  EntryPoint += (ULONG_PTR)ImageBase;
1650 
1651  /* Save other data */
1652  DriverInfo->ImageAddress = ImageBase;
1653  DriverInfo->SectionPointer = SectionPointer;
1654  DriverInfo->EntryPoint = (PVOID)EntryPoint;
1655  DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1656 
1657  /* All is good */
1658  return STATUS_SUCCESS;
1659 }
1660 
1661 /* Class 27 - Unload Image */
1663 {
1664  PVOID *SectionPointer = Buffer;
1665 
1666  /* Validate size */
1667  if (Size != sizeof(PVOID))
1668  {
1669  /* Incorrect length, fail */
1671  }
1672 
1673  /* Only kernel mode can call this function */
1675 
1676  /* Unload the image */
1677  MmUnloadSystemImage(*SectionPointer);
1678  return STATUS_SUCCESS;
1679 }
1680 
1681 /* Class 28 - Time Adjustment Information */
1683 {
1686 
1687  /* Check if enough storage was provided */
1689  {
1690  * ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
1692  }
1693 
1694  /* Give time values to our caller */
1695  TimeInfo->TimeIncrement = KeMaximumIncrement;
1696  TimeInfo->TimeAdjustment = KeTimeAdjustment;
1697  TimeInfo->Enable = !KiTimeAdjustmentEnabled;
1698 
1699  return STATUS_SUCCESS;
1700 }
1701 
1703 {
1707 
1708  /* Check size of a buffer, it must match our expectations */
1711 
1712  /* Check who is calling */
1713  if (PreviousMode != KernelMode)
1714  {
1715  /* Check access rights */
1717  {
1719  }
1720  }
1721 
1722  /* FIXME: behaviour suggests the member be named 'Disable' */
1723  if (TimeInfo->Enable)
1724  {
1725  /* Disable time adjustment and set default value */
1728  }
1729  else
1730  {
1731  /* Check if a valid time adjustment value is given */
1732  if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
1733 
1734  /* Enable time adjustment and set the adjustment value */
1736  KeTimeAdjustment = TimeInfo->TimeAdjustment;
1737  }
1738 
1739  return STATUS_SUCCESS;
1740 }
1741 
1742 /* Class 29 - Summary Memory Information */
1744 {
1745  /* FIXME */
1746  DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1747  return STATUS_NOT_IMPLEMENTED;
1748 }
1749 
1750 /* Class 30 - Next Event Id Information */
1752 {
1753  /* FIXME */
1754  DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1755  return STATUS_NOT_IMPLEMENTED;
1756 }
1757 
1758 /* Class 31 */
1760 {
1761  /* FIXME */
1762  DPRINT1("NtQuerySystemInformation - SystemPerformanceTraceInformation not implemented\n");
1763  return STATUS_NOT_IMPLEMENTED;
1764 }
1765 
1766 /* Class 32 - Crash Dump Information */
1768 {
1769  /* FIXME */
1770  DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1771  return STATUS_NOT_IMPLEMENTED;
1772 }
1773 
1774 /* Class 33 - Exception Information */
1776 {
1777  PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
1779  PKPRCB Prcb;
1780  ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
1781  ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
1782  CHAR i;
1783 
1784  /* Check size of a buffer, it must match our expectations */
1785  if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
1787 
1788  /* Sum up exception count information from all processors */
1789  for (i = 0; i < KeNumberProcessors; i++)
1790  {
1791  Prcb = KiProcessorBlock[i];
1792  if (Prcb)
1793  {
1794  AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
1795  ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
1796 #ifndef _M_ARM
1797  FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
1798 #endif // _M_ARM
1799  }
1800  }
1801 
1802  /* Save information in user's buffer */
1803  ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
1804  ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
1805  ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
1806  ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
1807 
1808  return STATUS_SUCCESS;
1809 }
1810 
1811 /* Class 34 - Crash Dump State Information */
1813 {
1814  /* FIXME */
1815  DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1816  return STATUS_NOT_IMPLEMENTED;
1817 }
1818 
1819 /* Class 35 - Kernel Debugger Information */
1821 {
1823 
1824 #if (NTDDI_VERSION >= NTDDI_VISTA)
1825  *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1826 #endif
1827 
1829  {
1831  }
1832 
1835 
1836 #if (NTDDI_VERSION < NTDDI_VISTA)
1837  *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1838 #endif
1839 
1840  return STATUS_SUCCESS;
1841 }
1842 
1843 /* Class 36 - Context Switch Information */
1845 {
1846  PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
1848  ULONG ContextSwitches;
1849  PKPRCB Prcb;
1850  CHAR i;
1851 
1852  /* Check size of a buffer, it must match our expectations */
1853  if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
1855 
1856  /* Calculate total value of context switches across all processors */
1857  ContextSwitches = 0;
1858  for (i = 0; i < KeNumberProcessors; i ++)
1859  {
1860  Prcb = KiProcessorBlock[i];
1861  if (Prcb)
1862  {
1863  ContextSwitches += KeGetContextSwitches(Prcb);
1864  }
1865  }
1866 
1867  ContextSwitchInformation->ContextSwitches = ContextSwitches;
1868 
1869  /* FIXME */
1870  ContextSwitchInformation->FindAny = 0;
1871  ContextSwitchInformation->FindLast = 0;
1872  ContextSwitchInformation->FindIdeal = 0;
1873  ContextSwitchInformation->IdleAny = 0;
1874  ContextSwitchInformation->IdleCurrent = 0;
1875  ContextSwitchInformation->IdleLast = 0;
1876  ContextSwitchInformation->IdleIdeal = 0;
1877  ContextSwitchInformation->PreemptAny = 0;
1878  ContextSwitchInformation->PreemptCurrent = 0;
1879  ContextSwitchInformation->PreemptLast = 0;
1880  ContextSwitchInformation->SwitchToIdle = 0;
1881 
1882  return STATUS_SUCCESS;
1883 }
1884 
1885 /* Class 37 - Registry Quota Information */
1887 {
1889 
1890  *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1892  {
1894  }
1895 
1896  DPRINT1("Faking max registry size of 32 MB\n");
1897  srqi->RegistryQuotaAllowed = 0x2000000;
1898  srqi->RegistryQuotaUsed = 0x200000;
1899  srqi->PagedPoolSize = 0x200000;
1900 
1901  return STATUS_SUCCESS;
1902 }
1903 
1905 {
1906  /* FIXME */
1907  DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1908  return STATUS_NOT_IMPLEMENTED;
1909 }
1910 
1911 /* Class 38 - Load And Call Image */
1913 {
1916  PLDR_DATA_TABLE_ENTRY ModuleObject;
1917  NTSTATUS Status;
1918  PIMAGE_NT_HEADERS NtHeader;
1919  DRIVER_OBJECT Win32k;
1920  PDRIVER_INITIALIZE DriverInit;
1921  PVOID ImageBase;
1922  ULONG_PTR EntryPoint;
1923 
1924  /* Validate the size */
1925  if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1926 
1927  /* Check who is calling */
1928  if (PreviousMode != KernelMode)
1929  {
1930  static const UNICODE_STRING Win32kName =
1931  RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
1932 
1933  /* Make sure we can load drivers */
1935  {
1936  /* FIXME: We can't, fail */
1938  }
1939 
1940  _SEH2_TRY
1941  {
1942  /* Probe and copy the unicode string */
1943  ProbeForRead(Buffer, sizeof(ImageName), 1);
1945 
1946  /* Probe the string buffer */
1947  ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
1948 
1949  /* Check if we have the correct name (nothing else is allowed!) */
1950  if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
1951  {
1953  }
1954  }
1956  {
1958  }
1959  _SEH2_END;
1960 
1961  /* Recursively call the function, so that we are from kernel mode */
1963  (PVOID)&Win32kName,
1964  sizeof(Win32kName));
1965  }
1966 
1967  /* Load the image */
1969  NULL,
1970  NULL,
1971  0,
1972  (PVOID)&ModuleObject,
1973  &ImageBase);
1974 
1975  if (!NT_SUCCESS(Status)) return Status;
1976 
1977  /* Get the headers */
1978  NtHeader = RtlImageNtHeader(ImageBase);
1979  if (!NtHeader)
1980  {
1981  /* Fail */
1982  MmUnloadSystemImage(ModuleObject);
1984  }
1985 
1986  /* Get the entrypoint */
1987  EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1988  EntryPoint += (ULONG_PTR)ImageBase;
1989  DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1990 
1991  /* Create a dummy device */
1992  RtlZeroMemory(&Win32k, sizeof(Win32k));
1994  Win32k.DriverStart = ImageBase;
1995 
1996  /* Call it */
1997  Status = (DriverInit)(&Win32k, NULL);
1999 
2000  /* Unload if we failed */
2001  if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
2002  return Status;
2003 }
2004 
2005 /* Class 39 - Priority Separation */
2007 {
2008  /* Check if the size is correct */
2009  if (Size != sizeof(ULONG))
2010  {
2012  }
2013 
2014  /* We need the TCB privilege */
2016  {
2018  }
2019 
2020  /* Modify the quantum table */
2022 
2023  return STATUS_SUCCESS;
2024 }
2025 
2026 /* Class 40 */
2027 QSI_DEF(SystemVerifierAddDriverInformation)
2028 {
2029  /* FIXME */
2030  DPRINT1("NtQuerySystemInformation - SystemVerifierAddDriverInformation not implemented\n");
2031  return STATUS_NOT_IMPLEMENTED;
2032 }
2033 
2034 /* Class 41 */
2035 QSI_DEF(SystemVerifierRemoveDriverInformation)
2036 {
2037  /* FIXME */
2038  DPRINT1("NtQuerySystemInformation - SystemVerifierRemoveDriverInformation not implemented\n");
2039  return STATUS_NOT_IMPLEMENTED;
2040 }
2041 
2042 /* Class 42 - Power Information */
2043 QSI_DEF(SystemProcessorIdleInformation)
2044 {
2045  *ReqSize = sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors;
2046 
2048  {
2050  }
2051 
2052  /* FIXME */
2053  DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
2054  return STATUS_NOT_IMPLEMENTED;
2055 }
2056 
2057 /* Class 43 */
2058 QSI_DEF(SystemLegacyDriverInformation)
2059 {
2060  /* FIXME */
2061  DPRINT1("NtQuerySystemInformation - SystemLegacyDriverInformation not implemented\n");
2062  return STATUS_NOT_IMPLEMENTED;
2063 }
2064 
2065 /* Class 44 - Current Time Zone Information */
2067 {
2068  *ReqSize = sizeof(RTL_TIME_ZONE_INFORMATION);
2069 
2070  if (sizeof(RTL_TIME_ZONE_INFORMATION) != Size)
2071  {
2073  }
2074 
2075  /* Copy the time zone information struct */
2076  memcpy(Buffer,
2077  &ExpTimeZoneInfo,
2078  sizeof(RTL_TIME_ZONE_INFORMATION));
2079 
2080  return STATUS_SUCCESS;
2081 }
2082 
2084 {
2085  /* Check user buffer's size */
2086  if (Size < sizeof(RTL_TIME_ZONE_INFORMATION))
2087  {
2089  }
2090 
2092 }
2093 
2094 static
2095 VOID
2097  PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
2098  PULONG RemainingPointer,
2099  PLIST_ENTRY ListHead,
2100  BOOLEAN ListUsesMisses)
2101 
2102 {
2105  PLIST_ENTRY ListEntry;
2106  ULONG Remaining;
2107 
2108  /* Get info pointer and remaining count of free array element */
2109  Info = *InfoPointer;
2110  Remaining = *RemainingPointer;
2111 
2112  /* Loop as long as we have lookaside lists and free array elements */
2113  for (ListEntry = ListHead->Flink;
2114  (ListEntry != ListHead) && (Remaining > 0);
2115  ListEntry = ListEntry->Flink, Remaining--)
2116  {
2117  LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
2118 
2119  /* Fill the next array element */
2120  Info->CurrentDepth = LookasideList->Depth;
2121  Info->MaximumDepth = LookasideList->MaximumDepth;
2122  Info->TotalAllocates = LookasideList->TotalAllocates;
2123  Info->TotalFrees = LookasideList->TotalFrees;
2124  Info->Type = LookasideList->Type;
2125  Info->Tag = LookasideList->Tag;
2126  Info->Size = LookasideList->Size;
2127 
2128  /* Check how the lists track misses/hits */
2129  if (ListUsesMisses)
2130  {
2131  /* Copy misses */
2132  Info->AllocateMisses = LookasideList->AllocateMisses;
2133  Info->FreeMisses = LookasideList->FreeMisses;
2134  }
2135  else
2136  {
2137  /* Calculate misses */
2138  Info->AllocateMisses = LookasideList->TotalAllocates
2139  - LookasideList->AllocateHits;
2140  Info->FreeMisses = LookasideList->TotalFrees
2141  - LookasideList->FreeHits;
2142  }
2143  }
2144 
2145  /* Return the updated pointer and remaining count */
2146  *InfoPointer = Info;
2147  *RemainingPointer = Remaining;
2148 }
2149 
2150 /* Class 45 - Lookaside Information */
2152 {
2155  PMDL Mdl;
2156  ULONG MaxCount, Remaining;
2157  KIRQL OldIrql;
2158  NTSTATUS Status;
2159 
2160  /* First we need to lock down the memory, since we are going to access it
2161  at high IRQL */
2164  Size,
2165  PreviousMode,
2166  IoWriteAccess,
2167  (PVOID*)&Info,
2168  &Mdl);
2169  if (!NT_SUCCESS(Status))
2170  {
2171  DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
2172  return Status;
2173  }
2174 
2175  /* Calculate how many items we can store */
2176  Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2177  if (Remaining == 0)
2178  {
2179  goto Leave;
2180  }
2181 
2182  /* Copy info from pool lookaside lists */
2184  &Remaining,
2186  FALSE);
2187  if (Remaining == 0)
2188  {
2189  goto Leave;
2190  }
2191 
2192  /* Copy info from system lookaside lists */
2194  &Remaining,
2196  TRUE);
2197  if (Remaining == 0)
2198  {
2199  goto Leave;
2200  }
2201 
2202  /* Acquire spinlock for ExpNonPagedLookasideListHead */
2204 
2205  /* Copy info from non-paged lookaside lists */
2207  &Remaining,
2209  TRUE);
2210 
2211  /* Release spinlock for ExpNonPagedLookasideListHead */
2213 
2214  if (Remaining == 0)
2215  {
2216  goto Leave;
2217  }
2218 
2219  /* Acquire spinlock for ExpPagedLookasideListHead */
2221 
2222  /* Copy info from paged lookaside lists */
2224  &Remaining,
2226  TRUE);
2227 
2228  /* Release spinlock for ExpPagedLookasideListHead */
2230 
2231 Leave:
2232 
2233  /* Release the locked user buffer */
2235 
2236  /* Return the size of the actually written data */
2237  *ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2238  return STATUS_SUCCESS;
2239 }
2240 
2241 /* Class 46 - Set time slip event */
2243 {
2244  /* FIXME */
2245  DPRINT1("NtSetSystemInformation - SystemTimeSlipNotification not implemented\n");
2246  return STATUS_NOT_IMPLEMENTED;
2247 }
2248 
2249 NTSTATUS
2250 NTAPI
2252 
2253 NTSTATUS
2254 NTAPI
2256 
2257 /* Class 47 - Create a new session (TSE) */
2259 {
2260  ULONG SessionId;
2262  NTSTATUS Status;
2263 
2264  if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2265 
2266  if (PreviousMode != KernelMode)
2267  {
2269  {
2271  }
2272 
2274  }
2275 
2278 
2279  return Status;
2280 }
2281 
2282 /* Class 48 - Delete an existing session (TSE) */
2284 {
2285  ULONG SessionId;
2287 
2288  if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2289 
2290  if (PreviousMode != KernelMode)
2291  {
2293  {
2295  }
2296  }
2297 
2298  SessionId = *(PULONG)Buffer;
2299 
2300  return MmSessionDelete(SessionId);
2301 }
2302 
2303 /* Class 49 - UNKNOWN */
2305 {
2306  /* FIXME */
2307  DPRINT1("NtQuerySystemInformation - SystemSessionInformation not implemented\n");
2308  return STATUS_NOT_IMPLEMENTED;
2309 }
2310 
2311 /* Class 50 - System range start address */
2313 {
2314  /* Check user buffer's size */
2315  if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
2316 
2318 
2319  if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
2320 
2321  return STATUS_SUCCESS;
2322 }
2323 
2324 /* Class 51 - Driver verifier information */
2326 {
2327  /* FIXME */
2328  DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
2329  return STATUS_NOT_IMPLEMENTED;
2330 }
2331 
2333 {
2334  /* FIXME */
2335  DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
2336  return STATUS_NOT_IMPLEMENTED;
2337 }
2338 
2339 /* Class 52 */
2340 SSI_DEF(SystemVerifierThunkExtend)
2341 {
2342  /* FIXME */
2343  DPRINT1("NtSetSystemInformation - SystemVerifierThunkExtend not implemented\n");
2344  return STATUS_NOT_IMPLEMENTED;
2345 }
2346 
2347 /* Class 53 - A session's processes */
2349 {
2350  /* FIXME */
2351  DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
2352  return STATUS_NOT_IMPLEMENTED;
2353 }
2354 
2355 /* Class 54 - Load & map in system space */
2357 {
2358  /* FIXME */
2359  DPRINT1("NtSetSystemInformation - SystemLoadGdiDriverInSystemSpaceInformation not implemented\n");
2360  return STATUS_NOT_IMPLEMENTED;
2361 }
2362 
2363 /* Class 55 - NUMA processor information */
2365 {
2366  ULONG MaxEntries, Node;
2368 
2369  /* Validate input size */
2370  if (Size < sizeof(ULONG))
2371  {
2373  }
2374 
2375  /* Return highest node */
2376  NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2377 
2378  /* Compute how much entries we will be able to put in output structure */
2379  MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask)) / sizeof(ULONGLONG);
2380  /* Make sure we don't overflow KeNodeBlock */
2381  if (MaxEntries > KeNumberNodes)
2382  {
2383  MaxEntries = KeNumberNodes;
2384  }
2385 
2386  /* If we have entries to write, and room for it */
2387  if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) &&
2388  MaxEntries != 0)
2389  {
2390  /* Already set size we return */
2391  *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) +
2392  MaxEntries * sizeof(ULONGLONG);
2393 
2394  /* For each node, return processor mask */
2395  for (Node = 0; Node < MaxEntries; ++Node)
2396  {
2398  }
2399  }
2400  else
2401  {
2402  /* We only returned highest node number */
2403  *ReqSize = sizeof(ULONG);
2404  }
2405 
2406  return STATUS_SUCCESS;
2407 }
2408 
2409 /* Class 56 - Prefetcher information */
2411 {
2412  /* FIXME */
2413  DPRINT1("NtQuerySystemInformation - SystemPrefetcherInformation not implemented\n");
2414  return STATUS_NOT_IMPLEMENTED;
2415 }
2416 
2417 /* Class 57 - Extended process information */
2419 {
2420  /* FIXME */
2421  DPRINT1("NtQuerySystemInformation - SystemExtendedProcessInformation not implemented\n");
2422  return STATUS_NOT_IMPLEMENTED;
2423 }
2424 
2425 /* Class 58 - Recommended shared data alignment */
2427 {
2428  /* FIXME */
2429  DPRINT1("NtQuerySystemInformation - SystemRecommendedSharedDataAlignment not implemented\n");
2430  return STATUS_NOT_IMPLEMENTED;
2431 }
2432 
2433 /* Class 60 - NUMA memory information */
2435 {
2436  ULONG MaxEntries, Node;
2438 
2439  /* Validate input size */
2440  if (Size < sizeof(ULONG))
2441  {
2443  }
2444 
2445  /* Return highest node */
2446  NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2447 
2448  /* Compute how much entries we will be able to put in output structure */
2449  MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory)) / sizeof(ULONGLONG);
2450  /* Make sure we don't overflow KeNodeBlock */
2451  if (MaxEntries > KeNumberNodes)
2452  {
2453  MaxEntries = KeNumberNodes;
2454  }
2455 
2456  /* If we have entries to write, and room for it */
2457  if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) &&
2458  MaxEntries != 0)
2459  {
2460  /* Already set size we return */
2461  *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) +
2462  MaxEntries * sizeof(ULONGLONG);
2463 
2464  /* If we have a single entry (us), directly return MM information */
2465  if (MaxEntries == 1)
2466  {
2467  NumaInformation->AvailableMemory[0] = MmAvailablePages << PAGE_SHIFT;
2468  }
2469  else
2470  {
2471  /* Otherwise, for each node, return available bytes */
2472  for (Node = 0; Node < MaxEntries; ++Node)
2473  {
2474  NumaInformation->AvailableMemory[Node] = (KeNodeBlock[Node]->FreeCount[0] + KeNodeBlock[Node]->FreeCount[1]) << PAGE_SHIFT;
2475  }
2476  }
2477  }
2478  else
2479  {
2480  /* We only returned highest node number */
2481  *ReqSize = sizeof(ULONG);
2482  }
2483 
2484  return STATUS_SUCCESS;
2485 }
2486 
2487 /* Class 64 - Extended handle information */
2489 {
2491  PLIST_ENTRY NextTableEntry;
2493  PHANDLE_TABLE_ENTRY HandleTableEntry;
2494  EXHANDLE Handle;
2495  ULONG Index = 0;
2496  NTSTATUS Status;
2497  PMDL Mdl;
2498  PAGED_CODE();
2499 
2500  DPRINT("NtQuerySystemInformation - SystemExtendedHandleInformation\n");
2501 
2502  /* Set initial required buffer size */
2504 
2505  /* Check user's buffer size */
2506  if (Size < *ReqSize)
2507  {
2509  }
2510 
2511  /* We need to lock down the memory */
2513  Size,
2515  IoWriteAccess,
2517  &Mdl);
2518  if (!NT_SUCCESS(Status))
2519  {
2520  DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
2521  return Status;
2522  }
2523 
2524  /* Reset of count of handles */
2525  HandleInformation->Count = 0;
2526 
2527  /* Enter a critical region */
2529 
2530  /* Acquire the handle table lock */
2532 
2533  /* Enumerate all system handles */
2534  for (NextTableEntry = HandleTableListHead.Flink;
2535  NextTableEntry != &HandleTableListHead;
2536  NextTableEntry = NextTableEntry->Flink)
2537  {
2538  /* Get current handle table */
2539  HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
2540 
2541  /* Set the initial value and loop the entries */
2542  Handle.Value = 0;
2543  while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
2544  {
2545  /* Validate the entry */
2546  if ((HandleTableEntry->Object) &&
2547  (HandleTableEntry->NextFreeTableEntry != -2))
2548  {
2549  /* Increase of count of handles */
2550  ++HandleInformation->Count;
2551 
2552  /* Lock the entry */
2553  if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
2554  {
2555  /* Increase required buffer size */
2556  *ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX);
2557 
2558  /* Check user's buffer size */
2559  if (*ReqSize > Size)
2560  {
2562  }
2563  else
2564  {
2565  POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
2566 
2567  /* Filling handle information */
2568  HandleInformation->Handle[Index].UniqueProcessId =
2569  (USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
2570 
2571  HandleInformation->Handle[Index].CreatorBackTraceIndex = 0;
2572 
2573 #if 0 /* FIXME!!! Type field currupted */
2574  HandleInformation->Handles[Index].ObjectTypeIndex =
2575  (UCHAR) ObjectHeader->Type->Index;
2576 #else
2577  HandleInformation->Handle[Index].ObjectTypeIndex = 0;
2578 #endif
2579 
2580  HandleInformation->Handle[Index].HandleAttributes =
2581  HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
2582 
2583  HandleInformation->Handle[Index].HandleValue =
2584  (USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
2585 
2586  HandleInformation->Handle[Index].Object = &ObjectHeader->Body;
2587 
2588  HandleInformation->Handle[Index].GrantedAccess =
2589  HandleTableEntry->GrantedAccess;
2590 
2591  HandleInformation->Handle[Index].Reserved = 0;
2592 
2593  ++Index;
2594  }
2595 
2596  /* Unlock it */
2597  ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
2598  }
2599  }
2600 
2601  /* Go to the next entry */
2602  Handle.Value += sizeof(HANDLE);
2603  }
2604  }
2605 
2606  /* Release the lock */
2608 
2609  /* Leave the critical region */
2611 
2612  /* Release the locked user buffer */
2614 
2615  return Status;
2616 }
2617 
2618 /* Class 70 - System object security mode information */
2620 {
2621  PULONG ObjectSecurityInfo = (PULONG)Buffer;
2622 
2623  /* Validate input size */
2624  if (Size != sizeof(ULONG))
2625  {
2627  }
2628 
2629  *ObjectSecurityInfo = ObpObjectSecurityMode;
2630 
2631  return STATUS_SUCCESS;
2632 }
2633 
2634 /* Class 73 - Logical processor information */
2636 {
2637  LONG i;
2638  PKPRCB Prcb;
2639  KAFFINITY CurrentProc;
2641  ULONG DataSize = 0, ProcessorFlags;
2643 
2644  /* First, browse active processors, thanks to the map */
2645  i = 0;
2646  CurrentInfo = Buffer;
2647  CurrentProc = KeActiveProcessors;
2648  do
2649  {
2650  /* If current processor is active and is main in case of HT/MC, return it */
2651  Prcb = KiProcessorBlock[i];
2652  if ((CurrentProc & 1) &&
2653  Prcb == Prcb->MultiThreadSetMaster)
2654  {
2655  /* Assume processor can do HT or multicore */
2656  ProcessorFlags = 1;
2657 
2658  /* If set is the same for PRCB and multithread, then
2659  * actually, the processor is single core
2660  */
2661  if (Prcb->SetMember == Prcb->MultiThreadProcessorSet)
2662  {
2663  ProcessorFlags = 0;
2664  }
2665 
2666  /* Check we have enough room to return */
2668  if (DataSize > Size)
2669  {
2671  }
2672  else
2673  {
2674  /* Zero output and return */
2676  CurrentInfo->ProcessorMask = Prcb->MultiThreadProcessorSet;
2677 
2678  /* Processor core needs 1 if HT/MC is supported */
2679  CurrentInfo->Relationship = RelationProcessorCore;
2680  CurrentInfo->ProcessorCore.Flags = ProcessorFlags;
2681  ++CurrentInfo;
2682  }
2683  }
2684 
2685  /* Move to the next proc */
2686  CurrentProc >>= 1;
2687  ++i;
2688  /* Loop while there's someone in the bitmask */
2689  } while (CurrentProc != 0);
2690 
2691  /* Now, return the NUMA nodes */
2692  for (i = 0; i < KeNumberNodes; ++i)
2693  {
2694  /* Check we have enough room to return */
2696  if (DataSize > Size)
2697  {
2699  }
2700  else
2701  {
2702  /* Zero output and return */
2704  CurrentInfo->ProcessorMask = KeActiveProcessors;
2705 
2706  /* NUMA node needs its ID */
2707  CurrentInfo->Relationship = RelationNumaNode;
2708  CurrentInfo->NumaNode.NodeNumber = i;
2709  ++CurrentInfo;
2710  }
2711  }
2712 
2713  *ReqSize = DataSize;
2714 
2715  return Status;
2716 }
2717 
2718 /* Class 76 - System firmware table information */
2720 {
2723  ULONG InputBufSize;
2724  ULONG DataSize = 0;
2725  ULONG TableCount = 0;
2726 
2727  DPRINT("NtQuerySystemInformation - SystemFirmwareTableInformation\n");
2728 
2729  /* Set initial required buffer size */
2730  *ReqSize = FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer);
2731 
2732  /* Check user's buffer size */
2733  if (Size < *ReqSize)
2734  {
2736  }
2737 
2738  InputBufSize = SysFirmwareInfo->TableBufferLength;
2739  switch (SysFirmwareInfo->ProviderSignature)
2740  {
2741  /*
2742  * ExpFirmwareTableResource and ExpFirmwareTableProviderListHead
2743  * variables should be used there somehow...
2744  */
2745  case SIG_ACPI:
2746  {
2747  /* FIXME: Not implemented yet */
2748  DPRINT1("ACPI provider not implemented\n");
2750  break;
2751  }
2752  case SIG_FIRM:
2753  {
2754  /* FIXME: Not implemented yet */
2755  DPRINT1("FIRM provider not implemented\n");
2757  break;
2758  }
2759  case SIG_RSMB:
2760  {
2762  if (DataSize > 0)
2763  {
2764  TableCount = 1;
2765  if (SysFirmwareInfo->Action == SystemFirmwareTable_Enumerate)
2766  {
2767  DataSize = TableCount * sizeof(ULONG);
2768  if (DataSize <= InputBufSize)
2769  {
2770  *(ULONG *)SysFirmwareInfo->TableBuffer = 0;
2771  }
2772  }
2773  else if (SysFirmwareInfo->Action == SystemFirmwareTable_Get
2774  && DataSize <= InputBufSize)
2775  {
2776  Status = ExpGetRawSMBiosTable(SysFirmwareInfo->TableBuffer, &DataSize, InputBufSize);
2777  }
2778  SysFirmwareInfo->TableBufferLength = DataSize;
2779  }
2780  break;
2781  }
2782  default:
2783  {
2784  DPRINT1("SystemFirmwareTableInformation: Unsupported provider (0x%x)\n",
2785  SysFirmwareInfo->ProviderSignature);
2787  }
2788  }
2789 
2790  if (NT_SUCCESS(Status))
2791  {
2792  switch (SysFirmwareInfo->Action)
2793  {
2796  {
2797  if (SysFirmwareInfo->TableBufferLength > InputBufSize)
2798  {
2800  }
2801  break;
2802  }
2803  default:
2804  {
2805  DPRINT1("SystemFirmwareTableInformation: Unsupported action (0x%x)\n",
2806  SysFirmwareInfo->Action);
2808  }
2809  }
2810  }
2811  else
2812  {
2813  SysFirmwareInfo->TableBufferLength = 0;
2814  }
2815  return Status;
2816 }
2817 
2818 /* Query/Set Calls Table */
2819 typedef
2820 struct _QSSI_CALLS
2821 {
2824 } QSSI_CALLS;
2825 
2826 // QS Query & Set
2827 // QX Query
2828 // XS Set
2829 // XX unknown behaviour
2830 //
2831 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
2832 #define SI_QX(n) {QSI_USE(n),NULL}
2833 #define SI_XS(n) {NULL,SSI_USE(n)}
2834 #define SI_XX(n) {NULL,NULL}
2835 
2836 static
2837 QSSI_CALLS
2839 {
2850  SI_QX(SystemCallTimeInformation), /* should be SI_XX */
2853  SI_QX(SystemStackTraceInformation), /* should be SI_XX */
2854  SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
2855  SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
2860  SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
2865  SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
2869  SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
2870  SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
2871  SI_QX(SystemPerformanceTraceInformation), /* it should be SI_XX */
2880  SI_QX(SystemVerifierAddDriverInformation), /* it should be SI_XX */
2881  SI_QX(SystemVerifierRemoveDriverInformation), /* it should be SI_XX */
2882  SI_QX(SystemProcessorIdleInformation), /* it should be SI_XX */
2883  SI_QX(SystemLegacyDriverInformation), /* it should be SI_XX */
2884  SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
2889  SI_QX(SystemSessionInformation), /* it should be SI_XX */
2892  SI_XS(SystemVerifierThunkExtend),
2901  SI_XX(SystemProcessorPowerInformation), /* FIXME: not implemented */
2902  SI_XX(SystemEmulationBasicInformation), /* FIXME: not implemented */
2903  SI_XX(SystemEmulationProcessorInformation), /* FIXME: not implemented */
2905  SI_XX(SystemLostDelayedWriteInformation), /* FIXME: not implemented */
2906  SI_XX(SystemBigPoolInformation), /* FIXME: not implemented */
2907  SI_XX(SystemSessionPoolTagInformation), /* FIXME: not implemented */
2908  SI_XX(SystemSessionMappedViewInformation), /* FIXME: not implemented */
2909  SI_XX(SystemHotpatchInformation), /* FIXME: not implemented */
2911  SI_XX(SystemWatchdogTimerHandler), /* FIXME: not implemented */
2912  SI_XX(SystemWatchdogTimerInformation), /* FIXME: not implemented */
2914  SI_XX(SystemWow64SharedInformation), /* FIXME: not implemented */
2915  SI_XX(SystemRegisterFirmwareTableInformationHandler), /* FIXME: not implemented */
2917 };
2918 
2920 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
2921 #define MAX_SYSTEM_INFO_CLASS RTL_NUMBER_OF(CallQS)
2922 
2923 /*
2924  * @implemented
2925  */
2927 NTSTATUS
2928 NTAPI
2930  _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
2931  _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation,
2932  _In_ ULONG SystemInformationLength,
2934 {
2936  ULONG CapturedResultLength = 0;
2939 
2940  PAGED_CODE();
2941 
2943 
2944  _SEH2_TRY
2945  {
2946 #if (NTDDI_VERSION >= NTDDI_VISTA)
2947  /*
2948  * Check whether the request is valid.
2949  */
2950  if (SystemInformationClass < MIN_SYSTEM_INFO_CLASS ||
2951  SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2952  {
2954  }
2955 #endif
2956 
2957  if (PreviousMode != KernelMode)
2958  {
2959  /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
2960  if (SystemInformationClass == SystemKernelDebuggerInformation)
2962 
2963  ProbeForWrite(SystemInformation, SystemInformationLength, Alignment);
2964  if (ReturnLength != NULL)
2966  }
2967 
2968  if (ReturnLength)
2969  *ReturnLength = 0;
2970 
2971 #if (NTDDI_VERSION < NTDDI_VISTA)
2972  /*
2973  * Check whether the request is valid.
2974  */
2975  if (SystemInformationClass < MIN_SYSTEM_INFO_CLASS ||
2976  SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2977  {
2979  }
2980 #endif
2981 
2982  if (CallQS[SystemInformationClass].Query != NULL)
2983  {
2984  /* Hand the request to a subhandler */
2985  Status = CallQS[SystemInformationClass].Query(SystemInformation,
2986  SystemInformationLength,
2987  &CapturedResultLength);
2988 
2989  /* Save the result length to the caller */
2990  if (ReturnLength)
2991  *ReturnLength = CapturedResultLength;
2992  }
2993  }
2995  {
2997  }
2998  _SEH2_END;
2999 
3000  return Status;
3001 }
3002 
3004 NTSTATUS
3005 NTAPI
3007  _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
3008  _In_reads_bytes_(SystemInformationLength) PVOID SystemInformation,
3009  _In_ ULONG SystemInformationLength)
3010 {
3013 
3014  PAGED_CODE();
3015 
3017 
3018  _SEH2_TRY
3019  {
3020  /*
3021  * If called from user mode, check possible unsafe arguments.
3022  */
3023  if (PreviousMode != KernelMode)
3024  {
3025  ProbeForRead(SystemInformation, SystemInformationLength, sizeof(ULONG));
3026  }
3027 
3028  /*
3029  * Check whether the request is valid.
3030  */
3031  if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
3032  (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
3033  {
3034  if (CallQS[SystemInformationClass].Set != NULL)
3035  {
3036  /* Hand the request to a subhandler */
3037  Status = CallQS[SystemInformationClass].Set(SystemInformation,
3038  SystemInformationLength);
3039  }
3040  }
3041  }
3043  {
3045  }
3046  _SEH2_END;
3047 
3048  return Status;
3049 }
3050 
3051 ULONG
3052 NTAPI
3054 {
3055  /* Just use Ke */
3056  return KeGetCurrentProcessorNumber();
3057 }
3058 
3059 #undef ExGetPreviousMode
3061 NTAPI
3063 {
3064  /* Just use Ke */
3065  return KeGetPreviousMode();
3066 }
static __inline NTSTATUS ProbeAndCaptureUnicodeString(OUT PUNICODE_STRING Dest, IN KPROCESSOR_MODE CurrentMode, IN const UNICODE_STRING *UnsafeSrc)
Definition: probe.h:142
#define ProbeForWriteUlong(Ptr)
Definition: probe.h:36
enum _SYSTEM_INFORMATION_CLASS SYSTEM_INFORMATION_CLASS
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
_SEH2_TRY
Definition: create.c:4226
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
ULONG CcLazyWriteIos
Definition: lazywrite.c:21
const LUID SeSystemEnvironmentPrivilege
Definition: priv.c:41
signed char * PCHAR
Definition: retypes.h:7
ULONGLONG AvailableMemory[MAXIMUM_NUMA_NODES]
Definition: extypes.h:1401
ULONG KeMaximumIncrement
Definition: clock.c:20
NTSTATUS NTAPI MmSessionCreate(OUT PULONG SessionId)
Definition: session.c:827
#define QSI_DEF(n)
Definition: sysinfo.c:596
IN CINT OUT PVOID IN ULONG OUT PULONG ReturnLength
Definition: dumpinfo.c:39
NTSTATUS NTAPI ExpQueryModuleInformation(IN PLIST_ENTRY KernelModeList, IN PLIST_ENTRY UserModeList, OUT PRTL_PROCESS_MODULES Modules, IN ULONG Length, OUT PULONG ReturnLength)
Definition: sysinfo.c:91
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
#define IN
Definition: typedefs.h:39
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3767
NTSTATUS NTAPI SeLocateProcessImageName(_In_ PEPROCESS Process, _Out_ PUNICODE_STRING *ProcessImageName)
Finds the process image name of a specific process.
Definition: audit.c:199
PHANDLE_TABLE_ENTRY NTAPI ExpLookupHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN EXHANDLE Handle)
Definition: handle.c:43
#define MM_VIRTMEM_GRANULARITY
Definition: mm.h:102
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
ERESOURCE ExpFirmwareTableResource
Definition: sysinfo.c:30
struct _SYSTEM_REGISTRY_QUOTA_INFORMATION SYSTEM_REGISTRY_QUOTA_INFORMATION
LOGICAL_PROCESSOR_RELATIONSHIP Relationship
Definition: ketypes.h:99
LIST_ENTRY ThreadListEntry
Definition: pstypes.h:1158
#define TYPE_ALIGNMENT(t)
Definition: ntbasedef.h:117
const LUID SeSystemtimePrivilege
Definition: priv.c:31
MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM]
Definition: balance.c:30
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
ULONG Index
Definition: obtypes.h:385
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define ROUND_UP(n, align)
Definition: eventvwr.h:30
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
ULONG InterruptTime
Definition: ketypes.h:741
LARGE_INTEGER IoWriteTransferCount
Definition: iomgr.c:42
struct _PROCESSOR_POWER_INFORMATION PROCESSOR_POWER_INFORMATION
LONG IoWriteOperationCount
Definition: ketypes.h:666
LIST_ENTRY ExPoolLookasideListHead
Definition: lookas.c:22
BOOLEAN NTAPI ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
Definition: sysinfo.c:363
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define _Out_
Definition: ms_sal.h:345
Definition: arc.h:32
struct _SYSTEM_NUMA_INFORMATION * PSYSTEM_NUMA_INFORMATION
const LUID SeDebugPrivilege
Definition: priv.c:39
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID)
Definition: iorsrce.c:830
ULONG_PTR ObAttributes
Definition: extypes.h:600
KDPC_DATA DpcData[2]
Definition: ketypes.h:681
#define SI_XS(n)
Definition: sysinfo.c:2833
#define TRUE
Definition: types.h:120
NTSTATUS NTAPI NtSetSystemEnvironmentValueEx(IN PUNICODE_STRING VariableName, IN LPGUID VendorGuid, IN PVOID Value, IN OUT PULONG ReturnLength, IN OUT PULONG Attributes)
Definition: sysinfo.c:579
LARGE_INTEGER IoReadTransferCount
Definition: iomgr.c:40
#define MC_USER
Definition: mm.h:114
uint16_t * PWSTR
Definition: typedefs.h:56
ULONG CcDataFlushes
Definition: copy.c:44
struct _SYSTEM_QUERY_TIME_ADJUST_INFORMATION * PSYSTEM_QUERY_TIME_ADJUST_INFORMATION
unsigned char * PUCHAR
Definition: retypes.h:3
ACPI_SIZE Length
Definition: actypes.h:1044
char CHAR
Definition: xmlstorage.h:175
LARGE_INTEGER CreateTime
Definition: pstypes.h:1104
static VOID ExpCopyLookasideInformation(PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer, PULONG RemainingPointer, PLIST_ENTRY ListHead, BOOLEAN ListUsesMisses)
Definition: sysinfo.c:2096
ULONG SessionId
Definition: dllmain.c:28
#define SI_QS(n)
Definition: sysinfo.c:2831
#define KeGetPreviousMode()
Definition: ketypes.h:1108
LONG NTSTATUS
Definition: precomp.h:26
PVOID DriverStart
Definition: iotypes.h:2279
KTHREAD Tcb
Definition: pstypes.h:1103
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1080
ULONG NTAPI KeQueryTimeIncrement(VOID)
Definition: clock.c:153
#define SIG_RSMB
Definition: sysinfo.c:24
SCHAR Priority
Definition: ketypes.h:1722
LARGE_INTEGER IoWriteTransferCount
Definition: ketypes.h:669
VOID NTAPI KeAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL OldIrql)
Definition: spinlock.c:50
FAST_MUTEX ExpEnvironmentLock
Definition: sysinfo.c:29
ULONG CcLazyWritePages
Definition: lazywrite.c:20
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
PFN_NUMBER MmLowestPhysicalPage
Definition: meminit.c:30
ULONG KeFeatureBits
Definition: krnlinit.c:22
struct _ThreadInfo ThreadInfo
static XMS_HANDLE HandleTable[XMS_MAX_HANDLES]
Definition: himem.c:83
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1435
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:3062
ULONG ARC_STATUS
Definition: arc.h:4
ULONG KiAdjustDpcThreshold
Definition: dpc.c:21
NTSTATUS NTAPI NtEnumerateSystemEnvironmentValuesEx(IN ULONG InformationClass, IN PVOID Buffer, IN ULONG BufferLength)
Definition: sysinfo.c:557
VOID NTAPI ExUnlockUserBuffer(PMDL Mdl)
Definition: sysinfo.c:194
#define KD_DEBUGGER_NOT_PRESENT
Definition: kdfuncs.h:133
struct _SYSTEM_PERFORMANCE_INFORMATION * PSYSTEM_PERFORMANCE_INFORMATION
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char * ModuleName
Definition: acpixf.h:1274
VOID NTAPI ExGetCurrentProcessorCounts(PULONG ThreadKernelTime, PULONG TotalCpuTime, PULONG ProcessorNumber)
Definition: sysinfo.c:345
ULONG_PTR FreeCount[2]
Definition: ketypes.h:836
NTSTATUS NTAPI ExGetPoolTagInfo(IN PSYSTEM_POOLTAG_INFORMATION SystemInformation, IN ULONG SystemInformationLength, IN OUT PULONG ReturnLength OPTIONAL)
Definition: expool.c:1353
uint16_t * PWCHAR
Definition: typedefs.h:56
ARC_STATUS NTAPI HalGetEnvironmentVariable(IN PCH Name, IN USHORT ValueLength, IN PCH Value)
Definition: rtc.c:70
_SEH2_END
Definition: create.c:4400
LARGE_INTEGER IoWriteTransferCount
Definition: memtest.h:13
if(dx==0 &&dy==0)
Definition: linetemp.h:174
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
BOOLEAN NTAPI ExVerifySuite(SUITE_TYPE SuiteType)
Definition: sysinfo.c:377
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
LARGE_INTEGER CreateTime
Definition: extypes.h:891
struct _SYSTEM_PROCESSOR_INFORMATION SYSTEM_PROCESSOR_INFORMATION
ULONG DpcTime
Definition: ketypes.h:740
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
VOID NTAPI ExUnlockHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:923
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
HANDLE UniqueProcessId
Definition: pstypes.h:1267
ULONG IoWriteOperationCount
Definition: iomgr.c:41
static BOOL Set
Definition: pageheap.c:10
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
NTSTATUS NTAPI ExLockUserBuffer(PVOID BaseAddress, ULONG Length, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation, PVOID *MappedSystemVa, PMDL *OutMdl)
Definition: sysinfo.c:202
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define MAX_ENVVAL_SIZE
Definition: sysinfo.c:20
BOOLEAN KiTimeAdjustmentEnabled
Definition: time.c:19
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
PKSTART_ROUTINE StartAddress
Definition: pstypes.h:1155
ULONG IoReadOperationCount
Definition: iomgr.c:39
uint32_t ULONG_PTR
Definition: typedefs.h:65
struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE GENERAL_LOOKASIDE
ERESOURCE PsLoadedModuleResource
Definition: sysldr.c:37
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
ULONG NTAPI NtGetCurrentProcessorNumber(VOID)
Definition: sysinfo.c:3053
BOOLEAN NTAPI ExAcquireResourceExclusiveLite(IN PERESOURCE Resource, IN BOOLEAN Wait)
Definition: resource.c:770
LARGE_INTEGER KeBootTime
Definition: clock.c:17
FORCEINLINE ULONG KeGetCurrentProcessorNumber(VOID)
Definition: ke.h:337
struct _SYSTEM_PROCESSOR_INFORMATION * PSYSTEM_PROCESSOR_INFORMATION
UCHAR KIRQL
Definition: env_spec_w32.h:591
PEPROCESS PsIdleProcess
Definition: psmgr.c:51
UNICODE_STRING PageFileName
Definition: extypes.h:1067
return STATUS_NOT_IMPLEMENTED
LARGE_INTEGER CurrentTime
Definition: extypes.h:850
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI MmSessionDelete(IN ULONG SessionId)
Definition: session.c:887
struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
struct _SYSTEM_REGISTRY_QUOTA_INFORMATION * PSYSTEM_REGISTRY_QUOTA_INFORMATION
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
static QSSI_CALLS CallQS[]
Definition: sysinfo.c:2838
#define FALSE
Definition: types.h:117
#define ANSI_NULL
SIZE_T CurrentSizeIncludingTransitionInPages
Definition: extypes.h:1119
long LONG
Definition: pedump.c:60
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
ULONG KeAlignmentFixupCount
Definition: ketypes.h:801
union node Node
Definition: types.h:1255
struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE * PGENERAL_LOOKASIDE
LARGE_INTEGER ExpTimeZoneBias
Definition: time.c:23
ULONG NTAPI ObGetProcessHandleCount(IN PEPROCESS Process)
Definition: obhandle.c:56
_In_ PEPROCESS _In_ KPROCESSOR_MODE AccessMode
Definition: mmfuncs.h:395
LARGE_INTEGER IdleProcessTime
Definition: memtest.h:11
NTSTATUS NTAPI IoWMIQueryAllData(IN PVOID DataBlockObject, IN OUT ULONG *InOutBufferSize, OUT PVOID OutBuffer)
Definition: wmi.c:169
CHAR * PCH
Definition: ntbasedef.h:391
struct _SYSTEM_FLAGS_INFORMATION SYSTEM_FLAGS_INFORMATION
Definition: extypes.h:595
struct _KTHREAD * CurrentThread
Definition: ketypes.h:571
struct _RTL_TIME_ZONE_INFORMATION RTL_TIME_ZONE_INFORMATION
LONG IoReadOperationCount
Definition: ketypes.h:665
unsigned char BOOLEAN
ULONG CcMapDataWait
Definition: pin.c:28
_In_ ULONG _Out_writes_bytes_opt_ InformationLength PAUX_MODULE_EXTENDED_INFO ModuleInfo
Definition: aux_klib.h:65
SIZE_T MmPeakCommitment
Definition: freelist.c:35
#define ObpGetHandleObject(x)
Definition: ob.h:91
const LUID SeLoadDriverPrivilege
Definition: priv.c:29
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
#define SIG_ACPI
Definition: sysinfo.c:22
PEPROCESS TheIdleProcess
Definition: kdpacket.c:30
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define _In_
Definition: ms_sal.h:308
struct _KPRCB * MultiThreadSetMaster
Definition: ketypes.h:758
struct _SYSTEM_FLAGS_INFORMATION * PSYSTEM_FLAGS_INFORMATION
ULONG KeTimeAdjustment
Definition: time.c:18
ULONG KiIdealDpcRate
Definition: dpc.c:22
VOID NTAPI PsChangeQuantumTable(IN BOOLEAN Immediate, IN ULONG PrioritySeparation)
Definition: process.c:235
Definition: bufpool.h:45
ULONG KernelTime
Definition: ketypes.h:738
#define SystemPerformanceInformation
Definition: memtest.h:87
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
void * PVOID
Definition: retypes.h:9
SIZE_T MmTotalCommittedPages
Definition: freelist.c:30
ULONG ExpTimeZoneId
Definition: time.c:25
ULONG DpcCount
Definition: ketypes.h:800
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
ULONG InterruptCount
Definition: ketypes.h:737
UCHAR WaitReason
Definition: ketypes.h:1904
CHAR BasePriority
Definition: ketypes.h:1857
struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION::@3885::@3887 NumaNode
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:406
NTSTATUS NTAPI MmUnloadSystemImage(IN PVOID ImageHandle)
Definition: sysldr.c:911
struct _SYSTEM_SET_TIME_ADJUST_INFORMATION * PSYSTEM_SET_TIME_ADJUST_INFORMATION
Status
Definition: gdiplustypes.h:24
#define SIG_FIRM
Definition: sysinfo.c:23
FAST_MUTEX
Definition: extypes.h:17
NTSTATUS NTAPI ExpGetRawSMBiosTable(_Out_opt_ PVOID Buffer, _Out_ ULONG *OutSize, _In_ ULONG BufferSize)
Definition: sysinfo.c:250
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
static __inline VOID ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString, IN KPROCESSOR_MODE CurrentMode)
Definition: probe.h:239
USHORT KeProcessorArchitecture
Definition: krnlinit.c:19
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
USHORT KeProcessorRevision
Definition: krnlinit.c:21
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID * BaseAddress
Definition: mmfuncs.h:404
LIST_ENTRY ExpNonPagedLookasideListHead
Definition: lookas.c:17
struct _SYSTEM_QUERY_TIME_ADJUST_INFORMATION SYSTEM_QUERY_TIME_ADJUST_INFORMATION
const GUID MSSmBios_RawSMBiosTables_GUID
Definition: hwhacks.c:20
ULONG CcDataPages
Definition: copy.c:43
ULONG KernelTime
Definition: ketypes.h:1927
struct _SYSTEM_THREAD_INFORMATION * PSYSTEM_THREAD_INFORMATION
struct _SYSTEM_PAGEFILE_INFORMATION SYSTEM_PAGEFILE_INFORMATION
#define STATUS_INVALID_IMAGE_FORMAT
Definition: ntstatus.h:359
#define __kernel_entry
Definition: specstrings.h:355
#define ASSERT(a)
Definition: mode.c:44
ULONG ObpObjectSecurityMode
Definition: obinit.c:56
#define PROCESSOR_FEATURE_MAX
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION * PSYSTEM_KERNEL_DEBUGGER_INFORMATION
#define SSI_DEF(n)
Definition: sysinfo.c:600
LIST_ENTRY HandleTableListHead
Definition: handle.c:18
struct _SYSTEM_CONTEXT_SWITCH_INFORMATION * PSYSTEM_CONTEXT_SWITCH_INFORMATION
FP_OP Operation
Definition: fpcontrol.c:150
_In_ WDFCOLLECTION _In_ ULONG Index
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define TAG_MDL
Definition: tag.h:86
uint64_t ULONGLONG
Definition: typedefs.h:67
NTSTATUS NTAPI NtSetSystemEnvironmentValue(IN PUNICODE_STRING VariableName, IN PUNICODE_STRING Value)
Definition: sysinfo.c:487
ULONG CcPinReadNoWait
Definition: pin.c:31
CLIENT_ID Cid
Definition: pstypes.h:1128
LIST_ENTRY PsLoadedModuleList
Definition: sysldr.c:34
struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION SYSTEM_LOGICAL_PROCESSOR_INFORMATION
struct _SYSTEM_PROCESS_INFORMATION SYSTEM_PROCESS_INFORMATION
ULONG GrantedAccess
Definition: extypes.h:606
#define ObDereferenceObject
Definition: obfuncs.h:203
PKNODE KeNodeBlock[1]
Definition: krnlinit.c:39
BOOLEAN NTAPI ExpLockHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:884
ULONG KiMinimumDpcRate
Definition: dpc.c:20
NTSYSAPI VOID NTAPI RtlFreeAnsiString(PANSI_STRING AnsiString)
PVOID HANDLE
Definition: typedefs.h:73
ULONG KeSystemCalls
Definition: ketypes.h:652
#define KD_DEBUGGER_ENABLED
Definition: kdfuncs.h:130
struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION SYSTEM_KERNEL_DEBUGGER_INFORMATION
_In_ ACCESS_MASK _In_opt_ POBJECT_TYPE _In_ KPROCESSOR_MODE _Out_ PVOID _Out_opt_ POBJECT_HANDLE_INFORMATION HandleInformation
Definition: obfuncs.h:40
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
struct _SYSTEM_FIRMWARE_TABLE_INFORMATION * PSYSTEM_FIRMWARE_TABLE_INFORMATION
BOOL Query(LPCTSTR *ServiceArgs, DWORD ArgCount, BOOL bExtended)
Definition: query.c:292
VOID FASTCALL ExReleaseResourceLite(IN PERESOURCE Resource)
Definition: resource.c:1817
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION * PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
struct _SYSTEM_FILECACHE_INFORMATION SYSTEM_FILECACHE_INFORMATION
FORCEINLINE NTSTATUS ExpConvertLdrModuleToRtlModule(IN ULONG ModuleCount, IN PLDR_DATA_TABLE_ENTRY LdrEntry, OUT PRTL_PROCESS_MODULE_INFORMATION ModuleInfo)
Definition: sysinfo.c:35
LARGE_INTEGER IoOtherTransferCount
Definition: ketypes.h:670
KSPIN_LOCK ExpPagedLookasideListLock
Definition: lookas.c:20
#define KeGetContextSwitches(Prcb)
Definition: ke.h:212
UNICODE_STRING ImageName
Definition: extypes.h:894
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
LIST_ENTRY MmLoadedUserImageList
Definition: sysldr.c:35
LARGE_INTEGER IoOtherTransferCount
Definition: iomgr.c:44
LONG IoOtherOperationCount
Definition: ketypes.h:667
ULONG CcMapDataNoWait
Definition: pin.c:29
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
struct _RTL_PROCESS_MODULE_INFORMATION RTL_PROCESS_MODULE_INFORMATION
NTSTATUS(* Set)(PVOID, ULONG)
Definition: sysinfo.c:2823
#define SharedUserData
unsigned char UCHAR
Definition: xmlstorage.h:181
Definition: ex.h:84
static const char * ImageName
Definition: image.c:34
DRIVER_INITIALIZE * PDRIVER_INITIALIZE
Definition: iotypes.h:2235
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define RtlImageDirectoryEntryToData
Definition: compat.h:668
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:792
#define NTSTATUS
Definition: precomp.h:20
C_ASSERT(SystemBasicInformation==0)
HANDLE InheritedFromUniqueProcessId
Definition: extypes.h:897
NTSYSAPI NTSTATUS NTAPI ZwSetSystemInformation(_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _In_reads_bytes_(SystemInformationLength) PVOID SystemInformation, _In_ ULONG SystemInformationLength)
KSPIN_LOCK ExpNonPagedLookasideListLock
Definition: lookas.c:18
#define KeEnterCriticalRegion()
Definition: ke_x.h:88
Definition: btrfs_drv.h:1876
NTSTATUS NTAPI NtQuerySystemEnvironmentValue(IN PUNICODE_STRING VariableName, OUT PWSTR ValueBuffer, IN ULONG ValueBufferLength, IN OUT PULONG ReturnLength OPTIONAL)
Definition: sysinfo.c:385
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION::@3885::@3886 ProcessorCore
PEPROCESS NTAPI PsGetNextProcess(IN PEPROCESS OldProcess OPTIONAL)
Definition: process.c:128
ULONG UserTime
Definition: ketypes.h:739
VOID NTAPI ExQueryPoolUsage(OUT PULONG PagedPoolPages, OUT PULONG NonPagedPoolPages, OUT PULONG PagedPoolAllocs, OUT PULONG PagedPoolFrees, OUT PULONG PagedPoolLookasideHits, OUT PULONG NonPagedPoolAllocs, OUT PULONG NonPagedPoolFrees, OUT PULONG NonPagedPoolLookasideHits)
Definition: expool.c:1765
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Definition: typedefs.h:119
#define SystemExtendServiceTableInformation
Definition: DriverTester.h:35
KPROCESS Pcb
Definition: pstypes.h:1262
struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
#define _Out_writes_bytes_to_opt_(size, count)
Definition: ms_sal.h:361
#define MIN_SYSTEM_INFO_CLASS
Definition: sysinfo.c:2920
ULONG CcPinMappedDataCount
Definition: pin.c:32
#define IMAGE_DIRECTORY_ENTRY_EXPORT
Definition: compat.h:151
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
KAFFINITY KeActiveProcessors
Definition: krnlinit.c:23
VOID NTAPI ExGetCurrentProcessorCpuUsage(PULONG CpuUsage)
Definition: sysinfo.c:324
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
UCHAR KeNumberNodes
Definition: krnlinit.c:40
const LUID SeTcbPrivilege
Definition: priv.c:26
LARGE_INTEGER IoReadTransferCount
Definition: ketypes.h:668
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
UINT64 SetMember
Definition: ketypes.h:583
LARGE_INTEGER IoReadTransferCount
Definition: memtest.h:12
struct _KTHREAD * IdleThread
Definition: ketypes.h:573
struct _SYSTEM_PROCESS_INFORMATION * PSYSTEM_PROCESS_INFORMATION
#define SystemLoadGdiDriverInformation
Definition: DriverTester.h:34
NTSTATUS NTAPI IoWMIOpenBlock(_In_ LPCGUID DataBlockGuid, _In_ ULONG DesiredAccess, _Out_ PVOID *DataBlockObject)
Definition: wmi.c:140
FORCEINLINE VOID ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1103
#define _SEH2_VOLATILE
Definition: pseh2_64.h:169
struct _SYSTEM_EXCEPTION_INFORMATION * PSYSTEM_EXCEPTION_INFORMATION
ULONG KiMaximumDpcQueueDepth
Definition: dpc.c:19
ARC_STATUS NTAPI HalSetEnvironmentVariable(IN PCH Name, IN PCH Value)
Definition: rtc.c:57
struct _FileName FileName
Definition: fatprocs.h:893
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
DRIVER_INFORMATION DriverInfo
Definition: main.c:59
#define KeLeaveCriticalRegion()
Definition: ke_x.h:119
LONG NTAPI ExSystemExceptionFilter(VOID)
Definition: harderr.c:349
KAFFINITY ActiveProcessorsAffinityMask
Definition: ntddk_ex.h:167
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
LARGE_INTEGER KernelTime
Definition: extypes.h:893
struct _SYSTEM_LOOKASIDE_INFORMATION SYSTEM_LOOKASIDE_INFORMATION
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:931
struct _SYSTEM_DEVICE_INFORMATION * PSYSTEM_DEVICE_INFORMATION
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSTATUS(* Query)(PVOID, ULONG, PULONG)
Definition: sysinfo.c:2822
enum _LOCK_OPERATION LOCK_OPERATION
RTL_TIME_ZONE_INFORMATION ExpTimeZoneInfo
Definition: time.c:21
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
CHAR FullPathName[AUX_KLIB_MODULE_PATH_LEN]
Definition: aux_klib.h:41
unsigned short USHORT
Definition: pedump.c:61
LARGE_INTEGER TimeZoneBias
Definition: extypes.h:851
#define SI_XX(n)
Definition: sysinfo.c:2834
UINT64 MultiThreadProcessorSet
Definition: ketypes.h:757
ULONG KeExceptionDispatchCount
Definition: ketypes.h:706
ULONG_PTR KAFFINITY
Definition: compat.h:85
ULONG FixedInstanceSize
Definition: wmistr.h:118
#define WMIGUID_QUERY
Definition: wmistr.h:159
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
PFN_COUNT MiUsedSwapPages
Definition: pagefile.c:52
ULONG NTAPI KeQueryRuntimeProcess(IN PKPROCESS Process, OUT PULONG UserTime)
Definition: procobj.c:860
PKPRCB KiProcessorBlock[]
Definition: krnlinit.c:32
struct _SYSTEM_PERFORMANCE_INFORMATION SYSTEM_PERFORMANCE_INFORMATION
ULONG CcPinReadWait
Definition: pin.c:30
#define FORCEINLINE
Definition: wdftypes.h:67
SYSTEM_FIRMWARE_TABLE_ACTION Action
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
NTSTATUS ExpSetTimeZoneInformation(PRTL_TIME_ZONE_INFORMATION TimeZoneInformation)
Definition: time.c:333
#define _Out_opt_
Definition: ms_sal.h:346
_In_ ULONG _Out_opt_ PULONG RequiredLength
Definition: wmifuncs.h:29
unsigned int * PULONG
Definition: retypes.h:1
struct _SYSTEM_BASIC_INFORMATION SYSTEM_BASIC_INFORMATION
struct _SYSTEM_INTERRUPT_INFORMATION * PSYSTEM_INTERRUPT_INFORMATION
#define NULL
Definition: types.h:112
PVOID MmHighestUserAddress
Definition: rtlcompat.c:29
LIST_ENTRY ExpFirmwareTableProviderListHead
Definition: sysinfo.c:31
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
LONG NextFreeTableEntry
Definition: extypes.h:612
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
ULONG KernelTime
Definition: ketypes.h:2042
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
enum _SUITE_TYPE SUITE_TYPE
ULONGLONG ActiveProcessorsAffinityMask[MAXIMUM_NUMA_NODES]
Definition: extypes.h:1400
LARGE_INTEGER IoOtherTransferCount
Definition: memtest.h:14
#define DPRINT1
Definition: precomp.h:8
#define RtlImageNtHeader
Definition: compat.h:665
ULONG UserTime
Definition: ketypes.h:1943
struct _SYSTEM_BASIC_INFORMATION * PSYSTEM_BASIC_INFORMATION
BOOLEAN NTAPI SeSinglePrivilegeCheck(_In_ LUID PrivilegeValue, _In_ KPROCESSOR_MODE PreviousMode)
Checks if a single privilege is present in the context of the calling thread.
Definition: priv.c:744
USHORT KeProcessorLevel
Definition: krnlinit.c:20
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:219
_In_ HANDLE Handle
Definition: extypes.h:390
#define OUT
Definition: typedefs.h:40
FORCEINLINE VOID ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1211
volatile UCHAR State
Definition: ketypes.h:1729
ULONG ERESOURCE
Definition: env_spec_w32.h:594
PFN_COUNT MiFreeSwapPages
Definition: pagefile.c:49
unsigned int ULONG
Definition: retypes.h:1
ULONG ContextSwitches
Definition: ketypes.h:1728
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNIMPLEMENTED
Definition: debug.h:115
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
LARGE_INTEGER UserTime
Definition: extypes.h:892
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:65
PVOID Object
Definition: extypes.h:599
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
ULONG WaitTime
Definition: ketypes.h:1815
struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO SYSTEM_HANDLE_TABLE_ENTRY_INFO
__kernel_entry NTSTATUS NTAPI NtSetSystemInformation(_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _In_reads_bytes_(SystemInformationLength) PVOID SystemInformation, _In_ ULONG SystemInformationLength)
Definition: sysinfo.c:3006
ULONG PagesUsed
Definition: mm.h:457
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
PFN_NUMBER MmHighestPhysicalPage
Definition: meminit.c:31
#define TAG_SEPA
Definition: tag.h:153
#define STATUS_SUCCESS
Definition: shellext.h:65
KAFFINITY ProcessorMask
Definition: ketypes.h:827
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
ULONG IoOtherOperationCount
Definition: iomgr.c:43
struct _QSSI_CALLS QSSI_CALLS
GLfloat GLfloat p
Definition: glext.h:8902
#define DPRINT
Definition: sndvol32.h:71
#define SI_QX(n)
Definition: sysinfo.c:2832
ULONG DpcRequestRate
Definition: ketypes.h:689
_In_ FILTER_INFORMATION_CLASS InformationClass
Definition: fltkernel.h:1713
POBJECT_TYPE Type
Definition: obtypes.h:493
#define OBJ_HANDLE_ATTRIBUTES
Definition: ob.h:52
ULONG NtGlobalFlag
Definition: init.c:54
#define MAX_SYSTEM_INFO_CLASS
Definition: sysinfo.c:2921
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define STATUS_ILLEGAL_FUNCTION
Definition: ntstatus.h:411
EX_PUSH_LOCK HandleTableListLock
Definition: handle.c:19
#define UInt32x32To64(a, b)
Definition: intsafe.h:252
NTSTATUS NTAPI NtQuerySystemEnvironmentValueEx(IN PUNICODE_STRING VariableName, IN LPGUID VendorGuid, IN PVOID Value, IN OUT PULONG ReturnLength, IN OUT PULONG Attributes)
Definition: sysinfo.c:567
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
struct _SYSTEM_DEVICE_INFORMATION SYSTEM_DEVICE_INFORMATION
#define MmSystemRangeStart
Definition: mm.h:32
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4751
struct _SYSTEM_DPC_BEHAVIOR_INFORMATION * PSYSTEM_DPC_BEHAVIOR_INFORMATION
LIST_ENTRY ExpPagedLookasideListHead
Definition: lookas.c:19
LIST_ENTRY ExSystemLookasideListHead
Definition: lookas.c:21
__kernel_entry NTSTATUS NTAPI NtQuerySystemInformation(_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation, _In_ ULONG SystemInformationLength, _Out_opt_ PULONG ReturnLength)
Definition: sysinfo.c:2929
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
LONGLONG QuadPart
Definition: typedefs.h:114
NTSTATUS NTAPI MmLoadSystemImage(IN PUNICODE_STRING FileName, IN PUNICODE_STRING NamePrefix OPTIONAL, IN PUNICODE_STRING LoadedName OPTIONAL, IN ULONG Flags, OUT PVOID *ModuleObject, OUT PVOID *ImageBaseAddress)
Definition: sysldr.c:2898
_Must_inspect_result_ _In_ LPCGUID _In_ ULONG _In_ FSRTL_ALLOCATE_ECP_FLAGS _In_opt_ PFSRTL_EXTRA_CREATE_PARAMETER_CLEANUP_CALLBACK _Inout_ PVOID LookasideList
Definition: fltkernel.h:2550
Definition: dlist.c:348
#define PAGED_CODE()
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
#define _In_reads_bytes_(size)
Definition: ms_sal.h:321
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68