817a2936145ec6fc5f0478c481e5dffe5f2a90d4
[reactos.git] / reactos / ntoskrnl / ex / sysinfo.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: ntoskrnl/ex/sysinfo.c
6 * PURPOSE: System information functions
7 *
8 * PROGRAMMERS: David Welch (welch@mcmail.com)
9 * Aleksey Bragin (aleksey@studiocerebral.com)
10 */
11
12 /* INCLUDES *****************************************************************/
13
14 #include <ntoskrnl.h>
15 #define NDEBUG
16 #include <internal/debug.h>
17
18 extern PEPROCESS PsIdleProcess;
19 extern ULONG NtGlobalFlag; /* FIXME: it should go in a ddk/?.h */
20 ULONGLONG STDCALL KeQueryInterruptTime(VOID);
21
22 VOID MmPrintMemoryStatistic(VOID);
23
24 /* FUNCTIONS *****************************************************************/
25
26 /*
27 * @unimplemented
28 */
29 VOID
30 STDCALL
31 ExEnumHandleTable (
32 PULONG HandleTable,
33 PVOID Callback,
34 PVOID Param,
35 PHANDLE Handle OPTIONAL
36 )
37 {
38 UNIMPLEMENTED;
39 }
40
41 /*
42 * @implemented
43 */
44 VOID
45 STDCALL
46 ExGetCurrentProcessorCpuUsage (
47 PULONG CpuUsage
48 )
49 {
50 PKPRCB Prcb;
51 ULONG TotalTime;
52 ULONGLONG ScaledIdle;
53
54 Prcb = KeGetCurrentPrcb();
55
56 ScaledIdle = Prcb->IdleThread->KernelTime * 100;
57 TotalTime = Prcb->KernelTime + Prcb->UserTime;
58 if (TotalTime != 0)
59 *CpuUsage = 100 - (ScaledIdle / TotalTime);
60 else
61 *CpuUsage = 0;
62 }
63
64 /*
65 * @implemented
66 */
67 VOID
68 STDCALL
69 ExGetCurrentProcessorCounts (
70 PULONG ThreadKernelTime,
71 PULONG TotalCpuTime,
72 PULONG ProcessorNumber
73 )
74 {
75 PKPRCB Prcb;
76
77 Prcb = KeGetCurrentPrcb();
78
79 *ThreadKernelTime = Prcb->KernelTime + Prcb->UserTime;
80 *TotalCpuTime = Prcb->CurrentThread->KernelTime;
81 *ProcessorNumber = KeGetCurrentKPCR()->ProcessorNumber;
82 }
83
84 /*
85 * @implemented
86 */
87 BOOLEAN
88 STDCALL
89 ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
90 {
91 /* Quick check to see if it exists at all */
92 if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return(FALSE);
93
94 /* Return our support for it */
95 return(SharedUserData->ProcessorFeatures[ProcessorFeature]);
96 }
97
98 NTSTATUS STDCALL
99 NtQuerySystemEnvironmentValue (IN PUNICODE_STRING VariableName,
100 OUT PWCHAR ValueBuffer,
101 IN ULONG ValueBufferLength,
102 IN OUT PULONG ReturnLength OPTIONAL)
103 {
104 ANSI_STRING AName;
105 UNICODE_STRING WName;
106 BOOLEAN Result;
107 PCH Value;
108 ANSI_STRING AValue;
109 UNICODE_STRING WValue;
110 KPROCESSOR_MODE PreviousMode;
111 NTSTATUS Status = STATUS_SUCCESS;
112
113 PAGED_CODE();
114
115 PreviousMode = ExGetPreviousMode();
116
117 if(PreviousMode != KernelMode)
118 {
119 _SEH_TRY
120 {
121 ProbeForRead(VariableName,
122 sizeof(UNICODE_STRING),
123 sizeof(ULONG));
124 ProbeForWrite(ValueBuffer,
125 ValueBufferLength,
126 sizeof(WCHAR));
127 if(ReturnLength != NULL)
128 {
129 ProbeForWrite(ReturnLength,
130 sizeof(ULONG),
131 sizeof(ULONG));
132 }
133 }
134 _SEH_HANDLE
135 {
136 Status = _SEH_GetExceptionCode();
137 }
138 _SEH_END;
139
140 if(!NT_SUCCESS(Status))
141 {
142 return Status;
143 }
144 }
145
146 /*
147 * Copy the name to kernel space if necessary and convert it to ANSI.
148 */
149 Status = RtlCaptureUnicodeString(&WName,
150 PreviousMode,
151 NonPagedPool,
152 FALSE,
153 VariableName);
154 if(NT_SUCCESS(Status))
155 {
156 /*
157 * according to ntinternals the SeSystemEnvironmentName privilege is required!
158 */
159 if(!SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
160 PreviousMode))
161 {
162 RtlReleaseCapturedUnicodeString(&WName,
163 PreviousMode,
164 FALSE);
165 DPRINT1("NtQuerySystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
166 return STATUS_PRIVILEGE_NOT_HELD;
167 }
168
169 /*
170 * convert the value name to ansi
171 */
172 Status = RtlUnicodeStringToAnsiString(&AName, &WName, TRUE);
173 RtlReleaseCapturedUnicodeString(&WName,
174 PreviousMode,
175 FALSE);
176 if(!NT_SUCCESS(Status))
177 {
178 return Status;
179 }
180
181 /*
182 * Create a temporary buffer for the value
183 */
184 Value = ExAllocatePool(NonPagedPool, ValueBufferLength);
185 if (Value == NULL)
186 {
187 RtlFreeAnsiString(&AName);
188 return STATUS_INSUFFICIENT_RESOURCES;
189 }
190
191 /*
192 * Get the environment variable
193 */
194 Result = HalGetEnvironmentVariable(AName.Buffer, Value, ValueBufferLength);
195 if(!Result)
196 {
197 RtlFreeAnsiString(&AName);
198 ExFreePool(Value);
199 return STATUS_UNSUCCESSFUL;
200 }
201
202 /*
203 * Convert the result to UNICODE, protect with SEH in case the value buffer
204 * isn't NULL-terminated!
205 */
206 _SEH_TRY
207 {
208 RtlInitAnsiString(&AValue, Value);
209 Status = RtlAnsiStringToUnicodeString(&WValue, &AValue, TRUE);
210 }
211 _SEH_HANDLE
212 {
213 Status = _SEH_GetExceptionCode();
214 }
215 _SEH_END;
216
217 if(NT_SUCCESS(Status))
218 {
219 /*
220 * Copy the result back to the caller.
221 */
222 _SEH_TRY
223 {
224 RtlCopyMemory(ValueBuffer, WValue.Buffer, WValue.Length);
225 ValueBuffer[WValue.Length / sizeof(WCHAR)] = L'\0';
226 if(ReturnLength != NULL)
227 {
228 *ReturnLength = WValue.Length + sizeof(WCHAR);
229 }
230
231 Status = STATUS_SUCCESS;
232 }
233 _SEH_HANDLE
234 {
235 Status = _SEH_GetExceptionCode();
236 }
237 _SEH_END;
238 }
239
240 /*
241 * Cleanup allocated resources.
242 */
243 RtlFreeAnsiString(&AName);
244 ExFreePool(Value);
245 }
246
247 return Status;
248 }
249
250
251 NTSTATUS STDCALL
252 NtSetSystemEnvironmentValue (IN PUNICODE_STRING VariableName,
253 IN PUNICODE_STRING Value)
254 {
255 UNICODE_STRING CapturedName, CapturedValue;
256 ANSI_STRING AName, AValue;
257 KPROCESSOR_MODE PreviousMode;
258 NTSTATUS Status;
259
260 PAGED_CODE();
261
262 PreviousMode = ExGetPreviousMode();
263
264 /*
265 * Copy the strings to kernel space if necessary
266 */
267 Status = RtlCaptureUnicodeString(&CapturedName,
268 PreviousMode,
269 NonPagedPool,
270 FALSE,
271 VariableName);
272 if(NT_SUCCESS(Status))
273 {
274 Status = RtlCaptureUnicodeString(&CapturedValue,
275 PreviousMode,
276 NonPagedPool,
277 FALSE,
278 Value);
279 if(NT_SUCCESS(Status))
280 {
281 /*
282 * according to ntinternals the SeSystemEnvironmentName privilege is required!
283 */
284 if(SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
285 PreviousMode))
286 {
287 /*
288 * convert the strings to ANSI
289 */
290 Status = RtlUnicodeStringToAnsiString(&AName,
291 &CapturedName,
292 TRUE);
293 if(NT_SUCCESS(Status))
294 {
295 Status = RtlUnicodeStringToAnsiString(&AValue,
296 &CapturedValue,
297 TRUE);
298 if(NT_SUCCESS(Status))
299 {
300 BOOLEAN Result = HalSetEnvironmentVariable(AName.Buffer,
301 AValue.Buffer);
302
303 Status = (Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
304 }
305 }
306 }
307 else
308 {
309 DPRINT1("NtSetSystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
310 Status = STATUS_PRIVILEGE_NOT_HELD;
311 }
312
313 RtlReleaseCapturedUnicodeString(&CapturedValue,
314 PreviousMode,
315 FALSE);
316 }
317
318 RtlReleaseCapturedUnicodeString(&CapturedName,
319 PreviousMode,
320 FALSE);
321 }
322
323 return Status;
324 }
325
326
327 /* --- Query/Set System Information --- */
328
329 /*
330 * NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
331 * so the stack is popped only in one place on x86 platform.
332 */
333 #define QSI_USE(n) QSI##n
334 #define QSI_DEF(n) \
335 static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
336
337 #define SSI_USE(n) SSI##n
338 #define SSI_DEF(n) \
339 static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
340
341
342 /* Class 0 - Basic Information */
343 QSI_DEF(SystemBasicInformation)
344 {
345 PSYSTEM_BASIC_INFORMATION Sbi
346 = (PSYSTEM_BASIC_INFORMATION) Buffer;
347
348 *ReqSize = sizeof (SYSTEM_BASIC_INFORMATION);
349 /*
350 * Check user buffer's size
351 */
352 if (Size < sizeof (SYSTEM_BASIC_INFORMATION))
353 {
354 return (STATUS_INFO_LENGTH_MISMATCH);
355 }
356 Sbi->Unknown = 0;
357 Sbi->MaximumIncrement = KeMaximumIncrement;
358 Sbi->PhysicalPageSize = PAGE_SIZE;
359 Sbi->NumberOfPhysicalPages = MmStats.NrTotalPages;
360 Sbi->LowestPhysicalPage = 0; /* FIXME */
361 Sbi->HighestPhysicalPage = MmStats.NrTotalPages; /* FIXME */
362 Sbi->AllocationGranularity = MM_VIRTMEM_GRANULARITY; /* hard coded on Intel? */
363 Sbi->LowestUserAddress = 0x10000; /* Top of 64k */
364 Sbi->HighestUserAddress = (ULONG_PTR)MmHighestUserAddress;
365 Sbi->ActiveProcessors = KeActiveProcessors;
366 Sbi->NumberProcessors = KeNumberProcessors;
367 return (STATUS_SUCCESS);
368 }
369
370 /* Class 1 - Processor Information */
371 QSI_DEF(SystemProcessorInformation)
372 {
373 PSYSTEM_PROCESSOR_INFORMATION Spi
374 = (PSYSTEM_PROCESSOR_INFORMATION) Buffer;
375 PKPRCB Prcb;
376 *ReqSize = sizeof (SYSTEM_PROCESSOR_INFORMATION);
377 /*
378 * Check user buffer's size
379 */
380 if (Size < sizeof (SYSTEM_PROCESSOR_INFORMATION))
381 {
382 return (STATUS_INFO_LENGTH_MISMATCH);
383 }
384 Prcb = KeGetCurrentPrcb();
385 Spi->ProcessorArchitecture = 0; /* Intel Processor */
386 Spi->ProcessorLevel = Prcb->CpuType;
387 Spi->ProcessorRevision = Prcb->CpuStep;
388 Spi->Unknown = 0;
389 Spi->FeatureBits = Prcb->FeatureBits;
390
391 DPRINT("Arch %d Level %d Rev 0x%x\n", Spi->ProcessorArchitecture,
392 Spi->ProcessorLevel, Spi->ProcessorRevision);
393
394 return (STATUS_SUCCESS);
395 }
396
397 /* Class 2 - Performance Information */
398 QSI_DEF(SystemPerformanceInformation)
399 {
400 PSYSTEM_PERFORMANCE_INFORMATION Spi
401 = (PSYSTEM_PERFORMANCE_INFORMATION) Buffer;
402
403 PEPROCESS TheIdleProcess;
404
405 *ReqSize = sizeof (SYSTEM_PERFORMANCE_INFORMATION);
406 /*
407 * Check user buffer's size
408 */
409 if (Size < sizeof (SYSTEM_PERFORMANCE_INFORMATION))
410 {
411 return (STATUS_INFO_LENGTH_MISMATCH);
412 }
413
414 TheIdleProcess = PsIdleProcess;
415
416 Spi->IdleTime.QuadPart = TheIdleProcess->Pcb.KernelTime * 100000LL;
417
418 Spi->ReadTransferCount.QuadPart = IoReadTransferCount;
419 Spi->WriteTransferCount.QuadPart = IoWriteTransferCount;
420 Spi->OtherTransferCount.QuadPart = IoOtherTransferCount;
421 Spi->ReadOperationCount = IoReadOperationCount;
422 Spi->WriteOperationCount = IoWriteOperationCount;
423 Spi->OtherOperationCount = IoOtherOperationCount;
424
425 Spi->AvailablePages = MmStats.NrFreePages;
426 /*
427 Add up all the used "Commitied" memory + pagefile.
428 Not sure this is right. 8^\
429 */
430 Spi->TotalCommittedPages = MiMemoryConsumers[MC_PPOOL].PagesUsed +
431 MiMemoryConsumers[MC_NPPOOL].PagesUsed+
432 MiMemoryConsumers[MC_CACHE].PagesUsed+
433 MiMemoryConsumers[MC_USER].PagesUsed+
434 MiUsedSwapPages;
435 /*
436 Add up the full system total + pagefile.
437 All this make Taskmgr happy but not sure it is the right numbers.
438 This too, fixes some of GlobalMemoryStatusEx numbers.
439 */
440 Spi->TotalCommitLimit = MmStats.NrTotalPages + MiFreeSwapPages +
441 MiUsedSwapPages;
442
443 Spi->PeakCommitment = 0; /* FIXME */
444 Spi->PageFaults = 0; /* FIXME */
445 Spi->WriteCopyFaults = 0; /* FIXME */
446 Spi->TransitionFaults = 0; /* FIXME */
447 Spi->CacheTransitionFaults = 0; /* FIXME */
448 Spi->DemandZeroFaults = 0; /* FIXME */
449 Spi->PagesRead = 0; /* FIXME */
450 Spi->PageReadIos = 0; /* FIXME */
451 Spi->CacheReads = 0; /* FIXME */
452 Spi->CacheIos = 0; /* FIXME */
453 Spi->PagefilePagesWritten = 0; /* FIXME */
454 Spi->PagefilePageWriteIos = 0; /* FIXME */
455 Spi->MappedFilePagesWritten = 0; /* FIXME */
456 Spi->MappedFilePageWriteIos = 0; /* FIXME */
457
458 Spi->PagedPoolUsage = MiMemoryConsumers[MC_PPOOL].PagesUsed;
459 Spi->PagedPoolAllocs = 0; /* FIXME */
460 Spi->PagedPoolFrees = 0; /* FIXME */
461 Spi->NonPagedPoolUsage = MiMemoryConsumers[MC_NPPOOL].PagesUsed;
462 Spi->NonPagedPoolAllocs = 0; /* FIXME */
463 Spi->NonPagedPoolFrees = 0; /* FIXME */
464
465 Spi->TotalFreeSystemPtes = 0; /* FIXME */
466
467 Spi->SystemCodePage = MmStats.NrSystemPages; /* FIXME */
468
469 Spi->TotalSystemDriverPages = 0; /* FIXME */
470 Spi->TotalSystemCodePages = 0; /* FIXME */
471 Spi->SmallNonPagedLookasideListAllocateHits = 0; /* FIXME */
472 Spi->SmallPagedLookasideListAllocateHits = 0; /* FIXME */
473 Spi->Reserved3 = 0; /* FIXME */
474
475 Spi->MmSystemCachePage = MiMemoryConsumers[MC_CACHE].PagesUsed;
476 Spi->PagedPoolPage = MmPagedPoolSize; /* FIXME */
477
478 Spi->SystemDriverPage = 0; /* FIXME */
479 Spi->FastReadNoWait = 0; /* FIXME */
480 Spi->FastReadWait = 0; /* FIXME */
481 Spi->FastReadResourceMiss = 0; /* FIXME */
482 Spi->FastReadNotPossible = 0; /* FIXME */
483
484 Spi->FastMdlReadNoWait = 0; /* FIXME */
485 Spi->FastMdlReadWait = 0; /* FIXME */
486 Spi->FastMdlReadResourceMiss = 0; /* FIXME */
487 Spi->FastMdlReadNotPossible = 0; /* FIXME */
488
489 Spi->MapDataNoWait = 0; /* FIXME */
490 Spi->MapDataWait = 0; /* FIXME */
491 Spi->MapDataNoWaitMiss = 0; /* FIXME */
492 Spi->MapDataWaitMiss = 0; /* FIXME */
493
494 Spi->PinMappedDataCount = 0; /* FIXME */
495 Spi->PinReadNoWait = 0; /* FIXME */
496 Spi->PinReadWait = 0; /* FIXME */
497 Spi->PinReadNoWaitMiss = 0; /* FIXME */
498 Spi->PinReadWaitMiss = 0; /* FIXME */
499 Spi->CopyReadNoWait = 0; /* FIXME */
500 Spi->CopyReadWait = 0; /* FIXME */
501 Spi->CopyReadNoWaitMiss = 0; /* FIXME */
502 Spi->CopyReadWaitMiss = 0; /* FIXME */
503
504 Spi->MdlReadNoWait = 0; /* FIXME */
505 Spi->MdlReadWait = 0; /* FIXME */
506 Spi->MdlReadNoWaitMiss = 0; /* FIXME */
507 Spi->MdlReadWaitMiss = 0; /* FIXME */
508 Spi->ReadAheadIos = 0; /* FIXME */
509 Spi->LazyWriteIos = 0; /* FIXME */
510 Spi->LazyWritePages = 0; /* FIXME */
511 Spi->DataFlushes = 0; /* FIXME */
512 Spi->DataPages = 0; /* FIXME */
513 Spi->ContextSwitches = 0; /* FIXME */
514 Spi->FirstLevelTbFills = 0; /* FIXME */
515 Spi->SecondLevelTbFills = 0; /* FIXME */
516 Spi->SystemCalls = 0; /* FIXME */
517
518 return (STATUS_SUCCESS);
519 }
520
521 /* Class 3 - Time Of Day Information */
522 QSI_DEF(SystemTimeOfDayInformation)
523 {
524 PSYSTEM_TIMEOFDAY_INFORMATION Sti;
525 LARGE_INTEGER CurrentTime;
526
527 Sti = (PSYSTEM_TIMEOFDAY_INFORMATION)Buffer;
528 *ReqSize = sizeof (SYSTEM_TIMEOFDAY_INFORMATION);
529
530 /* Check user buffer's size */
531 if (Size < sizeof (SYSTEM_TIMEOFDAY_INFORMATION))
532 {
533 return STATUS_INFO_LENGTH_MISMATCH;
534 }
535
536 KeQuerySystemTime(&CurrentTime);
537
538 Sti->BootTime= SystemBootTime;
539 Sti->CurrentTime = CurrentTime;
540 Sti->TimeZoneBias.QuadPart = ExpTimeZoneBias.QuadPart;
541 Sti->TimeZoneId = ExpTimeZoneId;
542 Sti->Reserved = 0;
543
544 return STATUS_SUCCESS;
545 }
546
547 /* Class 4 - Path Information */
548 QSI_DEF(SystemPathInformation)
549 {
550 /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
551 DPRINT1("NtQuerySystemInformation - SystemPathInformation not implemented\n");
552
553 return (STATUS_BREAKPOINT);
554 }
555
556 /* Class 5 - Process Information */
557 QSI_DEF(SystemProcessInformation)
558 {
559 ULONG ovlSize=0, nThreads;
560 PEPROCESS pr, syspr;
561 unsigned char *pCur;
562
563 /* scan the process list */
564
565 PSYSTEM_PROCESS_INFORMATION Spi
566 = (PSYSTEM_PROCESS_INFORMATION) Buffer;
567
568 *ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
569
570 if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
571 {
572 return (STATUS_INFO_LENGTH_MISMATCH); // in case buffer size is too small
573 }
574
575 syspr = PsGetNextProcess(NULL);
576 pr = syspr;
577 pCur = (unsigned char *)Spi;
578
579 do
580 {
581 PSYSTEM_PROCESS_INFORMATION SpiCur;
582 int curSize, i = 0;
583 ANSI_STRING imgName;
584 int inLen=32; // image name len in bytes
585 PLIST_ENTRY current_entry;
586 PETHREAD current;
587
588 SpiCur = (PSYSTEM_PROCESS_INFORMATION)pCur;
589
590 current_entry = pr->ThreadListHead.Flink;
591 while (current_entry != &pr->ThreadListHead)
592 {
593 nThreads++;
594 current_entry = current_entry->Flink;
595 }
596
597 // size of the structure for every process
598 curSize = sizeof(SYSTEM_PROCESS_INFORMATION)-sizeof(SYSTEM_THREAD_INFORMATION)+sizeof(SYSTEM_THREAD_INFORMATION)*nThreads;
599 ovlSize += curSize+inLen;
600
601 if (ovlSize > Size)
602 {
603 *ReqSize = ovlSize;
604 ObDereferenceObject(pr);
605
606 return (STATUS_INFO_LENGTH_MISMATCH); // in case buffer size is too small
607 }
608
609 // fill system information
610 SpiCur->NextEntryOffset = curSize+inLen; // relative offset to the beginnnig of the next structure
611 SpiCur->NumberOfThreads = nThreads;
612 SpiCur->CreateTime = pr->CreateTime;
613 SpiCur->UserTime.QuadPart = pr->Pcb.UserTime * 100000LL;
614 SpiCur->KernelTime.QuadPart = pr->Pcb.KernelTime * 100000LL;
615 SpiCur->ImageName.Length = strlen(pr->ImageFileName) * sizeof(WCHAR);
616 SpiCur->ImageName.MaximumLength = inLen;
617 SpiCur->ImageName.Buffer = (void*)(pCur+curSize);
618
619 // copy name to the end of the struct
620 if(pr != PsIdleProcess)
621 {
622 RtlInitAnsiString(&imgName, pr->ImageFileName);
623 RtlAnsiStringToUnicodeString(&SpiCur->ImageName, &imgName, FALSE);
624 }
625 else
626 {
627 RtlInitUnicodeString(&SpiCur->ImageName, NULL);
628 }
629
630 SpiCur->BasePriority = pr->Pcb.BasePriority;
631 SpiCur->UniqueProcessId = pr->UniqueProcessId;
632 SpiCur->InheritedFromUniqueProcessId = pr->InheritedFromUniqueProcessId;
633 SpiCur->HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
634 SpiCur->PeakVirtualSize = pr->PeakVirtualSize;
635 SpiCur->VirtualSize = pr->VirtualSize.QuadPart;
636 SpiCur->PageFaultCount = pr->LastFaultCount;
637 SpiCur->PeakWorkingSetSize = pr->Vm.PeakWorkingSetSize; // Is this right using ->Vm. here ?
638 SpiCur->WorkingSetSize = pr->Vm.WorkingSetSize; // Is this right using ->Vm. here ?
639 SpiCur->QuotaPeakPagedPoolUsage =
640 pr->QuotaPeakPoolUsage[0];
641 SpiCur->QuotaPagedPoolUsage =
642 pr->QuotaPoolUsage[0];
643 SpiCur->QuotaPeakNonPagedPoolUsage =
644 pr->QuotaPeakPoolUsage[1];
645 SpiCur->QuotaNonPagedPoolUsage =
646 pr->QuotaPoolUsage[1];
647 SpiCur->PagefileUsage = pr->PagefileUsage; // FIXME
648 SpiCur->PeakPagefileUsage = pr->PeakPagefileUsage;
649 // KJK::Hyperion: I don't know what does this mean. VM_COUNTERS
650 // doesn't seem to contain any equivalent field
651 //SpiCur->TotalPrivateBytes = pr->NumberOfPrivatePages; //FIXME: bytes != pages
652
653 current_entry = pr->ThreadListHead.Flink;
654 while (current_entry != &pr->ThreadListHead)
655 {
656 current = CONTAINING_RECORD(current_entry, ETHREAD,
657 ThreadListEntry);
658
659 SpiCur->TH[i].KernelTime.QuadPart = current->Tcb.KernelTime * 100000LL;
660 SpiCur->TH[i].UserTime.QuadPart = current->Tcb.UserTime * 100000LL;
661 // SpiCur->TH[i].CreateTime = current->CreateTime;
662 SpiCur->TH[i].WaitTime = current->Tcb.WaitTime;
663 SpiCur->TH[i].StartAddress = (PVOID) current->StartAddress;
664 SpiCur->TH[i].ClientId = current->Cid;
665 SpiCur->TH[i].Priority = current->Tcb.Priority;
666 SpiCur->TH[i].BasePriority = current->Tcb.BasePriority;
667 SpiCur->TH[i].ContextSwitches = current->Tcb.ContextSwitches;
668 SpiCur->TH[i].ThreadState = current->Tcb.State;
669 SpiCur->TH[i].WaitReason = current->Tcb.WaitReason;
670 i++;
671 current_entry = current_entry->Flink;
672 }
673
674 pr = PsGetNextProcess(pr);
675 nThreads = 0;
676 if ((pr == syspr) || (pr == NULL))
677 {
678 SpiCur->NextEntryOffset = 0;
679 break;
680 }
681 else
682 pCur = pCur + curSize + inLen;
683 } while ((pr != syspr) && (pr != NULL));
684
685 if(pr != NULL)
686 {
687 ObDereferenceObject(pr);
688 }
689
690 *ReqSize = ovlSize;
691 return (STATUS_SUCCESS);
692 }
693
694 /* Class 6 - Call Count Information */
695 QSI_DEF(SystemCallCountInformation)
696 {
697 /* FIXME */
698 DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
699 return (STATUS_NOT_IMPLEMENTED);
700 }
701
702 /* Class 7 - Device Information */
703 QSI_DEF(SystemDeviceInformation)
704 {
705 PSYSTEM_DEVICE_INFORMATION Sdi
706 = (PSYSTEM_DEVICE_INFORMATION) Buffer;
707 PCONFIGURATION_INFORMATION ConfigInfo;
708
709 *ReqSize = sizeof (SYSTEM_DEVICE_INFORMATION);
710 /*
711 * Check user buffer's size
712 */
713 if (Size < sizeof (SYSTEM_DEVICE_INFORMATION))
714 {
715 return (STATUS_INFO_LENGTH_MISMATCH);
716 }
717
718 ConfigInfo = IoGetConfigurationInformation ();
719
720 Sdi->NumberOfDisks = ConfigInfo->DiskCount;
721 Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
722 Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
723 Sdi->NumberOfTapes = ConfigInfo->TapeCount;
724 Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
725 Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
726
727 return (STATUS_SUCCESS);
728 }
729
730 /* Class 8 - Processor Performance Information */
731 QSI_DEF(SystemProcessorPerformanceInformation)
732 {
733 PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
734 = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
735
736 ULONG i;
737 LARGE_INTEGER CurrentTime;
738 PKPRCB Prcb;
739
740 *ReqSize = KeNumberProcessors * sizeof (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
741 /*
742 * Check user buffer's size
743 */
744 if (Size < KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))
745 {
746 return (STATUS_INFO_LENGTH_MISMATCH);
747 }
748
749 CurrentTime.QuadPart = KeQueryInterruptTime();
750 Prcb = ((PKPCR)KPCR_BASE)->Prcb;
751 for (i = 0; i < KeNumberProcessors; i++)
752 {
753 Spi->IdleTime.QuadPart = (Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime) * 100000LL; // IdleTime
754 Spi->KernelTime.QuadPart = Prcb->KernelTime * 100000LL; // KernelTime
755 Spi->UserTime.QuadPart = Prcb->UserTime * 100000LL;
756 Spi->DpcTime.QuadPart = Prcb->DpcTime * 100000LL;
757 Spi->InterruptTime.QuadPart = Prcb->InterruptTime * 100000LL;
758 Spi->InterruptCount = Prcb->InterruptCount; // Interrupt Count
759 Spi++;
760 Prcb = (PKPRCB)((ULONG_PTR)Prcb + PAGE_SIZE);
761 }
762
763 return (STATUS_SUCCESS);
764 }
765
766 /* Class 9 - Flags Information */
767 QSI_DEF(SystemFlagsInformation)
768 {
769 if (sizeof (SYSTEM_FLAGS_INFORMATION) != Size)
770 {
771 * ReqSize = sizeof (SYSTEM_FLAGS_INFORMATION);
772 return (STATUS_INFO_LENGTH_MISMATCH);
773 }
774 ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
775 return (STATUS_SUCCESS);
776 }
777
778 SSI_DEF(SystemFlagsInformation)
779 {
780 if (sizeof (SYSTEM_FLAGS_INFORMATION) != Size)
781 {
782 return (STATUS_INFO_LENGTH_MISMATCH);
783 }
784 NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
785 return (STATUS_SUCCESS);
786 }
787
788 /* Class 10 - Call Time Information */
789 QSI_DEF(SystemCallTimeInformation)
790 {
791 /* FIXME */
792 DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
793 return (STATUS_NOT_IMPLEMENTED);
794 }
795
796 /* Class 11 - Module Information */
797 QSI_DEF(SystemModuleInformation)
798 {
799 return LdrpQueryModuleInformation(Buffer, Size, ReqSize);
800 }
801
802 /* Class 12 - Locks Information */
803 QSI_DEF(SystemLocksInformation)
804 {
805 /* FIXME */
806 DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
807 return (STATUS_NOT_IMPLEMENTED);
808 }
809
810 /* Class 13 - Stack Trace Information */
811 QSI_DEF(SystemStackTraceInformation)
812 {
813 /* FIXME */
814 DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
815 return (STATUS_NOT_IMPLEMENTED);
816 }
817
818 /* Class 14 - Paged Pool Information */
819 QSI_DEF(SystemPagedPoolInformation)
820 {
821 /* FIXME */
822 DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
823 return (STATUS_NOT_IMPLEMENTED);
824 }
825
826 /* Class 15 - Non Paged Pool Information */
827 QSI_DEF(SystemNonPagedPoolInformation)
828 {
829 /* FIXME */
830 DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
831 return (STATUS_NOT_IMPLEMENTED);
832 }
833
834
835 VOID
836 ObpGetNextHandleByProcessCount(PSYSTEM_HANDLE_TABLE_ENTRY_INFO pshi,
837 PEPROCESS Process,
838 int Count);
839
840 /* Class 16 - Handle Information */
841 QSI_DEF(SystemHandleInformation)
842 {
843 PSYSTEM_HANDLE_INFORMATION Shi =
844 (PSYSTEM_HANDLE_INFORMATION) Buffer;
845
846 DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
847
848 if (Size < sizeof (SYSTEM_HANDLE_INFORMATION))
849 {
850 * ReqSize = sizeof (SYSTEM_HANDLE_INFORMATION);
851 return (STATUS_INFO_LENGTH_MISMATCH);
852 }
853
854 DPRINT("SystemHandleInformation 1\n");
855
856 PEPROCESS pr, syspr;
857 int curSize, i = 0;
858 ULONG hCount = 0;
859
860 /* First Calc Size from Count. */
861 syspr = PsGetNextProcess(NULL);
862 pr = syspr;
863
864 do
865 {
866 hCount = hCount + (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
867 pr = PsGetNextProcess(pr);
868
869 if ((pr == syspr) || (pr == NULL))
870 break;
871 } while ((pr != syspr) && (pr != NULL));
872
873 if(pr != NULL)
874 {
875 ObDereferenceObject(pr);
876 }
877
878 DPRINT("SystemHandleInformation 2\n");
879
880 curSize = sizeof(SYSTEM_HANDLE_INFORMATION)+
881 ( (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) * hCount) -
882 (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) ));
883
884 Shi->NumberOfHandles = hCount;
885
886 if (curSize > Size)
887 {
888 *ReqSize = curSize;
889 return (STATUS_INFO_LENGTH_MISMATCH);
890 }
891
892 DPRINT("SystemHandleInformation 3\n");
893
894 /* Now get Handles from all processs. */
895 syspr = PsGetNextProcess(NULL);
896 pr = syspr;
897
898 do
899 {
900 int Count = 0, HandleCount;
901
902 HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
903
904 for (Count = 0; HandleCount > 0 ; HandleCount--)
905 {
906 ObpGetNextHandleByProcessCount( &Shi->Handles[i], pr, Count);
907 Count++;
908 i++;
909 }
910
911 pr = PsGetNextProcess(pr);
912
913 if ((pr == syspr) || (pr == NULL))
914 break;
915 } while ((pr != syspr) && (pr != NULL));
916
917 if(pr != NULL)
918 {
919 ObDereferenceObject(pr);
920 }
921
922 DPRINT("SystemHandleInformation 4\n");
923 return (STATUS_SUCCESS);
924
925 }
926 /*
927 SSI_DEF(SystemHandleInformation)
928 {
929
930 return (STATUS_SUCCESS);
931 }
932 */
933
934 /* Class 17 - Information */
935 QSI_DEF(SystemObjectInformation)
936 {
937 /* FIXME */
938 DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
939 return (STATUS_NOT_IMPLEMENTED);
940 }
941
942 /* Class 18 - Information */
943 QSI_DEF(SystemPageFileInformation)
944 {
945 SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
946
947 if (Size < sizeof (SYSTEM_PAGEFILE_INFORMATION))
948 {
949 * ReqSize = sizeof (SYSTEM_PAGEFILE_INFORMATION);
950 return (STATUS_INFO_LENGTH_MISMATCH);
951 }
952
953 UNICODE_STRING FileName; /* FIXME */
954
955 /* FIXME */
956 Spfi->NextEntryOffset = 0;
957
958 Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
959 Spfi->TotalInUse = MiUsedSwapPages;
960 Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
961 Spfi->PageFileName = FileName;
962 return (STATUS_SUCCESS);
963 }
964
965 /* Class 19 - Vdm Instemul Information */
966 QSI_DEF(SystemVdmInstemulInformation)
967 {
968 /* FIXME */
969 DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
970 return (STATUS_NOT_IMPLEMENTED);
971 }
972
973 /* Class 20 - Vdm Bop Information */
974 QSI_DEF(SystemVdmBopInformation)
975 {
976 /* FIXME */
977 DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
978 return (STATUS_NOT_IMPLEMENTED);
979 }
980
981 /* Class 21 - File Cache Information */
982 QSI_DEF(SystemFileCacheInformation)
983 {
984 SYSTEM_CACHE_INFORMATION *Sci = (SYSTEM_CACHE_INFORMATION *) Buffer;
985
986 if (Size < sizeof (SYSTEM_CACHE_INFORMATION))
987 {
988 * ReqSize = sizeof (SYSTEM_CACHE_INFORMATION);
989 return (STATUS_INFO_LENGTH_MISMATCH);
990 }
991 /* Return the Byte size not the page size. */
992 Sci->CurrentSize =
993 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
994 Sci->PeakSize =
995 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
996
997 Sci->PageFaultCount = 0; /* FIXME */
998 Sci->MinimumWorkingSet = 0; /* FIXME */
999 Sci->MaximumWorkingSet = 0; /* FIXME */
1000 Sci->TransitionSharedPages = 0; /* FIXME */
1001 Sci->TransitionSharedPagesPeak = 0; /* FIXME */
1002
1003 return (STATUS_SUCCESS);
1004 }
1005
1006 SSI_DEF(SystemFileCacheInformation)
1007 {
1008 if (Size < sizeof (SYSTEM_CACHE_INFORMATION))
1009 {
1010 return (STATUS_INFO_LENGTH_MISMATCH);
1011 }
1012 /* FIXME */
1013 DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1014 return (STATUS_NOT_IMPLEMENTED);
1015 }
1016
1017 /* Class 22 - Pool Tag Information */
1018 QSI_DEF(SystemPoolTagInformation)
1019 {
1020 /* FIXME */
1021 DPRINT1("NtQuerySystemInformation - SystemPoolTagInformation not implemented\n");
1022 return (STATUS_NOT_IMPLEMENTED);
1023 }
1024
1025 /* Class 23 - Interrupt Information for all processors */
1026 QSI_DEF(SystemInterruptInformation)
1027 {
1028 PKPRCB Prcb;
1029 UINT i;
1030 ULONG ti;
1031 PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1032
1033 if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1034 {
1035 return (STATUS_INFO_LENGTH_MISMATCH);
1036 }
1037
1038 ti = KeQueryTimeIncrement();
1039
1040 Prcb = ((PKPCR)KPCR_BASE)->Prcb;
1041 for (i = 0; i < KeNumberProcessors; i++)
1042 {
1043 sii->ContextSwitches = Prcb->KeContextSwitches;
1044 sii->DpcCount = 0; /* FIXME */
1045 sii->DpcRate = 0; /* FIXME */
1046 sii->TimeIncrement = ti;
1047 sii->DpcBypassCount = 0; /* FIXME */
1048 sii->ApcBypassCount = 0; /* FIXME */
1049 sii++;
1050 Prcb = (PKPRCB)((ULONG_PTR)Prcb + PAGE_SIZE);
1051 }
1052
1053 return STATUS_SUCCESS;
1054 }
1055
1056 /* Class 24 - DPC Behaviour Information */
1057 QSI_DEF(SystemDpcBehaviourInformation)
1058 {
1059 /* FIXME */
1060 DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1061 return (STATUS_NOT_IMPLEMENTED);
1062 }
1063
1064 SSI_DEF(SystemDpcBehaviourInformation)
1065 {
1066 /* FIXME */
1067 DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1068 return (STATUS_NOT_IMPLEMENTED);
1069 }
1070
1071 /* Class 25 - Full Memory Information */
1072 QSI_DEF(SystemFullMemoryInformation)
1073 {
1074 PULONG Spi = (PULONG) Buffer;
1075
1076 PEPROCESS TheIdleProcess;
1077
1078 * ReqSize = sizeof (ULONG);
1079
1080 if (sizeof (ULONG) != Size)
1081 {
1082 return (STATUS_INFO_LENGTH_MISMATCH);
1083 }
1084 DPRINT("SystemFullMemoryInformation\n");
1085
1086 TheIdleProcess = PsIdleProcess;
1087
1088 DPRINT("PID: %d, KernelTime: %u PFFree: %d PFUsed: %d\n",
1089 TheIdleProcess->UniqueProcessId,
1090 TheIdleProcess->Pcb.KernelTime,
1091 MiFreeSwapPages,
1092 MiUsedSwapPages);
1093
1094 #ifndef NDEBUG
1095 MmPrintMemoryStatistic();
1096 #endif
1097
1098 *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1099
1100 return (STATUS_SUCCESS);
1101 }
1102
1103 /* Class 26 - Load Image */
1104 SSI_DEF(SystemLoadImage)
1105 {
1106 PSYSTEM_LOAD_IMAGE Sli = (PSYSTEM_LOAD_IMAGE)Buffer;
1107
1108 if (sizeof(SYSTEM_LOAD_IMAGE) != Size)
1109 {
1110 return(STATUS_INFO_LENGTH_MISMATCH);
1111 }
1112
1113 return(LdrpLoadImage(&Sli->ModuleName,
1114 &Sli->ModuleBase,
1115 &Sli->SectionPointer,
1116 &Sli->EntryPoint,
1117 &Sli->ExportDirectory));
1118 }
1119
1120 /* Class 27 - Unload Image */
1121 SSI_DEF(SystemUnloadImage)
1122 {
1123 PSYSTEM_UNLOAD_IMAGE Sui = (PSYSTEM_UNLOAD_IMAGE)Buffer;
1124
1125 if (sizeof(SYSTEM_UNLOAD_IMAGE) != Size)
1126 {
1127 return(STATUS_INFO_LENGTH_MISMATCH);
1128 }
1129
1130 return(LdrpUnloadImage(Sui->ModuleBase));
1131 }
1132
1133 /* Class 28 - Time Adjustment Information */
1134 QSI_DEF(SystemTimeAdjustmentInformation)
1135 {
1136 if (sizeof (SYSTEM_SET_TIME_ADJUSTMENT) > Size)
1137 {
1138 * ReqSize = sizeof (SYSTEM_SET_TIME_ADJUSTMENT);
1139 return (STATUS_INFO_LENGTH_MISMATCH);
1140 }
1141 /* FIXME: */
1142 DPRINT1("NtQuerySystemInformation - SystemTimeAdjustmentInformation not implemented\n");
1143 return (STATUS_NOT_IMPLEMENTED);
1144 }
1145
1146 SSI_DEF(SystemTimeAdjustmentInformation)
1147 {
1148 if (sizeof (SYSTEM_SET_TIME_ADJUSTMENT) > Size)
1149 {
1150 return (STATUS_INFO_LENGTH_MISMATCH);
1151 }
1152 /* FIXME: */
1153 DPRINT1("NtSetSystemInformation - SystemTimeAdjustmentInformation not implemented\n");
1154 return (STATUS_NOT_IMPLEMENTED);
1155 }
1156
1157 /* Class 29 - Summary Memory Information */
1158 QSI_DEF(SystemSummaryMemoryInformation)
1159 {
1160 /* FIXME */
1161 DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1162 return (STATUS_NOT_IMPLEMENTED);
1163 }
1164
1165 /* Class 30 - Next Event Id Information */
1166 QSI_DEF(SystemNextEventIdInformation)
1167 {
1168 /* FIXME */
1169 DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1170 return (STATUS_NOT_IMPLEMENTED);
1171 }
1172
1173 /* Class 31 - Event Ids Information */
1174 QSI_DEF(SystemEventIdsInformation)
1175 {
1176 /* FIXME */
1177 DPRINT1("NtQuerySystemInformation - SystemEventIdsInformation not implemented\n");
1178 return (STATUS_NOT_IMPLEMENTED);
1179 }
1180
1181 /* Class 32 - Crash Dump Information */
1182 QSI_DEF(SystemCrashDumpInformation)
1183 {
1184 /* FIXME */
1185 DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1186 return (STATUS_NOT_IMPLEMENTED);
1187 }
1188
1189 /* Class 33 - Exception Information */
1190 QSI_DEF(SystemExceptionInformation)
1191 {
1192 /* FIXME */
1193 DPRINT1("NtQuerySystemInformation - SystemExceptionInformation not implemented\n");
1194 return (STATUS_NOT_IMPLEMENTED);
1195 }
1196
1197 /* Class 34 - Crash Dump State Information */
1198 QSI_DEF(SystemCrashDumpStateInformation)
1199 {
1200 /* FIXME */
1201 DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1202 return (STATUS_NOT_IMPLEMENTED);
1203 }
1204
1205 /* Class 35 - Kernel Debugger Information */
1206 QSI_DEF(SystemKernelDebuggerInformation)
1207 {
1208 /* FIXME */
1209 DPRINT1("NtQuerySystemInformation - SystemKernelDebuggerInformation not implemented\n");
1210 return (STATUS_NOT_IMPLEMENTED);
1211 }
1212
1213 /* Class 36 - Context Switch Information */
1214 QSI_DEF(SystemContextSwitchInformation)
1215 {
1216 /* FIXME */
1217 DPRINT1("NtQuerySystemInformation - SystemContextSwitchInformation not implemented\n");
1218 return (STATUS_NOT_IMPLEMENTED);
1219 }
1220
1221 /* Class 37 - Registry Quota Information */
1222 QSI_DEF(SystemRegistryQuotaInformation)
1223 {
1224 PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1225
1226 *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1227 if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1228 {
1229 return STATUS_INFO_LENGTH_MISMATCH;
1230 }
1231
1232 DPRINT1("Faking max registry size of 32 MB\n");
1233 srqi->RegistryQuotaAllowed = 0x2000000;
1234 srqi->RegistryQuotaUsed = 0x200000;
1235 srqi->Reserved1 = (void*)0x200000;
1236
1237 return STATUS_SUCCESS;
1238 }
1239
1240 SSI_DEF(SystemRegistryQuotaInformation)
1241 {
1242 /* FIXME */
1243 DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1244 return (STATUS_NOT_IMPLEMENTED);
1245 }
1246
1247 /* Class 38 - Load And Call Image */
1248 SSI_DEF(SystemLoadAndCallImage)
1249 {
1250 PSYSTEM_LOAD_AND_CALL_IMAGE Slci = (PSYSTEM_LOAD_AND_CALL_IMAGE)Buffer;
1251
1252 if (sizeof(SYSTEM_LOAD_AND_CALL_IMAGE) != Size)
1253 {
1254 return(STATUS_INFO_LENGTH_MISMATCH);
1255 }
1256
1257 return(LdrpLoadAndCallImage(&Slci->ModuleName));
1258 }
1259
1260 /* Class 39 - Priority Separation */
1261 SSI_DEF(SystemPrioritySeperation)
1262 {
1263 /* FIXME */
1264 DPRINT1("NtSetSystemInformation - SystemPrioritySeperation not implemented\n");
1265 return (STATUS_NOT_IMPLEMENTED);
1266 }
1267
1268 /* Class 40 - Plug Play Bus Information */
1269 QSI_DEF(SystemPlugPlayBusInformation)
1270 {
1271 /* FIXME */
1272 DPRINT1("NtQuerySystemInformation - SystemPlugPlayBusInformation not implemented\n");
1273 return (STATUS_NOT_IMPLEMENTED);
1274 }
1275
1276 /* Class 41 - Dock Information */
1277 QSI_DEF(SystemDockInformation)
1278 {
1279 /* FIXME */
1280 DPRINT1("NtQuerySystemInformation - SystemDockInformation not implemented\n");
1281 return (STATUS_NOT_IMPLEMENTED);
1282 }
1283
1284 /* Class 42 - Power Information */
1285 QSI_DEF(SystemPowerInformation)
1286 {
1287 /* FIXME */
1288 DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
1289 return (STATUS_NOT_IMPLEMENTED);
1290 }
1291
1292 /* Class 43 - Processor Speed Information */
1293 QSI_DEF(SystemProcessorSpeedInformation)
1294 {
1295 /* FIXME */
1296 DPRINT1("NtQuerySystemInformation - SystemProcessorSpeedInformation not implemented\n");
1297 return (STATUS_NOT_IMPLEMENTED);
1298 }
1299
1300 /* Class 44 - Current Time Zone Information */
1301 QSI_DEF(SystemCurrentTimeZoneInformation)
1302 {
1303 * ReqSize = sizeof (TIME_ZONE_INFORMATION);
1304
1305 if (sizeof (TIME_ZONE_INFORMATION) != Size)
1306 {
1307 return STATUS_INFO_LENGTH_MISMATCH;
1308 }
1309
1310 /* Copy the time zone information struct */
1311 memcpy(Buffer,
1312 &ExpTimeZoneInfo,
1313 sizeof(TIME_ZONE_INFORMATION));
1314
1315 return STATUS_SUCCESS;
1316 }
1317
1318
1319 SSI_DEF(SystemCurrentTimeZoneInformation)
1320 {
1321 /* Check user buffer's size */
1322 if (Size < sizeof (TIME_ZONE_INFORMATION))
1323 {
1324 return STATUS_INFO_LENGTH_MISMATCH;
1325 }
1326
1327 return ExpSetTimeZoneInformation((PTIME_ZONE_INFORMATION)Buffer);
1328 }
1329
1330
1331 /* Class 45 - Lookaside Information */
1332 QSI_DEF(SystemLookasideInformation)
1333 {
1334 /* FIXME */
1335 DPRINT1("NtQuerySystemInformation - SystemLookasideInformation not implemented\n");
1336 return (STATUS_NOT_IMPLEMENTED);
1337 }
1338
1339
1340 /* Class 46 - Set time slip event */
1341 SSI_DEF(SystemSetTimeSlipEvent)
1342 {
1343 /* FIXME */
1344 DPRINT1("NtSetSystemInformation - SystemSetTimSlipEvent not implemented\n");
1345 return (STATUS_NOT_IMPLEMENTED);
1346 }
1347
1348
1349 /* Class 47 - Create a new session (TSE) */
1350 SSI_DEF(SystemCreateSession)
1351 {
1352 /* FIXME */
1353 DPRINT1("NtSetSystemInformation - SystemCreateSession not implemented\n");
1354 return (STATUS_NOT_IMPLEMENTED);
1355 }
1356
1357
1358 /* Class 48 - Delete an existing session (TSE) */
1359 SSI_DEF(SystemDeleteSession)
1360 {
1361 /* FIXME */
1362 DPRINT1("NtSetSystemInformation - SystemDeleteSession not implemented\n");
1363 return (STATUS_NOT_IMPLEMENTED);
1364 }
1365
1366
1367 /* Class 49 - UNKNOWN */
1368 QSI_DEF(SystemInvalidInfoClass4)
1369 {
1370 /* FIXME */
1371 DPRINT1("NtQuerySystemInformation - SystemInvalidInfoClass4 not implemented\n");
1372 return (STATUS_NOT_IMPLEMENTED);
1373 }
1374
1375
1376 /* Class 50 - System range start address */
1377 QSI_DEF(SystemRangeStartInformation)
1378 {
1379 /* FIXME */
1380 DPRINT1("NtQuerySystemInformation - SystemRangeStartInformation not implemented\n");
1381 return (STATUS_NOT_IMPLEMENTED);
1382 }
1383
1384
1385 /* Class 51 - Driver verifier information */
1386 QSI_DEF(SystemVerifierInformation)
1387 {
1388 /* FIXME */
1389 DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
1390 return (STATUS_NOT_IMPLEMENTED);
1391 }
1392
1393
1394 SSI_DEF(SystemVerifierInformation)
1395 {
1396 /* FIXME */
1397 DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
1398 return (STATUS_NOT_IMPLEMENTED);
1399 }
1400
1401
1402 /* Class 52 - Add a driver verifier */
1403 SSI_DEF(SystemAddVerifier)
1404 {
1405 /* FIXME */
1406 DPRINT1("NtSetSystemInformation - SystemAddVerifier not implemented\n");
1407 return (STATUS_NOT_IMPLEMENTED);
1408 }
1409
1410
1411 /* Class 53 - A session's processes */
1412 QSI_DEF(SystemSessionProcessesInformation)
1413 {
1414 /* FIXME */
1415 DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
1416 return (STATUS_NOT_IMPLEMENTED);
1417 }
1418
1419
1420 /* Query/Set Calls Table */
1421 typedef
1422 struct _QSSI_CALLS
1423 {
1424 NTSTATUS (* Query) (PVOID,ULONG,PULONG);
1425 NTSTATUS (* Set) (PVOID,ULONG);
1426
1427 } QSSI_CALLS;
1428
1429 // QS Query & Set
1430 // QX Query
1431 // XS Set
1432 // XX unknown behaviour
1433 //
1434 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
1435 #define SI_QX(n) {QSI_USE(n),NULL}
1436 #define SI_XS(n) {NULL,SSI_USE(n)}
1437 #define SI_XX(n) {NULL,NULL}
1438
1439 static
1440 QSSI_CALLS
1441 CallQS [] =
1442 {
1443 SI_QX(SystemBasicInformation),
1444 SI_QX(SystemProcessorInformation),
1445 SI_QX(SystemPerformanceInformation),
1446 SI_QX(SystemTimeOfDayInformation),
1447 SI_QX(SystemPathInformation), /* should be SI_XX */
1448 SI_QX(SystemProcessInformation),
1449 SI_QX(SystemCallCountInformation),
1450 SI_QX(SystemDeviceInformation),
1451 SI_QX(SystemProcessorPerformanceInformation),
1452 SI_QS(SystemFlagsInformation),
1453 SI_QX(SystemCallTimeInformation), /* should be SI_XX */
1454 SI_QX(SystemModuleInformation),
1455 SI_QX(SystemLocksInformation),
1456 SI_QX(SystemStackTraceInformation), /* should be SI_XX */
1457 SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
1458 SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
1459 SI_QX(SystemHandleInformation),
1460 SI_QX(SystemObjectInformation),
1461 SI_QX(SystemPageFileInformation),
1462 SI_QX(SystemVdmInstemulInformation),
1463 SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
1464 SI_QS(SystemFileCacheInformation),
1465 SI_QX(SystemPoolTagInformation),
1466 SI_QX(SystemInterruptInformation),
1467 SI_QS(SystemDpcBehaviourInformation),
1468 SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
1469 SI_XS(SystemLoadImage),
1470 SI_XS(SystemUnloadImage),
1471 SI_QS(SystemTimeAdjustmentInformation),
1472 SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
1473 SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
1474 SI_QX(SystemEventIdsInformation), /* it should be SI_XX */
1475 SI_QX(SystemCrashDumpInformation),
1476 SI_QX(SystemExceptionInformation),
1477 SI_QX(SystemCrashDumpStateInformation),
1478 SI_QX(SystemKernelDebuggerInformation),
1479 SI_QX(SystemContextSwitchInformation),
1480 SI_QS(SystemRegistryQuotaInformation),
1481 SI_XS(SystemLoadAndCallImage),
1482 SI_XS(SystemPrioritySeperation),
1483 SI_QX(SystemPlugPlayBusInformation), /* it should be SI_XX */
1484 SI_QX(SystemDockInformation), /* it should be SI_XX */
1485 SI_QX(SystemPowerInformation), /* it should be SI_XX */
1486 SI_QX(SystemProcessorSpeedInformation), /* it should be SI_XX */
1487 SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
1488 SI_QX(SystemLookasideInformation),
1489 SI_XS(SystemSetTimeSlipEvent),
1490 SI_XS(SystemCreateSession),
1491 SI_XS(SystemDeleteSession),
1492 SI_QX(SystemInvalidInfoClass4), /* it should be SI_XX */
1493 SI_QX(SystemRangeStartInformation),
1494 SI_QS(SystemVerifierInformation),
1495 SI_XS(SystemAddVerifier),
1496 SI_QX(SystemSessionProcessesInformation)
1497 };
1498
1499
1500 /*
1501 * @implemented
1502 */
1503 NTSTATUS STDCALL
1504 NtQuerySystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
1505 OUT PVOID UnsafeSystemInformation,
1506 IN ULONG Length,
1507 OUT PULONG UnsafeResultLength)
1508 {
1509 ULONG ResultLength;
1510 PVOID SystemInformation;
1511 NTSTATUS Status;
1512 NTSTATUS FStatus;
1513
1514 PAGED_CODE();
1515
1516 /* DPRINT("NtQuerySystemInformation Start. Class:%d\n",
1517 SystemInformationClass );
1518 */
1519 /*if (ExGetPreviousMode() == KernelMode)
1520 {*/
1521 SystemInformation = UnsafeSystemInformation;
1522 /*}
1523 else
1524 {
1525 SystemInformation = ExAllocatePool(NonPagedPool, Length);
1526 if (SystemInformation == NULL)
1527 {
1528 return(STATUS_NO_MEMORY);
1529 }
1530 }*/
1531
1532 /* Clear user buffer. */
1533 RtlZeroMemory(SystemInformation, Length);
1534
1535 /*
1536 * Check the request is valid.
1537 */
1538 if ((SystemInformationClass >= SystemInformationClassMin) &&
1539 (SystemInformationClass < SystemInformationClassMax))
1540 {
1541 if (NULL != CallQS [SystemInformationClass].Query)
1542 {
1543 /*
1544 * Hand the request to a subhandler.
1545 */
1546 FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
1547 Length,
1548 &ResultLength);
1549 /*if (ExGetPreviousMode() != KernelMode)
1550 {
1551 Status = MmCopyToCaller(UnsafeSystemInformation,
1552 SystemInformation,
1553 Length);
1554 ExFreePool(SystemInformation);
1555 if (!NT_SUCCESS(Status))
1556 {
1557 return(Status);
1558 }
1559 }*/
1560 if (UnsafeResultLength != NULL)
1561 {
1562 /*if (ExGetPreviousMode() == KernelMode)
1563 {
1564 *UnsafeResultLength = ResultLength;
1565 }
1566 else
1567 {*/
1568 Status = MmCopyToCaller(UnsafeResultLength,
1569 &ResultLength,
1570 sizeof(ULONG));
1571 if (!NT_SUCCESS(Status))
1572 {
1573 return(Status);
1574 }
1575 /*}*/
1576 }
1577 return(FStatus);
1578 }
1579 }
1580 return (STATUS_INVALID_INFO_CLASS);
1581 }
1582
1583
1584 NTSTATUS
1585 STDCALL
1586 NtSetSystemInformation (
1587 IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
1588 IN PVOID SystemInformation,
1589 IN ULONG SystemInformationLength
1590 )
1591 {
1592 PAGED_CODE();
1593
1594 /*
1595 * If called from user mode, check
1596 * possible unsafe arguments.
1597 */
1598 #if 0
1599 if (KernelMode != KeGetPreviousMode())
1600 {
1601 // Check arguments
1602 //ProbeForWrite(
1603 // SystemInformation,
1604 // Length
1605 // );
1606 //ProbeForWrite(
1607 // ResultLength,
1608 // sizeof (ULONG)
1609 // );
1610 }
1611 #endif
1612 /*
1613 * Check the request is valid.
1614 */
1615 if ( (SystemInformationClass >= SystemInformationClassMin)
1616 && (SystemInformationClass < SystemInformationClassMax)
1617 )
1618 {
1619 if (NULL != CallQS [SystemInformationClass].Set)
1620 {
1621 /*
1622 * Hand the request to a subhandler.
1623 */
1624 return CallQS [SystemInformationClass].Set (
1625 SystemInformation,
1626 SystemInformationLength
1627 );
1628 }
1629 }
1630 return (STATUS_INVALID_INFO_CLASS);
1631 }
1632
1633
1634 NTSTATUS
1635 STDCALL
1636 NtFlushInstructionCache (
1637 IN HANDLE ProcessHandle,
1638 IN PVOID BaseAddress,
1639 IN UINT NumberOfBytesToFlush
1640 )
1641 {
1642 PAGED_CODE();
1643
1644 __asm__("wbinvd\n");
1645 return STATUS_SUCCESS;
1646 }
1647
1648
1649 /* EOF */