sysinfo.c File Reference

#include <ntoskrnl.h>
#include <wmidata.h>
#include <wmistr.h>
#include <debug.h>

Include dependency graph for sysinfo.c:

Go to the source code of this file.

Classes
struct	_QSSI_CALLS

Macros
#define	NDEBUG
#define	MAX_ENVVAL_SIZE   1024
#define	SIG_ACPI   0x41435049
#define	SIG_FIRM   0x4649524D
#define	SIG_RSMB   0x52534D42
#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)
#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}
#define	MIN_SYSTEM_INFO_CLASS   (SystemBasicInformation)
#define	MAX_SYSTEM_INFO_CLASS   (sizeof(CallQS) / sizeof(CallQS[0]))

Typedefs
typedef struct _QSSI_CALLS	QSSI_CALLS

Functions
FORCEINLINE NTSTATUS	ExpConvertLdrModuleToRtlModule (IN ULONG ModuleCount, IN PLDR_DATA_TABLE_ENTRY LdrEntry, OUT PRTL_PROCESS_MODULE_INFORMATION ModuleInfo)
NTSTATUS NTAPI	ExpQueryModuleInformation (IN PLIST_ENTRY KernelModeList, IN PLIST_ENTRY UserModeList, OUT PRTL_PROCESS_MODULES Modules, IN ULONG Length, OUT PULONG ReturnLength)
VOID NTAPI	ExUnlockUserBuffer (PMDL Mdl)
NTSTATUS NTAPI	ExLockUserBuffer (PVOID BaseAddress, ULONG Length, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation, PVOID *MappedSystemVa, PMDL *OutMdl)
NTSTATUS NTAPI	ExpGetRawSMBiosTable (_Out_opt_ PVOID Buffer, _Out_ ULONG *OutSize, _In_ ULONG BufferSize)
VOID NTAPI	ExGetCurrentProcessorCpuUsage (PULONG CpuUsage)
VOID NTAPI	ExGetCurrentProcessorCounts (PULONG ThreadKernelTime, PULONG TotalCpuTime, PULONG ProcessorNumber)
BOOLEAN NTAPI	ExIsProcessorFeaturePresent (IN ULONG ProcessorFeature)
BOOLEAN NTAPI	ExVerifySuite (SUITE_TYPE SuiteType)
NTSTATUS NTAPI	NtQuerySystemEnvironmentValue (IN PUNICODE_STRING VariableName, OUT PWSTR ValueBuffer, IN ULONG ValueBufferLength, IN OUT PULONG ReturnLength OPTIONAL)
NTSTATUS NTAPI	NtSetSystemEnvironmentValue (IN PUNICODE_STRING VariableName, IN PUNICODE_STRING Value)
NTSTATUS NTAPI	NtEnumerateSystemEnvironmentValuesEx (IN ULONG InformationClass, IN PVOID Buffer, IN ULONG BufferLength)
NTSTATUS NTAPI	NtQuerySystemEnvironmentValueEx (IN PUNICODE_STRING VariableName, IN LPGUID VendorGuid, IN PVOID Value, IN OUT PULONG ReturnLength, IN OUT PULONG Attributes)
NTSTATUS NTAPI	NtSetSystemEnvironmentValueEx (IN PUNICODE_STRING VariableName, IN LPGUID VendorGuid, IN PVOID Value, IN OUT PULONG ReturnLength, IN OUT PULONG Attributes)
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)
	QSI_DEF (SystemBasicInformation)
	QSI_DEF (SystemProcessorInformation)
	QSI_DEF (SystemPerformanceInformation)
	QSI_DEF (SystemTimeOfDayInformation)
	QSI_DEF (SystemPathInformation)
	QSI_DEF (SystemProcessInformation)
	QSI_DEF (SystemCallCountInformation)
	QSI_DEF (SystemDeviceInformation)
	QSI_DEF (SystemProcessorPerformanceInformation)
	QSI_DEF (SystemFlagsInformation)
	SSI_DEF (SystemFlagsInformation)
	QSI_DEF (SystemCallTimeInformation)
	QSI_DEF (SystemModuleInformation)
	QSI_DEF (SystemLocksInformation)
	QSI_DEF (SystemStackTraceInformation)
	QSI_DEF (SystemPagedPoolInformation)
	QSI_DEF (SystemNonPagedPoolInformation)
	QSI_DEF (SystemHandleInformation)
	QSI_DEF (SystemObjectInformation)
	QSI_DEF (SystemPageFileInformation)
	QSI_DEF (SystemVdmInstemulInformation)
	QSI_DEF (SystemVdmBopInformation)
	QSI_DEF (SystemFileCacheInformation)
	SSI_DEF (SystemFileCacheInformation)
	QSI_DEF (SystemPoolTagInformation)
	QSI_DEF (SystemInterruptInformation)
	QSI_DEF (SystemDpcBehaviourInformation)
	SSI_DEF (SystemDpcBehaviourInformation)
	QSI_DEF (SystemFullMemoryInformation)
	SSI_DEF (SystemLoadGdiDriverInformation)
	SSI_DEF (SystemUnloadGdiDriverInformation)
	QSI_DEF (SystemTimeAdjustmentInformation)
	SSI_DEF (SystemTimeAdjustmentInformation)
	QSI_DEF (SystemSummaryMemoryInformation)
	QSI_DEF (SystemNextEventIdInformation)
	QSI_DEF (SystemPerformanceTraceInformation)
	QSI_DEF (SystemCrashDumpInformation)
	QSI_DEF (SystemExceptionInformation)
	QSI_DEF (SystemCrashDumpStateInformation)
	QSI_DEF (SystemKernelDebuggerInformation)
	QSI_DEF (SystemContextSwitchInformation)
	QSI_DEF (SystemRegistryQuotaInformation)
	SSI_DEF (SystemRegistryQuotaInformation)
	SSI_DEF (SystemExtendServiceTableInformation)
	SSI_DEF (SystemPrioritySeperation)
	QSI_DEF (SystemVerifierAddDriverInformation)
	QSI_DEF (SystemVerifierRemoveDriverInformation)
	QSI_DEF (SystemProcessorIdleInformation)
	QSI_DEF (SystemLegacyDriverInformation)
	QSI_DEF (SystemCurrentTimeZoneInformation)
	SSI_DEF (SystemCurrentTimeZoneInformation)
static VOID	ExpCopyLookasideInformation (PSYSTEM_LOOKASIDE_INFORMATION *InfoPointer, PULONG RemainingPointer, PLIST_ENTRY ListHead, BOOLEAN ListUsesMisses)
	QSI_DEF (SystemLookasideInformation)
	SSI_DEF (SystemTimeSlipNotification)
NTSTATUS NTAPI	MmSessionCreate (OUT PULONG SessionId)
NTSTATUS NTAPI	MmSessionDelete (IN ULONG SessionId)
	SSI_DEF (SystemSessionCreate)
	SSI_DEF (SystemSessionDetach)
	QSI_DEF (SystemSessionInformation)
	QSI_DEF (SystemRangeStartInformation)
	QSI_DEF (SystemVerifierInformation)
	SSI_DEF (SystemVerifierInformation)
	SSI_DEF (SystemVerifierThunkExtend)
	QSI_DEF (SystemSessionProcessesInformation)
	SSI_DEF (SystemLoadGdiDriverInSystemSpaceInformation)
	QSI_DEF (SystemNumaProcessorMap)
	QSI_DEF (SystemPrefetcherInformation)
	QSI_DEF (SystemExtendedProcessInformation)
	QSI_DEF (SystemRecommendedSharedDataAlignment)
	QSI_DEF (SystemNumaAvailableMemory)
	QSI_DEF (SystemExtendedHandleInformation)
	QSI_DEF (SystemObjectSecurityMode)
	QSI_DEF (SystemLogicalProcessorInformation)
	QSI_DEF (SystemFirmwareTableInformation)
	C_ASSERT (SystemBasicInformation==0)
__kernel_entry NTSTATUS NTAPI	NtQuerySystemInformation (_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID SystemInformation, _In_ ULONG Length, _Out_opt_ PULONG UnsafeResultLength)
NTSTATUS NTAPI	NtSetSystemInformation (IN SYSTEM_INFORMATION_CLASS SystemInformationClass, IN PVOID SystemInformation, IN ULONG SystemInformationLength)
ULONG NTAPI	NtGetCurrentProcessorNumber (VOID)
KPROCESSOR_MODE NTAPI	ExGetPreviousMode (VOID)

Variables
LIST_ENTRY	HandleTableListHead
EX_PUSH_LOCK	HandleTableListLock
FAST_MUTEX	ExpEnvironmentLock
ERESOURCE	ExpFirmwareTableResource
LIST_ENTRY	ExpFirmwareTableProviderListHead
static QSSI_CALLS	CallQS []

Macro Definition Documentation

MAX_ENVVAL_SIZE

#define MAX_ENVVAL_SIZE   1024

Definition at line 20 of file sysinfo.c.

MAX_SYSTEM_INFO_CLASS

#define MAX_SYSTEM_INFO_CLASS   (sizeof(CallQS) / sizeof(CallQS[0]))

Definition at line 2921 of file sysinfo.c.

MIN_SYSTEM_INFO_CLASS

#define MIN_SYSTEM_INFO_CLASS   (SystemBasicInformation)

Definition at line 2920 of file sysinfo.c.

NDEBUG

#define NDEBUG

Definition at line 16 of file sysinfo.c.

QSI_DEF

#define QSI_DEF

(

n

)

static NTSTATUS QSI_USE(n) (PVOID Buffer, ULONG Size, PULONG ReqSize)

Definition at line 596 of file sysinfo.c.

QSI_USE

#define QSI_USE

(

n

)

QSI##n

Definition at line 595 of file sysinfo.c.

SI_QS

#define SI_QS

(

n

)

{QSI_USE(n),SSI_USE(n)}

Definition at line 2831 of file sysinfo.c.

SI_QX

#define SI_QX

(

n

)

{QSI_USE(n),NULL}

Definition at line 2832 of file sysinfo.c.

SI_XS

#define SI_XS

(

n

)

{NULL,SSI_USE(n)}

Definition at line 2833 of file sysinfo.c.

SI_XX

#define SI_XX

(

n

)

{NULL,NULL}

Definition at line 2834 of file sysinfo.c.

SIG_ACPI

#define SIG_ACPI   0x41435049

Definition at line 22 of file sysinfo.c.

SIG_FIRM

#define SIG_FIRM   0x4649524D

Definition at line 23 of file sysinfo.c.

SIG_RSMB

#define SIG_RSMB   0x52534D42

Definition at line 24 of file sysinfo.c.

SSI_DEF

#define SSI_DEF

(

n

)

static NTSTATUS SSI_USE(n) (PVOID Buffer, ULONG Size)

Definition at line 600 of file sysinfo.c.

SSI_USE

#define SSI_USE

(

n

)

SSI##n

Definition at line 599 of file sysinfo.c.

Typedef Documentation

QSSI_CALLS

typedef struct _QSSI_CALLS QSSI_CALLS

Function Documentation

C_ASSERT()

C_ASSERT

(

SystemBasicInformation

= =0

)

ExGetCurrentProcessorCounts()

VOID NTAPI ExGetCurrentProcessorCounts	(	PULONG	ThreadKernelTime,
		PULONG	TotalCpuTime,
		PULONG	ProcessorNumber
	)

Definition at line 345 of file sysinfo.c.

{
    PKPRCB Prcb;

    Prcb = KeGetCurrentPrcb();

    *ThreadKernelTime = Prcb->KernelTime + Prcb->UserTime;
    *TotalCpuTime = Prcb->CurrentThread->KernelTime;
    *ProcessorNumber = KeGetCurrentProcessorNumber();
}

Referenced by NdisGetCurrentProcessorCounts().

ExGetCurrentProcessorCpuUsage()

VOID NTAPI ExGetCurrentProcessorCpuUsage

(

PULONG

CpuUsage

)

Definition at line 324 of file sysinfo.c.

{
    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;
}

Referenced by NdisGetCurrentProcessorCpuUsage().

ExGetPreviousMode()

KPROCESSOR_MODE NTAPI ExGetPreviousMode

(

VOID

)

Definition at line 3066 of file sysinfo.c.

{
    /* Just use Ke */
    return KeGetPreviousMode();
}

Referenced by _Function_class_(), _IRQL_requires_max_(), ApphelpCacheAccessCheck(), CreateClientPort(), DbgkMapViewOfSection(), DbgkUnMapViewOfSection(), IKsPin_PinMasterClock(), IopCreateFile(), IopDeviceFsIoControl(), IopGetSetSecurityObject(), IopQueryAttributesFile(), IopUnloadDriver(), KernelModeTest(), KsFastMethodHandler(), KsFastPropertyHandler(), KsInstallBusEnumInterface(), KsReadFile(), KsRemoveBusEnumInterface(), KsStreamIo(), KsWriteFile(), MiQueryMemoryBasicInformation(), MiQueryMemorySectionName(), MmCreateArm3Section(), MmCreateCacheSection(), MmCreateDataFileSection(), MmCreateImageSection(), MmCreatePageFileSection(), MmCreateSection(), NtAccessCheck(), NtAddAtom(), NtAlertResumeThread(), NtAlertThread(), NtAllocateLocallyUniqueId(), NtAllocateUuids(), NtAssignProcessToJobObject(), NtCancelTimer(), NtClearEvent(), NtClose(), NtCloseObjectAuditAlarm(), NtCompareTokens(), NtCreateDebugObject(), NtCreateDirectoryObject(), NtCreateEvent(), NtCreateEventPair(), NtCreateIoCompletion(), NtCreateJobObject(), NtCreateKey(), NtCreateMutant(), NtCreatePagingFile(), NtCreateProcessEx(), NtCreateProfile(), NtCreateSection(), NtCreateSemaphore(), NtCreateSymbolicLinkObject(), NtCreateTimer(), NtCreateToken(), NtDebugActiveProcess(), NtDebugContinue(), NtDelayExecution(), NtDeleteKey(), NtDeleteValueKey(), NtDisplayString(), NtDuplicateObject(), NtEnumerateKey(), NtEnumerateValueKey(), NtExtendSection(), NtFindAtom(), NtFlushInstructionCache(), NtFlushKey(), NtFlushVirtualMemory(), NtGetContextThread(), NtGetWriteWatch(), NtImpersonateThread(), NtIsProcessInJob(), NtLoadKeyEx(), NtLockProductActivationKeys(), NtLockVirtualMemory(), NtMakePermanentObject(), NtMapViewOfSection(), NtNotifyChangeDirectoryFile(), NtOpenDirectoryObject(), NtOpenEvent(), NtOpenEventPair(), NtOpenIoCompletion(), NtOpenJobObject(), NtOpenKey(), NtOpenMutant(), NtOpenObjectAuditAlarm(), NtOpenProcessTokenEx(), NtOpenSection(), NtOpenSemaphore(), NtOpenSymbolicLinkObject(), NtOpenThreadTokenEx(), NtOpenTimer(), NtPrivilegedServiceAuditAlarm(), NtProtectVirtualMemory(), NtPulseEvent(), NtQueryDirectoryFile(), NtQueryDirectoryObject(), NtQueryEvent(), NtQueryInformationAtom(), NtQueryInformationFile(), NtQueryInformationJobObject(), NtQueryInformationProcess(), NtQueryInformationThread(), NtQueryInformationToken(), NtQueryIntervalProfile(), NtQueryIoCompletion(), NtQueryKey(), NtQueryMutant(), NtQueryObject(), NtQueryPerformanceCounter(), NtQuerySection(), NtQuerySecurityObject(), NtQuerySemaphore(), NtQuerySymbolicLinkObject(), NtQuerySystemEnvironmentValue(), NtQuerySystemInformation(), NtQuerySystemTime(), NtQueryTimer(), NtQueryTimerResolution(), NtQueryValueKey(), NtQueryVirtualMemory(), NtQueueApcThreadEx(), NtRaiseHardError(), NtReadVirtualMemory(), NtReleaseMutant(), NtReleaseSemaphore(), NtRemoveIoCompletion(), NtRemoveProcessDebug(), NtResetEvent(), NtResetWriteWatch(), NtResumeProcess(), NtResumeThread(), NtSaveKeyEx(), NtSaveMergedKeys(), NtSetContextThread(), NtSetDebugFilterState(), NtSetDefaultHardErrorPort(), NtSetEvent(), NtSetEventBoostPriority(), NtSetHighEventPair(), NtSetHighWaitLowEventPair(), NtSetInformationDebugObject(), NtSetInformationFile(), NtSetInformationJobObject(), NtSetInformationObject(), NtSetInformationProcess(), NtSetInformationThread(), NtSetInformationToken(), NtSetIoCompletion(), NtSetLowEventPair(), NtSetLowWaitHighEventPair(), NtSetSecurityObject(), NtSetSystemEnvironmentValue(), NtSetSystemInformation(), NtSetSystemTime(), NtSetTimer(), NtSetTimerResolution(), NtSetValueKey(), NtSignalAndWaitForSingleObject(), NtStartProfile(), NtStopProfile(), NtSuspendProcess(), NtSuspendThread(), NtTerminateJobObject(), NtTestAlert(), NtUnloadKey2(), NtUnlockVirtualMemory(), NtUnmapViewOfSection(), NtUserGetGuiResources(), NtWaitForDebugEvent(), NtWaitForMultipleObjects(), NtWaitForSingleObject(), NtWaitHighEventPair(), NtWaitLowEventPair(), NtWriteVirtualMemory(), ObpCreateHandle(), ObQueryObjectAuditingByHandle(), PsOpenTokenOfProcess(), PspAssignPrimaryToken(), PspCreateProcess(), PspCreateThread(), PspSetPrimaryToken(), QSI_DEF(), SepAccessCheckAndAuditAlarm(), SSI_DEF(), START_TEST(), TestMessageHandler(), UserModeTest(), VfatSetRenameInformation(), WmipOpenGuidForEvents(), and WmipRegisterGuids().

ExIsProcessorFeaturePresent()

BOOLEAN NTAPI ExIsProcessorFeaturePresent

(

IN ULONG

ProcessorFeature

)

Definition at line 363 of file sysinfo.c.

{
    /* 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]);
}

Referenced by KsecReadMachineSpecificCounters(), PciApplyHacks(), and PciQueryRequirements().

ExLockUserBuffer()

NTSTATUS NTAPI ExLockUserBuffer	(	PVOID	BaseAddress,
		ULONG	Length,
		KPROCESSOR_MODE	AccessMode,
		LOCK_OPERATION	Operation,
		PVOID *	MappedSystemVa,
		PMDL *	OutMdl
	)

Definition at line 202 of file sysinfo.c.

{
    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;
}

Referenced by QSI_DEF().

ExpConvertLdrModuleToRtlModule()

FORCEINLINE NTSTATUS ExpConvertLdrModuleToRtlModule	(	IN ULONG	ModuleCount,
		IN PLDR_DATA_TABLE_ENTRY	LdrEntry,
		OUT PRTL_PROCESS_MODULE_INFORMATION	ModuleInfo
	)

Definition at line 35 of file sysinfo.c.

{
    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;
}

Referenced by ExpQueryModuleInformation().

ExpCopyLookasideInformation()

static VOID ExpCopyLookasideInformation ( PSYSTEM_LOOKASIDE_INFORMATION *  InfoPointer, PULONG  RemainingPointer, PLIST_ENTRY  ListHead, BOOLEAN  ListUsesMisses  )

static

Definition at line 2083 of file sysinfo.c.

{
    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;
}

Referenced by QSI_DEF().

ExpGetRawSMBiosTable()

NTSTATUS NTAPI ExpGetRawSMBiosTable	(	_Out_opt_ PVOID	Buffer,
		_Out_ ULONG *	OutSize,
		_In_ ULONG	BufferSize
	)

Definition at line 250 of file sysinfo.c.

{
    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;
}

Referenced by QSI_DEF().

ExpQueryModuleInformation()

NTSTATUS NTAPI ExpQueryModuleInformation	(	IN PLIST_ENTRY	KernelModeList,
		IN PLIST_ENTRY	UserModeList,
		OUT PRTL_PROCESS_MODULES	Modules,
		IN ULONG	Length,
		OUT PULONG	ReturnLength
	)

Definition at line 91 of file sysinfo.c.

{
    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;
}

Referenced by QSI_DEF().

ExQueryPoolUsage()

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
	)

Definition at line 1714 of file expool.c.

{
    ULONG i;
    PPOOL_DESCRIPTOR PoolDesc;

    //
    // Assume all failures
    //
    *PagedPoolPages = 0;
    *PagedPoolAllocs = 0;
    *PagedPoolFrees = 0;

    //
    // Tally up the totals for all the apged pool
    //
    for (i = 0; i < ExpNumberOfPagedPools + 1; i++)
    {
        PoolDesc = ExpPagedPoolDescriptor[i];
        *PagedPoolPages += PoolDesc->TotalPages + PoolDesc->TotalBigPages;
        *PagedPoolAllocs += PoolDesc->RunningAllocs;
        *PagedPoolFrees += PoolDesc->RunningDeAllocs;
    }

    //
    // The first non-paged pool has a hardcoded well-known descriptor name
    //
    PoolDesc = &NonPagedPoolDescriptor;
    *NonPagedPoolPages = PoolDesc->TotalPages + PoolDesc->TotalBigPages;
    *NonPagedPoolAllocs = PoolDesc->RunningAllocs;
    *NonPagedPoolFrees = PoolDesc->RunningDeAllocs;

    //
    // If the system has more than one non-paged pool, copy the other descriptor
    // totals as well
    //
#if 0
    if (ExpNumberOfNonPagedPools > 1)
    {
        for (i = 0; i < ExpNumberOfNonPagedPools; i++)
        {
            PoolDesc = ExpNonPagedPoolDescriptor[i];
            *NonPagedPoolPages += PoolDesc->TotalPages + PoolDesc->TotalBigPages;
            *NonPagedPoolAllocs += PoolDesc->RunningAllocs;
            *NonPagedPoolFrees += PoolDesc->RunningDeAllocs;
        }
    }
#endif

    //
    // Get the amount of hits in the system lookaside lists
    //
    if (!IsListEmpty(&ExPoolLookasideListHead))
    {
        PLIST_ENTRY ListEntry;

        for (ListEntry = ExPoolLookasideListHead.Flink;
             ListEntry != &ExPoolLookasideListHead;
             ListEntry = ListEntry->Flink)
        {
            PGENERAL_LOOKASIDE Lookaside;

            Lookaside = CONTAINING_RECORD(ListEntry, GENERAL_LOOKASIDE, ListEntry);

            if (Lookaside->Type == NonPagedPool)
            {
                *NonPagedPoolLookasideHits += Lookaside->AllocateHits;
            }
            else
            {
                *PagedPoolLookasideHits += Lookaside->AllocateHits;
            }
        }
    }
}

Referenced by QSI_DEF().

ExUnlockUserBuffer()

VOID NTAPI ExUnlockUserBuffer

(

PMDL

Mdl

)

Definition at line 194 of file sysinfo.c.

{
    MmUnlockPages(Mdl);
    ExFreePoolWithTag(Mdl, TAG_MDL);
}

Referenced by ExLockUserBuffer(), and QSI_DEF().

ExVerifySuite()

BOOLEAN NTAPI ExVerifySuite

(

SUITE_TYPE

SuiteType

)

Definition at line 377 of file sysinfo.c.

{
    if (SuiteType == Personal) return TRUE;
    return FALSE;
}

Referenced by DisplayBootBitmap(), InitializeMachineInformation(), and InitializeTransferPackets().

MmSessionCreate()

NTSTATUS NTAPI MmSessionCreate

(

OUT PULONG

SessionId

)

Definition at line 822 of file session.c.

{
    PEPROCESS Process = PsGetCurrentProcess();
    ULONG SessionLeaderExists;
    NTSTATUS Status;

    /* Fail if the process is already in a session */
    if (Process->Flags & PSF_PROCESS_IN_SESSION_BIT)
    {
        DPRINT1("Process already in session\n");
        return STATUS_ALREADY_COMMITTED;
    }

    /* Check if the process is already the session leader */
    if (!Process->Vm.Flags.SessionLeader)
    {
        /* Atomically set it as the leader */
        SessionLeaderExists = InterlockedCompareExchange(&MiSessionLeaderExists, 1, 0);
        if (SessionLeaderExists)
        {
            DPRINT1("Session leader race\n");
            return STATUS_INVALID_SYSTEM_SERVICE;
        }

        /* Do the work required to upgrade him */
        MiSessionLeader(Process);
    }

    /* Create the session */
    KeEnterCriticalRegion();
    Status = MiSessionCreateInternal(SessionId);
    if (!NT_SUCCESS(Status))
    {
        KeLeaveCriticalRegion();
        return Status;
    }

    /* Set up the session working set */
    Status = MiSessionInitializeWorkingSetList();
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        //MiDereferenceSession();
        ASSERT(FALSE);
        KeLeaveCriticalRegion();
        return Status;
    }

    /* All done */
    KeLeaveCriticalRegion();

    /* Set and assert the flags, and return */
    MmSessionSpace->u.Flags.Initialized = 1;
    PspSetProcessFlag(Process, PSF_PROCESS_IN_SESSION_BIT);
    ASSERT(MiSessionLeaderExists == 1);
    return Status;
}

Referenced by SSI_DEF().

MmSessionDelete()

NTSTATUS NTAPI MmSessionDelete

(

IN ULONG

SessionId

)

Definition at line 882 of file session.c.

{
    PEPROCESS Process = PsGetCurrentProcess();

    /* Process must be in a session */
    if (!(Process->Flags & PSF_PROCESS_IN_SESSION_BIT))
    {
        DPRINT1("Not in a session!\n");
        return STATUS_UNABLE_TO_FREE_VM;
    }

    /* It must be the session leader */
    if (!Process->Vm.Flags.SessionLeader)
    {
        DPRINT1("Not a session leader!\n");
        return STATUS_UNABLE_TO_FREE_VM;
    }

    /* Remove one reference count */
    KeEnterCriticalRegion();
    /* FIXME: Do it */
    KeLeaveCriticalRegion();

    /* All done */
    return STATUS_SUCCESS;
}

Referenced by SSI_DEF().

NtEnumerateSystemEnvironmentValuesEx()

NTSTATUS NTAPI NtEnumerateSystemEnvironmentValuesEx	(	IN ULONG	InformationClass,
		IN PVOID	Buffer,
		IN ULONG	BufferLength
	)

Definition at line 557 of file sysinfo.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

NtGetCurrentProcessorNumber()

ULONG NTAPI NtGetCurrentProcessorNumber

(

VOID

)

Definition at line 3057 of file sysinfo.c.

{
    /* Just use Ke */
    return KeGetCurrentProcessorNumber();
}

Referenced by RtlGetCurrentProcessorNumber().

NtQuerySystemEnvironmentValue()

NTSTATUS NTAPI NtQuerySystemEnvironmentValue	(	IN PUNICODE_STRING	VariableName,
		OUT PWSTR	ValueBuffer,
		IN ULONG	ValueBufferLength,
		IN OUT PULONG ReturnLength	OPTIONAL
	)

Definition at line 385 of file sysinfo.c.

{
    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;
}

Referenced by Test_API().

NtQuerySystemEnvironmentValueEx()

NTSTATUS NTAPI NtQuerySystemEnvironmentValueEx	(	IN PUNICODE_STRING	VariableName,
		IN LPGUID	VendorGuid,
		IN PVOID	Value,
		IN OUT PULONG	ReturnLength,
		IN OUT PULONG	Attributes
	)

Definition at line 567 of file sysinfo.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

NtQuerySystemInformation()

__kernel_entry NTSTATUS NTAPI NtQuerySystemInformation	(	_In_ SYSTEM_INFORMATION_CLASS	SystemInformationClass,
		_Out_writes_bytes_to_opt_(SystemInformationLength, *ReturnLength) PVOID	SystemInformation,
		_In_ ULONG	Length,
		_Out_opt_ PULONG	UnsafeResultLength
	)

Definition at line 2929 of file sysinfo.c.

{
    KPROCESSOR_MODE PreviousMode;
    ULONG ResultLength = 0;
    ULONG Alignment = TYPE_ALIGNMENT(ULONG);
    NTSTATUS FStatus = STATUS_NOT_IMPLEMENTED;

    PAGED_CODE();

    PreviousMode = ExGetPreviousMode();

    _SEH2_TRY
    {
#if (NTDDI_VERSION >= NTDDI_VISTA)
        /*
         * Check if 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, Length, Alignment);
            if (UnsafeResultLength != NULL)
                ProbeForWriteUlong(UnsafeResultLength);
        }

        if (UnsafeResultLength)
            *UnsafeResultLength = 0;

#if (NTDDI_VERSION < NTDDI_VISTA)
        /*
         * Check if the request is valid.
         */
        if (SystemInformationClass < MIN_SYSTEM_INFO_CLASS ||
            SystemInformationClass >= MAX_SYSTEM_INFO_CLASS)
        {
            _SEH2_YIELD(return STATUS_INVALID_INFO_CLASS);
        }
#endif

        if (NULL != CallQS [SystemInformationClass].Query)
        {
            /*
             * Hand the request to a subhandler.
             */
            FStatus = CallQS [SystemInformationClass].Query(SystemInformation,
                                                            Length,
                                                            &ResultLength);

            /* Save the result length to the caller */
            if (UnsafeResultLength)
                *UnsafeResultLength = ResultLength;
        }
    }
    _SEH2_EXCEPT(ExSystemExceptionFilter())
    {
        FStatus = _SEH2_GetExceptionCode();
    }
    _SEH2_END;

    return FStatus;
}

Referenced by BaseQuerySystemFirmware(), GetLogicalProcessorInformation(), GetNumaAvailableMemoryNode(), GetNumaHighestNodeNumber(), GetNumaNodeProcessorMask(), GetNumaProcessorNode(), GetSystemInfo(), and GetSystemRegistryQuota().

NtSetSystemEnvironmentValue()

NTSTATUS NTAPI NtSetSystemEnvironmentValue	(	IN PUNICODE_STRING	VariableName,
		IN PUNICODE_STRING	Value
	)

Definition at line 487 of file sysinfo.c.

{
    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;
}

NtSetSystemEnvironmentValueEx()

NTSTATUS NTAPI NtSetSystemEnvironmentValueEx	(	IN PUNICODE_STRING	VariableName,
		IN LPGUID	VendorGuid,
		IN PVOID	Value,
		IN OUT PULONG	ReturnLength,
		IN OUT PULONG	Attributes
	)

Definition at line 579 of file sysinfo.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

NtSetSystemInformation()

NTSTATUS NTAPI NtSetSystemInformation	(	IN SYSTEM_INFORMATION_CLASS	SystemInformationClass,
		IN PVOID	SystemInformation,
		IN ULONG	SystemInformationLength
	)

Definition at line 3008 of file sysinfo.c.

{
    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 the request is valid.
         */
        if ((SystemInformationClass >= MIN_SYSTEM_INFO_CLASS) &&
            (SystemInformationClass < MAX_SYSTEM_INFO_CLASS))
        {
            if (NULL != CallQS [SystemInformationClass].Set)
            {
                /*
                 * Hand the request to a subhandler.
                 */
                Status = CallQS [SystemInformationClass].Set(SystemInformation,
                                                             SystemInformationLength);
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;

    return Status;
}

QSI_DEF() [1/55]

QSI_DEF

(

SystemBasicInformation

)

Definition at line 615 of file sysinfo.c.

{
    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;
}

QSI_DEF() [2/55]

QSI_DEF

(

SystemProcessorInformation

)

Definition at line 645 of file sysinfo.c.

{
    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;
    Spi->Reserved = 0;
    Spi->ProcessorFeatureBits = KeFeatureBits;

    DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
        Spi->ProcessorLevel, Spi->ProcessorRevision);

    return STATUS_SUCCESS;
}

QSI_DEF() [3/55]

QSI_DEF

(

SystemPerformanceInformation

)

Definition at line 670 of file sysinfo.c.

{
    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;
    /*
     *   Add up all the used "Committed" memory + pagefile.
     *   Not sure this is right. 8^\
     */
    Spi->CommittedPages = MiMemoryConsumers[MC_SYSTEM].PagesUsed +
                          MiMemoryConsumers[MC_CACHE].PagesUsed +
                          MiMemoryConsumers[MC_USER].PagesUsed +
                          MiUsedSwapPages;
    /*
     *  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 = 0; /* FIXME */
    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_CACHE].PagesUsed;
    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;
}

QSI_DEF() [4/55]

QSI_DEF

(

SystemTimeOfDayInformation

)

Definition at line 825 of file sysinfo.c.

{
    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;
}

QSI_DEF() [5/55]

QSI_DEF

(

SystemPathInformation

)

Definition at line 862 of file sysinfo.c.

{
    /* FIXME: QSI returns STATUS_BREAKPOINT. Why? */
    DPRINT1("NtQuerySystemInformation - SystemPathInformation not implemented\n");

    return STATUS_BREAKPOINT;
}

QSI_DEF() [6/55]

QSI_DEF

(

SystemProcessInformation

)

Definition at line 871 of file sysinfo.c.

{
    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);
                        RtlAnsiStringToUnicodeString(&SpiCurrent->ImageName, &ImageName, FALSE);
                    }
                }
                else
                {
                    RtlInitUnicodeString(&SpiCurrent->ImageName, NULL);
                }

                SpiCurrent->BasePriority = Process->Pcb.BasePriority;
                SpiCurrent->UniqueProcessId = Process->UniqueProcessId;
                SpiCurrent->InheritedFromUniqueProcessId = Process->InheritedFromUniqueProcessId;
                SpiCurrent->HandleCount = 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[0];
                SpiCurrent->QuotaPagedPoolUsage = Process->QuotaUsage[0];
                SpiCurrent->QuotaPeakNonPagedPoolUsage = Process->QuotaPeak[1];
                SpiCurrent->QuotaNonPagedPoolUsage = Process->QuotaUsage[1];
                SpiCurrent->PagefileUsage = Process->QuotaUsage[2];
                SpiCurrent->PeakPagefileUsage = Process->QuotaPeak[2];
                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;
}

QSI_DEF() [7/55]

QSI_DEF

(

SystemCallCountInformation

)

Definition at line 1114 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemCallCountInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [8/55]

QSI_DEF

(

SystemDeviceInformation

)

Definition at line 1122 of file sysinfo.c.

{
    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;
}

QSI_DEF() [9/55]

QSI_DEF

(

SystemProcessorPerformanceInformation

)

Definition at line 1149 of file sysinfo.c.

{
    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;
}

QSI_DEF() [10/55]

QSI_DEF

(

SystemFlagsInformation

)

Definition at line 1186 of file sysinfo.c.

{
#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;
}

QSI_DEF() [11/55]

QSI_DEF

(

SystemCallTimeInformation

)

Definition at line 1222 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemCallTimeInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [12/55]

QSI_DEF

(

SystemModuleInformation

)

Definition at line 1230 of file sysinfo.c.

{
    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;
}

QSI_DEF() [13/55]

QSI_DEF

(

SystemLocksInformation

)

Definition at line 1252 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemLocksInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [14/55]

QSI_DEF

(

SystemStackTraceInformation

)

Definition at line 1260 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemStackTraceInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [15/55]

QSI_DEF

(

SystemPagedPoolInformation

)

Definition at line 1268 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemPagedPoolInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [16/55]

QSI_DEF

(

SystemNonPagedPoolInformation

)

Definition at line 1276 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemNonPagedPoolInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [17/55]

QSI_DEF

(

SystemHandleInformation

)

Definition at line 1285 of file sysinfo.c.

{
    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;
}

QSI_DEF() [18/55]

QSI_DEF

(

SystemObjectInformation

)

Definition at line 1414 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemObjectInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [19/55]

QSI_DEF

(

SystemPageFileInformation

)

Definition at line 1422 of file sysinfo.c.

{
    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;
}

QSI_DEF() [20/55]

QSI_DEF

(

SystemVdmInstemulInformation

)

Definition at line 1446 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemVdmInstemulInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [21/55]

QSI_DEF

(

SystemVdmBopInformation

)

Definition at line 1454 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemVdmBopInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [22/55]

QSI_DEF

(

SystemFileCacheInformation

)

Definition at line 1462 of file sysinfo.c.

{
    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_CACHE].PagesUsed * PAGE_SIZE;
    Sci->PeakSize =
            MiMemoryConsumers[MC_CACHE].PagesUsed * PAGE_SIZE; /* FIXME */
    /* Taskmgr multiplies this one by page size right away */
    Sci->CurrentSizeIncludingTransitionInPages =
        MiMemoryConsumers[MC_CACHE].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;
}

QSI_DEF() [23/55]

QSI_DEF

(

SystemPoolTagInformation

)

Definition at line 1503 of file sysinfo.c.

{
    if (Size < sizeof(SYSTEM_POOLTAG_INFORMATION)) return STATUS_INFO_LENGTH_MISMATCH;
    return ExGetPoolTagInfo(Buffer, Size, ReqSize);
}

QSI_DEF() [24/55]

QSI_DEF

(

SystemInterruptInformation

)

Definition at line 1510 of file sysinfo.c.

{
    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;
}

QSI_DEF() [25/55]

QSI_DEF

(

SystemDpcBehaviourInformation

)

Definition at line 1540 of file sysinfo.c.

{
    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;
}

QSI_DEF() [26/55]

QSI_DEF

(

SystemFullMemoryInformation

)

Definition at line 1565 of file sysinfo.c.

{
    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;
}

QSI_DEF() [27/55]

QSI_DEF

(

SystemTimeAdjustmentInformation

)

Definition at line 1668 of file sysinfo.c.

{
    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;
}

QSI_DEF() [28/55]

QSI_DEF

(

SystemSummaryMemoryInformation

)

Definition at line 1729 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemSummaryMemoryInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [29/55]

QSI_DEF

(

SystemNextEventIdInformation

)

Definition at line 1737 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemNextEventIdInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [30/55]

QSI_DEF

(

SystemPerformanceTraceInformation

)

Definition at line 1745 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemPerformanceTraceInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [31/55]

QSI_DEF

(

SystemCrashDumpInformation

)

Definition at line 1753 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemCrashDumpInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [32/55]

QSI_DEF

(

SystemExceptionInformation

)

Definition at line 1761 of file sysinfo.c.

{
    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;
}

QSI_DEF() [33/55]

QSI_DEF

(

SystemCrashDumpStateInformation

)

Definition at line 1798 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemCrashDumpStateInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [34/55]

QSI_DEF

(

SystemKernelDebuggerInformation

)

Definition at line 1806 of file sysinfo.c.

{
    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;
}

QSI_DEF() [35/55]

QSI_DEF

(

SystemContextSwitchInformation

)

Definition at line 1830 of file sysinfo.c.

{
    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;
}

QSI_DEF() [36/55]

QSI_DEF

(

SystemRegistryQuotaInformation

)

Definition at line 1872 of file sysinfo.c.

{
    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;
}

QSI_DEF() [37/55]

QSI_DEF

(

SystemVerifierAddDriverInformation

)

Definition at line 2013 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemVerifierAddDriverInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [38/55]

QSI_DEF

(

SystemVerifierRemoveDriverInformation

)

Definition at line 2021 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemVerifierRemoveDriverInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [39/55]

QSI_DEF

(

SystemProcessorIdleInformation

)

Definition at line 2029 of file sysinfo.c.

{
    *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;
}

QSI_DEF() [40/55]

QSI_DEF

(

SystemLegacyDriverInformation

)

Definition at line 2044 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemLegacyDriverInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [41/55]

QSI_DEF

(

SystemCurrentTimeZoneInformation

)

Definition at line 2052 of file sysinfo.c.

{
    *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;
}

QSI_DEF() [42/55]

QSI_DEF

(

SystemLookasideInformation

)

Definition at line 2138 of file sysinfo.c.

{
    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;
}

QSI_DEF() [43/55]

QSI_DEF

(

SystemSessionInformation

)

Definition at line 2294 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemSessionInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [44/55]

QSI_DEF

(

SystemRangeStartInformation

)

Definition at line 2303 of file sysinfo.c.

{
    /* 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;
}

QSI_DEF() [45/55]

QSI_DEF

(

SystemVerifierInformation

)

Definition at line 2316 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemVerifierInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [46/55]

QSI_DEF

(

SystemSessionProcessesInformation

)

Definition at line 2342 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemSessionProcessInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [47/55]

QSI_DEF

(

SystemNumaProcessorMap

)

Definition at line 2360 of file sysinfo.c.

{
    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;
}

QSI_DEF() [48/55]

QSI_DEF

(

SystemPrefetcherInformation

)

Definition at line 2407 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemPrefetcherInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [49/55]

QSI_DEF

(

SystemExtendedProcessInformation

)

Definition at line 2416 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemExtendedProcessInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [50/55]

QSI_DEF

(

SystemRecommendedSharedDataAlignment

)

Definition at line 2425 of file sysinfo.c.

{
    /* FIXME */
    DPRINT1("NtQuerySystemInformation - SystemRecommendedSharedDataAlignment not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

QSI_DEF() [51/55]

QSI_DEF

(

SystemNumaAvailableMemory

)

Definition at line 2434 of file sysinfo.c.

{
    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 >=