[NTOSKRNL]
[reactos.git] / reactos / 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 #define NDEBUG
15 #include <debug.h>
16
17 /* The maximum size of an environment value (in bytes) */
18 #define MAX_ENVVAL_SIZE 1024
19
20 FAST_MUTEX ExpEnvironmentLock;
21 ERESOURCE ExpFirmwareTableResource;
22 LIST_ENTRY ExpFirmwareTableProviderListHead;
23
24 FORCEINLINE
25 NTSTATUS
26 ExpConvertLdrModuleToRtlModule(IN ULONG ModuleCount,
27 IN PLDR_DATA_TABLE_ENTRY LdrEntry,
28 OUT PRTL_PROCESS_MODULE_INFORMATION ModuleInfo)
29 {
30 PCHAR p;
31 NTSTATUS Status;
32 ANSI_STRING ModuleName;
33
34 /* Fill it out */
35 ModuleInfo->MappedBase = NULL;
36 ModuleInfo->ImageBase = LdrEntry->DllBase;
37 ModuleInfo->ImageSize = LdrEntry->SizeOfImage;
38 ModuleInfo->Flags = LdrEntry->Flags;
39 ModuleInfo->LoadCount = LdrEntry->LoadCount;
40 ModuleInfo->LoadOrderIndex = (USHORT)ModuleCount;
41 ModuleInfo->InitOrderIndex = 0;
42
43 /* Setup name */
44 RtlInitEmptyAnsiString(&ModuleName,
45 ModuleInfo->FullPathName,
46 sizeof(ModuleInfo->FullPathName));
47
48 /* Convert it */
49 Status = RtlUnicodeStringToAnsiString(&ModuleName,
50 &LdrEntry->FullDllName,
51 FALSE);
52 if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
53 {
54 /* Calculate offset to name */
55 p = ModuleName.Buffer + ModuleName.Length;
56 while ((p > ModuleName.Buffer) && (*--p))
57 {
58 /* Check if we found the separator */
59 if (*p == OBJ_NAME_PATH_SEPARATOR)
60 {
61 /* We did, break out */
62 p++;
63 break;
64 }
65 }
66
67 /* Set the offset */
68 ModuleInfo->OffsetToFileName = (USHORT)(p - ModuleName.Buffer);
69 }
70 else
71 {
72 /* Return empty name */
73 ModuleInfo->FullPathName[0] = ANSI_NULL;
74 ModuleInfo->OffsetToFileName = 0;
75 }
76
77 return Status;
78 }
79
80 NTSTATUS
81 NTAPI
82 ExpQueryModuleInformation(IN PLIST_ENTRY KernelModeList,
83 IN PLIST_ENTRY UserModeList,
84 OUT PRTL_PROCESS_MODULES Modules,
85 IN ULONG Length,
86 OUT PULONG ReturnLength)
87 {
88 NTSTATUS Status = STATUS_SUCCESS;
89 ULONG RequiredLength;
90 PRTL_PROCESS_MODULE_INFORMATION ModuleInfo;
91 PLDR_DATA_TABLE_ENTRY LdrEntry;
92 ULONG ModuleCount = 0;
93 PLIST_ENTRY NextEntry;
94
95 /* Setup defaults */
96 RequiredLength = FIELD_OFFSET(RTL_PROCESS_MODULES, Modules);
97 ModuleInfo = &Modules->Modules[0];
98
99 /* Loop the kernel list */
100 NextEntry = KernelModeList->Flink;
101 while (NextEntry != KernelModeList)
102 {
103 /* Get the entry */
104 LdrEntry = CONTAINING_RECORD(NextEntry,
105 LDR_DATA_TABLE_ENTRY,
106 InLoadOrderLinks);
107
108 /* Update size and check if we can manage one more entry */
109 RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
110 if (Length >= RequiredLength)
111 {
112 Status = ExpConvertLdrModuleToRtlModule(ModuleCount,
113 LdrEntry,
114 ModuleInfo);
115
116 /* Go to the next module */
117 ModuleInfo++;
118 }
119 else
120 {
121 /* Set error code */
122 Status = STATUS_INFO_LENGTH_MISMATCH;
123 }
124
125 /* Update count and move to next entry */
126 ModuleCount++;
127 NextEntry = NextEntry->Flink;
128 }
129
130 /* Check if caller also wanted user modules */
131 if (UserModeList)
132 {
133 NextEntry = UserModeList->Flink;
134 while (NextEntry != UserModeList)
135 {
136 /* Get the entry */
137 LdrEntry = CONTAINING_RECORD(NextEntry,
138 LDR_DATA_TABLE_ENTRY,
139 InLoadOrderLinks);
140
141 /* Update size and check if we can manage one more entry */
142 RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
143 if (Length >= RequiredLength)
144 {
145 Status = ExpConvertLdrModuleToRtlModule(ModuleCount,
146 LdrEntry,
147 ModuleInfo);
148
149 /* Go to the next module */
150 ModuleInfo++;
151 }
152 else
153 {
154 /* Set error code */
155 Status = STATUS_INFO_LENGTH_MISMATCH;
156 }
157
158 /* Update count and move to next entry */
159 ModuleCount++;
160 NextEntry = NextEntry->Flink;
161 }
162 }
163
164 /* Update return length */
165 if (ReturnLength) *ReturnLength = RequiredLength;
166
167 /* Validate the length again */
168 if (Length >= FIELD_OFFSET(RTL_PROCESS_MODULES, Modules))
169 {
170 /* Set the final count */
171 Modules->NumberOfModules = ModuleCount;
172 }
173 else
174 {
175 /* Otherwise, we failed */
176 Status = STATUS_INFO_LENGTH_MISMATCH;
177 }
178
179 /* Done */
180 return Status;
181 }
182
183 VOID
184 NTAPI
185 ExUnlockUserBuffer(PMDL Mdl)
186 {
187 MmUnlockPages(Mdl);
188 ExFreePoolWithTag(Mdl, TAG_MDL);
189 }
190
191 NTSTATUS
192 NTAPI
193 ExLockUserBuffer(
194 PVOID BaseAddress,
195 ULONG Length,
196 KPROCESSOR_MODE AccessMode,
197 LOCK_OPERATION Operation,
198 PVOID *MappedSystemVa,
199 PMDL *OutMdl)
200 {
201 PMDL Mdl;
202 PAGED_CODE();
203
204 *MappedSystemVa = NULL;
205 *OutMdl = NULL;
206
207 /* Allocate an MDL for the buffer */
208 Mdl = IoAllocateMdl(BaseAddress, Length, FALSE, TRUE, NULL);
209 if (Mdl == NULL)
210 {
211 return STATUS_INSUFFICIENT_RESOURCES;
212 }
213
214 /* Enter SEH for probing */
215 _SEH2_TRY
216 {
217 MmProbeAndLockPages(Mdl, AccessMode, Operation);
218 }
219 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
220 {
221 ExFreePoolWithTag(Mdl, TAG_MDL);
222 return _SEH2_GetExceptionCode();
223 }
224 _SEH2_END;
225
226 /* Return the safe kernel mode buffer */
227 *MappedSystemVa = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
228 if (*MappedSystemVa == NULL)
229 {
230 ExUnlockUserBuffer(Mdl);
231 return STATUS_INSUFFICIENT_RESOURCES;
232 }
233
234 /* Return the MDL */
235 *OutMdl = Mdl;
236 return STATUS_SUCCESS;
237 }
238
239 /* FUNCTIONS *****************************************************************/
240
241 /*
242 * @implemented
243 */
244 VOID
245 NTAPI
246 ExGetCurrentProcessorCpuUsage(PULONG CpuUsage)
247 {
248 PKPRCB Prcb;
249 ULONG TotalTime;
250 ULONGLONG ScaledIdle;
251
252 Prcb = KeGetCurrentPrcb();
253
254 ScaledIdle = (ULONGLONG)Prcb->IdleThread->KernelTime * 100;
255 TotalTime = Prcb->KernelTime + Prcb->UserTime;
256 if (TotalTime != 0)
257 *CpuUsage = (ULONG)(100 - (ScaledIdle / TotalTime));
258 else
259 *CpuUsage = 0;
260 }
261
262 /*
263 * @implemented
264 */
265 VOID
266 NTAPI
267 ExGetCurrentProcessorCounts(PULONG ThreadKernelTime,
268 PULONG TotalCpuTime,
269 PULONG ProcessorNumber)
270 {
271 PKPRCB Prcb;
272
273 Prcb = KeGetCurrentPrcb();
274
275 *ThreadKernelTime = Prcb->KernelTime + Prcb->UserTime;
276 *TotalCpuTime = Prcb->CurrentThread->KernelTime;
277 *ProcessorNumber = KeGetCurrentProcessorNumber();
278 }
279
280 /*
281 * @implemented
282 */
283 BOOLEAN
284 NTAPI
285 ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
286 {
287 /* Quick check to see if it exists at all */
288 if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return(FALSE);
289
290 /* Return our support for it */
291 return(SharedUserData->ProcessorFeatures[ProcessorFeature]);
292 }
293
294 /*
295 * @implemented
296 */
297 BOOLEAN
298 NTAPI
299 ExVerifySuite(SUITE_TYPE SuiteType)
300 {
301 if (SuiteType == Personal) return TRUE;
302 return FALSE;
303 }
304
305 NTSTATUS
306 NTAPI
307 NtQuerySystemEnvironmentValue(IN PUNICODE_STRING VariableName,
308 OUT PWSTR ValueBuffer,
309 IN ULONG ValueBufferLength,
310 IN OUT PULONG ReturnLength OPTIONAL)
311 {
312 ANSI_STRING AName;
313 UNICODE_STRING WName;
314 ARC_STATUS Result;
315 PCH AnsiValueBuffer;
316 ANSI_STRING AValue;
317 UNICODE_STRING WValue;
318 KPROCESSOR_MODE PreviousMode;
319 NTSTATUS Status;
320 PAGED_CODE();
321
322 /* Check if the call came from user mode */
323 PreviousMode = ExGetPreviousMode();
324 if (PreviousMode != KernelMode)
325 {
326 _SEH2_TRY
327 {
328 /* Probe the input and output buffers */
329 ProbeForRead(VariableName, sizeof(UNICODE_STRING), sizeof(ULONG));
330 ProbeForWrite(ValueBuffer, ValueBufferLength, sizeof(WCHAR));
331 if (ReturnLength != NULL) ProbeForWriteUlong(ReturnLength);
332 }
333 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
334 {
335 /* Return the exception code */
336 _SEH2_YIELD(return _SEH2_GetExceptionCode());
337 }
338 _SEH2_END;
339 }
340
341 /* According to NTInternals the SeSystemEnvironmentName privilege is required! */
342 if (!SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege, PreviousMode))
343 {
344 DPRINT1("NtQuerySystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
345 return STATUS_PRIVILEGE_NOT_HELD;
346 }
347
348 /* Copy the name to kernel space if necessary */
349 Status = ProbeAndCaptureUnicodeString(&WName, PreviousMode, VariableName);
350 if (!NT_SUCCESS(Status)) return Status;
351
352 /* Convert the name to ANSI and release the captured UNICODE string */
353 Status = RtlUnicodeStringToAnsiString(&AName, &WName, TRUE);
354 ReleaseCapturedUnicodeString(&WName, PreviousMode);
355 if (!NT_SUCCESS(Status)) return Status;
356
357 /* Allocate a buffer for the ANSI environment variable */
358 AnsiValueBuffer = ExAllocatePoolWithTag(NonPagedPool, MAX_ENVVAL_SIZE, 'rvnE');
359 if (AnsiValueBuffer == NULL)
360 {
361 RtlFreeAnsiString(&AName);
362 return STATUS_INSUFFICIENT_RESOURCES;
363 }
364
365 /* Get the environment variable and free the ANSI name */
366 Result = HalGetEnvironmentVariable(AName.Buffer,
367 MAX_ENVVAL_SIZE,
368 AnsiValueBuffer);
369 RtlFreeAnsiString(&AName);
370
371 /* Check if we had success */
372 if (Result == ESUCCESS)
373 {
374 /* Copy the result back to the caller. */
375 _SEH2_TRY
376 {
377 /* Initialize ANSI string from the result */
378 RtlInitAnsiString(&AValue, AnsiValueBuffer);
379
380 /* Initialize a UNICODE string from the callers buffer */
381 RtlInitEmptyUnicodeString(&WValue, ValueBuffer, (USHORT)ValueBufferLength);
382
383 /* Convert the result to UNICODE */
384 Status = RtlAnsiStringToUnicodeString(&WValue, &AValue, FALSE);
385
386 if (ReturnLength != NULL)
387 *ReturnLength = WValue.Length;
388 }
389 _SEH2_EXCEPT(ExSystemExceptionFilter())
390 {
391 Status = _SEH2_GetExceptionCode();
392 }
393 _SEH2_END;
394 }
395 else
396 {
397 Status = STATUS_UNSUCCESSFUL;
398 }
399
400 /* Free the allocated ANSI value buffer */
401 ExFreePoolWithTag(AnsiValueBuffer, 'rvnE');
402
403 return Status;
404 }
405
406
407 NTSTATUS
408 NTAPI
409 NtSetSystemEnvironmentValue(IN PUNICODE_STRING VariableName,
410 IN PUNICODE_STRING Value)
411 {
412 UNICODE_STRING CapturedName, CapturedValue;
413 ANSI_STRING AName, AValue;
414 KPROCESSOR_MODE PreviousMode;
415 NTSTATUS Status;
416
417 PAGED_CODE();
418
419 PreviousMode = ExGetPreviousMode();
420
421 /*
422 * Copy the strings to kernel space if necessary
423 */
424 Status = ProbeAndCaptureUnicodeString(&CapturedName,
425 PreviousMode,
426 VariableName);
427 if (NT_SUCCESS(Status))
428 {
429 Status = ProbeAndCaptureUnicodeString(&CapturedValue,
430 PreviousMode,
431 Value);
432 if (NT_SUCCESS(Status))
433 {
434 /*
435 * according to ntinternals the SeSystemEnvironmentName privilege is required!
436 */
437 if (SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
438 PreviousMode))
439 {
440 /*
441 * convert the strings to ANSI
442 */
443 Status = RtlUnicodeStringToAnsiString(&AName,
444 &CapturedName,
445 TRUE);
446 if (NT_SUCCESS(Status))
447 {
448 Status = RtlUnicodeStringToAnsiString(&AValue,
449 &CapturedValue,
450 TRUE);
451 if (NT_SUCCESS(Status))
452 {
453 ARC_STATUS Result = HalSetEnvironmentVariable(AName.Buffer,
454 AValue.Buffer);
455
456 Status = (Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
457 }
458 }
459 }
460 else
461 {
462 DPRINT1("NtSetSystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
463 Status = STATUS_PRIVILEGE_NOT_HELD;
464 }
465
466 ReleaseCapturedUnicodeString(&CapturedValue,
467 PreviousMode);
468 }
469
470 ReleaseCapturedUnicodeString(&CapturedName,
471 PreviousMode);
472 }
473
474 return Status;
475 }
476
477 NTSTATUS
478 NTAPI
479 NtEnumerateSystemEnvironmentValuesEx(IN ULONG InformationClass,
480 IN PVOID Buffer,
481 IN ULONG BufferLength)
482 {
483 UNIMPLEMENTED;
484 return STATUS_NOT_IMPLEMENTED;
485 }
486
487 NTSTATUS
488 NTAPI
489 NtQuerySystemEnvironmentValueEx(IN PUNICODE_STRING VariableName,
490 IN LPGUID VendorGuid,
491 IN PVOID Value,
492 IN OUT PULONG ReturnLength,
493 IN OUT PULONG Attributes)
494 {
495 UNIMPLEMENTED;
496 return STATUS_NOT_IMPLEMENTED;
497 }
498
499 NTSTATUS
500 NTAPI
501 NtSetSystemEnvironmentValueEx(IN PUNICODE_STRING VariableName,
502 IN LPGUID VendorGuid)
503 {
504 UNIMPLEMENTED;
505 return STATUS_NOT_IMPLEMENTED;
506 }
507
508 /* --- Query/Set System Information --- */
509
510 /*
511 * NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
512 * so the stack is popped only in one place on x86 platform.
513 */
514 #define QSI_USE(n) QSI##n
515 #define QSI_DEF(n) \
516 static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
517
518 #define SSI_USE(n) SSI##n
519 #define SSI_DEF(n) \
520 static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
521
522 VOID
523 NTAPI
524 ExQueryPoolUsage(OUT PULONG PagedPoolPages,
525 OUT PULONG NonPagedPoolPages,
526 OUT PULONG PagedPoolAllocs,
527 OUT PULONG PagedPoolFrees,
528 OUT PULONG PagedPoolLookasideHits,
529 OUT PULONG NonPagedPoolAllocs,
530 OUT PULONG NonPagedPoolFrees,
531 OUT PULONG NonPagedPoolLookasideHits);
532
533 /* Class 0 - Basic Information */
534 QSI_DEF(SystemBasicInformation)
535 {
536 PSYSTEM_BASIC_INFORMATION Sbi
537 = (PSYSTEM_BASIC_INFORMATION) Buffer;
538
539 *ReqSize = sizeof(SYSTEM_BASIC_INFORMATION);
540
541 /* Check user buffer's size */
542 if (Size != sizeof(SYSTEM_BASIC_INFORMATION))
543 {
544 return STATUS_INFO_LENGTH_MISMATCH;
545 }
546
547 RtlZeroMemory(Sbi, Size);
548 Sbi->Reserved = 0;
549 Sbi->TimerResolution = KeMaximumIncrement;
550 Sbi->PageSize = PAGE_SIZE;
551 Sbi->NumberOfPhysicalPages = MmNumberOfPhysicalPages;
552 Sbi->LowestPhysicalPageNumber = (ULONG)MmLowestPhysicalPage;
553 Sbi->HighestPhysicalPageNumber = (ULONG)MmHighestPhysicalPage;
554 Sbi->AllocationGranularity = MM_VIRTMEM_GRANULARITY; /* hard coded on Intel? */
555 Sbi->MinimumUserModeAddress = 0x10000; /* Top of 64k */
556 Sbi->MaximumUserModeAddress = (ULONG_PTR)MmHighestUserAddress;
557 Sbi->ActiveProcessorsAffinityMask = KeActiveProcessors;
558 Sbi->NumberOfProcessors = KeNumberProcessors;
559
560 return STATUS_SUCCESS;
561 }
562
563 /* Class 1 - Processor Information */
564 QSI_DEF(SystemProcessorInformation)
565 {
566 PSYSTEM_PROCESSOR_INFORMATION Spi
567 = (PSYSTEM_PROCESSOR_INFORMATION) Buffer;
568
569 *ReqSize = sizeof(SYSTEM_PROCESSOR_INFORMATION);
570
571 /* Check user buffer's size */
572 if (Size < sizeof(SYSTEM_PROCESSOR_INFORMATION))
573 {
574 return STATUS_INFO_LENGTH_MISMATCH;
575 }
576 Spi->ProcessorArchitecture = KeProcessorArchitecture;
577 Spi->ProcessorLevel = KeProcessorLevel;
578 Spi->ProcessorRevision = KeProcessorRevision;
579 Spi->Reserved = 0;
580 Spi->ProcessorFeatureBits = KeFeatureBits;
581
582 DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
583 Spi->ProcessorLevel, Spi->ProcessorRevision);
584
585 return STATUS_SUCCESS;
586 }
587
588 /* Class 2 - Performance Information */
589 QSI_DEF(SystemPerformanceInformation)
590 {
591 ULONG IdleUser, IdleKernel;
592 PSYSTEM_PERFORMANCE_INFORMATION Spi
593 = (PSYSTEM_PERFORMANCE_INFORMATION) Buffer;
594
595 PEPROCESS TheIdleProcess;
596
597 *ReqSize = sizeof(SYSTEM_PERFORMANCE_INFORMATION);
598
599 /* Check user buffer's size */
600 if (Size < sizeof(SYSTEM_PERFORMANCE_INFORMATION))
601 {
602 return STATUS_INFO_LENGTH_MISMATCH;
603 }
604
605 TheIdleProcess = PsIdleProcess;
606
607 IdleKernel = KeQueryRuntimeProcess(&TheIdleProcess->Pcb, &IdleUser);
608 Spi->IdleProcessTime.QuadPart = UInt32x32To64(IdleKernel, KeMaximumIncrement);
609 Spi->IoReadTransferCount = IoReadTransferCount;
610 Spi->IoWriteTransferCount = IoWriteTransferCount;
611 Spi->IoOtherTransferCount = IoOtherTransferCount;
612 Spi->IoReadOperationCount = IoReadOperationCount;
613 Spi->IoWriteOperationCount = IoWriteOperationCount;
614 Spi->IoOtherOperationCount = IoOtherOperationCount;
615
616 Spi->AvailablePages = (ULONG)MmAvailablePages;
617 /*
618 * Add up all the used "Committed" memory + pagefile.
619 * Not sure this is right. 8^\
620 */
621 Spi->CommittedPages = MiMemoryConsumers[MC_SYSTEM].PagesUsed +
622 MiMemoryConsumers[MC_CACHE].PagesUsed +
623 MiMemoryConsumers[MC_USER].PagesUsed +
624 MiUsedSwapPages;
625 /*
626 * Add up the full system total + pagefile.
627 * All this make Taskmgr happy but not sure it is the right numbers.
628 * This too, fixes some of GlobalMemoryStatusEx numbers.
629 */
630 Spi->CommitLimit = MmNumberOfPhysicalPages + MiFreeSwapPages + MiUsedSwapPages;
631
632 Spi->PeakCommitment = 0; /* FIXME */
633 Spi->PageFaultCount = 0; /* FIXME */
634 Spi->CopyOnWriteCount = 0; /* FIXME */
635 Spi->TransitionCount = 0; /* FIXME */
636 Spi->CacheTransitionCount = 0; /* FIXME */
637 Spi->DemandZeroCount = 0; /* FIXME */
638 Spi->PageReadCount = 0; /* FIXME */
639 Spi->PageReadIoCount = 0; /* FIXME */
640 Spi->CacheReadCount = 0; /* FIXME */
641 Spi->CacheIoCount = 0; /* FIXME */
642 Spi->DirtyPagesWriteCount = 0; /* FIXME */
643 Spi->DirtyWriteIoCount = 0; /* FIXME */
644 Spi->MappedPagesWriteCount = 0; /* FIXME */
645 Spi->MappedWriteIoCount = 0; /* FIXME */
646
647 Spi->PagedPoolPages = 0;
648 Spi->NonPagedPoolPages = 0;
649 Spi->PagedPoolAllocs = 0;
650 Spi->PagedPoolFrees = 0;
651 Spi->PagedPoolLookasideHits = 0;
652 Spi->NonPagedPoolAllocs = 0;
653 Spi->NonPagedPoolFrees = 0;
654 Spi->NonPagedPoolLookasideHits = 0;
655 ExQueryPoolUsage(&Spi->PagedPoolPages,
656 &Spi->NonPagedPoolPages,
657 &Spi->PagedPoolAllocs,
658 &Spi->PagedPoolFrees,
659 &Spi->PagedPoolLookasideHits,
660 &Spi->NonPagedPoolAllocs,
661 &Spi->NonPagedPoolFrees,
662 &Spi->NonPagedPoolLookasideHits);
663 Spi->FreeSystemPtes = 0; /* FIXME */
664
665 Spi->ResidentSystemCodePage = 0; /* FIXME */
666
667 Spi->TotalSystemDriverPages = 0; /* FIXME */
668 Spi->Spare3Count = 0; /* FIXME */
669
670 Spi->ResidentSystemCachePage = MiMemoryConsumers[MC_CACHE].PagesUsed;
671 Spi->ResidentPagedPoolPage = 0; /* FIXME */
672
673 Spi->ResidentSystemDriverPage = 0; /* FIXME */
674 Spi->CcFastReadNoWait = 0; /* FIXME */
675 Spi->CcFastReadWait = 0; /* FIXME */
676 Spi->CcFastReadResourceMiss = 0; /* FIXME */
677 Spi->CcFastReadNotPossible = 0; /* FIXME */
678
679 Spi->CcFastMdlReadNoWait = 0; /* FIXME */
680 Spi->CcFastMdlReadWait = 0; /* FIXME */
681 Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
682 Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
683
684 Spi->CcMapDataNoWait = 0; /* FIXME */
685 Spi->CcMapDataWait = 0; /* FIXME */
686 Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
687 Spi->CcMapDataWaitMiss = 0; /* FIXME */
688
689 Spi->CcPinMappedDataCount = 0; /* FIXME */
690 Spi->CcPinReadNoWait = 0; /* FIXME */
691 Spi->CcPinReadWait = 0; /* FIXME */
692 Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
693 Spi->CcPinReadWaitMiss = 0; /* FIXME */
694 Spi->CcCopyReadNoWait = 0; /* FIXME */
695 Spi->CcCopyReadWait = 0; /* FIXME */
696 Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
697 Spi->CcCopyReadWaitMiss = 0; /* FIXME */
698
699 Spi->CcMdlReadNoWait = 0; /* FIXME */
700 Spi->CcMdlReadWait = 0; /* FIXME */
701 Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
702 Spi->CcMdlReadWaitMiss = 0; /* FIXME */
703 Spi->CcReadAheadIos = 0; /* FIXME */
704 Spi->CcLazyWriteIos = 0; /* FIXME */
705 Spi->CcLazyWritePages = 0; /* FIXME */
706 Spi->CcDataFlushes = 0; /* FIXME */
707 Spi->CcDataPages = 0; /* FIXME */
708 Spi->ContextSwitches = 0; /* FIXME */
709 Spi->FirstLevelTbFills = 0; /* FIXME */
710 Spi->SecondLevelTbFills = 0; /* FIXME */
711 Spi->SystemCalls = 0; /* FIXME */
712
713 return STATUS_SUCCESS;
714 }
715
716 /* Class 3 - Time Of Day Information */
717 QSI_DEF(SystemTimeOfDayInformation)
718 {
719 SYSTEM_TIMEOFDAY_INFORMATION Sti;
720 LARGE_INTEGER CurrentTime;
721
722 /* Set amount of written information to 0 */
723 *ReqSize = 0;
724
725 /* Check user buffer's size */
726 if (Size > sizeof(SYSTEM_TIMEOFDAY_INFORMATION))
727 {
728 return STATUS_INFO_LENGTH_MISMATCH;
729 }
730
731 /* Get current time */
732 KeQuerySystemTime(&CurrentTime);
733
734 /* Zero local buffer */
735 RtlZeroMemory(&Sti, sizeof(SYSTEM_TIMEOFDAY_INFORMATION));
736
737 /* Fill local time structure */
738 Sti.BootTime= KeBootTime;
739 Sti.CurrentTime = CurrentTime;
740 Sti.TimeZoneBias.QuadPart = ExpTimeZoneBias.QuadPart;
741 Sti.TimeZoneId = ExpTimeZoneId;
742 Sti.Reserved = 0;
743
744 /* Copy as much as requested by caller */
745 RtlCopyMemory(Buffer, &Sti, Size);
746
747 /* Set amount of information we copied */
748 *ReqSize = Size;
749
750 return STATUS_SUCCESS;
751 }
752
753 /* Class 4 - Path Information */
754 QSI_DEF(SystemPathInformation)
755 {
756 /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
757 DPRINT1("NtQuerySystemInformation - SystemPathInformation not implemented\n");
758
759 return STATUS_BREAKPOINT;
760 }
761
762 /* Class 5 - Process Information */
763 QSI_DEF(SystemProcessInformation)
764 {
765 PSYSTEM_PROCESS_INFORMATION SpiCurrent;
766 PSYSTEM_THREAD_INFORMATION ThreadInfo;
767 PEPROCESS Process = NULL, SystemProcess;
768 PETHREAD CurrentThread;
769 ANSI_STRING ImageName;
770 ULONG CurrentSize;
771 USHORT ImageNameMaximumLength; // image name len in bytes
772 USHORT ImageNameLength;
773 PLIST_ENTRY CurrentEntry;
774 ULONG TotalSize = 0, ThreadsCount;
775 ULONG TotalUser, TotalKernel;
776 PUCHAR Current;
777 NTSTATUS Status = STATUS_SUCCESS;
778 PUNICODE_STRING ProcessImageName;
779 PWCHAR szSrc;
780 BOOLEAN Overflow = FALSE;
781
782 _SEH2_TRY
783 {
784 /* scan the process list */
785
786 PSYSTEM_PROCESS_INFORMATION Spi
787 = (PSYSTEM_PROCESS_INFORMATION) Buffer;
788
789 *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
790
791 /* Check for overflow */
792 if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
793 {
794 Overflow = TRUE;
795 }
796
797 /* Zero user's buffer */
798 if (!Overflow) RtlZeroMemory(Spi, Size);
799
800 SystemProcess = PsIdleProcess;
801 Process = SystemProcess;
802 Current = (PUCHAR) Spi;
803
804 do
805 {
806 SpiCurrent = (PSYSTEM_PROCESS_INFORMATION) Current;
807
808 if ((Process->ProcessExiting) &&
809 (Process->Pcb.Header.SignalState) &&
810 !(Process->ActiveThreads) &&
811 (IsListEmpty(&Process->Pcb.ThreadListHead)))
812 {
813 DPRINT1("Process %p (%s:%p) is a zombie\n",
814 Process, Process->ImageFileName, Process->UniqueProcessId);
815 CurrentSize = 0;
816 ImageNameMaximumLength = 0;
817 goto Skip;
818 }
819
820 ThreadsCount = 0;
821 CurrentEntry = Process->Pcb.ThreadListHead.Flink;
822 while (CurrentEntry != &Process->Pcb.ThreadListHead)
823 {
824 ThreadsCount++;
825 CurrentEntry = CurrentEntry->Flink;
826 }
827
828 // size of the structure for every process
829 CurrentSize = sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION) * ThreadsCount;
830 ImageNameLength = 0;
831 Status = SeLocateProcessImageName(Process, &ProcessImageName);
832 szSrc = NULL;
833 if (NT_SUCCESS(Status) && (ProcessImageName->Length > 0))
834 {
835 szSrc = (PWCHAR)((PCHAR)ProcessImageName->Buffer + ProcessImageName->Length);
836 /* Loop the file name*/
837 while (szSrc > ProcessImageName->Buffer)
838 {
839 /* Make sure this isn't a backslash */
840 if (*--szSrc == OBJ_NAME_PATH_SEPARATOR)
841 {
842 szSrc++;
843 break;
844 }
845 else
846 {
847 ImageNameLength += sizeof(WCHAR);
848 }
849 }
850 }
851 if (!ImageNameLength && Process != PsIdleProcess)
852 {
853 ImageNameLength = (USHORT)strlen(Process->ImageFileName) * sizeof(WCHAR);
854 }
855
856 /* Round up the image name length as NT does */
857 if (ImageNameLength > 0)
858 ImageNameMaximumLength = ROUND_UP(ImageNameLength + sizeof(WCHAR), 8);
859 else
860 ImageNameMaximumLength = 0;
861
862 TotalSize += CurrentSize + ImageNameMaximumLength;
863
864 /* Check for overflow */
865 if (TotalSize > Size)
866 {
867 Overflow = TRUE;
868 }
869
870 /* Fill system information */
871 if (!Overflow)
872 {
873 SpiCurrent->NextEntryOffset = CurrentSize + ImageNameMaximumLength; // relative offset to the beginnnig of the next structure
874 SpiCurrent->NumberOfThreads = ThreadsCount;
875 SpiCurrent->CreateTime = Process->CreateTime;
876 SpiCurrent->ImageName.Length = ImageNameLength;
877 SpiCurrent->ImageName.MaximumLength = ImageNameMaximumLength;
878 SpiCurrent->ImageName.Buffer = (void*)(Current + CurrentSize);
879
880 /* Copy name to the end of the struct */
881 if(Process != PsIdleProcess)
882 {
883 if (szSrc)
884 {
885 RtlCopyMemory(SpiCurrent->ImageName.Buffer, szSrc, SpiCurrent->ImageName.Length);
886
887 /* Release the memory allocated by SeLocateProcessImageName */
888 ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
889 }
890 else
891 {
892 RtlInitAnsiString(&ImageName, Process->ImageFileName);
893 RtlAnsiStringToUnicodeString(&SpiCurrent->ImageName, &ImageName, FALSE);
894 }
895 }
896 else
897 {
898 RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
899 }
900
901 SpiCurrent->BasePriority = Process->Pcb.BasePriority;
902 SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
903 SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
904 SpiCurrent->HandleCount = ObGetProcessHandleCount(Process);
905 SpiCurrent->PeakVirtualSize = Process->PeakVirtualSize;
906 SpiCurrent->VirtualSize = Process->VirtualSize;
907 SpiCurrent->PageFaultCount = Process->Vm.PageFaultCount;
908 SpiCurrent->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
909 SpiCurrent->WorkingSetSize = Process->Vm.WorkingSetSize;
910 SpiCurrent->QuotaPeakPagedPoolUsage = Process->QuotaPeak[0];
911 SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[0];
912 SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[1];
913 SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[1];
914 SpiCurrent->PagefileUsage = Process->QuotaUsage[2];
915 SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[2];
916 SpiCurrent->PrivatePageCount = Process->CommitCharge;
917 ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCurrent + 1);
918
919 CurrentEntry = Process->Pcb.ThreadListHead.Flink;
920 while (CurrentEntry != &Process->Pcb.ThreadListHead)
921 {
922 CurrentThread = (PETHREAD)CONTAINING_RECORD(CurrentEntry, KTHREAD,
923 ThreadListEntry);
924
925 ThreadInfo->KernelTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.KernelTime, KeMaximumIncrement);
926 ThreadInfo->UserTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.UserTime, KeMaximumIncrement);
927 ThreadInfo->CreateTime.QuadPart = CurrentThread->CreateTime.QuadPart;
928 ThreadInfo->WaitTime = CurrentThread->Tcb.WaitTime;
929 ThreadInfo->StartAddress = (PVOID) CurrentThread->StartAddress;
930 ThreadInfo->ClientId = CurrentThread->Cid;
931 ThreadInfo->Priority = CurrentThread->Tcb.Priority;
932 ThreadInfo->BasePriority = CurrentThread->Tcb.BasePriority;
933 ThreadInfo->ContextSwitches = CurrentThread->Tcb.ContextSwitches;
934 ThreadInfo->ThreadState = CurrentThread->Tcb.State;
935 ThreadInfo->WaitReason = CurrentThread->Tcb.WaitReason;
936
937 ThreadInfo++;
938 CurrentEntry = CurrentEntry->Flink;
939 }
940
941 /* Query total user/kernel times of a process */
942 TotalKernel = KeQueryRuntimeProcess(&Process->Pcb, &TotalUser);
943 SpiCurrent->UserTime.QuadPart = UInt32x32To64(TotalUser, KeMaximumIncrement);
944 SpiCurrent->KernelTime.QuadPart = UInt32x32To64(TotalKernel, KeMaximumIncrement);
945 }
946
947 /* Handle idle process entry */
948 Skip:
949 if (Process == PsIdleProcess) Process = NULL;
950
951 Process = PsGetNextProcess(Process);
952 ThreadsCount = 0;
953 if ((Process == SystemProcess) || (Process == NULL))
954 {
955 if (!Overflow)
956 SpiCurrent->NextEntryOffset = 0;
957 break;
958 }
959 else
960 Current += CurrentSize + ImageNameMaximumLength;
961 } while ((Process != SystemProcess) && (Process != NULL));
962
963 if(Process != NULL)
964 ObDereferenceObject(Process);
965 Status = STATUS_SUCCESS;
966 }
967 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
968 {
969 if(Process != NULL)
970 ObDereferenceObject(Process);
971 Status = _SEH2_GetExceptionCode();
972 }
973 _SEH2_END
974
975 if (Overflow)
976 Status = STATUS_INFO_LENGTH_MISMATCH;
977
978 *ReqSize = TotalSize;
979 return Status;
980 }
981
982 /* Class 6 - Call Count Information */
983 QSI_DEF(SystemCallCountInformation)
984 {
985 /* FIXME */
986 DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
987 return STATUS_NOT_IMPLEMENTED;
988 }
989
990 /* Class 7 - Device Information */
991 QSI_DEF(SystemDeviceInformation)
992 {
993 PSYSTEM_DEVICE_INFORMATION Sdi
994 = (PSYSTEM_DEVICE_INFORMATION) Buffer;
995 PCONFIGURATION_INFORMATION ConfigInfo;
996
997 *ReqSize = sizeof(SYSTEM_DEVICE_INFORMATION);
998
999 /* Check user buffer's size */
1000 if (Size < sizeof(SYSTEM_DEVICE_INFORMATION))
1001 {
1002 return STATUS_INFO_LENGTH_MISMATCH;
1003 }
1004
1005 ConfigInfo = IoGetConfigurationInformation();
1006
1007 Sdi->NumberOfDisks = ConfigInfo->DiskCount;
1008 Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
1009 Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
1010 Sdi->NumberOfTapes = ConfigInfo->TapeCount;
1011 Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
1012 Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
1013
1014 return STATUS_SUCCESS;
1015 }
1016
1017 /* Class 8 - Processor Performance Information */
1018 QSI_DEF(SystemProcessorPerformanceInformation)
1019 {
1020 PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
1021 = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
1022
1023 LONG i;
1024 ULONG TotalTime;
1025 PKPRCB Prcb;
1026
1027 *ReqSize = KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
1028
1029 /* Check user buffer's size */
1030 if (Size < *ReqSize)
1031 {
1032 return STATUS_INFO_LENGTH_MISMATCH;
1033 }
1034
1035 for (i = 0; i < KeNumberProcessors; i++)
1036 {
1037 /* Get the PRCB on this processor */
1038 Prcb = KiProcessorBlock[i];
1039
1040 /* Calculate total user and kernel times */
1041 TotalTime = Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime;
1042 Spi->IdleTime.QuadPart = UInt32x32To64(TotalTime, KeMaximumIncrement);
1043 Spi->KernelTime.QuadPart = UInt32x32To64(Prcb->KernelTime, KeMaximumIncrement);
1044 Spi->UserTime.QuadPart = UInt32x32To64(Prcb->UserTime, KeMaximumIncrement);
1045 Spi->DpcTime.QuadPart = UInt32x32To64(Prcb->DpcTime, KeMaximumIncrement);
1046 Spi->InterruptTime.QuadPart = UInt32x32To64(Prcb->InterruptTime, KeMaximumIncrement);
1047 Spi->InterruptCount = Prcb->InterruptCount;
1048 Spi++;
1049 }
1050
1051 return STATUS_SUCCESS;
1052 }
1053
1054 /* Class 9 - Flags Information */
1055 QSI_DEF(SystemFlagsInformation)
1056 {
1057 if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1058 {
1059 *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1060 return (STATUS_INFO_LENGTH_MISMATCH);
1061 }
1062 ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
1063 return STATUS_SUCCESS;
1064 }
1065
1066 SSI_DEF(SystemFlagsInformation)
1067 {
1068 if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1069 {
1070 return STATUS_INFO_LENGTH_MISMATCH;
1071 }
1072 NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
1073 return STATUS_SUCCESS;
1074 }
1075
1076 /* Class 10 - Call Time Information */
1077 QSI_DEF(SystemCallTimeInformation)
1078 {
1079 /* FIXME */
1080 DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
1081 return STATUS_NOT_IMPLEMENTED;
1082 }
1083
1084 /* Class 11 - Module Information */
1085 QSI_DEF(SystemModuleInformation)
1086 {
1087 NTSTATUS Status;
1088
1089 /* Acquire system module list lock */
1090 KeEnterCriticalRegion();
1091 ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE);
1092
1093 /* Call the generic handler with the system module list */
1094 Status = ExpQueryModuleInformation(&PsLoadedModuleList,
1095 &MmLoadedUserImageList,
1096 (PRTL_PROCESS_MODULES)Buffer,
1097 Size,
1098 ReqSize);
1099
1100 /* Release list lock and return status */
1101 ExReleaseResourceLite(&PsLoadedModuleResource);
1102 KeLeaveCriticalRegion();
1103 return Status;
1104 }
1105
1106 /* Class 12 - Locks Information */
1107 QSI_DEF(SystemLocksInformation)
1108 {
1109 /* FIXME */
1110 DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
1111 return STATUS_NOT_IMPLEMENTED;
1112 }
1113
1114 /* Class 13 - Stack Trace Information */
1115 QSI_DEF(SystemStackTraceInformation)
1116 {
1117 /* FIXME */
1118 DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
1119 return STATUS_NOT_IMPLEMENTED;
1120 }
1121
1122 /* Class 14 - Paged Pool Information */
1123 QSI_DEF(SystemPagedPoolInformation)
1124 {
1125 /* FIXME */
1126 DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
1127 return STATUS_NOT_IMPLEMENTED;
1128 }
1129
1130 /* Class 15 - Non Paged Pool Information */
1131 QSI_DEF(SystemNonPagedPoolInformation)
1132 {
1133 /* FIXME */
1134 DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
1135 return STATUS_NOT_IMPLEMENTED;
1136 }
1137
1138
1139 /* Class 16 - Handle Information */
1140 QSI_DEF(SystemHandleInformation)
1141 {
1142 PEPROCESS pr, syspr;
1143 ULONG curSize, i = 0;
1144 ULONG hCount = 0;
1145
1146 PSYSTEM_HANDLE_INFORMATION Shi =
1147 (PSYSTEM_HANDLE_INFORMATION) Buffer;
1148
1149 DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1150
1151 if (Size < sizeof(SYSTEM_HANDLE_INFORMATION))
1152 {
1153 *ReqSize = sizeof(SYSTEM_HANDLE_INFORMATION);
1154 return STATUS_INFO_LENGTH_MISMATCH;
1155 }
1156
1157 DPRINT("SystemHandleInformation 1\n");
1158
1159 /* First Calc Size from Count. */
1160 syspr = PsGetNextProcess(NULL);
1161 pr = syspr;
1162
1163 do
1164 {
1165 hCount = hCount + ObGetProcessHandleCount(pr);
1166 pr = PsGetNextProcess(pr);
1167
1168 if ((pr == syspr) || (pr == NULL)) break;
1169 }
1170 while ((pr != syspr) && (pr != NULL));
1171
1172 if(pr != NULL)
1173 {
1174 ObDereferenceObject(pr);
1175 }
1176
1177 DPRINT("SystemHandleInformation 2\n");
1178
1179 curSize = sizeof(SYSTEM_HANDLE_INFORMATION) +
1180 ((sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) * hCount) -
1181 (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO)));
1182
1183 Shi->NumberOfHandles = hCount;
1184
1185 if (curSize > Size)
1186 {
1187 *ReqSize = curSize;
1188 return (STATUS_INFO_LENGTH_MISMATCH);
1189 }
1190
1191 DPRINT("SystemHandleInformation 3\n");
1192
1193 /* Now get Handles from all processs. */
1194 syspr = PsGetNextProcess(NULL);
1195 pr = syspr;
1196
1197 do
1198 {
1199 int Count = 0, HandleCount;
1200
1201 HandleCount = ObGetProcessHandleCount(pr);
1202
1203 for (Count = 0; HandleCount > 0 ; HandleCount--)
1204 {
1205 Shi->Handles[i].UniqueProcessId = (USHORT)(ULONG_PTR)pr->UniqueProcessId;
1206 Count++;
1207 i++;
1208 }
1209
1210 pr = PsGetNextProcess(pr);
1211
1212 if ((pr == syspr) || (pr == NULL)) break;
1213 }
1214 while ((pr != syspr) && (pr != NULL));
1215
1216 if(pr != NULL) ObDereferenceObject(pr);
1217
1218 DPRINT("SystemHandleInformation 4\n");
1219 return STATUS_SUCCESS;
1220
1221 }
1222 /*
1223 SSI_DEF(SystemHandleInformation)
1224 {
1225
1226 return STATUS_SUCCESS;
1227 }
1228 */
1229
1230 /* Class 17 - Information */
1231 QSI_DEF(SystemObjectInformation)
1232 {
1233 /* FIXME */
1234 DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1235 return STATUS_NOT_IMPLEMENTED;
1236 }
1237
1238 /* Class 18 - Information */
1239 QSI_DEF(SystemPageFileInformation)
1240 {
1241 UNICODE_STRING FileName; /* FIXME */
1242 SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
1243
1244 if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
1245 {
1246 * ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
1247 return STATUS_INFO_LENGTH_MISMATCH;
1248 }
1249
1250 RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1251
1252 /* FIXME */
1253 Spfi->NextEntryOffset = 0;
1254
1255 Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
1256 Spfi->TotalInUse = MiUsedSwapPages;
1257 Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1258 Spfi->PageFileName = FileName;
1259 return STATUS_SUCCESS;
1260 }
1261
1262 /* Class 19 - Vdm Instemul Information */
1263 QSI_DEF(SystemVdmInstemulInformation)
1264 {
1265 /* FIXME */
1266 DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1267 return STATUS_NOT_IMPLEMENTED;
1268 }
1269
1270 /* Class 20 - Vdm Bop Information */
1271 QSI_DEF(SystemVdmBopInformation)
1272 {
1273 /* FIXME */
1274 DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1275 return STATUS_NOT_IMPLEMENTED;
1276 }
1277
1278 /* Class 21 - File Cache Information */
1279 QSI_DEF(SystemFileCacheInformation)
1280 {
1281 SYSTEM_FILECACHE_INFORMATION *Sci = (SYSTEM_FILECACHE_INFORMATION *) Buffer;
1282
1283 if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1284 {
1285 *ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
1286 return STATUS_INFO_LENGTH_MISMATCH;
1287 }
1288
1289 RtlZeroMemory(Sci, sizeof(SYSTEM_FILECACHE_INFORMATION));
1290
1291 /* Return the Byte size not the page size. */
1292 Sci->CurrentSize =
1293 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
1294 Sci->PeakSize =
1295 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
1296 /* Taskmgr multiplies this one by page size right away */
1297 Sci->CurrentSizeIncludingTransitionInPages =
1298 MiMemoryConsumers[MC_CACHE].PagesUsed; /* FIXME: Should be */
1299 /* system working set and standby pages. */
1300 Sci->PageFaultCount = 0; /* FIXME */
1301 Sci->MinimumWorkingSet = 0; /* FIXME */
1302 Sci->MaximumWorkingSet = 0; /* FIXME */
1303
1304 return STATUS_SUCCESS;
1305 }
1306
1307 SSI_DEF(SystemFileCacheInformation)
1308 {
1309 if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1310 {
1311 return STATUS_INFO_LENGTH_MISMATCH;
1312 }
1313 /* FIXME */
1314 DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1315 return STATUS_NOT_IMPLEMENTED;
1316 }
1317
1318 /* Class 22 - Pool Tag Information */
1319 QSI_DEF(SystemPoolTagInformation)
1320 {
1321 if (Size < sizeof(SYSTEM_POOLTAG_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
1322 return ExGetPoolTagInfo(Buffer, Size, ReqSize);
1323 }
1324
1325 /* Class 23 - Interrupt Information for all processors */
1326 QSI_DEF(SystemInterruptInformation)
1327 {
1328 PKPRCB Prcb;
1329 LONG i;
1330 ULONG ti;
1331 PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1332
1333 if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1334 {
1335 return STATUS_INFO_LENGTH_MISMATCH;
1336 }
1337
1338 ti = KeQueryTimeIncrement();
1339
1340 for (i = 0; i < KeNumberProcessors; i++)
1341 {
1342 Prcb = KiProcessorBlock[i];
1343 sii->ContextSwitches = KeGetContextSwitches(Prcb);
1344 sii->DpcCount = Prcb->DpcData[0].DpcCount;
1345 sii->DpcRate = Prcb->DpcRequestRate;
1346 sii->TimeIncrement = ti;
1347 sii->DpcBypassCount = 0;
1348 sii->ApcBypassCount = 0;
1349 sii++;
1350 }
1351
1352 return STATUS_SUCCESS;
1353 }
1354
1355 /* Class 24 - DPC Behaviour Information */
1356 QSI_DEF(SystemDpcBehaviourInformation)
1357 {
1358 /* FIXME */
1359 DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1360 return STATUS_NOT_IMPLEMENTED;
1361 }
1362
1363 SSI_DEF(SystemDpcBehaviourInformation)
1364 {
1365 /* FIXME */
1366 DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1367 return STATUS_NOT_IMPLEMENTED;
1368 }
1369
1370 /* Class 25 - Full Memory Information */
1371 QSI_DEF(SystemFullMemoryInformation)
1372 {
1373 PULONG Spi = (PULONG) Buffer;
1374
1375 PEPROCESS TheIdleProcess;
1376
1377 *ReqSize = sizeof(ULONG);
1378
1379 if (sizeof(ULONG) != Size)
1380 {
1381 return STATUS_INFO_LENGTH_MISMATCH;
1382 }
1383
1384 DPRINT("SystemFullMemoryInformation\n");
1385
1386 TheIdleProcess = PsIdleProcess;
1387
1388 DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
1389 TheIdleProcess->UniqueProcessId,
1390 TheIdleProcess->Pcb.KernelTime,
1391 MiFreeSwapPages,
1392 MiUsedSwapPages);
1393
1394 *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1395
1396 return STATUS_SUCCESS;
1397 }
1398
1399 /* Class 26 - Load Image */
1400 SSI_DEF(SystemLoadGdiDriverInformation)
1401 {
1402 PSYSTEM_GDI_DRIVER_INFORMATION DriverInfo = (PVOID)Buffer;
1403 UNICODE_STRING ImageName;
1404 PVOID ImageBase;
1405 PVOID SectionPointer;
1406 ULONG_PTR EntryPoint;
1407 NTSTATUS Status;
1408 ULONG DirSize;
1409 PIMAGE_NT_HEADERS NtHeader;
1410
1411 /* Validate size */
1412 if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1413 {
1414 /* Incorrect buffer length, fail */
1415 return STATUS_INFO_LENGTH_MISMATCH;
1416 }
1417
1418 /* Only kernel mode can call this function */
1419 if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1420
1421 /* Load the driver */
1422 ImageName = DriverInfo->DriverName;
1423 Status = MmLoadSystemImage(&ImageName,
1424 NULL,
1425 NULL,
1426 0,
1427 &SectionPointer,
1428 &ImageBase);
1429 if (!NT_SUCCESS(Status)) return Status;
1430
1431 /* Return the export pointer */
1432 DriverInfo->ExportSectionPointer =
1433 RtlImageDirectoryEntryToData(ImageBase,
1434 TRUE,
1435 IMAGE_DIRECTORY_ENTRY_EXPORT,
1436 &DirSize);
1437
1438 /* Get the entrypoint */
1439 NtHeader = RtlImageNtHeader(ImageBase);
1440 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1441 EntryPoint += (ULONG_PTR)ImageBase;
1442
1443 /* Save other data */
1444 DriverInfo->ImageAddress = ImageBase;
1445 DriverInfo->SectionPointer = SectionPointer;
1446 DriverInfo->EntryPoint = (PVOID)EntryPoint;
1447 DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1448
1449 /* All is good */
1450 return STATUS_SUCCESS;
1451 }
1452
1453 /* Class 27 - Unload Image */
1454 SSI_DEF(SystemUnloadGdiDriverInformation)
1455 {
1456 PVOID *SectionPointer = Buffer;
1457
1458 /* Validate size */
1459 if (Size != sizeof(PVOID))
1460 {
1461 /* Incorrect length, fail */
1462 return STATUS_INFO_LENGTH_MISMATCH;
1463 }
1464
1465 /* Only kernel mode can call this function */
1466 if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1467
1468 /* Unload the image */
1469 MmUnloadSystemImage(*SectionPointer);
1470 return STATUS_SUCCESS;
1471 }
1472
1473 /* Class 28 - Time Adjustment Information */
1474 QSI_DEF(SystemTimeAdjustmentInformation)
1475 {
1476 PSYSTEM_QUERY_TIME_ADJUST_INFORMATION TimeInfo =
1477 (PSYSTEM_QUERY_TIME_ADJUST_INFORMATION)Buffer;
1478
1479 /* Check if enough storage was provided */
1480 if (sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION) > Size)
1481 {
1482 * ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
1483 return STATUS_INFO_LENGTH_MISMATCH;
1484 }
1485
1486 /* Give time values to our caller */
1487 TimeInfo->TimeIncrement = KeMaximumIncrement;
1488 TimeInfo->TimeAdjustment = KeTimeAdjustment;
1489 TimeInfo->Enable = !KiTimeAdjustmentEnabled;
1490
1491 return STATUS_SUCCESS;
1492 }
1493
1494 SSI_DEF(SystemTimeAdjustmentInformation)
1495 {
1496 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1497 PSYSTEM_SET_TIME_ADJUST_INFORMATION TimeInfo =
1498 (PSYSTEM_SET_TIME_ADJUST_INFORMATION)Buffer;
1499
1500 /* Check size of a buffer, it must match our expectations */
1501 if (sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION) != Size)
1502 return STATUS_INFO_LENGTH_MISMATCH;
1503
1504 /* Check who is calling */
1505 if (PreviousMode != KernelMode)
1506 {
1507 /* Check access rights */
1508 if (!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
1509 {
1510 return STATUS_PRIVILEGE_NOT_HELD;
1511 }
1512 }
1513
1514 /* FIXME: behaviour suggests the member be named 'Disable' */
1515 if (TimeInfo->Enable)
1516 {
1517 /* Disable time adjustment and set default value */
1518 KiTimeAdjustmentEnabled = FALSE;
1519 KeTimeAdjustment = KeMaximumIncrement;
1520 }
1521 else
1522 {
1523 /* Check if a valid time adjustment value is given */
1524 if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
1525
1526 /* Enable time adjustment and set the adjustment value */
1527 KiTimeAdjustmentEnabled = TRUE;
1528 KeTimeAdjustment = TimeInfo->TimeAdjustment;
1529 }
1530
1531 return STATUS_SUCCESS;
1532 }
1533
1534 /* Class 29 - Summary Memory Information */
1535 QSI_DEF(SystemSummaryMemoryInformation)
1536 {
1537 /* FIXME */
1538 DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1539 return STATUS_NOT_IMPLEMENTED;
1540 }
1541
1542 /* Class 30 - Next Event Id Information */
1543 QSI_DEF(SystemNextEventIdInformation)
1544 {
1545 /* FIXME */
1546 DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1547 return STATUS_NOT_IMPLEMENTED;
1548 }
1549
1550 /* Class 31 - Event Ids Information */
1551 QSI_DEF(SystemEventIdsInformation)
1552 {
1553 /* FIXME */
1554 DPRINT1("NtQuerySystemInformation - SystemEventIdsInformation not implemented\n");
1555 return STATUS_NOT_IMPLEMENTED;
1556 }
1557
1558 /* Class 32 - Crash Dump Information */
1559 QSI_DEF(SystemCrashDumpInformation)
1560 {
1561 /* FIXME */
1562 DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1563 return STATUS_NOT_IMPLEMENTED;
1564 }
1565
1566 /* Class 33 - Exception Information */
1567 QSI_DEF(SystemExceptionInformation)
1568 {
1569 PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
1570 (PSYSTEM_EXCEPTION_INFORMATION)Buffer;
1571 PKPRCB Prcb;
1572 ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
1573 ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
1574 CHAR i;
1575
1576 /* Check size of a buffer, it must match our expectations */
1577 if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
1578 return STATUS_INFO_LENGTH_MISMATCH;
1579
1580 /* Sum up exception count information from all processors */
1581 for (i = 0; i < KeNumberProcessors; i++)
1582 {
1583 Prcb = KiProcessorBlock[i];
1584 if (Prcb)
1585 {
1586 AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
1587 ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
1588 FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
1589 }
1590 }
1591
1592 /* Save information in user's buffer */
1593 ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
1594 ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
1595 ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
1596 ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
1597
1598 return STATUS_SUCCESS;
1599 }
1600
1601 /* Class 34 - Crash Dump State Information */
1602 QSI_DEF(SystemCrashDumpStateInformation)
1603 {
1604 /* FIXME */
1605 DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1606 return STATUS_NOT_IMPLEMENTED;
1607 }
1608
1609 /* Class 35 - Kernel Debugger Information */
1610 QSI_DEF(SystemKernelDebuggerInformation)
1611 {
1612 PSYSTEM_KERNEL_DEBUGGER_INFORMATION skdi = (PSYSTEM_KERNEL_DEBUGGER_INFORMATION) Buffer;
1613
1614 *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1615 if (Size < sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION))
1616 {
1617 return STATUS_INFO_LENGTH_MISMATCH;
1618 }
1619
1620 skdi->KernelDebuggerEnabled = KD_DEBUGGER_ENABLED;
1621 skdi->KernelDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
1622
1623 return STATUS_SUCCESS;
1624 }
1625
1626 /* Class 36 - Context Switch Information */
1627 QSI_DEF(SystemContextSwitchInformation)
1628 {
1629 PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
1630 (PSYSTEM_CONTEXT_SWITCH_INFORMATION)Buffer;
1631 ULONG ContextSwitches;
1632 PKPRCB Prcb;
1633 CHAR i;
1634
1635 /* Check size of a buffer, it must match our expectations */
1636 if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
1637 return STATUS_INFO_LENGTH_MISMATCH;
1638
1639 /* Calculate total value of context switches across all processors */
1640 ContextSwitches = 0;
1641 for (i = 0; i < KeNumberProcessors; i ++)
1642 {
1643 Prcb = KiProcessorBlock[i];
1644 if (Prcb)
1645 {
1646 ContextSwitches += KeGetContextSwitches(Prcb);
1647 }
1648 }
1649
1650 ContextSwitchInformation->ContextSwitches = ContextSwitches;
1651
1652 /* FIXME */
1653 ContextSwitchInformation->FindAny = 0;
1654 ContextSwitchInformation->FindLast = 0;
1655 ContextSwitchInformation->FindIdeal = 0;
1656 ContextSwitchInformation->IdleAny = 0;
1657 ContextSwitchInformation->IdleCurrent = 0;
1658 ContextSwitchInformation->IdleLast = 0;
1659 ContextSwitchInformation->IdleIdeal = 0;
1660 ContextSwitchInformation->PreemptAny = 0;
1661 ContextSwitchInformation->PreemptCurrent = 0;
1662 ContextSwitchInformation->PreemptLast = 0;
1663 ContextSwitchInformation->SwitchToIdle = 0;
1664
1665 return STATUS_SUCCESS;
1666 }
1667
1668 /* Class 37 - Registry Quota Information */
1669 QSI_DEF(SystemRegistryQuotaInformation)
1670 {
1671 PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1672
1673 *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1674 if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1675 {
1676 return STATUS_INFO_LENGTH_MISMATCH;
1677 }
1678
1679 DPRINT1("Faking max registry size of 32 MB\n");
1680 srqi->RegistryQuotaAllowed = 0x2000000;
1681 srqi->RegistryQuotaUsed = 0x200000;
1682 srqi->PagedPoolSize = 0x200000;
1683
1684 return STATUS_SUCCESS;
1685 }
1686
1687 SSI_DEF(SystemRegistryQuotaInformation)
1688 {
1689 /* FIXME */
1690 DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1691 return STATUS_NOT_IMPLEMENTED;
1692 }
1693
1694 /* Class 38 - Load And Call Image */
1695 SSI_DEF(SystemExtendServiceTableInformation)
1696 {
1697 UNICODE_STRING ImageName;
1698 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1699 PLDR_DATA_TABLE_ENTRY ModuleObject;
1700 NTSTATUS Status;
1701 PIMAGE_NT_HEADERS NtHeader;
1702 DRIVER_OBJECT Win32k;
1703 PDRIVER_INITIALIZE DriverInit;
1704 PVOID ImageBase;
1705 ULONG_PTR EntryPoint;
1706
1707 /* Validate the size */
1708 if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1709
1710 /* Check who is calling */
1711 if (PreviousMode != KernelMode)
1712 {
1713 static const UNICODE_STRING Win32kName =
1714 RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
1715
1716 /* Make sure we can load drivers */
1717 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, UserMode))
1718 {
1719 /* FIXME: We can't, fail */
1720 return STATUS_PRIVILEGE_NOT_HELD;
1721 }
1722
1723 _SEH2_TRY
1724 {
1725 /* Probe and copy the unicode string */
1726 ProbeForRead(Buffer, sizeof(ImageName), 1);
1727 ImageName = *(PUNICODE_STRING)Buffer;
1728
1729 /* Probe the string buffer */
1730 ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
1731
1732 /* Check if we have the correct name (nothing else is allowed!) */
1733 if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
1734 {
1735 _SEH2_YIELD(return STATUS_PRIVILEGE_NOT_HELD);
1736 }
1737 }
1738 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1739 {
1740 _SEH2_YIELD(return _SEH2_GetExceptionCode());
1741 }
1742 _SEH2_END;
1743
1744 /* Recursively call the function, so that we are from kernel mode */
1745 return ZwSetSystemInformation(SystemExtendServiceTableInformation,
1746 (PVOID)&Win32kName,
1747 sizeof(Win32kName));
1748 }
1749
1750 /* Load the image */
1751 Status = MmLoadSystemImage((PUNICODE_STRING)Buffer,
1752 NULL,
1753 NULL,
1754 0,
1755 (PVOID)&ModuleObject,
1756 &ImageBase);
1757
1758 if (!NT_SUCCESS(Status)) return Status;
1759
1760 /* Get the headers */
1761 NtHeader = RtlImageNtHeader(ImageBase);
1762 if (!NtHeader)
1763 {
1764 /* Fail */
1765 MmUnloadSystemImage(ModuleObject);
1766 return STATUS_INVALID_IMAGE_FORMAT;
1767 }
1768
1769 /* Get the entrypoint */
1770 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1771 EntryPoint += (ULONG_PTR)ImageBase;
1772 DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1773
1774 /* Create a dummy device */
1775 RtlZeroMemory(&Win32k, sizeof(Win32k));
1776 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1777 Win32k.DriverStart = ImageBase;
1778
1779 /* Call it */
1780 Status = (DriverInit)(&Win32k, NULL);
1781 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1782
1783 /* Unload if we failed */
1784 if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
1785 return Status;
1786 }
1787
1788 /* Class 39 - Priority Separation */
1789 SSI_DEF(SystemPrioritySeperation)
1790 {
1791 /* FIXME */
1792 DPRINT1("NtSetSystemInformation - SystemPrioritySeperation not implemented\n");
1793 return STATUS_NOT_IMPLEMENTED;
1794 }
1795
1796 /* Class 40 - Plug Play Bus Information */
1797 QSI_DEF(SystemPlugPlayBusInformation)
1798 {
1799 /* FIXME */
1800 DPRINT1("NtQuerySystemInformation - SystemPlugPlayBusInformation not implemented\n");
1801 return STATUS_NOT_IMPLEMENTED;
1802 }
1803
1804 /* Class 41 - Dock Information */
1805 QSI_DEF(SystemDockInformation)
1806 {
1807 /* FIXME */
1808 DPRINT1("NtQuerySystemInformation - SystemDockInformation not implemented\n");
1809 return STATUS_NOT_IMPLEMENTED;
1810 }
1811
1812 /* Class 42 - Power Information */
1813 QSI_DEF(SystemPowerInformation)
1814 {
1815 /* FIXME */
1816 DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
1817 return STATUS_NOT_IMPLEMENTED;
1818 }
1819
1820 /* Class 43 - Processor Speed Information */
1821 QSI_DEF(SystemProcessorSpeedInformation)
1822 {
1823 /* FIXME */
1824 DPRINT1("NtQuerySystemInformation - SystemProcessorSpeedInformation not implemented\n");
1825 return STATUS_NOT_IMPLEMENTED;
1826 }
1827
1828 /* Class 44 - Current Time Zone Information */
1829 QSI_DEF(SystemCurrentTimeZoneInformation)
1830 {
1831 *ReqSize = sizeof(TIME_ZONE_INFORMATION);
1832
1833 if (sizeof(TIME_ZONE_INFORMATION) != Size)
1834 {
1835 return STATUS_INFO_LENGTH_MISMATCH;
1836 }
1837
1838 /* Copy the time zone information struct */
1839 memcpy(Buffer,
1840 &ExpTimeZoneInfo,
1841 sizeof(TIME_ZONE_INFORMATION));
1842
1843 return STATUS_SUCCESS;
1844 }
1845
1846
1847 SSI_DEF(SystemCurrentTimeZoneInformation)
1848 {
1849 /* Check user buffer's size */
1850 if (Size < sizeof(TIME_ZONE_INFORMATION))
1851 {
1852 return STATUS_INFO_LENGTH_MISMATCH;
1853 }
1854
1855 return ExpSetTimeZoneInformation((PTIME_ZONE_INFORMATION)Buffer);
1856 }
1857
1858 static
1859 VOID
1860 ExpCopyLookasideInformation(
1861 PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
1862 PULONG RemainingPointer,
1863 PLIST_ENTRY ListHead,
1864 BOOLEAN ListUsesMisses)
1865
1866 {
1867 PSYSTEM_LOOKASIDE_INFORMATION Info;
1868 PGENERAL_LOOKASIDE LookasideList;
1869 PLIST_ENTRY ListEntry;
1870 ULONG Remaining;
1871
1872 /* Get info pointer and remaining count of free array element */
1873 Info = *InfoPointer;
1874 Remaining = *RemainingPointer;
1875
1876 /* Loop as long as we have lookaside lists and free array elements */
1877 for (ListEntry = ListHead->Flink;
1878 (ListEntry != ListHead) && (Remaining > 0);
1879 ListEntry = ListEntry->Flink, Remaining--)
1880 {
1881 LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
1882
1883 /* Fill the next array element */
1884 Info->CurrentDepth = LookasideList->Depth;
1885 Info->MaximumDepth = LookasideList->MaximumDepth;
1886 Info->TotalAllocates = LookasideList->TotalAllocates;
1887 Info->TotalFrees = LookasideList->TotalFrees;
1888 Info->Type = LookasideList->Type;
1889 Info->Tag = LookasideList->Tag;
1890 Info->Size = LookasideList->Size;
1891
1892 /* Check how the lists track misses/hits */
1893 if (ListUsesMisses)
1894 {
1895 /* Copy misses */
1896 Info->AllocateMisses = LookasideList->AllocateMisses;
1897 Info->FreeMisses = LookasideList->FreeMisses;
1898 }
1899 else
1900 {
1901 /* Calculate misses */
1902 Info->AllocateMisses = LookasideList->TotalAllocates
1903 - LookasideList->AllocateHits;
1904 Info->FreeMisses = LookasideList->TotalFrees
1905 - LookasideList->FreeHits;
1906 }
1907 }
1908
1909 /* Return the updated pointer and remaining count */
1910 *InfoPointer = Info;
1911 *RemainingPointer = Remaining;
1912 }
1913
1914 /* Class 45 - Lookaside Information */
1915 QSI_DEF(SystemLookasideInformation)
1916 {
1917 KPROCESSOR_MODE PreviousMode;
1918 PSYSTEM_LOOKASIDE_INFORMATION Info;
1919 PMDL Mdl;
1920 ULONG MaxCount, Remaining;
1921 KIRQL OldIrql;
1922 NTSTATUS Status;
1923
1924 /* First we need to lock down the memory, since we are going to access it
1925 at high IRQL */
1926 PreviousMode = ExGetPreviousMode();
1927 Status = ExLockUserBuffer(Buffer,
1928 Size,
1929 PreviousMode,
1930 IoWriteAccess,
1931 (PVOID*)&Info,
1932 &Mdl);
1933 if (!NT_SUCCESS(Status))
1934 {
1935 DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
1936 return Status;
1937 }
1938
1939 /* Calculate how many items we can store */
1940 Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
1941 if (Remaining == 0)
1942 {
1943 goto Leave;
1944 }
1945
1946 /* Copy info from pool lookaside lists */
1947 ExpCopyLookasideInformation(&Info,
1948 &Remaining,
1949 &ExPoolLookasideListHead,
1950 FALSE);
1951 if (Remaining == 0)
1952 {
1953 goto Leave;
1954 }
1955
1956 /* Copy info from system lookaside lists */
1957 ExpCopyLookasideInformation(&Info,
1958 &Remaining,
1959 &ExSystemLookasideListHead,
1960 TRUE);
1961 if (Remaining == 0)
1962 {
1963 goto Leave;
1964 }
1965
1966 /* Acquire spinlock for ExpNonPagedLookasideListHead */
1967 OldIrql = KfAcquireSpinLock(&ExpNonPagedLookasideListLock);
1968
1969 /* Copy info from non-paged lookaside lists */
1970 ExpCopyLookasideInformation(&Info,
1971 &Remaining,
1972 &ExpNonPagedLookasideListHead,
1973 TRUE);
1974
1975 /* Release spinlock for ExpNonPagedLookasideListHead */
1976 KfReleaseSpinLock(&ExpNonPagedLookasideListLock, OldIrql);
1977
1978 if (Remaining == 0)
1979 {
1980 goto Leave;
1981 }
1982
1983 /* Acquire spinlock for ExpPagedLookasideListHead */
1984 OldIrql = KfAcquireSpinLock(&ExpPagedLookasideListLock);
1985
1986 /* Copy info from paged lookaside lists */
1987 ExpCopyLookasideInformation(&Info,
1988 &Remaining,
1989 &ExpPagedLookasideListHead,
1990 TRUE);
1991
1992 /* Release spinlock for ExpPagedLookasideListHead */
1993 KfReleaseSpinLock(&ExpPagedLookasideListLock, OldIrql);
1994
1995 Leave:
1996
1997 /* Release the locked user buffer */
1998 ExUnlockUserBuffer(Mdl);
1999
2000 /* Return the size of the actually written data */
2001 *ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2002 return STATUS_SUCCESS;
2003 }
2004
2005
2006 /* Class 46 - Set time slip event */
2007 SSI_DEF(SystemSetTimeSlipEvent)
2008 {
2009 /* FIXME */
2010 DPRINT1("NtSetSystemInformation - SystemSetTimSlipEvent not implemented\n");
2011 return STATUS_NOT_IMPLEMENTED;
2012 }
2013
2014 NTSTATUS
2015 NTAPI
2016 MmSessionCreate(OUT PULONG SessionId);
2017
2018 NTSTATUS
2019 NTAPI
2020 MmSessionDelete(IN ULONG SessionId);
2021
2022 /* Class 47 - Create a new session (TSE) */
2023 SSI_DEF(SystemCreateSession)
2024 {
2025 ULONG SessionId;
2026 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2027 NTSTATUS Status;
2028
2029 if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2030
2031 if (PreviousMode != KernelMode)
2032 {
2033 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2034 {
2035 return STATUS_PRIVILEGE_NOT_HELD;
2036 }
2037 }
2038
2039 Status = MmSessionCreate(&SessionId);
2040 if (NT_SUCCESS(Status)) *(PULONG)Buffer = SessionId;
2041
2042 return Status;
2043 }
2044
2045
2046 /* Class 48 - Delete an existing session (TSE) */
2047 SSI_DEF(SystemDeleteSession)
2048 {
2049 ULONG SessionId;
2050 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2051
2052 if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2053
2054 if (PreviousMode != KernelMode)
2055 {
2056 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2057 {
2058 return STATUS_PRIVILEGE_NOT_HELD;
2059 }
2060 }
2061
2062 SessionId = *(PULONG)Buffer;
2063
2064 return MmSessionDelete(SessionId);
2065 }
2066
2067
2068 /* Class 49 - UNKNOWN */
2069 QSI_DEF(SystemInvalidInfoClass4)
2070 {
2071 /* FIXME */
2072 DPRINT1("NtQuerySystemInformation - SystemInvalidInfoClass4 not implemented\n");
2073 return STATUS_NOT_IMPLEMENTED;
2074 }
2075
2076
2077 /* Class 50 - System range start address */
2078 QSI_DEF(SystemRangeStartInformation)
2079 {
2080 /* Check user buffer's size */
2081 if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
2082
2083 *(PULONG_PTR)Buffer = (ULONG_PTR)MmSystemRangeStart;
2084
2085 if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
2086
2087 return STATUS_SUCCESS;
2088 }
2089
2090 /* Class 51 - Driver verifier information */
2091 QSI_DEF(SystemVerifierInformation)
2092 {
2093 /* FIXME */
2094 DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
2095 return STATUS_NOT_IMPLEMENTED;
2096 }
2097
2098
2099 SSI_DEF(SystemVerifierInformation)
2100 {
2101 /* FIXME */
2102 DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
2103 return STATUS_NOT_IMPLEMENTED;
2104 }
2105
2106
2107 /* Class 52 - Add a driver verifier */
2108 SSI_DEF(SystemAddVerifier)
2109 {
2110 /* FIXME */
2111 DPRINT1("NtSetSystemInformation - SystemAddVerifier not implemented\n");
2112 return STATUS_NOT_IMPLEMENTED;
2113 }
2114
2115
2116 /* Class 53 - A session's processes */
2117 QSI_DEF(SystemSessionProcessesInformation)
2118 {
2119 /* FIXME */
2120 DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
2121 return STATUS_NOT_IMPLEMENTED;
2122 }
2123
2124
2125 /* Query/Set Calls Table */
2126 typedef
2127 struct _QSSI_CALLS
2128 {
2129 NTSTATUS (* Query) (PVOID,ULONG,PULONG);
2130 NTSTATUS (* Set) (PVOID,ULONG);
2131
2132 } QSSI_CALLS;
2133
2134 // QS Query & Set
2135 // QX Query
2136 // XS Set
2137 // XX unknown behaviour
2138 //
2139 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
2140 #define SI_QX(n) {QSI_USE(n),NULL}
2141 #define SI_XS(n) {NULL,SSI_USE(n)}
2142 #define SI_XX(n) {NULL,NULL}
2143
2144 static
2145 QSSI_CALLS
2146 CallQS [] =
2147 {
2148 SI_QX(SystemBasicInformation),
2149 SI_QX(SystemProcessorInformation),
2150 SI_QX(SystemPerformanceInformation),
2151 SI_QX(SystemTimeOfDayInformation),
2152 SI_QX(SystemPathInformation), /* should be SI_XX */
2153 SI_QX(SystemProcessInformation), // aka SystemProcessesAndThreadsInformation
2154 SI_QX(SystemCallCountInformation), // aka SystemCallCounts
2155 SI_QX(SystemDeviceInformation), // aka SystemConfigurationInformation
2156 SI_QX(SystemProcessorPerformanceInformation), // aka SystemProcessorTimes
2157 SI_QS(SystemFlagsInformation), // aka SystemGlobalFlag
2158 SI_QX(SystemCallTimeInformation), /* should be SI_XX */
2159 SI_QX(SystemModuleInformation),
2160 SI_QX(SystemLocksInformation), // aka SystemLockInformation
2161 SI_QX(SystemStackTraceInformation), /* should be SI_XX */
2162 SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
2163 SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
2164 SI_QX(SystemHandleInformation),
2165 SI_QX(SystemObjectInformation),
2166 SI_QX(SystemPageFileInformation), // aka SystemPagefileInformation
2167 SI_QX(SystemVdmInstemulInformation), // aka SystemInstructionEmulationCounts
2168 SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
2169 SI_QS(SystemFileCacheInformation), // aka SystemCacheInformation
2170 SI_QX(SystemPoolTagInformation),
2171 SI_QX(SystemInterruptInformation), // aka SystemProcessorStatistics
2172 SI_QS(SystemDpcBehaviourInformation), // aka SystemDpcInformation
2173 SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
2174 SI_XS(SystemLoadGdiDriverInformation), // correct: SystemLoadImage
2175 SI_XS(SystemUnloadGdiDriverInformation), // correct: SystemUnloadImage
2176 SI_QS(SystemTimeAdjustmentInformation), // aka SystemTimeAdjustment
2177 SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
2178 SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
2179 SI_QX(SystemEventIdsInformation), /* it should be SI_XX */ // SystemPerformanceTraceInformation
2180 SI_QX(SystemCrashDumpInformation),
2181 SI_QX(SystemExceptionInformation),
2182 SI_QX(SystemCrashDumpStateInformation),
2183 SI_QX(SystemKernelDebuggerInformation),
2184 SI_QX(SystemContextSwitchInformation),
2185 SI_QS(SystemRegistryQuotaInformation),
2186 SI_XS(SystemExtendServiceTableInformation), // correct: SystemLoadAndCallImage
2187 SI_XS(SystemPrioritySeperation),
2188 SI_QX(SystemPlugPlayBusInformation), /* it should be SI_XX */
2189 SI_QX(SystemDockInformation), /* it should be SI_XX */
2190 SI_QX(SystemPowerInformation), /* it should be SI_XX */ // SystemPowerInformationNative? SystemInvalidInfoClass2
2191 SI_QX(SystemProcessorSpeedInformation), /* it should be SI_XX */
2192 SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */ // aka SystemTimeZoneInformation
2193 SI_QX(SystemLookasideInformation),
2194 SI_XS(SystemSetTimeSlipEvent),
2195 SI_XS(SystemCreateSession),
2196 SI_XS(SystemDeleteSession),
2197 SI_QX(SystemInvalidInfoClass4), /* it should be SI_XX */ // SystemSessionInformation?
2198 SI_QX(SystemRangeStartInformation),
2199 SI_QS(SystemVerifierInformation),
2200 SI_XS(SystemAddVerifier),
2201 SI_QX(SystemSessionProcessesInformation)
2202 };
2203
2204 C_ASSERT(SystemBasicInformation == 0);
2205 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
2206 #define MAX_SYSTEM_INFO_CLASS (sizeof(CallQS) / sizeof(CallQS[0]))
2207
2208 /*
2209 * @implemented
2210 */
2211 NTSTATUS NTAPI
2212 NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2213 OUT PVOID SystemInformation,
2214 IN ULONG Length,
2215 OUT PULONG UnsafeResultLength)
2216 {
2217 KPROCESSOR_MODE PreviousMode;
2218 ULONG ResultLength = 0;
2219 NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;
2220
2221 PAGED_CODE();
2222
2223 PreviousMode = ExGetPreviousMode();
2224
2225 _SEH2_TRY
2226 {
2227 if (PreviousMode != KernelMode)
2228 {
2229 /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
2230 ProbeForWrite(SystemInformation, Length, 1);
2231 if (UnsafeResultLength != NULL)
2232 ProbeForWriteUlong(UnsafeResultLength);
2233 }
2234
2235 if (UnsafeResultLength)
2236 *UnsafeResultLength = 0;
2237
2238 /*
2239 * Check if the request is valid.
2240 */
2241 if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2242 {
2243 _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
2244 }
2245
2246 if (NULL != CallQS [SystemInformationClass].Query)
2247 {
2248 /*
2249 * Hand the request to a subhandler.
2250 */
2251 FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
2252 Length,
2253 &ResultLength);
2254
2255 /* Save the result length to the caller */
2256 if (UnsafeResultLength)
2257 *UnsafeResultLength = ResultLength;
2258 }
2259 }
2260 _SEH2_EXCEPT(ExSystemExceptionFilter())
2261 {
2262 FStatus = _SEH2_GetExceptionCode();
2263 }
2264 _SEH2_END;
2265
2266 return FStatus;
2267 }
2268
2269
2270 NTSTATUS
2271 NTAPI
2272 NtSetSystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2273 IN PVOID SystemInformation,
2274 IN ULONG SystemInformationLength)
2275 {
2276 PAGED_CODE();
2277
2278 /*
2279 * If called from user mode, check
2280 * possible unsafe arguments.
2281 */
2282 #if 0
2283 if (KernelMode != KeGetPreviousMode())
2284 {
2285 // Check arguments
2286 //ProbeForWrite(
2287 // SystemInformation,
2288 // Length
2289 // );
2290 //ProbeForWrite(
2291 // ResultLength,
2292 // sizeof (ULONG)
2293 // );
2294 }
2295 #endif
2296 /*
2297 * Check the request is valid.
2298 */
2299 if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
2300 (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
2301 {
2302 if (NULL != CallQS [SystemInformationClass].Set)
2303 {
2304 /*
2305 * Hand the request to a subhandler.
2306 */
2307 return CallQS [SystemInformationClass].Set(SystemInformation,
2308 SystemInformationLength);
2309 }
2310 }
2311
2312 return STATUS_INVALID_INFO_CLASS;
2313 }
2314
2315 NTSTATUS
2316 NTAPI
2317 NtFlushInstructionCache(IN HANDLE ProcessHandle,
2318 IN PVOID BaseAddress,
2319 IN ULONG NumberOfBytesToFlush)
2320 {
2321 PAGED_CODE();
2322
2323 #if defined(_M_IX86) || defined(_M_AMD64)
2324 __wbinvd();
2325 #elif defined(_M_PPC)
2326 __asm__ __volatile__("tlbsync");
2327 #elif defined(_M_MIPS)
2328 DPRINT1("NtFlushInstructionCache() is not implemented\n");
2329 for (;;);
2330 #elif defined(_M_ARM)
2331 __asm__ __volatile__("mov r1, #0; mcr p15, 0, r1, c7, c5, 0");
2332 #else
2333 #error Unknown architecture
2334 #endif
2335 return STATUS_SUCCESS;
2336 }
2337
2338 ULONG
2339 NTAPI
2340 NtGetCurrentProcessorNumber(VOID)
2341 {
2342 /* Just return the CPU */
2343 return KeGetCurrentProcessorNumber();
2344 }
2345
2346 /*
2347 * @implemented
2348 */
2349 #undef ExGetPreviousMode
2350 KPROCESSOR_MODE
2351 NTAPI
2352 ExGetPreviousMode (VOID)
2353 {
2354 return KeGetPreviousMode();
2355 }