ipacm: SRAM NAT, DDR NAT, back-and-forth NAT
NAT can be run out SRAM, then DDR, then back-and-forth all relative to
the number of connections the NAT can hold.
Change-Id: I385245a94f42472e6cb38db921f0133e71235020
CRs-Fixed: 2771990
Signed-off-by: Perry Randise <prandise@codeaurora.org>
diff --git a/ipacm/inc/IPACM_Config.h b/ipacm/inc/IPACM_Config.h
index 1915fbc..cc89c83 100644
--- a/ipacm/inc/IPACM_Config.h
+++ b/ipacm/inc/IPACM_Config.h
@@ -1,5 +1,5 @@
/*
-Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
+Copyright (c) 2013-2020, 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
@@ -109,6 +109,7 @@
int ipa_num_alg_ports;
+ const char* ipa_nat_memtype;
int ipa_nat_max_entries;
bool ipacm_odu_router_mode;
@@ -226,6 +227,11 @@
return ipa_nat_max_entries;
}
+ inline const char* GetNatMemType(void)
+ {
+ return ipa_nat_memtype;
+ }
+
inline int GetNatIfacesCnt()
{
return ipa_nat_iface_entries;
@@ -261,6 +267,8 @@
enum ipa_hw_type GetIPAVer(bool get = false);
+ int ResetClkVote(void);
+
bool isEthBridgingSupported();
bool isIPAv3Supported();
@@ -360,6 +368,10 @@
static const char *DEVICE_NAME_ODU;
private:
+
+ static const int DEFAULT_IPV6CT_MAX_ENTRIES = 500;
+ const char* DEFAULT_NAT_MEMTYPE = "DDR";
+
enum ipa_hw_type ver;
static IPACM_Config *pInstance;
static const char *DEVICE_NAME;
diff --git a/ipacm/inc/IPACM_Conntrack_NATApp.h b/ipacm/inc/IPACM_Conntrack_NATApp.h
index b362907..95dcdfe 100644
--- a/ipacm/inc/IPACM_Conntrack_NATApp.h
+++ b/ipacm/inc/IPACM_Conntrack_NATApp.h
@@ -1,5 +1,5 @@
/*
-Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
+Copyright (c) 2013-2020, 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
@@ -87,6 +87,8 @@
int curCnt, max_entries;
+ const char* mem_type;
+
ipacm_alg *pALGPorts;
uint16_t nALGPort;
diff --git a/ipacm/inc/IPACM_Xml.h b/ipacm/inc/IPACM_Xml.h
index 64c00ed..c78eefd 100644
--- a/ipacm/inc/IPACM_Xml.h
+++ b/ipacm/inc/IPACM_Xml.h
@@ -1,5 +1,5 @@
/*
-Copyright (c) 2013, The Linux Foundation. All rights reserved.
+Copyright (c) 2013-2020, 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
@@ -109,6 +109,9 @@
#define Port_TAG "Port"
#define TCP_PROTOCOL_TAG "TCP"
#define UDP_PROTOCOL_TAG "UDP"
+#define DDR_TABLETYPE_TAG "DDR"
+#define SRAM_TABLETYPE_TAG "SRAM"
+#define HYBRID_TABLETYPE_TAG "HYBRID"
/* FIREWALL Config Entries */
#define Firewall_TAG "Firewall"
@@ -177,6 +180,7 @@
#define IPACMNat_TAG "IPACMNAT"
#define NAT_MaxEntries_TAG "MaxNatEntries"
+#define NAT_TableType_TAG "NatTableType"
#define IP_PassthroughFlag_TAG "IPPassthroughFlag"
#define IP_PassthroughMode_TAG "IPPassthroughMode"
@@ -275,6 +279,7 @@
ipacm_private_subnet_conf_t private_subnet_config;
ipacm_alg_conf_t alg_config;
int nat_max_entries;
+ const char* nat_table_memtype;
bool odu_enable;
bool router_mode_enable;
bool odu_embms_enable;
diff --git a/ipacm/src/IPACM_Config.cpp b/ipacm/src/IPACM_Config.cpp
index c396c6c..88dab03 100644
--- a/ipacm/src/IPACM_Config.cpp
+++ b/ipacm/src/IPACM_Config.cpp
@@ -1,5 +1,5 @@
/*
-Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
+Copyright (c) 2013-2020, 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
@@ -137,6 +137,7 @@
ipa_num_ipa_interfaces = 0;
ipa_num_private_subnet = 0;
ipa_num_alg_ports = 0;
+ ipa_nat_memtype = DEFAULT_NAT_MEMTYPE;
ipa_nat_max_entries = 0;
ipa_nat_iface_entries = 0;
ipa_sw_rt_enable = false;
@@ -172,6 +173,7 @@
int IPACM_Config::Init(void)
{
+ static bool already_reset = false;
/* Read IPACM Config file */
char IPACM_config_file[IPA_MAX_FILE_LEN];
IPACM_conf_t *cfg;
@@ -191,12 +193,23 @@
{
IPACMERR("Failed opening %s.\n", DEVICE_NAME);
}
+
ver = GetIPAVer(true);
+
+ if ( ! already_reset )
+ {
+ if ( ResetClkVote() == 0 )
+ {
+ already_reset = true;
+ }
+ }
+
#ifdef FEATURE_IPACM_HAL
strlcpy(IPACM_config_file, "/vendor/etc/IPACM_cfg.xml", sizeof(IPACM_config_file));
#else
strlcpy(IPACM_config_file, "/etc/IPACM_cfg.xml", sizeof(IPACM_config_file));
#endif
+
IPACMDBG_H("\n IPACM XML file is %s \n", IPACM_config_file);
if (IPACM_SUCCESS == ipacm_read_cfg_xml(IPACM_config_file, cfg))
{
@@ -294,6 +307,11 @@
ipa_nat_max_entries = cfg->nat_max_entries;
IPACMDBG_H("Nat Maximum Entries %d\n", ipa_nat_max_entries);
+ ipa_nat_memtype =
+ (cfg->nat_table_memtype) ?
+ cfg->nat_table_memtype : DEFAULT_NAT_MEMTYPE;
+ IPACMDBG_H("Nat Mem Type %s\n", ipa_nat_memtype);
+
/* Find ODU is either router mode or bridge mode*/
ipacm_odu_enable = cfg->odu_enable;
ipacm_odu_router_mode = cfg->router_mode_enable;
@@ -906,6 +924,24 @@
return ver;
}
+int IPACM_Config::ResetClkVote(void)
+{
+ int ret = -1;
+
+ if ( m_fd > 0 )
+ {
+ ret = ioctl(m_fd, IPA_IOC_APP_CLOCK_VOTE, IPA_APP_CLK_RESET_VOTE);
+
+ if ( ret )
+ {
+ IPACMERR("APP_CLOCK_VOTE ioctl failure %d on IPA fd %d\n",
+ ret, m_fd);
+ }
+ }
+
+ return ret;
+}
+
bool IPACM_Config::isEthBridgingSupported()
{
enum ipa_hw_type hw_type;
diff --git a/ipacm/src/IPACM_Conntrack_NATApp.cpp b/ipacm/src/IPACM_Conntrack_NATApp.cpp
index a9c7140..111733a 100644
--- a/ipacm/src/IPACM_Conntrack_NATApp.cpp
+++ b/ipacm/src/IPACM_Conntrack_NATApp.cpp
@@ -1,5 +1,5 @@
/*
-Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
+Copyright (c) 2013-2020, 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
@@ -39,11 +39,21 @@
#define HDR_METADATA_MUX_ID_BMASK 0x00FF0000
#define HDR_METADATA_MUX_ID_SHFT 0x10
+#undef strcasesame
+#define strcasesame(a, b) (!strcasecmp(a, b))
+
+#undef SRAM_IN_USE
+#define SRAM_IN_USE() \
+ ( strcasesame(mem_type, "HYBRID" ) || \
+ strcasesame(mem_type, "SRAM" ) )
+
/* NatApp class Implementation */
NatApp *NatApp::pInstance = NULL;
NatApp::NatApp()
{
max_entries = 0;
+ mem_type = NULL;
+
cache = NULL;
nat_table_hdl = 0;
@@ -85,6 +95,8 @@
return -1;
}
+ mem_type = pConfig->GetNatMemType();
+
max_entries = pConfig->GetNatMaxEntries();
size = (sizeof(nat_table_entry) * max_entries);
@@ -158,7 +170,6 @@
}
/* NAT APP related object function definitions */
-
int NatApp::AddTable(uint32_t pub_ip, uint8_t mux_id)
{
int ret;
@@ -175,7 +186,7 @@
curCnt = 0;
}
#endif
- ret = ipa_nat_add_ipv4_tbl(pub_ip, max_entries, &nat_table_hdl);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip, mem_type, max_entries, &nat_table_hdl);
if(ret)
{
IPACMERR("unable to create nat table Error:%d\n", ret);
@@ -773,6 +784,20 @@
int cnt;
uint32_t ts;
bool read_to = false;
+ bool keep_awake;
+
+ keep_awake = ( max_entries && SRAM_IN_USE() && ipa_nat_is_sram_supported() );
+
+ if ( keep_awake )
+ {
+ IPACMDBG("Voting clock on\n");
+
+ if ( ipa_nat_vote_clock(IPA_APP_CLK_VOTE) != 0 )
+ {
+ IPACMERR("Voting clock on failed\n");
+ return;
+ }
+ }
for(cnt = 0; cnt < max_entries; cnt++)
{
@@ -804,6 +829,15 @@
} /* end of for loop */
+ if ( keep_awake )
+ {
+ IPACMDBG("Voting clock off\n");
+
+ if ( ipa_nat_vote_clock(IPA_APP_CLK_DEVOTE) != 0 )
+ {
+ IPACMERR("Voting clock off failed\n");
+ }
+ }
}
bool NatApp::isAlgPort(uint8_t proto, uint16_t port)
diff --git a/ipacm/src/IPACM_Xml.cpp b/ipacm/src/IPACM_Xml.cpp
index d59bbb0..28b7af5 100644
--- a/ipacm/src/IPACM_Xml.cpp
+++ b/ipacm/src/IPACM_Xml.cpp
@@ -1,5 +1,5 @@
/*
-Copyright (c) 2013, 2019, The Linux Foundation. All rights reserved.
+Copyright (c) 2013, 2019-2020, 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
@@ -448,6 +448,31 @@
IPACMDBG_H("Nat Table Max Entries %d\n", config->nat_max_entries);
}
}
+ else if (IPACM_util_icmp_string((char*)xml_node->name, NAT_TableType_TAG) == 0)
+ {
+ config->nat_table_memtype = DDR_TABLETYPE_TAG;
+ content = IPACM_read_content_element(xml_node);
+ if (content)
+ {
+ str_size = strlen(content);
+ memset(content_buf, 0, sizeof(content_buf));
+ memcpy(content_buf, (void *)content, str_size);
+ content_buf[MAX_XML_STR_LEN-1] = '\0';
+ if (0 == strncasecmp(content_buf, DDR_TABLETYPE_TAG, str_size))
+ {
+ config->nat_table_memtype = DDR_TABLETYPE_TAG;
+ }
+ else if (0 == strncasecmp(content_buf, SRAM_TABLETYPE_TAG, str_size))
+ {
+ config->nat_table_memtype = SRAM_TABLETYPE_TAG;
+ }
+ else if (0 == strncasecmp(content_buf, HYBRID_TABLETYPE_TAG, str_size))
+ {
+ config->nat_table_memtype = HYBRID_TABLETYPE_TAG;
+ }
+ }
+ IPACMDBG_H("NAT Table location %s\n", config->nat_table_memtype);
+ }
}
break;
default:
diff --git a/ipacm/src/IPACM_cfg.xml b/ipacm/src/IPACM_cfg.xml
index 0c125e5..29c4d21 100644
--- a/ipacm/src/IPACM_cfg.xml
+++ b/ipacm/src/IPACM_cfg.xml
@@ -175,6 +175,7 @@
</IPACMALG>
<IPACMNAT>
<MaxNatEntries>500</MaxNatEntries>
+ <NatTableType>HYBRID</NatTableType>
</IPACMNAT>
</IPACM>
</system>
diff --git a/ipanat/Android.bp b/ipanat/Android.bp
index 310304d..424dd54 100644
--- a/ipanat/Android.bp
+++ b/ipanat/Android.bp
@@ -6,8 +6,13 @@
header_libs: ["qti_kernel_headers"],
srcs: [
- "src/ipa_nat_drv.c",
+ "src/ipa_nat_map.cpp",
+ "src/ipa_table.c",
+ "src/ipa_nat_statemach.c",
"src/ipa_nat_drvi.c",
+ "src/ipa_nat_drv.c",
+ "src/ipa_mem_descriptor.c",
+ "src/ipa_nat_utils.c",
],
shared_libs:
diff --git a/ipanat/inc/ipa_ipv6ct.h b/ipanat/inc/ipa_ipv6ct.h
new file mode 100644
index 0000000..d0c84c8
--- /dev/null
+++ b/ipanat/inc/ipa_ipv6ct.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2018-2020 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.
+ */
+#ifndef IPA_IPV6CT_H
+#define IPA_IPV6CT_H
+
+#include <stdint.h>
+
+/**
+ * enum ipa_ipv6_ct_direction_settings_type - direction filter settings
+ *
+ * IPA_IPV6CT_DIRECTION_DENY_ALL - deny inbound and outbound
+ * IPA_IPV6CT_DIRECTION_ALLOW_OUT - allow outbound and deny inbound
+ * IPA_IPV6CT_DIRECTION_ALLOW_IN - allow inbound and deny outbound
+ * IPA_IPV6CT_DIRECTION_ALLOW_ALL - allow inbound and outbound
+ */
+typedef enum
+{
+ IPA_IPV6CT_DIRECTION_DENY_ALL = 0,
+ IPA_IPV6CT_DIRECTION_ALLOW_OUT = 1,
+ IPA_IPV6CT_DIRECTION_ALLOW_IN = 2,
+ IPA_IPV6CT_DIRECTION_ALLOW_ALL = 3
+} ipa_ipv6_ct_direction_settings_type;
+
+/**
+ * struct ipa_ipv6ct_rule - To hold IPv6CT rule
+ * @src_ipv6_lsb: source IPv6 address LSB
+ * @src_ipv6_msb: source IPv6 address MSB
+ * @dest_ipv6_lsb: destination IPv6 address LSB
+ * @dest_ipv6_msb: destination IPv6 address MSB
+ * @direction_settings: direction filter settings (inbound/outbound) (see ipa_ipv6_ct_direction_settings_type)
+ * @src_port: source port
+ * @dest_port: destination port
+ * @protocol: protocol of rule (tcp/udp)
+ */
+typedef struct {
+ uint64_t src_ipv6_lsb;
+ uint64_t src_ipv6_msb;
+ uint64_t dest_ipv6_lsb;
+ uint64_t dest_ipv6_msb;
+ ipa_ipv6_ct_direction_settings_type direction_settings;
+ uint16_t src_port;
+ uint16_t dest_port;
+ uint8_t protocol;
+} ipa_ipv6ct_rule;
+
+/**
+ * ipa_ipv6ct_add_tbl() - create IPv6CT table
+ * @number_of_entries: [in] number of IPv6CT entries
+ * @table_handle: [out] handle of new IPv6CT table
+ *
+ * To create new IPv6CT table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_ipv6ct_add_tbl(uint16_t number_of_entries, uint32_t* table_handle);
+
+/**
+ * ipa_ipv6ct_del_tbl() - delete IPv6CT table
+ * @table_handle: [in] Handle of IPv6CT table
+ *
+ * To delete given IPv6CT table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_ipv6ct_del_tbl(uint32_t table_handle);
+
+/**
+ * ipa_ipv6ct_add_rule() - to insert new IPv6CT rule
+ * @table_handle: [in] handle of IPv6CT table
+ * @user_rule: [in] Pointer to new rule
+ * @rule_handle: [out] Return the handle to rule
+ *
+ * To insert new rule into a IPv6CT table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_ipv6ct_add_rule(uint32_t table_handle, const ipa_ipv6ct_rule* user_rule, uint32_t* rule_handle);
+
+/**
+ * ipa_ipv6ct_del_rule() - to delete IPv6CT rule
+ * @table_handle: [in] handle of IPv6CT table
+ * @rule_handle: [in] IPv6CT rule handle
+ *
+ * To delete a rule from a IPv6CT table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_ipv6ct_del_rule(uint32_t table_handle, uint32_t rule_handle);
+
+/**
+ * ipa_ipv6ct_query_timestamp() - to query timestamp
+ * @table_handle: [in] handle of IPv6CT table
+ * @rule_handle: [in] IPv6CT rule handle
+ * @time_stamp: [out] time stamp of rule
+ *
+ * To retrieve the timestamp that lastly the IPv6CT rule was accessed
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_ipv6ct_query_timestamp(uint32_t table_handle, uint32_t rule_handle, uint32_t* time_stamp);
+
+/**
+ * ipa_ipv6ct_dump_table() - dumps IPv6CT table
+ * @table_handle: [in] handle of IPv6CT table
+ */
+void ipa_ipv6ct_dump_table(uint32_t tbl_hdl);
+
+#endif
+
diff --git a/ipanat/inc/ipa_ipv6cti.h b/ipanat/inc/ipa_ipv6cti.h
new file mode 100644
index 0000000..4d4e160
--- /dev/null
+++ b/ipanat/inc/ipa_ipv6cti.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2018-2020 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.
+ */
+#ifndef IPA_IPV6CTI_H
+#define IPA_IPV6CTI_H
+
+#include "ipa_table.h"
+#include "ipa_mem_descriptor.h"
+#include "ipa_nat_utils.h"
+
+#define IPA_IPV6CT_MAX_TBLS 1
+
+#define IPA_IPV6CT_RULE_FLAG_FIELD_OFFSET 34
+#define IPA_IPV6CT_RULE_NEXT_FIELD_OFFSET 40
+#define IPA_IPV6CT_RULE_PROTO_FIELD_OFFSET 38
+
+#define IPA_IPV6CT_FLAG_ENABLE_BIT 1
+
+#define IPA_IPV6CT_DIRECTION_ALLOW_BIT 1
+#define IPA_IPV6CT_DIRECTION_DISALLOW_BIT 0
+
+#define IPA_IPV6CT_INVALID_PROTO_FIELD_VALUE 0xFF00
+#define IPA_IPV6CT_INVALID_PROTO_FIELD_CMP 0xFF
+
+typedef enum
+{
+ IPA_IPV6CT_TABLE_FLAGS,
+ IPA_IPV6CT_TABLE_NEXT_INDEX,
+ IPA_IPV6CT_TABLE_PROTOCOL,
+ IPA_IPV6CT_TABLE_DMA_CMD_MAX
+} ipa_ipv6ct_table_dma_cmd_type;
+
+/*------------------------ IPV6CT Table Entry ---------------------------------------------------
+
+ -------------------------------------------------------------------------------------------------
+ | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+ ---------------------------------------------------------------------------------------------------
+ | Outbound Src IPv6 Address (8 LSB Bytes) |
+ ---------------------------------------------------------------------------------------------------
+ | Outbound Src IPv6 Address (8 MSB Bytes) |
+ ---------------------------------------------------------------------------------------------------
+ | Outbound Dest IPv6 Address (8 LSB Bytes) |
+ ---------------------------------------------------------------------------------------------------
+ | Outbound Dest IPv6 Address (8 MSB Bytes) |
+ ---------------------------------------------------------------------------------------------------
+ | Protocol | TimeStamp (3B) | Flags (2B) | Reserved (2B) |
+ | (1B) | |Enable|Redirect|Resv | |
+ ---------------------------------------------------------------------------------------------------
+ |Reserved |Direction(1B)| Src Port (2B) | Dest Port (2B) | Next Index (2B) |
+ | (1B) |IN|OUT|Resv | | | |
+ ---------------------------------------------------------------------------------------------------
+ | SW Specific Parameters(4B) | Reserved (4B) |
+ | Prev Index (2B) | Reserved (2B) | |
+ ---------------------------------------------------------------------------------------------------
+ | Reserved (8B) |
+ ---------------------------------------------------------------------------------------------------
+
+ Dont change below structure definition.
+ It should be same as above(little endian order)
+ -------------------------------------------------------------------------------------------------*/
+typedef struct
+{
+ uint64_t src_ipv6_lsb : 64;
+ uint64_t src_ipv6_msb : 64;
+ uint64_t dest_ipv6_lsb : 64;
+ uint64_t dest_ipv6_msb : 64;
+
+ uint64_t rsvd1 : 30;
+ uint64_t redirect : 1;
+ uint64_t enable : 1;
+ uint64_t time_stamp : 24;
+ uint64_t protocol : 8;
+
+ uint64_t next_index : 16;
+ uint64_t dest_port : 16;
+ uint64_t src_port : 16;
+ uint64_t rsvd2 : 6;
+ uint64_t out_allowed : 1;
+ uint64_t in_allowed : 1;
+ uint64_t rsvd3 : 8;
+
+ uint64_t rsvd4 : 48;
+ uint64_t prev_index : 16;
+
+ uint64_t rsvd5 : 64;
+} ipa_ipv6ct_hw_entry;
+
+/*
+ ----------------------
+ | 1 | 0 |
+ ----------------------
+ | Flags(2B) |
+ |Enable|Redirect|Resv|
+ ----------------------
+*/
+typedef struct
+{
+ uint32_t rsvd1 : 14;
+ uint32_t redirect : 1;
+ uint32_t enable : 1;
+} ipa_ipv6ct_flags;
+
+typedef struct
+{
+ ipa_mem_descriptor mem_desc;
+ ipa_table table;
+ ipa_table_dma_cmd_helper table_dma_cmd_helpers[IPA_IPV6CT_TABLE_DMA_CMD_MAX];
+} ipa_ipv6ct_table;
+
+typedef struct
+{
+ ipa_descriptor* ipa_desc;
+ ipa_ipv6ct_table tables[IPA_IPV6CT_MAX_TBLS];
+ uint8_t table_cnt;
+} ipa_ipv6ct;
+
+#endif
diff --git a/ipanat/inc/ipa_mem_descriptor.h b/ipanat/inc/ipa_mem_descriptor.h
new file mode 100644
index 0000000..e33100c
--- /dev/null
+++ b/ipanat/inc/ipa_mem_descriptor.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018-2019 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.
+ */
+#ifndef IPA_MEM_DESCRIPTOR_H
+#define IPA_MEM_DESCRIPTOR_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <linux/msm_ipa.h>
+
+typedef struct
+{
+ int orig_rqst_size;
+ int mmap_size;
+ void* base_addr;
+ void* mmap_addr;
+ uint32_t addr_offset;
+ unsigned long allocate_ioctl_num;
+ unsigned long delete_ioctl_num;
+ char name[IPA_RESOURCE_NAME_MAX];
+ uint8_t table_index;
+ uint8_t valid;
+ bool consider_using_sram;
+ bool sram_available;
+ bool sram_to_be_used;
+ struct ipa_nat_in_sram_info nat_sram_info;
+} ipa_mem_descriptor;
+
+void ipa_mem_descriptor_init(
+ ipa_mem_descriptor* desc,
+ const char* device_name,
+ int size,
+ uint8_t table_index,
+ unsigned long allocate_ioctl_num,
+ unsigned long delete_ioctl_num,
+ bool consider_using_sram );
+
+int ipa_mem_descriptor_allocate_memory(
+ ipa_mem_descriptor* desc,
+ int ipa_fd);
+
+int ipa_mem_descriptor_delete(
+ ipa_mem_descriptor* desc,
+ int ipa_fd);
+
+#endif
+
diff --git a/ipanat/inc/ipa_nat_drv.h b/ipanat/inc/ipa_nat_drv.h
index d5aa0c6..9be97f3 100644
--- a/ipanat/inc/ipa_nat_drv.h
+++ b/ipanat/inc/ipa_nat_drv.h
@@ -1,37 +1,43 @@
/*
-Copyright (c) 2013 - 2017, 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.
-*/
+ * Copyright (c) 2013-2020 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.
+ */
#ifndef IPA_NAT_DRV_H
#define IPA_NAT_DRV_H
-#include "string.h" /* memset */
-#include "stdlib.h" /* free, malloc */
-#include "stdint.h" /* uint32_t */
+#include "ipa_nat_utils.h"
+
+#include <stdint.h> /* uint32_t */
+#include <stdbool.h>
+
+/**
+ * ipa_nat_is_sram_supported() - Reports if sram is available for use
+ */
+bool ipa_nat_is_sram_supported(void);
/**
* struct ipa_nat_ipv4_rule - To hold ipv4 nat rule
@@ -41,6 +47,9 @@
* @private_port: private port
* @protocol: protocol of rule (tcp/udp)
* @pdn_index: PDN index in the PDN config table
+ * @redirect: used internally by various API calls
+ * @enable: used internally by various API calls
+ * @time_stamp: used internally by various API calls
*/
typedef struct {
uint32_t target_ip;
@@ -50,14 +59,46 @@
uint16_t public_port;
uint8_t protocol;
uint8_t pdn_index;
+ uint8_t redirect;
+ uint8_t enable;
+ uint32_t time_stamp;
} ipa_nat_ipv4_rule;
+static inline char* prep_nat_ipv4_rule_4print(
+ const ipa_nat_ipv4_rule* rule_ptr,
+ char* buf_ptr,
+ uint32_t buf_sz )
+{
+ if ( rule_ptr && buf_ptr && buf_sz )
+ {
+ snprintf(
+ buf_ptr, buf_sz,
+ "IPV4 RULE: "
+ "protocol(0x%02X) "
+ "public_port(0x%04X) "
+ "target_ip(0x%08X) "
+ "target_port(0x%04X) "
+ "private_ip(0x%08X) "
+ "private_port(0x%04X) "
+ "pdn_index(0x%02X)",
+ rule_ptr->protocol,
+ rule_ptr->public_port,
+ rule_ptr->target_ip,
+ rule_ptr->target_port,
+ rule_ptr->private_ip,
+ rule_ptr->private_port,
+ rule_ptr->pdn_index);
+ }
+
+ return buf_ptr;
+}
+
/**
-* struct ipa_nat_pdn_entry - holds a PDN entry data
-* @public_ip: PDN's public ip address
-* @src_metadata: metadata to be used for source NAT metadata replacement
-* @dst_metadata: metadata to be used for destination NAT metadata replacement
-*/
+ * struct ipa_nat_pdn_entry - holds a PDN entry data
+ * @public_ip: PDN's public ip address
+ * @src_metadata: metadata to be used for source NAT metadata replacement
+ * @dst_metadata: metadata to be used for destination NAT metadata replacement
+ */
typedef struct {
uint32_t public_ip;
uint32_t src_metadata;
@@ -67,6 +108,7 @@
/**
* ipa_nat_add_ipv4_tbl() - create ipv4 nat table
* @public_ip_addr: [in] public ipv4 address
+ * @mem_type_ptr: [in] type of memory table is to reside in
* @number_of_entries: [in] number of nat entries
* @table_handle: [out] Handle of new ipv4 nat table
*
@@ -74,9 +116,11 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_add_ipv4_tbl(uint32_t public_ip_addr,
- uint16_t number_of_entries,
- uint32_t *table_handle);
+int ipa_nat_add_ipv4_tbl(
+ uint32_t public_ip_addr,
+ const char *mem_type_ptr,
+ uint16_t number_of_entries,
+ uint32_t *table_handle);
/**
* ipa_nat_del_ipv4_tbl() - delete ipv4 table
@@ -132,16 +176,78 @@
/**
-* ipa_nat_modify_pdn() - modify single PDN entry in the PDN config table
-* @table_handle: [in] handle of ipv4 nat table
-* @pdn_index : [in] the index of the entry to be modified
-* @pdn_info : [in] values for the PDN entry to be changed
-*
-* Modify a PDN entry
-*
-* Returns: 0 On Success, negative on failure
-*/
+ * ipa_nat_modify_pdn() - modify single PDN entry in the PDN config table
+ * @table_handle: [in] handle of ipv4 nat table
+ * @pdn_index : [in] the index of the entry to be modified
+ * @pdn_info : [in] values for the PDN entry to be changed
+ *
+ * Modify a PDN entry
+ *
+ * Returns: 0 On Success, negative on failure
+ */
int ipa_nat_modify_pdn(uint32_t tbl_hdl,
uint8_t pdn_index,
ipa_nat_pdn_entry *pdn_info);
-#endif /* IPA_NAT_DRV_H */
\ No newline at end of file
+
+/**
+* ipa_nat_get_pdn_index() - get a PDN index for a public ip
+* @public_ip : [in] IPv4 address of the PDN entry
+* @pdn_index : [out] the index of the requested PDN entry
+*
+* Get a PDN entry
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_get_pdn_index(uint32_t public_ip, uint8_t *pdn_index);
+
+/**
+* ipa_nat_alloc_pdn() - allocate a PDN for new WAN
+* @pdn_info : [in] values for the PDN entry to be created
+* @pdn_index : [out] the index of the requested PDN entry
+*
+* allocate a new PDN entry
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_alloc_pdn(ipa_nat_pdn_entry *pdn_info,
+ uint8_t *pdn_index);
+
+/**
+* ipa_nat_get_pdn_count() - get the number of allocated PDNs
+* @pdn_cnt : [out] the number of allocated PDNs
+*
+* get the number of allocated PDNs
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_get_pdn_count(uint8_t *pdn_cnt);
+
+/**
+* ipa_nat_dealloc_pdn() - deallocate a PDN entry
+* @pdn_index : [in] pdn index to be deallocated
+*
+* deallocate a PDN in specified index - zero the PDN entry
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_dealloc_pdn(uint8_t pdn_index);
+
+
+/**
+ * ipa_nat_dump_ipv4_table() - dumps IPv4 NAT table
+ * @table_handle: [in] handle of IPv4 NAT table
+ */
+void ipa_nat_dump_ipv4_table(uint32_t tbl_hdl);
+
+/**
+ * ipa_nat_vote_clock() - used for voting clock
+ * @vote_type: [in] desired vote type
+ */
+int ipa_nat_vote_clock(
+ enum ipa_app_clock_vote_type vote_type );
+
+int ipa_nat_switch_to(
+ enum ipa3_nat_mem_in nmi );
+
+#endif
+
diff --git a/ipanat/inc/ipa_nat_drvi.h b/ipanat/inc/ipa_nat_drvi.h
index 292a47b..ae6d363 100644
--- a/ipanat/inc/ipa_nat_drvi.h
+++ b/ipanat/inc/ipa_nat_drvi.h
@@ -1,68 +1,57 @@
/*
-Copyright (c) 2013 - 2019, 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.
-*/
+ * Copyright (c) 2013-2020 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.
+ */
#ifndef IPA_NAT_DRVI_H
#define IPA_NAT_DRVI_H
-#include <stdio.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <linux/msm_ipa.h>
-#include <netinet/in.h>
-#include <sys/inotify.h>
-#include <errno.h>
-#include <pthread.h>
-#include <unistd.h>
+#include "ipa_table.h"
+#include "ipa_mem_descriptor.h"
+#include "ipa_nat_utils.h"
-#include "ipa_nat_logi.h"
+#undef MAKE_TBL_HDL
+#define MAKE_TBL_HDL(hdl, mt) \
+ ((mt) << 31 | (hdl))
-#define NAT_DUMP
+#undef BREAK_TBL_HDL
+#define BREAK_TBL_HDL(hdl_in, mt, hdl_out) \
+ do { \
+ mt = (hdl_in) >> 31 & 0x0000000001; \
+ hdl_out = (hdl_in) & 0x00000000FF; \
+ } while ( 0 )
+
+#undef VALID_TBL_HDL
+#define VALID_TBL_HDL(h) \
+ (((h) & 0x00000000FF) == IPA_NAT_MAX_IP4_TBLS)
/*======= IMPLEMENTATION related data structures and functions ======= */
-#ifdef IPA_ON_R3PC
-#define NAT_MMAP_MEM_SIZE (2 * 1024UL * 1024UL - 1)
-#endif
-#define IPA_DEV_NAME "/dev/ipa"
-#define NAT_DEV_DIR "/dev"
-#define NAT_DEV_NAME "ipaNatTable"
-#define NAT_DEV_FULL_NAME "/dev/ipaNatTable"
-
-#define IPA_NAT_TABLE_VALID 1
#define IPA_NAT_MAX_IP4_TBLS 1
-#define IPA_NAT_BASE_TABLE_PERCENTAGE .8
-#define IPA_NAT_EXPANSION_TABLE_PERCENTAGE .2
-
-#define IPA_NAT_NUM_OF_BASE_TABLES 2
-#define IPA_NAT_UNUSED_BASE_ENTRIES 2
#define IPA_NAT_RULE_FLAG_FIELD_OFFSET 18
#define IPA_NAT_RULE_NEXT_FIELD_OFFSET 8
@@ -71,199 +60,54 @@
#define IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET 2
#define IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET 0
-#define IPA_NAT_RULE_FLAG_FIELD_SIZE 2
-#define IPA_NAT_RULE_NEXTFIELD_FIELD_SIZE 2
-
-#define IPA_NAT_FLAG_ENABLE_BIT_MASK 0x8000
-#define IPA_NAT_FLAG_DISABLE_BIT_MASK 0x0000
-
#define IPA_NAT_FLAG_ENABLE_BIT 1
-#define IPA_NAT_FLAG_DISABLE_BIT 0
#define IPA_NAT_INVALID_PROTO_FIELD_VALUE 0xFF00
-
-#define IPA_NAT_INVALID_INDEX 0xFF
-#define IPA_NAT_INVALID_NAT_ENTRY 0x0
-
-#define INDX_TBL_ENTRY_SIZE_IN_BITS 16
-
-/* ----------- Rule id -----------------------
-
- ------------------------------------------------
- | 3bits | 12 bits | 1 bit |
- ------------------------------------------------
- | reserved | index into table | 0 - base |
- | | | 1 - expansion |
- ------------------------------------------------
-
-*/
-#define IPA_NAT_RULE_HDL_TBL_TYPE_BITS 0x1
-#define IPA_NAT_RULE_HDL_TBL_TYPE_MASK 0x1
-
-/* ----------- sw specif parameter -----
- ------------------------------------
- | 16 bits | 16 bits |
- ------------------------------------
- | index table | prev index |
- | entry | |
- ------------------------------------
------------------------------------------*/
-#define IPA_NAT_SW_PARAM_PREV_INDX_BYTE 0
-#define IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE 1
+/*
+ * IPA_NAT_INVALID_PROTO_FIELD_VALUE above is what's passed to the IPA
+ * in a DMA command. It is written into the NAT's rule, by the
+ * IPA. After being written, It minifests in the rule in the form
+ * below, hence it will be used when perusing the "struct
+ * ipa_nat_rule".
+ */
+#define IPA_NAT_INVALID_PROTO_FIELD_VALUE_IN_RULE 0xFF
typedef enum {
- IPA_NAT_BASE_TBL = 0,
- IPA_NAT_EXPN_TBL = 1,
- IPA_NAT_INDX_TBL = 2,
- IPA_NAT_INDEX_EXPN_TBL = 3,
-} nat_table_type;
-
-typedef enum {
- NEXT_INDEX_FIELD,
- PUBLIC_PORT_FILED,
- PRIVATE_PORT_FIELD,
- TARGET_PORT_FIELD,
- IP_CHKSUM_FIELD,
- ENABLE_FIELD,
- TIME_STAMP_FIELD,
- PROTOCOL_FIELD,
- TCP_UDP_CHKSUM_FIELD,
- SW_SPEC_PARAM_PREV_INDEX_FIELD,
- SW_SPEC_PARAM_INDX_TBL_ENTRY_FIELD,
- INDX_TBL_TBL_ENTRY_FIELD,
- INDX_TBL_NEXT_INDEX_FILED
-} ipa_nat_rule_field_type;
+ IPA_NAT_TABLE_FLAGS,
+ IPA_NAT_TABLE_NEXT_INDEX,
+ IPA_NAT_TABLE_PROTOCOL,
+ IPA_NAT_INDEX_TABLE_ENTRY,
+ IPA_NAT_INDEX_TABLE_NEXT_INDEX,
+ IPA_NAT_TABLE_DMA_CMD_MAX
+} ipa_nat_table_dma_cmd_type;
/*
- ---------------------------------------------
- | 3 | 2 | 1 | 0 |
- ---------------------------------------------
- | Public Port(2B) | Next Index(2B) |
- ---------------------------------------------
-*/
-typedef struct {
- uint32_t next_index:16;
- uint32_t public_port:16;
-} next_index_pub_port;
-
-
-/*
- ---------------------------------------------
- | 3 | 2 | 1 | 0 |
- ---------------------------------------------
- | Flags(2B) | IP check sum Diff(2B)|
- |EN|FIN|Resv | | |
- ---------------------------------------------
-*/
-typedef struct {
- uint32_t ip_chksum:16;
- uint32_t rsvd1:14;
- uint32_t redirect:1;
- uint32_t enable:1;
-} ipcksum_enbl;
-
-
-/*
- ---------------------------------------
- | 7 | 6 | 5 | 4 |
- ---------------------------------------
- | Proto | TimeStamp(3B) |
- | (1B) | |
- ---------------------------------------
-*/
-typedef struct {
- uint32_t time_stamp:24;
- uint32_t protocol:8;
-} time_stamp_proto;
-
-
-/*
- ---------------------------------------------
- | 3 | 2 | 1 | 0 |
- ---------------------------------------------
- | next_index | Table entry |
- ----------------------------------------------
-*/
-typedef struct {
- uint16_t tbl_entry;
- uint16_t next_index;
-} tbl_ent_nxt_indx;
-
-/*--------------------------------------------------
- 32 bit sw_spec_params is interpreted as follows
- ------------------------------------
- | 16 bits | 16 bits |
- ------------------------------------
- | index table | prev index |
- | entry | |
- ------------------------------------
---------------------------------------------------*/
-typedef struct {
- uint16_t prev_index;
- uint16_t index_table_entry;
-} sw_spec_params;
-
-/*------------------------ NAT Table Entry ---------------------------------------
-
- -----------------------------------------------------------------------------------
- | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
- -----------------------------------------------------------------------------------
- | Target IP(4B) | Private IP(4B) |
- -----------------------------------------------------------------------------------
- |Target Port(2B) | Private Port(2B) | Public Port(2B) | Next Index(2B) |
- -----------------------------------------------------------------------------------
- | Proto | TimeStamp(3B) | Flags(2B) | IP check sum Diff(2B)|
- | (1B) | |EN|FIN|Resv | | |
- -----------------------------------------------------------------------------------
- | TCP/UDP checksum |PDN info| Reserved| SW Specific Parameters(4B) |
- | diff (2B) | (1B) | (1B) | |
- -----------------------------------------------------------------------------------
-
- Dont change below structure definition.
- It should be same as above(little endian order)
- -------------------------------------------------------------------------------*/
+ * ------------------------ NAT Table Entry -----------------------------------------
+ *
+ * ------------------------------------------------------------------------------------
+ * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
+ * ------------------------------------------------------------------------------------
+ * | Target IP(4B) | Private IP(4B) |
+ * ------------------------------------------------------------------------------------
+ * |Target Port(2B) | Private Port(2B) | Public Port(2B) | Next Index(2B) |
+ * ------------------------------------------------------------------------------------
+ * | Proto | TimeStamp(3B) | Flags(2B) | IP check sum Diff(2B)|
+ * | (1B) | |EN|Redirect|Resv | |
+ * ------------------------------------------------------------------------------------
+ * | TCP/UDP checksum |PDN info|Reserved | SW Specific Parameters(4B) |
+ * | diff (2B) | (1B) | (1B) | |
+ * ------------------------------------------------------------------------------------
+ *
+ * Dont change below structure definition.
+ *
+ * It should be same as above(little endian order)
+ *
+ * -------------------------------------------------------------------------------
+ */
struct ipa_nat_rule {
uint64_t private_ip:32;
uint64_t target_ip:32;
- uint64_t nxt_indx_pub_port:32;
- uint64_t private_port:16;
- uint64_t target_port:16;
-
- uint64_t ip_cksm_enbl:32;
- uint64_t ts_proto:32;
-
- /*--------------------------------------------------
- 32 bit sw_spec_params is interpreted as follows
- ------------------------------------
- | 16 bits | 16 bits |
- ------------------------------------
- | index table | prev index |
- | entry | |
- ------------------------------------
- --------------------------------------------------*/
- uint64_t sw_spec_params:32;
-
- uint64_t rsvd2:8;
-
- /*-----------------------------------------
- 8 bit PDN info is interpreted as following
- ------------------------------------
- | 4 bits | 4 bits |
- ------------------------------------
- | PDN index | reserved |
- | | |
- ------------------------------------
- -------------------------------------------*/
- uint64_t rsvd3:4;
- uint64_t pdn_index:4;
- uint64_t tcp_udp_chksum:16;
-};
-
-struct ipa_nat_sw_rule {
- uint64_t private_ip:32;
- uint64_t target_ip:32;
-
uint64_t next_index:16;
uint64_t public_port:16;
uint64_t private_port:16;
@@ -276,39 +120,127 @@
uint64_t time_stamp:24;
uint64_t protocol:8;
- /*--------------------------------------------------
- 32 bit sw_spec_params is interpreted as follows
- ------------------------------------
- | 16 bits | 16 bits |
- ------------------------------------
- | index table | prev index |
- | entry | |
- ------------------------------------
- --------------------------------------------------*/
+ /*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
+ ------------------------------------
+ | 16 bits | 16 bits |
+ ------------------------------------
+ | index table | prev index |
+ | entry | |
+ ------------------------------------
+ --------------------------------------------------*/
uint64_t prev_index:16;
uint64_t indx_tbl_entry:16;
- uint64_t rsvd2 :8;
- /*-----------------------------------------
- 8 bit PDN info is interpreted as following
- ------------------------------------
- | 4 bits | 4 bits |
- ------------------------------------
- | PDN index | reserved |
- | | |
- ------------------------------------
- -------------------------------------------*/
- uint64_t rsvd3 :4;
- uint64_t pdn_index :4;
+ uint64_t rsvd2:8;
+ /*-----------------------------------------
+ 8 bit PDN info is interpreted as following
+ ------------------------------------
+ | 4 bits | 4 bits |
+ ------------------------------------
+ | PDN index | reserved |
+ | | |
+ ------------------------------------
+ -------------------------------------------*/
+ uint64_t rsvd3:4;
+ uint64_t pdn_index:4;
uint64_t tcp_udp_chksum:16;
};
-#define IPA_NAT_TABLE_ENTRY_SIZE 32
-#define IPA_NAT_INDEX_TABLE_ENTRY_SIZE 4
+
+static inline char* prep_nat_rule_4print(
+ struct ipa_nat_rule* rule_ptr,
+ char* buf_ptr,
+ uint32_t buf_sz )
+{
+ if ( rule_ptr && buf_ptr && buf_sz )
+ {
+ snprintf(
+ buf_ptr, buf_sz,
+ "NAT RULE: "
+ "protocol(0x%02X) "
+ "public_port(0x%04X) "
+ "target_ip(0x%08X) "
+ "target_port(0x%04X) "
+ "private_ip(0x%08X) "
+ "private_port(0x%04X) "
+ "pdn_index(0x%02X) "
+ "ip_chksum(0x%04X) "
+ "tcp_udp_chksum(0x%04X) "
+ "redirect(0x%02X) "
+ "enable(0x%02X) "
+ "time_stamp(0x%08X) "
+ "indx_tbl_entry(0x%04X) "
+ "prev_index(0x%04X) "
+ "next_index(0x%04X)",
+ rule_ptr->protocol,
+ rule_ptr->public_port,
+ rule_ptr->target_ip,
+ rule_ptr->target_port,
+ rule_ptr->private_ip,
+ rule_ptr->private_port,
+ rule_ptr->pdn_index,
+ rule_ptr->ip_chksum,
+ rule_ptr->tcp_udp_chksum,
+ rule_ptr->redirect,
+ rule_ptr->enable,
+ rule_ptr->time_stamp,
+ rule_ptr->indx_tbl_entry,
+ rule_ptr->prev_index,
+ rule_ptr->next_index);
+ }
+
+ return buf_ptr;
+}
+
+static inline const char *ipa3_nat_mem_in_as_str(
+ enum ipa3_nat_mem_in nmi)
+{
+ switch (nmi) {
+ case IPA_NAT_MEM_IN_DDR:
+ return "IPA_NAT_MEM_IN_DDR";
+ case IPA_NAT_MEM_IN_SRAM:
+ return "IPA_NAT_MEM_IN_SRAM";
+ default:
+ break;
+ }
+ return "???";
+}
+
+static inline char *ipa_ioc_v4_nat_init_as_str(
+ struct ipa_ioc_v4_nat_init *ptr,
+ char *buf,
+ uint32_t buf_sz)
+{
+ if (ptr && buf && buf_sz) {
+ snprintf(
+ buf, buf_sz,
+ "V4 NAT INIT: tbl_index(0x%02X) ipv4_rules_offset(0x%08X) expn_rules_offset(0x%08X) index_offset(0x%08X) index_expn_offset(0x%08X) table_entries(0x%04X) expn_table_entries(0x%04X) ip_addr(0x%08X)",
+ ptr->tbl_index,
+ ptr->ipv4_rules_offset,
+ ptr->expn_rules_offset,
+ ptr->index_offset,
+ ptr->index_expn_offset,
+ ptr->table_entries,
+ ptr->expn_table_entries,
+ ptr->ip_addr);
+ }
+ return buf;
+}
+
+/*
+ ---------------------------------------
+ | 1 | 0 |
+ ---------------------------------------
+ | Flags(2B) |
+ |Enable|Redirect|Resv |
+ ---------------------------------------
+*/
+typedef struct {
+ uint32_t rsvd1:14;
+ uint32_t redirect:1;
+ uint32_t enable:1;
+} ipa_nat_flags;
struct ipa_nat_indx_tbl_rule {
- uint32_t tbl_entry_nxt_indx;
-};
-
-struct ipa_nat_sw_indx_tbl_rule {
uint16_t tbl_entry;
uint16_t next_index;
};
@@ -318,109 +250,28 @@
};
struct ipa_nat_ip4_table_cache {
- uint8_t valid;
uint32_t public_addr;
-
- int nat_fd;
- int size;
- uint32_t tbl_addr_offset;
- char table_name[IPA_RESOURCE_NAME_MAX];
-
- char *ipv4_rules_addr;
- char *index_table_addr;
- uint16_t table_entries;
-
- char *ipv4_expn_rules_addr;
- char *index_table_expn_addr;
- uint16_t expn_table_entries;
-
+ ipa_mem_descriptor mem_desc;
+ ipa_table table;
+ ipa_table index_table;
struct ipa_nat_indx_tbl_meta_info *index_expn_table_meta;
-
- uint16_t *rule_id_array;
-#ifdef IPA_ON_R3PC
- uint32_t mmap_offset;
-#endif
-
- uint16_t cur_tbl_cnt;
- uint16_t cur_expn_tbl_cnt;
+ ipa_table_dma_cmd_helper table_dma_cmd_helpers[IPA_NAT_TABLE_DMA_CMD_MAX];
};
struct ipa_nat_cache {
+ ipa_descriptor* ipa_desc;
struct ipa_nat_ip4_table_cache ip4_tbl[IPA_NAT_MAX_IP4_TBLS];
- int ipa_fd;
uint8_t table_cnt;
- enum ipa_hw_type ver;
+ enum ipa3_nat_mem_in nmi;
};
-struct ipa_nat_indx_tbl_sw_rule {
- uint16_t tbl_entry;
- uint16_t next_index;
- uint16_t prev_index;
-};
-
-typedef enum {
- IPA_NAT_DEL_TYPE_ONLY_ONE,
- IPA_NAT_DEL_TYPE_HEAD,
- IPA_NAT_DEL_TYPE_MIDDLE,
- IPA_NAT_DEL_TYPE_LAST,
-} del_type;
-
-/**
- * ipa_nati_parse_ipv4_rule_hdl() - prase rule handle
- * @tbl_hdl: [in] nat table rule
- * @rule_hdl: [in] nat rule handle
- * @expn_tbl: [out] expansion table or not
- * @tbl_entry: [out] index into table
- *
- * Parse the rule handle to retrieve the nat table
- * type and entry of nat table
- *
- * Returns: None
- */
-void ipa_nati_parse_ipv4_rule_hdl(uint8_t tbl_hdl,
- uint16_t rule_hdl,
- uint8_t *expn_tbl,
- uint16_t *tbl_entry);
-
-/**
- * ipa_nati_make_rule_hdl() - makes nat rule handle
- * @tbl_hdl: [in] nat table handle
- * @tbl_entry: [in] nat table entry
- *
- * Calculate the nat rule handle which from
- * nat entry which will be returned to client of
- * nat driver
- *
- * Returns: >0 nat rule handle
- */
-uint16_t ipa_nati_make_rule_hdl(uint16_t tbl_hdl,
- uint16_t tbl_entry);
-
-uint32_t ipa_nati_get_index_entry_offset(
- struct ipa_nat_ip4_table_cache*,
- nat_table_type tbl_type,
- uint16_t indx_tbl_entry);
-uint32_t ipa_nati_get_entry_offset(
- struct ipa_nat_ip4_table_cache*,
- nat_table_type tbl_type,
- uint16_t tbl_entry);
-
-int ipa_nati_add_ipv4_tbl(uint32_t public_ip_addr,
- uint16_t number_of_entries,
- uint32_t *table_hanle);
-
-int ipa_nati_alloc_table(uint16_t number_of_entries,
- struct ipa_ioc_nat_alloc_mem *mem,
- uint16_t*, uint16_t*);
-
-int ipa_nati_update_cache(struct ipa_ioc_nat_alloc_mem *,
- uint32_t public_ip_addr,
- uint16_t tbl_entries,
- uint16_t expn_tbl_entries);
+int ipa_nati_add_ipv4_tbl(
+ uint32_t public_ip_addr,
+ const char *mem_type_ptr,
+ uint16_t number_of_entries,
+ uint32_t *table_hanle);
int ipa_nati_del_ipv4_table(uint32_t tbl_hdl);
-int ipa_nati_reset_ipv4_table(uint32_t tbl_hdl);
-int ipa_nati_post_ipv4_init_cmd(uint8_t tbl_index);
int ipa_nati_query_timestamp(uint32_t tbl_hdl,
uint32_t rule_hdl,
@@ -428,81 +279,112 @@
int ipa_nati_modify_pdn(struct ipa_ioc_nat_pdn_entry *entry);
+int ipa_nati_get_pdn_index(uint32_t public_ip, uint8_t *pdn_index);
+
+int ipa_nati_alloc_pdn(ipa_nat_pdn_entry *pdn_info, uint8_t *pdn_index);
+
+int ipa_nati_get_pdn_cnt(void);
+
+int ipa_nati_dealloc_pdn(uint8_t pdn_index);
+
int ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
const ipa_nat_ipv4_rule *clnt_rule,
uint32_t *rule_hdl);
-int ipa_nati_generate_rule(uint32_t tbl_hdl,
- const ipa_nat_ipv4_rule *clnt_rule,
- struct ipa_nat_sw_rule *rule,
- struct ipa_nat_indx_tbl_sw_rule *index_sw_rule,
- uint16_t *tbl_entry,
- uint16_t *indx_tbl_entry);
-
-uint16_t ipa_nati_expn_tbl_free_entry(struct ipa_nat_rule *expn_tbl,
- uint16_t size);
-
-uint16_t ipa_nati_generate_tbl_rule(const ipa_nat_ipv4_rule *clnt_rule,
- struct ipa_nat_sw_rule *sw_rule,
- struct ipa_nat_ip4_table_cache *tbl_ptr);
-
-uint16_t ipa_nati_generate_index_rule(const ipa_nat_ipv4_rule *clnt_rule,
- struct ipa_nat_indx_tbl_sw_rule *sw_rule,
- struct ipa_nat_ip4_table_cache *tbl_ptr);
-
-uint16_t ipa_nati_index_expn_get_free_entry(struct ipa_nat_indx_tbl_rule *tbl,
- uint16_t size);
-
-void ipa_nati_copy_ipv4_rule_to_hw(
- struct ipa_nat_ip4_table_cache *ipv4_cache,
- struct ipa_nat_sw_rule *rule,
- uint16_t entry, uint8_t tbl_index);
-
-void ipa_nati_copy_ipv4_index_rule_to_hw(
- struct ipa_nat_ip4_table_cache *ipv4_cache,
- struct ipa_nat_indx_tbl_sw_rule *indx_sw_rule,
- uint16_t entry, uint8_t tbl_index);
-
-void ipa_nati_write_next_index(uint8_t tbl_indx,
- nat_table_type tbl_type,
- uint16_t value,
- uint32_t offset);
-
-int ipa_nati_post_ipv4_dma_cmd(uint8_t tbl_indx,
- uint16_t entry);
-
int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
uint32_t rule_hdl);
-int ipa_nati_post_del_dma_cmd(uint8_t tbl_indx,
- uint16_t tbl_entry,
- uint8_t expn_tbl,
- del_type rule_pos);
+int ipa_nati_get_sram_size(
+ uint32_t* size_ptr);
-void ipa_nati_find_index_rule_pos(
- struct ipa_nat_ip4_table_cache *cache_ptr,
- uint16_t tbl_entry,
- del_type *rule_pos);
+int ipa_nati_clear_ipv4_tbl(
+ uint32_t tbl_hdl );
-void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx);
-void ipa_nati_find_rule_pos(struct ipa_nat_ip4_table_cache *cache_ptr,
- uint8_t expn_tbl,
- uint16_t tbl_entry,
- del_type *rule_pos);
-void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx);
+int ipa_nati_copy_ipv4_tbl(
+ uint32_t src_tbl_hdl,
+ uint32_t dst_tbl_hdl,
+ ipa_table_walk_cb copy_cb );
-uint16_t Read16BitFieldValue(uint32_t param,
- ipa_nat_rule_field_type fld_type);
+typedef enum
+{
+ USE_NAT_TABLE = 0,
+ USE_INDEX_TABLE = 1,
-/* ========================================================
- Debug functions
- ========================================================*/
-#ifdef NAT_DUMP
-void ipa_nati_print_rule(struct ipa_nat_rule*, uint32_t);
-void ipa_nat_dump_ipv4_table(uint32_t);
-void ipa_nati_print_index_rule(struct ipa_nat_indx_tbl_rule*,
- uint32_t, uint16_t);
-int ipa_nati_query_nat_rules(uint32_t, nat_table_type);
-#endif
+ USE_MAX
+} WhichTbl2Use;
+
+#define VALID_WHICHTBL2USE(w) \
+ ( (w) >= USE_NAT_TABLE && (w) < USE_MAX )
+
+int ipa_nati_walk_ipv4_tbl(
+ uint32_t tbl_hdl,
+ WhichTbl2Use which,
+ ipa_table_walk_cb walk_cb,
+ void* arb_data_ptr );
+
+/*
+ * The following used for retrieving table stats.
+ */
+typedef struct
+{
+ enum ipa3_nat_mem_in nmi;
+ uint32_t tot_ents;
+ uint32_t tot_base_ents;
+ uint32_t tot_base_ents_filled;
+ uint32_t tot_expn_ents;
+ uint32_t tot_expn_ents_filled;
+ uint32_t tot_chains;
+ uint32_t min_chain_len;
+ uint32_t max_chain_len;
+ float avg_chain_len;
+} ipa_nati_tbl_stats;
+
+int ipa_nati_ipv4_tbl_stats(
+ uint32_t tbl_hdl,
+ ipa_nati_tbl_stats* nat_stats_ptr,
+ ipa_nati_tbl_stats* idx_stats_ptr );
+
+int ipa_nati_vote_clock(
+ enum ipa_app_clock_vote_type vote_type );
+
+int ipa_NATI_add_ipv4_tbl(
+ enum ipa3_nat_mem_in nmi,
+ uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint32_t* tbl_hdl);
+
+int ipa_NATI_del_ipv4_table(
+ uint32_t tbl_hdl);
+
+int ipa_NATI_clear_ipv4_tbl(
+ uint32_t tbl_hdl );
+
+int ipa_NATI_walk_ipv4_tbl(
+ uint32_t tbl_hdl,
+ WhichTbl2Use which,
+ ipa_table_walk_cb walk_cb,
+ void* arb_data_ptr );
+
+int ipa_NATI_ipv4_tbl_stats(
+ uint32_t tbl_hdl,
+ ipa_nati_tbl_stats* nat_stats_ptr,
+ ipa_nati_tbl_stats* idx_stats_ptr );
+
+int ipa_NATI_query_timestamp(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t* time_stamp);
+
+int ipa_NATI_add_ipv4_rule(
+ uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule* clnt_rule,
+ uint32_t* rule_hdl);
+
+int ipa_NATI_del_ipv4_rule(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl);
+
+int ipa_NATI_post_ipv4_init_cmd(
+ uint32_t tbl_hdl );
#endif /* #ifndef IPA_NAT_DRVI_H */
diff --git a/ipanat/inc/ipa_nat_logi.h b/ipanat/inc/ipa_nat_logi.h
deleted file mode 100644
index 5f79cc6..0000000
--- a/ipanat/inc/ipa_nat_logi.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-Copyright (c) 2013, 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.
-*/
-/*!
- @file
- ipa_nat_logi.h
-
- @brief
- This file implements the IPAM log functionality.
-
- @Author
-
-
-*/
-
-#ifndef IPA_NAT_LOGI_H
-#define IPA_NAT_LOGI_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <syslog.h>
-
-#define PERROR(fmt) printf("%s:%d %s()", __FILE__, __LINE__, __FUNCTION__);\
- perror(fmt);
-
-#define IPAERR(fmt, ...) printf("ERR: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
-
-#ifdef DEBUG
-#define IPADBG(fmt, ...) printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
-
-#define IPADUMP(fmt, ...) printf(fmt, ##__VA_ARGS__);
-
-#else
-#define IPADBG(fmt, ...)
-#define IPADUMP(fmt, ...)
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* IPA_NAT_LOGI_H */
diff --git a/ipanat/inc/ipa_nat_map.h b/ipanat/inc/ipa_nat_map.h
new file mode 100644
index 0000000..d81061b
--- /dev/null
+++ b/ipanat/inc/ipa_nat_map.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+#if !defined(_IPA_NATI_MAP_H_)
+# define _IPA_NATI_MAP_H_
+
+#include <stdint.h>
+
+# ifdef __cplusplus
+extern "C"
+{
+# endif /* __cplusplus */
+
+/* Used below */
+#define MAKE_AS_STR_CASE(v) case v: return #v
+
+/*
+ * The following is used to describe which map to use.
+ *
+ * PLEASE KEEP THE FOLLOWING IN SYNC WITH ipa_which_map_as_str()
+ * BELOW.
+ */
+typedef enum
+{
+ MAP_NUM_00 = 0,
+ MAP_NUM_01 = 1,
+ MAP_NUM_02 = 2,
+ MAP_NUM_03 = 3,
+
+ MAP_NUM_99 = 4,
+
+ MAP_NUM_MAX
+} ipa_which_map;
+
+#define VALID_IPA_USE_MAP(w) \
+ ( (w) >= MAP_NUM_00 || (w) < MAP_NUM_MAX )
+
+/* KEEP THE FOLLOWING IN SYNC WITH ABOVE. */
+static inline const char* ipa_which_map_as_str(
+ ipa_which_map w )
+{
+ switch ( w )
+ {
+ MAKE_AS_STR_CASE(MAP_NUM_00);
+ MAKE_AS_STR_CASE(MAP_NUM_01);
+ MAKE_AS_STR_CASE(MAP_NUM_02);
+ MAKE_AS_STR_CASE(MAP_NUM_03);
+
+ MAKE_AS_STR_CASE(MAP_NUM_99);
+ default:
+ break;
+ }
+
+ return "???";
+}
+
+int ipa_nat_map_add(
+ ipa_which_map which,
+ uint32_t key,
+ uint32_t val );
+
+int ipa_nat_map_find(
+ ipa_which_map which,
+ uint32_t key,
+ uint32_t* val_ptr );
+
+int ipa_nat_map_del(
+ ipa_which_map which,
+ uint32_t key,
+ uint32_t* val_ptr );
+
+int ipa_nat_map_clear(
+ ipa_which_map which );
+
+int ipa_nat_map_dump(
+ ipa_which_map which );
+
+# ifdef __cplusplus
+}
+# endif /* __cplusplus */
+
+#endif /* #if !defined(_IPA_NATI_MAP_H_) */
diff --git a/ipanat/inc/ipa_nat_statemach.h b/ipanat/inc/ipa_nat_statemach.h
new file mode 100644
index 0000000..a86dd87
--- /dev/null
+++ b/ipanat/inc/ipa_nat_statemach.h
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+#if !defined(_IPA_NAT_STATEMACH_H_)
+# define _IPA_NAT_STATEMACH_H_
+
+/******************************************************************************/
+/**
+ * The following enum represents the states that a nati object can be
+ * in.
+ */
+typedef enum {
+ NATI_STATE_NULL = 0,
+ NATI_STATE_DDR_ONLY = 1, /* NAT in DDR only (traditional) */
+ NATI_STATE_SRAM_ONLY = 2, /* NAT in SRAM only (new) */
+ NATI_STATE_HYBRID = 3, /* NAT simultaneously in both SRAM/DDR */
+ NATI_STATE_HYBRID_DDR = 4, /* NAT transitioned from SRAM to DDR */
+
+ NATI_STATE_LAST
+} ipa_nati_state;
+
+# undef strcasesame
+# define strcasesame(a, b) (!strcasecmp(a, b))
+
+static inline ipa_nati_state mem_type_str_to_ipa_nati_state(
+ const char* str )
+{
+ if ( str ) {
+ if (strcasesame(str, "HYBRID" ))
+ return NATI_STATE_HYBRID;
+ if (strcasesame(str, "SRAM" ))
+ return NATI_STATE_SRAM_ONLY;
+ }
+ return NATI_STATE_DDR_ONLY;
+}
+
+/******************************************************************************/
+/**
+ * The following enum represents the API triggers that may or may not
+ * cause a nati object to transition through its various allowable
+ * states defined in ipa_nati_state above.
+ */
+typedef enum {
+ NATI_TRIG_NULL = 0,
+ NATI_TRIG_ADD_TABLE = 1,
+ NATI_TRIG_DEL_TABLE = 2,
+ NATI_TRIG_CLR_TABLE = 3,
+ NATI_TRIG_WLK_TABLE = 4,
+ NATI_TRIG_TBL_STATS = 5,
+ NATI_TRIG_ADD_RULE = 6,
+ NATI_TRIG_DEL_RULE = 7,
+ NATI_TRIG_TBL_SWITCH = 8,
+ NATI_TRIG_GOTO_DDR = 9,
+ NATI_TRIG_GOTO_SRAM = 10,
+ NATI_TRIG_GET_TSTAMP = 11,
+
+ NATI_TRIG_LAST
+} ipa_nati_trigger;
+
+/******************************************************************************/
+/**
+ * The following structure used to keep switch stats.
+ */
+typedef struct
+{
+ uint32_t pass;
+ uint32_t fail;
+} nati_switch_stats;
+
+/******************************************************************************/
+/**
+ * The following structure used to direct map usage.
+ *
+ * Maps are needed to map rule handles..orig to new and new to orig.
+ * See comments in ipa_nat_statemach.c on this topic...
+ */
+typedef struct
+{
+ uint32_t orig2new_map;
+ uint32_t new2orig_map;
+} nati_map_pair;
+
+/******************************************************************************/
+/**
+ * The following is a nati object that will maintain state relative to
+ * various API calls.
+ */
+typedef struct
+{
+ ipa_nati_state prev_state;
+ ipa_nati_state curr_state;
+ uint32_t ddr_tbl_hdl;
+ uint32_t sram_tbl_hdl;
+ uint32_t tot_slots_in_sram;
+ uint32_t back_to_sram_thresh;
+ /*
+ * tot_rules_in_table[0] for ddr, and
+ * tot_rules_in_table[1] for sram
+ */
+ uint32_t tot_rules_in_table[2];
+ /*
+ * map_pairs[0] for ddr, and
+ * map_pairs[1] for sram
+ */
+ nati_map_pair map_pairs[2];
+ /*
+ * sw_stats[0] for ddr, and
+ * sw_stats[1] for sram
+ */
+ nati_switch_stats sw_stats[2];
+} ipa_nati_obj;
+
+/*
+ * For use with the arrays above..in ipa_nati_obj...
+ */
+#undef DDR_SUB
+#undef SRAM_SUB
+
+#define DDR_SUB 0
+#define SRAM_SUB 1
+
+#undef IN_HYBRID_STATE
+#define IN_HYBRID_STATE() \
+ ( nati_obj.curr_state == NATI_STATE_HYBRID || \
+ nati_obj.curr_state == NATI_STATE_HYBRID_DDR )
+
+#undef SRAM_CURRENTLY_ACTIVE
+#define SRAM_CURRENTLY_ACTIVE() \
+ ( nati_obj.curr_state == NATI_STATE_SRAM_ONLY || \
+ nati_obj.curr_state == NATI_STATE_HYBRID )
+
+#define SRAM_TO_BE_ACCESSED(t) \
+ ( SRAM_CURRENTLY_ACTIVE() || \
+ (t) == NATI_TRIG_GOTO_SRAM || \
+ (t) == NATI_TRIG_TBL_SWITCH )
+
+/*
+ * NOTE: The exclusion of timestamp retrieval and table creation
+ * below.
+ *
+ * Why?
+ *
+ * In re timestamp:
+ *
+ * Because timestamp retrieval institutes too many repetitive
+ * accesses, hence would lead to too many successive votes. Instead,
+ * it will be handled differently and in the app layer above.
+ *
+ * In re table creation:
+ *
+ * Because it can't be known, apriori, whether or not sram is
+ * really available for use. Instead, we'll move table creation
+ * voting to a place where we know sram is available.
+ */
+#undef VOTE_REQUIRED
+#define VOTE_REQUIRED(t) \
+ ( SRAM_TO_BE_ACCESSED(t) && \
+ (t) != NATI_TRIG_GET_TSTAMP && \
+ (t) != NATI_TRIG_ADD_TABLE )
+
+/******************************************************************************/
+/**
+ * A helper macro for changing a nati object's state...
+ */
+# undef SET_NATIOBJ_STATE
+# define SET_NATIOBJ_STATE(x, s) { \
+ (x)->prev_state = (x)->curr_state; \
+ (x)->curr_state = s; \
+ }
+
+/******************************************************************************/
+/**
+ * A function signature for a state/trigger callback function...
+ */
+typedef int (*nati_statemach_cb)(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr );
+
+/******************************************************************************/
+/**
+ * A structure for relating state to trigger callbacks.
+ */
+typedef struct
+{
+ ipa_nati_state state;
+ ipa_nati_trigger trigger;
+ nati_statemach_cb sm_cb;
+ const char* state_as_str;
+ const char* trigger_as_str;
+ const char* sm_cb_as_str;
+} nati_statemach_tuple;
+
+#undef SM_ROW
+#define SM_ROW(s, t, f) \
+ { s, t, f, #s, #t, #f }
+
+/******************************************************************************/
+/**
+ * FUNCTION: ipa_nati_statemach
+ *
+ * PARAMS:
+ *
+ * @nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * @trigger (IN) The trigger to run through the state machine
+ *
+ * @arb_data_ptr (IN) Anything you like. Will be passed, untouched,
+ * to the state/trigger callback function.
+ *
+ * DESCRIPTION:
+ *
+ * This function allows a nati object and a trigger to be run
+ * through the state machine.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+int ipa_nati_statemach(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr );
+
+/*
+ * To follow are a number of structures, designed to hold function
+ * arguments, that are to be passed into the state machine...
+ */
+typedef struct
+{
+ uint32_t public_ip_addr;
+ uint16_t number_of_entries;
+ uint32_t* tbl_hdl;
+} table_add_args;
+
+typedef struct
+{
+ uint32_t tbl_hdl;
+} table_del_args;
+
+typedef table_del_args table_clear_args;
+
+typedef struct
+{
+ uint32_t tbl_hdl;
+ WhichTbl2Use which;
+ ipa_table_walk_cb walk_cb;
+ void* arb_data_ptr;
+} table_walk_args;
+
+typedef struct
+{
+ uint32_t tbl_hdl;
+ ipa_nati_tbl_stats* nat_stats_ptr;
+ ipa_nati_tbl_stats* idx_stats_ptr;
+} table_stats_args;
+
+typedef struct
+{
+ uint32_t tbl_hdl;
+ const ipa_nat_ipv4_rule* clnt_rule;
+ uint32_t* rule_hdl;
+} rule_add_args;
+
+typedef struct
+{
+ uint32_t tbl_hdl;
+ uint32_t rule_hdl;
+} rule_del_args;
+
+typedef struct
+{
+ uint32_t tbl_hdl;
+ uint32_t rule_hdl;
+ uint32_t* time_stamp;
+} timestap_query_args;
+
+#endif /* #if !defined(_IPA_NAT_STATEMACH_H_) */
diff --git a/ipanat/inc/ipa_nat_utils.h b/ipanat/inc/ipa_nat_utils.h
new file mode 100644
index 0000000..b6545da
--- /dev/null
+++ b/ipanat/inc/ipa_nat_utils.h
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2013, 2018-2019 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.
+ */
+#ifndef IPA_NAT_UTILS_H
+#define IPA_NAT_UTILS_H
+
+#include <stdio.h>
+#include <string.h>
+#include <syslog.h>
+#include <time.h>
+#include <linux/msm_ipa.h>
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#if !defined(MSM_IPA_TESTS) && !defined(FEATURE_IPA_ANDROID)
+#ifdef USE_GLIB
+#include <glib.h>
+#define strlcpy g_strlcpy
+#else
+size_t strlcpy(char* dst, const char* src, size_t size);
+#endif
+#endif
+
+#define IPAERR(fmt, ...) printf("ERR: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
+
+#define IPAINFO(fmt, ...) printf("INFO: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
+
+#define IPAWARN(fmt, ...) printf("WARN: %s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
+
+#undef UNUSED
+#define UNUSED(v) (void)(v)
+
+#ifdef NAT_DEBUG
+#define IPADBG(fmt, ...) printf("%s:%d %s() " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__);
+#else
+#define IPADBG(fmt, ...)
+#endif
+
+typedef struct
+{
+ int fd;
+ enum ipa_hw_type ver;
+} ipa_descriptor;
+
+ipa_descriptor* ipa_descriptor_open(void);
+
+void ipa_descriptor_close(
+ ipa_descriptor*);
+
+void ipa_read_debug_info(
+ const char* debug_file_path);
+
+static inline char* prep_ioc_nat_dma_cmd_4print(
+ struct ipa_ioc_nat_dma_cmd* cmd_ptr,
+ char* buf_ptr,
+ uint32_t buf_sz )
+{
+ uint32_t i, len, buf_left;
+
+ if ( cmd_ptr && buf_ptr && buf_sz )
+ {
+ snprintf(
+ buf_ptr,
+ buf_sz,
+ "NAT_DMA_CMD: mem_type(%u) entries(%u) ",
+ cmd_ptr->mem_type,
+ cmd_ptr->entries);
+
+ for ( i = 0; i < cmd_ptr->entries; i++ )
+ {
+ len = strlen(buf_ptr);
+
+ buf_left = buf_sz - len;
+
+ if ( buf_left > 0 && buf_left < buf_sz )
+ {
+ snprintf(
+ buf_ptr + len,
+ buf_left,
+ "[%u](table_index(0x%02X) base_addr(0x%02X) offset(0x%08X) data(0x%04X)) ",
+ i,
+ cmd_ptr->dma[i].table_index,
+ cmd_ptr->dma[i].base_addr,
+ cmd_ptr->dma[i].offset,
+ (uint32_t) cmd_ptr->dma[i].data);
+ }
+ }
+ }
+
+ return buf_ptr;
+}
+
+#undef NANOS_PER_SEC
+#undef MICROS_PER_SEC
+#undef MILLIS_PER_SEC
+
+#define NANOS_PER_SEC 1000000000
+#define MICROS_PER_SEC 1000000
+#define MILLIS_PER_SEC 1000
+
+/**
+ * A macro for converting seconds to nanoseconds...
+ */
+#define SECS2NanSECS(x) ((x) * NANOS_PER_SEC)
+
+/**
+ * A macro for converting seconds to microseconds...
+ */
+#define SECS2MicSECS(x) ((x) * MICROS_PER_SEC)
+
+/**
+ * A macro for converting seconds to milliseconds...
+ */
+#define SECS2MilSECS(x) ((x) * MILLIS_PER_SEC)
+
+/******************************************************************************/
+
+typedef enum
+{
+ TimeAsNanSecs = 0,
+ TimeAsMicSecs = 1,
+ TimeAsMilSecs = 2
+} TimeAs_t;
+
+#undef VALID_TIMEAS
+#define VALID_TIMEAS(ta) \
+ ( (ta) == TimeAsNanSecs || \
+ (ta) == TimeAsMicSecs || \
+ (ta) == TimeAsMilSecs )
+
+int currTimeAs(
+ TimeAs_t timeAs,
+ uint64_t* valPtr );
+
+#endif /* IPA_NAT_UTILS_H */
diff --git a/ipanat/inc/ipa_table.h b/ipanat/inc/ipa_table.h
new file mode 100644
index 0000000..aa2159b
--- /dev/null
+++ b/ipanat/inc/ipa_table.h
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2018-2019 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.
+ */
+#ifndef IPA_TABLE_H
+#define IPA_TABLE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <linux/msm_ipa.h>
+
+#define IPA_TABLE_MAX_ENTRIES 5120
+
+#define IPA_TABLE_INVALID_ENTRY 0x0
+
+#undef VALID_INDEX
+#define VALID_INDEX(idx) \
+ ( (idx) != IPA_TABLE_INVALID_ENTRY )
+
+#undef VALID_RULE_HDL
+#define VALID_RULE_HDL(hdl) \
+ ( (hdl) != IPA_TABLE_INVALID_ENTRY )
+
+#undef GOTO_REC
+#define GOTO_REC(tbl, rec_idx) \
+ ( (tbl)->table_addr + ((rec_idx) * (tbl)->entry_size) )
+
+typedef enum
+{
+ IPA_NAT_BASE_TBL = 0,
+ IPA_NAT_EXPN_TBL = 1,
+ IPA_NAT_INDX_TBL = 2,
+ IPA_NAT_INDEX_EXPN_TBL = 3,
+ IPA_IPV6CT_BASE_TBL = 4,
+ IPA_IPV6CT_EXPN_TBL = 5,
+} ipa_table_dma_type;
+
+#define VALID_IPA_TABLE_DMA_TYPE(t) \
+ ( (t) >= IPA_NAT_BASE_TBL && (t) <= IPA_IPV6CT_EXPN_TBL )
+
+/*
+ * --------- NAT Rule Handle Entry ID structure ---------
+ *
+ * +-----------+-----------+------------------+----------------+
+ * | 1 bit | 2 bits | 12 bits | 1 bit |
+ * +-----------+-----------+------------------+----------------+
+ * | 0 - DDR | reserved | index into table | 0 - base |
+ * | 1 - SRAM | | | 1 - expansion |
+ * +-----------+-----------+------------------+----------------+
+ */
+#define IPA_TABLE_TYPE_BITS 0x00000001
+#define IPA_TABLE_TYPE_MASK 0x00000001
+#define IPA_TABLE_INDX_MASK 0x00000FFF
+#define IPA_TABLE_TYPE_MEM_SHIFT 15
+
+#undef BREAK_RULE_HDL
+#define BREAK_RULE_HDL(tbl, hdl, mt, iet, indx) \
+ do { \
+ mt = ((hdl) >> IPA_TABLE_TYPE_MEM_SHIFT) & IPA_TABLE_TYPE_MASK; \
+ iet = (hdl) & IPA_TABLE_TYPE_MASK; \
+ indx = ((hdl) >> IPA_TABLE_TYPE_BITS) & IPA_TABLE_INDX_MASK; \
+ indx += (iet) ? tbl->table_entries : 0; \
+ /*IPADBG("hdl(%u) -> mt(%u) iet(%u) indx(%u)\n", hdl, mt, iet, indx);*/ \
+ } while ( 0 )
+
+typedef int (*entry_validity_checker)(
+ void* entry);
+
+typedef uint16_t (*entry_next_index_getter)(
+ void* entry);
+
+typedef uint16_t (*entry_prev_index_getter)(
+ void* entry,
+ uint16_t entry_index,
+ void* meta,
+ uint16_t base_table_size);
+
+typedef void (*entry_prev_index_setter)(
+ void* entry,
+ uint16_t entry_index,
+ uint16_t prev_index,
+ void* meta,
+ uint16_t base_table_size);
+
+typedef int (*entry_head_inserter)(
+ void* entry,
+ void* user_data,
+ uint16_t* dma_command_data);
+
+typedef int (*entry_tail_inserter)(
+ void* entry,
+ void* user_data);
+
+typedef uint16_t (*entry_delete_head_dma_command_data_getter)(
+ void* head,
+ void* next_entry);
+
+typedef struct
+{
+ entry_validity_checker entry_is_valid;
+ entry_next_index_getter entry_get_next_index;
+ entry_prev_index_getter entry_get_prev_index;
+ entry_prev_index_setter entry_set_prev_index;
+ entry_head_inserter entry_head_insert;
+ entry_tail_inserter entry_tail_insert;
+ entry_delete_head_dma_command_data_getter
+ entry_get_delete_head_dma_command_data;
+} ipa_table_entry_interface;
+
+typedef enum
+{
+ HELP_UPDATE_HEAD = 0,
+ HELP_UPDATE_ENTRY = 1,
+ HELP_DELETE_HEAD = 2,
+
+ HELP_UPDATE_MAX,
+} dma_help_type;
+
+#undef VALID_DMA_HELP_TYPE
+#define VALID_DMA_HELP_TYPE(t) \
+ ( (t) >= HELP_UPDATE_HEAD && (t) < HELP_UPDATE_MAX )
+
+typedef struct
+{
+ uint32_t offset;
+ ipa_table_dma_type table_type;
+ ipa_table_dma_type expn_table_type;
+ uint8_t table_indx;
+} ipa_table_dma_cmd_helper;
+
+typedef struct
+{
+ char name[IPA_RESOURCE_NAME_MAX];
+
+ enum ipa3_nat_mem_in nmi;
+
+ int entry_size;
+
+ uint16_t table_entries;
+ uint16_t expn_table_entries;
+ uint32_t tot_tbl_ents;
+
+ uint8_t* table_addr;
+ uint8_t* expn_table_addr;
+
+ uint16_t cur_tbl_cnt;
+ uint16_t cur_expn_tbl_cnt;
+
+ ipa_table_entry_interface* entry_interface;
+
+ ipa_table_dma_cmd_helper* dma_help[HELP_UPDATE_MAX];
+
+ void* meta;
+ int meta_entry_size;
+} ipa_table;
+
+typedef struct
+{
+ uint16_t prev_index;
+ void* prev_entry;
+
+ uint16_t curr_index;
+ void* curr_entry;
+
+ uint16_t next_index;
+ void* next_entry;
+} ipa_table_iterator;
+
+
+void ipa_table_init(
+ ipa_table* table,
+ const char* table_name,
+ enum ipa3_nat_mem_in nmi,
+ int entry_size,
+ void* meta,
+ int meta_entry_size,
+ ipa_table_entry_interface* entry_interface);
+
+int ipa_table_calculate_entries_num(
+ ipa_table* table,
+ uint16_t number_of_entries,
+ enum ipa3_nat_mem_in nmi);
+
+int ipa_table_calculate_size(
+ ipa_table* table);
+
+uint8_t* ipa_table_calculate_addresses(
+ ipa_table* table,
+ uint8_t* base_addr);
+
+void ipa_table_reset(
+ ipa_table* table);
+
+int ipa_table_add_entry(
+ ipa_table* table,
+ void* user_data,
+ uint16_t* index,
+ uint32_t* rule_hdl,
+ struct ipa_ioc_nat_dma_cmd* cmd);
+
+void ipa_table_create_delete_command(
+ ipa_table* table,
+ struct ipa_ioc_nat_dma_cmd* cmd,
+ ipa_table_iterator* iterator);
+
+void ipa_table_delete_entry(
+ ipa_table* table,
+ ipa_table_iterator* iterator,
+ uint8_t is_prev_empty);
+
+void ipa_table_erase_entry(
+ ipa_table* table,
+ uint16_t index);
+
+int ipa_table_get_entry(
+ ipa_table* table,
+ uint32_t entry_handle,
+ void** entry,
+ uint16_t* entry_index);
+
+void* ipa_table_get_entry_by_index(
+ ipa_table* table,
+ uint16_t index);
+
+void ipa_table_dma_cmd_helper_init(
+ ipa_table_dma_cmd_helper* dma_cmd_helper,
+ uint8_t table_indx,
+ ipa_table_dma_type table_type,
+ ipa_table_dma_type expn_table_type,
+ uint32_t offset);
+
+void ipa_table_dma_cmd_generate(
+ ipa_table_dma_cmd_helper* dma_cmd_helper,
+ uint8_t is_expn,
+ uint32_t entry_offset,
+ uint16_t data,
+ struct ipa_ioc_nat_dma_cmd* cmd);
+
+int ipa_table_iterator_init(
+ ipa_table_iterator* iterator,
+ ipa_table* table,
+ void* curr_entry,
+ uint16_t curr_index);
+
+int ipa_table_iterator_next(
+ ipa_table_iterator* iterator,
+ ipa_table* table);
+
+int ipa_table_iterator_end(
+ ipa_table_iterator* iterator,
+ ipa_table* table,
+ uint16_t head_index,
+ void* head);
+
+int ipa_table_iterator_is_head_with_tail(
+ ipa_table_iterator* iterator);
+
+int ipa_calc_num_sram_table_entries(
+ uint32_t sram_size,
+ uint32_t table1_ent_size,
+ uint32_t table2_ent_size,
+ uint16_t* num_entries_ptr);
+
+typedef int (*ipa_table_walk_cb)(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr );
+
+typedef enum
+{
+ WHEN_SLOT_EMPTY = 0,
+ WHEN_SLOT_FILLED = 1,
+
+ WHEN_SLOT_MAX
+} When2Callback;
+
+#define VALID_WHEN2CALLBACK(w) \
+ ( (w) >= WHEN_SLOT_EMPTY && (w) < WHEN_SLOT_MAX )
+
+int ipa_table_walk(
+ ipa_table* table,
+ uint16_t start_index,
+ When2Callback when,
+ ipa_table_walk_cb walk_cb,
+ void* arb_data_ptr );
+
+int ipa_table_add_dma_cmd(
+ ipa_table* tbl_ptr,
+ dma_help_type help_type,
+ void* rec_ptr,
+ uint16_t rec_index,
+ uint16_t data_for_entry,
+ struct ipa_ioc_nat_dma_cmd* cmd_ptr );
+
+#endif
diff --git a/ipanat/src/Makefile.am b/ipanat/src/Makefile.am
index 8e2d005..abfc353 100644
--- a/ipanat/src/Makefile.am
+++ b/ipanat/src/Makefile.am
@@ -1,12 +1,15 @@
-AM_CFLAGS = -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs
+AM_CFLAGS = -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -Wno-unused-variable
+
if KERNELMODULES
AM_CFLAGS += -I./../inc $(KERNEL_DIR)/include
else
AM_CFLAGS += -I./../inc
endif
-#AM_CFLAGS += -DDEBUG -g
+
+#AM_CFLAGS += -g -DDEBUG -DNAT_DEBUG
common_CFLAGS = -DUSE_GLIB @GLIB_CFLAGS@
+
if !KERNELMODULES
common_LDFLAGS = -lrt @GLIB_LIBS@
endif
@@ -17,22 +20,40 @@
library_includedir = $(pkgincludedir)
endif
-c_sources = ipa_nat_drv.c \
- ipa_nat_drvi.c \
- ipa_nat_logi.c
+cpp_sources = \
+ ipa_nat_map.cpp
-library_include_HEADERS = ./../inc/ipa_nat_drvi.h \
- ./../inc/ipa_nat_drv.h \
- ./../inc/ipa_nat_logi.h
+c_sources = \
+ ipa_table.c \
+ ipa_nat_statemach.c \
+ ipa_nat_drvi.c \
+ ipa_nat_drv.c \
+ ipa_mem_descriptor.c \
+ ipa_nat_utils.c \
+ ipa_ipv6ct.c
+
+library_include_HEADERS = \
+ ../inc/ipa_mem_descriptor.h \
+ ../inc/ipa_nat_drv.h \
+ ../inc/ipa_nat_drvi.h \
+ ../inc/ipa_nat_map.h \
+ ../inc/ipa_nat_statemach.h \
+ ../inc/ipa_nat_utils.h \
+ ../inc/ipa_table.h
if KERNELMODULES
noinst_LIBRARIES = libipanat.a
libipanat_a_C = @C@
-libipanat_a_SOURCES = $(c_sources)
+libipanat_a_CC = @CC@
+libipanat_a_SOURCES = $(c_sources) $(cpp_sources)
+libipanat_a_CFLAGS = $(AM_CFLAGS) $(common_CFLAGS)
+libipanat_a_CXXFLAGS = $(AM_CFLAGS) $(common_CPPFLAGS)
else
lib_LTLIBRARIES = libipanat.la
libipanat_la_C = @C@
-libipanat_la_SOURCES = $(c_sources)
+libipanat_la_CC = @CC@
+libipanat_la_SOURCES = $(c_sources) $(cpp_sources)
libipanat_la_CFLAGS = $(AM_CFLAGS) $(common_CFLAGS)
+libipanat_la_CXXFLAGS = $(AM_CFLAGS) $(common_CPPFLAGS)
libipanat_la_LDFLAGS = -shared $(common_LDFLAGS) -version-info 1:0:0
endif
diff --git a/ipanat/src/ipa_ipv6ct.c b/ipanat/src/ipa_ipv6ct.c
new file mode 100644
index 0000000..a5ffbb0
--- /dev/null
+++ b/ipanat/src/ipa_ipv6ct.c
@@ -0,0 +1,856 @@
+/*
+ * Copyright (c) 2018-2020 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 "ipa_ipv6ct.h"
+#include "ipa_ipv6cti.h"
+
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#define IPA_IPV6CT_DEBUG_FILE_PATH "/sys/kernel/debug/ipa/ipv6ct"
+#define IPA_IPV6CT_TABLE_NAME "IPA IPv6CT table"
+
+static int ipa_ipv6ct_create_table(ipa_ipv6ct_table* ipv6ct_table, uint16_t number_of_entries, uint8_t table_index);
+static int ipa_ipv6ct_destroy_table(ipa_ipv6ct_table* ipv6ct_table);
+static void ipa_ipv6ct_create_table_dma_cmd_helpers(ipa_ipv6ct_table* ipv6ct_table, uint8_t table_indx);
+static int ipa_ipv6ct_post_init_cmd(ipa_ipv6ct_table* ipv6ct_table, uint8_t tbl_index);
+static int ipa_ipv6ct_post_dma_cmd(struct ipa_ioc_nat_dma_cmd* cmd);
+static uint16_t ipa_ipv6ct_hash(const ipa_ipv6ct_rule* rule, uint16_t size);
+static uint16_t ipa_ipv6ct_xor_segments(uint64_t num);
+
+static int table_entry_is_valid(void* entry);
+static uint16_t table_entry_get_next_index(void* entry);
+static uint16_t table_entry_get_prev_index(void* entry, uint16_t entry_index, void* meta, uint16_t base_table_size);
+static void table_entry_set_prev_index(void* entry, uint16_t entry_index, uint16_t prev_index,
+ void* meta, uint16_t base_table_size);
+static int table_entry_head_insert(void* entry, void* user_data, uint16_t* dma_command_data);
+static int table_entry_tail_insert(void* entry, void* user_data);
+static uint16_t table_entry_get_delete_head_dma_command_data(void* head, void* next_entry);
+
+static ipa_ipv6ct ipv6ct;
+static pthread_mutex_t ipv6ct_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static ipa_table_entry_interface entry_interface =
+{
+ table_entry_is_valid,
+ table_entry_get_next_index,
+ table_entry_get_prev_index,
+ table_entry_set_prev_index,
+ table_entry_head_insert,
+ table_entry_tail_insert,
+ table_entry_get_delete_head_dma_command_data
+};
+
+/**
+ * ipa_ipv6ct_add_tbl() - Adds a new IPv6CT table
+ * @number_of_entries: [in] number of IPv6CT entries
+ * @table_handle: [out] handle of new IPv6CT table
+ *
+ * This function creates new IPv6CT table and posts IPv6CT init command to HW
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_ipv6ct_add_tbl(uint16_t number_of_entries, uint32_t* table_handle)
+{
+ int ret;
+ ipa_ipv6ct_table* ipv6ct_table;
+
+ IPADBG("\n");
+
+ if (table_handle == NULL || number_of_entries == 0)
+ {
+ IPAERR("Invalid parameters table_handle=%pK number_of_entries=%d\n", table_handle, number_of_entries);
+ return -EINVAL;
+ }
+
+ *table_handle = 0;
+
+ if (ipv6ct.table_cnt >= IPA_IPV6CT_MAX_TBLS)
+ {
+ IPAERR("Can't add addition IPv6 connection tracking table. Maximum %d tables allowed\n", IPA_IPV6CT_MAX_TBLS);
+ return -EINVAL;
+ }
+
+ if (!ipv6ct.ipa_desc)
+ {
+ ipv6ct.ipa_desc = ipa_descriptor_open();
+ if (ipv6ct.ipa_desc == NULL)
+ {
+ IPAERR("failed to open IPA driver file descriptor\n");
+ return -EIO;
+ }
+ }
+
+ if (ipv6ct.ipa_desc->ver < IPA_HW_v4_0)
+ {
+ IPAERR("IPv6 connection tracking isn't supported for IPA version %d\n", ipv6ct.ipa_desc->ver);
+ ret = -EPERM;
+ goto bail_ipa_desc;
+ }
+
+ ipv6ct_table = &ipv6ct.tables[ipv6ct.table_cnt];
+ ret = ipa_ipv6ct_create_table(ipv6ct_table, number_of_entries, ipv6ct.table_cnt);
+ if (ret)
+ {
+ IPAERR("unable to create ipv6ct table Error: %d\n", ret);
+ goto bail_ipa_desc;
+ }
+
+ /* Initialize the ipa hw with ipv6ct table dimensions */
+ ret = ipa_ipv6ct_post_init_cmd(ipv6ct_table, ipv6ct.table_cnt);
+ if (ret)
+ {
+ IPAERR("unable to post ipv6ct_init command Error %d\n", ret);
+ goto bail_ipv6ct_table;
+ }
+
+ /* Return table handle */
+ ++ipv6ct.table_cnt;
+ *table_handle = ipv6ct.table_cnt;
+
+ IPADBG("Returning table handle 0x%x\n", *table_handle);
+ return 0;
+
+bail_ipv6ct_table:
+ ipa_ipv6ct_destroy_table(ipv6ct_table);
+bail_ipa_desc:
+ if (!ipv6ct.table_cnt) {
+ ipa_descriptor_close(ipv6ct.ipa_desc);
+ ipv6ct.ipa_desc = NULL;
+ }
+ return ret;
+}
+
+int ipa_ipv6ct_del_tbl(uint32_t table_handle)
+{
+ ipa_ipv6ct_table* ipv6ct_table;
+ int ret;
+
+ IPADBG("\n");
+
+ if (ipv6ct.ipa_desc->ver < IPA_HW_v4_0)
+ {
+ IPAERR("IPv6 connection tracking isn't supported for IPA version %d\n", ipv6ct.ipa_desc->ver);
+ return -EINVAL;
+ }
+
+ if (table_handle == IPA_TABLE_INVALID_ENTRY || table_handle > IPA_IPV6CT_MAX_TBLS)
+ {
+ IPAERR("invalid table handle %d passed\n", table_handle);
+ return -EINVAL;
+ }
+ IPADBG("Passed Table Handle: 0x%x\n", table_handle);
+
+ if (pthread_mutex_lock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to lock the ipv6ct mutex\n");
+ return -EINVAL;
+ }
+
+ ipv6ct_table = &ipv6ct.tables[table_handle - 1];
+ if (!ipv6ct_table->mem_desc.valid)
+ {
+ IPAERR("invalid table handle %d\n", table_handle);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ ret = ipa_ipv6ct_destroy_table(ipv6ct_table);
+ if (ret)
+ {
+ IPAERR("unable to delete IPV6CT table with handle %d\n", table_handle);
+ goto unlock;
+ }
+
+ if (!--ipv6ct.table_cnt) {
+ ipa_descriptor_close(ipv6ct.ipa_desc);
+ ipv6ct.ipa_desc = NULL;
+ }
+
+unlock:
+ if (pthread_mutex_unlock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to unlock the ipv6ct mutex\n");
+ return (ret) ? ret : -EPERM;
+ }
+
+ IPADBG("return\n");
+ return ret;
+}
+
+int ipa_ipv6ct_add_rule(uint32_t table_handle, const ipa_ipv6ct_rule* user_rule, uint32_t* rule_handle)
+{
+ int ret;
+ ipa_ipv6ct_table* ipv6ct_table;
+ uint16_t new_entry_index;
+ uint32_t new_entry_handle;
+ uint32_t cmd_sz =
+ sizeof(struct ipa_ioc_nat_dma_cmd) +
+ (MAX_DMA_ENTRIES_FOR_ADD * sizeof(struct ipa_ioc_nat_dma_one));
+ char cmd_buf[cmd_sz];
+ struct ipa_ioc_nat_dma_cmd* cmd =
+ (struct ipa_ioc_nat_dma_cmd*) cmd_buf;
+
+ IPADBG("In\n");
+
+ memset(cmd_buf, 0, sizeof(cmd_buf));
+
+ if (ipv6ct.ipa_desc->ver < IPA_HW_v4_0)
+ {
+ IPAERR("IPv6 connection tracking isn't supported for IPA version %d\n", ipv6ct.ipa_desc->ver);
+ return -EINVAL;
+ }
+
+ if (table_handle == IPA_TABLE_INVALID_ENTRY || table_handle > IPA_IPV6CT_MAX_TBLS ||
+ rule_handle == NULL || user_rule == NULL)
+ {
+ IPAERR("Invalid parameters table_handle=%d rule_handle=%pK user_rule=%pK\n",
+ table_handle, rule_handle, user_rule);
+ return -EINVAL;
+ }
+ IPADBG("Passed Table handle: 0x%x\n", table_handle);
+
+ if (user_rule->protocol == IPA_IPV6CT_INVALID_PROTO_FIELD_CMP)
+ {
+ IPAERR("invalid parameter protocol=%d\n", user_rule->protocol);
+ return -EINVAL;
+ }
+
+ if (pthread_mutex_lock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to lock the ipv6ct mutex\n");
+ return -EINVAL;
+ }
+
+ ipv6ct_table = &ipv6ct.tables[table_handle - 1];
+ if (!ipv6ct_table->mem_desc.valid)
+ {
+ IPAERR("invalid table handle %d\n", table_handle);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ new_entry_index = ipa_ipv6ct_hash(user_rule, ipv6ct_table->table.table_entries - 1);
+
+ ret = ipa_table_add_entry(&ipv6ct_table->table, (void*)user_rule, &new_entry_index, &new_entry_handle, cmd);
+ if (ret)
+ {
+ IPAERR("failed to add a new IPV6CT entry\n");
+ goto unlock;
+ }
+
+ ret = ipa_ipv6ct_post_dma_cmd(cmd);
+ if (ret)
+ {
+ IPAERR("unable to post dma command\n");
+ goto bail;
+ }
+
+ if (pthread_mutex_unlock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to unlock the ipv6ct mutex\n");
+ return -EPERM;
+ }
+
+ *rule_handle = new_entry_handle;
+
+ IPADBG("return\n");
+
+ return 0;
+
+bail:
+ ipa_table_erase_entry(&ipv6ct_table->table, new_entry_index);
+
+unlock:
+ if (pthread_mutex_unlock(&ipv6ct_mutex))
+ IPAERR("unable to unlock the ipv6ct mutex\n");
+
+ IPADBG("return\n");
+
+ return ret;
+}
+
+int ipa_ipv6ct_del_rule(uint32_t table_handle, uint32_t rule_handle)
+{
+ ipa_ipv6ct_table* ipv6ct_table;
+ ipa_table_iterator table_iterator;
+ ipa_ipv6ct_hw_entry* entry;
+ uint16_t index;
+ uint32_t cmd_sz =
+ sizeof(struct ipa_ioc_nat_dma_cmd) +
+ (MAX_DMA_ENTRIES_FOR_DEL * sizeof(struct ipa_ioc_nat_dma_one));
+ char cmd_buf[cmd_sz];
+ struct ipa_ioc_nat_dma_cmd* cmd =
+ (struct ipa_ioc_nat_dma_cmd*) cmd_buf;
+ int ret;
+
+ IPADBG("In\n");
+
+ memset(cmd_buf, 0, sizeof(cmd_buf));
+
+ if (ipv6ct.ipa_desc->ver < IPA_HW_v4_0)
+ {
+ IPAERR("IPv6 connection tracking isn't supported for IPA version %d\n", ipv6ct.ipa_desc->ver);
+ return -EINVAL;
+ }
+
+ if (table_handle == IPA_TABLE_INVALID_ENTRY || table_handle > IPA_IPV6CT_MAX_TBLS ||
+ rule_handle == IPA_TABLE_INVALID_ENTRY)
+ {
+ IPAERR("Invalid parameters table_handle=%d rule_handle=%d\n", table_handle, rule_handle);
+ return -EINVAL;
+ }
+ IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", table_handle, rule_handle);
+
+ if (pthread_mutex_lock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to lock the ipv6ct mutex\n");
+ return -EINVAL;
+ }
+
+ ipv6ct_table = &ipv6ct.tables[table_handle - 1];
+ if (!ipv6ct_table->mem_desc.valid)
+ {
+ IPAERR("invalid table handle %d\n", table_handle);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ ret = ipa_table_get_entry(&ipv6ct_table->table, rule_handle, (void**)&entry, &index);
+ if (ret)
+ {
+ IPAERR("unable to retrive the entry with handle=%d in IPV6CT table with handle=%d\n",
+ rule_handle, table_handle);
+ goto unlock;
+ }
+
+ ret = ipa_table_iterator_init(&table_iterator, &ipv6ct_table->table, entry, index);
+ if (ret)
+ {
+ IPAERR("unable to create iterator which points to the entry index=%d in IPV6CT table with handle=%d\n",
+ index, table_handle);
+ goto unlock;
+ }
+
+ ipa_table_create_delete_command(&ipv6ct_table->table, cmd, &table_iterator);
+
+ ret = ipa_ipv6ct_post_dma_cmd(cmd);
+ if (ret)
+ {
+ IPAERR("unable to post dma command\n");
+ goto unlock;
+ }
+
+ if (!ipa_table_iterator_is_head_with_tail(&table_iterator))
+ {
+ /* The entry can be deleted */
+ uint8_t is_prev_empty = (table_iterator.prev_entry != NULL &&
+ ((ipa_ipv6ct_hw_entry*)table_iterator.prev_entry)->protocol == IPA_IPV6CT_INVALID_PROTO_FIELD_CMP);
+ ipa_table_delete_entry(&ipv6ct_table->table, &table_iterator, is_prev_empty);
+ }
+
+unlock:
+ if (pthread_mutex_unlock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to unlock the ipv6ct mutex\n");
+ return (ret) ? ret : -EPERM;
+ }
+
+ IPADBG("return\n");
+
+ return ret;
+}
+
+int ipa_ipv6ct_query_timestamp(uint32_t table_handle, uint32_t rule_handle, uint32_t* time_stamp)
+{
+ int ret;
+ ipa_ipv6ct_table* ipv6ct_table;
+ ipa_ipv6ct_hw_entry *entry;
+
+ IPADBG("\n");
+
+ if (ipv6ct.ipa_desc->ver < IPA_HW_v4_0)
+ {
+ IPAERR("IPv6 connection tracking isn't supported for IPA version %d\n", ipv6ct.ipa_desc->ver);
+ return -EINVAL;
+ }
+
+ if (table_handle == IPA_TABLE_INVALID_ENTRY || table_handle > IPA_IPV6CT_MAX_TBLS ||
+ rule_handle == IPA_TABLE_INVALID_ENTRY || time_stamp == NULL)
+ {
+ IPAERR("invalid parameters passed table_handle=%d rule_handle=%d time_stamp=%pK\n",
+ table_handle, rule_handle, time_stamp);
+ return -EINVAL;
+ }
+ IPADBG("Passed Table: %d and rule handle %d\n", table_handle, rule_handle);
+
+ if (pthread_mutex_lock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to lock the ipv6ct mutex\n");
+ return -EINVAL;
+ }
+
+ ipv6ct_table = &ipv6ct.tables[table_handle - 1];
+ if (!ipv6ct_table->mem_desc.valid)
+ {
+ IPAERR("invalid table handle %d\n", table_handle);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ ret = ipa_table_get_entry(&ipv6ct_table->table, rule_handle, (void**)&entry, NULL);
+ if (ret)
+ {
+ IPAERR("unable to retrive the entry with handle=%d in IPV6CT table with handle=%d\n",
+ rule_handle, table_handle);
+ goto unlock;
+ }
+
+ *time_stamp = entry->time_stamp;
+
+unlock:
+ if (pthread_mutex_unlock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to unlock the ipv6ct mutex\n");
+ return (ret) ? ret : -EPERM;
+ }
+
+ IPADBG("return\n");
+ return ret;
+}
+
+/**
+* ipv6ct_hash() - Find the index into ipv6ct table
+* @rule: [in] an IPv6CT rule
+* @size: [in] size of the IPv6CT table
+*
+* This hash method is used to find the hash index of an entry into IPv6CT table.
+* In case of result zero, N-1 will be returned, where N is size of IPv6CT table.
+*
+* Returns: >0 index into IPv6CT table, negative on failure
+*/
+static uint16_t ipa_ipv6ct_hash(const ipa_ipv6ct_rule* rule, uint16_t size)
+{
+ uint16_t hash = 0;
+
+ IPADBG("src_ipv6_lsb 0x%llx\n", rule->src_ipv6_lsb);
+ IPADBG("src_ipv6_msb 0x%llx\n", rule->src_ipv6_msb);
+ IPADBG("dest_ipv6_lsb 0x%llx\n", rule->dest_ipv6_lsb);
+ IPADBG("dest_ipv6_msb 0x%llx\n", rule->dest_ipv6_msb);
+ IPADBG("src_port: 0x%x dest_port: 0x%x\n", rule->src_port, rule->dest_port);
+ IPADBG("protocol: 0x%x size: 0x%x\n", rule->protocol, size);
+
+ hash ^= ipa_ipv6ct_xor_segments(rule->src_ipv6_lsb);
+ hash ^= ipa_ipv6ct_xor_segments(rule->src_ipv6_msb);
+ hash ^= ipa_ipv6ct_xor_segments(rule->dest_ipv6_lsb);
+ hash ^= ipa_ipv6ct_xor_segments(rule->dest_ipv6_msb);
+
+ hash ^= rule->src_port;
+ hash ^= rule->dest_port;
+ hash ^= rule->protocol;
+
+ /*
+ * The size passed to hash function expected be power^2-1, while the actual size is power^2,
+ * actual_size = size + 1
+ */
+ hash &= size;
+
+ /* If the hash resulted to zero then set it to maximum value as zero is unused entry in ipv6ct table */
+ if (hash == 0)
+ {
+ hash = size;
+ }
+
+ IPADBG("ipa_ipv6ct_hash returning value: %d\n", hash);
+ return hash;
+}
+
+static uint16_t ipa_ipv6ct_xor_segments(uint64_t num)
+{
+ const uint64_t mask = 0xffff;
+ const size_t bits_in_two_byte = 16;
+ uint16_t ret = 0;
+
+ IPADBG("\n");
+
+ while (num)
+ {
+ ret ^= (uint16_t)(num & mask);
+ num >>= bits_in_two_byte;
+ }
+
+ IPADBG("return\n");
+ return ret;
+}
+
+static int table_entry_is_valid(void* entry)
+{
+ ipa_ipv6ct_hw_entry* ipv6ct_entry = (ipa_ipv6ct_hw_entry*)entry;
+
+ IPADBG("\n");
+
+ return ipv6ct_entry->enable;
+}
+
+static uint16_t table_entry_get_next_index(void* entry)
+{
+ uint16_t result;
+ ipa_ipv6ct_hw_entry* ipv6ct_entry = (ipa_ipv6ct_hw_entry*)entry;
+
+ IPADBG("\n");
+
+ result = ipv6ct_entry->next_index;
+
+ IPADBG("Next entry of %pK is %d\n", entry, result);
+ return result;
+}
+
+static uint16_t table_entry_get_prev_index(void* entry, uint16_t entry_index, void* meta, uint16_t base_table_size)
+{
+ uint16_t result;
+ ipa_ipv6ct_hw_entry* ipv6ct_entry = (ipa_ipv6ct_hw_entry*)entry;
+
+ IPADBG("\n");
+
+ result = ipv6ct_entry->prev_index;
+
+ IPADBG("Previous entry of %d is %d\n", entry_index, result);
+ return result;
+}
+
+static void table_entry_set_prev_index(void* entry, uint16_t entry_index, uint16_t prev_index,
+ void* meta, uint16_t base_table_size)
+{
+ ipa_ipv6ct_hw_entry* ipv6ct_entry = (ipa_ipv6ct_hw_entry*)entry;
+
+ IPADBG("Previous entry of %d is %d\n", entry_index, prev_index);
+
+ ipv6ct_entry->prev_index = prev_index;
+
+ IPADBG("return\n");
+}
+
+static int table_entry_copy_from_user(void* entry, void* user_data)
+{
+ ipa_ipv6ct_hw_entry* ipv6ct_entry = (ipa_ipv6ct_hw_entry*)entry;
+ const ipa_ipv6ct_rule* user_rule = (const ipa_ipv6ct_rule*)user_data;
+
+ IPADBG("\n");
+
+ ipv6ct_entry->src_ipv6_lsb = user_rule->src_ipv6_lsb;
+ ipv6ct_entry->src_ipv6_msb = user_rule->src_ipv6_msb;
+ ipv6ct_entry->dest_ipv6_lsb = user_rule->dest_ipv6_lsb;
+ ipv6ct_entry->dest_ipv6_msb = user_rule->dest_ipv6_msb;
+ ipv6ct_entry->protocol = user_rule->protocol;
+ ipv6ct_entry->src_port = user_rule->src_port;
+ ipv6ct_entry->dest_port = user_rule->dest_port;
+
+ switch (user_rule->direction_settings)
+ {
+ case IPA_IPV6CT_DIRECTION_DENY_ALL:
+ break;
+ case IPA_IPV6CT_DIRECTION_ALLOW_OUT:
+ ipv6ct_entry->out_allowed = IPA_IPV6CT_DIRECTION_ALLOW_BIT;
+ break;
+ case IPA_IPV6CT_DIRECTION_ALLOW_IN:
+ ipv6ct_entry->in_allowed = IPA_IPV6CT_DIRECTION_ALLOW_BIT;
+ break;
+ case IPA_IPV6CT_DIRECTION_ALLOW_ALL:
+ ipv6ct_entry->out_allowed = IPA_IPV6CT_DIRECTION_ALLOW_BIT;
+ ipv6ct_entry->in_allowed = IPA_IPV6CT_DIRECTION_ALLOW_BIT;
+ break;
+ default:
+ IPAERR("wrong value for IPv6CT direction setting parameter %d\n", user_rule->direction_settings);
+ return -EINVAL;
+ }
+
+ IPADBG("return\n");
+ return 0;
+}
+
+static int table_entry_head_insert(void* entry, void* user_data, uint16_t* dma_command_data)
+{
+ int ret;
+
+ IPADBG("\n");
+
+ ret = table_entry_copy_from_user(entry, user_data);
+ if (ret)
+ {
+ IPAERR("unable to copy from user a new entry\n");
+ return ret;
+ }
+
+ *dma_command_data = 0;
+ ((ipa_ipv6ct_flags*)dma_command_data)->enable = IPA_IPV6CT_FLAG_ENABLE_BIT;
+
+ IPADBG("return\n");
+ return 0;
+}
+
+static int table_entry_tail_insert(void* entry, void* user_data)
+{
+ int ret;
+
+ IPADBG("\n");
+
+ ret = table_entry_copy_from_user(entry, user_data);
+ if (ret)
+ {
+ IPAERR("unable to copy from user a new entry\n");
+ return ret;
+ }
+
+ ((ipa_ipv6ct_hw_entry*)entry)->enable = IPA_IPV6CT_FLAG_ENABLE_BIT;
+
+ IPADBG("return\n");
+ return 0;
+}
+
+static uint16_t table_entry_get_delete_head_dma_command_data(void* head, void* next_entry)
+{
+ IPADBG("\n");
+ return IPA_IPV6CT_INVALID_PROTO_FIELD_VALUE;
+}
+
+/**
+ * ipa_ipv6ct_create_table() - Creates a new IPv6CT table
+ * @ipv6ct_table: [in] IPv6CT table
+ * @number_of_entries: [in] number of IPv6CT entries
+ * @table_index: [in] the index of the IPv6CT table
+ *
+ * This function creates new IPv6CT table:
+ * - Initializes table, memory descriptor and table_dma_cmd_helpers structures
+ * - Allocates, maps and clears the memory for table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+static int ipa_ipv6ct_create_table(ipa_ipv6ct_table* ipv6ct_table, uint16_t number_of_entries, uint8_t table_index)
+{
+ int ret, size;
+
+ IPADBG("\n");
+
+ ipa_table_init(
+ &ipv6ct_table->table, IPA_IPV6CT_TABLE_NAME, IPA_NAT_MEM_IN_DDR,
+ sizeof(ipa_ipv6ct_hw_entry), NULL, 0, &entry_interface);
+
+ ret = ipa_table_calculate_entries_num(
+ &ipv6ct_table->table, number_of_entries, IPA_NAT_MEM_IN_DDR);
+
+ if (ret)
+ {
+ IPAERR("unable to calculate number of entries in ipv6ct table %d, while required by user %d\n",
+ table_index, number_of_entries);
+ return ret;
+ }
+
+ size = ipa_table_calculate_size(&ipv6ct_table->table);
+ IPADBG("IPv6CT table size: %d\n", size);
+
+ ipa_mem_descriptor_init(
+ &ipv6ct_table->mem_desc,
+ IPA_IPV6CT_DEV_NAME,
+ size,
+ table_index,
+ IPA_IOC_ALLOC_IPV6CT_TABLE,
+ IPA_IOC_DEL_IPV6CT_TABLE,
+ false); /* false here means don't consider using sram */
+
+ ret = ipa_mem_descriptor_allocate_memory(
+ &ipv6ct_table->mem_desc,
+ ipv6ct.ipa_desc->fd);
+
+ if (ret)
+ {
+ IPAERR("unable to allocate ipv6ct memory descriptor Error: %d\n", ret);
+ goto bail;
+ }
+
+ ipa_table_calculate_addresses(&ipv6ct_table->table, ipv6ct_table->mem_desc.base_addr);
+
+ ipa_table_reset(&ipv6ct_table->table);
+
+ ipa_ipv6ct_create_table_dma_cmd_helpers(ipv6ct_table, table_index);
+
+ IPADBG("return\n");
+ return 0;
+
+bail:
+ memset(ipv6ct_table, 0, sizeof(*ipv6ct_table));
+ return ret;
+}
+
+static int ipa_ipv6ct_destroy_table(ipa_ipv6ct_table* ipv6ct_table)
+{
+ int ret;
+
+ IPADBG("\n");
+
+ ret = ipa_mem_descriptor_delete(&ipv6ct_table->mem_desc, ipv6ct.ipa_desc->fd);
+ if (ret)
+ IPAERR("unable to delete IPV6CT descriptor\n");
+
+ memset(ipv6ct_table, 0, sizeof(*ipv6ct_table));
+
+ IPADBG("return\n");
+ return ret;
+}
+
+/**
+ * ipa_ipv6ct_create_table_dma_cmd_helpers() -
+ * Creates dma_cmd_helpers for base table in the received IPv6CT table
+ * @ipv6ct_table: [in] IPv6CT table
+ * @table_indx: [in] The index of the IPv6CT table
+ *
+ * A DMA command helper helps to generate the DMA command for one
+ * specific field change. Each table has 3 different types of field
+ * change: update_head, update_entry and delete_head. This function
+ * creates the helpers and updates the base table correspondingly.
+ */
+static void ipa_ipv6ct_create_table_dma_cmd_helpers(
+ ipa_ipv6ct_table* ipv6ct_table,
+ uint8_t table_indx )
+{
+ IPADBG("\n");
+
+ ipa_table_dma_cmd_helper_init(
+ &ipv6ct_table->table_dma_cmd_helpers[IPA_IPV6CT_TABLE_FLAGS],
+ table_indx,
+ IPA_IPV6CT_BASE_TBL,
+ IPA_IPV6CT_EXPN_TBL,
+ ipv6ct_table->mem_desc.addr_offset + IPA_IPV6CT_RULE_FLAG_FIELD_OFFSET);
+
+ ipa_table_dma_cmd_helper_init(
+ &ipv6ct_table->table_dma_cmd_helpers[IPA_IPV6CT_TABLE_NEXT_INDEX],
+ table_indx,
+ IPA_IPV6CT_BASE_TBL,
+ IPA_IPV6CT_EXPN_TBL,
+ ipv6ct_table->mem_desc.addr_offset + IPA_IPV6CT_RULE_NEXT_FIELD_OFFSET);
+
+ ipa_table_dma_cmd_helper_init(
+ &ipv6ct_table->table_dma_cmd_helpers[IPA_IPV6CT_TABLE_PROTOCOL],
+ table_indx,
+ IPA_IPV6CT_BASE_TBL,
+ IPA_IPV6CT_EXPN_TBL,
+ ipv6ct_table->mem_desc.addr_offset + IPA_IPV6CT_RULE_PROTO_FIELD_OFFSET);
+
+ ipv6ct_table->table.dma_help[HELP_UPDATE_HEAD] =
+ &ipv6ct_table->table_dma_cmd_helpers[IPA_IPV6CT_TABLE_FLAGS];
+ ipv6ct_table->table.dma_help[HELP_UPDATE_ENTRY] =
+ &ipv6ct_table->table_dma_cmd_helpers[IPA_IPV6CT_TABLE_NEXT_INDEX];
+ ipv6ct_table->table.dma_help[HELP_DELETE_HEAD] =
+ &ipv6ct_table->table_dma_cmd_helpers[IPA_IPV6CT_TABLE_PROTOCOL];
+
+ IPADBG("return\n");
+}
+
+static int ipa_ipv6ct_post_init_cmd(ipa_ipv6ct_table* ipv6ct_table, uint8_t tbl_index)
+{
+ struct ipa_ioc_ipv6ct_init cmd;
+ int ret;
+
+ IPADBG("\n");
+
+ cmd.tbl_index = tbl_index;
+
+ cmd.base_table_offset = ipv6ct_table->mem_desc.addr_offset;
+ cmd.expn_table_offset = cmd.base_table_offset + (ipv6ct_table->table.table_entries * sizeof(ipa_ipv6ct_hw_entry));
+
+ /* Driverr/HW expected base table size to be power^2-1 due to H/W hash calculation */
+ cmd.table_entries = ipv6ct_table->table.table_entries - 1;
+ cmd.expn_table_entries = ipv6ct_table->table.expn_table_entries;
+
+ ret = ioctl(ipv6ct.ipa_desc->fd, IPA_IOC_INIT_IPV6CT_TABLE, &cmd);
+ if (ret)
+ {
+ IPAERR("unable to post init cmd Error: %d IPA fd %d\n", ret, ipv6ct.ipa_desc->fd);
+ return ret;
+ }
+
+ IPADBG("Posted IPA_IOC_INIT_IPV6CT_TABLE to kernel successfully\n");
+ return 0;
+}
+
+static int ipa_ipv6ct_post_dma_cmd(struct ipa_ioc_nat_dma_cmd* cmd)
+{
+ IPADBG("\n");
+
+ cmd->mem_type = IPA_NAT_MEM_IN_DDR;
+
+ if (ioctl(ipv6ct.ipa_desc->fd, IPA_IOC_TABLE_DMA_CMD, cmd))
+ {
+ IPAERR("ioctl (IPA_IOC_TABLE_DMA_CMD) on fd %d has failed\n",
+ ipv6ct.ipa_desc->fd);
+ return -EIO;
+ }
+ IPADBG("posted IPA_IOC_TABLE_DMA_CMD to kernel successfully\n");
+ return 0;
+}
+
+void ipa_ipv6ct_dump_table(uint32_t table_handle)
+{
+ ipa_ipv6ct_table* ipv6ct_table;
+
+ if (ipv6ct.ipa_desc->ver < IPA_HW_v4_0)
+ {
+ IPAERR("IPv6 connection tracking isn't supported for IPA version %d\n", ipv6ct.ipa_desc->ver);
+ return;
+ }
+
+ if (table_handle == IPA_TABLE_INVALID_ENTRY || table_handle > IPA_IPV6CT_MAX_TBLS)
+ {
+ IPAERR("invalid parameters passed %d\n", table_handle);
+ return;
+ }
+
+ if (pthread_mutex_lock(&ipv6ct_mutex))
+ {
+ IPAERR("unable to lock the ipv6ct mutex\n");
+ return;
+ }
+
+ ipv6ct_table = &ipv6ct.tables[table_handle - 1];
+ if (!ipv6ct_table->mem_desc.valid)
+ {
+ IPAERR("invalid table handle %d\n", table_handle);
+ goto unlock;
+ }
+
+ /* Prevents interleaving with later kernel printouts. Flush doesn't help. */
+ sleep(1);
+ ipa_read_debug_info(IPA_IPV6CT_DEBUG_FILE_PATH);
+ sleep(1);
+
+unlock:
+ if (pthread_mutex_unlock(&ipv6ct_mutex))
+ IPAERR("unable to unlock the ipv6ct mutex\n");
+}
diff --git a/ipanat/src/ipa_mem_descriptor.c b/ipanat/src/ipa_mem_descriptor.c
new file mode 100644
index 0000000..172564d
--- /dev/null
+++ b/ipanat/src/ipa_mem_descriptor.c
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) 2018-2020 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 "ipa_mem_descriptor.h"
+#include "ipa_nat_utils.h"
+
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <unistd.h>
+
+#define IPA_DEV_DIR "/dev/"
+
+#ifdef IPA_ON_R3PC
+#define IPA_DEVICE_MMAP_MEM_SIZE (2 * 1024UL * 1024UL - 1)
+#endif
+
+static int AllocateMemory(
+ ipa_mem_descriptor* desc,
+ int ipa_fd)
+{
+ struct ipa_ioc_nat_ipv6ct_table_alloc cmd;
+ int ret = 0;
+
+ IPADBG("In\n");
+
+#ifndef IPA_ON_R3PC
+ /*
+ * If/when the number of NAT table entries requested yields a byte
+ * count that will fit in SRAM, SRAM will be used to hold the NAT
+ * table. When SRAM is used, some odd things can happen, relative
+ * to mmap'ing's virtual memory scheme, that require us to make
+ * some adjustments.
+ *
+ * To be more specific, the real physical SRAM location for the
+ * table and the table's size may not play well with Linux's
+ * mmap'ing virtual memory scheme....which likes everything to be
+ * PAGE_SIZE aligned and sized in multiples of PAGE_SIZE.
+ *
+ * Given the above, if the NAT table's (in SRAM) physical address
+ * in not on a PAGE_SIZE boundary, it will be offset into the
+ * mmap'd virtual memory, hence we need to know that offset in
+ * order to get to the table. If said offset plus the table's
+ * size takes it across a PAGE_SIZE boundary, we need to allocate
+ * more space to ensure that the table is completely within the
+ * mmap'd virtual memory.
+ */
+ desc->sram_available = desc->sram_to_be_used = false;
+
+ memset(&desc->nat_sram_info, 0, sizeof(desc->nat_sram_info));
+
+ ret = ioctl(
+ ipa_fd,
+ IPA_IOC_GET_NAT_IN_SRAM_INFO,
+ &desc->nat_sram_info);
+
+ if ( ret == 0 )
+ {
+ IPADBG("sram_mem_available_for_nat(0x%08x) "
+ "nat_table_offset_into_mmap(0x%08x) "
+ "best_nat_in_sram_size_rqst(0x%08x)\n",
+ desc->nat_sram_info.sram_mem_available_for_nat,
+ desc->nat_sram_info.nat_table_offset_into_mmap,
+ desc->nat_sram_info.best_nat_in_sram_size_rqst);
+
+ desc->sram_available = true;
+
+ if ( desc->consider_using_sram )
+ {
+ if (desc->orig_rqst_size <=
+ desc->nat_sram_info.sram_mem_available_for_nat)
+ {
+ desc->sram_to_be_used = true;
+ }
+ }
+ }
+#endif
+
+ /*
+ * Now do the actual allocation...
+ */
+ memset(&cmd, 0, sizeof(cmd));
+
+ cmd.size = desc->orig_rqst_size;
+
+ ret = ioctl(ipa_fd, desc->allocate_ioctl_num, &cmd);
+
+ if (ret)
+ {
+ IPAERR("Unable to post %s allocate table command. Error %d IPA fd %d\n",
+ desc->name, ret, ipa_fd);
+ goto bail;
+ }
+
+ desc->addr_offset = cmd.offset;
+
+ IPADBG("The memory desc for %s allocated successfully\n", desc->name);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static int MapMemory(
+ ipa_mem_descriptor* desc,
+ int ipa_fd)
+{
+ char device_full_path[IPA_RESOURCE_NAME_MAX];
+ size_t ipa_dev_dir_path_len;
+ int device_fd;
+ int ret = 0;
+
+ UNUSED(ipa_fd);
+
+ IPADBG("In\n");
+
+ ipa_dev_dir_path_len =
+ strlcpy(device_full_path, IPA_DEV_DIR, IPA_RESOURCE_NAME_MAX);
+
+ if (ipa_dev_dir_path_len >= IPA_RESOURCE_NAME_MAX)
+ {
+ IPAERR("Unable to copy a string with size %zu to buffer with size %d\n",
+ ipa_dev_dir_path_len, IPA_RESOURCE_NAME_MAX);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ strlcpy(device_full_path + ipa_dev_dir_path_len,
+ desc->name, IPA_RESOURCE_NAME_MAX - ipa_dev_dir_path_len);
+
+ device_fd = open(device_full_path, O_RDWR);
+
+ if (device_fd < 0)
+ {
+ IPAERR("unable to open the desc %s in path %s. Error:%d\n",
+ desc->name, device_full_path, device_fd);
+ ret = -EIO;
+ goto bail;
+ }
+
+#ifndef IPA_ON_R3PC
+ /*
+ * If/when the number of NAT table entries requested yields a byte
+ * count that will fit in SRAM, SRAM will be used to hold the NAT
+ * table. When SRAM is used, some odd things can happen, relative
+ * to mmap'ing's virtual memory scheme, that require us to make
+ * some adjustments.
+ *
+ * To be more specific, the real physical SRAM location for the
+ * table and the table's size may not play well with Linux's
+ * mmap'ing virtual memory scheme....which likes everything to be
+ * PAGE_SIZE aligned and sized in multiples of PAGE_SIZE.
+ *
+ * Given the above, if the NAT table's (in SRAM) physical address
+ * in not on a PAGE_SIZE boundary, it will be offset into the
+ * mmap'd virtual memory, hence we need to know that offset in
+ * order to get to the table. If said offset plus the table's
+ * size takes it across a PAGE_SIZE boundary, we need to allocate
+ * more space to ensure that the table is completely within the
+ * mmap'd virtual memory.
+ */
+ desc->mmap_size =
+ ( desc->sram_to_be_used ) ?
+ desc->nat_sram_info.best_nat_in_sram_size_rqst :
+ desc->orig_rqst_size;
+
+ desc->mmap_addr = desc->base_addr =
+ (void* )mmap(
+ NULL,
+ desc->mmap_size,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED,
+ device_fd,
+ 0);
+#else
+ IPADBG("user space r3pc\n");
+ desc->mmap_addr = desc->base_addr =
+ (void *) mmap(
+ (caddr_t)0,
+ IPA_DEVICE_MMAP_MEM_SIZE,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED,
+ device_fd,
+ 0);
+#endif
+
+ if (desc->base_addr == MAP_FAILED)
+ {
+ IPAERR("Unable to mmap the memory for %s\n", desc->name);
+ ret = -EINVAL;
+ goto close;
+ }
+
+ if ( desc->sram_to_be_used )
+ {
+ desc->base_addr =
+ (uint8_t*) (desc->base_addr) +
+ desc->nat_sram_info.nat_table_offset_into_mmap;
+ }
+
+ IPADBG("mmap for %s return value 0x%lx -> 0x%lx\n",
+ desc->name,
+ (long unsigned int) desc->mmap_addr,
+ (long unsigned int) desc->base_addr);
+
+close:
+ if (close(device_fd))
+ {
+ IPAERR("unable to close the file descriptor for %s\n", desc->name);
+ ret = -EINVAL;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static int DeallocateMemory(
+ ipa_mem_descriptor* desc,
+ int ipa_fd)
+{
+ struct ipa_ioc_nat_ipv6ct_table_del cmd;
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ memset(&cmd, 0, sizeof(cmd));
+
+ cmd.table_index = desc->table_index;
+
+ cmd.mem_type =
+ ( desc->sram_to_be_used ) ?
+ IPA_NAT_MEM_IN_SRAM :
+ IPA_NAT_MEM_IN_DDR;
+
+ ret = ioctl(ipa_fd, desc->delete_ioctl_num, &cmd);
+
+ if (ret)
+ {
+ IPAERR("unable to post table delete command for %s Error: %d IPA fd %d\n",
+ desc->name, ret, ipa_fd);
+ goto bail;
+ }
+
+ IPADBG("posted delete command for %s to kernel successfully\n", desc->name);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+void ipa_mem_descriptor_init(
+ ipa_mem_descriptor* desc,
+ const char* device_name,
+ int size,
+ uint8_t table_index,
+ unsigned long allocate_ioctl_num,
+ unsigned long delete_ioctl_num,
+ bool consider_using_sram )
+{
+ IPADBG("In\n");
+
+ strlcpy(desc->name, device_name, IPA_RESOURCE_NAME_MAX);
+
+ desc->orig_rqst_size = desc->mmap_size = size;
+ desc->table_index = table_index;
+ desc->allocate_ioctl_num = allocate_ioctl_num;
+ desc->delete_ioctl_num = delete_ioctl_num;
+ desc->consider_using_sram = consider_using_sram;
+
+ IPADBG("Out\n");
+}
+
+int ipa_mem_descriptor_allocate_memory(
+ ipa_mem_descriptor* desc,
+ int ipa_fd)
+{
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = AllocateMemory(desc, ipa_fd);
+
+ if (ret)
+ {
+ IPAERR("unable to allocate %s\n", desc->name);
+ goto bail;
+ }
+
+ ret = MapMemory(desc, ipa_fd);
+
+ if (ret)
+ {
+ IPAERR("unable to map %s\n", desc->name);
+ DeallocateMemory(desc, ipa_fd);
+ goto bail;
+ }
+
+ desc->valid = TRUE;
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_mem_descriptor_delete(
+ ipa_mem_descriptor* desc,
+ int ipa_fd)
+{
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if (! desc->valid)
+ {
+ IPAERR("invalid desc handle passed\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ desc->valid = FALSE;
+
+#ifndef IPA_ON_R3PC
+ munmap(desc->mmap_addr, desc->mmap_size);
+#else
+ munmap(desc->mmap_addr, IPA_DEVICE_MMAP_MEM_SIZE);
+#endif
+
+ ret = DeallocateMemory(desc, ipa_fd);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
diff --git a/ipanat/src/ipa_nat_drv.c b/ipanat/src/ipa_nat_drv.c
index d01a6c9..0fbf473 100644
--- a/ipanat/src/ipa_nat_drv.c
+++ b/ipanat/src/ipa_nat_drv.c
@@ -1,38 +1,41 @@
/*
-Copyright (c) 2013 - 2017, 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.
-*/
+ * Copyright (c) 2013-2020 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 "ipa_nat_drv.h"
#include "ipa_nat_drvi.h"
+#include <errno.h>
+
/**
* ipa_nat_add_ipv4_tbl() - create ipv4 nat table
* @public_ip_addr: [in] public ipv4 address
+ * @mem_type_ptr: [in] type of memory table is to reside in
* @number_of_entries: [in] number of nat entries
* @table_handle: [out] Handle of new ipv4 nat table
*
@@ -40,27 +43,36 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_add_ipv4_tbl(uint32_t public_ip_addr,
- uint16_t number_of_entries,
- uint32_t *tbl_hdl)
+int ipa_nat_add_ipv4_tbl(
+ uint32_t public_ip_addr,
+ const char *mem_type_ptr,
+ uint16_t number_of_entries,
+ uint32_t *tbl_hdl)
{
- int ret;
+ int ret;
- if (NULL == tbl_hdl || 0 == number_of_entries) {
- IPAERR("Invalid parameters \n");
- return -EINVAL;
- }
+ if (tbl_hdl == NULL || mem_type_ptr == NULL || number_of_entries == 0) {
+ IPAERR(
+ "Invalid parameters tbl_hdl=%pK mem_type_ptr=%p number_of_entries=%d\n",
+ tbl_hdl,
+ mem_type_ptr,
+ number_of_entries);
+ return -EINVAL;
+ }
- ret = ipa_nati_add_ipv4_tbl(public_ip_addr,
- number_of_entries,
- tbl_hdl);
- if (ret != 0) {
- IPAERR("unable to add table \n");
- return -EINVAL;
- }
- IPADBG("Returning table handle 0x%x\n", *tbl_hdl);
+ *tbl_hdl = 0;
- return ret;
+ ret = ipa_nati_add_ipv4_tbl(
+ public_ip_addr, mem_type_ptr, number_of_entries, tbl_hdl);
+
+ if (ret) {
+ IPAERR("unable to add NAT table\n");
+ return ret;
+ }
+
+ IPADBG("Returning table handle 0x%x\n", *tbl_hdl);
+
+ return ret;
} /* __ipa_nat_add_ipv4_tbl() */
/**
@@ -71,16 +83,17 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_del_ipv4_tbl(uint32_t tbl_hdl)
+int ipa_nat_del_ipv4_tbl(
+ uint32_t tbl_hdl)
{
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
- IPAERR("invalid table handle passed \n");
- return -EINVAL;
- }
- IPADBG("Passed Table Handle: 0x%x\n", tbl_hdl);
+ if ( ! VALID_TBL_HDL(tbl_hdl) ) {
+ IPAERR("Invalid table handle passed 0x%08X\n", tbl_hdl);
+ return -EINVAL;
+ }
- return ipa_nati_del_ipv4_table(tbl_hdl);
+ IPADBG("Passed Table Handle: 0x%08X\n", tbl_hdl);
+
+ return ipa_nati_del_ipv4_table(tbl_hdl);
}
/**
@@ -93,28 +106,32 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_add_ipv4_rule(uint32_t tbl_hdl,
- const ipa_nat_ipv4_rule *clnt_rule,
- uint32_t *rule_hdl)
+int ipa_nat_add_ipv4_rule(
+ uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule *clnt_rule,
+ uint32_t *rule_hdl)
{
- int result = -EINVAL;
+ int result = -EINVAL;
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS || NULL == rule_hdl ||
- NULL == clnt_rule) {
- IPAERR("invalide table handle passed \n");
- return result;
- }
- IPADBG("Passed Table handle: 0x%x\n", tbl_hdl);
-
- if (ipa_nati_add_ipv4_rule(tbl_hdl, clnt_rule, rule_hdl) != 0) {
+ if ( ! VALID_TBL_HDL(tbl_hdl) ||
+ rule_hdl == NULL ||
+ clnt_rule == NULL ) {
+ IPAERR(
+ "Invalid parameters tbl_hdl=%d clnt_rule=%pK rule_hdl=%pK\n",
+ tbl_hdl, clnt_rule, rule_hdl);
return result;
}
- IPADBG("returning rule handle 0x%x\n", *rule_hdl);
- return 0;
-}
+ IPADBG("Passed Table handle: 0x%x\n", tbl_hdl);
+ if (ipa_nati_add_ipv4_rule(tbl_hdl, clnt_rule, rule_hdl)) {
+ return result;
+ }
+
+ IPADBG("Returning rule handle %u\n", *rule_hdl);
+
+ return 0;
+}
/**
* ipa_nat_del_ipv4_rule() - to delete ipv4 nat rule
@@ -125,25 +142,31 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_del_ipv4_rule(uint32_t tbl_hdl,
- uint32_t rule_hdl)
+int ipa_nat_del_ipv4_rule(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl)
{
- int result = -EINVAL;
+ int result = -EINVAL;
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- IPA_NAT_INVALID_NAT_ENTRY == rule_hdl) {
- IPAERR("invalide parameters\n");
- return result;
- }
- IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
+ if ( ! VALID_TBL_HDL(tbl_hdl) || ! VALID_RULE_HDL(rule_hdl) )
+ {
+ IPAERR("Invalid parameters tbl_hdl=0x%08X rule_hdl=0x%08X\n",
+ tbl_hdl, rule_hdl);
+ return result;
+ }
- result = ipa_nati_del_ipv4_rule(tbl_hdl, rule_hdl);
- if (result) {
- IPAERR("unable to delete rule from hw \n");
- return result;
- }
+ IPADBG("Passed Table: 0x%08X and rule handle 0x%08X\n", tbl_hdl, rule_hdl);
- return 0;
+ result = ipa_nati_del_ipv4_rule(tbl_hdl, rule_hdl);
+ if (result) {
+ IPAERR(
+ "Unable to delete rule with handle 0x%08X "
+ "from hw for NAT table with handle 0x%08X\n",
+ rule_hdl, tbl_hdl);
+ return result;
+ }
+
+ return 0;
}
/**
@@ -157,22 +180,25 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_query_timestamp(uint32_t tbl_hdl,
- uint32_t rule_hdl,
- uint32_t *time_stamp)
+int ipa_nat_query_timestamp(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t *time_stamp)
{
+ if ( ! VALID_TBL_HDL(tbl_hdl) ||
+ ! VALID_RULE_HDL(rule_hdl) ||
+ time_stamp == NULL )
+ {
+ IPAERR("Invalid parameters passed tbl_hdl=0x%x rule_hdl=%u time_stamp=%pK\n",
+ tbl_hdl, rule_hdl, time_stamp);
+ return -EINVAL;
+ }
- if (0 == tbl_hdl || tbl_hdl > IPA_NAT_MAX_IP4_TBLS ||
- NULL == time_stamp) {
- IPAERR("invalid parameters passed \n");
- return -EINVAL;
- }
- IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
+ IPADBG("Passed Table 0x%x and rule handle %u\n", tbl_hdl, rule_hdl);
- return ipa_nati_query_timestamp(tbl_hdl, rule_hdl, time_stamp);
+ return ipa_nati_query_timestamp(tbl_hdl, rule_hdl, time_stamp);
}
-
/**
* ipa_nat_modify_pdn() - modify single PDN entry in the PDN config table
* @table_handle: [in] handle of ipv4 nat table
@@ -183,24 +209,25 @@
*
* Returns: 0 On Success, negative on failure
*/
-int ipa_nat_modify_pdn(uint32_t tbl_hdl,
+int ipa_nat_modify_pdn(
+ uint32_t tbl_hdl,
uint8_t pdn_index,
ipa_nat_pdn_entry *pdn_info)
{
struct ipa_ioc_nat_pdn_entry pdn_data;
- if (0 == tbl_hdl || tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
- IPAERR("invalid parameters passed \n");
- return -EINVAL;
- }
-
- if (!pdn_info) {
- IPAERR("pdn_info is NULL \n");
+ if ( ! VALID_TBL_HDL(tbl_hdl) ||
+ pdn_info == NULL) {
+ IPAERR(
+ "invalid parameters passed tbl_hdl=%d pdn_info=%pK\n",
+ tbl_hdl, pdn_info);
return -EINVAL;
}
if (pdn_index > IPA_MAX_PDN_NUM) {
- IPAERR("PDN index is out of range %d", pdn_index);
+ IPAERR(
+ "PDN index %d is out of range maximum %d",
+ pdn_index, IPA_MAX_PDN_NUM);
return -EINVAL;
}
@@ -212,4 +239,110 @@
return ipa_nati_modify_pdn(&pdn_data);
}
+/**
+* ipa_nat_get_pdn_index() - get a PDN index for a public ip
+* @public_ip : [in] IPv4 address of the PDN entry
+* @pdn_index : [out] the index of the requested PDN entry
+*
+* Get a PDN entry
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_get_pdn_index(
+ uint32_t public_ip,
+ uint8_t *pdn_index)
+{
+ if(!pdn_index)
+ {
+ IPAERR("NULL PDN index\n");
+ return -EINVAL;
+ }
+ return ipa_nati_get_pdn_index(public_ip, pdn_index);
+}
+
+/**
+* ipa_nat_alloc_pdn() - allocate a PDN for new WAN
+* @pdn_info : [in] values for the PDN entry to be created
+* @pdn_index : [out] the index of the requested PDN entry
+*
+* allocate a new PDN entry
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_alloc_pdn(
+ ipa_nat_pdn_entry *pdn_info,
+ uint8_t *pdn_index)
+{
+ if(!pdn_info)
+ {
+ IPAERR("NULL PDN info\n");
+ return -EINVAL;
+ }
+
+ if(!pdn_index)
+ {
+ IPAERR("NULL PDN index\n");
+ return -EINVAL;
+ }
+
+ return ipa_nati_alloc_pdn(pdn_info, pdn_index);
+}
+
+/**
+* ipa_nat_get_pdn_count() - get the number of allocated PDNs
+* @pdn_cnt : [out] the number of allocated PDNs
+*
+* get the number of allocated PDNs
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_get_pdn_count(
+ uint8_t *pdn_cnt)
+{
+ if(!pdn_cnt)
+ {
+ IPAERR("NULL PDN count\n");
+ return -EINVAL;
+ }
+
+ *pdn_cnt = ipa_nati_get_pdn_cnt();
+
+ return 0;
+}
+
+/**
+* ipa_nat_dealloc_pdn() - deallocate a PDN entry
+* @pdn_index : [in] pdn index to be deallocated
+*
+* deallocate a PDN in specified index - zero the PDN entry
+*
+* Returns: 0 On Success, negative on failure
+*/
+int ipa_nat_dealloc_pdn(
+ uint8_t pdn_index)
+{
+ if(pdn_index > IPA_MAX_PDN_NUM) {
+ IPAERR("PDN index is out of range %d", pdn_index);
+ return -EINVAL;
+ }
+
+ return ipa_nati_dealloc_pdn(pdn_index);
+}
+
+/**
+ * ipa_nat_vote_clock() - used for voting clock
+ * @vote_type: [in] desired vote type
+ */
+int ipa_nat_vote_clock(
+ enum ipa_app_clock_vote_type vote_type )
+{
+ if ( ! (vote_type >= IPA_APP_CLK_DEVOTE &&
+ vote_type <= IPA_APP_CLK_RESET_VOTE) )
+ {
+ IPAERR("Bad vote_type(%u) parameter\n", vote_type);
+ return -EINVAL;
+ }
+
+ return ipa_nati_vote_clock(vote_type);
+}
diff --git a/ipanat/src/ipa_nat_drvi.c b/ipanat/src/ipa_nat_drvi.c
index 43ceaf5..b8d64f6 100644
--- a/ipanat/src/ipa_nat_drvi.c
+++ b/ipanat/src/ipa_nat_drvi.c
@@ -1,377 +1,164 @@
/*
-Copyright (c) 2013 - 2019, 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.
-*/
+ * Copyright (c) 2013-2020 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 "ipa_nat_drv.h"
#include "ipa_nat_drvi.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include <pthread.h>
+#include <unistd.h>
#include <linux/msm_ipa.h>
-#ifdef USE_GLIB
-#include <glib.h>
-#define strlcpy g_strlcpy
-#else
-#ifndef FEATURE_IPA_ANDROID
-static size_t strlcpy(char * dst, const char * src, size_t size)
-{
- size_t i;
+#define MAX_DMA_ENTRIES_FOR_ADD 4
+#define MAX_DMA_ENTRIES_FOR_DEL 3
- if (size < 1)
- return 0;
- for (i = 0; i < (size - 1) && src[i] != '\0'; i++)
- dst[i] = src[i];
- for (; i < size; i++)
- dst[i] = '\0';
- return strlen(dst);
-}
-#endif
-#endif
+#define IPA_NAT_DEBUG_FILE_PATH "/sys/kernel/debug/ipa/ip4_nat"
+#define IPA_NAT_TABLE_NAME "IPA NAT table"
+#define IPA_NAT_INDEX_TABLE_NAME "IPA NAT index table"
-struct ipa_nat_cache ipv4_nat_cache;
-pthread_mutex_t nat_mutex = PTHREAD_MUTEX_INITIALIZER;
+#undef min
+#define min(a, b) ((a) < (b)) ? (a) : (b)
+
+#undef max
+#define max(a, b) ((a) > (b)) ? (a) : (b)
+
+static struct ipa_nat_cache ipv4_nat_cache[IPA_NAT_MEM_IN_MAX];
+
+static struct ipa_nat_cache *active_nat_cache_ptr = NULL;
+
+#undef DDR_IS_ACTIVE
+#define DDR_IS_ACTIVE() \
+ (active_nat_cache_ptr) ? \
+ (active_nat_cache_ptr->nmi == IPA_NAT_MEM_IN_DDR) : \
+ false
+
+#undef SRAM_IS_ACTIVE
+#define SRAM_IS_ACTIVE() \
+ (active_nat_cache_ptr) ? \
+ (active_nat_cache_ptr->nmi == IPA_NAT_MEM_IN_SRAM) : \
+ false
+
+extern pthread_mutex_t nat_mutex;
static ipa_nat_pdn_entry pdns[IPA_MAX_PDN_NUM];
+static int num_pdns = 0;
-/* ------------------------------------------
- UTILITY FUNCTIONS START
- --------------------------------------------*/
-
-/**
- * UpdateSwSpecParams() - updates sw specific params
- * @rule: [in/out] nat table rule
- * @param_type: [in] which param need to update
- * @value: [in] value of param
- *
- * Update SW specific params in the passed rule.
- *
- * Returns: None
+/*
+ * ----------------------------------------------------------------------------
+ * Private helpers for manipulating regular tables
+ * ----------------------------------------------------------------------------
*/
-void UpdateSwSpecParams(struct ipa_nat_rule *rule,
- uint8_t param_type,
- uint32_t value)
+static int table_entry_is_valid(
+ void* entry)
{
- uint32_t temp = rule->sw_spec_params;
+ struct ipa_nat_rule* rule = (struct ipa_nat_rule*) entry;
- if (IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE == param_type) {
- value = (value << INDX_TBL_ENTRY_SIZE_IN_BITS);
- temp &= 0x0000FFFF;
- } else {
- temp &= 0xFFFF0000;
- }
+ IPADBG("In\n");
- temp = (temp | value);
- rule->sw_spec_params = temp;
- return;
+ IPADBG("enable(%u)\n", rule->enable);
+
+ IPADBG("Out\n");
+
+ return rule->enable;
+}
+
+static uint16_t table_entry_get_next_index(
+ void* entry)
+{
+ uint16_t result;
+ struct ipa_nat_rule* rule = (struct ipa_nat_rule*)entry;
+
+ IPADBG("In\n");
+
+ result = rule->next_index;
+
+ IPADBG("Next entry of %pK is %u\n", entry, result);
+
+ IPADBG("Out\n");
+
+ return result;
+}
+
+static uint16_t table_entry_get_prev_index(
+ void* entry,
+ uint16_t entry_index,
+ void* meta,
+ uint16_t base_table_size)
+{
+ uint16_t result;
+ struct ipa_nat_rule* rule = (struct ipa_nat_rule*)entry;
+
+ UNUSED(entry_index);
+ UNUSED(meta);
+ UNUSED(base_table_size);
+
+ IPADBG("In\n");
+
+ result = rule->prev_index;
+
+ IPADBG("Previous entry of %u is %u\n", entry_index, result);
+
+ IPADBG("Out\n");
+
+ return result;
+}
+
+static void table_entry_set_prev_index(
+ void* entry,
+ uint16_t entry_index,
+ uint16_t prev_index,
+ void* meta,
+ uint16_t base_table_size)
+{
+ struct ipa_nat_rule* rule = (struct ipa_nat_rule*) entry;
+
+ UNUSED(entry_index);
+ UNUSED(meta);
+ UNUSED(base_table_size);
+
+ IPADBG("In\n");
+
+ IPADBG("Previous entry of %u is %u\n", entry_index, prev_index);
+
+ rule->prev_index = prev_index;
+
+ IPADBG("Out\n");
}
/**
- * Read8BitFieldValue()
- * @rule: [in/out]
- * @param_type: [in]
- * @value: [in]
- *
- *
- *
- * Returns: None
- */
-
-uint8_t Read8BitFieldValue(uint32_t param,
- ipa_nat_rule_field_type fld_type)
-{
- void *temp = (void *)¶m;
-
- switch (fld_type) {
-
- case PROTOCOL_FIELD:
- return ((time_stamp_proto *)temp)->protocol;
-
- default:
- IPAERR("Invalid Field type passed\n");
- return 0;
- }
-}
-
-uint16_t Read16BitFieldValue(uint32_t param,
- ipa_nat_rule_field_type fld_type)
-{
- void *temp = (void *)¶m;
-
- switch (fld_type) {
-
- case NEXT_INDEX_FIELD:
- return ((next_index_pub_port *)temp)->next_index;
-
- case PUBLIC_PORT_FILED:
- return ((next_index_pub_port *)temp)->public_port;
-
- case ENABLE_FIELD:
- return ((ipcksum_enbl *)temp)->enable;
-
- case SW_SPEC_PARAM_PREV_INDEX_FIELD:
- return ((sw_spec_params *)temp)->prev_index;
-
- case SW_SPEC_PARAM_INDX_TBL_ENTRY_FIELD:
- return ((sw_spec_params *)temp)->index_table_entry;
-
- case INDX_TBL_TBL_ENTRY_FIELD:
- return ((tbl_ent_nxt_indx *)temp)->tbl_entry;
-
- case INDX_TBL_NEXT_INDEX_FILED:
- return ((tbl_ent_nxt_indx *)temp)->next_index;
-
-#ifdef NAT_DUMP
- case IP_CHKSUM_FIELD:
- return ((ipcksum_enbl *)temp)->ip_chksum;
-#endif
-
- default:
- IPAERR("Invalid Field type passed\n");
- return 0;
- }
-}
-
-uint32_t Read32BitFieldValue(uint32_t param,
- ipa_nat_rule_field_type fld_type)
-{
-
- void *temp = (void *)¶m;
-
- switch (fld_type) {
-
- case TIME_STAMP_FIELD:
- return ((time_stamp_proto *)temp)->time_stamp;
-
- default:
- IPAERR("Invalid Field type passed\n");
- return 0;
- }
-}
-
-/**
-* GetIPAVer(void) - store IPA HW ver in cache
-*
-*
-* Returns: 0 on success, negative on failure
-*/
-int GetIPAVer(void)
-{
- int ret;
-
- ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_GET_HW_VERSION, &ipv4_nat_cache.ver);
- if (ret != 0) {
- perror("GetIPAVer(): ioctl error value");
- IPAERR("unable to get IPA version. Error ;%d\n", ret);
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- return -EINVAL;
- }
- IPADBG("IPA version is %d\n", ipv4_nat_cache.ver);
- return 0;
-}
-
-/**
- * CreateNatDevice() - Create nat devices
- * @mem: [in] name of device that need to create
- *
- * Create Nat device and Register for file create
- * notification in given directory and wait till
- * receive notification
- *
- * Returns: 0 on success, negative on failure
- */
-int CreateNatDevice(struct ipa_ioc_nat_alloc_mem *mem)
-{
- int ret;
-
- ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_ALLOC_NAT_MEM, mem);
- if (ret != 0) {
- perror("CreateNatDevice(): ioctl error value");
- IPAERR("unable to post nat mem init. Error ;%d\n", ret);
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- return -EINVAL;
- }
- IPADBG("posted IPA_IOC_ALLOC_NAT_MEM to kernel successfully\n");
- return 0;
-}
-
-/**
- * GetNearest2Power() - Returns the nearest power of 2
- * @num: [in] given number
- * @ret: [out] nearest power of 2
- *
- * Returns the nearest power of 2 for a
- * given number
- *
- * Returns: 0 on success, negative on failure
- */
-int GetNearest2Power(uint16_t num, uint16_t *ret)
-{
- uint16_t number = num;
- uint16_t tmp = 1;
- *ret = 0;
-
- if (0 == num) {
- return -EINVAL;
- }
-
- if (1 == num) {
- *ret = 2;
- return 0;
- }
-
- for (;;) {
- if (1 == num) {
- if (number != tmp) {
- tmp *= 2;
- }
-
- *ret = tmp;
- return 0;
- }
-
- num >>= 1;
- tmp *= 2;
- }
-
- return -EINVAL;
-}
-
-/**
- * GetNearestEven() - Returns the nearest even number
- * @num: [in] given number
- * @ret: [out] nearest even number
- *
- * Returns the nearest even number for a given number
- *
- * Returns: 0 on success, negative on failure
- */
-void GetNearestEven(uint16_t num, uint16_t *ret)
-{
-
- if (num < 2) {
- *ret = 2;
- return;
- }
-
- while ((num % 2) != 0) {
- num = num + 1;
- }
-
- *ret = num;
- return;
-}
-
-/**
- * dst_hash() - Find the index into ipv4 base table
- * @public_ip: [in] public_ip
- * @trgt_ip: [in] Target IP address
- * @trgt_port: [in] Target port
- * @public_port: [in] Public port
- * @proto: [in] Protocol (TCP/IP)
- * @size: [in] size of the ipv4 base Table
- *
- * This hash method is used to find the hash index of new nat
- * entry into ipv4 base table. In case of zero index, the
- * new entry will be stored into N-1 index where N is size of
- * ipv4 base table
- *
- * Returns: >0 index into ipv4 base table, negative on failure
- */
-static uint16_t dst_hash(uint32_t public_ip, uint32_t trgt_ip,
- uint16_t trgt_port, uint16_t public_port,
- uint8_t proto, uint16_t size)
-{
- uint16_t hash = ((uint16_t)(trgt_ip)) ^ ((uint16_t)(trgt_ip >> 16)) ^
- (trgt_port) ^ (public_port) ^ (proto);
-
- if (ipv4_nat_cache.ver >= IPA_HW_v4_0)
- hash ^= ((uint16_t)(public_ip)) ^
- ((uint16_t)(public_ip >> 16));
-
- IPADBG("public ip 0x%X\n", public_ip);
- IPADBG("trgt_ip: 0x%x trgt_port: 0x%x\n", trgt_ip, trgt_port);
- IPADBG("public_port: 0x%x\n", public_port);
- IPADBG("proto: 0x%x size: 0x%x\n", proto, size);
-
- hash = (hash & size);
-
- /* If the hash resulted to zero then set it to maximum value
- as zero is unused entry in nat tables */
- if (0 == hash) {
- return size;
- }
-
- IPADBG("dst_hash returning value: %d\n", hash);
- return hash;
-}
-
-/**
- * src_hash() - Find the index into ipv4 index base table
- * @priv_ip: [in] Private IP address
- * @priv_port: [in] Private port
- * @trgt_ip: [in] Target IP address
- * @trgt_port: [in] Target Port
- * @proto: [in] Protocol (TCP/IP)
- * @size: [in] size of the ipv4 index base Table
- *
- * This hash method is used to find the hash index of new nat
- * entry into ipv4 index base table. In case of zero index, the
- * new entry will be stored into N-1 index where N is size of
- * ipv4 index base table
- *
- * Returns: >0 index into ipv4 index base table, negative on failure
- */
-static uint16_t src_hash(uint32_t priv_ip, uint16_t priv_port,
- uint32_t trgt_ip, uint16_t trgt_port,
- uint8_t proto, uint16_t size)
-{
- uint16_t hash = ((uint16_t)(priv_ip)) ^ ((uint16_t)(priv_ip >> 16)) ^
- (priv_port) ^
- ((uint16_t)(trgt_ip)) ^ ((uint16_t)(trgt_ip >> 16)) ^
- (trgt_port) ^ (proto);
-
- IPADBG("priv_ip: 0x%x priv_port: 0x%x\n", priv_ip, priv_port);
- IPADBG("trgt_ip: 0x%x trgt_port: 0x%x\n", trgt_ip, trgt_port);
- IPADBG("proto: 0x%x size: 0x%x\n", proto, size);
-
- hash = (hash & size);
-
- /* If the hash resulted to zero then set it to maximum value
- as zero is unused entry in nat tables */
- if (0 == hash) {
- return size;
- }
-
- IPADBG("src_hash returning value: %d\n", hash);
- return hash;
-}
-
-/**
- * ipa_nati_calc_ip_cksum() - Calculate the source nat
- * IP checksum diff
+ * ipa_nati_calc_ip_cksum() - Calculate the source nat IP checksum diff
* @pub_ip_addr: [in] public ip address
* @priv_ip_addr: [in] Private ip address
*
@@ -383,12 +170,15 @@
*
* Returns: >0 ip checksum diff
*/
-static uint16_t ipa_nati_calc_ip_cksum(uint32_t pub_ip_addr,
- uint32_t priv_ip_addr)
+static uint16_t ipa_nati_calc_ip_cksum(
+ uint32_t pub_ip_addr,
+ uint32_t priv_ip_addr)
{
uint16_t ret;
uint32_t cksum = 0;
+ IPADBG("In\n");
+
/* Add LSB(2 bytes) of public ip address to cksum */
cksum += (pub_ip_addr & 0xFFFF);
@@ -424,12 +214,14 @@
/* Return the LSB(2 bytes) of checksum */
ret = (uint16_t)cksum;
+
+ IPADBG("Out\n");
+
return ret;
}
/**
- * ipa_nati_calc_tcp_udp_cksum() - Calculate the source nat
- * TCP/UDP checksum diff
+ * ipa_nati_calc_tcp_udp_cksum() - Calculate the source nat TCP/UDP checksum diff
* @pub_ip_addr: [in] public ip address
* @pub_port: [in] public tcp/udp port
* @priv_ip_addr: [in] Private ip address
@@ -443,14 +235,17 @@
*
* Returns: >0 tcp/udp checksum diff
*/
-static uint16_t ipa_nati_calc_tcp_udp_cksum(uint32_t pub_ip_addr,
- uint16_t pub_port,
- uint32_t priv_ip_addr,
- uint16_t priv_port)
+static uint16_t ipa_nati_calc_tcp_udp_cksum(
+ uint32_t pub_ip_addr,
+ uint16_t pub_port,
+ uint32_t priv_ip_addr,
+ uint16_t priv_port)
{
uint16_t ret = 0;
uint32_t cksum = 0;
+ IPADBG("In\n");
+
/* Add LSB(2 bytes) of public ip address to cksum */
cksum += (pub_ip_addr & 0xFFFF);
@@ -505,1953 +300,2390 @@
/* return the LSB(2 bytes) of checksum */
ret = (uint16_t)cksum;
+
+ IPADBG("Out\n");
+
return ret;
}
-/**
- * ipa_nati_make_rule_hdl() - makes nat rule handle
- * @tbl_hdl: [in] nat table handle
- * @tbl_entry: [in] nat table entry
- *
- * Calculate the nat rule handle which from
- * nat entry which will be returned to client of
- * nat driver
- *
- * Returns: >0 nat rule handle
- */
-uint16_t ipa_nati_make_rule_hdl(uint16_t tbl_hdl,
- uint16_t tbl_entry)
+static int table_entry_copy_from_user(
+ void* entry,
+ void* user_data)
{
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- uint16_t rule_hdl = 0;
- uint16_t cnt = 0;
+ uint32_t pub_ip_addr;
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
+ struct ipa_nat_rule* nat_entry = (struct ipa_nat_rule*) entry;
+ const ipa_nat_ipv4_rule* user_rule = (const ipa_nat_ipv4_rule*) user_data;
- if (tbl_entry >= tbl_ptr->table_entries) {
- /* Increase the current expansion table count */
- tbl_ptr->cur_expn_tbl_cnt++;
+ IPADBG("In\n");
- /* Update the index into table */
- rule_hdl = tbl_entry - tbl_ptr->table_entries;
- rule_hdl = (rule_hdl << IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
- /* Update the table type mask */
- rule_hdl = (rule_hdl | IPA_NAT_RULE_HDL_TBL_TYPE_MASK);
- } else {
- /* Increase the current count */
- tbl_ptr->cur_tbl_cnt++;
+ pub_ip_addr = pdns[user_rule->pdn_index].public_ip;
- rule_hdl = tbl_entry;
- rule_hdl = (rule_hdl << IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
+ nat_entry->private_ip = user_rule->private_ip;
+ nat_entry->private_port = user_rule->private_port;
+ nat_entry->protocol = user_rule->protocol;
+ nat_entry->public_port = user_rule->public_port;
+ nat_entry->target_ip = user_rule->target_ip;
+ nat_entry->target_port = user_rule->target_port;
+ nat_entry->pdn_index = user_rule->pdn_index;
+
+ nat_entry->ip_chksum =
+ ipa_nati_calc_ip_cksum(pub_ip_addr, user_rule->private_ip);
+
+ if (IPPROTO_TCP == nat_entry->protocol ||
+ IPPROTO_UDP == nat_entry->protocol) {
+ nat_entry->tcp_udp_chksum = ipa_nati_calc_tcp_udp_cksum(
+ pub_ip_addr,
+ user_rule->public_port,
+ user_rule->private_ip,
+ user_rule->private_port);
}
- for (; cnt < (tbl_ptr->table_entries + tbl_ptr->expn_table_entries); cnt++) {
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_ptr->rule_id_array[cnt]) {
- tbl_ptr->rule_id_array[cnt] = rule_hdl;
- return cnt + 1;
- }
- }
+ IPADBG("Out\n");
return 0;
}
-/**
- * ipa_nati_parse_ipv4_rule_hdl() - prase rule handle
- * @tbl_hdl: [in] nat table rule
- * @rule_hdl: [in] nat rule handle
- * @expn_tbl: [out] expansion table or not
- * @tbl_entry: [out] index into table
- *
- * Parse the rule handle to retrieve the nat table
- * type and entry of nat table
- *
- * Returns: None
+static int table_entry_head_insert(
+ void* entry,
+ void* user_data,
+ uint16_t* dma_command_data)
+{
+ int ret;
+
+ IPADBG("In\n");
+
+ IPADBG("entry(%p) user_data(%p) dma_command_data(%p)\n",
+ entry,
+ user_data,
+ dma_command_data);
+
+ ret = table_entry_copy_from_user(entry, user_data);
+
+ if (ret) {
+ IPAERR("unable to copy from user a new entry\n");
+ goto bail;
+ }
+
+ *dma_command_data = 0;
+
+ ((ipa_nat_flags*)dma_command_data)->enable = IPA_NAT_FLAG_ENABLE_BIT;
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static int table_entry_tail_insert(
+ void* entry,
+ void* user_data)
+{
+ struct ipa_nat_rule* nat_entry = (struct ipa_nat_rule*) entry;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ IPADBG("entry(%p) user_data(%p)\n",
+ entry,
+ user_data);
+
+ ret = table_entry_copy_from_user(entry, user_data);
+
+ if (ret) {
+ IPAERR("unable to copy from user a new entry\n");
+ goto bail;
+ }
+
+ nat_entry->enable = IPA_NAT_FLAG_ENABLE_BIT;
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static uint16_t table_entry_get_delete_head_dma_command_data(
+ void* head,
+ void* next_entry)
+{
+ UNUSED(head);
+ UNUSED(next_entry);
+
+ IPADBG("In\n");
+
+ IPADBG("Out\n");
+
+ return IPA_NAT_INVALID_PROTO_FIELD_VALUE;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * Private helpers for manipulating index tables
+ * ----------------------------------------------------------------------------
*/
-void ipa_nati_parse_ipv4_rule_hdl(uint8_t tbl_index,
- uint16_t rule_hdl, uint8_t *expn_tbl,
- uint16_t *tbl_entry)
+static int index_table_entry_is_valid(
+ void* entry)
{
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- uint16_t rule_id;
+ struct ipa_nat_indx_tbl_rule* rule =
+ (struct ipa_nat_indx_tbl_rule*) entry;
- *expn_tbl = 0;
- *tbl_entry = IPA_NAT_INVALID_NAT_ENTRY;
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_index];
-
- if (rule_hdl >= (tbl_ptr->table_entries + tbl_ptr->expn_table_entries)) {
- IPAERR("invalid rule handle\n");
- return;
- }
-
- rule_id = tbl_ptr->rule_id_array[rule_hdl-1];
-
- /* Retrieve the table type */
- *expn_tbl = 0;
- if (rule_id & IPA_NAT_RULE_HDL_TBL_TYPE_MASK) {
- *expn_tbl = 1;
- }
-
- /* Retrieve the table entry */
- *tbl_entry = (rule_id >> IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
- return;
-}
-
-uint32_t ipa_nati_get_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
- nat_table_type tbl_type,
- uint16_t tbl_entry)
-{
- struct ipa_nat_rule *tbl_ptr;
- uint32_t ret = 0;
-
- if (IPA_NAT_EXPN_TBL == tbl_type) {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
- } else {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
- }
-
- ret = (char *)&tbl_ptr[tbl_entry] - (char *)tbl_ptr;
- ret += cache_ptr->tbl_addr_offset;
- return ret;
-}
-
-uint32_t ipa_nati_get_index_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
- nat_table_type tbl_type,
- uint16_t indx_tbl_entry)
-{
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- uint32_t ret = 0;
-
- if (IPA_NAT_INDEX_EXPN_TBL == tbl_type) {
- indx_tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
- } else {
- indx_tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
- }
-
- ret = (char *)&indx_tbl_ptr[indx_tbl_entry] - (char *)indx_tbl_ptr;
- ret += cache_ptr->tbl_addr_offset;
- return ret;
-}
-
-/* ------------------------------------------
- UTILITY FUNCTIONS END
---------------------------------------------*/
-
-/* ------------------------------------------
- Main Functions
---------------------------------------------**/
-void ipa_nati_reset_tbl(uint8_t tbl_indx)
-{
- uint16_t table_entries = ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
- uint16_t expn_table_entries = ipv4_nat_cache.ip4_tbl[tbl_indx].expn_table_entries;
-
- /* Base table */
- IPADBG("memset() base table to 0, %p\n",
- ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr);
-
- memset(ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr,
- 0,
- IPA_NAT_TABLE_ENTRY_SIZE * table_entries);
-
- /* Base expansino table */
- IPADBG("memset() expn base table to 0, %p\n",
- ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_expn_rules_addr);
-
- memset(ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_expn_rules_addr,
- 0,
- IPA_NAT_TABLE_ENTRY_SIZE * expn_table_entries);
-
- /* Index table */
- IPADBG("memset() index table to 0, %p\n",
- ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_addr);
-
- memset(ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_addr,
- 0,
- IPA_NAT_INDEX_TABLE_ENTRY_SIZE * table_entries);
-
- /* Index expansion table */
- IPADBG("memset() index expn table to 0, %p\n",
- ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_expn_addr);
-
- memset(ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_expn_addr,
- 0,
- IPA_NAT_INDEX_TABLE_ENTRY_SIZE * expn_table_entries);
-
- IPADBG("returning from ipa_nati_reset_tbl()\n");
- return;
-}
-
-int ipa_nati_add_ipv4_tbl(uint32_t public_ip_addr,
- uint16_t number_of_entries,
- uint32_t *tbl_hdl)
-{
- struct ipa_ioc_nat_alloc_mem mem;
- uint8_t tbl_indx = ipv4_nat_cache.table_cnt;
- uint16_t table_entries, expn_table_entries;
int ret;
- *tbl_hdl = 0;
- /* Allocate table */
- memset(&mem, 0, sizeof(mem));
- ret = ipa_nati_alloc_table(number_of_entries,
- &mem,
- &table_entries,
- &expn_table_entries);
- if (0 != ret) {
- IPAERR("unable to allocate nat table\n");
- return -ENOMEM;
- }
+ IPADBG("In\n");
- /* Update the cache
- The (IPA_NAT_UNUSED_BASE_ENTRIES/2) indicates zero entry entries
- for both base and expansion table
- */
- ret = ipa_nati_update_cache(&mem,
- public_ip_addr,
- table_entries,
- expn_table_entries);
- if (0 != ret) {
- IPAERR("unable to update cache Error: %d\n", ret);
- return -EINVAL;
- }
+ ret = (rule->tbl_entry) ? 1 : 0;
- /* Reset the nat table before posting init cmd */
- ipa_nati_reset_tbl(tbl_indx);
+ IPADBG("enable(%d)\n", ret);
- /* Initialize the ipa hw with nat table dimensions */
- ret = ipa_nati_post_ipv4_init_cmd(tbl_indx);
- if (0 != ret) {
- IPAERR("unable to post nat_init command Error %d\n", ret);
- return -EINVAL;
- }
+ IPADBG("Out\n");
- /* store the initial public ip address in the cached pdn table
- this is backward compatible for pre IPAv4 versions, we will always
- use this ip as the single PDN address
- */
- pdns[0].public_ip = public_ip_addr;
-
- /* Return table handle */
- ipv4_nat_cache.table_cnt++;
- *tbl_hdl = ipv4_nat_cache.table_cnt;
-
-#ifdef NAT_DUMP
- ipa_nat_dump_ipv4_table(*tbl_hdl);
-#endif
- return 0;
-}
-
-int ipa_nati_alloc_table(uint16_t number_of_entries,
- struct ipa_ioc_nat_alloc_mem *mem,
- uint16_t *table_entries,
- uint16_t *expn_table_entries)
-{
- int fd = 0, ret;
- uint16_t total_entries;
-
- /* Copy the table name */
- strlcpy(mem->dev_name, NAT_DEV_NAME, IPA_RESOURCE_NAME_MAX);
-
- /* Calculate the size for base table and expansion table */
- *table_entries = (uint16_t)(number_of_entries * IPA_NAT_BASE_TABLE_PERCENTAGE);
- if (*table_entries == 0) {
- *table_entries = 1;
- }
- if (GetNearest2Power(*table_entries, table_entries)) {
- IPAERR("unable to calculate power of 2\n");
- return -EINVAL;
- }
-
- *expn_table_entries = (uint16_t)(number_of_entries * IPA_NAT_EXPANSION_TABLE_PERCENTAGE);
- GetNearestEven(*expn_table_entries, expn_table_entries);
-
- total_entries = (*table_entries)+(*expn_table_entries);
-
- /* Calclate the memory size for both table and index table entries */
- mem->size = (IPA_NAT_TABLE_ENTRY_SIZE * total_entries);
- IPADBG("Nat Table size: %zu\n", mem->size);
- mem->size += (IPA_NAT_INDEX_TABLE_ENTRY_SIZE * total_entries);
- IPADBG("Nat Base and Index Table size: %zu\n", mem->size);
-
- if (!ipv4_nat_cache.ipa_fd) {
- fd = open(IPA_DEV_NAME, O_RDONLY);
- if (fd < 0) {
- perror("ipa_nati_alloc_table(): open error value:");
- IPAERR("unable to open ipa device\n");
- return -EIO;
- }
- ipv4_nat_cache.ipa_fd = fd;
- }
-
- if (GetIPAVer()) {
- IPAERR("unable to get ipa ver\n");
- return -EIO;
- }
-
- ret = CreateNatDevice(mem);
return ret;
}
-
-int ipa_nati_update_cache(struct ipa_ioc_nat_alloc_mem *mem,
- uint32_t public_addr,
- uint16_t tbl_entries,
- uint16_t expn_tbl_entries)
+static uint16_t index_table_entry_get_next_index(
+ void* entry)
{
- uint32_t index = ipv4_nat_cache.table_cnt;
- char *ipv4_rules_addr = NULL;
+ uint16_t result;
+ struct ipa_nat_indx_tbl_rule* rule = (struct ipa_nat_indx_tbl_rule*)entry;
- int fd = 0;
- int flags = MAP_SHARED;
- int prot = PROT_READ | PROT_WRITE;
- off_t offset = 0;
+ IPADBG("In\n");
+
+ result = rule->next_index;
+
+ IPADBG("Next entry of %pK is %d\n", entry, result);
+
+ IPADBG("Out\n");
+
+ return result;
+}
+
+static uint16_t index_table_entry_get_prev_index(
+ void* entry,
+ uint16_t entry_index,
+ void* meta,
+ uint16_t base_table_size)
+{
+ uint16_t result = 0;
+ struct ipa_nat_indx_tbl_meta_info* index_expn_table_meta =
+ (struct ipa_nat_indx_tbl_meta_info*)meta;
+
+ UNUSED(entry);
+
+ IPADBG("In\n");
+
+ if (entry_index >= base_table_size)
+ result = index_expn_table_meta[entry_index - base_table_size].prev_index;
+
+ IPADBG("Previous entry of %d is %d\n", entry_index, result);
+
+ IPADBG("Out\n");
+
+ return result;
+}
+
+static void index_table_entry_set_prev_index(
+ void* entry,
+ uint16_t entry_index,
+ uint16_t prev_index,
+ void* meta,
+ uint16_t base_table_size)
+{
+ struct ipa_nat_indx_tbl_meta_info* index_expn_table_meta =
+ (struct ipa_nat_indx_tbl_meta_info*) meta;
+
+ UNUSED(entry);
+
+ IPADBG("In\n");
+
+ IPADBG("Previous entry of %u is %u\n", entry_index, prev_index);
+
+ if ( entry_index >= base_table_size )
+ {
+ index_expn_table_meta[entry_index - base_table_size].prev_index = prev_index;
+ }
+ else if ( VALID_INDEX(prev_index) )
+ {
+ IPAERR("Base table entry %u can't has prev entry %u, but only %u",
+ entry_index, prev_index, IPA_TABLE_INVALID_ENTRY);
+ }
+
+ IPADBG("Out\n");
+}
+
+static int index_table_entry_head_insert(
+ void* entry,
+ void* user_data,
+ uint16_t* dma_command_data)
+{
+ IPADBG("In\n");
+
+ UNUSED(entry);
+
+ IPADBG("entry(%p) user_data(%p) dma_command_data(%p)\n",
+ entry,
+ user_data,
+ dma_command_data);
+
+ *dma_command_data = *((uint16_t*)user_data);
+
+ IPADBG("Out\n");
+
+ return 0;
+}
+
+static int index_table_entry_tail_insert(
+ void* entry,
+ void* user_data)
+{
+ struct ipa_nat_indx_tbl_rule* rule_ptr =
+ (struct ipa_nat_indx_tbl_rule*) entry;
+
+ IPADBG("In\n");
+
+ IPADBG("entry(%p) user_data(%p)\n",
+ entry,
+ user_data);
+
+ rule_ptr->tbl_entry = *((uint16_t*)user_data);
+
+ IPADBG("Out\n");
+
+ return 0;
+}
+
+static uint16_t index_table_entry_get_delete_head_dma_command_data(
+ void* head,
+ void* next_entry)
+{
+ uint16_t result;
+ struct ipa_nat_indx_tbl_rule* rule =
+ (struct ipa_nat_indx_tbl_rule*)next_entry;
+
+ UNUSED(head);
+
+ IPADBG("In\n");
+
+ result = rule->tbl_entry;
+
+ IPADBG("Out\n");
+
+ return result;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * Private data and functions used by this file's API
+ * ----------------------------------------------------------------------------
+ */
+static ipa_table_entry_interface entry_interface = {
+ table_entry_is_valid,
+ table_entry_get_next_index,
+ table_entry_get_prev_index,
+ table_entry_set_prev_index,
+ table_entry_head_insert,
+ table_entry_tail_insert,
+ table_entry_get_delete_head_dma_command_data
+};
+
+static ipa_table_entry_interface index_entry_interface = {
+ index_table_entry_is_valid,
+ index_table_entry_get_next_index,
+ index_table_entry_get_prev_index,
+ index_table_entry_set_prev_index,
+ index_table_entry_head_insert,
+ index_table_entry_tail_insert,
+ index_table_entry_get_delete_head_dma_command_data
+};
+
+/**
+ * ipa_nati_create_table_dma_cmd_helpers()
+ *
+ * Creates dma_cmd_helpers for base and index tables in the received
+ * NAT table
+ *
+ * @nat_table: [in] NAT table
+ * @table_indx: [in] The index of the NAT table
+ *
+ * A DMA command helper helps to generate the DMA command for one
+ * specific field change. Each table has 3 different types of field
+ * change: update_head, update_entry and delete_head. This function
+ * creates the helpers for base and index tables and updates the
+ * tables correspondingly.
+ */
+static void ipa_nati_create_table_dma_cmd_helpers(
+ struct ipa_nat_ip4_table_cache* nat_table,
+ uint8_t table_indx)
+{
+ IPADBG("In\n");
+
+ /*
+ * Create helpers for base table
+ */
+ ipa_table_dma_cmd_helper_init(
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_TABLE_FLAGS],
+ table_indx,
+ IPA_NAT_BASE_TBL,
+ IPA_NAT_EXPN_TBL,
+ nat_table->mem_desc.addr_offset + IPA_NAT_RULE_FLAG_FIELD_OFFSET);
+
+ ipa_table_dma_cmd_helper_init(
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_TABLE_NEXT_INDEX],
+ table_indx,
+ IPA_NAT_BASE_TBL,
+ IPA_NAT_EXPN_TBL,
+ nat_table->mem_desc.addr_offset + IPA_NAT_RULE_NEXT_FIELD_OFFSET);
+
+ ipa_table_dma_cmd_helper_init(
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_TABLE_PROTOCOL],
+ table_indx,
+ IPA_NAT_BASE_TBL,
+ IPA_NAT_EXPN_TBL,
+ nat_table->mem_desc.addr_offset + IPA_NAT_RULE_PROTO_FIELD_OFFSET);
+
+ /*
+ * Create helpers for index table
+ */
+ ipa_table_dma_cmd_helper_init(
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_INDEX_TABLE_ENTRY],
+ table_indx,
+ IPA_NAT_INDX_TBL,
+ IPA_NAT_INDEX_EXPN_TBL,
+ nat_table->mem_desc.addr_offset + IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET);
+
+ ipa_table_dma_cmd_helper_init(
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_INDEX_TABLE_NEXT_INDEX],
+ table_indx,
+ IPA_NAT_INDX_TBL,
+ IPA_NAT_INDEX_EXPN_TBL,
+ nat_table->mem_desc.addr_offset + IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET);
+
+ /*
+ * Init helpers for base table
+ */
+ nat_table->table.dma_help[HELP_UPDATE_HEAD] =
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_TABLE_FLAGS];
+
+ nat_table->table.dma_help[HELP_UPDATE_ENTRY] =
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_TABLE_NEXT_INDEX];
+
+ nat_table->table.dma_help[HELP_DELETE_HEAD] =
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_TABLE_PROTOCOL];
+
+ /*
+ * Init helpers for index table
+ */
+ nat_table->index_table.dma_help[HELP_UPDATE_HEAD] =
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_INDEX_TABLE_ENTRY];
+
+ nat_table->index_table.dma_help[HELP_UPDATE_ENTRY] =
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_INDEX_TABLE_NEXT_INDEX];
+
+ nat_table->index_table.dma_help[HELP_DELETE_HEAD] =
+ &nat_table->table_dma_cmd_helpers[IPA_NAT_INDEX_TABLE_ENTRY];
+
+ IPADBG("Out\n");
+}
+
+/**
+ * ipa_nati_create_table() - Creates a new IPv4 NAT table
+ * @nat_table: [in] IPv4 NAT table
+ * @public_ip_addr: [in] public IPv4 address
+ * @number_of_entries: [in] number of NAT entries
+ * @table_index: [in] the index of the IPv4 NAT table
+ *
+ * This function creates new IPv4 NAT table:
+ * - Initializes table, index table, memory descriptor and
+ * table_dma_cmd_helpers structures
+ * - Allocates the index expansion table meta data
+ * - Allocates, maps and clears the memory for table and index table
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+static int ipa_nati_create_table(
+ struct ipa_nat_cache* nat_cache_ptr,
+ struct ipa_nat_ip4_table_cache* nat_table,
+ uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint8_t table_index)
+{
+ int ret, size;
+ void* base_addr;
+
#ifdef IPA_ON_R3PC
- int ret = 0;
uint32_t nat_mem_offset = 0;
#endif
- ipv4_nat_cache.ip4_tbl[index].valid = IPA_NAT_TABLE_VALID;
- ipv4_nat_cache.ip4_tbl[index].public_addr = public_addr;
- ipv4_nat_cache.ip4_tbl[index].size = mem->size;
- ipv4_nat_cache.ip4_tbl[index].tbl_addr_offset = mem->offset;
+ IPADBG("In\n");
- ipv4_nat_cache.ip4_tbl[index].table_entries = tbl_entries;
- ipv4_nat_cache.ip4_tbl[index].expn_table_entries = expn_tbl_entries;
+ nat_table->public_addr = public_ip_addr;
- IPADBG("num of ipv4 rules:%d\n", tbl_entries);
- IPADBG("num of ipv4 expn rules:%d\n", expn_tbl_entries);
+ ipa_table_init(
+ &nat_table->table,
+ IPA_NAT_TABLE_NAME,
+ nat_cache_ptr->nmi,
+ sizeof(struct ipa_nat_rule),
+ NULL,
+ 0,
+ &entry_interface);
- /* allocate memory for nat index expansion table */
- if (NULL == ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta) {
- ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta =
- malloc(sizeof(struct ipa_nat_indx_tbl_meta_info) * expn_tbl_entries);
+ ret = ipa_table_calculate_entries_num(
+ &nat_table->table,
+ number_of_entries,
+ nat_cache_ptr->nmi);
- if (NULL == ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta) {
- IPAERR("Fail to allocate ipv4 index expansion table meta\n");
- return 0;
- }
-
- memset(ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta,
- 0,
- sizeof(struct ipa_nat_indx_tbl_meta_info) * expn_tbl_entries);
+ if (ret) {
+ IPAERR(
+ "unable to calculate number of entries in "
+ "nat table %d, while required by user %d\n",
+ table_index, number_of_entries);
+ goto done;
}
- /* Allocate memory for rule_id_array */
- if (NULL == ipv4_nat_cache.ip4_tbl[index].rule_id_array) {
- ipv4_nat_cache.ip4_tbl[index].rule_id_array =
- malloc(sizeof(uint16_t) * (tbl_entries + expn_tbl_entries));
+ /*
+ * Allocate memory for NAT index expansion table meta data
+ */
+ nat_table->index_expn_table_meta = (struct ipa_nat_indx_tbl_meta_info*)
+ calloc(nat_table->table.expn_table_entries,
+ sizeof(struct ipa_nat_indx_tbl_meta_info));
- if (NULL == ipv4_nat_cache.ip4_tbl[index].rule_id_array) {
- IPAERR("Fail to allocate rule id array\n");
- return 0;
- }
-
- memset(ipv4_nat_cache.ip4_tbl[index].rule_id_array,
- 0,
- sizeof(uint16_t) * (tbl_entries + expn_tbl_entries));
+ if (nat_table->index_expn_table_meta == NULL) {
+ size = nat_table->table.expn_table_entries *
+ sizeof(struct ipa_nat_indx_tbl_meta_info);
+ IPAERR(
+ "Fail to allocate ipv4 index expansion table meta with size %d\n",
+ size);
+ ret = -ENOMEM;
+ goto done;
}
+ ipa_table_init(
+ &nat_table->index_table,
+ IPA_NAT_INDEX_TABLE_NAME,
+ nat_cache_ptr->nmi,
+ sizeof(struct ipa_nat_indx_tbl_rule),
+ nat_table->index_expn_table_meta,
+ sizeof(struct ipa_nat_indx_tbl_meta_info),
+ &index_entry_interface);
- /* open the nat table */
- strlcpy(mem->dev_name, NAT_DEV_FULL_NAME, IPA_RESOURCE_NAME_MAX);
- fd = open(mem->dev_name, O_RDWR);
- if (fd < 0) {
- perror("ipa_nati_update_cache(): open error value:");
- IPAERR("unable to open nat device. Error:%d\n", fd);
- return -EIO;
+ nat_table->index_table.table_entries =
+ nat_table->table.table_entries;
+
+ nat_table->index_table.expn_table_entries =
+ nat_table->table.expn_table_entries;
+
+ nat_table->index_table.tot_tbl_ents =
+ nat_table->table.tot_tbl_ents;
+
+ size = ipa_table_calculate_size(&nat_table->table);
+ size += ipa_table_calculate_size(&nat_table->index_table);
+
+ IPADBG("Nat Base and Index Table size: %d\n", size);
+
+ ipa_mem_descriptor_init(
+ &nat_table->mem_desc,
+ IPA_NAT_DEV_NAME,
+ size,
+ table_index,
+ IPA_IOC_ALLOC_NAT_TABLE,
+ IPA_IOC_DEL_NAT_TABLE,
+ true); /* true here means do consider using sram */
+
+ ret = ipa_mem_descriptor_allocate_memory(
+ &nat_table->mem_desc,
+ nat_cache_ptr->ipa_desc->fd);
+
+ if (ret) {
+ IPAERR("unable to allocate nat memory descriptor Error: %d\n", ret);
+ goto bail_meta;
}
- /* copy the nat table name */
- strlcpy(ipv4_nat_cache.ip4_tbl[index].table_name,
- mem->dev_name,
- IPA_RESOURCE_NAME_MAX);
- ipv4_nat_cache.ip4_tbl[index].nat_fd = fd;
-
- /* open the nat device Table */
-#ifndef IPA_ON_R3PC
- ipv4_rules_addr = (void *)mmap(NULL, mem->size,
- prot, flags,
- fd, offset);
-#else
- IPADBG("user space r3pc\n");
- ipv4_rules_addr = (void *)mmap((caddr_t)0, NAT_MMAP_MEM_SIZE,
- prot, flags,
- fd, offset);
-#endif
- if (MAP_FAILED == ipv4_rules_addr) {
- perror("unable to mmap the memory\n");
- return -EINVAL;
- }
+ base_addr = nat_table->mem_desc.base_addr;
#ifdef IPA_ON_R3PC
- ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_GET_NAT_OFFSET, &nat_mem_offset);
- if (ret != 0) {
- perror("ipa_nati_post_ipv4_init_cmd(): ioctl error value");
- IPAERR("unable to post ant offset cmd Error: %d\n", ret);
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- return -EIO;
+ ret = ioctl(nat_cache_ptr->ipa_desc->fd,
+ IPA_IOC_GET_NAT_OFFSET,
+ &nat_mem_offset);
+ if (ret) {
+ IPAERR("unable to post ant offset cmd Error: %d IPA fd %d\n",
+ ret, nat_cache_ptr->ipa_desc->fd);
+ goto bail_mem_desc;
}
- ipv4_rules_addr += nat_mem_offset;
- ipv4_nat_cache.ip4_tbl[index].mmap_offset = nat_mem_offset;
+ base_addr += nat_mem_offset;
#endif
- IPADBG("mmap return value 0x%lx\n", (long unsigned int)ipv4_rules_addr);
+ base_addr =
+ ipa_table_calculate_addresses(&nat_table->table, base_addr);
+ ipa_table_calculate_addresses(&nat_table->index_table, base_addr);
- ipv4_nat_cache.ip4_tbl[index].ipv4_rules_addr = ipv4_rules_addr;
+ ipa_table_reset(&nat_table->table);
+ ipa_table_reset(&nat_table->index_table);
- ipv4_nat_cache.ip4_tbl[index].ipv4_expn_rules_addr =
- ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * tbl_entries);
+ ipa_nati_create_table_dma_cmd_helpers(nat_table, table_index);
- ipv4_nat_cache.ip4_tbl[index].index_table_addr =
- ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * (tbl_entries + expn_tbl_entries));
+ goto done;
- ipv4_nat_cache.ip4_tbl[index].index_table_expn_addr =
- ipv4_rules_addr +
- (IPA_NAT_TABLE_ENTRY_SIZE * (tbl_entries + expn_tbl_entries))+
- (IPA_NAT_INDEX_TABLE_ENTRY_SIZE * tbl_entries);
+#ifdef IPA_ON_R3PC
+bail_mem_desc:
+ ipa_mem_descriptor_delete(&nat_table->mem_desc, nat_cache_ptr->ipa_desc->fd);
+#endif
- return 0;
+bail_meta:
+ free(nat_table->index_expn_table_meta);
+ memset(nat_table, 0, sizeof(*nat_table));
+
+done:
+ IPADBG("Out\n");
+
+ return ret;
}
-/* comment: check the implementation once
- offset should be in terms of byes */
-int ipa_nati_post_ipv4_init_cmd(uint8_t tbl_index)
+static int ipa_nati_destroy_table(
+ struct ipa_nat_cache* nat_cache_ptr,
+ struct ipa_nat_ip4_table_cache* nat_table)
+{
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_mem_descriptor_delete(
+ &nat_table->mem_desc, nat_cache_ptr->ipa_desc->fd);
+
+ if (ret)
+ IPAERR("unable to delete NAT descriptor\n");
+
+ free(nat_table->index_expn_table_meta);
+
+ memset(nat_table, 0, sizeof(*nat_table));
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static int ipa_nati_post_ipv4_init_cmd(
+ struct ipa_nat_cache* nat_cache_ptr,
+ struct ipa_nat_ip4_table_cache* nat_table,
+ uint8_t tbl_index,
+ bool focus_change )
{
struct ipa_ioc_v4_nat_init cmd;
- uint32_t offset = ipv4_nat_cache.ip4_tbl[tbl_index].tbl_addr_offset;
- int ret;
- cmd.tbl_index = tbl_index;
+ char buf[1024];
+ int ret;
- cmd.ipv4_rules_offset = offset;
- cmd.expn_rules_offset = cmd.ipv4_rules_offset +
- (ipv4_nat_cache.ip4_tbl[tbl_index].table_entries * IPA_NAT_TABLE_ENTRY_SIZE);
+ IPADBG("In\n");
- cmd.index_offset = cmd.expn_rules_offset +
- (ipv4_nat_cache.ip4_tbl[tbl_index].expn_table_entries * IPA_NAT_TABLE_ENTRY_SIZE);
+ IPADBG("nat_cache_ptr(%p) nat_table(%p) tbl_index(%u) focus_change(%u)\n",
+ nat_cache_ptr, nat_table, tbl_index, focus_change);
- cmd.index_expn_offset = cmd.index_offset +
- (ipv4_nat_cache.ip4_tbl[tbl_index].table_entries * IPA_NAT_INDEX_TABLE_ENTRY_SIZE);
+ memset(&cmd, 0, sizeof(cmd));
- cmd.table_entries = ipv4_nat_cache.ip4_tbl[tbl_index].table_entries - 1;
- cmd.expn_table_entries = ipv4_nat_cache.ip4_tbl[tbl_index].expn_table_entries;
+ cmd.tbl_index = tbl_index;
+ cmd.focus_change = focus_change;
- cmd.ip_addr = ipv4_nat_cache.ip4_tbl[tbl_index].public_addr;
+ cmd.mem_type = nat_cache_ptr->nmi;
- ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_V4_INIT_NAT, &cmd);
- if (ret != 0) {
- perror("ipa_nati_post_ipv4_init_cmd(): ioctl error value");
- IPAERR("unable to post init cmd Error: %d\n", ret);
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- return -EINVAL;
+ cmd.ipv4_rules_offset =
+ nat_table->mem_desc.addr_offset;
+
+ cmd.expn_rules_offset =
+ cmd.ipv4_rules_offset +
+ (nat_table->table.table_entries * sizeof(struct ipa_nat_rule));
+
+ cmd.index_offset =
+ cmd.expn_rules_offset +
+ (nat_table->table.expn_table_entries * sizeof(struct ipa_nat_rule));
+
+ cmd.index_expn_offset =
+ cmd.index_offset +
+ (nat_table->index_table.table_entries * sizeof(struct ipa_nat_indx_tbl_rule));
+
+ /*
+ * Driverr/HW expected base table size to be power^2-1 due to H/W
+ * hash calculation
+ */
+ cmd.table_entries =
+ nat_table->table.table_entries - 1;
+ cmd.expn_table_entries =
+ nat_table->table.expn_table_entries;
+
+ cmd.ip_addr = nat_table->public_addr;
+
+ *buf = '\0';
+ IPADBG("%s\n", ipa_ioc_v4_nat_init_as_str(&cmd, buf, sizeof(buf)));
+
+ ret = ioctl(nat_cache_ptr->ipa_desc->fd, IPA_IOC_V4_INIT_NAT, &cmd);
+
+ if (ret) {
+ IPAERR("unable to post init cmd Error: %d IPA fd %d\n",
+ ret, nat_cache_ptr->ipa_desc->fd);
+ goto bail;
}
+
IPADBG("Posted IPA_IOC_V4_INIT_NAT to kernel successfully\n");
- return 0;
-}
+bail:
+ IPADBG("Out\n");
-int ipa_nati_del_ipv4_table(uint32_t tbl_hdl)
-{
- uint8_t index = (uint8_t)(tbl_hdl - 1);
- void *addr = (void *)ipv4_nat_cache.ip4_tbl[index].ipv4_rules_addr;
- struct ipa_ioc_v4_nat_del del_cmd;
- int ret;
-
- if (!ipv4_nat_cache.ip4_tbl[index].valid) {
- IPAERR("invalid table handle passed\n");
- ret = -EINVAL;
- goto fail;
- }
-
- if (pthread_mutex_lock(&nat_mutex) != 0) {
- ret = -1;
- goto lock_mutex_fail;
- }
-
- /* unmap the device memory from user space */
-#ifndef IPA_ON_R3PC
- munmap(addr, ipv4_nat_cache.ip4_tbl[index].size);
-#else
- addr = (char *)addr - ipv4_nat_cache.ip4_tbl[index].mmap_offset;
- munmap(addr, NAT_MMAP_MEM_SIZE);
-#endif
-
- /* close the file descriptor of nat device */
- if (close(ipv4_nat_cache.ip4_tbl[index].nat_fd)) {
- IPAERR("unable to close the file descriptor\n");
- ret = -EINVAL;
- if (pthread_mutex_unlock(&nat_mutex) != 0)
- goto unlock_mutex_fail;
- goto fail;
- }
-
- del_cmd.table_index = index;
- del_cmd.public_ip_addr = ipv4_nat_cache.ip4_tbl[index].public_addr;
- ret = ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_V4_DEL_NAT, &del_cmd);
- if (ret != 0) {
- perror("ipa_nati_del_ipv4_table(): ioctl error value");
- IPAERR("unable to post nat del command init Error: %d\n", ret);
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- ret = -EINVAL;
- if (pthread_mutex_unlock(&nat_mutex) != 0)
- goto unlock_mutex_fail;
- goto fail;
- }
- IPAERR("posted IPA_IOC_V4_DEL_NAT to kernel successfully\n");
-
- free(ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta);
- free(ipv4_nat_cache.ip4_tbl[index].rule_id_array);
-
- memset(&ipv4_nat_cache.ip4_tbl[index],
- 0,
- sizeof(ipv4_nat_cache.ip4_tbl[index]));
-
- /* Decrease the table count by 1*/
- ipv4_nat_cache.table_cnt--;
-
- if (pthread_mutex_unlock(&nat_mutex) != 0) {
- ret = -1;
- goto unlock_mutex_fail;
- }
-
- return 0;
-
-lock_mutex_fail:
- IPAERR("unable to lock the nat mutex\n");
- return ret;
-
-unlock_mutex_fail:
- IPAERR("unable to unlock the nat mutex\n");
-
-fail:
return ret;
}
-int ipa_nati_query_timestamp(uint32_t tbl_hdl,
- uint32_t rule_hdl,
- uint32_t *time_stamp)
+static void ipa_nati_copy_second_index_entry_to_head(
+ struct ipa_nat_ip4_table_cache* nat_table,
+ ipa_table_iterator* index_table_iterator,
+ struct ipa_ioc_nat_dma_cmd* cmd)
{
- uint8_t tbl_index = (uint8_t)(tbl_hdl - 1);
- uint8_t expn_tbl = 0;
- uint16_t tbl_entry = 0;
- struct ipa_nat_rule *tbl_ptr = NULL;
+ uint16_t index;
+ struct ipa_nat_rule* table;
+ struct ipa_nat_indx_tbl_rule* index_table_rule =
+ (struct ipa_nat_indx_tbl_rule*)index_table_iterator->next_entry;
- if (!ipv4_nat_cache.ip4_tbl[tbl_index].valid) {
- IPAERR("invalid table handle\n");
- return -EINVAL;
+ IPADBG("In\n");
+
+ /*
+ * The DMA command for field tbl_entry already added by the
+ * index_table.ipa_table_create_delete_command()
+ */
+ ipa_table_add_dma_cmd(
+ &nat_table->index_table,
+ HELP_UPDATE_ENTRY,
+ index_table_iterator->curr_entry,
+ index_table_iterator->curr_index,
+ index_table_rule->next_index,
+ cmd);
+
+ /* Change the indx_tbl_entry field in the related table rule */
+ if (index_table_rule->tbl_entry < nat_table->table.table_entries) {
+ index = index_table_rule->tbl_entry;
+ table = (struct ipa_nat_rule*)nat_table->table.table_addr;
+ } else {
+ index = index_table_rule->tbl_entry - nat_table->table.table_entries;
+ table = (struct ipa_nat_rule*)nat_table->table.expn_table_addr;
}
- if (pthread_mutex_lock(&nat_mutex) != 0) {
- IPAERR("unable to lock the nat mutex\n");
- return -1;
- }
+ table[index].indx_tbl_entry = index_table_iterator->curr_index;
- ipa_nati_parse_ipv4_rule_hdl(tbl_index, (uint16_t)rule_hdl,
- &expn_tbl, &tbl_entry);
-
- tbl_ptr =
- (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_index].ipv4_rules_addr;
- if (expn_tbl) {
- tbl_ptr =
- (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_index].ipv4_expn_rules_addr;
- }
-
- if (tbl_ptr)
- *time_stamp = Read32BitFieldValue(tbl_ptr[tbl_entry].ts_proto,
- TIME_STAMP_FIELD);
-
- if (pthread_mutex_unlock(&nat_mutex) != 0) {
- IPAERR("unable to unlock the nat mutex\n");
- return -1;
- }
-
- return 0;
+ IPADBG("Out\n");
}
-int ipa_nati_modify_pdn(struct ipa_ioc_nat_pdn_entry *entry)
+/**
+ * dst_hash() - Find the index into ipv4 base table
+ * @public_ip: [in] public_ip
+ * @trgt_ip: [in] Target IP address
+ * @trgt_port: [in] Target port
+ * @public_port: [in] Public port
+ * @proto: [in] Protocol (TCP/IP)
+ * @size: [in] size of the ipv4 base Table
+ *
+ * This hash method is used to find the hash index of new nat
+ * entry into ipv4 base table. In case of zero index, the
+ * new entry will be stored into N-1 index where N is size of
+ * ipv4 base table
+ *
+ * Returns: >0 index into ipv4 base table, negative on failure
+ */
+static uint16_t dst_hash(
+ struct ipa_nat_cache* nat_cache_ptr,
+ uint32_t public_ip,
+ uint32_t trgt_ip,
+ uint16_t trgt_port,
+ uint16_t public_port,
+ uint8_t proto,
+ uint16_t size)
{
+ uint16_t hash =
+ ((uint16_t)(trgt_ip)) ^
+ ((uint16_t)(trgt_ip >> 16)) ^
+ (trgt_port) ^
+ (public_port) ^
+ (proto);
+
+ IPADBG("In\n");
+
+ IPADBG("public_ip: 0x%08X public_port: 0x%04X\n", public_ip, public_port);
+ IPADBG("target_ip: 0x%08X target_port: 0x%04X\n", trgt_ip, trgt_port);
+ IPADBG("proto: 0x%02X size: 0x%04X\n", proto, size);
+
+ if (nat_cache_ptr->ipa_desc->ver >= IPA_HW_v4_0)
+ hash ^=
+ ((uint16_t)(public_ip)) ^
+ ((uint16_t)(public_ip >> 16));
+
+ /*
+ * The size passed to hash function expected be power^2-1, while
+ * the actual size is power^2, actual_size = size + 1
+ */
+ hash = (hash & size);
+
+ /*
+ * If the hash resulted to zero then set it to maximum value as
+ * zero is unused entry in nat tables
+ */
+ if (hash == 0) {
+ hash = size;
+ }
+
+ IPADBG("dst_hash returning value: %d\n", hash);
+
+ IPADBG("Out\n");
+
+ return hash;
+}
+
+/**
+ * src_hash() - Find the index into ipv4 index base table
+ * @priv_ip: [in] Private IP address
+ * @priv_port: [in] Private port
+ * @trgt_ip: [in] Target IP address
+ * @trgt_port: [in] Target Port
+ * @proto: [in] Protocol (TCP/IP)
+ * @size: [in] size of the ipv4 index base Table
+ *
+ * This hash method is used to find the hash index of new nat
+ * entry into ipv4 index base table. In case of zero index, the
+ * new entry will be stored into N-1 index where N is size of
+ * ipv4 index base table
+ *
+ * Returns: >0 index into ipv4 index base table, negative on failure
+ */
+static uint16_t src_hash(
+ uint32_t priv_ip,
+ uint16_t priv_port,
+ uint32_t trgt_ip,
+ uint16_t trgt_port,
+ uint8_t proto,
+ uint16_t size)
+{
+ uint16_t hash =
+ ((uint16_t)(priv_ip)) ^
+ ((uint16_t)(priv_ip >> 16)) ^
+ (priv_port) ^
+ ((uint16_t)(trgt_ip)) ^
+ ((uint16_t)(trgt_ip >> 16)) ^
+ (trgt_port) ^
+ (proto);
+
+ IPADBG("In\n");
+
+ IPADBG("private_ip: 0x%08X private_port: 0x%04X\n", priv_ip, priv_port);
+ IPADBG(" target_ip: 0x%08X target_port: 0x%04X\n", trgt_ip, trgt_port);
+ IPADBG("proto: 0x%02X size: 0x%04X\n", proto, size);
+
+ /*
+ * The size passed to hash function expected be power^2-1, while
+ * the actual size is power^2, actual_size = size + 1
+ */
+ hash = (hash & size);
+
+ /*
+ * If the hash resulted to zero then set it to maximum value as
+ * zero is unused entry in nat tables
+ */
+ if (hash == 0) {
+ hash = size;
+ }
+
+ IPADBG("src_hash returning value: %d\n", hash);
+
+ IPADBG("Out\n");
+
+ return hash;
+}
+
+static int ipa_nati_post_ipv4_dma_cmd(
+ struct ipa_nat_cache* nat_cache_ptr,
+ struct ipa_ioc_nat_dma_cmd* cmd)
+{
+ char buf[4096];
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ cmd->mem_type = nat_cache_ptr->nmi;
+
+ *buf = '\0';
+ IPADBG("%s\n", prep_ioc_nat_dma_cmd_4print(cmd, buf, sizeof(buf)));
+
+ if (ioctl(nat_cache_ptr->ipa_desc->fd, IPA_IOC_TABLE_DMA_CMD, cmd)) {
+ IPAERR("ioctl (IPA_IOC_TABLE_DMA_CMD) on fd %d has failed\n",
+ nat_cache_ptr->ipa_desc->fd);
+ ret = -EIO;
+ goto bail;
+ }
+
+ IPADBG("Posted IPA_IOC_TABLE_DMA_CMD to kernel successfully\n");
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * API functions exposed to the upper layers
+ * ----------------------------------------------------------------------------
+ */
+int ipa_nati_modify_pdn(
+ struct ipa_ioc_nat_pdn_entry *entry)
+{
+ struct ipa_nat_cache* nat_cache_ptr;
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ nat_cache_ptr =
+ (ipv4_nat_cache[IPA_NAT_MEM_IN_DDR].ipa_desc) ?
+ &ipv4_nat_cache[IPA_NAT_MEM_IN_DDR] :
+ &ipv4_nat_cache[IPA_NAT_MEM_IN_SRAM];
+
+ if ( nat_cache_ptr->ipa_desc == NULL )
+ {
+ IPAERR("Uninitialized cache file descriptor\n");
+ ret = -EIO;
+ goto done;
+ }
+
if (entry->public_ip == 0)
IPADBG("PDN %d public ip will be set to 0\n", entry->pdn_index);
- if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_MODIFY_PDN, entry)) {
- perror("ipa_nati_modify_pdn(): ioctl error value");
- IPAERR("unable to call modify pdn icotl\n");
- IPAERR("index %d, ip 0x%X, src_metdata 0x%X, dst_metadata 0x%X\n",
- entry->pdn_index, entry->public_ip, entry->src_metadata, entry->dst_metadata);
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- return -EIO;
+ ret = ioctl(nat_cache_ptr->ipa_desc->fd, IPA_IOC_NAT_MODIFY_PDN, entry);
+
+ if ( ret ) {
+ IPAERR("unable to call modify pdn icotl\nindex %d, ip 0x%X, src_metdata 0x%X, dst_metadata 0x%X IPA fd %d\n",
+ entry->pdn_index,
+ entry->public_ip,
+ entry->src_metadata,
+ entry->dst_metadata,
+ nat_cache_ptr->ipa_desc->fd);
+ goto done;
}
- pdns[entry->pdn_index].public_ip = entry->public_ip;
+ pdns[entry->pdn_index].public_ip = entry->public_ip;
pdns[entry->pdn_index].dst_metadata = entry->dst_metadata;
pdns[entry->pdn_index].src_metadata = entry->src_metadata;
IPADBG("posted IPA_IOC_NAT_MODIFY_PDN to kernel successfully and stored in cache\n index %d, ip 0x%X, src_metdata 0x%X, dst_metadata 0x%X\n",
- entry->pdn_index, entry->public_ip, entry->src_metadata, entry->dst_metadata);
+ entry->pdn_index,
+ entry->public_ip,
+ entry->src_metadata,
+ entry->dst_metadata);
+done:
+ IPADBG("Out\n");
- return 0;
+ return ret;
}
-int ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
- const ipa_nat_ipv4_rule *clnt_rule,
- uint32_t *rule_hdl)
+int ipa_nati_get_pdn_index(
+ uint32_t public_ip,
+ uint8_t *pdn_index)
{
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- struct ipa_nat_sw_rule sw_rule;
- struct ipa_nat_indx_tbl_sw_rule index_sw_rule;
- uint16_t new_entry, new_index_tbl_entry;
+ int i = 0;
- /* verify that the rule's PDN is valid */
- if (clnt_rule->pdn_index >= IPA_MAX_PDN_NUM ||
- pdns[clnt_rule->pdn_index].public_ip == 0) {
- IPAERR("invalid parameters, pdn index %d, public ip = 0x%X\n",
- clnt_rule->pdn_index, pdns[clnt_rule->pdn_index].public_ip);
- return -EINVAL;
+ for(i = 0; i < (IPA_MAX_PDN_NUM - 1); i++) {
+ if(pdns[i].public_ip == public_ip) {
+ IPADBG("ip 0x%X matches PDN index %d\n", public_ip, i);
+ *pdn_index = i;
+ return 0;
+ }
}
- memset(&sw_rule, 0, sizeof(sw_rule));
- memset(&index_sw_rule, 0, sizeof(index_sw_rule));
+ IPAERR("ip 0x%X does not match any PDN\n", public_ip);
- /* Generate rule from client input */
- if (ipa_nati_generate_rule(tbl_hdl, clnt_rule,
- &sw_rule, &index_sw_rule,
- &new_entry, &new_index_tbl_entry)) {
- IPAERR("unable to generate rule\n");
- return -EINVAL;
- }
+ return -EIO;
+}
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
- ipa_nati_copy_ipv4_rule_to_hw(tbl_ptr, &sw_rule, new_entry, (uint8_t)(tbl_hdl-1));
- ipa_nati_copy_ipv4_index_rule_to_hw(tbl_ptr,
- &index_sw_rule,
- new_index_tbl_entry,
- (uint8_t)(tbl_hdl-1));
+int ipa_nati_alloc_pdn(
+ ipa_nat_pdn_entry *pdn_info,
+ uint8_t *pdn_index)
+{
+ ipa_nat_pdn_entry zero_test;
+ struct ipa_ioc_nat_pdn_entry pdn_data;
+ int i, ret;
- IPADBG("new entry:%d, new index entry: %d\n", new_entry, new_index_tbl_entry);
- if (ipa_nati_post_ipv4_dma_cmd((uint8_t)(tbl_hdl - 1), new_entry)) {
- IPAERR("unable to post dma command\n");
+ IPADBG("alloc PDN for ip 0x%x\n", pdn_info->public_ip);
+
+ memset(&zero_test, 0, sizeof(zero_test));
+
+ if(num_pdns >= (IPA_MAX_PDN_NUM - 1)) {
+ IPAERR("exceeded max num of PDNs, num_pdns %d\n", num_pdns);
return -EIO;
}
- /* Generate rule handle */
- *rule_hdl = ipa_nati_make_rule_hdl((uint16_t)tbl_hdl, new_entry);
- if (!(*rule_hdl)) {
- IPAERR("unable to generate rule handle\n");
- return -EINVAL;
- }
-
-#ifdef NAT_DUMP
- ipa_nat_dump_ipv4_table(tbl_hdl);
-#endif
-
- return 0;
-}
-
-int ipa_nati_generate_rule(uint32_t tbl_hdl,
- const ipa_nat_ipv4_rule *clnt_rule,
- struct ipa_nat_sw_rule *rule,
- struct ipa_nat_indx_tbl_sw_rule *index_sw_rule,
- uint16_t *tbl_entry,
- uint16_t *indx_tbl_entry)
-{
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- uint16_t tmp;
-
- if (NULL == clnt_rule || NULL == index_sw_rule ||
- NULL == rule || NULL == tbl_entry ||
- NULL == indx_tbl_entry) {
- IPAERR("invalid parameters\n");
- return -EINVAL;
- }
-
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
-
- *tbl_entry = ipa_nati_generate_tbl_rule(clnt_rule,
- rule,
- tbl_ptr);
- if (IPA_NAT_INVALID_NAT_ENTRY == *tbl_entry) {
- IPAERR("unable to generate table entry\n");
- return -EINVAL;
- }
-
- index_sw_rule->tbl_entry = *tbl_entry;
- *indx_tbl_entry = ipa_nati_generate_index_rule(clnt_rule,
- index_sw_rule,
- tbl_ptr);
- if (IPA_NAT_INVALID_NAT_ENTRY == *indx_tbl_entry) {
- IPAERR("unable to generate index table entry\n");
- return -EINVAL;
- }
-
- rule->indx_tbl_entry = *indx_tbl_entry;
- if (*indx_tbl_entry >= tbl_ptr->table_entries) {
- tmp = *indx_tbl_entry - tbl_ptr->table_entries;
- tbl_ptr->index_expn_table_meta[tmp].prev_index = index_sw_rule->prev_index;
- }
-
- return 0;
-}
-
-uint16_t ipa_nati_generate_tbl_rule(const ipa_nat_ipv4_rule *clnt_rule,
- struct ipa_nat_sw_rule *sw_rule,
- struct ipa_nat_ip4_table_cache *tbl_ptr)
-{
- uint32_t pub_ip_addr;
- uint16_t prev = 0, nxt_indx = 0, new_entry;
- struct ipa_nat_rule *tbl = NULL, *expn_tbl = NULL;
-
- pub_ip_addr = pdns[clnt_rule->pdn_index].public_ip;
-
- tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_rules_addr;
- expn_tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_expn_rules_addr;
-
- /* copy the values from client rule to sw rule */
- sw_rule->private_ip = clnt_rule->private_ip;
- sw_rule->private_port = clnt_rule->private_port;
- sw_rule->protocol = clnt_rule->protocol;
- sw_rule->public_port = clnt_rule->public_port;
- sw_rule->target_ip = clnt_rule->target_ip;
- sw_rule->target_port = clnt_rule->target_port;
- sw_rule->pdn_index = clnt_rule->pdn_index;
-
- /* consider only public and private ip fields */
- sw_rule->ip_chksum = ipa_nati_calc_ip_cksum(pub_ip_addr,
- clnt_rule->private_ip);
-
- if (IPPROTO_TCP == sw_rule->protocol ||
- IPPROTO_UDP == sw_rule->protocol) {
- /* consider public and private ip & port fields */
- sw_rule->tcp_udp_chksum = ipa_nati_calc_tcp_udp_cksum(
- pub_ip_addr,
- clnt_rule->public_port,
- clnt_rule->private_ip,
- clnt_rule->private_port);
- }
-
- sw_rule->rsvd1 = 0;
- sw_rule->enable = IPA_NAT_FLAG_DISABLE_BIT;
- sw_rule->next_index = 0;
-
- /*
- SW sets this timer to 0.
- The assumption is that 0 is an invalid clock value and no clock
- wraparounds are expected
- */
- sw_rule->time_stamp = 0;
- sw_rule->rsvd2 = 0;
- sw_rule->rsvd3 = 0;
- sw_rule->prev_index = 0;
- sw_rule->indx_tbl_entry = 0;
-
- new_entry = dst_hash(pub_ip_addr, clnt_rule->target_ip,
- clnt_rule->target_port,
- clnt_rule->public_port,
- clnt_rule->protocol,
- tbl_ptr->table_entries-1);
-
- /* check whether there is any collision
- if no collision return */
- if (!Read16BitFieldValue(tbl[new_entry].ip_cksm_enbl,
- ENABLE_FIELD)) {
- sw_rule->prev_index = 0;
- IPADBG("Destination Nat New Entry Index %d\n", new_entry);
- return new_entry;
- }
-
- /* First collision */
- if (Read16BitFieldValue(tbl[new_entry].nxt_indx_pub_port,
- NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY) {
- sw_rule->prev_index = new_entry;
- } else { /* check for more than one collision */
- /* Find the IPA_NAT_DEL_TYPE_LAST entry in list */
- nxt_indx = Read16BitFieldValue(tbl[new_entry].nxt_indx_pub_port,
- NEXT_INDEX_FIELD);
-
- while (nxt_indx != IPA_NAT_INVALID_NAT_ENTRY) {
- prev = nxt_indx;
-
- nxt_indx -= tbl_ptr->table_entries;
- nxt_indx = Read16BitFieldValue(expn_tbl[nxt_indx].nxt_indx_pub_port,
- NEXT_INDEX_FIELD);
-
- /* Handling error case */
- if (prev == nxt_indx) {
- IPAERR("Error: Prev index:%d and next:%d index should not be same\n", prev, nxt_indx);
- return IPA_NAT_INVALID_NAT_ENTRY;
+ for(i = 0; i < (IPA_MAX_PDN_NUM - 1); i++) {
+ if(pdns[i].public_ip == pdn_info->public_ip)
+ {
+ IPADBG("found the same pdn in index %d\n", i);
+ *pdn_index = i;
+ if((pdns[i].src_metadata != pdn_info->src_metadata) ||
+ (pdns[i].dst_metadata != pdn_info->dst_metadata))
+ {
+ IPAERR("WARNING: metadata values don't match! [%d, %d], [%d, %d]\n\n",
+ pdns[i].src_metadata, pdn_info->src_metadata,
+ pdns[i].dst_metadata, pdn_info->dst_metadata);
}
+ return 0;
}
- sw_rule->prev_index = prev;
- }
-
- /* On collision check for the free entry in expansion table */
- new_entry = ipa_nati_expn_tbl_free_entry(expn_tbl,
- tbl_ptr->expn_table_entries);
-
- if (IPA_NAT_INVALID_NAT_ENTRY == new_entry) {
- /* Expansion table is full return*/
- IPAERR("Expansion table is full\n");
- IPAERR("Current Table: %d & Expn Entries: %d\n",
- tbl_ptr->cur_tbl_cnt, tbl_ptr->cur_expn_tbl_cnt);
- return IPA_NAT_INVALID_NAT_ENTRY;
- }
- new_entry += tbl_ptr->table_entries;
-
- IPADBG("new entry index %d\n", new_entry);
- return new_entry;
-}
-
-/* returns expn table entry index */
-uint16_t ipa_nati_expn_tbl_free_entry(struct ipa_nat_rule *expn_tbl,
- uint16_t size)
-{
- int cnt;
-
- for (cnt = 1; cnt < size; cnt++) {
- if (!Read16BitFieldValue(expn_tbl[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- IPADBG("new expansion table entry index %d\n", cnt);
- return cnt;
- }
- }
-
- IPAERR("nat expansion table is full\n");
- return 0;
-}
-
-uint16_t ipa_nati_generate_index_rule(const ipa_nat_ipv4_rule *clnt_rule,
- struct ipa_nat_indx_tbl_sw_rule *sw_rule,
- struct ipa_nat_ip4_table_cache *tbl_ptr)
-{
- struct ipa_nat_indx_tbl_rule *indx_tbl, *indx_expn_tbl;
- uint16_t prev = 0, nxt_indx = 0, new_entry;
-
- indx_tbl =
- (struct ipa_nat_indx_tbl_rule *)tbl_ptr->index_table_addr;
- indx_expn_tbl =
- (struct ipa_nat_indx_tbl_rule *)tbl_ptr->index_table_expn_addr;
-
- new_entry = src_hash(clnt_rule->private_ip,
- clnt_rule->private_port,
- clnt_rule->target_ip,
- clnt_rule->target_port,
- clnt_rule->protocol,
- tbl_ptr->table_entries-1);
-
- /* check whether there is any collision
- if no collision return */
- if (!Read16BitFieldValue(indx_tbl[new_entry].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- sw_rule->prev_index = 0;
- IPADBG("Source Nat Index Table Entry %d\n", new_entry);
- return new_entry;
- }
-
- /* check for more than one collision */
- if (Read16BitFieldValue(indx_tbl[new_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED) == IPA_NAT_INVALID_NAT_ENTRY) {
- sw_rule->prev_index = new_entry;
- IPADBG("First collosion. Entry %d\n", new_entry);
- } else {
- /* Find the IPA_NAT_DEL_TYPE_LAST entry in list */
- nxt_indx = Read16BitFieldValue(indx_tbl[new_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- while (nxt_indx != IPA_NAT_INVALID_NAT_ENTRY) {
- prev = nxt_indx;
-
- nxt_indx -= tbl_ptr->table_entries;
- nxt_indx = Read16BitFieldValue(indx_expn_tbl[nxt_indx].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- /* Handling error case */
- if (prev == nxt_indx) {
- IPAERR("Error: Prev:%d and next:%d index should not be same\n", prev, nxt_indx);
- return IPA_NAT_INVALID_NAT_ENTRY;
- }
- }
-
- sw_rule->prev_index = prev;
- }
-
- /* On collision check for the free entry in expansion table */
- new_entry = ipa_nati_index_expn_get_free_entry(indx_expn_tbl,
- tbl_ptr->expn_table_entries);
-
- if (IPA_NAT_INVALID_NAT_ENTRY == new_entry) {
- /* Expansion table is full return*/
- IPAERR("Index expansion table is full\n");
- IPAERR("Current Table: %d & Expn Entries: %d\n",
- tbl_ptr->cur_tbl_cnt, tbl_ptr->cur_expn_tbl_cnt);
- return IPA_NAT_INVALID_NAT_ENTRY;
- }
- new_entry += tbl_ptr->table_entries;
-
-
- if (sw_rule->prev_index == new_entry) {
- IPAERR("Error: prev_entry:%d ", sw_rule->prev_index);
- IPAERR("and new_entry:%d should not be same ", new_entry);
- IPAERR("infinite loop detected\n");
- return IPA_NAT_INVALID_NAT_ENTRY;
- }
-
- IPADBG("index table entry %d\n", new_entry);
- return new_entry;
-}
-
-/* returns index expn table entry index */
-uint16_t ipa_nati_index_expn_get_free_entry(
- struct ipa_nat_indx_tbl_rule *indx_tbl,
- uint16_t size)
-{
- int cnt;
- for (cnt = 1; cnt < size; cnt++) {
- if (!Read16BitFieldValue(indx_tbl[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- return cnt;
- }
- }
-
- IPAERR("nat index expansion table is full\n");
- return 0;
-}
-
-void ipa_nati_write_next_index(uint8_t tbl_indx,
- nat_table_type tbl_type,
- uint16_t value,
- uint32_t offset)
-{
- struct ipa_ioc_nat_dma_cmd *cmd;
-
- IPADBG("Updating next index field of table %d on collosion using dma\n", tbl_type);
- IPADBG("table index: %d, value: %d offset;%d\n", tbl_indx, value, offset);
-
- cmd = (struct ipa_ioc_nat_dma_cmd *)
- malloc(sizeof(struct ipa_ioc_nat_dma_cmd)+
- sizeof(struct ipa_ioc_nat_dma_one));
- if (NULL == cmd) {
- IPAERR("unable to allocate memory\n");
- return;
- }
-
- cmd->dma[0].table_index = tbl_indx;
- cmd->dma[0].base_addr = tbl_type;
- cmd->dma[0].data = value;
- cmd->dma[0].offset = offset;
-
- cmd->entries = 1;
- if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd)) {
- perror("ipa_nati_post_ipv4_dma_cmd(): ioctl error value");
- IPAERR("unable to call dma icotl to update next index\n");
- IPAERR("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- goto fail;
- }
-
-fail:
- free(cmd);
-
- return;
-}
-
-void ipa_nati_copy_ipv4_rule_to_hw(
- struct ipa_nat_ip4_table_cache *ipv4_cache,
- struct ipa_nat_sw_rule *rule,
- uint16_t entry, uint8_t tbl_index)
-{
- struct ipa_nat_rule *tbl_ptr;
- uint16_t prev_entry = rule->prev_index;
- nat_table_type tbl_type;
- uint32_t offset = 0;
-
- if (entry < ipv4_cache->table_entries) {
- tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_rules_addr;
-
- memcpy(&tbl_ptr[entry],
- rule,
- sizeof(struct ipa_nat_rule));
- } else {
- tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_expn_rules_addr;
- memcpy(&tbl_ptr[entry - ipv4_cache->table_entries],
- rule,
- sizeof(struct ipa_nat_rule));
- }
-
- /* Update the previos entry next_index */
- if (IPA_NAT_INVALID_NAT_ENTRY != prev_entry) {
-
- if (prev_entry < ipv4_cache->table_entries) {
- tbl_type = IPA_NAT_BASE_TBL;
- tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_rules_addr;
- } else {
- tbl_type = IPA_NAT_EXPN_TBL;
- /* tbp_ptr is already pointing to expansion table
- no need to initialize it */
- prev_entry = prev_entry - ipv4_cache->table_entries;
- }
-
- offset = ipa_nati_get_entry_offset(ipv4_cache, tbl_type, prev_entry);
- offset += IPA_NAT_RULE_NEXT_FIELD_OFFSET;
-
- ipa_nati_write_next_index(tbl_index, tbl_type, entry, offset);
- }
-
- return;
-}
-
-void ipa_nati_copy_ipv4_index_rule_to_hw(
- struct ipa_nat_ip4_table_cache *ipv4_cache,
- struct ipa_nat_indx_tbl_sw_rule *indx_sw_rule,
- uint16_t entry,
- uint8_t tbl_index)
-{
- struct ipa_nat_indx_tbl_rule *tbl_ptr;
- struct ipa_nat_sw_indx_tbl_rule sw_rule;
- uint16_t prev_entry = indx_sw_rule->prev_index;
- nat_table_type tbl_type;
- uint16_t offset = 0;
-
- sw_rule.next_index = indx_sw_rule->next_index;
- sw_rule.tbl_entry = indx_sw_rule->tbl_entry;
-
- if (entry < ipv4_cache->table_entries) {
- tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_addr;
-
- memcpy(&tbl_ptr[entry],
- &sw_rule,
- sizeof(struct ipa_nat_indx_tbl_rule));
- } else {
- tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_expn_addr;
-
- memcpy(&tbl_ptr[entry - ipv4_cache->table_entries],
- &sw_rule,
- sizeof(struct ipa_nat_indx_tbl_rule));
- }
-
- /* Update the next field of previous entry on collosion */
- if (IPA_NAT_INVALID_NAT_ENTRY != prev_entry) {
- if (prev_entry < ipv4_cache->table_entries) {
- tbl_type = IPA_NAT_INDX_TBL;
- tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_addr;
- } else {
- tbl_type = IPA_NAT_INDEX_EXPN_TBL;
- /* tbp_ptr is already pointing to expansion table
- no need to initialize it */
- prev_entry = prev_entry - ipv4_cache->table_entries;
- }
-
- offset = ipa_nati_get_index_entry_offset(ipv4_cache, tbl_type, prev_entry);
- offset += IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
-
- IPADBG("Updating next index field of index table on collosion using dma()\n");
- ipa_nati_write_next_index(tbl_index, tbl_type, entry, offset);
- }
-
- return;
-}
-
-int ipa_nati_post_ipv4_dma_cmd(uint8_t tbl_indx,
- uint16_t entry)
-{
- struct ipa_ioc_nat_dma_cmd *cmd;
- struct ipa_nat_rule *tbl_ptr;
- uint32_t offset = ipv4_nat_cache.ip4_tbl[tbl_indx].tbl_addr_offset;
- int ret = 0;
-
- cmd = (struct ipa_ioc_nat_dma_cmd *)
- malloc(sizeof(struct ipa_ioc_nat_dma_cmd)+
- sizeof(struct ipa_ioc_nat_dma_one));
- if (NULL == cmd) {
- IPAERR("unable to allocate memory\n");
- return -ENOMEM;
- }
-
- if (entry < ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries) {
- tbl_ptr =
- (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr;
-
- cmd->dma[0].table_index = tbl_indx;
- cmd->dma[0].base_addr = IPA_NAT_BASE_TBL;
- cmd->dma[0].data = IPA_NAT_FLAG_ENABLE_BIT_MASK;
-
- cmd->dma[0].offset = (char *)&tbl_ptr[entry] - (char *)tbl_ptr;
- cmd->dma[0].offset += IPA_NAT_RULE_FLAG_FIELD_OFFSET;
- } else {
- tbl_ptr =
- (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_expn_rules_addr;
- entry = entry - ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
-
- cmd->dma[0].table_index = tbl_indx;
- cmd->dma[0].base_addr = IPA_NAT_EXPN_TBL;
- cmd->dma[0].data = IPA_NAT_FLAG_ENABLE_BIT_MASK;
-
- cmd->dma[0].offset = (char *)&tbl_ptr[entry] - (char *)tbl_ptr;
- cmd->dma[0].offset += IPA_NAT_RULE_FLAG_FIELD_OFFSET;
- cmd->dma[0].offset += offset;
- }
-
- cmd->entries = 1;
- if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd)) {
- perror("ipa_nati_post_ipv4_dma_cmd(): ioctl error value");
- IPAERR("unable to call dma icotl\n");
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- ret = -EIO;
- goto fail;
- }
- IPADBG("posted IPA_IOC_NAT_DMA to kernel successfully during add operation\n");
-
-
-fail:
- free(cmd);
-
- return ret;
-}
-
-
-int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
- uint32_t rule_hdl)
-{
- uint8_t expn_tbl;
- uint16_t tbl_entry;
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- del_type rule_pos;
- uint8_t tbl_indx = (uint8_t)(tbl_hdl - 1);
- int ret;
-
- /* Parse the rule handle */
- ipa_nati_parse_ipv4_rule_hdl(tbl_indx, (uint16_t)rule_hdl,
- &expn_tbl, &tbl_entry);
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_entry) {
- IPAERR("Invalid Rule Entry\n");
- ret = -EINVAL;
- goto fail;
- }
-
- if (pthread_mutex_lock(&nat_mutex) != 0) {
- ret = -1;
- goto mutex_lock_error;
- }
-
- IPADBG("Delete below rule\n");
- IPADBG("tbl_entry:%d expn_tbl:%d\n", tbl_entry, expn_tbl);
-
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
- if (!tbl_ptr->valid) {
- IPAERR("invalid table handle\n");
- ret = -EINVAL;
- if (pthread_mutex_unlock(&nat_mutex) != 0)
- goto mutex_unlock_error;
- goto fail;
- }
-
- ipa_nati_find_rule_pos(tbl_ptr, expn_tbl,
- tbl_entry, &rule_pos);
- IPADBG("rule_pos:%d\n", rule_pos);
-
- if (ipa_nati_post_del_dma_cmd(tbl_indx, tbl_entry,
- expn_tbl, rule_pos)) {
- ret = -EINVAL;
- if (pthread_mutex_unlock(&nat_mutex) != 0)
- goto mutex_unlock_error;
- goto fail;
- }
-
- ipa_nati_del_dead_ipv4_head_nodes(tbl_indx);
-
- /* Reset rule_id_array entry */
- ipv4_nat_cache.ip4_tbl[tbl_indx].rule_id_array[rule_hdl-1] =
- IPA_NAT_INVALID_NAT_ENTRY;
-
-#ifdef NAT_DUMP
- IPADBG("Dumping Table after deleting rule\n");
- ipa_nat_dump_ipv4_table(tbl_hdl);
-#endif
-
- if (pthread_mutex_unlock(&nat_mutex) != 0) {
- ret = -1;
- goto mutex_unlock_error;
- }
-
- return 0;
-
-mutex_lock_error:
- IPAERR("unable to lock the nat mutex\n");
- return ret;
-
-mutex_unlock_error:
- IPAERR("unable to unlock the nat mutex\n");
-
-fail:
- return ret;
-}
-
-void ReorderCmds(struct ipa_ioc_nat_dma_cmd *cmd, int size)
-{
- int indx_tbl_start = 0, cnt, cnt1;
- struct ipa_ioc_nat_dma_cmd *tmp;
-
- IPADBG("called ReorderCmds() with entries :%d\n", cmd->entries);
-
- for (cnt = 0; cnt < cmd->entries; cnt++) {
- if (cmd->dma[cnt].base_addr == IPA_NAT_INDX_TBL ||
- cmd->dma[cnt].base_addr == IPA_NAT_INDEX_EXPN_TBL) {
- indx_tbl_start = cnt;
+ if(!memcmp((pdns + i), &zero_test, sizeof(ipa_nat_pdn_entry)))
+ {
+ IPADBG("found an empty pdn in index %d\n", i);
break;
}
}
- if (indx_tbl_start == 0) {
- IPADBG("Reorder not needed\n");
- return;
+ if(i >= (IPA_MAX_PDN_NUM - 1))
+ {
+ IPAERR("couldn't find an empty entry while num is %d\n",
+ num_pdns);
+ return -EIO;
}
- tmp = (struct ipa_ioc_nat_dma_cmd *)malloc(size);
- if (tmp == NULL) {
- IPAERR("unable to allocate memory\n");
- return;
+ pdn_data.pdn_index = i;
+ pdn_data.public_ip = pdn_info->public_ip;
+ pdn_data.src_metadata = pdn_info->src_metadata;
+ pdn_data.dst_metadata = pdn_info->dst_metadata;
+
+ ret = ipa_nati_modify_pdn(&pdn_data);
+ if(!ret)
+ {
+ num_pdns++;
+ *pdn_index = i;
+ IPADBG("modify num_pdns (%d)\n", num_pdns);
}
- cnt1 = 0;
- tmp->entries = cmd->entries;
- for (cnt = indx_tbl_start; cnt < cmd->entries; cnt++) {
- tmp->dma[cnt1] = cmd->dma[cnt];
- cnt1++;
- }
-
- for (cnt = 0; cnt < indx_tbl_start; cnt++) {
- tmp->dma[cnt1] = cmd->dma[cnt];
- cnt1++;
- }
-
- memset(cmd, 0, size);
- memcpy(cmd, tmp, size);
- free(tmp);
-
- return;
+ return ret;
}
-int ipa_nati_post_del_dma_cmd(uint8_t tbl_indx,
- uint16_t cur_tbl_entry,
- uint8_t expn_tbl,
- del_type rule_pos)
+int ipa_nati_get_pdn_cnt(void)
{
+ return num_pdns;
+}
-#define MAX_DMA_ENTRIES_FOR_DEL 3
+int ipa_nati_dealloc_pdn(
+ uint8_t pdn_index)
+{
+ ipa_nat_pdn_entry zero_test;
+ struct ipa_ioc_nat_pdn_entry pdn_data;
+ int ret;
- struct ipa_nat_ip4_table_cache *cache_ptr;
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- struct ipa_nat_rule *tbl_ptr;
- int ret = 0, size = 0;
+ IPADBG(" trying to deallocate PDN index %d\n", pdn_index);
- uint16_t indx_tbl_entry = IPA_NAT_INVALID_NAT_ENTRY;
- del_type indx_rule_pos;
-
- struct ipa_ioc_nat_dma_cmd *cmd;
- uint8_t no_of_cmds = 0;
-
- uint16_t prev_entry = IPA_NAT_INVALID_NAT_ENTRY;
- uint16_t next_entry = IPA_NAT_INVALID_NAT_ENTRY;
- uint16_t indx_next_entry = IPA_NAT_INVALID_NAT_ENTRY;
- uint16_t indx_next_next_entry = IPA_NAT_INVALID_NAT_ENTRY;
- uint16_t table_entry;
-
- size = sizeof(struct ipa_ioc_nat_dma_cmd)+
- (MAX_DMA_ENTRIES_FOR_DEL * sizeof(struct ipa_ioc_nat_dma_one));
-
- cmd = (struct ipa_ioc_nat_dma_cmd *)malloc(size);
- if (NULL == cmd) {
- IPAERR("unable to allocate memory\n");
- return -ENOMEM;
+ if(!num_pdns)
+ {
+ IPAERR("pdn table is already empty\n");
+ return -EIO;
}
- cache_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
- if (!expn_tbl) {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
- } else {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
+ memset(&zero_test, 0, sizeof(zero_test));
+
+ if(!memcmp((pdns + pdn_index), &zero_test, sizeof(ipa_nat_pdn_entry)))
+ {
+ IPAERR("pdn entry is a zero entry\n");
+ return -EIO;
}
+ IPADBG("PDN in index %d has ip 0x%X\n", pdn_index, pdns[pdn_index].public_ip);
- if (!Read16BitFieldValue(tbl_ptr[cur_tbl_entry].ip_cksm_enbl,
- ENABLE_FIELD)) {
- IPAERR("Deleting invalid(not enabled) rule\n");
+ pdn_data.pdn_index = pdn_index;
+ pdn_data.src_metadata = 0;
+ pdn_data.dst_metadata = 0;
+ pdn_data.public_ip = 0;
+
+ ret = ipa_nati_modify_pdn(&pdn_data);
+ if(ret)
+ {
+ IPAERR("failed modifying PDN\n");
+ return -EIO;
+ }
+
+ memset((pdns + pdn_index), 0, sizeof(ipa_nat_pdn_entry));
+
+ num_pdns--;
+
+ IPADBG("successfully removed pdn from index %d num_pdns %d\n", pdn_index, num_pdns);
+
+ return 0;
+}
+
+/*
+ * ----------------------------------------------------------------------------
+ * Previously public API functions, but have been hijacked (in
+ * ipa_nat_statemach.c). The new definitions that replaced these, now
+ * call the functions below.
+ * ----------------------------------------------------------------------------
+ */
+int ipa_NATI_post_ipv4_init_cmd(
+ uint32_t tbl_hdl )
+{
+ enum ipa3_nat_mem_in nmi;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ int ret;
+
+ IPADBG("In\n");
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
ret = -EINVAL;
- goto fail;
+ goto bail;
}
- indx_tbl_entry =
- Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
- SW_SPEC_PARAM_INDX_TBL_ENTRY_FIELD);
+ IPADBG("nmi(%s)\n", ipa3_nat_mem_in_as_str(nmi));
- /* ================================================
- Base Table rule Deletion
- ================================================*/
- /* Just delete the current rule by disabling the flag field */
- if (IPA_NAT_DEL_TYPE_ONLY_ONE == rule_pos) {
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
- cmd->dma[no_of_cmds].data = IPA_NAT_FLAG_DISABLE_BIT_MASK;
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr,
- cur_tbl_entry);
- cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_FLAG_FIELD_OFFSET;
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
}
- /* Just update the protocol field to invalid */
- else if (IPA_NAT_DEL_TYPE_HEAD == rule_pos) {
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
- cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_PROTO_FIELD_VALUE;
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr,
- cur_tbl_entry);
- cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_PROTO_FIELD_OFFSET;
-
- IPADBG("writing invalid proto: 0x%x\n", cmd->dma[no_of_cmds].data);
+ if ( ! nat_cache_ptr->table_cnt ) {
+ IPAERR("No initialized table in NAT cache\n");
+ ret = -EINVAL;
+ goto unlock;
}
- /*
- Update the previous entry of next_index field value
- with current entry next_index field value
- */
- else if (IPA_NAT_DEL_TYPE_MIDDLE == rule_pos) {
- prev_entry =
- Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
- SW_SPEC_PARAM_PREV_INDEX_FIELD);
+ nat_table = &nat_cache_ptr->ip4_tbl[tbl_hdl - 1];
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].data =
- Read16BitFieldValue(tbl_ptr[cur_tbl_entry].nxt_indx_pub_port,
- NEXT_INDEX_FIELD);
+ ret = ipa_nati_post_ipv4_init_cmd(
+ nat_cache_ptr,
+ nat_table,
+ tbl_hdl - 1,
+ true);
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
- if (prev_entry >= cache_ptr->table_entries) {
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_EXPN_TBL;
- prev_entry -= cache_ptr->table_entries;
- }
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr, prev_entry);
-
- cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_NEXT_FIELD_OFFSET;
+ if (ret) {
+ IPAERR("unable to post nat_init command Error %d\n", ret);
+ goto unlock;
}
- /*
- Reset the previous entry of next_index field with 0
- */
- else if (IPA_NAT_DEL_TYPE_LAST == rule_pos) {
- prev_entry =
- Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
- SW_SPEC_PARAM_PREV_INDEX_FIELD);
+ active_nat_cache_ptr = nat_cache_ptr;
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_NAT_ENTRY;
-
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
- if (prev_entry >= cache_ptr->table_entries) {
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_EXPN_TBL;
- prev_entry -= cache_ptr->table_entries;
- }
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr, prev_entry);
-
- cmd->dma[no_of_cmds].offset += IPA_NAT_RULE_NEXT_FIELD_OFFSET;
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
}
- /* ================================================
- Base Table rule Deletion End
- ================================================*/
-
- /* ================================================
- Index Table rule Deletion
- ================================================*/
- ipa_nati_find_index_rule_pos(cache_ptr,
- indx_tbl_entry,
- &indx_rule_pos);
- IPADBG("Index table entry: 0x%x\n", indx_tbl_entry);
- IPADBG("and position: %d\n", indx_rule_pos);
- if (indx_tbl_entry >= cache_ptr->table_entries) {
- indx_tbl_entry -= cache_ptr->table_entries;
- indx_tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
- } else {
- indx_tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
- }
-
- /* Just delete the current rule by resetting nat_table_index field to 0 */
- if (IPA_NAT_DEL_TYPE_ONLY_ONE == indx_rule_pos) {
- no_of_cmds++;
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_NAT_ENTRY;
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_index_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr,
- indx_tbl_entry);
-
- cmd->dma[no_of_cmds].offset +=
- IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET;
- }
-
- /* copy the next entry values to current entry */
- else if (IPA_NAT_DEL_TYPE_HEAD == indx_rule_pos) {
- next_entry =
- Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- next_entry -= cache_ptr->table_entries;
-
- no_of_cmds++;
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
- cmd->dma[no_of_cmds].table_index = tbl_indx;
-
- /* Copy the nat_table_index field value of next entry */
- indx_tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
- cmd->dma[no_of_cmds].data =
- Read16BitFieldValue(indx_tbl_ptr[next_entry].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD);
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_index_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr,
- indx_tbl_entry);
-
- cmd->dma[no_of_cmds].offset +=
- IPA_NAT_INDEX_RULE_NAT_INDEX_FIELD_OFFSET;
-
- /* Copy the next_index field value of next entry */
- no_of_cmds++;
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].data =
- Read16BitFieldValue(indx_tbl_ptr[next_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_index_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr, indx_tbl_entry);
-
- cmd->dma[no_of_cmds].offset +=
- IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
- indx_next_entry = next_entry;
- }
-
- /*
- Update the previous entry of next_index field value
- with current entry next_index field value
- */
- else if (IPA_NAT_DEL_TYPE_MIDDLE == indx_rule_pos) {
- prev_entry = cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index;
-
- no_of_cmds++;
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].data =
- Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
- if (prev_entry >= cache_ptr->table_entries) {
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDEX_EXPN_TBL;
- prev_entry -= cache_ptr->table_entries;
- }
-
- IPADBG("prev_entry: %d update with cur next_index: %d\n",
- prev_entry, cmd->dma[no_of_cmds].data);
- IPADBG("prev_entry: %d exist in table_type:%d\n",
- prev_entry, cmd->dma[no_of_cmds].base_addr);
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_index_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr, prev_entry);
-
- cmd->dma[no_of_cmds].offset +=
- IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
- }
-
- /* Reset the previous entry next_index field with 0 */
- else if (IPA_NAT_DEL_TYPE_LAST == indx_rule_pos) {
- prev_entry = cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index;
-
- no_of_cmds++;
- cmd->dma[no_of_cmds].table_index = tbl_indx;
- cmd->dma[no_of_cmds].data = IPA_NAT_INVALID_NAT_ENTRY;
-
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
- if (prev_entry >= cache_ptr->table_entries) {
- cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDEX_EXPN_TBL;
- prev_entry -= cache_ptr->table_entries;
- }
-
- IPADBG("Reseting prev_entry: %d next_index\n", prev_entry);
- IPADBG("prev_entry: %d exist in table_type:%d\n",
- prev_entry, cmd->dma[no_of_cmds].base_addr);
-
- cmd->dma[no_of_cmds].offset =
- ipa_nati_get_index_entry_offset(cache_ptr,
- cmd->dma[no_of_cmds].base_addr, prev_entry);
-
- cmd->dma[no_of_cmds].offset +=
- IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
- }
-
- /* ================================================
- Index Table rule Deletion End
- ================================================*/
- cmd->entries = no_of_cmds + 1;
-
- if (cmd->entries > 1) {
- ReorderCmds(cmd, size);
- }
- if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd)) {
- perror("ipa_nati_post_del_dma_cmd(): ioctl error value");
- IPAERR("unable to post cmd\n");
- IPADBG("ipa fd %d\n", ipv4_nat_cache.ipa_fd);
- ret = -EIO;
- goto fail;
- }
-
- /* if entry exist in IPA_NAT_DEL_TYPE_MIDDLE of list
- Update the previous entry in sw specific parameters
- */
- if (IPA_NAT_DEL_TYPE_MIDDLE == rule_pos) {
- /* Retrieve the current entry prev_entry value */
- prev_entry =
- Read16BitFieldValue(tbl_ptr[cur_tbl_entry].sw_spec_params,
- SW_SPEC_PARAM_PREV_INDEX_FIELD);
-
- /* Retrieve the next entry */
- next_entry =
- Read16BitFieldValue(tbl_ptr[cur_tbl_entry].nxt_indx_pub_port,
- NEXT_INDEX_FIELD);
-
- next_entry -= cache_ptr->table_entries;
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
-
- /* copy the current entry prev_entry value to next entry*/
- UpdateSwSpecParams(&tbl_ptr[next_entry],
- IPA_NAT_SW_PARAM_PREV_INDX_BYTE,
- prev_entry);
- }
-
- /* Reset the other field values of current delete entry
- In case of IPA_NAT_DEL_TYPE_HEAD, don't reset */
- if (IPA_NAT_DEL_TYPE_HEAD != rule_pos) {
- memset(&tbl_ptr[cur_tbl_entry], 0, sizeof(struct ipa_nat_rule));
- }
-
- if (indx_rule_pos == IPA_NAT_DEL_TYPE_HEAD) {
-
- /* Update next next entry previous value to current
- entry as we moved the next entry values
- to current entry */
- indx_next_next_entry =
- Read16BitFieldValue(indx_tbl_ptr[indx_next_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- if (indx_next_next_entry != 0 &&
- indx_next_next_entry >= cache_ptr->table_entries) {
-
- IPADBG("Next Next entry: %d\n", indx_next_next_entry);
- indx_next_next_entry -= cache_ptr->table_entries;
-
- IPADBG("Updating entry: %d prev index to: %d\n",
- indx_next_next_entry, indx_tbl_entry);
- cache_ptr->index_expn_table_meta[indx_next_next_entry].prev_index =
- indx_tbl_entry;
- }
-
- /* Now reset the next entry as we copied
- the next entry to current entry */
- IPADBG("Resetting, index table entry(Proper): %d\n",
- (cache_ptr->table_entries + indx_next_entry));
-
- /* This resets both table entry and next index values */
- indx_tbl_ptr[indx_next_entry].tbl_entry_nxt_indx = 0;
-
- /*
- In case of IPA_NAT_DEL_TYPE_HEAD, update the sw specific parameters
- (index table entry) of base table entry
- */
- indx_tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
- table_entry =
- Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD);
-
- if (table_entry >= cache_ptr->table_entries) {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
- table_entry -= cache_ptr->table_entries;
- } else {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
- }
-
- UpdateSwSpecParams(&tbl_ptr[table_entry],
- IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE,
- indx_tbl_entry);
- } else {
- /* Update the prev_entry value (in index_expn_table_meta)
- for the next_entry in list with current entry prev_entry value
- */
- if (IPA_NAT_DEL_TYPE_MIDDLE == indx_rule_pos) {
- next_entry =
- Read16BitFieldValue(indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
-
- if (next_entry >= cache_ptr->table_entries) {
- next_entry -= cache_ptr->table_entries;
- }
-
- cache_ptr->index_expn_table_meta[next_entry].prev_index =
- cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index;
-
- cache_ptr->index_expn_table_meta[indx_tbl_entry].prev_index =
- IPA_NAT_INVALID_NAT_ENTRY;
- }
-
- IPADBG("At, indx_tbl_entry value: %d\n", indx_tbl_entry);
- IPADBG("At, indx_tbl_entry member address: %p\n",
- &indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx);
-
- indx_tbl_ptr[indx_tbl_entry].tbl_entry_nxt_indx = 0;
-
- }
-
-fail:
- free(cmd);
+bail:
+ IPADBG("Out\n");
return ret;
}
-void ipa_nati_find_index_rule_pos(
- struct ipa_nat_ip4_table_cache *cache_ptr,
- uint16_t tbl_entry,
- del_type *rule_pos)
+/**
+ * ipa_NATI_add_ipv4_tbl() - Adds a new IPv4 NAT table
+ * @ct: [in] the desired cache type to use
+ * @public_ip_addr: [in] public IPv4 address
+ * @number_of_entries: [in] number of NAT entries
+ * @table_handle: [out] handle of new IPv4 NAT table
+ *
+ * This function creates new IPv4 NAT table and posts IPv4 NAT init command to HW
+ *
+ * Returns: 0 On Success, negative on failure
+ */
+int ipa_NATI_add_ipv4_tbl(
+ enum ipa3_nat_mem_in nmi,
+ uint32_t public_ip_addr,
+ uint16_t number_of_entries,
+ uint32_t* tbl_hdl )
{
- struct ipa_nat_indx_tbl_rule *tbl_ptr;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ int ret = 0;
- if (tbl_entry >= cache_ptr->table_entries) {
- tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
+ IPADBG("In\n");
- tbl_entry -= cache_ptr->table_entries;
- if (Read16BitFieldValue(tbl_ptr[tbl_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED) == IPA_NAT_INVALID_NAT_ENTRY) {
- *rule_pos = IPA_NAT_DEL_TYPE_LAST;
- } else {
- *rule_pos = IPA_NAT_DEL_TYPE_MIDDLE;
- }
- } else {
- tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_addr;
+ *tbl_hdl = 0;
- if (Read16BitFieldValue(tbl_ptr[tbl_entry].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED) == IPA_NAT_INVALID_NAT_ENTRY) {
- *rule_pos = IPA_NAT_DEL_TYPE_ONLY_ONE;
- } else {
- *rule_pos = IPA_NAT_DEL_TYPE_HEAD;
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ IPADBG("nmi(%s)\n", ipa3_nat_mem_in_as_str(nmi));
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ nat_cache_ptr->nmi = nmi;
+
+ if (nat_cache_ptr->table_cnt >= IPA_NAT_MAX_IP4_TBLS) {
+ IPAERR(
+ "Can't add addition NAT table. Maximum %d tables allowed\n",
+ IPA_NAT_MAX_IP4_TBLS);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ if ( ! nat_cache_ptr->ipa_desc ) {
+ nat_cache_ptr->ipa_desc = ipa_descriptor_open();
+ if ( nat_cache_ptr->ipa_desc == NULL ) {
+ IPAERR("failed to open IPA driver file descriptor\n");
+ ret = -EIO;
+ goto unlock;
}
}
+
+ nat_table = &nat_cache_ptr->ip4_tbl[nat_cache_ptr->table_cnt];
+
+ ret = ipa_nati_create_table(
+ nat_cache_ptr,
+ nat_table,
+ public_ip_addr,
+ number_of_entries,
+ nat_cache_ptr->table_cnt);
+
+ if (ret) {
+ IPAERR("unable to create nat table Error: %d\n", ret);
+ goto failed_create_table;
+ }
+
+ /*
+ * Initialize the ipa hw with nat table dimensions
+ */
+ ret = ipa_nati_post_ipv4_init_cmd(
+ nat_cache_ptr,
+ nat_table,
+ nat_cache_ptr->table_cnt,
+ false);
+
+ if (ret) {
+ IPAERR("unable to post nat_init command Error %d\n", ret);
+ goto failed_post_init_cmd;
+ }
+
+ active_nat_cache_ptr = nat_cache_ptr;
+
+ /*
+ * Store the initial public ip address in the cached pdn table
+ * this is backward compatible for pre IPAv4 versions, we will
+ * always use this ip as the single PDN address
+ */
+ pdns[0].public_ip = public_ip_addr;
+ num_pdns = 1;
+
+ nat_cache_ptr->table_cnt++;
+
+ /*
+ * Return table handle
+ */
+ *tbl_hdl = MAKE_TBL_HDL(nat_cache_ptr->table_cnt, nmi);
+
+ IPADBG("tbl_hdl value(0x%08X) num_pdns (%d)\n", *tbl_hdl, num_pdns);
+
+ goto unlock;
+
+failed_post_init_cmd:
+ ipa_nati_destroy_table(nat_cache_ptr, nat_table);
+
+failed_create_table:
+ if (!nat_cache_ptr->table_cnt) {
+ ipa_descriptor_close(nat_cache_ptr->ipa_desc);
+ nat_cache_ptr->ipa_desc = NULL;
+ }
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = -EPERM;
+ goto bail;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
}
-void ipa_nati_find_rule_pos(struct ipa_nat_ip4_table_cache *cache_ptr,
- uint8_t expn_tbl,
- uint16_t tbl_entry,
- del_type *rule_pos)
+int ipa_NATI_del_ipv4_table(
+ uint32_t tbl_hdl )
{
- struct ipa_nat_rule *tbl_ptr;
+ enum ipa3_nat_mem_in nmi;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
- if (expn_tbl) {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
- if (Read16BitFieldValue(tbl_ptr[tbl_entry].nxt_indx_pub_port,
- NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY) {
- *rule_pos = IPA_NAT_DEL_TYPE_LAST;
- } else {
- *rule_pos = IPA_NAT_DEL_TYPE_MIDDLE;
- }
- } else {
- tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
- if (Read16BitFieldValue(tbl_ptr[tbl_entry].nxt_indx_pub_port,
- NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY) {
- *rule_pos = IPA_NAT_DEL_TYPE_ONLY_ONE;
- } else {
- *rule_pos = IPA_NAT_DEL_TYPE_HEAD;
+ int ret;
+
+ IPADBG("In\n");
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ IPADBG("nmi(%s)\n", ipa3_nat_mem_in_as_str(nmi));
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ nat_table = &nat_cache_ptr->ip4_tbl[tbl_hdl - 1];
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ if (! nat_table->mem_desc.valid) {
+ IPAERR("invalid table handle %d\n", tbl_hdl);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ ret = ipa_nati_destroy_table(nat_cache_ptr, nat_table);
+ if (ret) {
+ IPAERR("unable to delete NAT table with handle %d\n", tbl_hdl);
+ goto unlock;
+ }
+
+ if (! --nat_cache_ptr->table_cnt) {
+ ipa_descriptor_close(nat_cache_ptr->ipa_desc);
+ nat_cache_ptr->ipa_desc = NULL;
+ }
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_NATI_query_timestamp(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t* time_stamp )
+{
+ enum ipa3_nat_mem_in nmi;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ struct ipa_nat_rule* rule_ptr;
+
+ char buf[1024];
+ int ret;
+
+ IPADBG("In\n");
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ IPADBG("nmi(%s)\n", ipa3_nat_mem_in_as_str(nmi));
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ nat_table = &nat_cache_ptr->ip4_tbl[tbl_hdl - 1];
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ if ( ! nat_table->mem_desc.valid ) {
+ IPAERR("invalid table handle %d\n", tbl_hdl);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ ret = ipa_table_get_entry(
+ &nat_table->table,
+ rule_hdl,
+ (void**) &rule_ptr,
+ NULL);
+
+ if (ret) {
+ IPAERR("Unable to retrive the entry with "
+ "handle=%u in NAT table with handle=0x%08X\n",
+ rule_hdl, tbl_hdl);
+ goto unlock;
+ }
+
+ *buf = '\0';
+ IPADBG("rule_hdl(0x%08X) -> %s\n",
+ rule_hdl,
+ prep_nat_rule_4print(rule_ptr, buf, sizeof(buf)));
+
+ *time_stamp = rule_ptr->time_stamp;
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_NATI_add_ipv4_rule(
+ uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule* clnt_rule,
+ uint32_t* rule_hdl)
+{
+ uint32_t cmd_sz =
+ sizeof(struct ipa_ioc_nat_dma_cmd) +
+ (MAX_DMA_ENTRIES_FOR_ADD * sizeof(struct ipa_ioc_nat_dma_one));
+ char cmd_buf[cmd_sz];
+ struct ipa_ioc_nat_dma_cmd* cmd =
+ (struct ipa_ioc_nat_dma_cmd*) cmd_buf;
+
+ enum ipa3_nat_mem_in nmi;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ struct ipa_nat_rule* rule;
+
+ uint16_t new_entry_index;
+ uint16_t new_index_tbl_entry_index;
+ uint32_t new_entry_handle;
+ char buf[1024];
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ memset(cmd_buf, 0, sizeof(cmd_buf));
+
+ if ( ! VALID_TBL_HDL(tbl_hdl) ||
+ ! clnt_rule ||
+ ! rule_hdl )
+ {
+ IPAERR("Bad arg: tbl_hdl(0x%08X) and/or clnt_rule(%p) and/or rule_hdl(%p)\n",
+ tbl_hdl, clnt_rule, rule_hdl);
+ ret = -EINVAL;
+ goto done;
+ }
+
+ *rule_hdl = 0;
+
+ IPADBG("tbl_hdl(0x%08X)\n", tbl_hdl);
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto done;
+ }
+
+ *buf = '\0';
+ IPADBG("tbl_hdl(0x%08X) nmi(%s) %s\n",
+ tbl_hdl,
+ ipa3_nat_mem_in_as_str(nmi),
+ prep_nat_ipv4_rule_4print(clnt_rule, buf, sizeof(buf)));
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ nat_table = &nat_cache_ptr->ip4_tbl[tbl_hdl - 1];
+
+ if (clnt_rule->protocol == IPAHAL_NAT_INVALID_PROTOCOL) {
+ IPAERR("invalid parameter protocol=%d\n", clnt_rule->protocol);
+ ret = -EINVAL;
+ goto done;
+ }
+
+ /*
+ * Verify that the rule's PDN is valid
+ */
+ if (clnt_rule->pdn_index >= IPA_MAX_PDN_NUM ||
+ pdns[clnt_rule->pdn_index].public_ip == 0) {
+ IPAERR("invalid parameters, pdn index %d, public ip = 0x%X\n",
+ clnt_rule->pdn_index, pdns[clnt_rule->pdn_index].public_ip);
+ ret = -EINVAL;
+ goto done;
+ }
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto done;
+ }
+
+ if (! nat_table->mem_desc.valid) {
+ IPAERR("invalid table handle %d\n", tbl_hdl);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ new_entry_index = dst_hash(
+ nat_cache_ptr,
+ pdns[clnt_rule->pdn_index].public_ip,
+ clnt_rule->target_ip,
+ clnt_rule->target_port,
+ clnt_rule->public_port,
+ clnt_rule->protocol,
+ nat_table->table.table_entries - 1);
+
+ ret = ipa_table_add_entry(
+ &nat_table->table,
+ (void*) clnt_rule,
+ &new_entry_index,
+ &new_entry_handle,
+ cmd);
+
+ if (ret) {
+ IPAERR("Failed to add a new NAT entry\n");
+ goto unlock;
+ }
+
+ new_index_tbl_entry_index =
+ src_hash(clnt_rule->private_ip,
+ clnt_rule->private_port,
+ clnt_rule->target_ip,
+ clnt_rule->target_port,
+ clnt_rule->protocol,
+ nat_table->table.table_entries - 1);
+
+ ret = ipa_table_add_entry(
+ &nat_table->index_table,
+ (void*) &new_entry_index,
+ &new_index_tbl_entry_index,
+ NULL,
+ cmd);
+
+ if (ret) {
+ IPAERR("failed to add a new NAT index entry\n");
+ goto fail_add_index_entry;
+ }
+
+ rule = ipa_table_get_entry_by_index(
+ &nat_table->table,
+ new_entry_index);
+
+ if (rule == NULL) {
+ IPAERR("Failed to retrieve the entry in index %d for NAT table with handle=%d\n",
+ new_entry_index, tbl_hdl);
+ ret = -EPERM;
+ goto bail;
+ }
+
+ rule->indx_tbl_entry = new_index_tbl_entry_index;
+
+ rule->redirect = clnt_rule->redirect;
+ rule->enable = clnt_rule->enable;
+ rule->time_stamp = clnt_rule->time_stamp;
+
+ IPADBG("new entry:%d, new index entry: %d\n",
+ new_entry_index, new_index_tbl_entry_index);
+
+ IPADBG("rule_hdl(0x%08X) -> %s\n",
+ new_entry_handle,
+ prep_nat_rule_4print(rule, buf, sizeof(buf)));
+
+ ret = ipa_nati_post_ipv4_dma_cmd(nat_cache_ptr, cmd);
+
+ if (ret) {
+ IPAERR("unable to post dma command\n");
+ goto bail;
+ }
+
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = -EPERM;
+ goto done;
+ }
+
+ *rule_hdl = new_entry_handle;
+
+ IPADBG("rule_hdl value(%u)\n", *rule_hdl);
+
+ goto done;
+
+bail:
+ ipa_table_erase_entry(&nat_table->index_table, new_index_tbl_entry_index);
+
+fail_add_index_entry:
+ ipa_table_erase_entry(&nat_table->table, new_entry_index);
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex))
+ IPAERR("unable to unlock the nat mutex\n");
+done:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_NATI_del_ipv4_rule(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl )
+{
+ uint32_t cmd_sz =
+ sizeof(struct ipa_ioc_nat_dma_cmd) +
+ (MAX_DMA_ENTRIES_FOR_DEL * sizeof(struct ipa_ioc_nat_dma_one));
+ char cmd_buf[cmd_sz];
+ struct ipa_ioc_nat_dma_cmd* cmd =
+ (struct ipa_ioc_nat_dma_cmd*) cmd_buf;
+
+ enum ipa3_nat_mem_in nmi;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ struct ipa_nat_rule* table_rule;
+ struct ipa_nat_indx_tbl_rule* index_table_rule;
+
+ ipa_table_iterator table_iterator;
+ ipa_table_iterator index_table_iterator;
+
+ uint16_t index;
+ char buf[1024];
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ memset(cmd_buf, 0, sizeof(cmd_buf));
+
+ IPADBG("tbl_hdl(0x%08X) rule_hdl(%u)\n", tbl_hdl, rule_hdl);
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto done;
+ }
+
+ IPADBG("nmi(%s)\n", ipa3_nat_mem_in_as_str(nmi));
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ nat_table = &nat_cache_ptr->ip4_tbl[tbl_hdl - 1];
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("Unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto done;
+ }
+
+ if (! nat_table->mem_desc.valid) {
+ IPAERR("Invalid table handle 0x%08X\n", tbl_hdl);
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ ret = ipa_table_get_entry(
+ &nat_table->table,
+ rule_hdl,
+ (void**) &table_rule,
+ &index);
+
+ if (ret) {
+ IPAERR("Unable to retrive the entry with rule_hdl=%u\n", rule_hdl);
+ goto unlock;
+ }
+
+ *buf = '\0';
+ IPADBG("rule_hdl(0x%08X) -> %s\n",
+ rule_hdl,
+ prep_nat_rule_4print(table_rule, buf, sizeof(buf)));
+
+ ret = ipa_table_iterator_init(
+ &table_iterator,
+ &nat_table->table,
+ table_rule,
+ index);
+
+ if (ret) {
+ IPAERR("Unable to create iterator which points to the "
+ "entry %u in NAT table with handle=0x%08X\n",
+ index, tbl_hdl);
+ goto unlock;
+ }
+
+ index = table_rule->indx_tbl_entry;
+
+ index_table_rule = (struct ipa_nat_indx_tbl_rule*)
+ ipa_table_get_entry_by_index(&nat_table->index_table, index);
+
+ if (index_table_rule == NULL) {
+ IPAERR("Unable to retrieve the entry in index %u "
+ "in NAT index table with handle=0x%08X\n",
+ index, tbl_hdl);
+ ret = -EPERM;
+ goto unlock;
+ }
+
+ ret = ipa_table_iterator_init(
+ &index_table_iterator,
+ &nat_table->index_table,
+ index_table_rule,
+ index);
+
+ if (ret) {
+ IPAERR("Unable to create iterator which points to the "
+ "entry %u in NAT index table with handle=0x%08X\n",
+ index, tbl_hdl);
+ goto unlock;
+ }
+
+ ipa_table_create_delete_command(
+ &nat_table->index_table,
+ cmd,
+ &index_table_iterator);
+
+ if (ipa_table_iterator_is_head_with_tail(&index_table_iterator)) {
+
+ ipa_nati_copy_second_index_entry_to_head(
+ nat_table, &index_table_iterator, cmd);
+ /*
+ * Iterate to the next entry which should be deleted
+ */
+ ret = ipa_table_iterator_next(
+ &index_table_iterator, &nat_table->index_table);
+
+ if (ret) {
+ IPAERR("Unable to move the iterator to the next entry "
+ "(points to the entry %u in NAT index table)\n",
+ index);
+ goto unlock;
}
}
+
+ ipa_table_create_delete_command(
+ &nat_table->table,
+ cmd,
+ &table_iterator);
+
+ ret = ipa_nati_post_ipv4_dma_cmd(nat_cache_ptr, cmd);
+
+ if (ret) {
+ IPAERR("Unable to post dma command\n");
+ goto unlock;
+ }
+
+ if (! ipa_table_iterator_is_head_with_tail(&table_iterator)) {
+ /* The entry can be deleted */
+ uint8_t is_prev_empty =
+ (table_iterator.prev_entry != NULL &&
+ ((struct ipa_nat_rule*)table_iterator.prev_entry)->protocol ==
+ IPAHAL_NAT_INVALID_PROTOCOL);
+
+ ipa_table_delete_entry(
+ &nat_table->table, &table_iterator, is_prev_empty);
+ }
+
+ ipa_table_delete_entry(
+ &nat_table->index_table,
+ &index_table_iterator,
+ FALSE);
+
+ if (index_table_iterator.curr_index >= nat_table->index_table.table_entries)
+ nat_table->index_expn_table_meta[
+ index_table_iterator.curr_index - nat_table->index_table.table_entries].
+ prev_index = IPA_TABLE_INVALID_ENTRY;
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("Unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+done:
+ IPADBG("Out\n");
+
+ return ret;
}
-void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx)
+/*
+ * ----------------------------------------------------------------------------
+ * New function to get sram size.
+ * ----------------------------------------------------------------------------
+ */
+int ipa_nati_get_sram_size(
+ uint32_t* size_ptr)
{
- struct ipa_nat_rule *tbl_ptr;
- uint16_t cnt;
+ struct ipa_nat_cache* nat_cache_ptr =
+ &ipv4_nat_cache[IPA_NAT_MEM_IN_SRAM];
+ struct ipa_nat_in_sram_info nat_sram_info;
+ int ret;
- tbl_ptr =
- (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr;
+ IPADBG("In\n");
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
- cnt++) {
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
- if (Read8BitFieldValue(tbl_ptr[cnt].ts_proto,
- PROTOCOL_FIELD) == IPAHAL_NAT_INVALID_PROTOCOL
- &&
- Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
- NEXT_INDEX_FIELD) == IPA_NAT_INVALID_NAT_ENTRY) {
- /* Delete the IPA_NAT_DEL_TYPE_HEAD node */
- IPADBG("deleting the dead node 0x%x\n", cnt);
- memset(&tbl_ptr[cnt], 0, sizeof(struct ipa_nat_rule));
+ if ( ! nat_cache_ptr->ipa_desc ) {
+ nat_cache_ptr->ipa_desc = ipa_descriptor_open();
+ if ( nat_cache_ptr->ipa_desc == NULL ) {
+ IPAERR("failed to open IPA driver file descriptor\n");
+ ret = -EIO;
+ goto unlock;
}
- } /* end of for loop */
+ }
- return;
+ memset(&nat_sram_info, 0, sizeof(nat_sram_info));
+
+ ret = ioctl(nat_cache_ptr->ipa_desc->fd,
+ IPA_IOC_GET_NAT_IN_SRAM_INFO,
+ &nat_sram_info);
+
+ if (ret) {
+ IPAERR("NAT_IN_SRAM_INFO ioctl failure %d on IPA fd %d\n",
+ ret, nat_cache_ptr->ipa_desc->fd);
+ goto unlock;
+ }
+
+ if ( (*size_ptr = nat_sram_info.sram_mem_available_for_nat) == 0 )
+ {
+ IPAERR("sram_mem_available_for_nat is zero\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
}
-
-/* ========================================================
- Debug functions
- ========================================================*/
-#ifdef NAT_DUMP
-void ipa_nat_dump_ipv4_table(uint32_t tbl_hdl)
+/*
+ * ----------------------------------------------------------------------------
+ * Utility functions
+ * ----------------------------------------------------------------------------
+ */
+static int print_nat_rule(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
{
- struct ipa_nat_rule *tbl_ptr;
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- int cnt;
- uint8_t atl_one = 0;
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
- IPAERR("invalid table handle passed\n");
+ char buf[1024];
+
+ struct ipa_nat_rule* rule_ptr =
+ (struct ipa_nat_rule*) record_ptr;
+
+ UNUSED(meta_record_ptr);
+ UNUSED(meta_record_index);
+
+ if ( rule_ptr->protocol == IPA_NAT_INVALID_PROTO_FIELD_VALUE_IN_RULE )
+ {
+ goto bail;
+ }
+
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
+
+ nmi++; /* stop compiler usage warning */
+
+ printf(" %s %s (0x%04X) (0x%08X) -> %s\n",
+ (table_ptr->nmi == IPA_NAT_MEM_IN_DDR) ? "DDR" : "SRAM",
+ (is_expn_tbl) ? "EXP " : "BASE",
+ record_index,
+ rule_hdl,
+ prep_nat_rule_4print(rule_ptr, buf, sizeof(buf)));
+
+ fflush(stdout);
+
+ *((bool*) arb_data_ptr) = false;
+
+bail:
+ return 0;
+}
+
+static int print_meta_data(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
+{
+ struct ipa_nat_indx_tbl_rule* index_entry =
+ (struct ipa_nat_indx_tbl_rule *) record_ptr;
+
+ struct ipa_nat_indx_tbl_meta_info* mi_ptr =
+ (struct ipa_nat_indx_tbl_meta_info*) meta_record_ptr;
+
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
+
+ UNUSED(meta_record_index);
+
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
+
+ nmi++; /* stop compiler usage warning */
+
+ if ( mi_ptr )
+ {
+ printf(" %s %s Entry_Index=0x%04X Table_Entry=0x%04X -> "
+ "Prev_Index=0x%04X Next_Index=0x%04X\n",
+ (table_ptr->nmi == IPA_NAT_MEM_IN_DDR) ? "DDR" : "SRAM",
+ (is_expn_tbl) ? "EXP " : "BASE",
+ record_index,
+ index_entry->tbl_entry,
+ mi_ptr->prev_index,
+ index_entry->next_index);
+ }
+ else
+ {
+ printf(" %s %s Entry_Index=0x%04X Table_Entry=0x%04X -> "
+ "Prev_Index=0xXXXX Next_Index=0x%04X\n",
+ (table_ptr->nmi == IPA_NAT_MEM_IN_DDR) ? "DDR" : "SRAM",
+ (is_expn_tbl) ? "EXP " : "BASE",
+ record_index,
+ index_entry->tbl_entry,
+ index_entry->next_index);
+ }
+
+ fflush(stdout);
+
+ *((bool*) arb_data_ptr) = false;
+
+ return 0;
+}
+
+void ipa_nat_dump_ipv4_table(
+ uint32_t tbl_hdl )
+{
+ bool empty;
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
return;
}
- /* Print ipv4 rules */
- IPADBG("Dumping ipv4 active rules:\n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_rules_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- atl_one = 1;
- ipa_nati_print_rule(&tbl_ptr[cnt], cnt);
- }
- }
- if (!atl_one) {
- IPADBG("No active base rules, total: %d\n",
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries);
- }
- atl_one = 0;
+ printf("\nIPv4 active rules:\n");
- /* Print ipv4 expansion rules */
- IPADBG("Dumping ipv4 active expansion rules:\n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_expn_rules_addr;
- for (cnt = 0;
- cnt <= ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- atl_one = 1;
- ipa_nati_print_rule(&tbl_ptr[cnt],
- (cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries));
- }
- }
- if (!atl_one) {
- IPADBG("No active base expansion rules, total: %d\n",
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries);
- }
- atl_one = 0;
+ empty = true;
- /* Print ipv4 index rules */
- IPADBG("Dumping ipv4 index active rules:\n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- atl_one = 1;
- ipa_nati_print_index_rule(&indx_tbl_ptr[cnt], cnt, 0);
- }
- }
- if (!atl_one) {
- IPADBG("No active index table rules, total:%d\n",
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries);
- }
- atl_one = 0;
+ ipa_nati_walk_ipv4_tbl(tbl_hdl, USE_NAT_TABLE, print_nat_rule, &empty);
-
- /* Print ipv4 index expansion rules */
- IPADBG("Dumping ipv4 index expansion active rules:\n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_expn_addr;
- for (cnt = 0;
- cnt <= ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- atl_one = 1;
- ipa_nati_print_index_rule(&indx_tbl_ptr[cnt],
- (cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries),
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_expn_table_meta[cnt].prev_index);
- }
+ if ( empty )
+ {
+ printf(" Empty\n");
}
- if (!atl_one) {
- IPADBG("No active index expansion rules, total:%d\n",
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries);
- }
- atl_one = 0;
+ printf("\nExpansion Index Table Meta Data:\n");
+
+ empty = true;
+
+ ipa_nati_walk_ipv4_tbl(tbl_hdl, USE_INDEX_TABLE, print_meta_data, &empty);
+
+ if ( empty )
+ {
+ printf(" Empty\n");
+ }
+
+ printf("\n");
+
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ }
}
-void ipa_nati_print_rule(
- struct ipa_nat_rule *param,
- uint32_t rule_id)
+int ipa_NATI_clear_ipv4_tbl(
+ uint32_t tbl_hdl )
{
- struct ipa_nat_sw_rule sw_rule;
- memcpy(&sw_rule, param, sizeof(sw_rule));
- uint32_t ip_addr;
+ enum ipa3_nat_mem_in nmi;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ int ret = 0;
- IPADUMP("rule-id:%d ", rule_id);
- ip_addr = sw_rule.target_ip;
- IPADUMP("Trgt-IP:%d.%d.%d.%d ",
- ((ip_addr & 0xFF000000) >> 24), ((ip_addr & 0x00FF0000) >> 16),
- ((ip_addr & 0x0000FF00) >> 8), ((ip_addr & 0x000000FF)));
+ IPADBG("In\n");
- IPADUMP("Trgt-Port:%d Priv-Port:%d ", sw_rule.target_port, sw_rule.private_port);
+ BREAK_TBL_HDL(tbl_hdl, nmi, tbl_hdl);
- ip_addr = sw_rule.private_ip;
- IPADUMP("Priv-IP:%d.%d.%d.%d ",
- ((ip_addr & 0xFF000000) >> 24), ((ip_addr & 0x00FF0000) >> 16),
- ((ip_addr & 0x0000FF00) >> 8), ((ip_addr & 0x000000FF)));
-
- IPADUMP("Pub-Port:%d Nxt-indx:%d ", sw_rule.public_port, sw_rule.next_index);
- IPADUMP("IP-cksm-delta:0x%x En-bit:0x%x ", sw_rule.ip_chksum, sw_rule.enable);
- IPADUMP("TS:0x%x Proto:0x%x ", sw_rule.time_stamp, sw_rule.protocol);
- IPADUMP("Prv-indx:%d indx_tbl_entry:%d ", sw_rule.prev_index, sw_rule.indx_tbl_entry);
- IPADUMP("Tcp-udp-cksum-delta:0x%x", sw_rule.tcp_udp_chksum);
- IPADUMP("\n");
- return;
-}
-
-void ipa_nati_print_index_rule(
- struct ipa_nat_indx_tbl_rule *param,
- uint32_t rule_id, uint16_t prev_indx)
-{
- struct ipa_nat_sw_indx_tbl_rule sw_rule;
- memcpy(&sw_rule, param, sizeof(sw_rule));
-
- IPADUMP("rule-id:%d Table_entry:%d Next_index:%d, prev_indx:%d",
- rule_id, sw_rule.tbl_entry, sw_rule.next_index, prev_indx);
- IPADUMP("\n");
- return;
-}
-
-int ipa_nati_query_nat_rules(
- uint32_t tbl_hdl,
- nat_table_type tbl_type)
-{
- struct ipa_nat_rule *tbl_ptr;
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- int cnt = 0, ret = 0;
-
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
- IPAERR("invalid table handle passed\n");
- return ret;
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto bail;
}
- /* Print ipv4 rules */
- if (tbl_type == IPA_NAT_BASE_TBL) {
- IPADBG("Counting ipv4 active rules:\n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].ipv4_rules_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- ret++;
- }
- }
- if (!ret) {
- IPADBG("No active base rules\n");
- }
+ IPADBG("nmi(%s)\n", ipa3_nat_mem_in_as_str(nmi));
- IPADBG("Number of active base rules: %d\n", ret);
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ if (pthread_mutex_lock(&nat_mutex)) {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
}
- /* Print ipv4 expansion rules */
- if (tbl_type == IPA_NAT_EXPN_TBL) {
- IPADBG("Counting ipv4 active expansion rules:\n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].ipv4_expn_rules_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- ret++;
- }
- }
- if (!ret) {
- IPADBG("No active base expansion rules\n");
- }
-
- IPADBG("Number of active base expansion rules: %d\n", ret);
+ if ( ! nat_cache_ptr->table_cnt ) {
+ IPAERR("No initialized table in NAT cache\n");
+ ret = -EINVAL;
+ goto unlock;
}
- /* Print ipv4 index rules */
- if (tbl_type == IPA_NAT_INDX_TBL) {
- IPADBG("Counting ipv4 index active rules:\n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].index_table_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- ret++;
- }
- }
- if (!ret) {
- IPADBG("No active index table rules\n");
- }
+ nat_table = &nat_cache_ptr->ip4_tbl[tbl_hdl - 1];
- IPADBG("Number of active index table rules: %d\n", ret);
+ ipa_table_reset(&nat_table->table);
+ nat_table->table.cur_tbl_cnt =
+ nat_table->table.cur_expn_tbl_cnt = 0;
+
+ ipa_table_reset(&nat_table->index_table);
+ nat_table->index_table.cur_tbl_cnt =
+ nat_table->index_table.cur_expn_tbl_cnt = 0;
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex)) {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
}
- /* Print ipv4 index expansion rules */
- if (tbl_type == IPA_NAT_INDEX_EXPN_TBL) {
- IPADBG("Counting ipv4 index expansion active rules:\n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].index_table_expn_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- ret++;
- }
- }
-
- if (!ret)
- IPADBG("No active index expansion rules\n");
-
- IPADBG("Number of active index expansion rules: %d\n", ret);
- }
+bail:
+ IPADBG("Out\n");
return ret;
}
-#endif
+
+int ipa_nati_copy_ipv4_tbl(
+ uint32_t src_tbl_hdl,
+ uint32_t dst_tbl_hdl,
+ ipa_table_walk_cb copy_cb )
+{
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! copy_cb )
+ {
+ IPAERR("copy_cb is null\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ if (pthread_mutex_lock(&nat_mutex))
+ {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ /*
+ * Clear the destination table...
+ */
+ ret = ipa_NATI_clear_ipv4_tbl(dst_tbl_hdl);
+
+ if ( ret == 0 )
+ {
+ uintptr_t dth = dst_tbl_hdl;
+ /*
+ * Now walk the source table and pass the valid records to the
+ * user's copy callback...
+ */
+ ret = ipa_NATI_walk_ipv4_tbl(
+ src_tbl_hdl, USE_NAT_TABLE, copy_cb, (void*) dth);
+
+ if ( ret != 0 )
+ {
+ IPAERR("ipa_table_walk returned non-zero (%d)\n", ret);
+ goto unlock;
+ }
+ }
+
+unlock:
+ if (pthread_mutex_unlock(&nat_mutex))
+ {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_NATI_walk_ipv4_tbl(
+ uint32_t tbl_hdl,
+ WhichTbl2Use which,
+ ipa_table_walk_cb walk_cb,
+ void* arb_data_ptr )
+{
+ enum ipa3_nat_mem_in nmi;
+ uint32_t broken_tbl_hdl;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ ipa_table* ipa_tbl_ptr;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_TBL_HDL(tbl_hdl) ||
+ ! VALID_WHICHTBL2USE(which) ||
+ ! walk_cb )
+ {
+ IPAERR("Bad arg: tbl_hdl(0x%08X) and/or WhichTbl2Use(%u) and/or walk_cb(%p)\n",
+ tbl_hdl, which, walk_cb);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ if ( pthread_mutex_lock(&nat_mutex) )
+ {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ /*
+ * Now walk the table and pass the valid records to the user's
+ * walk callback...
+ */
+ BREAK_TBL_HDL(tbl_hdl, nmi, broken_tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) )
+ {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ if ( ! nat_cache_ptr->table_cnt )
+ {
+ IPAERR("No initialized table in NAT cache\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ nat_table = &nat_cache_ptr->ip4_tbl[broken_tbl_hdl - 1];
+
+ ipa_tbl_ptr =
+ (which == USE_NAT_TABLE) ?
+ &nat_table->table :
+ &nat_table->index_table;
+
+ ret = ipa_table_walk(ipa_tbl_ptr, 0, WHEN_SLOT_FILLED, walk_cb, arb_data_ptr);
+
+ if ( ret != 0 )
+ {
+ IPAERR("ipa_table_walk returned non-zero (%d)\n", ret);
+ goto unlock;
+ }
+
+unlock:
+ if ( pthread_mutex_unlock(&nat_mutex) )
+ {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+typedef struct
+{
+ WhichTbl2Use which;
+ uint32_t tot_for_avg;
+ ipa_nati_tbl_stats* stats_ptr;
+} chain_stat_help;
+
+static int gen_chain_stats(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
+{
+ chain_stat_help* csh_ptr = (chain_stat_help*) arb_data_ptr;
+
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
+
+ uint32_t chain_len = 0;
+
+ UNUSED(record_index);
+ UNUSED(meta_record_ptr);
+ UNUSED(meta_record_index);
+
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
+
+ if ( is_expn_tbl )
+ {
+ nmi++; /* stop compiler usage warning */
+ return 1;
+ }
+
+ if ( csh_ptr->which == USE_NAT_TABLE )
+ {
+ struct ipa_nat_rule* list_elem_ptr =
+ (struct ipa_nat_rule*) record_ptr;
+
+ if ( list_elem_ptr->next_index )
+ {
+ chain_len = 1;
+
+ while ( list_elem_ptr->next_index )
+ {
+ chain_len++;
+
+ list_elem_ptr = (struct ipa_nat_rule*)
+ GOTO_REC(table_ptr, list_elem_ptr->next_index);
+ }
+ }
+ }
+ else
+ {
+ struct ipa_nat_indx_tbl_rule* list_elem_ptr =
+ (struct ipa_nat_indx_tbl_rule*) record_ptr;
+
+ if ( list_elem_ptr->next_index )
+ {
+ chain_len = 1;
+
+ while ( list_elem_ptr->next_index )
+ {
+ chain_len++;
+
+ list_elem_ptr = (struct ipa_nat_indx_tbl_rule*)
+ GOTO_REC(table_ptr, list_elem_ptr->next_index);
+ }
+ }
+ }
+
+ if ( chain_len )
+ {
+ csh_ptr->stats_ptr->tot_chains += 1;
+
+ csh_ptr->tot_for_avg += chain_len;
+
+ if ( csh_ptr->stats_ptr->min_chain_len == 0 )
+ {
+ csh_ptr->stats_ptr->min_chain_len = chain_len;
+ }
+ else
+ {
+ csh_ptr->stats_ptr->min_chain_len =
+ min(csh_ptr->stats_ptr->min_chain_len, chain_len);
+ }
+
+ csh_ptr->stats_ptr->max_chain_len =
+ max(csh_ptr->stats_ptr->max_chain_len, chain_len);
+ }
+
+ return 0;
+}
+
+int ipa_NATI_ipv4_tbl_stats(
+ uint32_t tbl_hdl,
+ ipa_nati_tbl_stats* nat_stats_ptr,
+ ipa_nati_tbl_stats* idx_stats_ptr )
+{
+ enum ipa3_nat_mem_in nmi;
+ uint32_t broken_tbl_hdl;
+ struct ipa_nat_cache* nat_cache_ptr;
+ struct ipa_nat_ip4_table_cache* nat_table;
+ ipa_table* ipa_tbl_ptr;
+
+ chain_stat_help csh;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_TBL_HDL(tbl_hdl) ||
+ ! nat_stats_ptr ||
+ ! idx_stats_ptr )
+ {
+ IPAERR("Bad arg: "
+ "tbl_hdl(0x%08X) and/or "
+ "nat_stats_ptr(%p) and/or "
+ "idx_stats_ptr(%p)\n",
+ tbl_hdl,
+ nat_stats_ptr,
+ idx_stats_ptr );
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ if ( pthread_mutex_lock(&nat_mutex) )
+ {
+ IPAERR("unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ memset(nat_stats_ptr, 0, sizeof(ipa_nati_tbl_stats));
+ memset(idx_stats_ptr, 0, sizeof(ipa_nati_tbl_stats));
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, broken_tbl_hdl);
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) )
+ {
+ IPAERR("Bad cache type argument passed\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ nat_cache_ptr = &ipv4_nat_cache[nmi];
+
+ if ( ! nat_cache_ptr->table_cnt )
+ {
+ IPAERR("No initialized table in NAT cache\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ nat_table = &nat_cache_ptr->ip4_tbl[broken_tbl_hdl - 1];
+
+ /*
+ * Gather NAT table stats...
+ */
+ ipa_tbl_ptr = &nat_table->table;
+
+ nat_stats_ptr->nmi = nmi;
+
+ nat_stats_ptr->tot_base_ents = ipa_tbl_ptr->table_entries;
+ nat_stats_ptr->tot_expn_ents = ipa_tbl_ptr->expn_table_entries;
+ nat_stats_ptr->tot_ents =
+ nat_stats_ptr->tot_base_ents + nat_stats_ptr->tot_expn_ents;
+
+ nat_stats_ptr->tot_base_ents_filled = ipa_tbl_ptr->cur_tbl_cnt;
+ nat_stats_ptr->tot_expn_ents_filled = ipa_tbl_ptr->cur_expn_tbl_cnt;
+
+ memset(&csh, 0, sizeof(chain_stat_help));
+
+ csh.which = USE_NAT_TABLE;
+ csh.stats_ptr = nat_stats_ptr;
+
+ ret = ipa_table_walk(
+ ipa_tbl_ptr, 0, WHEN_SLOT_FILLED, gen_chain_stats, &csh);
+
+ if ( ret < 0 )
+ {
+ IPAERR("Error gathering chain stats\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ if ( csh.tot_for_avg && nat_stats_ptr->tot_chains )
+ {
+ nat_stats_ptr->avg_chain_len =
+ (float) csh.tot_for_avg / (float) nat_stats_ptr->tot_chains;
+ }
+
+ /*
+ * Now lets gather index table stats...
+ */
+ ipa_tbl_ptr = &nat_table->index_table;
+
+ idx_stats_ptr->nmi = nmi;
+
+ idx_stats_ptr->tot_base_ents = ipa_tbl_ptr->table_entries;
+ idx_stats_ptr->tot_expn_ents = ipa_tbl_ptr->expn_table_entries;
+ idx_stats_ptr->tot_ents =
+ idx_stats_ptr->tot_base_ents + idx_stats_ptr->tot_expn_ents;
+
+ idx_stats_ptr->tot_base_ents_filled = ipa_tbl_ptr->cur_tbl_cnt;
+ idx_stats_ptr->tot_expn_ents_filled = ipa_tbl_ptr->cur_expn_tbl_cnt;
+
+ memset(&csh, 0, sizeof(chain_stat_help));
+
+ csh.which = USE_INDEX_TABLE;
+ csh.stats_ptr = idx_stats_ptr;
+
+ ret = ipa_table_walk(
+ ipa_tbl_ptr, 0, WHEN_SLOT_FILLED, gen_chain_stats, &csh);
+
+ if ( ret < 0 )
+ {
+ IPAERR("Error gathering chain stats\n");
+ ret = -EINVAL;
+ goto unlock;
+ }
+
+ if ( csh.tot_for_avg && idx_stats_ptr->tot_chains )
+ {
+ idx_stats_ptr->avg_chain_len =
+ (float) csh.tot_for_avg / (float) idx_stats_ptr->tot_chains;
+ }
+
+ ret = 0;
+
+unlock:
+ if ( pthread_mutex_unlock(&nat_mutex) )
+ {
+ IPAERR("unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_vote_clock(
+ enum ipa_app_clock_vote_type vote_type )
+{
+ struct ipa_nat_cache* nat_cache_ptr =
+ &ipv4_nat_cache[IPA_NAT_MEM_IN_SRAM];
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! nat_cache_ptr->ipa_desc ) {
+ nat_cache_ptr->ipa_desc = ipa_descriptor_open();
+ if ( nat_cache_ptr->ipa_desc == NULL ) {
+ IPAERR("failed to open IPA driver file descriptor\n");
+ ret = -EIO;
+ goto bail;
+ }
+ }
+
+ ret = ioctl(nat_cache_ptr->ipa_desc->fd,
+ IPA_IOC_APP_CLOCK_VOTE,
+ vote_type);
+
+ if (ret) {
+ IPAERR("APP_CLOCK_VOTE ioctl failure %d on IPA fd %d\n",
+ ret, nat_cache_ptr->ipa_desc->fd);
+ goto bail;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
diff --git a/ipanat/src/ipa_nat_logi.c b/ipanat/src/ipa_nat_logi.c
deleted file mode 100644
index b829b78..0000000
--- a/ipanat/src/ipa_nat_logi.c
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-Copyright (c) 2013, 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.
-*/
-/*!
- @file
- IPACM_log.cpp
-
- @brief
- This file implements the IPAM log functionality.
-
- @Author
- Skylar Chang
-
-*/
-#include "ipa_nat_logi.h"
-#include <stdlib.h>
-#include <unistd.h>
-
-void log_nat_message(char *msg)
-{
- return;
-}
-
-
diff --git a/ipanat/src/ipa_nat_map.cpp b/ipanat/src/ipa_nat_map.cpp
new file mode 100644
index 0000000..d2bcf54
--- /dev/null
+++ b/ipanat/src/ipa_nat_map.cpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2019-2020 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 <map>
+#include <iterator>
+
+#include "ipa_nat_utils.h"
+
+#include "ipa_nat_map.h"
+
+static std::map<uint32_t, uint32_t> map_array[MAP_NUM_MAX];
+
+/******************************************************************************/
+
+int ipa_nat_map_add(
+ ipa_which_map which,
+ uint32_t key,
+ uint32_t val )
+{
+ int ret_val = 0;
+
+ std::pair<std::map<uint32_t, uint32_t>::iterator, bool> ret;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_IPA_USE_MAP(which) )
+ {
+ IPAERR("Bad arg which(%u)\n", which);
+ ret_val = -1;
+ goto bail;
+ }
+
+ IPADBG("[%s] key(%u) -> val(%u)\n",
+ ipa_which_map_as_str(which), key, val);
+
+ ret = map_array[which].insert(std::pair<uint32_t, uint32_t>(key, val));
+
+ if ( ret.second == false )
+ {
+ IPAERR("[%s] key(%u) already exists in map\n",
+ ipa_which_map_as_str(which),
+ key);
+ ret_val = -1;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret_val;
+}
+
+/******************************************************************************/
+
+int ipa_nat_map_find(
+ ipa_which_map which,
+ uint32_t key,
+ uint32_t* val_ptr )
+{
+ int ret_val = 0;
+
+ std::map<uint32_t, uint32_t>::iterator it;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_IPA_USE_MAP(which) )
+ {
+ IPAERR("Bad arg which(%u)\n", which);
+ ret_val = -1;
+ goto bail;
+ }
+
+ IPADBG("[%s] key(%u)\n",
+ ipa_which_map_as_str(which), key);
+
+ it = map_array[which].find(key);
+
+ if ( it == map_array[which].end() )
+ {
+ IPAERR("[%s] key(%u) not found in map\n",
+ ipa_which_map_as_str(which),
+ key);
+ ret_val = -1;
+ }
+ else
+ {
+ if ( val_ptr )
+ {
+ *val_ptr = it->second;
+ IPADBG("[%s] key(%u) -> val(%u)\n",
+ ipa_which_map_as_str(which),
+ key, *val_ptr);
+ }
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret_val;
+}
+
+/******************************************************************************/
+
+int ipa_nat_map_del(
+ ipa_which_map which,
+ uint32_t key,
+ uint32_t* val_ptr )
+{
+ int ret_val = 0;
+
+ std::map<uint32_t, uint32_t>::iterator it;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_IPA_USE_MAP(which) )
+ {
+ IPAERR("Bad arg which(%u)\n", which);
+ ret_val = -1;
+ goto bail;
+ }
+
+ IPADBG("[%s] key(%u)\n",
+ ipa_which_map_as_str(which), key);
+
+ it = map_array[which].find(key);
+
+ if ( it == map_array[which].end() )
+ {
+ IPAERR("[%s] key(%u) not found in map\n",
+ ipa_which_map_as_str(which),
+ key);
+ ret_val = -1;
+ }
+ else
+ {
+ if ( val_ptr )
+ {
+ *val_ptr = it->second;
+ IPADBG("[%s] key(%u) -> val(%u)\n",
+ ipa_which_map_as_str(which),
+ key, *val_ptr);
+ }
+ map_array[which].erase(it);
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret_val;
+}
+
+int ipa_nat_map_clear(
+ ipa_which_map which )
+{
+ int ret_val = 0;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_IPA_USE_MAP(which) )
+ {
+ IPAERR("Bad arg which(%u)\n", which);
+ ret_val = -1;
+ goto bail;
+ }
+
+ map_array[which].clear();
+
+bail:
+ IPADBG("Out\n");
+
+ return ret_val;
+}
+
+int ipa_nat_map_dump(
+ ipa_which_map which )
+{
+ std::map<uint32_t, uint32_t>::iterator it;
+
+ int ret_val = 0;
+
+ IPADBG("In\n");
+
+ if ( ! VALID_IPA_USE_MAP(which) )
+ {
+ IPAERR("Bad arg which(%u)\n", which);
+ ret_val = -1;
+ goto bail;
+ }
+
+ printf("Dumping: %s\n", ipa_which_map_as_str(which));
+
+ for ( it = map_array[which].begin();
+ it != map_array[which].end();
+ it++ )
+ {
+ printf(" Key[%u|0x%08X] -> Value[%u|0x%08X]\n",
+ it->first,
+ it->first,
+ it->second,
+ it->second);
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret_val;
+}
diff --git a/ipanat/src/ipa_nat_statemach.c b/ipanat/src/ipa_nat_statemach.c
new file mode 100644
index 0000000..c65f88a
--- /dev/null
+++ b/ipanat/src/ipa_nat_statemach.c
@@ -0,0 +1,2477 @@
+/*
+ * Copyright (c) 2019-2020 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 <errno.h>
+#include <pthread.h>
+
+#include "ipa_nat_drv.h"
+#include "ipa_nat_drvi.h"
+
+#include "ipa_nat_map.h"
+
+#include "ipa_nat_statemach.h"
+
+#undef PRCNT_OF
+#define PRCNT_OF(v) \
+ ((.25) * (v))
+
+#undef CHOOSE_MEM_SUB
+#define CHOOSE_MEM_SUB() \
+ (nati_obj.curr_state == NATI_STATE_HYBRID) ? \
+ SRAM_SUB : \
+ DDR_SUB
+
+#undef CHOOSE_MAPS
+#define CHOOSE_MAPS(o2n, n2o) \
+ do { \
+ uint32_t sub = CHOOSE_MEM_SUB(); \
+ o2n = nati_obj.map_pairs[sub].orig2new_map; \
+ n2o = nati_obj.map_pairs[sub].new2orig_map; \
+ } while (0)
+
+#undef CHOOSE_CNTR
+#define CHOOSE_CNTR() \
+ &(nati_obj.tot_rules_in_table[CHOOSE_MEM_SUB()])
+
+#undef CHOOSE_SW_STATS
+#define CHOOSE_SW_STATS() \
+ &(nati_obj.sw_stats[CHOOSE_MEM_SUB()])
+
+/*
+ * BACKROUND INFORMATION
+ *
+ * As it relates to why this file exists...
+ *
+ * In the past, a NAT table API was presented to upper layer
+ * applications. Said API mananged low level details of NAT table
+ * creation, manipulation, and destruction. The API
+ * managed/manipulated NAT tables that lived exclusively in DDR. DDR
+ * based tables are fine, but lead to uneeded bus accesses to/from DDR
+ * by the IPA while doing its NAT duties. These accesses cause NAT to
+ * take longer than necessary.
+ *
+ * If the DDR bus accesses could be eliminated by storing the table in
+ * the IPA's internal memory (ie. SRAM), the IPA's IP V4 NAT could be
+ * sped up. This leads us to the following description of this file's
+ * intent.
+ *
+ * The purpose and intent of this file is to hijack the API described
+ * above, but in a way that allows the tables to live in both SRAM and
+ * DDR. The details of whether SRAM or DDR is being used is hidden
+ * from the application. More specifically, the API will allow the
+ * following to occur completely tranparent to the application using
+ * the API.
+ *
+ * (1) NAT tables can live exclusively in DDR (traditional and
+ * historically like before)
+ *
+ * (2) NAT tables can live simultaneously in SRAM and DDR. SRAM
+ * initially being used by the IPA, but both being kept in sync.
+ * When SRAM becomes too full, a switch to DDR will occur.
+ *
+ * (3) The same as (2) above, but after the switch to DDR occurs,
+ * we'll have the ability to switch back to SRAM if/when DDR
+ * table entry deletions take us to a small enough entry
+ * count. An entry count that when met, allows us to switch back
+ * using SRAM again.
+ *
+ * As above, all of these details will just magically happen unknown
+ * to the application using the API. The implementation is done via a
+ * state machine.
+ */
+
+/*
+ * The following will be used to keep state machine state for and
+ * between API calls...
+ */
+static ipa_nati_obj nati_obj = {
+ .prev_state = NATI_STATE_NULL,
+ .curr_state = NATI_STATE_DDR_ONLY,
+ .ddr_tbl_hdl = 0,
+ .sram_tbl_hdl = 0,
+ .tot_slots_in_sram = 0,
+ .back_to_sram_thresh = 0,
+ /*
+ * Remember:
+ * tot_rules_in_table[0] for ddr, and
+ * tot_rules_in_table[1] for sram
+ */
+ .tot_rules_in_table = { 0, 0 },
+ /*
+ * Remember:
+ * map_pairs[0] for ddr, and
+ * map_pairs[1] for sram
+ */
+ .map_pairs = { {MAP_NUM_00, MAP_NUM_01}, {MAP_NUM_02, MAP_NUM_03} },
+ /*
+ * Remember:
+ * sw_stats[0] for ddr, and
+ * sw_stats[1] for sram
+ */
+ .sw_stats = { {0, 0}, {0, 0} },
+};
+
+/*
+ * The following needed to protect nati_obj above, as well as a number
+ * of data stuctures within the file ipa_nat_drvi.c
+ */
+pthread_mutex_t nat_mutex;
+static bool nat_mutex_init = false;
+
+static inline int mutex_init(void)
+{
+ static pthread_mutexattr_t nat_mutex_attr;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ ret = pthread_mutexattr_init(&nat_mutex_attr);
+
+ if ( ret != 0 )
+ {
+ IPAERR("pthread_mutexattr_init() failed: ret(%d)\n", ret );
+ goto bail;
+ }
+
+ ret = pthread_mutexattr_settype(
+ &nat_mutex_attr, PTHREAD_MUTEX_RECURSIVE);
+
+ if ( ret != 0 )
+ {
+ IPAERR("pthread_mutexattr_settype() failed: ret(%d)\n",
+ ret );
+ goto bail;
+ }
+
+ ret = pthread_mutex_init(&nat_mutex, &nat_mutex_attr);
+
+ if ( ret != 0 )
+ {
+ IPAERR("pthread_mutex_init() failed: ret(%d)\n",
+ ret );
+ goto bail;
+ }
+
+ nat_mutex_init = true;
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/*
+ * ****************************************************************************
+ *
+ * HIJACKED API FUNCTIONS START HERE
+ *
+ * ****************************************************************************
+ */
+int ipa_nati_add_ipv4_tbl(
+ uint32_t public_ip_addr,
+ const char* mem_type_ptr,
+ uint16_t number_of_entries,
+ uint32_t* tbl_hdl)
+{
+ table_add_args args = {
+ .public_ip_addr = public_ip_addr,
+ .number_of_entries = number_of_entries,
+ .tbl_hdl = tbl_hdl,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ /*
+ * If first time in here, then let XML drive initial state...
+ */
+ if (nati_obj.prev_state == NATI_STATE_NULL)
+ {
+ SET_NATIOBJ_STATE(
+ &nati_obj,
+ mem_type_str_to_ipa_nati_state(mem_type_ptr));
+ }
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_ADD_TABLE, (void*) &args);
+
+ if ( ret == 0 )
+ {
+ IPADBG("tbl_hdl val(0x%08X)\n", *tbl_hdl);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_del_ipv4_table(
+ uint32_t tbl_hdl)
+{
+ table_del_args args = {
+ .tbl_hdl = tbl_hdl,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_DEL_TABLE, (void*) &args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_clear_ipv4_tbl(
+ uint32_t tbl_hdl )
+{
+ table_clear_args args = {
+ .tbl_hdl = tbl_hdl,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_CLR_TABLE, (void*) &args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_walk_ipv4_tbl(
+ uint32_t tbl_hdl,
+ WhichTbl2Use which,
+ ipa_table_walk_cb walk_cb,
+ void* arb_data_ptr )
+{
+ table_walk_args args = {
+ .tbl_hdl = tbl_hdl,
+ .which = which,
+ .walk_cb = walk_cb,
+ .arb_data_ptr = arb_data_ptr,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_WLK_TABLE, (void*) &args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_ipv4_tbl_stats(
+ uint32_t tbl_hdl,
+ ipa_nati_tbl_stats* nat_stats_ptr,
+ ipa_nati_tbl_stats* idx_stats_ptr )
+{
+ table_stats_args args = {
+ .tbl_hdl = tbl_hdl,
+ .nat_stats_ptr = nat_stats_ptr,
+ .idx_stats_ptr = idx_stats_ptr,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_TBL_STATS, (void*) &args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_add_ipv4_rule(
+ uint32_t tbl_hdl,
+ const ipa_nat_ipv4_rule* clnt_rule,
+ uint32_t* rule_hdl )
+{
+ rule_add_args args = {
+ .tbl_hdl = tbl_hdl,
+ .clnt_rule = clnt_rule,
+ .rule_hdl = rule_hdl,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_ADD_RULE, (void*) &args);
+
+ if ( ret == 0 )
+ {
+ IPADBG("rule_hdl val(%u)\n", *rule_hdl);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_del_ipv4_rule(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl )
+{
+ rule_del_args args = {
+ .tbl_hdl = tbl_hdl,
+ .rule_hdl = rule_hdl,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_DEL_RULE, (void*) &args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nati_query_timestamp(
+ uint32_t tbl_hdl,
+ uint32_t rule_hdl,
+ uint32_t* time_stamp)
+{
+ timestap_query_args args = {
+ .tbl_hdl = tbl_hdl,
+ .rule_hdl = rule_hdl,
+ .time_stamp = time_stamp,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_GET_TSTAMP, (void*) &args);
+
+ if ( ret == 0 )
+ {
+ IPADBG("time_stamp val(0x%08X)\n", *time_stamp);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_nat_switch_to(
+ enum ipa3_nat_mem_in nmi )
+{
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) || ! IN_HYBRID_STATE() )
+ {
+ IPAERR("Bad nmi(%s) and/or not in hybrid state\n",
+ ipa3_nat_mem_in_as_str(nmi));
+ ret = -1;
+ goto bail;
+ }
+
+ if ( (nmi == IPA_NAT_MEM_IN_SRAM && nati_obj.curr_state == NATI_STATE_HYBRID_DDR)
+ ||
+ (nmi == IPA_NAT_MEM_IN_DDR && nati_obj.curr_state == NATI_STATE_HYBRID) )
+ {
+ ret = ipa_nati_statemach(&nati_obj, NATI_TRIG_TBL_SWITCH, 0);
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+bool ipa_nat_is_sram_supported(void)
+{
+ return VALID_TBL_HDL(nati_obj.sram_tbl_hdl);
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: migrate_rule
+ *
+ * PARAMS:
+ *
+ * table_ptr (IN) The table being walked
+ *
+ * tbl_rule_hdl (IN) The nat rule's handle from the source table
+ *
+ * record_ptr (IN) The nat rule record from the source table
+ *
+ * record_index (IN) The record above's index in the table being walked
+ *
+ * meta_record_ptr (IN) If meta data in table, this will be it
+ *
+ * meta_record_index (IN) The record above's index in the table being walked
+ *
+ * arb_data_ptr (IN) The destination table handle
+ *
+ * DESCRIPTION:
+ *
+ * This routine is intended to copy records from a source table to a
+ * destination table.
+
+ * It is used in union with the ipa_nati_copy_ipv4_tbl() API call
+ * below.
+ *
+ * It is compatible with the ipa_table_walk() API.
+ *
+ * In the context of the ipa_nati_copy_ipv4_tbl(), the arguments
+ * passed in are as enumerated above.
+ *
+ * AN IMPORTANT NOTE ON RULE HANDLES WHEN IN MYBRID MODE
+ *
+ * The rule_hdl is used to find a rule in the nat table. It is, in
+ * effect, an index into the table. The applcation above us retains
+ * it for future manipulation of the rule in the table.
+ *
+ * In hybrid mode, a rule can and will move between SRAM and DDR.
+ * Because of this, its handle will change. The application has
+ * only the original handle and doesn't know of the new handle. A
+ * mapping, used in hybrid mode, will maintain a relationship
+ * between the original handle and the rule's current real handle...
+ *
+ * To help you get a mindset of how this is done:
+ *
+ * The original handle will map (point) to the new and new handle
+ * will map (point) back to original.
+ *
+ * NOTE WELL: There are two sets of maps. One for each memory type...
+ *
+ * RETURNS:
+ *
+ * Returns 0 on success, non-zero on failure
+ */
+static int migrate_rule(
+ ipa_table* table_ptr,
+ uint32_t tbl_rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
+{
+ struct ipa_nat_rule* nat_rule_ptr = (struct ipa_nat_rule*) record_ptr;
+ uint32_t dst_tbl_hdl = (uint32_t) arb_data_ptr;
+
+ ipa_nat_ipv4_rule v4_rule;
+
+ uint32_t orig_rule_hdl;
+ uint32_t new_rule_hdl;
+
+ uint32_t src_orig2new_map, src_new2orig_map;
+ uint32_t dst_orig2new_map, dst_new2orig_map;
+ uint32_t* cnt_ptr;
+
+ const char* mig_dir_ptr;
+
+ char buf[1024];
+ int ret;
+
+ UNUSED(buf);
+ UNUSED(record_index);
+ UNUSED(meta_record_ptr);
+ UNUSED(meta_record_index);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_mem_type(%s) tbl_rule_hdl(%u) -> %s\n",
+ ipa3_nat_mem_in_as_str(table_ptr->nmi),
+ tbl_rule_hdl,
+ prep_nat_rule_4print(nat_rule_ptr, buf, sizeof(buf)));
+
+ IPADBG("dst_tbl_hdl(0x%08X)\n", dst_tbl_hdl);
+
+ /*
+ * What is the type of the source table?
+ */
+ if ( table_ptr->nmi == IPA_NAT_MEM_IN_SRAM )
+ {
+ mig_dir_ptr = "SRAM -> DDR";
+
+ src_orig2new_map = nati_obj.map_pairs[SRAM_SUB].orig2new_map;
+ src_new2orig_map = nati_obj.map_pairs[SRAM_SUB].new2orig_map;
+
+ dst_orig2new_map = nati_obj.map_pairs[DDR_SUB].orig2new_map;
+ dst_new2orig_map = nati_obj.map_pairs[DDR_SUB].new2orig_map;
+
+ cnt_ptr = &(nati_obj.tot_rules_in_table[DDR_SUB]);
+ }
+ else
+ {
+ mig_dir_ptr = "DDR -> SRAM";
+
+ src_orig2new_map = nati_obj.map_pairs[DDR_SUB].orig2new_map;
+ src_new2orig_map = nati_obj.map_pairs[DDR_SUB].new2orig_map;
+
+ dst_orig2new_map = nati_obj.map_pairs[SRAM_SUB].orig2new_map;
+ dst_new2orig_map = nati_obj.map_pairs[SRAM_SUB].new2orig_map;
+
+ cnt_ptr = &(nati_obj.tot_rules_in_table[SRAM_SUB]);
+ }
+
+ src_orig2new_map++; /* to avoid compiler usage warning */
+
+ if ( nat_rule_ptr->protocol == IPA_NAT_INVALID_PROTO_FIELD_VALUE_IN_RULE )
+ {
+ IPADBG("%s: Special \"first rule in list\" case. "
+ "Rule's enabled bit on, but protocol implies deleted\n",
+ mig_dir_ptr);
+ ret = 0;
+ goto bail;
+ }
+
+ ret = ipa_nat_map_find(src_new2orig_map, tbl_rule_hdl, &orig_rule_hdl);
+
+ if ( ret != 0 )
+ {
+ IPAERR("%s: ipa_nat_map_find(src_new2orig_map) fail\n", mig_dir_ptr);
+ goto bail;
+ }
+
+ memset(&v4_rule, 0, sizeof(v4_rule));
+
+ v4_rule.private_ip = nat_rule_ptr->private_ip;
+ v4_rule.private_port = nat_rule_ptr->private_port;
+ v4_rule.protocol = nat_rule_ptr->protocol;
+ v4_rule.public_port = nat_rule_ptr->public_port;
+ v4_rule.target_ip = nat_rule_ptr->target_ip;
+ v4_rule.target_port = nat_rule_ptr->target_port;
+ v4_rule.pdn_index = nat_rule_ptr->pdn_index;
+ v4_rule.redirect = nat_rule_ptr->redirect;
+ v4_rule.enable = nat_rule_ptr->enable;
+ v4_rule.time_stamp = nat_rule_ptr->time_stamp;
+
+ ret = ipa_NATI_add_ipv4_rule(dst_tbl_hdl, &v4_rule, &new_rule_hdl);
+
+ if ( ret != 0 )
+ {
+ IPAERR("%s: ipa_NATI_add_ipv4_rule() fail\n", mig_dir_ptr);
+ goto bail;
+ }
+
+ (*cnt_ptr)++;
+
+ /*
+ * The following is needed to maintain the original handle and
+ * have it point to the new handle.
+ *
+ * Remember, original handle points to new and the new handle
+ * points back to original.
+ */
+ ret = ipa_nat_map_add(dst_orig2new_map, orig_rule_hdl, new_rule_hdl);
+
+ if ( ret != 0 )
+ {
+ IPAERR("%s: ipa_nat_map_add(dst_orig2new_map) fail\n", mig_dir_ptr);
+ goto bail;
+ }
+
+ ret = ipa_nat_map_add(dst_new2orig_map, new_rule_hdl, orig_rule_hdl);
+
+ if ( ret != 0 )
+ {
+ IPAERR("%s: ipa_nat_map_add(dst_new2orig_map) fail\n", mig_dir_ptr);
+ goto bail;
+ }
+
+ IPADBG("orig_rule_hdl(0x%08X) new_rule_hdl(0x%08X)\n",
+ orig_rule_hdl, new_rule_hdl);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/*
+ * ****************************************************************************
+ *
+ * STATE MACHINE CODE BEGINS HERE
+ *
+ * ****************************************************************************
+ */
+static int _smUndef(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr ); /* forward declaration */
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smDelTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the destruction of the DDR based NAT
+ * table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smDelTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_del_args* args = (table_del_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+
+ int ret;
+
+ UNUSED(nati_obj_ptr);
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X)\n", tbl_hdl);
+
+ ret = ipa_NATI_del_ipv4_table(tbl_hdl);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smAddDdrTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the creation of a NAT table in DDR.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smAddDdrTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_add_args* args = (table_add_args*) arb_data_ptr;
+
+ uint32_t public_ip_addr = args->public_ip_addr;
+ uint16_t number_of_entries = args->number_of_entries;
+ uint32_t* tbl_hdl_ptr = args->tbl_hdl;
+
+ int ret;
+
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("public_ip_addr(0x%08X) number_of_entries(%u) tbl_hdl_ptr(%p)\n",
+ public_ip_addr, number_of_entries, tbl_hdl_ptr);
+
+ ret = ipa_NATI_add_ipv4_tbl(
+ IPA_NAT_MEM_IN_DDR,
+ public_ip_addr,
+ number_of_entries,
+ &nati_obj_ptr->ddr_tbl_hdl);
+
+ if ( ret == 0 )
+ {
+ *tbl_hdl_ptr = nati_obj_ptr->ddr_tbl_hdl;
+
+ IPADBG("DDR table creation successful: tbl_hdl(0x%08X)\n",
+ *tbl_hdl_ptr);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smAddSramTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the creation of a NAT table in SRAM.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smAddSramTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_add_args* args = (table_add_args*) arb_data_ptr;
+
+ uint32_t public_ip_addr = args->public_ip_addr;
+ uint16_t number_of_entries = args->number_of_entries;
+ uint32_t* tbl_hdl_ptr = args->tbl_hdl;
+
+ uint32_t sram_size = 0;
+
+ int ret;
+
+ UNUSED(number_of_entries);
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("public_ip_addr(0x%08X) tbl_hdl_ptr(%p)\n",
+ public_ip_addr, tbl_hdl_ptr);
+
+ ret = ipa_nati_get_sram_size(&sram_size);
+
+ if ( ret == 0 )
+ {
+ ret = ipa_calc_num_sram_table_entries(
+ sram_size,
+ sizeof(struct ipa_nat_rule),
+ sizeof(struct ipa_nat_indx_tbl_rule),
+ (uint16_t*) &nati_obj_ptr->tot_slots_in_sram);
+
+ if ( ret == 0 )
+ {
+ nati_obj_ptr->back_to_sram_thresh =
+ PRCNT_OF(nati_obj_ptr->tot_slots_in_sram);
+
+ IPADBG("sram_size(%u or 0x%x) tot_slots_in_sram(%u) back_to_sram_thresh(%u)\n",
+ sram_size,
+ sram_size,
+ nati_obj_ptr->tot_slots_in_sram,
+ nati_obj_ptr->back_to_sram_thresh);
+
+ IPADBG("Voting clock on for sram table creation\n");
+
+ if ( (ret = ipa_nat_vote_clock(IPA_APP_CLK_VOTE)) != 0 )
+ {
+ IPAERR("Voting clock on failed\n");
+ goto done;
+ }
+
+ ret = ipa_NATI_add_ipv4_tbl(
+ IPA_NAT_MEM_IN_SRAM,
+ public_ip_addr,
+ nati_obj_ptr->tot_slots_in_sram,
+ &nati_obj_ptr->sram_tbl_hdl);
+
+ if ( ipa_nat_vote_clock(IPA_APP_CLK_DEVOTE) != 0 )
+ {
+ IPAWARN("Voting clock off failed\n");
+ }
+
+ if ( ret == 0 )
+ {
+ *tbl_hdl_ptr = nati_obj_ptr->sram_tbl_hdl;
+
+ IPADBG("SRAM table creation successful: tbl_hdl(0x%08X)\n",
+ *tbl_hdl_ptr);
+ }
+ }
+ }
+
+done:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smAddSramAndDdrTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the creation of NAT tables in both DDR
+ * and in SRAM.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smAddSramAndDdrTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_add_args* args = (table_add_args*) arb_data_ptr;
+
+ uint32_t public_ip_addr = args->public_ip_addr;
+ uint16_t number_of_entries = args->number_of_entries;
+ uint32_t* tbl_hdl_ptr = args->tbl_hdl;
+
+ uint32_t tbl_hdl;
+
+ int ret;
+
+ UNUSED(tbl_hdl_ptr);
+
+ IPADBG("In\n");
+
+ nati_obj_ptr->tot_rules_in_table[SRAM_SUB] = 0;
+ nati_obj_ptr->tot_rules_in_table[DDR_SUB] = 0;
+
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[SRAM_SUB].orig2new_map);
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[SRAM_SUB].new2orig_map);
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[DDR_SUB].orig2new_map);
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[DDR_SUB].new2orig_map);
+
+ ret = _smAddSramTbl(nati_obj_ptr, trigger, arb_data_ptr);
+
+ if ( ret == 0 )
+ {
+ if ( nati_obj_ptr->tot_slots_in_sram >= number_of_entries )
+ {
+ /*
+ * The number of slots in SRAM can accommodate what was
+ * being requested for DDR, hence no need to use DDR and
+ * we will continue by using SRAM only...
+ */
+ SET_NATIOBJ_STATE(nati_obj_ptr, NATI_STATE_SRAM_ONLY);
+ }
+ else
+ {
+ /*
+ * SRAM not big enough. Let's create secondary DDR based
+ * table...
+ */
+ table_add_args new_args = {
+ .public_ip_addr = public_ip_addr,
+ .number_of_entries = number_of_entries,
+ .tbl_hdl = &tbl_hdl, /* to protect app's table handle above */
+ };
+
+ ret = _smAddDdrTbl(nati_obj_ptr, trigger, (void*) &new_args);
+
+ if ( ret == 0 )
+ {
+ /*
+ * The following will tell the IPA to change focus to
+ * SRAM...
+ */
+ ret = ipa_nati_statemach(nati_obj_ptr, NATI_TRIG_GOTO_SRAM, 0);
+ }
+ }
+ }
+ else
+ {
+ /*
+ * SRAM table creation in HYBRID mode failed. Can we fall
+ * back to DDR only? We need to try and see what happens...
+ */
+ ret = _smAddDdrTbl(nati_obj_ptr, trigger, arb_data_ptr);
+
+ if ( ret == 0 )
+ {
+ SET_NATIOBJ_STATE(nati_obj_ptr, NATI_STATE_DDR_ONLY);
+ }
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smDelSramAndDdrTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the destruction of the SRAM, then DDR
+ * based NAT tables.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smDelSramAndDdrTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ int ret;
+
+ IPADBG("In\n");
+
+ nati_obj_ptr->tot_rules_in_table[SRAM_SUB] = 0;
+ nati_obj_ptr->tot_rules_in_table[DDR_SUB] = 0;
+
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[SRAM_SUB].orig2new_map);
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[SRAM_SUB].new2orig_map);
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[DDR_SUB].orig2new_map);
+ ipa_nat_map_clear(nati_obj_ptr->map_pairs[DDR_SUB].new2orig_map);
+
+ ret = _smDelTbl(nati_obj_ptr, trigger, arb_data_ptr);
+
+ if ( ret == 0 )
+ {
+ table_del_args new_args = {
+ .tbl_hdl = nati_obj_ptr->ddr_tbl_hdl,
+ };
+
+ ret = _smDelTbl(nati_obj_ptr, trigger, (void*) &new_args);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smClrTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the clearing of a table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smClrTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_clear_args* args = (table_clear_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+
+ enum ipa3_nat_mem_in nmi;
+ uint32_t unused_hdl, sub;
+
+ int ret;
+
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X)\n", tbl_hdl);
+
+ BREAK_TBL_HDL(tbl_hdl, nmi, unused_hdl);
+
+ unused_hdl++; /* to avoid compiler usage warning */
+
+ if ( ! IPA_VALID_NAT_MEM_IN(nmi) ) {
+ IPAERR("Bad cache type\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ sub = (nmi == IPA_NAT_MEM_IN_SRAM) ? SRAM_SUB : DDR_SUB;
+
+ nati_obj_ptr->tot_rules_in_table[sub] = 0;
+
+ ipa_nat_map_clear(nati_obj.map_pairs[sub].orig2new_map);
+ ipa_nat_map_clear(nati_obj.map_pairs[sub].new2orig_map);
+
+ ret = ipa_NATI_clear_ipv4_tbl(tbl_hdl);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smClrTblHybrid
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the clearing of the appropriate hybrid
+ * table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smClrTblHybrid(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_clear_args* args = (table_clear_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+
+ table_clear_args new_args = {
+ .tbl_hdl =
+ (nati_obj_ptr->curr_state == NATI_STATE_HYBRID) ?
+ tbl_hdl :
+ nati_obj_ptr->ddr_tbl_hdl,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = _smClrTbl(nati_obj_ptr, trigger, (void*) &new_args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smWalkTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the walk of a table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smWalkTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_walk_args* args = (table_walk_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ WhichTbl2Use which = args->which;
+ ipa_table_walk_cb walk_cb = args->walk_cb;
+ void* wadp = args->arb_data_ptr;
+
+ int ret;
+
+ UNUSED(nati_obj_ptr);
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X)\n", tbl_hdl);
+
+ ret = ipa_NATI_walk_ipv4_tbl(tbl_hdl, which, walk_cb, wadp);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smWalkTblHybrid
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the walk of the appropriate hybrid
+ * table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smWalkTblHybrid(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_walk_args* args = (table_walk_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ WhichTbl2Use which = args->which;
+ ipa_table_walk_cb walk_cb = args->walk_cb;
+ void* wadp = args->arb_data_ptr;
+
+ table_walk_args new_args = {
+ .tbl_hdl =
+ (nati_obj_ptr->curr_state == NATI_STATE_HYBRID) ?
+ tbl_hdl :
+ nati_obj_ptr->ddr_tbl_hdl,
+ .which = which,
+ .walk_cb = walk_cb,
+ .arb_data_ptr = wadp,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = _smWalkTbl(nati_obj_ptr, trigger, (void*) &new_args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smStatTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will get size/usage stats for a table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smStatTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_stats_args* args = (table_stats_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ ipa_nati_tbl_stats* nat_stats_ptr = args->nat_stats_ptr;
+ ipa_nati_tbl_stats* idx_stats_ptr = args->idx_stats_ptr;
+
+ int ret;
+
+ UNUSED(nati_obj_ptr);
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X)\n", tbl_hdl);
+
+ ret = ipa_NATI_ipv4_tbl_stats(tbl_hdl, nat_stats_ptr, idx_stats_ptr);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smStatTblHybrid
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the retrieval of table size/usage stats
+ * for the appropriate hybrid table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smStatTblHybrid(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ table_stats_args* args = (table_stats_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ ipa_nati_tbl_stats* nat_stats_ptr = args->nat_stats_ptr;
+ ipa_nati_tbl_stats* idx_stats_ptr = args->idx_stats_ptr;
+
+ table_stats_args new_args = {
+ .tbl_hdl =
+ (nati_obj_ptr->curr_state == NATI_STATE_HYBRID) ?
+ tbl_hdl :
+ nati_obj_ptr->ddr_tbl_hdl,
+ .nat_stats_ptr = nat_stats_ptr,
+ .idx_stats_ptr = idx_stats_ptr,
+ };
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = _smStatTbl(nati_obj_ptr, trigger, (void*) &new_args);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smAddRuleToTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the addtion of a NAT rule into the DDR
+ * based table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smAddRuleToTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ rule_add_args* args = (rule_add_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ ipa_nat_ipv4_rule* clnt_rule = (ipa_nat_ipv4_rule*) args->clnt_rule;
+ uint32_t* rule_hdl = args->rule_hdl;
+
+ char buf[1024];
+
+ int ret;
+
+ UNUSED(buf);
+ UNUSED(nati_obj_ptr);
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X) clnt_rule_ptr(%p) rule_hdl_ptr(%p) %s\n",
+ tbl_hdl, clnt_rule, rule_hdl,
+ prep_nat_ipv4_rule_4print(clnt_rule, buf, sizeof(buf)));
+
+ clnt_rule->redirect = clnt_rule->enable = clnt_rule->time_stamp = 0;
+
+ ret = ipa_NATI_add_ipv4_rule(tbl_hdl, clnt_rule, rule_hdl);
+
+ if ( ret == 0 )
+ {
+ uint32_t* cnt_ptr = CHOOSE_CNTR();
+
+ (*cnt_ptr)++;
+
+ IPADBG("rule_hdl value(%u or 0x%08X)\n",
+ *rule_hdl, *rule_hdl);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smDelRuleFromTbl
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the deletion of a NAT rule from the DDR
+ * based table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smDelRuleFromTbl(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ rule_del_args* args = (rule_del_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ uint32_t rule_hdl = args->rule_hdl;
+
+ int ret;
+
+ UNUSED(nati_obj_ptr);
+ UNUSED(trigger);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X) rule_hdl(%u)\n", tbl_hdl, rule_hdl);
+
+ ret = ipa_NATI_del_ipv4_rule(tbl_hdl, rule_hdl);
+
+ if ( ret == 0 )
+ {
+ uint32_t* cnt_ptr = CHOOSE_CNTR();
+
+ (*cnt_ptr)--;
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smAddRuleHybrid
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the addition of a NAT rule into either
+ * the SRAM or DDR based table.
+ *
+ * *** !!! HOWEVER *** REMEMBER !!! ***
+ *
+ * We're here because we're in a HYBRID state...with the potential
+ * moving between SRAM and DDR. THIS HAS IMLICATIONS AS IT RELATES
+ * TO RULE MAPPING.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smAddRuleHybrid(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ rule_add_args* args = (rule_add_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ ipa_nat_ipv4_rule* clnt_rule = (ipa_nat_ipv4_rule*) args->clnt_rule;
+ uint32_t* rule_hdl = args->rule_hdl;
+
+ rule_add_args new_args = {
+ .tbl_hdl =
+ (nati_obj_ptr->curr_state == NATI_STATE_HYBRID) ?
+ tbl_hdl :
+ nati_obj_ptr->ddr_tbl_hdl,
+ .clnt_rule = clnt_rule,
+ .rule_hdl = rule_hdl,
+ };
+
+ uint32_t orig2new_map, new2orig_map;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ ret = _smAddRuleToTbl(nati_obj_ptr, trigger, (void*) &new_args);
+
+ if ( ret == 0 )
+ {
+ /*
+ * The rule_hdl is used to find a rule in the nat table. It
+ * is, in effect, an index into the table. The applcation
+ * above us retains it for future manipulation of the rule in
+ * the table.
+ *
+ * In hybrid mode, a rule can and will move between SRAM and
+ * DDR. Because of this, its handle will change. The
+ * application has only the original handle and doesn't know
+ * of the new handle. A mapping, used in hybrid mode, will
+ * maintain a relationship between the original handle and the
+ * rule's current real handle...
+ *
+ * To help you get a mindset of how this is done:
+ *
+ * The original handle will map (point) to the new and new
+ * handle will map (point) back to original.
+ *
+ * NOTE WELL: There are two sets of maps. One for each memory
+ * type...
+ */
+ CHOOSE_MAPS(orig2new_map, new2orig_map);
+
+ ret = ipa_nat_map_add(orig2new_map, *rule_hdl, *rule_hdl);
+
+ if ( ret == 0 )
+ {
+ ret = ipa_nat_map_add(new2orig_map, *rule_hdl, *rule_hdl);
+ }
+ }
+ else
+ {
+ if ( nati_obj_ptr->curr_state == NATI_STATE_HYBRID )
+ {
+ /*
+ * In hybrid mode, we always start in SRAM...hence
+ * NATI_STATE_HYBRID implies SRAM. The rule addition
+ * above did not work, meaning the SRAM table is full,
+ * hence let's jump to DDR...
+ *
+ * The following will focus us on DDR and cause the copy
+ * of data from SRAM to DDR.
+ */
+ IPAINFO("Add of rule failed...attempting table switch\n");
+
+ ret = ipa_nati_statemach(nati_obj_ptr, NATI_TRIG_TBL_SWITCH, 0);
+
+ if ( ret == 0 )
+ {
+ SET_NATIOBJ_STATE(nati_obj_ptr, NATI_STATE_HYBRID_DDR);
+
+ /*
+ * Now add the rule to DDR...
+ */
+ ret = ipa_nati_statemach(nati_obj_ptr, trigger, arb_data_ptr);
+ }
+ }
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smDelRuleHybrid
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the deletion of a NAT rule from either
+ * the SRAM or DDR based table.
+ *
+ * *** !!! HOWEVER *** REMEMBER !!! ***
+ *
+ * We're here because we're in a HYBRID state...with the potential
+ * moving between SRAM and DDR. THIS HAS IMLICATIONS AS IT RELATES
+ * TO RULE MAPPING.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smDelRuleHybrid(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ rule_del_args* args = (rule_del_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ uint32_t orig_rule_hdl = args->rule_hdl;
+
+ uint32_t new_rule_hdl;
+
+ uint32_t orig2new_map, new2orig_map;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ CHOOSE_MAPS(orig2new_map, new2orig_map);
+
+ /*
+ * The rule_hdl is used to find a rule in the nat table. It is,
+ * in effect, an index into the table. The applcation above us
+ * retains it for future manipulation of the rule in the table.
+ *
+ * In hybrid mode, a rule can and will move between SRAM and DDR.
+ * Because of this, its handle will change. The application has
+ * only the original handle and doesn't know of the new handle. A
+ * mapping, used in hybrid mode, will maintain a relationship
+ * between the original handle and the rule's current real
+ * handle...
+ *
+ * To help you get a mindset of how this is done:
+ *
+ * The original handle will map (point) to the new and new
+ * handle will map (point) back to original.
+ *
+ * NOTE WELL: There are two sets of maps. One for each memory
+ * type...
+ */
+ ret = ipa_nat_map_del(orig2new_map, orig_rule_hdl, &new_rule_hdl);
+
+ if ( ret == 0 )
+ {
+ rule_del_args new_args = {
+ .tbl_hdl =
+ (nati_obj_ptr->curr_state == NATI_STATE_HYBRID) ?
+ tbl_hdl :
+ nati_obj_ptr->ddr_tbl_hdl,
+ .rule_hdl = new_rule_hdl,
+ };
+
+ IPADBG("orig_rule_hdl(0x%08X) -> new_rule_hdl(0x%08X)\n",
+ orig_rule_hdl, new_rule_hdl);
+
+ ipa_nat_map_del(new2orig_map, new_rule_hdl, NULL);
+
+ ret = _smDelRuleFromTbl(nati_obj_ptr, trigger, (void*) &new_args);
+
+ if ( ret == 0 && nati_obj_ptr->curr_state == NATI_STATE_HYBRID_DDR )
+ {
+ /*
+ * We need to check when/if we can go back to SRAM.
+ *
+ * How/why can we go back?
+ *
+ * Given enough deletions, and when we get to a user
+ * defined threshold (ie. a percentage of what SRAM can
+ * hold), we can pop back to using SRAM.
+ */
+ uint32_t* cnt_ptr = CHOOSE_CNTR();
+
+ if ( *cnt_ptr <= nati_obj_ptr->back_to_sram_thresh )
+ {
+ /*
+ * The following will focus us on SRAM and cause the copy
+ * of data from DDR to SRAM.
+ */
+ IPAINFO("Switch back to SRAM threshold has been reached -> "
+ "Total rules in DDR(%u) <= SRAM THRESH(%u)\n",
+ *cnt_ptr,
+ nati_obj_ptr->back_to_sram_thresh);
+
+ ret = ipa_nati_statemach(nati_obj_ptr, NATI_TRIG_TBL_SWITCH, 0);
+
+ if ( ret == 0 )
+ {
+ SET_NATIOBJ_STATE(nati_obj_ptr, NATI_STATE_HYBRID);
+ }
+ else
+ {
+ /*
+ * The following will force us stay in DDR for
+ * now, but the next delete will trigger the
+ * switch logic above to run again...perhaps it
+ * will work then.
+ */
+ ret = 0;
+ }
+ }
+ }
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smGoToDdr
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the IPA to use the DDR based NAT
+ * table...
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smGoToDdr(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ int ret;
+
+ UNUSED(trigger);
+ UNUSED(arb_data_ptr);
+
+ IPADBG("In\n");
+
+ ret = ipa_NATI_post_ipv4_init_cmd(nati_obj_ptr->ddr_tbl_hdl);
+
+ if ( ret == 0 )
+ {
+ SET_NATIOBJ_STATE(nati_obj_ptr, NATI_STATE_HYBRID_DDR);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smGoToSram
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause the IPA to use the SRAM based NAT
+ * table...
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smGoToSram(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ int ret;
+
+ UNUSED(trigger);
+ UNUSED(arb_data_ptr);
+
+ IPADBG("In\n");
+
+ ret = ipa_NATI_post_ipv4_init_cmd(nati_obj_ptr->sram_tbl_hdl);
+
+ if ( ret == 0 )
+ {
+ SET_NATIOBJ_STATE(nati_obj_ptr, NATI_STATE_HYBRID);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smSwitchFromDdrToSram
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause a copy of the DDR table to SRAM and then
+ * will make the IPA use the SRAM...
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smSwitchFromDdrToSram(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ nati_switch_stats* sw_stats_ptr = CHOOSE_SW_STATS();
+
+ uint32_t* cnt_ptr = CHOOSE_CNTR();
+
+ ipa_nati_tbl_stats nat_stats, idx_stats;
+
+ const char* mem_type;
+
+ uint64_t start, stop;
+
+ int stats_ret, ret;
+
+ UNUSED(cnt_ptr);
+ UNUSED(trigger);
+ UNUSED(arb_data_ptr);
+
+ IPADBG("In\n");
+
+ stats_ret = ipa_NATI_ipv4_tbl_stats(
+ nati_obj_ptr->ddr_tbl_hdl, &nat_stats, &idx_stats);
+
+ currTimeAs(TimeAsNanSecs, &start);
+
+ /*
+ * First, switch focus to SRAM...
+ */
+ ret = ipa_nati_statemach(nati_obj_ptr, NATI_TRIG_GOTO_SRAM, 0);
+
+ if ( ret == 0 )
+ {
+ /*
+ * Clear destination counter...
+ */
+ nati_obj_ptr->tot_rules_in_table[SRAM_SUB] = 0;
+
+ /*
+ * Clear destination SRAM maps...
+ */
+ ipa_nat_map_clear(nati_obj.map_pairs[SRAM_SUB].orig2new_map);
+ ipa_nat_map_clear(nati_obj.map_pairs[SRAM_SUB].new2orig_map);
+
+ /*
+ * Now copy DDR's content to SRAM...
+ */
+ ret = ipa_nati_copy_ipv4_tbl(
+ nati_obj_ptr->ddr_tbl_hdl,
+ nati_obj_ptr->sram_tbl_hdl,
+ migrate_rule);
+
+ currTimeAs(TimeAsNanSecs, &stop);
+
+ if ( ret == 0 )
+ {
+ sw_stats_ptr->pass += 1;
+
+ IPADBG("Transistion from DDR to SRAM took %f microseconds\n",
+ (float) (stop - start) / 1000.0);
+ }
+ else
+ {
+ sw_stats_ptr->fail += 1;
+ }
+
+ IPADBG("Transistion pass/fail counts (DDR to SRAM) PASS: %u FAIL: %u\n",
+ sw_stats_ptr->pass,
+ sw_stats_ptr->fail);
+
+ if ( stats_ret == 0 )
+ {
+ mem_type = ipa3_nat_mem_in_as_str(nat_stats.nmi);
+
+ /*
+ * NAT table stats...
+ */
+ IPADBG("Able to add (%u) records to %s "
+ "NAT table of size (%u) or (%f) percent\n",
+ *cnt_ptr,
+ mem_type,
+ nat_stats.tot_ents,
+ ((float) *cnt_ptr / (float) nat_stats.tot_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "NAT BASE table of size (%u) or (%f) percent\n",
+ nat_stats.tot_base_ents_filled,
+ mem_type,
+ nat_stats.tot_base_ents,
+ ((float) nat_stats.tot_base_ents_filled /
+ (float) nat_stats.tot_base_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "NAT EXPN table of size (%u) or (%f) percent\n",
+ nat_stats.tot_expn_ents_filled,
+ mem_type,
+ nat_stats.tot_expn_ents,
+ ((float) nat_stats.tot_expn_ents_filled /
+ (float) nat_stats.tot_expn_ents) * 100.0);
+
+ IPADBG("%s NAT table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ nat_stats.tot_chains,
+ nat_stats.min_chain_len,
+ nat_stats.max_chain_len,
+ nat_stats.avg_chain_len);
+
+ /*
+ * INDEX table stats...
+ */
+ IPADBG("Able to add (%u) records to %s "
+ "IDX table of size (%u) or (%f) percent\n",
+ *cnt_ptr,
+ mem_type,
+ idx_stats.tot_ents,
+ ((float) *cnt_ptr / (float) idx_stats.tot_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "IDX BASE table of size (%u) or (%f) percent\n",
+ idx_stats.tot_base_ents_filled,
+ mem_type,
+ idx_stats.tot_base_ents,
+ ((float) idx_stats.tot_base_ents_filled /
+ (float) idx_stats.tot_base_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "IDX EXPN table of size (%u) or (%f) percent\n",
+ idx_stats.tot_expn_ents_filled,
+ mem_type,
+ idx_stats.tot_expn_ents,
+ ((float) idx_stats.tot_expn_ents_filled /
+ (float) idx_stats.tot_expn_ents) * 100.0);
+
+ IPADBG("%s IDX table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ idx_stats.tot_chains,
+ idx_stats.min_chain_len,
+ idx_stats.max_chain_len,
+ idx_stats.avg_chain_len);
+
+ mem_type++; /* to avoid compiler usage warning */
+ }
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smSwitchFromSramToDdr
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following will cause a copy of the SRAM table to DDR and then
+ * will make the IPA use the DDR...
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smSwitchFromSramToDdr(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ nati_switch_stats* sw_stats_ptr = CHOOSE_SW_STATS();
+
+ uint32_t* cnt_ptr = CHOOSE_CNTR();
+
+ ipa_nati_tbl_stats nat_stats, idx_stats;
+
+ const char* mem_type;
+
+ uint64_t start, stop;
+
+ int stats_ret, ret;
+
+ UNUSED(cnt_ptr);
+ UNUSED(trigger);
+ UNUSED(arb_data_ptr);
+
+ IPADBG("In\n");
+
+ stats_ret = ipa_NATI_ipv4_tbl_stats(
+ nati_obj_ptr->sram_tbl_hdl, &nat_stats, &idx_stats);
+
+ currTimeAs(TimeAsNanSecs, &start);
+
+ /*
+ * First, switch focus to DDR...
+ */
+ ret = ipa_nati_statemach(nati_obj_ptr, NATI_TRIG_GOTO_DDR, 0);
+
+ if ( ret == 0 )
+ {
+ /*
+ * Clear destination counter...
+ */
+ nati_obj_ptr->tot_rules_in_table[DDR_SUB] = 0;
+
+ /*
+ * Clear destination DDR maps...
+ */
+ ipa_nat_map_clear(nati_obj.map_pairs[DDR_SUB].orig2new_map);
+ ipa_nat_map_clear(nati_obj.map_pairs[DDR_SUB].new2orig_map);
+
+ /*
+ * Now copy SRAM's content to DDR...
+ */
+ ret = ipa_nati_copy_ipv4_tbl(
+ nati_obj_ptr->sram_tbl_hdl,
+ nati_obj_ptr->ddr_tbl_hdl,
+ migrate_rule);
+
+ currTimeAs(TimeAsNanSecs, &stop);
+
+ if ( ret == 0 )
+ {
+ sw_stats_ptr->pass += 1;
+
+ IPADBG("Transistion from SRAM to DDR took %f microseconds\n",
+ (float) (stop - start) / 1000.0);
+ }
+ else
+ {
+ sw_stats_ptr->fail += 1;
+ }
+
+ IPADBG("Transistion pass/fail counts (SRAM to DDR) PASS: %u FAIL: %u\n",
+ sw_stats_ptr->pass,
+ sw_stats_ptr->fail);
+
+ if ( stats_ret == 0 )
+ {
+ mem_type = ipa3_nat_mem_in_as_str(nat_stats.nmi);
+
+ /*
+ * NAT table stats...
+ */
+ IPADBG("Able to add (%u) records to %s "
+ "NAT table of size (%u) or (%f) percent\n",
+ *cnt_ptr,
+ mem_type,
+ nat_stats.tot_ents,
+ ((float) *cnt_ptr / (float) nat_stats.tot_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "NAT BASE table of size (%u) or (%f) percent\n",
+ nat_stats.tot_base_ents_filled,
+ mem_type,
+ nat_stats.tot_base_ents,
+ ((float) nat_stats.tot_base_ents_filled /
+ (float) nat_stats.tot_base_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "NAT EXPN table of size (%u) or (%f) percent\n",
+ nat_stats.tot_expn_ents_filled,
+ mem_type,
+ nat_stats.tot_expn_ents,
+ ((float) nat_stats.tot_expn_ents_filled /
+ (float) nat_stats.tot_expn_ents) * 100.0);
+
+ IPADBG("%s NAT table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ nat_stats.tot_chains,
+ nat_stats.min_chain_len,
+ nat_stats.max_chain_len,
+ nat_stats.avg_chain_len);
+
+ /*
+ * INDEX table stats...
+ */
+ IPADBG("Able to add (%u) records to %s "
+ "IDX table of size (%u) or (%f) percent\n",
+ *cnt_ptr,
+ mem_type,
+ idx_stats.tot_ents,
+ ((float) *cnt_ptr / (float) idx_stats.tot_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "IDX BASE table of size (%u) or (%f) percent\n",
+ idx_stats.tot_base_ents_filled,
+ mem_type,
+ idx_stats.tot_base_ents,
+ ((float) idx_stats.tot_base_ents_filled /
+ (float) idx_stats.tot_base_ents) * 100.0);
+
+ IPADBG("Able to add (%u) records to %s "
+ "IDX EXPN table of size (%u) or (%f) percent\n",
+ idx_stats.tot_expn_ents_filled,
+ mem_type,
+ idx_stats.tot_expn_ents,
+ ((float) idx_stats.tot_expn_ents_filled /
+ (float) idx_stats.tot_expn_ents) * 100.0);
+
+ IPADBG("%s IDX table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ idx_stats.tot_chains,
+ idx_stats.min_chain_len,
+ idx_stats.max_chain_len,
+ idx_stats.avg_chain_len);
+
+ mem_type++; /* to avoid compiler usage warning */
+ }
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smGetTmStmp
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * Retrieve rule's timestamp from NAT table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smGetTmStmp(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ timestap_query_args* args = (timestap_query_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ uint32_t rule_hdl = args->rule_hdl;
+ uint32_t* time_stamp = args->time_stamp;
+
+ int ret;
+
+ UNUSED(nati_obj_ptr);
+ UNUSED(trigger);
+ UNUSED(arb_data_ptr);
+
+ IPADBG("In\n");
+
+ IPADBG("tbl_hdl(0x%08X) rule_hdl(%u) time_stamp_ptr(%p)\n",
+ tbl_hdl, rule_hdl, time_stamp);
+
+ ret = ipa_NATI_query_timestamp(tbl_hdl, rule_hdl, time_stamp);
+
+ if ( ret == 0 )
+ {
+ IPADBG("time_stamp(0x%08X)\n", *time_stamp);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smGetTmStmpHybrid
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * Retrieve rule's timestamp from the state approriate NAT table.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smGetTmStmpHybrid(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ timestap_query_args* args = (timestap_query_args*) arb_data_ptr;
+
+ uint32_t tbl_hdl = args->tbl_hdl;
+ uint32_t orig_rule_hdl = args->rule_hdl;
+ uint32_t* time_stamp = args->time_stamp;
+
+ uint32_t new_rule_hdl;
+
+ uint32_t orig2new_map, new2orig_map;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ CHOOSE_MAPS(orig2new_map, new2orig_map);
+
+ new2orig_map++; /* to avoid compiler usage warning */
+
+ ret = ipa_nat_map_find(orig2new_map, orig_rule_hdl, &new_rule_hdl);
+
+ if ( ret == 0 )
+ {
+ timestap_query_args new_args = {
+ .tbl_hdl =
+ (nati_obj_ptr->curr_state == NATI_STATE_HYBRID) ?
+ tbl_hdl :
+ nati_obj_ptr->ddr_tbl_hdl,
+ .rule_hdl = new_rule_hdl,
+ .time_stamp = time_stamp,
+ };
+
+ ret = _smGetTmStmp(nati_obj_ptr, trigger, (void*) &new_args);
+ }
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/******************************************************************************/
+/*
+ * The following table relates a nati object's state and a transition
+ * trigger to a callback...
+ */
+static nati_statemach_tuple
+_state_mach_tbl[NATI_STATE_LAST+1][NATI_TRIG_LAST+1] =
+{
+ {
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_NULL, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_ADD_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_DEL_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_CLR_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_WLK_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_TBL_STATS, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_ADD_RULE, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_DEL_RULE, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_TBL_SWITCH, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_GOTO_DDR, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_GOTO_SRAM, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_GET_TSTAMP, _smUndef ),
+ SM_ROW( NATI_STATE_NULL, NATI_TRIG_LAST, _smUndef ),
+ },
+
+ {
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_NULL, _smUndef ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_ADD_TABLE, _smAddDdrTbl),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_DEL_TABLE, _smDelTbl ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_CLR_TABLE, _smClrTbl ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_WLK_TABLE, _smWalkTbl ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_TBL_STATS, _smStatTbl ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_ADD_RULE, _smAddRuleToTbl ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_DEL_RULE, _smDelRuleFromTbl ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_TBL_SWITCH, _smUndef ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_GOTO_DDR, _smUndef ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_GOTO_SRAM, _smUndef ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_GET_TSTAMP, _smGetTmStmp ),
+ SM_ROW( NATI_STATE_DDR_ONLY, NATI_TRIG_LAST, _smUndef ),
+ },
+
+ {
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_NULL, _smUndef ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_ADD_TABLE, _smAddSramTbl),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_DEL_TABLE, _smDelTbl ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_CLR_TABLE, _smClrTbl ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_WLK_TABLE, _smWalkTbl ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_TBL_STATS, _smStatTbl ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_ADD_RULE, _smAddRuleToTbl ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_DEL_RULE, _smDelRuleFromTbl ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_TBL_SWITCH, _smUndef ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_GOTO_DDR, _smUndef ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_GOTO_SRAM, _smUndef ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_GET_TSTAMP, _smGetTmStmp ),
+ SM_ROW( NATI_STATE_SRAM_ONLY, NATI_TRIG_LAST, _smUndef ),
+ },
+
+ {
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_NULL, _smUndef ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_ADD_TABLE, _smAddSramAndDdrTbl ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_DEL_TABLE, _smDelSramAndDdrTbl ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_CLR_TABLE, _smClrTblHybrid ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_WLK_TABLE, _smWalkTblHybrid ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_TBL_STATS, _smStatTblHybrid ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_ADD_RULE, _smAddRuleHybrid ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_DEL_RULE, _smDelRuleHybrid ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_TBL_SWITCH, _smSwitchFromSramToDdr ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_GOTO_DDR, _smGoToDdr ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_GOTO_SRAM, _smGoToSram ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_GET_TSTAMP, _smGetTmStmpHybrid ),
+ SM_ROW( NATI_STATE_HYBRID, NATI_TRIG_LAST, _smUndef ),
+ },
+
+ {
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_NULL, _smUndef ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_ADD_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_DEL_TABLE, _smDelSramAndDdrTbl ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_CLR_TABLE, _smClrTblHybrid ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_WLK_TABLE, _smWalkTblHybrid ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_TBL_STATS, _smStatTblHybrid ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_ADD_RULE, _smAddRuleHybrid ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_DEL_RULE, _smDelRuleHybrid ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_TBL_SWITCH, _smSwitchFromDdrToSram ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_GOTO_DDR, _smGoToDdr ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_GOTO_SRAM, _smGoToSram ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_GET_TSTAMP, _smGetTmStmpHybrid ),
+ SM_ROW( NATI_STATE_HYBRID_DDR, NATI_TRIG_LAST, _smUndef ),
+ },
+
+ {
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_NULL, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_ADD_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_DEL_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_CLR_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_WLK_TABLE, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_TBL_STATS, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_ADD_RULE, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_DEL_RULE, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_TBL_SWITCH, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_GOTO_DDR, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_GOTO_SRAM, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_GET_TSTAMP, _smUndef ),
+ SM_ROW( NATI_STATE_LAST, NATI_TRIG_LAST, _smUndef ),
+ },
+};
+
+/******************************************************************************/
+/*
+ * FUNCTION: _smUndef
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Whatever you like
+ *
+ * DESCRIPTION:
+ *
+ * The following does nothing, except report an undefined action for
+ * a particular state/trigger combo...
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+static int _smUndef(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ UNUSED(arb_data_ptr);
+
+ IPAERR("CB(%s): undefined action for STATE(%s) with TRIGGER(%s)\n",
+ _state_mach_tbl[nati_obj_ptr->curr_state][trigger].sm_cb_as_str,
+ _state_mach_tbl[nati_obj_ptr->curr_state][trigger].state_as_str,
+ _state_mach_tbl[nati_obj_ptr->curr_state][trigger].trigger_as_str);
+
+ return -1;
+}
+
+/******************************************************************************/
+/*
+ * FUNCTION: ipa_nati_statemach
+ *
+ * PARAMS:
+ *
+ * nati_obj_ptr (IN) A pointer to an initialized nati object
+ *
+ * trigger (IN) The trigger to run through the state machine
+ *
+ * arb_data_ptr (IN) Anything you like. Will be passed, untouched,
+ * to the state/trigger callback function.
+ *
+ * DESCRIPTION:
+ *
+ * This function allows a nati object and a trigger to be run
+ * through the state machine.
+ *
+ * RETURNS:
+ *
+ * zero on success, otherwise non-zero
+ */
+int ipa_nati_statemach(
+ ipa_nati_obj* nati_obj_ptr,
+ ipa_nati_trigger trigger,
+ void* arb_data_ptr )
+{
+ const char* ss_ptr = _state_mach_tbl[nati_obj_ptr->curr_state][trigger].state_as_str;
+ const char* ts_ptr = _state_mach_tbl[nati_obj_ptr->curr_state][trigger].trigger_as_str;
+ const char* cbs_ptr = _state_mach_tbl[nati_obj_ptr->curr_state][trigger].sm_cb_as_str;
+
+ bool vote = false;
+
+ int ret;
+
+ UNUSED(ss_ptr);
+ UNUSED(ts_ptr);
+ UNUSED(cbs_ptr);
+
+ IPADBG("In\n");
+
+ if ( ! nat_mutex_init )
+ {
+ ret = mutex_init();
+
+ if ( ret != 0 )
+ {
+ goto bail;
+ }
+ }
+
+ if ( pthread_mutex_lock(&nat_mutex) )
+ {
+ IPAERR("Unable to lock the nat mutex\n");
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ IPADBG("STATE(%s) TRIGGER(%s) CB(%s)\n", ss_ptr, ts_ptr, cbs_ptr);
+
+ vote = VOTE_REQUIRED(trigger);
+
+ if ( vote )
+ {
+ IPADBG("Voting clock on STATE(%s) TRIGGER(%s)\n",
+ ss_ptr, ts_ptr);
+
+ if ( ipa_nat_vote_clock(IPA_APP_CLK_VOTE) != 0 )
+ {
+ IPAERR("Voting failed STATE(%s) TRIGGER(%s)\n", ss_ptr, ts_ptr);
+ ret = -EINVAL;
+ goto unlock;
+ }
+ }
+
+ ret = _state_mach_tbl[nati_obj_ptr->curr_state][trigger].sm_cb(
+ nati_obj_ptr, trigger, arb_data_ptr);
+
+ if ( vote )
+ {
+ IPADBG("Voting clock off STATE(%s) TRIGGER(%s)\n",
+ ss_ptr, ts_ptr);
+
+ if ( ipa_nat_vote_clock(IPA_APP_CLK_DEVOTE) != 0 )
+ {
+ IPAERR("Voting failed STATE(%s) TRIGGER(%s)\n", ss_ptr, ts_ptr);
+ }
+ }
+
+unlock:
+ if ( pthread_mutex_unlock(&nat_mutex) )
+ {
+ IPAERR("Unable to unlock the nat mutex\n");
+ ret = (ret) ? ret : -EPERM;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
diff --git a/ipanat/src/ipa_nat_utils.c b/ipanat/src/ipa_nat_utils.c
new file mode 100644
index 0000000..e10207c
--- /dev/null
+++ b/ipanat/src/ipa_nat_utils.c
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2013, 2018-2019 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 "ipa_nat_utils.h"
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <stdlib.h>
+
+#define IPA_MAX_MSG_LEN 4096
+
+static char dbg_buff[IPA_MAX_MSG_LEN];
+
+#if !defined(MSM_IPA_TESTS) && !defined(USE_GLIB) && !defined(FEATURE_IPA_ANDROID)
+size_t strlcpy(char* dst, const char* src, size_t size)
+{
+ size_t i;
+
+ if (size == 0)
+ return strlen(src);
+
+ for (i = 0; i < (size - 1) && src[i] != '\0'; ++i)
+ dst[i] = src[i];
+
+ dst[i] = '\0';
+
+ return i + strlen(src + i);
+}
+#endif
+
+ipa_descriptor* ipa_descriptor_open(void)
+{
+ ipa_descriptor* desc_ptr;
+ int res = 0;
+
+ IPADBG("In\n");
+
+ desc_ptr = calloc(1, sizeof(ipa_descriptor));
+
+ if ( desc_ptr == NULL )
+ {
+ IPAERR("Unable to allocate ipa_descriptor\n");
+ goto bail;
+ }
+
+ desc_ptr->fd = open(IPA_DEV_NAME, O_RDONLY);
+
+ if (desc_ptr->fd < 0)
+ {
+ IPAERR("Unable to open ipa device\n");
+ goto free;
+ }
+
+ res = ioctl(desc_ptr->fd, IPA_IOC_GET_HW_VERSION, &desc_ptr->ver);
+
+ if (res == 0)
+ {
+ IPADBG("IPA version is %d\n", desc_ptr->ver);
+ }
+ else
+ {
+ IPAERR("Unable to get IPA version. Error %d\n", res);
+ desc_ptr->ver = IPA_HW_None;
+ }
+
+ goto bail;
+
+free:
+ free(desc_ptr);
+ desc_ptr = NULL;
+
+bail:
+ IPADBG("Out\n");
+
+ return desc_ptr;
+}
+
+void ipa_descriptor_close(
+ ipa_descriptor* desc_ptr)
+{
+ IPADBG("In\n");
+
+ if ( desc_ptr )
+ {
+ if ( desc_ptr->fd >= 0)
+ {
+ close(desc_ptr->fd);
+ }
+ free(desc_ptr);
+ }
+
+ IPADBG("Out\n");
+}
+
+void ipa_read_debug_info(
+ const char* debug_file_path)
+{
+ size_t result;
+ FILE* debug_file;
+
+ debug_file = fopen(debug_file_path, "r");
+ if (debug_file == NULL)
+ {
+ printf("Failed to open %s\n", debug_file_path);
+ return;
+ }
+
+ for (;;)
+ {
+ result = fread(dbg_buff, sizeof(char), IPA_MAX_MSG_LEN, debug_file);
+ if (!result)
+ break;
+
+ if (result < IPA_MAX_MSG_LEN)
+ {
+ if (ferror(debug_file))
+ {
+ printf("Failed to read from %s\n", debug_file_path);
+ break;
+ }
+
+ dbg_buff[result] = '\0';
+ }
+ else
+ {
+ dbg_buff[IPA_MAX_MSG_LEN - 1] = '\0';
+ }
+
+
+ printf("%s", dbg_buff);
+
+ if (feof(debug_file))
+ break;
+ }
+ fclose(debug_file);
+}
+
+void log_nat_message(char *msg)
+{
+ UNUSED(msg);
+
+ return;
+}
+
+int currTimeAs(
+ TimeAs_t timeAs,
+ uint64_t* valPtr )
+{
+ struct timespec timeSpec;
+
+ int ret = 0;
+
+ if ( ! VALID_TIMEAS(timeAs) || ! valPtr )
+ {
+ IPAERR("Bad arg: timeAs (%u) and/or valPtr (%p)\n",
+ timeAs, valPtr );
+ ret = -1;
+ goto bail;
+ }
+
+ memset(&timeSpec, 0, sizeof(timeSpec));
+
+ if ( clock_gettime(CLOCK_MONOTONIC, &timeSpec) != 0 )
+ {
+ IPAERR("Can't get system clock time\n" );
+ ret = -1;
+ goto bail;
+ }
+
+ switch( timeAs )
+ {
+ case TimeAsNanSecs:
+ *valPtr =
+ (uint64_t) (SECS2NanSECS((uint64_t) timeSpec.tv_sec) +
+ ((uint64_t) timeSpec.tv_nsec));
+ break;
+ case TimeAsMicSecs:
+ *valPtr =
+ (uint64_t) (SECS2MicSECS((uint64_t) timeSpec.tv_sec) +
+ ((uint64_t) timeSpec.tv_nsec / 1000));
+ break;
+ case TimeAsMilSecs:
+ *valPtr =
+ (uint64_t) (SECS2MilSECS((uint64_t) timeSpec.tv_sec) +
+ ((uint64_t) timeSpec.tv_nsec / 1000000));
+ break;
+ }
+
+bail:
+ return ret;
+}
diff --git a/ipanat/src/ipa_table.c b/ipanat/src/ipa_table.c
new file mode 100644
index 0000000..f73dff0
--- /dev/null
+++ b/ipanat/src/ipa_table.c
@@ -0,0 +1,1344 @@
+/*
+ * Copyright (c) 2018-2020 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 "ipa_table.h"
+#include "ipa_nat_utils.h"
+
+#include <errno.h>
+
+#define IPA_BASE_TABLE_PERCENTAGE .8
+#define IPA_EXPANSION_TABLE_PERCENTAGE .2
+
+#define IPA_BASE_TABLE_PCNT_4SRAM 1.00
+#define IPA_EXPANSION_TABLE_PCNT_4SRAM 0.43
+
+/*
+ * The table number of entries is limited by Entry ID structure
+ * above. The base table max entries is limited by index into table
+ * bits number.
+ *
+ * The table max ents number is: (base table max ents / base table percentage)
+ *
+ * IPA_TABLE_MAX_ENTRIES = 2^(index into table) / IPA_BASE_TABLE_PERCENTAGE
+ */
+
+static int InsertHead(
+ ipa_table* table,
+ void* rec_ptr, /* empty record in table */
+ uint16_t rec_index, /* index of record above */
+ void* user_data,
+ struct ipa_ioc_nat_dma_cmd* cmd );
+
+static int InsertTail(
+ ipa_table* table,
+ void* rec_ptr, /* occupied record at index below */
+ uint16_t* rec_index_ptr, /* pointer to index of record above */
+ void* user_data,
+ struct ipa_ioc_nat_dma_cmd* cmd );
+
+static uint16_t MakeEntryHdl(
+ ipa_table* tbl,
+ uint16_t tbl_entry );
+
+static int FindExpnTblFreeEntry(
+ ipa_table* table,
+ void** free_entry,
+ uint16_t* entry_index );
+
+static int Get2PowerTightUpperBound(
+ uint16_t num);
+
+static int GetEvenTightUpperBound(
+ uint16_t num);
+
+void ipa_table_init(
+ ipa_table* table,
+ const char* table_name,
+ enum ipa3_nat_mem_in nmi,
+ int entry_size,
+ void* meta,
+ int meta_entry_size,
+ ipa_table_entry_interface* entry_interface )
+{
+ IPADBG("In\n");
+
+ memset(table, 0, sizeof(ipa_table));
+
+ strlcpy(table->name, table_name, IPA_RESOURCE_NAME_MAX);
+
+ table->nmi = nmi;
+ table->entry_size = entry_size;
+ table->meta = meta;
+ table->meta_entry_size = meta_entry_size;
+ table->entry_interface = entry_interface;
+
+ IPADBG("Table %s with entry size %d has been initialized\n",
+ table->name, table->entry_size);
+
+ IPADBG("Out\n");
+}
+
+int ipa_table_calculate_entries_num(
+ ipa_table* table,
+ uint16_t number_of_entries,
+ enum ipa3_nat_mem_in nmi)
+{
+ uint16_t table_entries, expn_table_entries;
+ float btp, etp;
+ int result = 0;
+
+ IPADBG("In\n");
+
+ if (number_of_entries > IPA_TABLE_MAX_ENTRIES)
+ {
+ IPAERR("Required number of %s entries %d exceeds the maximum %d\n",
+ table->name, number_of_entries, IPA_TABLE_MAX_ENTRIES);
+ result = -EINVAL;
+ goto bail;
+ }
+
+ if ( nmi == IPA_NAT_MEM_IN_SRAM )
+ {
+ btp = IPA_BASE_TABLE_PCNT_4SRAM;
+ etp = IPA_EXPANSION_TABLE_PCNT_4SRAM;
+ }
+ else
+ {
+ btp = IPA_BASE_TABLE_PERCENTAGE;
+ etp = IPA_EXPANSION_TABLE_PERCENTAGE;
+ }
+
+ table_entries = Get2PowerTightUpperBound(number_of_entries * btp);
+ expn_table_entries = GetEvenTightUpperBound(number_of_entries * etp);
+
+ table->tot_tbl_ents = table_entries + expn_table_entries;
+
+ if ( table->tot_tbl_ents > IPA_TABLE_MAX_ENTRIES )
+ {
+ IPAERR("Required number of %s entries %u "
+ "(user provided %u) exceeds the maximum %u\n",
+ table->name,
+ table->tot_tbl_ents,
+ number_of_entries,
+ IPA_TABLE_MAX_ENTRIES);
+ result = -EINVAL;
+ goto bail;
+ }
+
+ table->table_entries = table_entries;
+ table->expn_table_entries = expn_table_entries;
+
+ IPADBG("Num of %s entries:%u expn entries:%u total entries:%u\n",
+ table->name,
+ table->table_entries,
+ table->expn_table_entries,
+ table->tot_tbl_ents);
+
+bail:
+ IPADBG("Out\n");
+
+ return result;
+}
+
+int ipa_table_calculate_size(ipa_table* table)
+{
+ int size = table->entry_size * (table->table_entries + table->expn_table_entries);
+
+ IPADBG("In\n");
+
+ IPADBG("%s size: %d\n", table->name, size);
+
+ IPADBG("Out\n");
+
+ return size;
+}
+
+uint8_t* ipa_table_calculate_addresses(
+ ipa_table* table,
+ uint8_t* base_addr)
+{
+ uint8_t* result = NULL;
+
+ IPADBG("In\n");
+
+ table->table_addr = base_addr;
+ table->expn_table_addr =
+ table->table_addr + table->entry_size * table->table_entries;
+
+ IPADBG("Table %s addresses: table_addr %pK expn_table_addr %pK\n",
+ table->name, table->table_addr, table->expn_table_addr);
+
+ result = table->expn_table_addr + table->entry_size * table->expn_table_entries;
+
+ IPADBG("Out\n");
+
+ return result;
+}
+
+void ipa_table_reset(
+ ipa_table* table)
+{
+ uint32_t i, tot;
+
+ IPADBG("In\n");
+
+ IPADBG("memset %s table to 0, %pK\n", table->name, table->table_addr);
+ tot = table->entry_size * table->table_entries;
+ for ( i = 0; i < tot; i++ )
+ {
+ table->table_addr[i] = '\0';
+ }
+
+ IPADBG("memset %s expn table to 0, %pK\n", table->name, table->expn_table_addr);
+ tot = table->entry_size * table->expn_table_entries;
+ for ( i = 0; i < tot; i++ )
+ {
+ table->expn_table_addr[i] = '\0';
+ }
+
+ IPADBG("Out\n");
+}
+
+int ipa_table_add_entry(
+ ipa_table* table,
+ void* user_data,
+ uint16_t* rec_index_ptr,
+ uint32_t* rule_hdl,
+ struct ipa_ioc_nat_dma_cmd* cmd )
+{
+ void* rec_ptr;
+ int ret = 0, occupied;
+
+ IPADBG("In\n");
+
+ rec_ptr = GOTO_REC(table, *rec_index_ptr);
+
+ /*
+ * Check whether there is any collision
+ */
+ occupied = table->entry_interface->entry_is_valid(rec_ptr);
+
+ if ( ! occupied )
+ {
+ IPADBG("Collision free (in %s) ... found open slot\n", table->name);
+ ret = InsertHead(table, rec_ptr, *rec_index_ptr, user_data, cmd);
+ }
+ else
+ {
+ IPADBG("Collision (in %s) ... will probe for open slot\n", table->name);
+ ret = InsertTail(table, rec_ptr, rec_index_ptr, user_data, cmd);
+ }
+
+ if (ret)
+ goto bail;
+
+ IPADBG("New Entry Index %u in %s\n", *rec_index_ptr, table->name);
+
+ if ( rule_hdl ) {
+ *rule_hdl = MakeEntryHdl(table, *rec_index_ptr);
+ IPADBG("rule_hdl value(%u)\n", *rule_hdl);
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+void ipa_table_create_delete_command(
+ ipa_table* table,
+ struct ipa_ioc_nat_dma_cmd* cmd,
+ ipa_table_iterator* iterator)
+{
+ IPADBG("In\n");
+
+ IPADBG("Delete rule at index(0x%04X) in %s\n",
+ iterator->curr_index,
+ table->name);
+
+ if ( ! VALID_INDEX(iterator->prev_index) )
+ {
+ /*
+ * The following two assigns (ie. the defaults), will cause
+ * the enabled bit in the record to be set to 0.
+ */
+ uint16_t data = 0;
+ dma_help_type ht = HELP_UPDATE_HEAD;
+
+ if ( VALID_INDEX(iterator->next_index) )
+ {
+ /*
+ * NOTE WELL HERE:
+ *
+ * This record is the first in a chain/list of
+ * records. Delete means something different in this
+ * context.
+ *
+ * The code below will cause the change of the protocol
+ * field in the rule record to 0xFF. It does not set the
+ * enable bit in the record to 0. This is done in special
+ * cases when the record being deleted is the first in a
+ * list of records.
+ *
+ * What does this mean? It means that the record is
+ * functionally deleted, but not really deleted. Why?
+ * Because the IPA will no longer use it because of the
+ * bad protocol (ie. functionally deleted), but these
+ * higher level APIs still see it as "enabled."
+ *
+ * This all means that deleted really means two things: 1)
+ * Not enabled, and 2) Not a valid record. APIs that walk
+ * the table...looking for enabled records (ie. the
+ * enabled bit)....now have to be a bit smarter to see the
+ * bad protocol as well.
+ */
+ data = table->entry_interface->
+ entry_get_delete_head_dma_command_data(
+ iterator->curr_entry, iterator->next_entry);
+
+ ht = HELP_DELETE_HEAD;
+ }
+
+ ipa_table_add_dma_cmd(table,
+ ht,
+ iterator->curr_entry,
+ iterator->curr_index,
+ data,
+ cmd);
+ }
+ else
+ {
+ ipa_table_add_dma_cmd(table,
+ HELP_UPDATE_ENTRY,
+ iterator->prev_entry,
+ iterator->prev_index,
+ iterator->next_index,
+ cmd);
+ }
+
+ IPADBG("Out\n");
+}
+
+void ipa_table_delete_entry(
+ ipa_table* table,
+ ipa_table_iterator* iterator,
+ uint8_t is_prev_empty)
+{
+ IPADBG("In\n");
+
+ if ( VALID_INDEX(iterator->next_index) )
+ {
+ /*
+ * Update the next entry's prev_index field with current
+ * entry's prev_index
+ */
+ table->entry_interface->entry_set_prev_index(
+ iterator->next_entry,
+ iterator->next_index,
+ iterator->prev_index,
+ table->meta,
+ table->table_entries);
+ }
+ else if (is_prev_empty)
+ {
+ if (iterator->prev_entry == NULL)
+ {
+ IPAERR("failed to delete of an empty head %d while delete the next entry %d in %s",
+ iterator->prev_index, iterator->curr_index, table->name);
+ }
+ else
+ {
+ /*
+ * Delete an empty head rule after the whole tail was deleted
+ */
+ IPADBG("deleting the dead node %d for %s\n",
+ iterator->prev_index, table->name);
+
+ memset(iterator->prev_entry, 0, table->entry_size);
+
+ --table->cur_tbl_cnt;
+ }
+ }
+
+ ipa_table_erase_entry(table, iterator->curr_index);
+
+ IPADBG("Out\n");
+}
+
+void ipa_table_erase_entry(
+ ipa_table* table,
+ uint16_t index)
+{
+ void* entry = GOTO_REC(table, index);
+
+ IPADBG("In\n");
+
+ IPADBG("table(%p) index(%u)\n", table, index);
+
+ memset(entry, 0, table->entry_size);
+
+ if ( index < table->table_entries )
+ {
+ --table->cur_tbl_cnt;
+ }
+ else
+ {
+ --table->cur_expn_tbl_cnt;
+ }
+
+ IPADBG("Out\n");
+}
+
+/**
+ * ipa_table_get_entry() - returns a table entry according to the received entry handle
+ * @table: [in] the table
+ * @entry_handle: [in] entry handle
+ * @entry: [out] the retrieved entry
+ * @entry_index: [out] absolute index of the retrieved entry
+ *
+ * Parse the entry handle to retrieve the entry and its index
+ *
+ * Returns: 0 on success, negative on failure
+ */
+int ipa_table_get_entry(
+ ipa_table* table,
+ uint32_t entry_handle,
+ void** entry,
+ uint16_t* entry_index )
+{
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rec_index;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ IPADBG("table(%p) entry_handle(%u) entry(%p) entry_index(%p)\n",
+ table, entry_handle, entry, entry_index);
+
+ /*
+ * Retrieve the memory and table type as well as the index
+ */
+ BREAK_RULE_HDL(table, entry_handle, nmi, is_expn_tbl, rec_index);
+
+ nmi++; /* to eliminate compiler usage warning */
+
+ if ( is_expn_tbl )
+ {
+ IPADBG("Retrieving entry from expansion table\n");
+ }
+ else
+ {
+ IPADBG("Retrieving entry from base (non-expansion) table\n");
+ }
+
+ if ( rec_index >= table->tot_tbl_ents )
+ {
+ IPAERR("The entry handle's record index (%u) exceeds table size (%u)\n",
+ rec_index, table->tot_tbl_ents);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ *entry = GOTO_REC(table, rec_index);
+
+ if ( entry_index )
+ {
+ *entry_index = rec_index;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+void* ipa_table_get_entry_by_index(
+ ipa_table* table,
+ uint16_t rec_index )
+{
+ void* result = NULL;
+
+ IPADBG("In\n");
+
+ IPADBG("table(%p) rec_index(%u)\n",
+ table,
+ rec_index);
+
+ if ( ! rec_index || rec_index >= table->tot_tbl_ents )
+ {
+ IPAERR("Invalid record index (%u): It's "
+ "either zero or exceeds table size (%u)\n",
+ rec_index, table->tot_tbl_ents);
+ goto bail;
+ }
+
+ result = GOTO_REC(table, rec_index);
+
+bail:
+ IPADBG("Out\n");
+
+ return result;
+}
+
+void ipa_table_dma_cmd_helper_init(
+ ipa_table_dma_cmd_helper* dma_cmd_helper,
+ uint8_t table_indx,
+ ipa_table_dma_type table_type,
+ ipa_table_dma_type expn_table_type,
+ uint32_t offset)
+{
+ IPADBG("In\n");
+
+ dma_cmd_helper->offset = offset;
+ dma_cmd_helper->table_indx = table_indx;
+ dma_cmd_helper->table_type = table_type;
+ dma_cmd_helper->expn_table_type = expn_table_type;
+
+ IPADBG("Out\n");
+}
+
+void ipa_table_dma_cmd_generate(
+ ipa_table_dma_cmd_helper* dma_cmd_helper,
+ uint8_t is_expn,
+ uint32_t entry_offset,
+ uint16_t data,
+ struct ipa_ioc_nat_dma_cmd* cmd)
+{
+ struct ipa_ioc_nat_dma_one* dma = &cmd->dma[cmd->entries];
+
+ IPADBG("In\n");
+
+ IPADBG("is_expn(0x%02X) entry_offset(0x%08X) data(0x%04X)\n",
+ is_expn, entry_offset, data);
+
+ dma->table_index = dma_cmd_helper->table_indx;
+
+ /*
+ * DMA parameter base_addr is the table type (see the IPA
+ * architecture document)
+ */
+ dma->base_addr =
+ (is_expn) ?
+ dma_cmd_helper->expn_table_type :
+ dma_cmd_helper->table_type;
+
+ dma->offset = dma_cmd_helper->offset + entry_offset;
+
+ dma->data = data;
+
+ IPADBG("dma_entry[%u](table_index(0x%02X) "
+ "base_addr(0x%02X) data(0x%04X) offset(0x%08X))\n",
+ cmd->entries,
+ dma->table_index,
+ dma->base_addr,
+ dma->data,
+ dma->offset);
+
+ cmd->entries++;
+
+ IPADBG("Out\n");
+}
+
+int ipa_table_iterator_init(
+ ipa_table_iterator* iterator,
+ ipa_table* table,
+ void* curr_entry,
+ uint16_t curr_index)
+{
+ int occupied;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ memset(iterator, 0, sizeof(ipa_table_iterator));
+
+ occupied = table->entry_interface->entry_is_valid(curr_entry);
+
+ if ( ! occupied )
+ {
+ IPAERR("Invalid (not enabled) rule %u in %s\n", curr_index, table->name);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ iterator->curr_entry = curr_entry;
+ iterator->curr_index = curr_index;
+
+ iterator->prev_index = table->entry_interface->entry_get_prev_index(
+ curr_entry,
+ curr_index,
+ table->meta,
+ table->table_entries);
+
+ iterator->next_index = table->entry_interface->entry_get_next_index(
+ curr_entry);
+
+ if ( VALID_INDEX(iterator->prev_index) )
+ {
+ iterator->prev_entry = ipa_table_get_entry_by_index(
+ table,
+ iterator->prev_index);
+
+ if ( iterator->prev_entry == NULL )
+ {
+ IPAERR("Failed to retrieve the entry at index 0x%04X for %s\n",
+ iterator->prev_index, table->name);
+ ret = -EPERM;
+ goto bail;
+ }
+ }
+
+ if ( VALID_INDEX(iterator->next_index) )
+ {
+ iterator->next_entry = ipa_table_get_entry_by_index(
+ table,
+ iterator->next_index);
+
+ if ( iterator->next_entry == NULL )
+ {
+ IPAERR("Failed to retrieve the entry at index 0x%04X for %s\n",
+ iterator->next_index, table->name);
+ ret = -EPERM;
+ goto bail;
+ }
+ }
+
+ IPADBG("[index/entry] for "
+ "prev:[0x%04X/%p] "
+ "curr:[0x%04X/%p] "
+ "next:[0x%04X/%p] "
+ "\"%s\"\n",
+ iterator->prev_index,
+ iterator->prev_entry,
+ iterator->curr_index,
+ iterator->curr_entry,
+ iterator->next_index,
+ iterator->next_entry,
+ table->name);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_table_iterator_next(
+ ipa_table_iterator* iterator,
+ ipa_table* table)
+{
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ iterator->prev_entry = iterator->curr_entry;
+ iterator->prev_index = iterator->curr_index;
+ iterator->curr_entry = iterator->next_entry;
+ iterator->curr_index = iterator->next_index;
+
+ iterator->next_index = table->entry_interface->entry_get_next_index(
+ iterator->curr_entry);
+
+ if ( ! VALID_INDEX(iterator->next_index) )
+ {
+ iterator->next_entry = NULL;
+ }
+ else
+ {
+ iterator->next_entry = ipa_table_get_entry_by_index(
+ table, iterator->next_index);
+
+ if (iterator->next_entry == NULL)
+ {
+ IPAERR("Failed to retrieve the entry at index %d for %s\n",
+ iterator->next_index, table->name);
+ ret = -EPERM;
+ goto bail;
+ }
+ }
+
+ IPADBG("Iterator moved to: prev_index=%d curr_index=%d next_index=%d\n",
+ iterator->prev_index, iterator->curr_index, iterator->next_index);
+
+ IPADBG(" prev_entry=%pK curr_entry=%pK next_entry=%pK\n",
+ iterator->prev_entry, iterator->curr_entry, iterator->next_entry);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_table_iterator_end(
+ ipa_table_iterator* iterator,
+ ipa_table* table_ptr,
+ uint16_t rec_index, /* a table slot relative to hash */
+ void* rec_ptr ) /* occupant record at index above */
+{
+ bool found_end = false;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ if ( ! iterator || ! table_ptr || ! rec_ptr )
+ {
+ IPAERR("Bad arg: iterator(%p) and/or table_ptr (%p) and/or rec_ptr(%p)\n",
+ iterator, table_ptr, rec_ptr);
+ ret = -1;
+ goto bail;
+ }
+
+ memset(iterator, 0, sizeof(ipa_table_iterator));
+
+ iterator->prev_index = rec_index;
+ iterator->prev_entry = rec_ptr;
+
+ while ( 1 )
+ {
+ uint16_t next_index =
+ table_ptr->entry_interface->entry_get_next_index(iterator->prev_entry);
+
+ if ( ! VALID_INDEX(next_index) )
+ {
+ found_end = true;
+ break;
+ }
+
+ if ( next_index == iterator->prev_index )
+ {
+ IPAERR("next_index(%u) and prev_index(%u) shouldn't be equal in %s\n",
+ next_index,
+ iterator->prev_index,
+ table_ptr->name);
+ break;
+ }
+
+ iterator->prev_index = next_index;
+ iterator->prev_entry = GOTO_REC(table_ptr, next_index);
+ }
+
+ if ( found_end )
+ {
+ IPADBG("Iterator found end of list record\n");
+ ret = 0;
+ }
+ else
+ {
+ IPAERR("Iterator can't find end of list record\n");
+ ret = -1;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_table_iterator_is_head_with_tail(
+ ipa_table_iterator* iterator)
+{
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ ret = VALID_INDEX(iterator->next_index) && ! VALID_INDEX(iterator->prev_index);
+
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static int InsertHead(
+ ipa_table* table,
+ void* rec_ptr, /* empty record in table */
+ uint16_t rec_index, /* index of record above */
+ void* user_data,
+ struct ipa_ioc_nat_dma_cmd* cmd )
+{
+ uint16_t enable_data = 0;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ ret = table->entry_interface->entry_head_insert(
+ rec_ptr,
+ user_data,
+ &enable_data);
+
+ if (ret)
+ {
+ IPAERR("unable to insert a new entry to the head in %s\n", table->name);
+ goto bail;
+ }
+
+ ipa_table_add_dma_cmd(
+ table,
+ HELP_UPDATE_HEAD,
+ rec_ptr,
+ rec_index,
+ enable_data,
+ cmd);
+
+ ++table->cur_tbl_cnt;
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+static int InsertTail(
+ ipa_table* table,
+ void* rec_ptr, /* occupied record at index below */
+ uint16_t* rec_index_ptr, /* pointer to index of record above */
+ void* user_data,
+ struct ipa_ioc_nat_dma_cmd* cmd )
+{
+ bool is_index_tbl = (table->meta) ? true : false;
+
+ ipa_table_iterator iterator;
+
+ uint16_t enable_data = 0;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ /*
+ * The most important side effect of the following is to set the
+ * iterator's prev_index and prev_entry...which will be the last
+ * valid entry on the end of the list.
+ */
+ ret = ipa_table_iterator_end(&iterator, table, *rec_index_ptr, rec_ptr);
+
+ if ( ret )
+ {
+ IPAERR("Failed to reach the end of list following rec_index(%u) in %s\n",
+ *rec_index_ptr, table->name);
+ goto bail;
+ }
+
+ /*
+ * The most important side effect of the following is to set the
+ * iterator's curr_index and curr_entry with the next available
+ * expansion table open slot.
+ */
+ ret = FindExpnTblFreeEntry(table, &iterator.curr_entry, &iterator.curr_index);
+
+ if ( ret )
+ {
+ IPAERR("FindExpnTblFreeEntry of %s failed\n", table->name);
+ goto bail;
+ }
+
+ /*
+ * Copy data into curr_entry (ie. open slot).
+ */
+ if ( is_index_tbl )
+ {
+ ret = table->entry_interface->entry_tail_insert(
+ iterator.curr_entry,
+ user_data);
+ }
+ else
+ {
+ /*
+ * We need enable bit when not index table, hence...
+ */
+ ret = table->entry_interface->entry_head_insert(
+ iterator.curr_entry,
+ user_data,
+ &enable_data);
+ }
+
+ if (ret)
+ {
+ IPAERR("Unable to insert a new entry to the tail in %s\n", table->name);
+ goto bail;
+ }
+
+ /*
+ * Update curr_entry's prev_index field with iterator.prev_index
+ */
+ table->entry_interface->entry_set_prev_index(
+ iterator.curr_entry, /* set by FindExpnTblFreeEntry above */
+ iterator.curr_index, /* set by FindExpnTblFreeEntry above */
+ iterator.prev_index, /* set by ipa_table_iterator_end above */
+ table->meta,
+ table->table_entries);
+
+ if ( ! is_index_tbl )
+ {
+ /*
+ * Generate dma command to have the IPA update the
+ * curr_entry's enable field when not the index table...
+ */
+ ipa_table_add_dma_cmd(
+ table,
+ HELP_UPDATE_HEAD,
+ iterator.curr_entry,
+ iterator.curr_index,
+ enable_data,
+ cmd);
+ }
+
+ /*
+ * Generate a dma command to have the IPA update the prev_entry's
+ * next_index with iterator.curr_index.
+ */
+ ipa_table_add_dma_cmd(
+ table,
+ HELP_UPDATE_ENTRY,
+ iterator.prev_entry,
+ iterator.prev_index,
+ iterator.curr_index,
+ cmd);
+
+ ++table->cur_expn_tbl_cnt;
+
+ *rec_index_ptr = iterator.curr_index;
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/**
+ * MakeEntryHdl() - makes an entry handle
+ * @tbl_hdl: [in] tbl - the table
+ * @tbl_entry: [in] tbl_entry - table entry
+ *
+ * Calculate the entry handle which will be returned to client
+ *
+ * Returns: >0 table entry handle
+ */
+static uint16_t MakeEntryHdl(
+ ipa_table* tbl,
+ uint16_t tbl_entry )
+{
+ uint16_t entry_hdl = 0;
+
+ IPADBG("In\n");
+
+ if (tbl_entry >= tbl->table_entries)
+ {
+ /*
+ * Update the index into table
+ */
+ entry_hdl = tbl_entry - tbl->table_entries;
+ entry_hdl = (entry_hdl << IPA_TABLE_TYPE_BITS);
+ /*
+ * Update the expansion table type bit
+ */
+ entry_hdl = (entry_hdl | IPA_TABLE_TYPE_MASK);
+ }
+ else
+ {
+ entry_hdl = tbl_entry;
+ entry_hdl = (entry_hdl << IPA_TABLE_TYPE_BITS);
+ }
+
+ /*
+ * Set memory type bit.
+ */
+ entry_hdl = entry_hdl | (tbl->nmi << IPA_TABLE_TYPE_MEM_SHIFT);
+
+ IPADBG("In: tbl_entry(%u) Out: entry_hdl(%u)\n", tbl_entry, entry_hdl);
+
+ IPADBG("Out\n");
+
+ return entry_hdl;
+}
+
+static int mt_slot(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
+{
+ UNUSED(table_ptr);
+ UNUSED(rule_hdl);
+ UNUSED(record_ptr);
+ UNUSED(meta_record_ptr);
+ UNUSED(meta_record_index);
+ UNUSED(arb_data_ptr);
+
+ IPADBG("%s: Empty expansion slot: (%u) in table of size: (%u)\n",
+ table_ptr->name,
+ record_index,
+ table_ptr->tot_tbl_ents);
+
+ return record_index;
+}
+
+/*
+ * returns expn table entry absolute index
+ */
+static int FindExpnTblFreeEntry(
+ ipa_table* table,
+ void** free_entry,
+ uint16_t* entry_index )
+{
+ int ret;
+
+ IPADBG("In\n");
+
+ if ( ! table || ! free_entry || ! entry_index )
+ {
+ IPAERR("Bad arg: table(%p) and/or "
+ "free_entry(%p) and/or entry_index(%p)\n",
+ table, free_entry, entry_index);
+ ret = -1;
+ goto bail;
+ }
+
+ *entry_index = 0;
+ *free_entry = NULL;
+
+ /*
+ * The following will start walk at expansion slots
+ * (ie. just after table->table_entries)...
+ */
+ ret = ipa_table_walk(table, table->table_entries, WHEN_SLOT_EMPTY, mt_slot, 0);
+
+ if ( ret > 0 )
+ {
+ *entry_index = (uint16_t) ret;
+
+ *free_entry = GOTO_REC(table, *entry_index);
+
+ IPADBG("%s: entry_index val (%u) free_entry val (%p)\n",
+ table->name,
+ *entry_index,
+ *free_entry);
+
+ ret = 0;
+ }
+ else
+ {
+ if ( ret < 0 )
+ {
+ IPAERR("%s: While searching table for emtpy slot\n",
+ table->name);
+ }
+ else
+ {
+ IPADBG("%s: No empty slots (ie. expansion table full): "
+ "BASE (avail/used): (%u/%u) EXPN (avail/used): (%u/%u)\n",
+ table->name,
+ table->table_entries,
+ table->cur_tbl_cnt,
+ table->expn_table_entries,
+ table->cur_expn_tbl_cnt);
+ }
+
+ ret = -1;
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+/**
+ * Get2PowerTightUpperBound() - Returns the tight upper bound which is a power of 2
+ * @num: [in] given number
+ *
+ * Returns the tight upper bound for a given number which is power of 2
+ *
+ * Returns: the tight upper bound which is power of 2
+ */
+static int Get2PowerTightUpperBound(uint16_t num)
+{
+ uint16_t tmp = num, prev = 0, curr = 2;
+
+ if (num == 0)
+ return 2;
+
+ while (tmp != 1)
+ {
+ prev = curr;
+ curr <<= 1;
+ tmp >>= 1;
+ }
+
+ return (num == prev) ? prev : curr;
+}
+
+/**
+ * GetEvenTightUpperBound() - Returns the tight upper bound which is an even number
+ * @num: [in] given number
+ *
+ * Returns the tight upper bound for a given number which is an even number
+ *
+ * Returns: the tight upper bound which is an even number
+ */
+static int GetEvenTightUpperBound(uint16_t num)
+{
+ if (num == 0)
+ return 2;
+
+ return (num % 2) ? num + 1 : num;
+}
+
+int ipa_calc_num_sram_table_entries(
+ uint32_t sram_size,
+ uint32_t table1_ent_size,
+ uint32_t table2_ent_size,
+ uint16_t* num_entries_ptr)
+{
+ ipa_table nat_table;
+ ipa_table index_table;
+ int size = 0;
+ uint16_t tot;
+
+ IPADBG("In\n");
+
+ IPADBG("sram_size(%x or %u)\n", sram_size, sram_size);
+
+ *num_entries_ptr = 0;
+
+ tot = 1;
+
+ while ( 1 )
+ {
+ IPADBG("Trying %u entries\n", tot);
+
+ ipa_table_init(&nat_table,
+ "tmp_sram_table1",
+ IPA_NAT_MEM_IN_DDR,
+ table1_ent_size,
+ NULL,
+ 0,
+ NULL);
+
+ ipa_table_init(&index_table,
+ "tmp_sram_table1",
+ IPA_NAT_MEM_IN_DDR,
+ table2_ent_size,
+ NULL,
+ 0,
+ NULL);
+
+ nat_table.table_entries = index_table.table_entries =
+ Get2PowerTightUpperBound(tot * IPA_BASE_TABLE_PCNT_4SRAM);
+ nat_table.expn_table_entries = index_table.expn_table_entries =
+ GetEvenTightUpperBound(tot * IPA_EXPANSION_TABLE_PCNT_4SRAM);
+
+ size = ipa_table_calculate_size(&nat_table);
+ size += ipa_table_calculate_size(&index_table);
+
+ IPADBG("%u entries consumes size(0x%x or %u)\n", tot, size, size);
+
+ if ( size > sram_size )
+ break;
+
+ *num_entries_ptr = tot;
+
+ ++tot;
+ }
+
+ IPADBG("Optimal number of entries: %u\n", *num_entries_ptr);
+
+ IPADBG("Out\n");
+
+ return (*num_entries_ptr) ? 0 : -1;
+}
+
+int ipa_table_walk(
+ ipa_table* ipa_tbl_ptr,
+ uint16_t start_index,
+ When2Callback when2cb,
+ ipa_table_walk_cb walk_cb,
+ void* arb_data_ptr )
+{
+ uint16_t i;
+ uint32_t tot;
+ uint8_t* rec_ptr;
+ void* meta_record_ptr;
+ uint16_t meta_record_index;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! ipa_tbl_ptr ||
+ ! VALID_WHEN2CALLBACK(when2cb) ||
+ ! walk_cb )
+ {
+ IPAERR("Bad arg: ipa_tbl_ptr(%p) and/or "
+ "when2cb(%u) and/or walk_cb(%p)\n",
+ ipa_tbl_ptr,
+ when2cb,
+ walk_cb);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ tot =
+ ipa_tbl_ptr->table_entries +
+ ipa_tbl_ptr->expn_table_entries;
+
+ if ( start_index >= tot )
+ {
+ IPAERR("Bad arg: start_index(%u)\n", start_index);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ /*
+ * Go through table...
+ */
+ for ( i = start_index, rec_ptr = GOTO_REC(ipa_tbl_ptr, start_index);
+ i < tot;
+ i++, rec_ptr += ipa_tbl_ptr->entry_size )
+ {
+ bool call_back;
+
+ if ( ipa_tbl_ptr->entry_interface->entry_is_valid(rec_ptr) )
+ {
+ call_back = (when2cb == WHEN_SLOT_FILLED) ? true : false;
+ }
+ else
+ {
+ call_back = (when2cb == WHEN_SLOT_EMPTY) ? true : false;
+ }
+
+ if ( call_back )
+ {
+ uint32_t rule_hdl = MakeEntryHdl(ipa_tbl_ptr, i);
+
+ meta_record_ptr = NULL;
+ meta_record_index = 0;
+
+ if ( i >= ipa_tbl_ptr->table_entries && ipa_tbl_ptr->meta )
+ {
+ meta_record_index = i - ipa_tbl_ptr->table_entries;
+
+ meta_record_ptr = (uint8_t*) ipa_tbl_ptr->meta +
+ (meta_record_index * ipa_tbl_ptr->meta_entry_size);
+ }
+
+ ret = walk_cb(
+ ipa_tbl_ptr,
+ rule_hdl,
+ rec_ptr,
+ i,
+ meta_record_ptr,
+ meta_record_index,
+ arb_data_ptr);
+
+ if ( ret != 0 )
+ {
+ if ( ret < 0 )
+ {
+ IPAERR("walk_cb returned non-zero (%d)\n", ret);
+ }
+ else
+ {
+ IPADBG("walk_cb returned non-zero (%d)\n", ret);
+ }
+ goto bail;
+ }
+ }
+ }
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
+
+int ipa_table_add_dma_cmd(
+ ipa_table* tbl_ptr,
+ dma_help_type help_type,
+ void* rec_ptr,
+ uint16_t rec_index,
+ uint16_t data_for_entry,
+ struct ipa_ioc_nat_dma_cmd* cmd_ptr )
+{
+ uint32_t tab_sz, entry_offset;
+
+ uint8_t is_expn;
+
+ int ret = 0;
+
+ IPADBG("In\n");
+
+ if ( ! tbl_ptr ||
+ ! VALID_DMA_HELP_TYPE(help_type) ||
+ ! rec_ptr ||
+ ! cmd_ptr )
+ {
+ IPAERR("Bad arg: tbl_ptr(%p) and/or help_type(%u) "
+ "and/or rec_ptr(%p) and/or cmd_ptr(%p)\n",
+ tbl_ptr,
+ help_type,
+ rec_ptr,
+ cmd_ptr);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ tab_sz =
+ tbl_ptr->table_entries +
+ tbl_ptr->expn_table_entries;
+
+ if ( rec_index >= tab_sz )
+ {
+ IPAERR("Bad arg: rec_index(%u)\n", rec_index);
+ ret = -EINVAL;
+ goto bail;
+ }
+
+ is_expn = (rec_index >= tbl_ptr->table_entries);
+
+ entry_offset = (uint8_t*) rec_ptr -
+ ((is_expn) ? tbl_ptr->expn_table_addr : tbl_ptr->table_addr);
+
+ ipa_table_dma_cmd_generate(
+ tbl_ptr->dma_help[help_type],
+ is_expn,
+ entry_offset,
+ data_for_entry,
+ cmd_ptr);
+
+bail:
+ IPADBG("Out\n");
+
+ return ret;
+}
diff --git a/ipanat/test/Android.mk b/ipanat/test/Android.mk
index b8ae6a4..b026794 100644
--- a/ipanat/test/Android.mk
+++ b/ipanat/test/Android.mk
@@ -14,7 +14,9 @@
LOCAL_ADDITIONAL_DEPENDENCIES := $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
LOCAL_MODULE := ipa_nat_test
-LOCAL_SRC_FILES := ipa_nat_test000.c \
+LOCAL_SRC_FILES := \
+ ipa_nat_testREG.c \
+ ipa_nat_test000.c \
ipa_nat_test001.c \
ipa_nat_test002.c \
ipa_nat_test003.c \
@@ -37,9 +39,12 @@
ipa_nat_test020.c \
ipa_nat_test021.c \
ipa_nat_test022.c \
+ ipa_nat_test023.c \
+ ipa_nat_test024.c \
+ ipa_nat_test025.c \
+ ipa_nat_test999.c \
main.c
-
LOCAL_SHARED_LIBRARIES := libipanat
LOCAL_MODULE_TAGS := debug
diff --git a/ipanat/test/Makefile.am b/ipanat/test/Makefile.am
index 3aec070..cefa7ed 100644
--- a/ipanat/test/Makefile.am
+++ b/ipanat/test/Makefile.am
@@ -2,9 +2,11 @@
-I$(top_srcdir)/ipanat/inc
AM_CPPFLAGS += -Wall -Wundef -Wno-trigraphs
-AM_CPPFLAGS += -g
+AM_CPPFLAGS += -g -DDEBUG -DNAT_DEBUG
-ipanattest_SOURCES = ipa_nat_test000.c \
+ipanattest_SOURCES = \
+ ipa_nat_testREG.c \
+ ipa_nat_test000.c \
ipa_nat_test001.c \
ipa_nat_test002.c \
ipa_nat_test003.c \
@@ -27,9 +29,12 @@
ipa_nat_test020.c \
ipa_nat_test021.c \
ipa_nat_test022.c \
+ ipa_nat_test023.c \
+ ipa_nat_test024.c \
+ ipa_nat_test025.c \
+ ipa_nat_test999.c \
main.c
-
bin_PROGRAMS = ipanattest
requiredlibs = ../src/libipanat.la
@@ -39,4 +44,3 @@
LOCAL_MODULE := libipanat
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)
-
diff --git a/ipanat/test/README.txt b/ipanat/test/README.txt
index 4e87121..9a84b10 100644
--- a/ipanat/test/README.txt
+++ b/ipanat/test/README.txt
@@ -1,18 +1,66 @@
-1 To run this suite separately(each test case creates table and delete table) use below command
- - To execute test suite nt times with n entries, command "ipanatest sep nt n"
+INTRODUCTION
+------------
- Example: To execute test suite 1 time with 100 entries, command "ipanattest sep 100"
+The ipanattest allow its user to drive NAT testing. It is run thusly:
+# ipanattest [-d -r N -i N -e N -m mt]
+Where:
+ -d Each test is discrete (create table, add rules, destroy table)
+ If not specified, only one table create and destroy for all tests
+ -r N Where N is the number of times to run the inotify regression test
+ -i N Where N is the number of times (iterations) to run test
+ -e N Where N is the number of entries in the NAT
+ -m mt Where mt is the type of memory to use for the NAT
+ Legal mt's: DDR, SRAM, or HYBRID (ie. use SRAM and DDR)
+ -g M-N Run tests M through N only
-2. To run test suite not separately(creates table and delete table only once) use below command
- - To execute test suite nt times with n entries, command "ipanatest reg nt n"
+More about each command line option:
- Example: To execute test suite 5 times with 32 entries, command "ipanattest reg 5 32"
+-d Makes each test discrete; meaning that, each test will create a
+ table, add rules, then destory the table.
+ Conversely, when -d not specified, each test will not create
+ and destroy a table. Only one table create and destroy at the
+ start and end of the run...with all test being run in between.
-3. To run inotify regression test use command, "ipanattest inotify nt"
+-r N Will cause the inotify regression test to be run N times.
- Example: To execute inotify 5 times, command "ipanattest inotify 5"
+-i N Will cause each test to be run N times
+-e N Will cause the creation of a table with N entries
-4. if we just give command "ipanattest", runs test suite 1 time with 100 entries (non separate)
+-m mt Will cause the NAT to live in either SRAM, DDR, or both
+ (ie. HYBRID)
+
+-g M-N Will cause test M to N to be run. This allows you to skip
+ or isolate tests
+
+When run with no arguments (ie. defaults):
+
+ 1) The tests will be non-discrete
+ 2) With only one iteration of the tests
+ 3) On a DDR based table with one hundred entries
+ 4) No inotify regression will be run
+
+EXAMPLE COMMAND LINES
+---------------------
+
+To execute discrete tests (create, add rules, and delete table for
+each test) one time on a table with one hundred entries:
+
+# ipanattest -d -i 1 -e 100
+
+To execute non-discrete (create and delete table only once) tests five
+times on a table with thirty-two entries:
+
+# ipanattest -i 5 -e 32
+
+To execute inotify regression test 5 times
+
+# ipanattest -r 5
+
+ADDING NEW TESTS
+----------------
+
+In main.c, please see and embellish nt_array[] and use the following
+file as a model: ipa_nat_testMODEL.c
diff --git a/ipanat/test/ipa_nat_test.h b/ipanat/test/ipa_nat_test.h
index d5ac0d5..150e4b6 100644
--- a/ipanat/test/ipa_nat_test.h
+++ b/ipanat/test/ipa_nat_test.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -27,78 +27,154 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-/*===========================================================================
-
- INCLUDE FILES FOR MODULE
-
-===========================================================================*/
-#include "stdint.h" /* uint32_t */
-#include "stdio.h"
+/*
+ * ===========================================================================
+ *
+ * INCLUDE FILES FOR MODULE
+ *
+ * ===========================================================================
+ */
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <time.h>
#include <netinet/in.h> /* for proto definitions */
+#include "ipa_nat_drv.h"
+#include "ipa_nat_drvi.h"
+
+#undef array_sz
+#define array_sz(a) \
+ ( sizeof(a)/sizeof(a[0]) )
+
#define u32 uint32_t
#define u16 uint16_t
#define u8 uint8_t
+#define RAN_ADDR rand_ip_addr()
+#define RAN_PORT rand_ip_port()
+
+static inline u32 rand_ip_addr()
+{
+ static char buf[64];
+
+ snprintf(
+ buf, sizeof(buf),
+ "%u.%u.%u.%u",
+ (rand() % 254) + 1,
+ rand() % 255,
+ rand() % 255,
+ (rand() % 254) + 1);
+
+ return (u32) inet_addr(buf);
+}
+
+static inline u16 rand_ip_port()
+{
+ return (u16) ((rand() % 60535) + 5000);
+}
+
/*============ Preconditions to run NAT Test cases =========*/
#define IPA_NAT_TEST_PRE_COND_TE 20
-#define CHECK_ERR1(x, tbl_hdl) \
- if(ipa_nat_validate_ipv4_table(tbl_hdl)) { \
- if(sep) {\
- ipa_nat_del_ipv4_tbl(tbl_hdl); \
- }\
- return -1;\
- }\
- if(x) { \
- IPAERR("%d\n", ret); \
- if(sep) {\
- ipa_nat_del_ipv4_tbl(tbl_hdl); \
- }\
- return -1; \
- }
+#define CHECK_ERR(x) \
+ if ( x ) { \
+ IPAERR("Abrupt end of %s with " \
+ "err: %d at line: %d\n", \
+ __FUNCTION__, x, __LINE__); \
+ return -1; \
+ }
-#define CHECK_ERR(x) if(x) { \
- IPAERR("%d\n", ret); \
- return -1;\
- }
+#define CHECK_ERR_TBL_STOP(x, th) \
+ if ( th ) { \
+ int _ter_ = ipa_nat_validate_ipv4_table(th); \
+ if ( _ter_ ) { \
+ if ( sep ) { \
+ ipa_nat_del_ipv4_tbl(th); \
+ } \
+ IPAERR("Abrupt end of %s with " \
+ "err: %d at line: %d\n", \
+ __FUNCTION__, _ter_, __LINE__); \
+ return -1; \
+ } \
+ } \
+ if ( x ) { \
+ if ( th ) { \
+ ipa_nat_dump_ipv4_table(th); \
+ if( sep ) { \
+ ipa_nat_del_ipv4_tbl(th); \
+ } \
+ } \
+ IPAERR("Abrupt end of %s with " \
+ "err: %d at line: %d\n", \
+ __FUNCTION__, x, __LINE__); \
+ return -1; \
+ }
-#if 0
-#define CHECK_ERR(x) if(x) { \
- IPAERR("%d\n", ret); \
- if(sep) {\
- ipa_nat_del_ipv4_tbl(tbl_hdl); \
- }\
- return -1;\
- }
-#endif
+#define CHECK_ERR_TBL_ACTION(x, th, action) \
+ if ( th ) { \
+ int _ter_ = ipa_nat_validate_ipv4_table(th); \
+ if ( _ter_ ) { \
+ IPAERR("ipa_nat_validate_ipv4_table() failed " \
+ "in: %s at line: %d\n", \
+ __FUNCTION__, __LINE__); \
+ action; \
+ } \
+ } \
+ if ( x ) { \
+ if ( th ) { \
+ ipa_nat_dump_ipv4_table(th); \
+ } \
+ IPAERR("error: %d in %s at line: %d\n", \
+ x, __FUNCTION__, __LINE__); \
+ action; \
+ }
-#define IPADBG(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
-#define IPAERR(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
+typedef int (*NatTestFunc)(
+ const char*, u32, int, u32, int, void*);
-#define NAT_DUMP
+typedef struct
+{
+ const char* func_name;
+ int num_ents_trigger;
+ int test_hold_time_in_secs;
+ NatTestFunc func;
+} NatTests;
+
+#undef NAT_TEST_ENTRY
+#define NAT_TEST_ENTRY(f, n, ht) \
+ {#f, (n), (ht), f}
+
+#define NAT_DEBUG
int ipa_nat_validate_ipv4_table(u32);
-int ipa_nat_test000(int, u32, u8);
-int ipa_nat_test001(int, u32, u8);
-int ipa_nat_test002(int, u32, u8);
-int ipa_nat_test003(int, u32, u8);
-int ipa_nat_test004(int, u32, u8);
-int ipa_nat_test005(int, u32, u8);
-int ipa_nat_test006(int, u32, u8);
-int ipa_nat_test007(int, u32, u8);
-int ipa_nat_test008(int, u32, u8);
-int ipa_nat_test009(int, u32, u8);
-int ipa_nat_test010(int, u32, u8);
-int ipa_nat_test011(int, u32, u8);
-int ipa_nat_test012(int, u32, u8);
-int ipa_nat_test013(int, u32, u8);
-int ipa_nat_test014(int, u32, u8);
-int ipa_nat_test015(int, u32, u8);
-int ipa_nat_test016(int, u32, u8);
-int ipa_nat_test017(int, u32, u8);
-int ipa_nat_test018(int, u32, u8);
-int ipa_nat_test019(int, u32, u8);
-int ipa_nat_test020(int, u32, u8);
-int ipa_nat_test021(int, int);
-int ipa_nat_test022(int, u32, u8);
+int ipa_nat_testREG(const char*, u32, int, u32, int, void*);
+
+int ipa_nat_test000(const char*, u32, int, u32, int, void*);
+int ipa_nat_test001(const char*, u32, int, u32, int, void*);
+int ipa_nat_test002(const char*, u32, int, u32, int, void*);
+int ipa_nat_test003(const char*, u32, int, u32, int, void*);
+int ipa_nat_test004(const char*, u32, int, u32, int, void*);
+int ipa_nat_test005(const char*, u32, int, u32, int, void*);
+int ipa_nat_test006(const char*, u32, int, u32, int, void*);
+int ipa_nat_test007(const char*, u32, int, u32, int, void*);
+int ipa_nat_test008(const char*, u32, int, u32, int, void*);
+int ipa_nat_test009(const char*, u32, int, u32, int, void*);
+int ipa_nat_test010(const char*, u32, int, u32, int, void*);
+int ipa_nat_test011(const char*, u32, int, u32, int, void*);
+int ipa_nat_test012(const char*, u32, int, u32, int, void*);
+int ipa_nat_test013(const char*, u32, int, u32, int, void*);
+int ipa_nat_test014(const char*, u32, int, u32, int, void*);
+int ipa_nat_test015(const char*, u32, int, u32, int, void*);
+int ipa_nat_test016(const char*, u32, int, u32, int, void*);
+int ipa_nat_test017(const char*, u32, int, u32, int, void*);
+int ipa_nat_test018(const char*, u32, int, u32, int, void*);
+int ipa_nat_test019(const char*, u32, int, u32, int, void*);
+int ipa_nat_test020(const char*, u32, int, u32, int, void*);
+int ipa_nat_test021(const char*, u32, int, u32, int, void*);
+int ipa_nat_test022(const char*, u32, int, u32, int, void*);
+int ipa_nat_test023(const char*, u32, int, u32, int, void*);
+int ipa_nat_test024(const char*, u32, int, u32, int, void*);
+int ipa_nat_test025(const char*, u32, int, u32, int, void*);
+int ipa_nat_test999(const char*, u32, int, u32, int, void*);
diff --git a/ipanat/test/ipa_nat_test000.c b/ipanat/test/ipa_nat_test000.c
index 09914ea..764a048 100644
--- a/ipanat/test/ipa_nat_test000.c
+++ b/ipanat/test/ipa_nat_test000.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2020 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
@@ -35,35 +35,36 @@
@brief
Verify the following scenario:
1. Add ipv4 table
- 2. Delete ipv4 table
*/
/*===========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test000(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test000(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
- int ret;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ int ret;
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- if (0 != ret)
+ IPADBG("In\n");
+
+ if ( ! sep )
{
- IPAERR("unable to create ipv4 nat table and returning Error:%d\n", ret);
- return -1;
- }
- IPADBG("create nat ipv4 table successfully() \n");
+ IPADBG("calling ipa_nat_add_ipv4_tbl()\n");
- IPADBG("calling ipa_nat_del_ipv4_tbl() \n");
- ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
- if (0 != ret)
- {
- IPAERR("Unable to delete ipv4 nat table %d\n", ret);
- return -1;
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, tbl_hdl_ptr);
+ CHECK_ERR_TBL_STOP(ret, *tbl_hdl_ptr);
+
+ IPADBG("create nat ipv4 table successfully()\n");
}
- IPADBG("deleted ipv4 nat table successfully. Test passed \n");
+
+ IPADBG("Out\n");
return 0;
}
diff --git a/ipanat/test/ipa_nat_test001.c b/ipanat/test/ipa_nat_test001.c
index 8daef33..08942d2 100644
--- a/ipanat/test/ipa_nat_test001.c
+++ b/ipanat/test/ipa_nat_test001.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -41,37 +41,48 @@
/*===========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test001(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test001(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s()\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ if ( sep )
+ {
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test002.c b/ipanat/test/ipa_nat_test002.c
index e6f5ae3..83992ec 100644
--- a/ipanat/test/ipa_nat_test002.c
+++ b/ipanat/test/ipa_nat_test002.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,44 +42,51 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test002(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test002(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
-
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s()\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test003.c b/ipanat/test/ipa_nat_test003.c
index 0634265..6082620 100644
--- a/ipanat/test/ipa_nat_test003.c
+++ b/ipanat/test/ipa_nat_test003.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,40 +43,62 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test003(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test003(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ ipa_nat_ipv4_rule ipv4_rule = {0};
+ u32 rule_hdl;
+
int ret;
- u32 rule_hdl, rule_hdl1;
- ipa_nat_ipv4_rule ipv4_rule;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
+ IPADBG("In\n");
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ if ( sep )
+ {
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
+
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
+
+ ipv4_rule.protocol = IPPROTO_TCP;
+ ipv4_rule.public_port = RAN_PORT;
+
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
-
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
-
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
-
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test004.c b/ipanat/test/ipa_nat_test004.c
index 02378ff..32936f1 100644
--- a/ipanat/test/ipa_nat_test004.c
+++ b/ipanat/test/ipa_nat_test004.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -35,36 +35,49 @@
@brief
Verify the following scenario:
1. Add ipv4 table
- 2. Query nat table handle
+ 2. Delete a bogus table handle
3. Delete ipv4 table
*/
/*===========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test004(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test004(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret = 0;
- u32 tbl_hdl1 = 0;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ u32 tbl_hdl1 = 0xFFFFFFFF;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
-
- ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
- CHECK_ERR(ret);
-
- ret = ipa_nat_del_ipv4_tbl(tbl_hdl1);
- if(ret == 0)
- {
- IPAERR("able to delete table using invalid table handle\n");
- return -1;
- }
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
+
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl1); /* intentionally pass bad handle */
+
+ if ( ret == 0 )
+ {
+ IPAERR("Able to delete table using invalid table handle\n");
+ CHECK_ERR_TBL_STOP(-1, tbl_hdl);
+ }
+
+ if ( sep )
+ {
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
+ }
+
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test005.c b/ipanat/test/ipa_nat_test005.c
index 12228d1..8ee78fc 100644
--- a/ipanat/test/ipa_nat_test005.c
+++ b/ipanat/test/ipa_nat_test005.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,41 +43,55 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test005(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test005(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
- int ret = 0;
- u32 rule_hdl, rule_hdl1;
- ipa_nat_ipv4_rule ipv4_rule;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
+ u32 rule_hdl;
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
+ int ret;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- if (sep)
+ IPADBG("In\n");
+
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ if ( sep )
+ {
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test006.c b/ipanat/test/ipa_nat_test006.c
index 36f0171..7de4f91 100644
--- a/ipanat/test/ipa_nat_test006.c
+++ b/ipanat/test/ipa_nat_test006.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -35,57 +35,67 @@
@brief
Verify the following scenario:
1. Add ipv4 table
- 2. add same ipv rules
- 3. delete first followed by second
- 4. Delete ipv4 table
+ 2. Add ipv rule
+ 3. Add same ipv rule
+ 4. Delete first followed by second
+ 5. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test006(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test006(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
- int ret=0;
- u32 rule_hdl, rule_hdl1;
- ipa_nat_ipv4_rule ipv4_rule;
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
+ u32 rule_hdl;
+ u32 rule_hdl1;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ int ret;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test007.c b/ipanat/test/ipa_nat_test007.c
index 4160c02..4d26592 100644
--- a/ipanat/test/ipa_nat_test007.c
+++ b/ipanat/test/ipa_nat_test007.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,47 +42,59 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test007(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test007(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ ipa_nat_ipv4_rule ipv4_rule = {0};
+
+ u32 rule_hdl;
+ u32 rule_hdl1;
+
int ret;
- u32 rule_hdl, rule_hdl1;
- ipa_nat_ipv4_rule ipv4_rule;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test008.c b/ipanat/test/ipa_nat_test008.c
index d016055..350e6f9 100644
--- a/ipanat/test/ipa_nat_test008.c
+++ b/ipanat/test/ipa_nat_test008.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,53 +42,62 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test008(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test008(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl, rule_hdl1;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1;
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule1 = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
- ipv4_rule1.target_ip = 0xC1171602; /* 193.23.22.2 */
- ipv4_rule1.target_port = 1234;
- ipv4_rule1.private_ip = 0xC2171602; /* 194.23.22.2 */
- ipv4_rule1.private_port = 5678;
+ ipv4_rule.public_port = RAN_PORT;
+
+ ipv4_rule1.target_ip = RAN_ADDR;
+ ipv4_rule1.target_port = RAN_PORT;
+ ipv4_rule1.private_ip = RAN_ADDR;
+ ipv4_rule1.private_port = RAN_PORT;
ipv4_rule1.protocol = IPPROTO_TCP;
- ipv4_rule1.public_port = 9050;
+ ipv4_rule1.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test009.c b/ipanat/test/ipa_nat_test009.c
index cf3c40f..7cf74a4 100644
--- a/ipanat/test/ipa_nat_test009.c
+++ b/ipanat/test/ipa_nat_test009.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,55 +42,62 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test009(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test009(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl, rule_hdl1;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1;
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule1 = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- ipv4_rule1.target_ip = 0xC1171602; /* 193.23.22.2 */
- ipv4_rule1.target_port = 1234;
- ipv4_rule1.private_ip = 0xC2171602; /* 194.23.22.2 */
- ipv4_rule1.private_port = 5678;
+ ipv4_rule1.target_ip = RAN_ADDR;
+ ipv4_rule1.target_port = RAN_PORT;
+ ipv4_rule1.private_ip = RAN_ADDR;
+ ipv4_rule1.private_port = RAN_PORT;
ipv4_rule1.protocol = IPPROTO_TCP;
- ipv4_rule1.public_port = 9050;
+ ipv4_rule1.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test010.c b/ipanat/test/ipa_nat_test010.c
index 42d7fee..7d9cd88 100644
--- a/ipanat/test/ipa_nat_test010.c
+++ b/ipanat/test/ipa_nat_test010.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,67 +42,75 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test010(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test010(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule1 = {0}, ipv4_rule2 = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- ipv4_rule1.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule1.target_port = 1235;
- ipv4_rule1.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule1.private_port = 5679;
+ ipv4_rule1.target_ip = RAN_ADDR;
+ ipv4_rule1.target_port = RAN_PORT;
+ ipv4_rule1.private_ip = RAN_ADDR;
+ ipv4_rule1.private_port = RAN_PORT;
ipv4_rule1.protocol = IPPROTO_TCP;
- ipv4_rule1.public_port = 9051;
+ ipv4_rule1.public_port = RAN_PORT;
- ipv4_rule2.target_ip = 0xC1171602; /* 193.23.22.2 */
- ipv4_rule2.target_port = 1235;
- ipv4_rule2.private_ip = 0xC2171602; /* 194.23.22.2 */
- ipv4_rule2.private_port = 5679;
+ ipv4_rule2.target_ip = RAN_ADDR;
+ ipv4_rule2.target_port = RAN_PORT;
+ ipv4_rule2.private_ip = RAN_ADDR;
+ ipv4_rule2.private_port = RAN_PORT;
ipv4_rule2.protocol = IPPROTO_TCP;
- ipv4_rule2.public_port = 9051;
+ ipv4_rule2.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
- if(sep)
+ IPADBG("In\n");
+
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test011.c b/ipanat/test/ipa_nat_test011.c
index bcce76c..525a37f 100644
--- a/ipanat/test/ipa_nat_test011.c
+++ b/ipanat/test/ipa_nat_test011.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,67 +42,75 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test011(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test011(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule1 = {0}, ipv4_rule2 = {0};
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- ipv4_rule1.target_ip = 0xF1181601;
- ipv4_rule1.target_port = 1555;
- ipv4_rule1.private_ip = 0xF2151601;
- ipv4_rule1.private_port = 5999;
+ ipv4_rule1.target_ip = RAN_ADDR;
+ ipv4_rule1.target_port = RAN_PORT;
+ ipv4_rule1.private_ip = RAN_ADDR;
+ ipv4_rule1.private_port = RAN_PORT;
ipv4_rule1.protocol = IPPROTO_TCP;
- ipv4_rule1.public_port = 9111;
+ ipv4_rule1.public_port = RAN_PORT;
- ipv4_rule2.target_ip = 0xC1166602;
- ipv4_rule2.target_port = 1555;
- ipv4_rule2.private_ip = 0xC2155602;
- ipv4_rule2.private_port = 5777;
+ ipv4_rule2.target_ip = RAN_ADDR;
+ ipv4_rule2.target_port = RAN_PORT;
+ ipv4_rule2.private_ip = RAN_ADDR;
+ ipv4_rule2.private_port = RAN_PORT;
ipv4_rule2.protocol = IPPROTO_TCP;
- ipv4_rule2.public_port = 9000;
+ ipv4_rule2.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test012.c b/ipanat/test/ipa_nat_test012.c
index 9d3c835..81c7d72 100644
--- a/ipanat/test/ipa_nat_test012.c
+++ b/ipanat/test/ipa_nat_test012.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,68 +42,75 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-
-int ipa_nat_test012(int totoal_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test012(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule1 = {0}, ipv4_rule2 = {0};
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- ipv4_rule1.target_ip = 0xD1171601;
- ipv4_rule1.target_port = 3512;
- ipv4_rule1.private_ip = 0xD2471601;
- ipv4_rule1.private_port = 9997;
+ ipv4_rule1.target_ip = RAN_ADDR;
+ ipv4_rule1.target_port = RAN_PORT;
+ ipv4_rule1.private_ip = RAN_ADDR;
+ ipv4_rule1.private_port = RAN_PORT;
ipv4_rule1.protocol = IPPROTO_TCP;
- ipv4_rule1.public_port = 8881;
+ ipv4_rule1.public_port = RAN_PORT;
- ipv4_rule2.target_ip = 0xC1172452;
- ipv4_rule2.target_port = 1895;
- ipv4_rule2.private_ip = 0xC2172452;
- ipv4_rule2.private_port = 6668;
+ ipv4_rule2.target_ip = RAN_ADDR;
+ ipv4_rule2.target_port = RAN_PORT;
+ ipv4_rule2.private_ip = RAN_ADDR;
+ ipv4_rule2.private_port = RAN_PORT;
ipv4_rule2.protocol = IPPROTO_TCP;
- ipv4_rule2.public_port = 5551;
+ ipv4_rule2.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, totoal_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test013.c b/ipanat/test/ipa_nat_test013.c
index 2b9b005..d962065 100644
--- a/ipanat/test/ipa_nat_test013.c
+++ b/ipanat/test/ipa_nat_test013.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,67 +42,75 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test013(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test013(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl, rule_hdl1, rule_hdl2;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule1, ipv4_rule2;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule1 = {0}, ipv4_rule2 = {0};
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- ipv4_rule1.target_ip = 0xC1171609; /* 193.23.22.9 */
- ipv4_rule1.target_port = 1235;
- ipv4_rule1.private_ip = 0xC2171609; /* 194.23.22.9 */
- ipv4_rule1.private_port = 6579;
+ ipv4_rule1.target_ip = RAN_ADDR;
+ ipv4_rule1.target_port = RAN_PORT;
+ ipv4_rule1.private_ip = RAN_ADDR;
+ ipv4_rule1.private_port = RAN_PORT;
ipv4_rule1.protocol = IPPROTO_TCP;
- ipv4_rule1.public_port = 8951;
+ ipv4_rule1.public_port = RAN_PORT;
- ipv4_rule2.target_ip = 0xC1171606; /* 193.23.22.6 */
- ipv4_rule2.target_port = 1235;
- ipv4_rule2.private_ip = 0xC2171606; /* 194.23.22.6 */
- ipv4_rule2.private_port = 7956;
+ ipv4_rule2.target_ip = RAN_ADDR;
+ ipv4_rule2.target_port = RAN_PORT;
+ ipv4_rule2.private_ip = RAN_ADDR;
+ ipv4_rule2.private_port = RAN_PORT;
ipv4_rule2.protocol = IPPROTO_TCP;
- ipv4_rule2.public_port = 5109;
+ ipv4_rule2.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule1, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test014.c b/ipanat/test/ipa_nat_test014.c
index fd30317..3daa2d9 100644
--- a/ipanat/test/ipa_nat_test014.c
+++ b/ipanat/test/ipa_nat_test014.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,54 +42,61 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test014(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test014(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s()\n", __FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test015.c b/ipanat/test/ipa_nat_test015.c
index eaef923..1dc8f97 100644
--- a/ipanat/test/ipa_nat_test015.c
+++ b/ipanat/test/ipa_nat_test015.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,55 +43,62 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-
-int ipa_nat_test015(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test015(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
-
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
- if(sep)
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test016.c b/ipanat/test/ipa_nat_test016.c
index 23157e2..f1ee4e6 100644
--- a/ipanat/test/ipa_nat_test016.c
+++ b/ipanat/test/ipa_nat_test016.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,54 +43,61 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test016(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test016(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test017.c b/ipanat/test/ipa_nat_test017.c
index d88e611..23369e4 100644
--- a/ipanat/test/ipa_nat_test017.c
+++ b/ipanat/test/ipa_nat_test017.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,54 +43,61 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test017(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test017(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test018.c b/ipanat/test/ipa_nat_test018.c
index c885d4d..ca3d712 100644
--- a/ipanat/test/ipa_nat_test018.c
+++ b/ipanat/test/ipa_nat_test018.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,54 +43,61 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test018(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test018(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test019.c b/ipanat/test/ipa_nat_test019.c
index 3ba3119..883294d 100644
--- a/ipanat/test/ipa_nat_test019.c
+++ b/ipanat/test/ipa_nat_test019.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -43,54 +43,61 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test019(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test019(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule;
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
-
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test020.c b/ipanat/test/ipa_nat_test020.c
index e6871b5..2a32da0 100644
--- a/ipanat/test/ipa_nat_test020.c
+++ b/ipanat/test/ipa_nat_test020.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -42,59 +42,67 @@
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test020(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test020(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
int ret;
u32 rule_hdl1, rule_hdl2, rule_hdl3, rule_hdl4;
- ipa_nat_ipv4_rule ipv4_rule;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ ipa_nat_ipv4_rule ipv4_rule = {0};
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ IPADBG("In\n");
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl4);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl2);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl4);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR(ret);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- if(sep)
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test021.c b/ipanat/test/ipa_nat_test021.c
index 48c4321..a2d5a8d 100644
--- a/ipanat/test/ipa_nat_test021.c
+++ b/ipanat/test/ipa_nat_test021.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2020 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
@@ -27,55 +27,99 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+
/*=========================================================================*/
/*!
@file
- ipa_nat_test021.c
+ ipa_nat_test021.cpp
@brief
Verify the following scenario:
1. Add ipv4 table
- 2. Delete ipv4 table
+ 2. add same 3 ipv rules
+ 3. delete Head and last entry
+ 4. add 2 new same ip4 entries
+ 5. Add head entry again
+ 6. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test021(int total_entries, int reg)
+int ipa_nat_test021(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+ int ret;
+ u32 rule_hdl1, rule_hdl2, rule_hdl3;
+ ipa_nat_ipv4_rule ipv4_rule = {0}, ipv4_rule2 = {0};
+ u32 rule_hdl21, rule_hdl22;
- int ret, i;
- u32 tbl_hdl;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ /* Rule 1 */
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
+ ipv4_rule.protocol = IPPROTO_TCP;
+ ipv4_rule.public_port = RAN_PORT;
- IPADBG("%s():\n",__FUNCTION__);
+ /* Rule 2*/
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
+ ipv4_rule.protocol = IPPROTO_UDP;
+ ipv4_rule.public_port = RAN_PORT;
- for(i=0; i<reg; i++)
+ IPADBG("In\n");
+
+ if ( sep )
{
- IPADBG("executing %d th time:\n",i);
-
- IPADBG("calling ipa_nat_add_ipv4_tbl() \n");
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- if (0 != ret)
- {
- IPAERR("unable to create ipv4 nat table and returning Error:%d\n", ret);
- IPADBG("executed %d times:\n",i);
- return -1;
- }
- IPADBG("create nat ipv4 table successfully() \n");
-
- IPADBG("calling ipa_nat_del_ipv4_tbl() \n");
- ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
- if (0 != ret)
- {
- IPAERR("Unable to delete ipv4 nat table %d\n", ret);
- IPADBG("executed %d times:\n",i);
- return -1;
- }
- IPADBG("deleted ipv4 nat table successfully. Test passed \n");
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
- IPADBG("executed %d times:\n",(i+1));
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ /* Delete head entry */
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ /* Delete Last Entry */
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ /* Add 2 different Entries */
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl21);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl22);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ /* Add first entry again */
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ if ( sep )
+ {
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
+ }
+
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test022.c b/ipanat/test/ipa_nat_test022.c
index ebdd291..3767e19 100644
--- a/ipanat/test/ipa_nat_test022.c
+++ b/ipanat/test/ipa_nat_test022.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -27,92 +27,273 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-
/*=========================================================================*/
/*!
@file
- ipa_nat_test022.cpp
+ ipa_nat_test022.c
@brief
- Verify the following scenario:
+ Note: Verify the following scenario:
1. Add ipv4 table
- 2. add same 3 ipv rules
- 3. delete Head and last entry
- 4. add 2 new same ip4 entries
- 5. Add head entry again
- 6. Delete ipv4 table
+ 2. Add ipv4 rules till filled
+ 3. Print stats
+ 4. Delete ipv4 table
*/
/*=========================================================================*/
#include "ipa_nat_test.h"
-#include "ipa_nat_drv.h"
-int ipa_nat_test022(int total_entries, u32 tbl_hdl, u8 sep)
+int ipa_nat_test022(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ ipa_nat_ipv4_rule ipv4_rule;
+ u32 rule_hdls[2048];
+
+ ipa_nati_tbl_stats nstats, last_nstats;
+ ipa_nati_tbl_stats istats, last_istats;
+
+ u32 i, tot;
+
+ bool switched = false;
+
+ const char* mem_type;
+
int ret;
- u32 rule_hdl1, rule_hdl2, rule_hdl3;
- ipa_nat_ipv4_rule ipv4_rule, ipv4_rule2;
- u32 rule_hdl21, rule_hdl22;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ IPADBG("In\n");
- /* Rule 1 */
- ipv4_rule.target_ip = 0xC1171601; /* 193.23.22.1 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171601; /* 194.23.22.1 */
- ipv4_rule.private_port = 5678;
- ipv4_rule.protocol = IPPROTO_TCP;
- ipv4_rule.public_port = 9050;
-
- /* Rule 2*/
- ipv4_rule.target_ip = 0xC1171604; /* 193.23.22.4 */
- ipv4_rule.target_port = 1234;
- ipv4_rule.private_ip = 0xC2171603; /* 194.23.22.3 */
- ipv4_rule.private_port = 5680;
- ipv4_rule.protocol = IPPROTO_UDP;
- ipv4_rule.public_port = 9066;
-
- IPADBG("%s():\n",__FUNCTION__);
-
- if(sep)
+ if ( sep )
{
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR1(ret, tbl_hdl);
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
}
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
- CHECK_ERR1(ret, tbl_hdl);
+ ret = ipa_nati_clear_ipv4_tbl(tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
- CHECK_ERR1(ret, tbl_hdl);
+ ret = ipa_nati_ipv4_tbl_stats(tbl_hdl, &nstats, &istats);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR1(ret, tbl_hdl);
+ IPAINFO("Attempting rule adds to %s table of size: (%u)\n",
+ ipa3_nat_mem_in_as_str(nstats.nmi),
+ nstats.tot_ents);
- /* Delete head entry */
- ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl1);
- CHECK_ERR1(ret, tbl_hdl);
+ last_nstats = nstats;
+ last_istats = istats;
- /* Delete Last Entry */
- ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdl3);
- CHECK_ERR1(ret, tbl_hdl);
+ memset(rule_hdls, 0, sizeof(rule_hdls));
- /* Add 2 different Entries */
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl21);
- CHECK_ERR1(ret, tbl_hdl);
+ for ( i = tot = 0; i < array_sz(rule_hdls); i++ )
+ {
+ IPADBG("Trying %d ipa_nat_add_ipv4_rule()\n", i);
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule2, &rule_hdl22);
- CHECK_ERR1(ret, tbl_hdl);
+ memset(&ipv4_rule, 0, sizeof(ipv4_rule));
- /* Add first entry again */
- ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
- CHECK_ERR1(ret, tbl_hdl);
+ ipv4_rule.protocol = IPPROTO_TCP;
+ ipv4_rule.public_port = RAN_PORT;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
- if(sep)
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdls[i]);
+ CHECK_ERR_TBL_ACTION(ret, tbl_hdl, break);
+
+ IPADBG("Success %d ipa_nat_add_ipv4_rule() -> rule_hdl(0x%08X)\n",
+ i, rule_hdls[i]);
+
+ ret = ipa_nati_ipv4_tbl_stats(tbl_hdl, &nstats, &istats);
+ CHECK_ERR_TBL_ACTION(ret, tbl_hdl, break);
+
+ /*
+ * Are we in hybrid mode and have we switched memory type?
+ * Check for it and print the appropriate stats.
+ */
+ if ( nstats.nmi != last_nstats.nmi )
+ {
+ mem_type = ipa3_nat_mem_in_as_str(last_nstats.nmi);
+
+ switched = true;
+
+ /*
+ * NAT table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ last_nstats.tot_ents,
+ ((float) tot / (float) last_nstats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT BASE table of size (%u) or (%f) percent\n",
+ last_nstats.tot_base_ents_filled,
+ mem_type,
+ last_nstats.tot_base_ents,
+ ((float) last_nstats.tot_base_ents_filled /
+ (float) last_nstats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT EXPN table of size (%u) or (%f) percent\n",
+ last_nstats.tot_expn_ents_filled,
+ mem_type,
+ last_nstats.tot_expn_ents,
+ ((float) last_nstats.tot_expn_ents_filled /
+ (float) last_nstats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s NAT table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ last_nstats.tot_chains,
+ last_nstats.min_chain_len,
+ last_nstats.max_chain_len,
+ last_nstats.avg_chain_len);
+
+ /*
+ * INDEX table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ last_istats.tot_ents,
+ ((float) tot / (float) last_istats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX BASE table of size (%u) or (%f) percent\n",
+ last_istats.tot_base_ents_filled,
+ mem_type,
+ last_istats.tot_base_ents,
+ ((float) last_istats.tot_base_ents_filled /
+ (float) last_istats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX EXPN table of size (%u) or (%f) percent\n",
+ last_istats.tot_expn_ents_filled,
+ mem_type,
+ last_istats.tot_expn_ents,
+ ((float) last_istats.tot_expn_ents_filled /
+ (float) last_istats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s IDX table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ last_istats.tot_chains,
+ last_istats.min_chain_len,
+ last_istats.max_chain_len,
+ last_istats.avg_chain_len);
+ }
+
+ last_nstats = nstats;
+ last_istats = istats;
+
+ if ( switched )
+ {
+ switched = false;
+
+ IPAINFO("Continuing rule adds to %s table of size: (%u)\n",
+ ipa3_nat_mem_in_as_str(nstats.nmi),
+ nstats.tot_ents);
+ }
+
+ tot++;
+ }
+
+ ret = ipa_nati_ipv4_tbl_stats(tbl_hdl, &nstats, &istats);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ mem_type = ipa3_nat_mem_in_as_str(nstats.nmi);
+
+ /*
+ * NAT table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ nstats.tot_ents,
+ ((float) tot / (float) nstats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT BASE table of size (%u) or (%f) percent\n",
+ nstats.tot_base_ents_filled,
+ mem_type,
+ nstats.tot_base_ents,
+ ((float) nstats.tot_base_ents_filled /
+ (float) nstats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT EXPN table of size (%u) or (%f) percent\n",
+ nstats.tot_expn_ents_filled,
+ mem_type,
+ nstats.tot_expn_ents,
+ ((float) nstats.tot_expn_ents_filled /
+ (float) nstats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s NAT table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ nstats.tot_chains,
+ nstats.min_chain_len,
+ nstats.max_chain_len,
+ nstats.avg_chain_len);
+
+ /*
+ * INDEX table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ istats.tot_ents,
+ ((float) tot / (float) istats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX BASE table of size (%u) or (%f) percent\n",
+ istats.tot_base_ents_filled,
+ mem_type,
+ istats.tot_base_ents,
+ ((float) istats.tot_base_ents_filled /
+ (float) istats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX EXPN table of size (%u) or (%f) percent\n",
+ istats.tot_expn_ents_filled,
+ mem_type,
+ istats.tot_expn_ents,
+ ((float) istats.tot_expn_ents_filled /
+ (float) istats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s IDX table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ istats.tot_chains,
+ istats.min_chain_len,
+ istats.max_chain_len,
+ istats.avg_chain_len);
+
+ IPAINFO("Deleting all rules\n");
+
+ for ( i = 0; i < tot; i++ )
+ {
+ IPADBG("Trying %d ipa_nat_del_ipv4_rule(0x%08X)\n",
+ i, rule_hdls[i]);
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdls[i]);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ IPADBG("Success ipa_nat_del_ipv4_rule(%d)\n", i);
+ }
+
+ if ( sep )
{
ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
- CHECK_ERR1(ret, tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
}
+ IPADBG("Out\n");
+
return 0;
}
diff --git a/ipanat/test/ipa_nat_test023.c b/ipanat/test/ipa_nat_test023.c
new file mode 100644
index 0000000..501b223
--- /dev/null
+++ b/ipanat/test/ipa_nat_test023.c
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*=========================================================================*/
+/*!
+ @file
+ ipa_nat_test023.c
+
+ @brief
+ Verify the following scenario:
+ 1. Add ipv4 table
+ 2. Add ipv rule three times to cause collisions and linking
+ 3. Delete rules in a particular order and observe list for expected
+ form
+ 4. Run 2 and 3 over and over until all delete cominations have been
+ run
+ 5. Delete ipv4 table
+*/
+/*=========================================================================*/
+
+#include "ipa_nat_test.h"
+
+int ipa_nat_test023(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
+{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ ipa_nat_ipv4_rule ipv4_rule = {0};
+
+ u32 rule_hdl1;
+ u32 rule_hdl2;
+ u32 rule_hdl3;
+
+ u32* rule_del_combos[6][3] = {
+ { &rule_hdl1, &rule_hdl2, &rule_hdl3 },
+ { &rule_hdl1, &rule_hdl3, &rule_hdl2 },
+
+ { &rule_hdl2, &rule_hdl1, &rule_hdl3 },
+ { &rule_hdl2, &rule_hdl3, &rule_hdl1 },
+
+ { &rule_hdl3, &rule_hdl1, &rule_hdl2 },
+ { &rule_hdl3, &rule_hdl2, &rule_hdl1 },
+ };
+
+ int i, j, ret;
+
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
+ ipv4_rule.protocol = IPPROTO_TCP;
+ ipv4_rule.public_port = RAN_PORT;
+
+ IPADBG("In\n");
+
+ if ( sep )
+ {
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
+
+ for ( i = 0; i < 6; i++ )
+ {
+ IPADBG("Adding rule 1\n");
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl1);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ IPADBG("Adding rule 2\n");
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl2);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ IPADBG("Adding rule 3\n");
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdl3);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ ipa_nat_dump_ipv4_table(tbl_hdl);
+
+ for ( j = 0; j < 3; j++ )
+ {
+ u32* rh_ptr = rule_del_combos[i][j];
+
+ IPADBG("Deleting rule %u\n",
+ ( rh_ptr == &rule_hdl1 ) ? 1 :
+ ( rh_ptr == &rule_hdl2 ) ? 2 : 3);
+
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, *rh_ptr);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ ipa_nat_dump_ipv4_table(tbl_hdl);
+ }
+ }
+
+ if ( sep )
+ {
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
+ }
+
+ IPADBG("Out\n");
+
+ return 0;
+}
diff --git a/ipanat/test/ipa_nat_test024.c b/ipanat/test/ipa_nat_test024.c
new file mode 100644
index 0000000..216fc39
--- /dev/null
+++ b/ipanat/test/ipa_nat_test024.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*=========================================================================*/
+/*!
+ @file
+ ipa_nat_test024.c
+
+ @brief
+ Verify the following scenario:
+ 1. Trigger thousands of table memory switches
+
+*/
+/*===========================================================================*/
+
+#include "ipa_nat_test.h"
+
+int ipa_nat_test024(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
+{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ int i, ret;
+
+ IPADBG("In\n");
+
+ if ( sep )
+ {
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
+
+ for ( i = 0; i < 1000; i++ )
+ {
+ ret = ipa_nat_test022(
+ nat_mem_type, pub_ip_add, total_entries, tbl_hdl, !sep, arb_data_ptr);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
+
+ if ( sep )
+ {
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
+ }
+
+ IPADBG("Out\n");
+
+ return 0;
+}
diff --git a/ipanat/test/ipa_nat_test025.c b/ipanat/test/ipa_nat_test025.c
new file mode 100644
index 0000000..d1c1b9d
--- /dev/null
+++ b/ipanat/test/ipa_nat_test025.c
@@ -0,0 +1,362 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*=========================================================================*/
+/*!
+ @file
+ ipa_nat_test025.c
+
+ @brief
+ Note: Verify the following scenario:
+ 1. Similare to test022, but with random deletes during adds
+*/
+/*=========================================================================*/
+
+#include "ipa_nat_test.h"
+
+#undef VALID_RULE
+#define VALID_RULE(r) ((r) != 0 && (r) != 0xFFFFFFFF)
+
+#undef GET_MAX
+#define GET_MAX(ram, rdm) \
+ do { \
+ while ( (ram = rand() % 20) < 4); \
+ while ( (rdm = rand() % 10) >= ram || rdm == 0 ); \
+ IPADBG("rand_adds_max(%u) rand_dels_max(%u)\n", ram, rdm); \
+ } while (0)
+
+int ipa_nat_test025(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
+{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ ipa_nat_ipv4_rule ipv4_rule;
+ u32 rule_hdls[1024];
+
+ ipa_nati_tbl_stats nstats, last_nstats;
+ ipa_nati_tbl_stats istats, last_istats;
+
+ u32 i;
+ u32 rand_adds_max, rand_dels_max;
+ u32 tot, tot_added, tot_deleted;
+
+ bool switched = false;
+
+ const char* mem_type;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ if ( sep )
+ {
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
+
+ ret = ipa_nati_clear_ipv4_tbl(tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ ret = ipa_nati_ipv4_tbl_stats(tbl_hdl, &nstats, &istats);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ IPAINFO("Attempting rule adds to %s table of size: (%u)\n",
+ ipa3_nat_mem_in_as_str(nstats.nmi),
+ nstats.tot_ents);
+
+ last_nstats = nstats;
+ last_istats = istats;
+
+ memset(rule_hdls, 0, sizeof(rule_hdls));
+
+ GET_MAX(rand_adds_max, rand_dels_max);
+
+ tot = tot_added = tot_deleted = 0;
+
+ for ( i = 0; i < array_sz(rule_hdls); i++ )
+ {
+ IPADBG("Trying %u ipa_nat_add_ipv4_rule()\n", i);
+
+ memset(&ipv4_rule, 0, sizeof(ipv4_rule));
+
+ ipv4_rule.protocol = IPPROTO_TCP;
+ ipv4_rule.public_port = RAN_PORT;
+ ipv4_rule.target_ip = RAN_ADDR;
+ ipv4_rule.target_port = RAN_PORT;
+ ipv4_rule.private_ip = RAN_ADDR;
+ ipv4_rule.private_port = RAN_PORT;
+
+ ret = ipa_nat_add_ipv4_rule(tbl_hdl, &ipv4_rule, &rule_hdls[i]);
+ CHECK_ERR_TBL_ACTION(ret, tbl_hdl, break);
+
+ IPADBG("Success %u ipa_nat_add_ipv4_rule() -> rule_hdl(0x%08X)\n",
+ i, rule_hdls[i]);
+
+ ret = ipa_nati_ipv4_tbl_stats(tbl_hdl, &nstats, &istats);
+ CHECK_ERR_TBL_ACTION(ret, tbl_hdl, break);
+
+ /*
+ * Are we in hybrid mode and have we switched memory type?
+ * Check for it and print the appropriate stats.
+ */
+ if ( nstats.nmi != last_nstats.nmi )
+ {
+ mem_type = ipa3_nat_mem_in_as_str(last_nstats.nmi);
+
+ switched = true;
+
+ /*
+ * NAT table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ last_nstats.tot_ents,
+ ((float) tot / (float) last_nstats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT BASE table of size (%u) or (%f) percent\n",
+ last_nstats.tot_base_ents_filled,
+ mem_type,
+ last_nstats.tot_base_ents,
+ ((float) last_nstats.tot_base_ents_filled /
+ (float) last_nstats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT EXPN table of size (%u) or (%f) percent\n",
+ last_nstats.tot_expn_ents_filled,
+ mem_type,
+ last_nstats.tot_expn_ents,
+ ((float) last_nstats.tot_expn_ents_filled /
+ (float) last_nstats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s NAT table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ last_nstats.tot_chains,
+ last_nstats.min_chain_len,
+ last_nstats.max_chain_len,
+ last_nstats.avg_chain_len);
+
+ /*
+ * INDEX table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ last_istats.tot_ents,
+ ((float) tot / (float) last_istats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX BASE table of size (%u) or (%f) percent\n",
+ last_istats.tot_base_ents_filled,
+ mem_type,
+ last_istats.tot_base_ents,
+ ((float) last_istats.tot_base_ents_filled /
+ (float) last_istats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX EXPN table of size (%u) or (%f) percent\n",
+ last_istats.tot_expn_ents_filled,
+ mem_type,
+ last_istats.tot_expn_ents,
+ ((float) last_istats.tot_expn_ents_filled /
+ (float) last_istats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s IDX table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ last_istats.tot_chains,
+ last_istats.min_chain_len,
+ last_istats.max_chain_len,
+ last_istats.avg_chain_len);
+ }
+
+ last_nstats = nstats;
+ last_istats = istats;
+
+ tot++;
+
+ if ( ++tot_added == rand_adds_max )
+ {
+ u32 j, k;
+ u32* hdl_ptr[tot];
+
+ for ( j = k = 0; j < array_sz(rule_hdls); j++ )
+ {
+ if ( VALID_RULE(rule_hdls[j]) )
+ {
+ hdl_ptr[k] = &(rule_hdls[j]);
+
+ if ( ++k == tot )
+ {
+ break;
+ }
+ }
+ }
+
+ IPADBG("About to delete %u rules\n", rand_dels_max);
+
+ while ( k )
+ {
+ while ( j = rand() % k, ! VALID_RULE(*(hdl_ptr[j])) );
+
+ IPADBG("Trying ipa_nat_del_ipv4_rule(0x%08X)\n",
+ *(hdl_ptr[j]));
+
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, *(hdl_ptr[j]));
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ IPADBG("Success ipa_nat_del_ipv4_rule(0x%08X)\n", *(hdl_ptr[j]));
+
+ *(hdl_ptr[j]) = 0xFFFFFFFF;
+
+ --tot;
+
+ if ( ++tot_deleted == rand_dels_max )
+ {
+ break;
+ }
+ }
+
+ GET_MAX(rand_adds_max, rand_dels_max);
+
+ tot_added = tot_deleted = 0;
+ }
+
+ if ( switched )
+ {
+ switched = false;
+
+ IPAINFO("Continuing rule adds to %s table of size: (%u)\n",
+ ipa3_nat_mem_in_as_str(nstats.nmi),
+ nstats.tot_ents);
+ }
+ }
+
+ ret = ipa_nati_ipv4_tbl_stats(tbl_hdl, &nstats, &istats);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ mem_type = ipa3_nat_mem_in_as_str(nstats.nmi);
+
+ /*
+ * NAT table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ nstats.tot_ents,
+ ((float) tot / (float) nstats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT BASE table of size (%u) or (%f) percent\n",
+ nstats.tot_base_ents_filled,
+ mem_type,
+ nstats.tot_base_ents,
+ ((float) nstats.tot_base_ents_filled /
+ (float) nstats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "NAT EXPN table of size (%u) or (%f) percent\n",
+ nstats.tot_expn_ents_filled,
+ mem_type,
+ nstats.tot_expn_ents,
+ ((float) nstats.tot_expn_ents_filled /
+ (float) nstats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s NAT table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ nstats.tot_chains,
+ nstats.min_chain_len,
+ nstats.max_chain_len,
+ nstats.avg_chain_len);
+
+ /*
+ * INDEX table stats...
+ */
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX table of size (%u) or (%f) percent\n",
+ tot,
+ mem_type,
+ istats.tot_ents,
+ ((float) tot / (float) istats.tot_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX BASE table of size (%u) or (%f) percent\n",
+ istats.tot_base_ents_filled,
+ mem_type,
+ istats.tot_base_ents,
+ ((float) istats.tot_base_ents_filled /
+ (float) istats.tot_base_ents) * 100.0);
+
+ IPAINFO("Able to add (%u) records to %s "
+ "IDX EXPN table of size (%u) or (%f) percent\n",
+ istats.tot_expn_ents_filled,
+ mem_type,
+ istats.tot_expn_ents,
+ ((float) istats.tot_expn_ents_filled /
+ (float) istats.tot_expn_ents) * 100.0);
+
+ IPAINFO("%s IDX table chains: tot_chains(%u) min_len(%u) max_len(%u) avg_len(%f)\n",
+ mem_type,
+ istats.tot_chains,
+ istats.min_chain_len,
+ istats.max_chain_len,
+ istats.avg_chain_len);
+
+ IPAINFO("Deleting remaining rules\n");
+
+ for ( i = 0; i < array_sz(rule_hdls); i++ )
+ {
+ if ( VALID_RULE(rule_hdls[i]) )
+ {
+ IPADBG("Trying ipa_nat_del_ipv4_rule(0x%08X)\n",
+ rule_hdls[i]);
+ ret = ipa_nat_del_ipv4_rule(tbl_hdl, rule_hdls[i]);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ IPADBG("Success ipa_nat_del_ipv4_rule(%u)\n", rule_hdls[i]);
+ }
+ }
+
+ if ( sep )
+ {
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
+ }
+
+ IPADBG("Out\n");
+
+ return 0;
+}
diff --git a/ipanat/test/ipa_nat_test999.c b/ipanat/test/ipa_nat_test999.c
new file mode 100644
index 0000000..f82ef18
--- /dev/null
+++ b/ipanat/test/ipa_nat_test999.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*=========================================================================*/
+/*!
+ @file
+ ipa_nat_test999.c
+
+ @brief
+ Verify the following scenario:
+ 1. Delete ipv4 table
+*/
+/*===========================================================================*/
+
+#include "ipa_nat_test.h"
+
+int ipa_nat_test999(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
+{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+ int ret;
+
+ IPADBG("In\n");
+
+ if ( ! sep )
+ {
+ IPADBG("calling ipa_nat_del_ipv4_tbl()\n");
+
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+
+ *tbl_hdl_ptr = 0;
+
+ CHECK_ERR(ret);
+
+ IPADBG("deleted ipv4 nat table successfully.\n");
+ }
+
+ IPADBG("Out\n");
+
+ return 0;
+}
diff --git a/ipanat/test/ipa_nat_testMODEL.c b/ipanat/test/ipa_nat_testMODEL.c
new file mode 100644
index 0000000..0f99159
--- /dev/null
+++ b/ipanat/test/ipa_nat_testMODEL.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*=========================================================================*/
+/*!
+ @file
+ ipa_nat_testXXX.c
+
+ @brief
+ Verify the following scenario:
+
+*/
+/*===========================================================================*/
+
+#include "ipa_nat_test.h"
+
+int ipa_nat_testXXX(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
+{
+ int* tbl_hdl_ptr = (int*) arb_data_ptr;
+
+ int ret;
+
+ IPADBG("In\n");
+
+ if ( sep )
+ {
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+ }
+
+ if ( sep )
+ {
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+ *tbl_hdl_ptr = 0;
+ CHECK_ERR(ret);
+ }
+
+ IPADBG("Out\n");
+
+ return 0;
+}
diff --git a/ipanat/test/ipa_nat_testREG.c b/ipanat/test/ipa_nat_testREG.c
new file mode 100644
index 0000000..10e29cf
--- /dev/null
+++ b/ipanat/test/ipa_nat_testREG.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*=========================================================================*/
+/*!
+ @file
+ ipa_nat_testREG.c
+
+ @brief
+ Verify the following scenario:
+ 1. Add ipv4 table
+ 2. Delete ipv4 table
+*/
+/*=========================================================================*/
+
+#include "ipa_nat_test.h"
+
+int ipa_nat_testREG(
+ const char* nat_mem_type,
+ u32 pub_ip_add,
+ int total_entries,
+ u32 tbl_hdl,
+ int sep,
+ void* arb_data_ptr)
+{
+ int* ireg_ptr = (int*) arb_data_ptr;
+
+ int i, ret;
+
+ IPADBG("In\n");
+
+ for ( i = 0; i < *ireg_ptr; i++ )
+ {
+ IPADBG("Executing iteration %d\n", i+1);
+
+ IPADBG("Calling ipa_nat_add_ipv4_tbl()\n");
+
+ ret = ipa_nat_add_ipv4_tbl(pub_ip_add, nat_mem_type, total_entries, &tbl_hdl);
+
+ CHECK_ERR_TBL_STOP(ret, tbl_hdl);
+
+ IPADBG("Iteration %d creation of nat ipv4 table successful\n", i+1);
+
+ IPADBG("Calling ipa_nat_del_ipv4_tbl()\n");
+
+ ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
+
+ CHECK_ERR(ret);
+
+ IPADBG("Iteration %d deletion of ipv4 nat table successful\n", i+1);
+ }
+
+ IPADBG("Executed %d iterations:\n", i);
+
+ IPADBG("Out\n");
+
+ return 0;
+}
diff --git a/ipanat/test/main.c b/ipanat/test/main.c
index c49ce3b..16d46fd 100644
--- a/ipanat/test/main.c
+++ b/ipanat/test/main.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2018-2020 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
@@ -26,615 +26,482 @@
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-
-
#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
+#include <libgen.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
+#include <errno.h>
-#include "ipa_nat_drv.h"
-#include "ipa_nat_drvi.h"
#include "ipa_nat_test.h"
+#include "ipa_nat_map.h"
-extern struct ipa_nat_cache ipv4_nat_cache;
+#undef strcasesame
+#define strcasesame(x, y) \
+ (! strcasecmp((x), (y)))
-int chk_for_loop(u32 tbl_hdl)
+static inline const char* legal_mem_type(
+ const char* mt )
{
- struct ipa_nat_rule *tbl_ptr;
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- int cnt;
- uint16_t cur_entry;
+ if ( strcasesame(mt, "DDR") ) return "DDR";
+ if ( strcasesame(mt, "SRAM") ) return "SRAM";
+ if ( strcasesame(mt, "HYBRID") ) return "HYBRID";
+ return NULL;
+}
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
- IPAERR("invalid table handle passed \n");
+static int nat_rule_loop_check(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
+{
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
+ uint32_t tbl_hdl = (uint32_t) arb_data_ptr;
+
+ struct ipa_nat_rule* rule_ptr =
+ (struct ipa_nat_rule*) record_ptr;
+
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
+
+ /*
+ * By virtue of this function being called back by the walk, this
+ * record_index is valid. Denote it as such in the map...
+ */
+ if ( ipa_nat_map_add(MAP_NUM_99, record_index, 1) )
+ {
+ IPAERR("ipa_nat_map_add(index(%u)) failed\n", record_index);
return -EINVAL;
}
- IPADBG("checking ipv4 rules:\n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_rules_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,ENABLE_FIELD)) {
- if(Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
- NEXT_INDEX_FIELD) == cnt)
- {
- IPAERR("Infinite loop detected, entry\n");
- ipa_nati_print_rule(&tbl_ptr[cnt], cnt);
- return -EINVAL;
- }
- }
+ if ( rule_ptr->next_index == record_index )
+ {
+ IPAERR("Infinite loop detected in IPv4 %s table, entry %u\n",
+ (is_expn_tbl) ? "expansion" : "base",
+ record_index);
+
+ ipa_nat_dump_ipv4_table(tbl_hdl);
+
+ return -EINVAL;
}
- /* Print ipv4 expansion rules */
- IPADBG("checking ipv4 active expansion rules:\n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_expn_rules_addr;
- for (cnt = 0;
- cnt <= ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- cur_entry =
- cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- if (Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
- NEXT_INDEX_FIELD) == cur_entry)
- {
- IPAERR("Infinite loop detected\n");
- ipa_nati_print_rule(&tbl_ptr[cnt],
- (cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries));
- return -EINVAL;
- }
- }
- }
-
- /* Print ipv4 index rules */
- IPADBG("checking ipv4 index active rules: \n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED) == cnt)
- {
- IPAERR("Infinite loop detected\n");
- ipa_nati_print_index_rule(&indx_tbl_ptr[cnt], cnt, 0);
- return -EINVAL;
- }
- }
- }
-
- /* Print ipv4 index expansion rules */
- IPADBG("Checking ipv4 index expansion active rules: \n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_expn_addr;
- for (cnt = 0;
- cnt <= ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- cur_entry =
- cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED) == cur_entry)
- {
- IPAERR("Infinite loop detected\n");
- ipa_nati_print_index_rule(&indx_tbl_ptr[cnt],
- (cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries),
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].index_expn_table_meta[cnt].prev_index);
- return -EINVAL;
- }
- }
- }
return 0;
}
-uint8_t is_base_entry_valid(u32 tbl_hdl, u16 entry)
+static int nat_rule_validity_check(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
{
- struct ipa_nat_rule *tbl_ptr;
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
+ uint16_t index;
- if (entry >
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries)
- {
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_expn_rules_addr;
- entry -=
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- }
- else
- {
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_rules_addr;
- }
- return (Read16BitFieldValue(tbl_ptr[entry].ip_cksm_enbl,
- ENABLE_FIELD));
-}
+ struct ipa_nat_rule* rule_ptr =
+ (struct ipa_nat_rule*) record_ptr;
-uint8_t is_index_entry_valid(u32 tbl_hdl, u16 entry)
-{
- struct ipa_nat_indx_tbl_rule *tbl_ptr;
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
- if (entry >
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries)
- {
- tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_expn_addr;
- entry -=
- ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- }
- else
- {
- tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_addr;
- }
- if (Read16BitFieldValue(tbl_ptr[entry].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- return 1;
- }
- else
- {
- return 0;
- }
-}
+ index = rule_ptr->next_index;
-int chk_for_validity(u32 tbl_hdl)
-{
- struct ipa_nat_rule *tbl_ptr;
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- uint16_t nxt_index, prv_index;
- int cnt;
+ if ( index && ipa_nat_map_find(MAP_NUM_99, index, NULL) )
+ {
+ IPAERR("Invalid next index %u found in IPv4 %s table entry %u\n",
+ index,
+ (is_expn_tbl) ? "expansion" : "base",
+ rule_index);
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
- IPAERR("invalid table handle passed \n");
return -EINVAL;
}
- /* Validate base table next_indx and prev_indx values */
- IPADBG("Validating ipv4 active rules: \n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_rules_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- nxt_index =
- Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
- NEXT_INDEX_FIELD);
- if (!is_base_entry_valid(tbl_hdl, nxt_index)) {
- IPAERR("Invalid next index found, entry:%d\n", cnt);
- }
- }
- }
+ if ( is_expn_tbl )
+ {
+ index = rule_ptr->prev_index;
- IPADBG("Validating ipv4 expansion active rules: \n");
- tbl_ptr = (struct ipa_nat_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].ipv4_expn_rules_addr;
- for (cnt = 0;
- cnt <= ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(tbl_ptr[cnt].ip_cksm_enbl,
- ENABLE_FIELD)) {
- /* Validate next index */
- nxt_index =
- Read16BitFieldValue(tbl_ptr[cnt].nxt_indx_pub_port,
- NEXT_INDEX_FIELD);
- if (!is_base_entry_valid(tbl_hdl, nxt_index)) {
- IPAERR("Invalid next index found, entry:%d\n", cnt);
- }
- /* Validate previous index */
- prv_index =
- Read16BitFieldValue(tbl_ptr[cnt].sw_spec_params,
- SW_SPEC_PARAM_PREV_INDEX_FIELD);
- if (!is_base_entry_valid(tbl_hdl, prv_index)) {
- IPAERR("Invalid Previous index found, entry:%d\n", cnt);
- }
- }
- }
+ if ( index && ipa_nat_map_find(MAP_NUM_99, index, NULL) )
+ {
+ IPAERR("Invalid previous index %u found in IPv4 %s table entry %u\n",
+ index,
+ "expansion",
+ rule_index);
- IPADBG("Validating ipv4 index active rules: \n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_addr;
- for (cnt = 0;
- cnt < ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- nxt_index =
- Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
- if (!is_index_entry_valid(tbl_hdl, nxt_index)) {
- IPAERR("Invalid next index found, entry:%d\n", cnt);
- }
- }
- }
-
- IPADBG("Validating ipv4 index expansion active rules: \n");
- indx_tbl_ptr = (struct ipa_nat_indx_tbl_rule *)
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_table_expn_addr;
- for (cnt = 0;
- cnt <= ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].expn_table_entries;
- cnt++) {
- if (Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_TBL_ENTRY_FIELD)) {
- /* Validate next index*/
- nxt_index =
- Read16BitFieldValue(indx_tbl_ptr[cnt].tbl_entry_nxt_indx,
- INDX_TBL_NEXT_INDEX_FILED);
- if (!is_index_entry_valid(tbl_hdl, nxt_index)) {
- IPAERR("Invalid next index found, entry:%d\n", cnt);
- }
-
- /* Validate previous index*/
- prv_index =
- ipv4_nat_cache.ip4_tbl[tbl_hdl-1].index_expn_table_meta[cnt].prev_index;
-
- if (!is_index_entry_valid(tbl_hdl, prv_index)) {
- IPAERR("Invalid Previous index found, entry:%d\n", cnt);
- }
+ return -EINVAL;
}
}
return 0;
}
-int ipa_nat_validate_ipv4_table(u32 tbl_hdl)
+static int index_loop_check(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
{
- int ret = 0;
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
+ uint32_t tbl_hdl = (uint32_t) arb_data_ptr;
- ret = chk_for_loop(tbl_hdl);
- if (ret)
+ struct ipa_nat_indx_tbl_rule* itr_ptr =
+ (struct ipa_nat_indx_tbl_rule*) record_ptr;
+
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
+
+ /*
+ * By virtue of this function being called back by the walk, this
+ * record_index is valid. Denote it as such in the map...
+ */
+ if ( ipa_nat_map_add(MAP_NUM_99, record_index, 1) )
+ {
+ IPAERR("ipa_nat_map_add(index(%u)) failed\n", record_index);
+ return -EINVAL;
+ }
+
+ if ( itr_ptr->next_index == record_index )
+ {
+ IPAERR("Infinite loop detected in IPv4 index %s table, entry %u\n",
+ (is_expn_tbl) ? "expansion" : "base",
+ record_index);
+
+ ipa_nat_dump_ipv4_table(tbl_hdl);
+
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int index_validity_check(
+ ipa_table* table_ptr,
+ uint32_t rule_hdl,
+ void* record_ptr,
+ uint16_t record_index,
+ void* meta_record_ptr,
+ uint16_t meta_record_index,
+ void* arb_data_ptr )
+{
+ enum ipa3_nat_mem_in nmi;
+ uint8_t is_expn_tbl;
+ uint16_t rule_index;
+ uint16_t index;
+
+ struct ipa_nat_indx_tbl_rule* itr_ptr =
+ (struct ipa_nat_indx_tbl_rule*) record_ptr;
+
+ BREAK_RULE_HDL(table_ptr, rule_hdl, nmi, is_expn_tbl, rule_index);
+
+ index = itr_ptr->next_index;
+
+ if ( index && ipa_nat_map_find(MAP_NUM_99, index, NULL) )
+ {
+ IPAERR("Invalid next index %u found in IPv4 index %s table entry %u\n",
+ index,
+ (is_expn_tbl) ? "expansion" : "base",
+ rule_index);
+
+ return -EINVAL;
+ }
+
+ if ( is_expn_tbl )
+ {
+ struct ipa_nat_indx_tbl_meta_info* mi_ptr = meta_record_ptr;
+
+ if ( ! mi_ptr )
+ {
+ IPAERR("Missing meta pointer for IPv4 index %s table entry %u\n",
+ "expansion",
+ rule_index);
+
+ return -EINVAL;
+ }
+
+ index = mi_ptr->prev_index;
+
+ if ( index && ipa_nat_map_find(MAP_NUM_99, index, NULL) )
+ {
+ IPAERR("Invalid previous index %u found in IPv4 index %s table entry %u\n",
+ index,
+ "expansion",
+ rule_index);
+
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
+int ipa_nat_validate_ipv4_table(
+ u32 tbl_hdl )
+{
+ int ret;
+
+ /*
+ * Map MAP_NUM_99 will be used to keep, and to check for,
+ * record validity.
+ *
+ * The first walk will fill it. The second walk will use it...
+ */
+ ipa_nat_map_clear(MAP_NUM_99);
+
+ IPADBG("Checking IPv4 active rules:\n");
+
+ ret = ipa_nati_walk_ipv4_tbl(tbl_hdl, USE_NAT_TABLE, nat_rule_loop_check, tbl_hdl);
+
+ if ( ret != 0 )
+ {
return ret;
- ret = chk_for_validity(tbl_hdl);
+ }
- return ret;
+ ret = ipa_nati_walk_ipv4_tbl(tbl_hdl, USE_NAT_TABLE, nat_rule_validity_check, 0);
+
+ if ( ret != 0 )
+ {
+ return ret;
+ }
+
+ /*
+ * Map MAP_NUM_99 will be used to keep, and to check for,
+ * record validity.
+ *
+ * The first walk will fill it. The second walk will use it...
+ */
+ ipa_nat_map_clear(MAP_NUM_99);
+
+ IPADBG("Checking IPv4 index active rules:\n");
+
+ ret = ipa_nati_walk_ipv4_tbl(tbl_hdl, USE_INDEX_TABLE, index_loop_check, tbl_hdl);
+
+ if ( ret != 0 )
+ {
+ return ret;
+ }
+
+ ret = ipa_nati_walk_ipv4_tbl(tbl_hdl, USE_INDEX_TABLE, index_validity_check, 0);
+
+ if ( ret != 0 )
+ {
+ return ret;
+ }
+
+ return 0;
}
-int main(int argc, char* argv[])
+static void
+_dispUsage(
+ const char* progNamePtr )
{
- int exec = 0, pass = 0, ret;
- int cnt, nt=1;
- int total_entries = 100;
- u8 sep = 0;
- u32 tbl_hdl = 0;
- u32 pub_ip_add = 0x011617c0; /* "192.23.22.1" */
+ printf(
+ "Usage: %s [-d -r N -i N -e N -m mt]\n"
+ "Where:\n"
+ " -d Each test is discrete (create table, add rules, destroy table)\n"
+ " If not specified, only one table create and destroy for all tests\n"
+ " -r N Where N is the number of times to run the inotify regression test\n"
+ " -i N Where N is the number of times (iterations) to run test\n"
+ " -e N Where N is the number of entries in the NAT\n"
+ " -m mt Where mt is the type of memory to use for the NAT\n"
+ " Legal mt's: DDR, SRAM, or HYBRID (ie. use SRAM and DDR)\n"
+ " -g M-N Run tests M through N only\n",
+ progNamePtr);
- IPADBG("ipa_nat_testing user space nat driver\n");
+ fflush(stdout);
+}
- if (argc == 4)
+static NatTests nt_array[] = {
+ NAT_TEST_ENTRY(ipa_nat_test000, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test001, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test002, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test003, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test004, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test005, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test006, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test007, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test008, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test009, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_test010, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test011, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test012, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test013, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test014, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test015, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test016, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test017, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test018, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test019, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test020, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test021, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test022, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test023, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test024, IPA_NAT_TEST_PRE_COND_TE, 0),
+ NAT_TEST_ENTRY(ipa_nat_test025, IPA_NAT_TEST_PRE_COND_TE, 0),
+ /*
+ * Add new tests just above this comment. Keep the following two
+ * at the end...
+ */
+ NAT_TEST_ENTRY(ipa_nat_test999, 1, 0),
+ NAT_TEST_ENTRY(ipa_nat_testREG, 1, 0),
+};
+
+int main(
+ int argc,
+ char* argv[] )
+{
+ int sep = 0;
+ int ireg = 0;
+ uint32_t nt = 1;
+ int total_ents = 100;
+ uint32_t ht = 0;
+ uint32_t start = 0, end = 0;
+
+ char* nat_mem_type = "DDR";
+
+ uint32_t tbl_hdl = 0;
+
+ uint32_t pub_ip_addr;
+
+ uint32_t i, ub, cnt, exec, pass;
+
+ void* adp;
+
+ time_t t;
+
+ int c, ret;
+
+ IPADBG("Testing user space nat driver\n");
+
+ while ( (c = getopt(argc, argv, "dr:i:e:m:h:g:?")) != -1 )
{
- if (!strncmp(argv[1], "reg", 3))
+ switch (c)
{
- nt = atoi(argv[2]);
- total_entries = atoi(argv[3]);
- IPADBG("Reg: %d, Nat Entries: %d\n", nt, total_entries);
- }
- else if (!strncmp(argv[1], "sep", 3))
- {
+ case 'd':
sep = 1;
- nt = atoi(argv[2]);
- total_entries = atoi(argv[3]);
+ break;
+ case 'r':
+ ireg = atoi(optarg);
+ break;
+ case 'i':
+ nt = atoi(optarg);
+ break;
+ case 'e':
+ total_ents = atoi(optarg);
+ break;
+ case 'm':
+ if ( ! (nat_mem_type = legal_mem_type(optarg)) )
+ {
+ fprintf(stderr, "Illegal: -m %s\n", optarg);
+ _dispUsage(basename(argv[0]));
+ exit(0);
+ }
+ break;
+ case 'h':
+ ht = atoi(optarg);
+ break;
+ case 'g':
+ if ( sscanf(optarg, "%u-%u", &start, &end) != 2
+ ||
+ ( start >= end || end >= array_sz(nt_array) - 1 ) )
+ {
+ fprintf(stderr, "Illegal: -f %s\n", optarg);
+ _dispUsage(basename(argv[0]));
+ exit(0);
+ }
+ break;
+ case '?':
+ default:
+ _dispUsage(basename(argv[0]));
+ exit(0);
+ break;
}
}
- else if (argc == 3)
+
+ srand(time(&t));
+
+ pub_ip_addr = RAN_ADDR;
+
+ exec = pass = 0;
+
+ for ( cnt = ret = 0; cnt < nt && ret == 0; cnt++ )
{
- if (!strncmp(argv[1], "inotify", 7))
+ IPADBG("ITERATION [%u] OF TESING\n", cnt + 1);
+
+ if ( ireg )
{
- ipa_nat_test021(total_entries, atoi(argv[2]));
- return 0;
+ adp = &ireg;
+ i = array_sz(nt_array) - 1;
+ ub = array_sz(nt_array);
}
- else if (!strncmp(argv[1], "sep", 3))
+ else
{
- sep = 1;
- total_entries = atoi(argv[2]);
+ adp = &tbl_hdl;
+ i = ( end ) ? start : 0;
+ ub = ( end ) ? end : array_sz(nt_array) - 1;
+
+ if ( i != 0 && ! sep )
+ {
+ ipa_nat_test000(
+ nat_mem_type, pub_ip_addr, total_ents, tbl_hdl, 0, adp);
+ }
+ }
+
+ for ( ; i < ub && ret == 0; i++ )
+ {
+ if ( total_ents >= nt_array[i].num_ents_trigger )
+ {
+ IPADBG("+------------------------------------------------+\n");
+ IPADBG("| Executing test: %s |\n", nt_array[i].func_name);
+ IPADBG("+------------------------------------------------+\n");
+
+ ret = nt_array[i].func(
+ nat_mem_type, pub_ip_addr, total_ents, tbl_hdl, sep, adp);
+
+ exec++;
+
+ if ( ret == 0 )
+ {
+ IPADBG("<<<<< Test %s SUCCEEDED >>>>>\n", nt_array[i].func_name);
+
+ pass++;
+
+ if ( ht || nt_array[i].test_hold_time_in_secs )
+ {
+ ht = (ht) ? ht : nt_array[i].test_hold_time_in_secs;
+
+ sleep(ht);
+ }
+ }
+ else
+ {
+ IPAERR("<<<<< Test %s FAILED >>>>>\n", nt_array[i].func_name);
+ }
+ }
}
}
- else if (argc == 2)
+
+ if ( ret && tbl_hdl )
{
- total_entries = atoi(argv[1]);
- IPADBG("Nat Entries: %d\n", total_entries);
+ ipa_nat_test999(
+ nat_mem_type, pub_ip_addr, total_ents, tbl_hdl, 0, &tbl_hdl);
}
+ IPADBG("Total NAT Tests Run:%u, Pass:%u, Fail:%u\n",
+ exec, pass, exec - pass);
- for (cnt=0; cnt<nt; cnt++)
- {
- IPADBG("%s():Executing %d time \n",__FUNCTION__, cnt);
-
- if (!sep)
- {
- ret = ipa_nat_add_ipv4_tbl(pub_ip_add, total_entries, &tbl_hdl);
- CHECK_ERR(ret);
- }
-
- if (sep)
- {
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test000(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test001(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
- }
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test002(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- if (sep)
- {
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test003(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test004(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test005(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
- }
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test006(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test007(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test008(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test00%d\n", exec);
- ret = ipa_nat_test009(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test00%d Fail\n", exec);
- }
- exec++;
-
- if (total_entries >= IPA_NAT_TEST_PRE_COND_TE)
- {
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test010(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test011(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test012(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test013(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test014(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test015(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test016(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test017(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test018(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test019(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test020(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
-
- IPADBG("\n\nExecuting ipa_nat_test0%d\n", exec);
- ret = ipa_nat_test022(total_entries, tbl_hdl, sep);
- if (!ret)
- {
- pass++;
- }
- else
- {
- IPAERR("ipa_nat_test0%d Fail\n", exec);
- }
- exec++;
- }
-
- if (!sep)
- {
- ret = ipa_nat_del_ipv4_tbl(tbl_hdl);
- CHECK_ERR(ret);
- }
- }
- /*======= Printing Results ==========*/
- IPADBG("Total ipa_nat Tests Run:%d, Pass:%d, Fail:%d\n",exec, pass, exec-pass);
return 0;
}