Пример #1
0
NTSTATUS
NotifierStoreWrite(
    IN  PXENVIF_NOTIFIER            Notifier,
    IN  PXENBUS_STORE_TRANSACTION   Transaction
    )
{
    PXENVIF_FRONTEND                Frontend = Notifier->Frontend;
    ULONG                           Port;
    NTSTATUS                        status;

    Port = EVTCHN(Port,
                  Notifier->EvtchnInterface,
                  Notifier->Evtchn);

    status = STORE(Printf,
                   Notifier->StoreInterface,
                   Transaction,
                   FrontendGetPath(Frontend),
                   "event-channel",
                   "%u",
                   Port);

    if (!NT_SUCCESS(status))
        goto fail1;

    return STATUS_SUCCESS;

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

    return status;
}
Пример #2
0
NTSTATUS
MacEnable(
    IN  PXENVIF_MAC     Mac
    )
{
    PXENVIF_FRONTEND    Frontend;
    NTSTATUS            status;

    Frontend = Mac->Frontend;

    ASSERT3U(KeGetCurrentIrql(), ==, DISPATCH_LEVEL);
    KeAcquireSpinLockAtDpcLevel(&Mac->Lock);

    status = STORE(Watch,
                   Mac->StoreInterface,
                   FrontendGetPath(Frontend),
                   "disconnect",
                   &Mac->Event,
                   &Mac->Watch);
    if (!NT_SUCCESS(status))
        goto fail1;

    ASSERT(!Mac->Enabled);
    Mac->Enabled = TRUE;

    KeReleaseSpinLockFromDpcLevel(&Mac->Lock);

    return STATUS_SUCCESS;

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

    KeReleaseSpinLockFromDpcLevel(&Mac->Lock);

    return status;
}
Пример #3
0
NTSTATUS
MacConnect(
    IN  PXENVIF_MAC     Mac
    )
{
    PXENVIF_FRONTEND    Frontend;
    PCHAR               Buffer;
    ULONG64             Mtu;
    NTSTATUS            status;

    Frontend = Mac->Frontend;

    Mac->StoreInterface = FrontendGetStoreInterface(Frontend);

    STORE(Acquire, Mac->StoreInterface);

    status = STORE(Read,
                   Mac->StoreInterface,
                   NULL,
                   FrontendGetPath(Frontend),
                   "mtu",
                   &Buffer);
    if (!NT_SUCCESS(status)) {
        Mtu = ETHERNET_MTU;
    } else {
        Mtu = strtol(Buffer, NULL, 10);

        STORE(Free,
              Mac->StoreInterface,
              Buffer);
    }

    status = STATUS_INVALID_PARAMETER;
    if (Mtu < ETHERNET_MIN)
        goto fail1;

    Mac->MaximumFrameSize = (ULONG)Mtu + sizeof (ETHERNET_TAGGED_HEADER);

    status = __MacSetPermanentAddress(Mac,
                                      FrontendGetPermanentMacAddress(Frontend));
    if (!NT_SUCCESS(status))
        goto fail2;

    status = __MacSetCurrentAddress(Mac,
                                    FrontendGetCurrentMacAddress(Frontend));
    if (!NT_SUCCESS(status))
        RtlCopyMemory(&Mac->CurrentAddress,
                      &Mac->PermanentAddress,
                      sizeof (ETHERNET_ADDRESS));

    RtlFillMemory(Mac->BroadcastAddress.Byte, ETHERNET_ADDRESS_LENGTH, 0xFF);

    Mac->DebugInterface = FrontendGetDebugInterface(Frontend);

    DEBUG(Acquire, Mac->DebugInterface);

    status = DEBUG(Register,
                   Mac->DebugInterface,
                   __MODULE__ "|MAC",
                   MacDebugCallback,
                   Mac,
                   &Mac->DebugCallback);
    if (!NT_SUCCESS(status))
        goto fail3;

    ASSERT(!Mac->Connected);
    Mac->Connected = TRUE;

    return STATUS_SUCCESS;

fail3:
    Error("fail3\n");

    DEBUG(Release, Mac->DebugInterface);
    Mac->DebugInterface = NULL;

    RtlZeroMemory(Mac->BroadcastAddress.Byte, ETHERNET_ADDRESS_LENGTH);
    RtlZeroMemory(Mac->CurrentAddress.Byte, ETHERNET_ADDRESS_LENGTH);
    RtlZeroMemory(Mac->PermanentAddress.Byte, ETHERNET_ADDRESS_LENGTH);

fail2:
    Error("fail2\n");

    Mac->MaximumFrameSize = 0;

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

    STORE(Release, Mac->StoreInterface);
    Mac->StoreInterface = NULL;

    return status;
}