lockctrl.c File Reference

#include "fatprocs.h"

Include dependency graph for lockctrl.c:

Go to the source code of this file.

Macros
#define	Dbg   (DEBUG_TRACE_LOCKCTRL)

Functions
	_Function_class_ (IRP_MJ_LOCK_CONTROL)
	_Function_class_ (FAST_IO_LOCK)
	_Function_class_ (FAST_IO_UNLOCK_SINGLE)
	_Function_class_ (FAST_IO_UNLOCK_ALL)
	_Function_class_ (FAST_IO_UNLOCK_ALL_BY_KEY)
	_Requires_lock_held_ (_Global_critical_region_)

Macro Definition Documentation

Dbg

#define Dbg   (DEBUG_TRACE_LOCKCTRL)

Definition at line 23 of file lockctrl.c.

Function Documentation

_Function_class_() [1/5]

_Function_class_

(

FAST_IO_LOCK

)

Definition at line 116 of file lockctrl.c.

{
    BOOLEAN Results = FALSE;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( DeviceObject );
 
    DebugTrace(+1, Dbg, "FatFastLock\n", 0);
 
    //
    //  Decode the type of file object we're being asked to process and make
    //  sure it is only a user file open.
    //
 
    if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        IoStatus->Information = 0;
 
        DebugTrace(-1, Dbg, "FatFastLock -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
        return TRUE;
    }
 
    //
    //  Acquire shared access to the Fcb
    //
 
    FsRtlEnterFileSystem();
    ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );
 
    _SEH2_TRY {
 
        //
        //  We check whether we can proceed
        //  based on the state of the file oplocks.
        //
 
        if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
 
            try_return( Results = FALSE );
        }
 
        //
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request
        //
 
#ifdef _MSC_VER
#pragma prefast( suppress:28159, "prefast indicates this API is obsolete but it is ok for fastfat to continue using it" )
#endif
        Results = FsRtlFastLock( &Fcb->Specific.Fcb.FileLock,
                                 FileObject,
                                 FileOffset,
                                 Length,
                                 ProcessId,
                                 Key,
                                 FailImmediately,
                                 ExclusiveLock,
                                 IoStatus,
                                 NULL,
                                 FALSE );
 
        if (Results) {
 
            //
            //  Set the flag indicating if Fast I/O is possible
            //
 
            Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
        }
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        DebugUnwind( FatFastLock );
 
        //
        //  Release the Fcb, and return to our caller
        //
 
        ExReleaseResourceLite( Fcb->Header.Resource );
        FsRtlExitFileSystem();
 
        DebugTrace(-1, Dbg, "FatFastLock -> %08lx\n", Results);
    } _SEH2_END;
 
    return Results;
}

_Function_class_() [2/5]

_Function_class_

(

FAST_IO_UNLOCK_ALL

)

Definition at line 378 of file lockctrl.c.

{
    BOOLEAN Results = FALSE;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( DeviceObject );
 
    DebugTrace(+1, Dbg, "FatFastUnlockAll\n", 0);
 
    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.
    //
 
    if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
 
        DebugTrace(-1, Dbg, "FatFastUnlockAll -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
        return TRUE;
    }
 
    //
    //  Acquire exclusive access to the Fcb this operation can always wait
    //
 
    FsRtlEnterFileSystem();
 
    (VOID) ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );
 
    _SEH2_TRY {
 
        //
        //  We check whether we can proceed based on the state of the file oplocks.
        //
 
        if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
 
            try_return( Results = FALSE );
        }
 
        //
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request.  The call will always succeed.
        //
 
        Results = TRUE;
        IoStatus->Status = FsRtlFastUnlockAll( &Fcb->Specific.Fcb.FileLock,
                                               FileObject,
                                               ProcessId,
                                               NULL );
 
        //
        //  Set the flag indicating if Fast I/O is possible
        //
 
        Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        DebugUnwind( FatFastUnlockAll );
 
        //
        //  Release the Fcb, and return to our caller
        //
 
        ExReleaseResourceLite( (Fcb)->Header.Resource );
 
        FsRtlExitFileSystem();
 
        DebugTrace(-1, Dbg, "FatFastUnlockAll -> %08lx\n", Results);
    } _SEH2_END;
 
    return Results;
}

_Function_class_() [3/5]

_Function_class_

(

FAST_IO_UNLOCK_ALL_BY_KEY

)

Definition at line 491 of file lockctrl.c.

{
    BOOLEAN Results = FALSE;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( DeviceObject );
 
    DebugTrace(+1, Dbg, "FatFastUnlockAllByKey\n", 0);
 
    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.
    //
 
    if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
 
        DebugTrace(-1, Dbg, "FatFastUnlockAll -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
        return TRUE;
    }
 
    //
    //  Acquire exclusive access to the Fcb this operation can always wait
    //
 
    FsRtlEnterFileSystem();
 
    (VOID) ExAcquireResourceSharedLite( Fcb->Header.Resource, TRUE );
 
    _SEH2_TRY {
 
        //
        //  We check whether we can proceed based on the state of the file oplocks.
        //
 
        if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
 
            try_return( Results = FALSE );
        }
 
        //
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request.  The call will always succeed.
        //
 
        Results = TRUE;
        IoStatus->Status = FsRtlFastUnlockAllByKey( &Fcb->Specific.Fcb.FileLock,
                                                    FileObject,
                                                    ProcessId,
                                                    Key,
                                                    NULL );
 
        //
        //  Set the flag indicating if Fast I/O is possible
        //
 
        Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        DebugUnwind( FatFastUnlockAllByKey );
 
        //
        //  Release the Fcb, and return to our caller
        //
 
        ExReleaseResourceLite( (Fcb)->Header.Resource );
 
        FsRtlExitFileSystem();
 
        DebugTrace(-1, Dbg, "FatFastUnlockAllByKey -> %08lx\n", Results);
    } _SEH2_END;
 
    return Results;
}

_Function_class_() [4/5]

_Function_class_

(

FAST_IO_UNLOCK_SINGLE

)

Definition at line 256 of file lockctrl.c.

{
    BOOLEAN Results = FALSE;
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    PAGED_CODE();
    UNREFERENCED_PARAMETER( DeviceObject );
 
    DebugTrace(+1, Dbg, "FatFastUnlockSingle\n", 0);
 
    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
    //
 
    if (FatDecodeFileObject( FileObject, &Vcb, &Fcb, &Ccb ) != UserFileOpen) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
 
        DebugTrace(-1, Dbg, "FatFastUnlockSingle -> TRUE (STATUS_INVALID_PARAMETER)\n", 0);
        return TRUE;
    }
 
    //
    //  Acquire exclusive access to the Fcb this operation can always wait
    //
 
    FsRtlEnterFileSystem();
 
    _SEH2_TRY {
 
        //
        //  We check whether we can proceed based on the state of the file oplocks.
        //
 
        if (!FsRtlOplockIsFastIoPossible( FatGetFcbOplock(Fcb) )) {
 
            try_return( Results = FALSE );
        }
 
        //
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request.  The call will always succeed.
        //
 
        Results = TRUE;
        IoStatus->Status = FsRtlFastUnlockSingle( &Fcb->Specific.Fcb.FileLock,
                                                  FileObject,
                                                  FileOffset,
                                                  Length,
                                                  ProcessId,
                                                  Key,
                                                  NULL,
                                                  FALSE );
 
        //
        //  Set the flag indicating if Fast I/O is possible
        //
 
        Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        DebugUnwind( FatFastUnlockSingle );
 
        //
        //  Release the Fcb, and return to our caller
        //
 
        FsRtlExitFileSystem();
 
        DebugTrace(-1, Dbg, "FatFastUnlockSingle -> %08lx\n", Results);
    } _SEH2_END;
 
    return Results;
}

_Function_class_() [5/5]

_Function_class_

(

IRP_MJ_LOCK_CONTROL

)

Definition at line 35 of file lockctrl.c.

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

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 608 of file lockctrl.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PIO_STACK_LOCATION IrpSp;
 
    TYPE_OF_OPEN TypeOfOpen;
 
    PVCB Vcb;
    PFCB Fcb;
    PCCB Ccb;
 
    BOOLEAN OplockPostIrp = FALSE;
 
    PAGED_CODE();
 
    //
    //  Get a pointer to the current Irp stack location
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatCommonLockControl\n", 0);
    DebugTrace( 0, Dbg, "Irp           = %p\n", Irp);
    DebugTrace( 0, Dbg, "MinorFunction = %08lx\n", IrpSp->MinorFunction);
 
    //
    //  Decode the type of file object we're being asked to process
    //
 
    TypeOfOpen = FatDecodeFileObject( IrpSp->FileObject, &Vcb, &Fcb, &Ccb );
 
    //
    //  If the file is not a user file open then we reject the request
    //  as an invalid parameter
    //
 
    if (TypeOfOpen != UserFileOpen) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
        DebugTrace(-1, Dbg, "FatCommonLockControl -> STATUS_INVALID_PARAMETER\n", 0);
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    //  Acquire exclusive access to the Fcb and enqueue the Irp if we didn't
    //  get access
    //
 
    if (!FatAcquireSharedFcb( IrpContext, Fcb )) {
 
        Status = FatFsdPostRequest( IrpContext, Irp );
 
        DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
        return Status;
    }
 
    _SEH2_TRY {
 
        //
        //  We check whether we can proceed
        //  based on the state of the file oplocks.
        //
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
 
        if (((IRP_MN_LOCK == IrpSp->MinorFunction) &&
             ((ULONGLONG)IrpSp->Parameters.LockControl.ByteOffset.QuadPart <
              (ULONGLONG)Fcb->Header.AllocationSize.QuadPart)) ||
            ((IRP_MN_LOCK != IrpSp->MinorFunction) &&
             FsRtlAreThereWaitingFileLocks( &Fcb->Specific.Fcb.FileLock ))) {
 
            //
            //  Check whether we can proceed based on the state of file oplocks if doing
            //  an operation that interferes with oplocks. Those operations are:
            //
            //      1. Lock a range within the file's AllocationSize.
            //      2. Unlock a range when there are waiting locks on the file. This one
            //         is not guaranteed to interfere with oplocks, but it could, as
            //         unlocking this range might cause a waiting lock to be granted
            //         within AllocationSize!
            //
 
#endif
            Status = FsRtlCheckOplock( FatGetFcbOplock(Fcb),
                                       Irp,
                                       IrpContext,
                                       FatOplockComplete,
                                       NULL );
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
        }
#endif
 
        if (Status != STATUS_SUCCESS) {
 
            OplockPostIrp = TRUE;
            try_return( NOTHING );
        }
 
        //
        //  Now call the FsRtl routine to do the actual processing of the
        //  Lock request
        //
 
        Status = FsRtlProcessFileLock( &Fcb->Specific.Fcb.FileLock, Irp, NULL );
 
        //
        //  Set the flag indicating if Fast I/O is possible
        //
 
        Fcb->Header.IsFastIoPossible = FatIsFastIoPossible( Fcb );
 
    try_exit:  NOTHING;
    } _SEH2_FINALLY {
 
        DebugUnwind( FatCommonLockControl );
 
        //
        //  Only if this is not an abnormal termination do we delete the
        //  irp context
        //
 
        if (!_SEH2_AbnormalTermination() && !OplockPostIrp) {
 
            FatCompleteRequest( IrpContext, FatNull, 0 );
        }
 
        //
        //  Release the Fcb, and return to our caller
        //
 
        FatReleaseFcb( IrpContext, Fcb );
 
        DebugTrace(-1, Dbg, "FatCommonLockControl -> %08lx\n", Status);
    } _SEH2_END;
 
    return Status;
}