Windows2000/private/ntos/dll/ntnap.c

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    ntnap.c

Abstract:

    This module contains the routines for initializing and performing
    profiling of NT API's.

Author:

    Russ Blake (russbl) 22-Apr-1991

Revision History:

--*/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <string.h>

#include "ntnapdef.h"
#include "ntnap.h"


// Initialization control: only want to initialize once; this
// prevents multiple initializations before data segment and
// global control are initialized.


BOOLEAN NapInitialized = FALSE;


// Counter frequency constant


LARGE_INTEGER NapFrequency;


// Profiling data structures


PNAPCONTROL NapControl = NULL;


// The following array is indexed by Service Number + 1.  Service
// Number -1 (element 0 of the following array) is reserved for
// calibration.  Initialization of this to NULL kicks off the
// NapDllInit sequence to create or open the data section.


PNAPDATA NapProfilingData = NULL;


VOID
NapDllInit (
    VOID
    )

/*++

Routine Description:

    NapDllInit() is called before calling any profiling api.  It
    initializes profiling for the NT native API's.

    NOTE:  Initialization occurs only once and is controlled by
       the NapInitDone global flag.

Arguments:

    None

Return Value:

    None

--*/

{
    ULONG i;
    LARGE_INTEGER CurrentCounter;

    if (!NapInitialized) {


    // Instance data for this process's ntdll.dll not yet initialized.


    NapInitialized = TRUE;


    // Get Counter frequency (current counter value is thrown away)
    // This call is not profiled because NapControl == NULL here.


    NtQueryPerformanceCounter(&CurrentCounter,
                  &NapFrequency);


    // Allocate or open data section for api profiling data.


    if (NT_SUCCESS(NapCreateDataSection(&NapControl))) {

        NapProfilingData = (PNAPDATA)(NapControl + 1);

        if (!NapControl->Initialized) {


        // We are the first process to get here: we jsut
        // allocated the section, so must initialize it.


        NapControl->Initialized = TRUE;

        NapControl->Paused = 0;


        // Clear the data area used for calibration data.


        NapProfilingData[0].NapLock = 0L;
        NapProfilingData[0].Calls = 0L;
        NapProfilingData[0].TimingErrors = 0L;
        NapProfilingData[0].TotalTime.HighPart = 0L;
        NapProfilingData[0].TotalTime.LowPart = 0L;
        NapProfilingData[0].FirstTime.HighPart = 0L;
        NapProfilingData[0].FirstTime.LowPart = 0L;
        NapProfilingData[0].MaxTime.HighPart = 0L;
        NapProfilingData[0].MaxTime.LowPart = 0L;
        NapProfilingData[0].MinTime.HighPart = MAX_LONG;
        NapProfilingData[0].MinTime.LowPart = MAX_ULONG;


        // Clear the rest of the data collection area


        NapClearData();


        //   Calibrate time overhead from profiling.  We care mostly
        //   about the minimum time here, to avoid extra time from
        //   interrupts etc.


        for (i=0; i<NUM_ITERATIONS; i++) {
            NapCalibrate();
        }
        }
    }
    }
}


NTSTATUS NapCreateDataSection(PNAPCONTROL *NapSectionPointer)
/*++
Routine Description:
    NapCreateData() is called to create the profiling data section.
    One section, named "\NapDataSection", is used for the whole system.
    It is accessible by anyone, so don't mess it up.
Arguments:
    NapSectionPointer - a pointer to a pointer which will be set to to point to the beginning of the section.
Return Value:
    Status
--*/
{
    NTSTATUS Status;
    HANDLE NapSectionHandle;
    HANDLE MyProcess;
    STRING NapSectionName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    LARGE_INTEGER AllocationSize;
    ULONG ViewSize;
    PNAPCONTROL SectionPointer;

    // Initialize object attributes for the dump file
    NapSectionName.Length = 15;
    NapSectionName.MaximumLength = 15;
    NapSectionName.Buffer = "\\NapDataSection";

    ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
    ObjectAttributes.ObjectName = &NapSectionName;
    ObjectAttributes.RootDirectory = NULL;
    ObjectAttributes.SecurityDescriptor = NULL;
    ObjectAttributes.SecurityQualityOfService = NULL;
    ObjectAttributes.Attributes = OBJ_OPENIF | OBJ_CASE_INSENSITIVE;

    AllocationSize.HighPart = 0;
    AllocationSize.LowPart = (NAP_API_COUNT + 1) * sizeof(NAPDATA);

    Status = NtCreateSection(&NapSectionHandle, SECTION_MAP_READ | SECTION_MAP_WRITE, &ObjectAttributes, &AllocationSize, PAGE_READWRITE, SEC_COMMIT, NULL);
    if (NT_SUCCESS(Status))
    {
        MyProcess = NtCurrentProcess();
        ViewSize = AllocationSize.LowPart;
        SectionPointer = NULL;
        Status = NtMapViewOfSection(NapSectionHandle, MyProcess, (PVOID *) &SectionPointer, 0, AllocationSize.LowPart, NULL, &ViewSize, ViewUnmap, MEM_TOP_DOWN, PAGE_READWRITE);
        *NapSectionPointer = SectionPointer;
    }

    return(Status);
}


VOID NapRecordInfo (IN ULONG ServiceNumber, IN LARGE_INTEGER Counters[])
/*++
Routine Description:
    NapRecordInfo() is called after the API being measured has
    returned, and the value of the performance counter has been
    obtained.

    NOTE:  Initialization occurs only once and is controlled by
       the NapInitDone global flag.

Arguments:

    ServiceNumber - the number of the service being measured.
            -1 is reserved for calibration.

    Counters      - a pointer to the value of the counter after the call
            to the measured routine.  Followed immediately
            in memory by the value of the counter before the
            call to the measured routine.

Return Value:

    None

--*/


{
    LARGE_INTEGER ElapsedTime;
    LARGE_INTEGER Difference;



    // First make sure we have been initialized


    if (NapControl != NULL) {


    // Check to be sure profiling is not paused

    if (NapControl->Paused == 0) {


        // Since ServiceNumber -1 is used for calibration, bump same
        // so indexes start at 0.


        ServiceNumber++;


        // Prevent others from changing data at the same time
        // we are.


        NapAcquireSpinLock(&(NapProfilingData[ServiceNumber].NapLock));


        // Record API info


        NapProfilingData[ServiceNumber].Calls++;


        // Elapsed time is end time minus start time


        ElapsedTime =
        RtlLargeIntegerSubtract(Counters[0],Counters[1]);


        // Now add elapsed time to total time


        NapProfilingData[ServiceNumber].TotalTime =
        RtlLargeIntegerAdd(NapProfilingData[ServiceNumber].TotalTime,
                   ElapsedTime);

        if (NapProfilingData[ServiceNumber].Calls == 1) {
        NapProfilingData[ServiceNumber].FirstTime = ElapsedTime;
        }
        else {
        Difference =
            RtlLargeIntegerSubtract(
            NapProfilingData[ServiceNumber].MaxTime,
            ElapsedTime);
        if (Difference.HighPart < 0) {


            // A new maximum was attained


            NapProfilingData[ServiceNumber].MaxTime = ElapsedTime;

        }
        Difference =
            RtlLargeIntegerSubtract(
            ElapsedTime,
            NapProfilingData[ServiceNumber].MinTime);
        if (Difference.HighPart < 0) {


            // A new minimum was attained


            NapProfilingData[ServiceNumber].MinTime = ElapsedTime;
        }
        }

        NapReleaseSpinLock(&(NapProfilingData[ServiceNumber].NapLock));
    }
    }
}



NTSTATUS
NapClearData (
    VOID
    )

/*++

Routine Description:

    NapClearData() is called to clear all the counters and timers.
    The calibration counters are not cleared.  For the rest,
    if not previously collected, the data will be lost.

Arguments:

    None

Return Value:

    Status

--*/

{
    ULONG ServiceNumber;


    // Initialize the first one after the calibration data


    NapAcquireSpinLock(&(NapProfilingData[1].NapLock));

    NapProfilingData[1].Calls = 0L;
    NapProfilingData[1].TimingErrors = 0L;
    NapProfilingData[1].TotalTime.HighPart = 0L;
    NapProfilingData[1].TotalTime.LowPart = 0L;
    NapProfilingData[1].FirstTime.HighPart = 0L;
    NapProfilingData[1].FirstTime.LowPart = 0L;
    NapProfilingData[1].MaxTime.HighPart = 0L;
    NapProfilingData[1].MaxTime.LowPart = 0L;
    NapProfilingData[1].MinTime.HighPart = MAX_LONG;
    NapProfilingData[1].MinTime.LowPart = MAX_ULONG;


    // Now use the initialized first one to initialize the rest



    for (ServiceNumber = 2; ServiceNumber <= NAP_API_COUNT; ServiceNumber++) {

    NapAcquireSpinLock(&(NapProfilingData[ServiceNumber].NapLock));

    NapProfilingData[ServiceNumber] = NapProfilingData[1];

    NapReleaseSpinLock(&(NapProfilingData[ServiceNumber].NapLock));
    }

    NapReleaseSpinLock(&(NapProfilingData[1].NapLock));

    return(STATUS_SUCCESS);
}



NTSTATUS
NapRetrieveData (
    OUT NAPDATA *NapApiData,
    OUT PCHAR **NapApiNames,
    OUT PLARGE_INTEGER *NapCounterFrequency
    )

/*++

Routine Description:

    NapRetrieveData() is called to get all the relevant data
    about API's that have been profiled.  It is wise to call
    NapPause() before calling this, and NapResume() afterwards.
    Can't just do these in here, 'cause you may be doing stuff outside
    of this call you don't want profiled.

Arguments:

    NapApiData - a pointer to a buffer to which is copied
         the array of counters; must be large enough for
         NAP_API_COUNT+1; call NapGetApiCount to obtain needed
         size.

    NapApiNames - a pointer to which is copied a pointer to
          an array of pointers to API names

    NapCounterFrequency - a buffer to which is copied the frequency
              of the performance counter

Return Value:

    Status

--*/

{
    ULONG ServiceNumber;

    *NapApiNames = NapNames;

    *NapCounterFrequency = &NapFrequency;

    for (ServiceNumber = 0; ServiceNumber <= NAP_API_COUNT; ServiceNumber++) {

    NapAcquireSpinLock(&(NapProfilingData[ServiceNumber].NapLock));

    NapApiData[ServiceNumber] = NapProfilingData[ServiceNumber];

    NapReleaseSpinLock(&(NapProfilingData[ServiceNumber].NapLock));
    NapReleaseSpinLock(&(NapApiData[ServiceNumber].NapLock));
    }

    return(STATUS_SUCCESS);
}



NTSTATUS
NapGetApiCount (
    OUT PULONG NapApiCount
    )

/*++

Routine Description:

    NapGetApiCount() is called to get the number of API's which are
    being profiled.  This can then be used to allocate an array for
    receiving the data from NapReturnData.

Arguments:

    NapApiCount - A pointer throug which the count is returned.

Return Value:

    Status

--*/


{

    *NapApiCount = NAP_API_COUNT;

    return(STATUS_SUCCESS);

}




NTSTATUS
NapPause (
    VOID
    )

/*++

Routine Description:

    NapPause() is called to temporarily cease data collection.
    Data collection is resumed by a companion call to NapResume.

Arguments:

    None

Return Value:

    Status

--*/


{
    NapControl->Paused++;

    return(STATUS_SUCCESS);
}


NTSTATUS
NapResume (
    VOID
    )

/*++

Routine Description:

    NapResume() is called to resume data collection after a companion
    call to NapPause.

Arguments:

    None

Return Value:

    Status

--*/


{
    NapControl->Paused--;

    return(STATUS_SUCCESS);
}