fastio.c

一个windows 文件系统驱动源码

/*
 * COPYRIGHT:        See COPYRIGHT.TXT
 * PROJECT:          Ext2 File System Driver for WinNT/2K/XP
 * FILE:             fastio.c
 * PROGRAMMER:       Matt Wu <[e-mail]>
 * HOMEPAGE:         http://ext2.yeah.net
 * UPDATE HISTORY: 
 */

/* INCLUDES *****************************************************************/

#include "ntifs.h"
#include "ext2fs.h"

/* GLOBALS ***************************************************************/

extern PEXT2_GLOBAL gExt2Global;

/* DEFINITIONS *************************************************************/

#ifdef ALLOC_PRAGMA
#if DBG
#pragma alloc_text(PAGE, Ext2FastIoRead)
#pragma alloc_text(PAGE, Ext2FastIoWrite)
#endif
#pragma alloc_text(PAGE, Ext2FastIoCheckIfPossible)
#pragma alloc_text(PAGE, Ext2FastIoQueryBasicInfo)
#pragma alloc_text(PAGE, Ext2FastIoQueryStandardInfo)
#pragma alloc_text(PAGE, Ext2FastIoQueryNetworkOpenInfo)
#pragma alloc_text(PAGE, Ext2FastIoLock)
#pragma alloc_text(PAGE, Ext2FastIoUnlockSingle)
#pragma alloc_text(PAGE, Ext2FastIoUnlockAll)
#pragma alloc_text(PAGE, Ext2FastIoUnlockAll)
#endif

BOOLEAN
Ext2FastIoCheckIfPossible (
              IN PFILE_OBJECT         FileObject,
              IN PLARGE_INTEGER       FileOffset,
              IN ULONG                Length,
              IN BOOLEAN              Wait,
              IN ULONG                LockKey,
              IN BOOLEAN              CheckForReadOperation,
              OUT PIO_STATUS_BLOCK    IoStatus,
              IN PDEVICE_OBJECT       DeviceObject
              )
{
    BOOLEAN          Status = FALSE;
    PEXT2_FCB        Fcb;
    LARGE_INTEGER    lLength;
    
    lLength.QuadPart = Length;
    
    __try
    {
        __try
        {
            if (DeviceObject == gExt2Global->DeviceObject)
            {
                Status = FALSE;
                __leave;
            }
            
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            
            ASSERT(Fcb != NULL);
            
            if (Fcb->Identifier.Type == EXT2VCB)
            {
                Status = FALSE;
                __leave;
            }
            
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
            
            if (FlagOn(Fcb->Ext2Mcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY))
            {
                Status = FALSE;
                __leave;
            }
            
            FsRtlEnterFileSystem();
            
            if (CheckForReadOperation)
            {
                Status = FsRtlFastCheckLockForRead(
                    &Fcb->FileLockAnchor,
                    FileOffset,
                    &lLength,
                    LockKey,
                    FileObject,
                    PsGetCurrentProcess());
            }
            else
            {
                if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY))
                {
                    Status = FALSE;
                }
                else
                {
                    Status = FsRtlFastCheckLockForWrite(
                        &Fcb->FileLockAnchor,
                        FileOffset,
                        &lLength,
                        LockKey,
                        FileObject,
                        PsGetCurrentProcess());
                }
            }
 #if DBG
            Ext2DbgPrint(D_FASTIO,"Ext2FastIIOCheckPossible: %-16.16s %-31s %s\n",
                Ext2DbgGetCurrentProcessName(),
                "FASTIO_CHECK_IF_POSSIBLE",
                Fcb->AnsiFileName.Buffer
                );
 #endif
            Ext2DbgPrint(D_FASTIO,"Ext2FastIIOCheckPossible: Offset: %I64u Length: %u Key: %u %s %s\n",
                FileOffset->QuadPart,
                Length,
                LockKey,
                (CheckForReadOperation ? "CheckForReadOperation:" : "CheckForWriteOperation:"),
                (Status ? "Succeeded" : "Failed"));
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            Status = FALSE;
        }
    }
    __finally
    {
        FsRtlExitFileSystem();
    }
    
    return Status;
}


#if DBG
BOOLEAN
Ext2FastIoRead (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)
{
    BOOLEAN     Status;
    PEXT2_FCB    Fcb;
    
    Fcb = (PEXT2_FCB) FileObject->FsContext;
    
    ASSERT(Fcb != NULL);
    
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
        (Fcb->Identifier.Size == sizeof(EXT2_FCB)));

    Ext2DbgPrint(D_FASTIO,"Ext2FastIoRead: %-16.16s %-31s %s\n",
        Ext2DbgGetCurrentProcessName(),
        "FASTIO_READ",
        Fcb->AnsiFileName.Buffer     );

    Ext2DbgPrint(D_FASTIO,"Ext2FastIoRead: Offset: %I64u Length: %u Key: %u\n",
        FileOffset->QuadPart,
        Length,
        LockKey       );

    Status = FsRtlCopyRead (
        FileObject, FileOffset, Length, Wait,
        LockKey, Buffer, IoStatus, DeviceObject);
    
    return Status;
}

BOOLEAN
Ext2FastIoWrite (
           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)
{
    BOOLEAN     Status;
    PEXT2_FCB    Fcb;
    
    Fcb = (PEXT2_FCB) FileObject->FsContext;
    
    ASSERT(Fcb != NULL);
    
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
        (Fcb->Identifier.Size == sizeof(EXT2_FCB)));

    Ext2DbgPrint(D_FASTIO, "Ext2FastIoWrite: %-16.16s %-31s %s\n",
        Ext2DbgGetCurrentProcessName(),
        "FASTIO_WRITE",
        Fcb->AnsiFileName.Buffer     );

    Ext2DbgPrint(D_FASTIO, "Ext2FastIoWrite: Offset: %I64xh Length: %xh Key: %xh\n",
        FileOffset->QuadPart,
        Length,
        LockKey       );

    if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY))
    {
        return FALSE;
    }

    Status = FsRtlCopyWrite (
        FileObject, FileOffset, Length, Wait,
        LockKey, Buffer, IoStatus, DeviceObject);
    
    return Status;
}

#endif /* DBG */


BOOLEAN
Ext2FastIoQueryBasicInfo (IN PFILE_OBJECT             FileObject,
              IN BOOLEAN                  Wait,
              OUT PFILE_BASIC_INFORMATION Buffer,
              OUT PIO_STATUS_BLOCK        IoStatus,
              IN PDEVICE_OBJECT           DeviceObject)
{
    BOOLEAN     Status = FALSE;
    PEXT2_FCB   Fcb;
    BOOLEAN     FcbMainResourceAcquired = FALSE;
    
    __try
    {
        __try
        {
            if (DeviceObject == gExt2Global->DeviceObject)
            {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                Status = TRUE;
                __leave;
            }
            
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            
            ASSERT(Fcb != NULL);
            
            if (Fcb->Identifier.Type == EXT2VCB)
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }
            
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if DBG         
            Ext2DbgPrint(D_FASTIO, "Ext2FastIoQueryBasicInfo: %-16.16s %-31s %s\n",
                Ext2DbgGetCurrentProcessName(),
                "FASTIO_QUERY_BASIC_INFO",
                Fcb->AnsiFileName.Buffer
                );
#endif          
            FsRtlEnterFileSystem();
            
            if (!ExAcquireResourceSharedLite(
                &Fcb->MainResource,
                Wait))
            {
                Status = FALSE;
                __leave;
            }
            
            FcbMainResourceAcquired = TRUE;
            
            RtlZeroMemory(Buffer, sizeof(FILE_BASIC_INFORMATION));
            
            /*
            typedef struct _FILE_BASIC_INFORMATION {
            LARGE_INTEGER   CreationTime;
            LARGE_INTEGER   LastAccessTime;
            LARGE_INTEGER   LastWriteTime;
            LARGE_INTEGER   ChangeTime;
            ULONG           FileAttributes;
            } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
            */

            Buffer->CreationTime = Ext2SysTime(Fcb->ext2_inode->i_ctime);
            Buffer->LastAccessTime = Ext2SysTime(Fcb->ext2_inode->i_atime);
            Buffer->LastWriteTime = Ext2SysTime(Fcb->ext2_inode->i_mtime);
            Buffer->ChangeTime = Ext2SysTime(Fcb->ext2_inode->i_mtime);
            
            
            Buffer->FileAttributes = Fcb->Ext2Mcb->FileAttr;
            
            IoStatus->Information = sizeof(FILE_BASIC_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)
    {
#if DBG
        Ext2DbgPrint(D_FASTIO, "Ext2FastIoQueryBasicInfo: %-16.16s %-31s *** Status: FALSE ***\n",
            Ext2DbgGetCurrentProcessName(),
            "FASTIO_QUERY_BASIC_INFO"
            );
#endif
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        Ext2DbgPrint(D_FASTIO, "Ext2FastIoQueryBasicInfo: %-16.16s %-31s *** Status: %s (%#x) ***\n",
            Ext2FastIoQueryBasicInfo,
            "FASTIO_QUERY_BASIC_INFO",
            Ext2DbgNtStatusToString(IoStatus->Status),
            IoStatus->Status
            );
    }