projects / reactos.git / blob
? search:


4546b75e4237dbc9804f7e22594bb4ea6a1333dc
[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 nThreads = 0;
591 current_entry = pr->ThreadListHead.Flink;
592 while (current_entry != &pr->ThreadListHead)
593 {
594 nThreads++;
595 current_entry = current_entry->Flink;
596 }
597
598 // size of the structure for every process
599 curSize = sizeof(SYSTEM_PROCESS_INFORMATION)-sizeof(SYSTEM_THREAD_INFORMATION)+sizeof(SYSTEM_THREAD_INFORMATION)*nThreads;
600 ovlSize += curSize+inLen;
601
602 if (ovlSize > Size)
603 {
604 *ReqSize = ovlSize;
605 ObDereferenceObject(pr);
606
607 return (STATUS_INFO_LENGTH_MISMATCH); // in case buffer size is too small
608 }
609
610 // fill system information
611 SpiCur->NextEntryOffset = curSize+inLen; // relative offset to the beginnnig of the next structure
612 SpiCur->NumberOfThreads = nThreads;
613 SpiCur->CreateTime = pr->CreateTime;
614 SpiCur->UserTime.QuadPart = pr->Pcb.UserTime * 100000LL;
615 SpiCur->KernelTime.QuadPart = pr->Pcb.KernelTime * 100000LL;
616 SpiCur->ImageName.Length = strlen(pr->ImageFileName) * sizeof(WCHAR);
617 SpiCur->ImageName.MaximumLength = inLen;
618 SpiCur->ImageName.Buffer = (void*)(pCur+curSize);
619
620 // copy name to the end of the struct
621 if(pr != PsIdleProcess)
622 {
623 RtlInitAnsiString(&imgName, pr->ImageFileName);
624 RtlAnsiStringToUnicodeString(&SpiCur->ImageName, &imgName, FALSE);
625 }
626 else
627 {
628 RtlInitUnicodeString(&SpiCur->ImageName, NULL);
629 }
630
631 SpiCur->BasePriority = pr->Pcb.BasePriority;
632 SpiCur->UniqueProcessId = pr->UniqueProcessId;
633 SpiCur->InheritedFromUniqueProcessId = pr->InheritedFromUniqueProcessId;
634 SpiCur->HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
635 SpiCur->PeakVirtualSize = pr->PeakVirtualSize;
636 SpiCur->VirtualSize = pr->VirtualSize.QuadPart;
637 SpiCur->PageFaultCount = pr->LastFaultCount;
638 SpiCur->PeakWorkingSetSize = pr->Vm.PeakWorkingSetSize; // Is this right using ->Vm. here ?
639 SpiCur->WorkingSetSize = pr->Vm.WorkingSetSize; // Is this right using ->Vm. here ?
640 SpiCur->QuotaPeakPagedPoolUsage =
641 pr->QuotaPeakPoolUsage[0];
642 SpiCur->QuotaPagedPoolUsage =
643 pr->QuotaPoolUsage[0];
644 SpiCur->QuotaPeakNonPagedPoolUsage =
645 pr->QuotaPeakPoolUsage[1];
646 SpiCur->QuotaNonPagedPoolUsage =
647 pr->QuotaPoolUsage[1];
648 SpiCur->PagefileUsage = pr->PagefileUsage; // FIXME
649 SpiCur->PeakPagefileUsage = pr->PeakPagefileUsage;
650 // KJK::Hyperion: I don't know what does this mean. VM_COUNTERS
651 // doesn't seem to contain any equivalent field
652 //SpiCur->TotalPrivateBytes = pr->NumberOfPrivatePages; //FIXME: bytes != pages
653
654 current_entry = pr->ThreadListHead.Flink;
655 while (current_entry != &pr->ThreadListHead)
656 {
657 current = CONTAINING_RECORD(current_entry, ETHREAD,
658 ThreadListEntry);
659
660 SpiCur->TH[i].KernelTime.QuadPart = current->Tcb.KernelTime * 100000LL;
661 SpiCur->TH[i].UserTime.QuadPart = current->Tcb.UserTime * 100000LL;
662 // SpiCur->TH[i].CreateTime = current->CreateTime;
663 SpiCur->TH[i].WaitTime = current->Tcb.WaitTime;
664 SpiCur->TH[i].StartAddress = (PVOID) current->StartAddress;
665 SpiCur->TH[i].ClientId = current->Cid;
666 SpiCur->TH[i].Priority = current->Tcb.Priority;
667 SpiCur->TH[i].BasePriority = current->Tcb.BasePriority;
668 SpiCur->TH[i].ContextSwitches = current->Tcb.ContextSwitches;
669 SpiCur->TH[i].ThreadState = current->Tcb.State;
670 SpiCur->TH[i].WaitReason = current->Tcb.WaitReason;
671 i++;
672 current_entry = current_entry->Flink;
673 }
674
675 pr = PsGetNextProcess(pr);
676 nThreads = 0;
677 if ((pr == syspr) || (pr == NULL))
678 {
679 SpiCur->NextEntryOffset = 0;
680 break;
681 }
682 else
683 pCur = pCur + curSize + inLen;
684 } while ((pr != syspr) && (pr != NULL));
685
686 if(pr != NULL)
687 {
688 ObDereferenceObject(pr);
689 }
690
691 *ReqSize = ovlSize;
692 return (STATUS_SUCCESS);
693 }
694
695 /* Class 6 - Call Count Information */
696 QSI_DEF(SystemCallCountInformation)
697 {
698 /* FIXME */
699 DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
700 return (STATUS_NOT_IMPLEMENTED);
701 }
702
703 /* Class 7 - Device Information */
704 QSI_DEF(SystemDeviceInformation)
705 {
706 PSYSTEM_DEVICE_INFORMATION Sdi
707 = (PSYSTEM_DEVICE_INFORMATION) Buffer;
708 PCONFIGURATION_INFORMATION ConfigInfo;
709
710 *ReqSize = sizeof (SYSTEM_DEVICE_INFORMATION);
711 /*
712 * Check user buffer's size
713 */
714 if (Size < sizeof (SYSTEM_DEVICE_INFORMATION))
715 {
716 return (STATUS_INFO_LENGTH_MISMATCH);
717 }
718
719 ConfigInfo = IoGetConfigurationInformation ();
720
721 Sdi->NumberOfDisks = ConfigInfo->DiskCount;
722 Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
723 Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
724 Sdi->NumberOfTapes = ConfigInfo->TapeCount;
725 Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
726 Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
727
728 return (STATUS_SUCCESS);
729 }
730
731 /* Class 8 - Processor Performance Information */
732 QSI_DEF(SystemProcessorPerformanceInformation)
733 {
734 PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
735 = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
736
737 ULONG i;
738 LARGE_INTEGER CurrentTime;
739 PKPRCB Prcb;
740
741 *ReqSize = KeNumberProcessors * sizeof (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
742 /*
743 * Check user buffer's size
744 */
745 if (Size < KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION))
746 {
747 return (STATUS_INFO_LENGTH_MISMATCH);
748 }
749
750 CurrentTime.QuadPart = KeQueryInterruptTime();
751 Prcb = ((PKPCR)KPCR_BASE)->Prcb;
752 for (i = 0; i < KeNumberProcessors; i++)
753 {
754 Spi->IdleTime.QuadPart = (Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime) * 100000LL; // IdleTime
755 Spi->KernelTime.QuadPart = Prcb->KernelTime * 100000LL; // KernelTime
756 Spi->UserTime.QuadPart = Prcb->UserTime * 100000LL;
757 Spi->DpcTime.QuadPart = Prcb->DpcTime * 100000LL;
758 Spi->InterruptTime.QuadPart = Prcb->InterruptTime * 100000LL;
759 Spi->InterruptCount = Prcb->InterruptCount; // Interrupt Count
760 Spi++;
761 Prcb = (PKPRCB)((ULONG_PTR)Prcb + PAGE_SIZE);
762 }
763
764 return (STATUS_SUCCESS);
765 }
766
767 /* Class 9 - Flags Information */
768 QSI_DEF(SystemFlagsInformation)
769 {
770 if (sizeof (SYSTEM_FLAGS_INFORMATION) != Size)
771 {
772 * ReqSize = sizeof (SYSTEM_FLAGS_INFORMATION);
773 return (STATUS_INFO_LENGTH_MISMATCH);
774 }
775 ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
776 return (STATUS_SUCCESS);
777 }
778
779 SSI_DEF(SystemFlagsInformation)
780 {
781 if (sizeof (SYSTEM_FLAGS_INFORMATION) != Size)
782 {
783 return (STATUS_INFO_LENGTH_MISMATCH);
784 }
785 NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
786 return (STATUS_SUCCESS);
787 }
788
789 /* Class 10 - Call Time Information */
790 QSI_DEF(SystemCallTimeInformation)
791 {
792 /* FIXME */
793 DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
794 return (STATUS_NOT_IMPLEMENTED);
795 }
796
797 /* Class 11 - Module Information */
798 QSI_DEF(SystemModuleInformation)
799 {
800 return LdrpQueryModuleInformation(Buffer, Size, ReqSize);
801 }
802
803 /* Class 12 - Locks Information */
804 QSI_DEF(SystemLocksInformation)
805 {
806 /* FIXME */
807 DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
808 return (STATUS_NOT_IMPLEMENTED);
809 }
810
811 /* Class 13 - Stack Trace Information */
812 QSI_DEF(SystemStackTraceInformation)
813 {
814 /* FIXME */
815 DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
816 return (STATUS_NOT_IMPLEMENTED);
817 }
818
819 /* Class 14 - Paged Pool Information */
820 QSI_DEF(SystemPagedPoolInformation)
821 {
822 /* FIXME */
823 DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
824 return (STATUS_NOT_IMPLEMENTED);
825 }
826
827 /* Class 15 - Non Paged Pool Information */
828 QSI_DEF(SystemNonPagedPoolInformation)
829 {
830 /* FIXME */
831 DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
832 return (STATUS_NOT_IMPLEMENTED);
833 }
834
835
836 VOID
837 ObpGetNextHandleByProcessCount(PSYSTEM_HANDLE_TABLE_ENTRY_INFO pshi,
838 PEPROCESS Process,
839 int Count);
840
841 /* Class 16 - Handle Information */
842 QSI_DEF(SystemHandleInformation)
843 {
844 PSYSTEM_HANDLE_INFORMATION Shi =
845 (PSYSTEM_HANDLE_INFORMATION) Buffer;
846
847 DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
848
849 if (Size < sizeof (SYSTEM_HANDLE_INFORMATION))
850 {
851 * ReqSize = sizeof (SYSTEM_HANDLE_INFORMATION);
852 return (STATUS_INFO_LENGTH_MISMATCH);
853 }
854
855 DPRINT("SystemHandleInformation 1\n");
856
857 PEPROCESS pr, syspr;
858 int curSize, i = 0;
859 ULONG hCount = 0;
860
861 /* First Calc Size from Count. */
862 syspr = PsGetNextProcess(NULL);
863 pr = syspr;
864
865 do
866 {
867 hCount = hCount + (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
868 pr = PsGetNextProcess(pr);
869
870 if ((pr == syspr) || (pr == NULL))
871 break;
872 } while ((pr != syspr) && (pr != NULL));
873
874 if(pr != NULL)
875 {
876 ObDereferenceObject(pr);
877 }
878
879 DPRINT("SystemHandleInformation 2\n");
880
881 curSize = sizeof(SYSTEM_HANDLE_INFORMATION)+
882 ( (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) * hCount) -
883 (sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO) ));
884
885 Shi->NumberOfHandles = hCount;
886
887 if (curSize > Size)
888 {
889 *ReqSize = curSize;
890 return (STATUS_INFO_LENGTH_MISMATCH);
891 }
892
893 DPRINT("SystemHandleInformation 3\n");
894
895 /* Now get Handles from all processs. */
896 syspr = PsGetNextProcess(NULL);
897 pr = syspr;
898
899 do
900 {
901 int Count = 0, HandleCount;
902
903 HandleCount = (pr->ObjectTable ? ObpGetHandleCountByHandleTable(pr->ObjectTable) : 0);
904
905 for (Count = 0; HandleCount > 0 ; HandleCount--)
906 {
907 ObpGetNextHandleByProcessCount( &Shi->Handles[i], pr, Count);
908 Count++;
909 i++;
910 }
911
912 pr = PsGetNextProcess(pr);
913
914 if ((pr == syspr) || (pr == NULL))
915 break;
916 } while ((pr != syspr) && (pr != NULL));
917
918 if(pr != NULL)
919 {
920 ObDereferenceObject(pr);
921 }
922
923 DPRINT("SystemHandleInformation 4\n");
924 return (STATUS_SUCCESS);
925
926 }
927 /*
928 SSI_DEF(SystemHandleInformation)
929 {
930
931 return (STATUS_SUCCESS);
932 }
933 */
934
935 /* Class 17 - Information */
936 QSI_DEF(SystemObjectInformation)
937 {
938 /* FIXME */
939 DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
940 return (STATUS_NOT_IMPLEMENTED);
941 }
942
943 /* Class 18 - Information */
944 QSI_DEF(SystemPageFileInformation)
945 {
946 SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
947
948 if (Size < sizeof (SYSTEM_PAGEFILE_INFORMATION))
949 {
950 * ReqSize = sizeof (SYSTEM_PAGEFILE_INFORMATION);
951 return (STATUS_INFO_LENGTH_MISMATCH);
952 }
953
954 UNICODE_STRING FileName; /* FIXME */
955
956 /* FIXME */
957 Spfi->NextEntryOffset = 0;
958
959 Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
960 Spfi->TotalInUse = MiUsedSwapPages;
961 Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
962 Spfi->PageFileName = FileName;
963 return (STATUS_SUCCESS);
964 }
965
966 /* Class 19 - Vdm Instemul Information */
967 QSI_DEF(SystemVdmInstemulInformation)
968 {
969 /* FIXME */
970 DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
971 return (STATUS_NOT_IMPLEMENTED);
972 }
973
974 /* Class 20 - Vdm Bop Information */
975 QSI_DEF(SystemVdmBopInformation)
976 {
977 /* FIXME */
978 DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
979 return (STATUS_NOT_IMPLEMENTED);
980 }
981
982 /* Class 21 - File Cache Information */
983 QSI_DEF(SystemFileCacheInformation)
984 {
985 SYSTEM_CACHE_INFORMATION *Sci = (SYSTEM_CACHE_INFORMATION *) Buffer;
986
987 if (Size < sizeof (SYSTEM_CACHE_INFORMATION))
988 {
989 * ReqSize = sizeof (SYSTEM_CACHE_INFORMATION);
990 return (STATUS_INFO_LENGTH_MISMATCH);
991 }
992 /* Return the Byte size not the page size. */
993 Sci->CurrentSize =
994 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE;
995 Sci->PeakSize =
996 MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
997
998 Sci->PageFaultCount = 0; /* FIXME */
999 Sci->MinimumWorkingSet = 0; /* FIXME */
1000 Sci->MaximumWorkingSet = 0; /* FIXME */
1001 Sci->TransitionSharedPages = 0; /* FIXME */
1002 Sci->TransitionSharedPagesPeak = 0; /* FIXME */
1003
1004 return (STATUS_SUCCESS);
1005 }
1006
1007 SSI_DEF(SystemFileCacheInformation)
1008 {
1009 if (Size < sizeof (SYSTEM_CACHE_INFORMATION))
1010 {
1011 return (STATUS_INFO_LENGTH_MISMATCH);
1012 }
1013 /* FIXME */
1014 DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
1015 return (STATUS_NOT_IMPLEMENTED);
1016 }
1017
1018 /* Class 22 - Pool Tag Information */
1019 QSI_DEF(SystemPoolTagInformation)
1020 {
1021 /* FIXME */
1022 DPRINT1("NtQuerySystemInformation - SystemPoolTagInformation not implemented\n");
1023 return (STATUS_NOT_IMPLEMENTED);
1024 }
1025
1026 /* Class 23 - Interrupt Information for all processors */
1027 QSI_DEF(SystemInterruptInformation)
1028 {
1029 PKPRCB Prcb;
1030 UINT i;
1031 ULONG ti;
1032 PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
1033
1034 if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
1035 {
1036 return (STATUS_INFO_LENGTH_MISMATCH);
1037 }
1038
1039 ti = KeQueryTimeIncrement();
1040
1041 Prcb = ((PKPCR)KPCR_BASE)->Prcb;
1042 for (i = 0; i < KeNumberProcessors; i++)
1043 {
1044 sii->ContextSwitches = Prcb->KeContextSwitches;
1045 sii->DpcCount = 0; /* FIXME */
1046 sii->DpcRate = 0; /* FIXME */
1047 sii->TimeIncrement = ti;
1048 sii->DpcBypassCount = 0; /* FIXME */
1049 sii->ApcBypassCount = 0; /* FIXME */
1050 sii++;
1051 Prcb = (PKPRCB)((ULONG_PTR)Prcb + PAGE_SIZE);
1052 }
1053
1054 return STATUS_SUCCESS;
1055 }
1056
1057 /* Class 24 - DPC Behaviour Information */
1058 QSI_DEF(SystemDpcBehaviourInformation)
1059 {
1060 /* FIXME */
1061 DPRINT1("NtQuerySystemInformation - SystemDpcBehaviourInformation not implemented\n");
1062 return (STATUS_NOT_IMPLEMENTED);
1063 }
1064
1065 SSI_DEF(SystemDpcBehaviourInformation)
1066 {
1067 /* FIXME */
1068 DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
1069 return (STATUS_NOT_IMPLEMENTED);
1070 }
1071
1072 /* Class 25 - Full Memory Information */
1073 QSI_DEF(SystemFullMemoryInformation)
1074 {
1075 PULONG Spi = (PULONG) Buffer;
1076
1077 PEPROCESS TheIdleProcess;
1078
1079 * ReqSize = sizeof (ULONG);
1080
1081 if (sizeof (ULONG) != Size)
1082 {
1083 return (STATUS_INFO_LENGTH_MISMATCH);
1084 }
1085 DPRINT("SystemFullMemoryInformation\n");
1086
1087 TheIdleProcess = PsIdleProcess;
1088
1089 DPRINT("PID: %d, KernelTime: %u PFFree: %d PFUsed: %d\n",
1090 TheIdleProcess->UniqueProcessId,
1091 TheIdleProcess->Pcb.KernelTime,
1092 MiFreeSwapPages,
1093 MiUsedSwapPages);
1094
1095 #ifndef NDEBUG
1096 MmPrintMemoryStatistic();
1097 #endif
1098
1099 *Spi = MiMemoryConsumers[MC_USER].PagesUsed;
1100
1101 return (STATUS_SUCCESS);
1102 }
1103
1104 /* Class 26 - Load Image */
1105 SSI_DEF(SystemLoadImage)
1106 {
1107 PSYSTEM_LOAD_IMAGE Sli = (PSYSTEM_LOAD_IMAGE)Buffer;
1108
1109 if (sizeof(SYSTEM_LOAD_IMAGE) != Size)
1110 {
1111 return(STATUS_INFO_LENGTH_MISMATCH);
1112 }
1113
1114 return(LdrpLoadImage(&Sli->ModuleName,
1115 &Sli->ModuleBase,
1116 &Sli->SectionPointer,
1117 &Sli->EntryPoint,
1118 &Sli->ExportDirectory));
1119 }
1120
1121 /* Class 27 - Unload Image */
1122 SSI_DEF(SystemUnloadImage)
1123 {
1124 PSYSTEM_UNLOAD_IMAGE Sui = (PSYSTEM_UNLOAD_IMAGE)Buffer;
1125
1126 if (sizeof(SYSTEM_UNLOAD_IMAGE) != Size)
1127 {
1128 return(STATUS_INFO_LENGTH_MISMATCH);
1129 }
1130
1131 return(LdrpUnloadImage(Sui->ModuleBase));
1132 }
1133
1134 /* Class 28 - Time Adjustment Information */
1135 QSI_DEF(SystemTimeAdjustmentInformation)
1136 {
1137 if (sizeof (SYSTEM_SET_TIME_ADJUSTMENT) > Size)
1138 {
1139 * ReqSize = sizeof (SYSTEM_SET_TIME_ADJUSTMENT);
1140 return (STATUS_INFO_LENGTH_MISMATCH);
1141 }
1142 /* FIXME: */
1143 DPRINT1("NtQuerySystemInformation - SystemTimeAdjustmentInformation not implemented\n");
1144 return (STATUS_NOT_IMPLEMENTED);
1145 }
1146
1147 SSI_DEF(SystemTimeAdjustmentInformation)
1148 {
1149 if (sizeof (SYSTEM_SET_TIME_ADJUSTMENT) > Size)
1150 {
1151 return (STATUS_INFO_LENGTH_MISMATCH);
1152 }
1153 /* FIXME: */
1154 DPRINT1("NtSetSystemInformation - SystemTimeAdjustmentInformation not implemented\n");
1155 return (STATUS_NOT_IMPLEMENTED);
1156 }
1157
1158 /* Class 29 - Summary Memory Information */
1159 QSI_DEF(SystemSummaryMemoryInformation)
1160 {
1161 /* FIXME */
1162 DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
1163 return (STATUS_NOT_IMPLEMENTED);
1164 }
1165
1166 /* Class 30 - Next Event Id Information */
1167 QSI_DEF(SystemNextEventIdInformation)
1168 {
1169 /* FIXME */
1170 DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
1171 return (STATUS_NOT_IMPLEMENTED);
1172 }
1173
1174 /* Class 31 - Event Ids Information */
1175 QSI_DEF(SystemEventIdsInformation)
1176 {
1177 /* FIXME */
1178 DPRINT1("NtQuerySystemInformation - SystemEventIdsInformation not implemented\n");
1179 return (STATUS_NOT_IMPLEMENTED);
1180 }
1181
1182 /* Class 32 - Crash Dump Information */
1183 QSI_DEF(SystemCrashDumpInformation)
1184 {
1185 /* FIXME */
1186 DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
1187 return (STATUS_NOT_IMPLEMENTED);
1188 }
1189
1190 /* Class 33 - Exception Information */
1191 QSI_DEF(SystemExceptionInformation)
1192 {
1193 /* FIXME */
1194 DPRINT1("NtQuerySystemInformation - SystemExceptionInformation not implemented\n");
1195 return (STATUS_NOT_IMPLEMENTED);
1196 }
1197
1198 /* Class 34 - Crash Dump State Information */
1199 QSI_DEF(SystemCrashDumpStateInformation)
1200 {
1201 /* FIXME */
1202 DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
1203 return (STATUS_NOT_IMPLEMENTED);
1204 }
1205
1206 /* Class 35 - Kernel Debugger Information */
1207 QSI_DEF(SystemKernelDebuggerInformation)
1208 {
1209 /* FIXME */
1210 DPRINT1("NtQuerySystemInformation - SystemKernelDebuggerInformation not implemented\n");
1211 return (STATUS_NOT_IMPLEMENTED);
1212 }
1213
1214 /* Class 36 - Context Switch Information */
1215 QSI_DEF(SystemContextSwitchInformation)
1216 {
1217 /* FIXME */
1218 DPRINT1("NtQuerySystemInformation - SystemContextSwitchInformation not implemented\n");
1219 return (STATUS_NOT_IMPLEMENTED);
1220 }
1221
1222 /* Class 37 - Registry Quota Information */
1223 QSI_DEF(SystemRegistryQuotaInformation)
1224 {
1225 PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
1226
1227 *ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
1228 if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
1229 {
1230 return STATUS_INFO_LENGTH_MISMATCH;
1231 }
1232
1233 DPRINT1("Faking max registry size of 32 MB\n");
1234 srqi->RegistryQuotaAllowed = 0x2000000;
1235 srqi->RegistryQuotaUsed = 0x200000;
1236 srqi->Reserved1 = (void*)0x200000;
1237
1238 return STATUS_SUCCESS;
1239 }
1240
1241 SSI_DEF(SystemRegistryQuotaInformation)
1242 {
1243 /* FIXME */
1244 DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
1245 return (STATUS_NOT_IMPLEMENTED);
1246 }
1247
1248 /* Class 38 - Load And Call Image */
1249 SSI_DEF(SystemLoadAndCallImage)
1250 {
1251 PSYSTEM_LOAD_AND_CALL_IMAGE Slci = (PSYSTEM_LOAD_AND_CALL_IMAGE)Buffer;
1252
1253 if (sizeof(SYSTEM_LOAD_AND_CALL_IMAGE) != Size)
1254 {
1255 return(STATUS_INFO_LENGTH_MISMATCH);
1256 }
1257
1258 return(LdrpLoadAndCallImage(&Slci->ModuleName));
1259 }
1260
1261 /* Class 39 - Priority Separation */
1262 SSI_DEF(SystemPrioritySeperation)
1263 {
1264 /* FIXME */
1265 DPRINT1("NtSetSystemInformation - SystemPrioritySeperation not implemented\n");
1266 return (STATUS_NOT_IMPLEMENTED);
1267 }
1268
1269 /* Class 40 - Plug Play Bus Information */
1270 QSI_DEF(SystemPlugPlayBusInformation)
1271 {
1272 /* FIXME */
1273 DPRINT1("NtQuerySystemInformation - SystemPlugPlayBusInformation not implemented\n");
1274 return (STATUS_NOT_IMPLEMENTED);
1275 }
1276
1277 /* Class 41 - Dock Information */
1278 QSI_DEF(SystemDockInformation)
1279 {
1280 /* FIXME */
1281 DPRINT1("NtQuerySystemInformation - SystemDockInformation not implemented\n");
1282 return (STATUS_NOT_IMPLEMENTED);
1283 }
1284
1285 /* Class 42 - Power Information */
1286 QSI_DEF(SystemPowerInformation)
1287 {
1288 /* FIXME */
1289 DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
1290 return (STATUS_NOT_IMPLEMENTED);
1291 }
1292
1293 /* Class 43 - Processor Speed Information */
1294 QSI_DEF(SystemProcessorSpeedInformation)
1295 {
1296 /* FIXME */
1297 DPRINT1("NtQuerySystemInformation - SystemProcessorSpeedInformation not implemented\n");
1298 return (STATUS_NOT_IMPLEMENTED);
1299 }
1300
1301 /* Class 44 - Current Time Zone Information */
1302 QSI_DEF(SystemCurrentTimeZoneInformation)
1303 {
1304 * ReqSize = sizeof (TIME_ZONE_INFORMATION);
1305
1306 if (sizeof (TIME_ZONE_INFORMATION) != Size)
1307 {
1308 return STATUS_INFO_LENGTH_MISMATCH;
1309 }
1310
1311 /* Copy the time zone information struct */
1312 memcpy(Buffer,
1313 &ExpTimeZoneInfo,
1314 sizeof(TIME_ZONE_INFORMATION));
1315
1316 return STATUS_SUCCESS;
1317 }
1318
1319
1320 SSI_DEF(SystemCurrentTimeZoneInformation)
1321 {
1322 /* Check user buffer's size */
1323 if (Size < sizeof (TIME_ZONE_INFORMATION))
1324 {
1325 return STATUS_INFO_LENGTH_MISMATCH;
1326 }
1327
1328 return ExpSetTimeZoneInformation((PTIME_ZONE_INFORMATION)Buffer);
1329 }
1330
1331
1332 /* Class 45 - Lookaside Information */
1333 QSI_DEF(SystemLookasideInformation)
1334 {
1335 /* FIXME */
1336 DPRINT1("NtQuerySystemInformation - SystemLookasideInformation not implemented\n");
1337 return (STATUS_NOT_IMPLEMENTED);
1338 }
1339
1340
1341 /* Class 46 - Set time slip event */
1342 SSI_DEF(SystemSetTimeSlipEvent)
1343 {
1344 /* FIXME */
1345 DPRINT1("NtSetSystemInformation - SystemSetTimSlipEvent not implemented\n");
1346 return (STATUS_NOT_IMPLEMENTED);
1347 }
1348
1349
1350 /* Class 47 - Create a new session (TSE) */
1351 SSI_DEF(SystemCreateSession)
1352 {
1353 /* FIXME */
1354 DPRINT1("NtSetSystemInformation - SystemCreateSession not implemented\n");
1355 return (STATUS_NOT_IMPLEMENTED);
1356 }
1357
1358
1359 /* Class 48 - Delete an existing session (TSE) */
1360 SSI_DEF(SystemDeleteSession)
1361 {
1362 /* FIXME */
1363 DPRINT1("NtSetSystemInformation - SystemDeleteSession not implemented\n");
1364 return (STATUS_NOT_IMPLEMENTED);
1365 }
1366
1367
1368 /* Class 49 - UNKNOWN */
1369 QSI_DEF(SystemInvalidInfoClass4)
1370 {
1371 /* FIXME */
1372 DPRINT1("NtQuerySystemInformation - SystemInvalidInfoClass4 not implemented\n");
1373 return (STATUS_NOT_IMPLEMENTED);
1374 }
1375
1376
1377 /* Class 50 - System range start address */
1378 QSI_DEF(SystemRangeStartInformation)
1379 {
1380 /* FIXME */
1381 DPRINT1("NtQuerySystemInformation - SystemRangeStartInformation not implemented\n");
1382 return (STATUS_NOT_IMPLEMENTED);
1383 }
1384
1385
1386 /* Class 51 - Driver verifier information */
1387 QSI_DEF(SystemVerifierInformation)
1388 {
1389 /* FIXME */
1390 DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
1391 return (STATUS_NOT_IMPLEMENTED);
1392 }
1393
1394
1395 SSI_DEF(SystemVerifierInformation)
1396 {
1397 /* FIXME */
1398 DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
1399 return (STATUS_NOT_IMPLEMENTED);
1400 }
1401
1402
1403 /* Class 52 - Add a driver verifier */
1404 SSI_DEF(SystemAddVerifier)
1405 {
1406 /* FIXME */
1407 DPRINT1("NtSetSystemInformation - SystemAddVerifier not implemented\n");
1408 return (STATUS_NOT_IMPLEMENTED);
1409 }
1410
1411
1412 /* Class 53 - A session's processes */
1413 QSI_DEF(SystemSessionProcessesInformation)
1414 {
1415 /* FIXME */
1416 DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
1417 return (STATUS_NOT_IMPLEMENTED);
1418 }
1419
1420
1421 /* Query/Set Calls Table */
1422 typedef
1423 struct _QSSI_CALLS
1424 {
1425 NTSTATUS (* Query) (PVOID,ULONG,PULONG);
1426 NTSTATUS (* Set) (PVOID,ULONG);
1427
1428 } QSSI_CALLS;
1429
1430 // QS Query & Set
1431 // QX Query
1432 // XS Set
1433 // XX unknown behaviour
1434 //
1435 #define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
1436 #define SI_QX(n) {QSI_USE(n),NULL}
1437 #define SI_XS(n) {NULL,SSI_USE(n)}
1438 #define SI_XX(n) {NULL,NULL}
1439
1440 static
1441 QSSI_CALLS
1442 CallQS [] =
1443 {
1444 SI_QX(SystemBasicInformation),
1445 SI_QX(SystemProcessorInformation),
1446 SI_QX(SystemPerformanceInformation),
1447 SI_QX(SystemTimeOfDayInformation),
1448 SI_QX(SystemPathInformation), /* should be SI_XX */
1449 SI_QX(SystemProcessInformation),
1450 SI_QX(SystemCallCountInformation),
1451 SI_QX(SystemDeviceInformation),
1452 SI_QX(SystemProcessorPerformanceInformation),
1453 SI_QS(SystemFlagsInformation),
1454 SI_QX(SystemCallTimeInformation), /* should be SI_XX */
1455 SI_QX(SystemModuleInformation),
1456 SI_QX(SystemLocksInformation),
1457 SI_QX(SystemStackTraceInformation), /* should be SI_XX */
1458 SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
1459 SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
1460 SI_QX(SystemHandleInformation),
1461 SI_QX(SystemObjectInformation),
1462 SI_QX(SystemPageFileInformation),
1463 SI_QX(SystemVdmInstemulInformation),
1464 SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
1465 SI_QS(SystemFileCacheInformation),
1466 SI_QX(SystemPoolTagInformation),
1467 SI_QX(SystemInterruptInformation),
1468 SI_QS(SystemDpcBehaviourInformation),
1469 SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
1470 SI_XS(SystemLoadImage),
1471 SI_XS(SystemUnloadImage),
1472 SI_QS(SystemTimeAdjustmentInformation),
1473 SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
1474 SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
1475 SI_QX(SystemEventIdsInformation), /* it should be SI_XX */
1476 SI_QX(SystemCrashDumpInformation),
1477 SI_QX(SystemExceptionInformation),
1478 SI_QX(SystemCrashDumpStateInformation),
1479 SI_QX(SystemKernelDebuggerInformation),
1480 SI_QX(SystemContextSwitchInformation),
1481 SI_QS(SystemRegistryQuotaInformation),
1482 SI_XS(SystemLoadAndCallImage),
1483 SI_XS(SystemPrioritySeperation),
1484 SI_QX(SystemPlugPlayBusInformation), /* it should be SI_XX */
1485 SI_QX(SystemDockInformation), /* it should be SI_XX */
1486 SI_QX(SystemPowerInformation), /* it should be SI_XX */
1487 SI_QX(SystemProcessorSpeedInformation), /* it should be SI_XX */
1488 SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
1489 SI_QX(SystemLookasideInformation),
1490 SI_XS(SystemSetTimeSlipEvent),
1491 SI_XS(SystemCreateSession),
1492 SI_XS(SystemDeleteSession),
1493 SI_QX(SystemInvalidInfoClass4), /* it should be SI_XX */
1494 SI_QX(SystemRangeStartInformation),
1495 SI_QS(SystemVerifierInformation),
1496 SI_XS(SystemAddVerifier),
1497 SI_QX(SystemSessionProcessesInformation)
1498 };
1499
1500
1501 /*
1502 * @implemented
1503 */
1504 NTSTATUS STDCALL
1505 NtQuerySystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
1506 OUT PVOID UnsafeSystemInformation,
1507 IN ULONG Length,
1508 OUT PULONG UnsafeResultLength)
1509 {
1510 ULONG ResultLength;
1511 PVOID SystemInformation;
1512 NTSTATUS Status;
1513 NTSTATUS FStatus;
1514
1515 PAGED_CODE();
1516
1517 /* DPRINT("NtQuerySystemInformation Start. Class:%d\n",
1518 SystemInformationClass );
1519 */
1520 /*if (ExGetPreviousMode() == KernelMode)
1521 {*/
1522 SystemInformation = UnsafeSystemInformation;
1523 /*}
1524 else
1525 {
1526 SystemInformation = ExAllocatePool(NonPagedPool, Length);
1527 if (SystemInformation == NULL)
1528 {
1529 return(STATUS_NO_MEMORY);
1530 }
1531 }*/
1532
1533 /* Clear user buffer. */
1534 RtlZeroMemory(SystemInformation, Length);
1535
1536 /*
1537 * Check the request is valid.
1538 */
1539 if ((SystemInformationClass >= SystemInformationClassMin) &&
1540 (SystemInformationClass < SystemInformationClassMax))
1541 {
1542 if (NULL != CallQS [SystemInformationClass].Query)
1543 {
1544 /*
1545 * Hand the request to a subhandler.
1546 */
1547 FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
1548 Length,
1549 &ResultLength);
1550 /*if (ExGetPreviousMode() != KernelMode)
1551 {
1552 Status = MmCopyToCaller(UnsafeSystemInformation,
1553 SystemInformation,
1554 Length);
1555 ExFreePool(SystemInformation);
1556 if (!NT_SUCCESS(Status))
1557 {
1558 return(Status);
1559 }
1560 }*/
1561 if (UnsafeResultLength != NULL)
1562 {
1563 /*if (ExGetPreviousMode() == KernelMode)
1564 {
1565 *UnsafeResultLength = ResultLength;
1566 }
1567 else
1568 {*/
1569 Status = MmCopyToCaller(UnsafeResultLength,
1570 &ResultLength,
1571 sizeof(ULONG));
1572 if (!NT_SUCCESS(Status))
1573 {
1574 return(Status);
1575 }
1576 /*}*/
1577 }
1578 return(FStatus);
1579 }
1580 }
1581 return (STATUS_INVALID_INFO_CLASS);
1582 }
1583
1584
1585 NTSTATUS
1586 STDCALL
1587 NtSetSystemInformation (
1588 IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
1589 IN PVOID SystemInformation,
1590 IN ULONG SystemInformationLength
1591 )
1592 {
1593 PAGED_CODE();
1594
1595 /*
1596 * If called from user mode, check
1597 * possible unsafe arguments.
1598 */
1599 #if 0
1600 if (KernelMode != KeGetPreviousMode())
1601 {
1602 // Check arguments
1603 //ProbeForWrite(
1604 // SystemInformation,
1605 // Length
1606 // );
1607 //ProbeForWrite(
1608 // ResultLength,
1609 // sizeof (ULONG)
1610 // );
1611 }
1612 #endif
1613 /*
1614 * Check the request is valid.
1615 */
1616 if ( (SystemInformationClass >= SystemInformationClassMin)
1617 && (SystemInformationClass < SystemInformationClassMax)
1618 )
1619 {
1620 if (NULL != CallQS [SystemInformationClass].Set)
1621 {
1622 /*
1623 * Hand the request to a subhandler.
1624 */
1625 return CallQS [SystemInformationClass].Set (
1626 SystemInformation,
1627 SystemInformationLength
1628 );
1629 }
1630 }
1631 return (STATUS_INVALID_INFO_CLASS);
1632 }
1633
1634
1635 NTSTATUS
1636 STDCALL
1637 NtFlushInstructionCache (
1638 IN HANDLE ProcessHandle,
1639 IN PVOID BaseAddress,
1640 IN UINT NumberOfBytesToFlush
1641 )
1642 {
1643 PAGED_CODE();
1644
1645 __asm__("wbinvd\n");
1646 return STATUS_SUCCESS;
1647 }
1648
1649
1650 /* EOF */
A free Windows-compatible Operating System