You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
378 lines
8.9 KiB
378 lines
8.9 KiB
|
|
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ioPerf.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the routines to collect performance info for driver calls...
|
|
|
|
Author:
|
|
|
|
Mike Fortin (mrfortin) May 8, 2000
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "iomgr.h"
|
|
|
|
#if (( defined(_X86_) ) && ( FPO ))
|
|
#pragma optimize( "y", off ) // disable FPO for consistent stack traces
|
|
#endif
|
|
|
|
NTSTATUS
|
|
IoPerfInit(
|
|
);
|
|
|
|
NTSTATUS
|
|
IoPerfReset(
|
|
);
|
|
|
|
NTSTATUS
|
|
FASTCALL
|
|
IoPerfCallDriver(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp,
|
|
IN PVOID ReturnAddress
|
|
);
|
|
|
|
VOID
|
|
FASTCALL
|
|
IoPerfCompleteRequest (
|
|
IN PIRP Irp,
|
|
IN CCHAR PriorityBoost
|
|
);
|
|
|
|
#ifndef NTPERF
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGEWMI, IoPerfCallDriver)
|
|
#pragma alloc_text(PAGEWMI, IoPerfInit)
|
|
#pragma alloc_text(PAGEWMI, IoPerfReset)
|
|
#pragma alloc_text(PAGEWMI, IopPerfLogFileCreate)
|
|
#endif
|
|
#endif // NTPERF
|
|
|
|
|
|
NTSTATUS
|
|
IoPerfInit(
|
|
)
|
|
{
|
|
if ( IopVerifierOn ){
|
|
// We will not log driver hooks if the verifier has
|
|
// also been turned on
|
|
// Probably want to log some event or make a testenv note about
|
|
// the perf implications of having the verifier turned on
|
|
//
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// Enable and hook in the Perf Routines
|
|
//
|
|
InterlockedExchangePointer((PVOID *)&pIofCallDriver, (PVOID) IoPerfCallDriver);
|
|
InterlockedExchangePointer((PVOID *)&pIofCompleteRequest, (PVOID) IoPerfCompleteRequest);
|
|
|
|
ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
IoPerfReset(
|
|
)
|
|
{
|
|
if ( IopVerifierOn ){
|
|
// We did not replace the function ptrs if the verifier
|
|
// also was turned on, so just return
|
|
//
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// Reset to init values, see IopSetIoRoutines
|
|
//
|
|
InterlockedExchangePointer((PVOID *)&pIofCallDriver, NULL);
|
|
InterlockedExchangePointer((PVOID *)&pIofCompleteRequest, (PVOID) IopfCompleteRequest);
|
|
|
|
ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
LONG IopPerfDriverUniqueMatchId;
|
|
|
|
NTSTATUS
|
|
FASTCALL
|
|
IoPerfCallDriver(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp,
|
|
IN PVOID ReturnAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is invoked to pass an I/O Request Packet (IRP) to another
|
|
driver at its dispatch routine, logging perf data along the way.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to device object to which the IRP should be passed.
|
|
|
|
Irp - Pointer to IRP for request.
|
|
|
|
Return Value:
|
|
|
|
Return status from driver's dispatch routine.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_STACK_LOCATION irpSp;
|
|
PDRIVER_OBJECT driverObject;
|
|
NTSTATUS status;
|
|
PVOID PerfInfoRoutineAddr;
|
|
ULONG MatchId;
|
|
#ifdef NTPERF
|
|
ULONGLONG PerfInfoTimeOfCall = PerfGetCycleCount();
|
|
#endif // NTPERF
|
|
|
|
//
|
|
// Ensure that this is really an I/O Request Packet.
|
|
//
|
|
UNREFERENCED_PARAMETER(ReturnAddress);
|
|
|
|
ASSERT( Irp->Type == IO_TYPE_IRP );
|
|
|
|
irpSp = IoGetNextIrpStackLocation( Irp );
|
|
|
|
//
|
|
// Invoke the driver at its dispatch routine entry point.
|
|
//
|
|
|
|
driverObject = DeviceObject->DriverObject;
|
|
|
|
//
|
|
// Prevent the driver from unloading.
|
|
//
|
|
|
|
ObReferenceObject(DeviceObject);
|
|
|
|
MatchId = InterlockedIncrement( &IopPerfDriverUniqueMatchId );
|
|
|
|
PerfInfoRoutineAddr = (PVOID) (ULONG_PTR) driverObject->MajorFunction[irpSp->MajorFunction];
|
|
|
|
//
|
|
// Log the Call Event
|
|
//
|
|
if (PERFINFO_IS_GROUP_ON(PERF_DRIVERS)) {
|
|
PERFINFO_DRIVER_MAJORFUNCTION MFInfo;
|
|
MFInfo.MajorFunction = irpSp->MajorFunction;
|
|
MFInfo.MinorFunction = irpSp->MinorFunction;
|
|
MFInfo.RoutineAddr = (PVOID) (ULONG_PTR) driverObject->MajorFunction[irpSp->MajorFunction];
|
|
MFInfo.Irp = Irp;
|
|
MFInfo.UniqMatchId = MatchId;
|
|
if (Irp->Flags & IRP_ASSOCIATED_IRP) {
|
|
ASSERT (Irp->AssociatedIrp.MasterIrp != NULL);
|
|
if (Irp->AssociatedIrp.MasterIrp != NULL) {
|
|
//
|
|
// The check for MasterIrp is defensive code.
|
|
// We have hit a bugcechk when a filter driver set the
|
|
// IRP_ASSOCIATED_IRP bit while MasterIrp pointing to NULL.
|
|
//
|
|
// The ASSERT above was to catch similar problems before we release.
|
|
//
|
|
MFInfo.FileNamePointer = Irp->AssociatedIrp.MasterIrp->Tail.Overlay.OriginalFileObject;
|
|
} else {
|
|
MFInfo.FileNamePointer = NULL;
|
|
}
|
|
} else {
|
|
MFInfo.FileNamePointer = Irp->Tail.Overlay.OriginalFileObject;
|
|
}
|
|
PerfInfoLogBytes(
|
|
PERFINFO_LOG_TYPE_DRIVER_MAJORFUNCTION_CALL,
|
|
&MFInfo,
|
|
sizeof(MFInfo)
|
|
);
|
|
}
|
|
|
|
//
|
|
// Do the normal IopfCallDriver work
|
|
//
|
|
status = IopfCallDriver(DeviceObject, Irp );
|
|
|
|
//
|
|
// Log the Return
|
|
//
|
|
if (PERFINFO_IS_GROUP_ON(PERF_DRIVERS)) {
|
|
PERFINFO_DRIVER_MAJORFUNCTION_RET MFInfo;
|
|
MFInfo.Irp = Irp;
|
|
MFInfo.UniqMatchId = MatchId;
|
|
|
|
PERFINFO_DRIVER_INTENTIONAL_DELAY();
|
|
|
|
PerfInfoLogBytes(
|
|
PERFINFO_LOG_TYPE_DRIVER_MAJORFUNCTION_RETURN,
|
|
&MFInfo,
|
|
sizeof(MFInfo)
|
|
);
|
|
|
|
PERFINFO_DRIVER_STACKTRACE();
|
|
}
|
|
|
|
ObDereferenceObject(DeviceObject);
|
|
|
|
return status;
|
|
}
|
|
|
|
VOID
|
|
FASTCALL
|
|
IoPerfCompleteRequest (
|
|
IN PIRP Irp,
|
|
IN CCHAR PriorityBoost
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is invoked when a driver completes an IRP, logging perf data
|
|
along the way.
|
|
|
|
Arguments:
|
|
|
|
Irp - Pointer to IRP for completed request.
|
|
|
|
PriorityBoost - Priority boost specified by the driver completing the IRP.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PERFINFO_DRIVER_COMPLETE_REQUEST CompleteRequest;
|
|
PERFINFO_DRIVER_COMPLETE_REQUEST_RET CompleteRequestRet;
|
|
PIO_STACK_LOCATION irpSp;
|
|
PVOID DriverRoutineAddr;
|
|
ULONG MatchId;
|
|
|
|
//
|
|
// Initialize locals.
|
|
//
|
|
|
|
DriverRoutineAddr = NULL;
|
|
|
|
//
|
|
// If the packet looks weird/improper pass it on to the real IO completion routine
|
|
// directly.
|
|
//
|
|
|
|
if (Irp->Type != IO_TYPE_IRP || Irp->CurrentLocation > (CCHAR) (Irp->StackCount + 1)) {
|
|
IopfCompleteRequest(Irp, PriorityBoost);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get current stack location and save the driver routine address to
|
|
// identify the driver that was processing the IRP when it got completed. If
|
|
// device object is NULL, try to get the completion routine addr.
|
|
//
|
|
|
|
irpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
if (irpSp->DeviceObject) {
|
|
|
|
//
|
|
// We don't want to cause a bugcheck in this code even when something else is
|
|
// corrupt.
|
|
//
|
|
|
|
ASSERT(irpSp->DeviceObject->DriverObject);
|
|
|
|
if (irpSp->DeviceObject->DriverObject) {
|
|
|
|
ASSERT(irpSp->MajorFunction <= IRP_MJ_MAXIMUM_FUNCTION);
|
|
|
|
if (irpSp->MajorFunction <= IRP_MJ_MAXIMUM_FUNCTION) {
|
|
|
|
DriverRoutineAddr = (PVOID) (ULONG_PTR) irpSp->DeviceObject->DriverObject->MajorFunction[irpSp->MajorFunction];
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
DriverRoutineAddr = (PVOID) (ULONG_PTR) irpSp->CompletionRoutine;
|
|
}
|
|
|
|
//
|
|
// Bump the ID that gets used to match COMPLETE_REQUEST and COMPLETE_REQUEST_RET
|
|
// entries logged for an IRP completion.
|
|
//
|
|
|
|
MatchId = InterlockedIncrement( &IopPerfDriverUniqueMatchId );
|
|
|
|
//
|
|
// Log the start of the completion.
|
|
//
|
|
|
|
if (PERFINFO_IS_GROUP_ON(PERF_DRIVERS)) {
|
|
|
|
CompleteRequest.Irp = Irp;
|
|
CompleteRequest.UniqMatchId = MatchId;
|
|
CompleteRequest.RoutineAddr = DriverRoutineAddr;
|
|
|
|
PerfInfoLogBytes(
|
|
PERFINFO_LOG_TYPE_DRIVER_COMPLETE_REQUEST,
|
|
&CompleteRequest,
|
|
sizeof(CompleteRequest)
|
|
);
|
|
}
|
|
|
|
//
|
|
// Do the normal IopfCompleteIrp work.
|
|
//
|
|
|
|
IopfCompleteRequest(Irp, PriorityBoost);
|
|
|
|
//
|
|
// After this point no fields of Irp should be accessed. E.g. the Irp may
|
|
// have been freed / reallocated etc. by a completion routine.
|
|
//
|
|
|
|
//
|
|
// Log the return.
|
|
//
|
|
|
|
if (PERFINFO_IS_GROUP_ON(PERF_DRIVERS)) {
|
|
|
|
CompleteRequestRet.Irp = Irp;
|
|
CompleteRequestRet.UniqMatchId = MatchId;
|
|
|
|
PerfInfoLogBytes(
|
|
PERFINFO_LOG_TYPE_DRIVER_COMPLETE_REQUEST_RETURN,
|
|
&CompleteRequestRet,
|
|
sizeof(CompleteRequestRet)
|
|
);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
IopPerfLogFileCreate(
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PUNICODE_STRING CompleteName
|
|
)
|
|
{
|
|
PERFINFO_LOG_FILE_CREATE(FileObject, CompleteName);
|
|
}
|