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

Include dependency graph for profobj.c:

Macros
#define	NDEBUG

Functions
VOID NTAPI	KeInitializeProfile (PKPROFILE Profile, PKPROCESS Process, PVOID ImageBase, SIZE_T ImageSize, ULONG BucketSize, KPROFILE_SOURCE ProfileSource, KAFFINITY Affinity)

BOOLEAN NTAPI	KeStartProfile (IN PKPROFILE Profile, IN PVOID Buffer)

BOOLEAN NTAPI	KeStopProfile (IN PKPROFILE Profile)

ULONG NTAPI	KeQueryIntervalProfile (IN KPROFILE_SOURCE ProfileSource)

VOID NTAPI	KeSetIntervalProfile (IN ULONG Interval, IN KPROFILE_SOURCE ProfileSource)

VOID NTAPI	KeProfileInterrupt (IN PKTRAP_FRAME TrapFrame)

VOID NTAPI	KiParseProfileList (IN PKTRAP_FRAME TrapFrame, IN KPROFILE_SOURCE Source, IN PLIST_ENTRY ListHead)

VOID NTAPI	KeProfileInterruptWithSource (IN PKTRAP_FRAME TrapFrame, IN KPROFILE_SOURCE Source)

VOID NTAPI	KeSetProfileIrql (IN KIRQL ProfileIrql)

Variables
KIRQL	KiProfileIrql = PROFILE_LEVEL

LIST_ENTRY	KiProfileListHead

LIST_ENTRY	KiProfileSourceListHead

KSPIN_LOCK	KiProfileLock

ULONG	KiProfileTimeInterval = 78125

ULONG	KiProfileAlignmentFixupInterval

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file profobj.c.

Function Documentation

◆ KeInitializeProfile()

VOID NTAPI KeInitializeProfile	(	PKPROFILE	Profile,
		PKPROCESS	Process,
		PVOID	ImageBase,
		SIZE_T	ImageSize,
		ULONG	BucketSize,
		KPROFILE_SOURCE	ProfileSource,
		KAFFINITY	Affinity
	)

Definition at line 28 of file profobj.c.

{
    /* Initialize the Header */
    Profile->Type = ProfileObject;
    Profile->Size = sizeof(KPROFILE);
 
    /* Copy all the settings we were given */
    Profile->Process = Process;
    Profile->RangeBase = ImageBase;
    Profile->BucketShift = BucketSize - 2; /* See ntinternals.net -- Alex */
    Profile->RangeLimit = (PVOID)((ULONG_PTR)ImageBase + ImageSize);
    Profile->Started = FALSE;
    Profile->Source = ProfileSource;
    Profile->Affinity = Affinity;
}

◆ KeProfileInterrupt()

VOID NTAPI KeProfileInterrupt ( IN PKTRAP_FRAME TrapFrame )

Definition at line 296 of file profobj.c.

{
    /* Called from HAL for Timer Profiling */
    KeProfileInterruptWithSource(TrapFrame, ProfileTime);
}

◆ KeProfileInterruptWithSource()

VOID NTAPI KeProfileInterruptWithSource	(	IN PKTRAP_FRAME	TrapFrame,
		IN KPROFILE_SOURCE	Source
	)

Definition at line 354 of file profobj.c.

{
    PKPROCESS Process = KeGetCurrentThread()->ApcState.Process;
 
    /* We have to parse 2 lists. Per-Process and System-Wide */
    KiParseProfileList(TrapFrame, Source, &Process->ProfileListHead);
    KiParseProfileList(TrapFrame, Source, &KiProfileListHead);
}

Referenced by HalpProfileInterruptHandler(), and KeProfileInterrupt().

◆ KeQueryIntervalProfile()

ULONG NTAPI KeQueryIntervalProfile ( IN KPROFILE_SOURCE ProfileSource )

Definition at line 219 of file profobj.c.

{
    HAL_PROFILE_SOURCE_INFORMATION ProfileSourceInformation;
    ULONG ReturnLength, Interval;
    NTSTATUS Status;
 
    /* Check what profile this is */
    if (ProfileSource == ProfileTime)
    {
        /* Return the time interval */
        Interval = KiProfileTimeInterval;
    }
    else if (ProfileSource == ProfileAlignmentFixup)
    {
        /* Return the alignment interval */
        Interval = KiProfileAlignmentFixupInterval;
    }
    else
    {
        /* Request it from HAL */
        ProfileSourceInformation.Source = ProfileSource;
        Status = HalQuerySystemInformation(HalProfileSourceInformation,
                                           sizeof(HAL_PROFILE_SOURCE_INFORMATION),
                                           &ProfileSourceInformation,
                                           &ReturnLength);
 
        /* Check if HAL handled it and supports this profile */
        if (NT_SUCCESS(Status) && (ProfileSourceInformation.Supported))
        {
            /* Get the interval */
            Interval = ProfileSourceInformation.Interval;
        }
        else
        {
            /* Unsupported or invalid source, fail */
            Interval = 0;
        }
    }
 
    /* Return the interval we got */
    return Interval;
}

◆ KeSetIntervalProfile()

VOID NTAPI KeSetIntervalProfile	(	IN ULONG	Interval,
		IN KPROFILE_SOURCE	ProfileSource
	)

Definition at line 264 of file profobj.c.

{
    HAL_PROFILE_SOURCE_INTERVAL ProfileSourceInterval;
 
    /* Check what profile this is */
    if (ProfileSource == ProfileTime)
    {
        /* Set the interval through HAL */
        KiProfileTimeInterval = (ULONG)HalSetProfileInterval(Interval);
    }
    else if (ProfileSource == ProfileAlignmentFixup)
    {
        /* Set the alignment interval */
        KiProfileAlignmentFixupInterval = Interval;
    }
    else
    {
        /* HAL handles any other interval */
        ProfileSourceInterval.Source = ProfileSource;
        ProfileSourceInterval.Interval = Interval;
        HalSetSystemInformation(HalProfileSourceInterval,
                                sizeof(HAL_PROFILE_SOURCE_INTERVAL),
                                &ProfileSourceInterval);
    }
}

◆ KeSetProfileIrql()

VOID NTAPI KeSetProfileIrql ( IN KIRQL ProfileIrql )

Definition at line 369 of file profobj.c.

{
    /* Set the IRQL at which Profiling will run */
    KiProfileIrql = ProfileIrql;
}

◆ KeStartProfile()

BOOLEAN NTAPI KeStartProfile	(	IN PKPROFILE	Profile,
		IN PVOID	Buffer
	)

Definition at line 52 of file profobj.c.

{
    KIRQL OldIrql;
    PKPROFILE_SOURCE_OBJECT SourceBuffer;
    PKPROFILE_SOURCE_OBJECT CurrentSource;
    BOOLEAN FreeBuffer = TRUE, SourceFound = FALSE, StartedProfile;
    PKPROCESS ProfileProcess;
    PLIST_ENTRY NextEntry;
 
    /* Allocate a buffer first, before we raise IRQL */
    SourceBuffer = ExAllocatePoolWithTag(NonPagedPool,
                                         sizeof(KPROFILE_SOURCE_OBJECT),
                                         'forP');
    if (!SourceBuffer) return FALSE;
    RtlZeroMemory(SourceBuffer, sizeof(KPROFILE_SOURCE_OBJECT));
 
    /* Raise to profile IRQL and acquire the profile lock */
    KeRaiseIrql(KiProfileIrql, &OldIrql);
    KeAcquireSpinLockAtDpcLevel(&KiProfileLock);
 
    /* Make sure it's not running */
    if (!Profile->Started)
    {
        /* Set it as Started */
        Profile->Buffer = Buffer;
        Profile->Started = TRUE;
        StartedProfile = TRUE;
 
        /* Get the process, if any */
        ProfileProcess = Profile->Process;
 
        /* Check where we should insert it */
        if (ProfileProcess)
        {
            /* Insert it into the Process List */
            InsertTailList(&ProfileProcess->ProfileListHead, &Profile->ProfileListEntry);
        }
        else
        {
            /* Insert it into the Global List */
            InsertTailList(&KiProfileListHead, &Profile->ProfileListEntry);
        }
 
        /* Start looping */
        for (NextEntry = KiProfileSourceListHead.Flink;
             NextEntry != &KiProfileSourceListHead;
             NextEntry = NextEntry->Flink)
        {
            /* Get the entry */
            CurrentSource = CONTAINING_RECORD(NextEntry,
                                              KPROFILE_SOURCE_OBJECT,
                                              ListEntry);
 
            /* Check if it's the same as the one being requested now */
            if (CurrentSource->Source == Profile->Source)
            {
                /* It is, break out */
                SourceFound = TRUE;
                break;
            }
        }
 
        /* See if the loop found something */
        if (!SourceFound)
        {
            /* Nothing found, use our allocated buffer */
            CurrentSource = SourceBuffer;
 
            /* Set up the Source Object */
            CurrentSource->Source = Profile->Source;
            InsertHeadList(&KiProfileSourceListHead, &CurrentSource->ListEntry);
 
            /* Don't free the pool later on */
            FreeBuffer = FALSE;
        }
    }
    else
    {
        /* Already running so nothing to start */
        StartedProfile = FALSE;
    }
 
    /* Release the profile lock */
    KeReleaseSpinLockFromDpcLevel(&KiProfileLock);
 
    /* Tell HAL to start the profile interrupt */
    HalStartProfileInterrupt(Profile->Source);
 
    /* Lower back to original IRQL */
    KeLowerIrql(OldIrql);
 
    /* Free the pool */
    if (FreeBuffer) ExFreePoolWithTag(SourceBuffer, 'forP');
 
    /* Return whether we could start the profile */
    return StartedProfile;
}

◆ KeStopProfile()

BOOLEAN NTAPI KeStopProfile ( IN PKPROFILE Profile )

Definition at line 153 of file profobj.c.

{
    KIRQL OldIrql;
    PKPROFILE_SOURCE_OBJECT CurrentSource = NULL;
    PLIST_ENTRY NextEntry;
    BOOLEAN SourceFound = FALSE, StoppedProfile;
 
    /* Raise to profile IRQL and acquire the profile lock */
    KeRaiseIrql(KiProfileIrql, &OldIrql);
    KeAcquireSpinLockAtDpcLevel(&KiProfileLock);
 
    /* Make sure it's running */
    if (Profile->Started)
    {
        /* Remove it from the list and disable */
        RemoveEntryList(&Profile->ProfileListEntry);
        Profile->Started = FALSE;
        StoppedProfile = TRUE;
 
        /* Start looping */
        for (NextEntry = KiProfileSourceListHead.Flink;
             NextEntry != &KiProfileSourceListHead;
             NextEntry = NextEntry->Flink)
        {
            /* Get the entry */
            CurrentSource = CONTAINING_RECORD(NextEntry,
                                              KPROFILE_SOURCE_OBJECT,
                                              ListEntry);
 
            /* Check if this is the Source Object */
            if (CurrentSource->Source == Profile->Source)
            {
                /* Remember we found one */
                SourceFound = TRUE;
 
                /* Remove it and break out */
                RemoveEntryList(&CurrentSource->ListEntry);
                break;
            }
        }
 
    }
    else
    {
        /* It wasn't! */
        StoppedProfile = FALSE;
    }
 
    /* Release the profile lock */
    KeReleaseSpinLockFromDpcLevel(&KiProfileLock);
 
    /* Stop the profile interrupt */
    HalStopProfileInterrupt(Profile->Source);
 
    /* Lower back to original IRQL */
    KeLowerIrql(OldIrql);
 
    /* Free the Source Object */
    if (SourceFound) ExFreePool(CurrentSource);
 
    /* Return whether we could stop the profile */
    return StoppedProfile;
}

◆ KiParseProfileList()

VOID NTAPI KiParseProfileList	(	IN PKTRAP_FRAME	TrapFrame,
		IN KPROFILE_SOURCE	Source,
		IN PLIST_ENTRY	ListHead
	)

Definition at line 304 of file profobj.c.

{
    PULONG BucketValue;
    PKPROFILE Profile;
    PLIST_ENTRY NextEntry;
    ULONG_PTR ProgramCounter;
 
    /* Get the Program Counter */
    ProgramCounter = KeGetTrapFramePc(TrapFrame);
 
    /* Loop the List */
    for (NextEntry = ListHead->Flink;
         NextEntry != ListHead;
         NextEntry = NextEntry->Flink)
    {
        /* Get the entry */
        Profile = CONTAINING_RECORD(NextEntry, KPROFILE, ProfileListEntry);
 
        /* Check if the source is good, and if it's within the range */
        if ((Profile->Source != Source) ||
            (ProgramCounter < (ULONG_PTR)Profile->RangeBase) ||
            (ProgramCounter > (ULONG_PTR)Profile->RangeLimit))
        {
            continue;
        }
 
        /* Get the Pointer to the Bucket Value representing this Program Counter */
        BucketValue = (PULONG)((ULONG_PTR)Profile->Buffer +
                               (((ProgramCounter - (ULONG_PTR)Profile->RangeBase)
                                >> Profile->BucketShift) &~ 0x3));
 
        /* Increment the value */
        (*BucketValue)++;
    }
}