[MS] Add messages 2200-2249 and 3502-3507 to netmsg.dll.
[reactos.git] / ntoskrnl / ex / sysinfo.c
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 }