oplock.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for oplock.c:

Go to the source code of this file.

Classes
struct	_INTERNAL_OPLOCK
struct	_WAIT_CONTEXT

Macros
#define	NDEBUG
#define	NO_OPLOCK   0x1
#define	LEVEL_1_OPLOCK   0x2
#define	BATCH_OPLOCK   0x4
#define	FILTER_OPLOCK   0x8
#define	LEVEL_2_OPLOCK   0x10
#define	EXCLUSIVE_LOCK   0x40
#define	PENDING_LOCK   0x80
#define	BROKEN_TO_LEVEL_2   0x100
#define	BROKEN_TO_NONE   0x200
#define	BROKEN_TO_NONE_FROM_LEVEL_2   0x400
#define	BROKEN_TO_CLOSE_PENDING   0x800
#define	BROKEN_ANY   (BROKEN_TO_LEVEL_2 | BROKEN_TO_NONE | BROKEN_TO_NONE_FROM_LEVEL_2 | BROKEN_TO_CLOSE_PENDING)
#define	BreakToIIIfRequired
#define	BreakToNoneIfRequired

Typedefs
typedef struct _INTERNAL_OPLOCK	INTERNAL_OPLOCK
typedef struct _INTERNAL_OPLOCK *	PINTERNAL_OPLOCK
typedef struct _WAIT_CONTEXT	WAIT_CONTEXT
typedef struct _WAIT_CONTEXT *	PWAIT_CONTEXT

Functions
VOID NTAPI	FsRtlNotifyCompletion (IN PVOID Context, IN PIRP Irp)
VOID NTAPI	FsRtlCompletionRoutinePriv (IN PVOID Context, IN PIRP Irp)
VOID	FsRtlRemoveAndCompleteWaitIrp (IN PWAIT_CONTEXT WaitCtx)
VOID NTAPI	FsRtlCancelWaitIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	FsRtlWaitOnIrp (IN PINTERNAL_OPLOCK Oplock, IN PIRP Irp, IN PVOID CompletionContext, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine, IN PKEVENT WaitEvent)
NTSTATUS	FsRtlOplockBreakNotify (IN PINTERNAL_OPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp)
VOID	FsRtlRemoveAndCompleteIrp (IN PIRP Irp)
VOID NTAPI	FsRtlCancelOplockIIIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	FsRtlAcknowledgeOplockBreak (IN PINTERNAL_OPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp, IN BOOLEAN SwitchToLevel2)
NTSTATUS	FsRtlOpBatchBreakClosePending (IN PINTERNAL_OPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp)
PINTERNAL_OPLOCK	FsRtlAllocateOplock (VOID)
VOID NTAPI	FsRtlCancelExclusiveIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	FsRtlRequestExclusiveOplock (IN POPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp, IN ULONG Flags)
NTSTATUS	FsRtlRequestOplockII (IN POPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp)
VOID	FsRtlOplockCleanup (IN PINTERNAL_OPLOCK Oplock, IN PIO_STACK_LOCATION Stack)
NTSTATUS NTAPI	FsRtlOplockBreakToNone (IN PINTERNAL_OPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
NTSTATUS NTAPI	FsRtlOplockBreakToII (IN PINTERNAL_OPLOCK Oplock, IN PIO_STACK_LOCATION Stack, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
NTSTATUS NTAPI	FsRtlCheckOplock (IN POPLOCK Oplock, IN PIRP Irp, IN PVOID Context, IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine OPTIONAL, IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine OPTIONAL)
BOOLEAN NTAPI	FsRtlCurrentBatchOplock (IN POPLOCK Oplock)
VOID NTAPI	FsRtlInitializeOplock (IN OUT POPLOCK Oplock)
NTSTATUS NTAPI	FsRtlOplockFsctrl (IN POPLOCK Oplock, IN PIRP Irp, IN ULONG OpenCount)
BOOLEAN NTAPI	FsRtlOplockIsFastIoPossible (IN POPLOCK Oplock)
VOID NTAPI	FsRtlUninitializeOplock (IN POPLOCK Oplock)

Macro Definition Documentation

BATCH_OPLOCK

#define BATCH_OPLOCK   0x4

Definition at line 17 of file oplock.c.

BreakToIIIfRequired

#define BreakToIIIfRequired

Value:

    if (IntOplock->Flags != LEVEL_2_OPLOCK || IntOplock->FileObject != Stack->FileObject) \
        return FsRtlOplockBreakToII(IntOplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine)

BreakToNoneIfRequired

#define BreakToNoneIfRequired

Value:

    if (IntOplock->Flags == LEVEL_2_OPLOCK || IntOplock->FileObject != Stack->FileObject) \
        return FsRtlOplockBreakToNone(IntOplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine)

BROKEN_ANY

#define BROKEN_ANY   (BROKEN_TO_LEVEL_2 | BROKEN_TO_NONE | BROKEN_TO_NONE_FROM_LEVEL_2 | BROKEN_TO_CLOSE_PENDING)

Definition at line 28 of file oplock.c.

BROKEN_TO_CLOSE_PENDING

#define BROKEN_TO_CLOSE_PENDING   0x800

Definition at line 27 of file oplock.c.

BROKEN_TO_LEVEL_2

#define BROKEN_TO_LEVEL_2   0x100

Definition at line 24 of file oplock.c.

BROKEN_TO_NONE

#define BROKEN_TO_NONE   0x200

Definition at line 25 of file oplock.c.

BROKEN_TO_NONE_FROM_LEVEL_2

#define BROKEN_TO_NONE_FROM_LEVEL_2   0x400

Definition at line 26 of file oplock.c.

EXCLUSIVE_LOCK

#define EXCLUSIVE_LOCK   0x40

Definition at line 21 of file oplock.c.

FILTER_OPLOCK

#define FILTER_OPLOCK   0x8

Definition at line 18 of file oplock.c.

LEVEL_1_OPLOCK

#define LEVEL_1_OPLOCK   0x2

Definition at line 16 of file oplock.c.

LEVEL_2_OPLOCK

#define LEVEL_2_OPLOCK   0x10

Definition at line 19 of file oplock.c.

NDEBUG

#define NDEBUG

Definition at line 12 of file oplock.c.

NO_OPLOCK

#define NO_OPLOCK   0x1

Definition at line 15 of file oplock.c.

PENDING_LOCK

#define PENDING_LOCK   0x80

Definition at line 22 of file oplock.c.

Typedef Documentation

INTERNAL_OPLOCK

typedef struct _INTERNAL_OPLOCK INTERNAL_OPLOCK

PINTERNAL_OPLOCK

typedef struct _INTERNAL_OPLOCK * PINTERNAL_OPLOCK

PWAIT_CONTEXT

typedef struct _WAIT_CONTEXT * PWAIT_CONTEXT

WAIT_CONTEXT

typedef struct _WAIT_CONTEXT WAIT_CONTEXT

Function Documentation

FsRtlAcknowledgeOplockBreak()

NTSTATUS FsRtlAcknowledgeOplockBreak	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp,
		IN BOOLEAN	SwitchToLevel2
	)

Definition at line 356 of file oplock.c.

{
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
    BOOLEAN Deref;
    BOOLEAN Locked;
 
    DPRINT("FsRtlAcknowledgeOplockBreak(%p, %p, %p, %u)\n", Oplock, Stack, Irp, Unknown);
 
    /* No oplock, nothing to acknowledge */
    if (Oplock == NULL)
    {
        Irp->IoStatus.Status = STATUS_INVALID_OPLOCK_PROTOCOL;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        return STATUS_INVALID_OPLOCK_PROTOCOL;
    }
 
    /* Acquire oplock internal lock */
    ExAcquireFastMutexUnsafe(Oplock->IntLock);
    Locked = TRUE;
    /* Does it match the file? */
    if (Oplock->FileObject != Stack->FileObject)
    {
        Irp->IoStatus.Status = STATUS_INVALID_OPLOCK_PROTOCOL;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_INVALID_OPLOCK_PROTOCOL;
    }
 
    /* Assume we'll have to deref our extra ref (level I) */
    Deref = TRUE;
 
    /* If we got broken to level 2 and asked for a shared lock
     * switch the oplock to shared
     */
    if (SwitchToLevel2 && BooleanFlagOn(Oplock->Flags, BROKEN_TO_LEVEL_2))
    {
        /* The IRP cannot be synchronous, we'll move it to the LEVEL_2 IRPs */
        ASSERT(!IoIsOperationSynchronous(Irp));
 
        /* Mark the IRP pending, and queue it for the shared IRPs */
        IoMarkIrpPending(Irp);
        Irp->IoStatus.Status = STATUS_SUCCESS;
        InsertTailList(&Oplock->SharedListHead, &Irp->Tail.Overlay.ListEntry);
 
        /* Don't deref, we're not done yet */
        Deref = FALSE;
        /* And mark we've got a shared lock */
        Oplock->Flags = LEVEL_2_OPLOCK;
        /* To find the lock back on cancel */
        Irp->IoStatus.Information = (ULONG_PTR)Oplock;
 
        /* Acquire the spinlock to set the cancel routine */
        IoAcquireCancelSpinLock(&Irp->CancelIrql);
        /* If IRP got canceled, call it immediately */
        if (Irp->Cancel)
        {
            ExReleaseFastMutexUnsafe(Oplock->IntLock);
            Locked = FALSE;
            FsRtlCancelOplockIIIrp(NULL, Irp);
        }
        /* Otherwise, just set our cancel routine */
        else
        {
            IoSetCancelRoutine(Irp, FsRtlCancelOplockIIIrp);
            IoReleaseCancelSpinLock(Irp->CancelIrql);
        }
    }
    /* If oplock got broken, remove it */
    else if (BooleanFlagOn(Oplock->Flags, (BROKEN_TO_NONE | BROKEN_TO_LEVEL_2)))
    {
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IofCompleteRequest(Irp, IO_DISK_INCREMENT);
        Oplock->Flags = NO_OPLOCK;
    }
    /* Same, but precise we got broken from none to shared */
    else if (BooleanFlagOn(Oplock->Flags, BROKEN_TO_NONE_FROM_LEVEL_2))
    {
        Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IofCompleteRequest(Irp, IO_DISK_INCREMENT);
        Oplock->Flags = NO_OPLOCK;
    }
 
    /* Now, complete any IRP waiting */
    for (NextEntry = Oplock->WaitListHead.Flink;
         NextEntry != &Oplock->WaitListHead;
         NextEntry = NextEntry->Flink)
    {
        WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
        FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
    }
 
    /* If we dropped oplock, remove our extra ref */
    if (Deref)
    {
        ObDereferenceObject(Oplock->FileObject);
    }
    /* And unset FO: no oplock left or shared */
    Oplock->FileObject = NULL;
 
    /* Don't leak the mutex! */
    if (Locked)
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FsRtlOplockFsctrl().

FsRtlAllocateOplock()

PINTERNAL_OPLOCK FsRtlAllocateOplock

(

VOID

)

Definition at line 542 of file oplock.c.

{
    PINTERNAL_OPLOCK Oplock = NULL;
 
    PAGED_CODE();
 
    DPRINT("FsRtlAllocateOplock()\n");
 
    _SEH2_TRY
    {
        /* Allocate and initialize the oplock */
        Oplock = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE | POOL_COLD_ALLOCATION, sizeof(INTERNAL_OPLOCK), TAG_OPLOCK);
        RtlZeroMemory(Oplock, sizeof(INTERNAL_OPLOCK));
        /* We allocate the fast mutex separately to have it non paged (while the rest of the oplock can be paged) */
        Oplock->IntLock = ExAllocatePoolWithTag(NonPagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE, sizeof(FAST_MUTEX), TAG_OPLOCK);
        ExInitializeFastMutex(Oplock->IntLock);
        /* Initialize the IRP list for level 2 oplock */
        InitializeListHead(&Oplock->SharedListHead);
        /* And for the wait IRPs */
        InitializeListHead(&Oplock->WaitListHead);
        Oplock->Flags = NO_OPLOCK;
    }
    _SEH2_FINALLY
    {
        /* In case of abnormal termination, it means either OPLOCK or FAST_MUTEX allocation failed */
        if (_SEH2_AbnormalTermination())
        {
            /* That FAST_MUTEX, free OPLOCK */
            if (Oplock != NULL)
            {
                ExFreePoolWithTag(Oplock, TAG_OPLOCK);
                Oplock = NULL;
            }
        }
    }
    _SEH2_END;
 
    return Oplock;
}

Referenced by FsRtlRequestExclusiveOplock(), and FsRtlRequestOplockII().

FsRtlCancelExclusiveIrp()

VOID NTAPI FsRtlCancelExclusiveIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 584 of file oplock.c.

{
    PINTERNAL_OPLOCK IntOplock;
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
 
    DPRINT("FsRtlCancelExclusiveIrp(%p, %p)\n", DeviceObject, Irp);
 
    /* Get the associated oplock */
    IntOplock = (PINTERNAL_OPLOCK)Irp->IoStatus.Information;
 
    /* Remove the cancel routine (us!) and release the cancel spinlock */
    IoSetCancelRoutine(Irp, NULL);
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* Acquire our internal FAST_MUTEX */
    ExAcquireFastMutex(IntOplock->IntLock);
    /* If we had an exclusive IRP */
    if (IntOplock->ExclusiveIrp != NULL && IntOplock->ExclusiveIrp->Cancel)
    {
        /* Cancel it, and remove it from the oplock */
        IntOplock->ExclusiveIrp->IoStatus.Status = STATUS_CANCELLED;
        IoCompleteRequest(IntOplock->ExclusiveIrp, IO_DISK_INCREMENT);
        IntOplock->ExclusiveIrp = NULL;
 
        /* Dereference the fileobject and remove the oplock */
        ObDereferenceObject(IntOplock->FileObject);
        IntOplock->FileObject = NULL;
        IntOplock->Flags = NO_OPLOCK;
 
        /* And complete any waiting IRP */
        for (NextEntry = IntOplock->WaitListHead.Flink;
             NextEntry != &IntOplock->WaitListHead;
             NextEntry = NextEntry->Flink)
        {
            WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
            FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
        }
    }
 
    /* Done! */
    ExReleaseFastMutexUnsafe(IntOplock->IntLock);
}

Referenced by FsRtlRequestExclusiveOplock().

FsRtlCancelOplockIIIrp()

VOID NTAPI FsRtlCancelOplockIIIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 311 of file oplock.c.

{
    PINTERNAL_OPLOCK Oplock;
    PLIST_ENTRY NextEntry;
    PIRP ListIrp;
    BOOLEAN Removed;
 
    DPRINT("FsRtlCancelOplockIIIrp(%p, %p)\n", DeviceObject, Irp);
 
    /* Get the associated oplock */
    Oplock = (PINTERNAL_OPLOCK)Irp->IoStatus.Information;
 
    /* Remove the cancel routine (it's OK, we're the cancel routine! )*/
    IoSetCancelRoutine(Irp, NULL);
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* Nothing removed yet */
    Removed = FALSE;
    ExAcquireFastMutex(Oplock->IntLock);
    /* Browse all the IRPs associated to the shared lock */
    for (NextEntry = Oplock->SharedListHead.Flink;
         NextEntry != &Oplock->SharedListHead;
         NextEntry = NextEntry->Flink)
    {
        ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
        /* If canceled, remove it */
        if (ListIrp->Cancel)
        {
            FsRtlRemoveAndCompleteIrp(ListIrp);
            Removed = TRUE;
        }
    }
 
    /* If no IRP left, the oplock is gone */
    if (Removed && IsListEmpty(&Oplock->SharedListHead))
    {
        Oplock->Flags = NO_OPLOCK;
    }
    /* Don't forget to release the mutex */
    ExReleaseFastMutex(Oplock->IntLock);
}

Referenced by FsRtlAcknowledgeOplockBreak(), and FsRtlRequestOplockII().

FsRtlCancelWaitIrp()

VOID NTAPI FsRtlCancelWaitIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 114 of file oplock.c.

{
    PINTERNAL_OPLOCK Oplock;
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
 
    DPRINT("FsRtlCancelWaitIrp(%p, %p)\n", DeviceObject, Irp);
 
    /* Get the associated oplock */
    Oplock = (PINTERNAL_OPLOCK)Irp->IoStatus.Information;
 
    /* Remove the cancel routine (we're being called!) */
    IoSetCancelRoutine(Irp, NULL);
    /* And release the cancel spin lock (always locked when cancel routine is called) */
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* Now, remove and complete any associated waiter */
    ExAcquireFastMutex(Oplock->IntLock);
    for (NextEntry = Oplock->WaitListHead.Flink;
         NextEntry != &Oplock->WaitListHead;
         NextEntry = NextEntry->Flink)
    {
        WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
 
        if (WaitCtx->Irp->Cancel)
        {
            FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
        }
    }
    ExReleaseFastMutex(Oplock->IntLock);
}

Referenced by FsRtlWaitOnIrp().

FsRtlCheckOplock()

NTSTATUS NTAPI FsRtlCheckOplock	(	IN POPLOCK	Oplock,
		IN PIRP	Irp,
		IN PVOID	Context,
		IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine	OPTIONAL,
		IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine	OPTIONAL
	)

Definition at line 1170 of file oplock.c.

{
    PINTERNAL_OPLOCK IntOplock;
    PIO_STACK_LOCATION Stack;
    ACCESS_MASK DesiredAccess;
    FILE_INFORMATION_CLASS FileInfo;
    ULONG CreateDisposition;
 
#define BreakToIIIfRequired                                                               \
    if (IntOplock->Flags != LEVEL_2_OPLOCK || IntOplock->FileObject != Stack->FileObject) \
        return FsRtlOplockBreakToII(IntOplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine)
 
#define BreakToNoneIfRequired                                                             \
    if (IntOplock->Flags == LEVEL_2_OPLOCK || IntOplock->FileObject != Stack->FileObject) \
        return FsRtlOplockBreakToNone(IntOplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine)
 
    DPRINT("FsRtlCheckOplock(%p, %p, %p, %p, %p)\n", Oplock, Irp, Context, CompletionRoutine, PostIrpRoutine);
 
    IntOplock = *Oplock;
 
    /* No oplock, easy! */
    if (IntOplock == NULL)
    {
        return STATUS_SUCCESS;
    }
 
    /* No sense on paging */
    if (Irp->Flags & IRP_PAGING_IO)
    {
        return STATUS_SUCCESS;
    }
 
    /* No oplock, easy (bis!) */
    if (IntOplock->Flags == NO_OPLOCK)
    {
        return STATUS_SUCCESS;
    }
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    /* If cleanup, cleanup the associated oplock & return */
    if (Stack->MajorFunction == IRP_MJ_CLEANUP)
    {
        FsRtlOplockCleanup(IntOplock, Stack);
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_LOCK_CONTROL)
    {
        /* OK for filter */
        if (BooleanFlagOn(IntOplock->Flags, FILTER_OPLOCK))
        {
            return STATUS_SUCCESS;
        }
 
        /* Lock operation, we will have to break to no lock if shared or not us */
        BreakToNoneIfRequired;
 
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL)
    {
        /* FSCTL should be safe, unless user wants a write FSCTL */
        if (Stack->Parameters.FileSystemControl.FsControlCode != FSCTL_SET_ZERO_DATA)
        {
            return STATUS_SUCCESS;
        }
 
        /* We will have to break for write if shared or not us! */
        BreakToNoneIfRequired;
 
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_WRITE)
    {
        /* Write operation, we will have to break if shared or not us */
        BreakToNoneIfRequired;
 
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_READ)
    {
        /* If that's filter oplock, it's alright */
        if (BooleanFlagOn(IntOplock->Flags, FILTER_OPLOCK))
        {
            return STATUS_SUCCESS;
        }
 
        /* Otherwise, we need to break to shared oplock */
        BreakToIIIfRequired;
 
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_CREATE)
    {
        DesiredAccess = Stack->Parameters.Create.SecurityContext->DesiredAccess;
 
        /* If that's just for reading, the oplock is fine */
        if ((!(DesiredAccess & ~(SYNCHRONIZE | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_READ_DATA)) && !(Stack->Parameters.Create.Options & FILE_RESERVE_OPFILTER))
            || (BooleanFlagOn(IntOplock->Flags, FILTER_OPLOCK) && !(DesiredAccess & ~(SYNCHRONIZE | READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | FILE_EXECUTE | FILE_READ_EA | FILE_WRITE_DATA)) && BooleanFlagOn(Stack->Parameters.Create.ShareAccess, FILE_SHARE_READ)))
        {
            return STATUS_SUCCESS;
        }
 
        /* Otherwise, check the disposition */
        CreateDisposition = (Stack->Parameters.Create.Options >> 24) & 0x000000FF;
        if (!CreateDisposition || CreateDisposition == FILE_OVERWRITE ||
            CreateDisposition == FILE_OVERWRITE_IF ||
            BooleanFlagOn(Stack->Parameters.Create.Options, FILE_RESERVE_OPFILTER))
        {
            /* Not us, we have to break the oplock! */
            BreakToNoneIfRequired;
 
            return STATUS_SUCCESS;
        }
 
        /* It's fine, we can have the oplock shared */
        BreakToIIIfRequired;
 
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_FLUSH_BUFFERS)
    {
        /* We need to share the lock, if not done yet! */
        BreakToIIIfRequired;
 
        return STATUS_SUCCESS;
    }
    else if (Stack->MajorFunction == IRP_MJ_SET_INFORMATION)
    {
        /* Only deal with really specific classes */
        FileInfo = Stack->Parameters.SetFile.FileInformationClass;
        if (FileInfo == FileRenameInformation || FileInfo == FileLinkInformation ||
            FileInfo == FileShortNameInformation)
        {
            /* No need to break */
            if (!BooleanFlagOn(IntOplock->Flags, (FILTER_OPLOCK | BATCH_OPLOCK)))
            {
                return STATUS_SUCCESS;
            }
            /* Otherwise break to none */
            else
            {
                BreakToNoneIfRequired;
 
                return STATUS_SUCCESS;
            }
        }
        else if (FileInfo == FileAllocationInformation)
        {
            BreakToNoneIfRequired;
 
            return STATUS_SUCCESS;
        }
        else if (FileInfo == FileEndOfFileInformation)
        {
            /* Advance only, nothing to do */
            if (Stack->Parameters.SetFile.AdvanceOnly)
            {
                return STATUS_SUCCESS;
            }
 
            /* Otherwise, attempt to break to none */
            BreakToNoneIfRequired;
 
            return STATUS_SUCCESS;
        }
    }
 
#undef BreakToIIIfRequired
#undef BreakToNoneIfRequired
 
    return STATUS_SUCCESS;
}

Referenced by _Dispatch_type_(), _Requires_lock_held_(), CdCommonLockControl(), Ext2Cleanup(), Ext2CreateFile(), Ext2LockControl(), Ext2ReadFile(), Ext2SetFileInformation(), Ext2WriteFile(), FatSetRenameInfo(), fsctl_request(), and open_file2().

FsRtlCompletionRoutinePriv()

VOID NTAPI FsRtlCompletionRoutinePriv	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 69 of file oplock.c.

{
    PKEVENT WaitEvent;
 
    PAGED_CODE();
 
    DPRINT("FsRtlCompletionRoutinePriv(%p, %p)\n", Context, Irp);
 
    /* Set the event */
    WaitEvent = (PKEVENT)Context;
    KeSetEvent(WaitEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by FsRtlWaitOnIrp().

FsRtlCurrentBatchOplock()

BOOLEAN NTAPI FsRtlCurrentBatchOplock

(

IN POPLOCK

Oplock

)

Definition at line 1364 of file oplock.c.

{
    PINTERNAL_OPLOCK IntOplock;
 
    PAGED_CODE();
 
    DPRINT("FsRtlCurrentBatchOplock(%p)\n", Oplock);
 
    IntOplock = *Oplock;
 
    /* Only return true if batch or filter oplock */
    if (IntOplock != NULL &&
        BooleanFlagOn(IntOplock->Flags, (FILTER_OPLOCK | BATCH_OPLOCK)))
    {
        return TRUE;
    }
 
    return FALSE;
}

Referenced by Ext2CreateFile(), and FatSetRenameInfo().

FsRtlInitializeOplock()

VOID NTAPI FsRtlInitializeOplock

(

IN OUT POPLOCK

Oplock

)

Definition at line 1400 of file oplock.c.

{
    PAGED_CODE();
 
    /* Nothing to do */
    DPRINT("FsRtlInitializeOplock(%p)\n", Oplock);
}

Referenced by CdCreateFcb(), create_fcb(), Ext2AllocateFcb(), FatCreateDcb(), and FatCreateFcb().

FsRtlNotifyCompletion()

VOID NTAPI FsRtlNotifyCompletion	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 56 of file oplock.c.

{
    PAGED_CODE();
 
    DPRINT("FsRtlNotifyCompletion(%p, %p)\n", Context, Irp);
 
    /* Just complete the IRP */
    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
}

Referenced by FsRtlOplockBreakNotify().

FsRtlOpBatchBreakClosePending()

NTSTATUS FsRtlOpBatchBreakClosePending	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp
	)

Definition at line 470 of file oplock.c.

{
    NTSTATUS Status;
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
 
    PAGED_CODE();
 
    DPRINT("FsRtlOpBatchBreakClosePending(%p, %p, %p)\n", Oplock, Stack, Irp);
 
    /* No oplock, that's not legit! */
    if (Oplock == NULL)
    {
        Irp->IoStatus.Status = STATUS_INVALID_OPLOCK_PROTOCOL;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        return STATUS_INVALID_OPLOCK_PROTOCOL;
    }
 
    Status = STATUS_SUCCESS;
    ExAcquireFastMutexUnsafe(Oplock->IntLock);
 
    /* First of all, check if all conditions are met:
     * Correct FO + broken oplock
     */
    if (Oplock->FileObject == Stack->FileObject && (BooleanFlagOn(Oplock->Flags, (BROKEN_TO_LEVEL_2 | BROKEN_TO_NONE | BROKEN_TO_NONE_FROM_LEVEL_2))))
    {
        /* If we have a pending or level 1 oplock... */
        if (BooleanFlagOn(Oplock->Flags, (PENDING_LOCK | LEVEL_1_OPLOCK)))
        {
            /* Remove our extra ref from the FO */
            if (Oplock->Flags & LEVEL_1_OPLOCK)
            {
                ObDereferenceObject(Oplock->FileObject);
            }
 
            /* And remove the oplock */
            Oplock->Flags = NO_OPLOCK;
            Oplock->FileObject = NULL;
 
            /* Complete any waiting IRP */
            for (NextEntry = Oplock->WaitListHead.Flink;
                 NextEntry != &Oplock->WaitListHead;
                 NextEntry = NextEntry->Flink)
            {
                WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
                FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
            }
        }
        /* Otherwise, mark the oplock as close pending */
        else
        {
            ClearFlag(Oplock->Flags, BROKEN_ANY);
            SetFlag(Oplock->Flags, BROKEN_TO_CLOSE_PENDING);
        }
    }
    /* Oplock is in invalid state */
    else
    {
        Status = STATUS_INVALID_OPLOCK_PROTOCOL;
    }
 
    /* And complete */
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
    ExReleaseFastMutexUnsafe(Oplock->IntLock);
 
    return Status;
}

Referenced by FsRtlOplockFsctrl().

FsRtlOplockBreakNotify()

NTSTATUS FsRtlOplockBreakNotify	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp
	)

Definition at line 239 of file oplock.c.

{
    PAGED_CODE();
 
    DPRINT("FsRtlOplockBreakNotify(%p, %p, %p)\n", Oplock, Stack, Irp);
 
    /* No oplock, no break to notify */
    if (Oplock == NULL)
    {
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        return STATUS_SUCCESS;
    }
 
    /* Notify by completing the IRP, unless we have broken to shared */
    ExAcquireFastMutexUnsafe(Oplock->IntLock);
    if (!BooleanFlagOn(Oplock->Flags, BROKEN_TO_LEVEL_2))
    {
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
 
    /* If it's pending, just complete the IRP and get rid of the oplock */
    if (BooleanFlagOn(Oplock->Flags, PENDING_LOCK))
    {
        Oplock->FileObject = NULL;
        Oplock->Flags = NO_OPLOCK;
        Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
 
    /* Otherwise, wait on the IRP */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    FsRtlWaitOnIrp(Oplock, Irp, NULL, FsRtlNotifyCompletion, NULL, NULL);
    return STATUS_SUCCESS;
}

Referenced by FsRtlOplockFsctrl().

FsRtlOplockBreakToII()

NTSTATUS NTAPI FsRtlOplockBreakToII	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp,
		IN PVOID	Context,
		IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine	OPTIONAL,
		IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine	OPTIONAL
	)

Definition at line 1035 of file oplock.c.

{
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
    KEVENT WaitEvent;
 
    DPRINT("FsRtlOplockBreakToII(%p, %p, %p, %p, %p, %p)\n", Oplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine);
 
    ExAcquireFastMutexUnsafe(Oplock->IntLock);
 
    /* If our lock, or if not exclusively locked, nothing to break! */
    if (!BooleanFlagOn(Oplock->Flags, EXCLUSIVE_LOCK) || Oplock->FileObject == Stack->FileObject)
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
 
    /* If already broken or not set yet */
    if (BooleanFlagOn(Oplock->Flags, (BROKEN_ANY | PENDING_LOCK)))
    {
        /* Drop oplock if pending */
        if (BooleanFlagOn(Oplock->Flags, PENDING_LOCK))
        {
            Oplock->Flags = NO_OPLOCK;
            Oplock->FileObject = NULL;
 
            ExReleaseFastMutexUnsafe(Oplock->IntLock);
            return STATUS_SUCCESS;
        }
 
    }
    /* To break! */
    else
    {
        /* Drop the cancel routine of the exclusive IRP */
        IoAcquireCancelSpinLock(&Oplock->ExclusiveIrp->CancelIrql);
        IoSetCancelRoutine(Oplock->ExclusiveIrp, NULL);
        IoReleaseCancelSpinLock(Oplock->ExclusiveIrp->CancelIrql);
 
        /* If it was canceled in between, break to no oplock */
        if (Oplock->ExclusiveIrp->Cancel)
        {
            /* Complete the IRP with cancellation */
            Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
            Oplock->ExclusiveIrp->IoStatus.Status = STATUS_CANCELLED;
            IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT);
 
            /* And mark we have no longer lock */
            Oplock->Flags = NO_OPLOCK;
            Oplock->ExclusiveIrp = NULL;
            ObDereferenceObject(Oplock->FileObject);
            Oplock->FileObject = NULL;
 
            /* Finally, complete any waiter */
            for (NextEntry = Oplock->WaitListHead.Flink;
                 NextEntry != &Oplock->WaitListHead;
                 NextEntry = NextEntry->Flink)
            {
                WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
                FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
            }
 
            ExReleaseFastMutexUnsafe(Oplock->IntLock);
 
            return STATUS_SUCCESS;
        }
 
        /* It wasn't canceled, so break to shared unless we were alone, in that case we break to no lock! */
        Oplock->ExclusiveIrp->IoStatus.Status = STATUS_SUCCESS;
        if (BooleanFlagOn(Oplock->Flags, (BATCH_OPLOCK | LEVEL_1_OPLOCK)))
        {
            SetFlag(Oplock->Flags, BROKEN_TO_LEVEL_2);
            Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_LEVEL_2;
        }
        else
        {
            SetFlag(Oplock->Flags, BROKEN_TO_NONE);
            Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
        }
        /* And complete */
        IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT);
        Oplock->ExclusiveIrp = NULL;
    }
 
    /* Wait if required */
    if (Stack->MajorFunction != IRP_MJ_CREATE || !BooleanFlagOn(Stack->Parameters.Create.Options, FILE_COMPLETE_IF_OPLOCKED))
    {
        FsRtlWaitOnIrp(Oplock, Irp, Context, CompletionRoutine, PostIrpRoutine, &WaitEvent);
 
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
 
        return STATUS_SUCCESS;
    }
    else
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_OPLOCK_BREAK_IN_PROGRESS;
    }
}

FsRtlOplockBreakToNone()

NTSTATUS NTAPI FsRtlOplockBreakToNone	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp,
		IN PVOID	Context,
		IN POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine	OPTIONAL,
		IN POPLOCK_FS_PREPOST_IRP PostIrpRoutine	OPTIONAL
	)

Definition at line 901 of file oplock.c.

{
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
    PIRP ListIrp;
    KEVENT WaitEvent;
 
    DPRINT("FsRtlOplockBreakToNone(%p, %p, %p, %p, %p, %p)\n", Oplock, Stack, Irp, Context, CompletionRoutine, PostIrpRoutine);
 
    ExAcquireFastMutexUnsafe(Oplock->IntLock);
 
    /* No oplock to break! */
    if (Oplock->Flags == NO_OPLOCK)
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
 
    /* Not broken yet, but set... Let's do it!
     * Also, we won't break a shared oplock
     */
    if (!BooleanFlagOn(Oplock->Flags, (BROKEN_ANY | PENDING_LOCK | LEVEL_2_OPLOCK)))
    {
        /* Remove our cancel routine, no longer needed */
        IoAcquireCancelSpinLock(&Oplock->ExclusiveIrp->CancelIrql);
        IoSetCancelRoutine(Oplock->ExclusiveIrp, NULL);
        IoReleaseCancelSpinLock(Oplock->ExclusiveIrp->CancelIrql);
 
        /* If the IRP got canceled, we need to cleanup a bit */
        if (Oplock->ExclusiveIrp->Cancel)
        {
            /* Return cancelation */
            Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
            Oplock->ExclusiveIrp->IoStatus.Status = STATUS_CANCELLED;
            IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT);
 
            /* No oplock left */
            Oplock->Flags = NO_OPLOCK;
            Oplock->ExclusiveIrp = NULL;
 
            /* No need for the FO anymore */
            ObDereferenceObject(Oplock->FileObject);
            Oplock->FileObject = NULL;
 
            /* And complete any waiting IRP */
            for (NextEntry = Oplock->WaitListHead.Flink;
                 NextEntry != &Oplock->WaitListHead;
                 NextEntry = NextEntry->Flink)
            {
                WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
                FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
            }
 
            /* Done! */
            ExReleaseFastMutexUnsafe(Oplock->IntLock);
 
            return STATUS_SUCCESS;
        }
 
        /* Easier break, just complete :-) */
        Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
        Oplock->ExclusiveIrp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT);
 
        /* And remove our exclusive IRP */
        Oplock->ExclusiveIrp = NULL;
        SetFlag(Oplock->Flags, BROKEN_TO_NONE);
    }
    /* Shared lock */
    else if (Oplock->Flags == LEVEL_2_OPLOCK)
    {
        /* Complete any IRP in the shared lock */
        for (NextEntry = Oplock->SharedListHead.Flink;
             NextEntry != &Oplock->SharedListHead;
             NextEntry = NextEntry->Flink)
        {
            ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
            FsRtlRemoveAndCompleteIrp(ListIrp);
        }
 
        /* No lock left */
        Oplock->Flags = NO_OPLOCK;
 
        /* Done */
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
    /* If it was broken to level 2, break it to none from level 2 */
    else if (Oplock->Flags & BROKEN_TO_LEVEL_2)
    {
        ClearFlag(Oplock->Flags, BROKEN_TO_LEVEL_2);
        SetFlag(Oplock->Flags, BROKEN_TO_NONE_FROM_LEVEL_2);
    }
    /* If it was pending, just drop the lock */
    else if (BooleanFlagOn(Oplock->Flags, PENDING_LOCK))
    {
        Oplock->Flags = NO_OPLOCK;
        Oplock->FileObject = NULL;
 
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
 
    /* If that's ours, job done */
    if (Oplock->FileObject == Stack->FileObject)
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_SUCCESS;
    }
 
    /* Otherwise, wait on the IRP */
    if (Stack->MajorFunction != IRP_MJ_CREATE || !BooleanFlagOn(Stack->Parameters.Create.Options, FILE_COMPLETE_IF_OPLOCKED))
    {
        FsRtlWaitOnIrp(Oplock, Irp, Context, CompletionRoutine, PostIrpRoutine, &WaitEvent);
 
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
 
        return STATUS_SUCCESS;
    }
    /* Done */
    else
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        return STATUS_OPLOCK_BREAK_IN_PROGRESS;
    }
}

FsRtlOplockCleanup()

VOID FsRtlOplockCleanup	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack
	)

Definition at line 816 of file oplock.c.

{
    PIO_STACK_LOCATION ListStack;
    PLIST_ENTRY NextEntry;
    PIRP ListIrp;
    PWAIT_CONTEXT WaitCtx;
 
    DPRINT("FsRtlOplockCleanup(%p, %p)\n", Oplock, Stack);
 
    ExAcquireFastMutexUnsafe(Oplock->IntLock);
    /* oplock cleaning only makes sense if there's an oplock */
    if (Oplock->Flags != NO_OPLOCK)
    {
        /* Shared lock */
        if (Oplock->Flags == LEVEL_2_OPLOCK)
        {
            /* Complete any associated IRP */
            for (NextEntry = Oplock->SharedListHead.Flink;
                 NextEntry != &Oplock->SharedListHead;
                 NextEntry = NextEntry->Flink)
            {
                ListIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
                ListStack = IoGetCurrentIrpStackLocation(ListIrp);
 
                if (Stack->FileObject == ListStack->FileObject)
                {
                    FsRtlRemoveAndCompleteIrp(ListIrp);
                }
            }
 
            /* If, in the end, no IRP is left, then the lock is gone */
            if (IsListEmpty(&Oplock->SharedListHead))
            {
                Oplock->Flags = NO_OPLOCK;
            }
        }
        else
        {
            /* If we have matching file */
            if (Oplock->FileObject == Stack->FileObject)
            {
                /* Oplock wasn't broken (still exclusive), easy case */
                if (!BooleanFlagOn(Oplock->Flags, (BROKEN_ANY | PENDING_LOCK)))
                {
                    /* Remove the cancel routine we set previously */
                    IoAcquireCancelSpinLock(&Oplock->ExclusiveIrp->CancelIrql);
                    IoSetCancelRoutine(Oplock->ExclusiveIrp, NULL);
                    IoReleaseCancelSpinLock(Oplock->ExclusiveIrp->CancelIrql);
 
                    /* And return the fact we broke the oplock to no oplock */
                    Oplock->ExclusiveIrp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
                    Oplock->ExclusiveIrp->IoStatus.Status = STATUS_SUCCESS;
 
                    /* And complete! */
                    IoCompleteRequest(Oplock->ExclusiveIrp, IO_DISK_INCREMENT);
                    Oplock->ExclusiveIrp = NULL;
                }
 
                /* If  no pending, we can safely dereference the file object */
                if (!BooleanFlagOn(Oplock->Flags, PENDING_LOCK))
                {
                    ObDereferenceObject(Oplock->FileObject);
                }
 
                /* Now, remove the oplock */
                Oplock->FileObject = NULL;
                Oplock->Flags = NO_OPLOCK;
 
                /* And complete any waiting IRP */
                for (NextEntry = Oplock->WaitListHead.Flink;
                     NextEntry != &Oplock->WaitListHead;
                     NextEntry = NextEntry->Flink)
                {
                    WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
                    FsRtlRemoveAndCompleteWaitIrp(WaitCtx);
                }
            }
        }
    }
    ExReleaseFastMutexUnsafe(Oplock->IntLock);
}

Referenced by FsRtlCheckOplock().

FsRtlOplockFsctrl()

NTSTATUS NTAPI FsRtlOplockFsctrl	(	IN POPLOCK	Oplock,
		IN PIRP	Irp,
		IN ULONG	OpenCount
	)

Definition at line 1430 of file oplock.c.

{
    PIO_STACK_LOCATION Stack;
    PINTERNAL_OPLOCK IntOplock;
 
    PAGED_CODE();
 
    DPRINT("FsRtlOplockFsctrl(%p, %p, %lu)\n", Oplock, Irp, OpenCount);
 
    IntOplock = *Oplock;
    Stack = IoGetCurrentIrpStackLocation(Irp);
    /* Make sure it's not called on create */
    if (Stack->MajorFunction != IRP_MJ_CREATE)
    {
        switch (Stack->Parameters.FileSystemControl.FsControlCode)
        {
            case FSCTL_OPLOCK_BREAK_NOTIFY:
                return FsRtlOplockBreakNotify(IntOplock, Stack, Irp);
 
            case FSCTL_OPLOCK_BREAK_ACK_NO_2:
                return FsRtlAcknowledgeOplockBreak(IntOplock, Stack, Irp, FALSE);
 
            case FSCTL_OPBATCH_ACK_CLOSE_PENDING:
                return FsRtlOpBatchBreakClosePending(IntOplock, Stack, Irp);
 
            case FSCTL_REQUEST_OPLOCK_LEVEL_1:
                /* We can only grant level 1 if synchronous, and only a single handle to it
                 * (plus, not a paging IO - obvious, and not cleanup done...)
                 */
                if (OpenCount == 1 && !IoIsOperationSynchronous(Irp) &&
                    !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE))
                {
                    return FsRtlRequestExclusiveOplock(Oplock, Stack, Irp, EXCLUSIVE_LOCK | LEVEL_1_OPLOCK);
                }
                /* Not matching, fail */
                else
                {
                    Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED;
                    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
                    return STATUS_OPLOCK_NOT_GRANTED;
                }
 
            case FSCTL_REQUEST_OPLOCK_LEVEL_2:
                /* Shared can only be granted if no byte-range lock, and async operation
                 * (plus, not a paging IO - obvious, and not cleanup done...)
                 */
                if (OpenCount == 0 && !IoIsOperationSynchronous(Irp) &&
                    !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE))
                {
                    return FsRtlRequestOplockII(Oplock, Stack, Irp);
                }
                /* Not matching, fail */
                else
                {
                    Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED;
                    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
                    return STATUS_OPLOCK_NOT_GRANTED;
                }
 
            case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
                return FsRtlAcknowledgeOplockBreak(IntOplock, Stack, Irp, TRUE);
 
            case FSCTL_REQUEST_BATCH_OPLOCK:
                /* Batch oplock can only be granted if there's a byte-range lock and async operation
                 * (plus, not a paging IO - obvious, and not cleanup done...)
                 */
                if (OpenCount == 1 && !IoIsOperationSynchronous(Irp) &&
                    !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE))
                {
                    return FsRtlRequestExclusiveOplock(Oplock, Stack, Irp, EXCLUSIVE_LOCK | BATCH_OPLOCK);
                }
                /* Not matching, fail */
                else
                {
                    Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED;
                    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
                    return STATUS_OPLOCK_NOT_GRANTED;
                }
 
            case FSCTL_REQUEST_FILTER_OPLOCK:
                /* Filter oplock can only be granted if there's a byte-range lock and async operation
                 * (plus, not a paging IO - obvious, and not cleanup done...)
                 */
                if (OpenCount == 1 && !IoIsOperationSynchronous(Irp) &&
                    !BooleanFlagOn(Irp->Flags, IRP_SYNCHRONOUS_PAGING_IO) && !BooleanFlagOn(Stack->FileObject->Flags, FO_CLEANUP_COMPLETE))
                {
                    return FsRtlRequestExclusiveOplock(Oplock, Stack, Irp, EXCLUSIVE_LOCK | FILTER_OPLOCK);
                }
                /* Not matching, fail */
                else
                {
                    Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED;
                    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
                    return STATUS_OPLOCK_NOT_GRANTED;
                }
 
            default:
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                IoCompleteRequest(Irp, IO_DISK_INCREMENT);
                return STATUS_INVALID_PARAMETER;
        }
    }
 
    /* That's a create operation! Only grant exclusive if there's a single user handle opened
     * and we're only performing reading operations.
     */
    if (OpenCount == 1 &&
        !(Stack->Parameters.Create.SecurityContext->DesiredAccess & ~(FILE_READ_ATTRIBUTES | FILE_READ_DATA)) &&
        (Stack->Parameters.Create.ShareAccess & FILE_SHARE_VALID_FLAGS) == FILE_SHARE_VALID_FLAGS)
    {
        return FsRtlRequestExclusiveOplock(Oplock, Stack, NULL, EXCLUSIVE_LOCK | PENDING_LOCK | FILTER_OPLOCK);
    }
 
    return STATUS_OPLOCK_NOT_GRANTED;
}

Referenced by Ext2OplockRequest(), fsctl_oplock(), and if().

FsRtlOplockIsFastIoPossible()

BOOLEAN NTAPI FsRtlOplockIsFastIoPossible

(

IN POPLOCK

Oplock

)

Definition at line 1564 of file oplock.c.

{
    PINTERNAL_OPLOCK IntOplock;
 
    PAGED_CODE();
 
    DPRINT("FsRtlOplockIsFastIoPossible(%p)\n", Oplock);
 
    IntOplock = *Oplock;
 
    /* If there's a shared oplock or if it was used for write operation, deny FastIO */
    if (IntOplock != NULL &&
        BooleanFlagOn(IntOplock->Flags, (BROKEN_ANY | LEVEL_2_OPLOCK)))
    {
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _Function_class_(), CdFastLock(), CdFastUnlockAll(), CdFastUnlockAllByKey(), CdFastUnlockSingle(), Ext2FastIoLock(), Ext2FastIoUnlockAll(), Ext2FastIoUnlockAllByKey(), Ext2FastIoUnlockSingle(), Ext2IsFastIoPossible(), and fast_io_possible().

FsRtlRemoveAndCompleteIrp()

VOID FsRtlRemoveAndCompleteIrp

(

IN PIRP

Irp

)

Definition at line 283 of file oplock.c.

{
    PIO_STACK_LOCATION Stack;
 
    DPRINT("FsRtlRemoveAndCompleteIrp(%p)\n", Irp);
 
    Stack = IoGetCurrentIrpStackLocation(Irp);
 
    /* Remove our extra ref */
    ObDereferenceObject(Stack->FileObject);
 
    /* Remove our cancel routine */
    IoAcquireCancelSpinLock(&Irp->CancelIrql);
    IoSetCancelRoutine(Irp, NULL);
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* Remove the IRP from the list it may be in (wait or shared) */
    RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
 
    /* And complete! */
    Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
    Irp->IoStatus.Status = (Irp->Cancel ? STATUS_CANCELLED : STATUS_SUCCESS);
 
    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
}

Referenced by FsRtlCancelOplockIIIrp(), FsRtlOplockBreakToNone(), FsRtlOplockCleanup(), and FsRtlRequestExclusiveOplock().

FsRtlRemoveAndCompleteWaitIrp()

VOID FsRtlRemoveAndCompleteWaitIrp

(

IN PWAIT_CONTEXT

WaitCtx

)

Definition at line 84 of file oplock.c.

{
    PIRP Irp;
 
    PAGED_CODE();
 
    DPRINT("FsRtlRemoveAndCompleteWaitIrp(%p)\n", WaitCtx);
 
    RemoveEntryList(&WaitCtx->WaitListEntry);
    Irp = WaitCtx->Irp;
 
    /* No cancel routine anymore */
    IoAcquireCancelSpinLock(&Irp->CancelIrql);
    IoSetCancelRoutine(Irp, NULL);
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    /* Set the information */
    Irp->IoStatus.Information = WaitCtx->SavedInformation;
    /* Set the status according to the fact it got cancel or not */
    Irp->IoStatus.Status = (Irp->Cancel ? STATUS_CANCELLED : STATUS_SUCCESS);
 
    /* Call the completion routine */
    WaitCtx->CompletionRoutine(WaitCtx->CompletionContext, Irp);
 
    /* And get rid of the now useless wait context */
    ExFreePoolWithTag(WaitCtx, TAG_OPLOCK);
}

Referenced by FsRtlAcknowledgeOplockBreak(), FsRtlCancelExclusiveIrp(), FsRtlCancelWaitIrp(), FsRtlOpBatchBreakClosePending(), FsRtlOplockBreakToII(), FsRtlOplockBreakToNone(), and FsRtlOplockCleanup().

FsRtlRequestExclusiveOplock()

NTSTATUS FsRtlRequestExclusiveOplock	(	IN POPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp,
		IN ULONG	Flags
	)

Definition at line 630 of file oplock.c.

{
    PINTERNAL_OPLOCK IntOplock;
    PIRP ListIrp;
    BOOLEAN Locked;
    NTSTATUS Status;
 
    DPRINT("FsRtlRequestExclusiveOplock(%p, %p, %p, %lu)\n", Oplock, Stack, Irp, Flags);
 
    IntOplock = *Oplock;
    Locked = FALSE;
    Status = STATUS_SUCCESS;
 
    /* Time to work! */
    _SEH2_TRY
    {
        /* Was the oplock already allocated? If not, do it now! */
        if (IntOplock == NULL)
        {
            *Oplock = FsRtlAllocateOplock();
            IntOplock = *Oplock;
        }
 
        /* Acquire our internal lock */
        ExAcquireFastMutexUnsafe(IntOplock->IntLock);
        Locked = TRUE;
 
        /* If we request exclusiveness, a filter or a pending oplock, grant it */
        if (Flags == (EXCLUSIVE_LOCK | PENDING_LOCK | FILTER_OPLOCK))
        {
            /* Either no oplock, or pending */
            ASSERT(BooleanFlagOn(IntOplock->Flags, (NO_OPLOCK | PENDING_LOCK)));
            IntOplock->ExclusiveIrp = Irp;
            IntOplock->FileObject = Stack->FileObject;
            IntOplock->Flags = (EXCLUSIVE_LOCK | PENDING_LOCK | FILTER_OPLOCK);
        }
        else
        {
            /* Otherwise, shared or no effective oplock */
            if (BooleanFlagOn(IntOplock->Flags, (LEVEL_2_OPLOCK | PENDING_LOCK | NO_OPLOCK)))
            {
                /* The shared IRPs list should contain a single entry! */
                if (IntOplock->Flags == LEVEL_2_OPLOCK)
                {
                    ListIrp = CONTAINING_RECORD(IntOplock->SharedListHead.Flink, IRP, Tail.Overlay.ListEntry);
                    ASSERT(IntOplock->SharedListHead.Flink == IntOplock->SharedListHead.Blink);
                    FsRtlRemoveAndCompleteIrp(ListIrp);
                }
 
                /* Set the exclusiveness */
                IntOplock->ExclusiveIrp = Irp;
                IntOplock->FileObject = Stack->FileObject;
                IntOplock->Flags = Flags;
 
                /* Mark the IRP pending and reference our file object */
                IoMarkIrpPending(Irp);
                ObReferenceObject(Stack->FileObject);
                Irp->IoStatus.Information = (ULONG_PTR)IntOplock;
 
                /* Now, set ourselves as cancel routine */
                IoAcquireCancelSpinLock(&Irp->CancelIrql);
                /* Unless IRP got canceled, then, just give up */
                if (Irp->Cancel)
                {
                    ExReleaseFastMutexUnsafe(IntOplock->IntLock);
                    Locked = FALSE;
                    FsRtlCancelExclusiveIrp(NULL, Irp);
                    Status = STATUS_CANCELLED;
                }
                else
                {
                    IoSetCancelRoutine(Irp, FsRtlCancelExclusiveIrp);
                    IoReleaseCancelSpinLock(Irp->CancelIrql);
                }
            }
            /* Cannot set exclusiveness, fail */
            else
            {
                if (Irp != NULL)
                {
                    Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED;
                    IoCompleteRequest(Irp, IO_DISK_INCREMENT);
                    Status = STATUS_OPLOCK_NOT_GRANTED;
                }
            }
        }
    }
    /* If locked, release */
    _SEH2_FINALLY
    {
        if (Locked)
        {
            ExReleaseFastMutexUnsafe(IntOplock->IntLock);
        }
    }
    _SEH2_END;
 
    return Status;
}

Referenced by FsRtlOplockFsctrl().

FsRtlRequestOplockII()

NTSTATUS FsRtlRequestOplockII	(	IN POPLOCK	Oplock,
		IN PIO_STACK_LOCATION	Stack,
		IN PIRP	Irp
	)

Definition at line 734 of file oplock.c.

{
    BOOLEAN Locked;
    NTSTATUS Status;
    PINTERNAL_OPLOCK IntOplock;
 
    DPRINT("FsRtlRequestOplockII(%p, %p, %p)\n", Oplock, Stack, Irp);
 
    IntOplock = *Oplock;
    Locked = FALSE;
    Status = STATUS_SUCCESS;
 
    _SEH2_TRY
    {
        /* No oplock yet? Allocate it */
        if (IntOplock == NULL)
        {
            *Oplock = FsRtlAllocateOplock();
            IntOplock = *Oplock;
        }
 
        /* Acquire the oplock */
        ExAcquireFastMutexUnsafe(IntOplock->IntLock);
        Locked = TRUE;
 
        /* If already shared, or no oplock that's fine! */
        if (BooleanFlagOn(IntOplock->Flags, (LEVEL_2_OPLOCK | NO_OPLOCK)))
        {
            IoMarkIrpPending(Irp);
            /* Granted! */
            Irp->IoStatus.Status = STATUS_SUCCESS;
 
            /* Insert in the shared list */
            InsertTailList(&IntOplock->SharedListHead, &Irp->Tail.Overlay.ListEntry);
 
            /* Save the associated oplock */
            Irp->IoStatus.Information = (ULONG_PTR)IntOplock;
 
            /* The oplock is shared */
            IntOplock->Flags = LEVEL_2_OPLOCK;
 
            /* Reference the fileobject */
            ObReferenceObject(Stack->FileObject);
 
            /* Set our cancel routine, unless the IRP got canceled in-between */
            IoAcquireCancelSpinLock(&Irp->CancelIrql);
            if (Irp->Cancel)
            {
                ExReleaseFastMutexUnsafe(IntOplock->IntLock);
                Locked = FALSE;
                FsRtlCancelOplockIIIrp(NULL, Irp);
                Status = STATUS_CANCELLED;
            }
            else
            {
                IoSetCancelRoutine(Irp, FsRtlCancelOplockIIIrp);
                IoReleaseCancelSpinLock(Irp->CancelIrql);
            }
        }
        /* Otherwise, just fail */
        else
        {
            Irp->IoStatus.Status = STATUS_OPLOCK_NOT_GRANTED;
            IoCompleteRequest(Irp, IO_DISK_INCREMENT);
            Status = STATUS_OPLOCK_NOT_GRANTED;
        }
    }
    _SEH2_FINALLY
    {
        if (Locked)
        {
            ExReleaseFastMutexUnsafe(IntOplock->IntLock);
        }
    }
    _SEH2_END;
 
    return Status;
}

Referenced by FsRtlOplockFsctrl().

FsRtlUninitializeOplock()

VOID NTAPI FsRtlUninitializeOplock

(

IN POPLOCK

Oplock

)

Definition at line 1600 of file oplock.c.

{
    PINTERNAL_OPLOCK IntOplock;
    PLIST_ENTRY NextEntry;
    PWAIT_CONTEXT WaitCtx;
    PIRP Irp;
    PIO_STACK_LOCATION Stack;
 
    DPRINT("FsRtlUninitializeOplock(%p)\n", Oplock);
 
    IntOplock = *Oplock;
 
    /* No oplock, nothing to do */
    if (IntOplock == NULL)
    {
        return;
    }
 
    /* Caller won't have the oplock anymore */
    *Oplock = NULL;
 
    _SEH2_TRY
    {
        ExAcquireFastMutexUnsafe(IntOplock->IntLock);
 
        /* If we had IRPs waiting for the lock, complete them */
        for (NextEntry = IntOplock->WaitListHead.Flink;
             NextEntry != &IntOplock->WaitListHead;
            NextEntry = NextEntry->Flink)
        {
            WaitCtx = CONTAINING_RECORD(NextEntry, WAIT_CONTEXT, WaitListEntry);
            Irp = WaitCtx->Irp;
 
            RemoveEntryList(&WaitCtx->WaitListEntry);
            /* Remove the cancel routine */
            IoAcquireCancelSpinLock(&Irp->CancelIrql);
            IoSetCancelRoutine(Irp, NULL);
            IoReleaseCancelSpinLock(Irp->CancelIrql);
 
            /* And complete */
            Irp->IoStatus.Information = 0;
            WaitCtx->CompletionRoutine(WaitCtx->CompletionContext, WaitCtx->Irp);
 
            ExFreePoolWithTag(WaitCtx, TAG_OPLOCK);
        }
 
        /* If we had shared IRPs (LEVEL_2), complete them */
        for (NextEntry = IntOplock->SharedListHead.Flink;
             NextEntry != &IntOplock->SharedListHead;
             NextEntry = NextEntry->Flink)
        {
            Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
            RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
 
            /* Remvoe the cancel routine */
            IoAcquireCancelSpinLock(&Irp->CancelIrql);
            IoSetCancelRoutine(Irp, NULL);
            IoReleaseCancelSpinLock(Irp->CancelIrql);
 
            /* Dereference the file object */
            Stack = IoGetCurrentIrpStackLocation(Irp);
            ObDereferenceObject(Stack->FileObject);
 
            /* And complete */
            Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_DISK_INCREMENT);
        }
 
        /* If we have an exclusive IRP, complete it */
        Irp = IntOplock->ExclusiveIrp;
        if (Irp != NULL)
        {
            /* Remvoe the cancel routine */
            IoAcquireCancelSpinLock(&Irp->CancelIrql);
            IoSetCancelRoutine(Irp, NULL);
            IoReleaseCancelSpinLock(Irp->CancelIrql);
 
            /* And complete */
            Irp->IoStatus.Information = FILE_OPLOCK_BROKEN_TO_NONE;
            Irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(Irp, IO_DISK_INCREMENT);
            IntOplock->ExclusiveIrp = NULL;
 
            /* If still referenced, dereference */
            if (IntOplock->FileObject != NULL)
            {
                ObDereferenceObject(IntOplock->FileObject);
            }
        }
    }
    _SEH2_FINALLY
    {
        ExReleaseFastMutexUnsafe(IntOplock->IntLock);
    }
    _SEH2_END;
 
    ExFreePoolWithTag(IntOplock->IntLock, TAG_OPLOCK);
    ExFreePoolWithTag(IntOplock, TAG_OPLOCK);
}

Referenced by CdDeleteFcb(), Ext2FreeFcb(), FatCreateDcb(), FatCreateFcb(), FatDeleteFcb(), and reap_fcb().

FsRtlWaitOnIrp()

VOID FsRtlWaitOnIrp	(	IN PINTERNAL_OPLOCK	Oplock,
		IN PIRP	Irp,
		IN PVOID	CompletionContext,
		IN POPLOCK_WAIT_COMPLETE_ROUTINE	CompletionRoutine,
		IN POPLOCK_FS_PREPOST_IRP	PostIrpRoutine,
		IN PKEVENT	WaitEvent
	)

Definition at line 148 of file oplock.c.

{
    BOOLEAN Locked;
    PWAIT_CONTEXT WaitCtx;
 
    DPRINT("FsRtlWaitOnIrp(%p, %p, %p, %p, %p, %p)\n", Oplock, Irp, CompletionContext, CompletionRoutine, PostIrpRoutine, WaitEvent);
 
    /* We must always be called with IntLock locked! */
    Locked = TRUE;
    /* Dirty check for above statement */
    ASSERT(Oplock->IntLock->Owner == KeGetCurrentThread());
 
    /* Allocate a wait context for the IRP */
    WaitCtx = ExAllocatePoolWithTag(PagedPool | POOL_RAISE_IF_ALLOCATION_FAILURE, sizeof(WAIT_CONTEXT), TAG_OPLOCK);
    WaitCtx->Irp = Irp;
    WaitCtx->SavedInformation = Irp->IoStatus.Information;
    /* If caller provided everything required, us it */
    if (CompletionRoutine != NULL)
    {
        WaitCtx->CompletionRoutine = CompletionRoutine;
        WaitCtx->CompletionContext = CompletionContext;
    }
    /* Otherwise, put ourselves */
    else
    {
        WaitCtx->CompletionRoutine = FsRtlCompletionRoutinePriv;
        WaitCtx->CompletionContext = WaitEvent;
        KeInitializeEvent(WaitEvent, NotificationEvent, FALSE);
    }
 
    /* If we got a prepost routine, call it now! */
    if (PostIrpRoutine != NULL)
    {
        PostIrpRoutine(CompletionContext, Irp);
    }
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    /* Queue the IRP - it's OK, we're locked */
    InsertHeadList(&Oplock->WaitListHead, &WaitCtx->WaitListEntry);
 
    /* Set the oplock as information of the IRP (for the cancel routine)
     * And lock the cancel routine lock for setting it
     */
    IoAcquireCancelSpinLock(&Irp->CancelIrql);
    Irp->IoStatus.Information = (ULONG_PTR)Oplock;
 
    /* If there's already a cancel routine
     * Cancel the IRP
     */
    if (Irp->Cancel)
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
        Locked = FALSE;
 
        if (CompletionRoutine != NULL)
        {
            IoMarkIrpPending(Irp);
        }
        FsRtlCancelWaitIrp(NULL, Irp);
    }
    /* Otherwise, put ourselves as the cancel routine and start waiting */
    else
    {
        IoSetCancelRoutine(Irp, FsRtlCancelWaitIrp);
        IoReleaseCancelSpinLock(Irp->CancelIrql);
        if (CompletionRoutine != NULL)
        {
            IoMarkIrpPending(Irp);
        }
        else
        {
            ExReleaseFastMutexUnsafe(Oplock->IntLock);
            Locked = FALSE;
            KeWaitForSingleObject(WaitEvent, Executive, KernelMode, FALSE, NULL);
        }
    }
 
    /* If we didn't unlock yet, do it now */
    if (Locked)
    {
        ExReleaseFastMutexUnsafe(Oplock->IntLock);
    }
}

Referenced by FsRtlOplockBreakNotify(), FsRtlOplockBreakToII(), and FsRtlOplockBreakToNone().