waitsup.c File Reference

#include "npfs.h"

Include dependency graph for waitsup.c:

Go to the source code of this file.

Macros
#define	NPFS_BUGCHECK_FILE_ID   (NPFS_BUGCHECK_WAITSUP)

Functions
VOID NTAPI	NpCancelWaitQueueIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	NpTimerDispatch (IN PKDPC Dpc, IN PVOID Context, IN PVOID Argument1, IN PVOID Argument2)
VOID NTAPI	NpInitializeWaitQueue (IN PNP_WAIT_QUEUE WaitQueue)
static BOOLEAN	NpEqualUnicodeString (IN PCUNICODE_STRING String1, IN PCUNICODE_STRING String2)
NTSTATUS NTAPI	NpCancelWaiter (IN PNP_WAIT_QUEUE WaitQueue, IN PUNICODE_STRING PipePath, IN NTSTATUS Status, IN PLIST_ENTRY List)
NTSTATUS NTAPI	NpAddWaiter (IN PNP_WAIT_QUEUE WaitQueue, IN LARGE_INTEGER WaitTime, IN PIRP Irp, IN PUNICODE_STRING AliasName)

Macro Definition Documentation

NPFS_BUGCHECK_FILE_ID

#define NPFS_BUGCHECK_FILE_ID   (NPFS_BUGCHECK_WAITSUP)

Definition at line 14 of file waitsup.c.

Function Documentation

NpAddWaiter()

NTSTATUS NTAPI NpAddWaiter	(	IN PNP_WAIT_QUEUE	WaitQueue,
		IN LARGE_INTEGER	WaitTime,
		IN PIRP	Irp,
		IN PUNICODE_STRING	AliasName
	)

Definition at line 221 of file waitsup.c.

{
    PIO_STACK_LOCATION IoStack;
    KIRQL OldIrql;
    NTSTATUS Status;
    PNP_WAIT_QUEUE_ENTRY WaitEntry;
    PFILE_PIPE_WAIT_FOR_BUFFER WaitBuffer;
    LARGE_INTEGER DueTime;
    ULONG i;
 
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    WaitEntry = ExAllocatePoolWithQuotaTag(NonPagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
                                           sizeof(*WaitEntry),
                                           NPFS_WRITE_BLOCK_TAG);
    if (!WaitEntry)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    KeInitializeDpc(&WaitEntry->Dpc, NpTimerDispatch, WaitEntry);
    KeInitializeTimer(&WaitEntry->Timer);
 
    if (AliasName)
    {
        WaitEntry->AliasName = *AliasName;
    }
    else
    {
        WaitEntry->AliasName.Length = 0;
        WaitEntry->AliasName.Buffer = NULL;
    }
 
    WaitEntry->WaitQueue = WaitQueue;
    WaitEntry->Irp = Irp;
 
    WaitBuffer = Irp->AssociatedIrp.SystemBuffer;
    if (WaitBuffer->TimeoutSpecified)
    {
        DueTime = WaitBuffer->Timeout;
    }
    else
    {
        DueTime = WaitTime;
    }
 
    for (i = 0; i < WaitBuffer->NameLength / sizeof(WCHAR); i++)
    {
        WaitBuffer->Name[i] = RtlUpcaseUnicodeChar(WaitBuffer->Name[i]);
    }
 
    Irp->Tail.Overlay.DriverContext[0] = WaitQueue;
    Irp->Tail.Overlay.DriverContext[1] = WaitEntry;
 
    KeAcquireSpinLock(&WaitQueue->WaitLock, &OldIrql);
 
    IoSetCancelRoutine(Irp, NpCancelWaitQueueIrp);
 
    if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
    {
        Status = STATUS_CANCELLED;
    }
    else
    {
        InsertTailList(&WaitQueue->WaitList, &Irp->Tail.Overlay.ListEntry);
 
        IoMarkIrpPending(Irp);
        Status = STATUS_PENDING;
 
        WaitEntry->FileObject = IoStack->FileObject;
        ObReferenceObject(WaitEntry->FileObject);
 
        KeSetTimer(&WaitEntry->Timer, DueTime, &WaitEntry->Dpc);
        WaitEntry = NULL;
    }
 
    KeReleaseSpinLock(&WaitQueue->WaitLock, OldIrql);
    if (WaitEntry) ExFreePool(WaitEntry);
 
    return Status;
}

Referenced by NpWaitForNamedPipe().

NpCancelWaiter()

NTSTATUS NTAPI NpCancelWaiter	(	IN PNP_WAIT_QUEUE	WaitQueue,
		IN PUNICODE_STRING	PipePath,
		IN NTSTATUS	Status,
		IN PLIST_ENTRY	List
	)

Definition at line 120 of file waitsup.c.

{
    UNICODE_STRING PipePathUpper;
    KIRQL OldIrql;
    PWCHAR Buffer;
    PLIST_ENTRY NextEntry;
    PNP_WAIT_QUEUE_ENTRY WaitEntry, Linkage;
    PIRP WaitIrp;
    PFILE_PIPE_WAIT_FOR_BUFFER WaitBuffer;
    UNICODE_STRING WaitName, PipeName;
 
    Linkage = NULL;
 
    Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                   PipePath->Length,
                                   NPFS_WAIT_BLOCK_TAG);
    if (!Buffer) return STATUS_INSUFFICIENT_RESOURCES;
 
    RtlInitEmptyUnicodeString(&PipePathUpper, Buffer, PipePath->Length);
    RtlUpcaseUnicodeString(&PipePathUpper, PipePath, FALSE);
 
    KeAcquireSpinLock(&WaitQueue->WaitLock, &OldIrql);
 
    NextEntry = WaitQueue->WaitList.Flink;
    while (NextEntry != &WaitQueue->WaitList)
    {
        WaitIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
        NextEntry = NextEntry->Flink;
        WaitEntry = WaitIrp->Tail.Overlay.DriverContext[1];
 
        if (WaitEntry->AliasName.Length)
        {
            ASSERT(FALSE);
            /* We have an alias. Use that for comparison */
            WaitName = WaitEntry->AliasName;
            PipeName = PipePathUpper;
        }
        else
        {
            /* Use the name from the wait buffer to compare */
            WaitBuffer = WaitIrp->AssociatedIrp.SystemBuffer;
            WaitName.Buffer = WaitBuffer->Name;
            WaitName.Length = WaitBuffer->NameLength;
            WaitName.MaximumLength = WaitName.Length;
 
            /* WaitName doesn't have a leading backslash,
             * so skip the one in PipePathUpper for the comparison */
            PipeName.Buffer = PipePathUpper.Buffer + 1;
            PipeName.Length = PipePathUpper.Length - sizeof(WCHAR);
            PipeName.MaximumLength = PipeName.Length;
        }
 
        /* Can't use RtlEqualUnicodeString with a spinlock held */
        if (NpEqualUnicodeString(&WaitName, &PipeName))
        {
            /* Found a matching wait. Cancel it */
            RemoveEntryList(&WaitIrp->Tail.Overlay.ListEntry);
            if (KeCancelTimer(&WaitEntry->Timer))
            {
                WaitEntry->WaitQueue = (PNP_WAIT_QUEUE)Linkage;
                Linkage = WaitEntry;
            }
            else
            {
                WaitEntry->Irp = NULL;
                WaitIrp->Tail.Overlay.DriverContext[1] = NULL;
            }
 
            if (IoSetCancelRoutine(WaitIrp, NULL))
            {
                WaitIrp->IoStatus.Information = 0;
                WaitIrp->IoStatus.Status = Status;
                InsertTailList(List, &WaitIrp->Tail.Overlay.ListEntry);
            }
            else
            {
                WaitIrp->Tail.Overlay.DriverContext[1] = NULL;
            }
        }
    }
 
    KeReleaseSpinLock(&WaitQueue->WaitLock, OldIrql);
 
    ExFreePoolWithTag(Buffer, NPFS_WAIT_BLOCK_TAG);
 
    while (Linkage)
    {
        WaitEntry = Linkage;
        Linkage = (PNP_WAIT_QUEUE_ENTRY)Linkage->WaitQueue;
        ObDereferenceObject(WaitEntry->FileObject);
        ExFreePool(WaitEntry);
    }
 
    return STATUS_SUCCESS;
}

Referenced by NpCreateExistingNamedPipe(), NpDeleteFcb(), and NpSetListeningPipeState().

NpCancelWaitQueueIrp()

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

Definition at line 20 of file waitsup.c.

{
    KIRQL OldIrql;
    PNP_WAIT_QUEUE_ENTRY WaitEntry;
    PNP_WAIT_QUEUE WaitQueue;
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    WaitQueue = Irp->Tail.Overlay.DriverContext[0];
 
    KeAcquireSpinLock(&WaitQueue->WaitLock, &OldIrql);
 
    WaitEntry = Irp->Tail.Overlay.DriverContext[1];
    if (WaitEntry)
    {
        RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
        if (!KeCancelTimer(&WaitEntry->Timer))
        {
            WaitEntry->Irp = NULL;
            WaitEntry = NULL;
        }
    }
 
    KeReleaseSpinLock(&WaitQueue->WaitLock, OldIrql);
 
    if (WaitEntry)
    {
        ObDereferenceObject(WaitEntry->FileObject);
        ExFreePool(WaitEntry);
    }
 
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_CANCELLED;
    IoCompleteRequest(Irp, IO_NAMED_PIPE_INCREMENT);
}

Referenced by NpAddWaiter().

NpEqualUnicodeString()

static BOOLEAN NpEqualUnicodeString ( IN PCUNICODE_STRING  String1, IN PCUNICODE_STRING  String2  )

static

Definition at line 104 of file waitsup.c.

{
    SIZE_T EqualLength;
 
    if (String1->Length != String2->Length)
        return FALSE;
 
    EqualLength = RtlCompareMemory(String1->Buffer,
                                   String2->Buffer,
                                   String1->Length);
    return EqualLength == String1->Length;
}

Referenced by NpCancelWaiter().

NpInitializeWaitQueue()

VOID NTAPI NpInitializeWaitQueue

(

IN PNP_WAIT_QUEUE

WaitQueue

)

Definition at line 96 of file waitsup.c.

{
    InitializeListHead(&WaitQueue->WaitList);
    KeInitializeSpinLock(&WaitQueue->WaitLock);
}

Referenced by NpInitializeVcb().

NpTimerDispatch()

VOID NTAPI NpTimerDispatch	(	IN PKDPC	Dpc,
		IN PVOID	Context,
		IN PVOID	Argument1,
		IN PVOID	Argument2
	)

Definition at line 59 of file waitsup.c.

{
    PIRP Irp;
    KIRQL OldIrql;
    PNP_WAIT_QUEUE_ENTRY WaitEntry = Context;
 
    KeAcquireSpinLock(&WaitEntry->WaitQueue->WaitLock, &OldIrql);
 
    Irp = WaitEntry->Irp;
    if (Irp)
    {
        RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
 
        if (!IoSetCancelRoutine(Irp, NULL))
        {
            Irp->Tail.Overlay.DriverContext[1] = NULL;
            Irp = NULL;
        }
    }
 
    KeReleaseSpinLock(&WaitEntry->WaitQueue->WaitLock, OldIrql);
 
    if (Irp)
    {
        Irp->IoStatus.Status = STATUS_IO_TIMEOUT;
        IoCompleteRequest(Irp, IO_NAMED_PIPE_INCREMENT);
    }
 
    ObDereferenceObject(WaitEntry->FileObject);
    ExFreePool(WaitEntry);
}

Referenced by NpAddWaiter().