fsctrl.c File Reference

#include "fatprocs.h"

Include dependency graph for fsctrl.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_FSCTRL)
#define	Dbg   (DEBUG_TRACE_FSCTRL)
#define	MCB_SCALE_LOG2   (Vcb->AllocationSupport.LogOfBytesPerSector)
#define	MCB_SCALE   (1 << MCB_SCALE_LOG2)
#define	MCB_SCALE_MODULO   (MCB_SCALE - 1)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
BOOLEAN	FatAddMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, IN LBO Lbo, IN ULONG SectorCount)
BOOLEAN	FatLookupMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, OUT PLBO Lbo, OUT PULONG ByteCount OPTIONAL, OUT PULONG Index OPTIONAL)
BOOLEAN	FatLookupLastMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, OUT PVBO Vbo, OUT PLBO Lbo, OUT PULONG Index)
BOOLEAN	FatGetNextMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN ULONG RunIndex, OUT PVBO Vbo, OUT PLBO Lbo, OUT PULONG ByteCount)
VOID	FatRemoveMcbEntry (IN PVCB Vcb, IN PLARGE_MCB Mcb, IN VBO Vbo, IN ULONG SectorCount)
	_Function_class_ (IRP_MJ_FILE_SYSTEM_CONTROL)
BOOLEAN	FatIsBootSectorFat (IN PPACKED_BOOT_SECTOR BootSector)
BOOLEAN	FatIsMediaWriteProtected (IN PIRP_CONTEXT IrpContext, IN PDEVICE_OBJECT TargetDeviceObject)
NTSTATUS	FatUnlockVolume (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatUnlockVolumeInternal (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PFILE_OBJECT FileObject OPTIONAL)
NTSTATUS	FatIsVolumeDirty (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatIsVolumeMounted (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatIsPathnameValid (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatQueryBpb (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
BOOLEAN	FatPerformVerifyDiskRead (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PVOID Buffer, IN LBO Lbo, IN ULONG NumberOfBytesToRead, IN BOOLEAN ReturnOnError)
NTSTATUS	FatGetStatistics (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
VOID	FatComputeMoveFileSplicePoints (IN PIRP_CONTEXT IrpContext, IN PFCB FcbOrDcb, IN ULONG FileOffset, IN ULONG TargetCluster, IN ULONG BytesToReallocate, OUT PULONG FirstSpliceSourceCluster, OUT PULONG FirstSpliceTargetCluster, OUT PULONG SecondSpliceSourceCluster, OUT PULONG SecondSpliceTargetCluster, IN OUT PLARGE_MCB SourceMcb)
NTSTATUS	FatAllowExtendedDasdIo (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatSearchBufferForLabel (IN PIRP_CONTEXT IrpContext, IN PVPB Vpb, IN PVOID Buffer, IN ULONG Size, OUT PBOOLEAN LabelFound)
VOID	FatVerifyLookupFatEntry (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN ULONG FatIndex, IN OUT PULONG FatEntry)
NTSTATUS	FatSetZeroOnDeallocate (__in PIRP_CONTEXT IrpContext, __in PIRP Irp)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_FSCTRL)

Definition at line 24 of file fsctrl.c.

Dbg

#define Dbg   (DEBUG_TRACE_FSCTRL)

Definition at line 30 of file fsctrl.c.

MCB_SCALE

#define MCB_SCALE   (1 << MCB_SCALE_LOG2)

MCB_SCALE_LOG2

#define MCB_SCALE_LOG2   (Vcb->AllocationSupport.LogOfBytesPerSector)

MCB_SCALE_MODULO

#define MCB_SCALE_MODULO   (MCB_SCALE - 1)

Function Documentation

_Function_class_()

_Function_class_

(

IRP_MJ_FILE_SYSTEM_CONTROL

)

Definition at line 635 of file fsctrl.c.

{
    BOOLEAN Wait;
    NTSTATUS Status;
    PIRP_CONTEXT IrpContext = NULL;
 
    BOOLEAN TopLevel;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    DebugTrace(+1, Dbg,"FatFsdFileSystemControl\n", 0);
 
    //
    //  Call the common FileSystem Control routine, with blocking allowed if
    //  synchronous.  This opeation needs to special case the mount
    //  and verify suboperations because we know they are allowed to block.
    //  We identify these suboperations by looking at the file object field
    //  and seeing if its null.
    //
 
    if (IoGetCurrentIrpStackLocation(Irp)->FileObject == NULL) {
 
        Wait = TRUE;
 
    } else {
 
        Wait = CanFsdWait( Irp );
    }
 
    FsRtlEnterFileSystem();
 
    TopLevel = FatIsIrpTopLevel( Irp );
 
    _SEH2_TRY {
 
        PIO_STACK_LOCATION IrpSp;
 
        IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
        //
        //  We need to made a special check here for the InvalidateVolumes
        //  FSCTL as that comes in with a FileSystem device object instead
        //  of a volume device object.
        //
 
        if (FatDeviceIsFatFsdo( IrpSp->DeviceObject) &&
            (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
            (IrpSp->MinorFunction == IRP_MN_USER_FS_REQUEST) &&
            (IrpSp->Parameters.FileSystemControl.FsControlCode ==
             FSCTL_INVALIDATE_VOLUMES)) {
 
            Status = FatInvalidateVolumes( Irp );
 
        } else {
 
            IrpContext = FatCreateIrpContext( Irp, Wait );
 
            Status = FatCommonFileSystemControl( IrpContext, Irp );
        }
 
    } _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
        //
        //  We had some trouble trying to perform the requested
        //  operation, so we'll abort the I/O request with
        //  the error status that we get back from the
        //  execption code
        //
 
        Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
    } _SEH2_END;
 
    if (TopLevel) { IoSetTopLevelIrp( NULL ); }
 
    FsRtlExitFileSystem();
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatFsdFileSystemControl -> %08lx\n", Status);
 
    return Status;
}

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 36 of file fsctrl.c.

{
    LBO Lbo;
    ULONG Index = 0;
    LONGLONG llVbo = 0;
 
    UNREFERENCED_PARAMETER(Vcb);
 
    while (FsRtlGetNextLargeMcbEntry(Mcb, Index, &llVbo, &Lbo, ByteCount)) {
        *Vbo = (VBO)llVbo;
        if (((ULONG)Lbo) == -1) {
            return FALSE;
        }
 
        Index++;
    }
 
    *Vbo = (VBO)llVbo;
 
    return TRUE;
}

FatAddMcbEntry()

BOOLEAN FatAddMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN VBO	Vbo,
		IN LBO	Lbo,
		IN ULONG	SectorCount
	)

Definition at line 364 of file fsctrl.c.

{
    BOOLEAN Result;
#if DBG
    VBO SparseVbo;
    LONGLONG SparseByteCount;
#endif
 
    PAGED_CODE();
 
    if (SectorCount) {
 
        //
        //  Round up sectors, but be careful as SectorCount approaches 4Gb.
        //  Note that for x>0, (x+m-1)/m = ((x-1)/m)+(m/m) = ((x-1)/m)+1
        //
 
        SectorCount--;
        SectorCount >>= MCB_SCALE_LOG2;
        SectorCount++;
    }
 
    Vbo >>= MCB_SCALE_LOG2;
    Lbo >>= MCB_SCALE_LOG2;
 
    NT_ASSERT( SectorCount != 0 );
 
    if (Mcb != &Vcb->DirtyFatMcb) {
        NT_ASSERT( FatNonSparseMcb( Vcb, Mcb, &SparseVbo, &SparseByteCount ) ||
                ((SparseVbo == Vbo) && (SparseByteCount == SectorCount )) );
    }
 
    Result = FsRtlAddLargeMcbEntry( Mcb,
                                  ((LONGLONG) Vbo),
                                  ((LONGLONG) Lbo),
                                  ((LONGLONG) SectorCount) );
 
    if (Mcb != &Vcb->DirtyFatMcb) {
        NT_ASSERT( FatNonSparseMcb( Vcb, Mcb, &SparseVbo, &SparseByteCount ) ||
                ((SparseVbo == Vbo) && (SparseByteCount == SectorCount )) );
    }
 
    return Result;
}

Referenced by _Requires_lock_held_(), FatComputeMoveFileSplicePoints(), FatExamineFatEntries(), and FatSetFatRun().

FatAllowExtendedDasdIo()

NTSTATUS FatAllowExtendedDasdIo	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 7022 of file fsctrl.c.

{
    PIO_STACK_LOCATION IrpSp;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    //
    //  Get the current Irp stack location and save some references.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Extract and decode the file object and check for type of open.
    //
 
    if (FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb ) != UserVolumeOpen) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    if ((Ccb == NULL) || !FlagOn( Ccb->Flags, CCB_FLAG_MANAGE_VOLUME_ACCESS )) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
        DebugTrace(-1, Dbg, "FatAllowExtendedDasdIo -> %08lx\n", STATUS_INVALID_PARAMETER);
        return STATUS_INVALID_PARAMETER;
    }
 
    SetFlag( Ccb->Flags, CCB_FLAG_ALLOW_EXTENDED_DASD_IO );
 
    FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
    return STATUS_SUCCESS;
}

FatComputeMoveFileSplicePoints()

VOID FatComputeMoveFileSplicePoints	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	FcbOrDcb,
		IN ULONG	FileOffset,
		IN ULONG	TargetCluster,
		IN ULONG	BytesToReallocate,
		OUT PULONG	FirstSpliceSourceCluster,
		OUT PULONG	FirstSpliceTargetCluster,
		OUT PULONG	SecondSpliceSourceCluster,
		OUT PULONG	SecondSpliceTargetCluster,
		IN OUT PLARGE_MCB	SourceMcb
	)

Definition at line 6822 of file fsctrl.c.

{
    VBO SourceVbo;
    LBO SourceLbo;
    ULONG SourceIndex;
    ULONG SourceBytesInRun;
    ULONG SourceBytesRemaining;
 
    ULONG SourceMcbVbo = 0;
    ULONG SourceMcbBytesInRun = 0;
 
    PVCB Vcb;
    BOOLEAN Result;
 
    PAGED_CODE();
 
    Vcb = FcbOrDcb->Vcb;
 
    //
    //  Get information on the final cluster in the previous allocation and
    //  prepare to enumerate it in the follow loop.
    //
 
    if (FileOffset == 0) {
 
        SourceIndex = 0;
        *FirstSpliceSourceCluster = 0;
        Result = FatGetNextMcbEntry( Vcb, &FcbOrDcb->Mcb,
                                     0,
                                     &SourceVbo,
                                     &SourceLbo,
                                     &SourceBytesInRun );
 
    } else {
 
        Result = FatLookupMcbEntry( Vcb, &FcbOrDcb->Mcb,
                                    FileOffset-1,
                                    &SourceLbo,
                                    &SourceBytesInRun,
                                    &SourceIndex);
 
        *FirstSpliceSourceCluster = FatGetIndexFromLbo( Vcb, SourceLbo );
 
        if ((Result) && (SourceBytesInRun == 1)) {
 
            SourceIndex += 1;
            Result = FatGetNextMcbEntry( Vcb, &FcbOrDcb->Mcb,
                                         SourceIndex,
                                         &SourceVbo,
                                         &SourceLbo,
                                         &SourceBytesInRun);
 
        } else {
 
            SourceVbo = FileOffset;
            SourceLbo += 1;
            SourceBytesInRun -= 1;
        }
    }
 
    //
    //  Run should always be present, but don't bugcheck in the case where it's not.
    //
 
    if (!Result) {
 
        NT_ASSERT( FALSE);
        FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR);
    }
 
    //
    //  At this point the variables:
    //
    //  - SourceIndex - SourceLbo - SourceBytesInRun -
    //
    //  all correctly decribe the allocation to be removed.  In the loop
    //  below we will start here and continue enumerating the Mcb runs
    //  until we are finished with the allocation to be relocated.
    //
 
    *FirstSpliceTargetCluster = TargetCluster;
 
    *SecondSpliceSourceCluster =
         *FirstSpliceTargetCluster +
         (BytesToReallocate >> Vcb->AllocationSupport.LogOfBytesPerCluster) - 1;
 
    for (SourceBytesRemaining = BytesToReallocate, SourceMcbVbo = 0;
 
         SourceBytesRemaining > 0;
 
         SourceIndex += 1,
         SourceBytesRemaining -= SourceMcbBytesInRun,
         SourceMcbVbo += SourceMcbBytesInRun) {
 
        if (SourceMcbVbo != 0) {
#ifdef _MSC_VER
#pragma prefast( suppress:28931, "needed for debug build" )
#endif
            Result = FatGetNextMcbEntry( Vcb, &FcbOrDcb->Mcb,
                                         SourceIndex,
                                         &SourceVbo,
                                         &SourceLbo,
                                         &SourceBytesInRun );
            NT_ASSERT( Result);
        }
 
        NT_ASSERT( SourceVbo == SourceMcbVbo + FileOffset );
 
        SourceMcbBytesInRun =
            SourceBytesInRun < SourceBytesRemaining ?
            SourceBytesInRun : SourceBytesRemaining;
 
        FatAddMcbEntry( Vcb, SourceMcb,
                        SourceMcbVbo,
                        SourceLbo,
                        SourceMcbBytesInRun );
    }
 
    //
    //  Now compute the cluster of the target of the second
    //  splice.  If the final run in the above loop was
    //  more than we needed, then we can just do arithmetic,
    //  otherwise we have to look up the next run.
    //
 
    if (SourceMcbBytesInRun < SourceBytesInRun) {
 
        *SecondSpliceTargetCluster =
            FatGetIndexFromLbo( Vcb, SourceLbo + SourceMcbBytesInRun );
 
    } else {
 
        if (FatGetNextMcbEntry( Vcb, &FcbOrDcb->Mcb,
                                SourceIndex,
                                &SourceVbo,
                                &SourceLbo,
                                &SourceBytesInRun )) {
 
            *SecondSpliceTargetCluster = FatGetIndexFromLbo( Vcb, SourceLbo );
 
        } else {
 
            *SecondSpliceTargetCluster = FAT_CLUSTER_LAST;
        }
    }
}

FatGetNextMcbEntry()

BOOLEAN FatGetNextMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN ULONG	RunIndex,
		OUT PVBO	Vbo,
		OUT PLBO	Lbo,
		OUT PULONG	ByteCount
	)

Definition at line 541 of file fsctrl.c.

{
    BOOLEAN Results;
    LONGLONG LiVbo;
    LONGLONG LiLbo;
    LONGLONG LiSectorCount;
 
    PAGED_CODE();
 
    LiVbo = LiLbo = 0;
 
    Results = FsRtlGetNextLargeMcbEntry( Mcb,
                                         RunIndex,
                                         &LiVbo,
                                         &LiLbo,
                                         &LiSectorCount );
 
    if (Results) {
 
        *Vbo = ((VBO) LiVbo) << MCB_SCALE_LOG2;
 
        if (((ULONG) LiLbo) != -1) {
 
            *Lbo = ((LBO) LiLbo) << MCB_SCALE_LOG2;
 
        } else {
 
            *Lbo = 0;
        }
 
        *ByteCount = ((ULONG) LiSectorCount) << MCB_SCALE_LOG2;
 
        if ((*ByteCount == 0) && (LiSectorCount != 0)) {
 
            //
            //  If 'ByteCount' overflows, then this is likely a file of
            //  max supported size (2^32 - 1) in one contiguous run.
            //
 
            NT_ASSERT( RunIndex == 0 );
 
            *ByteCount = 0xFFFFFFFF;
        }
    }
 
    return Results;
}

Referenced by _Requires_lock_held_(), FatComputeMoveFileSplicePoints(), and FatPagingFileIo().

FatGetStatistics()

NTSTATUS FatGetStatistics	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 4892 of file fsctrl.c.

{
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status;
    PVCB Vcb;
 
    PFILE_SYSTEM_STATISTICS Buffer;
    ULONG BufferLength;
    ULONG StatsSize;
    ULONG BytesToCopy;
 
    PAGED_CODE();
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatGetStatistics...\n", 0);
 
    //
    // Extract the buffer
    //
 
    BufferLength = IrpSp->Parameters.FileSystemControl.OutputBufferLength;
 
    //
    //  Get a pointer to the output buffer.
    //
 
    Buffer = Irp->AssociatedIrp.SystemBuffer;
 
    //
    //  Make sure the buffer is big enough for at least the common part.
    //
 
    if (BufferLength < sizeof(FILESYSTEM_STATISTICS)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_BUFFER_TOO_SMALL );
 
        DebugTrace(-1, Dbg, "FatGetStatistics -> %08lx\n", STATUS_BUFFER_TOO_SMALL );
 
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    //
    //  Now see how many bytes we can copy.
    //
 
    StatsSize = sizeof(FILE_SYSTEM_STATISTICS) * FatData.NumberProcessors;
 
    if (BufferLength < StatsSize) {
 
        BytesToCopy = BufferLength;
        Status = STATUS_BUFFER_OVERFLOW;
 
    } else {
 
        BytesToCopy = StatsSize;
        Status =  STATUS_SUCCESS;
    }
 
    //
    //  Get the Vcb.
    //
 
    Vcb = &((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Vcb;
 
    //
    //  Fill in the output buffer
    //
 
    RtlCopyMemory( Buffer, Vcb->Statistics, BytesToCopy );
 
    Irp->IoStatus.Information = BytesToCopy;
 
    FatCompleteRequest( IrpContext, Irp, Status );
 
    DebugTrace(-1, Dbg, "FatGetStatistics -> %08lx\n", Status);
 
    return Status;
}

FatIsBootSectorFat()

BOOLEAN FatIsBootSectorFat

(

IN PPACKED_BOOT_SECTOR

BootSector

)

Definition at line 2522 of file fsctrl.c.

{
    BOOLEAN Result;
    BIOS_PARAMETER_BLOCK Bpb = {0};
 
    DebugTrace(+1, Dbg, "FatIsBootSectorFat, BootSector = %p\n", BootSector);
 
    //
    //  The result is true unless we decide that it should be false
    //
 
    Result = TRUE;
 
    //
    //  Unpack the bios and then test everything
    //
 
    FatUnpackBios( &Bpb, &BootSector->PackedBpb );
    if (Bpb.Sectors != 0) { Bpb.LargeSectors = 0; }
 
    if ((BootSector->Jump[0] != 0xe9) &&
        (BootSector->Jump[0] != 0xeb) &&
        (BootSector->Jump[0] != 0x49)) {
 
        Result = FALSE;
 
    //
    //  Enforce some sanity on the sector size (easy check)
    //
 
    } else if ((Bpb.BytesPerSector !=  128) &&
               (Bpb.BytesPerSector !=  256) &&
               (Bpb.BytesPerSector !=  512) &&
               (Bpb.BytesPerSector != 1024) &&
               (Bpb.BytesPerSector != 2048) &&
               (Bpb.BytesPerSector != 4096)) {
 
        Result = FALSE;
 
    //
    //  Likewise on the clustering.
    //
 
    } else if ((Bpb.SectorsPerCluster !=  1) &&
               (Bpb.SectorsPerCluster !=  2) &&
               (Bpb.SectorsPerCluster !=  4) &&
               (Bpb.SectorsPerCluster !=  8) &&
               (Bpb.SectorsPerCluster != 16) &&
               (Bpb.SectorsPerCluster != 32) &&
               (Bpb.SectorsPerCluster != 64) &&
               (Bpb.SectorsPerCluster != 128)) {
 
        Result = FALSE;
 
    //
    //  Likewise on the reserved sectors (must reflect at least the boot sector!)
    //
 
    } else if (Bpb.ReservedSectors == 0) {
 
        Result = FALSE;
 
    //
    //  No FATs? Wrong ...
    //
 
    } else if (Bpb.Fats == 0) {
 
        Result = FALSE;
 
    //
    // Prior to DOS 3.2 might contains value in both of Sectors and
    // Sectors Large.
    //
 
    } else if ((Bpb.Sectors == 0) && (Bpb.LargeSectors == 0)) {
 
        Result = FALSE;
 
    //
    //  Check that FAT32 (SectorsPerFat == 0) claims some FAT space and
    //  is of a version we recognize, currently Version 0.0.
    //
 
    } else if (Bpb.SectorsPerFat == 0 && ( Bpb.LargeSectorsPerFat == 0 ||
                                           Bpb.FsVersion != 0 )) {
 
        Result = FALSE;
 
    } else if ((Bpb.Media != 0xf0) &&
               (Bpb.Media != 0xf8) &&
               (Bpb.Media != 0xf9) &&
               (Bpb.Media != 0xfb) &&
               (Bpb.Media != 0xfc) &&
               (Bpb.Media != 0xfd) &&
               (Bpb.Media != 0xfe) &&
               (Bpb.Media != 0xff) &&
               (!FatData.FujitsuFMR || ((Bpb.Media != 0x00) &&
                                        (Bpb.Media != 0x01) &&
                                        (Bpb.Media != 0xfa)))) {
 
        Result = FALSE;
 
    //
    //  If this isn't FAT32, then there better be a claimed root directory
    //  size here ...
    //
 
    } else if (Bpb.SectorsPerFat != 0 && Bpb.RootEntries == 0) {
 
        Result = FALSE;
 
    //
    //  If this is FAT32 (i.e., extended BPB), look for and refuse to mount
    //  mirror-disabled volumes. If we did, we would need to only write to
    //  the FAT# indicated in the ActiveFat field. The only user of this is
    //  the FAT->FAT32 converter after the first pass of protected mode work
    //  (booting into realmode) and NT should absolutely not be attempting
    //  to mount such an in-transition volume.
    //
 
    } else if (Bpb.SectorsPerFat == 0 && Bpb.MirrorDisabled) {
 
        Result = FALSE;
    }
 
    DebugTrace(-1, Dbg, "FatIsBootSectorFat -> %08lx\n", Result);
 
    return Result;
}

FatIsMediaWriteProtected()

BOOLEAN FatIsMediaWriteProtected	(	IN PIRP_CONTEXT	IrpContext,
		IN PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 2678 of file fsctrl.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Query the partition table
    //
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    //
    //  See if the media is write protected.  On success or any kind
    //  of error (possibly illegal device function), assume it is
    //  writeable, and only complain if he tells us he is write protected.
    //
 
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_IS_WRITABLE,
                                         TargetDeviceObject,
                                         NULL,
                                         0,
                                         NULL,
                                         0,
                                         FALSE,
                                         &Event,
                                         &Iosb );
 
    //
    //  Just return FALSE in the unlikely event we couldn't allocate an Irp.
    //
 
    if ( Irp == NULL ) {
 
        return FALSE;
    }
 
    SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
    Status = IoCallDriver( TargetDeviceObject, Irp );
 
    if ( Status == STATUS_PENDING ) {
 
        (VOID) KeWaitForSingleObject( &Event,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      (PLARGE_INTEGER)NULL );
 
        Status = Iosb.Status;
    }
 
    return (BOOLEAN)(Status == STATUS_MEDIA_WRITE_PROTECTED);
}

FatIsPathnameValid()

NTSTATUS FatIsPathnameValid	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 4168 of file fsctrl.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatIsPathnameValid...\n", 0);
 
    FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
 
    DebugTrace(-1, Dbg, "FatIsPathnameValid -> %08lx\n", STATUS_SUCCESS);
 
    return STATUS_SUCCESS;
}

FatIsVolumeDirty()

NTSTATUS FatIsVolumeDirty	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 3965 of file fsctrl.c.

{
    PIO_STACK_LOCATION IrpSp;
 
    TYPE_OF_OPEN TypeOfOpen;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PULONG VolumeState;
 
    PAGED_CODE();
 
    //
    //  Get the current stack location and extract the output
    //  buffer information.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Get a pointer to the output buffer.  Look at the system buffer field in the
    //  irp first.  Then the Irp Mdl.
    //
 
    if (Irp->AssociatedIrp.SystemBuffer != NULL) {
 
        VolumeState = Irp->AssociatedIrp.SystemBuffer;
 
    } else if (Irp->MdlAddress != NULL) {
 
        VolumeState = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, LowPagePriority | MdlMappingNoExecute );
 
        if (VolumeState == NULL) {
 
            FatCompleteRequest( IrpContext, Irp, STATUS_INSUFFICIENT_RESOURCES );
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    } else {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_USER_BUFFER );
        return STATUS_INVALID_USER_BUFFER;
    }
 
    //
    //  Make sure the output buffer is large enough and then initialize
    //  the answer to be that the volume isn't dirty.
    //
 
    if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < sizeof(ULONG)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    *VolumeState = 0;
 
    //
    //  Decode the file object
    //
 
    TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
 
    if (TypeOfOpen != UserVolumeOpen) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
        return STATUS_INVALID_PARAMETER;
    }
 
    if (Vcb->VcbCondition != VcbGood) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_VOLUME_DISMOUNTED );
        return STATUS_VOLUME_DISMOUNTED;
    }
 
    //
    //  Disable PopUps, we want to return any error.
    //
 
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS);
 
    //
    //  Verify the Vcb.  We want to make double sure that this volume
    //  is around so that we know our information is good.
    //
 
    FatVerifyVcb( IrpContext, Vcb );
 
    //
    //  Now set the returned information.  We can avoid probing the disk since
    //  we know our internal state is in sync.
    //
 
    if ( FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNTED_DIRTY) ) {
 
        SetFlag( *VolumeState, VOLUME_IS_DIRTY );
    }
 
    Irp->IoStatus.Information = sizeof( ULONG );
 
    FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
    return STATUS_SUCCESS;
}

FatIsVolumeMounted()

NTSTATUS FatIsVolumeMounted	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 4096 of file fsctrl.c.

{
    NTSTATUS Status;
 
    PIO_STACK_LOCATION IrpSp;
 
    PVCB Vcb = NULL;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    Status = STATUS_SUCCESS;
 
    DebugTrace(+1, Dbg, "FatIsVolumeMounted...\n", 0);
 
    //
    //  Decode the file object.
    //
 
    (VOID)FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
 
    NT_ASSERT( Vcb != NULL );
    _Analysis_assume_( Vcb != NULL );
 
    //
    //  Disable PopUps, we want to return any error.
    //
 
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS);
 
    //
    //  Verify the Vcb.
    //
 
    FatVerifyVcb( IrpContext, Vcb );
 
    FatCompleteRequest( IrpContext, Irp, Status );
 
    DebugTrace(-1, Dbg, "FatIsVolumeMounted -> %08lx\n", Status);
 
    return Status;
}

FatLookupLastMcbEntry()

BOOLEAN FatLookupLastMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		OUT PVBO	Vbo,
		OUT PLBO	Lbo,
		OUT PULONG Index	OPTIONAL
	)

Definition at line 494 of file fsctrl.c.

{
    BOOLEAN Results;
    LONGLONG LiVbo;
    LONGLONG LiLbo;
    ULONG LocalIndex;
 
    PAGED_CODE();
 
    LiVbo = LiLbo = 0;
    LocalIndex = 0;
 
    Results = FsRtlLookupLastLargeMcbEntryAndIndex( Mcb,
                                                    &LiVbo,
                                                    &LiLbo,
                                                    &LocalIndex );
 
    *Vbo = ((VBO) LiVbo) << MCB_SCALE_LOG2;
 
    if (((ULONG) LiLbo) != -1) {
 
        *Lbo = ((LBO) LiLbo) << MCB_SCALE_LOG2;
 
        *Lbo += (MCB_SCALE - 1);
        *Vbo += (MCB_SCALE - 1);
 
    } else {
 
        *Lbo = 0;
    }
 
    if (Index) {
        *Index = LocalIndex;
    }
 
    return Results;
}

Referenced by _Requires_lock_held_().

FatLookupMcbEntry()

BOOLEAN FatLookupMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN VBO	Vbo,
		OUT PLBO	Lbo,
		OUT PULONG ByteCount	OPTIONAL,
		OUT PULONG Index	OPTIONAL
	)

Definition at line 418 of file fsctrl.c.

{
    BOOLEAN Results;
    LONGLONG LiLbo;
    LONGLONG LiSectorCount;
    ULONG Remainder;
 
    LiLbo = 0;
    LiSectorCount = 0;
 
    Remainder = Vbo & MCB_SCALE_MODULO;
 
    Results = FsRtlLookupLargeMcbEntry( Mcb,
                                        (Vbo >> MCB_SCALE_LOG2),
                                        &LiLbo,
                                        ARGUMENT_PRESENT(ByteCount) ? &LiSectorCount : NULL,
                                        NULL,
                                        NULL,
                                        Index );
 
    if ((ULONG) LiLbo != -1) {
 
        *Lbo = (((LBO) LiLbo) << MCB_SCALE_LOG2);
 
        if (Results) {
 
            *Lbo += Remainder;
        }
 
    } else {
 
        *Lbo = 0;
    }
 
    if (ARGUMENT_PRESENT(ByteCount)) {
 
        *ByteCount = (ULONG) LiSectorCount;
 
        if (*ByteCount) {
 
            *ByteCount <<= MCB_SCALE_LOG2;
 
            //
            //  If ByteCount overflows, then this is likely the case of
            //  a file of max-supported size (4GiB - 1), allocated in a
            //  single continuous run.
            //
 
            if (*ByteCount == 0) {
 
                *ByteCount = 0xFFFFFFFF;
            }
 
            if (Results) {
 
                *ByteCount -= Remainder;
            }
        }
 
    }
 
    return Results;
}

Referenced by _Requires_lock_held_(), FatComputeMoveFileSplicePoints(), and FatPagingFileIo().

FatPerformVerifyDiskRead()

BOOLEAN FatPerformVerifyDiskRead	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PVOID	Buffer,
		IN LBO	Lbo,
		IN ULONG	NumberOfBytesToRead,
		IN BOOLEAN	ReturnOnError
	)

Definition at line 4569 of file fsctrl.c.

{
    KEVENT Event;
    PIRP Irp;
    LARGE_INTEGER ByteOffset;
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;
 
    PAGED_CODE();
 
    DebugTrace(0, Dbg, "FatPerformVerifyDiskRead, Lbo = %08lx\n", Lbo );
 
    //
    //  Initialize the event we're going to use
    //
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    //
    //  Build the irp for the operation and also set the overrride flag
    //
 
    ByteOffset.QuadPart = Lbo;
 
    Irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ,
                                        Vcb->TargetDeviceObject,
                                        Buffer,
                                        NumberOfBytesToRead,
                                        &ByteOffset,
                                        &Event,
                                        &Iosb );
 
    if ( Irp == NULL ) {
 
        FatRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
    }
 
    SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
 
    //
    //  Call the device to do the read and wait for it to finish.
    //
 
    Status = IoCallDriver( Vcb->TargetDeviceObject, Irp );
 
    if (Status == STATUS_PENDING) {
 
        (VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, (PLARGE_INTEGER)NULL );
 
        Status = Iosb.Status;
    }
 
    NT_ASSERT( Status != STATUS_VERIFY_REQUIRED );
 
    //
    //  Special case this error code because this probably means we used
    //  the wrong sector size and we want to reject STATUS_WRONG_VOLUME.
    //
 
    if (Status == STATUS_INVALID_PARAMETER) {
 
        return FALSE;
    }
 
    //
    //  If it doesn't succeed then either return or raise the error.
    //
 
    if (!NT_SUCCESS(Status)) {
 
        if (ReturnOnError) {
 
            return FALSE;
 
        } else {
 
            FatNormalizeAndRaiseStatus( IrpContext, Status );
        }
    }
 
    //
    //  And return to our caller
    //
 
    return TRUE;
}

Referenced by FatVerifyLookupFatEntry().

FatQueryBpb()

NTSTATUS FatQueryBpb	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 4213 of file fsctrl.c.

{
    PIO_STACK_LOCATION IrpSp;
 
    PVCB Vcb;
 
    PFSCTL_QUERY_FAT_BPB_BUFFER BpbBuffer;
 
    PAGED_CODE();
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatQueryBpb...\n", 0);
 
    //
    //  Get the Vcb.  If we didn't keep the information needed for this call,
    //  we had a reason ...
    //
 
    Vcb = &((PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject)->Vcb;
 
    if (Vcb->First0x24BytesOfBootSector == NULL) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST );
        DebugTrace(-1, Dbg, "FatQueryBpb -> %08lx\n", STATUS_INVALID_DEVICE_REQUEST );
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    //
    // Extract the buffer
    //
 
    BpbBuffer = (PFSCTL_QUERY_FAT_BPB_BUFFER)Irp->AssociatedIrp.SystemBuffer;
 
    //
    //  Make sure the buffer is big enough.
    //
 
    if (IrpSp->Parameters.FileSystemControl.OutputBufferLength < 0x24) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_BUFFER_TOO_SMALL );
        DebugTrace(-1, Dbg, "FatQueryBpb -> %08lx\n", STATUS_BUFFER_TOO_SMALL );
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    //
    //  Fill in the output buffer
    //
 
    RtlCopyMemory( BpbBuffer->First0x24BytesOfBootSector,
                   Vcb->First0x24BytesOfBootSector,
                   0x24 );
 
    Irp->IoStatus.Information = 0x24;
 
    FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
    DebugTrace(-1, Dbg, "FatQueryBpb -> %08lx\n", STATUS_SUCCESS);
    return STATUS_SUCCESS;
}

FatRemoveMcbEntry()

VOID FatRemoveMcbEntry	(	IN PVCB	Vcb,
		IN PLARGE_MCB	Mcb,
		IN VBO	Vbo,
		IN ULONG	SectorCount
	)

Definition at line 599 of file fsctrl.c.

{
    PAGED_CODE();
 
    if ((SectorCount) && (SectorCount != 0xFFFFFFFF)) {
 
        SectorCount--;
        SectorCount >>= MCB_SCALE_LOG2;
        SectorCount++;
    }
 
    Vbo >>= MCB_SCALE_LOG2;
 
#if DBG
    _SEH2_TRY {
#endif
 
        FsRtlRemoveLargeMcbEntry( Mcb,
                                  (LONGLONG) Vbo,
                                  (LONGLONG) SectorCount);
 
#if DBG
    } _SEH2_EXCEPT(FatBugCheckExceptionFilter( _SEH2_GetExceptionInformation() )) {
 
          NOTHING;
    } _SEH2_END;
#endif
 
}

Referenced by _Requires_lock_held_(), FatCloseEaFile(), and FatTearDownAllocationSupport().

FatSearchBufferForLabel()

NTSTATUS FatSearchBufferForLabel	(	IN PIRP_CONTEXT	IrpContext,
		IN PVPB	Vpb,
		IN PVOID	Buffer,
		IN ULONG	Size,
		OUT PBOOLEAN	LabelFound
	)

Definition at line 7819 of file fsctrl.c.

{
    NTSTATUS Status;
    WCHAR UnicodeBuffer[11];
 
    PDIRENT Dirent;
    PDIRENT TerminationDirent;
    ULONG VolumeLabelLength;
    UCHAR OemBuffer[11];
    OEM_STRING OemString;
    UNICODE_STRING UnicodeString;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    Dirent = Buffer;
 
    TerminationDirent = Dirent + Size / sizeof(DIRENT);
 
    while ( Dirent < TerminationDirent ) {
 
        if ( Dirent->FileName[0] == FAT_DIRENT_NEVER_USED ) {
 
            Dirent = TerminationDirent;
            break;
        }
 
        //
        //  If the entry is the non-deleted volume label break from the loop.
        //
        //  Note that all out parameters are already correctly set.
        //
 
        if (((Dirent->Attributes & ~FAT_DIRENT_ATTR_ARCHIVE) ==
             FAT_DIRENT_ATTR_VOLUME_ID) &&
            (Dirent->FileName[0] != FAT_DIRENT_DELETED)) {
 
            break;
        }
 
        Dirent += 1;
    }
 
    if (Dirent >= TerminationDirent) {
 
        //
        //  We've run out of buffer.
        //
 
        *LabelFound = FALSE;
        return STATUS_SUCCESS;
    }
 
 
    OemString.Buffer = (PCHAR)&OemBuffer[0];
    OemString.MaximumLength = 11;
 
    RtlCopyMemory( OemString.Buffer, Dirent->FileName, 11 );
 
    //
    //  Translate the first character from 0x5 to 0xe5.
    //
 
    if (OemString.Buffer[0] == FAT_DIRENT_REALLY_0E5) {
 
        OemString.Buffer[0] = 0xe5;
    }
 
    //
    //  Compute the length of the volume name
    //
 
    for ( OemString.Length = 11;
          OemString.Length > 0;
          OemString.Length -= 1) {
 
        if ( (OemString.Buffer[OemString.Length-1] != 0x00) &&
             (OemString.Buffer[OemString.Length-1] != 0x20) ) { break; }
    }
 
    UnicodeString.MaximumLength = sizeof( UnicodeBuffer );
    UnicodeString.Buffer = &UnicodeBuffer[0];
 
    Status = RtlOemStringToCountedUnicodeString( &UnicodeString,
                                                 &OemString,
                                                 FALSE );
 
    if ( !NT_SUCCESS( Status ) ) {
 
        return Status;
    }
 
    VolumeLabelLength = UnicodeString.Length;
 
    if ( (VolumeLabelLength != (ULONG)Vpb->VolumeLabelLength) ||
         (!RtlEqualMemory(&UnicodeBuffer[0],
                          &Vpb->VolumeLabel[0],
                          VolumeLabelLength)) ) {
 
        return STATUS_WRONG_VOLUME;
    }
 
    //
    //  We found a matching label.
    //
 
    *LabelFound = TRUE;
    return STATUS_SUCCESS;
}

FatSetZeroOnDeallocate()

NTSTATUS FatSetZeroOnDeallocate	(	__in PIRP_CONTEXT	IrpContext,
		__in PIRP	Irp
	)

Definition at line 8123 of file fsctrl.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    PVCB Vcb;
    PFCB FcbOrDcb;
    PCCB Ccb;
 
    TYPE_OF_OPEN TypeOfOpen;
 
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    BOOLEAN ReleaseFcb = FALSE;
 
    PAGED_CODE();
 
    //
    //  This call should always be synchronous.
    //
 
    SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
    TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &FcbOrDcb, &Ccb );
 
    if ((TypeOfOpen != UserFileOpen) ||
        (!IrpSp->FileObject->WriteAccess) ) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_ACCESS_DENIED );
        return STATUS_ACCESS_DENIED;
    }
 
    //
    //  Readonly mount should be just that: read only.
    //
 
    if (FlagOn( Vcb->VcbState, VCB_STATE_FLAG_WRITE_PROTECTED)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_MEDIA_WRITE_PROTECTED );
        return STATUS_MEDIA_WRITE_PROTECTED;
    }
 
    //
    // Acquire main then paging to exclude everyone from this FCB.
    //
 
    FatAcquireExclusiveFcb(IrpContext, FcbOrDcb);
    ReleaseFcb = TRUE;
 
    _SEH2_TRY {
 
        SetFlag( FcbOrDcb->FcbState, FCB_STATE_ZERO_ON_DEALLOCATION );
 
    } _SEH2_FINALLY {
 
        if (ReleaseFcb) {
            FatReleaseFcb(IrpContext, FcbOrDcb);
        }
 
    } _SEH2_END;
 
    FatCompleteRequest( IrpContext, Irp, Status );
    return Status;
}

FatUnlockVolume()

NTSTATUS FatUnlockVolume	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 3354 of file fsctrl.c.

{
    NTSTATUS Status;
 
    PIO_STACK_LOCATION IrpSp;
 
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatUnlockVolume...\n", 0);
 
    //
    //  Decode the file object, the only type of opens we accept are
    //  user volume opens.
    //
 
    if (FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb ) != UserVolumeOpen) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
        DebugTrace(-1, Dbg, "FatUnlockVolume -> %08lx\n", STATUS_INVALID_PARAMETER);
        return STATUS_INVALID_PARAMETER;
    }
 
    if ((Ccb == NULL) || !FlagOn( Ccb->Flags, CCB_FLAG_MANAGE_VOLUME_ACCESS )) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
        DebugTrace(-1, Dbg, "FatUnlockVolume -> %08lx\n", STATUS_INVALID_PARAMETER);
        return STATUS_INVALID_PARAMETER;
    }
 
    Status = FatUnlockVolumeInternal( IrpContext, Vcb, IrpSp->FileObject );
 
    //
    //  Send notification that the volume is avaliable.
    //
 
    if (NT_SUCCESS( Status )) {
 
        FsRtlNotifyVolumeEvent( IrpSp->FileObject, FSRTL_VOLUME_UNLOCK );
    }
 
    FatCompleteRequest( IrpContext, Irp, Status );
 
    DebugTrace(-1, Dbg, "FatUnlockVolume -> %08lx\n", Status);
 
    return Status;
}

FatUnlockVolumeInternal()

NTSTATUS FatUnlockVolumeInternal	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PFILE_OBJECT FileObject	OPTIONAL
	)

Definition at line 3601 of file fsctrl.c.

{
    KIRQL SavedIrql;
    NTSTATUS Status = STATUS_NOT_LOCKED;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    IoAcquireVpbSpinLock( &SavedIrql );
 
    if (FlagOn(Vcb->Vpb->Flags, VPB_LOCKED) && FileObject == Vcb->FileObjectWithVcbLocked) {
 
        //
        //  This one locked it, unlock the volume
        //
 
        ClearFlag( Vcb->Vpb->Flags, (VPB_LOCKED | VPB_DIRECT_WRITES_ALLOWED) );
        ClearFlag( Vcb->VcbState, VCB_STATE_FLAG_LOCKED );
        Vcb->FileObjectWithVcbLocked = NULL;
 
        Status = STATUS_SUCCESS;
    }
 
    IoReleaseVpbSpinLock( SavedIrql );
 
    return Status;
}

Referenced by FatUnlockVolume().

FatVerifyLookupFatEntry()

VOID FatVerifyLookupFatEntry	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN ULONG	FatIndex,
		IN OUT PULONG	FatEntry
	)

Definition at line 7969 of file fsctrl.c.

{
    ULONG PageEntryOffset;
    ULONG OffsetIntoVolumeFile;
    PVOID Buffer;
 
    PAGED_CODE();
 
    NT_ASSERT(Vcb->AllocationSupport.FatIndexBitSize == 32);
 
    FatVerifyIndexIsValid( IrpContext, Vcb, FatIndex);
 
    Buffer = FsRtlAllocatePoolWithTag( NonPagedPoolNxCacheAligned,
                                       PAGE_SIZE,
                                       TAG_ENTRY_LOOKUP_BUFFER );
 
    OffsetIntoVolumeFile =  FatReservedBytes(&Vcb->Bpb) + FatIndex * sizeof(ULONG);
    PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) / sizeof(ULONG);
 
    _SEH2_TRY {
 
        FatPerformVerifyDiskRead( IrpContext,
                                  Vcb,
                                  Buffer,
                                  OffsetIntoVolumeFile & ~(PAGE_SIZE - 1),
                                  PAGE_SIZE,
                                  TRUE );
 
        *FatEntry = ((PULONG)(Buffer))[PageEntryOffset];
 
    } _SEH2_FINALLY {
 
        ExFreePool( Buffer );
    } _SEH2_END;
}