csqtest.c

Go to the documentation of this file.

/*
 * CSQ Test Driver
 * Copyright (c) 2004, Vizzini (vizzini@plasmic.com)
 * Released under the GNU GPL for the ReactOS project
 *
 * This driver is designed to exercise the cancel-safe IRP queue logic.
 * Please refer to reactos/include/ddk/csq.h and reactos/drivers/lib/csq.
 */
#include <ntddk.h>
#include <csq.h>
 
/* XXX shortcomings in our headers... */
#define assert(x)
#ifndef KdPrint
#define KdPrint(x) DbgPrint x
#endif
 
/* Device name */
#define NT_DEVICE_NAME L"\\Device\\csqtest"
 
/* DosDevices name */
#define DOS_DEVICE_NAME L"\\??\\csqtest"
 
/* Global CSQ struct that the CSQ functions init */
IO_CSQ Csq;
 
/* List and lock for the actual IRP queue */
LIST_ENTRY IrpQueue;
KSPIN_LOCK IrpQueueLock;
 
/* Device object */
PDEVICE_OBJECT DeviceObject;
 
/*
 * CSQ Callbacks
 */
VOID NTAPI CsqInsertIrp(PIO_CSQ Csq, PIRP Irp)
{
    KdPrint(("Inserting IRP 0x%x into CSQ\n", Irp));
    InsertTailList(&IrpQueue, &Irp->Tail.Overlay.ListEntry);
}
 
VOID NTAPI CsqRemoveIrp(PIO_CSQ Csq, PIRP Irp)
{
    KdPrint(("Removing IRP 0x%x from CSQ\n", Irp));
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}
 
PIRP NTAPI CsqPeekNextIrp(PIO_CSQ Csq, PIRP Irp, PVOID PeekContext)
{
    KdPrint(("Peeking for next IRP\n"));
 
    if(Irp)
        return CONTAINING_RECORD(&Irp->Tail.Overlay.ListEntry.Flink, IRP, Tail.Overlay.ListEntry);
 
    if(IsListEmpty(&IrpQueue))
        return NULL;
 
    return CONTAINING_RECORD(IrpQueue.Flink, IRP, Tail.Overlay.ListEntry);
}
 
VOID NTAPI CsqAcquireLock(PIO_CSQ Csq, PKIRQL Irql)
{
    KdPrint(("Acquiring spin lock\n"));
    KeAcquireSpinLock(&IrpQueueLock, Irql);
}
 
VOID NTAPI CsqReleaseLock(PIO_CSQ Csq, KIRQL Irql)
{
    KdPrint(("Releasing spin lock\n"));
    KeReleaseSpinLock(&IrpQueueLock, Irql);
}
 
VOID NTAPI CsqCompleteCancelledIrp(PIO_CSQ Csq, PIRP Irp)
{
    KdPrint(("cancelling irp 0x%x\n", Irp));
    Irp->IoStatus.Status = STATUS_CANCELLED;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
 
NTSTATUS NTAPI CsqInsertIrpEx(PIO_CSQ Csq, PIRP Irp, PVOID InsertContext)
/*
 * FUNCTION: Insert into IRP queue, with extra context
 *
 * NOTE: Switch call in DriverEntry to IoCsqInitializeEx to use this
 */
{
    CsqInsertIrp(Csq, Irp);
    return STATUS_PENDING;
}
 
/*
 * DISPATCH ROUTINES
 */
 
NTSTATUS NTAPI DispatchCreateCloseCleanup(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PIO_STACK_LOCATION StackLocation = IoGetCurrentIrpStackLocation(Irp);
 
    if(StackLocation->MajorFunction == IRP_MJ_CLEANUP)
        {
            /* flush the irp queue */
            PIRP CurrentIrp;
 
            KdPrint(("csqtest: Cleanup received; flushing the IRP queue with cancel\n"));
 
            while((CurrentIrp = IoCsqRemoveNextIrp(&Csq, 0)))
                {
                    CurrentIrp->IoStatus.Status = STATUS_CANCELLED;
                    CurrentIrp->IoStatus.Information = 0;
 
                    IoCompleteRequest(CurrentIrp, IO_NO_INCREMENT);
                }
        }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
NTSTATUS NTAPI DispatchReadWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    /* According to the cancel sample in the DDK, IoCsqInsertIrp() marks the irp pending */
    /* However, I think it's wrong. */
    IoMarkIrpPending(Irp);
    IoCsqInsertIrp(&Csq, Irp, 0);
 
    return STATUS_PENDING;
}
 
NTSTATUS NTAPI DispatchIoctl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
 * all IOCTL requests flush the irp queue
 */
{
    PIRP CurrentIrp;
 
    KdPrint(("csqtest: Ioctl received; flushing the IRP queue with success\n"));
 
    while((CurrentIrp = IoCsqRemoveNextIrp(&Csq, 0)))
        {
            CurrentIrp->IoStatus.Status = STATUS_SUCCESS;
            CurrentIrp->IoStatus.Information = 0;
 
            IoCompleteRequest(CurrentIrp, IO_NO_INCREMENT);
        }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}
 
VOID NTAPI Unload(PDRIVER_OBJECT DriverObject)
/*
 * Function: called by the OS to release resources before unload
 */
{
    UNICODE_STRING LinkName;
 
    RtlInitUnicodeString(&LinkName, DOS_DEVICE_NAME);
 
    IoDeleteSymbolicLink(&LinkName);
 
    if(DeviceObject)
        IoDeleteDevice(DeviceObject);
}
 
/*
 * DriverEntry
 */
 
NTSTATUS NTAPI DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
    NTSTATUS Status;
    UNICODE_STRING NtName;
    UNICODE_STRING DosName;
 
    DriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreateCloseCleanup;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchCreateCloseCleanup;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = DispatchCreateCloseCleanup;
    DriverObject->MajorFunction[IRP_MJ_READ] = DispatchReadWrite;
    DriverObject->MajorFunction[IRP_MJ_WRITE] = DispatchReadWrite;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
    DriverObject->DriverUnload = Unload;
 
    Status = IoCsqInitialize(&Csq, CsqInsertIrp, CsqRemoveIrp, CsqPeekNextIrp,
                                                     CsqAcquireLock, CsqReleaseLock, CsqCompleteCancelledIrp);
 
    if(Status != STATUS_SUCCESS)
        KdPrint(("csqtest: IoCsqInitialize failed: 0x%x\n", Status));
    else
        KdPrint(("csqtest: IoCsqInitialize succeeded\n"));
 
    InitializeListHead(&IrpQueue);
    KeInitializeSpinLock(&IrpQueueLock);
 
    /* Set up a device */
    RtlInitUnicodeString(&NtName, NT_DEVICE_NAME);
    Status = IoCreateDevice(DriverObject, 0, &NtName, FILE_DEVICE_UNKNOWN, 0, 0, &DeviceObject);
 
    if(!NT_SUCCESS(Status))
        {
            KdPrint(("csqtest: Unable to create device: 0x%x\n", Status));
            return Status;
        }
 
    RtlInitUnicodeString(&DosName, DOS_DEVICE_NAME);
    Status = IoCreateSymbolicLink(&DosName, &NtName);
 
    if(!NT_SUCCESS(Status))
        {
            KdPrint(("csqtest: Unable to create link: 0x%x\n", Status));
            return Status;
        }
 
    DeviceObject->Flags |= DO_BUFFERED_IO;
 
    return STATUS_SUCCESS;
}