ReactOS  0.4.12-dev-409-g9f418243
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,
54  ModuleInfo->FullPathName,
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 */
82  ModuleInfo->FullPathName[0] = ANSI_NULL;
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 {
196  MmUnlockPages(Mdl);
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 */
236  *MappedSystemVa = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
237  if (*MappedSystemVa == NULL)
238  {
239  ExUnlockUserBuffer(Mdl);
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  Spi->Reserved = 0;
662 
663  DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
664  Spi->ProcessorLevel, Spi->ProcessorRevision);
665 
666  return STATUS_SUCCESS;
667 }
668 
669 /* Class 2 - Performance Information */
671 {
672  LONG i;
673  ULONG IdleUser, IdleKernel;
674  PKPRCB Prcb;
677 
679 
680  *ReqSize = sizeof(SYSTEM_PERFORMANCE_INFORMATION);
681 
682  /* Check user buffer's size */
683  if (Size < sizeof(SYSTEM_PERFORMANCE_INFORMATION))
684  {
686  }
687 
689 
690  IdleKernel = KeQueryRuntimeProcess(&TheIdleProcess->Pcb, &IdleUser);
698  for (i = 0; i < KeNumberProcessors; i ++)
699  {
700  Prcb = KiProcessorBlock[i];
701  if (Prcb)
702  {
709  }
710  }
711 
713  /*
714  * Add up all the used "Committed" memory + pagefile.
715  * Not sure this is right. 8^\
716  */
721  /*
722  * Add up the full system total + pagefile.
723  * All this make Taskmgr happy but not sure it is the right numbers.
724  * This too, fixes some of GlobalMemoryStatusEx numbers.
725  */
727 
728  Spi->PeakCommitment = 0; /* FIXME */
729  Spi->PageFaultCount = 0; /* FIXME */
730  Spi->CopyOnWriteCount = 0; /* FIXME */
731  Spi->TransitionCount = 0; /* FIXME */
732  Spi->CacheTransitionCount = 0; /* FIXME */
733  Spi->DemandZeroCount = 0; /* FIXME */
734  Spi->PageReadCount = 0; /* FIXME */
735  Spi->PageReadIoCount = 0; /* FIXME */
736  Spi->CacheReadCount = 0; /* FIXME */
737  Spi->CacheIoCount = 0; /* FIXME */
738  Spi->DirtyPagesWriteCount = 0; /* FIXME */
739  Spi->DirtyWriteIoCount = 0; /* FIXME */
740  Spi->MappedPagesWriteCount = 0; /* FIXME */
741  Spi->MappedWriteIoCount = 0; /* FIXME */
742 
743  Spi->PagedPoolPages = 0;
744  Spi->NonPagedPoolPages = 0;
745  Spi->PagedPoolAllocs = 0;
746  Spi->PagedPoolFrees = 0;
747  Spi->PagedPoolLookasideHits = 0;
748  Spi->NonPagedPoolAllocs = 0;
749  Spi->NonPagedPoolFrees = 0;
750  Spi->NonPagedPoolLookasideHits = 0;
752  &Spi->NonPagedPoolPages,
753  &Spi->PagedPoolAllocs,
754  &Spi->PagedPoolFrees,
756  &Spi->NonPagedPoolAllocs,
757  &Spi->NonPagedPoolFrees,
759  Spi->FreeSystemPtes = 0; /* FIXME */
760 
761  Spi->ResidentSystemCodePage = 0; /* FIXME */
762 
763  Spi->TotalSystemDriverPages = 0; /* FIXME */
764  Spi->Spare3Count = 0; /* FIXME */
765 
767  Spi->ResidentPagedPoolPage = 0; /* FIXME */
768 
769  Spi->ResidentSystemDriverPage = 0; /* FIXME */
770  Spi->CcFastReadNoWait = 0; /* FIXME */
771  Spi->CcFastReadWait = 0; /* FIXME */
772  Spi->CcFastReadResourceMiss = 0; /* FIXME */
773  Spi->CcFastReadNotPossible = 0; /* FIXME */
774 
775  Spi->CcFastMdlReadNoWait = 0; /* FIXME */
776  Spi->CcFastMdlReadWait = 0; /* FIXME */
777  Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
778  Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
779 
782  Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
783  Spi->CcMapDataWaitMiss = 0; /* FIXME */
784 
788  Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
789  Spi->CcPinReadWaitMiss = 0; /* FIXME */
790  Spi->CcCopyReadNoWait = 0; /* FIXME */
791  Spi->CcCopyReadWait = 0; /* FIXME */
792  Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
793  Spi->CcCopyReadWaitMiss = 0; /* FIXME */
794 
795  Spi->CcMdlReadNoWait = 0; /* FIXME */
796  Spi->CcMdlReadWait = 0; /* FIXME */
797  Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
798  Spi->CcMdlReadWaitMiss = 0; /* FIXME */
799  Spi->CcReadAheadIos = 0; /* FIXME */
803  Spi->CcDataPages = CcDataPages;
804 
805  Spi->ContextSwitches = 0;
806  Spi->FirstLevelTbFills = 0;
807  Spi->SecondLevelTbFills = 0;
808  Spi->SystemCalls = 0;
809  for (i = 0; i < KeNumberProcessors; i ++)
810  {
811  Prcb = KiProcessorBlock[i];
812  if (Prcb)
813  {
815  Spi->FirstLevelTbFills += Prcb->KeFirstLevelTbFills;
816  Spi->SecondLevelTbFills += Prcb->KeSecondLevelTbFills;
817  Spi->SystemCalls += Prcb->KeSystemCalls;
818  }
819  }
820 
821  return STATUS_SUCCESS;
822 }
823 
824 /* Class 3 - Time Of Day Information */
826 {
828  LARGE_INTEGER CurrentTime;
829 
830  /* Set amount of written information to 0 */
831  *ReqSize = 0;
832 
833  /* Check user buffer's size */
834  if (Size > sizeof(SYSTEM_TIMEOFDAY_INFORMATION))
835  {
837  }
838 
839  /* Get current time */
840  KeQuerySystemTime(&CurrentTime);
841 
842  /* Zero local buffer */
844 
845  /* Fill local time structure */
846  Sti.BootTime= KeBootTime;
847  Sti.CurrentTime = CurrentTime;
850  Sti.Reserved = 0;
851 
852  /* Copy as much as requested by caller */
853  RtlCopyMemory(Buffer, &Sti, Size);
854 
855  /* Set amount of information we copied */
856  *ReqSize = Size;
857 
858  return STATUS_SUCCESS;
859 }
860 
861 /* Class 4 - Path Information */
863 {
864  /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
865  DPRINT1("NtQuerySystemInformation - SystemPathInformation not implemented\n");
866 
867  return STATUS_BREAKPOINT;
868 }
869 
870 /* Class 5 - Process Information */
872 {
873  PSYSTEM_PROCESS_INFORMATION SpiCurrent;
875  PEPROCESS Process = NULL, SystemProcess;
876  PETHREAD CurrentThread;
878  ULONG CurrentSize;
879  USHORT ImageNameMaximumLength; // image name length in bytes
880  USHORT ImageNameLength;
881  PLIST_ENTRY CurrentEntry;
882  ULONG TotalSize = 0, ThreadsCount;
883  ULONG TotalUser, TotalKernel;
884  PUCHAR Current;
886  PUNICODE_STRING TempProcessImageName;
887  _SEH2_VOLATILE PUNICODE_STRING ProcessImageName = NULL;
888  PWCHAR szSrc;
889  BOOLEAN Overflow = FALSE;
890 
891  _SEH2_TRY
892  {
893  /* scan the process list */
894 
897 
898  *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
899 
900  /* Check for overflow */
901  if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
902  {
903  Overflow = TRUE;
904  }
905 
906  /* Zero user's buffer */
907  if (!Overflow) RtlZeroMemory(Spi, Size);
908 
909  SystemProcess = PsIdleProcess;
910  Process = SystemProcess;
911  Current = (PUCHAR) Spi;
912 
913  do
914  {
915  SpiCurrent = (PSYSTEM_PROCESS_INFORMATION) Current;
916 
917  /* Lock the Process */
919  ExAcquirePushLockShared(&Process->ProcessLock);
920 
921  if ((Process->ProcessExiting) &&
922  (Process->Pcb.Header.SignalState) &&
923  !(Process->ActiveThreads) &&
924  (IsListEmpty(&Process->Pcb.ThreadListHead)))
925  {
926  DPRINT1("Process %p (%s:%p) is a zombie\n",
927  Process, Process->ImageFileName, Process->UniqueProcessId);
928  CurrentSize = 0;
929  ImageNameMaximumLength = 0;
930 
931  /* Unlock the Process */
932  ExReleasePushLockShared(&Process->ProcessLock);
934  goto Skip;
935  }
936 
937  ThreadsCount = 0;
938  CurrentEntry = Process->Pcb.ThreadListHead.Flink;
939  while (CurrentEntry != &Process->Pcb.ThreadListHead)
940  {
941  ThreadsCount++;
942  CurrentEntry = CurrentEntry->Flink;
943  }
944 
945  // size of the structure for every process
946  CurrentSize = sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION) * ThreadsCount;
947  ImageNameLength = 0;
948  Status = SeLocateProcessImageName(Process, &TempProcessImageName);
949  ProcessImageName = TempProcessImageName;
950  szSrc = NULL;
951  if (NT_SUCCESS(Status) && (ProcessImageName->Length > 0))
952  {
953  szSrc = (PWCHAR)((PCHAR)ProcessImageName->Buffer + ProcessImageName->Length);
954  /* Loop the file name*/
955  while (szSrc > ProcessImageName->Buffer)
956  {
957  /* Make sure this isn't a backslash */
958  if (*--szSrc == OBJ_NAME_PATH_SEPARATOR)
959  {
960  szSrc++;
961  break;
962  }
963  else
964  {
965  ImageNameLength += sizeof(WCHAR);
966  }
967  }
968  }
969  if (!ImageNameLength && Process != PsIdleProcess)
970  {
971  ImageNameLength = (USHORT)strlen(Process->ImageFileName) * sizeof(WCHAR);
972  }
973 
974  /* Round up the image name length as NT does */
975  if (ImageNameLength > 0)
976  ImageNameMaximumLength = ROUND_UP(ImageNameLength + sizeof(WCHAR), 8);
977  else
978  ImageNameMaximumLength = 0;
979 
980  TotalSize += CurrentSize + ImageNameMaximumLength;
981 
982  /* Check for overflow */
983  if (TotalSize > Size)
984  {
985  Overflow = TRUE;
986  }
987 
988  /* Fill system information */
989  if (!Overflow)
990  {
991  SpiCurrent->NextEntryOffset = CurrentSize + ImageNameMaximumLength; // relative offset to the beginning of the next structure
992  SpiCurrent->NumberOfThreads = ThreadsCount;
993  SpiCurrent->CreateTime = Process->CreateTime;
994  SpiCurrent->ImageName.Length = ImageNameLength;
995  SpiCurrent->ImageName.MaximumLength = ImageNameMaximumLength;
996  SpiCurrent->ImageName.Buffer = (void*)(Current + CurrentSize);
997 
998  /* Copy name to the end of the struct */
999  if(Process != PsIdleProcess)
1000  {
1001  if (szSrc)
1002  {
1003  RtlCopyMemory(SpiCurrent->ImageName.Buffer, szSrc, SpiCurrent->ImageName.Length);
1004  }
1005  else
1006  {
1007  RtlInitAnsiString(&ImageName, Process->ImageFileName);
1009  }
1010  }
1011  else
1012  {
1013  RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
1014  }
1015 
1016  SpiCurrent->BasePriority = Process->Pcb.BasePriority;
1017  SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
1018  SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
1020  SpiCurrent->PeakVirtualSize = Process->PeakVirtualSize;
1021  SpiCurrent->VirtualSize = Process->VirtualSize;
1022  SpiCurrent->PageFaultCount = Process->Vm.PageFaultCount;
1023  SpiCurrent->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
1024  SpiCurrent->WorkingSetSize = Process->Vm.WorkingSetSize;
1025  SpiCurrent->QuotaPeakPagedPoolUsage = Process->QuotaPeak[0];
1026  SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[0];
1027  SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[1];
1028  SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[1];
1029  SpiCurrent->PagefileUsage = Process->QuotaUsage[2];
1030  SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[2];
1031  SpiCurrent->PrivatePageCount = Process->CommitCharge;
1032  ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCurrent + 1);
1033 
1034  CurrentEntry = Process->Pcb.ThreadListHead.Flink;
1035  while (CurrentEntry != &Process->Pcb.ThreadListHead)
1036  {
1037  CurrentThread = CONTAINING_RECORD(CurrentEntry, ETHREAD, Tcb.ThreadListEntry);
1038 
1039  ThreadInfo->KernelTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.KernelTime, KeMaximumIncrement);
1040  ThreadInfo->UserTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.UserTime, KeMaximumIncrement);
1041  ThreadInfo->CreateTime.QuadPart = CurrentThread->CreateTime.QuadPart;
1042  ThreadInfo->WaitTime = CurrentThread->Tcb.WaitTime;
1043  ThreadInfo->StartAddress = (PVOID) CurrentThread->StartAddress;
1044  ThreadInfo->ClientId = CurrentThread->Cid;
1045  ThreadInfo->Priority = CurrentThread->Tcb.Priority;
1046  ThreadInfo->BasePriority = CurrentThread->Tcb.BasePriority;
1047  ThreadInfo->ContextSwitches = CurrentThread->Tcb.ContextSwitches;
1048  ThreadInfo->ThreadState = CurrentThread->Tcb.State;
1049  ThreadInfo->WaitReason = CurrentThread->Tcb.WaitReason;
1050 
1051  ThreadInfo++;
1052  CurrentEntry = CurrentEntry->Flink;
1053  }
1054 
1055  /* Query total user/kernel times of a process */
1056  TotalKernel = KeQueryRuntimeProcess(&Process->Pcb, &TotalUser);
1057  SpiCurrent->UserTime.QuadPart = UInt32x32To64(TotalUser, KeMaximumIncrement);
1058  SpiCurrent->KernelTime.QuadPart = UInt32x32To64(TotalKernel, KeMaximumIncrement);
1059  }
1060 
1061  if (ProcessImageName)
1062  {
1063  /* Release the memory allocated by SeLocateProcessImageName */
1064  ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
1065  ProcessImageName = NULL;
1066  }
1067 
1068  /* Unlock the Process */
1069  ExReleasePushLockShared(&Process->ProcessLock);
1071 
1072  /* Handle idle process entry */
1073 Skip:
1074  if (Process == PsIdleProcess) Process = NULL;
1075 
1077  ThreadsCount = 0;
1078  if ((Process == SystemProcess) || (Process == NULL))
1079  {
1080  if (!Overflow)
1081  SpiCurrent->NextEntryOffset = 0;
1082  break;
1083  }
1084  else
1085  Current += CurrentSize + ImageNameMaximumLength;
1086  } while ((Process != SystemProcess) && (Process != NULL));
1087 
1088  if(Process != NULL)
1091  }
1093  {
1094  if(Process != NULL)
1096  if (ProcessImageName)
1097  {
1098  /* Release the memory allocated by SeLocateProcessImageName */
1099  ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
1100  }
1101 
1103  }
1104  _SEH2_END
1105 
1106  if (Overflow)
1108 
1109  *ReqSize = TotalSize;
1110  return Status;
1111 }
1112 
1113 /* Class 6 - Call Count Information */
1115 {
1116  /* FIXME */
1117  DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
1118  return STATUS_NOT_IMPLEMENTED;
1119 }
1120 
1121 /* Class 7 - Device Information */
1123 {
1126  PCONFIGURATION_INFORMATION ConfigInfo;
1127 
1128  *ReqSize = sizeof(SYSTEM_DEVICE_INFORMATION);
1129 
1130  /* Check user buffer's size */
1131  if (Size < sizeof(SYSTEM_DEVICE_INFORMATION))
1132  {
1134  }
1135 
1136  ConfigInfo = IoGetConfigurationInformation();
1137 
1138  Sdi->NumberOfDisks = ConfigInfo->DiskCount;
1139  Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
1140  Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
1141  Sdi->NumberOfTapes = ConfigInfo->TapeCount;
1142  Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
1143  Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
1144 
1145  return STATUS_SUCCESS;
1146 }
1147 
1148 /* Class 8 - Processor Performance Information */
1150 {
1153 
1154  LONG i;
1155  ULONG TotalTime;
1156  PKPRCB Prcb;
1157 
1159 
1160  /* Check user buffer's size */
1161  if (Size < *ReqSize)
1162  {
1164  }
1165 
1166  for (i = 0; i < KeNumberProcessors; i++)
1167  {
1168  /* Get the PRCB on this processor */
1169  Prcb = KiProcessorBlock[i];
1170 
1171  /* Calculate total user and kernel times */
1172  TotalTime = Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime;
1178  Spi->InterruptCount = Prcb->InterruptCount;
1179  Spi++;
1180  }
1181 
1182  return STATUS_SUCCESS;
1183 }
1184 
1185 /* Class 9 - Flags Information */
1187 {
1188 #if (NTDDI_VERSION >= NTDDI_VISTA)
1189  *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1190 #endif
1191 
1192  if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1193  {
1195  }
1196 
1198 #if (NTDDI_VERSION < NTDDI_VISTA)
1199  *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1200 #endif
1201 
1202  return STATUS_SUCCESS;
1203 }
1204 
1206 {
1207  if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1208  {
1210  }
1211 
1213  {
1214  return STATUS_ACCESS_DENIED;
1215  }
1216 
1218  return STATUS_SUCCESS;
1219 }
1220 
1221 /* Class 10 - Call Time Information */
1223 {
1224  /* FIXME */
1225  DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
1226  return STATUS_NOT_IMPLEMENTED;
1227 }
1228 
1229 /* Class 11 - Module Information */
1231 {
1232  NTSTATUS Status;
1233 
1234  /* Acquire system module list lock */
1237 
1238  /* Call the generic handler with the system module list */
1242  Size,
1243  ReqSize);
1244 
1245  /* Release list lock and return status */
1248  return Status;
1249 }
1250 
1251 /* Class 12 - Locks Information */
1253 {
1254  /* FIXME */
1255  DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
1256  return STATUS_NOT_IMPLEMENTED;
1257 }
1258 
1259 /* Class 13 - Stack Trace Information */
1261 {
1262  /* FIXME */
1263  DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
1264  return STATUS_NOT_IMPLEMENTED;
1265 }
1266 
1267 /* Class 14 - Paged Pool Information */
1269 {
1270  /* FIXME */
1271  DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
1272  return STATUS_NOT_IMPLEMENTED;
1273 }
1274 
1275 /* Class 15 - Non Paged Pool Information */
1277 {
1278  /* FIXME */
1279  DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
1280  return STATUS_NOT_IMPLEMENTED;
1281 }
1282 
1283 
1284 /* Class 16 - Handle Information */
1286 {
1288  PLIST_ENTRY NextTableEntry;
1290  PHANDLE_TABLE_ENTRY HandleTableEntry;
1291  EXHANDLE Handle;
1292  ULONG Index = 0;
1293  NTSTATUS Status;
1294  PMDL Mdl;
1295  PAGED_CODE();
1296 
1297  DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1298 
1299  /* Set initial required buffer size */
1300  *ReqSize = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handles);
1301 
1302  /* Check user's buffer size */
1303  if (Size < *ReqSize)
1304  {
1306  }
1307 
1308  /* We need to lock down the memory */
1310  Size,
1312  IoWriteAccess,
1314  &Mdl);
1315  if (!NT_SUCCESS(Status))
1316  {
1317  DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
1318  return Status;
1319  }
1320 
1321  /* Reset of count of handles */
1322  HandleInformation->NumberOfHandles = 0;
1323 
1324  /* Enter a critical region */
1326 
1327  /* Acquire the handle table lock */
1329 
1330  /* Enumerate all system handles */
1331  for (NextTableEntry = HandleTableListHead.Flink;
1332  NextTableEntry != &HandleTableListHead;
1333  NextTableEntry = NextTableEntry->Flink)
1334  {
1335  /* Get current handle table */
1336  HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
1337 
1338  /* Set the initial value and loop the entries */
1339  Handle.Value = 0;
1340  while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
1341  {
1342  /* Validate the entry */
1343  if ((HandleTableEntry->Object) &&
1344  (HandleTableEntry->NextFreeTableEntry != -2))
1345  {
1346  /* Increase of count of handles */
1347  ++HandleInformation->NumberOfHandles;
1348 
1349  /* Lock the entry */
1350  if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
1351  {
1352  /* Increase required buffer size */
1353  *ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO);
1354 
1355  /* Check user's buffer size */
1356  if (*ReqSize > Size)
1357  {
1359  }
1360  else
1361  {
1362  POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
1363 
1364  /* Filling handle information */
1365  HandleInformation->Handles[Index].UniqueProcessId =
1366  (USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
1367 
1368  HandleInformation->Handles[Index].CreatorBackTraceIndex = 0;
1369 
1370 #if 0 /* FIXME!!! Type field currupted */
1371  HandleInformation->Handles[Index].ObjectTypeIndex =
1372  (UCHAR) ObjectHeader->Type->Index;
1373 #else
1374  HandleInformation->Handles[Index].ObjectTypeIndex = 0;
1375 #endif
1376 
1377  HandleInformation->Handles[Index].HandleAttributes =
1378  HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
1379 
1380  HandleInformation->Handles[Index].HandleValue =
1381  (USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
1382 
1383  HandleInformation->Handles[Index].Object = &ObjectHeader->Body;
1384 
1385  HandleInformation->Handles[Index].GrantedAccess =
1386  HandleTableEntry->GrantedAccess;
1387 
1388  ++Index;
1389  }
1390 
1391  /* Unlock it */
1392  ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
1393  }
1394  }
1395 
1396  /* Go to the next entry */
1397  Handle.Value += sizeof(HANDLE);
1398  }
1399  }
1400 
1401  /* Release the lock */
1403 
1404  /* Leave the critical region */
1406 
1407  /* Release the locked user buffer */
1408  ExUnlockUserBuffer(Mdl);
1409 
1410  return Status;
1411 }
1412 
1413 /* Class 17 - Information */
1415 {
1416  /* FIXME */
1417  DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1418  return STATUS_NOT_IMPLEMENTED;
1419 }
1420 
1421 /* Class 18 - Information */
1423 {
1424  UNICODE_STRING FileName; /* FIXME */
1426 
1427  if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
1428  {
1429  * ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
1431  }
1432 
1433  RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1434 
1435  /* FIXME */
1436  Spfi->NextEntryOffset = 0;
1437 
1439  Spfi->TotalInUse = MiUsedSwapPages;
1440  Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1441  Spfi->PageFileName = FileName;
1442  return STATUS_SUCCESS;
1443 }
1444 
1445 /* Class 19 - Vdm Instemul Information */
1447 {
1448  /* FIXME */
1449  DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1450  return STATUS_NOT_IMPLEMENTED;
1451 }
1452 
1453 /* Class 20 - Vdm Bop Information */
1455 {
1456  /* FIXME */
1457  DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1458  return STATUS_NOT_IMPLEMENTED;
1459 }
1460 
1461 /* Class 21 - File Cache Information */
1463 {
1465 
1466  *ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
1467 
1468  if (Size < *ReqSize)
1469  {
1471  }
1472 
1474 
1475  /* Return the Byte size not the page size. */
1476  Sci->CurrentSize =
1478  Sci->PeakSize =
1480  /* Taskmgr multiplies this one by page size right away */
1482  MiMemoryConsumers[MC_CACHE].PagesUsed; /* FIXME: Should be */
1483  /* system working set and standby pages. */
1484  Sci->PageFaultCount = 0; /* FIXME */
1485  Sci->MinimumWorkingSet = 0; /* FIXME */
1486  Sci->MaximumWorkingSet = 0; /* FIXME */
1487 
1488  return STATUS_SUCCESS;
1489 }
1490 
1492 {
1493  if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1494  {
1496  }
1497  /* FIXME */
1498  DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1499  return STATUS_NOT_IMPLEMENTED;
1500 }
1501 
1502 /* Class 22 - Pool Tag Information */
1504 {
1506  return ExGetPoolTagInfo(Buffer, Size, ReqSize);
1507 }
1508 
1509 /* Class 23 - Interrupt Information for all processors */
1511 {
1512  PKPRCB Prcb;
1513  LONG i;
1514  ULONG ti;
1516 
1518  {
1520  }
1521 
1522  ti = KeQueryTimeIncrement();
1523 
1524  for (i = 0; i < KeNumberProcessors; i++)
1525  {
1526  Prcb = KiProcessorBlock[i];
1528  sii->DpcCount = Prcb->DpcData[0].DpcCount;
1529  sii->DpcRate = Prcb->DpcRequestRate;
1530  sii->TimeIncrement = ti;
1531  sii->DpcBypassCount = 0;
1532  sii->ApcBypassCount = 0;
1533  sii++;
1534  }
1535 
1536  return STATUS_SUCCESS;
1537 }
1538 
1539 /* Class 24 - DPC Behaviour Information */
1541 {
1543 
1544  if (Size < sizeof(SYSTEM_DPC_BEHAVIOR_INFORMATION))
1545  {
1547  }
1548 
1552  sdbi->IdealDpcRate = KiIdealDpcRate;
1553 
1554  return STATUS_SUCCESS;
1555 }
1556 
1558 {
1559  /* FIXME */
1560  DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1561  return STATUS_NOT_IMPLEMENTED;
1562 }
1563 
1564 /* Class 25 - Full Memory Information */
1566 {
1567  PULONG Spi = (PULONG) Buffer;
1568 
1570 
1571  *ReqSize = sizeof(ULONG);
1572 
1573  if (sizeof(ULONG) != Size)
1574  {
1576  }
1577 
1578  DPRINT("SystemFullMemoryInformation\n");
1579 
1581 
1582  DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
1586  MiUsedSwapPages);
1587 
1589 
1590  return STATUS_SUCCESS;
1591 }
1592 
1593 /* Class 26 - Load Image */
1595 {
1598  PVOID ImageBase;
1599  PVOID SectionPointer;
1600  ULONG_PTR EntryPoint;
1601  NTSTATUS Status;
1602  ULONG DirSize;
1603  PIMAGE_NT_HEADERS NtHeader;
1604 
1605  /* Validate size */
1606  if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1607  {
1608  /* Incorrect buffer length, fail */
1610  }
1611 
1612  /* Only kernel mode can call this function */
1614 
1615  /* Load the driver */
1616  ImageName = DriverInfo->DriverName;
1618  NULL,
1619  NULL,
1620  0,
1621  &SectionPointer,
1622  &ImageBase);
1623  if (!NT_SUCCESS(Status)) return Status;
1624 
1625  /* Return the export pointer */
1626  DriverInfo->ExportSectionPointer =
1627  RtlImageDirectoryEntryToData(ImageBase,
1628  TRUE,
1630  &DirSize);
1631 
1632  /* Get the entrypoint */
1633  NtHeader = RtlImageNtHeader(ImageBase);
1634  EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1635  EntryPoint += (ULONG_PTR)ImageBase;
1636 
1637  /* Save other data */
1638  DriverInfo->ImageAddress = ImageBase;
1639  DriverInfo->SectionPointer = SectionPointer;
1640  DriverInfo->EntryPoint = (PVOID)EntryPoint;
1641  DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1642 
1643  /* All is good */
1644  return STATUS_SUCCESS;
1645 }
1646 
1647 /* Class 27 - Unload Image */
1649 {
1650  PVOID *SectionPointer = Buffer;
1651 
1652  /* Validate size */
1653  if (Size != sizeof(PVOID))
1654  {
1655  /* Incorrect length, fail */
1657  }
1658 
1659  /* Only kernel mode can call this function */
1661 
1662  /* Unload the image */
1663  MmUnloadSystemImage(*SectionPointer);
1664  return STATUS_SUCCESS;
1665 }
1666 
1667 /* Class 28 - Time Adjustment Information */
1669 {
1672 
1673  /* Check if enough storage was provided */
1675  {
1676  * ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
1678  }
1679 
1680  /* Give time values to our caller */
1681  TimeInfo->TimeIncrement = KeMaximumIncrement;
1682  TimeInfo->TimeAdjustment = KeTimeAdjustment;
1683  TimeInfo->Enable = !KiTimeAdjustmentEnabled;
1684 
1685  return STATUS_SUCCESS;
1686 }
1687 
1689 {
1693 
1694  /* Check size of a buffer, it must match our expectations */
1697 
1698  /* Check who is calling */
1699  if (PreviousMode != KernelMode)
1700  {
1701  /* Check access rights */
1703  {
1705  }
1706  }
1707 
1708  /* FIXME: behaviour suggests the member be named 'Disable' */
1709  if (TimeInfo->Enable)
1710  {
1711  /* Disable time adjustment and set default value */
1714  }
1715  else
1716  {
1717  /* Check if a valid time adjustment value is given */
1718  if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
1719 
1720  /* Enable time adjustment and set the adjustment value */
1722  KeTimeAdjustment = TimeInfo->TimeAdjustment;
1723  }
1724 
1725  return STATUS_SUCCESS;
1726 }
1727 
1728 /* Class 29 - Summary Memory Information */
1730 {
1731  /* FIXME */
1732  DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1733  return STATUS_NOT_IMPLEMENTED;
1734 }
1735 
1736 /* Class 30 - Next Event Id Information */
1738 {
1739  /* FIXME */
1740  DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1741  return STATUS_NOT_IMPLEMENTED;
1742 }
1743 
1744 /* Class 31 */
1746 {
1747  /* FIXME */
1748  DPRINT1("NtQuerySystemInformation - SystemPerformanceTraceInformation not implemented\n");
1749  return STATUS_NOT_IMPLEMENTED;
1750 }
1751 
1752 /* Class 32 - Crash Dump Information */
1754 {
1755  /* FIXME */
1756  DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1757  return STATUS_NOT_IMPLEMENTED;
1758 }
1759 
1760 /* Class 33 - Exception Information */
1762 {
1763  PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
1765  PKPRCB Prcb;
1766  ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
1767  ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
1768  CHAR i;
1769 
1770  /* Check size of a buffer, it must match our expectations */
1771  if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
1773 
1774  /* Sum up exception count information from all processors */
1775  for (i = 0; i < KeNumberProcessors; i++)
1776  {
1777  Prcb = KiProcessorBlock[i];
1778  if (Prcb)
1779  {
1780  AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
1781  ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
1782 #ifndef _M_ARM
1783  FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
1784 #endif // _M_ARM
1785  }
1786  }
1787 
1788  /* Save information in user's buffer */
1789  ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
1790  ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
1791  ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
1792  ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
1793 
1794  return STATUS_SUCCESS;
1795 }
1796 
1797 /* Class 34 - Crash Dump State Information */
1799 {
1800  /* FIXME */
1801  DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1802  return STATUS_NOT_IMPLEMENTED;
1803 }
1804 
1805 /* Class 35 - Kernel Debugger Information */
1807 {
1809 
1810 #if (NTDDI_VERSION >= NTDDI_VISTA)
1811  *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1812 #endif
1813 
1815  {
1817  }
1818 
1821 
1822 #if (NTDDI_VERSION < NTDDI_VISTA)
1823  *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1824 #endif
1825 
1826  return STATUS_SUCCESS;
1827 }
1828 
1829 /* Class 36 - Context Switch Information */
1831 {
1832  PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
1834  ULONG ContextSwitches;
1835  PKPRCB Prcb;
1836  CHAR i;
1837 
1838  /* Check size of a buffer, it must match our expectations */
1839  if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
1841 
1842  /* Calculate total value of context switches across all processors */
1843  ContextSwitches = 0;
1844  for (i = 0; i < KeNumberProcessors; i ++)
1845  {
1846  Prcb = KiProcessorBlock[i];
1847  if (Prcb)
1848  {
1849  ContextSwitches += KeGetContextSwitches(Prcb);
1850  }
1851  }
1852 
1853  ContextSwitchInformation->ContextSwitches = ContextSwitches;
1854 
1855  /* FIXME */
1856  ContextSwitchInformation->FindAny = 0;
1857  ContextSwitchInformation->FindLast = 0;
1858  ContextSwitchInformation->FindIdeal = 0;
1859  ContextSwitchInformation->IdleAny = 0;
1860  ContextSwitchInformation->IdleCurrent = 0;
1861  ContextSwitchInformation->IdleLast = 0;
1862  ContextSwitchInformation->IdleIdeal = 0;
1863  ContextSwitchInformation->PreemptAny = 0;
1864  ContextSwitchInformation->PreemptCurrent = 0;
1865  ContextSwitchInformation->PreemptLast = 0;
1866  ContextSwitchInformation->SwitchToIdle = 0;
1867 
1868  return STATUS_SUCCESS;
1869 }
1870 
1871 /* Class 37 - Registry Quota Information */
1873 {
1875 
1876  *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1878  {
1880  }
1881 
1882  DPRINT1("Faking max registry size of 32 MB\n");
1883  srqi->RegistryQuotaAllowed = 0x2000000;
1884  srqi->RegistryQuotaUsed = 0x200000;
1885  srqi->PagedPoolSize = 0x200000;
1886 
1887  return STATUS_SUCCESS;
1888 }
1889 
1891 {
1892  /* FIXME */
1893  DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1894  return STATUS_NOT_IMPLEMENTED;
1895 }
1896 
1897 /* Class 38 - Load And Call Image */
1899 {
1902  PLDR_DATA_TABLE_ENTRY ModuleObject;
1903  NTSTATUS Status;
1904  PIMAGE_NT_HEADERS NtHeader;
1905  DRIVER_OBJECT Win32k;
1906  PDRIVER_INITIALIZE DriverInit;
1907  PVOID ImageBase;
1908  ULONG_PTR EntryPoint;
1909 
1910  /* Validate the size */
1911  if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1912 
1913  /* Check who is calling */
1914  if (PreviousMode != KernelMode)
1915  {
1916  static const UNICODE_STRING Win32kName =
1917  RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
1918 
1919  /* Make sure we can load drivers */
1921  {
1922  /* FIXME: We can't, fail */
1924  }
1925 
1926  _SEH2_TRY
1927  {
1928  /* Probe and copy the unicode string */
1929  ProbeForRead(Buffer, sizeof(ImageName), 1);
1931 
1932  /* Probe the string buffer */
1933  ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
1934 
1935  /* Check if we have the correct name (nothing else is allowed!) */
1936  if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
1937  {
1939  }
1940  }
1942  {
1944  }
1945  _SEH2_END;
1946 
1947  /* Recursively call the function, so that we are from kernel mode */
1949  (PVOID)&Win32kName,
1950  sizeof(Win32kName));
1951  }
1952 
1953  /* Load the image */
1955  NULL,
1956  NULL,
1957  0,
1958  (PVOID)&ModuleObject,
1959  &ImageBase);
1960 
1961  if (!NT_SUCCESS(Status)) return Status;
1962 
1963  /* Get the headers */
1964  NtHeader = RtlImageNtHeader(ImageBase);
1965  if (!NtHeader)
1966  {
1967  /* Fail */
1968  MmUnloadSystemImage(ModuleObject);
1970  }
1971 
1972  /* Get the entrypoint */
1973  EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1974  EntryPoint += (ULONG_PTR)ImageBase;
1975  DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1976 
1977  /* Create a dummy device */
1978  RtlZeroMemory(&Win32k, sizeof(Win32k));
1980  Win32k.DriverStart = ImageBase;
1981 
1982  /* Call it */
1983  Status = (DriverInit)(&Win32k, NULL);
1985 
1986  /* Unload if we failed */
1987  if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
1988  return Status;
1989 }
1990 
1991 /* Class 39 - Priority Separation */
1993 {
1994  /* Check if the size is correct */
1995  if (Size != sizeof(ULONG))
1996  {
1998  }
1999 
2000  /* We need the TCB privilege */
2002  {
2004  }
2005 
2006  /* Modify the quantum table */
2008 
2009  return STATUS_SUCCESS;
2010 }
2011 
2012 /* Class 40 */
2013 QSI_DEF(SystemVerifierAddDriverInformation)
2014 {
2015  /* FIXME */
2016  DPRINT1("NtQuerySystemInformation - SystemVerifierAddDriverInformation not implemented\n");
2017  return STATUS_NOT_IMPLEMENTED;
2018 }
2019 
2020 /* Class 41 */
2021 QSI_DEF(SystemVerifierRemoveDriverInformation)
2022 {
2023  /* FIXME */
2024  DPRINT1("NtQuerySystemInformation - SystemVerifierRemoveDriverInformation not implemented\n");
2025  return STATUS_NOT_IMPLEMENTED;
2026 }
2027 
2028 /* Class 42 - Power Information */
2029 QSI_DEF(SystemProcessorIdleInformation)
2030 {
2031  *ReqSize = sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors;
2032 
2034  {
2036  }
2037 
2038  /* FIXME */
2039  DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
2040  return STATUS_NOT_IMPLEMENTED;
2041 }
2042 
2043 /* Class 43 */
2044 QSI_DEF(SystemLegacyDriverInformation)
2045 {
2046  /* FIXME */
2047  DPRINT1("NtQuerySystemInformation - SystemLegacyDriverInformation not implemented\n");
2048  return STATUS_NOT_IMPLEMENTED;
2049 }
2050 
2051 /* Class 44 - Current Time Zone Information */
2053 {
2054  *ReqSize = sizeof(RTL_TIME_ZONE_INFORMATION);
2055 
2056  if (sizeof(RTL_TIME_ZONE_INFORMATION) != Size)
2057  {
2059  }
2060 
2061  /* Copy the time zone information struct */
2062  memcpy(Buffer,
2063  &ExpTimeZoneInfo,
2064  sizeof(RTL_TIME_ZONE_INFORMATION));
2065 
2066  return STATUS_SUCCESS;
2067 }
2068 
2069 
2071 {
2072  /* Check user buffer's size */
2073  if (Size < sizeof(RTL_TIME_ZONE_INFORMATION))
2074  {
2076  }
2077 
2079 }
2080 
2081 static
2082 VOID
2084  PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
2085  PULONG RemainingPointer,
2086  PLIST_ENTRY ListHead,
2087  BOOLEAN ListUsesMisses)
2088 
2089 {
2092  PLIST_ENTRY ListEntry;
2093  ULONG Remaining;
2094 
2095  /* Get info pointer and remaining count of free array element */
2096  Info = *InfoPointer;
2097  Remaining = *RemainingPointer;
2098 
2099  /* Loop as long as we have lookaside lists and free array elements */
2100  for (ListEntry = ListHead->Flink;
2101  (ListEntry != ListHead) && (Remaining > 0);
2102  ListEntry = ListEntry->Flink, Remaining--)
2103  {
2104  LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
2105 
2106  /* Fill the next array element */
2107  Info->CurrentDepth = LookasideList->Depth;
2108  Info->MaximumDepth = LookasideList->MaximumDepth;
2109  Info->TotalAllocates = LookasideList->TotalAllocates;
2110  Info->TotalFrees = LookasideList->TotalFrees;
2111  Info->Type = LookasideList->Type;
2112  Info->Tag = LookasideList->Tag;
2113  Info->Size = LookasideList->Size;
2114 
2115  /* Check how the lists track misses/hits */
2116  if (ListUsesMisses)
2117  {
2118  /* Copy misses */
2119  Info->AllocateMisses = LookasideList->AllocateMisses;
2120  Info->FreeMisses = LookasideList->FreeMisses;
2121  }
2122  else
2123  {
2124  /* Calculate misses */
2125  Info->AllocateMisses = LookasideList->TotalAllocates
2126  - LookasideList->AllocateHits;
2127  Info->FreeMisses = LookasideList->TotalFrees
2128  - LookasideList->FreeHits;
2129  }
2130  }
2131 
2132  /* Return the updated pointer and remaining count */
2133  *InfoPointer = Info;
2134  *RemainingPointer = Remaining;
2135 }
2136 
2137 /* Class 45 - Lookaside Information */
2139 {
2142  PMDL Mdl;
2143  ULONG MaxCount, Remaining;
2144  KIRQL OldIrql;
2145  NTSTATUS Status;
2146 
2147  /* First we need to lock down the memory, since we are going to access it
2148  at high IRQL */
2151  Size,
2152  PreviousMode,
2153  IoWriteAccess,
2154  (PVOID*)&Info,
2155  &Mdl);
2156  if (!NT_SUCCESS(Status))
2157  {
2158  DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
2159  return Status;
2160  }
2161 
2162  /* Calculate how many items we can store */
2163  Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2164  if (Remaining == 0)
2165  {
2166  goto Leave;
2167  }
2168 
2169  /* Copy info from pool lookaside lists */
2171  &Remaining,
2173  FALSE);
2174  if (Remaining == 0)
2175  {
2176  goto Leave;
2177  }
2178 
2179  /* Copy info from system lookaside lists */
2181  &Remaining,
2183  TRUE);
2184  if (Remaining == 0)
2185  {
2186  goto Leave;
2187  }
2188 
2189  /* Acquire spinlock for ExpNonPagedLookasideListHead */
2191 
2192  /* Copy info from non-paged lookaside lists */
2194  &Remaining,
2196  TRUE);
2197 
2198  /* Release spinlock for ExpNonPagedLookasideListHead */
2200 
2201  if (Remaining == 0)
2202  {
2203  goto Leave;
2204  }
2205 
2206  /* Acquire spinlock for ExpPagedLookasideListHead */
2208 
2209  /* Copy info from paged lookaside lists */
2211  &Remaining,
2213  TRUE);
2214 
2215  /* Release spinlock for ExpPagedLookasideListHead */
2217 
2218 Leave:
2219 
2220  /* Release the locked user buffer */
2221  ExUnlockUserBuffer(Mdl);
2222 
2223  /* Return the size of the actually written data */
2224  *ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2225  return STATUS_SUCCESS;
2226 }
2227 
2228 
2229 /* Class 46 - Set time slip event */
2231 {
2232  /* FIXME */
2233  DPRINT1("NtSetSystemInformation - SystemTimeSlipNotification not implemented\n");
2234  return STATUS_NOT_IMPLEMENTED;
2235 }
2236 
2237 NTSTATUS
2238 NTAPI
2240 
2241 NTSTATUS
2242 NTAPI
2244 
2245 /* Class 47 - Create a new session (TSE) */
2247 {
2248  ULONG SessionId;
2250  NTSTATUS Status;
2251 
2252  if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2253 
2254  if (PreviousMode != KernelMode)
2255  {
2257  {
2259  }
2260 
2262  }
2263 
2266 
2267  return Status;
2268 }
2269 
2270 
2271 /* Class 48 - Delete an existing session (TSE) */
2273 {
2274  ULONG SessionId;
2276 
2277  if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2278 
2279  if (PreviousMode != KernelMode)
2280  {
2282  {
2284  }
2285  }
2286 
2287  SessionId = *(PULONG)Buffer;
2288 
2289  return MmSessionDelete(SessionId);
2290 }
2291 
2292 
2293 /* Class 49 - UNKNOWN */
2295 {
2296  /* FIXME */
2297  DPRINT1("NtQuerySystemInformation - SystemSessionInformation not implemented\n");
2298  return STATUS_NOT_IMPLEMENTED;
2299 }
2300 
2301 
2302 /* Class 50 - System range start address */
2304 {
2305  /* Check user buffer's size */
2306  if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
2307 
2309 
2310  if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
2311 
2312  return STATUS_SUCCESS;
2313 }
2314 
2315 /* Class 51 - Driver verifier information */
2317 {
2318  /* FIXME */
2319  DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
2320  return STATUS_NOT_IMPLEMENTED;
2321 }
2322 
2323 
2325 {
2326  /* FIXME */
2327  DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
2328  return STATUS_NOT_IMPLEMENTED;
2329 }
2330 
2331 
2332 /* Class 52 */
2333 SSI_DEF(SystemVerifierThunkExtend)
2334 {
2335  /* FIXME */
2336  DPRINT1("NtSetSystemInformation - SystemVerifierThunkExtend not implemented\n");
2337  return STATUS_NOT_IMPLEMENTED;
2338 }
2339 
2340 
2341 /* Class 53 - A session's processes */
2343 {
2344  /* FIXME */
2345  DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
2346  return STATUS_NOT_IMPLEMENTED;
2347 }
2348 
2349 
2350 /* Class 54 - Load & map in system space */
2352 {
2353  /* FIXME */
2354  DPRINT1("NtSetSystemInformation - SystemLoadGdiDriverInSystemSpaceInformation not implemented\n");
2355  return STATUS_NOT_IMPLEMENTED;
2356 }
2357 
2358 
2359 /* Class 55 - NUMA processor information */
2361 {
2362  ULONG MaxEntries, Node;
2364 
2365  /* Validate input size */
2366  if (Size < sizeof(ULONG))
2367  {
2369  }
2370 
2371  /* Return highest node */
2372  NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2373 
2374  /* Compute how much entries we will be able to put in output structure */
2375  MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask)) / sizeof(ULONGLONG);
2376  /* Make sure we don't overflow KeNodeBlock */
2377  if (MaxEntries > KeNumberNodes)
2378  {
2379  MaxEntries = KeNumberNodes;
2380  }
2381 
2382  /* If we have entries to write, and room for it */
2383  if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) &&
2384  MaxEntries != 0)
2385  {
2386  /* Already set size we return */
2387  *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) +
2388  MaxEntries * sizeof(ULONGLONG);
2389 
2390  /* For each node, return processor mask */
2391  for (Node = 0; Node < MaxEntries; ++Node)
2392  {
2394  }
2395  }
2396  else
2397  {
2398  /* We only returned highest node number */
2399  *ReqSize = sizeof(ULONG);
2400  }
2401 
2402  return STATUS_SUCCESS;
2403 }
2404 
2405 
2406 /* Class 56 - Prefetcher information */
2408 {
2409  /* FIXME */
2410  DPRINT1("NtQuerySystemInformation - SystemPrefetcherInformation not implemented\n");
2411  return STATUS_NOT_IMPLEMENTED;
2412 }
2413 
2414 
2415 /* Class 57 - Extended process information */
2417 {
2418  /* FIXME */
2419  DPRINT1("NtQuerySystemInformation - SystemExtendedProcessInformation not implemented\n");
2420  return STATUS_NOT_IMPLEMENTED;
2421 }
2422 
2423 
2424 /* Class 58 - Recommended shared ata alignment */
2426 {
2427  /* FIXME */
2428  DPRINT1("NtQuerySystemInformation - SystemRecommendedSharedDataAlignment not implemented\n");
2429  return STATUS_NOT_IMPLEMENTED;
2430 }
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 */
2613  ExUnlockUserBuffer(Mdl);
2614 
2615  return Status;
2616 }
2617 
2618 /* Class 76 - System firmware table information */
2620 {
2623  ULONG InputBufSize;
2624  ULONG DataSize = 0;
2625  ULONG TableCount = 0;
2626 
2627  DPRINT("NtQuerySystemInformation - SystemFirmwareTableInformation\n");
2628 
2629  /* Set initial required buffer size */
2630  *ReqSize = FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer);
2631 
2632  /* Check user's buffer size */
2633  if (Size < *ReqSize)
2634  {
2636  }
2637 
2638  InputBufSize = SysFirmwareInfo->TableBufferLength;
2639  switch (SysFirmwareInfo->ProviderSignature)
2640  {
2641  /*
2642  * ExpFirmwareTableResource and ExpFirmwareTableProviderListHead
2643  * variables should be used there somehow...
2644  */
2645  case SIG_ACPI:
2646  {
2647  /* FIXME: Not implemented yet */
2648  DPRINT1("ACPI provider not implemented\n");
2650  break;
2651  }
2652  case SIG_FIRM:
2653  {
2654  /* FIXME: Not implemented yet */
2655  DPRINT1("FIRM provider not implemented\n");
2657  break;
2658  }
2659  case SIG_RSMB:
2660  {
2662  if (DataSize > 0)
2663  {
2664  TableCount = 1;
2665  if (SysFirmwareInfo->Action == SystemFirmwareTable_Enumerate)
2666  {
2667  DataSize = TableCount * sizeof(ULONG);
2668  if (DataSize <= InputBufSize)
2669  {
2670  *(ULONG *)SysFirmwareInfo->TableBuffer = 0;
2671  }
2672  }
2673  else if (SysFirmwareInfo->Action == SystemFirmwareTable_Get
2674  && DataSize <= InputBufSize)
2675  {
2676  Status = ExpGetRawSMBiosTable(SysFirmwareInfo->TableBuffer, &DataSize, InputBufSize);
2677  }
2678  SysFirmwareInfo->TableBufferLength = DataSize;
2679  }
2680  break;
2681  }
2682  default:
2683  {
2684  DPRINT1("SystemFirmwareTableInformation: Unsupported provider (0x%x)\n",
2685  SysFirmwareInfo->ProviderSignature);
2687  }
2688  }
2689 
2690  if (NT_SUCCESS(Status))
2691  {
2692  switch (SysFirmwareInfo->Action)
2693  {
2696  {
2697  if (SysFirmwareInfo->TableBufferLength > InputBufSize)
2698  {
2700  }
2701  break;
2702  }
2703  default:
2704  {
2705  DPRINT1("SystemFirmwareTableInformation: Unsupported action (0x%x)\n",
2706  SysFirmwareInfo->Action);
2708  }
2709  }
2710  }
2711  else
2712  {
2713  SysFirmwareInfo->TableBufferLength = 0;
2714  }
2715  return Status;
2716 }
2717 
2718 /* Query/Set Calls Table */
2719 typedef
2720 struct _QSSI_CALLS
2721 {
2724 } QSSI_CALLS;
2725 
2726 // QS Query & Set
2727 // QX Query
2728 // XS Set
2729 // XX unknown behaviour
2730 //
2731 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
2732 #define SI_QX(n) {QSI_USE(n),NULL}
2733 #define SI_XS(n) {NULL,SSI_USE(n)}
2734 #define SI_XX(n) {NULL,NULL}
2735 
2736 static
2737 QSSI_CALLS
2739 {
2744  SI_QX(SystemPathInformation), /* should be SI_XX */
2750  SI_QX(SystemCallTimeInformation), /* should be SI_XX */
2753  SI_QX(SystemStackTraceInformation), /* should be SI_XX */
2754  SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
2755  SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
2760  SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
2765  SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
2769  SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
2770  SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
2771  SI_QX(SystemPerformanceTraceInformation), /* it should be SI_XX */
2780  SI_QX(SystemVerifierAddDriverInformation), /* it should be SI_XX */
2781  SI_QX(SystemVerifierRemoveDriverInformation), /* it should be SI_XX */
2782  SI_QX(SystemProcessorIdleInformation), /* it should be SI_XX */
2783  SI_QX(SystemLegacyDriverInformation), /* it should be SI_XX */
2784  SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
2789  SI_QX(SystemSessionInformation), /* it should be SI_XX */
2792  SI_XS(SystemVerifierThunkExtend),
2801  SI_XX(SystemProcessorPowerInformation), /* FIXME: not implemented */
2802  SI_XX(SystemEmulationBasicInformation), /* FIXME: not implemented */
2803  SI_XX(SystemEmulationProcessorInformation), /* FIXME: not implemented */
2805  SI_XX(SystemLostDelayedWriteInformation), /* FIXME: not implemented */
2806  SI_XX(SystemBigPoolInformation), /* FIXME: not implemented */
2807  SI_XX(SystemSessionPoolTagInformation), /* FIXME: not implemented */
2808  SI_XX(SystemSessionMappedViewInformation), /* FIXME: not implemented */
2809  SI_XX(SystemHotpatchInformation), /* FIXME: not implemented */
2810  SI_XX(SystemObjectSecurityMode), /* FIXME: not implemented */
2811  SI_XX(SystemWatchdogTimerHandler), /* FIXME: not implemented */
2812  SI_XX(SystemWatchdogTimerInformation), /* FIXME: not implemented */
2813  SI_XX(SystemLogicalProcessorInformation), /* FIXME: not implemented */
2814  SI_XX(SystemWow64SharedInformation), /* FIXME: not implemented */
2815  SI_XX(SystemRegisterFirmwareTableInformationHandler), /* FIXME: not implemented */
2817 };
2818 
2820 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
2821 #define MAX_SYSTEM_INFO_CLASS (sizeof(CallQS) / sizeof(CallQS[0]))
2822 
2823 /*
2824  * @implemented
2825  */
2827 NTSTATUS
2828 NTAPI
2830  _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
2831  _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation,
2832  _In_ ULONG Length,
2833  _Out_opt_ PULONG UnsafeResultLength)
2834 {
2836  ULONG ResultLength = 0;
2838  NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;
2839 
2840  PAGED_CODE();
2841 
2843 
2844  _SEH2_TRY
2845  {
2846 #if (NTDDI_VERSION >= NTDDI_VISTA)
2847  /*
2848  * Check if the request is valid.
2849  */
2850  if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2851  {
2853  }
2854 #endif
2855 
2856  if (PreviousMode != KernelMode)
2857  {
2858  /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
2859  if (SystemInformationClass == SystemKernelDebuggerInformation)
2861 
2862  ProbeForWrite(SystemInformation, Length, Alignment);
2863  if (UnsafeResultLength != NULL)
2864  ProbeForWriteUlong(UnsafeResultLength);
2865  }
2866 
2867  if (UnsafeResultLength)
2868  *UnsafeResultLength = 0;
2869 
2870 #if (NTDDI_VERSION < NTDDI_VISTA)
2871  /*
2872  * Check if the request is valid.
2873  */
2874  if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2875  {
2877  }
2878 #endif
2879 
2880  if (NULL != CallQS [SystemInformationClass].Query)
2881  {
2882  /*
2883  * Hand the request to a subhandler.
2884  */
2885  FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
2886  Length,
2887  &ResultLength);
2888 
2889  /* Save the result length to the caller */
2890  if (UnsafeResultLength)
2891  *UnsafeResultLength = ResultLength;
2892  }
2893  }
2895  {
2896  FStatus = _SEH2_GetExceptionCode();
2897  }
2898  _SEH2_END;
2899 
2900  return FStatus;
2901 }
2902 
2903 
2904 NTSTATUS
2905 NTAPI
2907  IN PVOID SystemInformation,
2908  IN ULONG SystemInformationLength)
2909 {
2912 
2913  PAGED_CODE();
2914 
2916 
2917  _SEH2_TRY
2918  {
2919  /*
2920  * If called from user mode, check
2921  * possible unsafe arguments.
2922  */
2923  if (PreviousMode != KernelMode)
2924  {
2925  ProbeForRead(SystemInformation, SystemInformationLength, sizeof(ULONG));
2926  }
2927 
2928  /*
2929  * Check the request is valid.
2930  */
2931  if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
2932  (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
2933  {
2934  if (NULL != CallQS [SystemInformationClass].Set)
2935  {
2936  /*
2937  * Hand the request to a subhandler.
2938  */
2939  Status = CallQS [SystemInformationClass].Set(SystemInformation,
2940  SystemInformationLength);
2941  }
2942  }
2943  }
2945  {
2947  }
2948  _SEH2_END;
2949 
2950  return Status;
2951 }
2952 
2953 ULONG
2954 NTAPI
2956 {
2957  /* Just use Ke */
2958  return KeGetCurrentProcessorNumber();
2959 }
2960 
2961 #undef ExGetPreviousMode
2963 NTAPI
2965 {
2966  /* Just use Ke */
2967  return KeGetPreviousMode();
2968 }
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
IN CINT OUT PVOID IN ULONG OUT PULONG ResultLength
Definition: conport.c:47
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
ULONG CcLazyWriteIos
Definition: lazywrite.c:21
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
const LUID SeSystemEnvironmentPrivilege
Definition: priv.c:43
signed char * PCHAR
Definition: retypes.h:7
ULONGLONG AvailableMemory[MAXIMUM_NUMA_NODES]
Definition: extypes.h:1397
ULONG KeMaximumIncrement
Definition: clock.c:20
NTSTATUS NTAPI MmSessionCreate(OUT PULONG SessionId)
Definition: session.c:822
#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:38
PHANDLE_TABLE_ENTRY NTAPI ExpLookupHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN EXHANDLE Handle)
Definition: handle.c:37
#define MM_VIRTMEM_GRANULARITY
Definition: mm.h:78
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
ERESOURCE ExpFirmwareTableResource
Definition: sysinfo.c:30
struct _SYSTEM_REGISTRY_QUOTA_INFORMATION SYSTEM_REGISTRY_QUOTA_INFORMATION
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
LIST_ENTRY ThreadListEntry
Definition: pstypes.h:1089
#define TYPE_ALIGNMENT(t)
Definition: ntbasedef.h:117
const LUID SeSystemtimePrivilege
Definition: priv.c:33
MM_MEMORY_CONSUMER MiMemoryConsumers[MC_MAXIMUM]
Definition: balance.c:36
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
ULONG Index
Definition: obtypes.h:385
#define ROUND_UP(n, align)
Definition: eventvwr.h:31
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
ULONG InterruptTime
Definition: ketypes.h:736
LARGE_INTEGER IoWriteTransferCount
Definition: iomgr.c:42
struct _PROCESSOR_POWER_INFORMATION PROCESSOR_POWER_INFORMATION
LONG IoWriteOperationCount
Definition: ketypes.h:661
LIST_ENTRY ExPoolLookasideListHead
Definition: lookas.c:26
BOOLEAN NTAPI ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
Definition: sysinfo.c:363
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define _Out_writes_bytes_to_opt_(size, count)
Definition: no_sal2.h:375
Definition: arc.h:32
struct _SYSTEM_NUMA_INFORMATION * PSYSTEM_NUMA_INFORMATION
const LUID SeDebugPrivilege
Definition: priv.c:41
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID)
Definition: iorsrce.c:830
ULONG_PTR ObAttributes
Definition: extypes.h:600
KDPC_DATA DpcData[2]
Definition: ketypes.h:676
#define SI_XS(n)
Definition: sysinfo.c:2733
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
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MC_USER
Definition: mm.h:94
uint16_t * PWSTR
Definition: typedefs.h:54
ULONG CcDataFlushes
Definition: copy.c:51
struct _SYSTEM_QUERY_TIME_ADJUST_INFORMATION * PSYSTEM_QUERY_TIME_ADJUST_INFORMATION
unsigned char * PUCHAR
Definition: retypes.h:3
ACPI_SIZE Length
Definition: actypes.h:1041
char CHAR
Definition: xmlstorage.h:175
LARGE_INTEGER CreateTime
Definition: pstypes.h:1035
NTSTATUS NTAPI SeLocateProcessImageName(IN PEPROCESS Process, OUT PUNICODE_STRING *ProcessImageName)
Definition: audit.c:122
static VOID ExpCopyLookasideInformation(PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer, PULONG RemainingPointer, PLIST_ENTRY ListHead, BOOLEAN ListUsesMisses)
Definition: sysinfo.c:2083
ULONG SessionId
Definition: dllmain.c:28
#define SI_QS(n)
Definition: sysinfo.c:2731
#define KeGetPreviousMode()
Definition: ketypes.h:1081
LONG NTSTATUS
Definition: precomp.h:26
PVOID DriverStart
Definition: iotypes.h:2170
KTHREAD Tcb
Definition: pstypes.h:1034
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1062
ULONG NTAPI KeQueryTimeIncrement(VOID)
Definition: clock.c:153
#define SIG_RSMB
Definition: sysinfo.c:24
SCHAR Priority
Definition: ketypes.h:1672
LARGE_INTEGER IoWriteTransferCount
Definition: ketypes.h:664
FAST_MUTEX ExpEnvironmentLock
Definition: sysinfo.c:29
ULONG CcLazyWritePages
Definition: lazywrite.c:20
PFN_NUMBER MmLowestPhysicalPage
Definition: meminit.c:30
BOOLEAN NTAPI SeSinglePrivilegeCheck(IN LUID PrivilegeValue, IN KPROCESSOR_MODE PreviousMode)
Definition: priv.c:524
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:1439
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:2964
ULONG ARC_STATUS
Definition: arc.h:4
ULONG KiAdjustDpcThreshold
Definition: dpc.c:21
#define MC_SYSTEM
Definition: mm.h:95
NTSTATUS NTAPI NtEnumerateSystemEnvironmentValuesEx(IN ULONG InformationClass, IN PVOID Buffer, IN ULONG BufferLength)
Definition: sysinfo.c:557
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:375
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:1260
VOID NTAPI ExGetCurrentProcessorCounts(PULONG ThreadKernelTime, PULONG TotalCpuTime, PULONG ProcessorNumber)
Definition: sysinfo.c:345
NTSTATUS NTAPI ExGetPoolTagInfo(IN PSYSTEM_POOLTAG_INFORMATION SystemInformation, IN ULONG SystemInformationLength, IN OUT PULONG ReturnLength OPTIONAL)
Definition: expool.c:1352
uint16_t * PWCHAR
Definition: typedefs.h:54
ARC_STATUS NTAPI HalGetEnvironmentVariable(IN PCH Name, IN USHORT ValueLength, IN PCH Value)
Definition: rtc.c:70
LARGE_INTEGER IoWriteTransferCount
Definition: memtest.h:13
PFN_NUMBER MmAvailablePages
Definition: freelist.c:26
BOOLEAN NTAPI ExVerifySuite(SUITE_TYPE SuiteType)
Definition: sysinfo.c:377
#define WCHAR
Definition: msvc.h:43
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
LARGE_INTEGER CreateTime
Definition: extypes.h:887
struct _SYSTEM_PROCESSOR_INFORMATION SYSTEM_PROCESSOR_INFORMATION
ULONG DpcTime
Definition: ketypes.h:735
_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:887
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
HANDLE UniqueProcessId
Definition: pstypes.h:1198
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
struct TraceInfo Info
ULONG IoWriteOperationCount
Definition: iomgr.c:41
#define PAGED_CODE()
Definition: video.h:57
static BOOL Set
Definition: pageheap.c:10
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
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:64
#define MAX_ENVVAL_SIZE
Definition: sysinfo.c:20
_SEH2_TRY
Definition: create.c:4250
BOOLEAN KiTimeAdjustmentEnabled
Definition: time.c:19
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
PKSTART_ROUTINE StartAddress
Definition: pstypes.h:1086
ULONG IoReadOperationCount
Definition: iomgr.c:39
uint32_t ULONG_PTR
Definition: typedefs.h:63
struct LOOKASIDE_ALIGN _GENERAL_LOOKASIDE GENERAL_LOOKASIDE
ERESOURCE PsLoadedModuleResource
Definition: sysldr.c:37
ULONG NTAPI NtGetCurrentProcessorNumber(VOID)
Definition: sysinfo.c:2955
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:325
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:1063
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
LARGE_INTEGER CurrentTime
Definition: extypes.h:846
NTSTATUS NTAPI MmSessionDelete(IN ULONG SessionId)
Definition: session.c:882
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:2738
#define ANSI_NULL
SIZE_T CurrentSizeIncludingTransitionInPages
Definition: extypes.h:1115
long LONG
Definition: pedump.c:60
_In_ ULONG BufferLength
Definition: usbdlib.h:225
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
ULONG KeAlignmentFixupCount
Definition: ketypes.h:796
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:59
NTSTATUS NTAPI NtSetSystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInformationClass, IN PVOID SystemInformation, IN ULONG SystemInformationLength)
Definition: sysinfo.c:2906
_In_ PEPROCESS _In_ KPROCESSOR_MODE AccessMode
Definition: mmfuncs.h:396
LARGE_INTEGER IdleProcessTime
Definition: memtest.h:11
NTSTATUS NTAPI IoWMIQueryAllData(IN PVOID DataBlockObject, IN OUT ULONG *InOutBufferSize, OUT PVOID OutBuffer)
Definition: wmi.c:155
CHAR * PCH
Definition: ntbasedef.h:398
struct _SYSTEM_FLAGS_INFORMATION SYSTEM_FLAGS_INFORMATION
Definition: extypes.h:595
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
struct _KTHREAD * CurrentThread
Definition: ketypes.h:566
struct _RTL_TIME_ZONE_INFORMATION RTL_TIME_ZONE_INFORMATION
LONG IoReadOperationCount
Definition: ketypes.h:660
unsigned char BOOLEAN
ULONG CcMapDataWait
Definition: pin.c:28
smooth NULL
Definition: ftsmooth.c:416
#define ObpGetHandleObject(x)
Definition: ob.h:81
#define STATUS_BREAKPOINT
Definition: ntstatus.h:172
const LUID SeLoadDriverPrivilege
Definition: priv.c:31
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:462
#define SIG_ACPI
Definition: sysinfo.c:22
PEPROCESS TheIdleProcess
Definition: kdpacket.c:30
#define FORCEINLINE
Definition: ntbasedef.h:221
_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 _Out_
Definition: no_sal2.h:323
void DPRINT(...)
Definition: polytest.cpp:61
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:733
#define SystemPerformanceInformation
Definition: memtest.h:87
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
void * PVOID
Definition: retypes.h:9
ULONG ExpTimeZoneId
Definition: time.c:25
ULONG DpcCount
Definition: ketypes.h:748
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:732
UCHAR WaitReason
Definition: ketypes.h:1854
CHAR BasePriority
Definition: ketypes.h:1807
NTSTATUS NTAPI MmUnloadSystemImage(IN PVOID ImageHandle)
Definition: sysldr.c:911
struct _SYSTEM_SET_TIME_ADJUST_INFORMATION * PSYSTEM_SET_TIME_ADJUST_INFORMATION
#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
#define _Out_opt_
Definition: no_sal2.h:339
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
_In_ HANDLE Handle
Definition: extypes.h:390
static __inline VOID ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString, IN KPROCESSOR_MODE CurrentMode)
Definition: probe.h:228
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:21
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:50
ULONG KernelTime
Definition: ketypes.h:1877
struct _SYSTEM_THREAD_INFORMATION * PSYSTEM_THREAD_INFORMATION
struct _SYSTEM_PAGEFILE_INFORMATION SYSTEM_PAGEFILE_INFORMATION
#define STATUS_INVALID_IMAGE_FORMAT
Definition: ntstatus.h:345
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
#define __kernel_entry
Definition: specstrings.h:50
if(!(yy_init))
Definition: macro.lex.yy.c:717
#define PROCESSOR_FEATURE_MAX
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
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
#define TAG_MDL
Definition: tag.h:86
uint64_t ULONGLONG
Definition: typedefs.h:65
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:1059
LIST_ENTRY PsLoadedModuleList
Definition: sysldr.c:34
struct _SYSTEM_PROCESS_INFORMATION SYSTEM_PROCESS_INFORMATION
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
ULONG GrantedAccess
Definition: extypes.h:606
PKNODE KeNodeBlock[1]
Definition: krnlinit.c:39
BOOLEAN NTAPI ExpLockHandleTableEntry(IN PHANDLE_TABLE HandleTable, IN PHANDLE_TABLE_ENTRY HandleTableEntry)
Definition: handle.c:848
static const UCHAR Index[8]
Definition: usbohci.c:18
ULONG KiMinimumDpcRate
Definition: dpc.c:20
NTSYSAPI VOID NTAPI RtlFreeAnsiString(PANSI_STRING AnsiString)
#define BufferSize
Definition: classpnp.h:419
PVOID HANDLE
Definition: typedefs.h:71
ULONG KeSystemCalls
Definition: ketypes.h:647
#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
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
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
NTSYSAPI NTSTATUS NTAPI ZwSetSystemInformation(_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _In_ PVOID SystemInformation, _In_ SIZE_T SystemInformationLength)
LARGE_INTEGER IoOtherTransferCount
Definition: ketypes.h:665
KSPIN_LOCK ExpPagedLookasideListLock
Definition: lookas.c:24
#define KeGetContextSwitches(Prcb)
Definition: ke.h:153
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
UNICODE_STRING ImageName
Definition: extypes.h:890
#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:662
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:2723
#define SharedUserData
unsigned char UCHAR
Definition: xmlstorage.h:181
Definition: ex.h:81
static const char * ImageName
Definition: image.c:34
DRIVER_INITIALIZE * PDRIVER_INITIALIZE
Definition: iotypes.h:2126
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:226
static const WCHAR L[]
Definition: oid.c:1087
#define RtlImageDirectoryEntryToData
Definition: compat.h:460
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
#define NTSTATUS
Definition: precomp.h:20
C_ASSERT(SystemBasicInformation==0)
HANDLE InheritedFromUniqueProcessId
Definition: extypes.h:893
KSPIN_LOCK ExpNonPagedLookasideListLock
Definition: lookas.c:22
#define KeEnterCriticalRegion()
Definition: ke_x.h:83
Definition: btrfs_drv.h:1801
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
PEPROCESS NTAPI PsGetNextProcess(IN PEPROCESS OldProcess OPTIONAL)
Definition: process.c:128
ULONG UserTime
Definition: ketypes.h:734
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:1721
#define PAGE_SIZE
Definition: env_spec_w32.h:49
Definition: typedefs.h:117
#define SystemExtendServiceTableInformation
Definition: DriverTester.h:35
KPROCESS Pcb
Definition: pstypes.h:1193
struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
#define MIN_SYSTEM_INFO_CLASS
Definition: sysinfo.c:2820
ULONG CcPinMappedDataCount
Definition: pin.c:32
#define IMAGE_DIRECTORY_ENTRY_EXPORT
Definition: compat.h:140
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
Status
Definition: gdiplustypes.h:24
const LUID SeTcbPrivilege
Definition: priv.c:28
LARGE_INTEGER IoReadTransferCount
Definition: ketypes.h:663
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
LARGE_INTEGER IoReadTransferCount
Definition: memtest.h:12
struct _KTHREAD * IdleThread
Definition: ketypes.h:568
#define _In_
Definition: no_sal2.h:204
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:126
FORCEINLINE VOID ExAcquirePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1077
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:884
PFN_COUNT MmNumberOfPhysicalPages
Definition: init.c:48
_Must_inspect_result_ _In_ USHORT _In_ PHIDP_PREPARSED_DATA _Out_writes_to_ LengthAttributes PHIDP_EXTENDED_ATTRIBUTES Attributes
Definition: hidpi.h:348
_SEH2_END
Definition: create.c:4424
DRIVER_INFORMATION DriverInfo
Definition: main.c:59
#define KeLeaveCriticalRegion()
Definition: ke_x.h:114
LONG NTAPI ExSystemExceptionFilter(VOID)
Definition: harderr.c:351
KAFFINITY ActiveProcessorsAffinityMask
Definition: ntddk_ex.h:171
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
LARGE_INTEGER KernelTime
Definition: extypes.h:889
struct _SYSTEM_LOOKASIDE_INFORMATION SYSTEM_LOOKASIDE_INFORMATION
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:935
struct _SYSTEM_DEVICE_INFORMATION * PSYSTEM_DEVICE_INFORMATION
NTSTATUS(* Query)(PVOID, ULONG, PULONG)
Definition: sysinfo.c:2722
enum _LOCK_OPERATION LOCK_OPERATION
RTL_TIME_ZONE_INFORMATION ExpTimeZoneInfo
Definition: time.c:21
unsigned short USHORT
Definition: pedump.c:61
LARGE_INTEGER TimeZoneBias
Definition: extypes.h:847
#define SI_XX(n)
Definition: sysinfo.c:2734
ULONG KeExceptionDispatchCount
Definition: ketypes.h:701
_In_ ULONG _Out_opt_ PULONG RequiredLength
Definition: wmifuncs.h:29
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:56
ULONG NTAPI KeQueryRuntimeProcess(IN PKPROCESS Process, OUT PULONG UserTime)
Definition: procobj.c:857
PKPRCB KiProcessorBlock[]
Definition: krnlinit.c:32
struct _SYSTEM_PERFORMANCE_INFORMATION SYSTEM_PERFORMANCE_INFORMATION
ULONG CcPinReadWait
Definition: pin.c:30
SYSTEM_FIRMWARE_TABLE_ACTION Action
#define SystemBasicInformation
Definition: xboxvmp.h:35
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
NTSTATUS ExpSetTimeZoneInformation(PRTL_TIME_ZONE_INFORMATION TimeZoneInformation)
Definition: time.c:278
unsigned int * PULONG
Definition: retypes.h:1
struct _SYSTEM_BASIC_INFORMATION SYSTEM_BASIC_INFORMATION
struct _SYSTEM_INTERRUPT_INFORMATION * PSYSTEM_INTERRUPT_INFORMATION
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:1992
enum _SUITE_TYPE SUITE_TYPE
ULONGLONG ActiveProcessorsAffinityMask[MAXIMUM_NUMA_NODES]
Definition: extypes.h:1396
LARGE_INTEGER IoOtherTransferCount
Definition: memtest.h:14
#define DPRINT1
Definition: precomp.h:8
#define RtlImageNtHeader
Definition: compat.h:457
ULONG UserTime
Definition: ketypes.h:1893
struct _SYSTEM_BASIC_INFORMATION * PSYSTEM_BASIC_INFORMATION
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
#define MC_CACHE
Definition: mm.h:93
#define OUT
Definition: typedefs.h:39
FORCEINLINE VOID ExReleasePushLockShared(PEX_PUSH_LOCK PushLock)
Definition: ex.h:1185
volatile UCHAR State
Definition: ketypes.h:1679
ULONG ERESOURCE
Definition: env_spec_w32.h:594
PFN_COUNT MiFreeSwapPages
Definition: pagefile.c:53
unsigned int ULONG
Definition: retypes.h:1
ULONG ContextSwitches
Definition: ketypes.h:1678
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
LARGE_INTEGER UserTime
Definition: extypes.h:888
#define ULONG_PTR
Definition: config.h:101
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468
uint32_t * PULONG_PTR
Definition: typedefs.h:63
PVOID Object
Definition: extypes.h:599
ULONG WaitTime
Definition: ketypes.h:1765
struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO SYSTEM_HANDLE_TABLE_ENTRY_INFO
ULONG PagesUsed
Definition: mm.h:385
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
PFN_NUMBER MmHighestPhysicalPage
Definition: meminit.c:31
#define TAG_SEPA
Definition: tag.h:187
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
KAFFINITY ProcessorMask
Definition: ketypes.h:776
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
ULONG IoOtherOperationCount
Definition: iomgr.c:43
struct _QSSI_CALLS QSSI_CALLS
GLfloat GLfloat p
Definition: glext.h:8902
#define SI_QX(n)
Definition: sysinfo.c:2732
ULONG DpcRequestRate
Definition: ketypes.h:684
_In_ FILTER_INFORMATION_CLASS InformationClass
Definition: fltkernel.h:1714
POBJECT_TYPE Type
Definition: obtypes.h:493
#define OBJ_HANDLE_ATTRIBUTES
Definition: ob.h:52
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:2725
ULONG NtGlobalFlag
Definition: init.c:51
#define MAX_SYSTEM_INFO_CLASS
Definition: sysinfo.c:2821
#define STATUS_ILLEGAL_FUNCTION
Definition: ntstatus.h:397
EX_PUSH_LOCK HandleTableListLock
Definition: handle.c:19
#define UInt32x32To64(a, b)
Definition: intsafe.h:258
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)
__kernel_entry NTSTATUS NTAPI NtQuerySystemInformation(_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation, _In_ ULONG Length, _Out_opt_ PULONG UnsafeResultLength)
Definition: sysinfo.c:2829
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:4733
ULONG FreeCount[2]
Definition: ketypes.h:785
struct _SYSTEM_DPC_BEHAVIOR_INFORMATION * PSYSTEM_DPC_BEHAVIOR_INFORMATION
LIST_ENTRY ExpPagedLookasideListHead
Definition: lookas.c:23
LIST_ENTRY ExSystemLookasideListHead
Definition: lookas.c:25
LONGLONG QuadPart
Definition: typedefs.h:112
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:2756
_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:2551
Definition: dlist.c:348
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68