4187fc2614a8ceacb3015b6c64c49ed83aaccf08
[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 length 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 TempProcessImageName;
779 _SEH2_VOLATILE PUNICODE_STRING ProcessImageName = NULL;
780 PWCHAR szSrc;
781 BOOLEAN Overflow = FALSE;
782
783 _SEH2_TRY
784 {
785 /* scan the process list */
786
787 PSYSTEM_PROCESS_INFORMATION Spi
788 = (PSYSTEM_PROCESS_INFORMATION) Buffer;
789
790 *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
791
792 /* Check for overflow */
793 if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
794 {
795 Overflow = TRUE;
796 }
797
798 /* Zero user's buffer */
799 if (!Overflow) RtlZeroMemory(Spi, Size);
800
801 SystemProcess = PsIdleProcess;
802 Process = SystemProcess;
803 Current = (PUCHAR) Spi;
804
805 do
806 {
807 SpiCurrent = (PSYSTEM_PROCESS_INFORMATION) Current;
808
809 if ((Process->ProcessExiting) &&
810 (Process->Pcb.Header.SignalState) &&
811 !(Process->ActiveThreads) &&
812 (IsListEmpty(&Process->Pcb.ThreadListHead)))
813 {
814 DPRINT1("Process %p (%s:%p) is a zombie\n",
815 Process, Process->ImageFileName, Process->UniqueProcessId);
816 CurrentSize = 0;
817 ImageNameMaximumLength = 0;
818 goto Skip;
819 }
820
821 ThreadsCount = 0;
822 CurrentEntry = Process->Pcb.ThreadListHead.Flink;
823 while (CurrentEntry != &Process->Pcb.ThreadListHead)
824 {
825 ThreadsCount++;
826 CurrentEntry = CurrentEntry->Flink;
827 }
828
829 // size of the structure for every process
830 CurrentSize = sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION) * ThreadsCount;
831 ImageNameLength = 0;
832 Status = SeLocateProcessImageName(Process, &TempProcessImageName);
833 ProcessImageName = TempProcessImageName;
834 szSrc = NULL;
835 if (NT_SUCCESS(Status) && (ProcessImageName->Length > 0))
836 {
837 szSrc = (PWCHAR)((PCHAR)ProcessImageName->Buffer + ProcessImageName->Length);
838 /* Loop the file name*/
839 while (szSrc > ProcessImageName->Buffer)
840 {
841 /* Make sure this isn't a backslash */
842 if (*--szSrc == OBJ_NAME_PATH_SEPARATOR)
843 {
844 szSrc++;
845 break;
846 }
847 else
848 {
849 ImageNameLength += sizeof(WCHAR);
850 }
851 }
852 }
853 if (!ImageNameLength && Process != PsIdleProcess)
854 {
855 ImageNameLength = (USHORT)strlen(Process->ImageFileName) * sizeof(WCHAR);
856 }
857
858 /* Round up the image name length as NT does */
859 if (ImageNameLength > 0)
860 ImageNameMaximumLength = ROUND_UP(ImageNameLength + sizeof(WCHAR), 8);
861 else
862 ImageNameMaximumLength = 0;
863
864 TotalSize += CurrentSize + ImageNameMaximumLength;
865
866 /* Check for overflow */
867 if (TotalSize > Size)
868 {
869 Overflow = TRUE;
870 }
871
872 /* Fill system information */
873 if (!Overflow)
874 {
875 SpiCurrent->NextEntryOffset = CurrentSize + ImageNameMaximumLength; // relative offset to the beginning of the next structure
876 SpiCurrent->NumberOfThreads = ThreadsCount;
877 SpiCurrent->CreateTime = Process->CreateTime;
878 SpiCurrent->ImageName.Length = ImageNameLength;
879 SpiCurrent->ImageName.MaximumLength = ImageNameMaximumLength;
880 SpiCurrent->ImageName.Buffer = (void*)(Current + CurrentSize);
881
882 /* Copy name to the end of the struct */
883 if(Process != PsIdleProcess)
884 {
885 if (szSrc)
886 {
887 RtlCopyMemory(SpiCurrent->ImageName.Buffer, szSrc, SpiCurrent->ImageName.Length);
888 }
889 else
890 {
891 RtlInitAnsiString(&ImageName, Process->ImageFileName);
892 RtlAnsiStringToUnicodeString(&SpiCurrent->ImageName, &ImageName, FALSE);
893 }
894 }
895 else
896 {
897 RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
898 }
899
900 SpiCurrent->BasePriority = Process->Pcb.BasePriority;
901 SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
902 SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
903 SpiCurrent->HandleCount = ObGetProcessHandleCount(Process);
904 SpiCurrent->PeakVirtualSize = Process->PeakVirtualSize;
905 SpiCurrent->VirtualSize = Process->VirtualSize;
906 SpiCurrent->PageFaultCount = Process->Vm.PageFaultCount;
907 SpiCurrent->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
908 SpiCurrent->WorkingSetSize = Process->Vm.WorkingSetSize;
909 SpiCurrent->QuotaPeakPagedPoolUsage = Process->QuotaPeak[0];
910 SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[0];
911 SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[1];
912 SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[1];
913 SpiCurrent->PagefileUsage = Process->QuotaUsage[2];
914 SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[2];
915 SpiCurrent->PrivatePageCount = Process->CommitCharge;
916 ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCurrent + 1);
917
918 CurrentEntry = Process->Pcb.ThreadListHead.Flink;
919 while (CurrentEntry != &Process->Pcb.ThreadListHead)
920 {
921 CurrentThread = CONTAINING_RECORD(CurrentEntry, ETHREAD, Tcb.ThreadListEntry);
922
923 ThreadInfo->KernelTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.KernelTime, KeMaximumIncrement);
924 ThreadInfo->UserTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.UserTime, KeMaximumIncrement);
925 ThreadInfo->CreateTime.QuadPart = CurrentThread->CreateTime.QuadPart;
926 ThreadInfo->WaitTime = CurrentThread->Tcb.WaitTime;
927 ThreadInfo->StartAddress = (PVOID) CurrentThread->StartAddress;
928 ThreadInfo->ClientId = CurrentThread->Cid;
929 ThreadInfo->Priority = CurrentThread->Tcb.Priority;
930 ThreadInfo->BasePriority = CurrentThread->Tcb.BasePriority;
931 ThreadInfo->ContextSwitches = CurrentThread->Tcb.ContextSwitches;
932 ThreadInfo->ThreadState = CurrentThread->Tcb.State;
933 ThreadInfo->WaitReason = CurrentThread->Tcb.WaitReason;
934
935 ThreadInfo++;
936 CurrentEntry = CurrentEntry->Flink;
937 }
938
939 /* Query total user/kernel times of a process */
940 TotalKernel = KeQueryRuntimeProcess(&Process->Pcb, &TotalUser);
941 SpiCurrent->UserTime.QuadPart = UInt32x32To64(TotalUser, KeMaximumIncrement);
942 SpiCurrent->KernelTime.QuadPart = UInt32x32To64(TotalKernel, KeMaximumIncrement);
943 }
944
945 if (ProcessImageName)
946 {
947 /* Release the memory allocated by SeLocateProcessImageName */
948 ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
949 ProcessImageName = NULL;
950 }
951
952 /* Handle idle process entry */
953 Skip:
954 if (Process == PsIdleProcess) Process = NULL;
955
956 Process = PsGetNextProcess(Process);
957 ThreadsCount = 0;
958 if ((Process == SystemProcess) || (Process == NULL))
959 {
960 if (!Overflow)
961 SpiCurrent->NextEntryOffset = 0;
962 break;
963 }
964 else
965 Current += CurrentSize + ImageNameMaximumLength;
966 } while ((Process != SystemProcess) && (Process != NULL));
967
968 if(Process != NULL)
969 ObDereferenceObject(Process);
970 Status = STATUS_SUCCESS;
971 }
972 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
973 {
974 if(Process != NULL)
975 ObDereferenceObject(Process);
976 if (ProcessImageName)
977 {
978 /* Release the memory allocated by SeLocateProcessImageName */
979 ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
980 }
981
982 Status = _SEH2_GetExceptionCode();
983 }
984 _SEH2_END
985
986 if (Overflow)
987 Status = STATUS_INFO_LENGTH_MISMATCH;
988
989 *ReqSize = TotalSize;
990 return Status;
991 }
992
993 /* Class 6 - Call Count Information */
994 QSI_DEF(SystemCallCountInformation)
995 {
996 /* FIXME */
997 DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
998 return STATUS_NOT_IMPLEMENTED;
999 }
1000
1001 /* Class 7 - Device Information */
1002 QSI_DEF(SystemDeviceInformation)
1003 {
1004 PSYSTEM_DEVICE_INFORMATION Sdi
1005 = (PSYSTEM_DEVICE_INFORMATION) Buffer;
1006 PCONFIGURATION_INFORMATION ConfigInfo;
1007
1008 *ReqSize = sizeof(SYSTEM_DEVICE_INFORMATION);
1009
1010 /* Check user buffer's size */
1011 if (Size < sizeof(SYSTEM_DEVICE_INFORMATION))
1012 {
1013 return STATUS_INFO_LENGTH_MISMATCH;
1014 }
1015
1016 ConfigInfo = IoGetConfigurationInformation();
1017
1018 Sdi->NumberOfDisks = ConfigInfo->DiskCount;
1019 Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
1020 Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
1021 Sdi->NumberOfTapes = ConfigInfo->TapeCount;
1022 Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
1023 Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
1024
1025 return STATUS_SUCCESS;
1026 }
1027
1028 /* Class 8 - Processor Performance Information */
1029 QSI_DEF(SystemProcessorPerformanceInformation)
1030 {
1031 PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
1032 = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
1033
1034 LONG i;
1035 ULONG TotalTime;
1036 PKPRCB Prcb;
1037
1038 *ReqSize = KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
1039
1040 /* Check user buffer's size */
1041 if (Size < *ReqSize)
1042 {
1043 return STATUS_INFO_LENGTH_MISMATCH;
1044 }
1045
1046 for (i = 0; i < KeNumberProcessors; i++)
1047 {
1048 /* Get the PRCB on this processor */
1049 Prcb = KiProcessorBlock[i];
1050
1051 /* Calculate total user and kernel times */
1052 TotalTime = Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime;
1053 Spi->IdleTime.QuadPart = UInt32x32To64(TotalTime, KeMaximumIncrement);
1054 Spi->KernelTime.QuadPart = UInt32x32To64(Prcb->KernelTime, KeMaximumIncrement);
1055 Spi->UserTime.QuadPart = UInt32x32To64(Prcb->UserTime, KeMaximumIncrement);
1056 Spi->DpcTime.QuadPart = UInt32x32To64(Prcb->DpcTime, KeMaximumIncrement);
1057 Spi->InterruptTime.QuadPart = UInt32x32To64(Prcb->InterruptTime, KeMaximumIncrement);
1058 Spi->InterruptCount = Prcb->InterruptCount;
1059 Spi++;
1060 }
1061
1062 return STATUS_SUCCESS;
1063 }
1064
1065 /* Class 9 - Flags Information */
1066 QSI_DEF(SystemFlagsInformation)
1067 {
1068 if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1069 {
1070 *ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
1071 return (STATUS_INFO_LENGTH_MISMATCH);
1072 }
1073 ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
1074 return STATUS_SUCCESS;
1075 }
1076
1077 SSI_DEF(SystemFlagsInformation)
1078 {
1079 if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
1080 {
1081 return STATUS_INFO_LENGTH_MISMATCH;
1082 }
1083
1084 if (!SeSinglePrivilegeCheck(SeDebugPrivilege, ExGetPreviousMode()))
1085 {
1086 return STATUS_ACCESS_DENIED;
1087 }
1088
1089 NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
1090 return STATUS_SUCCESS;
1091 }
1092
1093 /* Class 10 - Call Time Information */
1094 QSI_DEF(SystemCallTimeInformation)
1095 {
1096 /* FIXME */
1097 DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
1098 return STATUS_NOT_IMPLEMENTED;
1099 }
1100
1101 /* Class 11 - Module Information */
1102 QSI_DEF(SystemModuleInformation)
1103 {
1104 NTSTATUS Status;
1105
1106 /* Acquire system module list lock */
1107 KeEnterCriticalRegion();
1108 ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE);
1109
1110 /* Call the generic handler with the system module list */
1111 Status = ExpQueryModuleInformation(&PsLoadedModuleList,
1112 &MmLoadedUserImageList,
1113 (PRTL_PROCESS_MODULES)Buffer,
1114 Size,
1115 ReqSize);
1116
1117 /* Release list lock and return status */
1118 ExReleaseResourceLite(&PsLoadedModuleResource);
1119 KeLeaveCriticalRegion();
1120 return Status;
1121 }
1122
1123 /* Class 12 - Locks Information */
1124 QSI_DEF(SystemLocksInformation)
1125 {
1126 /* FIXME */
1127 DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
1128 return STATUS_NOT_IMPLEMENTED;
1129 }
1130
1131 /* Class 13 - Stack Trace Information */
1132 QSI_DEF(SystemStackTraceInformation)
1133 {
1134 /* FIXME */
1135 DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
1136 return STATUS_NOT_IMPLEMENTED;
1137 }
1138
1139 /* Class 14 - Paged Pool Information */
1140 QSI_DEF(SystemPagedPoolInformation)
1141 {
1142 /* FIXME */
1143 DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
1144 return STATUS_NOT_IMPLEMENTED;
1145 }
1146
1147 /* Class 15 - Non Paged Pool Information */
1148 QSI_DEF(SystemNonPagedPoolInformation)
1149 {
1150 /* FIXME */
1151 DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
1152 return STATUS_NOT_IMPLEMENTED;
1153 }
1154
1155
1156 /* Class 16 - Handle Information */
1157 QSI_DEF(SystemHandleInformation)
1158 {
1159 PEPROCESS pr, syspr;
1160 ULONG curSize, i = 0;
1161 ULONG hCount = 0;
1162
1163 PSYSTEM_HANDLE_INFORMATION Shi =
1164 (PSYSTEM_HANDLE_INFORMATION) Buffer;
1165
1166 DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1167
1168 if (Size < sizeof(SYSTEM_HANDLE_INFORMATION))
1169 {
1170 *ReqSize = sizeof(SYSTEM_HANDLE_INFORMATION);
1171 return STATUS_INFO_LENGTH_MISMATCH;
1172 }
1173
1174 DPRINT("SystemHandleInformation 1\n");
1175
1176 /* First Calc Size from Count. */
1177 syspr = PsGetNextProcess(NULL);
1178 pr = syspr;
1179
1180 do
1181 {
1182 hCount = hCount + ObGetProcessHandleCount(pr);
1183 pr = PsGetNextProcess(pr);
1184
1185 if ((pr == syspr) || (pr == NULL)) break;
1186 }
1187 while ((pr != syspr) && (pr != NULL));
1188
1189 if(pr != NULL)
1190 {
1191 ObDereferenceObject(pr);
1192 }
1193
1194 DPRINT("SystemHandleInformation 2\n");
1195
1196 curSize = sizeof(SYSTEM_HANDLE_INFORMATION) +
1197 ((sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) * hCount) -
1198 (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO)));
1199
1200 Shi->NumberOfHandles = hCount;
1201
1202 if (curSize > Size)
1203 {
1204 *ReqSize = curSize;
1205 return (STATUS_INFO_LENGTH_MISMATCH);
1206 }
1207
1208 DPRINT("SystemHandleInformation 3\n");
1209
1210 /* Now get Handles from all processes. */
1211 syspr = PsGetNextProcess(NULL);
1212 pr = syspr;
1213
1214 do
1215 {
1216 int Count = 0, HandleCount;
1217
1218 HandleCount = ObGetProcessHandleCount(pr);
1219
1220 for (Count = 0; HandleCount > 0 ; HandleCount--)
1221 {
1222 Shi->Handles[i].UniqueProcessId = (USHORT)(ULONG_PTR)pr->UniqueProcessId;
1223 Count++;
1224 i++;
1225 }
1226
1227 pr = PsGetNextProcess(pr);
1228
1229 if ((pr == syspr) || (pr == NULL)) break;
1230 }
1231 while ((pr != syspr) && (pr != NULL));
1232
1233 if(pr != NULL) ObDereferenceObject(pr);
1234
1235 DPRINT("SystemHandleInformation 4\n");
1236 return STATUS_SUCCESS;
1237
1238 }
1239 /*
1240 SSI_DEF(SystemHandleInformation)
1241 {
1242
1243 return STATUS_SUCCESS;
1244 }
1245 */
1246
1247 /* Class 17 - Information */
1248 QSI_DEF(SystemObjectInformation)
1249 {
1250 /* FIXME */
1251 DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1252 return STATUS_NOT_IMPLEMENTED;
1253 }
1254
1255 /* Class 18 - Information */
1256 QSI_DEF(SystemPageFileInformation)
1257 {
1258 UNICODE_STRING FileName; /* FIXME */
1259 SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
1260
1261 if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
1262 {
1263 * ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
1264 return STATUS_INFO_LENGTH_MISMATCH;
1265 }
1266
1267 RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1268
1269 /* FIXME */
1270 Spfi->NextEntryOffset = 0;
1271
1272 Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
1273 Spfi->TotalInUse = MiUsedSwapPages;
1274 Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1275 Spfi->PageFileName = FileName;
1276 return STATUS_SUCCESS;
1277 }
1278
1279 /* Class 19 - Vdm Instemul Information */
1280 QSI_DEF(SystemVdmInstemulInformation)
1281 {
1282 /* FIXME */
1283 DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1284 return STATUS_NOT_IMPLEMENTED;
1285 }
1286
1287 /* Class 20 - Vdm Bop Information */
1288 QSI_DEF(SystemVdmBopInformation)
1289 {
1290 /* FIXME */
1291 DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1292 return STATUS_NOT_IMPLEMENTED;
1293 }
1294
1295 /* Class 21 - File Cache Information */
1296 QSI_DEF(SystemFileCacheInformation)
1297 {
1298 SYSTEM_FILECACHE_INFORMATION *Sci = (SYSTEM_FILECACHE_INFORMATION *) Buffer;
1299
1300 *ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
1301
1302 if (Size < *ReqSize)
1303 {
1304 return STATUS_INFO_LENGTH_MISMATCH;
1305 }
1306
1307 RtlZeroMemory(Sci, sizeof(SYSTEM_FILECACHE_INFORMATION));
1308
1309 /* Return the Byte size not the page size. */
1310 Sci->CurrentSize =
1311 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
1312 Sci->PeakSize =
1313 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
1314 /* Taskmgr multiplies this one by page size right away */
1315 Sci->CurrentSizeIncludingTransitionInPages =
1316 MiMemoryConsumers[MC_CACHE].PagesUsed; /* FIXME: Should be */
1317 /* system working set and standby pages. */
1318 Sci->PageFaultCount = 0; /* FIXME */
1319 Sci->MinimumWorkingSet = 0; /* FIXME */
1320 Sci->MaximumWorkingSet = 0; /* FIXME */
1321
1322 return STATUS_SUCCESS;
1323 }
1324
1325 SSI_DEF(SystemFileCacheInformation)
1326 {
1327 if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1328 {
1329 return STATUS_INFO_LENGTH_MISMATCH;
1330 }
1331 /* FIXME */
1332 DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1333 return STATUS_NOT_IMPLEMENTED;
1334 }
1335
1336 /* Class 22 - Pool Tag Information */
1337 QSI_DEF(SystemPoolTagInformation)
1338 {
1339 if (Size < sizeof(SYSTEM_POOLTAG_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
1340 return ExGetPoolTagInfo(Buffer, Size, ReqSize);
1341 }
1342
1343 /* Class 23 - Interrupt Information for all processors */
1344 QSI_DEF(SystemInterruptInformation)
1345 {
1346 PKPRCB Prcb;
1347 LONG i;
1348 ULONG ti;
1349 PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1350
1351 if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1352 {
1353 return STATUS_INFO_LENGTH_MISMATCH;
1354 }
1355
1356 ti = KeQueryTimeIncrement();
1357
1358 for (i = 0; i < KeNumberProcessors; i++)
1359 {
1360 Prcb = KiProcessorBlock[i];
1361 sii->ContextSwitches = KeGetContextSwitches(Prcb);
1362 sii->DpcCount = Prcb->DpcData[0].DpcCount;
1363 sii->DpcRate = Prcb->DpcRequestRate;
1364 sii->TimeIncrement = ti;
1365 sii->DpcBypassCount = 0;
1366 sii->ApcBypassCount = 0;
1367 sii++;
1368 }
1369
1370 return STATUS_SUCCESS;
1371 }
1372
1373 /* Class 24 - DPC Behaviour Information */
1374 QSI_DEF(SystemDpcBehaviourInformation)
1375 {
1376 /* FIXME */
1377 DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1378 return STATUS_NOT_IMPLEMENTED;
1379 }
1380
1381 SSI_DEF(SystemDpcBehaviourInformation)
1382 {
1383 /* FIXME */
1384 DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1385 return STATUS_NOT_IMPLEMENTED;
1386 }
1387
1388 /* Class 25 - Full Memory Information */
1389 QSI_DEF(SystemFullMemoryInformation)
1390 {
1391 PULONG Spi = (PULONG) Buffer;
1392
1393 PEPROCESS TheIdleProcess;
1394
1395 *ReqSize = sizeof(ULONG);
1396
1397 if (sizeof(ULONG) != Size)
1398 {
1399 return STATUS_INFO_LENGTH_MISMATCH;
1400 }
1401
1402 DPRINT("SystemFullMemoryInformation\n");
1403
1404 TheIdleProcess = PsIdleProcess;
1405
1406 DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
1407 TheIdleProcess->UniqueProcessId,
1408 TheIdleProcess->Pcb.KernelTime,
1409 MiFreeSwapPages,
1410 MiUsedSwapPages);
1411
1412 *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1413
1414 return STATUS_SUCCESS;
1415 }
1416
1417 /* Class 26 - Load Image */
1418 SSI_DEF(SystemLoadGdiDriverInformation)
1419 {
1420 PSYSTEM_GDI_DRIVER_INFORMATION DriverInfo = (PVOID)Buffer;
1421 UNICODE_STRING ImageName;
1422 PVOID ImageBase;
1423 PVOID SectionPointer;
1424 ULONG_PTR EntryPoint;
1425 NTSTATUS Status;
1426 ULONG DirSize;
1427 PIMAGE_NT_HEADERS NtHeader;
1428
1429 /* Validate size */
1430 if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1431 {
1432 /* Incorrect buffer length, fail */
1433 return STATUS_INFO_LENGTH_MISMATCH;
1434 }
1435
1436 /* Only kernel mode can call this function */
1437 if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1438
1439 /* Load the driver */
1440 ImageName = DriverInfo->DriverName;
1441 Status = MmLoadSystemImage(&ImageName,
1442 NULL,
1443 NULL,
1444 0,
1445 &SectionPointer,
1446 &ImageBase);
1447 if (!NT_SUCCESS(Status)) return Status;
1448
1449 /* Return the export pointer */
1450 DriverInfo->ExportSectionPointer =
1451 RtlImageDirectoryEntryToData(ImageBase,
1452 TRUE,
1453 IMAGE_DIRECTORY_ENTRY_EXPORT,
1454 &DirSize);
1455
1456 /* Get the entrypoint */
1457 NtHeader = RtlImageNtHeader(ImageBase);
1458 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1459 EntryPoint += (ULONG_PTR)ImageBase;
1460
1461 /* Save other data */
1462 DriverInfo->ImageAddress = ImageBase;
1463 DriverInfo->SectionPointer = SectionPointer;
1464 DriverInfo->EntryPoint = (PVOID)EntryPoint;
1465 DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1466
1467 /* All is good */
1468 return STATUS_SUCCESS;
1469 }
1470
1471 /* Class 27 - Unload Image */
1472 SSI_DEF(SystemUnloadGdiDriverInformation)
1473 {
1474 PVOID *SectionPointer = Buffer;
1475
1476 /* Validate size */
1477 if (Size != sizeof(PVOID))
1478 {
1479 /* Incorrect length, fail */
1480 return STATUS_INFO_LENGTH_MISMATCH;
1481 }
1482
1483 /* Only kernel mode can call this function */
1484 if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1485
1486 /* Unload the image */
1487 MmUnloadSystemImage(*SectionPointer);
1488 return STATUS_SUCCESS;
1489 }
1490
1491 /* Class 28 - Time Adjustment Information */
1492 QSI_DEF(SystemTimeAdjustmentInformation)
1493 {
1494 PSYSTEM_QUERY_TIME_ADJUST_INFORMATION TimeInfo =
1495 (PSYSTEM_QUERY_TIME_ADJUST_INFORMATION)Buffer;
1496
1497 /* Check if enough storage was provided */
1498 if (sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION) > Size)
1499 {
1500 * ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
1501 return STATUS_INFO_LENGTH_MISMATCH;
1502 }
1503
1504 /* Give time values to our caller */
1505 TimeInfo->TimeIncrement = KeMaximumIncrement;
1506 TimeInfo->TimeAdjustment = KeTimeAdjustment;
1507 TimeInfo->Enable = !KiTimeAdjustmentEnabled;
1508
1509 return STATUS_SUCCESS;
1510 }
1511
1512 SSI_DEF(SystemTimeAdjustmentInformation)
1513 {
1514 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1515 PSYSTEM_SET_TIME_ADJUST_INFORMATION TimeInfo =
1516 (PSYSTEM_SET_TIME_ADJUST_INFORMATION)Buffer;
1517
1518 /* Check size of a buffer, it must match our expectations */
1519 if (sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION) != Size)
1520 return STATUS_INFO_LENGTH_MISMATCH;
1521
1522 /* Check who is calling */
1523 if (PreviousMode != KernelMode)
1524 {
1525 /* Check access rights */
1526 if (!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
1527 {
1528 return STATUS_PRIVILEGE_NOT_HELD;
1529 }
1530 }
1531
1532 /* FIXME: behaviour suggests the member be named 'Disable' */
1533 if (TimeInfo->Enable)
1534 {
1535 /* Disable time adjustment and set default value */
1536 KiTimeAdjustmentEnabled = FALSE;
1537 KeTimeAdjustment = KeMaximumIncrement;
1538 }
1539 else
1540 {
1541 /* Check if a valid time adjustment value is given */
1542 if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
1543
1544 /* Enable time adjustment and set the adjustment value */
1545 KiTimeAdjustmentEnabled = TRUE;
1546 KeTimeAdjustment = TimeInfo->TimeAdjustment;
1547 }
1548
1549 return STATUS_SUCCESS;
1550 }
1551
1552 /* Class 29 - Summary Memory Information */
1553 QSI_DEF(SystemSummaryMemoryInformation)
1554 {
1555 /* FIXME */
1556 DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1557 return STATUS_NOT_IMPLEMENTED;
1558 }
1559
1560 /* Class 30 - Next Event Id Information */
1561 QSI_DEF(SystemNextEventIdInformation)
1562 {
1563 /* FIXME */
1564 DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1565 return STATUS_NOT_IMPLEMENTED;
1566 }
1567
1568 /* Class 31 */
1569 QSI_DEF(SystemPerformanceTraceInformation)
1570 {
1571 /* FIXME */
1572 DPRINT1("NtQuerySystemInformation - SystemPerformanceTraceInformation not implemented\n");
1573 return STATUS_NOT_IMPLEMENTED;
1574 }
1575
1576 /* Class 32 - Crash Dump Information */
1577 QSI_DEF(SystemCrashDumpInformation)
1578 {
1579 /* FIXME */
1580 DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1581 return STATUS_NOT_IMPLEMENTED;
1582 }
1583
1584 /* Class 33 - Exception Information */
1585 QSI_DEF(SystemExceptionInformation)
1586 {
1587 PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
1588 (PSYSTEM_EXCEPTION_INFORMATION)Buffer;
1589 PKPRCB Prcb;
1590 ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
1591 ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
1592 CHAR i;
1593
1594 /* Check size of a buffer, it must match our expectations */
1595 if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
1596 return STATUS_INFO_LENGTH_MISMATCH;
1597
1598 /* Sum up exception count information from all processors */
1599 for (i = 0; i < KeNumberProcessors; i++)
1600 {
1601 Prcb = KiProcessorBlock[i];
1602 if (Prcb)
1603 {
1604 AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
1605 ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
1606 #ifndef _M_ARM
1607 FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
1608 #endif // _M_ARM
1609 }
1610 }
1611
1612 /* Save information in user's buffer */
1613 ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
1614 ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
1615 ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
1616 ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
1617
1618 return STATUS_SUCCESS;
1619 }
1620
1621 /* Class 34 - Crash Dump State Information */
1622 QSI_DEF(SystemCrashDumpStateInformation)
1623 {
1624 /* FIXME */
1625 DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1626 return STATUS_NOT_IMPLEMENTED;
1627 }
1628
1629 /* Class 35 - Kernel Debugger Information */
1630 QSI_DEF(SystemKernelDebuggerInformation)
1631 {
1632 PSYSTEM_KERNEL_DEBUGGER_INFORMATION skdi = (PSYSTEM_KERNEL_DEBUGGER_INFORMATION) Buffer;
1633
1634 *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1635 if (Size < sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION))
1636 {
1637 return STATUS_INFO_LENGTH_MISMATCH;
1638 }
1639
1640 skdi->KernelDebuggerEnabled = KD_DEBUGGER_ENABLED;
1641 skdi->KernelDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
1642
1643 return STATUS_SUCCESS;
1644 }
1645
1646 /* Class 36 - Context Switch Information */
1647 QSI_DEF(SystemContextSwitchInformation)
1648 {
1649 PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
1650 (PSYSTEM_CONTEXT_SWITCH_INFORMATION)Buffer;
1651 ULONG ContextSwitches;
1652 PKPRCB Prcb;
1653 CHAR i;
1654
1655 /* Check size of a buffer, it must match our expectations */
1656 if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
1657 return STATUS_INFO_LENGTH_MISMATCH;
1658
1659 /* Calculate total value of context switches across all processors */
1660 ContextSwitches = 0;
1661 for (i = 0; i < KeNumberProcessors; i ++)
1662 {
1663 Prcb = KiProcessorBlock[i];
1664 if (Prcb)
1665 {
1666 ContextSwitches += KeGetContextSwitches(Prcb);
1667 }
1668 }
1669
1670 ContextSwitchInformation->ContextSwitches = ContextSwitches;
1671
1672 /* FIXME */
1673 ContextSwitchInformation->FindAny = 0;
1674 ContextSwitchInformation->FindLast = 0;
1675 ContextSwitchInformation->FindIdeal = 0;
1676 ContextSwitchInformation->IdleAny = 0;
1677 ContextSwitchInformation->IdleCurrent = 0;
1678 ContextSwitchInformation->IdleLast = 0;
1679 ContextSwitchInformation->IdleIdeal = 0;
1680 ContextSwitchInformation->PreemptAny = 0;
1681 ContextSwitchInformation->PreemptCurrent = 0;
1682 ContextSwitchInformation->PreemptLast = 0;
1683 ContextSwitchInformation->SwitchToIdle = 0;
1684
1685 return STATUS_SUCCESS;
1686 }
1687
1688 /* Class 37 - Registry Quota Information */
1689 QSI_DEF(SystemRegistryQuotaInformation)
1690 {
1691 PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1692
1693 *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1694 if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1695 {
1696 return STATUS_INFO_LENGTH_MISMATCH;
1697 }
1698
1699 DPRINT1("Faking max registry size of 32 MB\n");
1700 srqi->RegistryQuotaAllowed = 0x2000000;
1701 srqi->RegistryQuotaUsed = 0x200000;
1702 srqi->PagedPoolSize = 0x200000;
1703
1704 return STATUS_SUCCESS;
1705 }
1706
1707 SSI_DEF(SystemRegistryQuotaInformation)
1708 {
1709 /* FIXME */
1710 DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1711 return STATUS_NOT_IMPLEMENTED;
1712 }
1713
1714 /* Class 38 - Load And Call Image */
1715 SSI_DEF(SystemExtendServiceTableInformation)
1716 {
1717 UNICODE_STRING ImageName;
1718 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1719 PLDR_DATA_TABLE_ENTRY ModuleObject;
1720 NTSTATUS Status;
1721 PIMAGE_NT_HEADERS NtHeader;
1722 DRIVER_OBJECT Win32k;
1723 PDRIVER_INITIALIZE DriverInit;
1724 PVOID ImageBase;
1725 ULONG_PTR EntryPoint;
1726
1727 /* Validate the size */
1728 if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1729
1730 /* Check who is calling */
1731 if (PreviousMode != KernelMode)
1732 {
1733 static const UNICODE_STRING Win32kName =
1734 RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
1735
1736 /* Make sure we can load drivers */
1737 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, UserMode))
1738 {
1739 /* FIXME: We can't, fail */
1740 return STATUS_PRIVILEGE_NOT_HELD;
1741 }
1742
1743 _SEH2_TRY
1744 {
1745 /* Probe and copy the unicode string */
1746 ProbeForRead(Buffer, sizeof(ImageName), 1);
1747 ImageName = *(PUNICODE_STRING)Buffer;
1748
1749 /* Probe the string buffer */
1750 ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
1751
1752 /* Check if we have the correct name (nothing else is allowed!) */
1753 if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
1754 {
1755 _SEH2_YIELD(return STATUS_PRIVILEGE_NOT_HELD);
1756 }
1757 }
1758 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1759 {
1760 _SEH2_YIELD(return _SEH2_GetExceptionCode());
1761 }
1762 _SEH2_END;
1763
1764 /* Recursively call the function, so that we are from kernel mode */
1765 return ZwSetSystemInformation(SystemExtendServiceTableInformation,
1766 (PVOID)&Win32kName,
1767 sizeof(Win32kName));
1768 }
1769
1770 /* Load the image */
1771 Status = MmLoadSystemImage((PUNICODE_STRING)Buffer,
1772 NULL,
1773 NULL,
1774 0,
1775 (PVOID)&ModuleObject,
1776 &ImageBase);
1777
1778 if (!NT_SUCCESS(Status)) return Status;
1779
1780 /* Get the headers */
1781 NtHeader = RtlImageNtHeader(ImageBase);
1782 if (!NtHeader)
1783 {
1784 /* Fail */
1785 MmUnloadSystemImage(ModuleObject);
1786 return STATUS_INVALID_IMAGE_FORMAT;
1787 }
1788
1789 /* Get the entrypoint */
1790 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1791 EntryPoint += (ULONG_PTR)ImageBase;
1792 DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1793
1794 /* Create a dummy device */
1795 RtlZeroMemory(&Win32k, sizeof(Win32k));
1796 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1797 Win32k.DriverStart = ImageBase;
1798
1799 /* Call it */
1800 Status = (DriverInit)(&Win32k, NULL);
1801 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1802
1803 /* Unload if we failed */
1804 if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
1805 return Status;
1806 }
1807
1808 /* Class 39 - Priority Separation */
1809 SSI_DEF(SystemPrioritySeperation)
1810 {
1811 /* Check if the size is correct */
1812 if (Size != sizeof(ULONG))
1813 {
1814 return STATUS_INFO_LENGTH_MISMATCH;
1815 }
1816
1817 /* We need the TCB privilege */
1818 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, ExGetPreviousMode()))
1819 {
1820 return STATUS_PRIVILEGE_NOT_HELD;
1821 }
1822
1823 /* Modify the quantum table */
1824 PsChangeQuantumTable(TRUE, *(PULONG)Buffer);
1825
1826 return STATUS_SUCCESS;
1827 }
1828
1829 /* Class 40 */
1830 QSI_DEF(SystemVerifierAddDriverInformation)
1831 {
1832 /* FIXME */
1833 DPRINT1("NtQuerySystemInformation - SystemVerifierAddDriverInformation not implemented\n");
1834 return STATUS_NOT_IMPLEMENTED;
1835 }
1836
1837 /* Class 41 */
1838 QSI_DEF(SystemVerifierRemoveDriverInformation)
1839 {
1840 /* FIXME */
1841 DPRINT1("NtQuerySystemInformation - SystemVerifierRemoveDriverInformation not implemented\n");
1842 return STATUS_NOT_IMPLEMENTED;
1843 }
1844
1845 /* Class 42 - Power Information */
1846 QSI_DEF(SystemProcessorIdleInformation)
1847 {
1848 *ReqSize = sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors;
1849
1850 if (sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors > Size)
1851 {
1852 return STATUS_INFO_LENGTH_MISMATCH;
1853 }
1854
1855 /* FIXME */
1856 DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
1857 return STATUS_NOT_IMPLEMENTED;
1858 }
1859
1860 /* Class 43 */
1861 QSI_DEF(SystemLegacyDriverInformation)
1862 {
1863 /* FIXME */
1864 DPRINT1("NtQuerySystemInformation - SystemLegacyDriverInformation not implemented\n");
1865 return STATUS_NOT_IMPLEMENTED;
1866 }
1867
1868 /* Class 44 - Current Time Zone Information */
1869 QSI_DEF(SystemCurrentTimeZoneInformation)
1870 {
1871 *ReqSize = sizeof(TIME_ZONE_INFORMATION);
1872
1873 if (sizeof(TIME_ZONE_INFORMATION) != Size)
1874 {
1875 return STATUS_INFO_LENGTH_MISMATCH;
1876 }
1877
1878 /* Copy the time zone information struct */
1879 memcpy(Buffer,
1880 &ExpTimeZoneInfo,
1881 sizeof(TIME_ZONE_INFORMATION));
1882
1883 return STATUS_SUCCESS;
1884 }
1885
1886
1887 SSI_DEF(SystemCurrentTimeZoneInformation)
1888 {
1889 /* Check user buffer's size */
1890 if (Size < sizeof(TIME_ZONE_INFORMATION))
1891 {
1892 return STATUS_INFO_LENGTH_MISMATCH;
1893 }
1894
1895 return ExpSetTimeZoneInformation((PTIME_ZONE_INFORMATION)Buffer);
1896 }
1897
1898 static
1899 VOID
1900 ExpCopyLookasideInformation(
1901 PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
1902 PULONG RemainingPointer,
1903 PLIST_ENTRY ListHead,
1904 BOOLEAN ListUsesMisses)
1905
1906 {
1907 PSYSTEM_LOOKASIDE_INFORMATION Info;
1908 PGENERAL_LOOKASIDE LookasideList;
1909 PLIST_ENTRY ListEntry;
1910 ULONG Remaining;
1911
1912 /* Get info pointer and remaining count of free array element */
1913 Info = *InfoPointer;
1914 Remaining = *RemainingPointer;
1915
1916 /* Loop as long as we have lookaside lists and free array elements */
1917 for (ListEntry = ListHead->Flink;
1918 (ListEntry != ListHead) && (Remaining > 0);
1919 ListEntry = ListEntry->Flink, Remaining--)
1920 {
1921 LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
1922
1923 /* Fill the next array element */
1924 Info->CurrentDepth = LookasideList->Depth;
1925 Info->MaximumDepth = LookasideList->MaximumDepth;
1926 Info->TotalAllocates = LookasideList->TotalAllocates;
1927 Info->TotalFrees = LookasideList->TotalFrees;
1928 Info->Type = LookasideList->Type;
1929 Info->Tag = LookasideList->Tag;
1930 Info->Size = LookasideList->Size;
1931
1932 /* Check how the lists track misses/hits */
1933 if (ListUsesMisses)
1934 {
1935 /* Copy misses */
1936 Info->AllocateMisses = LookasideList->AllocateMisses;
1937 Info->FreeMisses = LookasideList->FreeMisses;
1938 }
1939 else
1940 {
1941 /* Calculate misses */
1942 Info->AllocateMisses = LookasideList->TotalAllocates
1943 - LookasideList->AllocateHits;
1944 Info->FreeMisses = LookasideList->TotalFrees
1945 - LookasideList->FreeHits;
1946 }
1947 }
1948
1949 /* Return the updated pointer and remaining count */
1950 *InfoPointer = Info;
1951 *RemainingPointer = Remaining;
1952 }
1953
1954 /* Class 45 - Lookaside Information */
1955 QSI_DEF(SystemLookasideInformation)
1956 {
1957 KPROCESSOR_MODE PreviousMode;
1958 PSYSTEM_LOOKASIDE_INFORMATION Info;
1959 PMDL Mdl;
1960 ULONG MaxCount, Remaining;
1961 KIRQL OldIrql;
1962 NTSTATUS Status;
1963
1964 /* First we need to lock down the memory, since we are going to access it
1965 at high IRQL */
1966 PreviousMode = ExGetPreviousMode();
1967 Status = ExLockUserBuffer(Buffer,
1968 Size,
1969 PreviousMode,
1970 IoWriteAccess,
1971 (PVOID*)&Info,
1972 &Mdl);
1973 if (!NT_SUCCESS(Status))
1974 {
1975 DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
1976 return Status;
1977 }
1978
1979 /* Calculate how many items we can store */
1980 Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
1981 if (Remaining == 0)
1982 {
1983 goto Leave;
1984 }
1985
1986 /* Copy info from pool lookaside lists */
1987 ExpCopyLookasideInformation(&Info,
1988 &Remaining,
1989 &ExPoolLookasideListHead,
1990 FALSE);
1991 if (Remaining == 0)
1992 {
1993 goto Leave;
1994 }
1995
1996 /* Copy info from system lookaside lists */
1997 ExpCopyLookasideInformation(&Info,
1998 &Remaining,
1999 &ExSystemLookasideListHead,
2000 TRUE);
2001 if (Remaining == 0)
2002 {
2003 goto Leave;
2004 }
2005
2006 /* Acquire spinlock for ExpNonPagedLookasideListHead */
2007 KeAcquireSpinLock(&ExpNonPagedLookasideListLock, &OldIrql);
2008
2009 /* Copy info from non-paged lookaside lists */
2010 ExpCopyLookasideInformation(&Info,
2011 &Remaining,
2012 &ExpNonPagedLookasideListHead,
2013 TRUE);
2014
2015 /* Release spinlock for ExpNonPagedLookasideListHead */
2016 KeReleaseSpinLock(&ExpNonPagedLookasideListLock, OldIrql);
2017
2018 if (Remaining == 0)
2019 {
2020 goto Leave;
2021 }
2022
2023 /* Acquire spinlock for ExpPagedLookasideListHead */
2024 KeAcquireSpinLock(&ExpPagedLookasideListLock, &OldIrql);
2025
2026 /* Copy info from paged lookaside lists */
2027 ExpCopyLookasideInformation(&Info,
2028 &Remaining,
2029 &ExpPagedLookasideListHead,
2030 TRUE);
2031
2032 /* Release spinlock for ExpPagedLookasideListHead */
2033 KeReleaseSpinLock(&ExpPagedLookasideListLock, OldIrql);
2034
2035 Leave:
2036
2037 /* Release the locked user buffer */
2038 ExUnlockUserBuffer(Mdl);
2039
2040 /* Return the size of the actually written data */
2041 *ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2042 return STATUS_SUCCESS;
2043 }
2044
2045
2046 /* Class 46 - Set time slip event */
2047 SSI_DEF(SystemTimeSlipNotification)
2048 {
2049 /* FIXME */
2050 DPRINT1("NtSetSystemInformation - SystemTimeSlipNotification not implemented\n");
2051 return STATUS_NOT_IMPLEMENTED;
2052 }
2053
2054 NTSTATUS
2055 NTAPI
2056 MmSessionCreate(OUT PULONG SessionId);
2057
2058 NTSTATUS
2059 NTAPI
2060 MmSessionDelete(IN ULONG SessionId);
2061
2062 /* Class 47 - Create a new session (TSE) */
2063 SSI_DEF(SystemSessionCreate)
2064 {
2065 ULONG SessionId;
2066 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2067 NTSTATUS Status;
2068
2069 if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2070
2071 if (PreviousMode != KernelMode)
2072 {
2073 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2074 {
2075 return STATUS_PRIVILEGE_NOT_HELD;
2076 }
2077
2078 ProbeForWriteUlong(Buffer);
2079 }
2080
2081 Status = MmSessionCreate(&SessionId);
2082 if (NT_SUCCESS(Status)) *(PULONG)Buffer = SessionId;
2083
2084 return Status;
2085 }
2086
2087
2088 /* Class 48 - Delete an existing session (TSE) */
2089 SSI_DEF(SystemSessionDetach)
2090 {
2091 ULONG SessionId;
2092 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2093
2094 if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2095
2096 if (PreviousMode != KernelMode)
2097 {
2098 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2099 {
2100 return STATUS_PRIVILEGE_NOT_HELD;
2101 }
2102 }
2103
2104 SessionId = *(PULONG)Buffer;
2105
2106 return MmSessionDelete(SessionId);
2107 }
2108
2109
2110 /* Class 49 - UNKNOWN */
2111 QSI_DEF(SystemSessionInformation)
2112 {
2113 /* FIXME */
2114 DPRINT1("NtQuerySystemInformation - SystemSessionInformation not implemented\n");
2115 return STATUS_NOT_IMPLEMENTED;
2116 }
2117
2118
2119 /* Class 50 - System range start address */
2120 QSI_DEF(SystemRangeStartInformation)
2121 {
2122 /* Check user buffer's size */
2123 if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
2124
2125 *(PULONG_PTR)Buffer = (ULONG_PTR)MmSystemRangeStart;
2126
2127 if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
2128
2129 return STATUS_SUCCESS;
2130 }
2131
2132 /* Class 51 - Driver verifier information */
2133 QSI_DEF(SystemVerifierInformation)
2134 {
2135 /* FIXME */
2136 DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
2137 return STATUS_NOT_IMPLEMENTED;
2138 }
2139
2140
2141 SSI_DEF(SystemVerifierInformation)
2142 {
2143 /* FIXME */
2144 DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
2145 return STATUS_NOT_IMPLEMENTED;
2146 }
2147
2148
2149 /* Class 52 */
2150 SSI_DEF(SystemVerifierThunkExtend)
2151 {
2152 /* FIXME */
2153 DPRINT1("NtSetSystemInformation - SystemVerifierThunkExtend not implemented\n");
2154 return STATUS_NOT_IMPLEMENTED;
2155 }
2156
2157
2158 /* Class 53 - A session's processes */
2159 QSI_DEF(SystemSessionProcessesInformation)
2160 {
2161 /* FIXME */
2162 DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
2163 return STATUS_NOT_IMPLEMENTED;
2164 }
2165
2166
2167 /* Class 54 - Load & map in system space */
2168 SSI_DEF(SystemLoadGdiDriverInSystemSpaceInformation)
2169 {
2170 /* FIXME */
2171 DPRINT1("NtSetSystemInformation - SystemLoadGdiDriverInSystemSpaceInformation not implemented\n");
2172 return STATUS_NOT_IMPLEMENTED;
2173 }
2174
2175
2176 /* Class 55 - NUMA processor information */
2177 QSI_DEF(SystemNumaProcessorMap)
2178 {
2179 ULONG MaxEntries, Node;
2180 PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
2181
2182 /* Validate input size */
2183 if (Size < sizeof(ULONG))
2184 {
2185 return STATUS_INFO_LENGTH_MISMATCH;
2186 }
2187
2188 /* Return highest node */
2189 NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2190
2191 /* Compute how much entries we will be able to put in output structure */
2192 MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask)) / sizeof(ULONGLONG);
2193 /* Make sure we don't overflow KeNodeBlock */
2194 if (MaxEntries > KeNumberNodes)
2195 {
2196 MaxEntries = KeNumberNodes;
2197 }
2198
2199 /* If we have entries to write, and room for it */
2200 if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) &&
2201 MaxEntries != 0)
2202 {
2203 /* Already set size we return */
2204 *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) +
2205 MaxEntries * sizeof(ULONGLONG);
2206
2207 /* For each node, return processor mask */
2208 for (Node = 0; Node < MaxEntries; ++Node)
2209 {
2210 NumaInformation->ActiveProcessorsAffinityMask[Node] = KeNodeBlock[Node]->ProcessorMask;
2211 }
2212 }
2213 else
2214 {
2215 /* We only returned highest node number */
2216 *ReqSize = sizeof(ULONG);
2217 }
2218
2219 return STATUS_SUCCESS;
2220 }
2221
2222
2223 /* Class 56 - Prefetcher information */
2224 QSI_DEF(SystemPrefetcherInformation)
2225 {
2226 /* FIXME */
2227 DPRINT1("NtQuerySystemInformation - SystemPrefetcherInformation not implemented\n");
2228 return STATUS_NOT_IMPLEMENTED;
2229 }
2230
2231
2232 /* Class 57 - Extended process information */
2233 QSI_DEF(SystemExtendedProcessInformation)
2234 {
2235 /* FIXME */
2236 DPRINT1("NtQuerySystemInformation - SystemExtendedProcessInformation not implemented\n");
2237 return STATUS_NOT_IMPLEMENTED;
2238 }
2239
2240
2241 /* Class 58 - Recommended shared ata alignment */
2242 QSI_DEF(SystemRecommendedSharedDataAlignment)
2243 {
2244 /* FIXME */
2245 DPRINT1("NtQuerySystemInformation - SystemRecommendedSharedDataAlignment not implemented\n");
2246 return STATUS_NOT_IMPLEMENTED;
2247 }
2248
2249
2250 /* Class 60 - NUMA memory information */
2251 QSI_DEF(SystemNumaAvailableMemory)
2252 {
2253 ULONG MaxEntries, Node;
2254 PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
2255
2256 /* Validate input size */
2257 if (Size < sizeof(ULONG))
2258 {
2259 return STATUS_INFO_LENGTH_MISMATCH;
2260 }
2261
2262 /* Return highest node */
2263 NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2264
2265 /* Compute how much entries we will be able to put in output structure */
2266 MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory)) / sizeof(ULONGLONG);
2267 /* Make sure we don't overflow KeNodeBlock */
2268 if (MaxEntries > KeNumberNodes)
2269 {
2270 MaxEntries = KeNumberNodes;
2271 }
2272
2273 /* If we have entries to write, and room for it */
2274 if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) &&
2275 MaxEntries != 0)
2276 {
2277 /* Already set size we return */
2278 *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) +
2279 MaxEntries * sizeof(ULONGLONG);
2280
2281 /* If we have a single entry (us), directly return MM information */
2282 if (MaxEntries == 1)
2283 {
2284 NumaInformation->AvailableMemory[0] = MmAvailablePages << PAGE_SHIFT;
2285 }
2286 else
2287 {
2288 /* Otherwise, for each node, return available bytes */
2289 for (Node = 0; Node < MaxEntries; ++Node)
2290 {
2291 NumaInformation->AvailableMemory[Node] = (KeNodeBlock[Node]->FreeCount[0] + KeNodeBlock[Node]->FreeCount[1]) << PAGE_SHIFT;
2292 }
2293 }
2294 }
2295 else
2296 {
2297 /* We only returned highest node number */
2298 *ReqSize = sizeof(ULONG);
2299 }
2300
2301 return STATUS_SUCCESS;
2302 }
2303
2304
2305 /* Query/Set Calls Table */
2306 typedef
2307 struct _QSSI_CALLS
2308 {
2309 NTSTATUS (* Query) (PVOID,ULONG,PULONG);
2310 NTSTATUS (* Set) (PVOID,ULONG);
2311 ULONG Alignment;
2312 } QSSI_CALLS;
2313
2314 // QS Query & Set
2315 // QX Query
2316 // XS Set
2317 // XX unknown behaviour
2318 //
2319 #define SI_QS(n) {QSI_USE(n),SSI_USE(n),TYPE_ALIGNMENT(ULONG)}
2320 #define SI_QX(n) {QSI_USE(n),NULL,TYPE_ALIGNMENT(ULONG)}
2321 #define SI_XS(n) {NULL,SSI_USE(n),TYPE_ALIGNMENT(ULONG)}
2322 #define SI_QS_ALIGN(n,a) {QSI_USE(n),SSI_USE(n),a}
2323 #define SI_QX_ALIGN(n,a) {QSI_USE(n),NULL,a}
2324 #define SI_XS_ALIGN(n,a) {NULL,SSI_USE(n),a}
2325 #define SI_XX(n) {NULL,NULL}
2326
2327 static
2328 QSSI_CALLS
2329 CallQS [] =
2330 {
2331 SI_QX(SystemBasicInformation),
2332 SI_QX(SystemProcessorInformation),
2333 SI_QX(SystemPerformanceInformation),
2334 SI_QX(SystemTimeOfDayInformation),
2335 SI_QX(SystemPathInformation), /* should be SI_XX */
2336 SI_QX(SystemProcessInformation),
2337 SI_QX(SystemCallCountInformation),
2338 SI_QX(SystemDeviceInformation),
2339 SI_QX(SystemProcessorPerformanceInformation),
2340 SI_QS(SystemFlagsInformation),
2341 SI_QX(SystemCallTimeInformation), /* should be SI_XX */
2342 SI_QX(SystemModuleInformation),
2343 SI_QX(SystemLocksInformation),
2344 SI_QX(SystemStackTraceInformation), /* should be SI_XX */
2345 SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
2346 SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
2347 SI_QX(SystemHandleInformation),
2348 SI_QX(SystemObjectInformation),
2349 SI_QX(SystemPageFileInformation),
2350 SI_QX(SystemVdmInstemulInformation),
2351 SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
2352 SI_QS(SystemFileCacheInformation),
2353 SI_QX(SystemPoolTagInformation),
2354 SI_QX(SystemInterruptInformation),
2355 SI_QS(SystemDpcBehaviourInformation),
2356 SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
2357 SI_XS(SystemLoadGdiDriverInformation),
2358 SI_XS(SystemUnloadGdiDriverInformation),
2359 SI_QS(SystemTimeAdjustmentInformation),
2360 SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
2361 SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
2362 SI_QX(SystemPerformanceTraceInformation), /* it should be SI_XX */
2363 SI_QX(SystemCrashDumpInformation),
2364 SI_QX(SystemExceptionInformation),
2365 SI_QX(SystemCrashDumpStateInformation),
2366 SI_QX_ALIGN(SystemKernelDebuggerInformation, TYPE_ALIGNMENT(BOOLEAN)),
2367 SI_QX(SystemContextSwitchInformation),
2368 SI_QS(SystemRegistryQuotaInformation),
2369 SI_XS(SystemExtendServiceTableInformation),
2370 SI_XS(SystemPrioritySeperation),
2371 SI_QX(SystemVerifierAddDriverInformation), /* it should be SI_XX */
2372 SI_QX(SystemVerifierRemoveDriverInformation), /* it should be SI_XX */
2373 SI_QX(SystemProcessorIdleInformation), /* it should be SI_XX */
2374 SI_QX(SystemLegacyDriverInformation), /* it should be SI_XX */
2375 SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
2376 SI_QX(SystemLookasideInformation),
2377 SI_XS(SystemTimeSlipNotification),
2378 SI_XS(SystemSessionCreate),
2379 SI_XS(SystemSessionDetach),
2380 SI_QX(SystemSessionInformation), /* it should be SI_XX */
2381 SI_QX(SystemRangeStartInformation),
2382 SI_QS(SystemVerifierInformation),
2383 SI_XS(SystemVerifierThunkExtend),
2384 SI_QX(SystemSessionProcessesInformation),
2385 SI_XS(SystemLoadGdiDriverInSystemSpaceInformation),
2386 SI_QX(SystemNumaProcessorMap),
2387 SI_QX(SystemPrefetcherInformation),
2388 SI_QX(SystemExtendedProcessInformation),
2389 SI_QX(SystemRecommendedSharedDataAlignment),
2390 SI_XX(SystemComPlusPackage),
2391 SI_QX(SystemNumaAvailableMemory)
2392 };
2393
2394 C_ASSERT(SystemBasicInformation == 0);
2395 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
2396 #define MAX_SYSTEM_INFO_CLASS (sizeof(CallQS) / sizeof(CallQS[0]))
2397
2398 /*
2399 * @implemented
2400 */
2401 NTSTATUS NTAPI
2402 NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2403 OUT PVOID SystemInformation,
2404 IN ULONG Length,
2405 OUT PULONG UnsafeResultLength)
2406 {
2407 KPROCESSOR_MODE PreviousMode;
2408 ULONG ResultLength = 0;
2409 NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;
2410
2411 PAGED_CODE();
2412
2413 PreviousMode = ExGetPreviousMode();
2414
2415 _SEH2_TRY
2416 {
2417 /*
2418 * Check if the request is valid.
2419 */
2420 if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2421 {
2422 _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
2423 }
2424
2425 if (PreviousMode != KernelMode)
2426 {
2427 /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
2428 ProbeForWrite(SystemInformation, Length, CallQS[SystemInformationClass].Alignment);
2429 if (UnsafeResultLength != NULL)
2430 ProbeForWriteUlong(UnsafeResultLength);
2431 }
2432
2433 if (UnsafeResultLength)
2434 *UnsafeResultLength = 0;
2435
2436 if (NULL != CallQS [SystemInformationClass].Query)
2437 {
2438 /*
2439 * Hand the request to a subhandler.
2440 */
2441 FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
2442 Length,
2443 &ResultLength);
2444
2445 /* Save the result length to the caller */
2446 if (UnsafeResultLength)
2447 *UnsafeResultLength = ResultLength;
2448 }
2449 }
2450 _SEH2_EXCEPT(ExSystemExceptionFilter())
2451 {
2452 FStatus = _SEH2_GetExceptionCode();
2453 }
2454 _SEH2_END;
2455
2456 return FStatus;
2457 }
2458
2459
2460 NTSTATUS
2461 NTAPI
2462 NtSetSystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2463 IN PVOID SystemInformation,
2464 IN ULONG SystemInformationLength)
2465 {
2466 NTSTATUS Status = STATUS_INVALID_INFO_CLASS;
2467 KPROCESSOR_MODE PreviousMode;
2468
2469 PAGED_CODE();
2470
2471 PreviousMode = ExGetPreviousMode();
2472
2473 _SEH2_TRY
2474 {
2475 /*
2476 * If called from user mode, check
2477 * possible unsafe arguments.
2478 */
2479 if (PreviousMode != KernelMode)
2480 {
2481 ProbeForRead(SystemInformation, SystemInformationLength, sizeof(ULONG));
2482 }
2483
2484 /*
2485 * Check the request is valid.
2486 */
2487 if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
2488 (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
2489 {
2490 if (NULL != CallQS [SystemInformationClass].Set)
2491 {
2492 /*
2493 * Hand the request to a subhandler.
2494 */
2495 Status = CallQS [SystemInformationClass].Set(SystemInformation,
2496 SystemInformationLength);
2497 }
2498 }
2499 }
2500 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2501 {
2502 Status = _SEH2_GetExceptionCode();
2503 }
2504 _SEH2_END;
2505
2506 return Status;
2507 }
2508
2509 NTSTATUS
2510 NTAPI
2511 NtFlushInstructionCache(
2512 _In_ HANDLE ProcessHandle,
2513 _In_opt_ PVOID BaseAddress,
2514 _In_ ULONG FlushSize)
2515 {
2516 KAPC_STATE ApcState;
2517 PKPROCESS Process;
2518 NTSTATUS Status;
2519 PAGED_CODE();
2520
2521 /* Is a base address given? */
2522 if (BaseAddress != NULL)
2523 {
2524 /* If the requested size is 0, there is nothing to do */
2525 if (FlushSize == 0)
2526 {
2527 return STATUS_SUCCESS;
2528 }
2529
2530 /* Is this a user mode call? */
2531 if (KeGetPreviousMode() != KernelMode)
2532 {
2533 /* Make sure the base address is in user space */
2534 if (BaseAddress > MmHighestUserAddress)
2535 {
2536 DPRINT1("Invalid BaseAddress 0x%p\n", BaseAddress);
2537 return STATUS_ACCESS_VIOLATION;
2538 }
2539 }
2540 }
2541
2542 /* Is another process requested? */
2543 if (ProcessHandle != NtCurrentProcess())
2544 {
2545 /* Reference the process */
2546 Status = ObReferenceObjectByHandle(ProcessHandle,
2547 PROCESS_VM_WRITE,
2548 PsProcessType,
2549 KeGetPreviousMode(),
2550 (PVOID*)&Process,
2551 NULL);
2552 if (!NT_SUCCESS(Status))
2553 {
2554 DPRINT1("Failed to reference the process %p\n", ProcessHandle);
2555 return Status;
2556 }
2557
2558 /* Attach to the process */
2559 KeStackAttachProcess(Process, &ApcState);
2560 }
2561
2562 /* FIXME: don't flush everything if a range is requested */
2563 #if defined(_M_IX86) || defined(_M_AMD64)
2564 __wbinvd();
2565 #elif defined(_M_PPC)
2566 __asm__ __volatile__("tlbsync");
2567 #elif defined(_M_MIPS)
2568 DPRINT1("NtFlushInstructionCache() is not implemented\n");
2569 DbgBreakPoint();
2570 #elif defined(_M_ARM)
2571 _MoveToCoprocessor(0, CP15_ICIALLU);
2572 #else
2573 #error Unknown architecture
2574 #endif
2575
2576 /* Check if we attached */
2577 if (ProcessHandle != NtCurrentProcess())
2578 {
2579 /* Detach from the process */
2580 KeUnstackDetachProcess(&ApcState);
2581 }
2582
2583 return STATUS_SUCCESS;
2584 }
2585
2586 ULONG
2587 NTAPI
2588 NtGetCurrentProcessorNumber(VOID)
2589 {
2590 /* Just return the CPU */
2591 return KeGetCurrentProcessorNumber();
2592 }
2593
2594 /*
2595 * @implemented
2596 */
2597 #undef ExGetPreviousMode
2598 KPROCESSOR_MODE
2599 NTAPI
2600 ExGetPreviousMode (VOID)
2601 {
2602 return KeGetPreviousMode();
2603 }