mirror of
https://github.com/reactos/reactos.git
synced 2024-12-28 18:15:11 +00:00
4c8a2a8815
- Implement firmware environment variable read/write APIs - Add, fix and improve related definitions and declarations - Add kernel32:UEFIFirmware apitest CORE-11954
3068 lines
93 KiB
C
3068 lines
93 KiB
C
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS kernel
|
|
* FILE: ntoskrnl/ex/sysinfo.c
|
|
* PURPOSE: System information functions
|
|
*
|
|
* PROGRAMMERS: David Welch (welch@mcmail.com)
|
|
* Aleksey Bragin (aleksey@reactos.org)
|
|
*/
|
|
|
|
/* INCLUDES *****************************************************************/
|
|
|
|
#include <ntoskrnl.h>
|
|
#include <wmidata.h>
|
|
#include <wmistr.h>
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
/* The maximum size of an environment value (in bytes) */
|
|
#define MAX_ENVVAL_SIZE 1024
|
|
|
|
#define SIG_ACPI 0x41435049
|
|
#define SIG_FIRM 0x4649524D
|
|
#define SIG_RSMB 0x52534D42
|
|
|
|
extern LIST_ENTRY HandleTableListHead;
|
|
extern EX_PUSH_LOCK HandleTableListLock;
|
|
|
|
FAST_MUTEX ExpEnvironmentLock;
|
|
ERESOURCE ExpFirmwareTableResource;
|
|
LIST_ENTRY ExpFirmwareTableProviderListHead;
|
|
|
|
FORCEINLINE
|
|
NTSTATUS
|
|
ExpConvertLdrModuleToRtlModule(IN ULONG ModuleCount,
|
|
IN PLDR_DATA_TABLE_ENTRY LdrEntry,
|
|
OUT PRTL_PROCESS_MODULE_INFORMATION ModuleInfo)
|
|
{
|
|
PCHAR p;
|
|
NTSTATUS Status;
|
|
ANSI_STRING ModuleName;
|
|
|
|
/* Fill it out */
|
|
ModuleInfo->MappedBase = NULL;
|
|
ModuleInfo->ImageBase = LdrEntry->DllBase;
|
|
ModuleInfo->ImageSize = LdrEntry->SizeOfImage;
|
|
ModuleInfo->Flags = LdrEntry->Flags;
|
|
ModuleInfo->LoadCount = LdrEntry->LoadCount;
|
|
ModuleInfo->LoadOrderIndex = (USHORT)ModuleCount;
|
|
ModuleInfo->InitOrderIndex = 0;
|
|
|
|
/* Setup name */
|
|
RtlInitEmptyAnsiString(&ModuleName,
|
|
ModuleInfo->FullPathName,
|
|
sizeof(ModuleInfo->FullPathName));
|
|
|
|
/* Convert it */
|
|
Status = RtlUnicodeStringToAnsiString(&ModuleName,
|
|
&LdrEntry->FullDllName,
|
|
FALSE);
|
|
if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
|
|
{
|
|
/* Calculate offset to name */
|
|
p = ModuleName.Buffer + ModuleName.Length;
|
|
while ((p > ModuleName.Buffer) && (*--p))
|
|
{
|
|
/* Check if we found the separator */
|
|
if (*p == OBJ_NAME_PATH_SEPARATOR)
|
|
{
|
|
/* We did, break out */
|
|
p++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Set the offset */
|
|
ModuleInfo->OffsetToFileName = (USHORT)(p - ModuleName.Buffer);
|
|
}
|
|
else
|
|
{
|
|
/* Return empty name */
|
|
ModuleInfo->FullPathName[0] = ANSI_NULL;
|
|
ModuleInfo->OffsetToFileName = 0;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
ExpQueryModuleInformation(IN PLIST_ENTRY KernelModeList,
|
|
IN PLIST_ENTRY UserModeList,
|
|
OUT PRTL_PROCESS_MODULES Modules,
|
|
IN ULONG Length,
|
|
OUT PULONG ReturnLength)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG RequiredLength;
|
|
PRTL_PROCESS_MODULE_INFORMATION ModuleInfo;
|
|
PLDR_DATA_TABLE_ENTRY LdrEntry;
|
|
ULONG ModuleCount = 0;
|
|
PLIST_ENTRY NextEntry;
|
|
|
|
/* Setup defaults */
|
|
RequiredLength = FIELD_OFFSET(RTL_PROCESS_MODULES, Modules);
|
|
ModuleInfo = &Modules->Modules[0];
|
|
|
|
/* Loop the kernel list */
|
|
NextEntry = KernelModeList->Flink;
|
|
while (NextEntry != KernelModeList)
|
|
{
|
|
/* Get the entry */
|
|
LdrEntry = CONTAINING_RECORD(NextEntry,
|
|
LDR_DATA_TABLE_ENTRY,
|
|
InLoadOrderLinks);
|
|
|
|
/* Update size and check if we can manage one more entry */
|
|
RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
|
|
if (Length >= RequiredLength)
|
|
{
|
|
Status = ExpConvertLdrModuleToRtlModule(ModuleCount,
|
|
LdrEntry,
|
|
ModuleInfo);
|
|
|
|
/* Go to the next module */
|
|
ModuleInfo++;
|
|
}
|
|
else
|
|
{
|
|
/* Set error code */
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Update count and move to next entry */
|
|
ModuleCount++;
|
|
NextEntry = NextEntry->Flink;
|
|
}
|
|
|
|
/* Check if caller also wanted user modules */
|
|
if (UserModeList)
|
|
{
|
|
NextEntry = UserModeList->Flink;
|
|
while (NextEntry != UserModeList)
|
|
{
|
|
/* Get the entry */
|
|
LdrEntry = CONTAINING_RECORD(NextEntry,
|
|
LDR_DATA_TABLE_ENTRY,
|
|
InLoadOrderLinks);
|
|
|
|
/* Update size and check if we can manage one more entry */
|
|
RequiredLength += sizeof(RTL_PROCESS_MODULE_INFORMATION);
|
|
if (Length >= RequiredLength)
|
|
{
|
|
Status = ExpConvertLdrModuleToRtlModule(ModuleCount,
|
|
LdrEntry,
|
|
ModuleInfo);
|
|
|
|
/* Go to the next module */
|
|
ModuleInfo++;
|
|
}
|
|
else
|
|
{
|
|
/* Set error code */
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Update count and move to next entry */
|
|
ModuleCount++;
|
|
NextEntry = NextEntry->Flink;
|
|
}
|
|
}
|
|
|
|
/* Update return length */
|
|
if (ReturnLength) *ReturnLength = RequiredLength;
|
|
|
|
/* Validate the length again */
|
|
if (Length >= FIELD_OFFSET(RTL_PROCESS_MODULES, Modules))
|
|
{
|
|
/* Set the final count */
|
|
Modules->NumberOfModules = ModuleCount;
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, we failed */
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Done */
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
ExUnlockUserBuffer(PMDL Mdl)
|
|
{
|
|
MmUnlockPages(Mdl);
|
|
ExFreePoolWithTag(Mdl, TAG_MDL);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
ExLockUserBuffer(
|
|
PVOID BaseAddress,
|
|
ULONG Length,
|
|
KPROCESSOR_MODE AccessMode,
|
|
LOCK_OPERATION Operation,
|
|
PVOID *MappedSystemVa,
|
|
PMDL *OutMdl)
|
|
{
|
|
PMDL Mdl;
|
|
PAGED_CODE();
|
|
|
|
*MappedSystemVa = NULL;
|
|
*OutMdl = NULL;
|
|
|
|
/* Allocate an MDL for the buffer */
|
|
Mdl = IoAllocateMdl(BaseAddress, Length, FALSE, TRUE, NULL);
|
|
if (Mdl == NULL)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
/* Enter SEH for probing */
|
|
_SEH2_TRY
|
|
{
|
|
MmProbeAndLockPages(Mdl, AccessMode, Operation);
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
ExFreePoolWithTag(Mdl, TAG_MDL);
|
|
_SEH2_YIELD(return _SEH2_GetExceptionCode());
|
|
}
|
|
_SEH2_END;
|
|
|
|
/* Return the safe kernel mode buffer */
|
|
*MappedSystemVa = MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority);
|
|
if (*MappedSystemVa == NULL)
|
|
{
|
|
ExUnlockUserBuffer(Mdl);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
/* Return the MDL */
|
|
*OutMdl = Mdl;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
ExpGetRawSMBiosTable(
|
|
_Out_opt_ PVOID Buffer,
|
|
_Out_ ULONG * OutSize,
|
|
_In_ ULONG BufferSize)
|
|
{
|
|
NTSTATUS Status;
|
|
PVOID DataBlockObject;
|
|
PWNODE_ALL_DATA AllData;
|
|
ULONG WMIBufSize;
|
|
|
|
ASSERT(OutSize != NULL);
|
|
*OutSize = 0;
|
|
|
|
/* Open the data block object for the SMBIOS table */
|
|
Status = IoWMIOpenBlock(&MSSmBios_RawSMBiosTables_GUID,
|
|
WMIGUID_QUERY,
|
|
&DataBlockObject);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("IoWMIOpenBlock failed: 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Query the required buffer size */
|
|
WMIBufSize = 0;
|
|
Status = IoWMIQueryAllData(DataBlockObject, &WMIBufSize, NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("IoWMIOpenBlock failed: 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
AllData = ExAllocatePoolWithTag(PagedPool, WMIBufSize, 'itfS');
|
|
if (AllData == NULL)
|
|
{
|
|
DPRINT1("Failed to allocate %lu bytes for SMBIOS tables\n", WMIBufSize);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
/* Query the buffer data */
|
|
Status = IoWMIQueryAllData(DataBlockObject, &WMIBufSize, AllData);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("IoWMIOpenBlock failed: 0x%08lx\n", Status);
|
|
ExFreePoolWithTag(AllData, 'itfS');
|
|
return Status;
|
|
}
|
|
|
|
Status = STATUS_SUCCESS;
|
|
*OutSize = AllData->FixedInstanceSize;
|
|
if (Buffer != NULL)
|
|
{
|
|
if (BufferSize >= *OutSize)
|
|
{
|
|
RtlMoveMemory(Buffer, AllData + 1, *OutSize);
|
|
}
|
|
else
|
|
{
|
|
Status = STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
}
|
|
|
|
/* Free the buffer */
|
|
ExFreePoolWithTag(AllData, 'itfS');
|
|
return Status;
|
|
}
|
|
|
|
/* FUNCTIONS *****************************************************************/
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
ExGetCurrentProcessorCpuUsage(PULONG CpuUsage)
|
|
{
|
|
PKPRCB Prcb;
|
|
ULONG TotalTime;
|
|
ULONGLONG ScaledIdle;
|
|
|
|
Prcb = KeGetCurrentPrcb();
|
|
|
|
ScaledIdle = (ULONGLONG)Prcb->IdleThread->KernelTime * 100;
|
|
TotalTime = Prcb->KernelTime + Prcb->UserTime;
|
|
if (TotalTime != 0)
|
|
*CpuUsage = (ULONG)(100 - (ScaledIdle / TotalTime));
|
|
else
|
|
*CpuUsage = 0;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
VOID
|
|
NTAPI
|
|
ExGetCurrentProcessorCounts(PULONG IdleTime,
|
|
PULONG KernelAndUserTime,
|
|
PULONG ProcessorNumber)
|
|
{
|
|
PKPRCB Prcb;
|
|
|
|
Prcb = KeGetCurrentPrcb();
|
|
|
|
*IdleTime = Prcb->IdleThread->KernelTime;
|
|
*KernelAndUserTime = Prcb->KernelTime + Prcb->UserTime;
|
|
*ProcessorNumber = (ULONG)Prcb->Number;
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
BOOLEAN
|
|
NTAPI
|
|
ExIsProcessorFeaturePresent(IN ULONG ProcessorFeature)
|
|
{
|
|
/* Quick check to see if it exists at all */
|
|
if (ProcessorFeature >= PROCESSOR_FEATURE_MAX) return(FALSE);
|
|
|
|
/* Return our support for it */
|
|
return(SharedUserData->ProcessorFeatures[ProcessorFeature]);
|
|
}
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
BOOLEAN
|
|
NTAPI
|
|
ExVerifySuite(SUITE_TYPE SuiteType)
|
|
{
|
|
if (SuiteType == Personal) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
NtQuerySystemEnvironmentValue(IN PUNICODE_STRING VariableName,
|
|
OUT PWSTR ValueBuffer,
|
|
IN ULONG ValueBufferLength,
|
|
IN OUT PULONG ReturnLength OPTIONAL)
|
|
{
|
|
ANSI_STRING AName;
|
|
UNICODE_STRING WName;
|
|
ARC_STATUS Result;
|
|
PCH AnsiValueBuffer;
|
|
ANSI_STRING AValue;
|
|
UNICODE_STRING WValue;
|
|
KPROCESSOR_MODE PreviousMode;
|
|
NTSTATUS Status;
|
|
PAGED_CODE();
|
|
|
|
/* Check if the call came from user mode */
|
|
PreviousMode = ExGetPreviousMode();
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
_SEH2_TRY
|
|
{
|
|
/* Probe the input and output buffers */
|
|
ProbeForRead(VariableName, sizeof(UNICODE_STRING), sizeof(ULONG));
|
|
ProbeForWrite(ValueBuffer, ValueBufferLength, sizeof(WCHAR));
|
|
if (ReturnLength != NULL) ProbeForWriteUlong(ReturnLength);
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
/* Return the exception code */
|
|
_SEH2_YIELD(return _SEH2_GetExceptionCode());
|
|
}
|
|
_SEH2_END;
|
|
}
|
|
|
|
/* According to NTInternals the SeSystemEnvironmentName privilege is required! */
|
|
if (!SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege, PreviousMode))
|
|
{
|
|
DPRINT1("NtQuerySystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
|
|
/* Copy the name to kernel space if necessary */
|
|
Status = ProbeAndCaptureUnicodeString(&WName, PreviousMode, VariableName);
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Convert the name to ANSI and release the captured UNICODE string */
|
|
Status = RtlUnicodeStringToAnsiString(&AName, &WName, TRUE);
|
|
ReleaseCapturedUnicodeString(&WName, PreviousMode);
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Allocate a buffer for the ANSI environment variable */
|
|
AnsiValueBuffer = ExAllocatePoolWithTag(NonPagedPool, MAX_ENVVAL_SIZE, 'rvnE');
|
|
if (AnsiValueBuffer == NULL)
|
|
{
|
|
RtlFreeAnsiString(&AName);
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
/* Get the environment variable and free the ANSI name */
|
|
Result = HalGetEnvironmentVariable(AName.Buffer,
|
|
MAX_ENVVAL_SIZE,
|
|
AnsiValueBuffer);
|
|
RtlFreeAnsiString(&AName);
|
|
|
|
/* Check if we had success */
|
|
if (Result == ESUCCESS)
|
|
{
|
|
/* Copy the result back to the caller. */
|
|
_SEH2_TRY
|
|
{
|
|
/* Initialize ANSI string from the result */
|
|
RtlInitAnsiString(&AValue, AnsiValueBuffer);
|
|
|
|
/* Initialize a UNICODE string from the callers buffer */
|
|
RtlInitEmptyUnicodeString(&WValue, ValueBuffer, (USHORT)ValueBufferLength);
|
|
|
|
/* Convert the result to UNICODE */
|
|
Status = RtlAnsiStringToUnicodeString(&WValue, &AValue, FALSE);
|
|
|
|
if (ReturnLength != NULL)
|
|
*ReturnLength = WValue.Length;
|
|
}
|
|
_SEH2_EXCEPT(ExSystemExceptionFilter())
|
|
{
|
|
Status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
}
|
|
else
|
|
{
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
/* Free the allocated ANSI value buffer */
|
|
ExFreePoolWithTag(AnsiValueBuffer, 'rvnE');
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
NtSetSystemEnvironmentValue(IN PUNICODE_STRING VariableName,
|
|
IN PUNICODE_STRING Value)
|
|
{
|
|
UNICODE_STRING CapturedName, CapturedValue;
|
|
ANSI_STRING AName, AValue;
|
|
KPROCESSOR_MODE PreviousMode;
|
|
NTSTATUS Status;
|
|
|
|
PAGED_CODE();
|
|
|
|
PreviousMode = ExGetPreviousMode();
|
|
|
|
/*
|
|
* Copy the strings to kernel space if necessary
|
|
*/
|
|
Status = ProbeAndCaptureUnicodeString(&CapturedName,
|
|
PreviousMode,
|
|
VariableName);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
Status = ProbeAndCaptureUnicodeString(&CapturedValue,
|
|
PreviousMode,
|
|
Value);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
/*
|
|
* according to ntinternals the SeSystemEnvironmentName privilege is required!
|
|
*/
|
|
if (SeSinglePrivilegeCheck(SeSystemEnvironmentPrivilege,
|
|
PreviousMode))
|
|
{
|
|
/*
|
|
* convert the strings to ANSI
|
|
*/
|
|
Status = RtlUnicodeStringToAnsiString(&AName,
|
|
&CapturedName,
|
|
TRUE);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
Status = RtlUnicodeStringToAnsiString(&AValue,
|
|
&CapturedValue,
|
|
TRUE);
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
ARC_STATUS Result = HalSetEnvironmentVariable(AName.Buffer,
|
|
AValue.Buffer);
|
|
|
|
Status = (Result ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DPRINT1("NtSetSystemEnvironmentValue: Caller requires the SeSystemEnvironmentPrivilege privilege!\n");
|
|
Status = STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
|
|
ReleaseCapturedUnicodeString(&CapturedValue,
|
|
PreviousMode);
|
|
}
|
|
|
|
ReleaseCapturedUnicodeString(&CapturedName,
|
|
PreviousMode);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
NtEnumerateSystemEnvironmentValuesEx(IN ULONG InformationClass,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferLength)
|
|
{
|
|
UNIMPLEMENTED;
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
NtQuerySystemEnvironmentValueEx(
|
|
_In_ PUNICODE_STRING VariableName,
|
|
_In_ LPGUID VendorGuid,
|
|
_Out_opt_ PVOID Value,
|
|
_Inout_ PULONG ReturnLength,
|
|
_Out_opt_ PULONG Attributes)
|
|
{
|
|
UNIMPLEMENTED;
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
NtSetSystemEnvironmentValueEx(
|
|
_In_ PUNICODE_STRING VariableName,
|
|
_In_ LPGUID VendorGuid,
|
|
_In_reads_bytes_opt_(ValueLength) PVOID Value,
|
|
_In_ ULONG ValueLength,
|
|
_In_ ULONG Attributes)
|
|
{
|
|
UNIMPLEMENTED;
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* --- Query/Set System Information --- */
|
|
|
|
/*
|
|
* NOTE: QSI_DEF(n) and SSI_DEF(n) define _cdecl function symbols
|
|
* so the stack is popped only in one place on x86 platform.
|
|
*/
|
|
#define QSI_USE(n) QSI##n
|
|
#define QSI_DEF(n) \
|
|
static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)
|
|
|
|
#define SSI_USE(n) SSI##n
|
|
#define SSI_DEF(n) \
|
|
static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)
|
|
|
|
VOID
|
|
NTAPI
|
|
ExQueryPoolUsage(OUT PULONG PagedPoolPages,
|
|
OUT PULONG NonPagedPoolPages,
|
|
OUT PULONG PagedPoolAllocs,
|
|
OUT PULONG PagedPoolFrees,
|
|
OUT PULONG PagedPoolLookasideHits,
|
|
OUT PULONG NonPagedPoolAllocs,
|
|
OUT PULONG NonPagedPoolFrees,
|
|
OUT PULONG NonPagedPoolLookasideHits);
|
|
|
|
/* Class 0 - Basic Information */
|
|
QSI_DEF(SystemBasicInformation)
|
|
{
|
|
PSYSTEM_BASIC_INFORMATION Sbi
|
|
= (PSYSTEM_BASIC_INFORMATION) Buffer;
|
|
|
|
*ReqSize = sizeof(SYSTEM_BASIC_INFORMATION);
|
|
|
|
/* Check user buffer's size */
|
|
if (Size != sizeof(SYSTEM_BASIC_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
RtlZeroMemory(Sbi, Size);
|
|
Sbi->Reserved = 0;
|
|
Sbi->TimerResolution = KeMaximumIncrement;
|
|
Sbi->PageSize = PAGE_SIZE;
|
|
Sbi->NumberOfPhysicalPages = MmNumberOfPhysicalPages;
|
|
Sbi->LowestPhysicalPageNumber = (ULONG)MmLowestPhysicalPage;
|
|
Sbi->HighestPhysicalPageNumber = (ULONG)MmHighestPhysicalPage;
|
|
Sbi->AllocationGranularity = MM_VIRTMEM_GRANULARITY; /* hard coded on Intel? */
|
|
Sbi->MinimumUserModeAddress = 0x10000; /* Top of 64k */
|
|
Sbi->MaximumUserModeAddress = (ULONG_PTR)MmHighestUserAddress;
|
|
Sbi->ActiveProcessorsAffinityMask = KeActiveProcessors;
|
|
Sbi->NumberOfProcessors = KeNumberProcessors;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 1 - Processor Information */
|
|
QSI_DEF(SystemProcessorInformation)
|
|
{
|
|
PSYSTEM_PROCESSOR_INFORMATION Spi
|
|
= (PSYSTEM_PROCESSOR_INFORMATION) Buffer;
|
|
|
|
*ReqSize = sizeof(SYSTEM_PROCESSOR_INFORMATION);
|
|
|
|
/* Check user buffer's size */
|
|
if (Size < sizeof(SYSTEM_PROCESSOR_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
Spi->ProcessorArchitecture = KeProcessorArchitecture;
|
|
Spi->ProcessorLevel = KeProcessorLevel;
|
|
Spi->ProcessorRevision = KeProcessorRevision;
|
|
#if (NTDDI_VERSION < NTDDI_WIN8)
|
|
Spi->Reserved = 0;
|
|
#else
|
|
Spi->MaximumProcessors = 0;
|
|
#endif
|
|
Spi->ProcessorFeatureBits = KeFeatureBits;
|
|
|
|
DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
|
|
Spi->ProcessorLevel, Spi->ProcessorRevision);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 2 - Performance Information */
|
|
QSI_DEF(SystemPerformanceInformation)
|
|
{
|
|
LONG i;
|
|
ULONG IdleUser, IdleKernel;
|
|
PKPRCB Prcb;
|
|
PSYSTEM_PERFORMANCE_INFORMATION Spi
|
|
= (PSYSTEM_PERFORMANCE_INFORMATION) Buffer;
|
|
|
|
PEPROCESS TheIdleProcess;
|
|
|
|
*ReqSize = sizeof(SYSTEM_PERFORMANCE_INFORMATION);
|
|
|
|
/* Check user buffer's size */
|
|
if (Size < sizeof(SYSTEM_PERFORMANCE_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
TheIdleProcess = PsIdleProcess;
|
|
|
|
IdleKernel = KeQueryRuntimeProcess(&TheIdleProcess->Pcb, &IdleUser);
|
|
Spi->IdleProcessTime.QuadPart = UInt32x32To64(IdleKernel, KeMaximumIncrement);
|
|
Spi->IoReadTransferCount = IoReadTransferCount;
|
|
Spi->IoWriteTransferCount = IoWriteTransferCount;
|
|
Spi->IoOtherTransferCount = IoOtherTransferCount;
|
|
Spi->IoReadOperationCount = IoReadOperationCount;
|
|
Spi->IoWriteOperationCount = IoWriteOperationCount;
|
|
Spi->IoOtherOperationCount = IoOtherOperationCount;
|
|
for (i = 0; i < KeNumberProcessors; i ++)
|
|
{
|
|
Prcb = KiProcessorBlock[i];
|
|
if (Prcb)
|
|
{
|
|
Spi->IoReadTransferCount.QuadPart += Prcb->IoReadTransferCount.QuadPart;
|
|
Spi->IoWriteTransferCount.QuadPart += Prcb->IoWriteTransferCount.QuadPart;
|
|
Spi->IoOtherTransferCount.QuadPart += Prcb->IoOtherTransferCount.QuadPart;
|
|
Spi->IoReadOperationCount += Prcb->IoReadOperationCount;
|
|
Spi->IoWriteOperationCount += Prcb->IoWriteOperationCount;
|
|
Spi->IoOtherOperationCount += Prcb->IoOtherOperationCount;
|
|
}
|
|
}
|
|
|
|
Spi->AvailablePages = (ULONG)MmAvailablePages;
|
|
|
|
Spi->CommittedPages = MmTotalCommittedPages;
|
|
/*
|
|
* Add up the full system total + pagefile.
|
|
* All this make Taskmgr happy but not sure it is the right numbers.
|
|
* This too, fixes some of GlobalMemoryStatusEx numbers.
|
|
*/
|
|
Spi->CommitLimit = MmNumberOfPhysicalPages + MiFreeSwapPages + MiUsedSwapPages;
|
|
|
|
Spi->PeakCommitment = MmPeakCommitment;
|
|
Spi->PageFaultCount = 0; /* FIXME */
|
|
Spi->CopyOnWriteCount = 0; /* FIXME */
|
|
Spi->TransitionCount = 0; /* FIXME */
|
|
Spi->CacheTransitionCount = 0; /* FIXME */
|
|
Spi->DemandZeroCount = 0; /* FIXME */
|
|
Spi->PageReadCount = 0; /* FIXME */
|
|
Spi->PageReadIoCount = 0; /* FIXME */
|
|
Spi->CacheReadCount = 0; /* FIXME */
|
|
Spi->CacheIoCount = 0; /* FIXME */
|
|
Spi->DirtyPagesWriteCount = 0; /* FIXME */
|
|
Spi->DirtyWriteIoCount = 0; /* FIXME */
|
|
Spi->MappedPagesWriteCount = 0; /* FIXME */
|
|
Spi->MappedWriteIoCount = 0; /* FIXME */
|
|
|
|
Spi->PagedPoolPages = 0;
|
|
Spi->NonPagedPoolPages = 0;
|
|
Spi->PagedPoolAllocs = 0;
|
|
Spi->PagedPoolFrees = 0;
|
|
Spi->PagedPoolLookasideHits = 0;
|
|
Spi->NonPagedPoolAllocs = 0;
|
|
Spi->NonPagedPoolFrees = 0;
|
|
Spi->NonPagedPoolLookasideHits = 0;
|
|
ExQueryPoolUsage(&Spi->PagedPoolPages,
|
|
&Spi->NonPagedPoolPages,
|
|
&Spi->PagedPoolAllocs,
|
|
&Spi->PagedPoolFrees,
|
|
&Spi->PagedPoolLookasideHits,
|
|
&Spi->NonPagedPoolAllocs,
|
|
&Spi->NonPagedPoolFrees,
|
|
&Spi->NonPagedPoolLookasideHits);
|
|
Spi->FreeSystemPtes = 0; /* FIXME */
|
|
|
|
Spi->ResidentSystemCodePage = 0; /* FIXME */
|
|
|
|
Spi->TotalSystemDriverPages = 0; /* FIXME */
|
|
Spi->Spare3Count = 0; /* FIXME */
|
|
|
|
Spi->ResidentSystemCachePage = MiMemoryConsumers[MC_USER].PagesUsed; /* FIXME */
|
|
Spi->ResidentPagedPoolPage = 0; /* FIXME */
|
|
|
|
Spi->ResidentSystemDriverPage = 0; /* FIXME */
|
|
Spi->CcFastReadNoWait = 0; /* FIXME */
|
|
Spi->CcFastReadWait = 0; /* FIXME */
|
|
Spi->CcFastReadResourceMiss = 0; /* FIXME */
|
|
Spi->CcFastReadNotPossible = 0; /* FIXME */
|
|
|
|
Spi->CcFastMdlReadNoWait = 0; /* FIXME */
|
|
Spi->CcFastMdlReadWait = 0; /* FIXME */
|
|
Spi->CcFastMdlReadResourceMiss = 0; /* FIXME */
|
|
Spi->CcFastMdlReadNotPossible = 0; /* FIXME */
|
|
|
|
Spi->CcMapDataNoWait = CcMapDataNoWait;
|
|
Spi->CcMapDataWait = CcMapDataWait;
|
|
Spi->CcMapDataNoWaitMiss = 0; /* FIXME */
|
|
Spi->CcMapDataWaitMiss = 0; /* FIXME */
|
|
|
|
Spi->CcPinMappedDataCount = CcPinMappedDataCount;
|
|
Spi->CcPinReadNoWait = CcPinReadNoWait;
|
|
Spi->CcPinReadWait = CcPinReadWait;
|
|
Spi->CcPinReadNoWaitMiss = 0; /* FIXME */
|
|
Spi->CcPinReadWaitMiss = 0; /* FIXME */
|
|
Spi->CcCopyReadNoWait = 0; /* FIXME */
|
|
Spi->CcCopyReadWait = 0; /* FIXME */
|
|
Spi->CcCopyReadNoWaitMiss = 0; /* FIXME */
|
|
Spi->CcCopyReadWaitMiss = 0; /* FIXME */
|
|
|
|
Spi->CcMdlReadNoWait = 0; /* FIXME */
|
|
Spi->CcMdlReadWait = 0; /* FIXME */
|
|
Spi->CcMdlReadNoWaitMiss = 0; /* FIXME */
|
|
Spi->CcMdlReadWaitMiss = 0; /* FIXME */
|
|
Spi->CcReadAheadIos = 0; /* FIXME */
|
|
Spi->CcLazyWriteIos = CcLazyWriteIos;
|
|
Spi->CcLazyWritePages = CcLazyWritePages;
|
|
Spi->CcDataFlushes = CcDataFlushes;
|
|
Spi->CcDataPages = CcDataPages;
|
|
|
|
Spi->ContextSwitches = 0;
|
|
Spi->FirstLevelTbFills = 0;
|
|
Spi->SecondLevelTbFills = 0;
|
|
Spi->SystemCalls = 0;
|
|
for (i = 0; i < KeNumberProcessors; i ++)
|
|
{
|
|
Prcb = KiProcessorBlock[i];
|
|
if (Prcb)
|
|
{
|
|
Spi->ContextSwitches += KeGetContextSwitches(Prcb);
|
|
Spi->FirstLevelTbFills += Prcb->KeFirstLevelTbFills;
|
|
Spi->SecondLevelTbFills += Prcb->KeSecondLevelTbFills;
|
|
Spi->SystemCalls += Prcb->KeSystemCalls;
|
|
}
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 3 - Time Of Day Information */
|
|
QSI_DEF(SystemTimeOfDayInformation)
|
|
{
|
|
SYSTEM_TIMEOFDAY_INFORMATION Sti;
|
|
LARGE_INTEGER CurrentTime;
|
|
|
|
/* Set amount of written information to 0 */
|
|
*ReqSize = 0;
|
|
|
|
/* Check user buffer's size */
|
|
if (Size > sizeof(SYSTEM_TIMEOFDAY_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Get current time */
|
|
KeQuerySystemTime(&CurrentTime);
|
|
|
|
/* Zero local buffer */
|
|
RtlZeroMemory(&Sti, sizeof(SYSTEM_TIMEOFDAY_INFORMATION));
|
|
|
|
/* Fill local time structure */
|
|
Sti.BootTime= KeBootTime;
|
|
Sti.CurrentTime = CurrentTime;
|
|
Sti.TimeZoneBias.QuadPart = ExpTimeZoneBias.QuadPart;
|
|
Sti.TimeZoneId = ExpTimeZoneId;
|
|
Sti.Reserved = 0;
|
|
|
|
/* Copy as much as requested by caller */
|
|
RtlCopyMemory(Buffer, &Sti, Size);
|
|
|
|
/* Set amount of information we copied */
|
|
*ReqSize = Size;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 4 - Path Information (DEPRECATED) */
|
|
QSI_DEF(SystemPathInformation)
|
|
{
|
|
/*
|
|
* Since NT 3.51, this information class is trivially implemented.
|
|
* The path to the NT directory is now stored in KUSER_SHARED_DATA
|
|
* as the NtSystemRoot member.
|
|
* Windows Checked builds show the following message and break to
|
|
* the debugger before failing the function as not implemented.
|
|
*/
|
|
#if DBG
|
|
DPRINT1("EX: SystemPathInformation now available via SharedUserData\n");
|
|
// DbgBreakPoint(); // Not needed in ReactOS.
|
|
#endif
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 5 - Process Information */
|
|
QSI_DEF(SystemProcessInformation)
|
|
{
|
|
PSYSTEM_PROCESS_INFORMATION SpiCurrent;
|
|
PSYSTEM_THREAD_INFORMATION ThreadInfo;
|
|
PEPROCESS Process = NULL, SystemProcess;
|
|
PETHREAD CurrentThread;
|
|
ANSI_STRING ImageName;
|
|
ULONG CurrentSize;
|
|
USHORT ImageNameMaximumLength; // image name length in bytes
|
|
USHORT ImageNameLength;
|
|
PLIST_ENTRY CurrentEntry;
|
|
ULONG TotalSize = 0, ThreadsCount;
|
|
ULONG TotalUser, TotalKernel;
|
|
PUCHAR Current;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PUNICODE_STRING TempProcessImageName;
|
|
_SEH2_VOLATILE PUNICODE_STRING ProcessImageName = NULL;
|
|
PWCHAR szSrc;
|
|
BOOLEAN Overflow = FALSE;
|
|
|
|
_SEH2_TRY
|
|
{
|
|
/* scan the process list */
|
|
|
|
PSYSTEM_PROCESS_INFORMATION Spi
|
|
= (PSYSTEM_PROCESS_INFORMATION) Buffer;
|
|
|
|
*ReqSize = sizeof(SYSTEM_PROCESS_INFORMATION);
|
|
|
|
/* Check for overflow */
|
|
if (Size < sizeof(SYSTEM_PROCESS_INFORMATION))
|
|
{
|
|
Overflow = TRUE;
|
|
}
|
|
|
|
/* Zero user's buffer */
|
|
if (!Overflow) RtlZeroMemory(Spi, Size);
|
|
|
|
SystemProcess = PsIdleProcess;
|
|
Process = SystemProcess;
|
|
Current = (PUCHAR) Spi;
|
|
|
|
do
|
|
{
|
|
SpiCurrent = (PSYSTEM_PROCESS_INFORMATION) Current;
|
|
|
|
/* Lock the Process */
|
|
KeEnterCriticalRegion();
|
|
ExAcquirePushLockShared(&Process->ProcessLock);
|
|
|
|
if ((Process->ProcessExiting) &&
|
|
(Process->Pcb.Header.SignalState) &&
|
|
!(Process->ActiveThreads) &&
|
|
(IsListEmpty(&Process->Pcb.ThreadListHead)))
|
|
{
|
|
DPRINT1("Process %p (%s:%p) is a zombie\n",
|
|
Process, Process->ImageFileName, Process->UniqueProcessId);
|
|
CurrentSize = 0;
|
|
ImageNameMaximumLength = 0;
|
|
|
|
/* Unlock the Process */
|
|
ExReleasePushLockShared(&Process->ProcessLock);
|
|
KeLeaveCriticalRegion();
|
|
goto Skip;
|
|
}
|
|
|
|
ThreadsCount = 0;
|
|
CurrentEntry = Process->Pcb.ThreadListHead.Flink;
|
|
while (CurrentEntry != &Process->Pcb.ThreadListHead)
|
|
{
|
|
ThreadsCount++;
|
|
CurrentEntry = CurrentEntry->Flink;
|
|
}
|
|
|
|
// size of the structure for every process
|
|
CurrentSize = sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION) * ThreadsCount;
|
|
ImageNameLength = 0;
|
|
Status = SeLocateProcessImageName(Process, &TempProcessImageName);
|
|
ProcessImageName = TempProcessImageName;
|
|
szSrc = NULL;
|
|
if (NT_SUCCESS(Status) && (ProcessImageName->Length > 0))
|
|
{
|
|
szSrc = (PWCHAR)((PCHAR)ProcessImageName->Buffer + ProcessImageName->Length);
|
|
/* Loop the file name*/
|
|
while (szSrc > ProcessImageName->Buffer)
|
|
{
|
|
/* Make sure this isn't a backslash */
|
|
if (*--szSrc == OBJ_NAME_PATH_SEPARATOR)
|
|
{
|
|
szSrc++;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
ImageNameLength += sizeof(WCHAR);
|
|
}
|
|
}
|
|
}
|
|
if (!ImageNameLength && Process != PsIdleProcess)
|
|
{
|
|
ImageNameLength = (USHORT)strlen(Process->ImageFileName) * sizeof(WCHAR);
|
|
}
|
|
|
|
/* Round up the image name length as NT does */
|
|
if (ImageNameLength > 0)
|
|
ImageNameMaximumLength = ROUND_UP(ImageNameLength + sizeof(WCHAR), 8);
|
|
else
|
|
ImageNameMaximumLength = 0;
|
|
|
|
TotalSize += CurrentSize + ImageNameMaximumLength;
|
|
|
|
/* Check for overflow */
|
|
if (TotalSize > Size)
|
|
{
|
|
Overflow = TRUE;
|
|
}
|
|
|
|
/* Fill system information */
|
|
if (!Overflow)
|
|
{
|
|
SpiCurrent->NextEntryOffset = CurrentSize + ImageNameMaximumLength; // relative offset to the beginning of the next structure
|
|
SpiCurrent->NumberOfThreads = ThreadsCount;
|
|
SpiCurrent->CreateTime = Process->CreateTime;
|
|
SpiCurrent->ImageName.Length = ImageNameLength;
|
|
SpiCurrent->ImageName.MaximumLength = ImageNameMaximumLength;
|
|
SpiCurrent->ImageName.Buffer = (void*)(Current + CurrentSize);
|
|
|
|
/* Copy name to the end of the struct */
|
|
if(Process != PsIdleProcess)
|
|
{
|
|
if (szSrc)
|
|
{
|
|
RtlCopyMemory(SpiCurrent->ImageName.Buffer, szSrc, SpiCurrent->ImageName.Length);
|
|
}
|
|
else
|
|
{
|
|
RtlInitAnsiString(&ImageName, Process->ImageFileName);
|
|
Status = RtlAnsiStringToUnicodeString(&SpiCurrent->ImageName, &ImageName, FALSE);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
SpiCurrent->ImageName.Length = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
|
|
}
|
|
|
|
SpiCurrent->BasePriority = Process->Pcb.BasePriority;
|
|
SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
|
|
SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
|
|
|
|
/* PsIdleProcess shares its handle table with PsInitialSystemProcess,
|
|
* so return the handle count for System only, not Idle one. */
|
|
SpiCurrent->HandleCount = (Process == PsIdleProcess) ? 0 : ObGetProcessHandleCount(Process);
|
|
|
|
SpiCurrent->PeakVirtualSize = Process->PeakVirtualSize;
|
|
SpiCurrent->VirtualSize = Process->VirtualSize;
|
|
SpiCurrent->PageFaultCount = Process->Vm.PageFaultCount;
|
|
SpiCurrent->PeakWorkingSetSize = Process->Vm.PeakWorkingSetSize;
|
|
SpiCurrent->WorkingSetSize = Process->Vm.WorkingSetSize;
|
|
SpiCurrent->QuotaPeakPagedPoolUsage = Process->QuotaPeak[PsPagedPool];
|
|
SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[PsPagedPool];
|
|
SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[PsNonPagedPool];
|
|
SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[PsNonPagedPool];
|
|
SpiCurrent->PagefileUsage = Process->QuotaUsage[PsPageFile];
|
|
SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[PsPageFile];
|
|
SpiCurrent->PrivatePageCount = Process->CommitCharge;
|
|
ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(SpiCurrent + 1);
|
|
|
|
CurrentEntry = Process->Pcb.ThreadListHead.Flink;
|
|
while (CurrentEntry != &Process->Pcb.ThreadListHead)
|
|
{
|
|
CurrentThread = CONTAINING_RECORD(CurrentEntry, ETHREAD, Tcb.ThreadListEntry);
|
|
|
|
ThreadInfo->KernelTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.KernelTime, KeMaximumIncrement);
|
|
ThreadInfo->UserTime.QuadPart = UInt32x32To64(CurrentThread->Tcb.UserTime, KeMaximumIncrement);
|
|
ThreadInfo->CreateTime.QuadPart = CurrentThread->CreateTime.QuadPart;
|
|
ThreadInfo->WaitTime = CurrentThread->Tcb.WaitTime;
|
|
ThreadInfo->StartAddress = (PVOID) CurrentThread->StartAddress;
|
|
ThreadInfo->ClientId = CurrentThread->Cid;
|
|
ThreadInfo->Priority = CurrentThread->Tcb.Priority;
|
|
ThreadInfo->BasePriority = CurrentThread->Tcb.BasePriority;
|
|
ThreadInfo->ContextSwitches = CurrentThread->Tcb.ContextSwitches;
|
|
ThreadInfo->ThreadState = CurrentThread->Tcb.State;
|
|
ThreadInfo->WaitReason = CurrentThread->Tcb.WaitReason;
|
|
|
|
ThreadInfo++;
|
|
CurrentEntry = CurrentEntry->Flink;
|
|
}
|
|
|
|
/* Query total user/kernel times of a process */
|
|
TotalKernel = KeQueryRuntimeProcess(&Process->Pcb, &TotalUser);
|
|
SpiCurrent->UserTime.QuadPart = UInt32x32To64(TotalUser, KeMaximumIncrement);
|
|
SpiCurrent->KernelTime.QuadPart = UInt32x32To64(TotalKernel, KeMaximumIncrement);
|
|
}
|
|
|
|
if (ProcessImageName)
|
|
{
|
|
/* Release the memory allocated by SeLocateProcessImageName */
|
|
ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
|
|
ProcessImageName = NULL;
|
|
}
|
|
|
|
/* Unlock the Process */
|
|
ExReleasePushLockShared(&Process->ProcessLock);
|
|
KeLeaveCriticalRegion();
|
|
|
|
/* Handle idle process entry */
|
|
Skip:
|
|
if (Process == PsIdleProcess) Process = NULL;
|
|
|
|
Process = PsGetNextProcess(Process);
|
|
ThreadsCount = 0;
|
|
if ((Process == SystemProcess) || (Process == NULL))
|
|
{
|
|
if (!Overflow)
|
|
SpiCurrent->NextEntryOffset = 0;
|
|
break;
|
|
}
|
|
else
|
|
Current += CurrentSize + ImageNameMaximumLength;
|
|
} while ((Process != SystemProcess) && (Process != NULL));
|
|
|
|
if(Process != NULL)
|
|
ObDereferenceObject(Process);
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
if(Process != NULL)
|
|
ObDereferenceObject(Process);
|
|
if (ProcessImageName)
|
|
{
|
|
/* Release the memory allocated by SeLocateProcessImageName */
|
|
ExFreePoolWithTag(ProcessImageName, TAG_SEPA);
|
|
}
|
|
|
|
Status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END
|
|
|
|
if (Overflow)
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
*ReqSize = TotalSize;
|
|
return Status;
|
|
}
|
|
|
|
/* Class 6 - Call Count Information */
|
|
QSI_DEF(SystemCallCountInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 7 - Device Information */
|
|
QSI_DEF(SystemDeviceInformation)
|
|
{
|
|
PSYSTEM_DEVICE_INFORMATION Sdi
|
|
= (PSYSTEM_DEVICE_INFORMATION) Buffer;
|
|
PCONFIGURATION_INFORMATION ConfigInfo;
|
|
|
|
*ReqSize = sizeof(SYSTEM_DEVICE_INFORMATION);
|
|
|
|
/* Check user buffer's size */
|
|
if (Size < sizeof(SYSTEM_DEVICE_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
ConfigInfo = IoGetConfigurationInformation();
|
|
|
|
Sdi->NumberOfDisks = ConfigInfo->DiskCount;
|
|
Sdi->NumberOfFloppies = ConfigInfo->FloppyCount;
|
|
Sdi->NumberOfCdRoms = ConfigInfo->CdRomCount;
|
|
Sdi->NumberOfTapes = ConfigInfo->TapeCount;
|
|
Sdi->NumberOfSerialPorts = ConfigInfo->SerialCount;
|
|
Sdi->NumberOfParallelPorts = ConfigInfo->ParallelCount;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 8 - Processor Performance Information */
|
|
QSI_DEF(SystemProcessorPerformanceInformation)
|
|
{
|
|
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION Spi
|
|
= (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION) Buffer;
|
|
|
|
LONG i;
|
|
ULONG TotalTime;
|
|
PKPRCB Prcb;
|
|
|
|
*ReqSize = KeNumberProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
|
|
|
|
/* Check user buffer's size */
|
|
if (Size < *ReqSize)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
for (i = 0; i < KeNumberProcessors; i++)
|
|
{
|
|
/* Get the PRCB on this processor */
|
|
Prcb = KiProcessorBlock[i];
|
|
|
|
/* Calculate total user and kernel times */
|
|
TotalTime = Prcb->IdleThread->KernelTime + Prcb->IdleThread->UserTime;
|
|
Spi->IdleTime.QuadPart = UInt32x32To64(TotalTime, KeMaximumIncrement);
|
|
Spi->KernelTime.QuadPart = UInt32x32To64(Prcb->KernelTime, KeMaximumIncrement);
|
|
Spi->UserTime.QuadPart = UInt32x32To64(Prcb->UserTime, KeMaximumIncrement);
|
|
Spi->DpcTime.QuadPart = UInt32x32To64(Prcb->DpcTime, KeMaximumIncrement);
|
|
Spi->InterruptTime.QuadPart = UInt32x32To64(Prcb->InterruptTime, KeMaximumIncrement);
|
|
Spi->InterruptCount = Prcb->InterruptCount;
|
|
Spi++;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 9 - Flags Information */
|
|
QSI_DEF(SystemFlagsInformation)
|
|
{
|
|
#if (NTDDI_VERSION >= NTDDI_VISTA)
|
|
*ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
|
|
#endif
|
|
|
|
if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags = NtGlobalFlag;
|
|
#if (NTDDI_VERSION < NTDDI_VISTA)
|
|
*ReqSize = sizeof(SYSTEM_FLAGS_INFORMATION);
|
|
#endif
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SSI_DEF(SystemFlagsInformation)
|
|
{
|
|
if (sizeof(SYSTEM_FLAGS_INFORMATION) != Size)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
if (!SeSinglePrivilegeCheck(SeDebugPrivilege, ExGetPreviousMode()))
|
|
{
|
|
#if (NTDDI_VERSION < NTDDI_WIN7)
|
|
return STATUS_ACCESS_VIOLATION;
|
|
#else
|
|
return STATUS_ACCESS_DENIED;
|
|
#endif
|
|
}
|
|
|
|
NtGlobalFlag = ((PSYSTEM_FLAGS_INFORMATION) Buffer)->Flags;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 10 - Call Time Information */
|
|
QSI_DEF(SystemCallTimeInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 11 - Module Information */
|
|
QSI_DEF(SystemModuleInformation)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
/* Acquire system module list lock */
|
|
KeEnterCriticalRegion();
|
|
ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, TRUE);
|
|
|
|
/* Call the generic handler with the system module list */
|
|
Status = ExpQueryModuleInformation(&PsLoadedModuleList,
|
|
&MmLoadedUserImageList,
|
|
(PRTL_PROCESS_MODULES)Buffer,
|
|
Size,
|
|
ReqSize);
|
|
|
|
/* Release list lock and return status */
|
|
ExReleaseResourceLite(&PsLoadedModuleResource);
|
|
KeLeaveCriticalRegion();
|
|
return Status;
|
|
}
|
|
|
|
/* Class 12 - Locks Information */
|
|
QSI_DEF(SystemLocksInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 13 - Stack Trace Information */
|
|
QSI_DEF(SystemStackTraceInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 14 - Paged Pool Information */
|
|
QSI_DEF(SystemPagedPoolInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 15 - Non Paged Pool Information */
|
|
QSI_DEF(SystemNonPagedPoolInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 16 - Handle Information */
|
|
QSI_DEF(SystemHandleInformation)
|
|
{
|
|
PSYSTEM_HANDLE_INFORMATION HandleInformation;
|
|
PLIST_ENTRY NextTableEntry;
|
|
PHANDLE_TABLE HandleTable;
|
|
PHANDLE_TABLE_ENTRY HandleTableEntry;
|
|
EXHANDLE Handle;
|
|
ULONG Index = 0;
|
|
NTSTATUS Status;
|
|
PMDL Mdl;
|
|
PAGED_CODE();
|
|
|
|
DPRINT("NtQuerySystemInformation - SystemHandleInformation\n");
|
|
|
|
/* Set initial required buffer size */
|
|
*ReqSize = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION, Handles);
|
|
|
|
/* Check user's buffer size */
|
|
if (Size < *ReqSize)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* We need to lock down the memory */
|
|
Status = ExLockUserBuffer(Buffer,
|
|
Size,
|
|
ExGetPreviousMode(),
|
|
IoWriteAccess,
|
|
(PVOID*)&HandleInformation,
|
|
&Mdl);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Reset of count of handles */
|
|
HandleInformation->NumberOfHandles = 0;
|
|
|
|
/* Enter a critical region */
|
|
KeEnterCriticalRegion();
|
|
|
|
/* Acquire the handle table lock */
|
|
ExAcquirePushLockShared(&HandleTableListLock);
|
|
|
|
/* Enumerate all system handles */
|
|
for (NextTableEntry = HandleTableListHead.Flink;
|
|
NextTableEntry != &HandleTableListHead;
|
|
NextTableEntry = NextTableEntry->Flink)
|
|
{
|
|
/* Get current handle table */
|
|
HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
|
|
|
|
/* Set the initial value and loop the entries */
|
|
Handle.Value = 0;
|
|
while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
|
|
{
|
|
/* Validate the entry */
|
|
if ((HandleTableEntry->Object) &&
|
|
(HandleTableEntry->NextFreeTableEntry != -2))
|
|
{
|
|
/* Increase of count of handles */
|
|
++HandleInformation->NumberOfHandles;
|
|
|
|
/* Lock the entry */
|
|
if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
|
|
{
|
|
/* Increase required buffer size */
|
|
*ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO);
|
|
|
|
/* Check user's buffer size */
|
|
if (*ReqSize > Size)
|
|
{
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
else
|
|
{
|
|
POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
|
|
|
|
/* Filling handle information */
|
|
HandleInformation->Handles[Index].UniqueProcessId =
|
|
(USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
|
|
|
|
HandleInformation->Handles[Index].CreatorBackTraceIndex = 0;
|
|
|
|
#if 0 /* FIXME!!! Type field currupted */
|
|
HandleInformation->Handles[Index].ObjectTypeIndex =
|
|
(UCHAR) ObjectHeader->Type->Index;
|
|
#else
|
|
HandleInformation->Handles[Index].ObjectTypeIndex = 0;
|
|
#endif
|
|
|
|
HandleInformation->Handles[Index].HandleAttributes =
|
|
HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
|
|
|
|
HandleInformation->Handles[Index].HandleValue =
|
|
(USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
|
|
|
|
HandleInformation->Handles[Index].Object = &ObjectHeader->Body;
|
|
|
|
HandleInformation->Handles[Index].GrantedAccess =
|
|
HandleTableEntry->GrantedAccess;
|
|
|
|
++Index;
|
|
}
|
|
|
|
/* Unlock it */
|
|
ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
|
|
}
|
|
}
|
|
|
|
/* Go to the next entry */
|
|
Handle.Value += sizeof(HANDLE);
|
|
}
|
|
}
|
|
|
|
/* Release the lock */
|
|
ExReleasePushLockShared(&HandleTableListLock);
|
|
|
|
/* Leave the critical region */
|
|
KeLeaveCriticalRegion();
|
|
|
|
/* Release the locked user buffer */
|
|
ExUnlockUserBuffer(Mdl);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/* Class 17 - Information */
|
|
QSI_DEF(SystemObjectInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 18 - Information */
|
|
QSI_DEF(SystemPageFileInformation)
|
|
{
|
|
UNICODE_STRING FileName; /* FIXME */
|
|
SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
|
|
|
|
if (Size < sizeof(SYSTEM_PAGEFILE_INFORMATION))
|
|
{
|
|
* ReqSize = sizeof(SYSTEM_PAGEFILE_INFORMATION);
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
RtlInitUnicodeString(&FileName, NULL); /* FIXME */
|
|
|
|
/* FIXME */
|
|
Spfi->NextEntryOffset = 0;
|
|
|
|
Spfi->TotalSize = MiFreeSwapPages + MiUsedSwapPages;
|
|
Spfi->TotalInUse = MiUsedSwapPages;
|
|
Spfi->PeakUsage = MiUsedSwapPages; /* FIXME */
|
|
Spfi->PageFileName = FileName;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 19 - Vdm Instemul Information */
|
|
QSI_DEF(SystemVdmInstemulInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 20 - Vdm Bop Information */
|
|
QSI_DEF(SystemVdmBopInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 21 - File Cache Information */
|
|
QSI_DEF(SystemFileCacheInformation)
|
|
{
|
|
SYSTEM_FILECACHE_INFORMATION *Sci = (SYSTEM_FILECACHE_INFORMATION *) Buffer;
|
|
|
|
*ReqSize = sizeof(SYSTEM_FILECACHE_INFORMATION);
|
|
|
|
if (Size < *ReqSize)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
RtlZeroMemory(Sci, sizeof(SYSTEM_FILECACHE_INFORMATION));
|
|
|
|
/* Return the Byte size not the page size. */
|
|
Sci->CurrentSize = MiMemoryConsumers[MC_USER].PagesUsed; /* FIXME */
|
|
Sci->PeakSize = MiMemoryConsumers[MC_USER].PagesUsed; /* FIXME */
|
|
/* Taskmgr multiplies this one by page size right away */
|
|
Sci->CurrentSizeIncludingTransitionInPages = MiMemoryConsumers[MC_USER].PagesUsed; /* FIXME: Should be */
|
|
/* system working set and standby pages. */
|
|
Sci->PageFaultCount = 0; /* FIXME */
|
|
Sci->MinimumWorkingSet = 0; /* FIXME */
|
|
Sci->MaximumWorkingSet = 0; /* FIXME */
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SSI_DEF(SystemFileCacheInformation)
|
|
{
|
|
if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 22 - Pool Tag Information */
|
|
QSI_DEF(SystemPoolTagInformation)
|
|
{
|
|
if (Size < sizeof(SYSTEM_POOLTAG_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
|
|
return ExGetPoolTagInfo(Buffer, Size, ReqSize);
|
|
}
|
|
|
|
/* Class 23 - Interrupt Information for all processors */
|
|
QSI_DEF(SystemInterruptInformation)
|
|
{
|
|
PKPRCB Prcb;
|
|
LONG i;
|
|
ULONG ti;
|
|
PSYSTEM_INTERRUPT_INFORMATION sii = (PSYSTEM_INTERRUPT_INFORMATION)Buffer;
|
|
|
|
if(Size < KeNumberProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
ti = KeQueryTimeIncrement();
|
|
|
|
for (i = 0; i < KeNumberProcessors; i++)
|
|
{
|
|
Prcb = KiProcessorBlock[i];
|
|
sii->ContextSwitches = KeGetContextSwitches(Prcb);
|
|
sii->DpcCount = Prcb->DpcData[0].DpcCount;
|
|
sii->DpcRate = Prcb->DpcRequestRate;
|
|
sii->TimeIncrement = ti;
|
|
sii->DpcBypassCount = 0;
|
|
sii->ApcBypassCount = 0;
|
|
sii++;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 24 - DPC Behaviour Information */
|
|
QSI_DEF(SystemDpcBehaviourInformation)
|
|
{
|
|
PSYSTEM_DPC_BEHAVIOR_INFORMATION sdbi = (PSYSTEM_DPC_BEHAVIOR_INFORMATION)Buffer;
|
|
|
|
if (Size < sizeof(SYSTEM_DPC_BEHAVIOR_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
sdbi->DpcQueueDepth = KiMaximumDpcQueueDepth;
|
|
sdbi->MinimumDpcRate = KiMinimumDpcRate;
|
|
sdbi->AdjustDpcThreshold = KiAdjustDpcThreshold;
|
|
sdbi->IdealDpcRate = KiIdealDpcRate;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SSI_DEF(SystemDpcBehaviourInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemDpcBehaviourInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 25 - Full Memory Information */
|
|
QSI_DEF(SystemFullMemoryInformation)
|
|
{
|
|
PULONG Spi = (PULONG) Buffer;
|
|
|
|
PEPROCESS TheIdleProcess;
|
|
|
|
*ReqSize = sizeof(ULONG);
|
|
|
|
if (sizeof(ULONG) != Size)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
DPRINT("SystemFullMemoryInformation\n");
|
|
|
|
TheIdleProcess = PsIdleProcess;
|
|
|
|
DPRINT("PID: %p, KernelTime: %u PFFree: %lu PFUsed: %lu\n",
|
|
TheIdleProcess->UniqueProcessId,
|
|
TheIdleProcess->Pcb.KernelTime,
|
|
MiFreeSwapPages,
|
|
MiUsedSwapPages);
|
|
|
|
*Spi = MiMemoryConsumers[MC_USER].PagesUsed;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 26 - Load Image */
|
|
SSI_DEF(SystemLoadGdiDriverInformation)
|
|
{
|
|
PSYSTEM_GDI_DRIVER_INFORMATION DriverInfo = (PVOID)Buffer;
|
|
UNICODE_STRING ImageName;
|
|
PVOID ImageBase;
|
|
PVOID SectionPointer;
|
|
ULONG_PTR EntryPoint;
|
|
NTSTATUS Status;
|
|
ULONG DirSize;
|
|
PIMAGE_NT_HEADERS NtHeader;
|
|
|
|
/* Validate size */
|
|
if (Size != sizeof(SYSTEM_GDI_DRIVER_INFORMATION))
|
|
{
|
|
/* Incorrect buffer length, fail */
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Only kernel mode can call this function */
|
|
if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
|
|
|
|
/* Load the driver */
|
|
ImageName = DriverInfo->DriverName;
|
|
Status = MmLoadSystemImage(&ImageName,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
&SectionPointer,
|
|
&ImageBase);
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Return the export pointer */
|
|
DriverInfo->ExportSectionPointer =
|
|
RtlImageDirectoryEntryToData(ImageBase,
|
|
TRUE,
|
|
IMAGE_DIRECTORY_ENTRY_EXPORT,
|
|
&DirSize);
|
|
|
|
/* Get the entrypoint */
|
|
NtHeader = RtlImageNtHeader(ImageBase);
|
|
EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
|
|
EntryPoint += (ULONG_PTR)ImageBase;
|
|
|
|
/* Save other data */
|
|
DriverInfo->ImageAddress = ImageBase;
|
|
DriverInfo->SectionPointer = SectionPointer;
|
|
DriverInfo->EntryPoint = (PVOID)EntryPoint;
|
|
DriverInfo->ImageLength = NtHeader->OptionalHeader.SizeOfImage;
|
|
|
|
/* All is good */
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 27 - Unload Image */
|
|
SSI_DEF(SystemUnloadGdiDriverInformation)
|
|
{
|
|
PVOID *SectionPointer = Buffer;
|
|
|
|
/* Validate size */
|
|
if (Size != sizeof(PVOID))
|
|
{
|
|
/* Incorrect length, fail */
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Only kernel mode can call this function */
|
|
if (ExGetPreviousMode() != KernelMode) return STATUS_PRIVILEGE_NOT_HELD;
|
|
|
|
/* Unload the image */
|
|
MmUnloadSystemImage(*SectionPointer);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 28 - Time Adjustment Information */
|
|
QSI_DEF(SystemTimeAdjustmentInformation)
|
|
{
|
|
PSYSTEM_QUERY_TIME_ADJUST_INFORMATION TimeInfo =
|
|
(PSYSTEM_QUERY_TIME_ADJUST_INFORMATION)Buffer;
|
|
|
|
/* Check if enough storage was provided */
|
|
if (sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION) > Size)
|
|
{
|
|
* ReqSize = sizeof(SYSTEM_QUERY_TIME_ADJUST_INFORMATION);
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Give time values to our caller */
|
|
TimeInfo->TimeIncrement = KeMaximumIncrement;
|
|
TimeInfo->TimeAdjustment = KeTimeAdjustment;
|
|
TimeInfo->Enable = !KiTimeAdjustmentEnabled;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SSI_DEF(SystemTimeAdjustmentInformation)
|
|
{
|
|
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
|
|
PSYSTEM_SET_TIME_ADJUST_INFORMATION TimeInfo =
|
|
(PSYSTEM_SET_TIME_ADJUST_INFORMATION)Buffer;
|
|
|
|
/* Check size of a buffer, it must match our expectations */
|
|
if (sizeof(SYSTEM_SET_TIME_ADJUST_INFORMATION) != Size)
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
/* Check who is calling */
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
/* Check access rights */
|
|
if (!SeSinglePrivilegeCheck(SeSystemtimePrivilege, PreviousMode))
|
|
{
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
}
|
|
|
|
/* FIXME: behaviour suggests the member be named 'Disable' */
|
|
if (TimeInfo->Enable)
|
|
{
|
|
/* Disable time adjustment and set default value */
|
|
KiTimeAdjustmentEnabled = FALSE;
|
|
KeTimeAdjustment = KeMaximumIncrement;
|
|
}
|
|
else
|
|
{
|
|
/* Check if a valid time adjustment value is given */
|
|
if (TimeInfo->TimeAdjustment == 0) return STATUS_INVALID_PARAMETER_2;
|
|
|
|
/* Enable time adjustment and set the adjustment value */
|
|
KiTimeAdjustmentEnabled = TRUE;
|
|
KeTimeAdjustment = TimeInfo->TimeAdjustment;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 29 - Summary Memory Information */
|
|
QSI_DEF(SystemSummaryMemoryInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 30 - Next Event Id Information */
|
|
QSI_DEF(SystemNextEventIdInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 31 */
|
|
QSI_DEF(SystemPerformanceTraceInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemPerformanceTraceInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 32 - Crash Dump Information */
|
|
QSI_DEF(SystemCrashDumpInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 33 - Exception Information */
|
|
QSI_DEF(SystemExceptionInformation)
|
|
{
|
|
PSYSTEM_EXCEPTION_INFORMATION ExceptionInformation =
|
|
(PSYSTEM_EXCEPTION_INFORMATION)Buffer;
|
|
PKPRCB Prcb;
|
|
ULONG AlignmentFixupCount = 0, ExceptionDispatchCount = 0;
|
|
ULONG FloatingEmulationCount = 0, ByteWordEmulationCount = 0;
|
|
CHAR i;
|
|
|
|
/* Check size of a buffer, it must match our expectations */
|
|
if (sizeof(SYSTEM_EXCEPTION_INFORMATION) != Size)
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
/* Sum up exception count information from all processors */
|
|
for (i = 0; i < KeNumberProcessors; i++)
|
|
{
|
|
Prcb = KiProcessorBlock[i];
|
|
if (Prcb)
|
|
{
|
|
AlignmentFixupCount += Prcb->KeAlignmentFixupCount;
|
|
ExceptionDispatchCount += Prcb->KeExceptionDispatchCount;
|
|
#ifndef _M_ARM
|
|
FloatingEmulationCount += Prcb->KeFloatingEmulationCount;
|
|
#endif // _M_ARM
|
|
}
|
|
}
|
|
|
|
/* Save information in user's buffer */
|
|
ExceptionInformation->AlignmentFixupCount = AlignmentFixupCount;
|
|
ExceptionInformation->ExceptionDispatchCount = ExceptionDispatchCount;
|
|
ExceptionInformation->FloatingEmulationCount = FloatingEmulationCount;
|
|
ExceptionInformation->ByteWordEmulationCount = ByteWordEmulationCount;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 34 - Crash Dump State Information */
|
|
QSI_DEF(SystemCrashDumpStateInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 35 - Kernel Debugger Information */
|
|
QSI_DEF(SystemKernelDebuggerInformation)
|
|
{
|
|
PSYSTEM_KERNEL_DEBUGGER_INFORMATION skdi = (PSYSTEM_KERNEL_DEBUGGER_INFORMATION) Buffer;
|
|
|
|
#if (NTDDI_VERSION >= NTDDI_VISTA)
|
|
*ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
|
|
#endif
|
|
|
|
if (Size < sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
skdi->KernelDebuggerEnabled = KD_DEBUGGER_ENABLED;
|
|
skdi->KernelDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
|
|
|
|
#if (NTDDI_VERSION < NTDDI_VISTA)
|
|
*ReqSize = sizeof(SYSTEM_KERNEL_DEBUGGER_INFORMATION);
|
|
#endif
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 36 - Context Switch Information */
|
|
QSI_DEF(SystemContextSwitchInformation)
|
|
{
|
|
PSYSTEM_CONTEXT_SWITCH_INFORMATION ContextSwitchInformation =
|
|
(PSYSTEM_CONTEXT_SWITCH_INFORMATION)Buffer;
|
|
ULONG ContextSwitches;
|
|
PKPRCB Prcb;
|
|
CHAR i;
|
|
|
|
/* Check size of a buffer, it must match our expectations */
|
|
if (sizeof(SYSTEM_CONTEXT_SWITCH_INFORMATION) != Size)
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
/* Calculate total value of context switches across all processors */
|
|
ContextSwitches = 0;
|
|
for (i = 0; i < KeNumberProcessors; i ++)
|
|
{
|
|
Prcb = KiProcessorBlock[i];
|
|
if (Prcb)
|
|
{
|
|
ContextSwitches += KeGetContextSwitches(Prcb);
|
|
}
|
|
}
|
|
|
|
ContextSwitchInformation->ContextSwitches = ContextSwitches;
|
|
|
|
/* FIXME */
|
|
ContextSwitchInformation->FindAny = 0;
|
|
ContextSwitchInformation->FindLast = 0;
|
|
ContextSwitchInformation->FindIdeal = 0;
|
|
ContextSwitchInformation->IdleAny = 0;
|
|
ContextSwitchInformation->IdleCurrent = 0;
|
|
ContextSwitchInformation->IdleLast = 0;
|
|
ContextSwitchInformation->IdleIdeal = 0;
|
|
ContextSwitchInformation->PreemptAny = 0;
|
|
ContextSwitchInformation->PreemptCurrent = 0;
|
|
ContextSwitchInformation->PreemptLast = 0;
|
|
ContextSwitchInformation->SwitchToIdle = 0;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 37 - Registry Quota Information */
|
|
QSI_DEF(SystemRegistryQuotaInformation)
|
|
{
|
|
PSYSTEM_REGISTRY_QUOTA_INFORMATION srqi = (PSYSTEM_REGISTRY_QUOTA_INFORMATION) Buffer;
|
|
|
|
*ReqSize = sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION);
|
|
if (Size < sizeof(SYSTEM_REGISTRY_QUOTA_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
DPRINT1("Faking max registry size of 32 MB\n");
|
|
srqi->RegistryQuotaAllowed = 0x2000000;
|
|
srqi->RegistryQuotaUsed = 0x200000;
|
|
srqi->PagedPoolSize = 0x200000;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SSI_DEF(SystemRegistryQuotaInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemRegistryQuotaInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 38 - Load And Call Image */
|
|
SSI_DEF(SystemExtendServiceTableInformation)
|
|
{
|
|
UNICODE_STRING ImageName;
|
|
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
|
|
PLDR_DATA_TABLE_ENTRY ModuleObject;
|
|
NTSTATUS Status;
|
|
PIMAGE_NT_HEADERS NtHeader;
|
|
DRIVER_OBJECT Win32k;
|
|
PDRIVER_INITIALIZE DriverInit;
|
|
PVOID ImageBase;
|
|
ULONG_PTR EntryPoint;
|
|
|
|
/* Validate the size */
|
|
if (Size != sizeof(UNICODE_STRING)) return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
/* Check who is calling */
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
static const UNICODE_STRING Win32kName =
|
|
RTL_CONSTANT_STRING(L"\\SystemRoot\\System32\\win32k.sys");
|
|
|
|
/* Make sure we can load drivers */
|
|
if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, UserMode))
|
|
{
|
|
/* FIXME: We can't, fail */
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
|
|
_SEH2_TRY
|
|
{
|
|
/* Probe and copy the unicode string */
|
|
ProbeForRead(Buffer, sizeof(ImageName), 1);
|
|
ImageName = *(PUNICODE_STRING)Buffer;
|
|
|
|
/* Probe the string buffer */
|
|
ProbeForRead(ImageName.Buffer, ImageName.Length, sizeof(WCHAR));
|
|
|
|
/* Check if we have the correct name (nothing else is allowed!) */
|
|
if (!RtlEqualUnicodeString(&ImageName, &Win32kName, FALSE))
|
|
{
|
|
_SEH2_YIELD(return STATUS_PRIVILEGE_NOT_HELD);
|
|
}
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
_SEH2_YIELD(return _SEH2_GetExceptionCode());
|
|
}
|
|
_SEH2_END;
|
|
|
|
/* Recursively call the function, so that we are from kernel mode */
|
|
return ZwSetSystemInformation(SystemExtendServiceTableInformation,
|
|
(PVOID)&Win32kName,
|
|
sizeof(Win32kName));
|
|
}
|
|
|
|
/* Load the image */
|
|
Status = MmLoadSystemImage((PUNICODE_STRING)Buffer,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
(PVOID)&ModuleObject,
|
|
&ImageBase);
|
|
|
|
if (!NT_SUCCESS(Status)) return Status;
|
|
|
|
/* Get the headers */
|
|
NtHeader = RtlImageNtHeader(ImageBase);
|
|
if (!NtHeader)
|
|
{
|
|
/* Fail */
|
|
MmUnloadSystemImage(ModuleObject);
|
|
return STATUS_INVALID_IMAGE_FORMAT;
|
|
}
|
|
|
|
/* Get the entrypoint */
|
|
EntryPoint = NtHeader->OptionalHeader.AddressOfEntryPoint;
|
|
EntryPoint += (ULONG_PTR)ImageBase;
|
|
DriverInit = (PDRIVER_INITIALIZE)EntryPoint;
|
|
|
|
/* Create a dummy device */
|
|
RtlZeroMemory(&Win32k, sizeof(Win32k));
|
|
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
|
|
Win32k.DriverStart = ImageBase;
|
|
|
|
/* Call it */
|
|
Status = (DriverInit)(&Win32k, NULL);
|
|
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
|
|
|
|
/* Unload if we failed */
|
|
if (!NT_SUCCESS(Status)) MmUnloadSystemImage(ModuleObject);
|
|
return Status;
|
|
}
|
|
|
|
/* Class 39 - Priority Separation */
|
|
SSI_DEF(SystemPrioritySeperation)
|
|
{
|
|
/* Check if the size is correct */
|
|
if (Size != sizeof(ULONG))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* We need the TCB privilege */
|
|
if (!SeSinglePrivilegeCheck(SeTcbPrivilege, ExGetPreviousMode()))
|
|
{
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
|
|
/* Modify the quantum table */
|
|
PsChangeQuantumTable(TRUE, *(PULONG)Buffer);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 40 */
|
|
QSI_DEF(SystemVerifierAddDriverInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemVerifierAddDriverInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 41 */
|
|
QSI_DEF(SystemVerifierRemoveDriverInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemVerifierRemoveDriverInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 42 - Power Information */
|
|
QSI_DEF(SystemProcessorIdleInformation)
|
|
{
|
|
*ReqSize = sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors;
|
|
|
|
if (sizeof(PROCESSOR_POWER_INFORMATION) * KeNumberProcessors > Size)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemPowerInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 43 */
|
|
QSI_DEF(SystemLegacyDriverInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemLegacyDriverInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 44 - Current Time Zone Information */
|
|
QSI_DEF(SystemCurrentTimeZoneInformation)
|
|
{
|
|
*ReqSize = sizeof(RTL_TIME_ZONE_INFORMATION);
|
|
|
|
if (sizeof(RTL_TIME_ZONE_INFORMATION) != Size)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Copy the time zone information struct */
|
|
memcpy(Buffer,
|
|
&ExpTimeZoneInfo,
|
|
sizeof(RTL_TIME_ZONE_INFORMATION));
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
SSI_DEF(SystemCurrentTimeZoneInformation)
|
|
{
|
|
/* Check user buffer's size */
|
|
if (Size < sizeof(RTL_TIME_ZONE_INFORMATION))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
return ExpSetTimeZoneInformation((PRTL_TIME_ZONE_INFORMATION)Buffer);
|
|
}
|
|
|
|
static
|
|
VOID
|
|
ExpCopyLookasideInformation(
|
|
PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer,
|
|
PULONG RemainingPointer,
|
|
PLIST_ENTRY ListHead,
|
|
BOOLEAN ListUsesMisses)
|
|
|
|
{
|
|
PSYSTEM_LOOKASIDE_INFORMATION Info;
|
|
PGENERAL_LOOKASIDE LookasideList;
|
|
PLIST_ENTRY ListEntry;
|
|
ULONG Remaining;
|
|
|
|
/* Get info pointer and remaining count of free array element */
|
|
Info = *InfoPointer;
|
|
Remaining = *RemainingPointer;
|
|
|
|
/* Loop as long as we have lookaside lists and free array elements */
|
|
for (ListEntry = ListHead->Flink;
|
|
(ListEntry != ListHead) && (Remaining > 0);
|
|
ListEntry = ListEntry->Flink, Remaining--)
|
|
{
|
|
LookasideList = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);
|
|
|
|
/* Fill the next array element */
|
|
Info->CurrentDepth = LookasideList->Depth;
|
|
Info->MaximumDepth = LookasideList->MaximumDepth;
|
|
Info->TotalAllocates = LookasideList->TotalAllocates;
|
|
Info->TotalFrees = LookasideList->TotalFrees;
|
|
Info->Type = LookasideList->Type;
|
|
Info->Tag = LookasideList->Tag;
|
|
Info->Size = LookasideList->Size;
|
|
|
|
/* Check how the lists track misses/hits */
|
|
if (ListUsesMisses)
|
|
{
|
|
/* Copy misses */
|
|
Info->AllocateMisses = LookasideList->AllocateMisses;
|
|
Info->FreeMisses = LookasideList->FreeMisses;
|
|
}
|
|
else
|
|
{
|
|
/* Calculate misses */
|
|
Info->AllocateMisses = LookasideList->TotalAllocates
|
|
- LookasideList->AllocateHits;
|
|
Info->FreeMisses = LookasideList->TotalFrees
|
|
- LookasideList->FreeHits;
|
|
}
|
|
}
|
|
|
|
/* Return the updated pointer and remaining count */
|
|
*InfoPointer = Info;
|
|
*RemainingPointer = Remaining;
|
|
}
|
|
|
|
/* Class 45 - Lookaside Information */
|
|
QSI_DEF(SystemLookasideInformation)
|
|
{
|
|
KPROCESSOR_MODE PreviousMode;
|
|
PSYSTEM_LOOKASIDE_INFORMATION Info;
|
|
PMDL Mdl;
|
|
ULONG MaxCount, Remaining;
|
|
KIRQL OldIrql;
|
|
NTSTATUS Status;
|
|
|
|
/* First we need to lock down the memory, since we are going to access it
|
|
at high IRQL */
|
|
PreviousMode = ExGetPreviousMode();
|
|
Status = ExLockUserBuffer(Buffer,
|
|
Size,
|
|
PreviousMode,
|
|
IoWriteAccess,
|
|
(PVOID*)&Info,
|
|
&Mdl);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Calculate how many items we can store */
|
|
Remaining = MaxCount = Size / sizeof(SYSTEM_LOOKASIDE_INFORMATION);
|
|
if (Remaining == 0)
|
|
{
|
|
goto Leave;
|
|
}
|
|
|
|
/* Copy info from pool lookaside lists */
|
|
ExpCopyLookasideInformation(&Info,
|
|
&Remaining,
|
|
&ExPoolLookasideListHead,
|
|
FALSE);
|
|
if (Remaining == 0)
|
|
{
|
|
goto Leave;
|
|
}
|
|
|
|
/* Copy info from system lookaside lists */
|
|
ExpCopyLookasideInformation(&Info,
|
|
&Remaining,
|
|
&ExSystemLookasideListHead,
|
|
TRUE);
|
|
if (Remaining == 0)
|
|
{
|
|
goto Leave;
|
|
}
|
|
|
|
/* Acquire spinlock for ExpNonPagedLookasideListHead */
|
|
KeAcquireSpinLock(&ExpNonPagedLookasideListLock, &OldIrql);
|
|
|
|
/* Copy info from non-paged lookaside lists */
|
|
ExpCopyLookasideInformation(&Info,
|
|
&Remaining,
|
|
&ExpNonPagedLookasideListHead,
|
|
TRUE);
|
|
|
|
/* Release spinlock for ExpNonPagedLookasideListHead */
|
|
KeReleaseSpinLock(&ExpNonPagedLookasideListLock, OldIrql);
|
|
|
|
if (Remaining == 0)
|
|
{
|
|
goto Leave;
|
|
}
|
|
|
|
/* Acquire spinlock for ExpPagedLookasideListHead */
|
|
KeAcquireSpinLock(&ExpPagedLookasideListLock, &OldIrql);
|
|
|
|
/* Copy info from paged lookaside lists */
|
|
ExpCopyLookasideInformation(&Info,
|
|
&Remaining,
|
|
&ExpPagedLookasideListHead,
|
|
TRUE);
|
|
|
|
/* Release spinlock for ExpPagedLookasideListHead */
|
|
KeReleaseSpinLock(&ExpPagedLookasideListLock, OldIrql);
|
|
|
|
Leave:
|
|
|
|
/* Release the locked user buffer */
|
|
ExUnlockUserBuffer(Mdl);
|
|
|
|
/* Return the size of the actually written data */
|
|
*ReqSize = (MaxCount - Remaining) * sizeof(SYSTEM_LOOKASIDE_INFORMATION);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 46 - Set time slip event */
|
|
SSI_DEF(SystemTimeSlipNotification)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemTimeSlipNotification not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
MmSessionCreate(OUT PULONG SessionId);
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
MmSessionDelete(IN ULONG SessionId);
|
|
|
|
/* Class 47 - Create a new session (TSE) */
|
|
SSI_DEF(SystemSessionCreate)
|
|
{
|
|
ULONG SessionId;
|
|
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
|
|
NTSTATUS Status;
|
|
|
|
if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
|
|
{
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
|
|
ProbeForWriteUlong(Buffer);
|
|
}
|
|
|
|
Status = MmSessionCreate(&SessionId);
|
|
if (NT_SUCCESS(Status)) *(PULONG)Buffer = SessionId;
|
|
|
|
return Status;
|
|
}
|
|
|
|
/* Class 48 - Delete an existing session (TSE) */
|
|
SSI_DEF(SystemSessionDetach)
|
|
{
|
|
ULONG SessionId;
|
|
KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
|
|
|
|
if (Size != sizeof(ULONG)) return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
if (!SeSinglePrivilegeCheck(SeLoadDriverPrivilege, PreviousMode))
|
|
{
|
|
return STATUS_PRIVILEGE_NOT_HELD;
|
|
}
|
|
}
|
|
|
|
SessionId = *(PULONG)Buffer;
|
|
|
|
return MmSessionDelete(SessionId);
|
|
}
|
|
|
|
/* Class 49 - UNKNOWN */
|
|
QSI_DEF(SystemSessionInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemSessionInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 50 - System range start address */
|
|
QSI_DEF(SystemRangeStartInformation)
|
|
{
|
|
/* Check user buffer's size */
|
|
if (Size != sizeof(ULONG_PTR)) return STATUS_INFO_LENGTH_MISMATCH;
|
|
|
|
*(PULONG_PTR)Buffer = (ULONG_PTR)MmSystemRangeStart;
|
|
|
|
if (ReqSize) *ReqSize = sizeof(ULONG_PTR);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 51 - Driver verifier information */
|
|
QSI_DEF(SystemVerifierInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
SSI_DEF(SystemVerifierInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemVerifierInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 52 */
|
|
SSI_DEF(SystemVerifierThunkExtend)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemVerifierThunkExtend not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 53 - A session's processes */
|
|
QSI_DEF(SystemSessionProcessesInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 54 - Load & map in system space */
|
|
SSI_DEF(SystemLoadGdiDriverInSystemSpaceInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtSetSystemInformation - SystemLoadGdiDriverInSystemSpaceInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 55 - NUMA processor information */
|
|
QSI_DEF(SystemNumaProcessorMap)
|
|
{
|
|
ULONG MaxEntries, Node;
|
|
PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
|
|
|
|
/* Validate input size */
|
|
if (Size < sizeof(ULONG))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Return highest node */
|
|
NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
|
|
|
|
/* Compute how much entries we will be able to put in output structure */
|
|
MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask)) / sizeof(ULONGLONG);
|
|
/* Make sure we don't overflow KeNodeBlock */
|
|
if (MaxEntries > KeNumberNodes)
|
|
{
|
|
MaxEntries = KeNumberNodes;
|
|
}
|
|
|
|
/* If we have entries to write, and room for it */
|
|
if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) &&
|
|
MaxEntries != 0)
|
|
{
|
|
/* Already set size we return */
|
|
*ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, ActiveProcessorsAffinityMask) +
|
|
MaxEntries * sizeof(ULONGLONG);
|
|
|
|
/* For each node, return processor mask */
|
|
for (Node = 0; Node < MaxEntries; ++Node)
|
|
{
|
|
NumaInformation->ActiveProcessorsAffinityMask[Node] = KeNodeBlock[Node]->ProcessorMask;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* We only returned highest node number */
|
|
*ReqSize = sizeof(ULONG);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 56 - Prefetcher information */
|
|
QSI_DEF(SystemPrefetcherInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemPrefetcherInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 57 - Extended process information */
|
|
QSI_DEF(SystemExtendedProcessInformation)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemExtendedProcessInformation not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 58 - Recommended shared data alignment */
|
|
QSI_DEF(SystemRecommendedSharedDataAlignment)
|
|
{
|
|
/* FIXME */
|
|
DPRINT1("NtQuerySystemInformation - SystemRecommendedSharedDataAlignment not implemented\n");
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/* Class 60 - NUMA memory information */
|
|
QSI_DEF(SystemNumaAvailableMemory)
|
|
{
|
|
ULONG MaxEntries, Node;
|
|
PSYSTEM_NUMA_INFORMATION NumaInformation = (PSYSTEM_NUMA_INFORMATION)Buffer;
|
|
|
|
/* Validate input size */
|
|
if (Size < sizeof(ULONG))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* Return highest node */
|
|
NumaInformation->HighestNodeNumber = KeNumberNodes - 1;
|
|
|
|
/* Compute how much entries we will be able to put in output structure */
|
|
MaxEntries = (Size - FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory)) / sizeof(ULONGLONG);
|
|
/* Make sure we don't overflow KeNodeBlock */
|
|
if (MaxEntries > KeNumberNodes)
|
|
{
|
|
MaxEntries = KeNumberNodes;
|
|
}
|
|
|
|
/* If we have entries to write, and room for it */
|
|
if (Size >= FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) &&
|
|
MaxEntries != 0)
|
|
{
|
|
/* Already set size we return */
|
|
*ReqSize = FIELD_OFFSET(SYSTEM_NUMA_INFORMATION, AvailableMemory) +
|
|
MaxEntries * sizeof(ULONGLONG);
|
|
|
|
/* If we have a single entry (us), directly return MM information */
|
|
if (MaxEntries == 1)
|
|
{
|
|
NumaInformation->AvailableMemory[0] = MmAvailablePages << PAGE_SHIFT;
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, for each node, return available bytes */
|
|
for (Node = 0; Node < MaxEntries; ++Node)
|
|
{
|
|
NumaInformation->AvailableMemory[Node] = (KeNodeBlock[Node]->FreeCount[0] + KeNodeBlock[Node]->FreeCount[1]) << PAGE_SHIFT;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* We only returned highest node number */
|
|
*ReqSize = sizeof(ULONG);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 64 - Extended handle information */
|
|
QSI_DEF(SystemExtendedHandleInformation)
|
|
{
|
|
PSYSTEM_HANDLE_INFORMATION_EX HandleInformation;
|
|
PLIST_ENTRY NextTableEntry;
|
|
PHANDLE_TABLE HandleTable;
|
|
PHANDLE_TABLE_ENTRY HandleTableEntry;
|
|
EXHANDLE Handle;
|
|
ULONG Index = 0;
|
|
NTSTATUS Status;
|
|
PMDL Mdl;
|
|
PAGED_CODE();
|
|
|
|
DPRINT("NtQuerySystemInformation - SystemExtendedHandleInformation\n");
|
|
|
|
/* Set initial required buffer size */
|
|
*ReqSize = FIELD_OFFSET(SYSTEM_HANDLE_INFORMATION_EX, Handle);
|
|
|
|
/* Check user's buffer size */
|
|
if (Size < *ReqSize)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
/* We need to lock down the memory */
|
|
Status = ExLockUserBuffer(Buffer,
|
|
Size,
|
|
ExGetPreviousMode(),
|
|
IoWriteAccess,
|
|
(PVOID*)&HandleInformation,
|
|
&Mdl);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to lock the user buffer: 0x%lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Reset of count of handles */
|
|
HandleInformation->Count = 0;
|
|
|
|
/* Enter a critical region */
|
|
KeEnterCriticalRegion();
|
|
|
|
/* Acquire the handle table lock */
|
|
ExAcquirePushLockShared(&HandleTableListLock);
|
|
|
|
/* Enumerate all system handles */
|
|
for (NextTableEntry = HandleTableListHead.Flink;
|
|
NextTableEntry != &HandleTableListHead;
|
|
NextTableEntry = NextTableEntry->Flink)
|
|
{
|
|
/* Get current handle table */
|
|
HandleTable = CONTAINING_RECORD(NextTableEntry, HANDLE_TABLE, HandleTableList);
|
|
|
|
/* Set the initial value and loop the entries */
|
|
Handle.Value = 0;
|
|
while ((HandleTableEntry = ExpLookupHandleTableEntry(HandleTable, Handle)))
|
|
{
|
|
/* Validate the entry */
|
|
if ((HandleTableEntry->Object) &&
|
|
(HandleTableEntry->NextFreeTableEntry != -2))
|
|
{
|
|
/* Increase of count of handles */
|
|
++HandleInformation->Count;
|
|
|
|
/* Lock the entry */
|
|
if (ExpLockHandleTableEntry(HandleTable, HandleTableEntry))
|
|
{
|
|
/* Increase required buffer size */
|
|
*ReqSize += sizeof(SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX);
|
|
|
|
/* Check user's buffer size */
|
|
if (*ReqSize > Size)
|
|
{
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
else
|
|
{
|
|
POBJECT_HEADER ObjectHeader = ObpGetHandleObject(HandleTableEntry);
|
|
|
|
/* Filling handle information */
|
|
HandleInformation->Handle[Index].UniqueProcessId =
|
|
(USHORT)(ULONG_PTR) HandleTable->UniqueProcessId;
|
|
|
|
HandleInformation->Handle[Index].CreatorBackTraceIndex = 0;
|
|
|
|
#if 0 /* FIXME!!! Type field currupted */
|
|
HandleInformation->Handles[Index].ObjectTypeIndex =
|
|
(UCHAR) ObjectHeader->Type->Index;
|
|
#else
|
|
HandleInformation->Handle[Index].ObjectTypeIndex = 0;
|
|
#endif
|
|
|
|
HandleInformation->Handle[Index].HandleAttributes =
|
|
HandleTableEntry->ObAttributes & OBJ_HANDLE_ATTRIBUTES;
|
|
|
|
HandleInformation->Handle[Index].HandleValue =
|
|
(USHORT)(ULONG_PTR) Handle.GenericHandleOverlay;
|
|
|
|
HandleInformation->Handle[Index].Object = &ObjectHeader->Body;
|
|
|
|
HandleInformation->Handle[Index].GrantedAccess =
|
|
HandleTableEntry->GrantedAccess;
|
|
|
|
HandleInformation->Handle[Index].Reserved = 0;
|
|
|
|
++Index;
|
|
}
|
|
|
|
/* Unlock it */
|
|
ExUnlockHandleTableEntry(HandleTable, HandleTableEntry);
|
|
}
|
|
}
|
|
|
|
/* Go to the next entry */
|
|
Handle.Value += sizeof(HANDLE);
|
|
}
|
|
}
|
|
|
|
/* Release the lock */
|
|
ExReleasePushLockShared(&HandleTableListLock);
|
|
|
|
/* Leave the critical region */
|
|
KeLeaveCriticalRegion();
|
|
|
|
/* Release the locked user buffer */
|
|
ExUnlockUserBuffer(Mdl);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/* Class 70 - System object security mode information */
|
|
QSI_DEF(SystemObjectSecurityMode)
|
|
{
|
|
PULONG ObjectSecurityInfo = (PULONG)Buffer;
|
|
|
|
/* Validate input size */
|
|
if (Size != sizeof(ULONG))
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
*ObjectSecurityInfo = ObpObjectSecurityMode;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* Class 73 - Logical processor information */
|
|
QSI_DEF(SystemLogicalProcessorInformation)
|
|
{
|
|
LONG i;
|
|
PKPRCB Prcb;
|
|
KAFFINITY CurrentProc;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG DataSize = 0, ProcessorFlags;
|
|
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION CurrentInfo;
|
|
|
|
/* First, browse active processors, thanks to the map */
|
|
i = 0;
|
|
CurrentInfo = Buffer;
|
|
CurrentProc = KeActiveProcessors;
|
|
do
|
|
{
|
|
/* If current processor is active and is main in case of HT/MC, return it */
|
|
Prcb = KiProcessorBlock[i];
|
|
if ((CurrentProc & 1) &&
|
|
Prcb == Prcb->MultiThreadSetMaster)
|
|
{
|
|
/* Assume processor can do HT or multicore */
|
|
ProcessorFlags = 1;
|
|
|
|
/* If set is the same for PRCB and multithread, then
|
|
* actually, the processor is single core
|
|
*/
|
|
if (Prcb->SetMember == Prcb->MultiThreadProcessorSet)
|
|
{
|
|
ProcessorFlags = 0;
|
|
}
|
|
|
|
/* Check we have enough room to return */
|
|
DataSize += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
|
|
if (DataSize > Size)
|
|
{
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
else
|
|
{
|
|
/* Zero output and return */
|
|
RtlZeroMemory(CurrentInfo, sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
|
|
CurrentInfo->ProcessorMask = Prcb->MultiThreadProcessorSet;
|
|
|
|
/* Processor core needs 1 if HT/MC is supported */
|
|
CurrentInfo->Relationship = RelationProcessorCore;
|
|
CurrentInfo->ProcessorCore.Flags = ProcessorFlags;
|
|
++CurrentInfo;
|
|
}
|
|
}
|
|
|
|
/* Move to the next proc */
|
|
CurrentProc >>= 1;
|
|
++i;
|
|
/* Loop while there's someone in the bitmask */
|
|
} while (CurrentProc != 0);
|
|
|
|
/* Now, return the NUMA nodes */
|
|
for (i = 0; i < KeNumberNodes; ++i)
|
|
{
|
|
/* Check we have enough room to return */
|
|
DataSize += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
|
|
if (DataSize > Size)
|
|
{
|
|
Status = STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
else
|
|
{
|
|
/* Zero output and return */
|
|
RtlZeroMemory(CurrentInfo, sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
|
|
CurrentInfo->ProcessorMask = KeActiveProcessors;
|
|
|
|
/* NUMA node needs its ID */
|
|
CurrentInfo->Relationship = RelationNumaNode;
|
|
CurrentInfo->NumaNode.NodeNumber = i;
|
|
++CurrentInfo;
|
|
}
|
|
}
|
|
|
|
*ReqSize = DataSize;
|
|
|
|
return Status;
|
|
}
|
|
|
|
/* Class 76 - System firmware table information */
|
|
QSI_DEF(SystemFirmwareTableInformation)
|
|
{
|
|
PSYSTEM_FIRMWARE_TABLE_INFORMATION SysFirmwareInfo = (PSYSTEM_FIRMWARE_TABLE_INFORMATION)Buffer;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG InputBufSize;
|
|
ULONG DataSize = 0;
|
|
ULONG TableCount = 0;
|
|
|
|
DPRINT("NtQuerySystemInformation - SystemFirmwareTableInformation\n");
|
|
|
|
/* Set initial required buffer size */
|
|
*ReqSize = FIELD_OFFSET(SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer);
|
|
|
|
/* Check user's buffer size */
|
|
if (Size < *ReqSize)
|
|
{
|
|
return STATUS_INFO_LENGTH_MISMATCH;
|
|
}
|
|
|
|
InputBufSize = SysFirmwareInfo->TableBufferLength;
|
|
switch (SysFirmwareInfo->ProviderSignature)
|
|
{
|
|
/*
|
|
* ExpFirmwareTableResource and ExpFirmwareTableProviderListHead
|
|
* variables should be used there somehow...
|
|
*/
|
|
case SIG_ACPI:
|
|
{
|
|
/* FIXME: Not implemented yet */
|
|
DPRINT1("ACPI provider not implemented\n");
|
|
Status = STATUS_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
case SIG_FIRM:
|
|
{
|
|
/* FIXME: Not implemented yet */
|
|
DPRINT1("FIRM provider not implemented\n");
|
|
Status = STATUS_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
case SIG_RSMB:
|
|
{
|
|
Status = ExpGetRawSMBiosTable(NULL, &DataSize, 0);
|
|
if (DataSize > 0)
|
|
{
|
|
TableCount = 1;
|
|
if (SysFirmwareInfo->Action == SystemFirmwareTable_Enumerate)
|
|
{
|
|
DataSize = TableCount * sizeof(ULONG);
|
|
if (DataSize <= InputBufSize)
|
|
{
|
|
*(ULONG *)SysFirmwareInfo->TableBuffer = 0;
|
|
}
|
|
}
|
|
else if (SysFirmwareInfo->Action == SystemFirmwareTable_Get
|
|
&& DataSize <= InputBufSize)
|
|
{
|
|
Status = ExpGetRawSMBiosTable(SysFirmwareInfo->TableBuffer, &DataSize, InputBufSize);
|
|
}
|
|
SysFirmwareInfo->TableBufferLength = DataSize;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
DPRINT1("SystemFirmwareTableInformation: Unsupported provider (0x%x)\n",
|
|
SysFirmwareInfo->ProviderSignature);
|
|
Status = STATUS_ILLEGAL_FUNCTION;
|
|
}
|
|
}
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
switch (SysFirmwareInfo->Action)
|
|
{
|
|
case SystemFirmwareTable_Enumerate:
|
|
case SystemFirmwareTable_Get:
|
|
{
|
|
if (SysFirmwareInfo->TableBufferLength > InputBufSize)
|
|
{
|
|
Status = STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
DPRINT1("SystemFirmwareTableInformation: Unsupported action (0x%x)\n",
|
|
SysFirmwareInfo->Action);
|
|
Status = STATUS_ILLEGAL_FUNCTION;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SysFirmwareInfo->TableBufferLength = 0;
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
/* Query/Set Calls Table */
|
|
typedef
|
|
struct _QSSI_CALLS
|
|
{
|
|
NTSTATUS (* Query) (PVOID,ULONG,PULONG);
|
|
NTSTATUS (* Set) (PVOID,ULONG);
|
|
} QSSI_CALLS;
|
|
|
|
// QS Query & Set
|
|
// QX Query
|
|
// XS Set
|
|
// XX unknown behaviour
|
|
//
|
|
#define SI_QS(n) {QSI_USE(n),SSI_USE(n)}
|
|
#define SI_QX(n) {QSI_USE(n),NULL}
|
|
#define SI_XS(n) {NULL,SSI_USE(n)}
|
|
#define SI_XX(n) {NULL,NULL}
|
|
|
|
static
|
|
QSSI_CALLS
|
|
CallQS[] =
|
|
{
|
|
SI_QX(SystemBasicInformation),
|
|
SI_QX(SystemProcessorInformation),
|
|
SI_QX(SystemPerformanceInformation),
|
|
SI_QX(SystemTimeOfDayInformation),
|
|
SI_QX(SystemPathInformation),
|
|
SI_QX(SystemProcessInformation),
|
|
SI_QX(SystemCallCountInformation),
|
|
SI_QX(SystemDeviceInformation),
|
|
SI_QX(SystemProcessorPerformanceInformation),
|
|
SI_QS(SystemFlagsInformation),
|
|
SI_QX(SystemCallTimeInformation), /* should be SI_XX */
|
|
SI_QX(SystemModuleInformation),
|
|
SI_QX(SystemLocksInformation),
|
|
SI_QX(SystemStackTraceInformation), /* should be SI_XX */
|
|
SI_QX(SystemPagedPoolInformation), /* should be SI_XX */
|
|
SI_QX(SystemNonPagedPoolInformation), /* should be SI_XX */
|
|
SI_QX(SystemHandleInformation),
|
|
SI_QX(SystemObjectInformation),
|
|
SI_QX(SystemPageFileInformation),
|
|
SI_QX(SystemVdmInstemulInformation),
|
|
SI_QX(SystemVdmBopInformation), /* it should be SI_XX */
|
|
SI_QS(SystemFileCacheInformation),
|
|
SI_QX(SystemPoolTagInformation),
|
|
SI_QX(SystemInterruptInformation),
|
|
SI_QS(SystemDpcBehaviourInformation),
|
|
SI_QX(SystemFullMemoryInformation), /* it should be SI_XX */
|
|
SI_XS(SystemLoadGdiDriverInformation),
|
|
SI_XS(SystemUnloadGdiDriverInformation),
|
|
SI_QS(SystemTimeAdjustmentInformation),
|
|
SI_QX(SystemSummaryMemoryInformation), /* it should be SI_XX */
|
|
SI_QX(SystemNextEventIdInformation), /* it should be SI_XX */
|
|
SI_QX(SystemPerformanceTraceInformation), /* it should be SI_XX */
|
|
SI_QX(SystemCrashDumpInformation),
|
|
SI_QX(SystemExceptionInformation),
|
|
SI_QX(SystemCrashDumpStateInformation),
|
|
SI_QX(SystemKernelDebuggerInformation),
|
|
SI_QX(SystemContextSwitchInformation),
|
|
SI_QS(SystemRegistryQuotaInformation),
|
|
SI_XS(SystemExtendServiceTableInformation),
|
|
SI_XS(SystemPrioritySeperation),
|
|
SI_QX(SystemVerifierAddDriverInformation), /* it should be SI_XX */
|
|
SI_QX(SystemVerifierRemoveDriverInformation), /* it should be SI_XX */
|
|
SI_QX(SystemProcessorIdleInformation), /* it should be SI_XX */
|
|
SI_QX(SystemLegacyDriverInformation), /* it should be SI_XX */
|
|
SI_QS(SystemCurrentTimeZoneInformation), /* it should be SI_QX */
|
|
SI_QX(SystemLookasideInformation),
|
|
SI_XS(SystemTimeSlipNotification),
|
|
SI_XS(SystemSessionCreate),
|
|
SI_XS(SystemSessionDetach),
|
|
SI_QX(SystemSessionInformation), /* it should be SI_XX */
|
|
SI_QX(SystemRangeStartInformation),
|
|
SI_QS(SystemVerifierInformation),
|
|
SI_XS(SystemVerifierThunkExtend),
|
|
SI_QX(SystemSessionProcessesInformation),
|
|
SI_XS(SystemLoadGdiDriverInSystemSpaceInformation),
|
|
SI_QX(SystemNumaProcessorMap),
|
|
SI_QX(SystemPrefetcherInformation),
|
|
SI_QX(SystemExtendedProcessInformation),
|
|
SI_QX(SystemRecommendedSharedDataAlignment),
|
|
SI_XX(SystemComPlusPackage),
|
|
SI_QX(SystemNumaAvailableMemory),
|
|
SI_XX(SystemProcessorPowerInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemEmulationBasicInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemEmulationProcessorInformation), /* FIXME: not implemented */
|
|
SI_QX(SystemExtendedHandleInformation),
|
|
SI_XX(SystemLostDelayedWriteInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemBigPoolInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemSessionPoolTagInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemSessionMappedViewInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemHotpatchInformation), /* FIXME: not implemented */
|
|
SI_QX(SystemObjectSecurityMode),
|
|
SI_XX(SystemWatchdogTimerHandler), /* FIXME: not implemented */
|
|
SI_XX(SystemWatchdogTimerInformation), /* FIXME: not implemented */
|
|
SI_QX(SystemLogicalProcessorInformation),
|
|
SI_XX(SystemWow64SharedInformation), /* FIXME: not implemented */
|
|
SI_XX(SystemRegisterFirmwareTableInformationHandler), /* FIXME: not implemented */
|
|
SI_QX(SystemFirmwareTableInformation),
|
|
};
|
|
|
|
C_ASSERT(SystemBasicInformation == 0);
|
|
#define MIN_SYSTEM_INFO_CLASS (SystemBasicInformation)
|
|
#define MAX_SYSTEM_INFO_CLASS RTL_NUMBER_OF(CallQS)
|
|
|
|
/*
|
|
* @implemented
|
|
*/
|
|
__kernel_entry
|
|
NTSTATUS
|
|
NTAPI
|
|
NtQuerySystemInformation(
|
|
_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
|
|
_Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation,
|
|
_In_ ULONG SystemInformationLength,
|
|
_Out_opt_ PULONG ReturnLength)
|
|
{
|
|
NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
|
|
ULONG CapturedResultLength = 0;
|
|
ULONG Alignment = TYPE_ALIGNMENT(ULONG);
|
|
KPROCESSOR_MODE PreviousMode;
|
|
|
|
PAGED_CODE();
|
|
|
|
PreviousMode = ExGetPreviousMode();
|
|
|
|
_SEH2_TRY
|
|
{
|
|
#if (NTDDI_VERSION >= NTDDI_VISTA)
|
|
/*
|
|
* Check whether the request is valid.
|
|
*/
|
|
if (SystemInformationClass < MIN_SYSTEM_INFO_CLASS ||
|
|
SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
|
|
{
|
|
_SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
|
|
}
|
|
#endif
|
|
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
/* SystemKernelDebuggerInformation needs only BOOLEAN alignment */
|
|
if (SystemInformationClass == SystemKernelDebuggerInformation)
|
|
Alignment = TYPE_ALIGNMENT(BOOLEAN);
|
|
|
|
ProbeForWrite(SystemInformation, SystemInformationLength, Alignment);
|
|
if (ReturnLength != NULL)
|
|
ProbeForWriteUlong(ReturnLength);
|
|
}
|
|
|
|
if (ReturnLength)
|
|
*ReturnLength = 0;
|
|
|
|
#if (NTDDI_VERSION < NTDDI_VISTA)
|
|
/*
|
|
* Check whether the request is valid.
|
|
*/
|
|
if (SystemInformationClass < MIN_SYSTEM_INFO_CLASS ||
|
|
SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
|
|
{
|
|
_SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
|
|
}
|
|
#endif
|
|
|
|
if (CallQS[SystemInformationClass].Query != NULL)
|
|
{
|
|
/* Hand the request to a subhandler */
|
|
Status = CallQS[SystemInformationClass].Query(SystemInformation,
|
|
SystemInformationLength,
|
|
&CapturedResultLength);
|
|
|
|
/* Save the result length to the caller */
|
|
if (ReturnLength)
|
|
*ReturnLength = CapturedResultLength;
|
|
}
|
|
}
|
|
_SEH2_EXCEPT(ExSystemExceptionFilter())
|
|
{
|
|
Status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
|
|
return Status;
|
|
}
|
|
|
|
__kernel_entry
|
|
NTSTATUS
|
|
NTAPI
|
|
NtSetSystemInformation(
|
|
_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass,
|
|
_In_reads_bytes_(SystemInformationLength) PVOID SystemInformation,
|
|
_In_ ULONG SystemInformationLength)
|
|
{
|
|
NTSTATUS Status = STATUS_INVALID_INFO_CLASS;
|
|
KPROCESSOR_MODE PreviousMode;
|
|
|
|
PAGED_CODE();
|
|
|
|
PreviousMode = ExGetPreviousMode();
|
|
|
|
_SEH2_TRY
|
|
{
|
|
/*
|
|
* If called from user mode, check possible unsafe arguments.
|
|
*/
|
|
if (PreviousMode != KernelMode)
|
|
{
|
|
ProbeForRead(SystemInformation, SystemInformationLength, sizeof(ULONG));
|
|
}
|
|
|
|
/*
|
|
* Check whether the request is valid.
|
|
*/
|
|
if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
|
|
(SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
|
|
{
|
|
if (CallQS[SystemInformationClass].Set != NULL)
|
|
{
|
|
/* Hand the request to a subhandler */
|
|
Status = CallQS[SystemInformationClass].Set(SystemInformation,
|
|
SystemInformationLength);
|
|
}
|
|
}
|
|
}
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
Status = _SEH2_GetExceptionCode();
|
|
}
|
|
_SEH2_END;
|
|
|
|
return Status;
|
|
}
|
|
|
|
ULONG
|
|
NTAPI
|
|
NtGetCurrentProcessorNumber(VOID)
|
|
{
|
|
/* Just use Ke */
|
|
return KeGetCurrentProcessorNumber();
|
|
}
|
|
|
|
#undef ExGetPreviousMode
|
|
KPROCESSOR_MODE
|
|
NTAPI
|
|
ExGetPreviousMode(VOID)
|
|
{
|
|
/* Just use Ke */
|
|
return KeGetPreviousMode();
|
|
}
|