M7350/qcom-opensource/kernel/kernel-tests/ip_accelerator/HeaderProcessingContextTestFixture.cpp
2024-09-09 08:57:42 +00:00

574 lines
15 KiB
C++

/*
* Copyright (c) 2015, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 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 "HeaderProcessingContextTestFixture.h"
#include "TestsUtils.h"
const Byte IpaHdrProcCtxTestFixture::WLAN_ETH2_HDR[WLAN_ETH2_HDR_SIZE] =
{
// WLAN hdr - 4 bytes
0xa1, 0xb2, 0xc3, 0xd4,
// ETH2 - 14 bytes
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00
};
const Byte IpaHdrProcCtxTestFixture::ETH2_HDR[ETH_HLEN] =
{
// ETH2 - 14 bytes
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00
};
const Byte IpaHdrProcCtxTestFixture::WLAN_802_3_HDR[WLAN_802_3_HDR_SIZE] =
{
// WLAN hdr - 4 bytes
0x0a, 0x0b, 0x0c, 0x0d,
// 802_3 - 26 bytes
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00
};
IpaHdrProcCtxTestFixture::IpaHdrProcCtxTestFixture():
m_procCtxHandleId(PROC_CTX_HANDLE_ID_MAX),
m_pCurrentProducer(NULL),
m_currProducerClient(IPA_CLIENT_MAX),
m_pCurrentConsumer(NULL),
m_currConsumerPipeNum(IPA_CLIENT_MAX),
m_sendSize1 (m_BUFF_MAX_SIZE),
m_sendSize2 (m_BUFF_MAX_SIZE),
m_expectedBufferSize1(0),
m_IpaIPType(IPA_IP_v4)
{
memset(m_headerHandles, 0, sizeof(m_headerHandles));
memset(m_procCtxHHandles, 0, sizeof(m_procCtxHHandles));
memset(m_sendBuffer1, 0, sizeof(m_sendBuffer1));
memset(m_sendBuffer2, 0, sizeof(m_sendBuffer2));
memset(m_expectedBuffer1, 0, sizeof(m_expectedBuffer1));
m_testSuiteName.push_back("HdrProcCtx");
}
bool IpaHdrProcCtxTestFixture::Setup()
{
ConfigureScenario(PHASE_TWENTY_TEST_CONFIGURATION);
// init producers
m_rndisEth2Producer.Open(INTERFACE0_TO_IPA_DATA_PATH,
INTERFACE0_FROM_IPA_DATA_PATH);
m_wlanEth2producer.Open(INTERFACE4_TO_IPA_DATA_PATH,
INTERFACE4_FROM_IPA_DATA_PATH);
// init consumers
m_defaultConsumer.Open(INTERFACE1_TO_IPA_DATA_PATH,
INTERFACE1_FROM_IPA_DATA_PATH);
m_rndisEth2Consumer.Open(INTERFACE2_TO_IPA_DATA_PATH,
INTERFACE2_FROM_IPA_DATA_PATH);
if (!m_headerInsertion.DeviceNodeIsOpened())
{
LOG_MSG_ERROR("HeaderInsertion block is not ready "
"for immediate commands!\n");
return false;
}
if (!m_routing.DeviceNodeIsOpened())
{
LOG_MSG_ERROR("Routing block is not ready "
"for immediate commands!\n");
return false;
}
if (!m_filtering.DeviceNodeIsOpened())
{
LOG_MSG_ERROR("Filtering block is not ready "
"for immediate commands!\n");
return false;
}
// resetting this component will reset
// both Routing and Filtering tables
m_headerInsertion.Reset();
return true;
} // Setup()
bool IpaHdrProcCtxTestFixture::Teardown()
{
m_rndisEth2Producer.Close();
m_wlanEth2producer.Close();
m_defaultConsumer.Close();
m_rndisEth2Consumer.Close();
return true;
} // Teardown()
void IpaHdrProcCtxTestFixture::AddAllHeaders()
{
for (int i = 0; i < HEADER_HANDLE_ID_MAX; i++) {
AddHeader(static_cast<HeaderHandleId>(i));
}
}
// Insert a single header
void IpaHdrProcCtxTestFixture::AddHeader(HeaderHandleId handleId)
{
static const int NUM_OF_HEADERS = 1;
struct ipa_ioc_add_hdr *hdrTable = NULL;
struct ipa_hdr_add *hdr = NULL;
// init hdr table
hdrTable = (struct ipa_ioc_add_hdr *) calloc(1,
sizeof(struct ipa_ioc_add_hdr)
+ NUM_OF_HEADERS * sizeof(struct ipa_hdr_add));
if (!hdrTable)
{
LOG_MSG_ERROR(
"calloc failed to allocate pHeaderDescriptor");
return;
}
hdrTable->commit = true;
hdrTable->num_hdrs = NUM_OF_HEADERS;
// init the hdr common fields
hdr = &hdrTable->hdr[0];
hdr->hdr_hdl = -1; //Return Value
hdr->is_partial = false;
hdr->status = -1; // Return Parameter
// init hdr specific fields
switch (handleId)
{
case HEADER_HANDLE_ID_WLAN_ETH2:
memcpy(hdr->hdr, WLAN_ETH2_HDR, WLAN_ETH2_HDR_SIZE);
hdr->hdr_len = WLAN_ETH2_HDR_SIZE;
strlcpy(hdr->name, "WLAN_ETH2", sizeof(hdr->name));
hdr->type = IPA_HDR_L2_ETHERNET_II;
break;
case HEADER_HANDLE_ID_RNDIS_ETH2:
if (!RNDISAggregationHelper::LoadRNDISEth2IP4Header(
hdr->hdr,
IPA_HDR_MAX_SIZE,
0,
(size_t*)&hdr->hdr_len))
return;
strlcpy(hdr->name, "RNDIS_ETH2", sizeof(hdr->name));
hdr->type = IPA_HDR_L2_ETHERNET_II;
break;
case HEADER_HANDLE_ID_ETH2:
strlcpy(hdr->name, "ETH2", sizeof(hdr->name));
memcpy(hdr->hdr, ETH2_HDR, ETH_HLEN);
hdr->type = IPA_HDR_L2_ETHERNET_II;
hdr->hdr_len = ETH_HLEN;
LOG_MSG_DEBUG(
"HEADER_HANDLE_ID_ETH2 NOT supported for now");
return;
break;
case HEADER_HANDLE_ID_WLAN_802_3:
strlcpy(hdr->name, "WLAN_802_3", sizeof(hdr->name));
memcpy(hdr->hdr, WLAN_802_3_HDR, WLAN_802_3_HDR_SIZE);
hdr->type = IPA_HDR_L2_802_3;
hdr->hdr_len = WLAN_802_3_HDR_SIZE;
LOG_MSG_DEBUG(
"HEADER_HANDLE_ID_WLAN_802_3 NOT supported for now");
return;
break;
default:
LOG_MSG_ERROR("header handleId not supported.");
return;
}
// commit header to HW
if (!m_headerInsertion.AddHeader(hdrTable))
{
LOG_MSG_ERROR("m_headerInsertion.AddHeader() failed.");
return;
}
// save header handle
m_headerHandles[handleId] = hdr->hdr_hdl;
}
void IpaHdrProcCtxTestFixture::AddAllProcCtx()
{
for (int i = 0; i <PROC_CTX_HANDLE_ID_MAX; i++)
{
AddProcCtx(static_cast<ProcCtxHandleId>(i));
}
}
// Insert a single proc_ctx
void IpaHdrProcCtxTestFixture::AddProcCtx(ProcCtxHandleId handleId)
{
static const int NUM_OF_PROC_CTX = 1;
struct ipa_ioc_add_hdr_proc_ctx *procCtxTable = NULL;
struct ipa_hdr_proc_ctx_add *procCtx = NULL;
// init proc ctx table
procCtxTable = (struct ipa_ioc_add_hdr_proc_ctx *)calloc(1,
sizeof(struct ipa_ioc_add_hdr_proc_ctx)
+ NUM_OF_PROC_CTX *
sizeof(struct ipa_hdr_proc_ctx_add));
if (!procCtxTable)
{
LOG_MSG_ERROR("calloc failed to allocate procCtxTable");
return;
}
procCtxTable->commit = true;
procCtxTable->num_proc_ctxs = NUM_OF_PROC_CTX;
// init proc_ctx common fields
procCtx = &procCtxTable->proc_ctx[0];
procCtx->proc_ctx_hdl = -1; // return value
procCtx->status = -1; // Return parameter
// init proc_ctx specific fields
switch (handleId)
{
case PROC_CTX_HANDLE_ID_WLAN_ETH2_2_ETH2:
procCtx->type = IPA_HDR_PROC_ETHII_TO_ETHII;
procCtx->hdr_hdl =
m_headerHandles[HEADER_HANDLE_ID_WLAN_ETH2];
break;
case PROC_CTX_HANDLE_ID_RNDIS_ETH2_2_ETH2:
procCtx->type = IPA_HDR_PROC_ETHII_TO_ETHII;
procCtx->hdr_hdl =
m_headerHandles[HEADER_HANDLE_ID_RNDIS_ETH2];
break;
case PROC_CTX_HANDLE_ID_ETH2_ETH2_2_ETH2:
procCtx->type = IPA_HDR_PROC_ETHII_TO_ETHII;
procCtx->hdr_hdl =
m_headerHandles[HEADER_HANDLE_ID_ETH2];
break;
case PROC_CTX_HANDLE_ID_WLAN_ETH2_2_802_3:
procCtx->type = IPA_HDR_PROC_ETHII_TO_802_3;
procCtx->hdr_hdl =
m_headerHandles[HEADER_HANDLE_ID_WLAN_802_3];
break;
case PROC_CTX_HANDLE_ID_RNDIS_802_3_2_ETH2:
procCtx->type = IPA_HDR_PROC_802_3_TO_ETHII;
procCtx->hdr_hdl =
m_headerHandles[HEADER_HANDLE_ID_RNDIS_ETH2];
break;
case PROC_CTX_HANDLE_ID_WLAN_802_3_2_ETH2:
procCtx->type = IPA_HDR_PROC_802_3_TO_802_3;
procCtx->hdr_hdl =
m_headerHandles[HEADER_HANDLE_ID_WLAN_802_3];
break;
default:
LOG_MSG_ERROR("proc ctx handleId not supported.");
return;
}
if (!m_headerInsertion.AddProcCtx(procCtxTable))
{
LOG_MSG_ERROR("m_headerInsertion.AddProcCtx(procCtxTable) failed.");
return;
}
// save proc_ctx handle
m_procCtxHHandles[handleId] = procCtx->proc_ctx_hdl;
}
void IpaHdrProcCtxTestFixture::AddRtBypassRule(uint32_t hdrHdl, uint32_t procCtxHdl)
{
static const char bypass0[] = "bypass0";
struct ipa_ioc_get_rt_tbl routing_table0;
if (!CreateIPv4BypassRoutingTable (
bypass0,
hdrHdl,
procCtxHdl))
{
LOG_MSG_ERROR("CreateIPv4BypassRoutingTable Failed\n");
return;
}
routing_table0.ip = IPA_IP_v4;
strlcpy(routing_table0.name, bypass0, sizeof(routing_table0.name));
if (!m_routing.GetRoutingTable(&routing_table0))
{
LOG_MSG_ERROR("m_routing.GetRoutingTable() Failed.");
return;
}
m_routingTableHdl = routing_table0.hdl;
}
void IpaHdrProcCtxTestFixture::AddFltBypassRule()
{
IPAFilteringTable FilterTable0;
struct ipa_flt_rule_add flt_rule_entry;
FilterTable0.Init(IPA_IP_v4,m_currProducerClient,false,1);
printf("FilterTable*.Init Completed Successfully..\n");
// Configuring Filtering Rule No.0
FilterTable0.GeneratePresetRule(1,flt_rule_entry);
flt_rule_entry.at_rear = true;
flt_rule_entry.flt_rule_hdl=-1; // return Value
flt_rule_entry.status = -1; // return value
flt_rule_entry.rule.action=IPA_PASS_TO_ROUTING;
flt_rule_entry.rule.rt_tbl_hdl=m_routingTableHdl;
flt_rule_entry.rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
flt_rule_entry.rule.attrib.u.v4.dst_addr_mask = 0x00000000; // Mask - Bypass rule
flt_rule_entry.rule.attrib.u.v4.dst_addr = 0x12345678; // Filter is irrelevant.
if (((uint8_t)-1 == FilterTable0.AddRuleToTable(flt_rule_entry)) ||
!m_filtering.AddFilteringRule(
FilterTable0.GetFilteringTable()))
{
LOG_MSG_ERROR(
"%s::m_filtering.AddFilteringRule() failed",
__FUNCTION__);
return;
}
else
{
printf("flt rule hdl0=0x%x, status=0x%x\n",
FilterTable0.ReadRuleFromTable(0)->flt_rule_hdl,
FilterTable0.ReadRuleFromTable(0)->status);
}
}
bool IpaHdrProcCtxTestFixture::ReceivePacketsAndCompare()
{
size_t receivedBufferSize1 = 0;
bool isSuccess = true;
// Receive results
Byte *receivedBuffer1 = new Byte[m_BUFF_MAX_SIZE];
if (NULL == receivedBuffer1)
{
printf("Memory allocation error.\n");
return false;
}
receivedBufferSize1 = m_pCurrentConsumer->ReceiveData(
receivedBuffer1,
m_BUFF_MAX_SIZE);
printf("Received %zu bytes on %s.\n",
receivedBufferSize1,
m_pCurrentConsumer->m_fromChannelName.c_str());
// Compare results
if (!CompareResultVsGolden(
m_expectedBuffer1,
m_expectedBufferSize1,
receivedBuffer1,
receivedBufferSize1))
{
printf("Comparison of Buffer Failed!\n");
isSuccess = false;
}
printf("Expected buffer 1 - %zu bytes\n", m_expectedBufferSize1);
print_buff(m_expectedBuffer1, m_expectedBufferSize1);
printf("Received buffer 1 - %zu bytes\n", receivedBufferSize1);
print_buff(receivedBuffer1, receivedBufferSize1);
delete[] receivedBuffer1;
return isSuccess;
}
// Create 1 IPv4 bypass routing entry and commits it
bool IpaHdrProcCtxTestFixture::CreateIPv4BypassRoutingTable (
const char *name,
uint32_t hdrHdl,
uint32_t procCtxHdl)
{
printf("Entering %s, %s()\n",__FUNCTION__, __FILE__);
struct ipa_ioc_add_rt_rule *rt_table = 0;
struct ipa_rt_rule_add *rt_rule_entry = NULL;
// Verify that only one is nonzero
if ((hdrHdl == 0 && procCtxHdl == 0) ||
(hdrHdl != 0 && procCtxHdl != 0))
{
LOG_MSG_ERROR("Error: hdrHdl = %u, procCtxHdl = %u\n");
return false;
}
rt_table = (struct ipa_ioc_add_rt_rule *)
calloc(1, sizeof(struct ipa_ioc_add_rt_rule) +
1*sizeof(struct ipa_rt_rule_add));
if(!rt_table) {
LOG_MSG_ERROR("calloc failed to allocate rt_table\n");
return false;
}
rt_table->num_rules = 1;
rt_table->ip = IPA_IP_v4;
rt_table->commit = true;
strlcpy(rt_table->rt_tbl_name, name, sizeof(rt_table->rt_tbl_name));
rt_rule_entry = &rt_table->rules[0];
rt_rule_entry->at_rear = 0;
rt_rule_entry->rule.dst = m_currConsumerPipeNum;
rt_rule_entry->rule.attrib.attrib_mask = IPA_FLT_DST_ADDR;
rt_rule_entry->rule.attrib.u.v4.dst_addr = 0xaabbccdd;
// All Packets will get a "Hit"
rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0x00000000;
rt_rule_entry->rule.hdr_hdl = hdrHdl;
rt_rule_entry->rule.hdr_proc_ctx_hdl = procCtxHdl;
if (false == m_routing.AddRoutingRule(rt_table))
{
printf("Routing rule addition(rt_table) failed!\n");
Free (rt_table);
return false;
}
Free (rt_table);
printf("Leaving %s, %s()\n",__FUNCTION__, __FILE__);
return true;
}
bool IpaHdrProcCtxTestFixture::AddRules()
{
printf("Entering %s, %s()\n",__FUNCTION__, __FILE__);
if (m_procCtxHandleId == PROC_CTX_HANDLE_ID_MAX)
{
LOG_MSG_ERROR("Test developer didn't implement "
"AddRules() or didn't set m_procCtxHandleId");
return false;
}
AddAllHeaders();
AddAllProcCtx();
AddRtBypassRule(0, m_procCtxHHandles[m_procCtxHandleId]);
AddFltBypassRule();
printf("Leaving %s, %s()\n",__FUNCTION__, __FILE__);
return true;
}// AddRules()
bool IpaHdrProcCtxTestFixture::SendPackets()
{
bool isSuccess = false;
// Send first packet
isSuccess = m_pCurrentProducer->SendData(
m_sendBuffer1,
m_sendSize1);
if (false == isSuccess)
{
LOG_MSG_ERROR("SendPackets Buffer1 failed on client %d\n", m_currProducerClient);
return false;
}
return true;
}
bool IpaHdrProcCtxTestFixture::Run()
{
bool res = false;
bool isSuccess = false;
printf("Entering %s, %s()\n",__FUNCTION__, __FILE__);
res = AddRules();
if (false == res) {
printf("Failed adding filtering rules.\n");
return false;
}
// Load input data - IP packets
res = LoadPackets(m_IpaIPType);
if (false == res) {
printf("Failed loading packets.\n");
return false;
}
res = GenerateExpectedPackets();
if (false == res) {
printf("GenerateExpectedPackets failed\n");
return false;
}
res = SendPackets();
if (false == res) {
printf("SendPackets failed\n");
return false;
}
// Receive packets from the channels and compare results
isSuccess = ReceivePacketsAndCompare();
printf("Leaving %s, %s(), Returning %d\n",
__FUNCTION__,
__FILE__,
isSuccess);
return isSuccess;
} // Run()
IpaHdrProcCtxTestFixture::~IpaHdrProcCtxTestFixture()
{
m_sendSize1 = 0;
}
RoutingDriverWrapper IpaHdrProcCtxTestFixture::m_routing;
Filtering IpaHdrProcCtxTestFixture::m_filtering;
HeaderInsertion IpaHdrProcCtxTestFixture::m_headerInsertion;