66975c0e8c3aa98672acf707d24b2b49f3da3412
[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 NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
1084 return STATUS_SUCCESS;
1085 }
1086
1087 /* Class 10 - Call Time Information */
1088 QSI_DEF(SystemCallTimeInformation)
1089 {
1090 /* FIXME */
1091 DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
1092 return STATUS_NOT_IMPLEMENTED;
1093 }
1094
1095 /* Class 11 - Module Information */
1096 QSI_DEF(SystemModuleInformation)
1097 {
1098 NTSTATUS Status;
1099
1100 /* Acquire system module list lock */
1101 KeEnterCriticalRegion();
1102 ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE);
1103
1104 /* Call the generic handler with the system module list */
1105 Status = ExpQueryModuleInformation(&PsLoadedModuleList,
1106 &MmLoadedUserImageList,
1107 (PRTL_PROCESS_MODULES)Buffer,
1108 Size,
1109 ReqSize);
1110
1111 /* Release list lock and return status */
1112 ExReleaseResourceLite(&PsLoadedModuleResource);
1113 KeLeaveCriticalRegion();
1114 return Status;
1115 }
1116
1117 /* Class 12 - Locks Information */
1118 QSI_DEF(SystemLocksInformation)
1119 {
1120 /* FIXME */
1121 DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
1122 return STATUS_NOT_IMPLEMENTED;
1123 }
1124
1125 /* Class 13 - Stack Trace Information */
1126 QSI_DEF(SystemStackTraceInformation)
1127 {
1128 /* FIXME */
1129 DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
1130 return STATUS_NOT_IMPLEMENTED;
1131 }
1132
1133 /* Class 14 - Paged Pool Information */
1134 QSI_DEF(SystemPagedPoolInformation)
1135 {
1136 /* FIXME */
1137 DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
1138 return STATUS_NOT_IMPLEMENTED;
1139 }
1140
1141 /* Class 15 - Non Paged Pool Information */
1142 QSI_DEF(SystemNonPagedPoolInformation)
1143 {
1144 /* FIXME */
1145 DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
1146 return STATUS_NOT_IMPLEMENTED;
1147 }
1148
1149
1150 /* Class 16 - Handle Information */
1151 QSI_DEF(SystemHandleInformation)
1152 {
1153 PEPROCESS pr, syspr;
1154 ULONG curSize, i = 0;
1155 ULONG hCount = 0;
1156
1157 PSYSTEM_HANDLE_INFORMATION Shi =
1158 (PSYSTEM_HANDLE_INFORMATION) Buffer;
1159
1160 DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
1161
1162 if (Size < sizeof(SYSTEM_HANDLE_INFORMATION))
1163 {
1164 *ReqSize = sizeof(SYSTEM_HANDLE_INFORMATION);
1165 return STATUS_INFO_LENGTH_MISMATCH;
1166 }
1167
1168 DPRINT("SystemHandleInformation 1\n");
1169
1170 /* First Calc Size from Count. */
1171 syspr = PsGetNextProcess(NULL);
1172 pr = syspr;
1173
1174 do
1175 {
1176 hCount = hCount + ObGetProcessHandleCount(pr);
1177 pr = PsGetNextProcess(pr);
1178
1179 if ((pr == syspr) || (pr == NULL)) break;
1180 }
1181 while ((pr != syspr) && (pr != NULL));
1182
1183 if(pr != NULL)
1184 {
1185 ObDereferenceObject(pr);
1186 }
1187
1188 DPRINT("SystemHandleInformation 2\n");
1189
1190 curSize = sizeof(SYSTEM_HANDLE_INFORMATION) +
1191 ((sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) * hCount) -
1192 (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO)));
1193
1194 Shi->NumberOfHandles = hCount;
1195
1196 if (curSize > Size)
1197 {
1198 *ReqSize = curSize;
1199 return (STATUS_INFO_LENGTH_MISMATCH);
1200 }
1201
1202 DPRINT("SystemHandleInformation 3\n");
1203
1204 /* Now get Handles from all processes. */
1205 syspr = PsGetNextProcess(NULL);
1206 pr = syspr;
1207
1208 do
1209 {
1210 int Count = 0, HandleCount;
1211
1212 HandleCount = ObGetProcessHandleCount(pr);
1213
1214 for (Count = 0; HandleCount > 0 ; HandleCount--)
1215 {
1216 Shi->Handles[i].UniqueProcessId = (USHORT)(ULONG_PTR)pr->UniqueProcessId;
1217 Count++;
1218 i++;
1219 }
1220
1221 pr = PsGetNextProcess(pr);
1222
1223 if ((pr == syspr) || (pr == NULL)) break;
1224 }
1225 while ((pr != syspr) && (pr != NULL));
1226
1227 if(pr != NULL) ObDereferenceObject(pr);
1228
1229 DPRINT("SystemHandleInformation 4\n");
1230 return STATUS_SUCCESS;
1231
1232 }
1233 /*
1234 SSI_DEF(SystemHandleInformation)
1235 {
1236
1237 return STATUS_SUCCESS;
1238 }
1239 */
1240
1241 /* Class 17 - Information */
1242 QSI_DEF(SystemObjectInformation)
1243 {
1244 /* FIXME */
1245 DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
1246 return STATUS_NOT_IMPLEMENTED;
1247 }
1248
1249 /* Class 18 - Information */
1250 QSI_DEF(SystemPageFileInformation)
1251 {
1252 UNICODE_STRING FileName; /* FIXME */
1253 SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
1254
1255 if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
1256 {
1257 * ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
1258 return STATUS_INFO_LENGTH_MISMATCH;
1259 }
1260
1261 RtlInitUnicodeString(&FileName, NULL); /* FIXME */
1262
1263 /* FIXME */
1264 Spfi->NextEntryOffset = 0;
1265
1266 Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
1267 Spfi->TotalInUse = MiUsedSwapPages;
1268 Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
1269 Spfi->PageFileName = FileName;
1270 return STATUS_SUCCESS;
1271 }
1272
1273 /* Class 19 - Vdm Instemul Information */
1274 QSI_DEF(SystemVdmInstemulInformation)
1275 {
1276 /* FIXME */
1277 DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
1278 return STATUS_NOT_IMPLEMENTED;
1279 }
1280
1281 /* Class 20 - Vdm Bop Information */
1282 QSI_DEF(SystemVdmBopInformation)
1283 {
1284 /* FIXME */
1285 DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
1286 return STATUS_NOT_IMPLEMENTED;
1287 }
1288
1289 /* Class 21 - File Cache Information */
1290 QSI_DEF(SystemFileCacheInformation)
1291 {
1292 SYSTEM_FILECACHE_INFORMATION *Sci = (SYSTEM_FILECACHE_INFORMATION *) Buffer;
1293
1294 *ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
1295
1296 if (Size < *ReqSize)
1297 {
1298 return STATUS_INFO_LENGTH_MISMATCH;
1299 }
1300
1301 RtlZeroMemory(Sci, sizeof(SYSTEM_FILECACHE_INFORMATION));
1302
1303 /* Return the Byte size not the page size. */
1304 Sci->CurrentSize =
1305 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
1306 Sci->PeakSize =
1307 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
1308 /* Taskmgr multiplies this one by page size right away */
1309 Sci->CurrentSizeIncludingTransitionInPages =
1310 MiMemoryConsumers[MC_CACHE].PagesUsed; /* FIXME: Should be */
1311 /* system working set and standby pages. */
1312 Sci->PageFaultCount = 0; /* FIXME */
1313 Sci->MinimumWorkingSet = 0; /* FIXME */
1314 Sci->MaximumWorkingSet = 0; /* FIXME */
1315
1316 return STATUS_SUCCESS;
1317 }
1318
1319 SSI_DEF(SystemFileCacheInformation)
1320 {
1321 if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
1322 {
1323 return STATUS_INFO_LENGTH_MISMATCH;
1324 }
1325 /* FIXME */
1326 DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1327 return STATUS_NOT_IMPLEMENTED;
1328 }
1329
1330 /* Class 22 - Pool Tag Information */
1331 QSI_DEF(SystemPoolTagInformation)
1332 {
1333 if (Size < sizeof(SYSTEM_POOLTAG_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
1334 return ExGetPoolTagInfo(Buffer, Size, ReqSize);
1335 }
1336
1337 /* Class 23 - Interrupt Information for all processors */
1338 QSI_DEF(SystemInterruptInformation)
1339 {
1340 PKPRCB Prcb;
1341 LONG i;
1342 ULONG ti;
1343 PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1344
1345 if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1346 {
1347 return STATUS_INFO_LENGTH_MISMATCH;
1348 }
1349
1350 ti = KeQueryTimeIncrement();
1351
1352 for (i = 0; i < KeNumberProcessors; i++)
1353 {
1354 Prcb = KiProcessorBlock[i];
1355 sii->ContextSwitches = KeGetContextSwitches(Prcb);
1356 sii->DpcCount = Prcb->DpcData[0].DpcCount;
1357 sii->DpcRate = Prcb->DpcRequestRate;
1358 sii->TimeIncrement = ti;
1359 sii->DpcBypassCount = 0;
1360 sii->ApcBypassCount = 0;
1361 sii++;
1362 }
1363
1364 return STATUS_SUCCESS;
1365 }
1366
1367 /* Class 24 - DPC Behaviour Information */
1368 QSI_DEF(SystemDpcBehaviourInformation)
1369 {
1370 /* FIXME */
1371 DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1372 return STATUS_NOT_IMPLEMENTED;
1373 }
1374
1375 SSI_DEF(SystemDpcBehaviourInformation)
1376 {
1377 /* FIXME */
1378 DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1379 return STATUS_NOT_IMPLEMENTED;
1380 }
1381
1382 /* Class 25 - Full Memory Information */
1383 QSI_DEF(SystemFullMemoryInformation)
1384 {
1385 PULONG Spi = (PULONG) Buffer;
1386
1387 PEPROCESS TheIdleProcess;
1388
1389 *ReqSize = sizeof(ULONG);
1390
1391 if (sizeof(ULONG) != Size)
1392 {
1393 return STATUS_INFO_LENGTH_MISMATCH;
1394 }
1395
1396 DPRINT("SystemFullMemoryInformation\n");
1397
1398 TheIdleProcess = PsIdleProcess;
1399
1400 DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
1401 TheIdleProcess->UniqueProcessId,
1402 TheIdleProcess->Pcb.KernelTime,
1403 MiFreeSwapPages,
1404 MiUsedSwapPages);
1405
1406 *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1407
1408 return STATUS_SUCCESS;
1409 }
1410
1411 /* Class 26 - Load Image */
1412 SSI_DEF(SystemLoadGdiDriverInformation)
1413 {
1414 PSYSTEM_GDI_DRIVER_INFORMATION DriverInfo = (PVOID)Buffer;
1415 UNICODE_STRING ImageName;
1416 PVOID ImageBase;
1417 PVOID SectionPointer;
1418 ULONG_PTR EntryPoint;
1419 NTSTATUS Status;
1420 ULONG DirSize;
1421 PIMAGE_NT_HEADERS NtHeader;
1422
1423 /* Validate size */
1424 if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
1425 {
1426 /* Incorrect buffer length, fail */
1427 return STATUS_INFO_LENGTH_MISMATCH;
1428 }
1429
1430 /* Only kernel mode can call this function */
1431 if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1432
1433 /* Load the driver */
1434 ImageName = DriverInfo->DriverName;
1435 Status = MmLoadSystemImage(&ImageName,
1436 NULL,
1437 NULL,
1438 0,
1439 &SectionPointer,
1440 &ImageBase);
1441 if (!NT_SUCCESS(Status)) return Status;
1442
1443 /* Return the export pointer */
1444 DriverInfo->ExportSectionPointer =
1445 RtlImageDirectoryEntryToData(ImageBase,
1446 TRUE,
1447 IMAGE_DIRECTORY_ENTRY_EXPORT,
1448 &DirSize);
1449
1450 /* Get the entrypoint */
1451 NtHeader = RtlImageNtHeader(ImageBase);
1452 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1453 EntryPoint += (ULONG_PTR)ImageBase;
1454
1455 /* Save other data */
1456 DriverInfo->ImageAddress = ImageBase;
1457 DriverInfo->SectionPointer = SectionPointer;
1458 DriverInfo->EntryPoint = (PVOID)EntryPoint;
1459 DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
1460
1461 /* All is good */
1462 return STATUS_SUCCESS;
1463 }
1464
1465 /* Class 27 - Unload Image */
1466 SSI_DEF(SystemUnloadGdiDriverInformation)
1467 {
1468 PVOID *SectionPointer = Buffer;
1469
1470 /* Validate size */
1471 if (Size != sizeof(PVOID))
1472 {
1473 /* Incorrect length, fail */
1474 return STATUS_INFO_LENGTH_MISMATCH;
1475 }
1476
1477 /* Only kernel mode can call this function */
1478 if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
1479
1480 /* Unload the image */
1481 MmUnloadSystemImage(*SectionPointer);
1482 return STATUS_SUCCESS;
1483 }
1484
1485 /* Class 28 - Time Adjustment Information */
1486 QSI_DEF(SystemTimeAdjustmentInformation)
1487 {
1488 PSYSTEM_QUERY_TIME_ADJUST_INFORMATION TimeInfo =
1489 (PSYSTEM_QUERY_TIME_ADJUST_INFORMATION)Buffer;
1490
1491 /* Check if enough storage was provided */
1492 if (sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION) > Size)
1493 {
1494 * ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
1495 return STATUS_INFO_LENGTH_MISMATCH;
1496 }
1497
1498 /* Give time values to our caller */
1499 TimeInfo->TimeIncrement = KeMaximumIncrement;
1500 TimeInfo->TimeAdjustment = KeTimeAdjustment;
1501 TimeInfo->Enable = !KiTimeAdjustmentEnabled;
1502
1503 return STATUS_SUCCESS;
1504 }
1505
1506 SSI_DEF(SystemTimeAdjustmentInformation)
1507 {
1508 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1509 PSYSTEM_SET_TIME_ADJUST_INFORMATION TimeInfo =
1510 (PSYSTEM_SET_TIME_ADJUST_INFORMATION)Buffer;
1511
1512 /* Check size of a buffer, it must match our expectations */
1513 if (sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION) != Size)
1514 return STATUS_INFO_LENGTH_MISMATCH;
1515
1516 /* Check who is calling */
1517 if (PreviousMode != KernelMode)
1518 {
1519 /* Check access rights */
1520 if (!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
1521 {
1522 return STATUS_PRIVILEGE_NOT_HELD;
1523 }
1524 }
1525
1526 /* FIXME: behaviour suggests the member be named 'Disable' */
1527 if (TimeInfo->Enable)
1528 {
1529 /* Disable time adjustment and set default value */
1530 KiTimeAdjustmentEnabled = FALSE;
1531 KeTimeAdjustment = KeMaximumIncrement;
1532 }
1533 else
1534 {
1535 /* Check if a valid time adjustment value is given */
1536 if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
1537
1538 /* Enable time adjustment and set the adjustment value */
1539 KiTimeAdjustmentEnabled = TRUE;
1540 KeTimeAdjustment = TimeInfo->TimeAdjustment;
1541 }
1542
1543 return STATUS_SUCCESS;
1544 }
1545
1546 /* Class 29 - Summary Memory Information */
1547 QSI_DEF(SystemSummaryMemoryInformation)
1548 {
1549 /* FIXME */
1550 DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1551 return STATUS_NOT_IMPLEMENTED;
1552 }
1553
1554 /* Class 30 - Next Event Id Information */
1555 QSI_DEF(SystemNextEventIdInformation)
1556 {
1557 /* FIXME */
1558 DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1559 return STATUS_NOT_IMPLEMENTED;
1560 }
1561
1562 /* Class 31 - Event Ids Information */
1563 QSI_DEF(SystemEventIdsInformation)
1564 {
1565 /* FIXME */
1566 DPRINT1("NtQuerySystemInformation - SystemEventIdsInformation not implemented\n");
1567 return STATUS_NOT_IMPLEMENTED;
1568 }
1569
1570 /* Class 32 - Crash Dump Information */
1571 QSI_DEF(SystemCrashDumpInformation)
1572 {
1573 /* FIXME */
1574 DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1575 return STATUS_NOT_IMPLEMENTED;
1576 }
1577
1578 /* Class 33 - Exception Information */
1579 QSI_DEF(SystemExceptionInformation)
1580 {
1581 PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
1582 (PSYSTEM_EXCEPTION_INFORMATION)Buffer;
1583 PKPRCB Prcb;
1584 ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
1585 ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
1586 CHAR i;
1587
1588 /* Check size of a buffer, it must match our expectations */
1589 if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
1590 return STATUS_INFO_LENGTH_MISMATCH;
1591
1592 /* Sum up exception count information from all processors */
1593 for (i = 0; i < KeNumberProcessors; i++)
1594 {
1595 Prcb = KiProcessorBlock[i];
1596 if (Prcb)
1597 {
1598 AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
1599 ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
1600 #ifndef _M_ARM
1601 FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
1602 #endif // _M_ARM
1603 }
1604 }
1605
1606 /* Save information in user's buffer */
1607 ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
1608 ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
1609 ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
1610 ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
1611
1612 return STATUS_SUCCESS;
1613 }
1614
1615 /* Class 34 - Crash Dump State Information */
1616 QSI_DEF(SystemCrashDumpStateInformation)
1617 {
1618 /* FIXME */
1619 DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1620 return STATUS_NOT_IMPLEMENTED;
1621 }
1622
1623 /* Class 35 - Kernel Debugger Information */
1624 QSI_DEF(SystemKernelDebuggerInformation)
1625 {
1626 PSYSTEM_KERNEL_DEBUGGER_INFORMATION skdi = (PSYSTEM_KERNEL_DEBUGGER_INFORMATION) Buffer;
1627
1628 *ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
1629 if (Size < sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION))
1630 {
1631 return STATUS_INFO_LENGTH_MISMATCH;
1632 }
1633
1634 skdi->KernelDebuggerEnabled = KD_DEBUGGER_ENABLED;
1635 skdi->KernelDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
1636
1637 return STATUS_SUCCESS;
1638 }
1639
1640 /* Class 36 - Context Switch Information */
1641 QSI_DEF(SystemContextSwitchInformation)
1642 {
1643 PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
1644 (PSYSTEM_CONTEXT_SWITCH_INFORMATION)Buffer;
1645 ULONG ContextSwitches;
1646 PKPRCB Prcb;
1647 CHAR i;
1648
1649 /* Check size of a buffer, it must match our expectations */
1650 if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
1651 return STATUS_INFO_LENGTH_MISMATCH;
1652
1653 /* Calculate total value of context switches across all processors */
1654 ContextSwitches = 0;
1655 for (i = 0; i < KeNumberProcessors; i ++)
1656 {
1657 Prcb = KiProcessorBlock[i];
1658 if (Prcb)
1659 {
1660 ContextSwitches += KeGetContextSwitches(Prcb);
1661 }
1662 }
1663
1664 ContextSwitchInformation->ContextSwitches = ContextSwitches;
1665
1666 /* FIXME */
1667 ContextSwitchInformation->FindAny = 0;
1668 ContextSwitchInformation->FindLast = 0;
1669 ContextSwitchInformation->FindIdeal = 0;
1670 ContextSwitchInformation->IdleAny = 0;
1671 ContextSwitchInformation->IdleCurrent = 0;
1672 ContextSwitchInformation->IdleLast = 0;
1673 ContextSwitchInformation->IdleIdeal = 0;
1674 ContextSwitchInformation->PreemptAny = 0;
1675 ContextSwitchInformation->PreemptCurrent = 0;
1676 ContextSwitchInformation->PreemptLast = 0;
1677 ContextSwitchInformation->SwitchToIdle = 0;
1678
1679 return STATUS_SUCCESS;
1680 }
1681
1682 /* Class 37 - Registry Quota Information */
1683 QSI_DEF(SystemRegistryQuotaInformation)
1684 {
1685 PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1686
1687 *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1688 if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1689 {
1690 return STATUS_INFO_LENGTH_MISMATCH;
1691 }
1692
1693 DPRINT1("Faking max registry size of 32 MB\n");
1694 srqi->RegistryQuotaAllowed = 0x2000000;
1695 srqi->RegistryQuotaUsed = 0x200000;
1696 srqi->PagedPoolSize = 0x200000;
1697
1698 return STATUS_SUCCESS;
1699 }
1700
1701 SSI_DEF(SystemRegistryQuotaInformation)
1702 {
1703 /* FIXME */
1704 DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1705 return STATUS_NOT_IMPLEMENTED;
1706 }
1707
1708 /* Class 38 - Load And Call Image */
1709 SSI_DEF(SystemExtendServiceTableInformation)
1710 {
1711 UNICODE_STRING ImageName;
1712 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
1713 PLDR_DATA_TABLE_ENTRY ModuleObject;
1714 NTSTATUS Status;
1715 PIMAGE_NT_HEADERS NtHeader;
1716 DRIVER_OBJECT Win32k;
1717 PDRIVER_INITIALIZE DriverInit;
1718 PVOID ImageBase;
1719 ULONG_PTR EntryPoint;
1720
1721 /* Validate the size */
1722 if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
1723
1724 /* Check who is calling */
1725 if (PreviousMode != KernelMode)
1726 {
1727 static const UNICODE_STRING Win32kName =
1728 RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
1729
1730 /* Make sure we can load drivers */
1731 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, UserMode))
1732 {
1733 /* FIXME: We can't, fail */
1734 return STATUS_PRIVILEGE_NOT_HELD;
1735 }
1736
1737 _SEH2_TRY
1738 {
1739 /* Probe and copy the unicode string */
1740 ProbeForRead(Buffer, sizeof(ImageName), 1);
1741 ImageName = *(PUNICODE_STRING)Buffer;
1742
1743 /* Probe the string buffer */
1744 ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
1745
1746 /* Check if we have the correct name (nothing else is allowed!) */
1747 if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
1748 {
1749 _SEH2_YIELD(return STATUS_PRIVILEGE_NOT_HELD);
1750 }
1751 }
1752 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1753 {
1754 _SEH2_YIELD(return _SEH2_GetExceptionCode());
1755 }
1756 _SEH2_END;
1757
1758 /* Recursively call the function, so that we are from kernel mode */
1759 return ZwSetSystemInformation(SystemExtendServiceTableInformation,
1760 (PVOID)&Win32kName,
1761 sizeof(Win32kName));
1762 }
1763
1764 /* Load the image */
1765 Status = MmLoadSystemImage((PUNICODE_STRING)Buffer,
1766 NULL,
1767 NULL,
1768 0,
1769 (PVOID)&ModuleObject,
1770 &ImageBase);
1771
1772 if (!NT_SUCCESS(Status)) return Status;
1773
1774 /* Get the headers */
1775 NtHeader = RtlImageNtHeader(ImageBase);
1776 if (!NtHeader)
1777 {
1778 /* Fail */
1779 MmUnloadSystemImage(ModuleObject);
1780 return STATUS_INVALID_IMAGE_FORMAT;
1781 }
1782
1783 /* Get the entrypoint */
1784 EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
1785 EntryPoint += (ULONG_PTR)ImageBase;
1786 DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
1787
1788 /* Create a dummy device */
1789 RtlZeroMemory(&Win32k, sizeof(Win32k));
1790 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1791 Win32k.DriverStart = ImageBase;
1792
1793 /* Call it */
1794 Status = (DriverInit)(&Win32k, NULL);
1795 ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
1796
1797 /* Unload if we failed */
1798 if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
1799 return Status;
1800 }
1801
1802 /* Class 39 - Priority Separation */
1803 SSI_DEF(SystemPrioritySeperation)
1804 {
1805 /* Check if the size is correct */
1806 if (Size != sizeof(ULONG))
1807 {
1808 return STATUS_INFO_LENGTH_MISMATCH;
1809 }
1810
1811 /* We need the TCB privilege */
1812 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, ExGetPreviousMode()))
1813 {
1814 return STATUS_PRIVILEGE_NOT_HELD;
1815 }
1816
1817 /* Modify the quantum table */
1818 PsChangeQuantumTable(TRUE, *(PULONG)Buffer);
1819
1820 return STATUS_SUCCESS;
1821 }
1822
1823 /* Class 40 - Plug Play Bus Information */
1824 QSI_DEF(SystemPlugPlayBusInformation)
1825 {
1826 /* FIXME */
1827 DPRINT1("NtQuerySystemInformation - SystemPlugPlayBusInformation not implemented\n");
1828 return STATUS_NOT_IMPLEMENTED;
1829 }
1830
1831 /* Class 41 - Dock Information */
1832 QSI_DEF(SystemDockInformation)
1833 {
1834 /* FIXME */
1835 DPRINT1("NtQuerySystemInformation - SystemDockInformation not implemented\n");
1836 return STATUS_NOT_IMPLEMENTED;
1837 }
1838
1839 /* Class 42 - Power Information */
1840 QSI_DEF(SystemPowerInformation)
1841 {
1842 *ReqSize = sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors;
1843
1844 if (sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors > Size)
1845 {
1846 return STATUS_INFO_LENGTH_MISMATCH;
1847 }
1848
1849 /* FIXME */
1850 DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
1851 return STATUS_NOT_IMPLEMENTED;
1852 }
1853
1854 /* Class 43 - Processor Speed Information */
1855 QSI_DEF(SystemProcessorSpeedInformation)
1856 {
1857 /* FIXME */
1858 DPRINT1("NtQuerySystemInformation - SystemProcessorSpeedInformation not implemented\n");
1859 return STATUS_NOT_IMPLEMENTED;
1860 }
1861
1862 /* Class 44 - Current Time Zone Information */
1863 QSI_DEF(SystemCurrentTimeZoneInformation)
1864 {
1865 *ReqSize = sizeof(TIME_ZONE_INFORMATION);
1866
1867 if (sizeof(TIME_ZONE_INFORMATION) != Size)
1868 {
1869 return STATUS_INFO_LENGTH_MISMATCH;
1870 }
1871
1872 /* Copy the time zone information struct */
1873 memcpy(Buffer,
1874 &ExpTimeZoneInfo,
1875 sizeof(TIME_ZONE_INFORMATION));
1876
1877 return STATUS_SUCCESS;
1878 }
1879
1880
1881 SSI_DEF(SystemCurrentTimeZoneInformation)
1882 {
1883 /* Check user buffer's size */
1884 if (Size < sizeof(TIME_ZONE_INFORMATION))
1885 {
1886 return STATUS_INFO_LENGTH_MISMATCH;
1887 }
1888
1889 return ExpSetTimeZoneInformation((PTIME_ZONE_INFORMATION)Buffer);
1890 }
1891
1892 static
1893 VOID
1894 ExpCopyLookasideInformation(
1895 PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
1896 PULONG RemainingPointer,
1897 PLIST_ENTRY ListHead,
1898 BOOLEAN ListUsesMisses)
1899
1900 {
1901 PSYSTEM_LOOKASIDE_INFORMATION Info;
1902 PGENERAL_LOOKASIDE LookasideList;
1903 PLIST_ENTRY ListEntry;
1904 ULONG Remaining;
1905
1906 /* Get info pointer and remaining count of free array element */
1907 Info = *InfoPointer;
1908 Remaining = *RemainingPointer;
1909
1910 /* Loop as long as we have lookaside lists and free array elements */
1911 for (ListEntry = ListHead->Flink;
1912 (ListEntry != ListHead) && (Remaining > 0);
1913 ListEntry = ListEntry->Flink, Remaining--)
1914 {
1915 LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
1916
1917 /* Fill the next array element */
1918 Info->CurrentDepth = LookasideList->Depth;
1919 Info->MaximumDepth = LookasideList->MaximumDepth;
1920 Info->TotalAllocates = LookasideList->TotalAllocates;
1921 Info->TotalFrees = LookasideList->TotalFrees;
1922 Info->Type = LookasideList->Type;
1923 Info->Tag = LookasideList->Tag;
1924 Info->Size = LookasideList->Size;
1925
1926 /* Check how the lists track misses/hits */
1927 if (ListUsesMisses)
1928 {
1929 /* Copy misses */
1930 Info->AllocateMisses = LookasideList->AllocateMisses;
1931 Info->FreeMisses = LookasideList->FreeMisses;
1932 }
1933 else
1934 {
1935 /* Calculate misses */
1936 Info->AllocateMisses = LookasideList->TotalAllocates
1937 - LookasideList->AllocateHits;
1938 Info->FreeMisses = LookasideList->TotalFrees
1939 - LookasideList->FreeHits;
1940 }
1941 }
1942
1943 /* Return the updated pointer and remaining count */
1944 *InfoPointer = Info;
1945 *RemainingPointer = Remaining;
1946 }
1947
1948 /* Class 45 - Lookaside Information */
1949 QSI_DEF(SystemLookasideInformation)
1950 {
1951 KPROCESSOR_MODE PreviousMode;
1952 PSYSTEM_LOOKASIDE_INFORMATION Info;
1953 PMDL Mdl;
1954 ULONG MaxCount, Remaining;
1955 KIRQL OldIrql;
1956 NTSTATUS Status;
1957
1958 /* First we need to lock down the memory, since we are going to access it
1959 at high IRQL */
1960 PreviousMode = ExGetPreviousMode();
1961 Status = ExLockUserBuffer(Buffer,
1962 Size,
1963 PreviousMode,
1964 IoWriteAccess,
1965 (PVOID*)&Info,
1966 &Mdl);
1967 if (!NT_SUCCESS(Status))
1968 {
1969 DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
1970 return Status;
1971 }
1972
1973 /* Calculate how many items we can store */
1974 Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
1975 if (Remaining == 0)
1976 {
1977 goto Leave;
1978 }
1979
1980 /* Copy info from pool lookaside lists */
1981 ExpCopyLookasideInformation(&Info,
1982 &Remaining,
1983 &ExPoolLookasideListHead,
1984 FALSE);
1985 if (Remaining == 0)
1986 {
1987 goto Leave;
1988 }
1989
1990 /* Copy info from system lookaside lists */
1991 ExpCopyLookasideInformation(&Info,
1992 &Remaining,
1993 &ExSystemLookasideListHead,
1994 TRUE);
1995 if (Remaining == 0)
1996 {
1997 goto Leave;
1998 }
1999
2000 /* Acquire spinlock for ExpNonPagedLookasideListHead */
2001 KeAcquireSpinLock(&ExpNonPagedLookasideListLock, &OldIrql);
2002
2003 /* Copy info from non-paged lookaside lists */
2004 ExpCopyLookasideInformation(&Info,
2005 &Remaining,
2006 &ExpNonPagedLookasideListHead,
2007 TRUE);
2008
2009 /* Release spinlock for ExpNonPagedLookasideListHead */
2010 KeReleaseSpinLock(&ExpNonPagedLookasideListLock, OldIrql);
2011
2012 if (Remaining == 0)
2013 {
2014 goto Leave;
2015 }
2016
2017 /* Acquire spinlock for ExpPagedLookasideListHead */
2018 KeAcquireSpinLock(&ExpPagedLookasideListLock, &OldIrql);
2019
2020 /* Copy info from paged lookaside lists */
2021 ExpCopyLookasideInformation(&Info,
2022 &Remaining,
2023 &ExpPagedLookasideListHead,
2024 TRUE);
2025
2026 /* Release spinlock for ExpPagedLookasideListHead */
2027 KeReleaseSpinLock(&ExpPagedLookasideListLock, OldIrql);
2028
2029 Leave:
2030
2031 /* Release the locked user buffer */
2032 ExUnlockUserBuffer(Mdl);
2033
2034 /* Return the size of the actually written data */
2035 *ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
2036 return STATUS_SUCCESS;
2037 }
2038
2039
2040 /* Class 46 - Set time slip event */
2041 SSI_DEF(SystemSetTimeSlipEvent)
2042 {
2043 /* FIXME */
2044 DPRINT1("NtSetSystemInformation - SystemSetTimSlipEvent not implemented\n");
2045 return STATUS_NOT_IMPLEMENTED;
2046 }
2047
2048 NTSTATUS
2049 NTAPI
2050 MmSessionCreate(OUT PULONG SessionId);
2051
2052 NTSTATUS
2053 NTAPI
2054 MmSessionDelete(IN ULONG SessionId);
2055
2056 /* Class 47 - Create a new session (TSE) */
2057 SSI_DEF(SystemCreateSession)
2058 {
2059 ULONG SessionId;
2060 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2061 NTSTATUS Status;
2062
2063 if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2064
2065 if (PreviousMode != KernelMode)
2066 {
2067 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2068 {
2069 return STATUS_PRIVILEGE_NOT_HELD;
2070 }
2071 }
2072
2073 Status = MmSessionCreate(&SessionId);
2074 if (NT_SUCCESS(Status)) *(PULONG)Buffer = SessionId;
2075
2076 return Status;
2077 }
2078
2079
2080 /* Class 48 - Delete an existing session (TSE) */
2081 SSI_DEF(SystemDeleteSession)
2082 {
2083 ULONG SessionId;
2084 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
2085
2086 if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
2087
2088 if (PreviousMode != KernelMode)
2089 {
2090 if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
2091 {
2092 return STATUS_PRIVILEGE_NOT_HELD;
2093 }
2094 }
2095
2096 SessionId = *(PULONG)Buffer;
2097
2098 return MmSessionDelete(SessionId);
2099 }
2100
2101
2102 /* Class 49 - UNKNOWN */
2103 QSI_DEF(SystemInvalidInfoClass4)
2104 {
2105 /* FIXME */
2106 DPRINT1("NtQuerySystemInformation - SystemInvalidInfoClass4 not implemented\n");
2107 return STATUS_NOT_IMPLEMENTED;
2108 }
2109
2110
2111 /* Class 50 - System range start address */
2112 QSI_DEF(SystemRangeStartInformation)
2113 {
2114 /* Check user buffer's size */
2115 if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
2116
2117 *(PULONG_PTR)Buffer = (ULONG_PTR)MmSystemRangeStart;
2118
2119 if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
2120
2121 return STATUS_SUCCESS;
2122 }
2123
2124 /* Class 51 - Driver verifier information */
2125 QSI_DEF(SystemVerifierInformation)
2126 {
2127 /* FIXME */
2128 DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
2129 return STATUS_NOT_IMPLEMENTED;
2130 }
2131
2132
2133 SSI_DEF(SystemVerifierInformation)
2134 {
2135 /* FIXME */
2136 DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
2137 return STATUS_NOT_IMPLEMENTED;
2138 }
2139
2140
2141 /* Class 52 - Add a driver verifier */
2142 SSI_DEF(SystemAddVerifier)
2143 {
2144 /* FIXME */
2145 DPRINT1("NtSetSystemInformation - SystemAddVerifier not implemented\n");
2146 return STATUS_NOT_IMPLEMENTED;
2147 }
2148
2149
2150 /* Class 53 - A session's processes */
2151 QSI_DEF(SystemSessionProcessesInformation)
2152 {
2153 /* FIXME */
2154 DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
2155 return STATUS_NOT_IMPLEMENTED;
2156 }
2157
2158
2159 /* Class 54 - Load & map in system space */
2160 SSI_DEF(SystemLoadGdiDriverInSystemSpaceInformation)
2161 {
2162 /* FIXME */
2163 DPRINT1("NtSetSystemInformation - SystemLoadGdiDriverInSystemSpaceInformation not implemented\n");
2164 return STATUS_NOT_IMPLEMENTED;
2165 }
2166
2167
2168 /* Class 55 - NUMA processor information */
2169 QSI_DEF(SystemNumaProcessorMap)
2170 {
2171 ULONG MaxEntries, Node;
2172 PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
2173
2174 /* Validate input size */
2175 if (Size < sizeof(ULONG))
2176 {
2177 return STATUS_INFO_LENGTH_MISMATCH;
2178 }
2179
2180 /* Return highest node */
2181 NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
2182
2183 /* Compute how much entries we will be able to put in output structure */
2184 MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask)) / sizeof(ULONGLONG);
2185 /* Make sure we don't overflow KeNodeBlock */
2186 if (MaxEntries > KeNumberNodes)
2187 {
2188 MaxEntries = KeNumberNodes;
2189 }
2190
2191 /* If we have entries to write, and room for it */
2192 if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) &&
2193 MaxEntries != 0)
2194 {
2195 /* Already set size we return */
2196 *ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) +
2197 MaxEntries * sizeof(ULONGLONG);
2198
2199 /* For each node, return processor mask */
2200 for (Node = 0; Node < MaxEntries; ++Node)
2201 {
2202 NumaInformation->ActiveProcessorsAffinityMask[Node] = KeNodeBlock[Node]->ProcessorMask;
2203 }
2204 }
2205 else
2206 {
2207 /* We only returned highest node number */
2208 *ReqSize = sizeof(ULONG);
2209 }
2210
2211 return STATUS_SUCCESS;
2212 }
2213
2214
2215 /* Query/Set Calls Table */
2216 typedef
2217 struct _QSSI_CALLS
2218 {
2219 NTSTATUS (* Query) (PVOID,ULONG,PULONG);
2220 NTSTATUS (* Set) (PVOID,ULONG);
2221
2222 } QSSI_CALLS;
2223
2224 // QS Query & Set
2225 // QX Query
2226 // XS Set
2227 // XX unknown behaviour
2228 //
2229 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
2230 #define SI_QX(n) {QSI_USE(n),NULL}
2231 #define SI_XS(n) {NULL,SSI_USE(n)}
2232 #define SI_XX(n) {NULL,NULL}
2233
2234 static
2235 QSSI_CALLS
2236 CallQS [] =
2237 {
2238 SI_QX(SystemBasicInformation),
2239 SI_QX(SystemProcessorInformation),
2240 SI_QX(SystemPerformanceInformation),
2241 SI_QX(SystemTimeOfDayInformation),
2242 SI_QX(SystemPathInformation), /* should be SI_XX */
2243 SI_QX(SystemProcessInformation), // aka SystemProcessesAndThreadsInformation
2244 SI_QX(SystemCallCountInformation), // aka SystemCallCounts
2245 SI_QX(SystemDeviceInformation), // aka SystemConfigurationInformation
2246 SI_QX(SystemProcessorPerformanceInformation), // aka SystemProcessorTimes
2247 SI_QS(SystemFlagsInformation), // aka SystemGlobalFlag
2248 SI_QX(SystemCallTimeInformation), /* should be SI_XX */
2249 SI_QX(SystemModuleInformation),
2250 SI_QX(SystemLocksInformation), // aka SystemLockInformation
2251 SI_QX(SystemStackTraceInformation), /* should be SI_XX */
2252 SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
2253 SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
2254 SI_QX(SystemHandleInformation),
2255 SI_QX(SystemObjectInformation),
2256 SI_QX(SystemPageFileInformation), // aka SystemPagefileInformation
2257 SI_QX(SystemVdmInstemulInformation), // aka SystemInstructionEmulationCounts
2258 SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
2259 SI_QS(SystemFileCacheInformation), // aka SystemCacheInformation
2260 SI_QX(SystemPoolTagInformation),
2261 SI_QX(SystemInterruptInformation), // aka SystemProcessorStatistics
2262 SI_QS(SystemDpcBehaviourInformation), // aka SystemDpcInformation
2263 SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
2264 SI_XS(SystemLoadGdiDriverInformation), // correct: SystemLoadImage
2265 SI_XS(SystemUnloadGdiDriverInformation), // correct: SystemUnloadImage
2266 SI_QS(SystemTimeAdjustmentInformation), // aka SystemTimeAdjustment
2267 SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
2268 SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
2269 SI_QX(SystemEventIdsInformation), /* it should be SI_XX */ // SystemPerformanceTraceInformation
2270 SI_QX(SystemCrashDumpInformation),
2271 SI_QX(SystemExceptionInformation),
2272 SI_QX(SystemCrashDumpStateInformation),
2273 SI_QX(SystemKernelDebuggerInformation),
2274 SI_QX(SystemContextSwitchInformation),
2275 SI_QS(SystemRegistryQuotaInformation),
2276 SI_XS(SystemExtendServiceTableInformation), // correct: SystemLoadAndCallImage
2277 SI_XS(SystemPrioritySeperation),
2278 SI_QX(SystemPlugPlayBusInformation), /* it should be SI_XX */
2279 SI_QX(SystemDockInformation), /* it should be SI_XX */
2280 SI_QX(SystemPowerInformation), /* it should be SI_XX */ // SystemPowerInformationNative? SystemInvalidInfoClass2
2281 SI_QX(SystemProcessorSpeedInformation), /* it should be SI_XX */
2282 SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */ // aka SystemTimeZoneInformation
2283 SI_QX(SystemLookasideInformation),
2284 SI_XS(SystemSetTimeSlipEvent),
2285 SI_XS(SystemCreateSession),
2286 SI_XS(SystemDeleteSession),
2287 SI_QX(SystemInvalidInfoClass4), /* it should be SI_XX */ // SystemSessionInformation?
2288 SI_QX(SystemRangeStartInformation),
2289 SI_QS(SystemVerifierInformation),
2290 SI_XS(SystemAddVerifier),
2291 SI_QX(SystemSessionProcessesInformation),
2292 SI_XS(SystemLoadGdiDriverInSystemSpaceInformation),
2293 SI_QX(SystemNumaProcessorMap)
2294 };
2295
2296 C_ASSERT(SystemBasicInformation == 0);
2297 #define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
2298 #define MAX_SYSTEM_INFO_CLASS (sizeof(CallQS) / sizeof(CallQS[0]))
2299
2300 /*
2301 * @implemented
2302 */
2303 NTSTATUS NTAPI
2304 NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2305 OUT PVOID SystemInformation,
2306 IN ULONG Length,
2307 OUT PULONG UnsafeResultLength)
2308 {
2309 KPROCESSOR_MODE PreviousMode;
2310 ULONG ResultLength = 0;
2311 NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;
2312
2313 PAGED_CODE();
2314
2315 PreviousMode = ExGetPreviousMode();
2316
2317 _SEH2_TRY
2318 {
2319 if (PreviousMode != KernelMode)
2320 {
2321 /* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
2322 ProbeForWrite(SystemInformation, Length, 1);
2323 if (UnsafeResultLength != NULL)
2324 ProbeForWriteUlong(UnsafeResultLength);
2325 }
2326
2327 if (UnsafeResultLength)
2328 *UnsafeResultLength = 0;
2329
2330 /*
2331 * Check if the request is valid.
2332 */
2333 if (SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
2334 {
2335 _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
2336 }
2337
2338 if (NULL != CallQS [SystemInformationClass].Query)
2339 {
2340 /*
2341 * Hand the request to a subhandler.
2342 */
2343 FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
2344 Length,
2345 &ResultLength);
2346
2347 /* Save the result length to the caller */
2348 if (UnsafeResultLength)
2349 *UnsafeResultLength = ResultLength;
2350 }
2351 }
2352 _SEH2_EXCEPT(ExSystemExceptionFilter())
2353 {
2354 FStatus = _SEH2_GetExceptionCode();
2355 }
2356 _SEH2_END;
2357
2358 return FStatus;
2359 }
2360
2361
2362 NTSTATUS
2363 NTAPI
2364 NtSetSystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
2365 IN PVOID SystemInformation,
2366 IN ULONG SystemInformationLength)
2367 {
2368 PAGED_CODE();
2369
2370 /*
2371 * If called from user mode, check
2372 * possible unsafe arguments.
2373 */
2374 #if 0
2375 if (KernelMode != KeGetPreviousMode())
2376 {
2377 // Check arguments
2378 //ProbeForWrite(
2379 // SystemInformation,
2380 // Length
2381 // );
2382 //ProbeForWrite(
2383 // ResultLength,
2384 // sizeof (ULONG)
2385 // );
2386 }
2387 #endif
2388 /*
2389 * Check the request is valid.
2390 */
2391 if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
2392 (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
2393 {
2394 if (NULL != CallQS [SystemInformationClass].Set)
2395 {
2396 /*
2397 * Hand the request to a subhandler.
2398 */
2399 return CallQS [SystemInformationClass].Set(SystemInformation,
2400 SystemInformationLength);
2401 }
2402 }
2403
2404 return STATUS_INVALID_INFO_CLASS;
2405 }
2406
2407 NTSTATUS
2408 NTAPI
2409 NtFlushInstructionCache(
2410 _In_ HANDLE ProcessHandle,
2411 _In_opt_ PVOID BaseAddress,
2412 _In_ ULONG FlushSize)
2413 {
2414 KAPC_STATE ApcState;
2415 PKPROCESS Process;
2416 NTSTATUS Status;
2417 PAGED_CODE();
2418
2419 /* Is a base address given? */
2420 if (BaseAddress != NULL)
2421 {
2422 /* If the requested size is 0, there is nothing to do */
2423 if (FlushSize == 0)
2424 {
2425 return STATUS_SUCCESS;
2426 }
2427
2428 /* Is this a user mode call? */
2429 if (KeGetPreviousMode() != KernelMode)
2430 {
2431 /* Make sure the base address is in user space */
2432 if (BaseAddress > MmHighestUserAddress)
2433 {
2434 DPRINT1("Invalid BaseAddress 0x%p\n", BaseAddress);
2435 return STATUS_ACCESS_VIOLATION;
2436 }
2437 }
2438 }
2439
2440 /* Is another process requested? */
2441 if (ProcessHandle != NtCurrentProcess())
2442 {
2443 /* Reference the process */
2444 Status = ObReferenceObjectByHandle(ProcessHandle,
2445 PROCESS_VM_WRITE,
2446 PsProcessType,
2447 KeGetPreviousMode(),
2448 (PVOID*)&Process,
2449 NULL);
2450 if (!NT_SUCCESS(Status))
2451 {
2452 DPRINT1("Failed to reference the process %p\n", ProcessHandle);
2453 return Status;
2454 }
2455
2456 /* Attach to the process */
2457 KeStackAttachProcess(Process, &ApcState);
2458 }
2459
2460 /* FIXME: don't flush everything if a range is requested */
2461 #if defined(_M_IX86) || defined(_M_AMD64)
2462 __wbinvd();
2463 #elif defined(_M_PPC)
2464 __asm__ __volatile__("tlbsync");
2465 #elif defined(_M_MIPS)
2466 DPRINT1("NtFlushInstructionCache() is not implemented\n");
2467 DbgBreakPoint();
2468 #elif defined(_M_ARM)
2469 _MoveToCoprocessor(0, CP15_ICIALLU);
2470 #else
2471 #error Unknown architecture
2472 #endif
2473
2474 /* Check if we attached */
2475 if (ProcessHandle != NtCurrentProcess())
2476 {
2477 /* Detach from the process */
2478 KeUnstackDetachProcess(&ApcState);
2479 }
2480
2481 return STATUS_SUCCESS;
2482 }
2483
2484 ULONG
2485 NTAPI
2486 NtGetCurrentProcessorNumber(VOID)
2487 {
2488 /* Just return the CPU */
2489 return KeGetCurrentProcessorNumber();
2490 }
2491
2492 /*
2493 * @implemented
2494 */
2495 #undef ExGetPreviousMode
2496 KPROCESSOR_MODE
2497 NTAPI
2498 ExGetPreviousMode (VOID)
2499 {
2500 return KeGetPreviousMode();
2501 }