fastio.c

一个windows 文件系统驱动源码

    return Status;
}

BOOLEAN
Ext2FastIoQueryStandardInfo (
                IN PFILE_OBJECT                 FileObject,
                IN BOOLEAN                      Wait,
                OUT PFILE_STANDARD_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, "Ext2FastIoQueryStandardInfo: %-16.16s %-31s %s\n",
                Ext2DbgGetCurrentProcessName(),
                "FASTIO_QUERY_STANDARD_INFO",
                Fcb->AnsiFileName.Buffer );
#endif          
            FsRtlEnterFileSystem();
            
            if (!ExAcquireResourceSharedLite(
                &Fcb->MainResource,
                Wait        ))
            {
                Status = FALSE;
                __leave;
            }
            
            FcbMainResourceAcquired = TRUE;
            
            RtlZeroMemory(Buffer, sizeof(FILE_STANDARD_INFORMATION));
            
            /*
            typedef struct _FILE_STANDARD_INFORMATION {
            LARGE_INTEGER   AllocationSize;
            LARGE_INTEGER   EndOfFile;
            ULONG           NumberOfLinks;
            BOOLEAN         DeletePending;
            BOOLEAN         Directory;
            } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
            */
            
            Buffer->AllocationSize.QuadPart =
                (LONGLONG)(Fcb->ext2_inode->i_size);
            Buffer->EndOfFile.QuadPart =
                (LONGLONG)(Fcb->ext2_inode->i_size);            
            Buffer->NumberOfLinks = Fcb->ext2_inode->i_links_count;
            
            if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY))
                Buffer->DeletePending = FALSE;
            else
                Buffer->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
            
            if (FlagOn(Fcb->Ext2Mcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY))
            {
                Buffer->Directory = TRUE;
            }
            else
            {
                Buffer->Directory = FALSE;
            }
            
            IoStatus->Information = sizeof(FILE_STANDARD_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 DBG
    if (Status == FALSE)
    {
        Ext2DbgPrint(D_FASTIO, "Ext2FastIoQueryStandardInfo: %-16.16s %-31s *** Status: FALSE ***\n",
            Ext2DbgGetCurrentProcessName(),
            "FASTIO_QUERY_STANDARD_INFO"            );
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        Ext2DbgPrint(D_FASTIO, "Ext2FastIoQueryStandardInfo: %-16.16s %-31s *** Status: %s (%#x) ***\n",
            Ext2DbgGetCurrentProcessName(),
            "FASTIO_QUERY_STANDARD_INFO",
            Ext2DbgNtStatusToString(IoStatus->Status),
            IoStatus->Status            );
    }
#endif
    
    return Status;
}

BOOLEAN
Ext2FastIoQueryNetworkOpenInfo (
     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;
    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,
                DRIVER_NAME ": %-16.16s %-31s %s\n",
                PsGetCurrentProcess()->ImageFileName,
                "FASTIO_QUERY_NETWORK_OPEN_INFO",
                Fcb->AnsiFileName.Buffer
                );
#endif          
            FsRtlEnterFileSystem();
            
            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 = 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;
            Buffer->AllocationSize.QuadPart =
                (LONGLONG)(Fcb->ext2_inode->i_size);
            Buffer->EndOfFile.QuadPart =
                (LONGLONG)(Fcb->ext2_inode->i_size);            
            
            Buffer->FileAttributes = Fcb->Ext2Mcb->FileAttr;
            
            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)
    {
        Ext2DbgPrint(D_FASTIO,
            DRIVER_NAME ": %-16.16s %-31s *** Status: FALSE ***\n",
            PsGetCurrentProcess()->ImageFileName,
            "FASTIO_QUERY_NETWORK_OPEN_INFO"
            );
    }
    else if (IoStatus->Status != STATUS_SUCCESS)
    {
        Ext2DbgPrint(D_FASTIO,
            DRIVER_NAME ": %-16.16s %-31s *** Status: %s (%#x) ***\n",
            PsGetCurrentProcess()->ImageFileName,
            "FASTIO_QUERY_NETWORK_OPEN_INFO",
            Ext2DbgNtStatusToString(IoStatus->Status),
            IoStatus->Status
            );
    }
    
    return Status;
}


BOOLEAN
Ext2FastIoLock (
           IN PFILE_OBJECT         FileObject,
           IN PLARGE_INTEGER       FileOffset,
           IN PLARGE_INTEGER       Length,
           IN PEPROCESS            Process,
           IN ULONG                Key,
           IN BOOLEAN              FailImmediately,
           IN BOOLEAN              ExclusiveLock,
           OUT PIO_STATUS_BLOCK    IoStatus,
           IN PDEVICE_OBJECT       DeviceObject
           )
{
    BOOLEAN     Status = FALSE;
    PEXT2_FCB   Fcb;
    
    __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 (FlagOn(Fcb->Ext2Mcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY))
            {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                Status = TRUE;
                __leave;
            }
#if DBG         
            Ext2DbgPrint(D_FASTIO, "Ext2FastIoLock: %-16.16s %-31s %s\n",
                Ext2DbgGetCurrentProcessName(),
                "FASTIO_LOCK",
                Fcb->AnsiFileName.Buffer        );
#endif          
            Ext2DbgPrint(D_FASTIO, "Ext2FastIoLock: Offset: %I64u Length: %I64u Key: %u %s%s\n",
                FileOffset->QuadPart,
                Length->QuadPart,
                Key,
                (FailImmediately ? "FailImmediately " : ""),
                (ExclusiveLock ? "ExclusiveLock " : "") );
            
            if (Fcb->CommonFCBHeader.IsFastIoPossible != FastIoIsQuestionable)
            {
#if DBG
                Ext2DbgPrint(D_FASTIO, "Ext2FastIoLock: %-16.16s %-31s %s\n",
                    (PUCHAR) Process + gProcessNameOffset,
                    "FastIoIsQuestionable",
                    Fcb->AnsiFileName.Buffer        );
#endif              
                Fcb->CommonFCBHeader.IsFastIoPossible = FastIoIsQuestionable;
            }
            
            FsRtlEnterFileSystem();