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.
555 lines
15 KiB
555 lines
15 KiB
/*++
|
|
Copyright (C) Microsoft Corporation, 1999
|
|
|
|
Module Name:
|
|
|
|
mcdwmi.c
|
|
|
|
Abstract:
|
|
|
|
This is the changer class driver - WMI support routines.
|
|
|
|
Environment:
|
|
|
|
kernel mode only
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "mchgr.h"
|
|
|
|
//
|
|
// Internal routines
|
|
//
|
|
NTSTATUS
|
|
ChangerWMIGetParameters(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
OUT PGET_CHANGER_PARAMETERS changerParameters
|
|
);
|
|
|
|
//
|
|
// List of WMI GUIDs
|
|
//
|
|
GUIDREGINFO ChangerWmiFdoGuidList[] =
|
|
{
|
|
{
|
|
WMI_CHANGER_PARAMETERS_GUID,
|
|
1,
|
|
0
|
|
},
|
|
|
|
{
|
|
WMI_CHANGER_PROBLEM_WARNING_GUID,
|
|
1,
|
|
WMIREG_FLAG_EVENT_ONLY_GUID
|
|
},
|
|
|
|
{
|
|
WMI_CHANGER_PROBLEM_DEVICE_ERROR_GUID,
|
|
1,
|
|
WMIREG_FLAG_EXPENSIVE
|
|
},
|
|
};
|
|
|
|
GUID ChangerDriveProblemEventGuid = WMI_CHANGER_PROBLEM_WARNING_GUID;
|
|
|
|
//
|
|
// GUID index. It should match the list defined above
|
|
//
|
|
#define ChangerParametersGuid 0
|
|
#define ChangerProblemWarningGuid 1
|
|
#define ChangerProblemDevErrorGuid 2
|
|
|
|
//
|
|
// ISSUE: 02/29/2000 - nramas : Should make wmi routines pagable
|
|
//
|
|
/*
|
|
#ifdef ALLOC_PRAGMA
|
|
|
|
#pragma alloc_text(PAGE,
|
|
|
|
#endif
|
|
*/
|
|
|
|
NTSTATUS
|
|
ChangerFdoQueryWmiRegInfo(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
OUT ULONG *RegFlags,
|
|
OUT PUNICODE_STRING InstanceName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback into the driver to retrieve the list of
|
|
guids or data blocks that the driver wants to register with WMI. This
|
|
routine may not pend or block. Driver should NOT call
|
|
ClassWmiCompleteRequest.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject is the device whose data block is being queried
|
|
|
|
*RegFlags returns with a set of flags that describe 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.
|
|
|
|
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.
|
|
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Use devnode for FDOs
|
|
//
|
|
*RegFlags = WMIREG_FLAG_INSTANCE_PDO;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
ChangerFdoQueryWmiDataBlock(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN ULONG GuidIndex,
|
|
IN ULONG BufferAvail,
|
|
OUT PUCHAR Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback into the driver to query for the contents of
|
|
a data block. When the driver has finished filling the data block it
|
|
must call ClassWmiCompleteRequest 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
|
|
|
|
BufferAvail on has the maximum size available to write the data
|
|
block.
|
|
|
|
Buffer on return is filled with the returned data block
|
|
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
|
|
PMCD_INIT_DATA mcdInitData;
|
|
ULONG sizeNeeded = 0;
|
|
|
|
switch (GuidIndex) {
|
|
case ChangerParametersGuid: {
|
|
GET_CHANGER_PARAMETERS changerParameters;
|
|
PWMI_CHANGER_PARAMETERS outBuffer;
|
|
|
|
sizeNeeded = sizeof(WMI_CHANGER_PARAMETERS);
|
|
if (BufferAvail < sizeNeeded) {
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
break;
|
|
}
|
|
|
|
status = ChangerWMIGetParameters(DeviceObject,
|
|
&changerParameters);
|
|
if (NT_SUCCESS(status)) {
|
|
outBuffer = (PWMI_CHANGER_PARAMETERS)Buffer;
|
|
outBuffer->NumberOfSlots = changerParameters.NumberStorageElements;
|
|
outBuffer->NumberOfDrives = changerParameters.NumberDataTransferElements;
|
|
outBuffer->NumberOfIEPorts = changerParameters.NumberIEElements;
|
|
outBuffer->NumberOfTransports = changerParameters.NumberTransportElements;
|
|
outBuffer->NumberOfDoors = changerParameters.NumberOfDoors;
|
|
outBuffer->MagazineSize = changerParameters.MagazineSize;
|
|
outBuffer->NumberOfCleanerSlots = changerParameters.NumberCleanerSlots;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case ChangerProblemDevErrorGuid: {
|
|
PWMI_CHANGER_PROBLEM_DEVICE_ERROR changerDeviceError;
|
|
|
|
mcdInitData = IoGetDriverObjectExtension(DeviceObject->DriverObject,
|
|
ChangerClassInitialize);
|
|
|
|
if (mcdInitData == NULL) {
|
|
status = STATUS_NO_SUCH_DEVICE;
|
|
break;
|
|
}
|
|
|
|
if (!(mcdInitData->ChangerPerformDiagnostics)) {
|
|
status = STATUS_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
sizeNeeded = sizeof(WMI_CHANGER_PROBLEM_DEVICE_ERROR);
|
|
if (BufferAvail < sizeNeeded) {
|
|
status = STATUS_BUFFER_TOO_SMALL;
|
|
break;
|
|
}
|
|
|
|
changerDeviceError = (PWMI_CHANGER_PROBLEM_DEVICE_ERROR)Buffer;
|
|
RtlZeroMemory(changerDeviceError,
|
|
sizeof(WMI_CHANGER_PROBLEM_DEVICE_ERROR));
|
|
status = mcdInitData->ChangerPerformDiagnostics(DeviceObject,
|
|
changerDeviceError);
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
sizeNeeded = 0;
|
|
status = STATUS_WMI_GUID_NOT_FOUND;
|
|
break;
|
|
}
|
|
} // switch (GuidIndex)
|
|
|
|
status = ClassWmiCompleteRequest(DeviceObject,
|
|
Irp,
|
|
status,
|
|
sizeNeeded,
|
|
IO_NO_INCREMENT);
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ChangerWMIGetParameters(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
OUT PGET_CHANGER_PARAMETERS changerParameters
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
Sends the IOCTL to get the changer parameters
|
|
|
|
Arguments :
|
|
|
|
DeviceObject The changer device objcet
|
|
ChangerParameters buffer in which the changer parameters is returned.
|
|
|
|
Return value:
|
|
|
|
NT Status.
|
|
--*/
|
|
{
|
|
KEVENT event;
|
|
PDEVICE_OBJECT topOfStack;
|
|
PIRP irp = NULL;
|
|
IO_STATUS_BLOCK ioStatus;
|
|
NTSTATUS status;
|
|
|
|
KeInitializeEvent(&event, SynchronizationEvent, FALSE);
|
|
|
|
topOfStack = IoGetAttachedDeviceReference(DeviceObject);
|
|
|
|
//
|
|
// Send down irp to get the changer parameters
|
|
//
|
|
irp = IoBuildDeviceIoControlRequest(
|
|
IOCTL_CHANGER_GET_PARAMETERS,
|
|
topOfStack,
|
|
NULL,
|
|
0,
|
|
changerParameters,
|
|
sizeof(GET_CHANGER_PARAMETERS),
|
|
FALSE,
|
|
&event,
|
|
&ioStatus);
|
|
if (irp != NULL) {
|
|
status = IoCallDriver(topOfStack, irp);
|
|
if (status == STATUS_PENDING) {
|
|
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
|
|
status = ioStatus.Status;
|
|
}
|
|
} else {
|
|
status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
ObDereferenceObject(topOfStack);
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ChangerWmiFunctionControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN ULONG GuidIndex,
|
|
IN CLASSENABLEDISABLEFUNCTION Function,
|
|
IN BOOLEAN Enable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback into the driver to enabled or disable event
|
|
generation or data block collection. A device should only expect a
|
|
single enable when the first event or data consumer enables events or
|
|
data collection and a single disable when the last event or data
|
|
consumer disables events or data collection. Data blocks will only
|
|
receive collection enable/disable if they were registered as requiring
|
|
it.
|
|
|
|
This function can be used to enable\disable datablock collection.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject is the device whose data block is being queried
|
|
|
|
GuidIndex is the index into the list of guids provided when the
|
|
device registered
|
|
|
|
Function specifies which functionality is being enabled or disabled
|
|
|
|
Enable is TRUE then the function is being enabled else disabled
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
if (Function == DataBlockCollection) {
|
|
DebugPrint((3,
|
|
"ChangerWmiFunctionControl : Irp %p - %s DataBlockCollection",
|
|
" for Device %p.\n",
|
|
Irp, Enable ? "Enable " : "Disable ", DeviceObject));
|
|
status = STATUS_SUCCESS;
|
|
} else {
|
|
//
|
|
// ISSUE: 03/01/2000 - nramas
|
|
// Need to handle EventGeneration. But now we don't do polling
|
|
// of the changers to detect failure. So, for now disallow
|
|
// EventGeneration
|
|
//
|
|
DebugPrint((1,
|
|
"ChangerWmiFunctionControl : Unknown function %d for ",
|
|
"Device %p, Irp %p\n",
|
|
Function, DeviceObject, Irp));
|
|
|
|
status = STATUS_INVALID_DEVICE_REQUEST;
|
|
}
|
|
|
|
status = ClassWmiCompleteRequest(DeviceObject,
|
|
Irp,
|
|
status,
|
|
0,
|
|
IO_NO_INCREMENT);
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ChangerFdoExecuteWmiMethod(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN ULONG GuidIndex,
|
|
IN ULONG MethodId,
|
|
IN ULONG InBufferSize,
|
|
IN ULONG OutBufferSize,
|
|
IN PUCHAR Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback into the driver to execute a method. When the
|
|
driver has finished filling the data block it must call
|
|
ClassWmiCompleteRequest 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
|
|
|
|
MethodId has the id of the method being called
|
|
|
|
InBufferSize has the size of the data block passed in as the input to
|
|
the method.
|
|
|
|
OutBufferSize on entry has the maximum size available to write the
|
|
returned data block.
|
|
|
|
Buffer is filled with the returned data block
|
|
|
|
|
|
Return Value:
|
|
|
|
status
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
|
|
|
|
DebugPrint((3,
|
|
"ChangerFdoExecuteMethod : Device %p, Irp %p, ",
|
|
"GuidIndex %d\n",
|
|
DeviceObject, Irp, GuidIndex));
|
|
|
|
if (GuidIndex > ChangerProblemDevErrorGuid) {
|
|
status = STATUS_WMI_GUID_NOT_FOUND;
|
|
}
|
|
|
|
status = ClassWmiCompleteRequest(DeviceObject,
|
|
Irp,
|
|
status,
|
|
0,
|
|
IO_NO_INCREMENT);
|
|
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ChangerFdoSetWmiDataBlock(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN ULONG GuidIndex,
|
|
IN ULONG BufferSize,
|
|
IN PUCHAR Buffer
|
|
)
|
|
/*+
|
|
|
|
Routine Description :
|
|
|
|
This routine is called to set the contents of a datablock.
|
|
When the driver is finished setting the buffer, it must call
|
|
ClassWmiCompleteRequest to complete the irp. The driver can
|
|
return STATUS_PENDING if the irp cannot be completed immediately.
|
|
|
|
Arguments :
|
|
|
|
Device object of the device being referred.
|
|
|
|
Irp is the WMI Irp
|
|
|
|
GuidIndex is the index of the guid for which the data is being set
|
|
|
|
BufferSize is the size of the data block
|
|
|
|
Buffer is the pointer to the data block
|
|
|
|
Return valus :
|
|
|
|
NTSTATUS returned by ClassWmiCompleteRequest
|
|
STATUS_WMI_READ_ONLY if the datablock cannot be modified.
|
|
STATUS_WMI_GUID_NOT_FOUND if an invalid guid index is passed
|
|
-*/
|
|
{
|
|
NTSTATUS status = STATUS_WMI_READ_ONLY;
|
|
|
|
DebugPrint((3,
|
|
"ChangerWmiSetBlock : Device %p, Irp %p, ",
|
|
"GuidIndex %d\n",
|
|
DeviceObject, Irp, GuidIndex));
|
|
|
|
if (GuidIndex > ChangerProblemDevErrorGuid) {
|
|
status = STATUS_WMI_GUID_NOT_FOUND;
|
|
}
|
|
|
|
status = ClassWmiCompleteRequest(DeviceObject,
|
|
Irp,
|
|
status,
|
|
0,
|
|
IO_NO_INCREMENT);
|
|
|
|
DebugPrint((3, "ChangerSetWmiDataBlock : Device %p, Irp %p, returns %x\n",
|
|
DeviceObject, Irp, status));
|
|
return status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ChangerFdoSetWmiDataItem(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN ULONG GuidIndex,
|
|
IN ULONG DataItemId,
|
|
IN ULONG BufferSize,
|
|
IN PUCHAR Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is a callback into the driver to query for the contents of
|
|
a data block. When the driver has finished filling the data block it
|
|
must call ClassWmiCompleteRequest 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
|
|
|
|
DataItemId has the id of the data item being set
|
|
|
|
BufferSize has the size of the data item passed
|
|
|
|
Buffer has the new values for the data item
|
|
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS returned by ClassWmiCompleteRequest
|
|
STATUS_WMI_READ_ONLY if the datablock cannot be modified.
|
|
STATUS_WMI_GUID_NOT_FOUND if an invalid guid index is passed
|
|
|
|
-*/
|
|
{
|
|
NTSTATUS status = STATUS_WMI_READ_ONLY;
|
|
|
|
DebugPrint((3,
|
|
"TapeSetWmiDataItem, Device %p, Irp %p, GuiIndex %d",
|
|
" BufferSize %#x Buffer %p\n",
|
|
DeviceObject, Irp,
|
|
GuidIndex, DataItemId,
|
|
BufferSize, Buffer));
|
|
|
|
if (GuidIndex > ChangerProblemDevErrorGuid) {
|
|
status = STATUS_WMI_GUID_NOT_FOUND;
|
|
}
|
|
|
|
status = ClassWmiCompleteRequest(DeviceObject,
|
|
Irp,
|
|
status,
|
|
0,
|
|
IO_NO_INCREMENT);
|
|
|
|
DebugPrint((3, "TapeSetWmiDataItem Device %p, Irp %p returns %lx\n",
|
|
DeviceObject, Irp, status));
|
|
|
|
return status;
|
|
}
|
|
|