udfprocs.h

windows 2000中的UDF文件系统的驱动程序.只有读的功能,不支持未关闭的盘片.只支持UDF2.0以下版本,不支持VAT格式的UDF.

}

INLINE
USHORT
UdfCS0DstringUnicodeSize (
    PIRP_CONTEXT IrpContext,
    PCHAR Dstring,
    UCHAR Length
    )

/*++

Routine Description:

    This routine computes the number of bytes required for the UNICODE representation
    of a CS0 Dstring (1/7.2.12)
    
Arguments:

    Dstring - a dstring
    
    Length - length of the dstring
    
Return Value:

    ULONG number of bytes.
    
--*/

{
    return (16 / *Dstring) * (Length - 1);
}

INLINE
BOOLEAN
UdfIsCharacterLegal (
    IN WCHAR Character
    )

/*++

Routine Description:

    This routine checks that a given UNICODE character is legal.
    
Arguments:

    Character - a character to check
    
Return Value:

    BOOLEAN True if a legal character, False otherwise.
    
--*/

{
    if (Character < 0xff && !FsRtlIsAnsiCharacterLegalHpfs( Character, FALSE )) {

        return FALSE;
    }

    return TRUE;
}

INLINE
BOOLEAN
UdfCS0DstringContainsLegalCharacters (
    IN PCHAR Dstring,
    IN ULONG Length
    )

/*++

Routine Description:

    This routine inspects a CS0 dstring for illegal characters.  The assumption is
    made that the string is legal CS0.
    
Arguments:

    Name - a name to check
    
Return Value:

    BOOLEAN True if legal characters are found, False otherwise.
    
--*/

{
    ULONG Step;
    WCHAR Char;
    PCHAR Bound = Dstring + Length;

    //
    //  Determine how big a step we take in the string according to the
    //  "compression" applied.
    //
    
    if (*Dstring == 16) {

        Step = sizeof( WCHAR );
    
    } else {

        Step = sizeof( CHAR );
    }

    //
    //  Advance past the compression marker and loop over the string.
    //
    
    for (Dstring++; Dstring < Bound; Dstring += Step) {

        //
        //  Perform the endianess swapcopy to convert from UDF bigendian CS0 to our
        //  little endian wide characters.
        //
        
        SwapCopyUchar2( &Char, Dstring );
        
        if (!UdfIsCharacterLegal( Char )) {

            DebugTrace(( 0, Dbg, "UdfCS0DstringContainsLegalCharacters, Char %04x @ %08x\n", (WCHAR) Char, Dstring ));

            return FALSE;
        }
    }

    return TRUE;
}


//
//  Filesystem control operations.  Implemented in Fsctrl.c
//

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

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


//
//  Routines to handle the prefix trees attached to directories, used to quickly travel common
//  bits of the hierarchy.  Implemented in PrefxSup.c
//

PLCB
UdfFindPrefix (
    IN PIRP_CONTEXT IrpContext,
    IN OUT PFCB *CurrentFcb,
    IN OUT PUNICODE_STRING RemainingName,
    IN BOOLEAN IgnoreCase
    );

VOID            
UdfInitializeLcbFromDirContext (
    IN PIRP_CONTEXT IrpContext,
    IN PLCB Lcb,
    IN PDIR_ENUM_CONTEXT DirContext
    );

PLCB
UdfInsertPrefix (
    IN PIRP_CONTEXT IrpContext,
    IN PFCB Fcb,
    IN PUNICODE_STRING Name,
    IN BOOLEAN ShortNameMatch,
    IN BOOLEAN IgnoreCase,
    IN PFCB ParentFcb
    );

VOID
UdfRemovePrefix (
    IN PIRP_CONTEXT IrpContext,
    IN PLCB Lcb
    );


//
//  Synchronization routines.  Implemented in Resrcsup.c
//
//  The following routines/macros are used to synchronize the in-memory structures.
//
//      Routine/Macro               Synchronizes                            Subsequent
//
//      UdfAcquireUdfData           Volume Mounts/Dismounts,Vcb Queue       UdfReleaseUdfData
//      UdfAcquireVcbExclusive      Vcb for open/close                      UdfReleaseVcb
//      UdfAcquireVcbShared         Vcb for open/close                      UdfReleaseVcb
//      UdfAcquireAllFiles          Locks out operations to all files       UdfReleaseAllFiles
//      UdfAcquireFileExclusive     Locks out file operations               UdfReleaseFile
//      UdfAcquireFileShared        Files for file operations               UdfReleaseFile
//      UdfAcquireFcbExclusive      Fcb for open/close                      UdfReleaseFcb
//      UdfAcquireFcbShared         Fcb for open/close                      UdfReleaseFcb
//      UdfLockUdfData              Fields in UdfData                       UdfUnlockUdfData
//      UdfLockVcb                  Vcb fields, FcbReference, FcbTable      UdfUnlockVcb
//      UdfLockFcb                  Fcb fields, prefix table, Mcb           UdfUnlockFcb
//

typedef enum _TYPE_OF_ACQUIRE {
    
    AcquireExclusive,
    AcquireShared,
    AcquireSharedStarveExclusive

} TYPE_OF_ACQUIRE, *PTYPE_OF_ACQUIRE;

BOOLEAN
UdfAcquireResource (
    IN PIRP_CONTEXT IrpContext,
    IN PERESOURCE Resource,
    IN BOOLEAN IgnoreWait,
    IN TYPE_OF_ACQUIRE Type
    );

//
//  BOOLEAN
//  UdfAcquireUdfData (
//      IN PIRP_CONTEXT IrpContext
//      );
//
//  VOID
//  UdfReleaseUdfData (
//      IN PIRP_CONTEXT IrpContext
//    );
//
//  BOOLEAN
//  UdfAcquireVcbExclusive (
//      IN PIRP_CONTEXT IrpContext,
//      IN PVCB Vcb,
//      IN BOOLEAN IgnoreWait
//      );
//
//  BOOLEAN
//  UdfAcquireVcbShared (
//      IN PIRP_CONTEXT IrpContext,
//      IN PVCB Vcb,
//      IN BOOLEAN IgnoreWait
//      );
//
//  VOID
//  UdfReleaseVcb (
//      IN PIRP_CONTEXT IrpContext,
//      IN PVCB Vcb
//      );
//
//  VOID
//  UdfAcquireAllFiles (
//      IN PIRP_CONTEXT,
//      IN PVCB Vcb
//      );
//
//  VOID
//  UdfReleaseAllFiles (
//      IN PIRP_CONTEXT,
//      IN PVCB Vcb
//      );
//
//  VOID
//  UdfAcquireFileExclusive (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb,
//      );
//
//  VOID
//  UdfAcquireFileShared (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//
//  VOID
//  UdfReleaseFile (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//    );
//
//  BOOLEAN
//  UdfAcquireFcbExclusive (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb,
//      IN BOOLEAN IgnoreWait
//      );
//
//  BOOLEAN
//  UdfAcquireFcbShared (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb,
//      IN BOOLEAN IgnoreWait
//      );
//
//  BOOLEAN
//  UdfReleaseFcb (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//
//  VOID
//  UdfLockUdfData (
//      );
//
//  VOID
//  UdfUnlockUdfData (
//      );
//
//  VOID
//  UdfLockVcb (
//      IN PIRP_CONTEXT IrpContext
//      );
//
//  VOID
//  UdfUnlockVcb (
//      IN PIRP_CONTEXT IrpContext
//      );
//
//  VOID
//  UdfLockFcb (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//
//  VOID
//  UdfUnlockFcb (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//

#define UdfAcquireUdfData(IC)                                                           \
    ExAcquireResourceExclusive( &UdfData.DataResource, TRUE )

#define UdfReleaseUdfData(IC)                                                           \
    ExReleaseResource( &UdfData.DataResource )

#define UdfAcquireVcbExclusive(IC,V,I)                                                  \
    UdfAcquireResource( (IC), &(V)->VcbResource, (I), AcquireExclusive )

#define UdfAcquireVcbShared(IC,V,I)                                                     \
    UdfAcquireResource( (IC), &(V)->VcbResource, (I), AcquireShared )

#define UdfReleaseVcb(IC,V)                                                             \
    ExReleaseResource( &(V)->VcbResource )

#define UdfAcquireAllFiles(IC,V)                                                        \
    UdfAcquireResource( (IC), &(V)->FileResource, FALSE, AcquireExclusive )

#define UdfReleaseAllFiles(IC,V)                                                        \
    ExReleaseResource( &(V)->FileResource )

#define UdfAcquireFileExclusive(IC,F)                                                   \
    UdfAcquireResource( (IC), (F)->Resource, FALSE, AcquireExclusive )

#define UdfAcquireFileShared(IC,F)                                                      \
    UdfAcquireResource( (IC), (F)->Resource, FALSE, AcquireShared )

#define UdfAcquireFileSharedStarveExclusive(IC,F)                                       \
    UdfAcquireResource( (IC), (F)->Resource, FALSE, AcquireSharedStarveExclusive )

#define UdfReleaseFile(IC,F)                                                            \
    ExReleaseResource( (F)->Resource )

#define UdfAcquireFcbExclusive(IC,F,I)                                                  \
    UdfAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireExclusive )

#define UdfAcquireFcbShared(IC,F,I)                                                     \
    UdfAcquireResource( (IC), &(F)->FcbNonpaged->FcbResource, (I), AcquireShared )

#define UdfReleaseFcb(IC,F)                                                             \
    ExReleaseResource( &(F)->FcbNonpaged->FcbResource )

#define UdfLockUdfData()                                                                \
    ExAcquireFastMutex( &UdfData.UdfDataMutex );                                        \
    UdfData.UdfDataLockThread = PsGetCurrentThread()

#define UdfUnlockUdfData()                                                              \
    UdfData.UdfDataLockThread = NULL;                                                   \
    ExReleaseFastMutex( &UdfData.UdfDataMutex )

#define UdfLockVcb(IC,V)                                                                \
    ExAcquireFastMutex( &(V)->VcbMutex );                                               \
    (V)->VcbLockThread = PsGetCurrentThread()

#define UdfUnlockVcb(IC,V)                                                              \
    (V)->VcbLockThread = NULL;                                                          \
    ExReleaseFastMutex( &(V)->VcbMutex )

#define UdfLockFcb(IC,F) {                                                              \
    PVOID _CurrentThread = PsGetCurrentThread();                                        \
    if (_CurrentThread != (F)->FcbLockThread) {                                         \
        ExAcquireFastMutex( &(F)->FcbNonpaged->FcbMutex );                              \
        ASSERT( (F)->FcbLockCount == 0 );                                               \
        (F)->FcbLockThread = _CurrentThread;                                            \
    }                                                                                   \
    (F)->FcbLockCount += 1;                                                             \
}

#define UdfUnlockFcb(IC,F) {                                                            \
    (F)->FcbLockCount -= 1;                                                             \
    if ((F)->FcbLockCount == 0) {                                                       \
        (F)->FcbLockThread = NULL;                                                      \
        ExReleaseFastMutex( &(F)->FcbNonpaged->FcbMutex );                              \
    }                                                                                   \
}

BOOLEAN
UdfNoopAcquire (
    IN PVOID Fcb,
    IN BOOLEAN Wait
    );

VOID
UdfNoopRelease (
    IN PVOID Fcb
    );

BOOLEAN
UdfAcquireForCache (
    IN PFCB Fcb,
    IN BOOLEAN Wait
    );

VOID
UdfReleaseFromCache (
    IN PFCB Fcb
    );

VOID
UdfAcquireForCreateSection (
    IN PFILE_OBJECT FileObject
    );

VOID
UdfReleaseForCreateSection (
    IN PFILE_OBJECT FileObject
    );


//
//  Structure support routines, implemented in StrucSup.c
//
//  These routines perform in-memory structure manipulations. They do *not* operate
//  on disk structures.
//

BOOLEAN
UdfInitializeVcb (
    IN PIRP_CONTEXT IrpContext,
    IN OUT PVCB Vcb,
    IN PDEVICE_OBJECT TargetDeviceObject,
    IN PVPB Vpb,
    IN PDISK_GEOMETRY DiskGeometry,
    IN ULONG MediaChangeCount
    );

VOID
UdfUpdateVcbPhase0 (
    IN PIRP_CONTEXT IrpContext,
    IN OUT PVCB Vcb
    );

VOID
UdfUpdateVcbPhase1 (
    IN PIRP_CONTEXT IrpContext,
    IN OUT PVCB Vcb,
    IN PNSR_FSD Fsd
    );

VOID
UdfDeleteVcb (
    IN PIRP_CONTEXT IrpContext,
    IN OUT PVCB Vcb
    );

PIRP_CONTEXT
UdfCreateIrpContext (
    IN PIRP Irp,
    IN BOOLEAN Wait
    );

VOID
UdfCleanupIrpContext (
    IN PIRP_CONTEXT IrpContext,
    IN BOOLEAN Post
    );

VOID
UdfInitializeStackIrpContext (
    OUT PIRP_CONTEXT IrpContext,
    IN PIRP_CONTEXT_LITE IrpContextLite
    );

//
//  PIRP_CONTEXT_LITE
//  UdfCreateIrpContextLite (
//      IN PIRP_CONTEXT IrpContext
//      );
//
//  VOID
//  UdfFreeIrpContextLite (
//      IN PIRP_CONTEXT_LITE IrpContextLite
//      );
//

#define UdfCreateIrpContextLite(IC)  \
    ExAllocatePoolWithTag( UdfNonPagedPool, sizeof( IRP_CONTEXT_LITE ), TAG_IRP_CONTEXT_LITE )

#define UdfFreeIrpContextLite(ICL)  \
    ExFreePool( ICL )

//
//  PUDF_IO_CONTEXT
//  UdfAllocateIoContext (
//      );
//
//  VOID
//  UdfFreeIoContext (
//      PUDF_IO_CONTEXT IoContext
//      );
//

#define UdfAllocateIoContext()                           \
    FsRtlAllocatePoolWithTag( UdfNonPagedPool,           \
                              sizeof( UDF_IO_CONTEXT ),  \
                              TAG_IO_CONTEXT )

#define UdfFreeIoContext(IO)     ExFreePool( IO )

//
//  VOID
//  UdfIncrementCleanupCounts (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//
//  VOID
//  UdfDecrementCleanupCounts (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//
//  VOID
//  UdfIncrementReferenceCounts (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb,
//      IN ULONG ReferenceCount
//      IN ULONG UserReferenceCount
//      );
//
//  VOID
//  UdfDecrementReferenceCounts (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb,
//      IN ULONG ReferenceCount
//      IN ULONG UserReferenceCount
//      );
//
//  VOID
//  UdfIncrementFcbReference (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//
//  VOID
//  UdfDecrementFcbReference (
//      IN PIRP_CONTEXT IrpContext,
//      IN PFCB Fcb
//      );
//

#define UdfIncrementCleanupCounts(IC,F) {        \
    ASSERT_LOCKED_VCB( (F)->Vcb );              \
    (F)->FcbCleanup += 1;                       \
    (F)->Vcb->VcbCleanup += 1;                  \
}

#define UdfDecrementCleanupCounts(IC,F) {        \
    ASSERT_LOCKED_VCB( (F)->Vcb );              \
    (F)->FcbCleanup -= 1;                       \