2366 lines
63 KiB
C
2366 lines
63 KiB
C
/*++
|
||
Copyright (C) Microsoft Corporation, 1991 - 1999
|
||
|
||
Module Name:
|
||
|
||
diskperf.c
|
||
|
||
Abstract:
|
||
|
||
This driver monitors disk accesses capturing performance data.
|
||
|
||
Environment:
|
||
|
||
kernel mode only
|
||
|
||
Notes:
|
||
|
||
--*/
|
||
|
||
|
||
#define INITGUID
|
||
|
||
#include "ntddk.h"
|
||
#include "ntdddisk.h"
|
||
#include "stdarg.h"
|
||
#include "stdio.h"
|
||
#include <ntddvol.h>
|
||
|
||
#include <mountdev.h>
|
||
#include "wmistr.h"
|
||
#include "wmidata.h"
|
||
#include "wmiguid.h"
|
||
#include "wmilib.h"
|
||
|
||
#ifdef POOL_TAGGING
|
||
#ifdef ExAllocatePool
|
||
#undef ExAllocatePool
|
||
#endif
|
||
#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'frPD')
|
||
#endif
|
||
|
||
#define DISKPERF_MAXSTR 64
|
||
|
||
//
|
||
// Device Extension
|
||
//
|
||
|
||
typedef struct _DEVICE_EXTENSION {
|
||
|
||
//
|
||
// Back pointer to device object
|
||
//
|
||
|
||
PDEVICE_OBJECT DeviceObject;
|
||
|
||
//
|
||
// Target Device Object
|
||
//
|
||
|
||
PDEVICE_OBJECT TargetDeviceObject;
|
||
|
||
//
|
||
// Physical device object
|
||
//
|
||
PDEVICE_OBJECT PhysicalDeviceObject;
|
||
|
||
//
|
||
// Disk number for reference in WMI
|
||
//
|
||
|
||
ULONG DiskNumber;
|
||
|
||
//
|
||
// If device is enabled for counting always
|
||
//
|
||
|
||
LONG EnabledAlways;
|
||
|
||
//
|
||
// Use to keep track of Volume info from ntddvol.h
|
||
//
|
||
|
||
WCHAR StorageManagerName[8];
|
||
|
||
//
|
||
// Disk performance counters
|
||
// and locals used to compute counters
|
||
//
|
||
|
||
ULONG Processors;
|
||
PDISK_PERFORMANCE DiskCounters; // per processor counters
|
||
LARGE_INTEGER LastIdleClock;
|
||
LONG QueueDepth;
|
||
LONG CountersEnabled;
|
||
|
||
//
|
||
// must synchronize paging path notifications
|
||
//
|
||
KEVENT PagingPathCountEvent;
|
||
ULONG PagingPathCount;
|
||
|
||
//
|
||
// Physical Device name or WMI Instance Name
|
||
//
|
||
|
||
UNICODE_STRING PhysicalDeviceName;
|
||
WCHAR PhysicalDeviceNameBuffer[DISKPERF_MAXSTR];
|
||
|
||
//
|
||
// Private context for using WmiLib
|
||
//
|
||
WMILIB_CONTEXT WmilibContext;
|
||
|
||
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
|
||
|
||
#define DEVICE_EXTENSION_SIZE sizeof(DEVICE_EXTENSION)
|
||
#define PROCESSOR_COUNTERS_SIZE FIELD_OFFSET(DISK_PERFORMANCE, QueryTime)
|
||
|
||
/*
|
||
Layout of Per Processor Counters is a contiguous block of memory:
|
||
Processor 1
|
||
+-----------------------+ +-----------------------+
|
||
|PROCESSOR_COUNTERS_SIZE| ... |PROCESSOR_COUNTERS_SIZE|
|
||
+-----------------------+ +-----------------------+
|
||
where PROCESSOR_COUNTERS_SIZE is less than sizeof(DISK_PERFORMANCE) since
|
||
we only put those we actually use for counting.
|
||
*/
|
||
|
||
UNICODE_STRING DiskPerfRegistryPath;
|
||
|
||
|
||
//
|
||
// Function declarations
|
||
//
|
||
|
||
NTSTATUS
|
||
DriverEntry(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING RegistryPath
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfForwardIrpSynchronous(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfAddDevice(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PDEVICE_OBJECT PhysicalDeviceObject
|
||
);
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfDispatchPnp(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfDispatchPower(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfStartDevice(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfRemoveDevice(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfSendToNextDriver(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfCreate(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfReadWrite(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfIoCompletion(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfDeviceControl(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfShutdownFlush(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
VOID
|
||
DiskPerfUnload(
|
||
IN PDRIVER_OBJECT DriverObject
|
||
);
|
||
|
||
NTSTATUS DiskPerfWmi(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
);
|
||
|
||
VOID
|
||
DiskPerfLogError(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN ULONG UniqueId,
|
||
IN NTSTATUS ErrorCode,
|
||
IN NTSTATUS Status
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfRegisterDevice(
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskPerfIrpCompletion(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskperfQueryWmiRegInfo(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
OUT ULONG *RegFlags,
|
||
OUT PUNICODE_STRING InstanceName,
|
||
OUT PUNICODE_STRING *RegistryPath,
|
||
OUT PUNICODE_STRING MofResourceName,
|
||
OUT PDEVICE_OBJECT *Pdo
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskperfQueryWmiDataBlock(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN ULONG GuidIndex,
|
||
IN ULONG InstanceIndex,
|
||
IN ULONG InstanceCount,
|
||
IN OUT PULONG InstanceLengthArray,
|
||
IN ULONG BufferAvail,
|
||
OUT PUCHAR Buffer
|
||
);
|
||
|
||
VOID
|
||
DiskPerfSyncFilterWithTarget(
|
||
IN PDEVICE_OBJECT FilterDevice,
|
||
IN PDEVICE_OBJECT TargetDevice
|
||
);
|
||
|
||
NTSTATUS
|
||
DiskperfWmiFunctionControl(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN ULONG GuidIndex,
|
||
IN WMIENABLEDISABLECONTROL Function,
|
||
IN BOOLEAN Enable
|
||
);
|
||
|
||
VOID
|
||
DiskPerfAddCounters(
|
||
IN OUT PDISK_PERFORMANCE TotalCounters,
|
||
IN PDISK_PERFORMANCE NewCounters,
|
||
IN LARGE_INTEGER Frequency
|
||
);
|
||
|
||
#if DBG
|
||
|
||
ULONG DiskPerfDebug = 0;
|
||
|
||
VOID
|
||
DiskPerfDebugPrint(
|
||
ULONG DebugPrintLevel,
|
||
PCCHAR DebugMessage,
|
||
...
|
||
);
|
||
|
||
#define DebugPrint(x) DiskPerfDebugPrint x
|
||
|
||
#else
|
||
|
||
#define DebugPrint(x)
|
||
|
||
#endif
|
||
|
||
//
|
||
// Define the sections that allow for discarding (i.e. paging) some of
|
||
// the code.
|
||
//
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text (INIT, DriverEntry)
|
||
#pragma alloc_text (PAGE, DiskPerfCreate)
|
||
#pragma alloc_text (PAGE, DiskPerfAddDevice)
|
||
#pragma alloc_text (PAGE, DiskPerfDispatchPnp)
|
||
#pragma alloc_text (PAGE, DiskPerfStartDevice)
|
||
#pragma alloc_text (PAGE, DiskPerfRemoveDevice)
|
||
#pragma alloc_text (PAGE, DiskPerfUnload)
|
||
#pragma alloc_text (PAGE, DiskPerfWmi)
|
||
#pragma alloc_text (PAGE, DiskperfQueryWmiRegInfo)
|
||
#pragma alloc_text (PAGE, DiskperfQueryWmiDataBlock)
|
||
#pragma alloc_text (PAGE, DiskPerfRegisterDevice)
|
||
#pragma alloc_text (PAGE, DiskPerfSyncFilterWithTarget)
|
||
#endif
|
||
|
||
WMIGUIDREGINFO DiskperfGuidList[] =
|
||
{
|
||
{ &DiskPerfGuid,
|
||
1,
|
||
0
|
||
}
|
||
};
|
||
|
||
#define DiskperfGuidCount (sizeof(DiskperfGuidList) / sizeof(WMIGUIDREGINFO))
|
||
|
||
#define USE_PERF_CTR
|
||
|
||
#ifdef USE_PERF_CTR
|
||
#define DiskPerfGetClock(a, b) (a) = KeQueryPerformanceCounter((b))
|
||
#else
|
||
#define DiskPerfGetClock(a, b) KeQuerySystemTime(&(a))
|
||
#endif
|
||
|
||
|
||
NTSTATUS
|
||
DriverEntry(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PUNICODE_STRING RegistryPath
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Installable driver initialization entry point.
|
||
This entry point is called directly by the I/O manager to set up the disk
|
||
performance driver. The driver object is set up and then the Pnp manager
|
||
calls DiskPerfAddDevice to attach to the boot devices.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - The disk performance driver object.
|
||
|
||
RegistryPath - pointer to a unicode string representing the path,
|
||
to driver-specific key in the registry.
|
||
|
||
Return Value:
|
||
|
||
STATUS_SUCCESS if successful
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
ULONG ulIndex;
|
||
PDRIVER_DISPATCH * dispatch;
|
||
|
||
//
|
||
// Remember registry path
|
||
//
|
||
|
||
DiskPerfRegistryPath.MaximumLength = RegistryPath->Length
|
||
+ sizeof(UNICODE_NULL);
|
||
DiskPerfRegistryPath.Buffer = ExAllocatePool(
|
||
PagedPool,
|
||
DiskPerfRegistryPath.MaximumLength);
|
||
if (DiskPerfRegistryPath.Buffer != NULL)
|
||
{
|
||
RtlCopyUnicodeString(&DiskPerfRegistryPath, RegistryPath);
|
||
} else {
|
||
DiskPerfRegistryPath.Length = 0;
|
||
DiskPerfRegistryPath.MaximumLength = 0;
|
||
}
|
||
|
||
//
|
||
// Create dispatch points
|
||
//
|
||
for (ulIndex = 0, dispatch = DriverObject->MajorFunction;
|
||
ulIndex <= IRP_MJ_MAXIMUM_FUNCTION;
|
||
ulIndex++, dispatch++) {
|
||
|
||
*dispatch = DiskPerfSendToNextDriver;
|
||
}
|
||
|
||
//
|
||
// Set up the device driver entry points.
|
||
//
|
||
|
||
DriverObject->MajorFunction[IRP_MJ_CREATE] = DiskPerfCreate;
|
||
DriverObject->MajorFunction[IRP_MJ_READ] = DiskPerfReadWrite;
|
||
DriverObject->MajorFunction[IRP_MJ_WRITE] = DiskPerfReadWrite;
|
||
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DiskPerfDeviceControl;
|
||
DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = DiskPerfWmi;
|
||
|
||
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = DiskPerfShutdownFlush;
|
||
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = DiskPerfShutdownFlush;
|
||
DriverObject->MajorFunction[IRP_MJ_PNP] = DiskPerfDispatchPnp;
|
||
DriverObject->MajorFunction[IRP_MJ_POWER] = DiskPerfDispatchPower;
|
||
|
||
DriverObject->DriverExtension->AddDevice = DiskPerfAddDevice;
|
||
DriverObject->DriverUnload = DiskPerfUnload;
|
||
|
||
return(STATUS_SUCCESS);
|
||
|
||
} // end DriverEntry()
|
||
|
||
#define FILTER_DEVICE_PROPOGATE_FLAGS 0
|
||
#define FILTER_DEVICE_PROPOGATE_CHARACTERISTICS (FILE_REMOVABLE_MEDIA | \
|
||
FILE_READ_ONLY_DEVICE | \
|
||
FILE_FLOPPY_DISKETTE \
|
||
)
|
||
|
||
VOID
|
||
DiskPerfSyncFilterWithTarget(
|
||
IN PDEVICE_OBJECT FilterDevice,
|
||
IN PDEVICE_OBJECT TargetDevice
|
||
)
|
||
{
|
||
ULONG propFlags;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Propogate all useful flags from target to diskperf. MountMgr will look
|
||
// at the diskperf object capabilities to figure out if the disk is
|
||
// a removable and perhaps other things.
|
||
//
|
||
propFlags = TargetDevice->Flags & FILTER_DEVICE_PROPOGATE_FLAGS;
|
||
FilterDevice->Flags |= propFlags;
|
||
|
||
propFlags = TargetDevice->Characteristics & FILTER_DEVICE_PROPOGATE_CHARACTERISTICS;
|
||
FilterDevice->Characteristics |= propFlags;
|
||
|
||
|
||
}
|
||
|
||
NTSTATUS
|
||
DiskPerfAddDevice(
|
||
IN PDRIVER_OBJECT DriverObject,
|
||
IN PDEVICE_OBJECT PhysicalDeviceObject
|
||
)
|
||
/*++
|
||
Routine Description:
|
||
|
||
Creates and initializes a new filter device object FiDO for the
|
||
corresponding PDO. Then it attaches the device object to the device
|
||
stack of the drivers for the device.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - Disk performance driver object.
|
||
PhysicalDeviceObject - Physical Device Object from the underlying layered driver
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
PDEVICE_OBJECT filterDeviceObject;
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
PIRP irp;
|
||
STORAGE_DEVICE_NUMBER number;
|
||
ULONG registrationFlag = 0;
|
||
PWMILIB_CONTEXT wmilibContext;
|
||
PCHAR buffer;
|
||
ULONG buffersize;
|
||
|
||
PAGED_CODE();
|
||
|
||
//
|
||
// Create a filter device object for this device (partition).
|
||
//
|
||
|
||
DebugPrint((2, "DiskPerfAddDevice: Driver %X Device %X\n",
|
||
DriverObject, PhysicalDeviceObject));
|
||
|
||
status = IoCreateDevice(DriverObject,
|
||
DEVICE_EXTENSION_SIZE,
|
||
NULL,
|
||
FILE_DEVICE_DISK,
|
||
FILE_DEVICE_SECURE_OPEN,
|
||
FALSE,
|
||
&filterDeviceObject);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
DebugPrint((1, "DiskPerfAddDevice: Cannot create filterDeviceObject\n"));
|
||
return status;
|
||
}
|
||
|
||
filterDeviceObject->Flags |= DO_DIRECT_IO;
|
||
|
||
deviceExtension = (PDEVICE_EXTENSION) filterDeviceObject->DeviceExtension;
|
||
|
||
RtlZeroMemory(deviceExtension, DEVICE_EXTENSION_SIZE);
|
||
DiskPerfGetClock(deviceExtension->LastIdleClock, NULL);
|
||
DebugPrint((10, "DiskPerfAddDevice: LIC=%I64u\n",
|
||
deviceExtension->LastIdleClock));
|
||
|
||
//
|
||
// Allocate per processor counters. NOTE: To save some memory, it does
|
||
// allocate memory beyond QueryTime. Remember to expand size if there
|
||
// is a need to use anything beyond this
|
||
//
|
||
deviceExtension->Processors = KeNumberProcessors;
|
||
buffersize= PROCESSOR_COUNTERS_SIZE * deviceExtension->Processors;
|
||
buffer = (PCHAR) ExAllocatePool(NonPagedPool, buffersize);
|
||
if (buffer != NULL) {
|
||
RtlZeroMemory(buffer, buffersize);
|
||
deviceExtension->DiskCounters = (PDISK_PERFORMANCE) buffer;
|
||
}
|
||
else {
|
||
DiskPerfLogError(
|
||
filterDeviceObject,
|
||
513,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
}
|
||
|
||
//
|
||
// Attaches the device object to the highest device object in the chain and
|
||
// return the previously highest device object, which is passed to
|
||
// IoCallDriver when pass IRPs down the device stack
|
||
//
|
||
|
||
deviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
|
||
|
||
deviceExtension->TargetDeviceObject =
|
||
IoAttachDeviceToDeviceStack(filterDeviceObject, PhysicalDeviceObject);
|
||
|
||
if (deviceExtension->TargetDeviceObject == NULL) {
|
||
IoDeleteDevice(filterDeviceObject);
|
||
DebugPrint((1, "DiskPerfAddDevice: Unable to attach %X to target %X\n",
|
||
filterDeviceObject, PhysicalDeviceObject));
|
||
return STATUS_NO_SUCH_DEVICE;
|
||
}
|
||
|
||
//
|
||
// Save the filter device object in the device extension
|
||
//
|
||
deviceExtension->DeviceObject = filterDeviceObject;
|
||
|
||
deviceExtension->PhysicalDeviceName.Buffer
|
||
= deviceExtension->PhysicalDeviceNameBuffer;
|
||
|
||
KeInitializeEvent(&deviceExtension->PagingPathCountEvent,
|
||
NotificationEvent, TRUE);
|
||
|
||
|
||
//
|
||
// Initialize WMI library context
|
||
//
|
||
wmilibContext = &deviceExtension->WmilibContext;
|
||
RtlZeroMemory(wmilibContext, sizeof(WMILIB_CONTEXT));
|
||
wmilibContext->GuidCount = DiskperfGuidCount;
|
||
wmilibContext->GuidList = DiskperfGuidList;
|
||
wmilibContext->QueryWmiRegInfo = DiskperfQueryWmiRegInfo;
|
||
wmilibContext->QueryWmiDataBlock = DiskperfQueryWmiDataBlock;
|
||
wmilibContext->WmiFunctionControl = DiskperfWmiFunctionControl;
|
||
|
||
//
|
||
// default to DO_POWER_PAGABLE
|
||
//
|
||
|
||
filterDeviceObject->Flags |= DO_POWER_PAGABLE;
|
||
|
||
//
|
||
// Clear the DO_DEVICE_INITIALIZING flag
|
||
//
|
||
|
||
filterDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
||
|
||
return STATUS_SUCCESS;
|
||
|
||
} // end DiskPerfAddDevice()
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfDispatchPnp(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Dispatch for PNP
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Supplies the device object.
|
||
|
||
Irp - Supplies the I/O request packet.
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS
|
||
|
||
--*/
|
||
|
||
{
|
||
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
NTSTATUS status;
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
|
||
PAGED_CODE();
|
||
|
||
DebugPrint((2, "DiskPerfDispatchPnp: Device %X Irp %X\n",
|
||
DeviceObject, Irp));
|
||
|
||
switch(irpSp->MinorFunction) {
|
||
|
||
case IRP_MN_START_DEVICE:
|
||
//
|
||
// Call the Start Routine handler to schedule a completion routine
|
||
//
|
||
DebugPrint((3,
|
||
"DiskPerfDispatchPnp: Schedule completion for START_DEVICE"));
|
||
status = DiskPerfStartDevice(DeviceObject, Irp);
|
||
break;
|
||
|
||
case IRP_MN_REMOVE_DEVICE:
|
||
{
|
||
//
|
||
// Call the Remove Routine handler to schedule a completion routine
|
||
//
|
||
DebugPrint((3,
|
||
"DiskPerfDispatchPnp: Schedule completion for REMOVE_DEVICE"));
|
||
status = DiskPerfRemoveDevice(DeviceObject, Irp);
|
||
break;
|
||
}
|
||
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
|
||
{
|
||
PIO_STACK_LOCATION irpStack;
|
||
ULONG count;
|
||
BOOLEAN setPagable;
|
||
|
||
DebugPrint((3,
|
||
"DiskPerfDispatchPnp: Processing DEVICE_USAGE_NOTIFICATION"));
|
||
irpStack = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
if (irpStack->Parameters.UsageNotification.Type != DeviceUsageTypePaging) {
|
||
status = DiskPerfSendToNextDriver(DeviceObject, Irp);
|
||
break; // out of case statement
|
||
}
|
||
|
||
deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
//
|
||
// wait on the paging path event
|
||
//
|
||
|
||
status = KeWaitForSingleObject(&deviceExtension->PagingPathCountEvent,
|
||
Executive, KernelMode,
|
||
FALSE, NULL);
|
||
|
||
//
|
||
// if removing last paging device, need to set DO_POWER_PAGABLE
|
||
// bit here, and possible re-set it below on failure.
|
||
//
|
||
|
||
setPagable = FALSE;
|
||
if (!irpStack->Parameters.UsageNotification.InPath &&
|
||
deviceExtension->PagingPathCount == 1 ) {
|
||
|
||
//
|
||
// removing the last paging file
|
||
// must have DO_POWER_PAGABLE bits set
|
||
//
|
||
|
||
if (DeviceObject->Flags & DO_POWER_INRUSH) {
|
||
DebugPrint((3, "DiskPerfDispatchPnp: last paging file "
|
||
"removed but DO_POWER_INRUSH set, so not "
|
||
"setting PAGABLE bit "
|
||
"for DO %p\n", DeviceObject));
|
||
} else {
|
||
DebugPrint((2, "DiskPerfDispatchPnp: Setting PAGABLE "
|
||
"bit for DO %p\n", DeviceObject));
|
||
DeviceObject->Flags |= DO_POWER_PAGABLE;
|
||
setPagable = TRUE;
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// send the irp synchronously
|
||
//
|
||
|
||
status = DiskPerfForwardIrpSynchronous(DeviceObject, Irp);
|
||
|
||
//
|
||
// now deal with the failure and success cases.
|
||
// note that we are not allowed to fail the irp
|
||
// once it is sent to the lower drivers.
|
||
//
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
|
||
IoAdjustPagingPathCount(
|
||
&deviceExtension->PagingPathCount,
|
||
irpStack->Parameters.UsageNotification.InPath);
|
||
|
||
if (irpStack->Parameters.UsageNotification.InPath) {
|
||
if (deviceExtension->PagingPathCount == 1) {
|
||
|
||
//
|
||
// first paging file addition
|
||
//
|
||
|
||
DebugPrint((3, "DiskPerfDispatchPnp: Clearing PAGABLE bit "
|
||
"for DO %p\n", DeviceObject));
|
||
DeviceObject->Flags &= ~DO_POWER_PAGABLE;
|
||
}
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// cleanup the changes done above
|
||
//
|
||
|
||
if (setPagable == TRUE) {
|
||
DeviceObject->Flags &= ~DO_POWER_PAGABLE;
|
||
setPagable = FALSE;
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// set the event so the next one can occur.
|
||
//
|
||
|
||
KeSetEvent(&deviceExtension->PagingPathCountEvent,
|
||
IO_NO_INCREMENT, FALSE);
|
||
|
||
//
|
||
// and complete the irp
|
||
//
|
||
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return status;
|
||
break;
|
||
|
||
}
|
||
|
||
default:
|
||
DebugPrint((3,
|
||
"DiskPerfDispatchPnp: Forwarding irp"));
|
||
//
|
||
// Simply forward all other Irps
|
||
//
|
||
return DiskPerfSendToNextDriver(DeviceObject, Irp);
|
||
|
||
}
|
||
|
||
return status;
|
||
|
||
} // end DiskPerfDispatchPnp()
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfIrpCompletion(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Forwarded IRP completion routine. Set an event and return
|
||
STATUS_MORE_PROCESSING_REQUIRED. Irp forwarder will wait on this
|
||
event and then re-complete the irp after cleaning up.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject is the device object of the WMI driver
|
||
Irp is the WMI irp that was just completed
|
||
Context is a PKEVENT that forwarder will wait on
|
||
|
||
Return Value:
|
||
|
||
STATUS_MORE_PORCESSING_REQUIRED
|
||
|
||
--*/
|
||
|
||
{
|
||
PKEVENT Event = (PKEVENT) Context;
|
||
|
||
UNREFERENCED_PARAMETER(DeviceObject);
|
||
UNREFERENCED_PARAMETER(Irp);
|
||
|
||
KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
|
||
|
||
return(STATUS_MORE_PROCESSING_REQUIRED);
|
||
|
||
} // end DiskPerfIrpCompletion()
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfStartDevice(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called when a Pnp Start Irp is received.
|
||
It will schedule a completion routine to initialize and register with WMI.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - a pointer to the device object
|
||
|
||
Irp - a pointer to the irp
|
||
|
||
|
||
Return Value:
|
||
|
||
Status of processing the Start Irp
|
||
|
||
--*/
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
KEVENT event;
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
|
||
|
||
status = DiskPerfForwardIrpSynchronous(DeviceObject, Irp);
|
||
|
||
DiskPerfSyncFilterWithTarget(DeviceObject,
|
||
deviceExtension->TargetDeviceObject);
|
||
|
||
//
|
||
// Complete WMI registration
|
||
//
|
||
DiskPerfRegisterDevice(DeviceObject);
|
||
|
||
//
|
||
// Complete the Irp
|
||
//
|
||
Irp->IoStatus.Status = status;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfRemoveDevice(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called when the device is to be removed.
|
||
It will de-register itself from WMI first, detach itself from the
|
||
stack before deleting itself.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - a pointer to the device object
|
||
|
||
Irp - a pointer to the irp
|
||
|
||
|
||
Return Value:
|
||
|
||
Status of removing the device
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
PWMILIB_CONTEXT wmilibContext;
|
||
|
||
PAGED_CODE();
|
||
|
||
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
|
||
|
||
//
|
||
// Remove registration with WMI first
|
||
//
|
||
IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_DEREGISTER);
|
||
|
||
//
|
||
// quickly zero out the count first to invalid the structure
|
||
//
|
||
wmilibContext = &deviceExtension->WmilibContext;
|
||
InterlockedExchange(
|
||
(PLONG) &(wmilibContext->GuidCount),
|
||
(LONG) 0);
|
||
RtlZeroMemory(wmilibContext, sizeof(WMILIB_CONTEXT));
|
||
|
||
status = DiskPerfForwardIrpSynchronous(DeviceObject, Irp);
|
||
|
||
IoDetachDevice(deviceExtension->TargetDeviceObject);
|
||
IoDeleteDevice(DeviceObject);
|
||
|
||
//
|
||
// Complete the Irp
|
||
//
|
||
Irp->IoStatus.Status = status;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
|
||
return status;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfSendToNextDriver(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine sends the Irp to the next driver in line
|
||
when the Irp is not processed by this driver.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject
|
||
Irp
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
|
||
IoSkipCurrentIrpStackLocation(Irp);
|
||
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
|
||
|
||
return IoCallDriver(deviceExtension->TargetDeviceObject, Irp);
|
||
|
||
} // end DiskPerfSendToNextDriver()
|
||
|
||
NTSTATUS
|
||
DiskPerfDispatchPower(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
|
||
PoStartNextPowerIrp(Irp);
|
||
IoSkipCurrentIrpStackLocation(Irp);
|
||
|
||
deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
||
return PoCallDriver(deviceExtension->TargetDeviceObject, Irp);
|
||
|
||
} // end DiskPerfDispatchPower
|
||
|
||
NTSTATUS
|
||
DiskPerfForwardIrpSynchronous(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine sends the Irp to the next driver in line
|
||
when the Irp needs to be processed by the lower drivers
|
||
prior to being processed by this one.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject
|
||
Irp
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
KEVENT event;
|
||
NTSTATUS status;
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
|
||
|
||
//
|
||
// copy the irpstack for the next device
|
||
//
|
||
|
||
IoCopyCurrentIrpStackLocationToNext(Irp);
|
||
|
||
//
|
||
// set a completion routine
|
||
//
|
||
|
||
IoSetCompletionRoutine(Irp, DiskPerfIrpCompletion,
|
||
&event, TRUE, TRUE, TRUE);
|
||
|
||
//
|
||
// call the next lower device
|
||
//
|
||
|
||
status = IoCallDriver(deviceExtension->TargetDeviceObject, Irp);
|
||
|
||
//
|
||
// wait for the actual completion
|
||
//
|
||
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
status = Irp->IoStatus.Status;
|
||
}
|
||
|
||
return status;
|
||
|
||
} // end DiskPerfForwardIrpSynchronous()
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfCreate(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine services open commands. It establishes
|
||
the driver's existance by returning status success.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Context for the activity.
|
||
Irp - The device control argument block.
|
||
|
||
Return Value:
|
||
|
||
NT Status
|
||
|
||
--*/
|
||
|
||
{
|
||
PAGED_CODE();
|
||
|
||
UNREFERENCED_PARAMETER(DeviceObject);
|
||
|
||
Irp->IoStatus.Status = STATUS_SUCCESS;
|
||
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return STATUS_SUCCESS;
|
||
|
||
} // end DiskPerfCreate()
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfReadWrite(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This is the driver entry point for read and write requests
|
||
to disks to which the diskperf driver has attached.
|
||
This driver collects statistics and then sets a completion
|
||
routine so that it can collect additional information when
|
||
the request completes. Then it calls the next driver below
|
||
it.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject
|
||
Irp
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
||
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
|
||
PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
|
||
ULONG processor = (ULONG) KeGetCurrentProcessorNumber();
|
||
PDISK_PERFORMANCE partitionCounters = NULL;
|
||
LONG queueLen;
|
||
PLARGE_INTEGER timeStamp;
|
||
|
||
if (deviceExtension->DiskCounters != NULL) {
|
||
partitionCounters = (PDISK_PERFORMANCE)
|
||
((PCHAR) deviceExtension->DiskCounters
|
||
+ (processor*PROCESSOR_COUNTERS_SIZE));
|
||
}
|
||
|
||
|
||
//
|
||
// Device is not initialized properly. Blindly pass the irp along
|
||
//
|
||
if (deviceExtension->CountersEnabled <= 0 ||
|
||
deviceExtension->PhysicalDeviceNameBuffer[0] == 0 ||
|
||
partitionCounters == NULL) {
|
||
return DiskPerfSendToNextDriver(DeviceObject, Irp);
|
||
}
|
||
|
||
//
|
||
// Increment queue depth counter.
|
||
//
|
||
|
||
queueLen = InterlockedIncrement(&deviceExtension->QueueDepth);
|
||
|
||
//
|
||
// Copy current stack to next stack.
|
||
//
|
||
|
||
*nextIrpStack = *currentIrpStack;
|
||
|
||
//
|
||
// Time stamp current request start.
|
||
//
|
||
|
||
timeStamp = (PLARGE_INTEGER) ¤tIrpStack->Parameters.Read;
|
||
DiskPerfGetClock(*timeStamp, NULL);
|
||
DebugPrint((10, "DiskPerfReadWrite: TS=%I64u\n", *timeStamp));
|
||
|
||
if (queueLen == 1) {
|
||
partitionCounters->IdleTime.QuadPart
|
||
+= timeStamp->QuadPart -
|
||
deviceExtension->LastIdleClock.QuadPart;
|
||
deviceExtension->LastIdleClock.QuadPart = timeStamp->QuadPart;
|
||
}
|
||
|
||
//
|
||
// Set completion routine callback.
|
||
//
|
||
|
||
IoSetCompletionRoutine(Irp,
|
||
DiskPerfIoCompletion,
|
||
DeviceObject,
|
||
TRUE,
|
||
TRUE,
|
||
TRUE);
|
||
|
||
//
|
||
// Return the results of the call to the disk driver.
|
||
//
|
||
|
||
return IoCallDriver(deviceExtension->TargetDeviceObject,
|
||
Irp);
|
||
|
||
} // end DiskPerfReadWrite()
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfIoCompletion(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN PVOID Context
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine will get control from the system at the completion of an IRP.
|
||
It will calculate the difference between the time the IRP was started
|
||
and the current time, and decrement the queue depth.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - for the IRP.
|
||
Irp - The I/O request that just completed.
|
||
Context - Not used.
|
||
|
||
Return Value:
|
||
|
||
The IRP status.
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
||
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
|
||
PDISK_PERFORMANCE partitionCounters;
|
||
LARGE_INTEGER timeStampComplete;
|
||
PLARGE_INTEGER difference;
|
||
KIRQL currentIrql;
|
||
LONG queueLen;
|
||
|
||
UNREFERENCED_PARAMETER(Context);
|
||
|
||
//
|
||
// Get the per processor partition counters
|
||
// NOTE: DiskPerfReadWrite already check to see if this buffer is NON
|
||
// NULL before scheduling this completion routine, so we assume that it
|
||
// is always non-NULL when we get here
|
||
//
|
||
|
||
partitionCounters = (PDISK_PERFORMANCE)
|
||
((PCHAR) deviceExtension->DiskCounters
|
||
+ ((ULONG)KeGetCurrentProcessorNumber()
|
||
* PROCESSOR_COUNTERS_SIZE));
|
||
//
|
||
// Time stamp current request complete.
|
||
//
|
||
|
||
if (partitionCounters == NULL) { // just in case
|
||
return STATUS_SUCCESS;
|
||
};
|
||
difference = (PLARGE_INTEGER) &irpStack->Parameters.Read;
|
||
DiskPerfGetClock(timeStampComplete, NULL);
|
||
difference->QuadPart = timeStampComplete.QuadPart - difference->QuadPart;
|
||
DebugPrint((10, "DiskPerfIoCompletion: TS=%I64u diff %I64u\n",
|
||
timeStampComplete, difference->QuadPart));
|
||
|
||
//
|
||
// Decrement the queue depth counters for the volume. This is
|
||
// done without the spinlock using the Interlocked functions.
|
||
// This is the only
|
||
// legal way to do this.
|
||
//
|
||
|
||
queueLen = InterlockedDecrement(&deviceExtension->QueueDepth);
|
||
|
||
if (queueLen < 0) { // do not over-decrement. Only happens at start
|
||
queueLen = InterlockedIncrement(&deviceExtension->QueueDepth);
|
||
}
|
||
if (queueLen == 0) {
|
||
deviceExtension->LastIdleClock = timeStampComplete;
|
||
}
|
||
|
||
//
|
||
// Update counters
|
||
//
|
||
|
||
if (irpStack->MajorFunction == IRP_MJ_READ) {
|
||
|
||
//
|
||
// Add bytes in this request to bytes read counters.
|
||
//
|
||
|
||
partitionCounters->BytesRead.QuadPart += Irp->IoStatus.Information;
|
||
|
||
//
|
||
// Increment read requests processed counters.
|
||
//
|
||
|
||
partitionCounters->ReadCount++;
|
||
|
||
//
|
||
// Calculate request processing time.
|
||
//
|
||
|
||
partitionCounters->ReadTime.QuadPart += difference->QuadPart;
|
||
DebugPrint((11, "Added RT delta %I64u total %I64u qlen=%d\n",
|
||
difference->QuadPart, partitionCounters->ReadTime.QuadPart,
|
||
queueLen));
|
||
}
|
||
|
||
else {
|
||
|
||
//
|
||
// Add bytes in this request to bytes write counters.
|
||
//
|
||
|
||
partitionCounters->BytesWritten.QuadPart += Irp->IoStatus.Information;
|
||
|
||
//
|
||
// Increment write requests processed counters.
|
||
//
|
||
|
||
partitionCounters->WriteCount++;
|
||
|
||
//
|
||
// Calculate request processing time.
|
||
//
|
||
|
||
partitionCounters->WriteTime.QuadPart += difference->QuadPart;
|
||
DebugPrint((11, "Added WT delta %I64u total %I64u qlen=%d\n",
|
||
difference->QuadPart, partitionCounters->WriteTime.QuadPart,
|
||
queueLen));
|
||
}
|
||
|
||
if (Irp->Flags & IRP_ASSOCIATED_IRP) {
|
||
partitionCounters->SplitCount++;
|
||
}
|
||
|
||
if (Irp->PendingReturned) {
|
||
IoMarkIrpPending(Irp);
|
||
}
|
||
return STATUS_SUCCESS;
|
||
|
||
} // DiskPerfIoCompletion
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfDeviceControl(
|
||
PDEVICE_OBJECT DeviceObject,
|
||
PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This device control dispatcher handles only the disk performance
|
||
device control. All others are passed down to the disk drivers.
|
||
The disk performane device control returns a current snapshot of
|
||
the performance data.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Context for the activity.
|
||
Irp - The device control argument block.
|
||
|
||
Return Value:
|
||
|
||
Status is returned.
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
||
PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
DebugPrint((2, "DiskPerfDeviceControl: DeviceObject %X Irp %X\n",
|
||
DeviceObject, Irp));
|
||
|
||
if (currentIrpStack->Parameters.DeviceIoControl.IoControlCode ==
|
||
IOCTL_DISK_PERFORMANCE) {
|
||
|
||
NTSTATUS status;
|
||
KIRQL currentIrql;
|
||
|
||
//
|
||
// Verify user buffer is large enough for the performance data.
|
||
//
|
||
|
||
if (currentIrpStack->Parameters.DeviceIoControl.OutputBufferLength <
|
||
sizeof(DISK_PERFORMANCE)) {
|
||
|
||
//
|
||
// Indicate unsuccessful status and no data transferred.
|
||
//
|
||
|
||
status = STATUS_BUFFER_TOO_SMALL;
|
||
Irp->IoStatus.Information = 0;
|
||
|
||
}
|
||
|
||
else {
|
||
ULONG i;
|
||
PDISK_PERFORMANCE totalCounters;
|
||
PDISK_PERFORMANCE diskCounters = deviceExtension->DiskCounters;
|
||
LARGE_INTEGER frequency, perfctr;
|
||
|
||
if (diskCounters == NULL) {
|
||
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return STATUS_UNSUCCESSFUL;
|
||
}
|
||
|
||
if (InterlockedCompareExchange(&deviceExtension->EnabledAlways, 1, 0) == 0)
|
||
{
|
||
InterlockedIncrement(&deviceExtension->CountersEnabled);
|
||
|
||
//
|
||
// reset per processor counters only
|
||
//
|
||
if (deviceExtension->DiskCounters != NULL)
|
||
{
|
||
RtlZeroMemory(deviceExtension->DiskCounters, PROCESSOR_COUNTERS_SIZE * deviceExtension->Processors);
|
||
}
|
||
|
||
DiskPerfGetClock(deviceExtension->LastIdleClock, NULL);
|
||
|
||
deviceExtension->QueueDepth = 0;
|
||
|
||
DebugPrint((10, "DiskPerfDeviceControl: LIC=%I64u\n", deviceExtension->LastIdleClock));
|
||
DebugPrint((3, "DiskPerfDeviceControl: Counters enabled %d\n", deviceExtension->CountersEnabled));
|
||
}
|
||
|
||
totalCounters = (PDISK_PERFORMANCE) Irp->AssociatedIrp.SystemBuffer;
|
||
RtlZeroMemory(totalCounters, sizeof(DISK_PERFORMANCE));
|
||
#ifdef USE_PERF_CTR
|
||
perfctr = KeQueryPerformanceCounter(&frequency);
|
||
#endif
|
||
KeQuerySystemTime(&totalCounters->QueryTime);
|
||
|
||
for (i=0; i<deviceExtension->Processors; i++) {
|
||
DiskPerfAddCounters(totalCounters, diskCounters, frequency);
|
||
diskCounters = (PDISK_PERFORMANCE)
|
||
((PCHAR) diskCounters + PROCESSOR_COUNTERS_SIZE);
|
||
}
|
||
totalCounters->QueueDepth = deviceExtension->QueueDepth;
|
||
|
||
if (totalCounters->QueueDepth == 0) {
|
||
LARGE_INTEGER difference;
|
||
|
||
difference.QuadPart =
|
||
#ifdef USE_PERF_CTR
|
||
perfctr.QuadPart
|
||
#else
|
||
totalCounters->QueryTime.QuadPart
|
||
#endif
|
||
- deviceExtension->LastIdleClock.QuadPart;
|
||
if (difference.QuadPart > 0) {
|
||
totalCounters->IdleTime.QuadPart +=
|
||
#ifdef USE_PERF_CTR
|
||
10000000 * difference.QuadPart / frequency.QuadPart;
|
||
#else
|
||
difference.QuadPart;
|
||
#endif
|
||
}
|
||
}
|
||
totalCounters->StorageDeviceNumber
|
||
= deviceExtension->DiskNumber;
|
||
RtlCopyMemory(
|
||
&totalCounters->StorageManagerName[0],
|
||
&deviceExtension->StorageManagerName[0],
|
||
8 * sizeof(WCHAR));
|
||
status = STATUS_SUCCESS;
|
||
Irp->IoStatus.Information = sizeof(DISK_PERFORMANCE);
|
||
}
|
||
|
||
//
|
||
// Complete request.
|
||
//
|
||
|
||
Irp->IoStatus.Status = status;
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
return status;
|
||
|
||
}
|
||
|
||
else {
|
||
|
||
//
|
||
// Set current stack back one.
|
||
//
|
||
|
||
Irp->CurrentLocation++,
|
||
Irp->Tail.Overlay.CurrentStackLocation++;
|
||
|
||
//
|
||
// Pass unrecognized device control requests
|
||
// down to next driver layer.
|
||
//
|
||
|
||
return IoCallDriver(deviceExtension->TargetDeviceObject, Irp);
|
||
}
|
||
} // end DiskPerfDeviceControl()
|
||
|
||
|
||
|
||
NTSTATUS DiskPerfWmi(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine handles any WMI requests for information. Since the disk
|
||
information is read-only, is always collected and does not have any
|
||
events only QueryAllData, QuerySingleInstance and GetRegInfo requests
|
||
are supported.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - Context for the activity.
|
||
Irp - The device control argument block.
|
||
|
||
Return Value:
|
||
|
||
Status is returned.
|
||
|
||
--*/
|
||
|
||
{
|
||
PIO_STACK_LOCATION irpSp;
|
||
NTSTATUS status;
|
||
PWMILIB_CONTEXT wmilibContext;
|
||
SYSCTL_IRP_DISPOSITION disposition;
|
||
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
PAGED_CODE();
|
||
|
||
DebugPrint((2, "DiskPerfWmi: DeviceObject %X Irp %X\n",
|
||
DeviceObject, Irp));
|
||
wmilibContext = &deviceExtension->WmilibContext;
|
||
if (wmilibContext->GuidCount == 0) // wmilibContext is not valid
|
||
{
|
||
DebugPrint((3, "DiskPerfWmi: WmilibContext invalid"));
|
||
return DiskPerfSendToNextDriver(DeviceObject, Irp);
|
||
}
|
||
|
||
irpSp = IoGetCurrentIrpStackLocation(Irp);
|
||
|
||
DebugPrint((3, "DiskPerfWmi: Calling WmiSystemControl\n"));
|
||
status = WmiSystemControl(wmilibContext,
|
||
DeviceObject,
|
||
Irp,
|
||
&disposition);
|
||
switch (disposition)
|
||
{
|
||
case IrpProcessed:
|
||
{
|
||
break;
|
||
}
|
||
|
||
case IrpNotCompleted:
|
||
{
|
||
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
||
break;
|
||
}
|
||
|
||
// case IrpForward:
|
||
// case IrpNotWmi:
|
||
default:
|
||
{
|
||
status = DiskPerfSendToNextDriver(DeviceObject, Irp);
|
||
break;
|
||
}
|
||
}
|
||
return(status);
|
||
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfShutdownFlush(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called for a shutdown and flush IRPs. These are sent by the
|
||
system before it actually shuts down or when the file system does a flush.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - Pointer to device object to being shutdown by system.
|
||
Irp - IRP involved.
|
||
|
||
Return Value:
|
||
|
||
NT Status
|
||
|
||
--*/
|
||
|
||
{
|
||
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
//
|
||
// Set current stack back one.
|
||
//
|
||
|
||
DebugPrint((2, "DiskPerfShutdownFlush: DeviceObject %X Irp %X\n",
|
||
DeviceObject, Irp));
|
||
Irp->CurrentLocation++,
|
||
Irp->Tail.Overlay.CurrentStackLocation++;
|
||
|
||
return IoCallDriver(deviceExtension->TargetDeviceObject, Irp);
|
||
|
||
} // end DiskPerfShutdownFlush()
|
||
|
||
|
||
VOID
|
||
DiskPerfUnload(
|
||
IN PDRIVER_OBJECT DriverObject
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Free all the allocated resources, etc.
|
||
|
||
Arguments:
|
||
|
||
DriverObject - pointer to a driver object.
|
||
|
||
Return Value:
|
||
|
||
VOID.
|
||
|
||
--*/
|
||
{
|
||
PAGED_CODE();
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
DiskPerfRegisterDevice(
|
||
IN PDEVICE_OBJECT DeviceObject
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Routine to initialize a proper name for the device object, and
|
||
register it with WMI
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - pointer to a device object to be initialized.
|
||
|
||
Return Value:
|
||
|
||
Status of the initialization. NOTE: If the registration fails,
|
||
the device name in the DeviceExtension will be left as empty.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS status;
|
||
IO_STATUS_BLOCK ioStatus;
|
||
KEVENT event;
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
PIRP irp;
|
||
STORAGE_DEVICE_NUMBER number;
|
||
ULONG registrationFlag = 0;
|
||
|
||
PAGED_CODE();
|
||
|
||
DebugPrint((2, "DiskPerfRegisterDevice: DeviceObject %X\n",
|
||
DeviceObject));
|
||
deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
|
||
//
|
||
// Request for the device number
|
||
//
|
||
irp = IoBuildDeviceIoControlRequest(
|
||
IOCTL_STORAGE_GET_DEVICE_NUMBER,
|
||
deviceExtension->TargetDeviceObject,
|
||
NULL,
|
||
0,
|
||
&number,
|
||
sizeof(number),
|
||
FALSE,
|
||
&event,
|
||
&ioStatus);
|
||
if (!irp) {
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
256,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
DebugPrint((3, "DiskPerfRegisterDevice: Fail to build irp\n"));
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
status = IoCallDriver(deviceExtension->TargetDeviceObject, irp);
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
status = ioStatus.Status;
|
||
}
|
||
|
||
if (NT_SUCCESS(status)) {
|
||
|
||
//
|
||
// Remember the disk number for use as parameter in DiskIoNotifyRoutine
|
||
//
|
||
deviceExtension->DiskNumber = number.DeviceNumber;
|
||
|
||
//
|
||
// Create device name for each partition
|
||
//
|
||
|
||
swprintf(
|
||
deviceExtension->PhysicalDeviceNameBuffer,
|
||
L"\\Device\\Harddisk%d\\Partition%d",
|
||
number.DeviceNumber, number.PartitionNumber);
|
||
|
||
RtlInitUnicodeString(&deviceExtension->PhysicalDeviceName, &deviceExtension->PhysicalDeviceNameBuffer[0]);
|
||
|
||
//
|
||
// Set default name for physical disk
|
||
//
|
||
RtlCopyMemory(
|
||
&(deviceExtension->StorageManagerName[0]),
|
||
L"PhysDisk",
|
||
8 * sizeof(WCHAR));
|
||
DebugPrint((3, "DiskPerfRegisterDevice: Device name %ws\n",
|
||
deviceExtension->PhysicalDeviceNameBuffer));
|
||
}
|
||
else {
|
||
|
||
// request for partition's information failed, try volume
|
||
|
||
ULONG outputSize = sizeof(MOUNTDEV_NAME);
|
||
PMOUNTDEV_NAME output;
|
||
VOLUME_NUMBER volumeNumber;
|
||
ULONG nameSize;
|
||
|
||
output = ExAllocatePool(PagedPool, outputSize);
|
||
if (!output) {
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
257,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
irp = IoBuildDeviceIoControlRequest(
|
||
IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
|
||
deviceExtension->TargetDeviceObject, NULL, 0,
|
||
output, outputSize, FALSE, &event, &ioStatus);
|
||
if (!irp) {
|
||
ExFreePool(output);
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
258,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
status = IoCallDriver(deviceExtension->TargetDeviceObject, irp);
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
||
status = ioStatus.Status;
|
||
}
|
||
|
||
if (status == STATUS_BUFFER_OVERFLOW) {
|
||
outputSize = sizeof(MOUNTDEV_NAME) + output->NameLength;
|
||
ExFreePool(output);
|
||
output = ExAllocatePool(PagedPool, outputSize);
|
||
|
||
if (!output) {
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
258,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
irp = IoBuildDeviceIoControlRequest(
|
||
IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
|
||
deviceExtension->TargetDeviceObject, NULL, 0,
|
||
output, outputSize, FALSE, &event, &ioStatus);
|
||
if (!irp) {
|
||
ExFreePool(output);
|
||
DiskPerfLogError(
|
||
DeviceObject, 259,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
status = IoCallDriver(deviceExtension->TargetDeviceObject, irp);
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(
|
||
&event,
|
||
Executive,
|
||
KernelMode,
|
||
FALSE,
|
||
NULL
|
||
);
|
||
status = ioStatus.Status;
|
||
}
|
||
}
|
||
if (!NT_SUCCESS(status)) {
|
||
ExFreePool(output);
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
260,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_CONFIGURATION_ERROR);
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// Since we get the volume name instead of the disk number,
|
||
// set it to a dummy value
|
||
// Todo: Instead of passing the disk number back to the user app.
|
||
// for tracing, pass the STORAGE_DEVICE_NUMBER structure instead.
|
||
|
||
deviceExtension->DiskNumber = -1;
|
||
|
||
nameSize = min(output->NameLength, sizeof(deviceExtension->PhysicalDeviceNameBuffer) - sizeof(WCHAR));
|
||
|
||
wcsncpy(deviceExtension->PhysicalDeviceNameBuffer, output->Name, nameSize / sizeof(WCHAR));
|
||
|
||
RtlInitUnicodeString(&deviceExtension->PhysicalDeviceName, &deviceExtension->PhysicalDeviceNameBuffer[0]);
|
||
|
||
ExFreePool(output);
|
||
|
||
//
|
||
// Now, get the VOLUME_NUMBER information
|
||
//
|
||
outputSize = sizeof(VOLUME_NUMBER);
|
||
RtlZeroMemory(&volumeNumber, sizeof(VOLUME_NUMBER));
|
||
|
||
KeInitializeEvent(&event, NotificationEvent, FALSE);
|
||
irp = IoBuildDeviceIoControlRequest(
|
||
IOCTL_VOLUME_QUERY_VOLUME_NUMBER,
|
||
deviceExtension->TargetDeviceObject, NULL, 0,
|
||
&volumeNumber,
|
||
sizeof(VOLUME_NUMBER),
|
||
FALSE, &event, &ioStatus);
|
||
if (!irp) {
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
265,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INSUFFICIENT_RESOURCES);
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
status = IoCallDriver(deviceExtension->TargetDeviceObject, irp);
|
||
if (status == STATUS_PENDING) {
|
||
KeWaitForSingleObject(&event, Executive,
|
||
KernelMode, FALSE, NULL);
|
||
status = ioStatus.Status;
|
||
}
|
||
if (!NT_SUCCESS(status) ||
|
||
volumeNumber.VolumeManagerName[0] == (WCHAR) UNICODE_NULL) {
|
||
|
||
RtlCopyMemory(
|
||
&deviceExtension->StorageManagerName[0],
|
||
L"LogiDisk",
|
||
8 * sizeof(WCHAR));
|
||
if (NT_SUCCESS(status))
|
||
deviceExtension->DiskNumber = volumeNumber.VolumeNumber;
|
||
}
|
||
else {
|
||
RtlCopyMemory(
|
||
&deviceExtension->StorageManagerName[0],
|
||
&volumeNumber.VolumeManagerName[0],
|
||
8 * sizeof(WCHAR));
|
||
deviceExtension->DiskNumber = volumeNumber.VolumeNumber;
|
||
}
|
||
DebugPrint((3, "DiskPerfRegisterDevice: Device name %ws\n",
|
||
deviceExtension->PhysicalDeviceNameBuffer));
|
||
}
|
||
|
||
status = IoWMIRegistrationControl(DeviceObject,
|
||
WMIREG_ACTION_REGISTER | registrationFlag );
|
||
if (! NT_SUCCESS(status)) {
|
||
DiskPerfLogError(
|
||
DeviceObject,
|
||
261,
|
||
STATUS_SUCCESS,
|
||
IO_ERR_INTERNAL_ERROR);
|
||
}
|
||
return status;
|
||
}
|
||
|
||
|
||
VOID
|
||
DiskPerfLogError(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN ULONG UniqueId,
|
||
IN NTSTATUS ErrorCode,
|
||
IN NTSTATUS Status
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Routine to log an error with the Error Logger
|
||
|
||
Arguments:
|
||
|
||
DeviceObject - the device object responsible for the error
|
||
UniqueId - an id for the error
|
||
Status - the status of the error
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
PIO_ERROR_LOG_PACKET errorLogEntry;
|
||
|
||
errorLogEntry = (PIO_ERROR_LOG_PACKET)
|
||
IoAllocateErrorLogEntry(
|
||
DeviceObject,
|
||
(UCHAR)(sizeof(IO_ERROR_LOG_PACKET) + sizeof(DEVICE_OBJECT))
|
||
);
|
||
|
||
if (errorLogEntry != NULL) {
|
||
errorLogEntry->ErrorCode = ErrorCode;
|
||
errorLogEntry->UniqueErrorValue = UniqueId;
|
||
errorLogEntry->FinalStatus = Status;
|
||
//
|
||
// The following is necessary because DumpData is of type ULONG
|
||
// and DeviceObject can be more than that
|
||
//
|
||
RtlCopyMemory(
|
||
&errorLogEntry->DumpData[0],
|
||
&DeviceObject,
|
||
sizeof(DEVICE_OBJECT));
|
||
errorLogEntry->DumpDataSize = sizeof(DEVICE_OBJECT);
|
||
IoWriteErrorLogEntry(errorLogEntry);
|
||
}
|
||
}
|
||
|
||
NTSTATUS
|
||
DiskperfQueryWmiRegInfo(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
OUT ULONG *RegFlags,
|
||
OUT PUNICODE_STRING InstanceName,
|
||
OUT PUNICODE_STRING *RegistryPath,
|
||
OUT PUNICODE_STRING MofResourceName,
|
||
OUT PDEVICE_OBJECT *Pdo
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is a callback into the driver to retrieve information about
|
||
the guids being registered.
|
||
|
||
Implementations of this routine may be in paged memory
|
||
|
||
Arguments:
|
||
|
||
DeviceObject is the device whose registration information is needed
|
||
|
||
*RegFlags returns with a set of flags that describe all of the guids being
|
||
registered for this device. If the device wants enable and disable
|
||
collection callbacks before receiving queries for the registered
|
||
guids then it should return the WMIREG_FLAG_EXPENSIVE flag. Also the
|
||
returned flags may specify WMIREG_FLAG_INSTANCE_PDO in which case
|
||
the instance name is determined from the PDO associated with the
|
||
device object. Note that the PDO must have an associated devnode. If
|
||
WMIREG_FLAG_INSTANCE_PDO is not set then Name must return a unique
|
||
name for the device. These flags are ORed into the flags specified
|
||
by the GUIDREGINFO for each guid.
|
||
|
||
InstanceName returns with the instance name for the guids if
|
||
WMIREG_FLAG_INSTANCE_PDO is not set in the returned *RegFlags. The
|
||
caller will call ExFreePool with the buffer returned.
|
||
|
||
*RegistryPath returns with the registry path of the driver. This is
|
||
required
|
||
|
||
MofResourceName returns with the name of the MOF resource attached to
|
||
the binary file. If the driver does not have a mof resource attached
|
||
then this can be returned unmodified. If a value is returned then
|
||
it is NOT freed.
|
||
|
||
*Pdo returns with the device object for the PDO associated with this
|
||
device if the WMIREG_FLAG_INSTANCE_PDO flag is retured in
|
||
*RegFlags.
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
USHORT size;
|
||
NTSTATUS status;
|
||
PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
PAGED_CODE();
|
||
|
||
size = deviceExtension->PhysicalDeviceName.Length + sizeof(UNICODE_NULL);
|
||
|
||
InstanceName->Buffer = ExAllocatePool(PagedPool,
|
||
size);
|
||
if (InstanceName->Buffer != NULL)
|
||
{
|
||
*RegistryPath = &DiskPerfRegistryPath;
|
||
|
||
*RegFlags = WMIREG_FLAG_INSTANCE_PDO | WMIREG_FLAG_EXPENSIVE;
|
||
*Pdo = deviceExtension->PhysicalDeviceObject;
|
||
status = STATUS_SUCCESS;
|
||
} else {
|
||
status = STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
return(status);
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
DiskperfQueryWmiDataBlock(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN ULONG GuidIndex,
|
||
IN ULONG InstanceIndex,
|
||
IN ULONG InstanceCount,
|
||
IN OUT PULONG InstanceLengthArray,
|
||
IN ULONG BufferAvail,
|
||
OUT PUCHAR Buffer
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is a callback into the driver to query for the contents of
|
||
all instances of a data block. When the driver has finished filling the
|
||
data block it must call WmiCompleteRequest to complete the irp. The
|
||
driver can return STATUS_PENDING if the irp cannot be completed
|
||
immediately.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject is the device whose data block is being queried
|
||
|
||
Irp is the Irp that makes this request
|
||
|
||
GuidIndex is the index into the list of guids provided when the
|
||
device registered
|
||
|
||
InstanceCount is the number of instnaces expected to be returned for
|
||
the data block.
|
||
|
||
InstanceLengthArray is a pointer to an array of ULONG that returns the
|
||
lengths of each instance of the data block. If this is NULL then
|
||
there was not enough space in the output buffer to fufill the request
|
||
so the irp should be completed with the buffer needed.
|
||
|
||
BufferAvail on entry has the maximum size available to write the data
|
||
blocks.
|
||
|
||
Buffer on return is filled with the returned data blocks. Note that each
|
||
instance of the data block must be aligned on a 8 byte boundry.
|
||
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
ULONG sizeNeeded;
|
||
KIRQL currentIrql;
|
||
PDISK_PERFORMANCE totalCounters;
|
||
PDISK_PERFORMANCE diskCounters;
|
||
PWMI_DISK_PERFORMANCE diskPerformance;
|
||
ULONG deviceNameSize;
|
||
PWCHAR diskNamePtr;
|
||
|
||
PAGED_CODE();
|
||
|
||
deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
if (GuidIndex == 0)
|
||
{
|
||
deviceNameSize = deviceExtension->PhysicalDeviceName.Length +
|
||
sizeof(USHORT);
|
||
sizeNeeded = ((sizeof(WMI_DISK_PERFORMANCE) + 1) & ~1) +
|
||
deviceNameSize;
|
||
diskCounters = deviceExtension->DiskCounters;
|
||
if (diskCounters == NULL)
|
||
{
|
||
status = STATUS_UNSUCCESSFUL;
|
||
}
|
||
else if (BufferAvail >= sizeNeeded)
|
||
{
|
||
//
|
||
// Update idle time if disk has been idle
|
||
//
|
||
ULONG i;
|
||
LARGE_INTEGER perfctr, frequency;
|
||
|
||
RtlZeroMemory(Buffer, sizeof(WMI_DISK_PERFORMANCE));
|
||
diskPerformance = (PWMI_DISK_PERFORMANCE)Buffer;
|
||
|
||
totalCounters = (PDISK_PERFORMANCE)diskPerformance;
|
||
KeQuerySystemTime(&totalCounters->QueryTime);
|
||
|
||
#ifdef USE_PERF_CTR
|
||
perfctr = KeQueryPerformanceCounter(&frequency);
|
||
#endif
|
||
for (i=0; i<deviceExtension->Processors; i++) {
|
||
DiskPerfAddCounters( totalCounters, diskCounters, frequency);
|
||
DebugPrint((11,
|
||
"DiskPerfQueryWmiDataBlock: R%d %I64u W%d%I64u ", i,
|
||
diskCounters->ReadTime, diskCounters->WriteTime));
|
||
diskCounters = (PDISK_PERFORMANCE)
|
||
((PCHAR)diskCounters + PROCESSOR_COUNTERS_SIZE);
|
||
}
|
||
DebugPrint((11, "\n"));
|
||
totalCounters->QueueDepth = deviceExtension->QueueDepth;
|
||
|
||
DebugPrint((9,
|
||
"QueryWmiDataBlock: Dev %X RT %I64u WT %I64u Rds %d Wts %d freq %I64u\n",
|
||
totalCounters,
|
||
totalCounters->ReadTime, totalCounters->WriteTime,
|
||
totalCounters->ReadCount, totalCounters->WriteCount,
|
||
frequency));
|
||
|
||
if (totalCounters->QueueDepth == 0) {
|
||
LARGE_INTEGER difference;
|
||
|
||
difference.QuadPart
|
||
#ifdef USE_PERF_CTR
|
||
= perfctr.QuadPart -
|
||
#else
|
||
= totalCounters->QueryTime.QuadPart -
|
||
#endif
|
||
deviceExtension->LastIdleClock.QuadPart;
|
||
if (frequency.QuadPart > 0) {
|
||
totalCounters->IdleTime.QuadPart +=
|
||
#ifdef USE_PERF_CTR
|
||
10000000 * difference.QuadPart / frequency.QuadPart;
|
||
#else
|
||
difference.QuadPart;
|
||
#endif
|
||
}
|
||
}
|
||
|
||
totalCounters->StorageDeviceNumber
|
||
= deviceExtension->DiskNumber;
|
||
RtlCopyMemory(
|
||
&totalCounters->StorageManagerName[0],
|
||
&deviceExtension->StorageManagerName[0],
|
||
8 * sizeof(WCHAR));
|
||
|
||
diskNamePtr = (PWCHAR)(Buffer +
|
||
((sizeof(DISK_PERFORMANCE) + 1) & ~1));
|
||
*diskNamePtr++ = deviceExtension->PhysicalDeviceName.Length;
|
||
RtlCopyMemory(diskNamePtr,
|
||
deviceExtension->PhysicalDeviceName.Buffer,
|
||
deviceExtension->PhysicalDeviceName.Length);
|
||
*InstanceLengthArray = sizeNeeded;
|
||
|
||
status = STATUS_SUCCESS;
|
||
} else {
|
||
status = STATUS_BUFFER_TOO_SMALL;
|
||
}
|
||
|
||
} else {
|
||
status = STATUS_WMI_GUID_NOT_FOUND;
|
||
sizeNeeded = 0;
|
||
}
|
||
|
||
status = WmiCompleteRequest(
|
||
DeviceObject,
|
||
Irp,
|
||
status,
|
||
sizeNeeded,
|
||
IO_NO_INCREMENT);
|
||
return(status);
|
||
}
|
||
|
||
|
||
NTSTATUS
|
||
DiskperfWmiFunctionControl(
|
||
IN PDEVICE_OBJECT DeviceObject,
|
||
IN PIRP Irp,
|
||
IN ULONG GuidIndex,
|
||
IN WMIENABLEDISABLECONTROL Function,
|
||
IN BOOLEAN Enable
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is a callback into the driver to query for enabling or
|
||
disabling events and data collection. When the driver has finished it
|
||
must call WmiCompleteRequest to complete the irp. The driver can return
|
||
STATUS_PENDING if the irp cannot be completed immediately.
|
||
|
||
Arguments:
|
||
|
||
DeviceObject is the device whose events or data collection are being
|
||
enabled or disabled
|
||
|
||
Irp is the Irp that makes this request
|
||
|
||
GuidIndex is the index into the list of guids provided when the
|
||
device registered
|
||
|
||
Function differentiates between event and data collection operations
|
||
|
||
Enable indicates whether to enable or disable
|
||
|
||
|
||
Return Value:
|
||
|
||
status
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
PDEVICE_EXTENSION deviceExtension;
|
||
ULONG i;
|
||
|
||
deviceExtension = DeviceObject->DeviceExtension;
|
||
|
||
if (GuidIndex == 0)
|
||
{
|
||
if (Function == WmiDataBlockControl) {
|
||
if (Enable) {
|
||
if (InterlockedIncrement(&deviceExtension->CountersEnabled) == 1) {
|
||
//
|
||
// Reset per processor counters to 0
|
||
//
|
||
if (deviceExtension->DiskCounters != NULL) {
|
||
RtlZeroMemory(
|
||
deviceExtension->DiskCounters,
|
||
PROCESSOR_COUNTERS_SIZE * deviceExtension->Processors);
|
||
}
|
||
DiskPerfGetClock(deviceExtension->LastIdleClock, NULL);
|
||
DebugPrint((10,
|
||
"DiskPerfWmiFunctionControl: LIC=%I64u\n",
|
||
deviceExtension->LastIdleClock));
|
||
deviceExtension->QueueDepth = 0;
|
||
DebugPrint((3, "DiskPerfWmi: Counters enabled %d\n",
|
||
deviceExtension->CountersEnabled));
|
||
}
|
||
} else {
|
||
if (InterlockedDecrement(&deviceExtension->CountersEnabled)
|
||
<= 0) {
|
||
deviceExtension->CountersEnabled = 0;
|
||
deviceExtension->QueueDepth = 0;
|
||
DebugPrint((3, "DiskPerfWmi: Counters disabled %d\n",
|
||
deviceExtension->CountersEnabled));
|
||
}
|
||
}
|
||
}
|
||
status = STATUS_SUCCESS;
|
||
} else {
|
||
status = STATUS_WMI_GUID_NOT_FOUND;
|
||
}
|
||
|
||
status = WmiCompleteRequest(
|
||
DeviceObject,
|
||
Irp,
|
||
status,
|
||
0,
|
||
IO_NO_INCREMENT);
|
||
return(status);
|
||
}
|
||
|
||
|
||
VOID
|
||
DiskPerfAddCounters(
|
||
IN OUT PDISK_PERFORMANCE TotalCounters,
|
||
IN PDISK_PERFORMANCE NewCounters,
|
||
IN LARGE_INTEGER Frequency
|
||
)
|
||
{
|
||
TotalCounters->BytesRead.QuadPart += NewCounters->BytesRead.QuadPart;
|
||
TotalCounters->BytesWritten.QuadPart+= NewCounters->BytesWritten.QuadPart;
|
||
TotalCounters->ReadCount += NewCounters->ReadCount;
|
||
TotalCounters->WriteCount += NewCounters->WriteCount;
|
||
TotalCounters->SplitCount += NewCounters->SplitCount;
|
||
#ifdef USE_PERF_CTR
|
||
if (Frequency.QuadPart > 0) {
|
||
TotalCounters->ReadTime.QuadPart +=
|
||
NewCounters->ReadTime.QuadPart * 10000000 / Frequency.QuadPart;
|
||
TotalCounters->WriteTime.QuadPart +=
|
||
NewCounters->WriteTime.QuadPart * 10000000 / Frequency.QuadPart;
|
||
TotalCounters->IdleTime.QuadPart +=
|
||
NewCounters->IdleTime.QuadPart * 10000000 / Frequency.QuadPart;
|
||
}
|
||
else
|
||
#endif
|
||
{
|
||
TotalCounters->ReadTime.QuadPart += NewCounters->ReadTime.QuadPart;
|
||
TotalCounters->WriteTime.QuadPart += NewCounters->WriteTime.QuadPart;
|
||
TotalCounters->IdleTime.QuadPart += NewCounters->IdleTime.QuadPart;
|
||
}
|
||
}
|
||
|
||
#if DBG
|
||
|
||
VOID
|
||
DiskPerfDebugPrint(
|
||
ULONG DebugPrintLevel,
|
||
PCCHAR DebugMessage,
|
||
...
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Debug print for all DiskPerf
|
||
|
||
Arguments:
|
||
|
||
Debug print level between 0 and 3, with 3 being the most verbose.
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
va_list ap;
|
||
|
||
va_start(ap, DebugMessage);
|
||
|
||
|
||
if ((DebugPrintLevel <= (DiskPerfDebug & 0x0000ffff)) ||
|
||
((1 << (DebugPrintLevel + 15)) & DiskPerfDebug)) {
|
||
|
||
DbgPrint(DebugMessage, ap);
|
||
}
|
||
|
||
va_end(ap);
|
||
|
||
}
|
||
#endif
|