IoReadWrite_drv.c File Reference

#include <kmt_test.h>
#include "IoReadWrite.h"
#include <debug.h>

Include dependency graph for IoReadWrite_drv.c:

Go to the source code of this file.

Classes
struct	_TEST_FCB

Macros
#define	NDEBUG

Typedefs
typedef struct _TEST_FCB	TEST_FCB
typedef struct _TEST_FCB *	PTEST_FCB

Functions
NTSTATUS	TestEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PCUNICODE_STRING RegistryPath, _Out_ PCWSTR *DeviceName, _Inout_ INT *Flags)
VOID	TestUnload (_In_ PDRIVER_OBJECT DriverObject)
static BOOLEAN NTAPI	TestAcquireForLazyWrite (_In_ PVOID Context, _In_ BOOLEAN Wait)
static VOID NTAPI	TestReleaseFromLazyWrite (_In_ PVOID Context)
static BOOLEAN NTAPI	TestAcquireForReadAhead (_In_ PVOID Context, _In_ BOOLEAN Wait)
static VOID NTAPI	TestReleaseFromReadAhead (_In_ PVOID Context)
static NTSTATUS	TestCommonRead (_In_ PVOID Buffer, _In_ ULONG Length, _In_ LONGLONG FileOffset, _In_ ULONG LockKey, _Out_ PIO_STATUS_BLOCK IoStatus)
static BOOLEAN NTAPI	TestFastIoRead (_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _Out_ PVOID Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
static NTSTATUS	TestCommonWrite (_In_ PVOID Buffer, _In_ ULONG Length, _In_ LONGLONG FileOffset, _In_ ULONG LockKey, _Out_ PIO_STATUS_BLOCK IoStatus)
static BOOLEAN NTAPI	TestFastIoWrite (_In_ PFILE_OBJECT FileObject, _In_ PLARGE_INTEGER FileOffset, _In_ ULONG Length, _In_ BOOLEAN Wait, _In_ ULONG LockKey, _In_ PVOID Buffer, _Out_ PIO_STATUS_BLOCK IoStatus, _In_ PDEVICE_OBJECT DeviceObject)
static NTSTATUS	TestIrpHandler (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PIO_STACK_LOCATION IoStack)

Variables
static KMT_IRP_HANDLER	TestIrpHandler
static FAST_IO_READ	TestFastIoRead
static FAST_IO_WRITE	TestFastIoWrite
static FAST_IO_DISPATCH	TestFastIoDispatch
static ULONG	TestLastFastReadKey
static ULONG	TestLastFastWriteKey
static PFILE_OBJECT	TestFileObject
static PDEVICE_OBJECT	TestDeviceObject

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 11 of file IoReadWrite_drv.c.

Typedef Documentation

PTEST_FCB

typedef struct _TEST_FCB * PTEST_FCB

TEST_FCB

typedef struct _TEST_FCB TEST_FCB

Function Documentation

TestAcquireForLazyWrite()

static BOOLEAN NTAPI TestAcquireForLazyWrite ( _In_ PVOID  Context, _In_ BOOLEAN  Wait  )

static

Definition at line 72 of file IoReadWrite_drv.c.

{
    ok_eq_pointer(Context, NULL);
    ok(0, "Unexpected call to AcquireForLazyWrite\n");
    return TRUE;
}

Referenced by TestIrpHandler().

TestAcquireForReadAhead()

static BOOLEAN NTAPI TestAcquireForReadAhead ( _In_ PVOID  Context, _In_ BOOLEAN  Wait  )

static

Definition at line 94 of file IoReadWrite_drv.c.

{
    ok_eq_pointer(Context, NULL);
    ok(0, "Unexpected call to AcquireForReadAhead\n");
    return TRUE;
}

Referenced by TestIrpHandler().

TestCommonRead()

static NTSTATUS TestCommonRead ( _In_ PVOID  Buffer, _In_ ULONG  Length, _In_ LONGLONG  FileOffset, _In_ ULONG  LockKey, _Out_ PIO_STATUS_BLOCK  IoStatus  )

static

Definition at line 115 of file IoReadWrite_drv.c.

{
    if (FileOffset >= TEST_FILE_SIZE)
    {
        trace("FileOffset %I64d > file size\n", FileOffset);
        IoStatus->Status = STATUS_END_OF_FILE;
        IoStatus->Information = 0;
    }
    else if (Length == 0 || Buffer == NULL)
    {
        IoStatus->Status = STATUS_BUFFER_OVERFLOW;
        IoStatus->Information = TEST_FILE_SIZE - FileOffset;
    }
    else
    {
        Length = min(Length, TEST_FILE_SIZE - FileOffset);
        RtlFillMemory(Buffer, Length, KEY_GET_DATA(LockKey));
        IoStatus->Status = TestGetReturnStatus(LockKey);
        IoStatus->Information = Length;
    }
    if (LockKey & KEY_RETURN_PENDING)
        return STATUS_PENDING;
    return IoStatus->Status;
}

Referenced by TestFastIoRead(), and TestIrpHandler().

TestCommonWrite()

static NTSTATUS TestCommonWrite ( _In_ PVOID  Buffer, _In_ ULONG  Length, _In_ LONGLONG  FileOffset, _In_ ULONG  LockKey, _Out_ PIO_STATUS_BLOCK  IoStatus  )

static

Definition at line 194 of file IoReadWrite_drv.c.

{
    ULONG i;
    PUCHAR BufferBytes = Buffer;
 
    for (i = 0; i < Length; i++)
        ok(BufferBytes[i] == KEY_GET_DATA(LockKey), "Buffer[%lu] = 0x%x, expected 0x%x\n", i, BufferBytes[i], KEY_GET_DATA(LockKey));
    IoStatus->Status = TestGetReturnStatus(LockKey);
    IoStatus->Information = Length;
 
    if (LockKey & KEY_RETURN_PENDING)
        return STATUS_PENDING;
    return IoStatus->Status;
}

Referenced by TestFastIoWrite(), and TestIrpHandler().

TestEntry()

NTSTATUS TestEntry	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PCUNICODE_STRING	RegistryPath,
		_Out_ PCWSTR *	DeviceName,
		_Inout_ INT *	Flags
	)

Definition at line 33 of file IoReadWrite_drv.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    *DeviceName = L"IoReadWrite";
    *Flags = TESTENTRY_NO_EXCLUSIVE_DEVICE |
             TESTENTRY_BUFFERED_IO_DEVICE |
             TESTENTRY_NO_READONLY_DEVICE;
 
    TestFastIoDispatch.FastIoRead = TestFastIoRead;
    TestFastIoDispatch.FastIoWrite = TestFastIoWrite;
    DriverObject->FastIoDispatch = &TestFastIoDispatch;
 
    KmtRegisterIrpHandler(IRP_MJ_CREATE, NULL, TestIrpHandler);
    KmtRegisterIrpHandler(IRP_MJ_CLEANUP, NULL, TestIrpHandler);
    KmtRegisterIrpHandler(IRP_MJ_READ, NULL, TestIrpHandler);
    KmtRegisterIrpHandler(IRP_MJ_WRITE, NULL, TestIrpHandler);
 
    return Status;
}

TestFastIoRead()

static BOOLEAN NTAPI TestFastIoRead ( _In_ PFILE_OBJECT  FileObject, _In_ PLARGE_INTEGER  FileOffset, _In_ ULONG  Length, _In_ BOOLEAN  Wait, _In_ ULONG  LockKey, _Out_ PVOID  Buffer, _Out_ PIO_STATUS_BLOCK  IoStatus, _In_ PDEVICE_OBJECT  DeviceObject  )

static

Definition at line 148 of file IoReadWrite_drv.c.

{
    PTEST_FCB Fcb;
    NTSTATUS Status;
 
    //trace("FastIoRead: %p %lx %I64d+%lu -> %p\n", FileObject, LockKey, FileOffset->QuadPart, Length, Buffer);
    ok_eq_pointer(FileObject, TestFileObject);
    ok_bool_true(Wait, "Wait is");
    ok_eq_pointer(DeviceObject, TestDeviceObject);
    Fcb = FileObject->FsContext;
    ok_bool_true(Fcb->Cached, "Cached is");
 
    TestLastFastReadKey = LockKey;
    ok((ULONG_PTR)Buffer < MM_USER_PROBE_ADDRESS, "Buffer is %p\n", Buffer);
    ok((ULONG_PTR)FileOffset > MM_USER_PROBE_ADDRESS, "FileOffset is %p\n", FileOffset);
    ok((ULONG_PTR)IoStatus > MM_USER_PROBE_ADDRESS, "IoStatus is %p\n", IoStatus);
    _SEH2_TRY
    {
        Status = TestCommonRead(Buffer, Length, FileOffset->QuadPart, LockKey, IoStatus);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        IoStatus->Status = _SEH2_GetExceptionCode();
        return FALSE;
    }
    _SEH2_END;
 
    if (Status == STATUS_PENDING)
        return FALSE;
 
    if (LockKey & KEY_USE_FASTIO)
        return TRUE;
    else
        return FALSE;
}

TestFastIoWrite()

static BOOLEAN NTAPI TestFastIoWrite ( _In_ PFILE_OBJECT  FileObject, _In_ PLARGE_INTEGER  FileOffset, _In_ ULONG  Length, _In_ BOOLEAN  Wait, _In_ ULONG  LockKey, _In_ PVOID  Buffer, _Out_ PIO_STATUS_BLOCK  IoStatus, _In_ PDEVICE_OBJECT  DeviceObject  )

static

Definition at line 217 of file IoReadWrite_drv.c.

{
    PTEST_FCB Fcb;
    NTSTATUS Status;
 
    //trace("FastIoWrite: %p %lx %p -> %I64d+%lu\n", FileObject, LockKey, Buffer, FileOffset->QuadPart, Length);
    ok_eq_pointer(FileObject, TestFileObject);
    ok_bool_true(Wait, "Wait is");
    ok_eq_pointer(DeviceObject, TestDeviceObject);
    Fcb = FileObject->FsContext;
    ok_bool_true(Fcb->Cached, "Cached is");
 
    TestLastFastWriteKey = LockKey;
    ok((ULONG_PTR)Buffer < MM_USER_PROBE_ADDRESS, "Buffer is %p\n", Buffer);
    ok((ULONG_PTR)FileOffset > MM_USER_PROBE_ADDRESS, "FileOffset is %p\n", FileOffset);
    ok((ULONG_PTR)IoStatus > MM_USER_PROBE_ADDRESS, "IoStatus is %p\n", IoStatus);
    _SEH2_TRY
    {
        Status = TestCommonWrite(Buffer, Length, FileOffset->QuadPart, LockKey, IoStatus);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        IoStatus->Status = _SEH2_GetExceptionCode();
        return FALSE;
    }
    _SEH2_END;
 
    if (Status == STATUS_PENDING)
        return FALSE;
 
    if (LockKey & KEY_USE_FASTIO)
        return TRUE;
    else
        return FALSE;
}

TestIrpHandler()

static NTSTATUS TestIrpHandler ( _In_ PDEVICE_OBJECT  DeviceObject, _In_ PIRP  Irp, _In_ PIO_STACK_LOCATION  IoStack  )

static

Definition at line 263 of file IoReadWrite_drv.c.

{
    NTSTATUS Status;
    PTEST_FCB Fcb;
    CACHE_MANAGER_CALLBACKS Callbacks;
    CACHE_UNINITIALIZE_EVENT CacheUninitEvent;
 
    PAGED_CODE();
 
    DPRINT("IRP %x/%x\n", IoStack->MajorFunction, IoStack->MinorFunction);
    ASSERT(IoStack->MajorFunction == IRP_MJ_CREATE ||
           IoStack->MajorFunction == IRP_MJ_CLEANUP ||
           IoStack->MajorFunction == IRP_MJ_READ ||
           IoStack->MajorFunction == IRP_MJ_WRITE);
 
    Status = STATUS_NOT_SUPPORTED;
    Irp->IoStatus.Information = 0;
 
    if (IoStack->MajorFunction == IRP_MJ_CREATE)
    {
        if (IoStack->FileObject->FileName.Length >= 2 * sizeof(WCHAR))
        {
            TestDeviceObject = DeviceObject;
            TestFileObject = IoStack->FileObject;
        }
        Fcb = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Fcb), 'FwrI');
        RtlZeroMemory(Fcb, sizeof(*Fcb));
        ExInitializeFastMutex(&Fcb->HeaderMutex);
        FsRtlSetupAdvancedHeader(&Fcb->Header, &Fcb->HeaderMutex);
        Fcb->Header.AllocationSize.QuadPart = TEST_FILE_SIZE;
        Fcb->Header.FileSize.QuadPart = TEST_FILE_SIZE;
        Fcb->Header.ValidDataLength.QuadPart = TEST_FILE_SIZE;
        IoStack->FileObject->FsContext = Fcb;
        IoStack->FileObject->SectionObjectPointer = &Fcb->SectionObjectPointers;
        if (IoStack->FileObject->FileName.Length >= 2 * sizeof(WCHAR) &&
            IoStack->FileObject->FileName.Buffer[1] != 'N')
        {
            Fcb->Cached = TRUE;
            Callbacks.AcquireForLazyWrite = TestAcquireForLazyWrite;
            Callbacks.ReleaseFromLazyWrite = TestReleaseFromLazyWrite;
            Callbacks.AcquireForReadAhead = TestAcquireForReadAhead;
            Callbacks.ReleaseFromReadAhead = TestReleaseFromReadAhead;
            CcInitializeCacheMap(IoStack->FileObject,
                                 (PCC_FILE_SIZES)&Fcb->Header.AllocationSize,
                                 FALSE,
                                 &Callbacks,
                                 NULL);
        }
        Irp->IoStatus.Information = FILE_OPENED;
        Status = STATUS_SUCCESS;
    }
    else if (IoStack->MajorFunction == IRP_MJ_CLEANUP)
    {
        KeInitializeEvent(&CacheUninitEvent.Event, NotificationEvent, FALSE);
        CcUninitializeCacheMap(IoStack->FileObject, NULL, &CacheUninitEvent);
        KeWaitForSingleObject(&CacheUninitEvent.Event, Executive, KernelMode, FALSE, NULL);
        Fcb = IoStack->FileObject->FsContext;
        ExFreePoolWithTag(Fcb, 'FwrI');
        IoStack->FileObject->FsContext = NULL;
        Status = STATUS_SUCCESS;
    }
    else if (IoStack->MajorFunction == IRP_MJ_READ)
    {
        //trace("IRP_MJ_READ: %p %lx %I64d+%lu -> %p\n", IoStack->FileObject, IoStack->Parameters.Read.Key, IoStack->Parameters.Read.ByteOffset.QuadPart, IoStack->Parameters.Read.Length, Irp->AssociatedIrp.SystemBuffer);
        ok_eq_pointer(DeviceObject, TestDeviceObject);
        ok_eq_pointer(IoStack->FileObject, TestFileObject);
        Fcb = IoStack->FileObject->FsContext;
        if (Fcb->Cached)
            ok_eq_hex(IoStack->Parameters.Read.Key, TestLastFastReadKey);
        ok(Irp->AssociatedIrp.SystemBuffer == NULL ||
           (ULONG_PTR)Irp->AssociatedIrp.SystemBuffer > MM_USER_PROBE_ADDRESS,
           "Buffer is %p\n",
           Irp->AssociatedIrp.SystemBuffer);
        Status = TestCommonRead(Irp->AssociatedIrp.SystemBuffer,
                                IoStack->Parameters.Read.Length,
                                IoStack->Parameters.Read.ByteOffset.QuadPart,
                                IoStack->Parameters.Read.Key,
                                &Irp->IoStatus);
    }
    else if (IoStack->MajorFunction == IRP_MJ_WRITE)
    {
        //trace("IRP_MJ_WRITE: %p %lx %I64d+%lu -> %p\n", IoStack->FileObject, IoStack->Parameters.Write.Key, IoStack->Parameters.Write.ByteOffset.QuadPart, IoStack->Parameters.Write.Length, Irp->AssociatedIrp.SystemBuffer);
        ok_eq_pointer(DeviceObject, TestDeviceObject);
        ok_eq_pointer(IoStack->FileObject, TestFileObject);
        Fcb = IoStack->FileObject->FsContext;
        if (Fcb->Cached)
            ok_eq_hex(IoStack->Parameters.Write.Key, TestLastFastWriteKey);
        ok(Irp->AssociatedIrp.SystemBuffer == NULL ||
           (ULONG_PTR)Irp->AssociatedIrp.SystemBuffer > MM_USER_PROBE_ADDRESS,
           "Buffer is %p\n",
           Irp->AssociatedIrp.SystemBuffer);
        Status = TestCommonWrite(Irp->AssociatedIrp.SystemBuffer,
                                 IoStack->Parameters.Write.Length,
                                 IoStack->Parameters.Write.ByteOffset.QuadPart,
                                 IoStack->Parameters.Write.Key,
                                 &Irp->IoStatus);
    }
 
    if (Status == STATUS_PENDING)
    {
        IoMarkIrpPending(Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        Status = STATUS_PENDING;
    }
    else
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    return Status;
}

TestReleaseFromLazyWrite()

static VOID NTAPI TestReleaseFromLazyWrite ( _In_ PVOID  Context )

static

Definition at line 84 of file IoReadWrite_drv.c.

{
    ok_eq_pointer(Context, NULL);
    ok(0, "Unexpected call to ReleaseFromLazyWrite\n");
}

Referenced by TestIrpHandler().

TestReleaseFromReadAhead()

static VOID NTAPI TestReleaseFromReadAhead ( _In_ PVOID  Context )

static

Definition at line 106 of file IoReadWrite_drv.c.

{
    ok_eq_pointer(Context, NULL);
    ok(0, "Unexpected call to ReleaseFromReadAhead\n");
}

Referenced by TestIrpHandler().

TestUnload()

VOID TestUnload

(

_In_ PDRIVER_OBJECT

DriverObject

)

Definition at line 63 of file IoReadWrite_drv.c.

{
    PAGED_CODE();
}

Variable Documentation

TestDeviceObject

PDEVICE_OBJECT TestDeviceObject

static

Definition at line 30 of file IoReadWrite_drv.c.

Referenced by TestFastIoRead(), TestFastIoWrite(), and TestIrpHandler().

TestFastIoDispatch

FAST_IO_DISPATCH TestFastIoDispatch

static

Definition at line 26 of file IoReadWrite_drv.c.

Referenced by TestEntry().

TestFastIoRead

FAST_IO_READ TestFastIoRead

static

Definition at line 23 of file IoReadWrite_drv.c.

Referenced by TestEntry().

TestFastIoWrite

FAST_IO_WRITE TestFastIoWrite

static

Definition at line 24 of file IoReadWrite_drv.c.

Referenced by TestEntry().

TestFileObject

PFILE_OBJECT TestFileObject

static

Definition at line 29 of file IoReadWrite_drv.c.

Referenced by TestFastIoRead(), TestFastIoWrite(), and TestIrpHandler().

TestIrpHandler

KMT_IRP_HANDLER TestIrpHandler

static

Definition at line 22 of file IoReadWrite_drv.c.

Referenced by TestEntry().

TestLastFastReadKey

ULONG TestLastFastReadKey

static

Definition at line 27 of file IoReadWrite_drv.c.

Referenced by TestFastIoRead(), and TestIrpHandler().

TestLastFastWriteKey

ULONG TestLastFastWriteKey

static

Definition at line 28 of file IoReadWrite_drv.c.

Referenced by TestFastIoWrite(), and TestIrpHandler().