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