pnp.c

虚拟Scsi Disk源程序 版权归原作者

						RtlStringCchPrintfW(pInformation,size,L"%ws", BUS_DEVICETEXT);

						Irp->IoStatus.Information = (ULONG_PTR)pInformation;
						status = STATUS_SUCCESS;
					}
					else
					{
						status = STATUS_INSUFFICIENT_RESOURCES;
					}

				}
				else
				{
					status = Irp->IoStatus.Status;
				}
				break;
			default:
				status = Irp->IoStatus.Status;
				break;
			}
		}
		break;

    case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    case IRP_MN_READ_CONFIG:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    case IRP_MN_WRITE_CONFIG:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    case IRP_MN_EJECT:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    case IRP_MN_SET_LOCK:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    case IRP_MN_QUERY_ID:
/*      IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;*/
		{
            PIO_STACK_LOCATION  irpStack = IoGetCurrentIrpStackLocation(Irp);
		    if(irpStack==NULL)
                break;
			if (Irp->IoStatus.Information != (ULONG_PTR)NULL)
			{
				status = Irp->IoStatus.Status;
				break;
			}
			else
			{
				PWCHAR pInformation;
				switch(irpStack->Parameters.QueryId.IdType)
				{
				case BusQueryInstanceID:
					{
						pInformation=(PWCHAR)ExAllocatePoolWithTag(
										PagedPool,
										12,
										VSCSIDISK_POOL_TAG
										);
						if(!pInformation) 
						{
							status = STATUS_INSUFFICIENT_RESOURCES;
							break;
						}
						RtlZeroMemory(pInformation, 12);

						RtlStringCchPrintfW(pInformation,12,L"%04d", 0);

						Irp->IoStatus.Information = (ULONG_PTR)pInformation;
						status = STATUS_SUCCESS;
					}
					break;

				case BusQueryDeviceID:
					{
						int size=sizeof(BUS_DEVICE_ID);
						pInformation=(PWCHAR)ExAllocatePoolWithTag(
										PagedPool,
										size,
										VSCSIDISK_POOL_TAG
										);
						if(!pInformation) 
						{
							status = STATUS_INSUFFICIENT_RESOURCES;
							break;
						}

						RtlZeroMemory(pInformation, size);
						RtlCopyMemory(pInformation,BUS_DEVICE_ID,size);
						Irp->IoStatus.Information = (ULONG_PTR)pInformation;
						status = STATUS_SUCCESS;
					}
					break;

				case BusQueryHardwareIDs:
					{
						int size=sizeof(BUS_HARDWARE_ID);
						pInformation=(PWCHAR)ExAllocatePoolWithTag(
										PagedPool,
										size,
										VSCSIDISK_POOL_TAG
										);
						if(!pInformation) 
						{
							status = STATUS_INSUFFICIENT_RESOURCES;
							break;
						}

						RtlZeroMemory(pInformation, size);
						RtlCopyMemory(pInformation,BUS_HARDWARE_ID,size);
						Irp->IoStatus.Information = (ULONG_PTR)pInformation;
						status = STATUS_SUCCESS;
					}
					break;

				case BusQueryCompatibleIDs:
					{
						int size=sizeof(BUS_COMPATIBLE_ID);
						pInformation=(PWCHAR)ExAllocatePoolWithTag(
										PagedPool,
										size,
										VSCSIDISK_POOL_TAG
										);
						if(!pInformation) 
						{
							status = STATUS_INSUFFICIENT_RESOURCES;
							break;
						}

						RtlZeroMemory(pInformation, size);
						RtlCopyMemory(pInformation,BUS_COMPATIBLE_ID,size);
						Irp->IoStatus.Information = (ULONG_PTR)pInformation;
						status = STATUS_SUCCESS;
					}
					break;
				}//end of switch(irpStack->Parameters.QueryId.IdType)
			}//end of if (Irp->IoStatus.Information != (ULONG_PTR)NULL) else
		}
		break;


    case IRP_MN_QUERY_BUS_INFORMATION:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    case IRP_MN_DEVICE_USAGE_NOTIFICATION:
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;

    default:
        // Pass down any unknown requests.
        IoSkipCurrentIrpStackLocation(Irp);
        status = IoCallDriver(deviceExtension->LowerDeviceObject, Irp);

        // Adjust our active I/O count
        VScsiDiskReleaseRemoveLock(deviceExtension);

        VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

        return status;
    }

    Irp->IoStatus.Status = status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);

    // Adjust the active I/O count
    VScsiDiskReleaseRemoveLock(deviceExtension);

    VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. IRP %p STATUS %x", Irp, status);

    return status;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  VScsiDiskGetDeviceCapabilities
//      Gets device capabilities structure from a bus driver
//
//  Arguments:
//      IN  DeviceExtension
//              our device extension
//
//  Return Value:
//      NT status code
//
NTSTATUS VScsiDiskGetDeviceCapabilities(
    IN  PVSCSIDISK_DEVICE_EXTENSION    DeviceExtension
    )
{
    NTSTATUS            status;
    PDEVICE_OBJECT      targetDeviceObject;
    PIRP                irp;
    KEVENT              event;
    IO_STATUS_BLOCK     ioStatus;
    PIO_STACK_LOCATION  irpStack;

    VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"++");

    // initialize device capabilities structure
    RtlZeroMemory(&DeviceExtension->DeviceCaps, sizeof(DEVICE_CAPABILITIES));
    DeviceExtension->DeviceCaps.Size = sizeof(DEVICE_CAPABILITIES);
    DeviceExtension->DeviceCaps.Version = 1;
    DeviceExtension->DeviceCaps.UINumber = -1;
    DeviceExtension->DeviceCaps.Address = -1;

    targetDeviceObject = IoGetAttachedDeviceReference(DeviceExtension->DeviceObject);

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildSynchronousFsdRequest(
                IRP_MJ_PNP,
                targetDeviceObject,
                NULL,
                0,
                NULL,
                &event,
                &ioStatus
                );

    if (irp != NULL)
    {
        irpStack = IoGetNextIrpStackLocation(irp);

        irpStack->MajorFunction = IRP_MJ_PNP;
        irpStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
        irpStack->Parameters.DeviceCapabilities.Capabilities = &DeviceExtension->DeviceCaps;

        irp->IoStatus.Status = STATUS_NOT_SUPPORTED;

        status = IoCallDriver(targetDeviceObject, irp);
        if (status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
            status = ioStatus.Status;
        }
    }
    else
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    ObDereferenceObject(targetDeviceObject);

    VScsiDiskDebugPrint(DBG_PNP, DBG_TRACE, __FUNCTION__"--. STATUS %x", status);

    return status;
}