xref: /reactos/ntoskrnl/ex/sysinfo.c (revision 44898a4e) 
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 
26 extern LIST_ENTRY HandleTableListHead;
27 extern EX_PUSH_LOCK HandleTableListLock;
28 
29 FAST_MUTEX ExpEnvironmentLock;
30 ERESOURCE ExpFirmwareTableResource;
31 LIST_ENTRY ExpFirmwareTableProviderListHead;
32 
33 FORCEINLINE
34 NTSTATUS
35 ExpConvertLdrModuleToRtlModule(IN ULONG ModuleCount,
36                                IN PLDR_DATA_TABLE_ENTRY LdrEntry,
37                                OUT PRTL_PROCESS_MODULE_INFORMATION ModuleInfo)
38 {
39     PCHAR p;
40     NTSTATUS Status;
41     ANSI_STRING ModuleName;
42 
43     /* Fill it out */
44     ModuleInfo->MappedBase = NULL;
45     ModuleInfo->ImageBase = LdrEntry->DllBase;
46     ModuleInfo->ImageSize = LdrEntry->SizeOfImage;
47     ModuleInfo->Flags = LdrEntry->Flags;
48     ModuleInfo->LoadCount = LdrEntry->LoadCount;
49     ModuleInfo->LoadOrderIndex = (USHORT)ModuleCount;
50     ModuleInfo->InitOrderIndex = 0;
51 
52     /* Setup name */
53     RtlInitEmptyAnsiString(&ModuleName,
54                            ModuleInfo->FullPathName,
55                            sizeof(ModuleInfo->FullPathName));
56 
57     /* Convert it */
58     Status = RtlUnicodeStringToAnsiString(&ModuleName,
59                                           &LdrEntry->FullDllName,
60                                           FALSE);
61     if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
62     {
63         /* Calculate offset to name */
64         p = ModuleName.Buffer + ModuleName.Length;
65         while ((p > ModuleName.Buffer) && (*--p))
66         {
67             /* Check if we found the separator */
68             if (*p == OBJ_NAME_PATH_SEPARATOR)
69             {
70                 /* We did, break out */
71                 p++;
72                 break;
73             }
74         }
75 
76         /* Set the offset */
77         ModuleInfo->OffsetToFileName = (USHORT)(p - ModuleName.Buffer);
78     }
79     else
80     {
81         /* Return empty name */
82         ModuleInfo->FullPathName[0] = ANSI_NULL;
83         ModuleInfo->OffsetToFileName = 0;
84     }
85 
86     return Status;
87 }
88 
89 NTSTATUS
90 NTAPI
91 ExpQueryModuleInformation(IN PLIST_ENTRY KernelModeList,
92                           IN PLIST_ENTRY UserModeList,
93                           OUT PRTL_PROCESS_MODULES Modules,
94                           IN ULONG Length,
95                           OUT PULONG ReturnLength)
96 {
97     NTSTATUS Status = STATUS_SUCCESS;
98     ULONG RequiredLength;
99     PRTL_PROCESS_MODULE_INFORMATION ModuleInfo;
100     PLDR_DATA_TABLE_ENTRY LdrEntry;
101     ULONG ModuleCount = 0;
102     PLIST_ENTRY NextEntry;
103 
104     /* Setup defaults */
105     RequiredLength = FIELD_OFFSET(RTL_PROCESS_MODULES, Modules);
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,
114                                      LDR_DATA_TABLE_ENTRY,
115                                      InLoadOrderLinks);
116 
117         /* Update size and check if we can manage one more entry */
118         RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
119         if (Length >= RequiredLength)
120         {
121             Status = ExpConvertLdrModuleToRtlModule(ModuleCount,
122                                                     LdrEntry,
123                                                     ModuleInfo);
124 
125             /* Go to the next module */
126             ModuleInfo++;
127         }
128         else
129         {
130             /* Set error code */
131             Status = STATUS_INFO_LENGTH_MISMATCH;
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,
147                                          LDR_DATA_TABLE_ENTRY,
148                                          InLoadOrderLinks);
149 
150             /* Update size and check if we can manage one more entry */
151             RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
152             if (Length >= RequiredLength)
153             {
154                 Status = ExpConvertLdrModuleToRtlModule(ModuleCount,
155                                                         LdrEntry,
156                                                         ModuleInfo);
157 
158                 /* Go to the next module */
159                 ModuleInfo++;
160             }
161             else
162             {
163                 /* Set error code */
164                 Status = STATUS_INFO_LENGTH_MISMATCH;
165             }
166 
167             /* Update count and move to next entry */
168             ModuleCount++;
169             NextEntry = NextEntry->Flink;
170         }
171     }
172 
173     /* Update return length */
174     if (ReturnLength) *ReturnLength = RequiredLength;
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 */
185         Status = STATUS_INFO_LENGTH_MISMATCH;
186     }
187 
188     /* Done */
189     return Status;
190 }
191 
192 VOID
193 NTAPI
194 ExUnlockUserBuffer(PMDL Mdl)
195 {
196     MmUnlockPages(Mdl);
197     ExFreePoolWithTag(Mdl, TAG_MDL);
198 }
199 
200 NTSTATUS
201 NTAPI
202 ExLockUserBuffer(
203     PVOID BaseAddress,
204     ULONG Length,
205     KPROCESSOR_MODE AccessMode,
206     LOCK_OPERATION Operation,
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 */
217     Mdl = IoAllocateMdl(BaseAddress, Length, FALSE, TRUE, NULL);
218     if (Mdl == NULL)
219     {
220         return STATUS_INSUFFICIENT_RESOURCES;
221     }
222 
223     /* Enter SEH for probing */
224     _SEH2_TRY
225     {
226         MmProbeAndLockPages(Mdl, AccessMode, Operation);
227     }
228     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
229     {
230         ExFreePoolWithTag(Mdl, TAG_MDL);
231         _SEH2_YIELD(return _SEH2_GetExceptionCode());
232     }
233     _SEH2_END;
234 
235     /* Return the safe kernel mode buffer */
236     *MappedSystemVa = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
237     if (*MappedSystemVa == NULL)
238     {
239         ExUnlockUserBuffer(Mdl);
240         return STATUS_INSUFFICIENT_RESOURCES;
241     }
242 
243     /* Return the MDL */
244     *OutMdl = Mdl;
245     return STATUS_SUCCESS;
246 }
247 
248 NTSTATUS
249 NTAPI
250 ExpGetRawSMBiosTable(
251     _Out_opt_ PVOID Buffer,
252     _Out_ ULONG * OutSize,
253     _In_ ULONG BufferSize)
254 {
255     NTSTATUS Status;
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 */
264     Status = IoWMIOpenBlock(&MSSmBios_RawSMBiosTables_GUID,
265                             WMIGUID_QUERY,
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);
286         return STATUS_INSUFFICIENT_RESOURCES;
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 
298     Status = STATUS_SUCCESS;
299     *OutSize = AllData->FixedInstanceSize;
300     if (Buffer != NULL)
301     {
302         if (BufferSize >= *OutSize)
303         {
304             RtlMoveMemory(Buffer, AllData + 1, *OutSize);
305         }
306         else
307         {
308             Status = STATUS_BUFFER_TOO_SMALL;
309         }
310     }
311 
312     /* Free the buffer */
313     ExFreePoolWithTag(AllData, 'itfS');
314     return Status;
315 }
316 
317 /* FUNCTIONS *****************************************************************/
318 
319 /*
320  * @implemented
321  */
322 VOID
323 NTAPI
324 ExGetCurrentProcessorCpuUsage(PULONG CpuUsage)
325 {
326     PKPRCB Prcb;
327     ULONG TotalTime;
328     ULONGLONG ScaledIdle;
329 
330     Prcb = KeGetCurrentPrcb();
331 
332     ScaledIdle = (ULONGLONG)Prcb->IdleThread->KernelTime * 100;
333     TotalTime = Prcb->KernelTime + Prcb->UserTime;
334     if (TotalTime != 0)
335         *CpuUsage = (ULONG)(100 - (ScaledIdle / TotalTime));
336     else
337         *CpuUsage = 0;
338 }
339 
340 /*
341  * @implemented
342  */
343 VOID
344 NTAPI
345 ExGetCurrentProcessorCounts(PULONG ThreadKernelTime,
346                             PULONG TotalCpuTime,
347                             PULONG ProcessorNumber)
348 {
349     PKPRCB Prcb;
350 
351     Prcb = KeGetCurrentPrcb();
352 
353     *ThreadKernelTime = Prcb->KernelTime + Prcb->UserTime;
354     *TotalCpuTime = Prcb->CurrentThread->KernelTime;
355     *ProcessorNumber = KeGetCurrentProcessorNumber();
356 }
357 
358 /*
359  * @implemented
360  */
361 BOOLEAN
362 NTAPI
363 ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
364 {
365     /* Quick check to see if it exists at all */
366     if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return(FALSE);
367 
368     /* Return our support for it */
369     return(SharedUserData->ProcessorFeatures[ProcessorFeature]);
370 }
371 
372 /*
373  * @implemented
374  */
375 BOOLEAN
376 NTAPI
377 ExVerifySuite(SUITE_TYPE SuiteType)
378 {
379     if (SuiteType == Personal) return TRUE;
380     return FALSE;
381 }
382 
383 NTSTATUS
384 NTAPI
385 NtQuerySystemEnvironmentValue(IN PUNICODE_STRING VariableName,
386                               OUT PWSTR ValueBuffer,
387                               IN ULONG ValueBufferLength,
388                               IN OUT PULONG ReturnLength OPTIONAL)
389 {
390     ANSI_STRING AName;
391     UNICODE_STRING WName;
392     ARC_STATUS Result;
393     PCH AnsiValueBuffer;
394     ANSI_STRING AValue;
395     UNICODE_STRING WValue;
396     KPROCESSOR_MODE PreviousMode;
397     NTSTATUS Status;
398     PAGED_CODE();
399 
400     /* Check if the call came from user mode */
401     PreviousMode = ExGetPreviousMode();
402     if (PreviousMode != KernelMode)
403     {
404         _SEH2_TRY
405         {
406             /* Probe the input and output buffers */
407             ProbeForRead(VariableName, sizeof(UNICODE_STRING), sizeof(ULONG));
408             ProbeForWrite(ValueBuffer, ValueBufferLength, sizeof(WCHAR));
409             if (ReturnLength != NULL) ProbeForWriteUlong(ReturnLength);
410         }
411         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
412         {
413             /* Return the exception code */
414             _SEH2_YIELD(return _SEH2_GetExceptionCode());
415         }
416         _SEH2_END;
417     }
418 
419     /* According to NTInternals the SeSystemEnvironmentName privilege is required! */
420     if (!SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege, PreviousMode))
421     {
422         DPRINT1("NtQuerySystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
423         return STATUS_PRIVILEGE_NOT_HELD;
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);
432     ReleaseCapturedUnicodeString(&WName, PreviousMode);
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);
440         return STATUS_INSUFFICIENT_RESOURCES;
441     }
442 
443     /* Get the environment variable and free the ANSI name */
444     Result = HalGetEnvironmentVariable(AName.Buffer,
445                                        MAX_ENVVAL_SIZE,
446                                        AnsiValueBuffer);
447     RtlFreeAnsiString(&AName);
448 
449     /* Check if we had success */
450     if (Result == ESUCCESS)
451     {
452         /* Copy the result back to the caller. */
453         _SEH2_TRY
454         {
455             /* Initialize ANSI string from the result */
456             RtlInitAnsiString(&AValue, AnsiValueBuffer);
457 
458             /* Initialize a UNICODE string from the callers buffer */
459             RtlInitEmptyUnicodeString(&WValue, ValueBuffer, (USHORT)ValueBufferLength);
460 
461             /* Convert the result to UNICODE */
462             Status = RtlAnsiStringToUnicodeString(&WValue, &AValue, FALSE);
463 
464             if (ReturnLength != NULL)
465                 *ReturnLength = WValue.Length;
466         }
467         _SEH2_EXCEPT(ExSystemExceptionFilter())
468         {
469             Status = _SEH2_GetExceptionCode();
470         }
471         _SEH2_END;
472     }
473     else
474     {
475         Status = STATUS_UNSUCCESSFUL;
476     }
477 
478     /* Free the allocated ANSI value buffer */
479     ExFreePoolWithTag(AnsiValueBuffer, 'rvnE');
480 
481     return Status;
482 }
483 
484 
485 NTSTATUS
486 NTAPI
487 NtSetSystemEnvironmentValue(IN PUNICODE_STRING VariableName,
488                             IN PUNICODE_STRING Value)
489 {
490     UNICODE_STRING CapturedName, CapturedValue;
491     ANSI_STRING AName, AValue;
492     KPROCESSOR_MODE PreviousMode;
493     NTSTATUS Status;
494 
495     PAGED_CODE();
496 
497     PreviousMode = ExGetPreviousMode();
498 
499     /*
500      * Copy the strings to kernel space if necessary
501      */
502     Status = ProbeAndCaptureUnicodeString(&CapturedName,
503                                           PreviousMode,
504                                           VariableName);
505     if (NT_SUCCESS(Status))
506     {
507         Status = ProbeAndCaptureUnicodeString(&CapturedValue,
508                                               PreviousMode,
509                                               Value);
510         if (NT_SUCCESS(Status))
511         {
512             /*
513              * according to ntinternals the SeSystemEnvironmentName privilege is required!
514              */
515             if (SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
516                                        PreviousMode))
517             {
518                 /*
519                  * convert the strings to ANSI
520                  */
521                 Status = RtlUnicodeStringToAnsiString(&AName,
522                                                       &CapturedName,
523                                                       TRUE);
524                 if (NT_SUCCESS(Status))
525                 {
526                     Status = RtlUnicodeStringToAnsiString(&AValue,
527                                                           &CapturedValue,
528                                                           TRUE);
529                     if (NT_SUCCESS(Status))
530                     {
531                         ARC_STATUS Result = HalSetEnvironmentVariable(AName.Buffer,
532                                                                       AValue.Buffer);
533 
534                         Status = (Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
535                     }
536                 }
537             }
538             else
539             {
540                 DPRINT1("NtSetSystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
541                 Status = STATUS_PRIVILEGE_NOT_HELD;
542             }
543 
544             ReleaseCapturedUnicodeString(&CapturedValue,
545                                          PreviousMode);
546         }
547 
548         ReleaseCapturedUnicodeString(&CapturedName,
549                                      PreviousMode);
550     }
551 
552     return Status;
553 }
554 
555 NTSTATUS
556 NTAPI
557 NtEnumerateSystemEnvironmentValuesEx(IN ULONG InformationClass,
558                                      IN PVOID Buffer,
559                                      IN ULONG BufferLength)
560 {
561     UNIMPLEMENTED;
562     return STATUS_NOT_IMPLEMENTED;
563 }
564 
565 NTSTATUS
566 NTAPI
567 NtQuerySystemEnvironmentValueEx(IN PUNICODE_STRING VariableName,
568                                 IN LPGUID VendorGuid,
569                                 IN PVOID Value,
570                                 IN OUT PULONG ReturnLength,
571                                 IN OUT PULONG Attributes)
572 {
573     UNIMPLEMENTED;
574     return STATUS_NOT_IMPLEMENTED;
575 }
576 
577 NTSTATUS
578 NTAPI
579 NtSetSystemEnvironmentValueEx(IN PUNICODE_STRING VariableName,
580                               IN LPGUID VendorGuid,
581                               IN PVOID Value,
582                               IN OUT PULONG ReturnLength,
583                               IN OUT PULONG Attributes)
584 {
585     UNIMPLEMENTED;
586     return STATUS_NOT_IMPLEMENTED;
587 }
588 
589 /* --- Query/Set System Information --- */
590 
591 /*
592  * NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
593  * so the stack is popped only in one place on x86 platform.
594  */
595 #define QSI_USE(n) QSI##n
596 #define QSI_DEF(n) \
597 static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
598 
599 #define SSI_USE(n) SSI##n
600 #define SSI_DEF(n) \
601 static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
602 
603 VOID
604 NTAPI
605 ExQueryPoolUsage(OUT PULONG PagedPoolPages,
606                  OUT PULONG NonPagedPoolPages,
607                  OUT PULONG PagedPoolAllocs,
608                  OUT PULONG PagedPoolFrees,
609                  OUT PULONG PagedPoolLookasideHits,
610                  OUT PULONG NonPagedPoolAllocs,
611                  OUT PULONG NonPagedPoolFrees,
612                  OUT PULONG NonPagedPoolLookasideHits);
613 
614 /* Class 0 - Basic Information */
615 QSI_DEF(SystemBasicInformation)
616 {
617     PSYSTEM_BASIC_INFORMATION Sbi
618         = (PSYSTEM_BASIC_INFORMATION) Buffer;
619 
620     *ReqSize = sizeof(SYSTEM_BASIC_INFORMATION);
621 
622     /* Check user buffer's size */
623     if (Size != sizeof(SYSTEM_BASIC_INFORMATION))
624     {
625         return STATUS_INFO_LENGTH_MISMATCH;
626     }
627 
628     RtlZeroMemory(Sbi, Size);
629     Sbi->Reserved = 0;
630     Sbi->TimerResolution = KeMaximumIncrement;
631     Sbi->PageSize = PAGE_SIZE;
632     Sbi->NumberOfPhysicalPages = MmNumberOfPhysicalPages;
633     Sbi->LowestPhysicalPageNumber = (ULONG)MmLowestPhysicalPage;
634     Sbi->HighestPhysicalPageNumber = (ULONG)MmHighestPhysicalPage;
635     Sbi->AllocationGranularity = MM_VIRTMEM_GRANULARITY; /* hard coded on Intel? */
636     Sbi->MinimumUserModeAddress = 0x10000; /* Top of 64k */
637     Sbi->MaximumUserModeAddress = (ULONG_PTR)MmHighestUserAddress;
638     Sbi->ActiveProcessorsAffinityMask = KeActiveProcessors;
639     Sbi->NumberOfProcessors = KeNumberProcessors;
640 
641     return STATUS_SUCCESS;
642 }
643 
644 /* Class 1 - Processor Information */
645 QSI_DEF(SystemProcessorInformation)
646 {
647     PSYSTEM_PROCESSOR_INFORMATION Spi
648         = (PSYSTEM_PROCESSOR_INFORMATION) Buffer;
649 
650     *ReqSize = sizeof(SYSTEM_PROCESSOR_INFORMATION);
651 
652     /* Check user buffer's size */
653     if (Size < sizeof(SYSTEM_PROCESSOR_INFORMATION))
654     {
655         return STATUS_INFO_LENGTH_MISMATCH;
656     }
657     Spi->ProcessorArchitecture = KeProcessorArchitecture;
658     Spi->ProcessorLevel = KeProcessorLevel;
659     Spi->ProcessorRevision = KeProcessorRevision;
660     Spi->Reserved = 0;
661     Spi->ProcessorFeatureBits = KeFeatureBits;
662 
663     DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
664         Spi->ProcessorLevel, Spi->ProcessorRevision);
665 
666     return STATUS_SUCCESS;
667 }
668 
669 /* Class 2 - Performance Information */
670 QSI_DEF(SystemPerformanceInformation)
671 {
672     ULONG IdleUser, IdleKernel;
673     PSYSTEM_PERFORMANCE_INFORMATION Spi
674         = (PSYSTEM_PERFORMANCE_INFORMATION) Buffer;
675 
676     PEPROCESS TheIdleProcess;
677 
678     *ReqSize = sizeof(SYSTEM_PERFORMANCE_INFORMATION);
679 
680     /* Check user buffer's size */
681     if (Size < sizeof(SYSTEM_PERFORMANCE_INFORMATION))
682     {
683         return STATUS_INFO_LENGTH_MISMATCH;
684     }
685 
686     TheIdleProcess = PsIdleProcess;
687 
688     IdleKernel = KeQueryRuntimeProcess(&TheIdleProcess->Pcb, &IdleUser);
689     Spi->IdleProcessTime.QuadPart = UInt32x32To64(IdleKernel, KeMaximumIncrement);
690     Spi->IoReadTransferCount = IoReadTransferCount;
691     Spi->IoWriteTransferCount = IoWriteTransferCount;
692     Spi->IoOtherTransferCount = IoOtherTransferCount;
693     Spi->IoReadOperationCount = IoReadOperationCount;
694     Spi->IoWriteOperationCount = IoWriteOperationCount;
695     Spi->IoOtherOperationCount = IoOtherOperationCount;
696 
697     Spi->AvailablePages = (ULONG)MmAvailablePages;
698     /*
699      *   Add up all the used "Committed" memory + pagefile.
700      *   Not sure this is right. 8^\
701      */
702     Spi->CommittedPages = MiMemoryConsumers[MC_SYSTEM].PagesUsed +
703                           MiMemoryConsumers[MC_CACHE].PagesUsed +
704                           MiMemoryConsumers[MC_USER].PagesUsed +
705                           MiUsedSwapPages;
706     /*
707      *  Add up the full system total + pagefile.
708      *  All this make Taskmgr happy but not sure it is the right numbers.
709      *  This too, fixes some of GlobalMemoryStatusEx numbers.
710      */
711     Spi->CommitLimit = MmNumberOfPhysicalPages + MiFreeSwapPages + MiUsedSwapPages;
712 
713     Spi->PeakCommitment = 0; /* FIXME */
714     Spi->PageFaultCount = 0; /* FIXME */
715     Spi->CopyOnWriteCount = 0; /* FIXME */
716     Spi->TransitionCount = 0; /* FIXME */
717     Spi->CacheTransitionCount = 0; /* FIXME */
718     Spi->DemandZeroCount = 0; /* FIXME */
719     Spi->PageReadCount = 0; /* FIXME */
720     Spi->PageReadIoCount = 0; /* FIXME */
721     Spi->CacheReadCount = 0; /* FIXME */
722     Spi->CacheIoCount = 0; /* FIXME */
723     Spi->DirtyPagesWriteCount = 0; /* FIXME */
724     Spi->DirtyWriteIoCount = 0; /* FIXME */
725     Spi->MappedPagesWriteCount = 0; /* FIXME */
726     Spi->MappedWriteIoCount = 0; /* FIXME */
727 
728     Spi->PagedPoolPages = 0;
729     Spi->NonPagedPoolPages = 0;
730     Spi->PagedPoolAllocs = 0;
731     Spi->PagedPoolFrees = 0;
732     Spi->PagedPoolLookasideHits = 0;
733     Spi->NonPagedPoolAllocs = 0;
734     Spi->NonPagedPoolFrees = 0;
735     Spi->NonPagedPoolLookasideHits = 0;
736     ExQueryPoolUsage(&Spi->PagedPoolPages,
737                      &Spi->NonPagedPoolPages,
738                      &Spi->PagedPoolAllocs,
739                      &Spi->PagedPoolFrees,
740                      &Spi->PagedPoolLookasideHits,
741                      &Spi->NonPagedPoolAllocs,
742                      &Spi->NonPagedPoolFrees,
743                      &Spi->NonPagedPoolLookasideHits);
744     Spi->FreeSystemPtes = 0; /* FIXME */
745 
746     Spi->ResidentSystemCodePage = 0; /* FIXME */
747 
748     Spi->TotalSystemDriverPages = 0; /* FIXME */
749     Spi->Spare3Count = 0; /* FIXME */
750 
751     Spi->ResidentSystemCachePage = MiMemoryConsumers[MC_CACHE].PagesUsed;
752     Spi->ResidentPagedPoolPage = 0; /* FIXME */
753 
754     Spi->ResidentSystemDriverPage = 0; /* FIXME */
755     Spi->CcFastReadNoWait = 0; /* FIXME */
756     Spi->CcFastReadWait = 0; /* FIXME */
757     Spi->CcFastReadResourceMiss = 0; /* FIXME */
758     Spi->CcFastReadNotPossible = 0; /* FIXME */
759 
760     Spi->CcFastMdlReadNoWait = 0; /* FIXME */
761     Spi->CcFastMdlReadWait = 0; /* FIXME */
762     Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
763     Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
764 
765     Spi->CcMapDataNoWait = CcMapDataNoWait;
766     Spi->CcMapDataWait = CcMapDataWait;
767     Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
768     Spi->CcMapDataWaitMiss = 0; /* FIXME */
769 
770     Spi->CcPinMappedDataCount = CcPinMappedDataCount;
771     Spi->CcPinReadNoWait = CcPinReadNoWait;
772     Spi->CcPinReadWait = CcPinReadWait;
773     Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
774     Spi->CcPinReadWaitMiss = 0; /* FIXME */
775     Spi->CcCopyReadNoWait = 0; /* FIXME */
776     Spi->CcCopyReadWait = 0; /* FIXME */
777     Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
778     Spi->CcCopyReadWaitMiss = 0; /* FIXME */
779 
780     Spi->CcMdlReadNoWait = 0; /* FIXME */
781     Spi->CcMdlReadWait = 0; /* FIXME */
782     Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
783     Spi->CcMdlReadWaitMiss = 0; /* FIXME */
784     Spi->CcReadAheadIos = 0; /* FIXME */
785     Spi->CcLazyWriteIos = CcLazyWriteIos;
786     Spi->CcLazyWritePages = CcLazyWritePages;
787     Spi->CcDataFlushes = CcDataFlushes;
788     Spi->CcDataPages = CcDataPages;
789     Spi->ContextSwitches = 0; /* FIXME */
790     Spi->FirstLevelTbFills = 0; /* FIXME */
791     Spi->SecondLevelTbFills = 0; /* FIXME */
792     Spi->SystemCalls = 0; /* FIXME */
793 
794     return STATUS_SUCCESS;
795 }
796 
797 /* Class 3 - Time Of Day Information */
798 QSI_DEF(SystemTimeOfDayInformation)
799 {
800     SYSTEM_TIMEOFDAY_INFORMATION Sti;
801     LARGE_INTEGER CurrentTime;
802 
803     /* Set amount of written information to 0 */
804     *ReqSize = 0;
805 
806     /* Check user buffer's size */
807     if (Size > sizeof(SYSTEM_TIMEOFDAY_INFORMATION))
808     {
809         return STATUS_INFO_LENGTH_MISMATCH;
810     }
811 
812     /* Get current time */
813     KeQuerySystemTime(&CurrentTime);
814 
815     /* Zero local buffer */
816     RtlZeroMemory(&Sti, sizeof(SYSTEM_TIMEOFDAY_INFORMATION));
817 
818     /* Fill local time structure */
819     Sti.BootTime= KeBootTime;
820     Sti.CurrentTime = CurrentTime;
821     Sti.TimeZoneBias.QuadPart = ExpTimeZoneBias.QuadPart;
822     Sti.TimeZoneId = ExpTimeZoneId;
823     Sti.Reserved = 0;
824 
825     /* Copy as much as requested by caller */
826     RtlCopyMemory(Buffer, &Sti, Size);
827 
828     /* Set amount of information we copied */
829     *ReqSize = Size;
830 
831     return STATUS_SUCCESS;
832 }
833 
834 /* Class 4 - Path Information */
835 QSI_DEF(SystemPathInformation)
836 {
837     /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
838     DPRINT1("NtQuerySystemInformation - SystemPathInformation not implemented\n");
839 
840     return STATUS_BREAKPOINT;
841 }
842 
843 /* Class 5 - Process Information */
844 QSI_DEF(SystemProcessInformation)
845 {
846     PSYSTEM_PROCESS_INFORMATION SpiCurrent;
847     PSYSTEM_THREAD_INFORMATION ThreadInfo;
848     PEPROCESS Process = NULL, SystemProcess;
849     PETHREAD CurrentThread;
850     ANSI_STRING ImageName;
851     ULONG CurrentSize;
852     USHORT ImageNameMaximumLength; // image name length in bytes
853     USHORT ImageNameLength;
854     PLIST_ENTRY CurrentEntry;
855     ULONG TotalSize = 0, ThreadsCount;
856     ULONG TotalUser, TotalKernel;
857     PUCHAR Current;
858     NTSTATUS Status = STATUS_SUCCESS;
859     PUNICODE_STRING TempProcessImageName;
860     _SEH2_VOLATILE PUNICODE_STRING ProcessImageName = NULL;
861     PWCHAR szSrc;
862     BOOLEAN Overflow = FALSE;
863 
864     _SEH2_TRY
865     {
866         /* scan the process list */
867 
868         PSYSTEM_PROCESS_INFORMATION Spi
869             = (PSYSTEM_PROCESS_INFORMATION) Buffer;
870 
871         *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
872 
873         /* Check for overflow */
874         if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
875         {
876             Overflow = TRUE;
877         }
878 
879         /* Zero user's buffer */
880         if (!Overflow) RtlZeroMemory(Spi, Size);
881 
882         SystemProcess = PsIdleProcess;
883         Process = SystemProcess;
884         Current = (PUCHAR) Spi;
885 
886         do
887         {
888             SpiCurrent = (PSYSTEM_PROCESS_INFORMATION) Current;
889 
890             /* Lock the Process */
891             KeEnterCriticalRegion();
892             ExAcquirePushLockShared(&Process->ProcessLock);
893 
894             if ((Process->ProcessExiting) &&
895                 (Process->Pcb.Header.SignalState) &&
896                 !(Process->ActiveThreads) &&
897                 (IsListEmpty(&Process->Pcb.ThreadListHead)))
898             {
899                 DPRINT1("Process %p (%s:%p) is a zombie\n",
900                         Process, Process->ImageFileName, Process->UniqueProcessId);
901                 CurrentSize = 0;
902                 ImageNameMaximumLength = 0;
903 
904                 /* Unlock the Process */
905                 ExReleasePushLockShared(&Process->ProcessLock);
906                 KeLeaveCriticalRegion();
907                 goto Skip;
908             }
909 
910             ThreadsCount = 0;
911             CurrentEntry = Process->Pcb.ThreadListHead.Flink;
912             while (CurrentEntry != &Process->Pcb.ThreadListHead)
913             {
914                 ThreadsCount++;
915                 CurrentEntry = CurrentEntry->Flink;
916             }
917 
918             // size of the structure for every process
919             CurrentSize = sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION) * ThreadsCount;
920             ImageNameLength = 0;
921             Status = SeLocateProcessImageName(Process, &TempProcessImageName);
922             ProcessImageName = TempProcessImageName;
923             szSrc = NULL;
924             if (NT_SUCCESS(Status) && (ProcessImageName->Length > 0))
925             {
926               szSrc = (PWCHAR)((PCHAR)ProcessImageName->Buffer + ProcessImageName->Length);
927               /* Loop the file name*/
928               while (szSrc > ProcessImageName->Buffer)
929               {
930                 /* Make sure this isn't a backslash */
931                 if (*--szSrc == OBJ_NAME_PATH_SEPARATOR)
932                 {
933                     szSrc++;
934                     break;
935                 }
936                 else
937                 {
938                     ImageNameLength += sizeof(WCHAR);
939                 }
940               }
941             }
942             if (!ImageNameLength && Process != PsIdleProcess)
943             {
944               ImageNameLength = (USHORT)strlen(Process->ImageFileName) * sizeof(WCHAR);
945             }
946 
947             /* Round up the image name length as NT does */
948             if (ImageNameLength > 0)
949                 ImageNameMaximumLength = ROUND_UP(ImageNameLength + sizeof(WCHAR), 8);
950             else
951                 ImageNameMaximumLength = 0;
952 
953             TotalSize += CurrentSize + ImageNameMaximumLength;
954 
955             /* Check for overflow */
956             if (TotalSize > Size)
957             {
958                 Overflow = TRUE;
959             }
960 
961             /* Fill system information */
962             if (!Overflow)
963             {
964                 SpiCurrent->NextEntryOffset = CurrentSize + ImageNameMaximumLength; // relative offset to the beginning of the next structure
965                 SpiCurrent->NumberOfThreads = ThreadsCount;
966                 SpiCurrent->CreateTime = Process->CreateTime;
967                 SpiCurrent->ImageName.Length = ImageNameLength;
968                 SpiCurrent->ImageName.MaximumLength = ImageNameMaximumLength;
969                 SpiCurrent->ImageName.Buffer = (void*)(Current + CurrentSize);
970 
971                 /* Copy name to the end of the struct */
972                 if(Process != PsIdleProcess)
973                 {
974                     if (szSrc)
975                     {
976                         RtlCopyMemory(SpiCurrent->ImageName.Buffer, szSrc, SpiCurrent->ImageName.Length);
977                     }
978                     else
979                     {
980                         RtlInitAnsiString(&ImageName, Process->ImageFileName);
981                         RtlAnsiStringToUnicodeString(&SpiCurrent->ImageName, &ImageName, FALSE);
982                     }
983                 }
984                 else
985                 {
986                     RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
987                 }
988 
989                 SpiCurrent->BasePriority = Process->Pcb.BasePriority;
990                 SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
991                 SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
992                 SpiCurrent->HandleCount = ObGetProcessHandleCount(Process);
993                 SpiCurrent->PeakVirtualSize = Process->PeakVirtualSize;
994                 SpiCurrent->VirtualSize = Process->VirtualSize;
995                 SpiCurrent->PageFaultCount = Process->Vm.PageFaultCount;
996                 SpiCurrent->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
997                 SpiCurrent->WorkingSetSize = Process->Vm.WorkingSetSize;
998                 SpiCurrent->QuotaPeakPagedPoolUsage = Process->QuotaPeak[0];
999                 SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[0];
1000                 SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[1];
1001                 SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[1];
1002                 SpiCurrent->PagefileUsage = Process->QuotaUsage[2];
1003                 SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[2];
1004                 SpiCurrent->PrivatePageCount = Process->CommitCharge;
1005                 ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCurrent + 1);
1006 
1007                 CurrentEntry = Process->Pcb.ThreadListHead.Flink;
1008                 while (CurrentEntry != &Process->Pcb.ThreadListHead)
1009                 {
1010                     CurrentThread = CONTAINING_RECORD(CurrentEntry, ETHREAD, Tcb.ThreadListEntry);
1011 
1012                     ThreadInfo->KernelTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.KernelTime, KeMaximumIncrement);
1013                     ThreadInfo->UserTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.UserTime, KeMaximumIncrement);
1014                     ThreadInfo->CreateTime.QuadPart = CurrentThread->CreateTime.QuadPart;
1015                     ThreadInfo->WaitTime = CurrentThread->Tcb.WaitTime;
1016                     ThreadInfo->StartAddress = (PVOID) CurrentThread->StartAddress;
1017                     ThreadInfo->ClientId = CurrentThread->Cid;
1018                     ThreadInfo->Priority = CurrentThread->Tcb.Priority;
1019                     ThreadInfo->BasePriority = CurrentThread->Tcb.BasePriority;
1020                     ThreadInfo->ContextSwitches = CurrentThread->Tcb.ContextSwitches;
1021                     ThreadInfo->ThreadState = CurrentThread->Tcb.State;
1022                     ThreadInfo->WaitReason = CurrentThread->Tcb.WaitReason;
1023 
1024                     ThreadInfo++;
1025                     CurrentEntry = CurrentEntry->Flink;
1026                 }
1027 
1028                 /* Query total user/kernel times of a process */
1029                 TotalKernel = KeQueryRuntimeProcess(&Process->Pcb, &TotalUser);
1030                 SpiCurrent->UserTime.QuadPart = UInt32x32To64(TotalUser, KeMaximumIncrement);
1031                 SpiCurrent->KernelTime.QuadPart = UInt32x32To64(TotalKernel, KeMaximumIncrement);
1032             }
1033 
1034             if (ProcessImageName)
1035             {
1036                 /* Release the memory allocated by SeLocateProcessImageName */
1037                 ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
1038                 ProcessImageName = NULL;
1039             }
1040 
1041             /* Unlock the Process */
1042             ExReleasePushLockShared(&Process->ProcessLock);
1043             KeLeaveCriticalRegion();
1044 
1045             /* Handle idle process entry */
1046 Skip:
1047             if (Process == PsIdleProcess) Process = NULL;
1048 
1049             Process = PsGetNextProcess(Process);
1050             ThreadsCount = 0;
1051             if ((Process == SystemProcess) || (Process == NULL))
1052             {
1053                 if (!Overflow)
1054                     SpiCurrent->NextEntryOffset = 0;
1055                 break;
1056             }
1057             else
1058                 Current += CurrentSize + ImageNameMaximumLength;
1059           }  while ((Process != SystemProcess) && (Process != NULL));
1060 
1061           if(Process != NULL)
1062             ObDereferenceObject(Process);
1063           Status = STATUS_SUCCESS;
1064     }
1065     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1066     {
1067         if(Process != NULL)
1068             ObDereferenceObject(Process);
1069         if (ProcessImageName)
1070         {
1071             /* Release the memory allocated by SeLocateProcessImageName */
1072             ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
1073         }
1074 
1075         Status = _SEH2_GetExceptionCode();
1076     }
1077     _SEH2_END
1078 
1079     if (Overflow)
1080         Status = STATUS_INFO_LENGTH_MISMATCH;
1081 
1082     *ReqSize = TotalSize;
1083     return Status;
1084 }
1085 
1086 /* Class 6 - Call Count Information */
1087 QSI_DEF(SystemCallCountInformation)
1088 {
1089     /* FIXME */
1090     DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
1091     return STATUS_NOT_IMPLEMENTED;
1092 }
1093 
1094 /* Class 7 - Device Information */
1095 QSI_DEF(SystemDeviceInformation)
1096 {
1097     PSYSTEM_DEVICE_INFORMATION Sdi
1098         = (PSYSTEM_DEVICE_INFORMATION) Buffer;
1099     PCONFIGURATION_INFORMATION ConfigInfo;
1100 
1101     *ReqSize = sizeof(SYSTEM_DEVICE_INFORMATION);
1102 
1103     /* Check user buffer's size */
1104     if (Size < sizeof(SYSTEM_DEVICE_INFORMATION))
1105     {
1106         return STATUS_INFO_LENGTH_MISMATCH;
1107     }
1108 
1109     ConfigInfo = IoGetConfigurationInformation();
1110 
1111     Sdi->NumberOfDisks = ConfigInfo->DiskCount;
1112     Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
1113     Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
1114     Sdi->NumberOfTapes = ConfigInfo->TapeCount;
1115     Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
1116     Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
1117 
1118     return STATUS_SUCCESS;
1119 }
1120 
1121 /* Class 8 - Processor Performance Information */
1122 QSI_DEF(SystemProcessorPerformanceInformation)
1123 {
1124     PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
1125         = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
1126 
1127     LONG i;
1128     ULONG TotalTime;
1129     PKPRCB Prcb;
1130 
1131     *ReqSize = KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
1132 
1133     /* Check user buffer's size */
1134     if (Size < *ReqSize)
1135     {
1136         return STATUS_INFO_LENGTH_MISMATCH;
1137     }
1138 
1139     for (i = 0; i < KeNumberProcessors; i++)
1140     {
1141         /* Get the PRCB on this processor */
1142         Prcb = KiProcessorBlock[i];
1143 
1144         /* Calculate total user and kernel times */
1145         TotalTime = Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime;
1146         Spi->IdleTime.QuadPart = UInt32x32To64(TotalTime, KeMaximumIncrement);
1147         Spi->KernelTime.QuadPart =  UInt32x32To64(Prcb->KernelTime, KeMaximumIncrement);
1148         Spi->UserTime.QuadPart = UInt32x32To64(Prcb->UserTime, KeMaximumIncrement);
1149         Spi->DpcTime.QuadPart = UInt32x32To64(Prcb->DpcTime, KeMaximumIncrement);
1150         Spi->InterruptTime.QuadPart = UInt32x32To64(Prcb->InterruptTime, KeMaximumIncrement);
1151         Spi->InterruptCount = Prcb->InterruptCount;
1152         Spi++;
1153     }
1154 
1155     return STATUS_SUCCESS;
1156 }
1157 
1158 /* Class 9 - Flags Information */
1159 QSI_DEF(SystemFlagsInformation)
1160 {
1161 #if (NTDDI_VERSION >= NTDDI_VISTA)
1162     *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1163 #endif
1164 
1165     if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1166     {
1167         return STATUS_INFO_LENGTH_MISMATCH;
1168     }
1169 
1170     ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
1171 #if (NTDDI_VERSION < NTDDI_VISTA)
1172     *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1173 #endif
1174 
1175     return STATUS_SUCCESS;
1176 }
1177 
1178 SSI_DEF(SystemFlagsInformation)
1179 {
1180     if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1181     {
1182         return STATUS_INFO_LENGTH_MISMATCH;
1183     }
1184 
1185     if (!SeSinglePrivilegeCheck(SeDebugPrivilege, ExGetPreviousMode()))
1186     {
1187         return STATUS_ACCESS_DENIED;
1188     }
1189 
1190     NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
1191     return STATUS_SUCCESS;
1192 }
1193 
1194 /* Class 10 - Call Time Information */
1195 QSI_DEF(SystemCallTimeInformation)
1196 {
1197     /* FIXME */
1198     DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
1199     return STATUS_NOT_IMPLEMENTED;
1200 }
1201 
1202 /* Class 11 - Module Information */
1203 QSI_DEF(SystemModuleInformation)
1204 {
1205     NTSTATUS Status;
1206 
1207     /* Acquire system module list lock */
1208     KeEnterCriticalRegion();
1209     ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE);
1210 
1211     /* Call the generic handler with the system module list */
1212     Status = ExpQueryModuleInformation(&PsLoadedModuleList,
1213                                        &MmLoadedUserImageList,
1214                                        (PRTL_PROCESS_MODULES)Buffer,
1215                                        Size,
1216                                        ReqSize);
1217 
1218     /* Release list lock and return status */
1219     ExReleaseResourceLite(&PsLoadedModuleResource);
1220     KeLeaveCriticalRegion();
1221     return Status;
1222 }
1223 
1224 /* Class 12 - Locks Information */
1225 QSI_DEF(SystemLocksInformation)
1226 {
1227     /* FIXME */
1228     DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
1229     return STATUS_NOT_IMPLEMENTED;
1230 }
1231 
1232 /* Class 13 - Stack Trace Information */
1233 QSI_DEF(SystemStackTraceInformation)
1234 {
1235     /* FIXME */
1236     DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
1237     return STATUS_NOT_IMPLEMENTED;
1238 }
1239 
1240 /* Class 14 - Paged Pool Information */
1241 QSI_DEF(SystemPagedPoolInformation)
1242 {
1243     /* FIXME */
1244     DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
1245     return STATUS_NOT_IMPLEMENTED;
1246 }
1247 
1248 /* Class 15 - Non Paged Pool Information */
1249 QSI_DEF(SystemNonPagedPoolInformation)
1250 {
1251     /* FIXME */
1252     DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
1253     return STATUS_NOT_IMPLEMENTED;
1254 }
1255 
1256 
1257 /* Class 16 - Handle Information */
1258 QSI_DEF(SystemHandleInformation)
1259 {
1260     PSYSTEM_HANDLE_INFORMATION HandleInformation;
1261     PLIST_ENTRY NextTableEntry;
1262     PHANDLE_TABLE HandleTable;
1263     PHANDLE_TABLE_ENTRY HandleTableEntry;
1264     EXHANDLE Handle;
1265     ULONG Index = 0;
1266     NTSTATUS Status;
1267     PMDL Mdl;
1268     PAGED_CODE();
1269 
1270     DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1271 
1272     /* Set initial required buffer size */
1273     *ReqSize = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handles);
1274 
1275     /* Check user's buffer size */
1276     if (Size < *ReqSize)
1277     {
1278         return STATUS_INFO_LENGTH_MISMATCH;
1279     }
1280 
1281     /* We need to lock down the memory */
1282     Status = ExLockUserBuffer(Buffer,
1283                               Size,
1284                               ExGetPreviousMode(),
1285                               IoWriteAccess,
1286                               (PVOID*)&HandleInformation,
1287                               &Mdl);
1288     if (!NT_SUCCESS(Status))
1289     {
1290         DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
1291         return Status;
1292     }
1293 
1294     /* Reset of count of handles */
1295     HandleInformation->NumberOfHandles = 0;
1296 
1297     /* Enter a critical region */
1298     KeEnterCriticalRegion();
1299 
1300     /* Acquire the handle table lock */
1301     ExAcquirePushLockShared(&HandleTableListLock);
1302 
1303     /* Enumerate all system handles */
1304     for (NextTableEntry = HandleTableListHead.Flink;
1305          NextTableEntry != &HandleTableListHead;
1306          NextTableEntry = NextTableEntry->Flink)
1307     {
1308         /* Get current handle table */
1309         HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
1310 
1311         /* Set the initial value and loop the entries */
1312         Handle.Value = 0;
1313         while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
1314         {
1315             /* Validate the entry */
1316             if ((HandleTableEntry->Object) &&
1317                 (HandleTableEntry->NextFreeTableEntry != -2))
1318             {
1319                 /* Increase of count of handles */
1320                 ++HandleInformation->NumberOfHandles;
1321 
1322                 /* Lock the entry */
1323                 if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
1324                 {
1325                     /* Increase required buffer size */
1326                     *ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO);
1327 
1328                     /* Check user's buffer size */
1329                     if (*ReqSize > Size)
1330                     {
1331                         Status = STATUS_INFO_LENGTH_MISMATCH;
1332                     }
1333                     else
1334                     {
1335                         POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
1336 
1337                         /* Filling handle information */
1338                         HandleInformation->Handles[Index].UniqueProcessId =
1339                             (USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
1340 
1341                         HandleInformation->Handles[Index].CreatorBackTraceIndex = 0;
1342 
1343 #if 0 /* FIXME!!! Type field currupted */
1344                         HandleInformation->Handles[Index].ObjectTypeIndex =
1345                             (UCHAR) ObjectHeader->Type->Index;
1346 #else
1347                         HandleInformation->Handles[Index].ObjectTypeIndex = 0;
1348 #endif
1349 
1350                         HandleInformation->Handles[Index].HandleAttributes =
1351                             HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
1352 
1353                         HandleInformation->Handles[Index].HandleValue =
1354                             (USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
1355 
1356                         HandleInformation->Handles[Index].Object = &ObjectHeader->Body;
1357 
1358                         HandleInformation->Handles[Index].GrantedAccess =
1359                             HandleTableEntry->GrantedAccess;
1360 
1361                         ++Index;
1362                     }
1363 
1364                     /* Unlock it */
1365                     ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
1366                 }
1367             }
1368 
1369             /* Go to the next entry */
1370             Handle.Value += sizeof(HANDLE);
1371         }
1372     }
1373 
1374     /* Release the lock */
1375     ExReleasePushLockShared(&HandleTableListLock);
1376 
1377     /* Leave the critical region */
1378     KeLeaveCriticalRegion();
1379 
1380     /* Release the locked user buffer */
1381     ExUnlockUserBuffer(Mdl);
1382 
1383     return Status;
1384 }
1385 
1386 /* Class 17 -  Information */
1387 QSI_DEF(SystemObjectInformation)
1388 {
1389     /* FIXME */
1390     DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1391     return STATUS_NOT_IMPLEMENTED;
1392 }
1393 
1394 /* Class 18 -  Information */
1395 QSI_DEF(SystemPageFileInformation)
1396 {
1397     UNICODE_STRING FileName; /* FIXME */
1398     SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
1399 
1400     if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
1401     {
1402         * ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
1403         return STATUS_INFO_LENGTH_MISMATCH;
1404     }
1405 
1406     RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1407 
1408     /* FIXME */
1409     Spfi->NextEntryOffset = 0;
1410 
1411     Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
1412     Spfi->TotalInUse = MiUsedSwapPages;
1413     Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1414     Spfi->PageFileName = FileName;
1415     return STATUS_SUCCESS;
1416 }
1417 
1418 /* Class 19 - Vdm Instemul Information */
1419 QSI_DEF(SystemVdmInstemulInformation)
1420 {
1421     /* FIXME */
1422     DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1423     return STATUS_NOT_IMPLEMENTED;
1424 }
1425 
1426 /* Class 20 - Vdm Bop Information */
1427 QSI_DEF(SystemVdmBopInformation)
1428 {
1429     /* FIXME */
1430     DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1431     return STATUS_NOT_IMPLEMENTED;
1432 }
1433 
1434 /* Class 21 - File Cache Information */
1435 QSI_DEF(SystemFileCacheInformation)
1436 {
1437     SYSTEM_FILECACHE_INFORMATION *Sci = (SYSTEM_FILECACHE_INFORMATION *) Buffer;
1438 
1439     *ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
1440 
1441     if (Size < *ReqSize)
1442     {
1443         return STATUS_INFO_LENGTH_MISMATCH;
1444     }
1445 
1446     RtlZeroMemory(Sci, sizeof(SYSTEM_FILECACHE_INFORMATION));
1447 
1448     /* Return the Byte size not the page size. */
1449     Sci->CurrentSize =
1450         MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
1451     Sci->PeakSize =
1452             MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
1453     /* Taskmgr multiplies this one by page size right away */
1454     Sci->CurrentSizeIncludingTransitionInPages =
1455         MiMemoryConsumers[MC_CACHE].PagesUsed; /* FIXME: Should be */
1456     /* system working set and standby pages. */
1457     Sci->PageFaultCount = 0; /* FIXME */
1458     Sci->MinimumWorkingSet = 0; /* FIXME */
1459     Sci->MaximumWorkingSet = 0; /* FIXME */
1460 
1461     return STATUS_SUCCESS;
1462 }
1463 
1464 SSI_DEF(SystemFileCacheInformation)
1465 {
1466     if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1467     {
1468         return STATUS_INFO_LENGTH_MISMATCH;
1469     }
1470     /* FIXME */
1471     DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1472     return STATUS_NOT_IMPLEMENTED;
1473 }
1474 
1475 /* Class 22 - Pool Tag Information */
1476 QSI_DEF(SystemPoolTagInformation)
1477 {
1478     if (Size < sizeof(SYSTEM_POOLTAG_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
1479     return ExGetPoolTagInfo(Buffer, Size, ReqSize);
1480 }
1481 
1482 /* Class 23 - Interrupt Information for all processors */
1483 QSI_DEF(SystemInterruptInformation)
1484 {
1485     PKPRCB Prcb;
1486     LONG i;
1487     ULONG ti;
1488     PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1489 
1490     if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1491     {
1492         return STATUS_INFO_LENGTH_MISMATCH;
1493     }
1494 
1495     ti = KeQueryTimeIncrement();
1496 
1497     for (i = 0; i < KeNumberProcessors; i++)
1498     {
1499         Prcb = KiProcessorBlock[i];
1500         sii->ContextSwitches = KeGetContextSwitches(Prcb);
1501         sii->DpcCount = Prcb->DpcData[0].DpcCount;
1502         sii->DpcRate = Prcb->DpcRequestRate;
1503         sii->TimeIncrement = ti;
1504         sii->DpcBypassCount = 0;
1505         sii->ApcBypassCount = 0;
1506         sii++;
1507     }
1508 
1509     return STATUS_SUCCESS;
1510 }
1511 
1512 /* Class 24 - DPC Behaviour Information */
1513 QSI_DEF(SystemDpcBehaviourInformation)
1514 {
1515     /* FIXME */
1516     DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1517     return STATUS_NOT_IMPLEMENTED;
1518 }
1519 
1520 SSI_DEF(SystemDpcBehaviourInformation)
1521 {
1522     /* FIXME */
1523     DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1524     return STATUS_NOT_IMPLEMENTED;
1525 }
1526 
1527 /* Class 25 - Full Memory Information */
1528 QSI_DEF(SystemFullMemoryInformation)
1529 {
1530     PULONG Spi = (PULONG) Buffer;
1531 
1532     PEPROCESS TheIdleProcess;
1533 
1534     *ReqSize = sizeof(ULONG);
1535 
1536     if (sizeof(ULONG) != Size)
1537     {
1538         return STATUS_INFO_LENGTH_MISMATCH;
1539     }
1540 
1541     DPRINT("SystemFullMemoryInformation\n");
1542 
1543     TheIdleProcess = PsIdleProcess;
1544 
1545     DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
1546            TheIdleProcess->UniqueProcessId,
1547            TheIdleProcess->Pcb.KernelTime,
1548            MiFreeSwapPages,
1549            MiUsedSwapPages);
1550 
1551     *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1552 
1553     return STATUS_SUCCESS;
1554 }
1555 
1556 /* Class 26 - Load Image */
1557 SSI_DEF(SystemLoadGdiDriverInformation)
1558 {
1559     PSYSTEM_GDI_DRIVER_INFORMATION DriverInfo = (PVOID)Buffer;
1560     UNICODE_STRING ImageName;
1561     PVOID ImageBase;
1562     PVOID SectionPointer;
1563     ULONG_PTR EntryPoint;
1564     NTSTATUS Status;
1565     ULONG DirSize;
1566     PIMAGE_NT_HEADERS NtHeader;
1567 
1568     /* Validate size */
1569     if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1570     {
1571         /* Incorrect buffer length, fail */
1572         return STATUS_INFO_LENGTH_MISMATCH;
1573     }
1574 
1575     /* Only kernel mode can call this function */
1576     if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1577 
1578     /* Load the driver */
1579     ImageName = DriverInfo->DriverName;
1580     Status = MmLoadSystemImage(&ImageName,
1581                                NULL,
1582                                NULL,
1583                                0,
1584                                &SectionPointer,
1585                                &ImageBase);
1586     if (!NT_SUCCESS(Status)) return Status;
1587 
1588     /* Return the export pointer */
1589     DriverInfo->ExportSectionPointer =
1590         RtlImageDirectoryEntryToData(ImageBase,
1591                                      TRUE,
1592                                      IMAGE_DIRECTORY_ENTRY_EXPORT,
1593                                      &DirSize);
1594 
1595     /* Get the entrypoint */
1596     NtHeader = RtlImageNtHeader(ImageBase);
1597     EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1598     EntryPoint += (ULONG_PTR)ImageBase;
1599 
1600     /* Save other data */
1601     DriverInfo->ImageAddress = ImageBase;
1602     DriverInfo->SectionPointer = SectionPointer;
1603     DriverInfo->EntryPoint = (PVOID)EntryPoint;
1604     DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1605 
1606     /* All is good */
1607     return STATUS_SUCCESS;
1608 }
1609 
1610 /* Class 27 - Unload Image */
1611 SSI_DEF(SystemUnloadGdiDriverInformation)
1612 {
1613     PVOID *SectionPointer = Buffer;
1614 
1615     /* Validate size */
1616     if (Size != sizeof(PVOID))
1617     {
1618         /* Incorrect length, fail */
1619         return STATUS_INFO_LENGTH_MISMATCH;
1620     }
1621 
1622     /* Only kernel mode can call this function */
1623     if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1624 
1625     /* Unload the image */
1626     MmUnloadSystemImage(*SectionPointer);
1627     return STATUS_SUCCESS;
1628 }
1629 
1630 /* Class 28 - Time Adjustment Information */
1631 QSI_DEF(SystemTimeAdjustmentInformation)
1632 {
1633     PSYSTEM_QUERY_TIME_ADJUST_INFORMATION TimeInfo =
1634         (PSYSTEM_QUERY_TIME_ADJUST_INFORMATION)Buffer;
1635 
1636     /* Check if enough storage was provided */
1637     if (sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION) > Size)
1638     {
1639         * ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
1640         return STATUS_INFO_LENGTH_MISMATCH;
1641     }
1642 
1643     /* Give time values to our caller */
1644     TimeInfo->TimeIncrement = KeMaximumIncrement;
1645     TimeInfo->TimeAdjustment = KeTimeAdjustment;
1646     TimeInfo->Enable = !KiTimeAdjustmentEnabled;
1647 
1648     return STATUS_SUCCESS;
1649 }
1650 
1651 SSI_DEF(SystemTimeAdjustmentInformation)
1652 {
1653     KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1654     PSYSTEM_SET_TIME_ADJUST_INFORMATION TimeInfo =
1655         (PSYSTEM_SET_TIME_ADJUST_INFORMATION)Buffer;
1656 
1657     /* Check size of a buffer, it must match our expectations */
1658     if (sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION) != Size)
1659         return STATUS_INFO_LENGTH_MISMATCH;
1660 
1661     /* Check who is calling */
1662     if (PreviousMode != KernelMode)
1663     {
1664         /* Check access rights */
1665         if (!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
1666         {
1667             return STATUS_PRIVILEGE_NOT_HELD;
1668         }
1669     }
1670 
1671     /* FIXME: behaviour suggests the member be named 'Disable' */
1672     if (TimeInfo->Enable)
1673     {
1674         /* Disable time adjustment and set default value */
1675         KiTimeAdjustmentEnabled = FALSE;
1676         KeTimeAdjustment = KeMaximumIncrement;
1677     }
1678     else
1679     {
1680         /* Check if a valid time adjustment value is given */
1681         if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
1682 
1683         /* Enable time adjustment and set the adjustment value */
1684         KiTimeAdjustmentEnabled = TRUE;
1685         KeTimeAdjustment = TimeInfo->TimeAdjustment;
1686     }
1687 
1688     return STATUS_SUCCESS;
1689 }
1690 
1691 /* Class 29 - Summary Memory Information */
1692 QSI_DEF(SystemSummaryMemoryInformation)
1693 {
1694     /* FIXME */
1695     DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1696     return STATUS_NOT_IMPLEMENTED;
1697 }
1698 
1699 /* Class 30 - Next Event Id Information */
1700 QSI_DEF(SystemNextEventIdInformation)
1701 {
1702     /* FIXME */
1703     DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1704     return STATUS_NOT_IMPLEMENTED;
1705 }
1706 
1707 /* Class 31 */
1708 QSI_DEF(SystemPerformanceTraceInformation)
1709 {
1710     /* FIXME */
1711     DPRINT1("NtQuerySystemInformation - SystemPerformanceTraceInformation not implemented\n");
1712     return STATUS_NOT_IMPLEMENTED;
1713 }
1714 
1715 /* Class 32 - Crash Dump Information */
1716 QSI_DEF(SystemCrashDumpInformation)
1717 {
1718     /* FIXME */
1719     DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1720     return STATUS_NOT_IMPLEMENTED;
1721 }
1722 
1723 /* Class 33 - Exception Information */
1724 QSI_DEF(SystemExceptionInformation)
1725 {
1726     PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
1727         (PSYSTEM_EXCEPTION_INFORMATION)Buffer;
1728     PKPRCB Prcb;
1729     ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
1730     ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
1731     CHAR i;
1732 
1733     /* Check size of a buffer, it must match our expectations */
1734     if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
1735         return STATUS_INFO_LENGTH_MISMATCH;
1736 
1737     /* Sum up exception count information from all processors */
1738     for (i = 0; i < KeNumberProcessors; i++)
1739     {
1740         Prcb = KiProcessorBlock[i];
1741         if (Prcb)
1742         {
1743             AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
1744             ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
1745 #ifndef _M_ARM
1746             FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
1747 #endif // _M_ARM
1748         }
1749     }
1750 
1751     /* Save information in user's buffer */
1752     ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
1753     ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
1754     ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
1755     ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
1756 
1757     return STATUS_SUCCESS;
1758 }
1759 
1760 /* Class 34 - Crash Dump State Information */
1761 QSI_DEF(SystemCrashDumpStateInformation)
1762 {
1763     /* FIXME */
1764     DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1765     return STATUS_NOT_IMPLEMENTED;
1766 }
1767 
1768 /* Class 35 - Kernel Debugger Information */
1769 QSI_DEF(SystemKernelDebuggerInformation)
1770 {
1771     PSYSTEM_KERNEL_DEBUGGER_INFORMATION skdi = (PSYSTEM_KERNEL_DEBUGGER_INFORMATION) Buffer;
1772 
1773 #if (NTDDI_VERSION >= NTDDI_VISTA)
1774     *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1775 #endif
1776 
1777     if (Size < sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION))
1778     {
1779         return STATUS_INFO_LENGTH_MISMATCH;
1780     }
1781 
1782     skdi->KernelDebuggerEnabled = KD_DEBUGGER_ENABLED;
1783     skdi->KernelDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
1784 
1785 #if (NTDDI_VERSION < NTDDI_VISTA)
1786     *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1787 #endif
1788 
1789     return STATUS_SUCCESS;
1790 }
1791 
1792 /* Class 36 - Context Switch Information */
1793 QSI_DEF(SystemContextSwitchInformation)
1794 {
1795     PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
1796         (PSYSTEM_CONTEXT_SWITCH_INFORMATION)Buffer;
1797     ULONG ContextSwitches;
1798     PKPRCB Prcb;
1799     CHAR i;
1800 
1801     /* Check size of a buffer, it must match our expectations */
1802     if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
1803         return STATUS_INFO_LENGTH_MISMATCH;
1804 
1805     /* Calculate total value of context switches across all processors */
1806     ContextSwitches = 0;
1807     for (i = 0; i < KeNumberProcessors; i ++)
1808     {
1809         Prcb = KiProcessorBlock[i];
1810         if (Prcb)
1811         {
1812             ContextSwitches += KeGetContextSwitches(Prcb);
1813         }
1814     }
1815 
1816     ContextSwitchInformation->ContextSwitches = ContextSwitches;
1817 
1818     /* FIXME */
1819     ContextSwitchInformation->FindAny = 0;
1820     ContextSwitchInformation->FindLast = 0;
1821     ContextSwitchInformation->FindIdeal = 0;
1822     ContextSwitchInformation->IdleAny = 0;
1823     ContextSwitchInformation->IdleCurrent = 0;
1824     ContextSwitchInformation->IdleLast = 0;
1825     ContextSwitchInformation->IdleIdeal = 0;
1826     ContextSwitchInformation->PreemptAny = 0;
1827     ContextSwitchInformation->PreemptCurrent = 0;
1828     ContextSwitchInformation->PreemptLast = 0;
1829     ContextSwitchInformation->SwitchToIdle = 0;
1830 
1831     return STATUS_SUCCESS;
1832 }
1833 
1834 /* Class 37 - Registry Quota Information */
1835 QSI_DEF(SystemRegistryQuotaInformation)
1836 {
1837     PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1838 
1839     *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1840     if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1841     {
1842         return STATUS_INFO_LENGTH_MISMATCH;
1843     }
1844 
1845     DPRINT1("Faking max registry size of 32 MB\n");
1846     srqi->RegistryQuotaAllowed = 0x2000000;
1847     srqi->RegistryQuotaUsed = 0x200000;
1848     srqi->PagedPoolSize = 0x200000;
1849 
1850     return STATUS_SUCCESS;
1851 }
1852 
1853 SSI_DEF(SystemRegistryQuotaInformation)
1854 {
1855     /* FIXME */
1856     DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1857     return STATUS_NOT_IMPLEMENTED;
1858 }
1859 
1860 /* Class 38 - Load And Call Image */
1861 SSI_DEF(SystemExtendServiceTableInformation)
1862 {
1863     UNICODE_STRING ImageName;
1864     KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1865     PLDR_DATA_TABLE_ENTRY ModuleObject;
1866     NTSTATUS Status;
1867     PIMAGE_NT_HEADERS NtHeader;
1868     DRIVER_OBJECT Win32k;
1869     PDRIVER_INITIALIZE DriverInit;
1870     PVOID ImageBase;
1871     ULONG_PTR EntryPoint;
1872 
1873     /* Validate the size */
1874     if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1875 
1876     /* Check who is calling */
1877     if (PreviousMode != KernelMode)
1878     {
1879         static const UNICODE_STRING Win32kName =
1880             RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
1881 
1882         /* Make sure we can load drivers */
1883         if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, UserMode))
1884         {
1885             /* FIXME: We can't, fail */
1886             return STATUS_PRIVILEGE_NOT_HELD;
1887         }
1888 
1889         _SEH2_TRY
1890         {
1891             /* Probe and copy the unicode string */
1892             ProbeForRead(Buffer, sizeof(ImageName), 1);
1893             ImageName = *(PUNICODE_STRING)Buffer;
1894 
1895             /* Probe the string buffer */
1896             ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
1897 
1898             /* Check if we have the correct name (nothing else is allowed!) */
1899             if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
1900             {
1901                 _SEH2_YIELD(return STATUS_PRIVILEGE_NOT_HELD);
1902             }
1903         }
1904         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1905         {
1906             _SEH2_YIELD(return _SEH2_GetExceptionCode());
1907         }
1908         _SEH2_END;
1909 
1910         /* Recursively call the function, so that we are from kernel mode */
1911         return ZwSetSystemInformation(SystemExtendServiceTableInformation,
1912                                       (PVOID)&Win32kName,
1913                                       sizeof(Win32kName));
1914     }
1915 
1916     /* Load the image */
1917     Status = MmLoadSystemImage((PUNICODE_STRING)Buffer,
1918                                NULL,
1919                                NULL,
1920                                0,
1921                                (PVOID)&ModuleObject,
1922                                &ImageBase);
1923 
1924     if (!NT_SUCCESS(Status)) return Status;
1925 
1926     /* Get the headers */
1927     NtHeader = RtlImageNtHeader(ImageBase);
1928     if (!NtHeader)
1929     {
1930         /* Fail */
1931         MmUnloadSystemImage(ModuleObject);
1932         return STATUS_INVALID_IMAGE_FORMAT;
1933     }
1934 
1935     /* Get the entrypoint */
1936     EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1937     EntryPoint += (ULONG_PTR)ImageBase;
1938     DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1939 
1940     /* Create a dummy device */
1941     RtlZeroMemory(&Win32k, sizeof(Win32k));
1942     ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1943     Win32k.DriverStart = ImageBase;
1944 
1945     /* Call it */
1946     Status = (DriverInit)(&Win32k, NULL);
1947     ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1948 
1949     /* Unload if we failed */
1950     if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
1951     return Status;
1952 }
1953 
1954 /* Class 39 - Priority Separation */
1955 SSI_DEF(SystemPrioritySeperation)
1956 {
1957     /* Check if the size is correct */
1958     if (Size != sizeof(ULONG))
1959     {
1960         return STATUS_INFO_LENGTH_MISMATCH;
1961     }
1962 
1963     /* We need the TCB privilege */
1964     if (!SeSinglePrivilegeCheck(SeTcbPrivilege, ExGetPreviousMode()))
1965     {
1966         return STATUS_PRIVILEGE_NOT_HELD;
1967     }
1968 
1969     /* Modify the quantum table */
1970     PsChangeQuantumTable(TRUE, *(PULONG)Buffer);
1971 
1972     return STATUS_SUCCESS;
1973 }
1974 
1975 /* Class 40 */
1976 QSI_DEF(SystemVerifierAddDriverInformation)
1977 {
1978     /* FIXME */
1979     DPRINT1("NtQuerySystemInformation - SystemVerifierAddDriverInformation not implemented\n");
1980     return STATUS_NOT_IMPLEMENTED;
1981 }
1982 
1983 /* Class 41 */
1984 QSI_DEF(SystemVerifierRemoveDriverInformation)
1985 {
1986     /* FIXME */
1987     DPRINT1("NtQuerySystemInformation - SystemVerifierRemoveDriverInformation not implemented\n");
1988     return STATUS_NOT_IMPLEMENTED;
1989 }
1990 
1991 /* Class 42 - Power Information */
1992 QSI_DEF(SystemProcessorIdleInformation)
1993 {
1994     *ReqSize = sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors;
1995 
1996     if (sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors > Size)
1997     {
1998         return STATUS_INFO_LENGTH_MISMATCH;
1999     }
2000 
2001     /* FIXME */
2002     DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
2003     return STATUS_NOT_IMPLEMENTED;
2004 }
2005 
2006 /* Class 43 */
2007 QSI_DEF(SystemLegacyDriverInformation)
2008 {
2009     /* FIXME */
2010     DPRINT1("NtQuerySystemInformation - SystemLegacyDriverInformation not implemented\n");
2011     return STATUS_NOT_IMPLEMENTED;
2012 }
2013 
2014 /* Class 44 - Current Time Zone Information */
2015 QSI_DEF(SystemCurrentTimeZoneInformation)
2016 {
2017     *ReqSize = sizeof(RTL_TIME_ZONE_INFORMATION);
2018 
2019     if (sizeof(RTL_TIME_ZONE_INFORMATION) != Size)
2020     {
2021         return STATUS_INFO_LENGTH_MISMATCH;
2022     }
2023 
2024     /* Copy the time zone information struct */
2025     memcpy(Buffer,
2026            &ExpTimeZoneInfo,
2027            sizeof(RTL_TIME_ZONE_INFORMATION));
2028 
2029     return STATUS_SUCCESS;
2030 }
2031 
2032 
2033 SSI_DEF(SystemCurrentTimeZoneInformation)
2034 {
2035     /* Check user buffer's size */
2036     if (Size < sizeof(RTL_TIME_ZONE_INFORMATION))
2037     {
2038         return STATUS_INFO_LENGTH_MISMATCH;
2039     }
2040 
2041     return ExpSetTimeZoneInformation((PRTL_TIME_ZONE_INFORMATION)Buffer);
2042 }
2043 
2044 static
2045 VOID
2046 ExpCopyLookasideInformation(
2047     PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
2048     PULONG RemainingPointer,
2049     PLIST_ENTRY ListHead,
2050     BOOLEAN ListUsesMisses)
2051 
2052 {
2053     PSYSTEM_LOOKASIDE_INFORMATION Info;
2054     PGENERAL_LOOKASIDE LookasideList;
2055     PLIST_ENTRY ListEntry;
2056     ULONG Remaining;
2057 
2058     /* Get info pointer and remaining count of free array element */
2059     Info = *InfoPointer;
2060     Remaining = *RemainingPointer;
2061 
2062     /* Loop as long as we have lookaside lists and free array elements */
2063     for (ListEntry = ListHead->Flink;
2064          (ListEntry != ListHead) && (Remaining > 0);
2065          ListEntry = ListEntry->Flink, Remaining--)
2066     {
2067         LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
2068 
2069         /* Fill the next array element */
2070         Info->CurrentDepth = LookasideList->Depth;
2071         Info->MaximumDepth = LookasideList->MaximumDepth;
2072         Info->TotalAllocates = LookasideList->TotalAllocates;
2073         Info->TotalFrees = LookasideList->TotalFrees;
2074         Info->Type = LookasideList->Type;
2075         Info->Tag = LookasideList->Tag;
2076         Info->Size = LookasideList->Size;
2077 
2078         /* Check how the lists track misses/hits */
2079         if (ListUsesMisses)
2080         {
2081             /* Copy misses */
2082             Info->AllocateMisses = LookasideList->AllocateMisses;
2083             Info->FreeMisses = LookasideList->FreeMisses;
2084         }
2085         else
2086         {
2087             /* Calculate misses */
2088             Info->AllocateMisses = LookasideList->TotalAllocates
2089                                    - LookasideList->AllocateHits;
2090             Info->FreeMisses = LookasideList->TotalFrees
2091                                - LookasideList->FreeHits;
2092         }
2093     }
2094 
2095     /* Return the updated pointer and remaining count */
2096     *InfoPointer = Info;
2097     *RemainingPointer = Remaining;
2098 }
2099 
2100 /* Class 45 - Lookaside Information */
2101 QSI_DEF(SystemLookasideInformation)
2102 {
2103     KPROCESSOR_MODE PreviousMode;
2104     PSYSTEM_LOOKASIDE_INFORMATION Info;
2105     PMDL Mdl;
2106     ULONG MaxCount, Remaining;
2107     KIRQL OldIrql;
2108     NTSTATUS Status;
2109 
2110     /* First we need to lock down the memory, since we are going to access it
2111        at high IRQL */
2112     PreviousMode = ExGetPreviousMode();
2113     Status = ExLockUserBuffer(Buffer,
2114                               Size,
2115                               PreviousMode,
2116                               IoWriteAccess,
2117                               (PVOID*)&Info,
2118                               &Mdl);
2119     if (!NT_SUCCESS(Status))
2120     {
2121         DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
2122         return Status;
2123     }
2124 
2125     /* Calculate how many items we can store */
2126     Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2127     if (Remaining == 0)
2128     {
2129         goto Leave;
2130     }
2131 
2132     /* Copy info from pool lookaside lists */
2133     ExpCopyLookasideInformation(&Info,
2134                                 &Remaining,
2135                                 &ExPoolLookasideListHead,
2136                                 FALSE);
2137     if (Remaining == 0)
2138     {
2139         goto Leave;
2140     }
2141 
2142     /* Copy info from system lookaside lists */
2143     ExpCopyLookasideInformation(&Info,
2144                                 &Remaining,
2145                                 &ExSystemLookasideListHead,
2146                                 TRUE);
2147     if (Remaining == 0)
2148     {
2149         goto Leave;
2150     }
2151 
2152     /* Acquire spinlock for ExpNonPagedLookasideListHead */
2153     KeAcquireSpinLock(&ExpNonPagedLookasideListLock, &OldIrql);
2154 
2155     /* Copy info from non-paged lookaside lists */
2156     ExpCopyLookasideInformation(&Info,
2157                                 &Remaining,
2158                                 &ExpNonPagedLookasideListHead,
2159                                 TRUE);
2160 
2161     /* Release spinlock for ExpNonPagedLookasideListHead */
2162     KeReleaseSpinLock(&ExpNonPagedLookasideListLock, OldIrql);
2163 
2164     if (Remaining == 0)
2165     {
2166         goto Leave;
2167     }
2168 
2169     /* Acquire spinlock for ExpPagedLookasideListHead */
2170     KeAcquireSpinLock(&ExpPagedLookasideListLock, &OldIrql);
2171 
2172     /* Copy info from paged lookaside lists */
2173     ExpCopyLookasideInformation(&Info,
2174                                 &Remaining,
2175                                 &ExpPagedLookasideListHead,
2176                                 TRUE);
2177 
2178     /* Release spinlock for ExpPagedLookasideListHead */
2179     KeReleaseSpinLock(&ExpPagedLookasideListLock, OldIrql);
2180 
2181 Leave:
2182 
2183     /* Release the locked user buffer */
2184     ExUnlockUserBuffer(Mdl);
2185 
2186     /* Return the size of the actually written data */
2187     *ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2188     return STATUS_SUCCESS;
2189 }
2190 
2191 
2192 /* Class 46 - Set time slip event */
2193 SSI_DEF(SystemTimeSlipNotification)
2194 {
2195     /* FIXME */
2196     DPRINT1("NtSetSystemInformation - SystemTimeSlipNotification not implemented\n");
2197     return STATUS_NOT_IMPLEMENTED;
2198 }
2199 
2200 NTSTATUS
2201 NTAPI
2202 MmSessionCreate(OUT PULONG SessionId);
2203 
2204 NTSTATUS
2205 NTAPI
2206 MmSessionDelete(IN ULONG SessionId);
2207 
2208 /* Class 47 - Create a new session (TSE) */
2209 SSI_DEF(SystemSessionCreate)
2210 {
2211     ULONG SessionId;
2212     KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2213     NTSTATUS Status;
2214 
2215     if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2216 
2217     if (PreviousMode != KernelMode)
2218     {
2219         if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2220         {
2221             return STATUS_PRIVILEGE_NOT_HELD;
2222         }
2223 
2224         ProbeForWriteUlong(Buffer);
2225     }
2226 
2227     Status = MmSessionCreate(&SessionId);
2228     if (NT_SUCCESS(Status)) *(PULONG)Buffer = SessionId;
2229 
2230     return Status;
2231 }
2232 
2233 
2234 /* Class 48 - Delete an existing session (TSE) */
2235 SSI_DEF(SystemSessionDetach)
2236 {
2237     ULONG SessionId;
2238     KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2239 
2240     if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2241 
2242     if (PreviousMode != KernelMode)
2243     {
2244         if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2245         {
2246             return STATUS_PRIVILEGE_NOT_HELD;
2247         }
2248     }
2249 
2250     SessionId = *(PULONG)Buffer;
2251 
2252     return MmSessionDelete(SessionId);
2253 }
2254 
2255 
2256 /* Class 49 - UNKNOWN */
2257 QSI_DEF(SystemSessionInformation)
2258 {
2259     /* FIXME */
2260     DPRINT1("NtQuerySystemInformation - SystemSessionInformation not implemented\n");
2261     return STATUS_NOT_IMPLEMENTED;
2262 }
2263 
2264 
2265 /* Class 50 - System range start address */
2266 QSI_DEF(SystemRangeStartInformation)
2267 {
2268     /* Check user buffer's size */
2269     if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
2270 
2271     *(PULONG_PTR)Buffer = (ULONG_PTR)MmSystemRangeStart;
2272 
2273     if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
2274 
2275     return STATUS_SUCCESS;
2276 }
2277 
2278 /* Class 51 - Driver verifier information */
2279 QSI_DEF(SystemVerifierInformation)
2280 {
2281     /* FIXME */
2282     DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
2283     return STATUS_NOT_IMPLEMENTED;
2284 }
2285 
2286 
2287 SSI_DEF(SystemVerifierInformation)
2288 {
2289     /* FIXME */
2290     DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
2291     return STATUS_NOT_IMPLEMENTED;
2292 }
2293 
2294 
2295 /* Class 52 */
2296 SSI_DEF(SystemVerifierThunkExtend)
2297 {
2298     /* FIXME */
2299     DPRINT1("NtSetSystemInformation - SystemVerifierThunkExtend not implemented\n");
2300     return STATUS_NOT_IMPLEMENTED;
2301 }
2302 
2303 
2304 /* Class 53 - A session's processes  */
2305 QSI_DEF(SystemSessionProcessesInformation)
2306 {
2307     /* FIXME */
2308     DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
2309     return STATUS_NOT_IMPLEMENTED;
2310 }
2311 
2312 
2313 /* Class 54 - Load & map in system space */
2314 SSI_DEF(SystemLoadGdiDriverInSystemSpaceInformation)
2315 {
2316     /* FIXME */
2317     DPRINT1("NtSetSystemInformation - SystemLoadGdiDriverInSystemSpaceInformation not implemented\n");
2318     return STATUS_NOT_IMPLEMENTED;
2319 }
2320 
2321 
2322 /* Class 55 - NUMA processor information  */
2323 QSI_DEF(SystemNumaProcessorMap)
2324 {
2325     ULONG MaxEntries, Node;
2326     PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
2327 
2328     /* Validate input size */
2329     if (Size < sizeof(ULONG))
2330     {
2331         return STATUS_INFO_LENGTH_MISMATCH;
2332     }
2333 
2334     /* Return highest node */
2335     NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2336 
2337     /* Compute how much entries we will be able to put in output structure */
2338     MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask)) / sizeof(ULONGLONG);
2339     /* Make sure we don't overflow KeNodeBlock */
2340     if (MaxEntries > KeNumberNodes)
2341     {
2342         MaxEntries = KeNumberNodes;
2343     }
2344 
2345     /* If we have entries to write, and room for it */
2346     if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) &&
2347         MaxEntries != 0)
2348     {
2349         /* Already set size we return */
2350         *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) +
2351                    MaxEntries * sizeof(ULONGLONG);
2352 
2353         /* For each node, return processor mask */
2354         for (Node = 0; Node < MaxEntries; ++Node)
2355         {
2356             NumaInformation->ActiveProcessorsAffinityMask[Node] = KeNodeBlock[Node]->ProcessorMask;
2357         }
2358     }
2359     else
2360     {
2361         /* We only returned highest node number */
2362         *ReqSize = sizeof(ULONG);
2363     }
2364 
2365     return STATUS_SUCCESS;
2366 }
2367 
2368 
2369 /* Class 56 - Prefetcher information  */
2370 QSI_DEF(SystemPrefetcherInformation)
2371 {
2372     /* FIXME */
2373     DPRINT1("NtQuerySystemInformation - SystemPrefetcherInformation not implemented\n");
2374     return STATUS_NOT_IMPLEMENTED;
2375 }
2376 
2377 
2378 /* Class 57 - Extended process information  */
2379 QSI_DEF(SystemExtendedProcessInformation)
2380 {
2381     /* FIXME */
2382     DPRINT1("NtQuerySystemInformation - SystemExtendedProcessInformation not implemented\n");
2383     return STATUS_NOT_IMPLEMENTED;
2384 }
2385 
2386 
2387 /* Class 58 - Recommended shared ata alignment  */
2388 QSI_DEF(SystemRecommendedSharedDataAlignment)
2389 {
2390     /* FIXME */
2391     DPRINT1("NtQuerySystemInformation - SystemRecommendedSharedDataAlignment not implemented\n");
2392     return STATUS_NOT_IMPLEMENTED;
2393 }
2394 
2395 
2396 /* Class 60 - NUMA memory information  */
2397 QSI_DEF(SystemNumaAvailableMemory)
2398 {
2399     ULONG MaxEntries, Node;
2400     PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
2401 
2402     /* Validate input size */
2403     if (Size < sizeof(ULONG))
2404     {
2405         return STATUS_INFO_LENGTH_MISMATCH;
2406     }
2407 
2408     /* Return highest node */
2409     NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2410 
2411     /* Compute how much entries we will be able to put in output structure */
2412     MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory)) / sizeof(ULONGLONG);
2413     /* Make sure we don't overflow KeNodeBlock */
2414     if (MaxEntries > KeNumberNodes)
2415     {
2416         MaxEntries = KeNumberNodes;
2417     }
2418 
2419     /* If we have entries to write, and room for it */
2420     if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) &&
2421         MaxEntries != 0)
2422     {
2423         /* Already set size we return */
2424         *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) +
2425                    MaxEntries * sizeof(ULONGLONG);
2426 
2427         /* If we have a single entry (us), directly return MM information */
2428         if (MaxEntries == 1)
2429         {
2430             NumaInformation->AvailableMemory[0] = MmAvailablePages << PAGE_SHIFT;
2431         }
2432         else
2433         {
2434             /* Otherwise, for each node, return available bytes */
2435             for (Node = 0; Node < MaxEntries; ++Node)
2436             {
2437                 NumaInformation->AvailableMemory[Node] = (KeNodeBlock[Node]->FreeCount[0] + KeNodeBlock[Node]->FreeCount[1]) << PAGE_SHIFT;
2438             }
2439         }
2440     }
2441     else
2442     {
2443         /* We only returned highest node number */
2444         *ReqSize = sizeof(ULONG);
2445     }
2446 
2447     return STATUS_SUCCESS;
2448 }
2449 
2450 /* Class 64 - Extended handle information  */
2451 QSI_DEF(SystemExtendedHandleInformation)
2452 {
2453     PSYSTEM_HANDLE_INFORMATION_EX HandleInformation;
2454     PLIST_ENTRY NextTableEntry;
2455     PHANDLE_TABLE HandleTable;
2456     PHANDLE_TABLE_ENTRY HandleTableEntry;
2457     EXHANDLE Handle;
2458     ULONG Index = 0;
2459     NTSTATUS Status;
2460     PMDL Mdl;
2461     PAGED_CODE();
2462 
2463     DPRINT("NtQuerySystemInformation - SystemExtendedHandleInformation\n");
2464 
2465     /* Set initial required buffer size */
2466     *ReqSize = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION_EX, Handle);
2467 
2468     /* Check user's buffer size */
2469     if (Size < *ReqSize)
2470     {
2471         return STATUS_INFO_LENGTH_MISMATCH;
2472     }
2473 
2474     /* We need to lock down the memory */
2475     Status = ExLockUserBuffer(Buffer,
2476                               Size,
2477                               ExGetPreviousMode(),
2478                               IoWriteAccess,
2479                               (PVOID*)&HandleInformation,
2480                               &Mdl);
2481     if (!NT_SUCCESS(Status))
2482     {
2483         DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
2484         return Status;
2485     }
2486 
2487     /* Reset of count of handles */
2488     HandleInformation->Count = 0;
2489 
2490     /* Enter a critical region */
2491     KeEnterCriticalRegion();
2492 
2493     /* Acquire the handle table lock */
2494     ExAcquirePushLockShared(&HandleTableListLock);
2495 
2496     /* Enumerate all system handles */
2497     for (NextTableEntry = HandleTableListHead.Flink;
2498          NextTableEntry != &HandleTableListHead;
2499          NextTableEntry = NextTableEntry->Flink)
2500     {
2501         /* Get current handle table */
2502         HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
2503 
2504         /* Set the initial value and loop the entries */
2505         Handle.Value = 0;
2506         while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
2507         {
2508             /* Validate the entry */
2509             if ((HandleTableEntry->Object) &&
2510                 (HandleTableEntry->NextFreeTableEntry != -2))
2511             {
2512                 /* Increase of count of handles */
2513                 ++HandleInformation->Count;
2514 
2515                 /* Lock the entry */
2516                 if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
2517                 {
2518                     /* Increase required buffer size */
2519                     *ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX);
2520 
2521                     /* Check user's buffer size */
2522                     if (*ReqSize > Size)
2523                     {
2524                         Status = STATUS_INFO_LENGTH_MISMATCH;
2525                     }
2526                     else
2527                     {
2528                         POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
2529 
2530                         /* Filling handle information */
2531                         HandleInformation->Handle[Index].UniqueProcessId =
2532                             (USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
2533 
2534                         HandleInformation->Handle[Index].CreatorBackTraceIndex = 0;
2535 
2536 #if 0 /* FIXME!!! Type field currupted */
2537                         HandleInformation->Handles[Index].ObjectTypeIndex =
2538                             (UCHAR) ObjectHeader->Type->Index;
2539 #else
2540                         HandleInformation->Handle[Index].ObjectTypeIndex = 0;
2541 #endif
2542 
2543                         HandleInformation->Handle[Index].HandleAttributes =
2544                             HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
2545 
2546                         HandleInformation->Handle[Index].HandleValue =
2547                             (USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
2548 
2549                         HandleInformation->Handle[Index].Object = &ObjectHeader->Body;
2550 
2551                         HandleInformation->Handle[Index].GrantedAccess =
2552                             HandleTableEntry->GrantedAccess;
2553 
2554                         HandleInformation->Handle[Index].Reserved = 0;
2555 
2556                         ++Index;
2557                     }
2558 
2559                     /* Unlock it */
2560                     ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
2561                 }
2562             }
2563 
2564             /* Go to the next entry */
2565             Handle.Value += sizeof(HANDLE);
2566         }
2567     }
2568 
2569     /* Release the lock */
2570     ExReleasePushLockShared(&HandleTableListLock);
2571 
2572     /* Leave the critical region */
2573     KeLeaveCriticalRegion();
2574 
2575     /* Release the locked user buffer */
2576     ExUnlockUserBuffer(Mdl);
2577 
2578     return Status;
2579 }
2580 
2581 /* Class 76 - System firmware table information  */
2582 QSI_DEF(SystemFirmwareTableInformation)
2583 {
2584     PSYSTEM_FIRMWARE_TABLE_INFORMATION SysFirmwareInfo = (PSYSTEM_FIRMWARE_TABLE_INFORMATION)Buffer;
2585     NTSTATUS Status = STATUS_SUCCESS;
2586     ULONG InputBufSize;
2587     ULONG DataSize = 0;
2588     ULONG TableCount = 0;
2589 
2590     DPRINT("NtQuerySystemInformation - SystemFirmwareTableInformation\n");
2591 
2592     /* Set initial required buffer size */
2593     *ReqSize = FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer);
2594 
2595     /* Check user's buffer size */
2596     if (Size < *ReqSize)
2597     {
2598         return STATUS_INFO_LENGTH_MISMATCH;
2599     }
2600 
2601     InputBufSize = SysFirmwareInfo->TableBufferLength;
2602     switch (SysFirmwareInfo->ProviderSignature)
2603     {
2604         /*
2605          * ExpFirmwareTableResource and ExpFirmwareTableProviderListHead
2606          * variables should be used there somehow...
2607          */
2608         case SIG_ACPI:
2609         {
2610             /* FIXME: Not implemented yet */
2611             DPRINT1("ACPI provider not implemented\n");
2612             Status = STATUS_NOT_IMPLEMENTED;
2613             break;
2614         }
2615         case SIG_FIRM:
2616         {
2617             /* FIXME: Not implemented yet */
2618             DPRINT1("FIRM provider not implemented\n");
2619             Status = STATUS_NOT_IMPLEMENTED;
2620             break;
2621         }
2622         case SIG_RSMB:
2623         {
2624             Status = ExpGetRawSMBiosTable(NULL, &DataSize, 0);
2625             if (DataSize > 0)
2626             {
2627                 TableCount = 1;
2628                 if (SysFirmwareInfo->Action == SystemFirmwareTable_Enumerate)
2629                 {
2630                     DataSize = TableCount * sizeof(ULONG);
2631                     if (DataSize <= InputBufSize)
2632                     {
2633                         *(ULONG *)SysFirmwareInfo->TableBuffer = 0;
2634                     }
2635                 }
2636                 else if (SysFirmwareInfo->Action == SystemFirmwareTable_Get
2637                          && DataSize <= InputBufSize)
2638                 {
2639                     Status = ExpGetRawSMBiosTable(SysFirmwareInfo->TableBuffer, &DataSize, InputBufSize);
2640                 }
2641                 SysFirmwareInfo->TableBufferLength = DataSize;
2642             }
2643             break;
2644         }
2645         default:
2646         {
2647             DPRINT1("SystemFirmwareTableInformation: Unsupported provider (0x%x)\n",
2648                     SysFirmwareInfo->ProviderSignature);
2649             Status = STATUS_ILLEGAL_FUNCTION;
2650         }
2651     }
2652 
2653     if (NT_SUCCESS(Status))
2654     {
2655         switch (SysFirmwareInfo->Action)
2656         {
2657             case SystemFirmwareTable_Enumerate:
2658             case SystemFirmwareTable_Get:
2659             {
2660                 if (SysFirmwareInfo->TableBufferLength > InputBufSize)
2661                 {
2662                     Status = STATUS_BUFFER_TOO_SMALL;
2663                 }
2664                 break;
2665             }
2666             default:
2667             {
2668                 DPRINT1("SystemFirmwareTableInformation: Unsupported action (0x%x)\n",
2669                         SysFirmwareInfo->Action);
2670                 Status = STATUS_ILLEGAL_FUNCTION;
2671             }
2672         }
2673     }
2674     else
2675     {
2676         SysFirmwareInfo->TableBufferLength = 0;
2677     }
2678     return Status;
2679 }
2680 
2681 /* Query/Set Calls Table */
2682 typedef
2683 struct _QSSI_CALLS
2684 {
2685     NTSTATUS (* Query) (PVOID,ULONG,PULONG);
2686     NTSTATUS (* Set) (PVOID,ULONG);
2687 } QSSI_CALLS;
2688 
2689 // QS    Query & Set
2690 // QX    Query
2691 // XS    Set
2692 // XX    unknown behaviour
2693 //
2694 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
2695 #define SI_QX(n) {QSI_USE(n),NULL}
2696 #define SI_XS(n) {NULL,SSI_USE(n)}
2697 #define SI_XX(n) {NULL,NULL}
2698 
2699 static
2700 QSSI_CALLS
2701 CallQS [] =
2702 {
2703     SI_QX(SystemBasicInformation),
2704     SI_QX(SystemProcessorInformation),
2705     SI_QX(SystemPerformanceInformation),
2706     SI_QX(SystemTimeOfDayInformation),
2707     SI_QX(SystemPathInformation), /* should be SI_XX */
2708     SI_QX(SystemProcessInformation),
2709     SI_QX(SystemCallCountInformation),
2710     SI_QX(SystemDeviceInformation),
2711     SI_QX(SystemProcessorPerformanceInformation),
2712     SI_QS(SystemFlagsInformation),
2713     SI_QX(SystemCallTimeInformation), /* should be SI_XX */
2714     SI_QX(SystemModuleInformation),
2715     SI_QX(SystemLocksInformation),
2716     SI_QX(SystemStackTraceInformation), /* should be SI_XX */
2717     SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
2718     SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
2719     SI_QX(SystemHandleInformation),
2720     SI_QX(SystemObjectInformation),
2721     SI_QX(SystemPageFileInformation),
2722     SI_QX(SystemVdmInstemulInformation),
2723     SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
2724     SI_QS(SystemFileCacheInformation),
2725     SI_QX(SystemPoolTagInformation),
2726     SI_QX(SystemInterruptInformation),
2727     SI_QS(SystemDpcBehaviourInformation),
2728     SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
2729     SI_XS(SystemLoadGdiDriverInformation),
2730     SI_XS(SystemUnloadGdiDriverInformation),
2731     SI_QS(SystemTimeAdjustmentInformation),
2732     SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
2733     SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
2734     SI_QX(SystemPerformanceTraceInformation), /* it should be SI_XX */
2735     SI_QX(SystemCrashDumpInformation),
2736     SI_QX(SystemExceptionInformation),
2737     SI_QX(SystemCrashDumpStateInformation),
2738     SI_QX(SystemKernelDebuggerInformation),
2739     SI_QX(SystemContextSwitchInformation),
2740     SI_QS(SystemRegistryQuotaInformation),
2741     SI_XS(SystemExtendServiceTableInformation),
2742     SI_XS(SystemPrioritySeperation),
2743     SI_QX(SystemVerifierAddDriverInformation), /* it should be SI_XX */
2744     SI_QX(SystemVerifierRemoveDriverInformation), /* it should be SI_XX */
2745     SI_QX(SystemProcessorIdleInformation), /* it should be SI_XX */
2746     SI_QX(SystemLegacyDriverInformation), /* it should be SI_XX */
2747     SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
2748     SI_QX(SystemLookasideInformation),
2749     SI_XS(SystemTimeSlipNotification),
2750     SI_XS(SystemSessionCreate),
2751     SI_XS(SystemSessionDetach),
2752     SI_QX(SystemSessionInformation), /* it should be SI_XX */
2753     SI_QX(SystemRangeStartInformation),
2754     SI_QS(SystemVerifierInformation),
2755     SI_XS(SystemVerifierThunkExtend),
2756     SI_QX(SystemSessionProcessesInformation),
2757     SI_XS(SystemLoadGdiDriverInSystemSpaceInformation),
2758     SI_QX(SystemNumaProcessorMap),
2759     SI_QX(SystemPrefetcherInformation),
2760     SI_QX(SystemExtendedProcessInformation),
2761     SI_QX(SystemRecommendedSharedDataAlignment),
2762     SI_XX(SystemComPlusPackage),
2763     SI_QX(SystemNumaAvailableMemory),
2764     SI_XX(SystemProcessorPowerInformation), /* FIXME: not implemented */
2765     SI_XX(SystemEmulationBasicInformation), /* FIXME: not implemented */
2766     SI_XX(SystemEmulationProcessorInformation), /* FIXME: not implemented */
2767     SI_QX(SystemExtendedHandleInformation),
2768     SI_XX(SystemLostDelayedWriteInformation), /* FIXME: not implemented */
2769     SI_XX(SystemBigPoolInformation), /* FIXME: not implemented */
2770     SI_XX(SystemSessionPoolTagInformation), /* FIXME: not implemented */
2771     SI_XX(SystemSessionMappedViewInformation), /* FIXME: not implemented */
2772     SI_XX(SystemHotpatchInformation), /* FIXME: not implemented */
2773     SI_XX(SystemObjectSecurityMode), /* FIXME: not implemented */
2774     SI_XX(SystemWatchdogTimerHandler), /* FIXME: not implemented */
2775     SI_XX(SystemWatchdogTimerInformation), /* FIXME: not implemented */
2776     SI_XX(SystemLogicalProcessorInformation), /* FIXME: not implemented */
2777     SI_XX(SystemWow64SharedInformation), /* FIXME: not implemented */
2778     SI_XX(SystemRegisterFirmwareTableInformationHandler), /* FIXME: not implemented */
2779     SI_QX(SystemFirmwareTableInformation),
2780 };
2781 
2782 C_ASSERT(SystemBasicInformation == 0);
2783 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
2784 #define MAX_SYSTEM_INFO_CLASS (sizeof(CallQS) / sizeof(CallQS[0]))
2785 
2786 /*
2787  * @implemented
2788  */
2789 __kernel_entry
2790 NTSTATUS
2791 NTAPI
2792 NtQuerySystemInformation(
2793     _In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
2794     _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation,
2795     _In_ ULONG Length,
2796     _Out_opt_ PULONG UnsafeResultLength)
2797 {
2798     KPROCESSOR_MODE PreviousMode;
2799     ULONG ResultLength = 0;
2800     ULONG Alignment = TYPE_ALIGNMENT(ULONG);
2801     NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;
2802 
2803     PAGED_CODE();
2804 
2805     PreviousMode = ExGetPreviousMode();
2806 
2807     _SEH2_TRY
2808     {
2809 #if (NTDDI_VERSION >= NTDDI_VISTA)
2810         /*
2811          * Check if the request is valid.
2812          */
2813         if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2814         {
2815             _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
2816         }
2817 #endif
2818 
2819         if (PreviousMode != KernelMode)
2820         {
2821             /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
2822             if (SystemInformationClass == SystemKernelDebuggerInformation)
2823                 Alignment = TYPE_ALIGNMENT(BOOLEAN);
2824 
2825             ProbeForWrite(SystemInformation, Length, Alignment);
2826             if (UnsafeResultLength != NULL)
2827                 ProbeForWriteUlong(UnsafeResultLength);
2828         }
2829 
2830         if (UnsafeResultLength)
2831             *UnsafeResultLength = 0;
2832 
2833 #if (NTDDI_VERSION < NTDDI_VISTA)
2834         /*
2835          * Check if the request is valid.
2836          */
2837         if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2838         {
2839             _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
2840         }
2841 #endif
2842 
2843         if (NULL != CallQS [SystemInformationClass].Query)
2844         {
2845             /*
2846              * Hand the request to a subhandler.
2847              */
2848             FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
2849                                                             Length,
2850                                                             &ResultLength);
2851 
2852             /* Save the result length to the caller */
2853             if (UnsafeResultLength)
2854                 *UnsafeResultLength = ResultLength;
2855         }
2856     }
2857     _SEH2_EXCEPT(ExSystemExceptionFilter())
2858     {
2859         FStatus = _SEH2_GetExceptionCode();
2860     }
2861     _SEH2_END;
2862 
2863     return FStatus;
2864 }
2865 
2866 
2867 NTSTATUS
2868 NTAPI
2869 NtSetSystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2870                         IN PVOID SystemInformation,
2871                         IN ULONG SystemInformationLength)
2872 {
2873     NTSTATUS Status = STATUS_INVALID_INFO_CLASS;
2874     KPROCESSOR_MODE PreviousMode;
2875 
2876     PAGED_CODE();
2877 
2878     PreviousMode = ExGetPreviousMode();
2879 
2880     _SEH2_TRY
2881     {
2882         /*
2883          * If called from user mode, check
2884          * possible unsafe arguments.
2885          */
2886         if (PreviousMode != KernelMode)
2887         {
2888             ProbeForRead(SystemInformation, SystemInformationLength, sizeof(ULONG));
2889         }
2890 
2891         /*
2892          * Check the request is valid.
2893          */
2894         if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
2895             (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
2896         {
2897             if (NULL != CallQS [SystemInformationClass].Set)
2898             {
2899                 /*
2900                  * Hand the request to a subhandler.
2901                  */
2902                 Status = CallQS [SystemInformationClass].Set(SystemInformation,
2903                                                              SystemInformationLength);
2904             }
2905         }
2906     }
2907     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2908     {
2909         Status = _SEH2_GetExceptionCode();
2910     }
2911     _SEH2_END;
2912 
2913     return Status;
2914 }
2915 
2916 ULONG
2917 NTAPI
2918 NtGetCurrentProcessorNumber(VOID)
2919 {
2920     /* Just use Ke */
2921     return KeGetCurrentProcessorNumber();
2922 }
2923 
2924 #undef ExGetPreviousMode
2925 KPROCESSOR_MODE
2926 NTAPI
2927 ExGetPreviousMode(VOID)
2928 {
2929     /* Just use Ke */
2930     return KeGetPreviousMode();
2931 }
2932