lockctrl.cpp File Reference

#include "udffs.h"

Include dependency graph for lockctrl.cpp:

Go to the source code of this file.

Macros
#define	UDF_BUG_CHECK_ID   UDF_FILE_SHUTDOWN

Functions
NTSTATUS NTAPI	UDFLockControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	UDFCommonLockControl (IN PtrUDFIrpContext PtrIrpContext, IN PIRP Irp)
BOOLEAN NTAPI	UDFFastLock (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, PEPROCESS ProcessId, ULONG Key, BOOLEAN FailImmediately, BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastUnlockSingle (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, PEPROCESS ProcessId, ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastUnlockAll (IN PFILE_OBJECT FileObject, PEPROCESS ProcessId, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
BOOLEAN NTAPI	UDFFastUnlockAllByKey (IN PFILE_OBJECT FileObject, PEPROCESS ProcessId, ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

Macro Definition Documentation

UDF_BUG_CHECK_ID

#define UDF_BUG_CHECK_ID   UDF_FILE_SHUTDOWN

Definition at line 20 of file lockctrl.cpp.

Function Documentation

UDFCommonLockControl()

NTSTATUS NTAPI UDFCommonLockControl	(	IN PtrUDFIrpContext	PtrIrpContext,
		IN PIRP	Irp
	)

Definition at line 105 of file lockctrl.cpp.

{
    NTSTATUS            RC = STATUS_SUCCESS;
    PIO_STACK_LOCATION  IrpSp = NULL;
    //IO_STATUS_BLOCK     LocalIoStatus;
//    BOOLEAN             CompleteRequest = FALSE;
    BOOLEAN             PostRequest = FALSE;
    BOOLEAN             CanWait = FALSE;
    PtrUDFNTRequiredFCB NtReqFcb = NULL;
    BOOLEAN             AcquiredFCB = FALSE;
    PFILE_OBJECT        FileObject = NULL;
    PtrUDFFCB           Fcb = NULL;
    PtrUDFCCB           Ccb = NULL;
 
    UDFPrint(("UDFCommonLockControl\n"));
 
    _SEH2_TRY {
        // First, get a pointer to the current I/O stack location.
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        ASSERT(IrpSp);
 
        FileObject = IrpSp->FileObject;
        ASSERT(FileObject);
 
        // Get the FCB and CCB pointers.
        Ccb = (PtrUDFCCB)(FileObject->FsContext2);
        ASSERT(Ccb);
        Fcb = Ccb->Fcb;
        ASSERT(Fcb);
        // Validate the sent-in FCB
        if ( (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) ||
             (Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
 
//            CompleteRequest = TRUE;
            try_return(RC = STATUS_INVALID_PARAMETER);
        }
 
        NtReqFcb = Fcb->NTRequiredFCB;
        CanWait = ((PtrIrpContext->IrpContextFlags & UDF_IRP_CONTEXT_CAN_BLOCK) ? TRUE : FALSE);
 
        // Acquire the FCB resource shared
        UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
        if (!UDFAcquireResourceExclusive(&(NtReqFcb->MainResource), CanWait)) {
            PostRequest = TRUE;
            try_return(RC = STATUS_PENDING);
        }
        AcquiredFCB = TRUE;
 
        RC = FsRtlProcessFileLock(&(NtReqFcb->FileLock), Irp, NULL);
//        CompleteRequest = TRUE;
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        // Release the FCB resources if acquired.
        if (AcquiredFCB) {
            UDF_CHECK_PAGING_IO_RESOURCE(NtReqFcb);
            UDFReleaseResource(&(NtReqFcb->MainResource));
            AcquiredFCB = FALSE;
        }
        if (PostRequest) {
            // Perform appropriate post related processing here
            RC = UDFPostRequest(PtrIrpContext, Irp);
        } else
        if(!_SEH2_AbnormalTermination()) {
            // Simply free up the IrpContext since the IRP has been queued or
            // Completed by FsRtlProcessFileLock
            UDFReleaseIrpContext(PtrIrpContext);
        }
    } _SEH2_END; // end of "__finally" processing
 
    return(RC);
} // end UDFCommonLockControl()

Referenced by UDFLockControl().

UDFFastLock()

BOOLEAN NTAPI UDFFastLock	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN PLARGE_INTEGER	Length,
		PEPROCESS	ProcessId,
		ULONG	Key,
		BOOLEAN	FailImmediately,
		BOOLEAN	ExclusiveLock,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 205 of file lockctrl.cpp.

{
    BOOLEAN Results = FALSE;
 
//    BOOLEAN             AcquiredFCB = FALSE;
    PtrUDFFCB           Fcb = NULL;
    PtrUDFCCB           Ccb = NULL;
 
    UDFPrint(("UDFFastLock\n"));
    //  Decode the type of file object we're being asked to process and make
    //  sure it is only a user file open.
 
 
    // Get the FCB and CCB pointers.
    Ccb = (PtrUDFCCB)(FileObject->FsContext2);
    ASSERT(Ccb);
    Fcb = Ccb->Fcb;
    ASSERT(Fcb);
    // Validate the sent-in FCB
    if ( (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) ||
         (Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        IoStatus->Information = 0;
        return TRUE;
    }
 
    //  Acquire exclusive access to the Fcb this operation can always wait
 
    FsRtlEnterFileSystem();
 
    // BUGBUG: kenr
    // (VOID) ExAcquireResourceShared( Fcb->Header.Resource, TRUE );
 
    _SEH2_TRY {
 
        //  We check whether we can proceed
        //  based on the state of the file oplocks.
 
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request
        if ((Results = FsRtlFastLock( &(Fcb->NTRequiredFCB->FileLock),
                                     FileObject,
                                     FileOffset,
                                     Length,
                                     ProcessId,
                                     Key,
                                     FailImmediately,
                                     ExclusiveLock,
                                     IoStatus,
                                     NULL,
                                     FALSE ))) {
 
            //  Set the flag indicating if Fast I/O is possible
            Fcb->NTRequiredFCB->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(Fcb);
        }
 
//try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        //  Release the Fcb, and return to our caller
 
        // BUGBUG: kenr
        //    UDFReleaseResource( (Fcb)->Header.Resource );
 
        FsRtlExitFileSystem();
 
    } _SEH2_END;
 
    return Results;
} // end UDFFastLock()

Referenced by UDFInitializeFunctionPointers().

UDFFastUnlockAll()

BOOLEAN NTAPI UDFFastUnlockAll	(	IN PFILE_OBJECT	FileObject,
		PEPROCESS	ProcessId,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 404 of file lockctrl.cpp.

{
    BOOLEAN Results = FALSE;
 
//    BOOLEAN             AcquiredFCB = FALSE;
    PtrUDFFCB           Fcb = NULL;
    PtrUDFCCB           Ccb = NULL;
 
    UDFPrint(("UDFFastUnlockAll\n"));
 
    IoStatus->Information = 0;
    //  Decode the type of file object we're being asked to process and make
    //  sure it is only a user file open.
 
    // Get the FCB and CCB pointers.
    Ccb = (PtrUDFCCB)(FileObject->FsContext2);
    ASSERT(Ccb);
    Fcb = Ccb->Fcb;
    ASSERT(Fcb);
    // Validate the sent-in FCB
    if ( (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) ||
         (Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        return TRUE;
    }
 
    //  Acquire shared access to the Fcb this operation can always wait
 
    FsRtlEnterFileSystem();
 
    UDF_CHECK_PAGING_IO_RESOURCE(Fcb->NTRequiredFCB);
    UDFAcquireResourceShared( &(Fcb->NTRequiredFCB->MainResource),TRUE );
 
    _SEH2_TRY {
 
        //  We check whether we can proceed
        //  based on the state of the file oplocks.
 
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request
        Results = TRUE;
        IoStatus->Status = FsRtlFastUnlockAll( &(Fcb->NTRequiredFCB->FileLock),
                                               FileObject,
                                               ProcessId,
                                               NULL );
 
        //  Set the flag indicating if Fast I/O is questionable
 
        Fcb->NTRequiredFCB->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible( Fcb );
 
//try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        //  Release the Fcb, and return to our caller
 
        UDF_CHECK_PAGING_IO_RESOURCE(Fcb->NTRequiredFCB);
        UDFReleaseResource(&(Fcb->NTRequiredFCB->MainResource));
        FsRtlExitFileSystem();
 
    } _SEH2_END;
 
    return Results;
} // end UDFFastUnlockAll()

Referenced by UDFInitializeFunctionPointers().

UDFFastUnlockAllByKey()

BOOLEAN NTAPI UDFFastUnlockAllByKey	(	IN PFILE_OBJECT	FileObject,
		PEPROCESS	ProcessId,
		ULONG	Key,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 494 of file lockctrl.cpp.

{
    BOOLEAN Results = FALSE;
 
//    BOOLEAN             AcquiredFCB = FALSE;
    PtrUDFFCB           Fcb = NULL;
    PtrUDFCCB           Ccb = NULL;
 
    UDFPrint(("UDFFastUnlockAllByKey\n"));
 
    IoStatus->Information = 0;
    //  Decode the type of file object we're being asked to process and make
    //  sure it is only a user file open.
 
    // Get the FCB and CCB pointers.
    Ccb = (PtrUDFCCB)(FileObject->FsContext2);
    ASSERT(Ccb);
    Fcb = Ccb->Fcb;
    ASSERT(Fcb);
    // Validate the sent-in FCB
    if ( (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) ||
         (Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        return TRUE;
    }
 
    //  Acquire shared access to the Fcb this operation can always wait
 
    FsRtlEnterFileSystem();
 
    UDF_CHECK_PAGING_IO_RESOURCE(Fcb->NTRequiredFCB);
    UDFAcquireResourceShared( &(Fcb->NTRequiredFCB->MainResource),TRUE );
 
    _SEH2_TRY {
 
        //  We check whether we can proceed
        //  based on the state of the file oplocks.
 
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request
        Results = TRUE;
        IoStatus->Status = FsRtlFastUnlockAllByKey( &(Fcb->NTRequiredFCB->FileLock),
                                                    FileObject,
                                                    ProcessId,
                                                    Key,
                                                    NULL );
 
        //  Set the flag indicating if Fast I/O is possible
 
        Fcb->NTRequiredFCB->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible( Fcb );
 
//try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        //  Release the Fcb, and return to our caller
 
        UDF_CHECK_PAGING_IO_RESOURCE(Fcb->NTRequiredFCB);
        UDFReleaseResource(&(Fcb->NTRequiredFCB->MainResource));
        FsRtlExitFileSystem();
 
    } _SEH2_END;
 
    return Results;
} // end UDFFastUnlockAllByKey()

Referenced by UDFInitializeFunctionPointers().

UDFFastUnlockSingle()

BOOLEAN NTAPI UDFFastUnlockSingle	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN PLARGE_INTEGER	Length,
		PEPROCESS	ProcessId,
		ULONG	Key,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 309 of file lockctrl.cpp.

{
    BOOLEAN Results = FALSE;
 
//    BOOLEAN             AcquiredFCB = FALSE;
    PtrUDFFCB           Fcb = NULL;
    PtrUDFCCB           Ccb = NULL;
 
    UDFPrint(("UDFFastUnlockSingle\n"));
    //  Decode the type of file object we're being asked to process and make
    //  sure it is only a user file open.
 
    IoStatus->Information = 0;
 
    // Get the FCB and CCB pointers.
    Ccb = (PtrUDFCCB)(FileObject->FsContext2);
    ASSERT(Ccb);
    Fcb = Ccb->Fcb;
    ASSERT(Fcb);
    // Validate the sent-in FCB
    if ( (Fcb->NodeIdentifier.NodeType == UDF_NODE_TYPE_VCB) ||
         (Fcb->FCBFlags & UDF_FCB_DIRECTORY)) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        return TRUE;
    }
 
    //  Acquire exclusive access to the Fcb this operation can always wait
 
    FsRtlEnterFileSystem();
 
    // BUGBUG: kenr
    // (VOID) ExAcquireResourceShared( Fcb->Header.Resource, TRUE );
 
    _SEH2_TRY {
 
        //  We check whether we can proceed
        //  based on the state of the file oplocks.
 
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request
        Results = TRUE;
        IoStatus->Status = FsRtlFastUnlockSingle( &(Fcb->NTRequiredFCB->FileLock),
                                                  FileObject,
                                                  FileOffset,
                                                  Length,
                                                  ProcessId,
                                                  Key,
                                                  NULL,
                                                  FALSE );
        //  Set the flag indicating if Fast I/O is possible
        Fcb->NTRequiredFCB->CommonFCBHeader.IsFastIoPossible = UDFIsFastIoPossible(Fcb);
 
//try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        //  Release the Fcb, and return to our caller
 
        // BUGBUG: kenr
        //    UDFReleaseResource( (Fcb)->Header.Resource );
 
        FsRtlExitFileSystem();
 
    } _SEH2_END;
 
    return Results;
} // end UDFFastUnlockSingle()

Referenced by UDFInitializeFunctionPointers().

UDFLockControl()

NTSTATUS NTAPI UDFLockControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 38 of file lockctrl.cpp.

{
    NTSTATUS            RC = STATUS_SUCCESS;
    PtrUDFIrpContext    PtrIrpContext = NULL;
    BOOLEAN             AreWeTopLevel = FALSE;
 
    UDFPrint(("UDFLockControl\n"));
//    BrutePoint();
 
    FsRtlEnterFileSystem();
    ASSERT(DeviceObject);
    ASSERT(Irp);
 
    // set the top level context
    AreWeTopLevel = UDFIsIrpTopLevel(Irp);
    //  Call the common Lock Control routine, with blocking allowed if
    //  synchronous
    _SEH2_TRY {
 
        // get an IRP context structure and issue the request
        PtrIrpContext = UDFAllocateIrpContext(Irp, DeviceObject);
        if(PtrIrpContext) {
            RC = UDFCommonLockControl(PtrIrpContext, Irp);
        } else {
            RC = STATUS_INSUFFICIENT_RESOURCES;
            Irp->IoStatus.Status = RC;
            Irp->IoStatus.Information = 0;
            // complete the IRP
            IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        }
 
    } _SEH2_EXCEPT(UDFExceptionFilter(PtrIrpContext, _SEH2_GetExceptionInformation())) {
 
        RC = UDFExceptionHandler(PtrIrpContext, Irp);
 
        UDFLogEvent(UDF_ERROR_INTERNAL_ERROR, RC);
    } _SEH2_END;
 
    if (AreWeTopLevel) {
        IoSetTopLevelIrp(NULL);
    }
 
    FsRtlExitFileSystem();
 
    return(RC);
} // end UDFLockControl()

Referenced by UDFInitializeFunctionPointers().