fileinfo.c File Reference

#include "fatprocs.h"

Include dependency graph for fileinfo.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_FILEINFO)
#define	Dbg   (DEBUG_TRACE_FILEINFO)

Functions
VOID	FatQueryBasicInfo (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN PFILE_OBJECT FileObject, IN OUT PFILE_BASIC_INFORMATION Buffer, IN OUT PLONG Length)
	_Requires_lock_held_ (_Global_critical_region_)
	_Function_class_ (IRP_MJ_SET_INFORMATION)
VOID	FatQueryInternalInfo (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN OUT PFILE_INTERNAL_INFORMATION Buffer, IN OUT PLONG Length)
VOID	FatQueryEaInfo (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN OUT PFILE_EA_INFORMATION Buffer, IN OUT PLONG Length)
VOID	FatQueryPositionInfo (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN OUT PFILE_POSITION_INFORMATION Buffer, IN OUT PLONG Length)
VOID	FatQueryShortNameInfo (IN PIRP_CONTEXT IrpContext, IN PFCB Fcb, IN OUT PFILE_NAME_INFORMATION Buffer, IN OUT PLONG Length)
NTSTATUS	FatSetRenameInfo (IN PIRP_CONTEXT IrpContext, IN PIRP Irp, IN PVCB Vcb, IN PFCB Fcb, IN PCCB Ccb)
NTSTATUS	FatSetPositionInfo (IN PIRP_CONTEXT IrpContext, IN PIRP Irp, IN PFILE_OBJECT FileObject)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_FILEINFO)

Definition at line 23 of file fileinfo.c.

Dbg

#define Dbg   (DEBUG_TRACE_FILEINFO)

Definition at line 29 of file fileinfo.c.

Function Documentation

_Function_class_()

_Function_class_

(

IRP_MJ_SET_INFORMATION

)

Definition at line 280 of file fileinfo.c.

{
    NTSTATUS Status;
    PIRP_CONTEXT IrpContext = NULL;
 
    BOOLEAN TopLevel;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatFsdSetInformation\n", 0);
 
    //
    //  Call the common set routine, with blocking allowed if synchronous
    //
 
    FsRtlEnterFileSystem();
 
    TopLevel = FatIsIrpTopLevel( Irp );
 
    _SEH2_TRY {
 
        IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ) );
 
        Status = FatCommonSetInformation( 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, "FatFsdSetInformation -> %08lx\n", Status);
 
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    return Status;
}

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 40 of file fileinfo.c.

{
    NTSTATUS Status;
    PIRP_CONTEXT IrpContext = NULL;
 
    BOOLEAN TopLevel;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatFsdQueryInformation\n", 0);
 
    //
    //  Call the common query routine, with blocking allowed if synchronous
    //
 
    FsRtlEnterFileSystem();
 
    TopLevel = FatIsIrpTopLevel( Irp );
 
    _SEH2_TRY {
 
        IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ) );
 
        Status = FatCommonQueryInformation( 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, "FatFsdQueryInformation -> %08lx\n", Status);
 
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    return Status;
}

FatQueryBasicInfo()

VOID FatQueryBasicInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN PFILE_OBJECT	FileObject,
		IN OUT PFILE_BASIC_INFORMATION	Buffer,
		IN OUT PLONG	Length
	)

Definition at line 1044 of file fileinfo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( FileObject );
    UNREFERENCED_PARAMETER( IrpContext );
 
    DebugTrace(+1, Dbg, "FatQueryBasicInfo...\n", 0);
 
    //
    //  Zero out the output buffer, and set it to indicate that
    //  the query is a normal file.  Later we might overwrite the
    //  attribute.
    //
 
    RtlZeroMemory( Buffer, sizeof(FILE_BASIC_INFORMATION) );
 
    //
    //  Extract the data and fill in the non zero fields of the output
    //  buffer
    //
 
    if (Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB) {
 
        //
        //  We have to munge a lie on the fly.  Every time we have to
        //  use 1/1/80 we need to convert to GMT since the TZ may have
        //  changed on us.
        //
 
        ExLocalTimeToSystemTime( &FatJanOne1980,
                                 &Buffer->LastWriteTime );
        Buffer->CreationTime = Buffer->LastAccessTime = Buffer->LastWriteTime;
 
    } else {
 
        Buffer->LastWriteTime = Fcb->LastWriteTime;
        Buffer->CreationTime = Fcb->CreationTime;
        Buffer->LastAccessTime = Fcb->LastAccessTime;
    }
 
    Buffer->FileAttributes = Fcb->DirentFatFlags;
 
 
    //
    //  If the temporary flag is set, then set it in the buffer.
    //
 
    if (FlagOn( Fcb->FcbState, FCB_STATE_TEMPORARY )) {
 
        SetFlag( Buffer->FileAttributes, FILE_ATTRIBUTE_TEMPORARY );
    }
 
    //
    //  If no attributes were set, set the normal bit.
    //
 
    if (Buffer->FileAttributes == 0) {
 
        Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
    }
 
    //
    //  Update the length and status output variables
    //
 
    *Length -= sizeof( FILE_BASIC_INFORMATION );
 
    DebugTrace( 0, Dbg, "*Length = %08lx\n", *Length);
 
    DebugTrace(-1, Dbg, "FatQueryBasicInfo -> VOID\n", 0);
 
    return;
}

FatQueryEaInfo()

VOID FatQueryEaInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN OUT PFILE_EA_INFORMATION	Buffer,
		IN OUT PLONG	Length
	)

Definition at line 1306 of file fileinfo.c.

{
    PBCB Bcb;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( Fcb );
    UNREFERENCED_PARAMETER( IrpContext );
 
    DebugTrace(+1, Dbg, "FatQueryEaInfo...\n", 0);
 
    Bcb = NULL;
 
    _SEH2_TRY {
 
        //
        //  Zero out the output buffer
        //
 
        RtlZeroMemory( Buffer, sizeof(FILE_EA_INFORMATION) );
 
#if 0
        //
        //  The Root dcb does not have any EAs so don't look for any.  Fat32
        //  doesn't have any, either.
        //
 
        if ( NodeType( Fcb ) != FAT_NTC_ROOT_DCB &&
             !FatIsFat32( Fcb->Vcb )) {
 
            PDIRENT Dirent;
 
            //
            //  Try to get the dirent for this file.
            //
 
            FatGetDirentFromFcbOrDcb( IrpContext,
                                      Fcb,
                                      &Dirent,
                                      &Bcb );
 
            if (Dirent != NULL) {
 
                //
                //  Get a the size needed to store the full eas for the file.
                //
 
                FatGetEaLength( IrpContext,
                                Fcb->Vcb,
                                Dirent,
                                &Buffer->EaSize );
            }
        }
#endif
 
        //
        //  Update the length and status output variables
        //
 
        *Length -= sizeof( FILE_EA_INFORMATION );
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatQueryEaInfo );
 
        //
        //  Unpin the dirent if pinned.
        //
 
        FatUnpinBcb( IrpContext, Bcb );
 
        DebugTrace( 0, Dbg, "*Length = %08lx\n", *Length);
 
        DebugTrace(-1, Dbg, "FatQueryEaInfo -> VOID\n", 0);
    } _SEH2_END;
}

Referenced by FatQueryEaInfo().

FatQueryInternalInfo()

VOID FatQueryInternalInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN OUT PFILE_INTERNAL_INFORMATION	Buffer,
		IN OUT PLONG	Length
	)

Definition at line 1242 of file fileinfo.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    DebugTrace(+1, Dbg, "FatQueryInternalInfo...\n", 0);
 
    _SEH2_TRY {
 
        Buffer->IndexNumber.QuadPart = FatGenerateFileIdFromFcb( Fcb );
 
        //
        //  Update the length and status output variables
        //
 
        *Length -= sizeof( FILE_INTERNAL_INFORMATION );
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatQueryInternalInfo );
 
        DebugTrace( 0, Dbg, "*Length = %08lx\n", *Length);
 
        DebugTrace(-1, Dbg, "FatQueryInternalInfo -> VOID\n", 0);
    } _SEH2_END;
 
    return;
}

Referenced by FatQueryInternalInfo().

FatQueryPositionInfo()

VOID FatQueryPositionInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	FileObject,
		IN OUT PFILE_POSITION_INFORMATION	Buffer,
		IN OUT PLONG	Length
	)

Definition at line 1417 of file fileinfo.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatQueryPositionInfo...\n", 0);
 
    //
    //  Get the current position found in the file object.
    //
 
    Buffer->CurrentByteOffset = FileObject->CurrentByteOffset;
 
    //
    //  Update the length and status output variables
    //
 
    *Length -= sizeof( FILE_POSITION_INFORMATION );
 
    DebugTrace( 0, Dbg, "*Length = %08lx\n", *Length);
 
    DebugTrace(-1, Dbg, "FatQueryPositionInfo -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

FatQueryShortNameInfo()

VOID FatQueryShortNameInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	Fcb,
		IN OUT PFILE_NAME_INFORMATION	Buffer,
		IN OUT PLONG	Length
	)

Definition at line 1686 of file fileinfo.c.

{
    NTSTATUS Status;
 
    ULONG BytesToCopy;
    WCHAR ShortNameBuffer[12];
    UNICODE_STRING ShortName;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatQueryNameInfo...\n", 0);
 
    //
    //  Convert the name to UNICODE
    //
 
    ShortName.Length = 0;
    ShortName.MaximumLength = sizeof(ShortNameBuffer);
    ShortName.Buffer = ShortNameBuffer;
 
    *Length -= FIELD_OFFSET(FILE_NAME_INFORMATION, FileName[0]);
 
#ifdef _MSC_VER
#pragma prefast( suppress:28931, "needed for debug build" )
#endif
    Status = RtlOemStringToCountedUnicodeString( &ShortName,
                                                 &Fcb->ShortName.Name.Oem,
                                                 FALSE );
 
    NT_ASSERT( Status == STATUS_SUCCESS );
 
    //
    //  If we overflow, set *Length to -1 as a flag.
    //
 
    if (*Length < ShortName.Length) {
 
        BytesToCopy = *Length;
        *Length = -1;
 
    } else {
 
        BytesToCopy = ShortName.Length;
        *Length -= ShortName.Length;
    }
 
    RtlCopyMemory( &Buffer->FileName[0],
                   &ShortName.Buffer[0],
                   BytesToCopy );
 
    Buffer->FileNameLength = ShortName.Length;
 
    //
    //  Return to caller
    //
 
    DebugTrace( 0, Dbg, "*Length = %08lx\n", *Length);
 
    DebugTrace(-1, Dbg, "FatQueryNameInfo -> VOID\n", 0);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return;
}

FatSetPositionInfo()

NTSTATUS FatSetPositionInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp,
		IN PFILE_OBJECT	FileObject
	)

Definition at line 4010 of file fileinfo.c.

{
    PFILE_POSITION_INFORMATION Buffer;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSetPositionInfo...\n", 0);
 
    Buffer = Irp->AssociatedIrp.SystemBuffer;
 
    //
    //  Check if the file does not use intermediate buffering.  If it
    //  does not use intermediate buffering then the new position we're
    //  supplied must be aligned properly for the device
    //
 
    if (FlagOn( FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING )) {
 
        PDEVICE_OBJECT DeviceObject;
 
        DeviceObject = IoGetCurrentIrpStackLocation( Irp )->DeviceObject;
 
        if ((Buffer->CurrentByteOffset.LowPart & DeviceObject->AlignmentRequirement) != 0) {
 
            DebugTrace(0, Dbg, "Cannot set position due to aligment conflict\n", 0);
            DebugTrace(-1, Dbg, "FatSetPositionInfo -> %08lx\n", STATUS_INVALID_PARAMETER);
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    //  The input parameter is fine so set the current byte offset and
    //  complete the request
    //
 
    DebugTrace(0, Dbg, "Set the new position to %08lx\n", Buffer->CurrentByteOffset);
 
    FileObject->CurrentByteOffset = Buffer->CurrentByteOffset;
 
    DebugTrace(-1, Dbg, "FatSetPositionInfo -> %08lx\n", STATUS_SUCCESS);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return STATUS_SUCCESS;
}

FatSetRenameInfo()

NTSTATUS FatSetRenameInfo	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp,
		IN PVCB	Vcb,
		IN PFCB	Fcb,
		IN PCCB	Ccb
	)

Definition at line 2694 of file fileinfo.c.

{
    BOOLEAN AllLowerComponent;
    BOOLEAN AllLowerExtension;
    BOOLEAN CaseOnlyRename;
    BOOLEAN ContinueWithRename;
    BOOLEAN CreateLfn = FALSE;
    BOOLEAN DeleteSourceDirent;
    BOOLEAN DeleteTarget;
    BOOLEAN NewDirentFromPool;
    BOOLEAN RenamedAcrossDirectories;
    BOOLEAN ReplaceIfExists;
 
    CCB LocalCcb;
    PCCB SourceCcb;
 
    DIRENT Dirent;
 
    NTSTATUS Status = STATUS_SUCCESS;
 
    OEM_STRING OldOemName;
    OEM_STRING NewOemName;
    UCHAR OemNameBuffer[24*2];
 
    PBCB DotDotBcb;
    PBCB NewDirentBcb;
    PBCB OldDirentBcb;
    PBCB SecondPageBcb;
    PBCB TargetDirentBcb;
 
    PDCB TargetDcb = NULL;
    PDCB OldParentDcb;
 
    PDIRENT DotDotDirent = NULL;
    PDIRENT FirstPageDirent = NULL;
    PDIRENT NewDirent = NULL;
    PDIRENT OldDirent = NULL;
    PDIRENT SecondPageDirent = NULL;
    PDIRENT ShortDirent = NULL;
    PDIRENT TargetDirent = NULL;
 
    PFCB TempFcb;
 
    PFILE_OBJECT TargetFileObject;
    PFILE_OBJECT FileObject;
 
    PIO_STACK_LOCATION IrpSp;
 
    PLIST_ENTRY Links;
 
    ULONG BytesInFirstPage = 0;
    ULONG DirentsInFirstPage = 0;
    ULONG DirentsRequired = 0;
    ULONG NewOffset = 0;
    ULONG NotifyAction = 0;
    ULONG SecondPageOffset = 0;
    ULONG ShortDirentOffset = 0;
    ULONG TargetDirentOffset = 0;
    ULONG TargetLfnOffset = 0;
 
    // NewName comes from the IRP buffer or the TargetFileObject, so we can't
    // go around modifying it. Instead we modify NewNameCopy.
    UNICODE_STRING NewName;
 
    // NB: these five UNICODE_STRINGS are allocated
    // from one chopped up pool allocation called UnicodeBuffer.
    UNICODE_STRING NewNameCopy;
    UNICODE_STRING NewUpcasedName;
    UNICODE_STRING OldName;
    UNICODE_STRING OldUpcasedName;
    UNICODE_STRING TargetLfn;
    PWCHAR UnicodeBuffer;
 
    UNICODE_STRING TargetOrigLfn = {0};
 
    UNICODE_STRING UniTunneledShortName;
    WCHAR UniTunneledShortNameBuffer[12];
    UNICODE_STRING UniTunneledLongName;
    WCHAR UniTunneledLongNameBuffer[26];
 
    LARGE_INTEGER TunneledCreationTime;
    ULONG TunneledDataSize;
    BOOLEAN HaveTunneledInformation = FALSE;
    BOOLEAN UsingTunneledLfn = FALSE;
 
    BOOLEAN InvalidateFcbOnRaise = FALSE;
 
    PFILE_OBJECT DirectoryFileObject = NULL;
    ULONG Flags = 0;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSetRenameInfo...\n", 0);
 
    //
    //  P H A S E  0: Initialize some variables.
    //
 
    CaseOnlyRename = FALSE;
    ContinueWithRename = FALSE;
    DeleteSourceDirent = FALSE;
    DeleteTarget = FALSE;
    NewDirentFromPool = FALSE;
    RenamedAcrossDirectories = FALSE;
 
    DotDotBcb = NULL;
    NewDirentBcb = NULL;
    OldDirentBcb = NULL;
    SecondPageBcb = NULL;
    TargetDirentBcb = NULL;
 
    NewOemName.Length = 0;
    NewOemName.MaximumLength = 24;
    NewOemName.Buffer = (PCHAR)&OemNameBuffer[0];
 
    OldOemName.Length = 0;
    OldOemName.MaximumLength = 24;
    OldOemName.Buffer = (PCHAR)&OemNameBuffer[24];
 
    UnicodeBuffer = FsRtlAllocatePoolWithTag( PagedPool,
                                              5 * MAX_LFN_CHARACTERS * sizeof(WCHAR),
                                              TAG_FILENAME_BUFFER );
 
    NewUpcasedName.Length = 0;
    NewUpcasedName.MaximumLength = MAX_LFN_CHARACTERS * sizeof(WCHAR);
    NewUpcasedName.Buffer = &UnicodeBuffer[0];
 
    OldName.Length = 0;
    OldName.MaximumLength = MAX_LFN_CHARACTERS * sizeof(WCHAR);
    OldName.Buffer = &UnicodeBuffer[MAX_LFN_CHARACTERS];
 
    OldUpcasedName.Length = 0;
    OldUpcasedName.MaximumLength = MAX_LFN_CHARACTERS * sizeof(WCHAR);
    OldUpcasedName.Buffer = &UnicodeBuffer[MAX_LFN_CHARACTERS * 2];
 
    TargetLfn.Length = 0;
    TargetLfn.MaximumLength = MAX_LFN_CHARACTERS * sizeof(WCHAR);
    TargetLfn.Buffer = &UnicodeBuffer[MAX_LFN_CHARACTERS * 3];
 
    NewNameCopy.Length = 0;
    NewNameCopy.MaximumLength = MAX_LFN_CHARACTERS * sizeof(WCHAR);
    NewNameCopy.Buffer = &UnicodeBuffer[MAX_LFN_CHARACTERS * 4];
 
    UniTunneledShortName.Length = 0;
    UniTunneledShortName.MaximumLength = sizeof(UniTunneledShortNameBuffer);
    UniTunneledShortName.Buffer = &UniTunneledShortNameBuffer[0];
 
    UniTunneledLongName.Length = 0;
    UniTunneledLongName.MaximumLength = sizeof(UniTunneledLongNameBuffer);
    UniTunneledLongName.Buffer = &UniTunneledLongNameBuffer[0];
 
    //
    //  Remember the name in case we have to modify the name
    //  value in the ea.
    //
 
    RtlCopyMemory( OldOemName.Buffer,
                   Fcb->ShortName.Name.Oem.Buffer,
                   OldOemName.Length );
 
    //
    //  Get the current stack location
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Extract information from the Irp to make our life easier
    //
 
    FileObject = IrpSp->FileObject;
    SourceCcb = FileObject->FsContext2;
    TargetFileObject = IrpSp->Parameters.SetFile.FileObject;
    ReplaceIfExists = IrpSp->Parameters.SetFile.ReplaceIfExists;
 
    RtlZeroMemory( &LocalCcb, sizeof(CCB) );
 
    //
    //  P H A S E  1:
    //
    //  Test if rename is legal.  Only small side-effects are not undone.
    //
 
    _SEH2_TRY {
 
        //
        //  Can't rename the root directory
        //
 
        if ( NodeType(Fcb) == FAT_NTC_ROOT_DCB ) {
 
            try_return( Status = STATUS_INVALID_PARAMETER );
        }
 
        //
        //  Check that we were not given a dcb with open handles beneath
        //  it.  If there are only UncleanCount == 0 Fcbs beneath us, then
        //  remove them from the prefix table, and they will just close
        //  and go away naturally.
        //
 
        if (NodeType(Fcb) == FAT_NTC_DCB) {
 
            PFCB BatchOplockFcb;
            ULONG BatchOplockCount;
 
            //
            //  Loop until there are no batch oplocks in the subtree below
            //  this directory.
            //
 
            while (TRUE) {
 
                BatchOplockFcb = NULL;
                BatchOplockCount = 0;
 
                //
                //  First look for any UncleanCount != 0 Fcbs, and fail if we
                //  find any.
                //
 
                for ( TempFcb = FatGetNextFcbBottomUp(IrpContext, NULL, Fcb);
                      TempFcb != Fcb;
                      TempFcb = FatGetNextFcbBottomUp(IrpContext, TempFcb, Fcb) ) {
 
                     if ( TempFcb->UncleanCount != 0 ) {
 
                         //
                         // If there is a batch oplock on this file then
                         // increment our count and remember the Fcb if
                         // this is the first.
                         //
 
                         if (FatIsFileOplockable( TempFcb ) &&
                             (FsRtlCurrentBatchOplock( FatGetFcbOplock(TempFcb) )
#if (NTDDI_VERSION >= NTDDI_WIN7)
                              ||
                              FsRtlCurrentOplockH( FatGetFcbOplock(TempFcb) )
#endif
                              )) {
 
                             BatchOplockCount += 1;
                             if ( BatchOplockFcb == NULL ) {
 
                                 BatchOplockFcb = TempFcb;
                             }
 
                         } else {
 
                            try_return( Status = STATUS_ACCESS_DENIED );
                         }
                     }
                }
 
                //
                //  If this is not the first pass for rename and the number
                //  of batch oplocks has not decreased then give up.
                //
 
                if ( BatchOplockFcb != NULL ) {
 
                    if ( (Irp->IoStatus.Information != 0) &&
                         (BatchOplockCount >= Irp->IoStatus.Information) ) {
 
                        try_return( Status = STATUS_ACCESS_DENIED );
                    }
 
                    //
                    //  Try to break this batch oplock.
                    //
 
                    Irp->IoStatus.Information = BatchOplockCount;
                    Status = FsRtlCheckOplock( FatGetFcbOplock(BatchOplockFcb),
                                               Irp,
                                               IrpContext,
                                               FatOplockComplete,
                                               NULL );
 
                    //
                    //  If the oplock was already broken then look for more
                    //  batch oplocks.
                    //
 
                    if (Status == STATUS_SUCCESS) {
 
                        continue;
                    }
 
                    //
                    //  Otherwise the oplock package will post or complete the
                    //  request.
                    //
 
                    try_return( Status = STATUS_PENDING );
                }
 
                break;
            }
 
            //
            //  Now try to get as many of these file object, and thus Fcbs
            //  to go away as possible, flushing first, of course.
            //
 
            FatPurgeReferencedFileObjects( IrpContext, Fcb, Flush );
 
            //
            //  OK, so there are no UncleanCount != 0, Fcbs.  Infact, there
            //  shouldn't really be any Fcbs left at all, except obstinate
            //  ones from user mapped sections .... Remove the full file name
            //  and exact case lfn.
            //
 
            for ( TempFcb = FatGetNextFcbBottomUp(IrpContext, NULL, Fcb);
                  TempFcb != Fcb;
                  TempFcb = FatGetNextFcbBottomUp(IrpContext, TempFcb, Fcb) ) {
 
                FatAcquireExclusiveFcb( IrpContext, TempFcb );
 
                if (TempFcb->FullFileName.Buffer != NULL) {
 
                    ExFreePool( TempFcb->FullFileName.Buffer );
                    TempFcb->FullFileName.Buffer = NULL;
                }
 
                FatReleaseFcb( IrpContext, TempFcb );
            }
        }
 
        //
        //  Check if this is a simple rename or a fully-qualified rename
        //  In both cases we need to figure out what the TargetDcb, and
        //  NewName are.
        //
 
        if (TargetFileObject == NULL) {
 
            //
            //  In the case of a simple rename the target dcb is the
            //  same as the source file's parent dcb, and the new file name
            //  is taken from the system buffer
            //
 
            PFILE_RENAME_INFORMATION Buffer;
 
            Buffer = Irp->AssociatedIrp.SystemBuffer;
 
            TargetDcb = Fcb->ParentDcb;
 
            NewName.Length = (USHORT) Buffer->FileNameLength;
            NewName.Buffer = (PWSTR) &Buffer->FileName;
 
            //
            //  Make sure the name is of legal length.
            //
 
            if (NewName.Length > 255*sizeof(WCHAR)) {
 
                try_return( Status = STATUS_OBJECT_NAME_INVALID );
            }
 
            RtlCopyUnicodeString(&NewNameCopy,&NewName);
 
        } else {
 
            //
            //  For a fully-qualified rename the target dcb is taken from
            //  the target file object, which must be on the same vcb as
            //  the source.
            //
 
            PVCB TargetVcb;
            PCCB TargetCcb;
 
            if ((FatDecodeFileObject( TargetFileObject,
                                      &TargetVcb,
                                      &TargetDcb,
                                      &TargetCcb ) != UserDirectoryOpen) ||
                (TargetVcb != Vcb)) {
 
                try_return( Status = STATUS_INVALID_PARAMETER );
            }
 
            //
            //  This name is by definition legal.
            //
 
            NewName = *((PUNICODE_STRING)&TargetFileObject->FileName);
 
            RtlCopyUnicodeString(&NewNameCopy,&NewName);
 
        }
 
        //
        //  We will need an upcased version of the unicode name and the
        //  old name as well.
        //
 
        Status = RtlUpcaseUnicodeString( &NewUpcasedName, &NewName, FALSE );
 
        if (!NT_SUCCESS(Status)) {
 
            try_return( Status );
        }
 
        FatGetUnicodeNameFromFcb( IrpContext, Fcb, &OldName );
 
        Status = RtlUpcaseUnicodeString( &OldUpcasedName, &OldName, FALSE );
 
        if (!NT_SUCCESS(Status)) {
            try_return(Status);
        }
 
        //
        //  Check if the current name and new name are equal, and the
        //  DCBs are equal.  If they are then our work is already done.
        //
 
        if (TargetDcb == Fcb->ParentDcb) {
 
            //
            //  OK, now if we found something then check if it was an exact
            //  match or just a case match.  If it was an exact match, then
            //  we can bail here.
            //
 
            if (FsRtlAreNamesEqual( &NewName,
                                    &OldName,
                                    FALSE,
                                    NULL )) {
 
                 try_return( Status = STATUS_SUCCESS );
            }
 
            //
            //  Check now for a case only rename.
            //
 
 
            if (FsRtlAreNamesEqual( &NewUpcasedName,
                                    &OldUpcasedName,
                                    FALSE,
                                    NULL )) {
 
                 CaseOnlyRename = TRUE;
            }
 
        } else {
 
            RenamedAcrossDirectories = TRUE;
        }
 
        //
        //  Upcase the name and convert it to the Oem code page.
        //
        //  If the new UNICODE name is already more than 12 characters,
        //  then we know the Oem name will not be valid
        //
 
        if (NewName.Length <= 12*sizeof(WCHAR)) {
 
            FatUnicodeToUpcaseOem( IrpContext, &NewOemName, &NewName );
 
            //
            //  If the name is not valid 8.3, zero the length.
            //
 
            if (FatSpaceInName( IrpContext, &NewName ) ||
                !FatIsNameShortOemValid( IrpContext, NewOemName, FALSE, FALSE, FALSE)) {
 
                NewOemName.Length = 0;
            }
 
        } else {
 
            NewOemName.Length = 0;
        }
 
        //
        //  Look in the tunnel cache for names and timestamps to restore
        //
 
        TunneledDataSize = sizeof(LARGE_INTEGER);
        HaveTunneledInformation = FsRtlFindInTunnelCache( &Vcb->Tunnel,
                                                          FatDirectoryKey(TargetDcb),
                                                          &NewName,
                                                          &UniTunneledShortName,
                                                          &UniTunneledLongName,
                                                          &TunneledDataSize,
                                                          &TunneledCreationTime );
        NT_ASSERT(TunneledDataSize == sizeof(LARGE_INTEGER));
 
 
        //
        //  Now we need to determine how many dirents this new name will
        //  require.
        //
 
        if ((NewOemName.Length == 0) ||
            (FatEvaluateNameCase( IrpContext,
                                  &NewNameCopy,
                                  &AllLowerComponent,
                                  &AllLowerExtension,
                                  &CreateLfn ),
             CreateLfn)) {
 
            DirentsRequired = FAT_LFN_DIRENTS_NEEDED(&NewNameCopy) + 1;
 
        } else {
 
            //
            //  The user-given name is a short name, but we might still have
            //  a tunneled long name we want to use. See if we can.
            //
 
            if (UniTunneledLongName.Length &&
                !FatLfnDirentExists(IrpContext, TargetDcb, &UniTunneledLongName, &TargetLfn)) {
 
                UsingTunneledLfn = CreateLfn = TRUE;
                DirentsRequired = FAT_LFN_DIRENTS_NEEDED(&UniTunneledLongName) + 1;
 
            } else {
 
                //
                //  This really is a simple dirent.  Note that the two AllLower BOOLEANs
                //  are correctly set now.
                //
 
                DirentsRequired = 1;
 
 
            }
        }
 
        //
        //  Do some extra checks here if we are not in Chicago mode.
        //
 
        if (!FatData.ChicagoMode) {
 
            //
            //  If the name was not 8.3 valid, fail the rename.
            //
 
            if (NewOemName.Length == 0) {
 
                try_return( Status = STATUS_OBJECT_NAME_INVALID );
            }
 
            //
            //  Don't use the magic bits.
            //
 
            AllLowerComponent = FALSE;
            AllLowerExtension = FALSE;
            CreateLfn = FALSE;
            UsingTunneledLfn = FALSE;
        }
 
        if (!CaseOnlyRename) {
 
            //
            //  Check if the new name already exists, wait is known to be
            //  true.
            //
 
            if (NewOemName.Length != 0) {
 
                FatStringTo8dot3( IrpContext,
                                  NewOemName,
                                  &LocalCcb.OemQueryTemplate.Constant );
 
            } else {
 
                SetFlag( LocalCcb.Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE );
            }
 
            LocalCcb.UnicodeQueryTemplate = NewUpcasedName;
            LocalCcb.ContainsWildCards = FALSE;
 
            Flags = 0;
 
 
            FatLocateDirent( IrpContext,
                             TargetDcb,
                             &LocalCcb,
                             0,
                             &Flags,
                             &TargetDirent,
                             &TargetDirentBcb,
                             (PVBO)&TargetDirentOffset,
                             NULL,
                             &TargetLfn,
                             &TargetOrigLfn );
 
            if (TargetDirent != NULL) {
 
 
                //
                //  The name already exists, check if the user wants
                //  to overwrite the name, and has access to do the overwrite
                //  We cannot overwrite a directory.
                //
 
                if ((!ReplaceIfExists) ||
                    (FlagOn(TargetDirent->Attributes, FAT_DIRENT_ATTR_DIRECTORY)) ||
                    (FlagOn(TargetDirent->Attributes, FAT_DIRENT_ATTR_READ_ONLY))) {
 
                    try_return( Status = STATUS_OBJECT_NAME_COLLISION );
                }
 
                //
                //  Check that the file has no open user handles, if it does
                //  then we will deny access.  We do the check by searching
                //  down the list of fcbs opened under our parent Dcb, and making
                //  sure none of the maching Fcbs have a non-zero unclean count or
                //  outstanding image sections.
                //
 
                for (Links = TargetDcb->Specific.Dcb.ParentDcbQueue.Flink;
                     Links != &TargetDcb->Specific.Dcb.ParentDcbQueue; ) {
 
                    TempFcb = CONTAINING_RECORD( Links, FCB, ParentDcbLinks );
 
                    //
                    //  Advance now.  The image section flush may cause the final
                    //  close, which will recursively happen underneath of us here.
                    //  It would be unfortunate if we looked through free memory.
                    //
 
                    Links = Links->Flink;
 
                    if ((TempFcb->DirentOffsetWithinDirectory == TargetDirentOffset) &&
                        ((TempFcb->UncleanCount != 0) ||
                         !MmFlushImageSection( &TempFcb->NonPaged->SectionObjectPointers,
                                               MmFlushForDelete))) {
 
                        //
                        //  If there are batch oplocks on this file then break the
                        //  oplocks before failing the rename.
                        //
 
                        Status = STATUS_ACCESS_DENIED;
 
                        if (FatIsFileOplockable( TempFcb ) &&
                            (FsRtlCurrentBatchOplock( FatGetFcbOplock(TempFcb) )
#if (NTDDI_VERSION >= NTDDI_WIN7)
                             ||
                             FsRtlCurrentOplockH( FatGetFcbOplock(TempFcb) )
#endif
                             )) {
 
                            //
                            //  Do all of our cleanup now since the IrpContext
                            //  could go away when this request is posted.
                            //
 
                            FatUnpinBcb( IrpContext, TargetDirentBcb );
 
                            Status = FsRtlCheckOplock( FatGetFcbOplock(TempFcb),
                                                       Irp,
                                                       IrpContext,
                                                       FatOplockComplete,
                                                       NULL );
 
                            if (Status != STATUS_PENDING) {
 
                                Status = STATUS_ACCESS_DENIED;
                            }
                        }
 
                        try_return( NOTHING );
                    }
                }
 
                //
                //  OK, this target is toast.  Remember the Lfn offset.
                //
 
                TargetLfnOffset = TargetDirentOffset -
                                  FAT_LFN_DIRENTS_NEEDED(&TargetOrigLfn) *
                                  sizeof(DIRENT);
 
                DeleteTarget = TRUE;
            }
        }
 
 
        //
        //  If we will need more dirents than we have, allocate them now.
        //
 
        if ((TargetDcb != Fcb->ParentDcb) ||
            (DirentsRequired !=
             (Fcb->DirentOffsetWithinDirectory -
              Fcb->LfnOffsetWithinDirectory) / sizeof(DIRENT) + 1)) {
 
            //
            //  Get some new allocation
            //
 
            NewOffset = FatCreateNewDirent( IrpContext,
                                            TargetDcb,
                                            DirentsRequired,
                                            FALSE );
 
            DeleteSourceDirent = TRUE;
 
        } else {
 
            NewOffset = Fcb->LfnOffsetWithinDirectory;
        }
 
        ContinueWithRename = TRUE;
 
    try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if (!ContinueWithRename) {
 
            //
            //  Undo everything from above.
            //
 
            ExFreePool( UnicodeBuffer );
            FatUnpinBcb( IrpContext, TargetDirentBcb );
 
        }
    } _SEH2_END;
 
    //
    //  Now, if we are already done, return here.
    //
 
    if (!ContinueWithRename) {
 
        return Status;
    }
 
    //
    //  P H A S E  2: Actually perform the rename.
    //
 
    _SEH2_TRY {
 
        //
        //  Report the fact that we are going to remove this entry.
        //  If we renamed within the same directory and the new name for the
        //  file did not previously exist, we report this as a rename old
        //  name.  Otherwise this is a removed file.
        //
 
        if (!RenamedAcrossDirectories && !DeleteTarget) {
 
            NotifyAction = FILE_ACTION_RENAMED_OLD_NAME;
 
        } else {
 
            NotifyAction = FILE_ACTION_REMOVED;
        }
 
        FatNotifyReportChange( IrpContext,
                               Vcb,
                               Fcb,
                               ((NodeType( Fcb ) == FAT_NTC_FCB)
                                ? FILE_NOTIFY_CHANGE_FILE_NAME
                                : FILE_NOTIFY_CHANGE_DIR_NAME ),
                               NotifyAction );
 
        _SEH2_TRY {
 
            //
            //  Capture a copy of the source dirent.
            //
 
            FatGetDirentFromFcbOrDcb( IrpContext, Fcb, FALSE, &OldDirent, &OldDirentBcb );
 
            Dirent = *OldDirent;
 
            //
            //  Tunnel the source Fcb - the names are disappearing regardless of
            //  whether the dirent allocation physically changed
            //
 
            FatTunnelFcbOrDcb( Fcb, SourceCcb );
 
            //
            //  From here until very nearly the end of the operation, if we raise there
            //  is no reasonable way to suppose we'd be able to undo the damage.  Not
            //  being a transactional filesystem, FAT is at the mercy of a lot of things
            //  (as the astute reader has no doubt realized by now).
            //
 
            InvalidateFcbOnRaise = TRUE;
 
            //
            //  Delete our current dirent(s) if we got a new one.
            //
 
            if (DeleteSourceDirent) {
 
                FatDeleteDirent( IrpContext, Fcb, NULL, FALSE );
            }
 
            //
            //  Delete a target conflict if we were meant to.
            //
 
            if (DeleteTarget) {
 
                FatDeleteFile( IrpContext,
                               TargetDcb,
                               TargetLfnOffset,
                               TargetDirentOffset,
                               TargetDirent,
                               &TargetLfn );
            }
 
            //
            //  We need to evaluate any short names required.  If there were any
            //  conflicts in existing short names, they would have been deleted above.
            //
            //  It isn't neccesary to worry about the UsingTunneledLfn case. Since we
            //  actually already know whether CreateLfn will be set either NewName is
            //  an Lfn and !UsingTunneledLfn is implied or NewName is a short name and
            //  we can handle that externally.
            //
 
            FatSelectNames( IrpContext,
                            TargetDcb,
                            &NewOemName,
                            &NewNameCopy,
                            &NewOemName,
                            (HaveTunneledInformation ? &UniTunneledShortName : NULL),
                            &AllLowerComponent,
                            &AllLowerExtension,
                            &CreateLfn );
 
            if (!CreateLfn && UsingTunneledLfn) {
 
                CreateLfn = TRUE;
                RtlCopyUnicodeString( &NewNameCopy, &UniTunneledLongName );
 
                //
                //  Short names are always upcase if an LFN exists
                //
 
                AllLowerComponent = FALSE;
                AllLowerExtension = FALSE;
            }
 
            //
            //  OK, now setup the new dirent(s) for the new name.
            //
 
            FatPrepareWriteDirectoryFile( IrpContext,
                                          TargetDcb,
                                          NewOffset,
                                          sizeof(DIRENT),
                                          &NewDirentBcb,
#ifndef __REACTOS__
                                          &NewDirent,
#else
                                          (PVOID *)&NewDirent,
#endif
                                          FALSE,
                                          TRUE,
                                          &Status );
 
            NT_ASSERT( NT_SUCCESS( Status ) );
 
            //
            //  Deal with the special case of an LFN + Dirent structure crossing
            //  a page boundry.
            //
 
            if ((NewOffset / PAGE_SIZE) !=
                ((NewOffset + (DirentsRequired - 1) * sizeof(DIRENT)) / PAGE_SIZE)) {
 
                SecondPageOffset = (NewOffset & ~(PAGE_SIZE - 1)) + PAGE_SIZE;
 
                BytesInFirstPage = SecondPageOffset - NewOffset;
 
                DirentsInFirstPage = BytesInFirstPage / sizeof(DIRENT);
 
                FatPrepareWriteDirectoryFile( IrpContext,
                                              TargetDcb,
                                              SecondPageOffset,
                                              sizeof(DIRENT),
                                              &SecondPageBcb,
#ifndef __REACTOS__
                                              &SecondPageDirent,
#else
                                              (PVOID *)&SecondPageDirent,
#endif
                                              FALSE,
                                              TRUE,
                                              &Status );
 
                NT_ASSERT( NT_SUCCESS( Status ) );
 
                FirstPageDirent = NewDirent;
 
                NewDirent = FsRtlAllocatePoolWithTag( PagedPool,
                                                      DirentsRequired * sizeof(DIRENT),
                                                      TAG_DIRENT );
 
                NewDirentFromPool = TRUE;
            }
 
            //
            //  Bump up Dirent and DirentOffset
            //
 
            ShortDirent = NewDirent + DirentsRequired - 1;
            ShortDirentOffset = NewOffset + (DirentsRequired - 1) * sizeof(DIRENT);
 
            //
            //  Fill in the fields of the dirent.
            //
 
            *ShortDirent = Dirent;
 
            FatConstructDirent( IrpContext,
                                ShortDirent,
                                &NewOemName,
                                AllLowerComponent,
                                AllLowerExtension,
                                CreateLfn ? &NewNameCopy : NULL,
                                Dirent.Attributes,
                                FALSE,
                                (HaveTunneledInformation ? &TunneledCreationTime : NULL) );
 
            if (HaveTunneledInformation) {
 
                //
                //  Need to go in and fix the timestamps in the FCB. Note that we can't use
                //  the TunneledCreationTime since the conversions may have failed.
                //
 
                Fcb->CreationTime = FatFatTimeToNtTime(IrpContext, ShortDirent->CreationTime, ShortDirent->CreationMSec);
                Fcb->LastWriteTime = FatFatTimeToNtTime(IrpContext, ShortDirent->LastWriteTime, 0);
                Fcb->LastAccessTime = FatFatDateToNtTime(IrpContext, ShortDirent->LastAccessDate);
            }
 
 
            //
            //  If the dirent crossed pages, split the contents of the
            //  temporary pool between the two pages.
            //
 
            if (NewDirentFromPool) {
 
                RtlCopyMemory( FirstPageDirent, NewDirent, BytesInFirstPage );
 
                RtlCopyMemory( SecondPageDirent,
                               NewDirent + DirentsInFirstPage,
                               DirentsRequired*sizeof(DIRENT) - BytesInFirstPage );
 
                ShortDirent = SecondPageDirent +
                              (DirentsRequired - DirentsInFirstPage) - 1;
            }
 
            Dirent = *ShortDirent;
 
        } _SEH2_FINALLY {
 
            //
            //  Remove the entry from the splay table, and then remove the
            //  full file name and exact case lfn. It is important that we
            //  always remove the name from the prefix table regardless of
            //  other errors.
            //
 
            FatRemoveNames( IrpContext, Fcb );
 
            if (Fcb->FullFileName.Buffer != NULL) {
 
                ExFreePool( Fcb->FullFileName.Buffer );
                Fcb->FullFileName.Buffer = NULL;
            }
 
            if (Fcb->ExactCaseLongName.Buffer) {
 
                ExFreePool( Fcb->ExactCaseLongName.Buffer );
                Fcb->ExactCaseLongName.Buffer = NULL;
            }
 
            FatUnpinBcb( IrpContext, OldDirentBcb );
            FatUnpinBcb( IrpContext, TargetDirentBcb );
            FatUnpinBcb( IrpContext, NewDirentBcb );
            FatUnpinBcb( IrpContext, SecondPageBcb );
        } _SEH2_END;
 
        //
        //  Now we need to update the location of the file's directory
        //  offset and move the fcb from its current parent dcb to
        //  the target dcb.
        //
 
        Fcb->LfnOffsetWithinDirectory = NewOffset;
        Fcb->DirentOffsetWithinDirectory = ShortDirentOffset;
 
        RemoveEntryList( &Fcb->ParentDcbLinks );
 
        //
        //  There is a deep reason we put files on the tail, others on the head,
        //  which is to allow us to easily enumerate all child directories before
        //  child files. This is important to let us maintain whole-volume lockorder
        //  via BottomUp enumeration.
        //
 
        if (NodeType(Fcb) == FAT_NTC_FCB) {
 
            InsertTailList( &TargetDcb->Specific.Dcb.ParentDcbQueue,
                            &Fcb->ParentDcbLinks );
 
        } else {
 
            InsertHeadList( &TargetDcb->Specific.Dcb.ParentDcbQueue,
                            &Fcb->ParentDcbLinks );
        }
 
        OldParentDcb = Fcb->ParentDcb;
        Fcb->ParentDcb = TargetDcb;
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
        //
        //  Break parent directory oplock on the old parent.  Directory oplock
        //  breaks are always advisory, so we will never block/get STATUS_PENDING
        //  here.
        //
 
        FsRtlCheckOplockEx( FatGetFcbOplock(OldParentDcb),
                            IrpContext->OriginatingIrp,
                            OPLOCK_FLAG_PARENT_OBJECT,
                            NULL,
                            NULL,
                            NULL );
#endif
 
        //
        //  If we renamed across directories, some cleanup is now in order.
        //
 
        if (RenamedAcrossDirectories) {
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
            //
            //  Break parent directory oplock on the new parent.  Directory oplock
            //  breaks are always advisory, so we will never block/get STATUS_PENDING
            //  here.
            //
 
            FsRtlCheckOplockEx( FatGetFcbOplock(TargetDcb),
                                IrpContext->OriginatingIrp,
                                OPLOCK_FLAG_PARENT_OBJECT,
                                NULL,
                                NULL,
                                NULL );
#endif
 
            //
            //  See if we need to uninitialize the cachemap for the source directory.
            //  Do this now in case we get unlucky and raise trying to finalize the
            //  operation.
            //
 
            if (IsListEmpty(&OldParentDcb->Specific.Dcb.ParentDcbQueue) &&
                (OldParentDcb->OpenCount == 0) &&
                (OldParentDcb->Specific.Dcb.DirectoryFile != NULL)) {
 
                NT_ASSERT( NodeType(OldParentDcb) == FAT_NTC_DCB );
 
                DirectoryFileObject = OldParentDcb->Specific.Dcb.DirectoryFile;
 
                OldParentDcb->Specific.Dcb.DirectoryFile = NULL;
            }
 
            //
            //  If we move a directory across directories, we have to change
            //  the cluster number in its .. entry
            //
 
            if (NodeType(Fcb) == FAT_NTC_DCB) {
 
                FatPrepareWriteDirectoryFile( IrpContext,
                                              Fcb,
                                              sizeof(DIRENT),
                                              sizeof(DIRENT),
                                              &DotDotBcb,
#ifndef __REACTOS__
                                              &DotDotDirent,
#else
                                              (PVOID *)&DotDotDirent,
#endif
                                              FALSE,
                                              TRUE,
                                              &Status );
 
                NT_ASSERT( NT_SUCCESS( Status ) );
 
                DotDotDirent->FirstClusterOfFile = (USHORT)
                    ( NodeType(TargetDcb) == FAT_NTC_ROOT_DCB ?
                      0 : TargetDcb->FirstClusterOfFile);
 
                if (FatIsFat32( Vcb )) {
 
                    DotDotDirent->FirstClusterOfFileHi = (USHORT)
                    ( NodeType( TargetDcb ) == FAT_NTC_ROOT_DCB ?
                      0 : (TargetDcb->FirstClusterOfFile >> 16));
                }
            }
        }
 
        //
        //  Now we need to setup the splay table and the name within
        //  the fcb.  Free the old short name at this point.
        //
 
        ExFreePool( Fcb->ShortName.Name.Oem.Buffer );
        Fcb->ShortName.Name.Oem.Buffer = NULL;
 
 
        FatConstructNamesInFcb( IrpContext,
                                Fcb,
                                &Dirent,
                                CreateLfn ? &NewName : NULL );
 
        FatSetFullNameInFcb( IrpContext, Fcb, &NewName );
 
        //
        //  The rest of the actions taken are not related to correctness of
        //  the in-memory structures, so we shouldn't toast the Fcb if we
        //  raise from here to the end.
        //
 
        InvalidateFcbOnRaise = FALSE;
 
        //
        //  If a file, set the file as modified so that the archive bit
        //  is set.  We prevent this from adjusting the write time by
        //  indicating the user flag in the ccb.
        //
 
        if (Fcb->Header.NodeTypeCode == FAT_NTC_FCB) {
 
            SetFlag( FileObject->Flags, FO_FILE_MODIFIED );
            SetFlag( Ccb->Flags, CCB_FLAG_USER_SET_LAST_WRITE );
        }
 
        //
        //  We have three cases to report.
        //
        //      1.  If we overwrote an existing file, we report this as
        //          a modified file.
        //
        //      2.  If we renamed to a new directory, then we added a file.
        //
        //      3.  If we renamed in the same directory, then we report the
        //          the renamednewname.
        //
 
        if (DeleteTarget) {
 
            FatNotifyReportChange( IrpContext,
                                   Vcb,
                                   Fcb,
                                   FILE_NOTIFY_CHANGE_ATTRIBUTES
                                   | FILE_NOTIFY_CHANGE_SIZE
                                   | FILE_NOTIFY_CHANGE_LAST_WRITE
                                   | FILE_NOTIFY_CHANGE_LAST_ACCESS
                                   | FILE_NOTIFY_CHANGE_CREATION
                                   | FILE_NOTIFY_CHANGE_EA,
                                   FILE_ACTION_MODIFIED );
 
        } else if (RenamedAcrossDirectories) {
 
            FatNotifyReportChange( IrpContext,
                                   Vcb,
                                   Fcb,
                                   ((NodeType( Fcb ) == FAT_NTC_FCB)
                                    ? FILE_NOTIFY_CHANGE_FILE_NAME
                                    : FILE_NOTIFY_CHANGE_DIR_NAME ),
                                   FILE_ACTION_ADDED );
 
        } else {
 
            FatNotifyReportChange( IrpContext,
                                   Vcb,
                                   Fcb,
                                   ((NodeType( Fcb ) == FAT_NTC_FCB)
                                    ? FILE_NOTIFY_CHANGE_FILE_NAME
                                    : FILE_NOTIFY_CHANGE_DIR_NAME ),
                                   FILE_ACTION_RENAMED_NEW_NAME );
        }
 
        //
        //  We need to update the file name in the dirent.  This value
        //  is never used elsewhere, so we don't concern ourselves
        //  with any error we may encounter.  We let chkdsk fix the
        //  disk at some later time.
        //
 
        if (!FatIsFat32(Vcb) &&
            Dirent.ExtendedAttributes != 0) {
 
            FatRenameEAs( IrpContext,
                          Fcb,
                          Dirent.ExtendedAttributes,
                          &OldOemName );
        }
 
        FatUnpinBcb( IrpContext, DotDotBcb );
 
        FatUnpinRepinnedBcbs( IrpContext );
 
        //
        //  Set our final status
        //
 
        Status = STATUS_SUCCESS;
 
    } _SEH2_FINALLY {
 
        DebugUnwind( FatSetRenameInfo );
 
        ExFreePool( UnicodeBuffer );
 
        if (UniTunneledLongName.Buffer != UniTunneledLongNameBuffer) {
 
            //
            //  Free pool if the buffer was grown on tunneling lookup
            //
 
            ExFreePool(UniTunneledLongName.Buffer);
        }
 
        if (NewDirentFromPool) {
 
            ExFreePool( NewDirent );
        }
 
        FatUnpinBcb( IrpContext, TargetDirentBcb );
        FatUnpinBcb( IrpContext, DotDotBcb );
 
        //
        //  Uninitialize the cachemap for the source directory if we need to.
        //
 
        if (DirectoryFileObject) {
 
            DebugTrace(0, Dbg, "Uninitialize our parent Stream Cache Map\n", 0);
 
            CcUninitializeCacheMap( DirectoryFileObject, NULL, NULL );
 
            ObDereferenceObject( DirectoryFileObject );
        }
 
        //
        //  If this was an abnormal termination, then we are in trouble.
        //  Should the operation have been in a sensitive state there is
        //  nothing we can do but invalidate the Fcb.
        //
 
        if (_SEH2_AbnormalTermination() && InvalidateFcbOnRaise) {
 
            Fcb->FcbCondition = FcbBad;
        }
 
        DebugTrace(-1, Dbg, "FatSetRenameInfo -> %08lx\n", Status);
    } _SEH2_END;
 
    return Status;
}

Referenced by FatSetRenameInfo().