easup.c File Reference

#include "fatprocs.h"

Include dependency graph for easup.c:

Go to the source code of this file.

Macros
#define	Dbg   (DEBUG_TRACE_EA)
#define	EA_SECTION_SIZE   (0x00040000)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
VOID	FatReadEaSet (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN USHORT EaHandle, IN POEM_STRING FileName, IN BOOLEAN ReturnEntireSet, OUT PEA_RANGE EaSetRange)
VOID	FatAppendPackedEa (IN PIRP_CONTEXT IrpContext, IN OUT PEA_SET_HEADER *EaSetHeader, IN OUT PULONG PackedEasLength, IN OUT PULONG AllocationLength, IN PFILE_FULL_EA_INFORMATION FullEa, IN ULONG BytesPerCluster)
VOID	FatDeletePackedEa (IN PIRP_CONTEXT IrpContext, IN OUT PEA_SET_HEADER EaSetHeader, IN OUT PULONG PackedEasLength, IN ULONG Offset)
ULONG	FatLocateNextEa (IN PIRP_CONTEXT IrpContext, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, IN ULONG PreviousOffset)
BOOLEAN	FatLocateEaByName (IN PIRP_CONTEXT IrpContext, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, IN POEM_STRING EaName, OUT PULONG Offset)
BOOLEAN	FatIsEaNameValid (IN PIRP_CONTEXT IrpContext, IN OEM_STRING Name)
VOID	FatPinEaRange (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT VirtualEaFile, IN PFCB EaFcb, IN OUT PEA_RANGE EaRange, IN ULONG StartingVbo, IN ULONG Length, IN NTSTATUS ErrorStatus)
VOID	FatMarkEaRangeDirty (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT EaFileObject, IN OUT PEA_RANGE EaRange)
VOID	FatUnpinEaRange (IN PIRP_CONTEXT IrpContext, IN OUT PEA_RANGE EaRange)

Macro Definition Documentation

Dbg

#define Dbg   (DEBUG_TRACE_EA)

Definition at line 22 of file easup.c.

EA_SECTION_SIZE

#define EA_SECTION_SIZE   (0x00040000)

Definition at line 49 of file easup.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 52 of file easup.c.

{
    PBCB EaBcb = NULL;
    BOOLEAN LockedEaFcb = FALSE;
    EA_RANGE EaSetRange;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatGetEaLength ...\n", 0);
 
    //
    //  If this is Fat32 volume, or if the handle is 0 then the Ea length is 0.
    //
 
    if (FatIsFat32( Vcb ) ||
        Dirent->ExtendedAttributes == 0) {
 
        *EaLength = 0;
        DebugTrace(-1, Dbg, "FatGetEaLength -> %08lx\n", TRUE);
        return;
    }
 
    RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
    //
    //  Use a try to facilitate cleanup.
    //
 
    _SEH2_TRY {
 
        PDIRENT EaDirent;
        OEM_STRING ThisFilename;
        UCHAR Buffer[12];
        PEA_SET_HEADER EaSetHeader;
 
        //
        //  Initial the local values.
        //
 
        EaBcb = NULL;
        LockedEaFcb = FALSE;
 
        //
        //  Try to get the Ea file object.  Return FALSE on failure.
        //
 
        FatGetEaFile( IrpContext,
                      Vcb,
                      &EaDirent,
                      &EaBcb,
                      FALSE,
                      FALSE );
 
        LockedEaFcb = TRUE;
 
        //
        //  If we didn't get the file because it doesn't exist, then the
        //  disk is corrupted.
        //
 
        if (Vcb->VirtualEaFile == NULL) {
 
            DebugTrace(0, Dbg, "FatGetEaLength:  Ea file doesn't exist\n", 0);
            FatRaiseStatus( IrpContext, STATUS_NO_EAS_ON_FILE );
        }
 
        //
        //  Try to pin down the Ea set header for the index in the
        //  dirent.  If the operation doesn't complete, return FALSE
        //  from this routine.
        //
 
        ThisFilename.Buffer = (PCHAR)Buffer;
        Fat8dot3ToString( IrpContext, Dirent, FALSE, &ThisFilename );
 
        FatReadEaSet( IrpContext,
                      Vcb,
                      Dirent->ExtendedAttributes,
                      &ThisFilename,
                      FALSE,
                      &EaSetRange );
 
        EaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
        //
        //  We now have the Ea set header for this file.  We simply copy
        //  the Ea length field.
        //
 
        CopyUchar4( EaLength, EaSetHeader->cbList );
        DebugTrace(0, Dbg, "FatGetEaLength:  Length of Ea is -> %08lx\n",
                   *EaLength);
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatGetEaLength );
 
        //
        //  Unpin the EaDirent and the EaSetHeader if pinned.
        //
 
        FatUnpinBcb( IrpContext, EaBcb );
 
        FatUnpinEaRange( IrpContext, &EaSetRange );
 
        //
        //  Release the Fcb for the Ea file if locked.
        //
 
        if (LockedEaFcb) {
 
            FatReleaseFcb( IrpContext, Vcb->EaFcb );
        }
 
        DebugTrace(-1, Dbg, "FatGetEaLength:  Ea length -> %08lx\n", *EaLength);
    } _SEH2_END;
 
    return;
}

FatAppendPackedEa()

VOID FatAppendPackedEa	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PEA_SET_HEADER *	EaSetHeader,
		IN OUT PULONG	PackedEasLength,
		IN OUT PULONG	AllocationLength,
		IN PFILE_FULL_EA_INFORMATION	FullEa,
		IN ULONG	BytesPerCluster
	)

Definition at line 2967 of file easup.c.

{
    ULONG PackedEaSize;
    PPACKED_EA ThisPackedEa;
    OEM_STRING EaName;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatAppendPackedEa...\n", 0);
 
    //
    //  As a quick check see if the computed packed ea size plus the
    //  current packed ea list size will overflow the buffer.  Full Ea and
    //  packed Ea only differ by 4 in their size
    //
 
    PackedEaSize = SizeOfFullEa( FullEa ) - 4;
 
    if ( PackedEaSize + *PackedEasLength > *AllocationLength ) {
 
        //
        //  We will overflow our current work buffer so allocate a larger
        //  one and copy over the current buffer
        //
 
        PVOID Temp;
        ULONG NewAllocationSize;
        ULONG OldAllocationSize;
 
        DebugTrace(0, Dbg, "Allocate a new ea list buffer\n", 0);
 
        //
        //  Compute a new size and allocate space.  Always increase the
        //  allocation in cluster increments.
        //
 
        NewAllocationSize = (SIZE_OF_EA_SET_HEADER
                             + PackedEaSize
                             + *PackedEasLength
                             + BytesPerCluster - 1)
                            & ~(BytesPerCluster - 1);
 
        Temp = FsRtlAllocatePoolWithTag( PagedPool,
                                         NewAllocationSize,
                                         TAG_EA_SET_HEADER );
 
        //
        //  Move over the existing ea list, and deallocate the old one
        //
 
        RtlCopyMemory( Temp,
                       *EaSetHeader,
                       OldAllocationSize = *AllocationLength
                                           + SIZE_OF_EA_SET_HEADER );
 
        ExFreePool( *EaSetHeader );
 
        //
        //  Set up so we will use the new packed ea list
        //
 
        *EaSetHeader = Temp;
 
        //
        //  Zero out the added memory.
        //
 
        RtlZeroMemory( &(*EaSetHeader)->PackedEas[*AllocationLength],
                       NewAllocationSize - OldAllocationSize );
 
        *AllocationLength = NewAllocationSize - SIZE_OF_EA_SET_HEADER;
    }
 
    //
    //  Determine if we need to increment our need ea changes count
    //
 
    if ( FlagOn(FullEa->Flags, FILE_NEED_EA )) {
 
        //
        //  The NeedEaCount field is long aligned so we will write
        //  directly to it.
        //
 
        (*EaSetHeader)->NeedEaCount++;
    }
 
    //
    //  Now copy over the ea, full ea's and packed ea are identical except
    //  that full ea also have a next ea offset that we skip over
    //
    //  Before:
    //             UsedSize                     Allocated
    //                |                             |
    //                V                             V
    //      +xxxxxxxx+-----------------------------+
    //
    //  After:
    //                              UsedSize    Allocated
    //                                 |            |
    //                                 V            V
    //      +xxxxxxxx+yyyyyyyyyyyyyyyy+------------+
    //
 
    ThisPackedEa = (PPACKED_EA) (RtlOffsetToPointer( (*EaSetHeader)->PackedEas,
                                                     *PackedEasLength ));
 
    RtlCopyMemory( ThisPackedEa,
                   (PUCHAR) FullEa + 4,
                   PackedEaSize );
 
    //
    //  Now convert the name to uppercase.
    //
 
    EaName.MaximumLength = EaName.Length = FullEa->EaNameLength;
    EaName.Buffer = ThisPackedEa->EaName;
 
    FatUpcaseEaName( IrpContext, &EaName, &EaName );
 
    //
    //  Increment the used size in the packed ea list structure
    //
 
    *PackedEasLength += PackedEaSize;
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatAppendPackedEa -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by FatCommonSetEa().

FatDeletePackedEa()

VOID FatDeletePackedEa	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PEA_SET_HEADER	EaSetHeader,
		IN OUT PULONG	PackedEasLength,
		IN ULONG	Offset
	)

Definition at line 3148 of file easup.c.

{
    PPACKED_EA PackedEa;
    ULONG PackedEaSize;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDeletePackedEa, Offset = %08lx\n", Offset);
 
    //
    //  Get a reference to the packed ea and figure out its size
    //
 
    PackedEa = (PPACKED_EA) (&EaSetHeader->PackedEas[Offset]);
 
    SizeOfPackedEa( PackedEa, &PackedEaSize );
 
    //
    //  Determine if we need to decrement our need ea changes count
    //
 
    if (FlagOn(PackedEa->Flags, EA_NEED_EA_FLAG)) {
 
        EaSetHeader->NeedEaCount--;
    }
 
    //
    //  Shrink the ea list over the deleted ea.  The amount to copy is the
    //  total size of the ea list minus the offset to the end of the ea
    //  we're deleting.
    //
    //  Before:
    //              Offset    Offset+PackedEaSize      UsedSize    Allocated
    //                |                |                  |            |
    //                V                V                  V            V
    //      +xxxxxxxx+yyyyyyyyyyyyyyyy+zzzzzzzzzzzzzzzzzz+------------+
    //
    //  After
    //              Offset            UsedSize                     Allocated
    //                |                  |                             |
    //                V                  V                             V
    //      +xxxxxxxx+zzzzzzzzzzzzzzzzzz+-----------------------------+
    //
 
    RtlCopyMemory( PackedEa,
                   (PUCHAR) PackedEa + PackedEaSize,
                   *PackedEasLength - (Offset + PackedEaSize) );
 
    //
    //  And zero out the remaing part of the ea list, to make things
    //  nice and more robust
    //
 
    RtlZeroMemory( &EaSetHeader->PackedEas[*PackedEasLength - PackedEaSize],
                   PackedEaSize );
 
    //
    //  Decrement the used size by the amount we just removed
    //
 
    *PackedEasLength -= PackedEaSize;
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatDeletePackedEa -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

Referenced by FatCommonSetEa().

FatIsEaNameValid()

BOOLEAN FatIsEaNameValid	(	IN PIRP_CONTEXT	IrpContext,
		IN OEM_STRING	Name
	)

Definition at line 3429 of file easup.c.

{
    ULONG Index;
 
    UCHAR Char;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Empty names are not valid.
    //
 
    if ( Name.Length == 0 ) { return FALSE; }
 
    //
    //  At this point we should only have a single name, which can't have
    //  more than 254 characters
    //
 
    if ( Name.Length > 254 ) { return FALSE; }
 
    for ( Index = 0; Index < (ULONG)Name.Length; Index += 1 ) {
 
        Char = Name.Buffer[ Index ];
 
        //
        //  Skip over and Dbcs chacters
        //
 
        if ( FsRtlIsLeadDbcsCharacter( Char ) ) {
 
            NT_ASSERT( Index != (ULONG)(Name.Length - 1) );
 
            Index += 1;
 
            continue;
        }
 
        //
        //  Make sure this character is legal, and if a wild card, that
        //  wild cards are permissible.
        //
 
        if ( !FsRtlIsAnsiCharacterLegalFat(Char, FALSE) ) {
 
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by FatCommonSetEa().

FatLocateEaByName()

BOOLEAN FatLocateEaByName	(	IN PIRP_CONTEXT	IrpContext,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		IN POEM_STRING	EaName,
		OUT PULONG	Offset
	)

Definition at line 3344 of file easup.c.

{
    PPACKED_EA PackedEa;
    OEM_STRING Name;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatLocateEaByName, EaName = %Z\n", EaName);
 
    //
    //  For each packed ea in the list check its name against the
    //  ea name we're searching for
    //
 
    for ( *Offset = 0;
          *Offset < PackedEasLength;
          *Offset = FatLocateNextEa( IrpContext,
                                     FirstPackedEa,
                                     PackedEasLength,
                                     *Offset )) {
 
        //
        //  Reference the packed ea and get a string to its name
        //
 
        PackedEa = (PPACKED_EA) ((PUCHAR) FirstPackedEa + *Offset);
 
        Name.Buffer = &PackedEa->EaName[0];
        Name.Length = PackedEa->EaNameLength;
        Name.MaximumLength = PackedEa->EaNameLength;
 
        //
        //  Compare the two strings, if they are equal then we've
        //  found the caller's ea
        //
 
        if ( RtlCompareString( EaName, &Name, TRUE ) == 0 ) {
 
            DebugTrace(-1, Dbg, "FatLocateEaByName -> TRUE, *Offset = %08lx\n", *Offset);
            return TRUE;
        }
    }
 
    //
    //  We've exhausted the ea list without finding a match so return false
    //
 
    DebugTrace(-1, Dbg, "FatLocateEaByName -> FALSE\n", 0);
    return FALSE;
}

Referenced by FatCommonSetEa().

FatLocateNextEa()

ULONG FatLocateNextEa	(	IN PIRP_CONTEXT	IrpContext,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		IN ULONG	PreviousOffset
	)

Definition at line 3257 of file easup.c.

{
    PPACKED_EA PackedEa;
    ULONG PackedEaSize;
    ULONG Offset;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatLocateNextEa, PreviousOffset = %08lx\n",
               PreviousOffset);
 
    //
    //  Make sure the previous offset is within the used size range
    //
 
    if ( PreviousOffset >= PackedEasLength ) {
 
        DebugTrace(-1, Dbg, "FatLocateNextEa -> 0xffffffff\n", 0);
        return 0xffffffff;
    }
 
    //
    //  Get a reference to the previous packed ea, and compute its size
    //
 
    PackedEa = (PPACKED_EA) ((PUCHAR) FirstPackedEa + PreviousOffset );
    SizeOfPackedEa( PackedEa, &PackedEaSize );
 
    //
    //  Compute to the next ea
    //
 
    Offset = PreviousOffset + PackedEaSize;
 
    //
    //  Now, if the new offset is beyond the ea size then we know
    //  that there isn't one so, we return an offset of 0xffffffff.
    //  otherwise we'll leave the new offset alone.
    //
 
    if ( Offset >= PackedEasLength ) {
 
        Offset = 0xffffffff;
    }
 
    DebugTrace(-1, Dbg, "FatLocateNextEa -> %08lx\n", Offset);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return Offset;
}

Referenced by FatLocateEaByName().

FatMarkEaRangeDirty()

VOID FatMarkEaRangeDirty	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	EaFileObject,
		IN OUT PEA_RANGE	EaRange
	)

Definition at line 3709 of file easup.c.

{
    PBCB *NextBcb;
    ULONG BcbCount;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If there is an auxilary buffer we need to copy the data back into the cache.
    //
 
    if (EaRange->AuxilaryBuffer == TRUE) {
 
        LARGE_INTEGER LargeVbo;
 
        LargeVbo.QuadPart = EaRange->StartingVbo;
 
        CcCopyWrite( EaFileObject,
                     &LargeVbo,
                     EaRange->Length,
                     TRUE,
                     EaRange->Data );
    }
 
    //
    //  Now walk through the Bcb chain and mark everything dirty.
    //
 
    BcbCount = EaRange->BcbChainLength;
    NextBcb = EaRange->BcbChain;
 
    while (BcbCount--) {
 
        if (*NextBcb != NULL) {
 
            CcSetDirtyPinnedData( *NextBcb, NULL );
        }
 
        NextBcb += 1;
    }
 
    return;
}

Referenced by FatCommonSetEa().

FatPinEaRange()

VOID FatPinEaRange	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	VirtualEaFile,
		IN PFCB	EaFcb,
		IN OUT PEA_RANGE	EaRange,
		IN ULONG	StartingVbo,
		IN ULONG	Length,
		IN NTSTATUS	ErrorStatus
	)

Definition at line 3512 of file easup.c.

{
    LARGE_INTEGER LargeVbo;
    ULONG ByteCount;
    PBCB *NextBcb;
    PVOID Buffer;
    PCHAR DestinationBuffer = NULL;
    BOOLEAN FirstPage = TRUE;
 
    PAGED_CODE();
 
    //
    //  Verify that the entire read is contained within the Ea file.
    //
 
    if (Length == 0
        || StartingVbo >= EaFcb->Header.AllocationSize.LowPart
        || (EaFcb->Header.AllocationSize.LowPart - StartingVbo) < Length) {
 
        FatRaiseStatus( IrpContext, ErrorStatus );
    }
 
    //
    //  If the read will span a section, the system addresses may not be contiguous.
    //  Allocate a separate buffer in this case.
    //
 
    if (((StartingVbo & (EA_SECTION_SIZE - 1)) + Length) > EA_SECTION_SIZE) {
 
        EaRange->Data = FsRtlAllocatePoolWithTag( PagedPool,
                                                  Length,
                                                  TAG_EA_DATA );
        EaRange->AuxilaryBuffer = TRUE;
 
        DestinationBuffer = EaRange->Data;
 
    } else {
 
        //
        //  PREfix correctly notes that if we don't decide here to have an aux buffer
        //  and the flag is up in the EaRange, we'll party on random memory since
        //  DestinationBuffer won't be set; however, this will never happen due to
        //  initialization of ea ranges and the cleanup in UnpinEaRange.
        //
 
        NT_ASSERT( EaRange->AuxilaryBuffer == FALSE );
    }
 
 
    //
    //  If the read will require more pages than our structure will hold then
    //  allocate an auxilary buffer.  We have to figure the number of pages
    //  being requested so we have to include the page offset of the first page of
    //  the request.
    //
 
    EaRange->BcbChainLength = (USHORT) (((StartingVbo & (PAGE_SIZE - 1)) + Length + PAGE_SIZE - 1) / PAGE_SIZE);
 
    if (EaRange->BcbChainLength > EA_BCB_ARRAY_SIZE) {
 
        EaRange->BcbChain = FsRtlAllocatePoolWithTag( PagedPool,
                                                      sizeof( PBCB ) * EaRange->BcbChainLength,
                                                      TAG_BCB );
 
        RtlZeroMemory( EaRange->BcbChain, sizeof( PBCB ) * EaRange->BcbChainLength );
 
    } else {
 
        EaRange->BcbChain = (PBCB *) &EaRange->BcbArray;
    }
 
    //
    //  Store the byte range data in the Ea Range structure.
    //
 
    EaRange->StartingVbo = StartingVbo;
    EaRange->Length = Length;
 
    //
    //  Compute the initial pin length.
    //
 
    ByteCount = PAGE_SIZE - (StartingVbo & (PAGE_SIZE - 1));
 
    //
    //  For each page in the range; pin the page and update the Bcb count, copy to
    //  the auxiliary buffer.
    //
 
    NextBcb = EaRange->BcbChain;
 
    while (Length != 0) {
 
        //
        //  Pin the page and remember the data start.
        //
 
        LargeVbo.QuadPart = StartingVbo;
 
        if (ByteCount > Length) {
 
            ByteCount = Length;
        }
 
        if (!CcPinRead( VirtualEaFile,
                        &LargeVbo,
                        ByteCount,
                        BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                        NextBcb,
                        &Buffer )) {
 
            //
            // Could not read the data without waiting (cache miss).
            //
 
            FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
        }
 
        //
        //  Increment the Bcb pointer and copy to the auxilary buffer if necessary.
        //
 
        NextBcb += 1;
 
        if (EaRange->AuxilaryBuffer == TRUE) {
 
            RtlCopyMemory( DestinationBuffer,
                           Buffer,
                           ByteCount );
 
            DestinationBuffer = (PCHAR) Add2Ptr( DestinationBuffer, ByteCount );
        }
 
        StartingVbo += ByteCount;
        Length -= ByteCount;
 
        //
        //  If this is the first page then update the Ea Range structure.
        //
 
        if (FirstPage) {
 
            FirstPage = FALSE;
            ByteCount = PAGE_SIZE;
 
            if (EaRange->AuxilaryBuffer == FALSE) {
 
                EaRange->Data = Buffer;
            }
        }
    }
 
    return;
}

Referenced by FatReadEaSet().

FatReadEaSet()

VOID FatReadEaSet	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN USHORT	EaHandle,
		IN POEM_STRING	FileName,
		IN BOOLEAN	ReturnEntireSet,
		OUT PEA_RANGE	EaSetRange
	)

Definition at line 1306 of file easup.c.

{
    ULONG BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;
 
    ULONG EaOffsetVbo;
    EA_RANGE EaOffsetRange;
    USHORT EaOffsetCluster;
 
    EA_RANGE EaHeaderRange;
    PEA_FILE_HEADER EaHeader;
 
    ULONG EaSetVbo;
    PEA_SET_HEADER EaSet;
 
    ULONG CbList;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( FileName );
 
    DebugTrace(+1, Dbg, "FatReadEaSet\n", 0);
    DebugTrace( 0, Dbg, "  Vcb      = %p\n", Vcb);
 
    //
    //  Verify that the Ea index has a legal value.  Raise status
    //  STATUS_NONEXISTENT_EA_ENTRY if illegal.
    //
 
    if (EaHandle < MIN_EA_HANDLE
        || EaHandle > MAX_EA_HANDLE) {
 
        DebugTrace(-1, Dbg, "FatReadEaSet: Illegal handle value\n", 0);
        FatRaiseStatus( IrpContext, STATUS_NONEXISTENT_EA_ENTRY );
    }
 
    //
    //  Verify that the virtual Ea file is large enough for us to read
    //  the EaOffet table for this index.
    //
 
    EaOffsetVbo = sizeof( EA_FILE_HEADER ) + (((ULONGLONG)EaHandle >> 7) << 8);
 
    //
    //  Zero the Ea range structures.
    //
 
    RtlZeroMemory( &EaHeaderRange, sizeof( EA_RANGE ));
    RtlZeroMemory( &EaOffsetRange, sizeof( EA_RANGE ));
 
    //
    //  Use a try statement to clean up on exit.
    //
 
    _SEH2_TRY {
 
        //
        //  Pin down the EA file header.
        //
 
        FatPinEaRange( IrpContext,
                       Vcb->VirtualEaFile,
                       Vcb->EaFcb,
                       &EaHeaderRange,
                       0,
                       sizeof( EA_FILE_HEADER ),
                       STATUS_NONEXISTENT_EA_ENTRY );
 
        EaHeader = (PEA_FILE_HEADER) EaHeaderRange.Data;
 
        //
        //  Pin down the Ea offset table for the particular index.
        //
 
        FatPinEaRange( IrpContext,
                       Vcb->VirtualEaFile,
                       Vcb->EaFcb,
                       &EaOffsetRange,
                       EaOffsetVbo,
                       sizeof( EA_OFF_TABLE ),
                       STATUS_NONEXISTENT_EA_ENTRY );
 
        //
        //  Check if the specifific handle is currently being used.
        //
 
        EaOffsetCluster = *((PUSHORT) EaOffsetRange.Data
                            + (EaHandle & (MAX_EA_OFFSET_INDEX - 1)));
 
        if (EaOffsetCluster == UNUSED_EA_HANDLE) {
 
            DebugTrace(0, Dbg, "FatReadEaSet: Ea handle is unused\n", 0);
            FatRaiseStatus( IrpContext, STATUS_NONEXISTENT_EA_ENTRY );
        }
 
        //
        //  Compute the file offset for the Ea data.
        //
 
        EaSetVbo = (EaHeader->EaBaseTable[EaHandle >> 7] + EaOffsetCluster)
                   << Vcb->AllocationSupport.LogOfBytesPerCluster;
 
        //
        //  Unpin the file header and offset table.
        //
 
        FatUnpinEaRange( IrpContext, &EaHeaderRange );
        FatUnpinEaRange( IrpContext, &EaOffsetRange );
 
        //
        //  Pin the ea set.
        //
 
        FatPinEaRange( IrpContext,
                       Vcb->VirtualEaFile,
                       Vcb->EaFcb,
                       EaSetRange,
                       EaSetVbo,
                       BytesPerCluster,
                       STATUS_DATA_ERROR );
 
        //
        //  Verify that the Ea set is valid and belongs to this index.
        //  Raise STATUS_DATA_ERROR if there is a data conflict.
        //
 
        EaSet = (PEA_SET_HEADER) EaSetRange->Data;
 
        if (EaSet->Signature != EA_SET_SIGNATURE
            || EaSet->OwnEaHandle != EaHandle ) {
 
            DebugTrace(0, Dbg, "FatReadEaSet: Ea set header is corrupt\n", 0);
            FatRaiseStatus( IrpContext, STATUS_DATA_ERROR );
        }
 
        //
        //  At this point we have pinned a single cluster of Ea data.  If
        //  this represents the entire Ea data for the Ea index, we are
        //  done.  Otherwise we need to check on the entire size of
        //  of the Ea set header and whether it is contained in the allocated
        //  size of the Ea virtual file.  At that point we can unpin
        //  the partial Ea set header and repin the entire header.
        //
 
        CbList = GetcbList( EaSet );
 
        if (ReturnEntireSet
            && CbList > BytesPerCluster ) {
 
            //
            //  Round up to the cluster size.
            //
 
            CbList = (CbList + EA_CBLIST_OFFSET + BytesPerCluster - 1)
                     & ~(BytesPerCluster - 1);
 
            FatUnpinEaRange( IrpContext, EaSetRange );
 
            RtlZeroMemory( EaSetRange, sizeof( EA_RANGE ));
 
            FatPinEaRange( IrpContext,
                           Vcb->VirtualEaFile,
                           Vcb->EaFcb,
                           EaSetRange,
                           EaSetVbo,
                           CbList,
                           STATUS_DATA_ERROR );
        }
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatReadEaSet );
 
        //
        //  Unpin the Ea base and offset tables if locked down.
        //
 
        FatUnpinEaRange( IrpContext, &EaHeaderRange );
        FatUnpinEaRange( IrpContext, &EaOffsetRange );
 
        DebugTrace(-1, Dbg, "FatReadEaSet:  Exit\n", 0);
    } _SEH2_END;
 
    return;
}

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), FatCommonSetEa(), and FatReadEaSet().

FatUnpinEaRange()

VOID FatUnpinEaRange	(	IN PIRP_CONTEXT	IrpContext,
		IN OUT PEA_RANGE	EaRange
	)

Definition at line 3782 of file easup.c.

{
    PBCB *NextBcb;
    ULONG BcbCount;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  If we allocated a auxilary buffer, deallocate it here.
    //
 
    if (EaRange->AuxilaryBuffer == TRUE) {
 
        ExFreePool( EaRange->Data );
        EaRange->AuxilaryBuffer = FALSE;
    }
 
    //
    //  Walk through the Bcb chain and unpin the data.
    //
 
    if (EaRange->BcbChain != NULL) {
 
        BcbCount = EaRange->BcbChainLength;
        NextBcb = EaRange->BcbChain;
 
        while (BcbCount--) {
 
            if (*NextBcb != NULL) {
 
                CcUnpinData( *NextBcb );
                *NextBcb = NULL;
            }
 
            NextBcb += 1;
        }
 
        //
        //  If we allocated a Bcb chain, deallocate it here.
        //
 
        if (EaRange->BcbChain != &EaRange->BcbArray[0]) {
 
            ExFreePool( EaRange->BcbChain );
        }
 
        EaRange->BcbChain = NULL;
    }
 
    return;
}

Referenced by _Requires_lock_held_(), FatCommonQueryEa(), FatCommonSetEa(), and FatReadEaSet().