23 Apr
2020
23 Apr
'20
1:51 p.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4c37757e81109128109fe…
commit 4c37757e81109128109feb0a0a9342452c6caf78
Author: Nguyen Trung Khanh <nguyentrungkhanh97(a)gmail.com>
AuthorDate: Thu Mar 5 10:58:56 2020 +0700
Commit: Victor Perevertkin <victor.perevertkin(a)reactos.org>
CommitDate: Thu Apr 23 16:33:09 2020 +0300
[NETKVM] Import NetKVM network adapter driver by Red Hat
CORE-15841
---
drivers/network/dd/CMakeLists.txt | 1 +
drivers/network/dd/netkvm/CMakeLists.txt | 37 +
drivers/network/dd/netkvm/Common/DebugData.h | 193 ++
drivers/network/dd/netkvm/Common/IONetDescriptor.h | 133 +
drivers/network/dd/netkvm/Common/ParaNdis-Common.c | 3017 ++++++++++++++++++++
drivers/network/dd/netkvm/Common/ParaNdis-Debug.c | 394 +++
drivers/network/dd/netkvm/Common/ParaNdis-Oid.c | 677 +++++
drivers/network/dd/netkvm/Common/ParaNdis-Oid.h | 104 +
drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c | 389 +++
drivers/network/dd/netkvm/Common/ethernetutils.h | 123 +
drivers/network/dd/netkvm/Common/kdebugprint.h | 108 +
drivers/network/dd/netkvm/Common/ndis56common.h | 892 ++++++
drivers/network/dd/netkvm/Common/quverp.h | 45 +
drivers/network/dd/netkvm/Common/rhel.ver | 64 +
drivers/network/dd/netkvm/Common/sw-offload.c | 619 ++++
drivers/network/dd/netkvm/Common/vendor.ver | 98 +
drivers/network/dd/netkvm/virtio/LICENSE | 30 +
drivers/network/dd/netkvm/virtio/VirtIO.h | 128 +
drivers/network/dd/netkvm/virtio/VirtIOPCICommon.c | 411 +++
drivers/network/dd/netkvm/virtio/VirtIOPCILegacy.c | 283 ++
drivers/network/dd/netkvm/virtio/VirtIOPCIModern.c | 597 ++++
.../network/dd/netkvm/virtio/VirtIORing-Packed.c | 651 +++++
drivers/network/dd/netkvm/virtio/VirtIORing.c | 562 ++++
drivers/network/dd/netkvm/virtio/kdebugprint.h | 11 +
drivers/network/dd/netkvm/virtio/linux/types.h | 19 +
.../network/dd/netkvm/virtio/linux/virtio_config.h | 73 +
.../network/dd/netkvm/virtio/linux/virtio_types.h | 47 +
drivers/network/dd/netkvm/virtio/osdep.h | 39 +
drivers/network/dd/netkvm/virtio/virtio_pci.h | 392 +++
.../network/dd/netkvm/virtio/virtio_pci_common.h | 88 +
drivers/network/dd/netkvm/virtio/virtio_ring.h | 50 +
.../netkvm/virtio/windows/virtio_ring_allocation.h | 24 +
drivers/network/dd/netkvm/wxp/ParaNdis5-Driver.c | 452 +++
drivers/network/dd/netkvm/wxp/ParaNdis5-Impl.c | 1474 ++++++++++
drivers/network/dd/netkvm/wxp/ParaNdis5-Oid.c | 785 +++++
drivers/network/dd/netkvm/wxp/ParaNdis5.h | 88 +
drivers/network/dd/netkvm/wxp/netkvm.inx | 331 +++
drivers/network/dd/netkvm/wxp/parandis.rc | 31 +
media/inf/CMakeLists.txt | 1 +
media/inf/netkvm.inf | 331 +++
sdk/include/ddk/ndis.h | 6 +-
sdk/include/xdk/kefuncs.h | 2 +-
42 files changed, 13796 insertions(+), 4 deletions(-)
diff --git a/drivers/network/dd/CMakeLists.txt b/drivers/network/dd/CMakeLists.txt
index 89b96df4897..39a20fce8e3 100644
--- a/drivers/network/dd/CMakeLists.txt
+++ b/drivers/network/dd/CMakeLists.txt
@@ -1,5 +1,6 @@
add_subdirectory(e1000)
add_subdirectory(ne2000)
+add_subdirectory(netkvm)
add_subdirectory(pcnet)
add_subdirectory(rtl8139)
diff --git a/drivers/network/dd/netkvm/CMakeLists.txt
b/drivers/network/dd/netkvm/CMakeLists.txt
new file mode 100644
index 00000000000..6906334f40e
--- /dev/null
+++ b/drivers/network/dd/netkvm/CMakeLists.txt
@@ -0,0 +1,37 @@
+
+include_directories(BEFORE common virtio)
+
+add_definitions(
+ -DNDIS_MINIPORT_DRIVER
+ -DNDIS51_MINIPORT=1)
+
+list(APPEND SOURCE
+ common/ParaNdis-Common.c
+ common/ParaNdis-Oid.c
+ common/ParaNdis-VirtIO.c
+ common/ParaNdis-Debug.c
+ common/sw-offload.c
+ virtio/VirtIOPCICommon.c
+ virtio/VirtIOPCILegacy.c
+ virtio/VirtIOPCIModern.c
+ virtio/VirtIORing.c
+ virtio/VirtIORing-Packed.c
+ wxp/ParaNdis5-Driver.c
+ wxp/ParaNdis5-Impl.c
+ wxp/ParaNdis5-Oid.c)
+
+add_library(netkvm MODULE ${SOURCE} wxp/parandis.rc)
+set_module_type(netkvm kernelmodedriver)
+add_importlibs(netkvm ndis ntoskrnl hal)
+add_cd_file(TARGET netkvm DESTINATION reactos/system32/drivers FOR all)
+
+if (NOT MSVC)
+ add_compile_flags("-Wno-unused-function")
+ add_compile_flags("-Wno-old-style-declaration")
+ add_compile_flags("-Wno-unknown-pragmas")
+ add_compile_flags("-Wno-unused-but-set-variable")
+ add_compile_flags("-Wno-pointer-sign")
+ add_compile_flags("-Wno-pointer-to-int-cast")
+ add_compile_flags("-Wno-int-to-pointer-cast")
+ add_compile_flags("-Wno-attributes")
+endif()
diff --git a/drivers/network/dd/netkvm/Common/DebugData.h
b/drivers/network/dd/netkvm/Common/DebugData.h
new file mode 100644
index 00000000000..cf0bf849f6a
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/DebugData.h
@@ -0,0 +1,193 @@
+/*
+ * This file contains definitions and data structures, common between
+ * NDIS driver and debugger helper unit, processing crash dump with built-in
+ * data provided by the driver.
+ *
+ * Included in NetKVM NDIS kernel driver for Windows.
+ * Included in NetKVMDumpParser application.
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef PARANDIS_DEBUG_DATA_H
+#define PARANDIS_DEBUG_DATA_H
+
+typedef enum _etagHistoryLogOperation
+{
+ hopPowerOff, // common::PowerOff, 1/0 - entry/exit (none, entry, none,
none)
+ hopPowerOn, // common::PowerOn, 1/0 - entry/exit (none, entry, none,
none)
+ hopSysPause, // ndis6::Pause, 1/0 - entry/completion
+ hopSysResume, // ndis6::Restart, 1/0 - entry/completion
+ hopInternalSendPause, // implementation, 1/0 - entry/completion
+ hopInternalReceivePause, // implementation, 1/0 - entry/completion
+ hopInternalSendResume, // implementation
+ hopInternalReceiveResume, // implementation
+ hopSysReset, // implementation driver, 1/0 - entry/completion
+ hopHalt, // implementation driver, 1/0 - entry/completion
+ hopConnectIndication, // implementation
+ hopDPC, // common::DpcWorkBody (1, none, none, none) (0, left,
free buffers, free desc)
+ hopSend, // implementation, when Send requested (nbl, nof lists,
nof bufs, nof bytes) (packet, 1, nof packets, none)
+ hopSendNBLRequest, // ndis6 implementation (nbl, nof packets, none, none)
+ hopSendPacketRequest, // not used
+ hopSendPacketMapped, // implementation, before the packet inserted into queue
(nbl, which packet, nof frags, none)
+ hopSubmittedPacket, // implementation, when the packet submitted (nbl, which
packet, result, flags)
+ hopBufferSent, // implementation, when the packet returned from VirtIO
queue (nbl, packet no., free buf, free desc)
+ hopReceiveStat, // common: RX (none, retrieved, reported, ready rx
buffers)
+ hopBufferReturned, // not used
+ hopSendComplete, // implementation, when the packet completed
+ hopTxProcess,
+ hopPacketReceived, // implementation, when the packet prepared for
indication (nbl, length, prio tag, type)
+ hopOidRequest, // implementation, none, OID, on entry(type, 1), on exit
(status, 0), on complete (status, 2)
+ hopPnpEvent // common, none, event, 0, 0
+}eHistoryLogOperation;
+
+// {E51FCE18-B3E7-441e-B18C-D9E9B71616F3}
+static const GUID ParaNdis_CrashGuid =
+{ 0xe51fce18, 0xb3e7, 0x441e, { 0xb1, 0x8c, 0xd9, 0xe9, 0xb7, 0x16, 0x16, 0xf3 } };
+
+/* This structure is NOT changeable */
+typedef struct _tagBugCheckStaticDataHeader
+{
+ USHORT SizeOfPointer;
+ USHORT StaticDataVersion;
+ USHORT PerNicDataVersion;
+ USHORT ulMaxContexts;
+ LARGE_INTEGER qCrashTime;
+ UINT64 PerNicData;
+ UINT64 DataArea;
+ UINT64 DataAreaSize;
+}tBugCheckStaticDataHeader;
+
+/* This structure is NOT changeable */
+typedef struct _tagBugCheckDataLocation
+{
+ UINT64 Address;
+ UINT64 Size;
+}tBugCheckDataLocation;
+
+#define PARANDIS_DEBUG_STATIC_DATA_VERSION 0
+#define PARANDIS_DEBUG_PER_NIC_DATA_VERSION 0
+#define PARANDIS_DEBUG_HISTORY_DATA_VERSION 1
+/* This structure is NOT changeable */
+typedef struct _tagBugCheckStaticDataContent_V0
+{
+ ULONG SizeOfHistory;
+ ULONG SizeOfHistoryEntry;
+ LONG CurrentHistoryIndex;
+ ULONG HistoryDataVersion;
+ ULONG64 HistoryData;
+}tBugCheckStaticDataContent_V0;
+
+#define PARANDIS_DEBUG_INTERRUPTS
+
+#ifdef PARANDIS_DEBUG_INTERRUPTS
+# define PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(p) \
+ NdisGetCurrentSystemTime(&(p)->LastInterruptTimeStamp)
+# define PARANDIS_GET_LAST_INTERRUPT_TIMESTAMP(p) \
+ (p)->LastInterruptTimeStamp.QuadPart
+#else
+# define PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(p)
+# define PARANDIS_GET_LAST_INTERRUPT_TIMESTAMP(p) (0)
+#endif
+
+typedef struct _tagBugCheckPerNicDataContent_V0
+{
+ UINT64 Context;
+ LARGE_INTEGER LastInterruptTimeStamp;
+ LARGE_INTEGER LastTxCompletionTimeStamp;
+ ULONG nofPacketsToComplete;
+ ULONG nofReadyTxBuffers;
+}tBugCheckPerNicDataContent_V0;
+
+typedef struct _tagBugCheckHistoryDataEntry_V0
+{
+ LARGE_INTEGER TimeStamp;
+ UINT64 Context;
+ UINT64 pParam1;
+ ULONG operation;
+ ULONG lParam2;
+ ULONG lParam3;
+ ULONG lParam4;
+}tBugCheckHistoryDataEntry_V0;
+
+typedef struct _tagBugCheckHistoryDataEntry_V1
+{
+ LARGE_INTEGER TimeStamp;
+ UINT64 Context;
+ ULONG uIRQL;
+ ULONG uProcessor;
+ UINT64 pParam1;
+ ULONG operation;
+ ULONG lParam2;
+ ULONG lParam3;
+ ULONG lParam4;
+}tBugCheckHistoryDataEntry_V1;
+
+
+#if (PARANDIS_DEBUG_STATIC_DATA_VERSION == 0)
+typedef tBugCheckStaticDataContent_V0 tBugCheckStaticDataContent;
+#endif
+
+#if (PARANDIS_DEBUG_PER_NIC_DATA_VERSION == 0)
+typedef tBugCheckPerNicDataContent_V0 tBugCheckPerNicDataContent;
+#endif
+
+#if (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 0)
+typedef tBugCheckHistoryDataEntry_V0 tBugCheckHistoryDataEntry;
+#elif (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 1)
+typedef tBugCheckHistoryDataEntry_V1 tBugCheckHistoryDataEntry;
+#endif
+
+typedef struct _tagBugCheckStaticDataContent_V1
+{
+ UINT64 res1;
+ UINT64 res2;
+ UINT64 History;
+}tBugCheckStaticDataContent_V1;
+
+typedef struct _tagBugCheckPerNicDataContent_V1
+{
+ UINT64 Context;
+ LARGE_INTEGER LastInterruptTimeStamp;
+ LARGE_INTEGER LastTxCompletionTimeStamp;
+ ULONG nofPacketsToComplete;
+ ULONG nofReadyTxBuffers;
+}tBugCheckPerNicDataContent_V1;
+
+
+#if (PARANDIS_DEBUG_HEADER_VERSION == 1)
+typedef tBugCheckStaticDataContent_V1 tBugCheckStaticDataContent;
+#endif
+
+#if (PARANDIS_DEBUG_PER_NIC_DATA_VERSION == 1)
+typedef tBugCheckPerNicDataContent_V1 tBugCheckPerNicDataContent;
+#endif
+
+// etc
+
+
+
+#endif
diff --git a/drivers/network/dd/netkvm/Common/IONetDescriptor.h
b/drivers/network/dd/netkvm/Common/IONetDescriptor.h
new file mode 100644
index 00000000000..8e9a05b2110
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/IONetDescriptor.h
@@ -0,0 +1,133 @@
+/*
+ * This file contains common guest/host definition, related
+ * to VirtIO network adapter
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef IONETDESCRIPTOR_H
+#define IONETDESCRIPTOR_H
+
+#pragma pack (push)
+#pragma pack (1)
+/* This is the first element of the scatter-gather list. If you don't
+ * specify GSO or CSUM features, you can simply ignore the header. */
+typedef struct _tagvirtio_net_hdr
+{
+#define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 // Use csum_start, csum_offset
+#define VIRTIO_NET_HDR_F_DATA_VALID 2 // Host checked checksum, no need to recheck
+ u8 flags;
+#define VIRTIO_NET_HDR_GSO_NONE 0 // Not a GSO frame
+#define VIRTIO_NET_HDR_GSO_TCPV4 1 // GSO frame, IPv4 TCP (TSO)
+#define VIRTIO_NET_HDR_GSO_UDP 3 // GSO frame, IPv4 UDP (UFO)
+#define VIRTIO_NET_HDR_GSO_TCPV6 4 // GSO frame, IPv6 TCP
+#define VIRTIO_NET_HDR_GSO_ECN 0x80 // TCP has ECN set
+ u8 gso_type;
+ u16 hdr_len; // Ethernet + IP + tcp/udp hdrs
+ u16 gso_size; // Bytes to append to gso_hdr_len per frame
+ u16 csum_start; // Position to start checksumming from
+ u16 csum_offset; // Offset after that to place checksum
+}virtio_net_hdr_basic;
+
+typedef struct _tagvirtio_net_hdr_ext
+{
+ virtio_net_hdr_basic BasicHeader;
+ u16 nBuffers;
+}virtio_net_hdr_ext;
+
+/*
+ * Control virtqueue data structures
+ *
+ * The control virtqueue expects a header in the first sg entry
+ * and an ack/status response in the last entry. Data for the
+ * command goes in between.
+ */
+typedef struct tag_virtio_net_ctrl_hdr {
+ u8 class_of_command;
+ u8 cmd;
+}virtio_net_ctrl_hdr;
+
+typedef u8 virtio_net_ctrl_ack;
+
+#define VIRTIO_NET_OK 0
+#define VIRTIO_NET_ERR 1
+
+/*
+ * Control the RX mode, ie. promiscuous, allmulti, etc...
+ * All commands require an "out" sg entry containing a 1 byte
+ * state value, zero = disable, non-zero = enable. Commands
+ * 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature.
+ * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA.
+ */
+#define VIRTIO_NET_CTRL_RX_MODE 0
+ #define VIRTIO_NET_CTRL_RX_MODE_PROMISC 0
+ #define VIRTIO_NET_CTRL_RX_MODE_ALLMULTI 1
+ #define VIRTIO_NET_CTRL_RX_MODE_ALLUNI 2
+ #define VIRTIO_NET_CTRL_RX_MODE_NOMULTI 3
+ #define VIRTIO_NET_CTRL_RX_MODE_NOUNI 4
+ #define VIRTIO_NET_CTRL_RX_MODE_NOBCAST 5
+
+/*
+ * Control the MAC filter table.
+ *
+ * The MAC filter table is managed by the hypervisor, the guest should
+ * assume the size is infinite. Filtering should be considered
+ * non-perfect, ie. based on hypervisor resources, the guest may
+ * received packets from sources not specified in the filter list.
+ *
+ * In addition to the class/cmd header, the TABLE_SET command requires
+ * two out scatterlists. Each contains a 4 byte count of entries followed
+ * by a concatenated byte stream of the ETH_ALEN MAC addresses. The
+ * first sg list contains unicast addresses, the second is for multicast.
+ * This functionality is present if the VIRTIO_NET_F_CTRL_RX feature
+ * is available.
+ */
+#define ETH_ALEN 6
+
+struct virtio_net_ctrl_mac {
+ u32 entries;
+ // follows
+ //u8 macs[][ETH_ALEN];
+};
+#define VIRTIO_NET_CTRL_MAC 1
+ #define VIRTIO_NET_CTRL_MAC_TABLE_SET 0
+
+/*
+ * Control VLAN filtering
+ *
+ * The VLAN filter table is controlled via a simple ADD/DEL interface.
+ * VLAN IDs not added may be filterd by the hypervisor. Del is the
+ * opposite of add. Both commands expect an out entry containing a 2
+ * byte VLAN ID. VLAN filtering is available with the
+ * VIRTIO_NET_F_CTRL_VLAN feature bit.
+ */
+#define VIRTIO_NET_CTRL_VLAN 2
+ #define VIRTIO_NET_CTRL_VLAN_ADD 0
+ #define VIRTIO_NET_CTRL_VLAN_DEL 1
+
+
+#pragma pack (pop)
+
+#endif
diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Common.c
b/drivers/network/dd/netkvm/Common/ParaNdis-Common.c
new file mode 100644
index 00000000000..ebb0c04b981
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/ParaNdis-Common.c
@@ -0,0 +1,3017 @@
+/*
+ * This file contains NDIS driver procedures, common for NDIS5 and NDIS6
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include "ndis56common.h"
+
+#ifdef WPP_EVENT_TRACING
+#include "ParaNdis-Common.tmh"
+#endif
+
+static void ReuseReceiveBufferRegular(PARANDIS_ADAPTER *pContext, pIONetDescriptor
pBuffersDescriptor);
+static void ReuseReceiveBufferPowerOff(PARANDIS_ADAPTER *pContext, pIONetDescriptor
pBuffersDescriptor);
+
+//#define ROUNDSIZE(sz) ((sz + 15) & ~15)
+#define MAX_VLAN_ID 4095
+
+#if 0
+void FORCEINLINE DebugDumpPacket(LPCSTR prefix, PVOID header, int level)
+{
+ PUCHAR peth = (PUCHAR)header;
+ DPrintf(level, ("[%s] %02X%02X%02X%02X%02X%02X =>
%02X%02X%02X%02X%02X%02X", prefix,
+ peth[6], peth[7], peth[8], peth[9], peth[10], peth[11],
+ peth[0], peth[1], peth[2], peth[3], peth[4], peth[5]));
+}
+#else
+void FORCEINLINE DebugDumpPacket(LPCSTR prefix, PVOID header, int level)
+{
+}
+#endif
+
+
+
+/**********************************************************
+Validates MAC address
+Valid MAC address is not broadcast, not multicast, not empty
+if bLocal is set, it must be LOCAL
+if not, is must be non-local or local
+Parameters:
+ PUCHAR pcMacAddress - MAC address to validate
+ BOOLEAN bLocal - TRUE, if we validate locally administered address
+Return value:
+ TRUE if valid
+***********************************************************/
+BOOLEAN ParaNdis_ValidateMacAddress(PUCHAR pcMacAddress, BOOLEAN bLocal)
+{
+ BOOLEAN bLA = FALSE, bEmpty, bBroadcast, bMulticast = FALSE;
+ bBroadcast = ETH_IS_BROADCAST(pcMacAddress);
+ bLA = !bBroadcast && ETH_IS_LOCALLY_ADMINISTERED(pcMacAddress);
+ bMulticast = !bBroadcast && ETH_IS_MULTICAST(pcMacAddress);
+ bEmpty = ETH_IS_EMPTY(pcMacAddress);
+ return !bBroadcast && !bEmpty && !bMulticast && (!bLocal ||
bLA);
+}
+
+static eInspectedPacketType QueryPacketType(PVOID data)
+{
+ if (ETH_IS_BROADCAST(data))
+ return iptBroadcast;
+ if (ETH_IS_MULTICAST(data))
+ return iptMulticast;
+ return iptUnicast;
+}
+
+typedef struct _tagConfigurationEntry
+{
+ const char *Name;
+ ULONG ulValue;
+ ULONG ulMinimal;
+ ULONG ulMaximal;
+}tConfigurationEntry;
+
+typedef struct _tagConfigurationEntries
+{
+ tConfigurationEntry isPromiscuous;
+ tConfigurationEntry PrioritySupport;
+ tConfigurationEntry ConnectRate;
+ tConfigurationEntry isLogEnabled;
+ tConfigurationEntry debugLevel;
+ tConfigurationEntry connectTimer;
+ tConfigurationEntry dpcChecker;
+ tConfigurationEntry TxCapacity;
+ tConfigurationEntry RxCapacity;
+ tConfigurationEntry InterruptRecovery;
+ tConfigurationEntry LogStatistics;
+ tConfigurationEntry PacketFiltering;
+ tConfigurationEntry ScatterGather;
+ tConfigurationEntry BatchReceive;
+ tConfigurationEntry OffloadTxChecksum;
+ tConfigurationEntry OffloadTxLSO;
+ tConfigurationEntry OffloadRxCS;
+ tConfigurationEntry OffloadGuestCS;
+ tConfigurationEntry UseSwTxChecksum;
+ tConfigurationEntry IPPacketsCheck;
+ tConfigurationEntry stdIpcsV4;
+ tConfigurationEntry stdTcpcsV4;
+ tConfigurationEntry stdTcpcsV6;
+ tConfigurationEntry stdUdpcsV4;
+ tConfigurationEntry stdUdpcsV6;
+ tConfigurationEntry stdLsoV1;
+ tConfigurationEntry stdLsoV2ip4;
+ tConfigurationEntry stdLsoV2ip6;
+ tConfigurationEntry PriorityVlanTagging;
+ tConfigurationEntry VlanId;
+ tConfigurationEntry UseMergeableBuffers;
+ tConfigurationEntry MTU;
+ tConfigurationEntry NumberOfHandledRXPackersInDPC;
+ tConfigurationEntry Indirect;
+}tConfigurationEntries;
+
+static const tConfigurationEntries defaultConfiguration =
+{
+ { "Promiscuous", 0, 0, 1 },
+ { "Priority", 0, 0, 1 },
+ { "ConnectRate", 100,10,10000 },
+ { "DoLog", 1, 0, 1 },
+ { "DebugLevel", 2, 0, 8 },
+ { "ConnectTimer", 0, 0, 300000 },
+ { "DpcCheck", 0, 0, 2 },
+ { "TxCapacity", 1024, 16, 1024 },
+ { "RxCapacity", 256, 32, 1024 },
+ { "InterruptRecovery", 0, 0, 1},
+ { "LogStatistics", 0, 0, 10000},
+ { "PacketFilter", 1, 0, 1},
+ { "Gather", 1, 0, 1},
+ { "BatchReceive", 1, 0, 1},
+ { "Offload.TxChecksum", 0, 0, 31},
+ { "Offload.TxLSO", 0, 0, 2},
+ { "Offload.RxCS", 0, 0, 31},
+ { "Offload.GuestCS", 0, 0, 1},
+ { "UseSwTxChecksum", 0, 0, 1 },
+ { "IPPacketsCheck", 0, 0, 3 },
+ { "*IPChecksumOffloadIPv4", 3, 0, 3 },
+ { "*TCPChecksumOffloadIPv4",3, 0, 3 },
+ { "*TCPChecksumOffloadIPv6",3, 0, 3 },
+ { "*UDPChecksumOffloadIPv4",3, 0, 3 },
+ { "*UDPChecksumOffloadIPv6",3, 0, 3 },
+ { "*LsoV1IPv4", 1, 0, 1 },
+ { "*LsoV2IPv4", 1, 0, 1 },
+ { "*LsoV2IPv6", 1, 0, 1 },
+ { "*PriorityVLANTag", 3, 0, 3},
+ { "VlanId", 0, 0, MAX_VLAN_ID},
+ { "MergeableBuf", 1, 0, 1},
+ { "MTU", 1500, 500, 65500},
+ { "NumberOfHandledRXPackersInDPC", MAX_RX_LOOPS, 1, 10000},
+ { "Indirect", 0, 0, 2},
+};
+
+static void ParaNdis_ResetVirtIONetDevice(PARANDIS_ADAPTER *pContext)
+{
+ virtio_device_reset(&pContext->IODevice);
+ DPrintf(0, ("[%s] Done", __FUNCTION__));
+ /* reset all the features in the device */
+ pContext->ulCurrentVlansFilterSet = 0;
+ pContext->ullGuestFeatures = 0;
+#ifdef VIRTIO_RESET_VERIFY
+ if (1)
+ {
+ u8 devStatus;
+ devStatus = virtio_get_status(&pContext->IODevice);
+ if (devStatus)
+ {
+ DPrintf(0, ("[%s] Device status is still %02X", __FUNCTION__,
(ULONG)devStatus));
+ virtio_device_reset(&pContext->IODevice);
+ devStatus = virtio_get_status(&pContext->IODevice);
+ DPrintf(0, ("[%s] Device status on retry %02X", __FUNCTION__,
(ULONG)devStatus));
+ }
+ }
+#endif
+}
+
+/**********************************************************
+Gets integer value for specifies in pEntry->Name name
+Parameters:
+ NDIS_HANDLE cfg previously open configuration
+ tConfigurationEntry *pEntry - Entry to fill value in
+***********************************************************/
+static void GetConfigurationEntry(NDIS_HANDLE cfg, tConfigurationEntry *pEntry)
+{
+ NDIS_STATUS status;
+ const char *statusName;
+ NDIS_STRING name = {0};
+ PNDIS_CONFIGURATION_PARAMETER pParam = NULL;
+ NDIS_PARAMETER_TYPE ParameterType = NdisParameterInteger;
+ NdisInitializeString(&name, (PUCHAR)pEntry->Name);
+ NdisReadConfiguration(
+ &status,
+ &pParam,
+ cfg,
+ &name,
+ ParameterType);
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ ULONG ulValue = pParam->ParameterData.IntegerData;
+ if (ulValue >= pEntry->ulMinimal && ulValue <=
pEntry->ulMaximal)
+ {
+ pEntry->ulValue = ulValue;
+ statusName = "value";
+ }
+ else
+ {
+ statusName = "out of range";
+ }
+ }
+ else
+ {
+ statusName = "nothing";
+ }
+ DPrintf(2, ("[%s] %s read for %s - 0x%x",
+ __FUNCTION__,
+ statusName,
+ pEntry->Name,
+ pEntry->ulValue));
+ if (name.Buffer) NdisFreeString(name);
+}
+
+static void DisableLSOv4Permanently(PARANDIS_ADAPTER *pContext, LPCSTR procname, LPCSTR
reason)
+{
+ if (pContext->Offload.flagsValue & osbT4Lso)
+ {
+ DPrintf(0, ("[%s] Warning: %s", procname, reason));
+ pContext->Offload.flagsValue &= ~osbT4Lso;
+ ParaNdis_ResetOffloadSettings(pContext, NULL, NULL);
+ }
+}
+
+static void DisableLSOv6Permanently(PARANDIS_ADAPTER *pContext, LPCSTR procname, LPCSTR
reason)
+{
+ if (pContext->Offload.flagsValue & osbT6Lso)
+ {
+ DPrintf(0, ("[%s] Warning: %s", procname, reason));
+ pContext->Offload.flagsValue &= ~osbT6Lso;
+ ParaNdis_ResetOffloadSettings(pContext, NULL, NULL);
+ }
+}
+
+static void DisableBothLSOPermanently(PARANDIS_ADAPTER *pContext, LPCSTR procname, LPCSTR
reason)
+{
+ if (pContext->Offload.flagsValue & (osbT4Lso | osbT6Lso))
+ {
+ DPrintf(0, ("[%s] Warning: %s", procname, reason));
+ pContext->Offload.flagsValue &= ~(osbT6Lso | osbT4Lso);
+ ParaNdis_ResetOffloadSettings(pContext, NULL, NULL);
+ }
+}
+
+/**********************************************************
+Loads NIC parameters from adapter registry key
+Parameters:
+ context
+ PUCHAR *ppNewMACAddress - pointer to hold MAC address if configured from host
+***********************************************************/
+static void ReadNicConfiguration(PARANDIS_ADAPTER *pContext, PUCHAR *ppNewMACAddress)
+{
+ NDIS_HANDLE cfg;
+ tConfigurationEntries *pConfiguration = ParaNdis_AllocateMemory(pContext,
sizeof(tConfigurationEntries));
+ if (pConfiguration)
+ {
+ *pConfiguration = defaultConfiguration;
+ cfg = ParaNdis_OpenNICConfiguration(pContext);
+ if (cfg)
+ {
+ GetConfigurationEntry(cfg, &pConfiguration->isLogEnabled);
+ GetConfigurationEntry(cfg, &pConfiguration->debugLevel);
+ GetConfigurationEntry(cfg, &pConfiguration->ConnectRate);
+ GetConfigurationEntry(cfg, &pConfiguration->PrioritySupport);
+ GetConfigurationEntry(cfg, &pConfiguration->isPromiscuous);
+ GetConfigurationEntry(cfg, &pConfiguration->TxCapacity);
+ GetConfigurationEntry(cfg, &pConfiguration->RxCapacity);
+ GetConfigurationEntry(cfg, &pConfiguration->connectTimer);
+ GetConfigurationEntry(cfg, &pConfiguration->dpcChecker);
+ GetConfigurationEntry(cfg, &pConfiguration->InterruptRecovery);
+ GetConfigurationEntry(cfg, &pConfiguration->LogStatistics);
+ GetConfigurationEntry(cfg, &pConfiguration->PacketFiltering);
+ GetConfigurationEntry(cfg, &pConfiguration->ScatterGather);
+ GetConfigurationEntry(cfg, &pConfiguration->BatchReceive);
+ GetConfigurationEntry(cfg, &pConfiguration->OffloadTxChecksum);
+ GetConfigurationEntry(cfg, &pConfiguration->OffloadTxLSO);
+ GetConfigurationEntry(cfg, &pConfiguration->OffloadRxCS);
+ GetConfigurationEntry(cfg, &pConfiguration->OffloadGuestCS);
+ GetConfigurationEntry(cfg, &pConfiguration->UseSwTxChecksum);
+ GetConfigurationEntry(cfg, &pConfiguration->IPPacketsCheck);
+ GetConfigurationEntry(cfg, &pConfiguration->stdIpcsV4);
+ GetConfigurationEntry(cfg, &pConfiguration->stdTcpcsV4);
+ GetConfigurationEntry(cfg, &pConfiguration->stdTcpcsV6);
+ GetConfigurationEntry(cfg, &pConfiguration->stdUdpcsV4);
+ GetConfigurationEntry(cfg, &pConfiguration->stdUdpcsV6);
+ GetConfigurationEntry(cfg, &pConfiguration->stdLsoV1);
+ GetConfigurationEntry(cfg, &pConfiguration->stdLsoV2ip4);
+ GetConfigurationEntry(cfg, &pConfiguration->stdLsoV2ip6);
+ GetConfigurationEntry(cfg, &pConfiguration->PriorityVlanTagging);
+ GetConfigurationEntry(cfg, &pConfiguration->VlanId);
+ GetConfigurationEntry(cfg, &pConfiguration->UseMergeableBuffers);
+ GetConfigurationEntry(cfg, &pConfiguration->MTU);
+ GetConfigurationEntry(cfg,
&pConfiguration->NumberOfHandledRXPackersInDPC);
+ GetConfigurationEntry(cfg, &pConfiguration->Indirect);
+
+ #if !defined(WPP_EVENT_TRACING)
+ bDebugPrint = pConfiguration->isLogEnabled.ulValue;
+ nDebugLevel = pConfiguration->debugLevel.ulValue;
+ #endif
+ // ignoring promiscuous setting, nothing to do with it
+ pContext->maxFreeTxDescriptors = pConfiguration->TxCapacity.ulValue;
+ pContext->NetMaxReceiveBuffers = pConfiguration->RxCapacity.ulValue;
+ pContext->ulMilliesToConnect = pConfiguration->connectTimer.ulValue;
+ pContext->nEnableDPCChecker = pConfiguration->dpcChecker.ulValue;
+ pContext->bDoInterruptRecovery =
pConfiguration->InterruptRecovery.ulValue != 0;
+ pContext->Limits.nPrintDiagnostic =
pConfiguration->LogStatistics.ulValue;
+ pContext->uNumberOfHandledRXPacketsInDPC =
pConfiguration->NumberOfHandledRXPackersInDPC.ulValue;
+ pContext->bDoSupportPriority = pConfiguration->PrioritySupport.ulValue
!= 0;
+ pContext->ulFormalLinkSpeed = pConfiguration->ConnectRate.ulValue;
+ pContext->ulFormalLinkSpeed *= 1000000;
+ pContext->bDoHwPacketFiltering =
pConfiguration->PacketFiltering.ulValue != 0;
+ pContext->bUseScatterGather = pConfiguration->ScatterGather.ulValue !=
0;
+ pContext->bBatchReceive = pConfiguration->BatchReceive.ulValue !=
0;
+ pContext->bDoHardwareChecksum = pConfiguration->UseSwTxChecksum.ulValue
== 0;
+ pContext->bDoGuestChecksumOnReceive =
pConfiguration->OffloadGuestCS.ulValue != 0;
+ pContext->bDoIPCheckTx = pConfiguration->IPPacketsCheck.ulValue &
1;
+ pContext->bDoIPCheckRx = pConfiguration->IPPacketsCheck.ulValue &
2;
+ pContext->Offload.flagsValue = 0;
+ // TX caps: 1 - TCP, 2 - UDP, 4 - IP, 8 - TCPv6, 16 - UDPv6
+ if (pConfiguration->OffloadTxChecksum.ulValue & 1)
pContext->Offload.flagsValue |= osbT4TcpChecksum | osbT4TcpOptionsChecksum;
+ if (pConfiguration->OffloadTxChecksum.ulValue & 2)
pContext->Offload.flagsValue |= osbT4UdpChecksum;
+ if (pConfiguration->OffloadTxChecksum.ulValue & 4)
pContext->Offload.flagsValue |= osbT4IpChecksum | osbT4IpOptionsChecksum;
+ if (pConfiguration->OffloadTxChecksum.ulValue & 8)
pContext->Offload.flagsValue |= osbT6TcpChecksum | osbT6TcpOptionsChecksum;
+ if (pConfiguration->OffloadTxChecksum.ulValue & 16)
pContext->Offload.flagsValue |= osbT6UdpChecksum;
+ if (pConfiguration->OffloadTxLSO.ulValue) pContext->Offload.flagsValue
|= osbT4Lso | osbT4LsoIp | osbT4LsoTcp;
+ if (pConfiguration->OffloadTxLSO.ulValue > 1)
pContext->Offload.flagsValue |= osbT6Lso | osbT6LsoTcpOptions;
+ // RX caps: 1 - TCP, 2 - UDP, 4 - IP, 8 - TCPv6, 16 - UDPv6
+ if (pConfiguration->OffloadRxCS.ulValue & 1)
pContext->Offload.flagsValue |= osbT4RxTCPChecksum | osbT4RxTCPOptionsChecksum;
+ if (pConfiguration->OffloadRxCS.ulValue & 2)
pContext->Offload.flagsValue |= osbT4RxUDPChecksum;
+ if (pConfiguration->OffloadRxCS.ulValue & 4)
pContext->Offload.flagsValue |= osbT4RxIPChecksum | osbT4RxIPOptionsChecksum;
+ if (pConfiguration->OffloadRxCS.ulValue & 8)
pContext->Offload.flagsValue |= osbT6RxTCPChecksum | osbT6RxTCPOptionsChecksum;
+ if (pConfiguration->OffloadRxCS.ulValue & 16)
pContext->Offload.flagsValue |= osbT6RxUDPChecksum;
+ /* full packet size that can be configured as GSO for VIRTIO is short */
+ /* NDIS test fails sometimes fails on segments 50-60K */
+ pContext->Offload.maxPacketSize = PARANDIS_MAX_LSO_SIZE;
+ pContext->InitialOffloadParameters.IPv4Checksum =
(UCHAR)pConfiguration->stdIpcsV4.ulValue;
+ pContext->InitialOffloadParameters.TCPIPv4Checksum =
(UCHAR)pConfiguration->stdTcpcsV4.ulValue;
+ pContext->InitialOffloadParameters.TCPIPv6Checksum =
(UCHAR)pConfiguration->stdTcpcsV6.ulValue;
+ pContext->InitialOffloadParameters.UDPIPv4Checksum =
(UCHAR)pConfiguration->stdUdpcsV4.ulValue;
+ pContext->InitialOffloadParameters.UDPIPv6Checksum =
(UCHAR)pConfiguration->stdUdpcsV6.ulValue;
+ pContext->InitialOffloadParameters.LsoV1 =
(UCHAR)pConfiguration->stdLsoV1.ulValue;
+ pContext->InitialOffloadParameters.LsoV2IPv4 =
(UCHAR)pConfiguration->stdLsoV2ip4.ulValue;
+ pContext->InitialOffloadParameters.LsoV2IPv6 =
(UCHAR)pConfiguration->stdLsoV2ip6.ulValue;
+ pContext->ulPriorityVlanSetting =
pConfiguration->PriorityVlanTagging.ulValue;
+ pContext->VlanId = pConfiguration->VlanId.ulValue & 0xfff;
+ pContext->bUseMergedBuffers =
pConfiguration->UseMergeableBuffers.ulValue != 0;
+ pContext->MaxPacketSize.nMaxDataSize = pConfiguration->MTU.ulValue;
+ pContext->bUseIndirect = pConfiguration->Indirect.ulValue != 0;
+ if (!pContext->bDoSupportPriority)
+ pContext->ulPriorityVlanSetting = 0;
+ // if Vlan not supported
+ if (!IsVlanSupported(pContext))
+ pContext->VlanId = 0;
+ if (1)
+ {
+ NDIS_STATUS status;
+ PVOID p;
+ UINT len = 0;
+ NdisReadNetworkAddress(&status, &p, &len, cfg);
+ if (status == NDIS_STATUS_SUCCESS && len ==
sizeof(pContext->CurrentMacAddress))
+ {
+ *ppNewMACAddress = ParaNdis_AllocateMemory(pContext,
sizeof(pContext->CurrentMacAddress));
+ if (*ppNewMACAddress)
+ {
+ NdisMoveMemory(*ppNewMACAddress, p, len);
+ }
+ else
+ {
+ DPrintf(0, ("[%s] MAC address present, but some problem
also...", __FUNCTION__));
+ }
+ }
+ else if (len && len != sizeof(pContext->CurrentMacAddress))
+ {
+ DPrintf(0, ("[%s] MAC address has wrong length of %d",
__FUNCTION__, len));
+ }
+ else
+ {
+ DPrintf(4, ("[%s] Nothing read for MAC, error %X",
__FUNCTION__, status));
+ }
+ }
+ NdisCloseConfiguration(cfg);
+ }
+ NdisFreeMemory(pConfiguration, 0, 0);
+ }
+}
+
+void ParaNdis_ResetOffloadSettings(PARANDIS_ADAPTER *pContext, tOffloadSettingsFlags
*pDest, PULONG from)
+{
+ if (!pDest) pDest = &pContext->Offload.flags;
+ if (!from) from = &pContext->Offload.flagsValue;
+
+ pDest->fTxIPChecksum = !!(*from & osbT4IpChecksum);
+ pDest->fTxTCPChecksum = !!(*from & osbT4TcpChecksum);
+ pDest->fTxUDPChecksum = !!(*from & osbT4UdpChecksum);
+ pDest->fTxTCPOptions = !!(*from & osbT4TcpOptionsChecksum);
+ pDest->fTxIPOptions = !!(*from & osbT4IpOptionsChecksum);
+
+ pDest->fTxLso = !!(*from & osbT4Lso);
+ pDest->fTxLsoIP = !!(*from & osbT4LsoIp);
+ pDest->fTxLsoTCP = !!(*from & osbT4LsoTcp);
+
+ pDest->fRxIPChecksum = !!(*from & osbT4RxIPChecksum);
+ pDest->fRxIPOptions = !!(*from & osbT4RxIPOptionsChecksum);
+ pDest->fRxTCPChecksum = !!(*from & osbT4RxTCPChecksum);
+ pDest->fRxTCPOptions = !!(*from & osbT4RxTCPOptionsChecksum);
+ pDest->fRxUDPChecksum = !!(*from & osbT4RxUDPChecksum);
+
+ pDest->fTxTCPv6Checksum = !!(*from & osbT6TcpChecksum);
+ pDest->fTxTCPv6Options = !!(*from & osbT6TcpOptionsChecksum);
+ pDest->fTxUDPv6Checksum = !!(*from & osbT6UdpChecksum);
+ pDest->fTxIPv6Ext = !!(*from & osbT6IpExtChecksum);
+
+ pDest->fTxLsov6 = !!(*from & osbT6Lso);
+ pDest->fTxLsov6IP = !!(*from & osbT6LsoIpExt);
+ pDest->fTxLsov6TCP = !!(*from & osbT6LsoTcpOptions);
+
+ pDest->fRxTCPv6Checksum = !!(*from & osbT6RxTCPChecksum);
+ pDest->fRxTCPv6Options = !!(*from & osbT6RxTCPOptionsChecksum);
+ pDest->fRxUDPv6Checksum = !!(*from & osbT6RxUDPChecksum);
+ pDest->fRxIPv6Ext = !!(*from & osbT6RxIpExtChecksum);
+}
+
+/**********************************************************
+Enumerates adapter resources and fills the structure holding them
+Verifies that IO assigned and has correct size
+Verifies that interrupt assigned
+Parameters:
+ PNDIS_RESOURCE_LIST RList - list of resources, received from NDIS
+ tAdapterResources *pResources - structure to fill
+Return value:
+ TRUE if everything is OK
+***********************************************************/
+static BOOLEAN GetAdapterResources(NDIS_HANDLE MiniportHandle, PNDIS_RESOURCE_LIST RList,
tAdapterResources *pResources)
+{
+ UINT i;
+ int read, bar = -1;
+ PCI_COMMON_HEADER pci_config;
+ NdisZeroMemory(pResources, sizeof(*pResources));
+
+ // read the PCI config space header
+ read = NdisReadPciSlotInformation(
+ MiniportHandle,
+ 0 /* SlotNumber, reserved */,
+ 0 /* Offset */,
+ &pci_config,
+ sizeof(pci_config));
+ if (read != sizeof(pci_config)) {
+ return FALSE;
+ }
+
+ for (i = 0; i < RList->Count; ++i)
+ {
+ ULONG type = RList->PartialDescriptors[i].Type;
+ if (type == CmResourceTypePort)
+ {
+ PHYSICAL_ADDRESS Start = RList->PartialDescriptors[i].u.Port.Start;
+ ULONG len = RList->PartialDescriptors[i].u.Port.Length;
+ DPrintf(0, ("Found IO ports at %08lX(%d)", Start.LowPart, len));
+ bar = virtio_get_bar_index(&pci_config, Start);
+ if (bar < 0) {
+ break;
+ }
+ pResources->PciBars[bar].BasePA = Start;
+ pResources->PciBars[bar].uLength = len;
+ pResources->PciBars[bar].bPortSpace = TRUE;
+ }
+ else if (type == CmResourceTypeMemory)
+ {
+ PHYSICAL_ADDRESS Start = RList->PartialDescriptors[i].u.Memory.Start;
+ ULONG len = RList->PartialDescriptors[i].u.Memory.Length;
+ DPrintf(0, ("Found IO memory at %08I64X(%d)", Start.QuadPart,
len));
+ bar = virtio_get_bar_index(&pci_config, Start);
+ if (bar < 0) {
+ break;
+ }
+ pResources->PciBars[bar].BasePA = Start;
+ pResources->PciBars[bar].uLength = len;
+ pResources->PciBars[bar].bPortSpace = FALSE;
+ }
+ else if (type == CmResourceTypeInterrupt)
+ {
+ pResources->Vector = RList->PartialDescriptors[i].u.Interrupt.Vector;
+ pResources->Level = RList->PartialDescriptors[i].u.Interrupt.Level;
+ pResources->Affinity =
RList->PartialDescriptors[i].u.Interrupt.Affinity;
+ pResources->InterruptFlags = RList->PartialDescriptors[i].Flags;
+ DPrintf(0, ("Found Interrupt vector %d, level %d, affinity %X, flags
%X",
+ pResources->Vector, pResources->Level,
(ULONG)pResources->Affinity, pResources->InterruptFlags));
+ }
+ }
+ return bar >= 0 && pResources->Vector;
+}
+
+static void DumpVirtIOFeatures(PARANDIS_ADAPTER *pContext)
+{
+ const struct { ULONG bitmask; const PCHAR Name; } Features[] =
+ {
+
+ {VIRTIO_NET_F_CSUM, "VIRTIO_NET_F_CSUM" },
+ {VIRTIO_NET_F_GUEST_CSUM, "VIRTIO_NET_F_GUEST_CSUM" },
+ {VIRTIO_NET_F_MAC, "VIRTIO_NET_F_MAC" },
+ {VIRTIO_NET_F_GSO, "VIRTIO_NET_F_GSO" },
+ {VIRTIO_NET_F_GUEST_TSO4, "VIRTIO_NET_F_GUEST_TSO4"},
+ {VIRTIO_NET_F_GUEST_TSO6, "VIRTIO_NET_F_GUEST_TSO6"},
+ {VIRTIO_NET_F_GUEST_ECN, "VIRTIO_NET_F_GUEST_ECN"},
+ {VIRTIO_NET_F_GUEST_UFO, "VIRTIO_NET_F_GUEST_UFO"},
+ {VIRTIO_NET_F_HOST_TSO4, "VIRTIO_NET_F_HOST_TSO4"},
+ {VIRTIO_NET_F_HOST_TSO6, "VIRTIO_NET_F_HOST_TSO6"},
+ {VIRTIO_NET_F_HOST_ECN, "VIRTIO_NET_F_HOST_ECN"},
+ {VIRTIO_NET_F_HOST_UFO, "VIRTIO_NET_F_HOST_UFO"},
+ {VIRTIO_NET_F_MRG_RXBUF, "VIRTIO_NET_F_MRG_RXBUF"},
+ {VIRTIO_NET_F_STATUS, "VIRTIO_NET_F_STATUS"},
+ {VIRTIO_NET_F_CTRL_VQ, "VIRTIO_NET_F_CTRL_VQ"},
+ {VIRTIO_NET_F_CTRL_RX, "VIRTIO_NET_F_CTRL_RX"},
+ {VIRTIO_NET_F_CTRL_VLAN, "VIRTIO_NET_F_CTRL_VLAN"},
+ {VIRTIO_NET_F_CTRL_RX_EXTRA, "VIRTIO_NET_F_CTRL_RX_EXTRA"},
+ {VIRTIO_RING_F_INDIRECT_DESC, "VIRTIO_RING_F_INDIRECT_DESC"},
+ {VIRTIO_F_VERSION_1, "VIRTIO_F_VERSION_1" },
+ {VIRTIO_F_ANY_LAYOUT, "VIRTIO_F_ANY_LAYOUT" },
+ };
+ UINT i;
+ for (i = 0; i < sizeof(Features)/sizeof(Features[0]); ++i)
+ {
+ if (VirtIODeviceGetHostFeature(pContext, Features[i].bitmask))
+ {
+ DPrintf(0, ("VirtIO Host Feature %s", Features[i].Name));
+ }
+ }
+}
+
+/**********************************************************
+ Only for test. Prints out if the interrupt line is ON
+Parameters:
+Return value:
+***********************************************************/
+static void JustForCheckClearInterrupt(PARANDIS_ADAPTER *pContext, const char *Label)
+{
+ if (pContext->bEnableInterruptChecking)
+ {
+ ULONG ulActive;
+ ulActive = virtio_read_isr_status(&pContext->IODevice);
+ if (ulActive)
+ {
+ DPrintf(0,("WARNING: Interrupt Line %d(%s)!", ulActive, Label));
+ }
+ }
+}
+
+/**********************************************************
+Prints out statistics
+***********************************************************/
+static void PrintStatistics(PARANDIS_ADAPTER *pContext)
+{
+ ULONG64 totalTxFrames =
+ pContext->Statistics.ifHCOutBroadcastPkts +
+ pContext->Statistics.ifHCOutMulticastPkts +
+ pContext->Statistics.ifHCOutUcastPkts;
+ ULONG64 totalRxFrames =
+ pContext->Statistics.ifHCInBroadcastPkts +
+ pContext->Statistics.ifHCInMulticastPkts +
+ pContext->Statistics.ifHCInUcastPkts;
+
+ DPrintf(0, ("[Diag!%X] RX buffers at VIRTIO %d of %d",
+ pContext->CurrentMacAddress[5],
+ pContext->NetNofReceiveBuffers,
+ pContext->NetMaxReceiveBuffers));
+ DPrintf(0, ("[Diag!] TX desc available %d/%d, buf %d/min. %d",
+ pContext->nofFreeTxDescriptors,
+ pContext->maxFreeTxDescriptors,
+ pContext->nofFreeHardwareBuffers,
+ pContext->minFreeHardwareBuffers));
+ pContext->minFreeHardwareBuffers = pContext->nofFreeHardwareBuffers;
+ if (pContext->NetTxPacketsToReturn)
+ {
+ DPrintf(0, ("[Diag!] TX packets to return %d",
pContext->NetTxPacketsToReturn));
+ }
+ DPrintf(0, ("[Diag!] Bytes transmitted %I64u, received %I64u",
+ pContext->Statistics.ifHCOutOctets,
+ pContext->Statistics.ifHCInOctets));
+ DPrintf(0, ("[Diag!] Tx frames %I64u, CSO %d, LSO %d, indirect %d",
+ totalTxFrames,
+ pContext->extraStatistics.framesCSOffload,
+ pContext->extraStatistics.framesLSO,
+ pContext->extraStatistics.framesIndirect));
+ DPrintf(0, ("[Diag!] Rx frames %I64u, Rx.Pri %d, RxHwCS.OK %d, FiltOut
%d",
+ totalRxFrames, pContext->extraStatistics.framesRxPriority,
+ pContext->extraStatistics.framesRxCSHwOK,
pContext->extraStatistics.framesFilteredOut));
+ if (pContext->extraStatistics.framesRxCSHwMissedBad ||
pContext->extraStatistics.framesRxCSHwMissedGood)
+ {
+ DPrintf(0, ("[Diag!] RxHwCS mistakes: missed bad %d, missed good %d",
+ pContext->extraStatistics.framesRxCSHwMissedBad,
pContext->extraStatistics.framesRxCSHwMissedGood));
+ }
+}
+
+static NDIS_STATUS NTStatusToNdisStatus(NTSTATUS nt_status) {
+ switch (nt_status) {
+ case STATUS_SUCCESS:
+ return NDIS_STATUS_SUCCESS;
+ case STATUS_NOT_FOUND:
+ case STATUS_DEVICE_NOT_CONNECTED:
+ return NDIS_STATUS_ADAPTER_NOT_FOUND;
+ case STATUS_INSUFFICIENT_RESOURCES:
+ return NDIS_STATUS_RESOURCES;
+ case STATUS_INVALID_PARAMETER:
+ return NDIS_STATUS_INVALID_DEVICE_REQUEST;
+ default:
+ return NDIS_STATUS_FAILURE;
+ }
+}
+
+static NDIS_STATUS FinalizeFeatures(PARANDIS_ADAPTER *pContext)
+{
+ NTSTATUS nt_status = virtio_set_features(&pContext->IODevice,
pContext->ullGuestFeatures);
+ if (!NT_SUCCESS(nt_status)) {
+ DPrintf(0, ("[%s] virtio_set_features failed with %x\n", __FUNCTION__,
nt_status));
+ }
+ return NTStatusToNdisStatus(nt_status);
+}
+
+/**********************************************************
+Initializes the context structure
+Major variables, received from NDIS on initialization, must be be set before this call
+(for ex. pContext->MiniportHandle)
+
+If this procedure fails, no need to call
+ ParaNdis_CleanupContext
+
+
+Parameters:
+Return value:
+ SUCCESS, if resources are OK
+ NDIS_STATUS_RESOURCE_CONFLICT if not
+***********************************************************/
+NDIS_STATUS ParaNdis_InitializeContext(
+ PARANDIS_ADAPTER *pContext,
+ PNDIS_RESOURCE_LIST pResourceList)
+{
+ NDIS_STATUS status = NDIS_STATUS_SUCCESS;
+ PUCHAR pNewMacAddress = NULL;
+ USHORT linkStatus = 0;
+ NTSTATUS nt_status;
+
+ DEBUG_ENTRY(0);
+ /* read first PCI IO bar*/
+ //ulIOAddress = ReadPCIConfiguration(miniportAdapterHandle, 0x10);
+ /* check this is IO and assigned */
+ ReadNicConfiguration(pContext, &pNewMacAddress);
+ if (pNewMacAddress)
+ {
+ if (ParaNdis_ValidateMacAddress(pNewMacAddress, TRUE))
+ {
+ DPrintf(0, ("[%s] WARNING: MAC address reloaded", __FUNCTION__));
+ NdisMoveMemory(pContext->CurrentMacAddress, pNewMacAddress,
sizeof(pContext->CurrentMacAddress));
+ }
+ else
+ {
+ DPrintf(0, ("[%s] WARNING: Invalid MAC address ignored",
__FUNCTION__));
+ }
+ NdisFreeMemory(pNewMacAddress, 0, 0);
+ }
+
+ pContext->MaxPacketSize.nMaxFullSizeOS = pContext->MaxPacketSize.nMaxDataSize +
ETH_HEADER_SIZE;
+ pContext->MaxPacketSize.nMaxFullSizeHwTx =
pContext->MaxPacketSize.nMaxFullSizeOS;
+ pContext->MaxPacketSize.nMaxFullSizeHwRx =
pContext->MaxPacketSize.nMaxFullSizeOS + ETH_PRIORITY_HEADER_SIZE;
+ if (pContext->ulPriorityVlanSetting)
+ pContext->MaxPacketSize.nMaxFullSizeHwTx =
pContext->MaxPacketSize.nMaxFullSizeHwRx;
+
+ if (GetAdapterResources(pContext->MiniportHandle, pResourceList,
&pContext->AdapterResources))
+ {
+ if (pContext->AdapterResources.InterruptFlags &
CM_RESOURCE_INTERRUPT_MESSAGE)
+ {
+ DPrintf(0, ("[%s] Message interrupt assigned", __FUNCTION__));
+ pContext->bUsingMSIX = TRUE;
+ }
+
+ nt_status = virtio_device_initialize(
+ &pContext->IODevice,
+ &ParaNdisSystemOps,
+ pContext,
+ pContext->bUsingMSIX);
+ if (!NT_SUCCESS(nt_status)) {
+ DPrintf(0, ("[%s] virtio_device_initialize failed with %x\n",
__FUNCTION__, nt_status));
+ status = NTStatusToNdisStatus(nt_status);
+ DEBUG_EXIT_STATUS(0, status);
+ return status;
+ }
+
+ pContext->bIODeviceInitialized = TRUE;
+ JustForCheckClearInterrupt(pContext, "init 0");
+ ParaNdis_ResetVirtIONetDevice(pContext);
+ JustForCheckClearInterrupt(pContext, "init 1");
+ virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_ACKNOWLEDGE);
+ JustForCheckClearInterrupt(pContext, "init 2");
+ virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER);
+ pContext->ullHostFeatures = virtio_get_features(&pContext->IODevice);
+ DumpVirtIOFeatures(pContext);
+ JustForCheckClearInterrupt(pContext, "init 3");
+ pContext->bLinkDetectSupported = 0 != VirtIODeviceGetHostFeature(pContext,
VIRTIO_NET_F_STATUS);
+
+ if(pContext->bLinkDetectSupported) {
+ virtio_get_config(&pContext->IODevice,
sizeof(pContext->CurrentMacAddress), &linkStatus, sizeof(linkStatus));
+ pContext->bConnected = (linkStatus & VIRTIO_NET_S_LINK_UP) != 0;
+ DPrintf(0, ("[%s] Link status on driver startup: %d", __FUNCTION__,
pContext->bConnected));
+ }
+
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_VERSION_1))
+ {
+ // virtio 1.0 always uses the extended header
+ pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_ext);
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_VERSION_1);
+ }
+ else
+ {
+ pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_basic);
+ }
+
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_ANY_LAYOUT))
+ {
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_ANY_LAYOUT);
+ }
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_EVENT_IDX))
+ {
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_RING_F_EVENT_IDX);
+ }
+
+ if (!pContext->bUseMergedBuffers &&
VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MRG_RXBUF))
+ {
+ DPrintf(0, ("[%s] Not using mergeable buffers", __FUNCTION__));
+ }
+ else
+ {
+ pContext->bUseMergedBuffers = VirtIODeviceGetHostFeature(pContext,
VIRTIO_NET_F_MRG_RXBUF) != 0;
+ if (pContext->bUseMergedBuffers)
+ {
+ pContext->nVirtioHeaderSize = sizeof(virtio_net_hdr_ext);
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_MRG_RXBUF);
+ }
+ }
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_MAC))
+ {
+ virtio_get_config(
+ &pContext->IODevice,
+ 0, // + offsetof(struct virtio_net_config, mac)
+ &pContext->PermanentMacAddress,
+ ETH_LENGTH_OF_ADDRESS);
+ if (!ParaNdis_ValidateMacAddress(pContext->PermanentMacAddress, FALSE))
+ {
+ DPrintf(0,("Invalid device MAC
ignored(%02x-%02x-%02x-%02x-%02x-%02x)",
+ pContext->PermanentMacAddress[0],
+ pContext->PermanentMacAddress[1],
+ pContext->PermanentMacAddress[2],
+ pContext->PermanentMacAddress[3],
+ pContext->PermanentMacAddress[4],
+ pContext->PermanentMacAddress[5]));
+ NdisZeroMemory(pContext->PermanentMacAddress,
sizeof(pContext->PermanentMacAddress));
+ }
+ }
+
+ if (ETH_IS_EMPTY(pContext->PermanentMacAddress))
+ {
+ DPrintf(0, ("No device MAC present, use default"));
+ pContext->PermanentMacAddress[0] = 0x02;
+ pContext->PermanentMacAddress[1] = 0x50;
+ pContext->PermanentMacAddress[2] = 0xF2;
+ pContext->PermanentMacAddress[3] = 0x00;
+ pContext->PermanentMacAddress[4] = 0x01;
+ pContext->PermanentMacAddress[5] = 0x80 | (UCHAR)(pContext->ulUniqueID
& 0xFF);
+ }
+ DPrintf(0,("Device MAC = %02x-%02x-%02x-%02x-%02x-%02x",
+ pContext->PermanentMacAddress[0],
+ pContext->PermanentMacAddress[1],
+ pContext->PermanentMacAddress[2],
+ pContext->PermanentMacAddress[3],
+ pContext->PermanentMacAddress[4],
+ pContext->PermanentMacAddress[5]));
+
+ if (ETH_IS_EMPTY(pContext->CurrentMacAddress))
+ {
+ NdisMoveMemory(
+ &pContext->CurrentMacAddress,
+ &pContext->PermanentMacAddress,
+ ETH_LENGTH_OF_ADDRESS);
+ }
+ else
+ {
+ DPrintf(0,("Current MAC = %02x-%02x-%02x-%02x-%02x-%02x",
+ pContext->CurrentMacAddress[0],
+ pContext->CurrentMacAddress[1],
+ pContext->CurrentMacAddress[2],
+ pContext->CurrentMacAddress[3],
+ pContext->CurrentMacAddress[4],
+ pContext->CurrentMacAddress[5]));
+ }
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CTRL_VQ)) {
+ pContext->bHasControlQueue = TRUE;
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_CTRL_VQ);
+ }
+ }
+ else
+ {
+ DPrintf(0, ("[%s] Error: Incomplete resources", __FUNCTION__));
+ status = NDIS_STATUS_RESOURCE_CONFLICT;
+ }
+
+
+ if (pContext->bDoHardwareChecksum)
+ {
+ ULONG dependentOptions;
+ dependentOptions = osbT4TcpChecksum | osbT4UdpChecksum |
osbT4TcpOptionsChecksum;
+ if (!VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CSUM) &&
+ (pContext->Offload.flagsValue & dependentOptions))
+ {
+ DPrintf(0, ("[%s] Host does not support CSUM, disabling CS
offload", __FUNCTION__) );
+ pContext->Offload.flagsValue &= ~dependentOptions;
+ }
+ }
+
+ if (pContext->bDoGuestChecksumOnReceive &&
VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_GUEST_CSUM))
+ {
+ DPrintf(0, ("[%s] Enabling guest checksum", __FUNCTION__) );
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_GUEST_CSUM);
+ }
+ else
+ {
+ pContext->bDoGuestChecksumOnReceive = FALSE;
+ }
+
+ // now, after we checked the capabilities, we can initialize current
+ // configuration of offload tasks
+ ParaNdis_ResetOffloadSettings(pContext, NULL, NULL);
+ if (pContext->Offload.flags.fTxLso && !pContext->bUseScatterGather)
+ {
+ DisableBothLSOPermanently(pContext, __FUNCTION__, "SG is not active");
+ }
+ if (pContext->Offload.flags.fTxLso &&
+ !VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_HOST_TSO4))
+ {
+ DisableLSOv4Permanently(pContext, __FUNCTION__, "Host does not support
TSOv4");
+ }
+ if (pContext->Offload.flags.fTxLsov6 &&
+ !VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_HOST_TSO6))
+ {
+ DisableLSOv6Permanently(pContext, __FUNCTION__, "Host does not support
TSOv6");
+ }
+ if (pContext->bUseIndirect)
+ {
+ const char *reason = "";
+ if (!VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_INDIRECT_DESC))
+ {
+ pContext->bUseIndirect = FALSE;
+ reason = "Host support";
+ }
+ else if (!pContext->bUseScatterGather)
+ {
+ pContext->bUseIndirect = FALSE;
+ reason = "SG";
+ }
+ DPrintf(0, ("[%s] %sable indirect Tx(!%s)", __FUNCTION__,
pContext->bUseIndirect ? "En" : "Dis", reason) );
+ }
+
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_NET_F_CTRL_RX_EXTRA) &&
+ pContext->bDoHwPacketFiltering)
+ {
+ DPrintf(0, ("[%s] Using hardware packet filtering", __FUNCTION__));
+ pContext->bHasHardwareFilters = TRUE;
+ }
+
+ status = FinalizeFeatures(pContext);
+
+ pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferRegular;
+
+ NdisInitializeEvent(&pContext->ResetEvent);
+ DEBUG_EXIT_STATUS(0, status);
+ return status;
+}
+
+/**********************************************************
+Free the resources allocated for VirtIO buffer descriptor
+Parameters:
+ PVOID pParam pIONetDescriptor to free
+ BOOLEAN bRemoveFromList TRUE, if also remove it from list
+***********************************************************/
+static void VirtIONetFreeBufferDescriptor(PARANDIS_ADAPTER *pContext, pIONetDescriptor
pBufferDescriptor)
+{
+ if(pBufferDescriptor)
+ {
+ if (pBufferDescriptor->pHolder)
+ ParaNdis_UnbindBufferFromPacket(pContext, pBufferDescriptor);
+ if (pBufferDescriptor->DataInfo.Virtual)
+ ParaNdis_FreePhysicalMemory(pContext, &pBufferDescriptor->DataInfo);
+ if (pBufferDescriptor->HeaderInfo.Virtual)
+ ParaNdis_FreePhysicalMemory(pContext,
&pBufferDescriptor->HeaderInfo);
+ NdisFreeMemory(pBufferDescriptor, 0, 0);
+ }
+}
+
+/**********************************************************
+Free all the buffer descriptors from specified list
+Parameters:
+ PLIST_ENTRY pListRoot list containing pIONetDescriptor structures
+ PNDIS_SPIN_LOCK pLock lock to protest this list
+Return value:
+***********************************************************/
+static void FreeDescriptorsFromList(PARANDIS_ADAPTER *pContext, PLIST_ENTRY pListRoot,
PNDIS_SPIN_LOCK pLock)
+{
+ pIONetDescriptor pBufferDescriptor;
+ LIST_ENTRY TempList;
+ InitializeListHead(&TempList);
+ NdisAcquireSpinLock(pLock);
+ while(!IsListEmpty(pListRoot))
+ {
+ pBufferDescriptor = (pIONetDescriptor)RemoveHeadList(pListRoot);
+ InsertTailList(&TempList, &pBufferDescriptor->listEntry);
+ }
+ NdisReleaseSpinLock(pLock);
+ while(!IsListEmpty(&TempList))
+ {
+ pBufferDescriptor = (pIONetDescriptor)RemoveHeadList(&TempList);
+ VirtIONetFreeBufferDescriptor(pContext, pBufferDescriptor);
+ }
+}
+
+static pIONetDescriptor AllocatePairOfBuffersOnInit(
+ PARANDIS_ADAPTER *pContext,
+ ULONG size1,
+ ULONG size2,
+ BOOLEAN bForTx)
+{
+ pIONetDescriptor p;
+ p = (pIONetDescriptor)ParaNdis_AllocateMemory(pContext, sizeof(*p));
+ if (p)
+ {
+ BOOLEAN b1 = FALSE, b2 = FALSE;
+ NdisZeroMemory(p, sizeof(*p));
+ p->HeaderInfo.size = size1;
+ p->DataInfo.size = size2;
+ p->HeaderInfo.IsCached = p->DataInfo.IsCached = 1;
+ p->HeaderInfo.IsTX = p->DataInfo.IsTX = bForTx;
+ p->nofUsedBuffers = 0;
+ b1 = ParaNdis_InitialAllocatePhysicalMemory(pContext, &p->HeaderInfo);
+ if (b1) b2 = ParaNdis_InitialAllocatePhysicalMemory(pContext,
&p->DataInfo);
+ if (b1 && b2)
+ {
+ BOOLEAN b = bForTx || ParaNdis_BindBufferToPacket(pContext, p);
+ if (!b)
+ {
+ DPrintf(0, ("[INITPHYS](%s) Failed to bind memory to net
packet", bForTx ? "TX" : "RX"));
+ VirtIONetFreeBufferDescriptor(pContext, p);
+ p = NULL;
+ }
+ }
+ else
+ {
+ if (b1) ParaNdis_FreePhysicalMemory(pContext, &p->HeaderInfo);
+ if (b2) ParaNdis_FreePhysicalMemory(pContext, &p->DataInfo);
+ NdisFreeMemory(p, 0, 0);
+ p = NULL;
+ DPrintf(0, ("[INITPHYS](%s) Failed to allocate memory block",
bForTx ? "TX" : "RX"));
+ }
+ }
+ if (p)
+ {
+ DPrintf(3, ("[INITPHYS](%s) Header v%p(p%08lX), Data v%p(p%08lX)",
bForTx ? "TX" : "RX",
+ p->HeaderInfo.Virtual, p->HeaderInfo.Physical.LowPart,
+ p->DataInfo.Virtual, p->DataInfo.Physical.LowPart));
+ }
+ return p;
+}
+
+/**********************************************************
+Allocates TX buffers according to startup setting (pContext->maxFreeTxDescriptors as
got from registry)
+Buffers are chained in NetFreeSendBuffers
+Parameters:
+ context
+***********************************************************/
+static void PrepareTransmitBuffers(PARANDIS_ADAPTER *pContext)
+{
+ UINT nBuffers, nMaxBuffers;
+ DEBUG_ENTRY(4);
+ nMaxBuffers = virtio_get_queue_size(pContext->NetSendQueue) / 2;
+ if (nMaxBuffers > pContext->maxFreeTxDescriptors) nMaxBuffers =
pContext->maxFreeTxDescriptors;
+
+ for (nBuffers = 0; nBuffers < nMaxBuffers; ++nBuffers)
+ {
+ pIONetDescriptor pBuffersDescriptor =
+ AllocatePairOfBuffersOnInit(
+ pContext,
+ pContext->nVirtioHeaderSize,
+ pContext->MaxPacketSize.nMaxFullSizeHwTx,
+ TRUE);
+ if (!pBuffersDescriptor) break;
+
+ NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual,
pBuffersDescriptor->HeaderInfo.size);
+ InsertTailList(&pContext->NetFreeSendBuffers,
&pBuffersDescriptor->listEntry);
+ pContext->nofFreeTxDescriptors++;
+ }
+
+ pContext->maxFreeTxDescriptors = pContext->nofFreeTxDescriptors;
+ pContext->nofFreeHardwareBuffers = pContext->nofFreeTxDescriptors * 2;
+ pContext->maxFreeHardwareBuffers = pContext->minFreeHardwareBuffers =
pContext->nofFreeHardwareBuffers;
+ DPrintf(0, ("[%s] available %d Tx descriptors, %d hw buffers",
+ __FUNCTION__, pContext->nofFreeTxDescriptors,
pContext->nofFreeHardwareBuffers));
+}
+
+static BOOLEAN AddRxBufferToQueue(PARANDIS_ADAPTER *pContext, pIONetDescriptor
pBufferDescriptor)
+{
+ UINT nBuffersToSubmit = 2;
+ struct VirtIOBufferDescriptor sg[2];
+ if (!pContext->bUseMergedBuffers)
+ {
+ sg[0].physAddr = pBufferDescriptor->HeaderInfo.Physical;
+ sg[0].length = pBufferDescriptor->HeaderInfo.size;
+ sg[1].physAddr = pBufferDescriptor->DataInfo.Physical;
+ sg[1].length = pBufferDescriptor->DataInfo.size;
+ }
+ else
+ {
+ sg[0].physAddr = pBufferDescriptor->DataInfo.Physical;
+ sg[0].length = pBufferDescriptor->DataInfo.size;
+ nBuffersToSubmit = 1;
+ }
+ return 0 <= virtqueue_add_buf(
+ pContext->NetReceiveQueue,
+ sg,
+ 0,
+ nBuffersToSubmit,
+ pBufferDescriptor,
+ NULL,
+ 0);
+}
+
+
+/**********************************************************
+Allocates maximum RX buffers for incoming packets
+Buffers are chained in NetReceiveBuffers
+Parameters:
+ context
+***********************************************************/
+static int PrepareReceiveBuffers(PARANDIS_ADAPTER *pContext)
+{
+ int nRet = 0;
+ UINT i;
+ DEBUG_ENTRY(4);
+
+ for (i = 0; i < pContext->NetMaxReceiveBuffers; ++i)
+ {
+ ULONG size1 = pContext->bUseMergedBuffers ? 4 :
pContext->nVirtioHeaderSize;
+ ULONG size2 = pContext->MaxPacketSize.nMaxFullSizeHwRx +
+ (pContext->bUseMergedBuffers ? pContext->nVirtioHeaderSize : 0);
+ pIONetDescriptor pBuffersDescriptor =
+ AllocatePairOfBuffersOnInit(pContext, size1, size2, FALSE);
+ if (!pBuffersDescriptor) break;
+
+ if (!AddRxBufferToQueue(pContext, pBuffersDescriptor))
+ {
+ VirtIONetFreeBufferDescriptor(pContext, pBuffersDescriptor);
+ break;
+ }
+
+ InsertTailList(&pContext->NetReceiveBuffers,
&pBuffersDescriptor->listEntry);
+
+ pContext->NetNofReceiveBuffers++;
+ }
+
+ pContext->NetMaxReceiveBuffers = pContext->NetNofReceiveBuffers;
+ DPrintf(0, ("[%s] MaxReceiveBuffers %d\n", __FUNCTION__,
pContext->NetMaxReceiveBuffers) );
+
+ virtqueue_kick(pContext->NetReceiveQueue);
+
+ return nRet;
+}
+
+static NDIS_STATUS FindNetQueues(PARANDIS_ADAPTER *pContext)
+{
+ struct virtqueue *queues[3];
+ unsigned nvqs = pContext->bHasControlQueue ? 3 : 2;
+ NTSTATUS status;
+
+ // We work with two or three virtqueues, 0 - receive, 1 - send, 2 - control
+ status = virtio_find_queues(
+ &pContext->IODevice,
+ nvqs,
+ queues);
+ if (!NT_SUCCESS(status)) {
+ DPrintf(0, ("[%s] virtio_find_queues failed with %x\n", __FUNCTION__,
status));
+ return NTStatusToNdisStatus(status);
+ }
+
+ pContext->NetReceiveQueue = queues[0];
+ pContext->NetSendQueue = queues[1];
+ if (pContext->bHasControlQueue) {
+ pContext->NetControlQueue = queues[2];
+ }
+
+ return NDIS_STATUS_SUCCESS;
+}
+
+// called on PASSIVE upon unsuccessful Init or upon Halt
+static void DeleteNetQueues(PARANDIS_ADAPTER *pContext)
+{
+ virtio_delete_queues(&pContext->IODevice);
+}
+
+/**********************************************************
+Initializes VirtIO buffering and related stuff:
+Allocates RX and TX queues and buffers
+Parameters:
+ context
+Return value:
+ TRUE if both queues are allocated
+***********************************************************/
+static NDIS_STATUS ParaNdis_VirtIONetInit(PARANDIS_ADAPTER *pContext)
+{
+ NDIS_STATUS status;
+ DEBUG_ENTRY(0);
+
+ pContext->ControlData.IsCached = 1;
+ pContext->ControlData.size = 512;
+
+ status = FindNetQueues(pContext);
+ if (status != NDIS_STATUS_SUCCESS) {
+ return status;
+ }
+
+ if (pContext->NetReceiveQueue && pContext->NetSendQueue)
+ {
+ PrepareTransmitBuffers(pContext);
+ PrepareReceiveBuffers(pContext);
+
+ if (pContext->NetControlQueue)
+ ParaNdis_InitialAllocatePhysicalMemory(pContext,
&pContext->ControlData);
+ if (!pContext->NetControlQueue || !pContext->ControlData.Virtual)
+ {
+ DPrintf(0, ("[%s] The Control vQueue does not work!\n",
__FUNCTION__) );
+ pContext->bHasHardwareFilters = FALSE;
+ }
+ if (pContext->nofFreeTxDescriptors &&
+ pContext->NetMaxReceiveBuffers &&
+ pContext->maxFreeHardwareBuffers)
+ {
+ pContext->sgTxGatherTable = ParaNdis_AllocateMemory(pContext,
+ pContext->maxFreeHardwareBuffers *
sizeof(pContext->sgTxGatherTable[0]));
+ if (!pContext->sgTxGatherTable)
+ {
+ DisableBothLSOPermanently(pContext, __FUNCTION__, "Can not allocate
SG table");
+ }
+ status = NDIS_STATUS_SUCCESS;
+ }
+ }
+ else
+ {
+ DeleteNetQueues(pContext);
+ status = NDIS_STATUS_RESOURCES;
+ }
+ return status;
+}
+
+static void VirtIODeviceRemoveStatus(VirtIODevice *vdev, u8 status)
+{
+ virtio_set_status(
+ vdev,
+ virtio_get_status(vdev) & ~status);
+}
+
+/**********************************************************
+Finishes initialization of context structure, calling also version dependent part
+If this procedure failed, ParaNdis_CleanupContext must be called
+Parameters:
+ context
+Return value:
+ SUCCESS or some kind of failure
+***********************************************************/
+NDIS_STATUS ParaNdis_FinishInitialization(PARANDIS_ADAPTER *pContext)
+{
+ NDIS_STATUS status = NDIS_STATUS_SUCCESS;
+ DEBUG_ENTRY(0);
+
+ NdisAllocateSpinLock(&pContext->SendLock);
+#if !defined(UNIFY_LOCKS)
+ NdisAllocateSpinLock(&pContext->ReceiveLock);
+#endif
+
+ InitializeListHead(&pContext->NetReceiveBuffers);
+ InitializeListHead(&pContext->NetReceiveBuffersWaiting);
+ InitializeListHead(&pContext->NetSendBuffersInUse);
+ InitializeListHead(&pContext->NetFreeSendBuffers);
+
+ status = ParaNdis_FinishSpecificInitialization(pContext);
+
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ status = ParaNdis_VirtIONetInit(pContext);
+ }
+
+ pContext->Limits.nReusedRxBuffers = pContext->NetMaxReceiveBuffers / 4 + 1;
+
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ JustForCheckClearInterrupt(pContext, "start 3");
+ pContext->bEnableInterruptHandlingDPC = TRUE;
+ ParaNdis_SetPowerState(pContext, NdisDeviceStateD0);
+ virtio_device_ready(&pContext->IODevice);
+ JustForCheckClearInterrupt(pContext, "start 4");
+ ParaNdis_UpdateDeviceFilters(pContext);
+ }
+ else
+ {
+ virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_FAILED);
+ }
+ DEBUG_EXIT_STATUS(0, status);
+ return status;
+}
+
+/**********************************************************
+Releases VirtIO related resources - queues and buffers
+Parameters:
+ context
+Return value:
+***********************************************************/
+static void VirtIONetRelease(PARANDIS_ADAPTER *pContext)
+{
+ BOOLEAN b;
+ DEBUG_ENTRY(0);
+
+ /* list NetReceiveBuffersWaiting must be free */
+ do
+ {
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ b = !IsListEmpty(&pContext->NetReceiveBuffersWaiting);
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ if (b)
+ {
+ DPrintf(0, ("[%s] There are waiting buffers", __FUNCTION__));
+ PrintStatistics(pContext);
+ NdisMSleep(5000000);
+ }
+ }while (b);
+
+ DeleteNetQueues(pContext);
+ virtio_device_shutdown(&pContext->IODevice);
+ pContext->bIODeviceInitialized = FALSE;
+
+ /* intentionally commented out
+ FreeDescriptorsFromList(
+ pContext,
+ &pContext->NetReceiveBuffersWaiting,
+ &pContext->ReceiveLock);
+ */
+
+ /* this can be freed, queue shut down */
+ FreeDescriptorsFromList(
+ pContext,
+ &pContext->NetReceiveBuffers,
+ &pContext->ReceiveLock);
+
+ /* this can be freed, queue shut down */
+ FreeDescriptorsFromList(
+ pContext,
+ &pContext->NetSendBuffersInUse,
+ &pContext->SendLock);
+
+ /* this can be freed, send disabled */
+ FreeDescriptorsFromList(
+ pContext,
+ &pContext->NetFreeSendBuffers,
+ &pContext->SendLock);
+
+ if (pContext->ControlData.Virtual)
+ ParaNdis_FreePhysicalMemory(pContext, &pContext->ControlData);
+
+ PrintStatistics(pContext);
+ if (pContext->sgTxGatherTable)
+ {
+ NdisFreeMemory(pContext->sgTxGatherTable, 0, 0);
+ }
+}
+
+static void PreventDPCServicing(PARANDIS_ADAPTER *pContext)
+{
+ LONG inside;;
+ pContext->bEnableInterruptHandlingDPC = FALSE;
+ do
+ {
+ inside = InterlockedIncrement(&pContext->counterDPCInside);
+ InterlockedDecrement(&pContext->counterDPCInside);
+ if (inside > 1)
+ {
+ DPrintf(0, ("[%s] waiting!", __FUNCTION__));
+ NdisMSleep(20000);
+ }
+ } while (inside > 1);
+}
+
+/**********************************************************
+Frees all the resources allocated when the context initialized,
+ calling also version-dependent part
+Parameters:
+ context
+***********************************************************/
+VOID ParaNdis_CleanupContext(PARANDIS_ADAPTER *pContext)
+{
+ UINT i;
+
+ /* disable any interrupt generation */
+ if (pContext->IODevice.addr)
+ {
+ //int nActive;
+ //nActive = virtio_read_isr_status(&pContext->IODevice);
+ /* back compat - remove the OK flag only in legacy mode */
+ VirtIODeviceRemoveStatus(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER_OK);
+ JustForCheckClearInterrupt(pContext, "exit 1");
+ //nActive += virtio_read_isr_status(&pContext->IODevice);
+ //nActive += virtio_read_isr_status(&pContext->IODevice);
+ //DPrintf(0, ("cleanup %d", nActive));
+ }
+
+ PreventDPCServicing(pContext);
+
+ /****************************************
+ ensure all the incoming packets returned,
+ free all the buffers and their descriptors
+ *****************************************/
+
+ if (pContext->bIODeviceInitialized)
+ {
+ JustForCheckClearInterrupt(pContext, "exit 2");
+ ParaNdis_ResetVirtIONetDevice(pContext);
+ JustForCheckClearInterrupt(pContext, "exit 3");
+ }
+
+ ParaNdis_SetPowerState(pContext, NdisDeviceStateD3);
+ VirtIONetRelease(pContext);
+
+ ParaNdis_FinalizeCleanup(pContext);
+
+ if (pContext->SendLock.SpinLock)
+ {
+ NdisFreeSpinLock(&pContext->SendLock);
+ }
+
+#if !defined(UNIFY_LOCKS)
+ if (pContext->ReceiveLock.SpinLock)
+ {
+ NdisFreeSpinLock(&pContext->ReceiveLock);
+ }
+#endif
+
+ /* free queue shared memory */
+ for (i = 0; i < MAX_NUM_OF_QUEUES; i++) {
+ if (pContext->SharedMemoryRanges[i].pBase != NULL) {
+ NdisMFreeSharedMemory(
+ pContext->MiniportHandle,
+ pContext->SharedMemoryRanges[i].uLength,
+ TRUE /* Cached */,
+ pContext->SharedMemoryRanges[i].pBase,
+ pContext->SharedMemoryRanges[i].BasePA);
+ pContext->SharedMemoryRanges[i].pBase = NULL;
+ }
+ }
+
+ /* unmap our port and memory IO resources */
+ for (i = 0; i < PCI_TYPE0_ADDRESSES; i++)
+ {
+ tBusResource *pRes = &pContext->AdapterResources.PciBars[i];
+ if (pRes->pBase != NULL)
+ {
+ if (pRes->bPortSpace)
+ {
+ NdisMDeregisterIoPortRange(
+ pContext->MiniportHandle,
+ pRes->BasePA.LowPart,
+ pRes->uLength,
+ pRes->pBase);
+ }
+ else
+ {
+ NdisMUnmapIoSpace(
+ pContext->MiniportHandle,
+ pRes->pBase,
+ pRes->uLength);
+ }
+ }
+ }
+}
+
+
+/**********************************************************
+System shutdown handler (shutdown, restart, bugcheck)
+Parameters:
+ context
+***********************************************************/
+VOID ParaNdis_OnShutdown(PARANDIS_ADAPTER *pContext)
+{
+ DEBUG_ENTRY(0); // this is only for kdbg :)
+ ParaNdis_ResetVirtIONetDevice(pContext);
+}
+
+/**********************************************************
+Handles hardware interrupt
+Parameters:
+ context
+ ULONG knownInterruptSources - bitmask of
+Return value:
+ TRUE, if it is our interrupt
+ sets *pRunDpc to TRUE if the DPC should be fired
+***********************************************************/
+BOOLEAN ParaNdis_OnLegacyInterrupt(
+ PARANDIS_ADAPTER *pContext,
+ OUT BOOLEAN *pRunDpc)
+{
+ ULONG status = virtio_read_isr_status(&pContext->IODevice);
+
+ if((status == 0) ||
+ (status == VIRTIO_NET_INVALID_INTERRUPT_STATUS) ||
+ (pContext->powerState != NdisDeviceStateD0))
+ {
+ *pRunDpc = FALSE;
+ return FALSE;
+ }
+
+ PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(pContext);
+ ParaNdis_VirtIODisableIrqSynchronized(pContext, isAny);
+ InterlockedOr(&pContext->InterruptStatus, (LONG) ((status & isControl) |
isReceive | isTransmit));
+ *pRunDpc = TRUE;
+ return TRUE;
+}
+
+BOOLEAN ParaNdis_OnQueuedInterrupt(
+ PARANDIS_ADAPTER *pContext,
+ OUT BOOLEAN *pRunDpc,
+ ULONG knownInterruptSources)
+{
+ struct virtqueue* _vq = ParaNdis_GetQueueForInterrupt(pContext,
knownInterruptSources);
+
+ /* If interrupts for this queue disabled do nothing */
+ if((_vq != NULL) && !ParaNDIS_IsQueueInterruptEnabled(_vq))
+ {
+ *pRunDpc = FALSE;
+ }
+ else
+ {
+ PARANDIS_STORE_LAST_INTERRUPT_TIMESTAMP(pContext);
+ InterlockedOr(&pContext->InterruptStatus, (LONG)knownInterruptSources);
+ ParaNdis_VirtIODisableIrqSynchronized(pContext, knownInterruptSources);
+ *pRunDpc = TRUE;
+ }
+
+ return *pRunDpc;
+}
+
+
+/**********************************************************
+It is called from Rx processing routines in regular mode of operation.
+Returns received buffer back to VirtIO queue, inserting it to NetReceiveBuffers.
+If needed, signals end of RX pause operation
+
+Must be called with &pContext->ReceiveLock acquired
+
+Parameters:
+ context
+ void *pDescriptor - pIONetDescriptor to return
+***********************************************************/
+void ReuseReceiveBufferRegular(PARANDIS_ADAPTER *pContext, pIONetDescriptor
pBuffersDescriptor)
+{
+ DEBUG_ENTRY(4);
+
+ if(!pBuffersDescriptor)
+ return;
+
+ RemoveEntryList(&pBuffersDescriptor->listEntry);
+
+ if(AddRxBufferToQueue(pContext, pBuffersDescriptor))
+ {
+ InsertTailList(&pContext->NetReceiveBuffers,
&pBuffersDescriptor->listEntry);
+
+ pContext->NetNofReceiveBuffers++;
+
+ if (pContext->NetNofReceiveBuffers > pContext->NetMaxReceiveBuffers)
+ {
+ DPrintf(0, (" Error: NetNofReceiveBuffers >
NetMaxReceiveBuffers(%d>%d)",
+ pContext->NetNofReceiveBuffers, pContext->NetMaxReceiveBuffers));
+ }
+
+ if (++pContext->Counters.nReusedRxBuffers >=
pContext->Limits.nReusedRxBuffers)
+ {
+ pContext->Counters.nReusedRxBuffers = 0;
+ virtqueue_kick_always(pContext->NetReceiveQueue);
+ }
+
+ if (IsListEmpty(&pContext->NetReceiveBuffersWaiting))
+ {
+ if (pContext->ReceiveState == srsPausing ||
pContext->ReceivePauseCompletionProc)
+ {
+ ONPAUSECOMPLETEPROC callback = pContext->ReceivePauseCompletionProc;
+ pContext->ReceiveState = srsDisabled;
+ pContext->ReceivePauseCompletionProc = NULL;
+ ParaNdis_DebugHistory(pContext, hopInternalReceivePause, NULL, 0, 0, 0);
+ if (callback) callback(pContext);
+ }
+ }
+ }
+ else
+ {
+ DPrintf(0, ("FAILED TO REUSE THE BUFFER!!!!"));
+ VirtIONetFreeBufferDescriptor(pContext, pBuffersDescriptor);
+ pContext->NetMaxReceiveBuffers--;
+ }
+}
+
+/**********************************************************
+It is called from Rx processing routines between power off and power on in non-paused
mode (Win8).
+Returns received buffer to NetReceiveBuffers.
+All the buffers will be placed into Virtio queue during power-on procedure
+
+Must be called with &pContext->ReceiveLock acquired
+
+Parameters:
+ context
+ void *pDescriptor - pIONetDescriptor to return
+***********************************************************/
+static void ReuseReceiveBufferPowerOff(PARANDIS_ADAPTER *pContext, pIONetDescriptor
pBuffersDescriptor)
+{
+ RemoveEntryList(&pBuffersDescriptor->listEntry);
+ InsertTailList(&pContext->NetReceiveBuffers,
&pBuffersDescriptor->listEntry);
+}
+
+/**********************************************************
+It is called from Tx processing routines
+Gets all the finished buffer from VirtIO TX path and
+returns them to NetFreeSendBuffers
+
+Must be called with &pContext->SendLock acquired
+
+Parameters:
+ context
+Return value:
+ (for reference) number of TX buffers returned
+***********************************************************/
+UINT ParaNdis_VirtIONetReleaseTransmitBuffers(
+ PARANDIS_ADAPTER *pContext)
+{
+ UINT len, i = 0;
+ pIONetDescriptor pBufferDescriptor;
+
+ DEBUG_ENTRY(4);
+
+ while(NULL != (pBufferDescriptor = virtqueue_get_buf(pContext->NetSendQueue,
&len)))
+ {
+ RemoveEntryList(&pBufferDescriptor->listEntry);
+ pContext->nofFreeTxDescriptors++;
+ if (!pBufferDescriptor->nofUsedBuffers)
+ {
+ DPrintf(0, ("[%s] ERROR: nofUsedBuffers not set!", __FUNCTION__));
+ }
+ pContext->nofFreeHardwareBuffers += pBufferDescriptor->nofUsedBuffers;
+ ParaNdis_OnTransmitBufferReleased(pContext, pBufferDescriptor);
+ InsertTailList(&pContext->NetFreeSendBuffers,
&pBufferDescriptor->listEntry);
+ DPrintf(3, ("[%s] Free Tx: desc %d, buff %d", __FUNCTION__,
pContext->nofFreeTxDescriptors, pContext->nofFreeHardwareBuffers));
+ pBufferDescriptor->nofUsedBuffers = 0;
+ ++i;
+ }
+ if (i)
+ {
+ NdisGetCurrentSystemTime(&pContext->LastTxCompletionTimeStamp);
+ pContext->bDoKickOnNoBuffer = TRUE;
+ pContext->nDetectedStoppedTx = 0;
+ }
+ DEBUG_EXIT_STATUS((i ? 3 : 5), i);
+ return i;
+}
+
+static ULONG FORCEINLINE QueryTcpHeaderOffset(PVOID packetData, ULONG ipHeaderOffset,
ULONG ipPacketLength)
+{
+ ULONG res;
+ tTcpIpPacketParsingResult ppr = ParaNdis_ReviewIPPacket(
+ (PUCHAR)packetData + ipHeaderOffset,
+ ipPacketLength,
+ __FUNCTION__);
+ if (ppr.xxpStatus == ppresXxpKnown)
+ {
+ res = ipHeaderOffset + ppr.ipHeaderSize;
+ }
+ else
+ {
+ DPrintf(0, ("[%s] ERROR: NOT a TCP or UDP packet - expected troubles!",
__FUNCTION__));
+ res = 0;
+ }
+ return res;
+}
+
+
+/*********************************************************
+Called with from ProcessTx routine with TxLock held
+Uses pContext->sgTxGatherTable
+***********************************************************/
+tCopyPacketResult ParaNdis_DoSubmitPacket(PARANDIS_ADAPTER *pContext,
tTxOperationParameters *Params)
+{
+ tCopyPacketResult result;
+ tMapperResult mapResult = {0,0,0};
+ // populating priority tag or LSO MAY require additional SG element
+ UINT nRequiredBuffers;
+ BOOLEAN bUseCopy = FALSE;
+ struct VirtIOBufferDescriptor *sg = pContext->sgTxGatherTable;
+
+ nRequiredBuffers = Params->nofSGFragments + 1 + ((Params->flags &
(pcrPriorityTag | pcrLSO)) ? 1 : 0);
+
+ result.size = 0;
+ result.error = cpeOK;
+ if (!pContext->bUseScatterGather || // only copy available
+ Params->nofSGFragments == 0 || // theoretical case
+ !sg || // only copy available
+ ((~Params->flags & pcrLSO) && nRequiredBuffers >
pContext->maxFreeHardwareBuffers) // to many fragments and normal size of packet
+ )
+ {
+ nRequiredBuffers = 2;
+ bUseCopy = TRUE;
+ }
+ else if (pContext->bUseIndirect && !(Params->flags &
pcrNoIndirect))
+ {
+ nRequiredBuffers = 1;
+ }
+
+ // I do not think this will help, but at least we can try freeing some buffers right
now
+ if (pContext->nofFreeHardwareBuffers < nRequiredBuffers ||
!pContext->nofFreeTxDescriptors)
+ {
+ ParaNdis_VirtIONetReleaseTransmitBuffers(pContext);
+ }
+
+ if (nRequiredBuffers > pContext->maxFreeHardwareBuffers)
+ {
+ // LSO and too many buffers, impossible to send
+ result.error = cpeTooLarge;
+ DPrintf(0, ("[%s] ERROR: too many fragments(%d required, %d
max.avail)!", __FUNCTION__,
+ nRequiredBuffers, pContext->maxFreeHardwareBuffers));
+ }
+ else if (pContext->nofFreeHardwareBuffers < nRequiredBuffers ||
!pContext->nofFreeTxDescriptors)
+ {
+ virtqueue_enable_cb_delayed(pContext->NetSendQueue);
+ result.error = cpeNoBuffer;
+ }
+ else if (Params->offloadMss && bUseCopy)
+ {
+ result.error = cpeInternalError;
+ DPrintf(0, ("[%s] ERROR: expecting SG for TSO! (%d buffers, %d bytes)",
__FUNCTION__,
+ Params->nofSGFragments, Params->ulDataSize));
+ }
+ else if (bUseCopy)
+ {
+ result = ParaNdis_DoCopyPacketData(pContext, Params);
+ }
+ else
+ {
+ UINT nMappedBuffers;
+ ULONGLONG paOfIndirectArea = 0;
+ PVOID vaOfIndirectArea = NULL;
+ pIONetDescriptor pBuffersDescriptor =
(pIONetDescriptor)RemoveHeadList(&pContext->NetFreeSendBuffers);
+ pContext->nofFreeTxDescriptors--;
+ NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual,
pBuffersDescriptor->HeaderInfo.size);
+ sg[0].physAddr = pBuffersDescriptor->HeaderInfo.Physical;
+ sg[0].length = pBuffersDescriptor->HeaderInfo.size;
+ ParaNdis_PacketMapper(
+ pContext,
+ Params->packet,
+ Params->ReferenceValue,
+ sg + 1,
+ pBuffersDescriptor,
+ &mapResult);
+ nMappedBuffers = mapResult.usBuffersMapped;
+ if (nMappedBuffers)
+ {
+ nMappedBuffers++;
+ if (pContext->bUseIndirect && !(Params->flags &
pcrNoIndirect))
+ {
+ ULONG space1 = (mapResult.usBufferSpaceUsed + 7) & ~7;
+ ULONG space2 = nMappedBuffers * SIZE_OF_SINGLE_INDIRECT_DESC;
+ if (pBuffersDescriptor->DataInfo.size >= (space1 + space2))
+ {
+ vaOfIndirectArea =
RtlOffsetToPointer(pBuffersDescriptor->DataInfo.Virtual, space1);
+ paOfIndirectArea = pBuffersDescriptor->DataInfo.Physical.QuadPart
+ space1;
+ pContext->extraStatistics.framesIndirect++;
+ }
+ else if (nMappedBuffers <= pContext->nofFreeHardwareBuffers)
+ {
+ // send as is, no indirect
+ }
+ else
+ {
+ result.error = cpeNoIndirect;
+ DPrintf(0, ("[%s] Unexpected ERROR of placement!",
__FUNCTION__));
+ }
+ }
+ if (result.error == cpeOK)
+ {
+ if (Params->flags & (pcrTcpChecksum | pcrUdpChecksum))
+ {
+ unsigned short addPriorityLen = (Params->flags &
pcrPriorityTag) ? ETH_PRIORITY_HEADER_SIZE : 0;
+ if (pContext->bDoHardwareChecksum)
+ {
+ virtio_net_hdr_basic *pheader =
pBuffersDescriptor->HeaderInfo.Virtual;
+ pheader->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+ if (!Params->tcpHeaderOffset)
+ {
+ Params->tcpHeaderOffset = QueryTcpHeaderOffset(
+ pBuffersDescriptor->DataInfo.Virtual,
+ pContext->Offload.ipHeaderOffset + addPriorityLen,
+ mapResult.usBufferSpaceUsed -
pContext->Offload.ipHeaderOffset - addPriorityLen);
+ }
+ else
+ {
+ Params->tcpHeaderOffset += addPriorityLen;
+ }
+ pheader->csum_start = (USHORT)Params->tcpHeaderOffset;
+ pheader->csum_offset = (Params->flags & pcrTcpChecksum)
? TCP_CHECKSUM_OFFSET : UDP_CHECKSUM_OFFSET;
+ }
+ else
+ {
+ // emulation mode - it is slow and intended only for test of
flows
+ // and debugging of WLK test cases
+ PVOID pCopy = ParaNdis_AllocateMemory(pContext,
Params->ulDataSize);
+ if (pCopy)
+ {
+ tTcpIpPacketParsingResult ppr;
+ // duplicate entire packet
+ ParaNdis_PacketCopier(Params->packet, pCopy,
Params->ulDataSize, Params->ReferenceValue, FALSE);
+ // calculate complete TCP/UDP checksum
+ ppr = ParaNdis_CheckSumVerify(
+ RtlOffsetToPointer(pCopy,
pContext->Offload.ipHeaderOffset + addPriorityLen),
+ Params->ulDataSize -
pContext->Offload.ipHeaderOffset - addPriorityLen,
+ pcrAnyChecksum | pcrFixXxpChecksum,
+ __FUNCTION__);
+ // data portion in aside buffer contains complete IP+TCP
header
+ // rewrite copy of original buffer by one new with calculated
data
+ NdisMoveMemory(
+ pBuffersDescriptor->DataInfo.Virtual,
+ pCopy,
+ mapResult.usBufferSpaceUsed);
+ NdisFreeMemory(pCopy, 0, 0);
+ }
+ }
+ }
+
+ if (0 <= virtqueue_add_buf(
+ pContext->NetSendQueue,
+ sg,
+ nMappedBuffers,
+ 0,
+ pBuffersDescriptor,
+ vaOfIndirectArea,
+ paOfIndirectArea))
+ {
+ pBuffersDescriptor->nofUsedBuffers = nMappedBuffers;
+ pContext->nofFreeHardwareBuffers -= nMappedBuffers;
+ if (pContext->minFreeHardwareBuffers >
pContext->nofFreeHardwareBuffers)
+ pContext->minFreeHardwareBuffers =
pContext->nofFreeHardwareBuffers;
+ pBuffersDescriptor->ReferenceValue = Params->ReferenceValue;
+ result.size = Params->ulDataSize;
+ DPrintf(2, ("[%s] Submitted %d buffers (%d bytes), avail %d
desc, %d bufs",
+ __FUNCTION__, nMappedBuffers, result.size,
+ pContext->nofFreeTxDescriptors,
pContext->nofFreeHardwareBuffers
+ ));
+ }
+ else
+ {
+ result.error = cpeInternalError;
+ DPrintf(0, ("[%s] Unexpected ERROR adding buffer to TX
engine!..", __FUNCTION__));
+ }
+ }
+ }
+ else
+ {
+ DPrintf(0, ("[%s] Unexpected ERROR: packet not mapped!",
__FUNCTION__));
+ result.error = cpeInternalError;
+ }
+
+ if (result.error == cpeOK)
+ {
+ UCHAR ethernetHeader[sizeof(ETH_HEADER)];
+ eInspectedPacketType packetType;
+ /* get the ethernet header for review */
+ ParaNdis_PacketCopier(Params->packet, ethernetHeader,
sizeof(ethernetHeader), Params->ReferenceValue, TRUE);
+ packetType = QueryPacketType(ethernetHeader);
+ DebugDumpPacket("sending", ethernetHeader, 3);
+ InsertTailList(&pContext->NetSendBuffersInUse,
&pBuffersDescriptor->listEntry);
+ pContext->Statistics.ifHCOutOctets += result.size;
+ switch (packetType)
+ {
+ case iptBroadcast:
+ pContext->Statistics.ifHCOutBroadcastOctets += result.size;
+ pContext->Statistics.ifHCOutBroadcastPkts++;
+ break;
+ case iptMulticast:
+ pContext->Statistics.ifHCOutMulticastOctets += result.size;
+ pContext->Statistics.ifHCOutMulticastPkts++;
+ break;
+ default:
+ pContext->Statistics.ifHCOutUcastOctets += result.size;
+ pContext->Statistics.ifHCOutUcastPkts++;
+ break;
+ }
+
+ if (Params->flags & pcrLSO)
+ pContext->extraStatistics.framesLSO++;
+ }
+ else
+ {
+ pContext->nofFreeTxDescriptors++;
+ InsertHeadList(&pContext->NetFreeSendBuffers,
&pBuffersDescriptor->listEntry);
+ }
+ }
+ if (result.error == cpeNoBuffer && pContext->bDoKickOnNoBuffer)
+ {
+ virtqueue_kick_always(pContext->NetSendQueue);
+ pContext->bDoKickOnNoBuffer = FALSE;
+ }
+ if (result.error == cpeOK)
+ {
+ if (Params->flags & (pcrTcpChecksum | pcrUdpChecksum))
+ pContext->extraStatistics.framesCSOffload++;
+ }
+ return result;
+}
+
+
+/**********************************************************
+It is called from Tx processing routines
+Prepares the VirtIO buffer and copies to it the data from provided packet
+
+Must be called with &pContext->SendLock acquired
+
+Parameters:
+ context
+ tPacketType packet specific type is NDIS dependent
+ tCopyPacketDataFunction PacketCopier procedure for NDIS-specific type of packet
+Return value:
+ (for reference) number of TX buffers returned
+***********************************************************/
+tCopyPacketResult ParaNdis_DoCopyPacketData(
+ PARANDIS_ADAPTER *pContext,
+ tTxOperationParameters *pParams)
+{
+ tCopyPacketResult result;
+ tCopyPacketResult CopierResult;
+ struct VirtIOBufferDescriptor sg[2];
+ pIONetDescriptor pBuffersDescriptor = NULL;
+ ULONG flags = pParams->flags;
+ UINT nRequiredHardwareBuffers = 2;
+ result.size = 0;
+ result.error = cpeOK;
+ if (pContext->nofFreeHardwareBuffers < nRequiredHardwareBuffers ||
+ IsListEmpty(&pContext->NetFreeSendBuffers))
+ {
+ result.error = cpeNoBuffer;
+ }
+ if(result.error == cpeOK)
+ {
+ pBuffersDescriptor =
(pIONetDescriptor)RemoveHeadList(&pContext->NetFreeSendBuffers);
+ NdisZeroMemory(pBuffersDescriptor->HeaderInfo.Virtual,
pBuffersDescriptor->HeaderInfo.size);
+ sg[0].physAddr = pBuffersDescriptor->HeaderInfo.Physical;
+ sg[0].length = pBuffersDescriptor->HeaderInfo.size;
+ sg[1].physAddr = pBuffersDescriptor->DataInfo.Physical;
+ CopierResult = ParaNdis_PacketCopier(
+ pParams->packet,
+ pBuffersDescriptor->DataInfo.Virtual,
+ pBuffersDescriptor->DataInfo.size,
+ pParams->ReferenceValue,
+ FALSE);
+ sg[1].length = result.size = CopierResult.size;
+ // did NDIS ask us to compute CS?
+ if ((flags & (pcrTcpChecksum | pcrUdpChecksum | pcrIpChecksum)) != 0)
+ {
+ // we asked
+ unsigned short addPriorityLen = (pParams->flags & pcrPriorityTag) ?
ETH_PRIORITY_HEADER_SIZE : 0;
+ PVOID ipPacket = RtlOffsetToPointer(
+ pBuffersDescriptor->DataInfo.Virtual,
pContext->Offload.ipHeaderOffset + addPriorityLen);
+ ULONG ipPacketLength = CopierResult.size -
pContext->Offload.ipHeaderOffset - addPriorityLen;
+ if (!pParams->tcpHeaderOffset &&
+ (flags & (pcrTcpChecksum | pcrUdpChecksum)) )
+ {
+ pParams->tcpHeaderOffset = QueryTcpHeaderOffset(
+ pBuffersDescriptor->DataInfo.Virtual,
+ pContext->Offload.ipHeaderOffset + addPriorityLen,
+ ipPacketLength);
+ }
+ else
+ {
+ pParams->tcpHeaderOffset += addPriorityLen;
+ }
+
+ if (pContext->bDoHardwareChecksum)
+ {
+ if (flags & (pcrTcpChecksum | pcrUdpChecksum))
+ {
+ // hardware offload
+ virtio_net_hdr_basic *pvnh = (virtio_net_hdr_basic
*)pBuffersDescriptor->HeaderInfo.Virtual;
+ pvnh->csum_start = (USHORT)pParams->tcpHeaderOffset;
+ pvnh->csum_offset = (flags & pcrTcpChecksum) ?
TCP_CHECKSUM_OFFSET : UDP_CHECKSUM_OFFSET;
+ pvnh->flags |= VIRTIO_NET_HDR_F_NEEDS_CSUM;
+ }
+ if (flags & (pcrIpChecksum))
+ {
+ ParaNdis_CheckSumVerify(
+ ipPacket,
+ ipPacketLength,
+ pcrIpChecksum | pcrFixIPChecksum,
+ __FUNCTION__);
+ }
+ }
+ else if (CopierResult.size > pContext->Offload.ipHeaderOffset)
+ {
+ ULONG csFlags = 0;
+ if (flags & pcrIpChecksum) csFlags |= pcrIpChecksum |
pcrFixIPChecksum;
+ if (flags & (pcrTcpChecksum | pcrUdpChecksum)) csFlags |=
pcrTcpChecksum | pcrUdpChecksum| pcrFixXxpChecksum;
+ // software offload
+ ParaNdis_CheckSumVerify(
+ ipPacket,
+ ipPacketLength,
+ csFlags,
+ __FUNCTION__);
+ }
+ else
+ {
+ DPrintf(0, ("[%s] ERROR: Invalid buffer size for offload!",
__FUNCTION__));
+ result.size = 0;
+ result.error = cpeInternalError;
+ }
+ }
+ pContext->nofFreeTxDescriptors--;
+ if (result.size)
+ {
+ eInspectedPacketType packetType;
+ packetType = QueryPacketType(pBuffersDescriptor->DataInfo.Virtual);
+ DebugDumpPacket("sending", pBuffersDescriptor->DataInfo.Virtual,
3);
+
+ pBuffersDescriptor->nofUsedBuffers = nRequiredHardwareBuffers;
+ pContext->nofFreeHardwareBuffers -= nRequiredHardwareBuffers;
+ if (pContext->minFreeHardwareBuffers >
pContext->nofFreeHardwareBuffers)
+ pContext->minFreeHardwareBuffers =
pContext->nofFreeHardwareBuffers;
+ if (0 > virtqueue_add_buf(
+ pContext->NetSendQueue,
+ sg,
+ 2,
+ 0,
+ pBuffersDescriptor,
+ NULL,
+ 0
+ ))
+ {
+ pBuffersDescriptor->nofUsedBuffers = 0;
+ pContext->nofFreeHardwareBuffers += nRequiredHardwareBuffers;
+ result.error = cpeInternalError;
+ result.size = 0;
+ DPrintf(0, ("[%s] Unexpected ERROR adding buffer to TX
engine!..", __FUNCTION__));
+ }
+ else
+ {
+ DPrintf(2, ("[%s] Submitted %d buffers (%d bytes), avail %d desc, %d
bufs",
+ __FUNCTION__, nRequiredHardwareBuffers, result.size,
+ pContext->nofFreeTxDescriptors,
pContext->nofFreeHardwareBuffers
+ ));
+ }
+ if (result.error != cpeOK)
+ {
+ InsertTailList(&pContext->NetFreeSendBuffers,
&pBuffersDescriptor->listEntry);
+ pContext->nofFreeTxDescriptors++;
+ }
+ else
+ {
+ ULONG reportedSize = pParams->ulDataSize;
+ pBuffersDescriptor->ReferenceValue = pParams->ReferenceValue;
+ InsertTailList(&pContext->NetSendBuffersInUse,
&pBuffersDescriptor->listEntry);
+ pContext->Statistics.ifHCOutOctets += reportedSize;
+ switch (packetType)
+ {
+ case iptBroadcast:
+ pContext->Statistics.ifHCOutBroadcastOctets += reportedSize;
+ pContext->Statistics.ifHCOutBroadcastPkts++;
+ break;
+ case iptMulticast:
+ pContext->Statistics.ifHCOutMulticastOctets += reportedSize;
+ pContext->Statistics.ifHCOutMulticastPkts++;
+ break;
+ default:
+ pContext->Statistics.ifHCOutUcastOctets += reportedSize;
+ pContext->Statistics.ifHCOutUcastPkts++;
+ break;
+ }
+ }
+ }
+ else
+ {
+ DPrintf(0, ("[%s] Unexpected ERROR in copying packet data!
Continue...", __FUNCTION__));
+ InsertTailList(&pContext->NetFreeSendBuffers,
&pBuffersDescriptor->listEntry);
+ pContext->nofFreeTxDescriptors++;
+ // the buffer is not copied and the callback will not be called
+ result.error = cpeInternalError;
+ }
+ }
+
+ return result;
+}
+
+static ULONG ShallPassPacket(PARANDIS_ADAPTER *pContext, PVOID address, UINT len,
eInspectedPacketType *pType)
+{
+ ULONG b;
+ if (len <= sizeof(ETH_HEADER)) return FALSE;
+ if (len > pContext->MaxPacketSize.nMaxFullSizeHwRx) return FALSE;
+ if (len > pContext->MaxPacketSize.nMaxFullSizeOS &&
!ETH_HAS_PRIO_HEADER(address)) return FALSE;
+ *pType = QueryPacketType(address);
+ if (pContext->PacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS) return TRUE;
+
+ switch(*pType)
+ {
+ case iptBroadcast:
+ b = pContext->PacketFilter & NDIS_PACKET_TYPE_BROADCAST;
+ break;
+ case iptMulticast:
+ b = pContext->PacketFilter & NDIS_PACKET_TYPE_ALL_MULTICAST;
+ if (!b && (pContext->PacketFilter &
NDIS_PACKET_TYPE_MULTICAST))
+ {
+ UINT i, n = pContext->MulticastData.nofMulticastEntries *
ETH_LENGTH_OF_ADDRESS;
+ b = 1;
+ for (i = 0; b && i < n; i += ETH_LENGTH_OF_ADDRESS)
+ {
+ ETH_COMPARE_NETWORK_ADDRESSES((PUCHAR)address,
&pContext->MulticastData.MulticastList[i], &b)
+ }
+ b = !b;
+ }
+ break;
+ default:
+ ETH_COMPARE_NETWORK_ADDRESSES((PUCHAR)address,
pContext->CurrentMacAddress, &b);
+ b = !b && (pContext->PacketFilter &
NDIS_PACKET_TYPE_DIRECTED);
+ break;
+ }
+ if (!b)
+ {
+ pContext->extraStatistics.framesFilteredOut++;
+ }
+ return b;
+}
+
+void
+ParaNdis_PadPacketReceived(PVOID pDataBuffer, PULONG pLength)
+{
+ // Ethernet standard declares minimal possible packet size
+ // Packets smaller than that must be padded before transfer
+ // Ethernet HW pads packets on transmit, however in our case
+ // some packets do not travel over Ethernet but being routed
+ // guest-to-guest by virtual switch.
+ // In this case padding is not performed and we may
+ // receive packet smaller than minimal allowed size. This is not
+ // a problem for real life scenarios however WHQL/HCK contains
+ // tests that check padding of received packets.
+ // To make these tests happy we have to pad small packets on receive
+
+ //NOTE: This function assumes that VLAN header has been already stripped out
+
+ if(*pLength < ETH_MIN_PACKET_SIZE)
+ {
+ RtlZeroMemory(RtlOffsetToPointer(pDataBuffer, *pLength), ETH_MIN_PACKET_SIZE -
*pLength);
+ *pLength = ETH_MIN_PACKET_SIZE;
+ }
+}
+
+/**********************************************************
+Manages RX path, calling NDIS-specific procedure for packet indication
+Parameters:
+ context
+***********************************************************/
+static UINT ParaNdis_ProcessRxPath(PARANDIS_ADAPTER *pContext, ULONG
ulMaxPacketsToIndicate)
+{
+ pIONetDescriptor pBuffersDescriptor;
+ UINT len, headerSize = pContext->nVirtioHeaderSize;
+ eInspectedPacketType packetType = iptInvalid;
+ UINT nReceived = 0, nRetrieved = 0, nReported = 0;
+ tPacketIndicationType *pBatchOfPackets;
+ UINT maxPacketsInBatch = pContext->NetMaxReceiveBuffers;
+ pBatchOfPackets = pContext->bBatchReceive ?
+ ParaNdis_AllocateMemory(pContext, maxPacketsInBatch *
sizeof(tPacketIndicationType)) : NULL;
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ while ((nReported < ulMaxPacketsToIndicate) && NULL != (pBuffersDescriptor
= virtqueue_get_buf(pContext->NetReceiveQueue, &len)))
+ {
+ PVOID pDataBuffer = RtlOffsetToPointer(pBuffersDescriptor->DataInfo.Virtual,
pContext->bUseMergedBuffers ? pContext->nVirtioHeaderSize : 0);
+ RemoveEntryList(&pBuffersDescriptor->listEntry);
+ InsertTailList(&pContext->NetReceiveBuffersWaiting,
&pBuffersDescriptor->listEntry);
+ pContext->NetNofReceiveBuffers--;
+ nRetrieved++;
+ DPrintf(2, ("[%s] retrieved header+%d b.", __FUNCTION__, len -
headerSize));
+ DebugDumpPacket("receive", pDataBuffer, 3);
+
+ if( !pContext->bSurprizeRemoved &&
+ ShallPassPacket(pContext, pDataBuffer, len - headerSize, &packetType)
&&
+ pContext->ReceiveState == srsEnabled &&
+ pContext->bConnected)
+ {
+ BOOLEAN b = FALSE;
+ ULONG length = len - headerSize;
+ if (!pBatchOfPackets)
+ {
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ b = NULL != ParaNdis_IndicateReceivedPacket(
+ pContext,
+ pDataBuffer,
+ &length,
+ FALSE,
+ pBuffersDescriptor);
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ }
+ else
+ {
+ tPacketIndicationType packet;
+ packet = ParaNdis_IndicateReceivedPacket(
+ pContext,
+ pDataBuffer,
+ &length,
+ TRUE,
+ pBuffersDescriptor);
+ b = packet != NULL;
+ if (b) pBatchOfPackets[nReceived] = packet;
+ }
+ if (!b)
+ {
+ pContext->ReuseBufferProc(pContext, pBuffersDescriptor);
+ //only possible reason for that is unexpected Vlan tag
+ //shall I count it as error?
+ pContext->Statistics.ifInErrors++;
+ pContext->Statistics.ifInDiscards++;
+ }
+ else
+ {
+ nReceived++;
+ nReported++;
+ pContext->Statistics.ifHCInOctets += length;
+ switch(packetType)
+ {
+ case iptBroadcast:
+ pContext->Statistics.ifHCInBroadcastPkts++;
+ pContext->Statistics.ifHCInBroadcastOctets += length;
+ break;
+ case iptMulticast:
+ pContext->Statistics.ifHCInMulticastPkts++;
+ pContext->Statistics.ifHCInMulticastOctets += length;
+ break;
+ default:
+ pContext->Statistics.ifHCInUcastPkts++;
+ pContext->Statistics.ifHCInUcastOctets += length;
+ break;
+ }
+ if (pBatchOfPackets && nReceived == maxPacketsInBatch)
+ {
+ DPrintf(1, ("[%s] received %d buffers of max %d",
__FUNCTION__, nReceived, ulMaxPacketsToIndicate));
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ ParaNdis_IndicateReceivedBatch(pContext, pBatchOfPackets,
nReceived);
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ nReceived = 0;
+ }
+ }
+ }
+ else
+ {
+ // reuse packet, there is no data or the RX is suppressed
+ pContext->ReuseBufferProc(pContext, pBuffersDescriptor);
+ }
+ }
+ ParaNdis_DebugHistory(pContext, hopReceiveStat, NULL, nRetrieved, nReported,
pContext->NetNofReceiveBuffers);
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ if (nReceived && pBatchOfPackets)
+ {
+ DPrintf(1, ("[%s]%d: received %d buffers of max %d", __FUNCTION__,
KeGetCurrentProcessorNumber(), nReceived, ulMaxPacketsToIndicate));
+ ParaNdis_IndicateReceivedBatch(pContext, pBatchOfPackets, nReceived);
+ }
+ if (pBatchOfPackets) NdisFreeMemory(pBatchOfPackets, 0, 0);
+ return nReported;
+}
+
+void ParaNdis_ReportLinkStatus(PARANDIS_ADAPTER *pContext, BOOLEAN bForce)
+{
+ BOOLEAN bConnected = TRUE;
+ if (pContext->bLinkDetectSupported)
+ {
+ USHORT linkStatus = 0;
+ USHORT offset = sizeof(pContext->CurrentMacAddress);
+ // link changed
+ virtio_get_config(&pContext->IODevice, offset, &linkStatus,
sizeof(linkStatus));
+ bConnected = (linkStatus & VIRTIO_NET_S_LINK_UP) != 0;
+ }
+ ParaNdis_IndicateConnect(pContext, bConnected, bForce);
+}
+
+static BOOLEAN RestartQueueSynchronously(tSynchronizedContext *SyncContext)
+{
+ struct virtqueue * _vq = (struct virtqueue *) SyncContext->Parameter;
+ bool res = true;
+ if (!virtqueue_enable_cb(_vq))
+ {
+ virtqueue_disable_cb(_vq);
+ res = false;
+ }
+
+ ParaNdis_DebugHistory(SyncContext->pContext, hopDPC,
(PVOID)SyncContext->Parameter, 0x20, res, 0);
+ return !res;
+}
+/**********************************************************
+DPC implementation, common for both NDIS
+Parameters:
+ context
+***********************************************************/
+ULONG ParaNdis_DPCWorkBody(PARANDIS_ADAPTER *pContext, ULONG ulMaxPacketsToIndicate)
+{
+ ULONG stillRequiresProcessing = 0;
+ ULONG interruptSources;
+ UINT uIndicatedRXPackets = 0;
+ UINT numOfPacketsToIndicate = min(ulMaxPacketsToIndicate,
pContext->uNumberOfHandledRXPacketsInDPC);
+
+ DEBUG_ENTRY(5);
+ if (pContext->bEnableInterruptHandlingDPC)
+ {
+ InterlockedIncrement(&pContext->counterDPCInside);
+ if (pContext->bEnableInterruptHandlingDPC)
+ {
+ BOOLEAN bDoKick = FALSE;
+
+ InterlockedExchange(&pContext->bDPCInactive, 0);
+ interruptSources = InterlockedExchange(&pContext->InterruptStatus,
0);
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)1, interruptSources, 0, 0);
+ if ((interruptSources & isControl) &&
pContext->bLinkDetectSupported)
+ {
+ ParaNdis_ReportLinkStatus(pContext, FALSE);
+ }
+ if (interruptSources & isTransmit)
+ {
+ bDoKick = ParaNdis_ProcessTx(pContext, TRUE, TRUE);
+ }
+ if (interruptSources & isReceive)
+ {
+ int nRestartResult = 0;
+
+ do
+ {
+ LONG rxActive =
InterlockedIncrement(&pContext->dpcReceiveActive);
+ if (rxActive == 1)
+ {
+ uIndicatedRXPackets += ParaNdis_ProcessRxPath(pContext,
numOfPacketsToIndicate - uIndicatedRXPackets);
+ InterlockedDecrement(&pContext->dpcReceiveActive);
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ nRestartResult = ParaNdis_SynchronizeWithInterrupt(
+ pContext, pContext->ulRxMessage,
RestartQueueSynchronously, pContext->NetReceiveQueue);
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)3, nRestartResult,
0, 0);
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ DPrintf(nRestartResult ? 2 : 6, ("[%s] queue
restarted%s", __FUNCTION__, nRestartResult ? "(Rerun)" :
"(Done)"));
+
+ if (uIndicatedRXPackets < numOfPacketsToIndicate)
+ {
+
+ }
+ else if (uIndicatedRXPackets == numOfPacketsToIndicate)
+ {
+ DPrintf(1, ("[%s] Breaking Rx loop after %d
indications", __FUNCTION__, uIndicatedRXPackets));
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)4,
nRestartResult, 0, 0);
+ break;
+ }
+ else
+ {
+ DPrintf(0, ("[%s] Glitch found: %d allowed, %d
indicated", __FUNCTION__, numOfPacketsToIndicate, uIndicatedRXPackets));
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)6,
nRestartResult, 0, 0);
+ }
+ }
+ else
+ {
+ InterlockedDecrement(&pContext->dpcReceiveActive);
+ if (!nRestartResult)
+ {
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ nRestartResult = ParaNdis_SynchronizeWithInterrupt(
+ pContext, pContext->ulRxMessage,
RestartQueueSynchronously, pContext->NetReceiveQueue);
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)5,
nRestartResult, 0, 0);
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ }
+ DPrintf(1, ("[%s] Skip Rx processing no.%d",
__FUNCTION__, rxActive));
+ break;
+ }
+ } while (nRestartResult);
+
+ if (nRestartResult) stillRequiresProcessing |= isReceive;
+ }
+
+ if (interruptSources & isTransmit)
+ {
+ NdisAcquireSpinLock(&pContext->SendLock);
+ if (ParaNdis_SynchronizeWithInterrupt(pContext, pContext->ulTxMessage,
RestartQueueSynchronously, pContext->NetSendQueue))
+ stillRequiresProcessing |= isTransmit;
+ if(bDoKick)
+ {
+#ifdef PARANDIS_TEST_TX_KICK_ALWAYS
+ virtqueue_kick_always(pContext->NetSendQueue);
+#else
+ virtqueue_kick(pContext->NetSendQueue);
+#endif
+ }
+ NdisReleaseSpinLock(&pContext->SendLock);
+ }
+ }
+ InterlockedDecrement(&pContext->counterDPCInside);
+ ParaNdis_DebugHistory(pContext, hopDPC, NULL, stillRequiresProcessing,
pContext->nofFreeHardwareBuffers, pContext->nofFreeTxDescriptors);
+ }
+ return stillRequiresProcessing;
+}
+
+/**********************************************************
+Periodically called procedure, checking dpc activity
+If DPC are not running, it does exactly the same that the DPC
+Parameters:
+ context
+***********************************************************/
+static BOOLEAN CheckRunningDpc(PARANDIS_ADAPTER *pContext)
+{
+ BOOLEAN bStopped;
+ BOOLEAN bReportHang = FALSE;
+ bStopped = 0 != InterlockedExchange(&pContext->bDPCInactive, TRUE);
+
+ if (bStopped)
+ {
+ pContext->nDetectedInactivity++;
+ if (pContext->nEnableDPCChecker)
+ {
+ if (pContext->NetTxPacketsToReturn)
+ {
+ DPrintf(0, ("[%s] - NO ACTIVITY!", __FUNCTION__));
+ if (!pContext->Limits.nPrintDiagnostic) PrintStatistics(pContext);
+ if (pContext->nEnableDPCChecker > 1)
+ {
+ int isrStatus1, isrStatus2;
+ isrStatus1 = virtio_read_isr_status(&pContext->IODevice);
+ isrStatus2 = virtio_read_isr_status(&pContext->IODevice);
+ if (isrStatus1 || isrStatus2)
+ {
+ DPrintf(0, ("WARNING: Interrupt status %d=>%d",
isrStatus1, isrStatus2));
+ }
+ }
+ // simulateDPC
+ InterlockedOr(&pContext->InterruptStatus, isAny);
+ ParaNdis_DPCWorkBody(pContext, PARANDIS_UNLIMITED_PACKETS_TO_INDICATE);
+ }
+ }
+ }
+ else
+ {
+ pContext->nDetectedInactivity = 0;
+ }
+
+ NdisAcquireSpinLock(&pContext->SendLock);
+ if (pContext->nofFreeHardwareBuffers != pContext->maxFreeHardwareBuffers)
+ {
+ if (pContext->nDetectedStoppedTx++ > 1)
+ {
+ DPrintf(0, ("[%s] - Suspicious Tx inactivity (%d)!", __FUNCTION__,
pContext->nofFreeHardwareBuffers));
+ //bReportHang = TRUE;
+#ifdef DBG_USE_VIRTIO_PCI_ISR_FOR_HOST_REPORT
+ WriteVirtIODeviceByte(pContext->IODevice.isr, 0);
+#endif
+ }
+ }
+ NdisReleaseSpinLock(&pContext->SendLock);
+
+
+ if (pContext->Limits.nPrintDiagnostic &&
+ ++pContext->Counters.nPrintDiagnostic >=
pContext->Limits.nPrintDiagnostic)
+ {
+ pContext->Counters.nPrintDiagnostic = 0;
+ // todo - collect more and put out optionally
+ PrintStatistics(pContext);
+ }
+
+ if (pContext->Statistics.ifHCInOctets == pContext->Counters.prevIn)
+ {
+ pContext->Counters.nRxInactivity++;
+ if (pContext->Counters.nRxInactivity >= 10)
+ {
+//#define CRASH_ON_NO_RX
+#if defined(CRASH_ON_NO_RX)
+ ONPAUSECOMPLETEPROC proc = (ONPAUSECOMPLETEPROC)(PVOID)1;
+ proc(pContext);
+#endif
+ }
+ }
+ else
+ {
+ pContext->Counters.nRxInactivity = 0;
+ pContext->Counters.prevIn = pContext->Statistics.ifHCInOctets;
+ }
+ return bReportHang;
+}
+
+/**********************************************************
+Common implementation of periodic poll
+Parameters:
+ context
+Return:
+ TRUE, if reset required
+***********************************************************/
+BOOLEAN ParaNdis_CheckForHang(PARANDIS_ADAPTER *pContext)
+{
+ static int nHangOn = 0;
+ BOOLEAN b = nHangOn >= 3 && nHangOn < 6;
+ DEBUG_ENTRY(3);
+ b |= CheckRunningDpc(pContext);
+ //uncomment to cause 3 consecutive resets
+ //nHangOn++;
+ DEBUG_EXIT_STATUS(b ? 0 : 6, b);
+ return b;
+}
+
+/**********************************************************
+Common handler of multicast address configuration
+Parameters:
+ PVOID Buffer array of addresses from NDIS
+ ULONG BufferSize size of incoming buffer
+ PUINT pBytesRead update on success
+ PUINT pBytesNeeded update on wrong buffer size
+Return value:
+ SUCCESS or kind of failure
+***********************************************************/
+NDIS_STATUS ParaNdis_SetMulticastList(
+ PARANDIS_ADAPTER *pContext,
+ PVOID Buffer,
+ ULONG BufferSize,
+ PUINT pBytesRead,
+ PUINT pBytesNeeded)
+{
+ NDIS_STATUS status;
+ ULONG length = BufferSize;
+ if (length > sizeof(pContext->MulticastData.MulticastList))
+ {
+ status = NDIS_STATUS_MULTICAST_FULL;
+ *pBytesNeeded = sizeof(pContext->MulticastData.MulticastList);
+ }
+ else if (length % ETH_LENGTH_OF_ADDRESS)
+ {
+ status = NDIS_STATUS_INVALID_LENGTH;
+ *pBytesNeeded = (length / ETH_LENGTH_OF_ADDRESS) * ETH_LENGTH_OF_ADDRESS;
+ }
+ else
+ {
+ NdisZeroMemory(pContext->MulticastData.MulticastList,
sizeof(pContext->MulticastData.MulticastList));
+ if (length)
+ NdisMoveMemory(pContext->MulticastData.MulticastList, Buffer, length);
+ pContext->MulticastData.nofMulticastEntries = length / ETH_LENGTH_OF_ADDRESS;
+ DPrintf(1, ("[%s] New multicast list of %d bytes", __FUNCTION__,
length));
+ *pBytesRead = length;
+ status = NDIS_STATUS_SUCCESS;
+ }
+ return status;
+}
+
+/**********************************************************
+Callable from synchronized routine or interrupt handler
+to enable or disable Rx and/or Tx interrupt generation
+Parameters:
+ context
+ interruptSource - isReceive, isTransmit
+ b - 1/0 enable/disable
+***********************************************************/
+VOID ParaNdis_VirtIOEnableIrqSynchronized(PARANDIS_ADAPTER *pContext, ULONG
interruptSource)
+{
+ if (interruptSource & isTransmit)
+ virtqueue_enable_cb(pContext->NetSendQueue);
+ if (interruptSource & isReceive)
+ virtqueue_enable_cb(pContext->NetReceiveQueue);
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)0x10, interruptSource, TRUE, 0);
+}
+
+VOID ParaNdis_VirtIODisableIrqSynchronized(PARANDIS_ADAPTER *pContext, ULONG
interruptSource)
+{
+ if (interruptSource & isTransmit)
+ virtqueue_disable_cb(pContext->NetSendQueue);
+ if (interruptSource & isReceive)
+ virtqueue_disable_cb(pContext->NetReceiveQueue);
+ ParaNdis_DebugHistory(pContext, hopDPC, (PVOID)0x10, interruptSource, FALSE, 0);
+}
+
+/**********************************************************
+Common handler of PnP events
+Parameters:
+Return value:
+***********************************************************/
+VOID ParaNdis_OnPnPEvent(
+ PARANDIS_ADAPTER *pContext,
+ NDIS_DEVICE_PNP_EVENT pEvent,
+ PVOID pInfo,
+ ULONG ulSize)
+{
+ const char *pName = "";
+ DEBUG_ENTRY(0);
+#undef MAKECASE
+#define MAKECASE(x) case (x): pName = #x; break;
+ switch (pEvent)
+ {
+ MAKECASE(NdisDevicePnPEventQueryRemoved)
+ MAKECASE(NdisDevicePnPEventRemoved)
+ MAKECASE(NdisDevicePnPEventSurpriseRemoved)
+ MAKECASE(NdisDevicePnPEventQueryStopped)
+ MAKECASE(NdisDevicePnPEventStopped)
+ MAKECASE(NdisDevicePnPEventPowerProfileChanged)
+ default:
+ break;
+ }
+ ParaNdis_DebugHistory(pContext, hopPnpEvent, NULL, pEvent, 0, 0);
+ DPrintf(0, ("[%s] (%s)", __FUNCTION__, pName));
+ if (pEvent == NdisDevicePnPEventSurpriseRemoved)
+ {
+ // on simulated surprise removal (under PnpTest) we need to reset the device
+ // to prevent any access of device queues to memory buffers
+ pContext->bSurprizeRemoved = TRUE;
+ ParaNdis_ResetVirtIONetDevice(pContext);
+ }
+ pContext->PnpEvents[pContext->nPnpEventIndex++] = pEvent;
+ if (pContext->nPnpEventIndex >
sizeof(pContext->PnpEvents)/sizeof(pContext->PnpEvents[0]))
+ pContext->nPnpEventIndex = 0;
+}
+
+static BOOLEAN SendControlMessage(
+ PARANDIS_ADAPTER *pContext,
+ UCHAR cls,
+ UCHAR cmd,
+ PVOID buffer1,
+ ULONG size1,
+ PVOID buffer2,
+ ULONG size2,
+ int levelIfOK
+ )
+{
+ BOOLEAN bOK = FALSE;
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ if (pContext->ControlData.Virtual && pContext->ControlData.size >
(size1 + size2 + 16))
+ {
+ struct VirtIOBufferDescriptor sg[4];
+ PUCHAR pBase = (PUCHAR)pContext->ControlData.Virtual;
+ PHYSICAL_ADDRESS phBase = pContext->ControlData.Physical;
+ ULONG offset = 0;
+ UINT nOut = 1;
+
+ ((virtio_net_ctrl_hdr *)pBase)->class_of_command = cls;
+ ((virtio_net_ctrl_hdr *)pBase)->cmd = cmd;
+ sg[0].physAddr = phBase;
+ sg[0].length = sizeof(virtio_net_ctrl_hdr);
+ offset += sg[0].length;
+ offset = (offset + 3) & ~3;
+ if (size1)
+ {
+ NdisMoveMemory(pBase + offset, buffer1, size1);
+ sg[nOut].physAddr = phBase;
+ sg[nOut].physAddr.QuadPart += offset;
+ sg[nOut].length = size1;
+ offset += size1;
+ offset = (offset + 3) & ~3;
+ nOut++;
+ }
+ if (size2)
+ {
+ NdisMoveMemory(pBase + offset, buffer2, size2);
+ sg[nOut].physAddr = phBase;
+ sg[nOut].physAddr.QuadPart += offset;
+ sg[nOut].length = size2;
+ offset += size2;
+ offset = (offset + 3) & ~3;
+ nOut++;
+ }
+ sg[nOut].physAddr = phBase;
+ sg[nOut].physAddr.QuadPart += offset;
+ sg[nOut].length = sizeof(virtio_net_ctrl_ack);
+ *(virtio_net_ctrl_ack *)(pBase + offset) = VIRTIO_NET_ERR;
+
+ if (0 <= virtqueue_add_buf(pContext->NetControlQueue, sg, nOut, 1,
(PVOID)1, NULL, 0))
+ {
+ UINT len;
+ void *p;
+ virtqueue_kick_always(pContext->NetControlQueue);
+ p = virtqueue_get_buf(pContext->NetControlQueue, &len);
+ if (!p)
+ {
+ DPrintf(0, ("%s - ERROR: get_buf failed", __FUNCTION__));
+ }
+ else if (len != sizeof(virtio_net_ctrl_ack))
+ {
+ DPrintf(0, ("%s - ERROR: wrong len %d", __FUNCTION__, len));
+ }
+ else if (*(virtio_net_ctrl_ack *)(pBase + offset) != VIRTIO_NET_OK)
+ {
+ DPrintf(0, ("%s - ERROR: error %d returned", __FUNCTION__,
*(virtio_net_ctrl_ack *)(pBase + offset)));
+ }
+ else
+ {
+ // everything is OK
+ DPrintf(levelIfOK, ("%s OK(%d.%d,buffers of %d and %d) ",
__FUNCTION__, cls, cmd, size1, size2));
+ bOK = TRUE;
+ }
+ }
+ else
+ {
+ DPrintf(0, ("%s - ERROR: add_buf failed", __FUNCTION__));
+ }
+ }
+ else
+ {
+ DPrintf(0, ("%s (buffer %d,%d) - ERROR: message too LARGE",
__FUNCTION__, size1, size2));
+ }
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ return bOK;
+}
+
+static VOID ParaNdis_DeviceFiltersUpdateRxMode(PARANDIS_ADAPTER *pContext)
+{
+ u8 val;
+ ULONG f = pContext->PacketFilter;
+ val = (f & NDIS_PACKET_TYPE_ALL_MULTICAST) ? 1 : 0;
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE,
VIRTIO_NET_CTRL_RX_MODE_ALLMULTI, &val, sizeof(val), NULL, 0, 2);
+ //SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE,
VIRTIO_NET_CTRL_RX_MODE_ALLUNI, &val, sizeof(val), NULL, 0, 2);
+ val = (f & (NDIS_PACKET_TYPE_MULTICAST | NDIS_PACKET_TYPE_ALL_MULTICAST)) ? 0 :
1;
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE,
VIRTIO_NET_CTRL_RX_MODE_NOMULTI, &val, sizeof(val), NULL, 0, 2);
+ val = (f & NDIS_PACKET_TYPE_DIRECTED) ? 0 : 1;
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE, VIRTIO_NET_CTRL_RX_MODE_NOUNI,
&val, sizeof(val), NULL, 0, 2);
+ val = (f & NDIS_PACKET_TYPE_BROADCAST) ? 0 : 1;
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE,
VIRTIO_NET_CTRL_RX_MODE_NOBCAST, &val, sizeof(val), NULL, 0, 2);
+ val = (f & NDIS_PACKET_TYPE_PROMISCUOUS) ? 1 : 0;
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_RX_MODE,
VIRTIO_NET_CTRL_RX_MODE_PROMISC, &val, sizeof(val), NULL, 0, 2);
+}
+
+static VOID ParaNdis_DeviceFiltersUpdateAddresses(PARANDIS_ADAPTER *pContext)
+{
+ struct
+ {
+ struct virtio_net_ctrl_mac header;
+ UCHAR addr[ETH_LENGTH_OF_ADDRESS];
+ } uCast;
+ uCast.header.entries = 1;
+ NdisMoveMemory(uCast.addr, pContext->CurrentMacAddress, sizeof(uCast.addr));
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_MAC, VIRTIO_NET_CTRL_MAC_TABLE_SET,
+ &uCast, sizeof(uCast),
&pContext->MulticastData,sizeof(pContext->MulticastData.nofMulticastEntries) +
pContext->MulticastData.nofMulticastEntries * ETH_ALEN, 2);
+}
+
+static VOID SetSingleVlanFilter(PARANDIS_ADAPTER *pContext, ULONG vlanId, BOOLEAN bOn,
int levelIfOK)
+{
+ u16 val = vlanId & 0xfff;
+ UCHAR cmd = bOn ? VIRTIO_NET_CTRL_VLAN_ADD : VIRTIO_NET_CTRL_VLAN_DEL;
+ SendControlMessage(pContext, VIRTIO_NET_CTRL_VLAN, cmd, &val, sizeof(val), NULL,
0, levelIfOK);
+}
+
+static VOID SetAllVlanFilters(PARANDIS_ADAPTER *pContext, BOOLEAN bOn)
+{
+ ULONG i;
+ for (i = 0; i <= MAX_VLAN_ID; ++i)
+ SetSingleVlanFilter(pContext, i, bOn, 7);
+}
+
+/*
+ possible values of filter set (pContext->ulCurrentVlansFilterSet):
+ 0 - all disabled
+ 1..4095 - one selected enabled
+ 4096 - all enabled
+ Note that only 0th vlan can't be enabled
+*/
+VOID ParaNdis_DeviceFiltersUpdateVlanId(PARANDIS_ADAPTER *pContext)
+{
+ if (pContext->bHasHardwareFilters)
+ {
+ ULONG newFilterSet;
+ if (IsVlanSupported(pContext))
+ newFilterSet = pContext->VlanId ? pContext->VlanId : (MAX_VLAN_ID +
1);
+ else
+ newFilterSet = IsPrioritySupported(pContext) ? (MAX_VLAN_ID + 1) : 0;
+ if (newFilterSet != pContext->ulCurrentVlansFilterSet)
+ {
+ if (pContext->ulCurrentVlansFilterSet > MAX_VLAN_ID)
+ SetAllVlanFilters(pContext, FALSE);
+ else if (pContext->ulCurrentVlansFilterSet)
+ SetSingleVlanFilter(pContext, pContext->ulCurrentVlansFilterSet,
FALSE, 2);
+
+ pContext->ulCurrentVlansFilterSet = newFilterSet;
+
+ if (pContext->ulCurrentVlansFilterSet > MAX_VLAN_ID)
+ SetAllVlanFilters(pContext, TRUE);
+ else if (pContext->ulCurrentVlansFilterSet)
+ SetSingleVlanFilter(pContext, pContext->ulCurrentVlansFilterSet, TRUE,
2);
+ }
+ }
+}
+
+VOID ParaNdis_UpdateDeviceFilters(PARANDIS_ADAPTER *pContext)
+{
+ if (pContext->bHasHardwareFilters)
+ {
+ ParaNdis_DeviceFiltersUpdateRxMode(pContext);
+ ParaNdis_DeviceFiltersUpdateAddresses(pContext);
+ ParaNdis_DeviceFiltersUpdateVlanId(pContext);
+ }
+}
+
+NDIS_STATUS ParaNdis_PowerOn(PARANDIS_ADAPTER *pContext)
+{
+ LIST_ENTRY TempList;
+ NDIS_STATUS status;
+ DEBUG_ENTRY(0);
+ ParaNdis_DebugHistory(pContext, hopPowerOn, NULL, 1, 0, 0);
+ ParaNdis_ResetVirtIONetDevice(pContext);
+ virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_ACKNOWLEDGE |
VIRTIO_CONFIG_S_DRIVER);
+ /* virtio_get_features must be called once upon device initialization:
+ otherwise the device will not work properly */
+ (void)virtio_get_features(&pContext->IODevice);
+
+ if (pContext->bUseMergedBuffers)
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_MRG_RXBUF);
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_RING_F_EVENT_IDX))
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_RING_F_EVENT_IDX);
+ if (pContext->bDoGuestChecksumOnReceive)
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_NET_F_GUEST_CSUM);
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_VERSION_1))
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_VERSION_1);
+ if (VirtIODeviceGetHostFeature(pContext, VIRTIO_F_ANY_LAYOUT))
+ VirtIODeviceEnableGuestFeature(pContext, VIRTIO_F_ANY_LAYOUT);
+
+ status = FinalizeFeatures(pContext);
+ if (status == NDIS_STATUS_SUCCESS) {
+ status = FindNetQueues(pContext);
+ }
+ if (status != NDIS_STATUS_SUCCESS) {
+ virtio_add_status(&pContext->IODevice, VIRTIO_CONFIG_S_FAILED);
+ return status;
+ }
+
+ ParaNdis_RestoreDeviceConfigurationAfterReset(pContext);
+
+ ParaNdis_UpdateDeviceFilters(pContext);
+
+ InitializeListHead(&TempList);
+
+ /* submit all the receive buffers */
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+
+ pContext->ReuseBufferProc = (tReuseReceiveBufferProc)ReuseReceiveBufferRegular;
+
+ while (!IsListEmpty(&pContext->NetReceiveBuffers))
+ {
+ pIONetDescriptor pBufferDescriptor =
+ (pIONetDescriptor)RemoveHeadList(&pContext->NetReceiveBuffers);
+ InsertTailList(&TempList, &pBufferDescriptor->listEntry);
+ }
+ pContext->NetNofReceiveBuffers = 0;
+ while (!IsListEmpty(&TempList))
+ {
+ pIONetDescriptor pBufferDescriptor =
+ (pIONetDescriptor)RemoveHeadList(&TempList);
+ if (AddRxBufferToQueue(pContext, pBufferDescriptor))
+ {
+ InsertTailList(&pContext->NetReceiveBuffers,
&pBufferDescriptor->listEntry);
+ pContext->NetNofReceiveBuffers++;
+ }
+ else
+ {
+ DPrintf(0, ("FAILED TO REUSE THE BUFFER!!!!"));
+ VirtIONetFreeBufferDescriptor(pContext, pBufferDescriptor);
+ pContext->NetMaxReceiveBuffers--;
+ }
+ }
+ virtqueue_kick(pContext->NetReceiveQueue);
+ ParaNdis_SetPowerState(pContext, NdisDeviceStateD0);
+ pContext->bEnableInterruptHandlingDPC = TRUE;
+ virtio_device_ready(&pContext->IODevice);
+
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+
+ // if bFastSuspendInProcess is set by Win8 power-off procedure,
+ // the ParaNdis_Resume enables Tx and RX
+ // otherwise it does not do anything in Vista+ (Tx and RX are enabled after power-on
by Restart)
+ ParaNdis_Resume(pContext);
+ pContext->bFastSuspendInProcess = FALSE;
+
+ ParaNdis_ReportLinkStatus(pContext, TRUE);
+ ParaNdis_DebugHistory(pContext, hopPowerOn, NULL, 0, 0, 0);
+
+ return status;
+}
+
+VOID ParaNdis_PowerOff(PARANDIS_ADAPTER *pContext)
+{
+ DEBUG_ENTRY(0);
+ ParaNdis_DebugHistory(pContext, hopPowerOff, NULL, 1, 0, 0);
+
+ ParaNdis_IndicateConnect(pContext, FALSE, FALSE);
+
+ // if bFastSuspendInProcess is set by Win8 power-off procedure
+ // the ParaNdis_Suspend does fast Rx stop without waiting (=>srsPausing, if there
are some RX packets in Ndis)
+ pContext->bFastSuspendInProcess = pContext->bNoPauseOnSuspend &&
pContext->ReceiveState == srsEnabled;
+ ParaNdis_Suspend(pContext);
+ if (pContext->IODevice.addr)
+ {
+ /* back compat - remove the OK flag only in legacy mode */
+ VirtIODeviceRemoveStatus(&pContext->IODevice, VIRTIO_CONFIG_S_DRIVER_OK);
+ }
+
+ if (pContext->bFastSuspendInProcess)
+ {
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ pContext->ReuseBufferProc =
(tReuseReceiveBufferProc)ReuseReceiveBufferPowerOff;
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ }
+
+ ParaNdis_SetPowerState(pContext, NdisDeviceStateD3);
+
+ PreventDPCServicing(pContext);
+
+ /*******************************************************************
+ shutdown queues to have all the receive buffers under our control
+ all the transmit buffers move to list of free buffers
+ ********************************************************************/
+
+ NdisAcquireSpinLock(&pContext->SendLock);
+ virtqueue_shutdown(pContext->NetSendQueue);
+ while (!IsListEmpty(&pContext->NetSendBuffersInUse))
+ {
+ pIONetDescriptor pBufferDescriptor =
+ (pIONetDescriptor)RemoveHeadList(&pContext->NetSendBuffersInUse);
+ InsertTailList(&pContext->NetFreeSendBuffers,
&pBufferDescriptor->listEntry);
+ pContext->nofFreeTxDescriptors++;
+ pContext->nofFreeHardwareBuffers += pBufferDescriptor->nofUsedBuffers;
+ }
+ NdisReleaseSpinLock(&pContext->SendLock);
+
+ NdisAcquireSpinLock(&pContext->ReceiveLock);
+ virtqueue_shutdown(pContext->NetReceiveQueue);
+ NdisReleaseSpinLock(&pContext->ReceiveLock);
+ if (pContext->NetControlQueue) {
+ virtqueue_shutdown(pContext->NetControlQueue);
+ }
+
+ DPrintf(0, ("WARNING: deleting queues!!!!!!!!!"));
+ DeleteNetQueues(pContext);
+ pContext->NetSendQueue = NULL;
+ pContext->NetReceiveQueue = NULL;
+ pContext->NetControlQueue = NULL;
+
+ ParaNdis_ResetVirtIONetDevice(pContext);
+ ParaNdis_DebugHistory(pContext, hopPowerOff, NULL, 0, 0, 0);
+}
+
+void ParaNdis_CallOnBugCheck(PARANDIS_ADAPTER *pContext)
+{
+ if (pContext->IODevice.isr)
+ {
+#ifdef DBG_USE_VIRTIO_PCI_ISR_FOR_HOST_REPORT
+ WriteVirtIODeviceByte(pContext->IODevice.isr, 1);
+#endif
+ }
+}
+
+tChecksumCheckResult ParaNdis_CheckRxChecksum(PARANDIS_ADAPTER *pContext, ULONG
virtioFlags, PVOID pRxPacket, ULONG len)
+{
+ tOffloadSettingsFlags f = pContext->Offload.flags;
+ tChecksumCheckResult res, resIp;
+ PVOID pIpHeader = RtlOffsetToPointer(pRxPacket, ETH_HEADER_SIZE);
+ tTcpIpPacketParsingResult ppr;
+ ULONG flagsToCalculate = 0;
+ res.value = 0;
+ resIp.value = 0;
+
+ //VIRTIO_NET_HDR_F_NEEDS_CSUM - we need to calculate TCP/UDP CS
+ //VIRTIO_NET_HDR_F_DATA_VALID - host tells us TCP/UDP CS is OK
+
+ if (f.fRxIPChecksum) flagsToCalculate |= pcrIpChecksum; // check only
+
+ if (!(virtioFlags & VIRTIO_NET_HDR_F_DATA_VALID))
+ {
+ if (virtioFlags & VIRTIO_NET_HDR_F_NEEDS_CSUM)
+ {
+ flagsToCalculate |= pcrFixXxpChecksum | pcrTcpChecksum | pcrUdpChecksum;
+ }
+ else
+ {
+ if (f.fRxTCPChecksum) flagsToCalculate |= pcrTcpV4Checksum;
+ if (f.fRxUDPChecksum) flagsToCalculate |= pcrUdpV4Checksum;
+ if (f.fRxTCPv6Checksum) flagsToCalculate |= pcrTcpV6Checksum;
+ if (f.fRxUDPv6Checksum) flagsToCalculate |= pcrUdpV6Checksum;
+ }
+ }
+
+ ppr = ParaNdis_CheckSumVerify(pIpHeader, len - ETH_HEADER_SIZE, flagsToCalculate,
__FUNCTION__);
+
+ if (virtioFlags & VIRTIO_NET_HDR_F_DATA_VALID)
+ {
+ pContext->extraStatistics.framesRxCSHwOK++;
+ ppr.xxpCheckSum = ppresCSOK;
+ }
+
+ if (ppr.ipStatus == ppresIPV4 && !ppr.IsFragment)
+ {
+ if (f.fRxIPChecksum)
+ {
+ res.flags.IpOK = ppr.ipCheckSum == ppresCSOK;
+ res.flags.IpFailed = ppr.ipCheckSum == ppresCSBad;
+ }
+ if(ppr.xxpStatus == ppresXxpKnown)
+ {
+ if(ppr.TcpUdp == ppresIsTCP) /* TCP */
+ {
+ if (f.fRxTCPChecksum)
+ {
+ res.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
+ res.flags.TcpFailed = !res.flags.TcpOK;
+ }
+ }
+ else /* UDP */
+ {
+ if (f.fRxUDPChecksum)
+ {
+ res.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
+ res.flags.UdpFailed = !res.flags.UdpOK;
+ }
+ }
+ }
+ }
+ else if (ppr.ipStatus == ppresIPV6)
+ {
+ if(ppr.xxpStatus == ppresXxpKnown)
+ {
+ if(ppr.TcpUdp == ppresIsTCP) /* TCP */
+ {
+ if (f.fRxTCPv6Checksum)
+ {
+ res.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
+ res.flags.TcpFailed = !res.flags.TcpOK;
+ }
+ }
+ else /* UDP */
+ {
+ if (f.fRxUDPv6Checksum)
+ {
+ res.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK || ppr.fixedXxpCS;
+ res.flags.UdpFailed = !res.flags.UdpOK;
+ }
+ }
+ }
+ }
+
+ if (pContext->bDoIPCheckRx &&
+ (f.fRxIPChecksum || f.fRxTCPChecksum || f.fRxUDPChecksum || f.fRxTCPv6Checksum ||
f.fRxUDPv6Checksum))
+ {
+ ppr = ParaNdis_CheckSumVerify(pIpHeader, len - ETH_HEADER_SIZE, pcrAnyChecksum,
__FUNCTION__);
+ if (ppr.ipStatus == ppresIPV4 && !ppr.IsFragment)
+ {
+ resIp.flags.IpOK = !!f.fRxIPChecksum && ppr.ipCheckSum == ppresCSOK;
+ resIp.flags.IpFailed = !!f.fRxIPChecksum && ppr.ipCheckSum ==
ppresCSBad;
+ if (f.fRxTCPChecksum && ppr.xxpStatus == ppresXxpKnown &&
ppr.TcpUdp == ppresIsTCP)
+ {
+ resIp.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK;
+ resIp.flags.TcpFailed = ppr.xxpCheckSum == ppresCSBad;
+ }
+ if (f.fRxUDPChecksum && ppr.xxpStatus == ppresXxpKnown &&
ppr.TcpUdp == ppresIsUDP)
+ {
+ resIp.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK;
+ resIp.flags.UdpFailed = ppr.xxpCheckSum == ppresCSBad;
+ }
+ }
+ else if (ppr.ipStatus == ppresIPV6)
+ {
+ if (f.fRxTCPv6Checksum && ppr.xxpStatus == ppresXxpKnown &&
ppr.TcpUdp == ppresIsTCP)
+ {
+ resIp.flags.TcpOK = ppr.xxpCheckSum == ppresCSOK;
+ resIp.flags.TcpFailed = ppr.xxpCheckSum == ppresCSBad;
+ }
+ if (f.fRxUDPv6Checksum && ppr.xxpStatus == ppresXxpKnown &&
ppr.TcpUdp == ppresIsUDP)
+ {
+ resIp.flags.UdpOK = ppr.xxpCheckSum == ppresCSOK;
+ resIp.flags.UdpFailed = ppr.xxpCheckSum == ppresCSBad;
+ }
+ }
+
+ if (res.value != resIp.value)
+ {
+ // if HW did not set some bits that IP checker set, it is a mistake:
+ // or GOOD CS is not labeled, or BAD checksum is not labeled
+ tChecksumCheckResult diff;
+ diff.value = resIp.value & ~res.value;
+ if (diff.flags.IpFailed || diff.flags.TcpFailed || diff.flags.UdpFailed)
+ pContext->extraStatistics.framesRxCSHwMissedBad++;
+ if (diff.flags.IpOK || diff.flags.TcpOK || diff.flags.UdpOK)
+ pContext->extraStatistics.framesRxCSHwMissedGood++;
+ if (diff.value)
+ {
+ DPrintf(0, ("[%s] real %X <> %X (virtio %X)",
__FUNCTION__, resIp.value, res.value, virtioFlags));
+ }
+ res.value = resIp.value;
+ }
+ }
+
+ return res;
+}
diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Debug.c
b/drivers/network/dd/netkvm/Common/ParaNdis-Debug.c
new file mode 100644
index 00000000000..f66b92502f8
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/ParaNdis-Debug.c
@@ -0,0 +1,394 @@
+/*
+ * This file contains debug support procedures, common for NDIS5 and NDIS6
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include "ndis56common.h"
+#include "stdarg.h"
+#include "ntstrsafe.h"
+
+//#define OVERRIDE_DEBUG_BREAK
+
+#ifdef WPP_EVENT_TRACING
+#include "ParaNdis-Debug.tmh"
+#endif
+
+int virtioDebugLevel = 1;
+int nDebugLevel = 1;
+int bDebugPrint = 1;
+
+static NDIS_SPIN_LOCK CrashLock;
+
+static KBUGCHECK_REASON_CALLBACK_ROUTINE ParaNdis_OnBugCheck;
+static VOID NTAPI ParaNdis_OnBugCheck(
+ IN KBUGCHECK_CALLBACK_REASON Reason,
+ IN PKBUGCHECK_REASON_CALLBACK_RECORD Record,
+ IN OUT PVOID ReasonSpecificData,
+ IN ULONG ReasonSpecificDataLength
+);
+static VOID ParaNdis_PrepareBugCheckData();
+
+typedef BOOLEAN (*KeRegisterBugCheckReasonCallbackType) (
+ __out PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
+ __in PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
+ __in KBUGCHECK_CALLBACK_REASON Reason,
+ __in PUCHAR Component
+ );
+
+typedef BOOLEAN (*KeDeregisterBugCheckReasonCallbackType) (
+ __inout PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord
+ );
+
+typedef ULONG (*vDbgPrintExType)(
+ __in ULONG ComponentId,
+ __in ULONG Level,
+ __in PCCH Format,
+ __in va_list arglist
+ );
+
+static ULONG DummyPrintProcedure(
+ __in ULONG ComponentId,
+ __in ULONG Level,
+ __in PCCH Format,
+ __in va_list arglist
+ )
+{
+ return 0;
+}
+static BOOLEAN KeRegisterBugCheckReasonCallbackDummyProc(
+ __out PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
+ __in PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
+ __in KBUGCHECK_CALLBACK_REASON Reason,
+ __in PUCHAR Component
+ )
+{
+ CallbackRecord->State = 0;
+ return FALSE;
+}
+
+BOOLEAN KeDeregisterBugCheckReasonCallbackDummyProc(
+ __inout PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord
+ )
+{
+ return FALSE;
+}
+
+static vDbgPrintExType PrintProcedure = DummyPrintProcedure;
+static KeRegisterBugCheckReasonCallbackType BugCheckRegisterCallback =
KeRegisterBugCheckReasonCallbackDummyProc;
+static KeDeregisterBugCheckReasonCallbackType BugCheckDeregisterCallback =
KeDeregisterBugCheckReasonCallbackDummyProc;
+KBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord;
+
+#if !defined(WPP_EVENT_TRACING) || defined(WPP_USE_BYPASS)
+#if defined(DPFLTR_MASK)
+
+//common case, except Win2K
+static void DebugPrint(const char *fmt, ...)
+{
+ va_list list;
+ va_start(list, fmt);
+ PrintProcedure(DPFLTR_DEFAULT_ID, 9 | DPFLTR_MASK, fmt, list);
+#if defined(VIRTIO_DBG_USE_IOPORT)
+ {
+ NTSTATUS status;
+ // use this way of output only for DISPATCH_LEVEL,
+ // higher requires more protection
+ if (KeGetCurrentIrql() <= DISPATCH_LEVEL)
+ {
+ char buf[256];
+ size_t len, i;
+ buf[0] = 0;
+ status = RtlStringCbVPrintfA(buf, sizeof(buf), fmt, list);
+ if (status == STATUS_SUCCESS) len = strlen(buf);
+ else if (status == STATUS_BUFFER_OVERFLOW) len = sizeof(buf);
+ else { memcpy(buf, "Can't print", 11); len = 11; }
+ NdisAcquireSpinLock(&CrashLock);
+ for (i = 0; i < len; ++i)
+ {
+ NdisRawWritePortUchar(VIRTIO_DBG_USE_IOPORT, buf[i]);
+ }
+ NdisRawWritePortUchar(VIRTIO_DBG_USE_IOPORT, '\n');
+ NdisReleaseSpinLock(&CrashLock);
+ }
+ }
+#endif
+}
+
+DEBUGPRINTFUNC pDebugPrint = DebugPrint;
+DEBUGPRINTFUNC VirtioDebugPrintProc = DebugPrint;
+
+#else //DPFLTR_MASK
+#pragma message("DebugPrint for Win2K")
+
+DEBUGPRINTFUNC pDebugPrint = DbgPrint;
+DEBUGPRINTFUNC VirtioDebugPrintProc = DbgPrint;
+
+#endif //DPFLTR_MASK
+#endif //!defined(WPP_EVENT_TRACING) || defined(WPP_USE_BYPASS)
+
+
+
+void _LogOutEntry(int level, const char *s)
+{
+ DPrintf(level, ("[%s]=>", s));
+}
+
+void _LogOutExitValue(int level, const char *s, ULONG value)
+{
+ DPrintf(level, ("[%s]<=0x%X", s, value));
+}
+
+void _LogOutString(int level, const char *s)
+{
+ DPrintf(level, ("[%s]", s));
+}
+
+VOID WppEnableCallback(
+ __in LPCGUID Guid,
+ __in __int64 Logger,
+ __in BOOLEAN Enable,
+ __in ULONG Flags,
+ __in UCHAR Level)
+{
+#if WPP_USE_BYPASS
+ DPrintfBypass(0, ("[%s] %s, flags %X, level %d",
+ __FUNCTION__, Enable ? "enabled" : "disabled",
+ Flags, (ULONG)Level));
+#endif
+ nDebugLevel = Level;
+ bDebugPrint = Enable;
+}
+
+
+#ifdef OVERRIDE_DEBUG_BREAK
+static PUCHAR pDbgBreakPoint;
+static UCHAR DbgBreakPointChunk[5];
+static void AnotherDbgBreak()
+{
+ DPrintf(0, ("Somebody tried to break into the debugger!"));
+}
+#endif
+
+void ParaNdis_DebugInitialize(PVOID DriverObject,PVOID RegistryPath)
+{
+ NDIS_STRING usRegister, usDeregister, usPrint;
+ PVOID pr, pd;
+ BOOLEAN res;
+ WPP_INIT_TRACING(DriverObject, RegistryPath);
+
+ NdisAllocateSpinLock(&CrashLock);
+ KeInitializeCallbackRecord(&CallbackRecord);
+ ParaNdis_PrepareBugCheckData();
+ NdisInitUnicodeString(&usPrint, L"vDbgPrintEx");
+ NdisInitUnicodeString(&usRegister,
L"KeRegisterBugCheckReasonCallback");
+ NdisInitUnicodeString(&usDeregister,
L"KeDeregisterBugCheckReasonCallback");
+ pd = MmGetSystemRoutineAddress(&usPrint);
+ if (pd) PrintProcedure = (vDbgPrintExType)pd;
+ pr = MmGetSystemRoutineAddress(&usRegister);
+ pd = MmGetSystemRoutineAddress(&usDeregister);
+ if (pr && pd)
+ {
+ BugCheckRegisterCallback = (KeRegisterBugCheckReasonCallbackType)pr;
+ BugCheckDeregisterCallback = (KeDeregisterBugCheckReasonCallbackType)pd;
+ }
+ res = BugCheckRegisterCallback(&CallbackRecord, ParaNdis_OnBugCheck,
KbCallbackSecondaryDumpData, "NetKvm");
+ DPrintf(0, ("[%s] Crash callback %sregistered", __FUNCTION__, res ?
"" : "NOT "));
+
+#ifdef OVERRIDE_DEBUG_BREAK
+ if (sizeof(PVOID) == sizeof(ULONG))
+ {
+ UCHAR replace[5] = {0xe9,0,0,0,0};
+ ULONG replacement;
+ NDIS_STRING usDbgBreakPointName;
+ NdisInitUnicodeString(&usDbgBreakPointName, L"DbgBreakPoint");
+ pDbgBreakPoint = (PUCHAR)MmGetSystemRoutineAddress(&usDbgBreakPointName);
+ if (pDbgBreakPoint)
+ {
+ DPrintf(0, ("Replacing original BP handler at %p",
pDbgBreakPoint));
+ replacement = RtlPointerToOffset(pDbgBreakPoint + 5, AnotherDbgBreak);
+ RtlCopyMemory(replace + 1, &replacement, sizeof(replacement));
+ RtlCopyMemory(DbgBreakPointChunk, pDbgBreakPoint,
sizeof(DbgBreakPointChunk));
+ RtlCopyMemory(pDbgBreakPoint, replace, sizeof(replace));
+ }
+ }
+#endif
+}
+
+void ParaNdis_DebugCleanup(PDRIVER_OBJECT pDriverObject)
+{
+#ifdef OVERRIDE_DEBUG_BREAK
+ if (sizeof(PVOID) == sizeof(ULONG) && pDbgBreakPoint)
+ {
+ DPrintf(0, ("Restoring original BP handler at %p", pDbgBreakPoint));
+ RtlCopyMemory(pDbgBreakPoint, DbgBreakPointChunk, sizeof(DbgBreakPointChunk));
+ }
+#endif
+ BugCheckDeregisterCallback(&CallbackRecord);
+ WPP_CLEANUP(pDriverObject);
+}
+
+
+#define MAX_CONTEXTS 4
+#if defined(ENABLE_HISTORY_LOG)
+#define MAX_HISTORY 0x40000
+#else
+#define MAX_HISTORY 2
+#endif
+typedef struct _tagBugCheckStaticData
+{
+ tBugCheckStaticDataHeader Header;
+ tBugCheckPerNicDataContent PerNicData[MAX_CONTEXTS];
+ tBugCheckStaticDataContent Data;
+ tBugCheckHistoryDataEntry History[MAX_HISTORY];
+}tBugCheckStaticData;
+
+
+typedef struct _tagBugCheckData
+{
+ tBugCheckStaticData StaticData;
+ tBugCheckDataLocation Location;
+}tBugCheckData;
+
+static tBugCheckData BugCheckData;
+static BOOLEAN bNative = TRUE;
+
+VOID ParaNdis_PrepareBugCheckData()
+{
+ BugCheckData.StaticData.Header.StaticDataVersion =
PARANDIS_DEBUG_STATIC_DATA_VERSION;
+ BugCheckData.StaticData.Header.PerNicDataVersion =
PARANDIS_DEBUG_PER_NIC_DATA_VERSION;
+ BugCheckData.StaticData.Header.ulMaxContexts = MAX_CONTEXTS;
+ BugCheckData.StaticData.Header.SizeOfPointer = sizeof(PVOID);
+ BugCheckData.StaticData.Header.PerNicData =
(UINT_PTR)(PVOID)BugCheckData.StaticData.PerNicData;
+ BugCheckData.StaticData.Header.DataArea = (UINT64)&BugCheckData.StaticData.Data;
+ BugCheckData.StaticData.Header.DataAreaSize = sizeof(BugCheckData.StaticData.Data);
+ BugCheckData.StaticData.Data.HistoryDataVersion =
PARANDIS_DEBUG_HISTORY_DATA_VERSION;
+ BugCheckData.StaticData.Data.SizeOfHistory = MAX_HISTORY;
+ BugCheckData.StaticData.Data.SizeOfHistoryEntry = sizeof(tBugCheckHistoryDataEntry);
+ BugCheckData.StaticData.Data.HistoryData =
(UINT_PTR)(PVOID)BugCheckData.StaticData.History;
+ BugCheckData.Location.Address = (UINT64)&BugCheckData;
+ BugCheckData.Location.Size = sizeof(BugCheckData);
+}
+
+void ParaNdis_DebugRegisterMiniport(PARANDIS_ADAPTER *pContext, BOOLEAN bRegister)
+{
+ UINT i;
+ NdisAcquireSpinLock(&CrashLock);
+ for (i = 0; i < MAX_CONTEXTS; ++i)
+ {
+ UINT64 val1 = bRegister ? 0 : (UINT_PTR)pContext;
+ UINT64 val2 = bRegister ? (UINT_PTR)pContext : 0;
+ if (BugCheckData.StaticData.PerNicData[i].Context != val1) continue;
+ BugCheckData.StaticData.PerNicData[i].Context = val2;
+ break;
+ }
+ NdisReleaseSpinLock(&CrashLock);
+}
+
+static UINT FillDataOnBugCheck()
+{
+ UINT i, n = 0;
+ NdisGetCurrentSystemTime(&BugCheckData.StaticData.Header.qCrashTime);
+ for (i = 0; i < MAX_CONTEXTS; ++i)
+ {
+ tBugCheckPerNicDataContent *pSave = &BugCheckData.StaticData.PerNicData[i];
+ PARANDIS_ADAPTER *p = (PARANDIS_ADAPTER *)pSave->Context;
+ if (!p) continue;
+ pSave->nofPacketsToComplete = p->NetTxPacketsToReturn;
+ pSave->nofReadyTxBuffers = p->nofFreeHardwareBuffers;
+ pSave->LastInterruptTimeStamp.QuadPart =
PARANDIS_GET_LAST_INTERRUPT_TIMESTAMP(p);
+ pSave->LastTxCompletionTimeStamp = p->LastTxCompletionTimeStamp;
+ ParaNdis_CallOnBugCheck(p);
+ ++n;
+ }
+ return n;
+}
+
+VOID NTAPI ParaNdis_OnBugCheck(
+ IN KBUGCHECK_CALLBACK_REASON Reason,
+ IN PKBUGCHECK_REASON_CALLBACK_RECORD Record,
+ IN OUT PVOID ReasonSpecificData,
+ IN ULONG ReasonSpecificDataLength
+ )
+{
+ KBUGCHECK_SECONDARY_DUMP_DATA *pDump = (KBUGCHECK_SECONDARY_DUMP_DATA
*)ReasonSpecificData;
+ if (KbCallbackSecondaryDumpData == Reason && ReasonSpecificDataLength >=
sizeof(*pDump))
+ {
+ ULONG dumpSize = sizeof(BugCheckData.Location);
+ if (!pDump->OutBuffer)
+ {
+ UINT nSaved;
+ nSaved = FillDataOnBugCheck();
+ if (pDump->InBufferLength >= dumpSize)
+ {
+ pDump->OutBuffer = pDump->InBuffer;
+ pDump->OutBufferLength = dumpSize;
+ }
+ else
+ {
+ pDump->OutBuffer = &BugCheckData.Location;
+ pDump->OutBufferLength = dumpSize;
+ bNative = FALSE;
+ }
+ DPrintf(0, ("[%s] system buffer of %d, saving data for %d NIC",
__FUNCTION__,pDump->InBufferLength, nSaved));
+ DPrintf(0, ("[%s] using %s buffer", __FUNCTION__, bNative ?
"native" : "own"));
+ }
+ else if (pDump->OutBuffer == pDump->InBuffer)
+ {
+ RtlCopyMemory(&pDump->Guid, &ParaNdis_CrashGuid,
sizeof(pDump->Guid));
+ RtlCopyMemory(pDump->InBuffer, &BugCheckData.Location, dumpSize);
+ pDump->OutBufferLength = dumpSize;
+ DPrintf(0, ("[%s] written %d to %p", __FUNCTION__,
(ULONG)BugCheckData.Location.Size, (UINT_PTR)BugCheckData.Location.Address ));
+ DPrintf(0, ("[%s] dump data (%d) at %p", __FUNCTION__,
pDump->OutBufferLength, pDump->OutBuffer));
+ }
+ }
+}
+
+#if defined(ENABLE_HISTORY_LOG)
+void ParaNdis_DebugHistory(
+ PARANDIS_ADAPTER *pContext,
+ eHistoryLogOperation op,
+ PVOID pParam1,
+ ULONG lParam2,
+ ULONG lParam3,
+ ULONG lParam4)
+{
+ tBugCheckHistoryDataEntry *phe;
+ ULONG index =
InterlockedIncrement(&BugCheckData.StaticData.Data.CurrentHistoryIndex);
+ index = (index - 1) % MAX_HISTORY;
+ phe = &BugCheckData.StaticData.History[index];
+ phe->Context = (UINT_PTR)pContext;
+ phe->operation = op;
+ phe->pParam1 = (UINT_PTR)pParam1;
+ phe->lParam2 = lParam2;
+ phe->lParam3 = lParam3;
+ phe->lParam4 = lParam4;
+#if (PARANDIS_DEBUG_HISTORY_DATA_VERSION == 1)
+ phe->uIRQL = KeGetCurrentIrql();
+ phe->uProcessor = KeGetCurrentProcessorNumber();
+#endif
+ NdisGetCurrentSystemTime(&phe->TimeStamp);
+}
+
+#endif
diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Oid.c
b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.c
new file mode 100644
index 00000000000..8d54b445dca
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.c
@@ -0,0 +1,677 @@
+/*
+ * This file contains NDIS OID support procedures, common for NDIS5 and NDIS6
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include "ParaNdis-Oid.h"
+
+#ifdef WPP_EVENT_TRACING
+#include "ParaNdis-Oid.tmh"
+#endif
+#include <sal.h>
+
+static const char VendorName[] = "Red Hat";
+
+static UCHAR FORCEINLINE hexdigit(UCHAR nibble)
+{
+ UCHAR c = nibble & 0xf;
+ c += (c <= 9) ? 0 : 7;
+ c += '0';
+ return c;
+}
+
+/**********************************************************
+Common implementation of copy operation when OID is set
+pOid->Flags (if used) controls when the source data may be truncated or padded on
copy
+Parameters:
+ tOidDesc *pOid - descriptor of OID
+ PVOID pDest - buffer to receive data sent by NDIS
+ ULONG ulSize - size of data to copy
+Return value:
+ SUCCESS or NDIS error code if target buffer size is wrong
+Rules:
+
+PDEST <>OK SIZE PAYLOAD SZ
+NULL any n/a any fail
+BUFF any 0 any success, none copied
+BUFF any SZ ==SZ success, copied SZ
+BUFF !lessok SZ <SZ fail (small), none copied
+BUFF !moreok SZ >SZ fail (overflow), none copied
+BUFF lessok SZ <SZ success, SZ cleared, payload sz
copied
+BUFF moreok SZ >SZ success, copied SZ
+***************************************************/
+NDIS_STATUS ParaNdis_OidSetCopy(
+ tOidDesc *pOid,
+ PVOID pDest,
+ ULONG ulSize)
+{
+ NDIS_STATUS status = NDIS_STATUS_SUCCESS;
+ if (!pDest)
+ {
+ status = NDIS_STATUS_INVALID_OID;
+ *(pOid->pBytesRead) = 0;
+ *(pOid->pBytesNeeded) = 0;
+ }
+ else if (ulSize)
+ {
+ if (pOid->InformationBufferLength < ulSize)
+ {
+ if (pOid->ulToDoFlags & ohfSetLessOK)
+ {
+ *(pOid->pBytesRead) = pOid->InformationBufferLength;
+ NdisZeroMemory(pDest, ulSize);
+ NdisMoveMemory(pDest, pOid->InformationBuffer,
pOid->InformationBufferLength);
+ }
+ else
+ {
+ status = NDIS_STATUS_BUFFER_TOO_SHORT;
+ *(pOid->pBytesRead) = 0;
+ *(pOid->pBytesNeeded) = ulSize;
+ }
+ }
+ else if (pOid->InformationBufferLength == ulSize || (pOid->ulToDoFlags
& ohfSetMoreOK))
+ {
+ *(pOid->pBytesRead) = ulSize;
+ NdisMoveMemory(pDest, pOid->InformationBuffer, ulSize);
+ }
+ else
+ {
+ status = NDIS_STATUS_BUFFER_OVERFLOW;
+ *(pOid->pBytesNeeded) = ulSize;
+ *(pOid->pBytesRead) = 0;
+ }
+ }
+ else
+ {
+ *(pOid->pBytesRead) = pOid->InformationBufferLength;
+ }
+ return status;
+}
+
+
+/**********************************************************
+Common handler of setting packet filter
+***********************************************************/
+NDIS_STATUS ParaNdis_OnSetPacketFilter(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ ULONG newValue;
+ NDIS_STATUS status = ParaNdis_OidSetCopy(
+ pOid,
+ &newValue,
+ sizeof(newValue));
+
+ if (newValue & ~PARANDIS_PACKET_FILTERS)
+ status = NDIS_STATUS_INVALID_DATA;
+
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ pContext->PacketFilter = newValue;
+ DPrintf(1, ("[%s] PACKET FILTER SET TO %x", __FUNCTION__,
pContext->PacketFilter));
+ ParaNdis_UpdateDeviceFilters(pContext);
+ }
+ return status;
+}
+
+void ParaNdis_FillPowerCapabilities(PNDIS_PNP_CAPABILITIES pCaps)
+{
+ NdisZeroMemory(pCaps, sizeof(*pCaps));
+ pCaps->WakeUpCapabilities.MinMagicPacketWakeUp = NdisDeviceStateUnspecified;
+ pCaps->WakeUpCapabilities.MinPatternWakeUp = NdisDeviceStateUnspecified;
+ pCaps->WakeUpCapabilities.MinLinkChangeWakeUp = NdisDeviceStateUnspecified;
+}
+
+
+/**********************************************************
+Common handler of setting multicast list
+***********************************************************/
+NDIS_STATUS ParaNdis_OnOidSetMulticastList(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ NDIS_STATUS status;
+ status = ParaNdis_SetMulticastList(
+ pContext,
+ pOid->InformationBuffer,
+ pOid->InformationBufferLength,
+ pOid->pBytesRead,
+ pOid->pBytesNeeded);
+ ParaNdis_UpdateDeviceFilters(pContext);
+ return status;
+}
+
+/**********************************************************
+Common helper of copy operation on GET OID
+Copies data from specified location to NDIS buffer
+64-bit variable will be casted to 32-bit, if specified on pOid->Flags
+
+Parameters:
+ tOidDesc *pOid - descriptor of OID
+ PVOID pInfo - source to copy from
+ ULONG ulSize - source info size
+Return value:
+ SUCCESS or kind of failure when the dest buffer size is wrong
+Comments:
+pInfo must be non-NULL, otherwise error returned
+ulSize may be 0, then SUCCESS returned without copy
+***********************************************************/
+NDIS_STATUS ParaNdis_OidQueryCopy(
+ tOidDesc *pOid,
+ PVOID pInfo,
+ ULONG ulSize,
+ BOOLEAN bFreeInfo)
+{
+ NDIS_STATUS status = NDIS_STATUS_SUCCESS;
+ *(pOid->pBytesNeeded) = ulSize;
+ if (!pInfo)
+ {
+ status = NDIS_STATUS_INVALID_OID;
+ *(pOid->pBytesWritten) = 0;
+ *(pOid->pBytesNeeded) = 0;
+ }
+ else if (pOid->InformationBufferLength >= ulSize)
+ {
+ if (ulSize) NdisMoveMemory(pOid->InformationBuffer, pInfo, ulSize);
+ *(pOid->pBytesWritten) = ulSize;
+ *(pOid->pBytesNeeded) = 0;
+ }
+ else if ((pOid->ulToDoFlags & ohfQuery3264) &&
pOid->InformationBufferLength == sizeof(ULONG) && ulSize == sizeof(ULONG64))
+ {
+ ULONG64 u64 = *(ULONG64 *)pInfo;
+ ULONG ul = (ULONG)u64;
+ NdisMoveMemory(pOid->InformationBuffer, &ul, sizeof(ul));
+ *(pOid->pBytesWritten) = sizeof(ul);
+ }
+ else
+ {
+ status = NDIS_STATUS_BUFFER_TOO_SHORT;
+ *(pOid->pBytesWritten) = 0;
+ }
+ if (bFreeInfo && pInfo)
+ {
+ NdisFreeMemory(pInfo, 0, 0);
+ }
+ return status;
+}
+
+/**********************************************************
+Common handler of Oid queries
+Parameters:
+ context
+ tOidDesc *pOid - filled descriptor of OID operation
+Return value:
+ SUCCESS or kind of failure
+***********************************************************/
+NDIS_STATUS ParaNdis_OidQueryCommon(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ NDIS_STATUS status = NDIS_STATUS_SUCCESS;
+ PVOID pInfo = NULL;
+ ULONG ulSize = 0;
+ BOOLEAN bFreeInfo = FALSE;
+ union _tagtemp
+ {
+ NDIS_MEDIUM Medium;
+ ULONG64 ul64;
+ ULONG ul;
+ USHORT us;
+ NDIS_PNP_CAPABILITIES PMCaps;
+ } u;
+#if defined(_MSC_VER)
+ #define CONCATFIELD(object, field) object.##field
+#else
+ #define CONCATFIELD(object, field) object.field
+#endif
+#define SETINFO(field, value) pInfo = CONCATFIELD(&u, field); ulSize =
sizeof(CONCATFIELD(u, field)); CONCATFIELD(u, field) = (value)
+ switch (pOid->Oid)
+ {
+ case OID_GEN_SUPPORTED_LIST:
+ ParaNdis_GetSupportedOid(&pInfo, &ulSize);
+ break;
+ case OID_GEN_HARDWARE_STATUS:
+ SETINFO(ul, NdisHardwareStatusReady);
+ break;
+ case OID_GEN_MEDIA_SUPPORTED:
+ __fallthrough;
+ case OID_GEN_MEDIA_IN_USE:
+ SETINFO(Medium, NdisMedium802_3);
+ break;
+ case OID_GEN_MAXIMUM_LOOKAHEAD:
+ SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS);
+ break;
+ case OID_GEN_MAXIMUM_FRAME_SIZE:
+ SETINFO(ul, pContext->MaxPacketSize.nMaxDataSize);
+ break;
+ case OID_GEN_TRANSMIT_BUFFER_SPACE:
+ SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS *
pContext->nofFreeTxDescriptors);
+ break;
+ case OID_GEN_RECEIVE_BUFFER_SPACE:
+ SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS *
pContext->NetMaxReceiveBuffers);
+ break;
+ case OID_GEN_RECEIVE_BLOCK_SIZE:
+ __fallthrough;
+ case OID_GEN_TRANSMIT_BLOCK_SIZE:
+ __fallthrough;
+ case OID_GEN_MAXIMUM_TOTAL_SIZE:
+ SETINFO(ul, pContext->MaxPacketSize.nMaxFullSizeOS);
+ break;
+ case OID_GEN_TRANSMIT_QUEUE_LENGTH:
+ // TODO: this is not completely correct, but only if
+ // the TX queue is not full
+ SETINFO(ul, pContext->maxFreeTxDescriptors -
pContext->nofFreeTxDescriptors);
+ break;
+ case OID_GEN_VENDOR_ID:
+ SETINFO(ul, 0x00ffffff);
+ break;
+ case OID_GEN_VENDOR_DESCRIPTION:
+ pInfo = (PVOID)VendorName;
+ ulSize = sizeof(VendorName);
+ break;
+
+ case OID_GEN_VENDOR_DRIVER_VERSION:
+ SETINFO(ul, (NDIS_MINIPORT_MAJOR_VERSION << 16) |
NDIS_MINIPORT_MINOR_VERSION);
+ break;
+ case OID_GEN_CURRENT_PACKET_FILTER:
+ pInfo = &pContext->PacketFilter;
+ ulSize = sizeof(pContext->PacketFilter);
+ break;
+ case OID_GEN_DRIVER_VERSION:
+ SETINFO(us, ((NDIS_MINIPORT_MAJOR_VERSION << 8) |
NDIS_MINIPORT_MINOR_VERSION));
+ break;
+ case OID_GEN_MAC_OPTIONS:
+ {
+ ULONG options = NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA |
+ NDIS_MAC_OPTION_TRANSFERS_NOT_PEND |
+ NDIS_MAC_OPTION_NO_LOOPBACK;
+ if (IsPrioritySupported(pContext))
+ options |= NDIS_MAC_OPTION_8021P_PRIORITY;
+ if (IsVlanSupported(pContext))
+ options |= NDIS_MAC_OPTION_8021Q_VLAN;
+ SETINFO(ul, options);
+ }
+ break;
+ case OID_GEN_MEDIA_CONNECT_STATUS:
+ SETINFO(ul, pContext->bConnected ? NdisMediaStateConnected :
NdisMediaStateDisconnected);
+ //NdisMediaStateConnected:
+ break;
+ case OID_GEN_MAXIMUM_SEND_PACKETS:
+ // NDIS ignores it for deserialized drivers
+ SETINFO(ul,pContext->nofFreeTxDescriptors);
+ break;
+ case OID_802_3_PERMANENT_ADDRESS:
+ pInfo = pContext->PermanentMacAddress;
+ ulSize = sizeof(pContext->PermanentMacAddress);
+ break;
+ case OID_802_3_CURRENT_ADDRESS:
+ pInfo = pContext->CurrentMacAddress;
+ ulSize = sizeof(pContext->CurrentMacAddress);
+ break;
+ case OID_PNP_QUERY_POWER:
+ // size if 0, just to indicate success
+ pInfo = &status;
+ break;
+ case OID_GEN_DIRECTED_BYTES_XMIT:
+ SETINFO(ul64, pContext->Statistics.ifHCOutUcastOctets);
+ break;
+ case OID_GEN_DIRECTED_FRAMES_XMIT:
+ SETINFO(ul64, pContext->Statistics.ifHCOutUcastPkts);
+ break;
+ case OID_GEN_MULTICAST_BYTES_XMIT:
+ SETINFO(ul64, pContext->Statistics.ifHCOutMulticastOctets);
+ break;
+ case OID_GEN_MULTICAST_FRAMES_XMIT:
+ SETINFO(ul64, pContext->Statistics.ifHCOutMulticastPkts);
+ break;
+ case OID_GEN_BROADCAST_BYTES_XMIT:
+ SETINFO(ul64, pContext->Statistics.ifHCOutBroadcastOctets);
+ break;
+ case OID_GEN_BROADCAST_FRAMES_XMIT:
+ SETINFO(ul64, pContext->Statistics.ifHCOutBroadcastPkts);
+ break;
+ case OID_GEN_DIRECTED_BYTES_RCV:
+ SETINFO(ul64, pContext->Statistics.ifHCInUcastOctets);
+ break;
+ case OID_GEN_DIRECTED_FRAMES_RCV:
+ SETINFO(ul64, pContext->Statistics.ifHCInUcastPkts);
+ break;
+ case OID_GEN_MULTICAST_BYTES_RCV:
+ SETINFO(ul64, pContext->Statistics.ifHCInMulticastOctets);
+ break;
+ case OID_GEN_MULTICAST_FRAMES_RCV:
+ SETINFO(ul64, pContext->Statistics.ifHCInMulticastPkts);
+ break;
+ case OID_GEN_BROADCAST_BYTES_RCV:
+ SETINFO(ul64, pContext->Statistics.ifHCInBroadcastOctets);
+ break;
+ case OID_GEN_BROADCAST_FRAMES_RCV:
+ SETINFO(ul64, pContext->Statistics.ifHCInBroadcastPkts);
+ break;
+ case OID_GEN_XMIT_OK:
+ SETINFO(ul64,
+ pContext->Statistics.ifHCOutUcastPkts +
+ pContext->Statistics.ifHCOutMulticastPkts +
+ pContext->Statistics.ifHCOutBroadcastPkts);
+ break;
+ case OID_GEN_RCV_OK:
+ SETINFO(ul64,
+ pContext->Statistics.ifHCInUcastPkts +
+ pContext->Statistics.ifHCInMulticastPkts +
+ pContext->Statistics.ifHCInBroadcastPkts);
+ DPrintf(4, ("[%s] Total frames %I64u", __FUNCTION__, u.ul64));
+ break;
+ case OID_GEN_XMIT_ERROR:
+ SETINFO(ul64, pContext->Statistics.ifOutErrors );
+ break;
+ case OID_GEN_RCV_ERROR:
+ __fallthrough;
+ case OID_GEN_RCV_NO_BUFFER:
+ __fallthrough;
+ case OID_802_3_RCV_OVERRUN:
+ __fallthrough;
+ case OID_GEN_RCV_CRC_ERROR:
+ __fallthrough;
+ case OID_802_3_RCV_ERROR_ALIGNMENT:
+ __fallthrough;
+ case OID_802_3_XMIT_UNDERRUN:
+ __fallthrough;
+ case OID_802_3_XMIT_ONE_COLLISION:
+ __fallthrough;
+ case OID_802_3_XMIT_DEFERRED:
+ __fallthrough;
+ case OID_802_3_XMIT_MAX_COLLISIONS:
+ __fallthrough;
+ case OID_802_3_XMIT_MORE_COLLISIONS:
+ __fallthrough;
+ case OID_802_3_XMIT_HEARTBEAT_FAILURE:
+ __fallthrough;
+ case OID_802_3_XMIT_TIMES_CRS_LOST:
+ __fallthrough;
+ case OID_802_3_XMIT_LATE_COLLISIONS:
+ SETINFO(ul64, 0);
+ break;
+ case OID_802_3_MULTICAST_LIST:
+ pInfo = pContext->MulticastData.MulticastList;
+ ulSize = pContext->MulticastData.nofMulticastEntries * ETH_LENGTH_OF_ADDRESS;
+ break;
+ case OID_802_3_MAXIMUM_LIST_SIZE:
+ SETINFO(ul, PARANDIS_MULTICAST_LIST_SIZE);
+ break;
+ case OID_PNP_CAPABILITIES:
+ pInfo = &u.PMCaps;
+ ulSize = sizeof(u.PMCaps);
+ ParaNdis_FillPowerCapabilities(&u.PMCaps);
+ break;
+ case OID_802_3_MAC_OPTIONS:
+ SETINFO(ul, 0);
+ break;
+ case OID_GEN_VLAN_ID:
+ SETINFO(ul, pContext->VlanId);
+ if (!IsVlanSupported(pContext))
+ status = NDIS_STATUS_NOT_SUPPORTED;
+ break;
+ case OID_GEN_CURRENT_LOOKAHEAD:
+ if (!pContext->DummyLookAhead) pContext->DummyLookAhead =
pContext->MaxPacketSize.nMaxFullSizeOS;
+ pInfo = &pContext->DummyLookAhead;
+ ulSize = sizeof(pContext->DummyLookAhead);
+ break;
+ case OID_PNP_ENABLE_WAKE_UP:
+ SETINFO(ul, pContext->ulEnableWakeup);
+ break;
+ default:
+ status = NDIS_STATUS_NOT_SUPPORTED;
+ break;
+ }
+
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ status = ParaNdis_OidQueryCopy(pOid, pInfo, ulSize, bFreeInfo);
+ }
+
+ return status;
+}
+
+
+/**********************************************************
+ Just gets OID name
+***********************************************************/
+const char *ParaNdis_OidName(NDIS_OID oid)
+{
+#undef MAKECASE
+#define MAKECASE(id) case id: return #id;
+ switch (oid)
+ {
+ MAKECASE(OID_GEN_SUPPORTED_LIST)
+ MAKECASE(OID_GEN_HARDWARE_STATUS)
+ MAKECASE(OID_GEN_MEDIA_SUPPORTED)
+ MAKECASE(OID_GEN_MEDIA_IN_USE)
+ MAKECASE(OID_GEN_MAXIMUM_LOOKAHEAD)
+ MAKECASE(OID_GEN_MAXIMUM_FRAME_SIZE)
+ MAKECASE(OID_GEN_LINK_SPEED)
+ MAKECASE(OID_GEN_TRANSMIT_BUFFER_SPACE)
+ MAKECASE(OID_GEN_RECEIVE_BUFFER_SPACE)
+ MAKECASE(OID_GEN_TRANSMIT_BLOCK_SIZE)
+ MAKECASE(OID_GEN_RECEIVE_BLOCK_SIZE)
+ MAKECASE(OID_GEN_VENDOR_ID)
+ MAKECASE(OID_GEN_VENDOR_DESCRIPTION)
+ MAKECASE(OID_GEN_CURRENT_PACKET_FILTER)
+ MAKECASE(OID_GEN_CURRENT_LOOKAHEAD)
+ MAKECASE(OID_GEN_DRIVER_VERSION)
+ MAKECASE(OID_GEN_MAXIMUM_TOTAL_SIZE)
+ MAKECASE(OID_GEN_PROTOCOL_OPTIONS)
+ MAKECASE(OID_GEN_MAC_OPTIONS)
+ MAKECASE(OID_GEN_MEDIA_CONNECT_STATUS)
+ MAKECASE(OID_GEN_MAXIMUM_SEND_PACKETS)
+ MAKECASE(OID_GEN_VENDOR_DRIVER_VERSION)
+ MAKECASE(OID_GEN_SUPPORTED_GUIDS)
+ MAKECASE(OID_GEN_TRANSPORT_HEADER_OFFSET)
+ MAKECASE(OID_GEN_MEDIA_CAPABILITIES)
+ MAKECASE(OID_GEN_PHYSICAL_MEDIUM)
+ MAKECASE(OID_GEN_XMIT_OK)
+ MAKECASE(OID_GEN_RCV_OK)
+ MAKECASE(OID_GEN_XMIT_ERROR)
+ MAKECASE(OID_GEN_RCV_ERROR)
+ MAKECASE(OID_GEN_RCV_NO_BUFFER)
+ MAKECASE(OID_GEN_DIRECTED_BYTES_XMIT)
+ MAKECASE(OID_GEN_DIRECTED_FRAMES_XMIT)
+ MAKECASE(OID_GEN_MULTICAST_BYTES_XMIT)
+ MAKECASE(OID_GEN_MULTICAST_FRAMES_XMIT)
+ MAKECASE(OID_GEN_BROADCAST_BYTES_XMIT)
+ MAKECASE(OID_GEN_BROADCAST_FRAMES_XMIT)
+ MAKECASE(OID_GEN_DIRECTED_BYTES_RCV)
+ MAKECASE(OID_GEN_DIRECTED_FRAMES_RCV)
+ MAKECASE(OID_GEN_MULTICAST_BYTES_RCV)
+ MAKECASE(OID_GEN_MULTICAST_FRAMES_RCV)
+ MAKECASE(OID_GEN_BROADCAST_BYTES_RCV)
+ MAKECASE(OID_GEN_BROADCAST_FRAMES_RCV)
+ MAKECASE(OID_GEN_RCV_CRC_ERROR)
+ MAKECASE(OID_GEN_TRANSMIT_QUEUE_LENGTH)
+ MAKECASE(OID_GEN_GET_TIME_CAPS)
+ MAKECASE(OID_GEN_GET_NETCARD_TIME)
+ MAKECASE(OID_GEN_NETCARD_LOAD)
+ MAKECASE(OID_GEN_DEVICE_PROFILE)
+ MAKECASE(OID_GEN_INIT_TIME_MS)
+ MAKECASE(OID_GEN_RESET_COUNTS)
+ MAKECASE(OID_GEN_MEDIA_SENSE_COUNTS)
+ MAKECASE(OID_GEN_VLAN_ID)
+ MAKECASE(OID_PNP_CAPABILITIES)
+ MAKECASE(OID_PNP_SET_POWER)
+ MAKECASE(OID_PNP_QUERY_POWER)
+ MAKECASE(OID_PNP_ADD_WAKE_UP_PATTERN)
+ MAKECASE(OID_PNP_REMOVE_WAKE_UP_PATTERN)
+ MAKECASE(OID_PNP_ENABLE_WAKE_UP)
+ MAKECASE(OID_802_3_PERMANENT_ADDRESS)
+ MAKECASE(OID_802_3_CURRENT_ADDRESS)
+ MAKECASE(OID_802_3_MULTICAST_LIST)
+ MAKECASE(OID_802_3_MAXIMUM_LIST_SIZE)
+ MAKECASE(OID_802_3_MAC_OPTIONS)
+ MAKECASE(OID_802_3_RCV_ERROR_ALIGNMENT)
+ MAKECASE(OID_802_3_XMIT_ONE_COLLISION)
+ MAKECASE(OID_802_3_XMIT_MORE_COLLISIONS)
+ MAKECASE(OID_802_3_XMIT_DEFERRED)
+ MAKECASE(OID_802_3_XMIT_MAX_COLLISIONS)
+ MAKECASE(OID_802_3_RCV_OVERRUN)
+ MAKECASE(OID_802_3_XMIT_UNDERRUN)
+ MAKECASE(OID_802_3_XMIT_HEARTBEAT_FAILURE)
+ MAKECASE(OID_802_3_XMIT_TIMES_CRS_LOST)
+ MAKECASE(OID_802_3_XMIT_LATE_COLLISIONS)
+ MAKECASE(OID_GEN_MACHINE_NAME)
+ MAKECASE(OID_TCP_TASK_OFFLOAD)
+ MAKECASE(OID_TCP_OFFLOAD_PARAMETERS)
+ MAKECASE(OID_OFFLOAD_ENCAPSULATION)
+ MAKECASE(OID_IP4_OFFLOAD_STATS)
+ MAKECASE(OID_IP6_OFFLOAD_STATS)
+ default:
+ {
+ static UCHAR buffer[9];
+ UINT i;
+ for (i = 0; i < 8; ++i)
+ {
+ UCHAR nibble = (UCHAR)((oid >> (28 - i * 4)) & 0xf);
+ buffer[i] = hexdigit(nibble);
+ }
+ return (char *)buffer;
+ }
+ }
+}
+
+/**********************************************************
+Checker of valid size of provided wake-up patter
+Return value: SUCCESS or kind of failure where the buffer is wrong
+***********************************************************/
+static NDIS_STATUS ValidateWakeupPattern(PNDIS_PM_PACKET_PATTERN p, PULONG pValidSize)
+{
+ NDIS_STATUS status = NDIS_STATUS_BUFFER_TOO_SHORT;
+
+ if (*pValidSize < sizeof(*p))
+ {
+ *pValidSize = sizeof(*p);
+ }
+ else
+ {
+ ULONG ul = p->PatternOffset + p->PatternSize;
+ if (*pValidSize >= ul) status = NDIS_STATUS_SUCCESS;
+ *pValidSize = ul;
+ DPrintf(2, ("[%s] pattern of %d at %d, mask %d (%s)",
+ __FUNCTION__, p->PatternSize, p->PatternOffset, p->MaskSize,
+ status == NDIS_STATUS_SUCCESS ? "OK" : "Fail"));
+ }
+ return status;
+}
+
+
+/**********************************************************
+Common handler of wake-up pattern addition
+***********************************************************/
+NDIS_STATUS ParaNdis_OnAddWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ NDIS_STATUS status;
+ PNDIS_PM_PACKET_PATTERN pPmPattern = (PNDIS_PM_PACKET_PATTERN)
pOid->InformationBuffer;
+ ULONG ulValidSize = pOid->InformationBufferLength;
+ status = ValidateWakeupPattern(pPmPattern, &ulValidSize);
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ *pOid->pBytesRead = ulValidSize;
+ }
+ else
+ {
+ *pOid->pBytesRead = 0;
+ *pOid->pBytesNeeded = ulValidSize;
+ }
+ // TODO: Apply
+ return status;
+}
+
+/**********************************************************
+Common handler of wake-up pattern removal
+***********************************************************/
+NDIS_STATUS ParaNdis_OnRemoveWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ NDIS_STATUS status;
+ PNDIS_PM_PACKET_PATTERN pPmPattern = (PNDIS_PM_PACKET_PATTERN)
pOid->InformationBuffer;
+ ULONG ulValidSize = pOid->InformationBufferLength;
+ status = ValidateWakeupPattern(pPmPattern, &ulValidSize);
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ *pOid->pBytesRead = ulValidSize;
+ }
+ else
+ {
+ *pOid->pBytesRead = 0;
+ *pOid->pBytesNeeded = ulValidSize;
+ }
+ return status;
+}
+
+/**********************************************************
+Common handler of wake-up enabling upon standby
+***********************************************************/
+NDIS_STATUS ParaNdis_OnEnableWakeup(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ NDIS_STATUS status = ParaNdis_OidSetCopy(pOid, &pContext->ulEnableWakeup,
sizeof(pContext->ulEnableWakeup));
+ if (status == NDIS_STATUS_SUCCESS)
+ {
+ DPrintf(0, ("[%s] new value %lX", __FUNCTION__,
pContext->ulEnableWakeup));
+ }
+ return status;
+}
+
+/**********************************************************
+Dummy implementation
+***********************************************************/
+NDIS_STATUS ParaNdis_OnSetLookahead(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ return ParaNdis_OidSetCopy(pOid, &pContext->DummyLookAhead,
sizeof(pContext->DummyLookAhead));
+}
+
+NDIS_STATUS ParaNdis_OnSetVlanId(PARANDIS_ADAPTER *pContext, tOidDesc *pOid)
+{
+ NDIS_STATUS status = NDIS_STATUS_NOT_SUPPORTED;
+ if (IsVlanSupported(pContext))
+ {
+ status = ParaNdis_OidSetCopy(pOid, &pContext->VlanId,
sizeof(pContext->VlanId));
+ pContext->VlanId &= 0xfff;
+ DPrintf(0, ("[%s] new value %d on MAC %X", __FUNCTION__,
pContext->VlanId, pContext->CurrentMacAddress[5]));
+ ParaNdis_DeviceFiltersUpdateVlanId(pContext);
+ }
+ return status;
+}
+
+/**********************************************************
+Retrieves support rules for specific OID
+***********************************************************/
+void ParaNdis_GetOidSupportRules(NDIS_OID oid, tOidWhatToDo *pRule, const tOidWhatToDo
*Table)
+{
+ static const tOidWhatToDo defaultRule = { 0, 0, 0, 0, 0, NULL, "Unknown
OID" };
+ UINT i;
+ *pRule = defaultRule;
+ pRule->oid = oid;
+
+ for (i = 0; Table[i].oid != 0; ++i)
+ {
+ if (Table[i].oid == oid)
+ {
+ *pRule = Table[i];
+ break;
+ }
+ }
+ pRule->name = ParaNdis_OidName(oid);
+}
diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-Oid.h
b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.h
new file mode 100644
index 00000000000..aac453ab97c
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/ParaNdis-Oid.h
@@ -0,0 +1,104 @@
+/*
+ * This file contains common for NDIS5/NDIS6 definition,
+ * related to OID support
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef PARANDIS_COMMON_OID_H
+#define PARANDIS_COMMON_OID_H
+
+#include "ndis56common.h"
+
+/**********************************************************
+Wrapper for all the data, related to any OID request
+***********************************************************/
+typedef struct _tagOidDesc
+{
+ NDIS_OID Oid; // oid code
+ ULONG ulToDoFlags; // combination of
eOidHelperFlags
+ PVOID InformationBuffer; // buffer received from NDIS
+ UINT InformationBufferLength; // its length
+ PUINT pBytesWritten; // OUT for query/method
+ PUINT pBytesNeeded; // OUT for query/set/method when
length of buffer is wrong
+ PUINT pBytesRead; // OUT for set/method
+ PVOID Reserved; // Reserved for pending requests
+} tOidDesc;
+
+typedef NDIS_STATUS (*OIDHANDLERPROC)(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+
+typedef struct _tagOidWhatToDo
+{
+ NDIS_OID oid; // oid number
+ int nEntryLevel; // do print on entry level
+ int nExitFailLevel; // do print on exit if failed
+ int nExitOKLevel; // do print on exit if OK
+ UINT Flags;
+ OIDHANDLERPROC OidSetProc; // procedure to call on SET
+ const char *name; // printable name
+}tOidWhatToDo;
+
+
+typedef enum _tageOidHelperFlags {
+ ohfQuery = 1, // can be queried
+ ohfSet = 2, // can be set
+ ohfQuerySet = ohfQuery | ohfSet,
+ ohfQueryStatOnly = 4, // redirect query stat to query
+ ohfQueryStat = ohfQueryStatOnly | ohfQuery,
+ ohfQuery3264 = 8 | ohfQuery, // convert 64 to 32 on query
+ ohfQueryStat3264 = 8 | ohfQueryStat, // convert 64 to 32 on query stat
+ ohfSetLessOK = 16, // on set: if buffer is smaller,
cleanup and copy
+ ohfSetMoreOK = 32 // on set: if buffer is larger, copy
anyway
+} eOidHelperFlags;
+
+
+
+
+/**********************************************************
+Common procedures related to OID support
+***********************************************************/
+NDIS_STATUS ParaNdis_OidQueryCommon(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OidQueryCopy(tOidDesc *pOid, PVOID pInfo, ULONG ulSize, BOOLEAN
bFreeInfo);
+static NDIS_STATUS ParaNdis_OidQuery(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnOidSetMulticastList(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnSetPacketFilter(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnAddWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnRemoveWakeupPattern(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnEnableWakeup(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnSetLookahead(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OnSetVlanId(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+NDIS_STATUS ParaNdis_OidSetCopy(tOidDesc *pOid, PVOID pDest, ULONG ulSize);
+void ParaNdis_FillPowerCapabilities(PNDIS_PNP_CAPABILITIES pCaps);
+void ParaNdis_GetOidSupportRules(NDIS_OID oid, tOidWhatToDo *pRule, const tOidWhatToDo
*Table);
+
+
+const char *ParaNdis_OidName(NDIS_OID oid);
+/**********************************************************
+Procedures to be implemented in NDIS5/NDIS6 specific modules
+***********************************************************/
+void ParaNdis_GetSupportedOid(PVOID *pOidsArray, PULONG pLength);
+NDIS_STATUS ParaNdis_OnSetPower(PARANDIS_ADAPTER *pContext, tOidDesc *pOid);
+
+#endif
diff --git a/drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c
b/drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c
new file mode 100644
index 00000000000..a1525502696
--- /dev/null
+++ b/drivers/network/dd/netkvm/Common/ParaNdis-VirtIO.c
@@ -0,0 +1,389 @@
+/*
+ * This file contains NDIS driver VirtIO callbacks
+ *
+ * Copyright (c) 2008-2017 Red Hat, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met :
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and / or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of their contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include "ndis56common.h"
+
+/////////////////////////////////////////////////////////////////////////////////////
+//
+// ReadVirtIODeviceRegister\WriteVirtIODeviceRegister
+// NDIS specific implementation of the IO and memory space read\write
+//
+// The lower 64k of memory is never mapped so we can use the same routines
+// for both port I/O and memory access and use the address alone to decide
+// which space to use.
+/////////////////////////////////////////////////////////////////////////////////////
+
+#define PORT_MASK 0xFFFF
+
+static u32 ReadVirtIODeviceRegister(ULONG_PTR ulRegister)
+{
+ ULONG ulValue;
+
+ if (ulRegister & ~PORT_MASK) {
+ NdisReadRegisterUlong(ulRegister, &ulValue);
+ } else {
+ NdisRawReadPortUlong(ulRegister, &ulValue);
+ }
+
+ DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, ulValue));
+ return ulValue;
+}
+
+static void WriteVirtIODeviceRegister(ULONG_PTR ulRegister, u32 ulValue)
+{
+ DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, ulValue));
+
+ if (ulRegister & ~PORT_MASK) {
+ NdisWriteRegisterUlong((PULONG)ulRegister, ulValue);
+ } else {
+ NdisRawWritePortUlong(ulRegister, ulValue);
+ }
+}
+
+static u8 ReadVirtIODeviceByte(ULONG_PTR ulRegister)
+{
+ u8 bValue;
+
+ if (ulRegister & ~PORT_MASK) {
+ NdisReadRegisterUchar(ulRegister, &bValue);
+ } else {
+ NdisRawReadPortUchar(ulRegister, &bValue);
+ }
+
+ DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, bValue));
+ return bValue;
+}
+
+static void WriteVirtIODeviceByte(ULONG_PTR ulRegister, u8 bValue)
+{
+ DPrintf(6, ("[%s]R[%x]=%x", __FUNCTION__, (ULONG)ulRegister, bValue));
+
+ if (ulRegister & ~PORT_MASK) {
+ NdisWriteRegisterUchar((PUCHAR)ulRegister, bValue);
+ } else {
+ NdisRawWritePortUchar(ulRegister, bValue);
+ }
+}
+
+static u16 ReadVirtIODeviceWord(ULONG_PTR ulRegister)
+{
+ u16 wValue;
+
+ if (ulRegister & ~PORT_MASK) {
+ NdisReadRegisterUshort(ulRegister, &wValue);
+ } else {
+ NdisRawReadPortUshort(ulRegister, &wValue);
+ }
+
+ DPrintf(6, ("[%s]R[%x]=%x\n", __FUNCTION__, (ULONG)ulRegister, wValue));
+ return wValue;
+}
+
+static void WriteVirtIODeviceWord(ULONG_PTR ulRegister, u16 wValue)
+{
+#if 1
+ if (ulRegister & ~PORT_MASK) {
+ NdisWriteRegisterUshort((PUSHORT)ulRegister, wValue);
+ } else {
+ NdisRawWritePortUshort(ulRegister, wValue);
+ }
+#else
+ // test only to cause long TX waiting queue of NDIS packets
+ // to recognize it and request for reset via Hang handler
+ static int nCounterToFail = 0;
+ static const int StartFail = 200, StopFail = 600;
+ BOOLEAN bFail = FALSE;
+ DPrintf(6, ("%s> R[%x] = %x\n", __FUNCTION__, (ULONG)ulRegister,
wValue));
+ if ((ulRegister & 0x1F) == 0x10)
+ {
+ nCounterToFail++;
+ bFail = nCounterToFail >= StartFail && nCounterToFail < StopFail;
+ }
+ if (!bFail) NdisRawWritePortUshort(ulRegister, wValue);
+ else
+ {
+ DPrintf(0, ("%s> FAILING R[%x] = %x\n", __FUNCTION__,
(ULONG)ulRegister, wValue));
+ }
+#endif
+}
+
+static void *mem_alloc_contiguous_pages(void *context, size_t size)
+{
+ PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context;
+ PVOID retVal = NULL;
+ ULONG i;
+
+ /* find the first unused memory range of the requested size */
+ for (i = 0; i < MAX_NUM_OF_QUEUES; i++) {
+ if (pContext->SharedMemoryRanges[i].pBase != NULL &&
+ pContext->SharedMemoryRanges[i].bUsed == FALSE &&
+ pContext->SharedMemoryRanges[i].uLength == (ULONG)size) {
+ retVal = pContext->SharedMemoryRanges[i].pBase;
+ pContext->SharedMemoryRanges[i].bUsed = TRUE;
+ break;
+ }
+ }
+
+ if (!retVal) {
+ /* find the first null memory range descriptor and allocate */
+ for (i = 0; i < MAX_NUM_OF_QUEUES; i++) {
+ if (pContext->SharedMemoryRanges[i].pBase == NULL) {
+ break;
+ }
+ }
+ if (i < MAX_NUM_OF_QUEUES) {
+ NdisMAllocateSharedMemory(
+ pContext->MiniportHandle,
+ (ULONG)size,
+ TRUE /* Cached */,
+ &pContext->SharedMemoryRanges[i].pBase,
+ &pContext->SharedMemoryRanges[i].BasePA);
+ retVal = pContext->SharedMemoryRanges[i].pBase;
+ if (retVal) {
+ NdisZeroMemory(retVal, size);
+ pContext->SharedMemoryRanges[i].uLength = (ULONG)size;
+ pContext->SharedMemoryRanges[i].bUsed = TRUE;
+ }
+ }
+ }
+
+ if (retVal) {
+ DPrintf(6, ("[%s] returning %p, size %x\n", __FUNCTION__, retVal,
(ULONG)size));
+ } else {
+ DPrintf(0, ("[%s] failed to allocate size %x\n", __FUNCTION__,
(ULONG)size));
+ }
+ return retVal;
+}
+
+static void mem_free_contiguous_pages(void *context, void *virt)
+{
+ PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context;
+ ULONG i;
+
+ for (i = 0; i < MAX_NUM_OF_QUEUES; i++) {
+ if (pContext->SharedMemoryRanges[i].pBase == virt) {
+ pContext->SharedMemoryRanges[i].bUsed = FALSE;
+ break;
+ }
+ }
+
+ if (i < MAX_NUM_OF_QUEUES) {
+ DPrintf(6, ("[%s] freed %p at index %d\n", __FUNCTION__, virt, i));
+ } else {
+ DPrintf(0, ("[%s] failed to free %p\n", __FUNCTION__, virt));
+ }
+}
+
+static ULONGLONG mem_get_physical_address(void *context, void *virt)
+{
+ PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context;
+ ULONG_PTR uAddr = (ULONG_PTR)virt;
+ ULONG i;
+
+ for (i = 0; i < MAX_NUM_OF_QUEUES; i++) {
+ ULONG_PTR uBase = (ULONG_PTR)pContext->SharedMemoryRanges[i].pBase;
+ if (uAddr >= uBase && uAddr < (uBase +
pContext->SharedMemoryRanges[i].uLength)) {
+ ULONGLONG retVal = pContext->SharedMemoryRanges[i].BasePA.QuadPart +
(uAddr - uBase);
+
+ DPrintf(6, ("[%s] translated %p to %I64X\n", __FUNCTION__, virt,
retVal));
+ return retVal;
+ }
+ }
+
+ DPrintf(0, ("[%s] failed to translate %p\n", __FUNCTION__, virt));
+ return 0;
+}
+
+static void *mem_alloc_nonpaged_block(void *context, size_t size)
+{
+ PVOID retVal;
+
+ if (NdisAllocateMemoryWithTag(
+ &retVal,
+ (UINT)size,
+ PARANDIS_MEMORY_TAG) != NDIS_STATUS_SUCCESS) {
+ retVal = NULL;
+ }
+
+ if (retVal) {
+ NdisZeroMemory(retVal, size);
+ DPrintf(6, ("[%s] returning %p, len %x\n", __FUNCTION__, retVal,
(ULONG)size));
+ } else {
+ DPrintf(0, ("[%s] failed to allocate size %x\n", __FUNCTION__,
(ULONG)size));
+ }
+ return retVal;
+}
+
+static void mem_free_nonpaged_block(void *context, void *addr)
+{
+ UNREFERENCED_PARAMETER(context);
+
+ NdisFreeMemory(addr, 0, 0);
+ DPrintf(6, ("[%s] freed %p\n", __FUNCTION__, addr));
+}
+
+static int PCIReadConfig(PPARANDIS_ADAPTER pContext,
+ int where,
+ void *buffer,
+ size_t length)
+{
+ ULONG read;
+
+ read = NdisReadPciSlotInformation(
+ pContext->MiniportHandle,
+ 0 /* SlotNumber */,
+ where,
+ buffer,
+ (ULONG)length);
+
+ if (read == length) {
+ DPrintf(6, ("[%s] read %d bytes at %d\n", __FUNCTION__, read, where));
+ return 0;
+ } else {
+ DPrintf(0, ("[%s] failed to read %d bytes at %d\n", __FUNCTION__, read,
where));
+ return -1;
+ }
+}
+
+static int pci_read_config_byte(void *context, int where, u8 *bVal)
+{
+ return PCIReadConfig((PPARANDIS_ADAPTER)context, where, bVal, sizeof(*bVal));
+}
+
+static int pci_read_config_word(void *context, int where, u16 *wVal)
+{
+ return PCIReadConfig((PPARANDIS_ADAPTER)context, where, wVal, sizeof(*wVal));
+}
+
+static int pci_read_config_dword(void *context, int where, u32 *dwVal)
+{
+ return PCIReadConfig((PPARANDIS_ADAPTER)context, where, dwVal, sizeof(*dwVal));
+}
+
+static size_t pci_get_resource_len(void *context, int bar)
+{
+ PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context;
+
+ if (bar < PCI_TYPE0_ADDRESSES) {
+ return pContext->AdapterResources.PciBars[bar].uLength;
+ }
+
+ DPrintf(0, ("[%s] queried invalid BAR %d\n", __FUNCTION__, bar));
+ return 0;
+}
+
+static void *pci_map_address_range(void *context, int bar, size_t offset, size_t maxlen)
+{
+ PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)context;
+
+ if (bar < PCI_TYPE0_ADDRESSES) {
+ tBusResource *pRes = &pContext->AdapterResources.PciBars[bar];
+ if (pRes->pBase == NULL) {
+ /* BAR not mapped yet */
+ if (pRes->bPortSpace) {
+ if (NDIS_STATUS_SUCCESS == NdisMRegisterIoPortRange(
+ &pRes->pBase,
+ pContext->MiniportHandle,
+ pRes->BasePA.LowPart,
+ pRes->uLength)) {
+ DPrintf(6, ("[%s] mapped port BAR at %x\n", __FUNCTION__,
pRes->BasePA.LowPart));
+ } else {
+ pRes->pBase = NULL;
+ DPrintf(0, ("[%s] failed to map port BAR at %x\n",
__FUNCTION__, pRes->BasePA.LowPart));
+ }
+ } else {
+ if (NDIS_STATUS_SUCCESS == NdisMMapIoSpace(
+ &pRes->pBase,
+ pContext->MiniportHandle,
+ pRes->BasePA,
+ pRes->uLength)) {
+ DPrintf(6, ("[%s] mapped memory BAR at %I64x\n",
__FUNCTION__, pRes->BasePA.QuadPart));
+ } else {
+ pRes->pBase = NULL;
+ DPrintf(0, ("[%s] failed to map memory BAR at %I64x\n",
__FUNCTION__, pRes->BasePA.QuadPart));
+ }
+ }
+ }
+ if (pRes->pBase != NULL && offset < pRes->uLength) {
+ if (pRes->bPortSpace) {
... 9139 lines suppressed ...