filobsup.c File Reference

#include "fatprocs.h"

Include dependency graph for filobsup.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_FILOBSUP)
#define	Dbg   (DEBUG_TRACE_FILOBSUP)

Functions
VOID	FatSetFileObject (IN PFILE_OBJECT FileObject OPTIONAL, IN TYPE_OF_OPEN TypeOfOpen, IN PVOID VcbOrFcbOrDcb, IN PCCB Ccb OPTIONAL)
TYPE_OF_OPEN	FatDecodeFileObject (_In_ PFILE_OBJECT FileObject, _Outptr_ PVCB *Vcb, _Outptr_ PFCB *FcbOrDcb, _Outptr_ PCCB *Ccb)
	_Requires_lock_held_ (_Global_critical_region_)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_FILOBSUP)

Definition at line 22 of file filobsup.c.

Dbg

#define Dbg   (DEBUG_TRACE_FILOBSUP)

Definition at line 28 of file filobsup.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 345 of file filobsup.c.

{
    PFCB OriginalFcb = Fcb;
    PFCB NextFcb;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatPurgeReferencedFileObjects, Fcb = %p\n", Fcb );
 
    NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
    //
    //  First, if we have a delayed close, force it closed.
    //
 
    FatFspClose(Fcb->Vcb);
 
    //
    //  Walk the directory tree forcing sections closed.
    //
    //  Note that it very important to get the next node to visit before
    //  acting on the current node.  This is because acting on a node may
    //  make it, and an arbitrary number of direct ancestors, vanish.
    //  Since we never visit ancestors in our top-down enumeration scheme, we
    //  can safely continue the enumeration even when the tree is vanishing
    //  beneath us.  This is way cool.
    //
 
    while ( Fcb != NULL ) {
 
        NextFcb = FatGetNextFcbTopDown(IrpContext, Fcb, OriginalFcb);
 
        //
        //  Check for the EA file fcb
        //
 
        if ( !FlagOn(Fcb->DirentFatFlags, FAT_DIRENT_ATTR_VOLUME_ID) ) {
 
            FatForceCacheMiss( IrpContext, Fcb, FlushType );
        }
 
        Fcb = NextFcb;
    }
 
    DebugTrace(-1, Dbg, "FatPurgeReferencedFileObjects (VOID)\n", 0 );
 
    return;
}

FatDecodeFileObject()

TYPE_OF_OPEN FatDecodeFileObject	(	_In_ PFILE_OBJECT	FileObject,
		_Outptr_ PVCB *	Vcb,
		_Outptr_ PFCB *	FcbOrDcb,
		_Outptr_ PCCB *	Ccb
	)

Definition at line 176 of file filobsup.c.

{
    TYPE_OF_OPEN TypeOfOpen;
    PVOID FsContext;
    PVOID FsContext2;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatDecodeFileObject, FileObject = %p\n", FileObject);
 
    //
    //  Reference the fs context fields of the file object, and zero out
    //  the out pointer parameters.
    //
 
    FsContext = FileObject->FsContext;
    FsContext2 = FileObject->FsContext2;
 
    //
    //  Special case the situation where FsContext is null
    //
 
    if (FsContext == NULL) {
 
        *Ccb = NULL;
        *FcbOrDcb = NULL;
        *Vcb = NULL;
 
        TypeOfOpen = UnopenedFileObject;
 
    } else {
 
        //
        //  Now we can case on the node type code of the fscontext pointer
        //  and set the appropriate out pointers
        //
 
        switch (NodeType(FsContext)) {
 
        case FAT_NTC_VCB:
 
            *Ccb = FsContext2;
            *FcbOrDcb = NULL;
            *Vcb = FsContext;
 
            TypeOfOpen = ( *Ccb == NULL ? VirtualVolumeFile : UserVolumeOpen );
 
            break;
 
        case FAT_NTC_ROOT_DCB:
        case FAT_NTC_DCB:
 
            *Ccb = FsContext2;
            *FcbOrDcb = FsContext;
            *Vcb = (*FcbOrDcb)->Vcb;
 
            TypeOfOpen = ( *Ccb == NULL ? DirectoryFile : UserDirectoryOpen );
 
            DebugTrace(0, Dbg, "Referencing directory: %wZ\n", &(*FcbOrDcb)->FullFileName);
 
            break;
 
        case FAT_NTC_FCB:
 
            *Ccb = FsContext2;
            *FcbOrDcb = FsContext;
            *Vcb = (*FcbOrDcb)->Vcb;
 
            if (*Ccb != NULL ) {
 
                TypeOfOpen = UserFileOpen;
                DebugTrace(0, Dbg, "Referencing file: %wZ\n", &(*FcbOrDcb)->FullFileName);
 
            } else {
 
                //
                // No Ccb means this is a special open.
                //
 
 
                if ( *FcbOrDcb == (*Vcb)->EaFcb ) {
 
                    TypeOfOpen = EaFile;
                    DebugTrace(0, Dbg, "Referencing EA file: %wZ\n", &(*FcbOrDcb)->FullFileName);
 
                } else {
 
#ifdef _MSC_VER
#pragma prefast(suppress:28159, "things are seriously wrong if we get here")
#endif
                    FatBugCheck( NodeType(FsContext), 0, 0 );
 
                }
 
            }
 
            break;
 
        default:
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "things are seriously wrong if we get here" )
#endif
            FatBugCheck( NodeType(FsContext), 0, 0 );
        }
    }
 
    //
    //  and return to our caller
    //
 
    DebugTrace(0, Dbg, "FatDecodeFileObject -> VCB(%p)\n", *Vcb);
    DebugTrace(0, Dbg, "FatDecodeFileObject -> FCB(%p)\n", *FcbOrDcb);
    DebugTrace(0, Dbg, "FatDecodeFileObject -> CCB(%p)\n", *Ccb);
    DebugTrace(-1, Dbg, "FatDecodeFileObject -> TypeOfOpen = %08lx\n", TypeOfOpen);
 
    return TypeOfOpen;
}

Referenced by _Function_class_(), _Requires_lock_held_(), FatAllowExtendedDasdIo(), FatCommonQueryEa(), FatCommonSetEa(), FatDeferredFlush(), FatFspDispatch(), FatIsVolumeDirty(), FatIsVolumeMounted(), FatSetRenameInfo(), FatSetZeroOnDeallocate(), and FatUnlockVolume().

FatSetFileObject()

VOID FatSetFileObject	(	IN PFILE_OBJECT FileObject	OPTIONAL,
		IN TYPE_OF_OPEN	TypeOfOpen,
		IN PVOID	VcbOrFcbOrDcb,
		IN PCCB Ccb	OPTIONAL
	)

Definition at line 39 of file filobsup.c.

{
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatSetFileObject, FileObject = %p\n", FileObject );
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
 
    NT_ASSERT(((TypeOfOpen == UnopenedFileObject))
 
                ||
 
           ((TypeOfOpen == UserFileOpen) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_FCB) &&
            (Ccb != NULL))
 
                ||
 
           ((TypeOfOpen == EaFile) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_FCB) &&
            (Ccb == NULL))
 
                ||
 
           ((TypeOfOpen == UserDirectoryOpen) &&
            ((NodeType(VcbOrFcbOrDcb) == FAT_NTC_DCB) || (NodeType(VcbOrFcbOrDcb) == FAT_NTC_ROOT_DCB)) &&
            (Ccb != NULL))
 
                ||
 
           ((TypeOfOpen == UserVolumeOpen) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) &&
            (Ccb != NULL))
 
                ||
 
           ((TypeOfOpen == VirtualVolumeFile) &&
            (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) &&
            (Ccb == NULL))
 
                ||
 
           ((TypeOfOpen == DirectoryFile) &&
            ((NodeType(VcbOrFcbOrDcb) == FAT_NTC_DCB) || (NodeType(VcbOrFcbOrDcb) == FAT_NTC_ROOT_DCB)) &&
            (Ccb == NULL))
            );
 
 
    UNREFERENCED_PARAMETER( TypeOfOpen );
 
    //
    //  If we were given an Fcb, Dcb, or Vcb, we have some processing to do.
    //
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
    if ( VcbOrFcbOrDcb != NULL ) {
 
        //
        //  Set the Vpb field in the file object, and if we were given an
        //  Fcb or Dcb move the field over to point to the nonpaged Fcb/Dcb
        //
 
        if (NodeType(VcbOrFcbOrDcb) == FAT_NTC_VCB) {
 
            FileObject->Vpb = ((PVCB)VcbOrFcbOrDcb)->Vpb;
 
        } else {
 
            FileObject->Vpb = ((PFCB)VcbOrFcbOrDcb)->Vcb->Vpb;
 
            //
            //  If this is a temporary file, note it in the FcbState
            //
 
            if (FlagOn(((PFCB)VcbOrFcbOrDcb)->FcbState, FCB_STATE_TEMPORARY)) {
 
                SetFlag(FileObject->Flags, FO_TEMPORARY_FILE);
            }
        }
    }
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
    //
    //  Now set the fscontext fields of the file object
    //
 
    if (ARGUMENT_PRESENT( FileObject )) {
 
        FileObject->FsContext  = VcbOrFcbOrDcb;
        FileObject->FsContext2 = Ccb;
    }
 
    NT_ASSERT((Ccb == NULL) || (NodeType(Ccb) == FAT_NTC_CCB));
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatSetFileObject -> VOID\n", 0);
 
    return;
}