C++ (Cpp) ThreadWake示例

示例#1

文件： vif.c 项目： benchalmers/win-xenvif

static VOID
VifDisable(
    IN  PXENVIF_VIF_CONTEXT Context
    )
{
    PXENVIF_FRONTEND        Frontend = PdoGetFrontend(Context->Pdo);
    KIRQL                   Irql;
    PKEVENT                 Event;

    Trace("====>\n");

    AcquireMrswLockExclusive(&Context->Lock, &Irql);

    if (!Context->Enabled) {
        ReleaseMrswLockExclusive(&Context->Lock, Irql, FALSE);
        goto done;
    }

    Context->Enabled = FALSE;

    Event = MacGetEvent(FrontendGetMac(Frontend));
    KeSetEvent(Event, IO_NO_INCREMENT, FALSE);

    SUSPEND(Deregister,
            Context->SuspendInterface,
            Context->SuspendCallbackLate);
    Context->SuspendCallbackLate = NULL;

    SUSPEND(Release, Context->SuspendInterface);
    Context->SuspendInterface = NULL;

    (VOID) FrontendSetState(Frontend, FRONTEND_CONNECTED);

    ReleaseMrswLockExclusive(&Context->Lock, Irql, TRUE);

    ReceiverWaitForPackets(FrontendGetReceiver(Frontend));
    TransmitterAbortPackets(FrontendGetTransmitter(Frontend));

    KeClearEvent(&Context->MonitorEvent);
    ThreadWake(Context->MonitorThread);

    Trace("waiting for monitor thread\n");

    (VOID) KeWaitForSingleObject(&Context->MonitorEvent,
                                 Executive,
                                 KernelMode,
                                 FALSE,
                                 NULL);

    RtlZeroMemory(&Context->Callback, sizeof (VIF_CALLBACK));

    ReleaseMrswLockShared(&Context->Lock);

done:
    Trace("<====\n");
}

示例#2

文件： pdo.c 项目： HeidCloud/win-xenbus

static DECLSPEC_NOINLINE NTSTATUS
PdoDispatchPower(
    IN  PXENFILT_PDO    Pdo,
    IN  PIRP            Irp
    )
{
    PIO_STACK_LOCATION  StackLocation;
    UCHAR               MinorFunction;
    POWER_STATE_TYPE    PowerType;
    NTSTATUS            status;

    status = IoAcquireRemoveLock(&Pdo->Dx->RemoveLock, Irp);
    if (!NT_SUCCESS(status))
        goto fail1;

    StackLocation = IoGetCurrentIrpStackLocation(Irp);
    MinorFunction = StackLocation->MinorFunction;

    if (MinorFunction != IRP_MN_QUERY_POWER &&
        MinorFunction != IRP_MN_SET_POWER) {
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp,
                               __PdoDispatchPower,
                               Pdo,
                               TRUE,
                               TRUE,
                               TRUE);

        status = IoCallDriver(Pdo->LowerDeviceObject, Irp);

        goto done;
    }

    PowerType = StackLocation->Parameters.Power.Type;

    Trace("====> (%02x:%s)\n",
          MinorFunction, 
          PowerMinorFunctionName(MinorFunction)); 

    switch (PowerType) {
    case DevicePowerState:
        IoMarkIrpPending(Irp);

        ASSERT3P(Pdo->DevicePowerIrp, ==, NULL);
        Pdo->DevicePowerIrp = Irp;
        KeMemoryBarrier();

        ThreadWake(Pdo->DevicePowerThread);

        status = STATUS_PENDING;
        break;

    case SystemPowerState:
        IoMarkIrpPending(Irp);

        ASSERT3P(Pdo->SystemPowerIrp, ==, NULL);
        Pdo->SystemPowerIrp = Irp;
        KeMemoryBarrier();

        ThreadWake(Pdo->SystemPowerThread);

        status = STATUS_PENDING;
        break;

    default:
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine(Irp,
                               __PdoDispatchPower,
                               Pdo,
                               TRUE,
                               TRUE,
                               TRUE);

        status = IoCallDriver(Pdo->LowerDeviceObject, Irp);
        break;
    }

    Trace("<==== (%02x:%s) (%08x)\n",
          MinorFunction, 
          PowerMinorFunctionName(MinorFunction),
          status);

done:
    return status;

fail1:
    Error("fail1 (%08x)\n", status);

    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return status;
}