Sync to wine64. Adds support for amd64 relays.. not that we use this feature.
[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 VOID MmPrintMemoryStatistic(VOID);
18
19 FAST_MUTEX ExpEnvironmentLock;
20 ERESOURCE ExpFirmwareTableResource;
21 LIST_ENTRY ExpFirmwareTableProviderListHead;
22
23 NTSTATUS
24 NTAPI
25 ExpQueryModuleInformation(IN PLIST_ENTRY KernelModeList,
26 IN PLIST_ENTRY UserModeList,
27 OUT PRTL_PROCESS_MODULES Modules,
28 IN ULONG Length,
29 OUT PULONG ReturnLength)
30 {
31 NTSTATUS Status = STATUS_SUCCESS;
32 ULONG RequiredLength;
33 PRTL_PROCESS_MODULE_INFORMATION ModuleInfo;
34 PLDR_DATA_TABLE_ENTRY LdrEntry;
35 ANSI_STRING ModuleName;
36 ULONG ModuleCount = 0;
37 PLIST_ENTRY NextEntry;
38 PCHAR p;
39
40 /* Setup defaults */
41 RequiredLength = FIELD_OFFSET(RTL_PROCESS_MODULES, Modules);
42 ModuleInfo = &Modules->Modules[0];
43
44 /* Loop the kernel list */
45 NextEntry = KernelModeList->Flink;
46 while (NextEntry != KernelModeList)
47 {
48 /* Get the entry */
49 LdrEntry = CONTAINING_RECORD(NextEntry,
50 LDR_DATA_TABLE_ENTRY,
51 InLoadOrderLinks);
52
53 /* Update size and check if we can manage one more entry */
54 RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
55 if (Length >= RequiredLength)
56 {
57 /* Fill it out */
58 ModuleInfo->MappedBase = NULL;
59 ModuleInfo->ImageBase = LdrEntry->DllBase;
60 ModuleInfo->ImageSize = LdrEntry->SizeOfImage;
61 ModuleInfo->Flags = LdrEntry->Flags;
62 ModuleInfo->LoadCount = LdrEntry->LoadCount;
63 ModuleInfo->LoadOrderIndex = (USHORT)ModuleCount;
64 ModuleInfo->InitOrderIndex = 0;
65
66 /* Setup name */
67 RtlInitEmptyAnsiString(&ModuleName,
68 ModuleInfo->FullPathName,
69 sizeof(ModuleInfo->FullPathName));
70
71 /* Convert it */
72 Status = RtlUnicodeStringToAnsiString(&ModuleName,
73 &LdrEntry->FullDllName,
74 FALSE);
75 if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
76 {
77 /* Calculate offset to name */
78 p = ModuleName.Buffer + ModuleName.Length;
79 while ((p > ModuleName.Buffer) && (*--p))
80 {
81 /* Check if we found the separator */
82 if (*p == OBJ_NAME_PATH_SEPARATOR)
83 {
84 /* We did, break out */
85 p++;
86 break;
87 }
88 }
89
90 /* Set the offset */
91 ModuleInfo->OffsetToFileName = p - ModuleName.Buffer;
92 }
93 else
94 {
95 /* Return empty name */
96 ModuleInfo->FullPathName[0] = ANSI_NULL;
97 ModuleInfo->OffsetToFileName = 0;
98 }
99
100 /* Go to the next module */
101 ModuleInfo++;
102 }
103 else
104 {
105 /* Set error code */
106 Status = STATUS_INFO_LENGTH_MISMATCH;
107 }
108
109 /* Update count and move to next entry */
110 ModuleCount++;
111 NextEntry = NextEntry->Flink;
112 }
113
114 /* Check if caller also wanted user modules */
115 if (UserModeList)
116 {
117 /* FIXME: TODO */
118 DPRINT1("User-mode list not yet supported in ReactOS!\n");
119 }
120
121 /* Update return length */
122 if (ReturnLength) *ReturnLength = RequiredLength;
123
124 /* Validate the length again */
125 if (Length >= FIELD_OFFSET(RTL_PROCESS_MODULES, Modules))
126 {
127 /* Set the final count */
128 Modules->NumberOfModules = ModuleCount;
129 }
130 else
131 {
132 /* Otherwise, we failed */
133 Status = STATUS_INFO_LENGTH_MISMATCH;
134 }
135
136 /* Done */
137 return Status;
138 }
139
140 /* FUNCTIONS *****************************************************************/
141
142 /*
143 * @implemented
144 */
145 #undef ExGetPreviousMode
146 KPROCESSOR_MODE
147 NTAPI
148 ExGetPreviousMode (VOID)
149 {
150 return KeGetPreviousMode();
151 }
152
153 /*
154 * @implemented
155 */
156 VOID
157 NTAPI
158 ExGetCurrentProcessorCpuUsage(PULONG CpuUsage)
159 {
160 PKPRCB Prcb;
161 ULONG TotalTime;
162 ULONGLONG ScaledIdle;
163
164 Prcb = KeGetCurrentPrcb();
165
166 ScaledIdle = Prcb->IdleThread->KernelTime * 100;
167 TotalTime = Prcb->KernelTime + Prcb->UserTime;
168 if (TotalTime != 0)
169 *CpuUsage = (ULONG)(100 - (ScaledIdle / TotalTime));
170 else
171 *CpuUsage = 0;
172 }
173
174 /*
175 * @implemented
176 */
177 VOID
178 NTAPI
179 ExGetCurrentProcessorCounts(PULONG ThreadKernelTime,
180 PULONG TotalCpuTime,
181 PULONG ProcessorNumber)
182 {
183 PKPRCB Prcb;
184
185 Prcb = KeGetCurrentPrcb();
186
187 *ThreadKernelTime = Prcb->KernelTime + Prcb->UserTime;
188 *TotalCpuTime = Prcb->CurrentThread->KernelTime;
189 *ProcessorNumber = KeGetCurrentProcessorNumber();
190 }
191
192 /*
193 * @implemented
194 */
195 BOOLEAN
196 NTAPI
197 ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
198 {
199 /* Quick check to see if it exists at all */
200 if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return(FALSE);
201
202 /* Return our support for it */
203 return(SharedUserData->ProcessorFeatures[ProcessorFeature]);
204 }
205
206 /*
207 * @implemented
208 */
209 BOOLEAN
210 NTAPI
211 ExVerifySuite(SUITE_TYPE SuiteType)
212 {
213 if (SuiteType == Personal) return TRUE;
214 return FALSE;
215 }
216
217 NTSTATUS
218 NTAPI
219 NtQuerySystemEnvironmentValue (IN PUNICODE_STRING VariableName,
220 OUT PWSTR ValueBuffer,
221 IN ULONG ValueBufferLength,
222 IN OUT PULONG ReturnLength OPTIONAL)
223 {
224 ANSI_STRING AName;
225 UNICODE_STRING WName;
226 ARC_STATUS Result;
227 PCH Value;
228 ANSI_STRING AValue;
229 UNICODE_STRING WValue;
230 KPROCESSOR_MODE PreviousMode;
231 NTSTATUS Status = STATUS_SUCCESS;
232
233 PAGED_CODE();
234
235 PreviousMode = ExGetPreviousMode();
236
237 if(PreviousMode != KernelMode)
238 {
239 _SEH2_TRY
240 {
241 ProbeForRead(VariableName,
242 sizeof(UNICODE_STRING),
243 sizeof(ULONG));
244 ProbeForWrite(ValueBuffer,
245 ValueBufferLength,
246 sizeof(WCHAR));
247 if(ReturnLength != NULL)
248 {
249 ProbeForWriteUlong(ReturnLength);
250 }
251 }
252 _SEH2_EXCEPT(ExSystemExceptionFilter())
253 {
254 Status = _SEH2_GetExceptionCode();
255 }
256 _SEH2_END;
257
258 if(!NT_SUCCESS(Status))
259 {
260 return Status;
261 }
262 }
263
264 /*
265 * Copy the name to kernel space if necessary and convert it to ANSI.
266 */
267 Status = ProbeAndCaptureUnicodeString(&WName,
268 PreviousMode,
269 VariableName);
270 if(NT_SUCCESS(Status))
271 {
272 /*
273 * according to ntinternals the SeSystemEnvironmentName privilege is required!
274 */
275 if(!SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
276 PreviousMode))
277 {
278 ReleaseCapturedUnicodeString(&WName,
279 PreviousMode);
280 DPRINT1("NtQuerySystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
281 return STATUS_PRIVILEGE_NOT_HELD;
282 }
283
284 /*
285 * convert the value name to ansi
286 */
287 Status = RtlUnicodeStringToAnsiString(&AName, &WName, TRUE);
288 ReleaseCapturedUnicodeString(&WName,
289 PreviousMode);
290 if(!NT_SUCCESS(Status))
291 {
292 return Status;
293 }
294
295 /*
296 * Create a temporary buffer for the value
297 */
298 Value = ExAllocatePool(NonPagedPool, ValueBufferLength);
299 if (Value == NULL)
300 {
301 RtlFreeAnsiString(&AName);
302 return STATUS_INSUFFICIENT_RESOURCES;
303 }
304
305 /*
306 * Get the environment variable
307 */
308 Result = HalGetEnvironmentVariable(AName.Buffer,
309 (USHORT)ValueBufferLength,
310 Value);
311 if(!Result)
312 {
313 RtlFreeAnsiString(&AName);
314 ExFreePool(Value);
315 return STATUS_UNSUCCESSFUL;
316 }
317
318 /*
319 * Convert the result to UNICODE, protect with SEH in case the value buffer
320 * isn't NULL-terminated!
321 */
322 _SEH2_TRY
323 {
324 RtlInitAnsiString(&AValue, Value);
325 Status = RtlAnsiStringToUnicodeString(&WValue, &AValue, TRUE);
326 }
327 _SEH2_EXCEPT(ExSystemExceptionFilter())
328 {
329 Status = _SEH2_GetExceptionCode();
330 }
331 _SEH2_END;
332
333 if(NT_SUCCESS(Status))
334 {
335 /*
336 * Copy the result back to the caller.
337 */
338 _SEH2_TRY
339 {
340 RtlCopyMemory(ValueBuffer, WValue.Buffer, WValue.Length);
341 ValueBuffer[WValue.Length / sizeof(WCHAR)] = L'\0';
342 if(ReturnLength != NULL)
343 {
344 *ReturnLength = WValue.Length + sizeof(WCHAR);
345 }
346
347 Status = STATUS_SUCCESS;
348 }
349 _SEH2_EXCEPT(ExSystemExceptionFilter())
350 {
351 Status = _SEH2_GetExceptionCode();
352 }
353 _SEH2_END;
354 }
355
356 /*
357 * Cleanup allocated resources.
358 */
359 RtlFreeAnsiString(&AName);
360 ExFreePool(Value);
361 }
362
363 return Status;
364 }
365
366
367 NTSTATUS NTAPI
368 NtSetSystemEnvironmentValue (IN PUNICODE_STRING VariableName,
369 IN PUNICODE_STRING Value)
370 {
371 UNICODE_STRING CapturedName, CapturedValue;
372 ANSI_STRING AName, AValue;
373 KPROCESSOR_MODE PreviousMode;
374 NTSTATUS Status;
375
376 PAGED_CODE();
377
378 PreviousMode = ExGetPreviousMode();
379
380 /*
381 * Copy the strings to kernel space if necessary
382 */
383 Status = ProbeAndCaptureUnicodeString(&CapturedName,
384 PreviousMode,
385 VariableName);
386 if(NT_SUCCESS(Status))
387 {
388 Status = ProbeAndCaptureUnicodeString(&CapturedValue,
389 PreviousMode,
390 Value);
391 if(NT_SUCCESS(Status))
392 {
393 /*
394 * according to ntinternals the SeSystemEnvironmentName privilege is required!
395 */
396 if(SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
397 PreviousMode))
398 {
399 /*
400 * convert the strings to ANSI
401 */
402 Status = RtlUnicodeStringToAnsiString(&AName,
403 &CapturedName,
404 TRUE);
405 if(NT_SUCCESS(Status))
406 {
407 Status = RtlUnicodeStringToAnsiString(&AValue,
408 &CapturedValue,
409 TRUE);
410 if(NT_SUCCESS(Status))
411 {
412 ARC_STATUS Result = HalSetEnvironmentVariable(AName.Buffer,
413 AValue.Buffer);
414
415 Status = (Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
416 }
417 }
418 }
419 else
420 {
421 DPRINT1("NtSetSystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
422 Status = STATUS_PRIVILEGE_NOT_HELD;
423 }
424
425 ReleaseCapturedUnicodeString(&CapturedValue,
426 PreviousMode);
427 }
428
429 ReleaseCapturedUnicodeString(&CapturedName,
430 PreviousMode);
431 }
432
433 return Status;
434 }
435
436 NTSTATUS
437 NTAPI
438 NtEnumerateSystemEnvironmentValuesEx(IN ULONG InformationClass,
439 IN PVOID Buffer,
440 IN ULONG BufferLength)
441 {
442 UNIMPLEMENTED;
443 return STATUS_NOT_IMPLEMENTED;
444 }
445
446 NTSTATUS
447 NTAPI
448 NtQuerySystemEnvironmentValueEx(IN PUNICODE_STRING VariableName,
449 IN LPGUID VendorGuid,
450 IN PVOID Value,
451 IN OUT PULONG ReturnLength,
452 IN OUT PULONG Attributes)
453 {
454 UNIMPLEMENTED;
455 return STATUS_NOT_IMPLEMENTED;
456 }
457
458 NTSTATUS
459 NTAPI
460 NtSetSystemEnvironmentValueEx(IN PUNICODE_STRING VariableName,
461 IN LPGUID VendorGuid)
462 {
463 UNIMPLEMENTED;
464 return STATUS_NOT_IMPLEMENTED;
465 }
466
467 /* --- Query/Set System Information --- */
468
469 /*
470 * NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
471 * so the stack is popped only in one place on x86 platform.
472 */
473 #define QSI_USE(n) QSI##n
474 #define QSI_DEF(n) \
475 static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
476
477 #define SSI_USE(n) SSI##n
478 #define SSI_DEF(n) \
479 static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
480
481
482 /* Class 0 - Basic Information */
483 QSI_DEF(SystemBasicInformation)
484 {
485 PSYSTEM_BASIC_INFORMATION Sbi
486 = (PSYSTEM_BASIC_INFORMATION) Buffer;
487
488 *ReqSize = sizeof (SYSTEM_BASIC_INFORMATION);
489 /*
490 * Check user buffer's size
491 */
492 if (Size != sizeof (SYSTEM_BASIC_INFORMATION))
493 {
494 return (STATUS_INFO_LENGTH_MISMATCH);
495 }
496 RtlZeroMemory(Sbi, Size);
497 Sbi->Reserved = 0;
498 Sbi->TimerResolution = KeMaximumIncrement;
499 Sbi->PageSize = PAGE_SIZE;
500 Sbi->NumberOfPhysicalPages = MmStats.NrTotalPages;
501 Sbi->LowestPhysicalPageNumber = 0; /* FIXME */
502 Sbi->HighestPhysicalPageNumber = MmStats.NrTotalPages; /* FIXME */
503 Sbi->AllocationGranularity = MM_VIRTMEM_GRANULARITY; /* hard coded on Intel? */
504 Sbi->MinimumUserModeAddress = 0x10000; /* Top of 64k */
505 Sbi->MaximumUserModeAddress = (ULONG_PTR)MmHighestUserAddress;
506 Sbi->ActiveProcessorsAffinityMask = KeActiveProcessors;
507 Sbi->NumberOfProcessors = KeNumberProcessors;
508 return (STATUS_SUCCESS);
509 }
510
511 /* Class 1 - Processor Information */
512 QSI_DEF(SystemProcessorInformation)
513 {
514 PSYSTEM_PROCESSOR_INFORMATION Spi
515 = (PSYSTEM_PROCESSOR_INFORMATION) Buffer;
516 PKPRCB Prcb;
517 *ReqSize = sizeof (SYSTEM_PROCESSOR_INFORMATION);
518 /*
519 * Check user buffer's size
520 */
521 if (Size < sizeof (SYSTEM_PROCESSOR_INFORMATION))
522 {
523 return (STATUS_INFO_LENGTH_MISMATCH);
524 }
525 Prcb = KeGetCurrentPrcb();
526 Spi->ProcessorArchitecture = KeProcessorArchitecture;
527 Spi->ProcessorLevel = KeProcessorLevel;
528 Spi->ProcessorRevision = KeProcessorRevision;
529 Spi->Reserved = 0;
530 Spi->ProcessorFeatureBits = KeFeatureBits;
531
532 DPRINT("Arch %d Level %d Rev 0x%x\n", Spi->ProcessorArchitecture,
533 Spi->ProcessorLevel, Spi->ProcessorRevision);
534
535 return (STATUS_SUCCESS);
536 }
537
538 /* Class 2 - Performance Information */
539 QSI_DEF(SystemPerformanceInformation)
540 {
541 PSYSTEM_PERFORMANCE_INFORMATION Spi
542 = (PSYSTEM_PERFORMANCE_INFORMATION) Buffer;
543
544 PEPROCESS TheIdleProcess;
545
546 *ReqSize = sizeof (SYSTEM_PERFORMANCE_INFORMATION);
547 /*
548 * Check user buffer's size
549 */
550 if (Size < sizeof (SYSTEM_PERFORMANCE_INFORMATION))
551 {
552 return (STATUS_INFO_LENGTH_MISMATCH);
553 }
554
555 TheIdleProcess = PsIdleProcess;
556
557 Spi->IdleProcessTime.QuadPart = TheIdleProcess->Pcb.KernelTime * 100000LL;
558
559 Spi->IoReadTransferCount = IoReadTransferCount;
560 Spi->IoWriteTransferCount = IoWriteTransferCount;
561 Spi->IoOtherTransferCount = IoOtherTransferCount;
562 Spi->IoReadOperationCount = IoReadOperationCount;
563 Spi->IoWriteOperationCount = IoWriteOperationCount;
564 Spi->IoOtherOperationCount = IoOtherOperationCount;
565
566 Spi->AvailablePages = MmStats.NrFreePages;
567 /*
568 Add up all the used "Committed" memory + pagefile.
569 Not sure this is right. 8^\
570 */
571 Spi->CommittedPages = MiMemoryConsumers[MC_PPOOL].PagesUsed +
572 MiMemoryConsumers[MC_NPPOOL].PagesUsed+
573 MiMemoryConsumers[MC_CACHE].PagesUsed+
574 MiMemoryConsumers[MC_USER].PagesUsed+
575 MiUsedSwapPages;
576 /*
577 Add up the full system total + pagefile.
578 All this make Taskmgr happy but not sure it is the right numbers.
579 This too, fixes some of GlobalMemoryStatusEx numbers.
580 */
581 Spi->CommitLimit = MmStats.NrTotalPages + MiFreeSwapPages +
582 MiUsedSwapPages;
583
584 Spi->PeakCommitment = 0; /* FIXME */
585 Spi->PageFaultCount = 0; /* FIXME */
586 Spi->CopyOnWriteCount = 0; /* FIXME */
587 Spi->TransitionCount = 0; /* FIXME */
588 Spi->CacheTransitionCount = 0; /* FIXME */
589 Spi->DemandZeroCount = 0; /* FIXME */
590 Spi->PageReadCount = 0; /* FIXME */
591 Spi->PageReadIoCount = 0; /* FIXME */
592 Spi->CacheReadCount = 0; /* FIXME */
593 Spi->CacheIoCount = 0; /* FIXME */
594 Spi->DirtyPagesWriteCount = 0; /* FIXME */
595 Spi->DirtyWriteIoCount = 0; /* FIXME */
596 Spi->MappedPagesWriteCount = 0; /* FIXME */
597 Spi->MappedWriteIoCount = 0; /* FIXME */
598
599 Spi->PagedPoolPages = MiMemoryConsumers[MC_PPOOL].PagesUsed;
600 Spi->PagedPoolAllocs = 0; /* FIXME */
601 Spi->PagedPoolFrees = 0; /* FIXME */
602 Spi->NonPagedPoolPages = MiMemoryConsumers[MC_NPPOOL].PagesUsed;
603 Spi->NonPagedPoolAllocs = 0; /* FIXME */
604 Spi->NonPagedPoolFrees = 0; /* FIXME */
605
606 Spi->FreeSystemPtes = 0; /* FIXME */
607
608 Spi->ResidentSystemCodePage = MmStats.NrSystemPages; /* FIXME */
609
610 Spi->TotalSystemDriverPages = 0; /* FIXME */
611 Spi->TotalSystemCodePages = 0; /* FIXME */
612 Spi->NonPagedPoolLookasideHits = 0; /* FIXME */
613 Spi->PagedPoolLookasideHits = 0; /* FIXME */
614 Spi->Spare3Count = 0; /* FIXME */
615
616 Spi->ResidentSystemCachePage = MiMemoryConsumers[MC_CACHE].PagesUsed;
617 Spi->ResidentPagedPoolPage = MmPagedPoolSize; /* FIXME */
618
619 Spi->ResidentSystemDriverPage = 0; /* FIXME */
620 Spi->CcFastReadNoWait = 0; /* FIXME */
621 Spi->CcFastReadWait = 0; /* FIXME */
622 Spi->CcFastReadResourceMiss = 0; /* FIXME */
623 Spi->CcFastReadNotPossible = 0; /* FIXME */
624
625 Spi->CcFastMdlReadNoWait = 0; /* FIXME */
626 Spi->CcFastMdlReadWait = 0; /* FIXME */
627 Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
628 Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
629
630 Spi->CcMapDataNoWait = 0; /* FIXME */
631 Spi->CcMapDataWait = 0; /* FIXME */
632 Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
633 Spi->CcMapDataWaitMiss = 0; /* FIXME */
634
635 Spi->CcPinMappedDataCount = 0; /* FIXME */
636 Spi->CcPinReadNoWait = 0; /* FIXME */
637 Spi->CcPinReadWait = 0; /* FIXME */
638 Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
639 Spi->CcPinReadWaitMiss = 0; /* FIXME */
640 Spi->CcCopyReadNoWait = 0; /* FIXME */
641 Spi->CcCopyReadWait = 0; /* FIXME */
642 Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
643 Spi->CcCopyReadWaitMiss = 0; /* FIXME */
644
645 Spi->CcMdlReadNoWait = 0; /* FIXME */
646 Spi->CcMdlReadWait = 0; /* FIXME */
647 Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
648 Spi->CcMdlReadWaitMiss = 0; /* FIXME */
649 Spi->CcReadAheadIos = 0; /* FIXME */
650 Spi->CcLazyWriteIos = 0; /* FIXME */
651 Spi->CcLazyWritePages = 0; /* FIXME */
652 Spi->CcDataFlushes = 0; /* FIXME */
653 Spi->CcDataPages = 0; /* FIXME */
654 Spi->ContextSwitches = 0; /* FIXME */
655 Spi->FirstLevelTbFills = 0; /* FIXME */
656 Spi->SecondLevelTbFills = 0; /* FIXME */
657 Spi->SystemCalls = 0; /* FIXME */
658
659 return (STATUS_SUCCESS);
660 }
661
662 /* Class 3 - Time Of Day Information */
663 QSI_DEF(SystemTimeOfDayInformation)
664 {
665 PSYSTEM_TIMEOFDAY_INFORMATION Sti;
666 LARGE_INTEGER CurrentTime;
667
668 Sti = (PSYSTEM_TIMEOFDAY_INFORMATION)Buffer;
669 *ReqSize = sizeof (SYSTEM_TIMEOFDAY_INFORMATION);
670
671 /* Check user buffer's size */
672 if (Size != sizeof (SYSTEM_TIMEOFDAY_INFORMATION))
673 {
674 return STATUS_INFO_LENGTH_MISMATCH;
675 }
676
677 KeQuerySystemTime(&CurrentTime);
678
679 Sti->BootTime= KeBootTime;
680 Sti->CurrentTime = CurrentTime;
681 Sti->TimeZoneBias.QuadPart = ExpTimeZoneBias.QuadPart;
682 Sti->TimeZoneId = ExpTimeZoneId;
683 Sti->Reserved = 0;
684
685 return STATUS_SUCCESS;
686 }
687
688 /* Class 4 - Path Information */
689 QSI_DEF(SystemPathInformation)
690 {
691 /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
692 DPRINT1("NtQuerySystemInformation - SystemPathInformation not implemented\n");
693
694 return (STATUS_BREAKPOINT);
695 }
696
697 /* Class 5 - Process Information */
698 QSI_DEF(SystemProcessInformation)
699 {
700 ULONG ovlSize = 0, nThreads;
701 PEPROCESS pr = NULL, syspr;
702 unsigned char *pCur;
703 NTSTATUS Status = STATUS_SUCCESS;
704
705 _SEH2_TRY
706 {
707 /* scan the process list */
708
709 PSYSTEM_PROCESS_INFORMATION Spi
710 = (PSYSTEM_PROCESS_INFORMATION) Buffer;
711
712 *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
713
714 if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
715 {
716 _SEH2_YIELD(return STATUS_INFO_LENGTH_MISMATCH); // in case buffer size is too small
717 }
718 RtlZeroMemory(Spi, Size);
719
720 syspr = PsIdleProcess;
721 pr = syspr;
722 pCur = (unsigned char *)Spi;
723
724 do
725 {
726 PSYSTEM_PROCESS_INFORMATION SpiCur;
727 int curSize;
728 ANSI_STRING imgName;
729 int inLen=32; // image name len in bytes
730 PLIST_ENTRY current_entry;
731 PETHREAD current;
732 PSYSTEM_THREAD_INFORMATION ThreadInfo;
733
734 SpiCur = (PSYSTEM_PROCESS_INFORMATION)pCur;
735
736 nThreads = 0;
737 current_entry = pr->ThreadListHead.Flink;
738 while (current_entry != &pr->ThreadListHead)
739 {
740 nThreads++;
741 current_entry = current_entry->Flink;
742 }
743
744 // size of the structure for every process
745 curSize = sizeof(SYSTEM_PROCESS_INFORMATION)+sizeof(SYSTEM_THREAD_INFORMATION)*nThreads;
746 ovlSize += curSize+inLen;
747
748 if (ovlSize > Size)
749 {
750 *ReqSize = ovlSize;
751 ObDereferenceObject(pr);
752
753 _SEH2_YIELD(return STATUS_INFO_LENGTH_MISMATCH); // in case buffer size is too small
754 }
755
756 // fill system information
757 SpiCur->NextEntryOffset = curSize+inLen; // relative offset to the beginnnig of the next structure
758 SpiCur->NumberOfThreads = nThreads;
759 SpiCur->CreateTime = pr->CreateTime;
760 SpiCur->UserTime.QuadPart = pr->Pcb.UserTime * 100000LL;
761 SpiCur->KernelTime.QuadPart = pr->Pcb.KernelTime * 100000LL;
762 SpiCur->ImageName.Length = strlen(pr->ImageFileName) * sizeof(WCHAR);
763 SpiCur->ImageName.MaximumLength = (USHORT)inLen;
764 SpiCur->ImageName.Buffer = (void*)(pCur+curSize);
765
766 // copy name to the end of the struct
767 if(pr != PsIdleProcess)
768 {
769 RtlInitAnsiString(&imgName, pr->ImageFileName);
770 RtlAnsiStringToUnicodeString(&SpiCur->ImageName, &imgName, FALSE);
771 }
772 else
773 {
774 RtlInitUnicodeString(&SpiCur->ImageName, NULL);
775 }
776
777 SpiCur->BasePriority = pr->Pcb.BasePriority;
778 SpiCur->UniqueProcessId = pr->UniqueProcessId;
779 SpiCur->InheritedFromUniqueProcessId = pr->InheritedFromUniqueProcessId;
780 SpiCur->HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
781 SpiCur->PeakVirtualSize = pr->PeakVirtualSize;
782 SpiCur->VirtualSize = pr->VirtualSize;
783 SpiCur->PageFaultCount = pr->Vm.PageFaultCount;
784 SpiCur->PeakWorkingSetSize = pr->Vm.PeakWorkingSetSize;
785 SpiCur->WorkingSetSize = pr->Vm.WorkingSetSize;
786 SpiCur->QuotaPeakPagedPoolUsage = pr->QuotaPeak[0];
787 SpiCur->QuotaPagedPoolUsage = pr->QuotaUsage[0];
788 SpiCur->QuotaPeakNonPagedPoolUsage = pr->QuotaPeak[1];
789 SpiCur->QuotaNonPagedPoolUsage = pr->QuotaUsage[1];
790 SpiCur->PagefileUsage = pr->QuotaUsage[2];
791 SpiCur->PeakPagefileUsage = pr->QuotaPeak[2];
792 SpiCur->PrivatePageCount = pr->CommitCharge;
793 ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCur + 1);
794
795 current_entry = pr->ThreadListHead.Flink;
796 while (current_entry != &pr->ThreadListHead)
797 {
798 current = CONTAINING_RECORD(current_entry, ETHREAD,
799 ThreadListEntry);
800
801 ThreadInfo->KernelTime.QuadPart = current->Tcb.KernelTime * 100000LL;
802 ThreadInfo->UserTime.QuadPart = current->Tcb.UserTime * 100000LL;
803 ThreadInfo->CreateTime.QuadPart = current->CreateTime.QuadPart;
804 ThreadInfo->WaitTime = current->Tcb.WaitTime;
805 ThreadInfo->StartAddress = (PVOID) current->StartAddress;
806 ThreadInfo->ClientId = current->Cid;
807 ThreadInfo->Priority = current->Tcb.Priority;
808 ThreadInfo->BasePriority = current->Tcb.BasePriority;
809 ThreadInfo->ContextSwitches = current->Tcb.ContextSwitches;
810 ThreadInfo->ThreadState = current->Tcb.State;
811 ThreadInfo->WaitReason = current->Tcb.WaitReason;
812 ThreadInfo++;
813 current_entry = current_entry->Flink;
814 }
815
816 /* Handle idle process entry */
817 if (pr == PsIdleProcess) pr = NULL;
818
819 pr = PsGetNextProcess(pr);
820 nThreads = 0;
821 if ((pr == syspr) || (pr == NULL))
822 {
823 SpiCur->NextEntryOffset = 0;
824 break;
825 }
826 else
827 pCur = pCur + curSize + inLen;
828 } while ((pr != syspr) && (pr != NULL));
829
830 if(pr != NULL)
831 ObDereferenceObject(pr);
832 Status = STATUS_SUCCESS;
833 }
834 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
835 {
836 if(pr != NULL)
837 ObDereferenceObject(pr);
838 Status = _SEH2_GetExceptionCode();
839 }
840 _SEH2_END
841
842 *ReqSize = ovlSize;
843 return Status;
844 }
845
846 /* Class 6 - Call Count Information */
847 QSI_DEF(SystemCallCountInformation)
848 {
849 /* FIXME */
850 DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
851 return (STATUS_NOT_IMPLEMENTED);
852 }
853
854 /* Class 7 - Device Information */
855 QSI_DEF(SystemDeviceInformation)
856 {
857 PSYSTEM_DEVICE_INFORMATION Sdi
858 = (PSYSTEM_DEVICE_INFORMATION) Buffer;
859 PCONFIGURATION_INFORMATION ConfigInfo;
860
861 *ReqSize = sizeof (SYSTEM_DEVICE_INFORMATION);
862 /*
863 * Check user buffer's size
864 */
865 if (Size < sizeof (SYSTEM_DEVICE_INFORMATION))
866 {
867 return (STATUS_INFO_LENGTH_MISMATCH);
868 }
869
870 ConfigInfo = IoGetConfigurationInformation ();
871
872 Sdi->NumberOfDisks = ConfigInfo->DiskCount;
873 Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
874 Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
875 Sdi->NumberOfTapes = ConfigInfo->TapeCount;
876 Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
877 Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
878
879 return (STATUS_SUCCESS);
880 }
881
882 /* Class 8 - Processor Performance Information */
883 QSI_DEF(SystemProcessorPerformanceInformation)
884 {
885 PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
886 = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
887
888 LONG i;
889 LARGE_INTEGER CurrentTime;
890 PKPRCB Prcb;
891
892 *ReqSize = KeNumberProcessors * sizeof (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
893 /*
894 * Check user buffer's size
895 */
896 if (Size < KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))
897 {
898 return (STATUS_INFO_LENGTH_MISMATCH);
899 }
900
901 CurrentTime.QuadPart = KeQueryInterruptTime();
902 Prcb = KeGetCurrentPrcb();
903 for (i = 0; i < KeNumberProcessors; i++)
904 {
905 Spi->IdleTime.QuadPart = (Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime) * 100000LL;
906 Spi->KernelTime.QuadPart = Prcb->KernelTime * 100000LL;
907 Spi->UserTime.QuadPart = Prcb->UserTime * 100000LL;
908 Spi->DpcTime.QuadPart = Prcb->DpcTime * 100000LL;
909 Spi->InterruptTime.QuadPart = Prcb->InterruptTime * 100000LL;
910 Spi->InterruptCount = Prcb->InterruptCount;
911 Spi++;
912 Prcb = (PKPRCB)((ULONG_PTR)Prcb + PAGE_SIZE);
913 }
914
915 return (STATUS_SUCCESS);
916 }
917
918 /* Class 9 - Flags Information */
919 QSI_DEF(SystemFlagsInformation)
920 {
921 if (sizeof (SYSTEM_FLAGS_INFORMATION) != Size)
922 {
923 * ReqSize = sizeof (SYSTEM_FLAGS_INFORMATION);
924 return (STATUS_INFO_LENGTH_MISMATCH);
925 }
926 ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
927 return (STATUS_SUCCESS);
928 }
929
930 SSI_DEF(SystemFlagsInformation)
931 {
932 if (sizeof (SYSTEM_FLAGS_INFORMATION) != Size)
933 {
934 return (STATUS_INFO_LENGTH_MISMATCH);
935 }
936 NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
937 return (STATUS_SUCCESS);
938 }
939
940 /* Class 10 - Call Time Information */
941 QSI_DEF(SystemCallTimeInformation)
942 {
943 /* FIXME */
944 DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
945 return (STATUS_NOT_IMPLEMENTED);
946 }
947
948 /* Class 11 - Module Information */
949 QSI_DEF(SystemModuleInformation)
950 {
951 extern LIST_ENTRY PsLoadedModuleList;
952 return ExpQueryModuleInformation(&PsLoadedModuleList,
953 NULL,
954 (PRTL_PROCESS_MODULES)Buffer,
955 Size,
956 ReqSize);
957 }
958
959 /* Class 12 - Locks Information */
960 QSI_DEF(SystemLocksInformation)
961 {
962 /* FIXME */
963 DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
964 return (STATUS_NOT_IMPLEMENTED);
965 }
966
967 /* Class 13 - Stack Trace Information */
968 QSI_DEF(SystemStackTraceInformation)
969 {
970 /* FIXME */
971 DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
972 return (STATUS_NOT_IMPLEMENTED);
973 }
974
975 /* Class 14 - Paged Pool Information */
976 QSI_DEF(SystemPagedPoolInformation)
977 {
978 /* FIXME */
979 DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
980 return (STATUS_NOT_IMPLEMENTED);
981 }
982
983 /* Class 15 - Non Paged Pool Information */
984 QSI_DEF(SystemNonPagedPoolInformation)
985 {
986 /* FIXME */
987 DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
988 return (STATUS_NOT_IMPLEMENTED);
989 }
990
991
992 /* Class 16 - Handle Information */
993 QSI_DEF(SystemHandleInformation)
994 {
995 PEPROCESS pr, syspr;
996 ULONG curSize, i = 0;
997 ULONG hCount = 0;
998
999 PSYSTEM_HANDLE_INFORMATION Shi =
1000 (PSYSTEM_HANDLE_INFORMATION) Buffer;
1001
1002 DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1003
1004 if (Size < sizeof (SYSTEM_HANDLE_INFORMATION))
1005 {
1006 * ReqSize = sizeof (SYSTEM_HANDLE_INFORMATION);
1007 return (STATUS_INFO_LENGTH_MISMATCH);
1008 }
1009
1010 DPRINT("SystemHandleInformation 1\n");
1011
1012 /* First Calc Size from Count. */
1013 syspr = PsGetNextProcess(NULL);
1014 pr = syspr;
1015
1016 do
1017 {
1018 hCount = hCount + (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
1019 pr = PsGetNextProcess(pr);
1020
1021 if ((pr == syspr) || (pr == NULL))
1022 break;
1023 } while ((pr != syspr) && (pr != NULL));
1024
1025 if(pr != NULL)
1026 {
1027 ObDereferenceObject(pr);
1028 }
1029
1030 DPRINT("SystemHandleInformation 2\n");
1031
1032 curSize = sizeof(SYSTEM_HANDLE_INFORMATION)+
1033 ( (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) * hCount) -
1034 (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) ));
1035
1036 Shi->NumberOfHandles = hCount;
1037
1038 if (curSize > Size)
1039 {
1040 *ReqSize = curSize;
1041 return (STATUS_INFO_LENGTH_MISMATCH);
1042 }
1043
1044 DPRINT("SystemHandleInformation 3\n");
1045
1046 /* Now get Handles from all processs. */
1047 syspr = PsGetNextProcess(NULL);
1048 pr = syspr;
1049
1050 do
1051 {
1052 int Count = 0, HandleCount;
1053
1054 HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
1055
1056 for (Count = 0; HandleCount > 0 ; HandleCount--)
1057 {
1058 Shi->Handles[i].UniqueProcessId = (USHORT)(ULONG_PTR)pr->UniqueProcessId;
1059 Count++;
1060 i++;
1061 }
1062
1063 pr = PsGetNextProcess(pr);
1064
1065 if ((pr == syspr) || (pr == NULL))
1066 break;
1067 } while ((pr != syspr) && (pr != NULL));
1068
1069 if(pr != NULL)
1070 {
1071 ObDereferenceObject(pr);
1072 }
1073
1074 DPRINT("SystemHandleInformation 4\n");
1075 return (STATUS_SUCCESS);
1076
1077 }
1078 /*
1079 SSI_DEF(SystemHandleInformation)
1080 {
1081
1082 return (STATUS_SUCCESS);
1083 }
1084 */
1085
1086 /* Class 17 - Information */
1087 QSI_DEF(SystemObjectInformation)
1088 {
1089 /* FIXME */
1090 DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1091 return (STATUS_NOT_IMPLEMENTED);
1092 }
1093
1094 /* Class 18 - Information */
1095 QSI_DEF(SystemPageFileInformation)
1096 {
1097 UNICODE_STRING FileName; /* FIXME */
1098 SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
1099
1100 if (Size < sizeof (SYSTEM_PAGEFILE_INFORMATION))
1101 {
1102 * ReqSize = sizeof (SYSTEM_PAGEFILE_INFORMATION);
1103 return (STATUS_INFO_LENGTH_MISMATCH);
1104 }
1105
1106 RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1107
1108 /* FIXME */
1109 Spfi->NextEntryOffset = 0;
1110
1111 Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
1112 Spfi->TotalInUse = MiUsedSwapPages;
1113 Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1114 Spfi->PageFileName = FileName;
1115 return (STATUS_SUCCESS);
1116 }
1117
1118 /* Class 19 - Vdm Instemul Information */
1119 QSI_DEF(SystemVdmInstemulInformation)
1120 {
1121 /* FIXME */
1122 DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1123 return (STATUS_NOT_IMPLEMENTED);
1124 }
1125
1126 /* Class 20 - Vdm Bop Information */
1127 QSI_DEF(SystemVdmBopInformation)
1128 {
1129 /* FIXME */
1130 DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1131 return (STATUS_NOT_IMPLEMENTED);
1132 }
1133
1134 /* Class 21 - File Cache Information */
1135 QSI_DEF(SystemFileCacheInformation)
1136 {
1137 SYSTEM_FILECACHE_INFORMATION *Sci = (SYSTEM_FILECACHE_INFORMATION *) Buffer;
1138
1139 if (Size < sizeof (SYSTEM_FILECACHE_INFORMATION))
1140 {
1141 * ReqSize = sizeof (SYSTEM_FILECACHE_INFORMATION);
1142 return (STATUS_INFO_LENGTH_MISMATCH);
1143 }
1144
1145 RtlZeroMemory(Sci, sizeof(SYSTEM_FILECACHE_INFORMATION));
1146
1147 /* Return the Byte size not the page size. */
1148 Sci->CurrentSize =
1149 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
1150 Sci->PeakSize =
1151 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
1152
1153 Sci->PageFaultCount = 0; /* FIXME */
1154 Sci->MinimumWorkingSet = 0; /* FIXME */
1155 Sci->MaximumWorkingSet = 0; /* FIXME */
1156
1157 return (STATUS_SUCCESS);
1158 }
1159
1160 SSI_DEF(SystemFileCacheInformation)
1161 {
1162 if (Size < sizeof (SYSTEM_FILECACHE_INFORMATION))
1163 {
1164 return (STATUS_INFO_LENGTH_MISMATCH);
1165 }
1166 /* FIXME */
1167 DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1168 return (STATUS_NOT_IMPLEMENTED);
1169 }
1170
1171 /* Class 22 - Pool Tag Information */
1172 QSI_DEF(SystemPoolTagInformation)
1173 {
1174 /* FIXME */
1175 DPRINT1("NtQuerySystemInformation - SystemPoolTagInformation not implemented\n");
1176 return (STATUS_NOT_IMPLEMENTED);
1177 }
1178
1179 /* Class 23 - Interrupt Information for all processors */
1180 QSI_DEF(SystemInterruptInformation)
1181 {
1182 PKPRCB Prcb;
1183 PKPCR Pcr;
1184 LONG i;
1185 ULONG ti;
1186 PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1187
1188 if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1189 {
1190 return (STATUS_INFO_LENGTH_MISMATCH);
1191 }
1192
1193 ti = KeQueryTimeIncrement();
1194
1195 for (i = 0; i < KeNumberProcessors; i++)
1196 {
1197 Prcb = KiProcessorBlock[i];
1198 #ifdef _M_AMD64
1199 Pcr = CONTAINING_RECORD(Prcb, KPCR, CurrentPrcb);
1200 #else
1201 Pcr = CONTAINING_RECORD(Prcb, KPCR, Prcb);
1202 #endif
1203 #ifdef _M_ARM // This code should probably be done differently
1204 sii->ContextSwitches = Pcr->ContextSwitches;
1205 #else
1206 sii->ContextSwitches = ((PKIPCR)Pcr)->ContextSwitches;
1207 #endif
1208 sii->DpcCount = Prcb->DpcData[0].DpcCount;
1209 sii->DpcRate = Prcb->DpcRequestRate;
1210 sii->TimeIncrement = ti;
1211 sii->DpcBypassCount = 0;
1212 sii->ApcBypassCount = 0;
1213 sii++;
1214 }
1215
1216 return STATUS_SUCCESS;
1217 }
1218
1219 /* Class 24 - DPC Behaviour Information */
1220 QSI_DEF(SystemDpcBehaviourInformation)
1221 {
1222 /* FIXME */
1223 DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1224 return (STATUS_NOT_IMPLEMENTED);
1225 }
1226
1227 SSI_DEF(SystemDpcBehaviourInformation)
1228 {
1229 /* FIXME */
1230 DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1231 return (STATUS_NOT_IMPLEMENTED);
1232 }
1233
1234 /* Class 25 - Full Memory Information */
1235 QSI_DEF(SystemFullMemoryInformation)
1236 {
1237 PULONG Spi = (PULONG) Buffer;
1238
1239 PEPROCESS TheIdleProcess;
1240
1241 * ReqSize = sizeof (ULONG);
1242
1243 if (sizeof (ULONG) != Size)
1244 {
1245 return (STATUS_INFO_LENGTH_MISMATCH);
1246 }
1247 DPRINT("SystemFullMemoryInformation\n");
1248
1249 TheIdleProcess = PsIdleProcess;
1250
1251 DPRINT("PID: %d, KernelTime: %u PFFree: %d PFUsed: %d\n",
1252 TheIdleProcess->UniqueProcessId,
1253 TheIdleProcess->Pcb.KernelTime,
1254 MiFreeSwapPages,
1255 MiUsedSwapPages);
1256
1257 #ifndef NDEBUG
1258 MmPrintMemoryStatistic();
1259 #endif
1260
1261 *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1262
1263 return (STATUS_SUCCESS);
1264 }
1265
1266 /* Class 26 - Load Image */
1267 SSI_DEF(SystemLoadGdiDriverInformation)
1268 {
1269 PSYSTEM_GDI_DRIVER_INFORMATION DriverInfo = (PVOID)Buffer;
1270 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1271 UNICODE_STRING ImageName;
1272 PVOID ImageBase;
1273 PLDR_DATA_TABLE_ENTRY ModuleObject;
1274 ULONG_PTR EntryPoint;
1275 NTSTATUS Status;
1276 ULONG DirSize;
1277 PIMAGE_NT_HEADERS NtHeader;
1278
1279 /* Validate size */
1280 if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1281 {
1282 /* Incorrect buffer length, fail */
1283 return STATUS_INFO_LENGTH_MISMATCH;
1284 }
1285
1286 /* Only kernel-mode can call this function */
1287 if (PreviousMode != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1288
1289 /* Load the driver */
1290 ImageName = DriverInfo->DriverName;
1291 Status = MmLoadSystemImage(&ImageName,
1292 NULL,
1293 NULL,
1294 0,
1295 (PVOID)&ModuleObject,
1296 &ImageBase);
1297 if (!NT_SUCCESS(Status)) return Status;
1298
1299 /* Return the export pointer */
1300 DriverInfo->ExportSectionPointer =
1301 RtlImageDirectoryEntryToData(ImageBase,
1302 TRUE,
1303 IMAGE_DIRECTORY_ENTRY_EXPORT,
1304 &DirSize);
1305
1306 /* Get the entrypoint */
1307 NtHeader = RtlImageNtHeader(ImageBase);
1308 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1309 EntryPoint += (ULONG_PTR)ImageBase;
1310
1311 /* Save other data */
1312 DriverInfo->ImageAddress = ImageBase;
1313 DriverInfo->SectionPointer = NULL;
1314 DriverInfo->EntryPoint = (PVOID)EntryPoint;
1315 DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1316
1317 /* All is good */
1318 return STATUS_SUCCESS;
1319 }
1320
1321 /* Class 27 - Unload Image */
1322 SSI_DEF(SystemUnloadGdiDriverInformation)
1323 {
1324 PLDR_DATA_TABLE_ENTRY LdrEntry;
1325 PLIST_ENTRY NextEntry;
1326 PVOID BaseAddr = *((PVOID*)Buffer);
1327
1328 if(Size != sizeof(PVOID))
1329 return STATUS_INFO_LENGTH_MISMATCH;
1330
1331 if(KeGetPreviousMode() != KernelMode)
1332 return STATUS_PRIVILEGE_NOT_HELD;
1333
1334 // Scan the module list
1335 NextEntry = PsLoadedModuleList.Flink;
1336 while(NextEntry != &PsLoadedModuleList)
1337 {
1338 LdrEntry = CONTAINING_RECORD(NextEntry,
1339 LDR_DATA_TABLE_ENTRY,
1340 InLoadOrderLinks);
1341
1342 if (LdrEntry->DllBase == BaseAddr)
1343 {
1344 // Found it.
1345 break;
1346 }
1347
1348 NextEntry = NextEntry->Flink;
1349 }
1350
1351 // Check if we found the image
1352 if(NextEntry != &PsLoadedModuleList)
1353 {
1354 return MmUnloadSystemImage(LdrEntry);
1355 }
1356 else
1357 {
1358 DPRINT1("Image 0x%x not found.\n", BaseAddr);
1359 return STATUS_DLL_NOT_FOUND;
1360 }
1361
1362 }
1363
1364 /* Class 28 - Time Adjustment Information */
1365 QSI_DEF(SystemTimeAdjustmentInformation)
1366 {
1367 if (sizeof (SYSTEM_SET_TIME_ADJUST_INFORMATION) > Size)
1368 {
1369 * ReqSize = sizeof (SYSTEM_SET_TIME_ADJUST_INFORMATION);
1370 return (STATUS_INFO_LENGTH_MISMATCH);
1371 }
1372 /* FIXME: */
1373 DPRINT1("NtQuerySystemInformation - SystemTimeAdjustmentInformation not implemented\n");
1374 return (STATUS_NOT_IMPLEMENTED);
1375 }
1376
1377 SSI_DEF(SystemTimeAdjustmentInformation)
1378 {
1379 if (sizeof (SYSTEM_SET_TIME_ADJUST_INFORMATION) > Size)
1380 {
1381 return (STATUS_INFO_LENGTH_MISMATCH);
1382 }
1383 /* FIXME: */
1384 DPRINT1("NtSetSystemInformation - SystemTimeAdjustmentInformation not implemented\n");
1385 return (STATUS_NOT_IMPLEMENTED);
1386 }
1387
1388 /* Class 29 - Summary Memory Information */
1389 QSI_DEF(SystemSummaryMemoryInformation)
1390 {
1391 /* FIXME */
1392 DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1393 return (STATUS_NOT_IMPLEMENTED);
1394 }
1395
1396 /* Class 30 - Next Event Id Information */
1397 QSI_DEF(SystemNextEventIdInformation)
1398 {
1399 /* FIXME */
1400 DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1401 return (STATUS_NOT_IMPLEMENTED);
1402 }
1403
1404 /* Class 31 - Event Ids Information */
1405 QSI_DEF(SystemEventIdsInformation)
1406 {
1407 /* FIXME */
1408 DPRINT1("NtQuerySystemInformation - SystemEventIdsInformation not implemented\n");
1409 return (STATUS_NOT_IMPLEMENTED);
1410 }
1411
1412 /* Class 32 - Crash Dump Information */
1413 QSI_DEF(SystemCrashDumpInformation)
1414 {
1415 /* FIXME */
1416 DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1417 return (STATUS_NOT_IMPLEMENTED);
1418 }
1419
1420 /* Class 33 - Exception Information */
1421 QSI_DEF(SystemExceptionInformation)
1422 {
1423 /* FIXME */
1424 DPRINT1("NtQuerySystemInformation - SystemExceptionInformation not implemented\n");
1425 return (STATUS_NOT_IMPLEMENTED);
1426 }
1427
1428 /* Class 34 - Crash Dump State Information */
1429 QSI_DEF(SystemCrashDumpStateInformation)
1430 {
1431 /* FIXME */
1432 DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1433 return (STATUS_NOT_IMPLEMENTED);
1434 }
1435
1436 /* Class 35 - Kernel Debugger Information */
1437 QSI_DEF(SystemKernelDebuggerInformation)
1438 {
1439 PSYSTEM_KERNEL_DEBUGGER_INFORMATION skdi = (PSYSTEM_KERNEL_DEBUGGER_INFORMATION) Buffer;
1440
1441 *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1442 if (Size < sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION))
1443 {
1444 return STATUS_INFO_LENGTH_MISMATCH;
1445 }
1446
1447 skdi->KernelDebuggerEnabled = KD_DEBUGGER_ENABLED;
1448 skdi->KernelDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
1449
1450 return STATUS_SUCCESS;
1451 }
1452
1453 /* Class 36 - Context Switch Information */
1454 QSI_DEF(SystemContextSwitchInformation)
1455 {
1456 /* FIXME */
1457 DPRINT1("NtQuerySystemInformation - SystemContextSwitchInformation not implemented\n");
1458 return (STATUS_NOT_IMPLEMENTED);
1459 }
1460
1461 /* Class 37 - Registry Quota Information */
1462 QSI_DEF(SystemRegistryQuotaInformation)
1463 {
1464 PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1465
1466 *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1467 if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1468 {
1469 return STATUS_INFO_LENGTH_MISMATCH;
1470 }
1471
1472 DPRINT1("Faking max registry size of 32 MB\n");
1473 srqi->RegistryQuotaAllowed = 0x2000000;
1474 srqi->RegistryQuotaUsed = 0x200000;
1475 srqi->PagedPoolSize = 0x200000;
1476
1477 return STATUS_SUCCESS;
1478 }
1479
1480 SSI_DEF(SystemRegistryQuotaInformation)
1481 {
1482 /* FIXME */
1483 DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1484 return (STATUS_NOT_IMPLEMENTED);
1485 }
1486
1487 /* Class 38 - Load And Call Image */
1488 SSI_DEF(SystemExtendServiceTableInformation)
1489 {
1490 UNICODE_STRING ImageName;
1491 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1492 PLDR_DATA_TABLE_ENTRY ModuleObject;
1493 NTSTATUS Status;
1494 PIMAGE_NT_HEADERS NtHeader;
1495 DRIVER_OBJECT Win32k;
1496 PDRIVER_INITIALIZE DriverInit;
1497 PVOID ImageBase;
1498 ULONG_PTR EntryPoint;
1499
1500 /* Validate the size */
1501 if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1502
1503 /* Check who is calling */
1504 if (PreviousMode != KernelMode)
1505 {
1506 /* Make sure we can load drivers */
1507 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, UserMode))
1508 {
1509 /* FIXME: We can't, fail */
1510 //return STATUS_PRIVILEGE_NOT_HELD;
1511 }
1512
1513 /* Probe and capture the driver name */
1514 ProbeAndCaptureUnicodeString(&ImageName, UserMode, Buffer);
1515
1516 /* Force kernel as previous mode */
1517 return ZwSetSystemInformation(SystemExtendServiceTableInformation,
1518 &ImageName,
1519 sizeof(ImageName));
1520 }
1521
1522 /* Just copy the string */
1523 ImageName = *(PUNICODE_STRING)Buffer;
1524
1525 /* Load the image */
1526 Status = MmLoadSystemImage(&ImageName,
1527 NULL,
1528 NULL,
1529 0,
1530 (PVOID)&ModuleObject,
1531 &ImageBase);
1532 if (!NT_SUCCESS(Status)) return Status;
1533
1534 /* Get the headers */
1535 NtHeader = RtlImageNtHeader(ImageBase);
1536 if (!NtHeader)
1537 {
1538 /* Fail */
1539 MmUnloadSystemImage(ModuleObject);
1540 return STATUS_INVALID_IMAGE_FORMAT;
1541 }
1542
1543 /* Get the entrypoint */
1544 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1545 EntryPoint += (ULONG_PTR)ImageBase;
1546 DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1547
1548 /* Create a dummy device */
1549 RtlZeroMemory(&Win32k, sizeof(Win32k));
1550 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1551 Win32k.DriverStart = ImageBase;
1552
1553 /* Call it */
1554 Status = (DriverInit)(&Win32k, NULL);
1555 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1556
1557 /* Unload if we failed */
1558 if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
1559 return Status;
1560 }
1561
1562 /* Class 39 - Priority Separation */
1563 SSI_DEF(SystemPrioritySeperation)
1564 {
1565 /* FIXME */
1566 DPRINT1("NtSetSystemInformation - SystemPrioritySeperation not implemented\n");
1567 return (STATUS_NOT_IMPLEMENTED);
1568 }
1569
1570 /* Class 40 - Plug Play Bus Information */
1571 QSI_DEF(SystemPlugPlayBusInformation)
1572 {
1573 /* FIXME */
1574 DPRINT1("NtQuerySystemInformation - SystemPlugPlayBusInformation not implemented\n");
1575 return (STATUS_NOT_IMPLEMENTED);
1576 }
1577
1578 /* Class 41 - Dock Information */
1579 QSI_DEF(SystemDockInformation)
1580 {
1581 /* FIXME */
1582 DPRINT1("NtQuerySystemInformation - SystemDockInformation not implemented\n");
1583 return (STATUS_NOT_IMPLEMENTED);
1584 }
1585
1586 /* Class 42 - Power Information */
1587 QSI_DEF(SystemPowerInformation)
1588 {
1589 /* FIXME */
1590 DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
1591 return (STATUS_NOT_IMPLEMENTED);
1592 }
1593
1594 /* Class 43 - Processor Speed Information */
1595 QSI_DEF(SystemProcessorSpeedInformation)
1596 {
1597 /* FIXME */
1598 DPRINT1("NtQuerySystemInformation - SystemProcessorSpeedInformation not implemented\n");
1599 return (STATUS_NOT_IMPLEMENTED);
1600 }
1601
1602 /* Class 44 - Current Time Zone Information */
1603 QSI_DEF(SystemCurrentTimeZoneInformation)
1604 {
1605 * ReqSize = sizeof (TIME_ZONE_INFORMATION);
1606
1607 if (sizeof (TIME_ZONE_INFORMATION) != Size)
1608 {
1609 return STATUS_INFO_LENGTH_MISMATCH;
1610 }
1611
1612 /* Copy the time zone information struct */
1613 memcpy(Buffer,
1614 &ExpTimeZoneInfo,
1615 sizeof(TIME_ZONE_INFORMATION));
1616
1617 return STATUS_SUCCESS;
1618 }
1619
1620
1621 SSI_DEF(SystemCurrentTimeZoneInformation)
1622 {
1623 /* Check user buffer's size */
1624 if (Size < sizeof (TIME_ZONE_INFORMATION))
1625 {
1626 return STATUS_INFO_LENGTH_MISMATCH;
1627 }
1628
1629 return ExpSetTimeZoneInformation((PTIME_ZONE_INFORMATION)Buffer);
1630 }
1631
1632
1633 /* Class 45 - Lookaside Information */
1634 QSI_DEF(SystemLookasideInformation)
1635 {
1636 /* FIXME */
1637 DPRINT1("NtQuerySystemInformation - SystemLookasideInformation not implemented\n");
1638 return (STATUS_NOT_IMPLEMENTED);
1639 }
1640
1641
1642 /* Class 46 - Set time slip event */
1643 SSI_DEF(SystemSetTimeSlipEvent)
1644 {
1645 /* FIXME */
1646 DPRINT1("NtSetSystemInformation - SystemSetTimSlipEvent not implemented\n");
1647 return (STATUS_NOT_IMPLEMENTED);
1648 }
1649
1650
1651 /* Class 47 - Create a new session (TSE) */
1652 SSI_DEF(SystemCreateSession)
1653 {
1654 /* FIXME */
1655 DPRINT1("NtSetSystemInformation - SystemCreateSession not implemented\n");
1656 return (STATUS_NOT_IMPLEMENTED);
1657 }
1658
1659
1660 /* Class 48 - Delete an existing session (TSE) */
1661 SSI_DEF(SystemDeleteSession)
1662 {
1663 /* FIXME */
1664 DPRINT1("NtSetSystemInformation - SystemDeleteSession not implemented\n");
1665 return (STATUS_NOT_IMPLEMENTED);
1666 }
1667
1668
1669 /* Class 49 - UNKNOWN */
1670 QSI_DEF(SystemInvalidInfoClass4)
1671 {
1672 /* FIXME */
1673 DPRINT1("NtQuerySystemInformation - SystemInvalidInfoClass4 not implemented\n");
1674 return (STATUS_NOT_IMPLEMENTED);
1675 }
1676
1677
1678 /* Class 50 - System range start address */
1679 QSI_DEF(SystemRangeStartInformation)
1680 {
1681 /* FIXME */
1682 DPRINT1("NtQuerySystemInformation - SystemRangeStartInformation not implemented\n");
1683 return (STATUS_NOT_IMPLEMENTED);
1684 }
1685
1686
1687 /* Class 51 - Driver verifier information */
1688 QSI_DEF(SystemVerifierInformation)
1689 {
1690 /* FIXME */
1691 DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
1692 return (STATUS_NOT_IMPLEMENTED);
1693 }
1694
1695
1696 SSI_DEF(SystemVerifierInformation)
1697 {
1698 /* FIXME */
1699 DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
1700 return (STATUS_NOT_IMPLEMENTED);
1701 }
1702
1703
1704 /* Class 52 - Add a driver verifier */
1705 SSI_DEF(SystemAddVerifier)
1706 {
1707 /* FIXME */
1708 DPRINT1("NtSetSystemInformation - SystemAddVerifier not implemented\n");
1709 return (STATUS_NOT_IMPLEMENTED);
1710 }
1711
1712
1713 /* Class 53 - A session's processes */
1714 QSI_DEF(SystemSessionProcessesInformation)
1715 {
1716 /* FIXME */
1717 DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
1718 return (STATUS_NOT_IMPLEMENTED);
1719 }
1720
1721
1722 /* Query/Set Calls Table */
1723 typedef
1724 struct _QSSI_CALLS
1725 {
1726 NTSTATUS (* Query) (PVOID,ULONG,PULONG);
1727 NTSTATUS (* Set) (PVOID,ULONG);
1728
1729 } QSSI_CALLS;
1730
1731 // QS Query & Set
1732 // QX Query
1733 // XS Set
1734 // XX unknown behaviour
1735 //
1736 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
1737 #define SI_QX(n) {QSI_USE(n),NULL}
1738 #define SI_XS(n) {NULL,SSI_USE(n)}
1739 #define SI_XX(n) {NULL,NULL}
1740
1741 static
1742 QSSI_CALLS
1743 CallQS [] =
1744 {
1745 SI_QX(SystemBasicInformation),
1746 SI_QX(SystemProcessorInformation),
1747 SI_QX(SystemPerformanceInformation),
1748 SI_QX(SystemTimeOfDayInformation),
1749 SI_QX(SystemPathInformation), /* should be SI_XX */
1750 SI_QX(SystemProcessInformation),
1751 SI_QX(SystemCallCountInformation),
1752 SI_QX(SystemDeviceInformation),
1753 SI_QX(SystemProcessorPerformanceInformation),
1754 SI_QS(SystemFlagsInformation),
1755 SI_QX(SystemCallTimeInformation), /* should be SI_XX */
1756 SI_QX(SystemModuleInformation),
1757 SI_QX(SystemLocksInformation),
1758 SI_QX(SystemStackTraceInformation), /* should be SI_XX */
1759 SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
1760 SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
1761 SI_QX(SystemHandleInformation),
1762 SI_QX(SystemObjectInformation),
1763 SI_QX(SystemPageFileInformation),
1764 SI_QX(SystemVdmInstemulInformation),
1765 SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
1766 SI_QS(SystemFileCacheInformation),
1767 SI_QX(SystemPoolTagInformation),
1768 SI_QX(SystemInterruptInformation),
1769 SI_QS(SystemDpcBehaviourInformation),
1770 SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
1771 SI_XS(SystemLoadGdiDriverInformation),
1772 SI_XS(SystemUnloadGdiDriverInformation),
1773 SI_QS(SystemTimeAdjustmentInformation),
1774 SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
1775 SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
1776 SI_QX(SystemEventIdsInformation), /* it should be SI_XX */
1777 SI_QX(SystemCrashDumpInformation),
1778 SI_QX(SystemExceptionInformation),
1779 SI_QX(SystemCrashDumpStateInformation),
1780 SI_QX(SystemKernelDebuggerInformation),
1781 SI_QX(SystemContextSwitchInformation),
1782 SI_QS(SystemRegistryQuotaInformation),
1783 SI_XS(SystemExtendServiceTableInformation),
1784 SI_XS(SystemPrioritySeperation),
1785 SI_QX(SystemPlugPlayBusInformation), /* it should be SI_XX */
1786 SI_QX(SystemDockInformation), /* it should be SI_XX */
1787 SI_QX(SystemPowerInformation), /* it should be SI_XX */
1788 SI_QX(SystemProcessorSpeedInformation), /* it should be SI_XX */
1789 SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
1790 SI_QX(SystemLookasideInformation),
1791 SI_XS(SystemSetTimeSlipEvent),
1792 SI_XS(SystemCreateSession),
1793 SI_XS(SystemDeleteSession),
1794 SI_QX(SystemInvalidInfoClass4), /* it should be SI_XX */
1795 SI_QX(SystemRangeStartInformation),
1796 SI_QS(SystemVerifierInformation),
1797 SI_XS(SystemAddVerifier),
1798 SI_QX(SystemSessionProcessesInformation)
1799 };
1800
1801 C_ASSERT(SystemBasicInformation == 0);
1802 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
1803 #define MAX_SYSTEM_INFO_CLASS (sizeof(CallQS) / sizeof(CallQS[0]))
1804
1805 /*
1806 * @implemented
1807 */
1808 NTSTATUS NTAPI
1809 NtQuerySystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
1810 OUT PVOID SystemInformation,
1811 IN ULONG Length,
1812 OUT PULONG UnsafeResultLength)
1813 {
1814 KPROCESSOR_MODE PreviousMode;
1815 ULONG ResultLength;
1816 NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;
1817
1818 PAGED_CODE();
1819
1820 PreviousMode = ExGetPreviousMode();
1821
1822 _SEH2_TRY
1823 {
1824 if (PreviousMode != KernelMode)
1825 {
1826 /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
1827 ProbeForWrite(SystemInformation, Length, 1);
1828 if (UnsafeResultLength != NULL)
1829 ProbeForWriteUlong(UnsafeResultLength);
1830 }
1831
1832 /*
1833 * Check the request is valid.
1834 */
1835 if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
1836 {
1837 _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
1838 }
1839
1840 if (NULL != CallQS [SystemInformationClass].Query)
1841 {
1842 /*
1843 * Hand the request to a subhandler.
1844 */
1845 FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
1846 Length,
1847 &ResultLength);
1848 if (UnsafeResultLength != NULL)
1849 {
1850 if (PreviousMode != KernelMode)
1851 {
1852 *UnsafeResultLength = ResultLength;
1853 }
1854 else
1855 {
1856 *UnsafeResultLength = ResultLength;
1857 }
1858 }
1859 }
1860 }
1861 _SEH2_EXCEPT(ExSystemExceptionFilter())
1862 {
1863 FStatus = _SEH2_GetExceptionCode();
1864 }
1865 _SEH2_END;
1866
1867 return (FStatus);
1868 }
1869
1870
1871 NTSTATUS
1872 NTAPI
1873 NtSetSystemInformation (
1874 IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
1875 IN PVOID SystemInformation,
1876 IN ULONG SystemInformationLength
1877 )
1878 {
1879 PAGED_CODE();
1880
1881 /*
1882 * If called from user mode, check
1883 * possible unsafe arguments.
1884 */
1885 #if 0
1886 if (KernelMode != KeGetPreviousMode())
1887 {
1888 // Check arguments
1889 //ProbeForWrite(
1890 // SystemInformation,
1891 // Length
1892 // );
1893 //ProbeForWrite(
1894 // ResultLength,
1895 // sizeof (ULONG)
1896 // );
1897 }
1898 #endif
1899 /*
1900 * Check the request is valid.
1901 */
1902 if ( (SystemInformationClass >= MIN_SYSTEM_INFO_CLASS)
1903 && (SystemInformationClass < MAX_SYSTEM_INFO_CLASS)
1904 )
1905 {
1906 if (NULL != CallQS [SystemInformationClass].Set)
1907 {
1908 /*
1909 * Hand the request to a subhandler.
1910 */
1911 return CallQS [SystemInformationClass].Set (
1912 SystemInformation,
1913 SystemInformationLength
1914 );
1915 }
1916 }
1917 return (STATUS_INVALID_INFO_CLASS);
1918 }
1919
1920
1921 NTSTATUS
1922 NTAPI
1923 NtFlushInstructionCache (
1924 IN HANDLE ProcessHandle,
1925 IN PVOID BaseAddress,
1926 IN ULONG NumberOfBytesToFlush
1927 )
1928 {
1929 PAGED_CODE();
1930
1931 #if defined(_M_IX86)
1932 __wbinvd();
1933 #elif defined(_M_PPC)
1934 __asm__ __volatile__("tlbsync");
1935 #elif defined(_M_MIPS)
1936 DPRINT1("NtFlushInstructionCache() is not implemented\n");
1937 for (;;);
1938 #elif defined(_M_ARM)
1939 __asm__ __volatile__("mov r1, #0; mcr p15, 0, r1, c7, c5, 0");
1940 #elif defined(_M_AMD64)
1941 DPRINT1("NtFlushInstructionCache() is not implemented\n");
1942 for (;;);
1943 #else
1944 #error Unknown architecture
1945 #endif
1946 return STATUS_SUCCESS;
1947 }
1948
1949 ULONG
1950 NTAPI
1951 NtGetCurrentProcessorNumber(VOID)
1952 {
1953 /* Just return the CPU */
1954 return KeGetCurrentProcessorNumber();
1955 }
1956
1957 /* EOF */