/*
* --------------------------------------------------------------------------
* OvsPartialCopyToMultipleNBLs --
*
* This is similar to OvsPartialCopyNBL() except that each NB will
* have its own NBL.
* --------------------------------------------------------------------------
*/
PNET_BUFFER_LIST
OvsPartialCopyToMultipleNBLs(PVOID ovsContext,
PNET_BUFFER_LIST nbl,
UINT32 copySize,
UINT32 headRoom,
BOOLEAN copyNblInfo)
{
PNET_BUFFER nb, nextNb = NULL, firstNb, prevNb;
POVS_SWITCH_CONTEXT context = (POVS_SWITCH_CONTEXT)ovsContext;
PNET_BUFFER_LIST firstNbl = NULL, newNbl, prevNbl = NULL;
nb = NET_BUFFER_LIST_FIRST_NB(nbl);
if (NET_BUFFER_NEXT_NB(nb) == NULL) {
return OvsPartialCopyNBL(context, nbl, copySize, headRoom, copyNblInfo);
}
firstNb = nb;
prevNb = nb;
while (nb) {
nextNb = NET_BUFFER_NEXT_NB(nb);
NET_BUFFER_NEXT_NB(nb) = NULL;
NET_BUFFER_LIST_FIRST_NB(nbl) = nb;
newNbl = OvsPartialCopyNBL(context, nbl, copySize, headRoom,
copyNblInfo);
if (newNbl == NULL) {
goto cleanup;
}
if (prevNbl == NULL) {
firstNbl = newNbl;
} else {
NET_BUFFER_LIST_NEXT_NBL(prevNbl) = newNbl;
NET_BUFFER_NEXT_NB(prevNb) = nb;
}
prevNbl = newNbl;
prevNb = nb;
nb = nextNb;
}
NET_BUFFER_LIST_FIRST_NB(nbl) = firstNb;
return firstNbl;
cleanup:
NET_BUFFER_NEXT_NB(prevNb) = nb;
NET_BUFFER_NEXT_NB(nb) = nextNb;
NET_BUFFER_LIST_FIRST_NB(nbl) = firstNb;
newNbl = firstNbl;
while (newNbl) {
firstNbl = NET_BUFFER_LIST_NEXT_NBL(newNbl);
NET_BUFFER_LIST_NEXT_NBL(newNbl) = NULL;
OvsCompleteNBL(context, newNbl, TRUE);
newNbl = firstNbl;
}
return NULL;
}
/*
*----------------------------------------------------------------------------
* OvsDoEncapVxlan
* Encapsulates the packet.
*----------------------------------------------------------------------------
*/
static __inline NDIS_STATUS
OvsDoEncapVxlan(PNET_BUFFER_LIST curNbl,
OvsIPv4TunnelKey *tunKey,
POVS_FWD_INFO fwdInfo,
POVS_PACKET_HDR_INFO layers,
POVS_SWITCH_CONTEXT switchContext,
PNET_BUFFER_LIST *newNbl)
{
NDIS_STATUS status;
PNET_BUFFER curNb;
PMDL curMdl;
PUINT8 bufferStart;
EthHdr *ethHdr;
IPHdr *ipHdr;
UDPHdr *udpHdr;
VXLANHdr *vxlanHdr;
UINT32 headRoom = OvsGetVxlanTunHdrSize();
UINT32 packetLength;
/*
* XXX: the assumption currently is that the NBL is owned by OVS, and
* headroom has already been allocated as part of allocating the NBL and
* MDL.
*/
curNb = NET_BUFFER_LIST_FIRST_NB(curNbl);
packetLength = NET_BUFFER_DATA_LENGTH(curNb);
if (layers->isTcp) {
NDIS_TCP_LARGE_SEND_OFFLOAD_NET_BUFFER_LIST_INFO tsoInfo;
tsoInfo.Value = NET_BUFFER_LIST_INFO(curNbl,
TcpLargeSendNetBufferListInfo);
OVS_LOG_TRACE("MSS %u packet len %u", tsoInfo.LsoV1Transmit.MSS, packetLength);
if (tsoInfo.LsoV1Transmit.MSS) {
OVS_LOG_TRACE("l4Offset %d", layers->l4Offset);
*newNbl = OvsTcpSegmentNBL(switchContext, curNbl, layers,
tsoInfo.LsoV1Transmit.MSS, headRoom);
if (*newNbl == NULL) {
OVS_LOG_ERROR("Unable to segment NBL");
return NDIS_STATUS_FAILURE;
}
}
}
/* If we didn't split the packet above, make a copy now */
if (*newNbl == NULL) {
*newNbl = OvsPartialCopyNBL(switchContext, curNbl, 0, headRoom,
FALSE /*NBL info*/);
if (*newNbl == NULL) {
OVS_LOG_ERROR("Unable to copy NBL");
return NDIS_STATUS_FAILURE;
}
}
curNbl = *newNbl;
for (curNb = NET_BUFFER_LIST_FIRST_NB(curNbl); curNb != NULL;
curNb = curNb->Next) {
status = NdisRetreatNetBufferDataStart(curNb, headRoom, 0, NULL);
if (status != NDIS_STATUS_SUCCESS) {
goto ret_error;
}
curMdl = NET_BUFFER_CURRENT_MDL(curNb);
bufferStart = (PUINT8)MmGetSystemAddressForMdlSafe(curMdl, LowPagePriority);
if (!bufferStart) {
status = NDIS_STATUS_RESOURCES;
goto ret_error;
}
bufferStart += NET_BUFFER_CURRENT_MDL_OFFSET(curNb);
if (NET_BUFFER_NEXT_NB(curNb)) {
OVS_LOG_TRACE("nb length %u next %u", NET_BUFFER_DATA_LENGTH(curNb),
NET_BUFFER_DATA_LENGTH(curNb->Next));
}
/* L2 header */
ethHdr = (EthHdr *)bufferStart;
NdisMoveMemory(ethHdr->Destination, fwdInfo->dstMacAddr,
sizeof ethHdr->Destination + sizeof ethHdr->Source);
ASSERT(((PCHAR)&fwdInfo->dstMacAddr + sizeof fwdInfo->dstMacAddr) ==
(PCHAR)&fwdInfo->srcMacAddr);
ethHdr->Type = htons(ETH_TYPE_IPV4);
// XXX: question: there are fields in the OvsIPv4TunnelKey for ttl and such,
// should we use those values instead? or will they end up being
// uninitialized;
/* IP header */
ipHdr = (IPHdr *)((PCHAR)ethHdr + sizeof *ethHdr);
ipHdr->ihl = sizeof *ipHdr / 4;
ipHdr->version = IPV4;
ipHdr->tos = 0;
ipHdr->tot_len = htons(NET_BUFFER_DATA_LENGTH(curNb) - sizeof *ethHdr);
ipHdr->id = 0;
ipHdr->frag_off = IP_DF_NBO;
ipHdr->ttl = tunKey->ttl ? tunKey->ttl : VXLAN_DEFAULT_TTL;
ipHdr->protocol = IPPROTO_UDP;
ASSERT(tunKey->dst == fwdInfo->dstIpAddr);
ASSERT(tunKey->src == fwdInfo->srcIpAddr || tunKey->src == 0);
ipHdr->saddr = fwdInfo->srcIpAddr;
ipHdr->daddr = fwdInfo->dstIpAddr;
ipHdr->check = 0;
ipHdr->check = IPChecksum((UINT8 *)ipHdr, sizeof *ipHdr, 0);
/* UDP header */
udpHdr = (UDPHdr *)((PCHAR)ipHdr + sizeof *ipHdr);
udpHdr->source = htons(tunKey->flow_hash | 32768);
udpHdr->dest = VXLAN_UDP_PORT_NBO;
udpHdr->len = htons(NET_BUFFER_DATA_LENGTH(curNb) - headRoom +
sizeof *udpHdr + sizeof *vxlanHdr);
udpHdr->check = 0;
/* VXLAN header */
vxlanHdr = (VXLANHdr *)((PCHAR)udpHdr + sizeof *udpHdr);
vxlanHdr->flags1 = 0;
vxlanHdr->locallyReplicate = 0;
vxlanHdr->flags2 = 0;
vxlanHdr->reserved1 = 0;
if (tunKey->flags | OVS_TNL_F_KEY) {
vxlanHdr->vxlanID = VXLAN_TUNNELID_TO_VNI(tunKey->tunnelId);
vxlanHdr->instanceID = 1;
}
vxlanHdr->reserved2 = 0;
}
return STATUS_SUCCESS;
ret_error:
OvsCompleteNBL(switchContext, *newNbl, TRUE);
*newNbl = NULL;
return status;
}
/*
*----------------------------------------------------------------------------
* OvsDoDecapVxlan
* Decapsulates to tunnel header in 'curNbl' and puts into 'tunKey'.
*----------------------------------------------------------------------------
*/
NDIS_STATUS
OvsDoDecapVxlan(POVS_SWITCH_CONTEXT switchContext,
PNET_BUFFER_LIST curNbl,
OvsIPv4TunnelKey *tunKey,
PNET_BUFFER_LIST *newNbl)
{
PNET_BUFFER curNb;
PMDL curMdl;
EthHdr *ethHdr;
IPHdr *ipHdr;
UDPHdr *udpHdr;
VXLANHdr *vxlanHdr;
UINT32 tunnelSize = 0, packetLength = 0;
PUINT8 bufferStart;
NDIS_STATUS status;
/* Check the the length of the UDP payload */
curNb = NET_BUFFER_LIST_FIRST_NB(curNbl);
packetLength = NET_BUFFER_DATA_LENGTH(curNb);
tunnelSize = OvsGetVxlanTunHdrSize();
if (packetLength <= tunnelSize) {
return NDIS_STATUS_INVALID_LENGTH;
}
/*
* Create a copy of the NBL so that we have all the headers in one MDL.
*/
*newNbl = OvsPartialCopyNBL(switchContext, curNbl,
tunnelSize + OVS_DEFAULT_COPY_SIZE, 0,
TRUE /*copy NBL info */);
if (*newNbl == NULL) {
return NDIS_STATUS_RESOURCES;
}
/* XXX: Handle VLAN header. */
curNbl = *newNbl;
curNb = NET_BUFFER_LIST_FIRST_NB(curNbl);
curMdl = NET_BUFFER_CURRENT_MDL(curNb);
bufferStart = (PUINT8)MmGetSystemAddressForMdlSafe(curMdl, LowPagePriority) +
NET_BUFFER_CURRENT_MDL_OFFSET(curNb);
if (!bufferStart) {
status = NDIS_STATUS_RESOURCES;
goto dropNbl;
}
ethHdr = (EthHdr *)bufferStart;
/* XXX: Handle IP options. */
ipHdr = (IPHdr *)((PCHAR)ethHdr + sizeof *ethHdr);
tunKey->src = ipHdr->saddr;
tunKey->dst = ipHdr->daddr;
tunKey->tos = ipHdr->tos;
tunKey->ttl = ipHdr->ttl;
tunKey->pad = 0;
udpHdr = (UDPHdr *)((PCHAR)ipHdr + sizeof *ipHdr);
/* Validate if NIC has indicated checksum failure. */
status = OvsValidateUDPChecksum(curNbl, udpHdr->check == 0);
if (status != NDIS_STATUS_SUCCESS) {
goto dropNbl;
}
/* Calculate and verify UDP checksum if NIC didn't do it. */
if (udpHdr->check != 0) {
status = OvsCalculateUDPChecksum(curNbl, curNb, ipHdr, udpHdr, packetLength);
if (status != NDIS_STATUS_SUCCESS) {
goto dropNbl;
}
}
vxlanHdr = (VXLANHdr *)((PCHAR)udpHdr + sizeof *udpHdr);
if (vxlanHdr->instanceID) {
tunKey->flags = OVS_TNL_F_KEY;
tunKey->tunnelId = VXLAN_VNI_TO_TUNNELID(vxlanHdr->vxlanID);
} else {
tunKey->flags = 0;
tunKey->tunnelId = 0;
}
/* Clear out the receive flag for the inner packet. */
NET_BUFFER_LIST_INFO(curNbl, TcpIpChecksumNetBufferListInfo) = 0;
NdisAdvanceNetBufferDataStart(curNb, tunnelSize, FALSE, NULL);
return NDIS_STATUS_SUCCESS;
dropNbl:
OvsCompleteNBL(switchContext, *newNbl, TRUE);
*newNbl = NULL;
return status;
}
