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   RTL_NUMBER_OF(CallQS)

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 IdleTime, PULONG KernelAndUserTime, 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, _Out_opt_ PVOID Value, _Inout_ PULONG ReturnLength, _Out_opt_ PULONG Attributes)
NTSTATUS NTAPI	NtSetSystemEnvironmentValueEx (_In_ PUNICODE_STRING VariableName, _In_ LPGUID VendorGuid, _In_reads_bytes_opt_(ValueLength) PVOID Value, _In_ ULONG ValueLength, _In_ ULONG 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 SystemInformationLength, _Out_opt_ PULONG ReturnLength)
__kernel_entry NTSTATUS NTAPI	NtSetSystemInformation (_In_ SYSTEM_INFORMATION_CLASS SystemInformationClass, _In_reads_bytes_(SystemInformationLength) 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   RTL_NUMBER_OF(CallQS)

Definition at line 2929 of file sysinfo.c.

MIN_SYSTEM_INFO_CLASS

#define MIN_SYSTEM_INFO_CLASS   (SystemBasicInformation)

Definition at line 2928 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 598 of file sysinfo.c.

QSI_USE

#define QSI_USE

(

n

)

QSI##n

Definition at line 597 of file sysinfo.c.

SI_QS

#define SI_QS

(

n

)

{QSI_USE(n),SSI_USE(n)}

Definition at line 2839 of file sysinfo.c.

SI_QX

#define SI_QX

(

n

)

{QSI_USE(n),NULL}

Definition at line 2840 of file sysinfo.c.

SI_XS

#define SI_XS

(

n

)

{NULL,SSI_USE(n)}

Definition at line 2841 of file sysinfo.c.

SI_XX

#define SI_XX

(

n

)

{NULL,NULL}

Definition at line 2842 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 602 of file sysinfo.c.

SSI_USE

#define SSI_USE

(

n

)

SSI##n

Definition at line 601 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	IdleTime,
		PULONG	KernelAndUserTime,
		PULONG	ProcessorNumber
	)

Definition at line 345 of file sysinfo.c.

{
    PKPRCB Prcb;
 
    Prcb = KeGetCurrentPrcb();
 
    *IdleTime = Prcb->IdleThread->KernelTime;
    *KernelAndUserTime = Prcb->KernelTime + Prcb->UserTime;
    *ProcessorNumber = (ULONG)Prcb->Number;
}

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 3070 of file sysinfo.c.

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

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(), PciQueryRequirements(), and START_TEST().

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;
    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
 
    *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 KdSystemDebugControl(), and 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 2104 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 1768 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(), KdSystemDebugControl(), 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(), and InitializeMachineInformation().

MmSessionCreate()

NTSTATUS NTAPI MmSessionCreate

(

OUT PULONG

SessionId

)

Definition at line 827 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 887 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();
    MiDereferenceSession();
    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 3061 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,
		_Out_opt_ PVOID	Value,
		_Inout_ PULONG	ReturnLength,
		_Out_opt_ PULONG	Attributes
	)

Definition at line 567 of file sysinfo.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by _Success_().

NtQuerySystemInformation()

__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
	)

Definition at line 2937 of file sysinfo.c.

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

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_reads_bytes_opt_(ValueLength) PVOID	Value,
		_In_ ULONG	ValueLength,
		_In_ ULONG	Attributes
	)

Definition at line 580 of file sysinfo.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by SetFirmwareEnvironmentVariableExW().

NtSetSystemInformation()

__kernel_entry NTSTATUS NTAPI NtSetSystemInformation	(	_In_ SYSTEM_INFORMATION_CLASS	SystemInformationClass,
		_In_reads_bytes_(SystemInformationLength) PVOID	SystemInformation,
		_In_ ULONG	SystemInformationLength
	)

Definition at line 3014 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 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;
}

QSI_DEF() [1/55]

QSI_DEF

(

SystemBasicInformation

)

Definition at line 617 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

(

SystemCallCountInformation

)

Definition at line 1136 of file sysinfo.c.

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

QSI_DEF() [3/55]

QSI_DEF

(

SystemCallTimeInformation

)

Definition at line 1248 of file sysinfo.c.

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

QSI_DEF() [4/55]

QSI_DEF

(

SystemContextSwitchInformation

)

Definition at line 1852 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() [5/55]

QSI_DEF

(

SystemCrashDumpInformation

)

Definition at line 1775 of file sysinfo.c.

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

QSI_DEF() [6/55]

QSI_DEF

(

SystemCrashDumpStateInformation

)

Definition at line 1820 of file sysinfo.c.

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

QSI_DEF() [7/55]

QSI_DEF

(

SystemCurrentTimeZoneInformation

)

Definition at line 2074 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() [8/55]

QSI_DEF

(

SystemDeviceInformation

)

Definition at line 1144 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

(

SystemDpcBehaviourInformation

)

Definition at line 1562 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() [10/55]

QSI_DEF

(

SystemExceptionInformation

)

Definition at line 1783 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() [11/55]

QSI_DEF

(

SystemExtendedHandleInformation

)

Definition at line 2496 of file sysinfo.c.

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

QSI_DEF() [12/55]

QSI_DEF

(

SystemExtendedProcessInformation

)

Definition at line 2426 of file sysinfo.c.

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

QSI_DEF() [13/55]

QSI_DEF

(

SystemFileCacheInformation

)

Definition at line 1487 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_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;
}

QSI_DEF() [14/55]

QSI_DEF

(

SystemFirmwareTableInformation

)

Definition at line 2727 of file sysinfo.c.

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

QSI_DEF() [15/55]

QSI_DEF

(

SystemFlagsInformation

)

Definition at line 1208 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() [16/55]

QSI_DEF

(

SystemFullMemoryInformation

)

Definition at line 1587 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() [17/55]

QSI_DEF

(

SystemHandleInformation

)

Definition at line 1310 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 corrupted */
                        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

(

SystemInterruptInformation

)

Definition at line 1532 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() [19/55]

QSI_DEF

(

SystemKernelDebuggerInformation

)

Definition at line 1828 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() [20/55]

QSI_DEF

(

SystemLegacyDriverInformation

)

Definition at line 2066 of file sysinfo.c.

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

QSI_DEF() [21/55]

QSI_DEF

(

SystemLocksInformation

)

Definition at line 1278 of file sysinfo.c.

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

QSI_DEF() [22/55]

QSI_DEF

(

SystemLogicalProcessorInformation

)

Definition at line 2643 of file sysinfo.c.

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

QSI_DEF() [23/55]

QSI_DEF

(

SystemLookasideInformation

)

Definition at line 2159 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() [24/55]

QSI_DEF

(

SystemModuleInformation

)

Definition at line 1256 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() [25/55]

QSI_DEF

(

SystemNextEventIdInformation

)

Definition at line 1759 of file sysinfo.c.

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

QSI_DEF() [26/55]

QSI_DEF

(

SystemNonPagedPoolInformation

)

Definition at line 1302 of file sysinfo.c.

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

QSI_DEF() [27/55]

QSI_DEF

(

SystemNumaAvailableMemory

)

Definition at line 2442 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 >= 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;
}

QSI_DEF() [28/55]

QSI_DEF

(

SystemNumaProcessorMap

)

Definition at line 2372 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() [29/55]

QSI_DEF

(

SystemObjectInformation

)

Definition at line 1439 of file sysinfo.c.

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

QSI_DEF() [30/55]

QSI_DEF

(

SystemObjectSecurityMode

)

Definition at line 2627 of file sysinfo.c.

{
    PULONG ObjectSecurityInfo = (PULONG)Buffer;
 
    /* Validate input size */
    if (Size != sizeof(ULONG))
    {
        return STATUS_INFO_LENGTH_MISMATCH;
    }
 
    *ObjectSecurityInfo = ObpObjectSecurityMode;
 
    return STATUS_SUCCESS;
}

QSI_DEF() [31/55]

QSI_DEF

(

SystemPagedPoolInformation

)

Definition at line 1294 of file sysinfo.c.

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

QSI_DEF() [32/55]

QSI_DEF

(

SystemPageFileInformation

)

Definition at line 1447 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() [33/55]

QSI_DEF

(

SystemPathInformation

)

Definition at line 868 of file sysinfo.c.

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

QSI_DEF() [34/55]

QSI_DEF

(

SystemPerformanceInformation

)

Definition at line 682 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;
 
    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;
}

QSI_DEF() [35/55]

QSI_DEF

(

SystemPerformanceTraceInformation

)

Definition at line 1767 of file sysinfo.c.

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

QSI_DEF() [36/55]

QSI_DEF

(

SystemPoolTagInformation

)

Definition at line 1525 of file sysinfo.c.

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

QSI_DEF() [37/55]

QSI_DEF

(

SystemPrefetcherInformation

)

Definition at line 2418 of file sysinfo.c.

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

QSI_DEF() [38/55]

QSI_DEF

(

SystemProcessInformation

)

Definition at line 885 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);
                        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;
}

QSI_DEF() [39/55]

QSI_DEF

(

SystemProcessorIdleInformation

)

Definition at line 2051 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

(

SystemProcessorInformation

)

Definition at line 647 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;
#if (NTDDI_VERSION < NTDDI_WIN8)
    Spi->Reserved = 0;
#else
    Spi->MaximumProcessors = 0;
#endif
 
    /* According to Geoff Chappell, on Win 8.1 x64 / Win 10 x86, where this
       field is extended to 64 bits, it continues to produce only the low 32
       bits. For the full value, use SYSTEM_PROCESSOR_FEATURES_INFORMATION.
       See https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/sysinfo/processor.htm
     */
    Spi->ProcessorFeatureBits = (ULONG)KeFeatureBits;
 
    DPRINT("Arch %u Level %u Rev 0x%x\n", Spi->ProcessorArchitecture,
        Spi->ProcessorLevel, Spi->ProcessorRevision);
 
    return STATUS_SUCCESS;
}

QSI_DEF() [41/55]

QSI_DEF

(

SystemProcessorPerformanceInformation

)

Definition at line 1171 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() [42/55]

QSI_DEF

(

SystemRangeStartInformation

)

Definition at line 2320 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() [43/55]

QSI_DEF

(

SystemRecommendedSharedDataAlignment

)

Definition at line 2434 of file sysinfo.c.

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

QSI_DEF() [44/55]

QSI_DEF

(

SystemRegistryQuotaInformation

)

Definition at line 1894 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() [45/55]

QSI_DEF

(

SystemSessionInformation

)

Definition at line 2312 of file sysinfo.c.

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

QSI_DEF() [46/55]

QSI_DEF

(

SystemSessionProcessesInformation

)

Definition at line 2356 of file sysinfo.c.

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

QSI_DEF() [47/55]

QSI_DEF

(

SystemStackTraceInformation

)

Definition at line 1286 of file sysinfo.c.

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

QSI_DEF() [48/55]

QSI_DEF

(

SystemSummaryMemoryInformation

)

Definition at line 1751 of file sysinfo.c.

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

QSI_DEF() [49/55]

QSI_DEF

(

SystemTimeAdjustmentInformation

)

Definition at line 1690 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() [50/55]

QSI_DEF

(

SystemTimeOfDayInformation

)

Definition at line 831 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() [51/55]

QSI_DEF

(

SystemVdmBopInformation

)

Definition at line 1479 of file sysinfo.c.

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

QSI_DEF() [52/55]

QSI_DEF

(

SystemVdmInstemulInformation

)

Definition at line 1471 of file sysinfo.c.

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

QSI_DEF() [53/55]

QSI_DEF

(

SystemVerifierAddDriverInformation

)

Definition at line 2035 of file sysinfo.c.

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

QSI_DEF() [54/55]

QSI_DEF

(

SystemVerifierInformation

)

Definition at line 2333 of file sysinfo.c.

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

QSI_DEF() [55/55]

QSI_DEF

(

SystemVerifierRemoveDriverInformation

)

Definition at line 2043 of file sysinfo.c.

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

SSI_DEF() [1/16]

SSI_DEF

(

SystemCurrentTimeZoneInformation

)

Definition at line 2091 of file sysinfo.c.

{
    /* Check user buffer's size */
    if (Size < sizeof(RTL_TIME_ZONE_INFORMATION))
    {
        return STATUS_INFO_LENGTH_MISMATCH;
    }
 
    return ExpSetTimeZoneInformation((PRTL_TIME_ZONE_INFORMATION)Buffer);
}

SSI_DEF() [2/16]

SSI_DEF

(

SystemDpcBehaviourInformation

)

Definition at line 1579 of file sysinfo.c.

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

SSI_DEF() [3/16]

SSI_DEF

(

SystemExtendServiceTableInformation

)

Definition at line 1920 of file sysinfo.c.

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

SSI_DEF() [4/16]

SSI_DEF

(

SystemFileCacheInformation

)

Definition at line 1513 of file sysinfo.c.

{
    if (Size < sizeof(SYSTEM_FILECACHE_INFORMATION))
    {
        return STATUS_INFO_LENGTH_MISMATCH;
    }
    /* FIXME */
    DPRINT1("NtSetSystemInformation - SystemFileCacheInformation not implemented\n");
    return STATUS_NOT_IMPLEMENTED;
}

SSI_DEF() [5/16]

SSI_DEF

(

SystemFlagsInformation

)

Definition at line 1227 of file sysinfo.c.

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

SSI_DEF() [6/16]

SSI_DEF

(

SystemLoadGdiDriverInformation

)

Definition at line 1616 of file sysinfo.c.

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

SSI_DEF() [7/16]

SSI_DEF

(

SystemLoadGdiDriverInSystemSpaceInformation

)

Definition at line 2364 of file sysinfo.c.

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

SSI_DEF() [8/16]

SSI_DEF

(

SystemPrioritySeperation

)

Definition at line 2014 of file sysinfo.c.

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

SSI_DEF() [9/16]

SSI_DEF

(

SystemRegistryQuotaInformation

)

Definition at line 1912 of file sysinfo.c.

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

SSI_DEF() [10/16]

SSI_DEF

(

SystemSessionCreate

)

Definition at line 2266 of file sysinfo.c.

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

SSI_DEF() [11/16]

SSI_DEF

(

SystemSessionDetach

)

Definition at line 2291 of file sysinfo.c.

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

SSI_DEF() [12/16]

SSI_DEF

(

SystemTimeAdjustmentInformation

)

Definition at line 1710 of file sysinfo.c.

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

SSI_DEF() [13/16]

SSI_DEF

(

SystemTimeSlipNotification

)

Definition at line 2250 of file sysinfo.c.

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

SSI_DEF() [14/16]

SSI_DEF

(

SystemUnloadGdiDriverInformation

)

Definition at line 1670 of file sysinfo.c.

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

SSI_DEF() [15/16]

SSI_DEF

(

SystemVerifierInformation

)

Definition at line 2340 of file sysinfo.c.

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

SSI_DEF() [16/16]

SSI_DEF

(

SystemVerifierThunkExtend

)

Definition at line 2348 of file sysinfo.c.

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

Variable Documentation

CallQS

QSSI_CALLS CallQS[]

static

Definition at line 2846 of file sysinfo.c.

Referenced by NtQuerySystemInformation(), and NtSetSystemInformation().

ExpEnvironmentLock

FAST_MUTEX ExpEnvironmentLock

Definition at line 29 of file sysinfo.c.

Referenced by ExpInitSystemPhase0().

ExpFirmwareTableProviderListHead

LIST_ENTRY ExpFirmwareTableProviderListHead

Definition at line 31 of file sysinfo.c.

Referenced by ExpInitSystemPhase0().

ExpFirmwareTableResource

ERESOURCE ExpFirmwareTableResource

Definition at line 30 of file sysinfo.c.

Referenced by ExpInitSystemPhase0().

HandleTableListHead

LIST_ENTRY HandleTableListHead

extern

Definition at line 18 of file handle.c.

Referenced by ExCreateHandleTable(), ExDupHandleTable(), ExpInitializeHandleTables(), and QSI_DEF().

HandleTableListLock

EX_PUSH_LOCK HandleTableListLock

extern

Definition at line 19 of file handle.c.

Referenced by ExCreateHandleTable(), ExDupHandleTable(), ExpInitializeHandleTables(), ExRemoveHandleTable(), and QSI_DEF().