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