fastio.c

I want to provide an example file system driver for Windows NT/2000/XP. For some time I have worked

                "FASTIO_LOCK",
                Fcb->AnsiFileName.Buffer
                ));

            KdPrint((
                DRIVER_NAME ": Offset: %I64u Length: %I64u Key: %u %s%s\n",
                FileOffset->QuadPart,
                Length->QuadPart,
                Key,
                (FailImmediately ? "FailImmediately " : ""),
                (ExclusiveLock ? "ExclusiveLock " : "")
                ));

            if (Fcb->CommonFCBHeader.IsFastIoPossible != FastIoIsQuestionable)
            {
                KdPrint((
                    DRIVER_NAME ": %-16.16s %-31s %s\n",
                    (PUCHAR) Process + ProcessNameOffset,
                    "FastIoIsQuestionable",
                    Fcb->AnsiFileName.Buffer
                    ));

                Fcb->CommonFCBHeader.IsFastIoPossible = FastIoIsQuestionable;
            }

            Status = FsRtlPrivateLock(
                &Fcb->FileLock,
                FileObject,
                FileOffset,
                Length,
                Process,
                Key,
                FailImmediately,
                ExclusiveLock,
                IoStatus,
                NULL,
                NULL,
                0
                );
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            IoStatus->Status = GetExceptionCode();
            Status = TRUE;
        }
    }
    __finally
    {
        FsRtlExitFileSystem();
    }

    if (Status == FALSE)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_LOCK"
            ));
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_LOCK",
            FsdNtStatusToString(IoStatus->Status),
            IoStatus->Status
            ));
    }

    return Status;
}

BOOLEAN
FsdFastIoUnlockSingle (
    IN PFILE_OBJECT         FileObject,
    IN PLARGE_INTEGER       FileOffset,
    IN PLARGE_INTEGER       Length,
    IN PEPROCESS            Process,
    IN ULONG                Key,
    OUT PIO_STATUS_BLOCK    IoStatus,
    IN PDEVICE_OBJECT       DeviceObject
    )
{
    BOOLEAN     Status = FALSE;
    PFSD_FCB    Fcb;

    __try
    {
        __try
        {
            FsRtlEnterFileSystem();

            if (DeviceObject == FsdGlobalData.DeviceObject)
            {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                Status = TRUE;
                __leave;
            }

            Fcb = (PFSD_FCB) FileObject->FsContext;

            ASSERT(Fcb != NULL);

            if (Fcb->Identifier.Type == VCB)
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            ASSERT((Fcb->Identifier.Type == FCB) &&
                   (Fcb->Identifier.Size == sizeof(FSD_FCB)));

            if (FlagOn(Fcb->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            KdPrint((
                DRIVER_NAME ": %-16.16s %-31s %s\n",
                (PUCHAR) Process + ProcessNameOffset,
                "FASTIO_UNLOCK_SINGLE",
                Fcb->AnsiFileName.Buffer
                ));

            KdPrint((
                DRIVER_NAME ": Offset: %I64u Length: %I64u Key: %u\n",
                FileOffset->QuadPart,
                Length->QuadPart,
                Key
                ));

            IoStatus->Status = FsRtlFastUnlockSingle(
                &Fcb->FileLock,
                FileObject,
                FileOffset,
                Length,
                Process,
                Key,
                NULL,
                0
                );                      

            IoStatus->Information = 0;

            Status =  TRUE;
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            IoStatus->Status = GetExceptionCode();
            Status = TRUE;
        }
    }
    __finally
    {
        FsRtlExitFileSystem();
    }

    if (Status == FALSE)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_UNLOCK_SINGLE"
            ));
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_UNLOCK_SINGLE",
            FsdNtStatusToString(IoStatus->Status),
            IoStatus->Status
            ));
    }

    return Status;
}

BOOLEAN
FsdFastIoUnlockAll (
    IN PFILE_OBJECT         FileObject,
    IN PEPROCESS            Process,
    OUT PIO_STATUS_BLOCK    IoStatus,
    IN PDEVICE_OBJECT       DeviceObject
    )
{
    BOOLEAN     Status = FALSE;
    PFSD_FCB    Fcb;

    __try
    {
        __try
        {
            FsRtlEnterFileSystem();

            if (DeviceObject == FsdGlobalData.DeviceObject)
            {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                Status = TRUE;
                __leave;
            }

            Fcb = (PFSD_FCB) FileObject->FsContext;

            ASSERT(Fcb != NULL);

            if (Fcb->Identifier.Type == VCB)
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            ASSERT((Fcb->Identifier.Type == FCB) &&
                   (Fcb->Identifier.Size == sizeof(FSD_FCB)));

            if (FlagOn(Fcb->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            KdPrint((
                DRIVER_NAME ": %-16.16s %-31s %s\n",
                (PUCHAR) Process + ProcessNameOffset,
                "FASTIO_UNLOCK_ALL",
                Fcb->AnsiFileName.Buffer
                ));

            IoStatus->Status = FsRtlFastUnlockAll(
                &Fcb->FileLock,
                FileObject,
                Process,
                NULL
                );

            IoStatus->Information = 0;

            Status =  TRUE;
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            IoStatus->Status = GetExceptionCode();
            Status = TRUE;
        }
    }
    __finally
    {
        FsRtlExitFileSystem();
    }

    if (Status == FALSE)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_UNLOCK_ALL"
            ));
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_UNLOCK_ALL",
            FsdNtStatusToString(IoStatus->Status),
            IoStatus->Status
            ));
    }

    return Status;
}

BOOLEAN
FsdFastIoUnlockAllByKey (
    IN PFILE_OBJECT         FileObject,
    IN PEPROCESS            Process,
    IN ULONG                Key,
    OUT PIO_STATUS_BLOCK    IoStatus,
    IN PDEVICE_OBJECT       DeviceObject
    )
{
    BOOLEAN     Status = FALSE;
    PFSD_FCB    Fcb;

    __try
    {
        __try
        {
            FsRtlEnterFileSystem();

            if (DeviceObject == FsdGlobalData.DeviceObject)
            {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                Status = TRUE;
                __leave;
            }

            Fcb = (PFSD_FCB) FileObject->FsContext;

            ASSERT(Fcb != NULL);

            if (Fcb->Identifier.Type == VCB)
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            ASSERT((Fcb->Identifier.Type == FCB) &&
                   (Fcb->Identifier.Size == sizeof(FSD_FCB)));

            if (FlagOn(Fcb->FileAttributes, FILE_ATTRIBUTE_DIRECTORY))
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            KdPrint((
                DRIVER_NAME ": %-16.16s %-31s %s\n",
                (PUCHAR) Process + ProcessNameOffset,
                "FASTIO_UNLOCK_ALL_BY_KEY",
                Fcb->AnsiFileName.Buffer
                ));

            KdPrint((
                DRIVER_NAME ": Key: %u\n",
                Key
                ));

            IoStatus->Status = FsRtlFastUnlockAllByKey(
                &Fcb->FileLock,
                FileObject,
                Process,
                Key,
                NULL
                );  

            IoStatus->Information = 0;

            Status =  TRUE;
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            IoStatus->Status = GetExceptionCode();
            Status = TRUE;
        }
    }
    __finally
    {
        FsRtlExitFileSystem();
    }

    if (Status == FALSE)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_UNLOCK_ALL_BY_KEY"
            ));
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
            (PUCHAR) Process + ProcessNameOffset,
            "FASTIO_UNLOCK_ALL_BY_KEY",
            FsdNtStatusToString(IoStatus->Status),
            IoStatus->Status
            ));
    }

    return Status;
}

BOOLEAN
FsdFastIoQueryNetworkOpenInfo (
    IN PFILE_OBJECT                     FileObject,
    IN BOOLEAN                          Wait,
    OUT PFILE_NETWORK_OPEN_INFORMATION  Buffer,
    OUT PIO_STATUS_BLOCK                IoStatus,
    IN PDEVICE_OBJECT                   DeviceObject
    )
{
    BOOLEAN     Status = FALSE;
    PFSD_FCB    Fcb;
    BOOLEAN     FcbMainResourceAcquired = FALSE;

    __try
    {
        __try
        {
            FsRtlEnterFileSystem();

            if (DeviceObject == FsdGlobalData.DeviceObject)
            {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                Status = TRUE;
                __leave;
            }

            Fcb = (PFSD_FCB) FileObject->FsContext;

            ASSERT(Fcb != NULL);

            if (Fcb->Identifier.Type == VCB)
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }

            ASSERT((Fcb->Identifier.Type == FCB) &&
                   (Fcb->Identifier.Size == sizeof(FSD_FCB)));

            KdPrint((
                DRIVER_NAME ": %-16.16s %-31s %s\n",
                FsdGetCurrentProcessName(),
                "FASTIO_QUERY_NETWORK_OPEN_INFO",
                Fcb->AnsiFileName.Buffer
                ));

            if (!ExAcquireResourceSharedLite(
                    &Fcb->MainResource,
                    Wait
                    ))
            {
                Status = FALSE;
                __leave;
            }

            FcbMainResourceAcquired = TRUE;

            RtlZeroMemory(Buffer, sizeof(FILE_NETWORK_OPEN_INFORMATION));

/*
            typedef struct _FILE_NETWORK_OPEN_INFORMATION {
                LARGE_INTEGER   CreationTime;
                LARGE_INTEGER   LastAccessTime;
                LARGE_INTEGER   LastWriteTime;
                LARGE_INTEGER   ChangeTime;
                LARGE_INTEGER   AllocationSize;
                LARGE_INTEGER   EndOfFile;
                ULONG           FileAttributes;
            } FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
*/

            Buffer->CreationTime.QuadPart = 0;

            Buffer->LastAccessTime.QuadPart = 0;

            Buffer->LastWriteTime.QuadPart = 0;

            Buffer->ChangeTime.QuadPart = 0;

            Buffer->AllocationSize.QuadPart =
                be32_to_cpu(Fcb->romfs_inode->size);

            Buffer->EndOfFile.QuadPart =
                be32_to_cpu(Fcb->romfs_inode->size);

            Buffer->FileAttributes = Fcb->FileAttributes;

            IoStatus->Information = sizeof(FILE_NETWORK_OPEN_INFORMATION);

            IoStatus->Status = STATUS_SUCCESS;

            Status =  TRUE;
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            IoStatus->Status = GetExceptionCode();
            Status = TRUE;
        }
    }
    __finally
    {
        if (FcbMainResourceAcquired)
        {
            ExReleaseResourceForThreadLite(
                &Fcb->MainResource,
                ExGetCurrentResourceThread()
                );
        }

        FsRtlExitFileSystem();
    }

    if (Status == FALSE)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
            FsdGetCurrentProcessName(),
            "FASTIO_QUERY_NETWORK_OPEN_INFO"
            ));
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        KdPrint((
            DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
            FsdGetCurrentProcessName(),
            "FASTIO_QUERY_NETWORK_OPEN_INFO",
            FsdNtStatusToString(IoStatus->Status),
            IoStatus->Status
            ));
    }

    return Status;
}

#pragma code_seg() // end FSD_PAGED_CODE