IPANAT: Fix checkpatch errors
To fix checkpatch Errors to proceed with futher check-ins
in ipanat library.
Change-Id: I9e8ff23f4bbe828dbb9ea8598b6ea29a0133adb2
diff --git a/configure.ac b/configure.ac
index 996082b..33164c0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -23,7 +23,25 @@
AC_ARG_WITH(sanitized-headers,
AS_HELP_STRING([--with-sanitized-headers=DIR],
[Specify the location of the sanitized Linux headers]),
- [CPPFLAGS="$CPPFLAGS -isystem $withval"])
+ [CPPFLAGS="$CPPFLAGS -idirafter $withval"])
+
+AC_ARG_WITH([glib],
+ AC_HELP_STRING([--with-glib],
+ [enable glib, building HLOS systems which use glib]))
+
+if (test "x${with_glib}" = "xyes"); then
+ AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
+ PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
+ AC_MSG_ERROR(GThread >= 2.16 is required))
+ PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
+ AC_MSG_ERROR(GLib >= 2.16 is required))
+ GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
+ GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
+ AC_SUBST(GLIB_CFLAGS)
+ AC_SUBST(GLIB_LIBS)
+fi
+
+AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
# Checks for header files.
AC_CHECK_HEADERS([fcntl.h netinet/in.h sys/ioctl.h unistd.h])
diff --git a/ipanat/inc/ipa_nat_drv.h b/ipanat/inc/ipa_nat_drv.h
index cda63f1..04e3af9 100644
--- a/ipanat/inc/ipa_nat_drv.h
+++ b/ipanat/inc/ipa_nat_drv.h
@@ -1,4 +1,4 @@
-/*
+/*
Copyright (c) 2013, The Linux Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without
@@ -36,39 +36,37 @@
* @target_ip: destination ip address
* @private_ip: private ip address
* @target_port: destination port
- * @private_port: private port
+ * @private_port: private port
* @protocol: protocol of rule (tcp/udp)
*/
-typedef struct
-{
- uint32_t target_ip;
- uint32_t private_ip;
- uint16_t target_port;
- uint16_t private_port;
- uint16_t public_port;
- uint8_t protocol;
-
-}ipa_nat_ipv4_rule;
+typedef struct {
+ uint32_t target_ip;
+ uint32_t private_ip;
+ uint16_t target_port;
+ uint16_t private_port;
+ uint16_t public_port;
+ uint8_t protocol;
+} ipa_nat_ipv4_rule;
/**
* ipa_nat_add_ipv4_tbl() - create ipv4 nat table
- * @public_ip_addr: [in] public ipv4 address
- * @number_of_entries: [in] number of nat entries
- * @table_handle: [out] Handle of new ipv4 nat table
- *
- * To create new ipv4 nat table
+ * @public_ip_addr: [in] public ipv4 address
+ * @number_of_entries: [in] number of nat entries
+ * @table_handle: [out] Handle of new ipv4 nat table
+ *
+ * To create new ipv4 nat table
*
* 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);
+ uint16_t number_of_entries,
+ uint32_t *table_handle);
/**
* ipa_nat_del_ipv4_tbl() - delete ipv4 table
- * @table_handle: [in] Handle of ipv4 nat table
- *
- * To delete given ipv4 nat table
+ * @table_handle: [in] Handle of ipv4 nat table
+ *
+ * To delete given ipv4 nat table
*
* Returns: 0 On Success, negative on failure
*/
@@ -76,43 +74,43 @@
/**
* ipa_nat_add_ipv4_rule() - to insert new ipv4 rule
- * @table_handle: [in] handle of ipv4 nat table
- * @rule: [in] Pointer to new rule
- * @rule_handle: [out] Return the handle to rule
- *
- * To insert new ipv4 nat rule into ipv4 nat table
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule: [in] Pointer to new rule
+ * @rule_handle: [out] Return the handle to rule
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
*
* Returns: 0 On Success, negative on failure
*/
int ipa_nat_add_ipv4_rule(uint32_t table_handle,
- const ipa_nat_ipv4_rule *rule,
- uint32_t *rule_handle);
+ const ipa_nat_ipv4_rule * rule,
+ uint32_t *rule_handle);
/**
* ipa_nat_del_ipv4_rule() - to delete ipv4 nat rule
- * @table_handle: [in] handle of ipv4 nat table
+ * @table_handle: [in] handle of ipv4 nat table
* @rule_handle: [in] ipv4 nat rule handle
- *
- * To insert new ipv4 nat rule into ipv4 nat table
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
*
* Returns: 0 On Success, negative on failure
*/
int ipa_nat_del_ipv4_rule(uint32_t table_handle,
- uint32_t rule_handle);
+ uint32_t rule_handle);
/**
* ipa_nat_query_timestamp() - to query timestamp
- * @table_handle: [in] handle of ipv4 nat table
- * @rule_handle: [in] ipv4 nat rule handle
- * @time_stamp: [out] time stamp of rule
- *
- * To retrieve the timestamp that lastly the
- * nat rule was accessed
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule_handle: [in] ipv4 nat rule handle
+ * @time_stamp: [out] time stamp of rule
+ *
+ * To retrieve the timestamp that lastly the
+ * nat rule was accessed
*
* Returns: 0 On Success, negative on failure
*/
int ipa_nat_query_timestamp(uint32_t table_handle,
- uint32_t rule_handle,
- uint32_t *time_stamp);
+ uint32_t rule_handle,
+ uint32_t *time_stamp);
diff --git a/ipanat/inc/ipa_nat_drvi.h b/ipanat/inc/ipa_nat_drvi.h
index 6fce315..219dbe4 100644
--- a/ipanat/inc/ipa_nat_drvi.h
+++ b/ipanat/inc/ipa_nat_drvi.h
@@ -1,4 +1,4 @@
-/*
+/*
Copyright (c) 2013, The Linux Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without
@@ -38,13 +38,11 @@
#include <linux/msm_ipa.h>
#include <netinet/in.h>
#include <sys/inotify.h>
+#include <errno.h>
#include "ipa_nat_logi.h"
#define NAT_DUMP
-//#define IPADBG(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
-//#define IPAERR(fmt, args...) printf(" %s:%d " fmt, __FUNCTION__, __LINE__, ## args)
-
/*======= IMPLEMENTATION related data structures and functions ======= */
#ifdef IPA_ON_R3PC
@@ -89,14 +87,14 @@
#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
@@ -110,18 +108,16 @@
------------------------------------
-----------------------------------------*/
#define IPA_NAT_SW_PARAM_PREV_INDX_BYTE 0
-#define IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE 1
+#define IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE 1
-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 {
+ 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
-{
+typedef enum {
NEXT_INDEX_FIELD,
PUBLIC_PORT_FILED,
PRIVATE_PORT_FIELD,
@@ -132,11 +128,10 @@
PROTOCOL_FIELD,
TCP_UDP_CHKSUM_FIELD,
SW_SPEC_PARAM_PREV_INDEX_FIELD,
- SW_SPEC_PARAM_INDX_TBL_ENTRY_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_rule_field_type;
/*
---------------------------------------------
@@ -145,11 +140,10 @@
| Public Port(2B) | Next Index(2B) |
---------------------------------------------
*/
-typedef struct
-{
+typedef struct {
uint32_t next_index:16;
- uint32_t public_port:16;
-}next_index_pub_port;
+ uint32_t public_port:16;
+} next_index_pub_port;
/*
@@ -160,13 +154,12 @@
|EN|FIN|Resv | | |
---------------------------------------------
*/
-typedef struct
-{
+typedef struct {
uint32_t ip_chksum:16;
- uint32_t rsvd1:14;
- uint32_t redirect:1;
- uint32_t enable:1;
-}ipcksum_enbl;
+ uint32_t rsvd1:14;
+ uint32_t redirect:1;
+ uint32_t enable:1;
+} ipcksum_enbl;
/*
@@ -177,11 +170,10 @@
| (1B) | |
---------------------------------------
*/
-typedef struct
-{
+typedef struct {
uint32_t time_stamp:24;
- uint32_t protocol:8;
-}time_stamp_proto;
+ uint32_t protocol:8;
+} time_stamp_proto;
/*
@@ -194,10 +186,10 @@
typedef struct {
uint16_t tbl_entry;
uint16_t next_index;
-}tbl_ent_nxt_indx;
+} tbl_ent_nxt_indx;
-/*--------------------------------------------------
- 32 bit sw_spec_params is interpreted as follows
+/*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
------------------------------------
| 16 bits | 16 bits |
------------------------------------
@@ -208,10 +200,10 @@
typedef struct {
uint16_t prev_index;
uint16_t index_table_entry;
-}sw_spec_params;
+} sw_spec_params;
/*------------------------ NAT Table Entry ---------------------------------------
-
+
-----------------------------------------------------------------------------------
| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
-----------------------------------------------------------------------------------
@@ -220,28 +212,28 @@
|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 | | |
+ | (1B) | |EN|FIN|Resv | | |
-----------------------------------------------------------------------------------
| TCP/UDP checksum | Reserved(2B) | SW Specific Parameters(4B) |
| diff (2B) | |
-----------------------------------------------------------------------------------
-
+
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 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 nxt_indx_pub_port:32;
+ uint64_t private_port:16;
+ uint64_t target_port:16;
- uint64_t ip_cksm_enbl:32;
+ uint64_t ip_cksm_enbl:32;
uint64_t ts_proto:32;
-
- /*--------------------------------------------------
- 32 bit sw_spec_params is interpreted as follows
+
+ /*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
------------------------------------
| 16 bits | 16 bits |
------------------------------------
@@ -251,29 +243,28 @@
--------------------------------------------------*/
uint64_t sw_spec_params:32;
- uint64_t rsvd2:16;
- uint64_t tcp_udp_chksum:16;
-
+ uint64_t rsvd2:16;
+ uint64_t tcp_udp_chksum:16;
};
struct ipa_nat_sw_rule {
- uint64_t private_ip:32;
- uint64_t target_ip:32;
+ 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;
- uint64_t target_port:16;
+ uint64_t next_index:16;
+ uint64_t public_port:16;
+ uint64_t private_port:16;
+ uint64_t target_port:16;
- uint64_t ip_chksum:16;
- uint64_t rsvd1:14;
- uint64_t redirect:1;
- uint64_t enable:1;
- uint64_t time_stamp:24;
- uint64_t protocol:8;
-
- /*--------------------------------------------------
- 32 bit sw_spec_params is interpreted as follows
+ uint64_t ip_chksum:16;
+ uint64_t rsvd1:14;
+ uint64_t redirect:1;
+ uint64_t enable:1;
+ uint64_t time_stamp:24;
+ uint64_t protocol:8;
+
+ /*--------------------------------------------------
+ 32 bit sw_spec_params is interpreted as follows
------------------------------------
| 16 bits | 16 bits |
------------------------------------
@@ -281,189 +272,196 @@
| entry | |
------------------------------------
--------------------------------------------------*/
- uint64_t prev_index:16;
- uint64_t indx_tbl_entry:16;
- uint64_t rsvd2:16;
- uint64_t tcp_udp_chksum:16;
-
+ uint64_t prev_index:16;
+ uint64_t indx_tbl_entry:16;
+ uint64_t rsvd2:16;
+ uint64_t tcp_udp_chksum:16;
};
#define IPA_NAT_TABLE_ENTRY_SIZE 32
-#define IPA_NAT_INDEX_TABLE_ENTRY_SIZE 4
+#define IPA_NAT_INDEX_TABLE_ENTRY_SIZE 4
struct ipa_nat_indx_tbl_rule {
- uint32_t tbl_entry_nxt_indx;
+ uint32_t tbl_entry_nxt_indx;
};
struct ipa_nat_sw_indx_tbl_rule {
- uint16_t tbl_entry;
- uint16_t next_index;
+ uint16_t tbl_entry;
+ uint16_t next_index;
};
struct ipa_nat_indx_tbl_meta_info {
- uint16_t prev_index;
+ uint16_t prev_index;
};
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];
+ uint8_t valid;
+ uint32_t public_addr;
- char *ipv4_rules_addr;
- char *index_table_addr;
- uint16_t table_entries;
+ int nat_fd;
+ int size;
+ uint32_t tbl_addr_offset;
+ char table_name[IPA_RESOURCE_NAME_MAX];
- char *ipv4_expn_rules_addr;
- char *index_table_expn_addr;
- uint16_t expn_table_entries;
-
- struct ipa_nat_indx_tbl_meta_info *index_expn_table_meta;
-
- uint16_t *rule_id_array;
+ 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;
+
+ struct ipa_nat_indx_tbl_meta_info *index_expn_table_meta;
+
+ uint16_t *rule_id_array;
#ifdef IPA_ON_R3PC
- uint32_t mmap_offset;
+ uint32_t mmap_offset;
#endif
};
struct ipa_nat_cache {
- struct ipa_nat_ip4_table_cache ip4_tbl[IPA_NAT_MAX_IP4_TBLS];
- int ipa_fd;
- uint8_t table_cnt;
+ struct ipa_nat_ip4_table_cache ip4_tbl[IPA_NAT_MAX_IP4_TBLS];
+ int ipa_fd;
+ uint8_t table_cnt;
};
struct ipa_nat_indx_tbl_sw_rule {
- uint16_t tbl_entry;
- uint16_t next_index;
- uint16_t prev_index;
+ 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;
+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
- *
+ * 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);
+ 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_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
+ *
+ * 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);
+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 *cache_ptr,
- nat_table_type tbl_type,
- uint16_t indx_tbl_entry);
+ nat_table_type tbl_type,
+ uint16_t indx_tbl_entry);
uint32_t ipa_nati_get_entry_offset(struct ipa_nat_ip4_table_cache *cache_ptr,
- nat_table_type tbl_type,
- uint16_t tbl_entry);
+ 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);
+ 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 *tbl_entries, uint16_t *expn_tbl_entries);
+ struct ipa_ioc_nat_alloc_mem *mem,
+ uint16_t *tbl_entries, uint16_t *expn_tbl_entries);
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);
+ uint32_t public_ip_addr,
+ uint16_t tbl_entries,
+ uint16_t expn_tbl_entries);
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,
- uint32_t *time_stamp);
+ 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_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);
+ 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 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ uint16_t entry);
int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
- uint32_t rule_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);
+ uint16_t tbl_entry,
+ uint8_t expn_tbl,
+ del_type rule_pos);
+
void ipa_nati_find_index_rule_pos(
- struct ipa_nat_ip4_table_cache *cache_ptr,
- uint16_t tbl_entry,
- del_type *rule_pos);
+ struct ipa_nat_ip4_table_cache *cache_ptr,
+ uint16_t tbl_entry,
+ del_type *rule_pos);
+
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);
+ uint8_t expn_tbl,
+ uint16_t tbl_entry,
+ del_type *rule_pos);
void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx);
/* ========================================================
- Debug functions
+ Debug functions
========================================================*/
#ifdef NAT_DUMP
void ipa_nati_print_rule(struct ipa_nat_rule *rule, uint32_t rule_id);
diff --git a/ipanat/src/Makefile.am b/ipanat/src/Makefile.am
index ef6969e..8bdb9b8 100644
--- a/ipanat/src/Makefile.am
+++ b/ipanat/src/Makefile.am
@@ -1,21 +1,21 @@
AM_CFLAGS = -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs
AM_CFLAGS += -I./../inc
-#AM_CFLAGS += -DDEBUG
+#AM_CFLAGS += -DDEBUG -g
+
+common_CFLAGS = -DUSE_GLIB @GLIB_CFLAGS@
+common_LDFLAGS = -lrt @GLIB_LIBS@
c_sources = ipa_nat_drv.c \
ipa_nat_drvi.c \
- ipa_nat_logi.c
+ ipa_nat_logi.c
library_includedir = $(pkgincludedir)
library_include_HEADERS = ./../inc/ipa_nat_drvi.h \
./../inc/ipa_nat_drv.h \
- ./../inc/ipa_nat_logi.h
+ ./../inc/ipa_nat_logi.h
lib_LTLIBRARIES = libipanat.la
libipanat_la_C = @C@
libipanat_la_SOURCES = $(c_sources)
-libipanat_la_CFLAGS = $(AM_CFLAGS)
-libipanat_la_LDFLAGS = -shared -version-info 1:0:0
-
-
-
+libipanat_la_CFLAGS = $(AM_CFLAGS) $(common_CFLAGS)
+libipanat_la_LDFLAGS = -shared $(common_LDFLAGS) -version-info 1:0:0
diff --git a/ipanat/src/ipa_nat_drv.c b/ipanat/src/ipa_nat_drv.c
index 2b62a3c..66504e1 100644
--- a/ipanat/src/ipa_nat_drv.c
+++ b/ipanat/src/ipa_nat_drv.c
@@ -1,4 +1,4 @@
-/*
+/*
Copyright (c) 2013, The Linux Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without
@@ -32,33 +32,31 @@
/**
* ipa_nat_add_ipv4_tbl() - create ipv4 nat table
- * @public_ip_addr: [in] public ipv4 address
- * @number_of_entries: [in] number of nat entries
- * @table_handle: [out] Handle of new ipv4 nat table
- *
- * To create new ipv4 nat table
+ * @public_ip_addr: [in] public ipv4 address
+ * @number_of_entries: [in] number of nat entries
+ * @table_handle: [out] Handle of new ipv4 nat table
+ *
+ * To create new ipv4 nat table
*
* 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)
+ uint16_t number_of_entries,
+ uint32_t *tbl_hdl)
{
int ret;
-
- if (NULL == tbl_hdl || 0 == number_of_entries)
- {
+
+ if (NULL == tbl_hdl || 0 == number_of_entries) {
IPAERR("Invalid parameters \n");
- return -1;
+ return -EINVAL;
}
-
+
ret = ipa_nati_add_ipv4_tbl(public_ip_addr,
- number_of_entries,
- tbl_hdl);
- if (ret != 0)
- {
+ number_of_entries,
+ tbl_hdl);
+ if (ret != 0) {
IPAERR("unable to add table \n");
- return -1;
+ return -EINVAL;
}
IPADBG("Returning table handle 0x%x\n", *tbl_hdl);
@@ -67,19 +65,18 @@
/**
* ipa_nat_del_ipv4_tbl() - delete ipv4 table
- * @table_handle: [in] Handle of ipv4 nat table
- *
- * To delete given ipv4 nat table
+ * @table_handle: [in] Handle of ipv4 nat table
+ *
+ * To delete given ipv4 nat table
*
* Returns: 0 On Success, negative on failure
*/
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)
- {
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
IPAERR("invalid table handle passed \n");
- return -1;
+ return -EINVAL;
}
IPADBG("Passed Table Handle: 0x%x\n", tbl_hdl);
@@ -88,31 +85,30 @@
/**
* ipa_nat_add_ipv4_rule() - to insert new ipv4 rule
- * @table_handle: [in] handle of ipv4 nat table
- * @rule: [in] Pointer to new rule
- * @rule_handle: [out] Return the handle to rule
- *
- * To insert new ipv4 nat rule into ipv4 nat table
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule: [in] Pointer to new rule
+ * @rule_handle: [out] Return the handle to rule
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
*
* 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;
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
tbl_hdl > IPA_NAT_MAX_IP4_TBLS || NULL == rule_hdl ||
- NULL == clnt_rule)
- {
+ NULL == clnt_rule) {
IPAERR("invalide table handle passed \n");
- return -1;
+ return result;
}
IPADBG("Passed Table handle: 0x%x\n", tbl_hdl);
- if(ipa_nati_add_ipv4_rule(tbl_hdl, clnt_rule, rule_hdl) != 0)
- {
- return -1;
+ if (ipa_nati_add_ipv4_rule(tbl_hdl, clnt_rule, rule_hdl) != 0) {
+ return result;
}
IPADBG("returning rule handle 0x%x\n", *rule_hdl);
@@ -122,29 +118,29 @@
/**
* ipa_nat_del_ipv4_rule() - to delete ipv4 nat rule
- * @table_handle: [in] handle of ipv4 nat table
+ * @table_handle: [in] handle of ipv4 nat table
* @rule_handle: [in] ipv4 nat rule handle
- *
- * To insert new ipv4 nat rule into ipv4 nat table
+ *
+ * To insert new ipv4 nat rule into ipv4 nat table
*
* Returns: 0 On Success, negative on failure
*/
int ipa_nat_del_ipv4_rule(uint32_t tbl_hdl,
- uint32_t rule_hdl)
+ uint32_t rule_hdl)
{
+ int result = -EINVAL;
if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- IPA_NAT_INVALID_NAT_ENTRY == rule_hdl)
- {
+ IPA_NAT_INVALID_NAT_ENTRY == rule_hdl) {
IPAERR("invalide parameters\n");
- return -1;
+ return result;
}
IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
- if (-1 == ipa_nati_del_ipv4_rule(tbl_hdl, rule_hdl))
- {
+ result = ipa_nati_del_ipv4_rule(tbl_hdl, rule_hdl);
+ if (result) {
IPAERR("unable to delete rule from hw \n");
- return -1;
+ return result;
}
return 0;
@@ -152,25 +148,24 @@
/**
* ipa_nat_query_timestamp() - to query timestamp
- * @table_handle: [in] handle of ipv4 nat table
- * @rule_handle: [in] ipv4 nat rule handle
- * @time_stamp: [out] time stamp of rule
- *
- * To retrieve the timestamp that lastly the
- * nat rule was accessed
+ * @table_handle: [in] handle of ipv4 nat table
+ * @rule_handle: [in] ipv4 nat rule handle
+ * @time_stamp: [out] time stamp of rule
+ *
+ * To retrieve the timestamp that lastly the
+ * nat rule was accessed
*
* Returns: 0 On Success, negative on failure
*/
int ipa_nat_query_timestamp(uint32_t tbl_hdl,
- uint32_t rule_hdl,
- uint32_t *time_stamp)
+ uint32_t rule_hdl,
+ uint32_t *time_stamp)
{
if (0 == tbl_hdl || tbl_hdl > IPA_NAT_MAX_IP4_TBLS ||
- NULL == time_stamp)
- {
+ NULL == time_stamp) {
IPAERR("invalid parameters passed \n");
- return -1;
+ return -EINVAL;
}
IPADBG("Passed Table: 0x%x and rule handle 0x%x\n", tbl_hdl, rule_hdl);
diff --git a/ipanat/src/ipa_nat_drvi.c b/ipanat/src/ipa_nat_drvi.c
index cd0dd2b..4d77a1f 100644
--- a/ipanat/src/ipa_nat_drvi.c
+++ b/ipanat/src/ipa_nat_drvi.c
@@ -1,18 +1,18 @@
-/*
+/*
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.
+ * 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
@@ -30,64 +30,62 @@
#include "ipa_nat_drv.h"
#include "ipa_nat_drvi.h"
-#define IPANAT_DUMMY_USE(element) element++;
+#ifdef USE_GLIB
+#include <glib.h>
+#define strlcpy g_strlcpy
+#endif
+
struct ipa_nat_cache ipv4_nat_cache;
/* ------------------------------------------
- UTILITY FUNCTIONS START
- --------------------------------------------*/
+ UTILITY FUNCTIONS START
+ --------------------------------------------*/
/**
* UpdateSwSpecParams() - updates sw specific params
- * @rule: [in/out] nat table rule
+ * @rule: [in/out] nat table rule
* @param_type: [in] which param need to update
- * @value: [in] value of param
- *
+ * @value: [in] value of param
+ *
* Update SW specific params in the passed rule.
*
- * Returns: None
+ * Returns: None
*/
-void UpdateSwSpecParams(struct ipa_nat_rule *rule,
- uint8_t param_type,
+void UpdateSwSpecParams(struct ipa_nat_rule *rule,
+ uint8_t param_type,
uint32_t value)
{
-
- uint32_t temp = rule->sw_spec_params;
+ uint32_t temp = rule->sw_spec_params;
- if(IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE == param_type)
- {
+ if (IPA_NAT_SW_PARAM_INDX_TBL_ENTRY_BYTE == param_type) {
value = (value << INDX_TBL_ENTRY_SIZE_IN_BITS);
temp &= 0x0000FFFF;
- }
- else
- {
+ } else {
temp &= 0xFFFF0000;
- }
-
- temp = (temp | value);
- rule->sw_spec_params = temp;
- return;
+ }
+
+ temp = (temp | value);
+ rule->sw_spec_params = temp;
+ return;
}
/**
* Read8BitFieldValue()
- * @rule: [in/out]
+ * @rule: [in/out]
* @param_type: [in]
* @value: [in]
- *
- *
*
- * Returns: None
+ *
+ *
+ * Returns: None
*/
uint8_t Read8BitFieldValue(uint32_t param,
ipa_nat_rule_field_type fld_type)
{
-
void *temp = (void *)¶m;
- switch (fld_type)
- {
+ switch (fld_type) {
case PROTOCOL_FIELD:
return ((time_stamp_proto *)temp)->protocol;
@@ -96,17 +94,14 @@
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)
- {
+ switch (fld_type) {
case NEXT_INDEX_FIELD:
return ((next_index_pub_port *)temp)->next_index;
@@ -137,8 +132,7 @@
default:
IPAERR("Invalid Field type passed\n");
return 0;
- }
-
+ }
}
uint32_t Read32BitFieldValue(uint32_t param,
@@ -147,8 +141,7 @@
void *temp = (void *)¶m;
- switch (fld_type)
- {
+ switch (fld_type) {
case TIME_STAMP_FIELD:
return ((time_stamp_proto *)temp)->time_stamp;
@@ -157,1210 +150,1169 @@
IPAERR("Invalid Field type passed\n");
return 0;
}
-
}
/**
* CreateNatDevice() - Create nat devices
* @mem: [in] name of device that need to create
- *
- * Create Nat device and Register for file 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
+ * 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 -1;
- }
- IPADBG("posted IPA_IOC_ALLOC_NAT_MEM to kernel successfully \n");
- return 0;
+#define EVENT_SIZE (sizeof (struct inotify_event))
+#define FILE_NAME_LENGTH (sizeof(NAT_DEV_NAME)*2 + 1)
+#define BUF_LEN (EVENT_SIZE + FILE_NAME_LENGTH)
+
+ int length;
+ int wd;
+ char buffer[BUF_LEN];
+ int ret, inotify_fd;
+
+ inotify_fd = inotify_init();
+ if (inotify_fd < 0) {
+ perror("inotify_init");
+ return -EINVAL;
+ }
+
+ IPADBG("Waiting for nofications in dir %s\n", NAT_DEV_DIR);
+ wd = inotify_add_watch(inotify_fd,
+ NAT_DEV_DIR,
+ IN_CREATE);
+
+ 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 -EIO;
+ }
+ IPADBG("posted IPA_IOC_ALLOC_NAT_MEM to kernel successfully \n");
+
+ length = read(inotify_fd, buffer, BUF_LEN);
+
+ if (length < 0) {
+ perror("inotify read");
+ return -EINVAL;
+ }
+
+ struct inotify_event *event = (struct inotify_event *)buffer;
+ if (event->len) {
+ if (event->mask & IN_CREATE) {
+ if (event->mask & IN_ISDIR) {
+ IPADBG("The directory %s was created.\n", event->name);
+ } else {
+ IPADBG("The file %s was created.\n", event->name);
+ }
+ }
+ }
+
+ (void)inotify_rm_watch(inotify_fd, wd);
+ (void)close(inotify_fd);
+ 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
+ * 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;
+ uint16_t number = num;
+ uint16_t tmp = 1;
+ *ret = 0;
- if(0 == num)
- {
- return -1;
- }
+ if (0 == num) {
+ return -EINVAL;
+ }
- if(1 == num)
- {
- *ret = 2;
- return 0;
- }
+ if (1 == num) {
+ *ret = 2;
+ return 0;
+ }
- for(;;)
- {
- if(1 == num)
- {
- if(number != tmp)
- {
- tmp *= 2;
- }
+ for (;;) {
+ if (1 == num) {
+ if (number != tmp) {
+ tmp *= 2;
+ }
- *ret = tmp;
- return 0;
- }
+ *ret = tmp;
+ return 0;
+ }
- num >>= 1;
- tmp *= 2;
- }
+ num >>= 1;
+ tmp *= 2;
+ }
- return -1;
+ 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
+ * Returns: 0 on success, negative on failure
*/
void GetNearestEven (uint16_t num, uint16_t *ret)
{
- if(num < 2)
- {
+ if (num < 2) {
*ret = 2;
- return;
- }
+ return;
+ }
- while ((num % 2) != 0)
- {
+ while ((num % 2) != 0) {
num = num + 1;
}
*ret = num;
- return;
+ return;
}
/**
* dst_hash() - Find the index into ipv4 base table
- * @trgt_ip: [in] Target IP address
- * @trgt_port: [in] Target port
- * @public_port: [in] Public port
- * @proto: [in] Protocol (TCP/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
+ *
+ * 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
+ * Returns: >0 index into ipv4 base table, negative on failure
*/
-static uint16_t dst_hash(uint32_t trgt_ip, uint16_t trgt_port,
- uint16_t public_port, uint8_t proto,
- uint16_t size)
+static uint16_t dst_hash(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("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);
+ uint16_t hash = ((uint16_t)(trgt_ip)) ^ ((uint16_t)(trgt_ip >> 16)) ^
+ (trgt_port) ^ (public_port) ^ (proto);
- hash = (hash & size);
+ 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);
- /* 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;
+ 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)
+ * @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
+ *
+ * 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
+ * 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)
+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);
+ 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);
+ 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);
- /* 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;
- }
+ hash = (hash & size);
- IPADBG("src_hash returning value: %d\n", hash);
- return hash;
+ /* 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
- * @pub_ip_addr: [in] public ip address
- * @priv_ip_addr: [in] Private ip address
- *
- * source nat ip checksum different is calculated as
- * public_ip_addr - private_ip_addr
+ * IP checksum diff
+ * @pub_ip_addr: [in] public ip address
+ * @priv_ip_addr: [in] Private ip address
+ *
+ * source nat ip checksum different is calculated as
+ * public_ip_addr - private_ip_addr
* Here we are using 1's complement to represent -ve number.
- * So take 1's complement of private ip addr and add it
+ * So take 1's complement of private ip addr and add it
* to public ip addr.
*
- * Returns: >0 ip checksum diff
+ * Returns: >0 ip checksum diff
*/
static uint16_t ipa_nati_calc_ip_cksum(uint32_t pub_ip_addr,
- uint32_t priv_ip_addr)
+ uint32_t priv_ip_addr)
{
- uint16_t ret;
- uint32_t cksum = 0;
+ uint16_t ret;
+ uint32_t cksum = 0;
- /* Add LSB(2 bytes) of public ip address to cksum */
- cksum += (pub_ip_addr & 0xFFFF);
-
- /* Add MSB(2 bytes) of public ip address to cksum
- and check for carry forward(CF), if any add it
- */
- cksum += (pub_ip_addr>>16);
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
-
- /* Calculate the 1's complement of private ip address */
- priv_ip_addr = (~priv_ip_addr);
-
- /* Add LSB(2 bytes) of private ip address to cksum
- and check for carry forward(CF), if any add it
- */
- cksum += (priv_ip_addr & 0xFFFF);
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
-
- /* Add MSB(2 bytes) of private ip address to cksum
- and check for carry forward(CF), if any add it
- */
- cksum += (priv_ip_addr>>16);
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
+ /* Add LSB(2 bytes) of public ip address to cksum */
+ cksum += (pub_ip_addr & 0xFFFF);
- /* Return the LSB(2 bytes) of checksum */
- ret = (uint16_t)cksum;
- return ret;
+ /* Add MSB(2 bytes) of public ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (pub_ip_addr>>16);
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+ /* Calculate the 1's complement of private ip address */
+ priv_ip_addr = (~priv_ip_addr);
+
+ /* Add LSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (priv_ip_addr & 0xFFFF);
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Add MSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (priv_ip_addr>>16);
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Return the LSB(2 bytes) of checksum */
+ ret = (uint16_t)cksum;
+ return ret;
}
/**
* 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
- * @priv_port: [in] Private tcp/udp prot
- *
- * source nat tcp/udp checksum is calculated as
+ * 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
+ * @priv_port: [in] Private tcp/udp prot
+ *
+ * source nat tcp/udp checksum is calculated as
* (pub_ip_addr + pub_port) - (priv_ip_addr + priv_port)
* Here we are using 1's complement to represent -ve number.
- * So take 1's complement of prviate ip addr &private port
+ * So take 1's complement of prviate ip addr &private port
* and add it public ip addr & public port.
*
- * Returns: >0 tcp/udp checksum diff
+ * 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;
+ uint16_t ret = 0;
+ uint32_t cksum = 0;
- /* Add LSB(2 bytes) of public ip address to cksum */
- cksum += (pub_ip_addr & 0xFFFF);
-
- /* Add MSB(2 bytes) of public ip address to cksum
- and check for carry forward(CF), if any add it
- */
- cksum += (pub_ip_addr>>16);
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
-
- /* Add public port to cksum and
- check for carry forward(CF), if any add it */
- cksum += pub_port;
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
+ /* Add LSB(2 bytes) of public ip address to cksum */
+ cksum += (pub_ip_addr & 0xFFFF);
- /* Calculate the 1's complement of private ip address */
- priv_ip_addr = (~priv_ip_addr);
-
- /* Add LSB(2 bytes) of private ip address to cksum
- and check for carry forward(CF), if any add it
- */
- cksum += (priv_ip_addr & 0xFFFF);
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
-
- /* Add MSB(2 bytes) of private ip address to cksum
- and check for carry forward(CF), if any add
- */
- cksum += (priv_ip_addr>>16);
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
+ /* Add MSB(2 bytes) of public ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (pub_ip_addr>>16);
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
- /* Calculate the 1's complement of private port */
- priv_port = (~priv_port);
-
- /* Add public port to cksum and
- check for carry forward(CF), if any add it */
- cksum += priv_port;
- if (cksum>>16)
- {
- cksum = (cksum & 0x0000FFFF);
- cksum += 1;
- }
+ /* Add public port to cksum and
+ check for carry forward(CF), if any add it */
+ cksum += pub_port;
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
- /* return the LSB(2 bytes) of checksum */
- ret = (uint16_t)cksum;
- return ret;
-
+ /* Calculate the 1's complement of private ip address */
+ priv_ip_addr = (~priv_ip_addr);
+
+ /* Add LSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add it
+ */
+ cksum += (priv_ip_addr & 0xFFFF);
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Add MSB(2 bytes) of private ip address to cksum
+ and check for carry forward(CF), if any add
+ */
+ cksum += (priv_ip_addr>>16);
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* Calculate the 1's complement of private port */
+ priv_port = (~priv_port);
+
+ /* Add public port to cksum and
+ check for carry forward(CF), if any add it */
+ cksum += priv_port;
+ if (cksum >> 16) {
+ cksum = (cksum & 0x0000FFFF);
+ cksum += 1;
+ }
+
+ /* return the LSB(2 bytes) of checksum */
+ ret = (uint16_t)cksum;
+ return ret;
}
/**
* ipa_nati_make_rule_hdl() - makes nat rule handle
- * @tbl_hdl: [in] nat table 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
+ * 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)
+uint16_t ipa_nati_make_rule_hdl(uint16_t tbl_hdl,
+ uint16_t tbl_entry)
{
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- uint16_t rule_hdl = 0;
- uint16_t cnt = 0;
-
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ uint16_t rule_hdl = 0;
+ uint16_t cnt = 0;
- if (tbl_entry >= tbl_ptr->table_entries)
- {
- /* 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
- {
- rule_hdl = tbl_entry;
- rule_hdl = (rule_hdl << IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
- }
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
- 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);
- }
- }
+ if (tbl_entry >= tbl_ptr->table_entries) {
+ /* 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 {
+ rule_hdl = tbl_entry;
+ rule_hdl = (rule_hdl << IPA_NAT_RULE_HDL_TBL_TYPE_BITS);
+ }
- return 0;
+ 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;
+ }
+ }
+
+ 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
+ * 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_index,
- uint16_t rule_hdl,
- uint8_t *expn_tbl,
- uint16_t *tbl_entry)
+ uint16_t rule_hdl, uint8_t *expn_tbl,
+ uint16_t *tbl_entry)
{
- struct ipa_nat_ip4_table_cache *tbl_ptr;
- uint16_t rule_id;
+ struct ipa_nat_ip4_table_cache *tbl_ptr;
+ uint16_t rule_id;
- *expn_tbl = 0;
- *tbl_entry = IPA_NAT_INVALID_NAT_ENTRY;
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_index];
+ *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;
- }
+ 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;
+ 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)
+ 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;
+ 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)
+ nat_table_type tbl_type,
+ uint16_t indx_tbl_entry)
{
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- uint32_t ret = 0;
+ 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;
- }
+ 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;
+ ret = (char *)&indx_tbl_ptr[indx_tbl_entry] - (char *)indx_tbl_ptr;
+ ret += cache_ptr->tbl_addr_offset;
+ return ret;
}
/* ------------------------------------------
- UTILITY FUNCTIONS END
+ UTILITY FUNCTIONS END
--------------------------------------------*/
/* ------------------------------------------
- Main Functions
+ 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;
+ 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 */
+ /* Base table */
IPADBG("memset() base table to 0, %p\n",
- ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr);
+ 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);
+ 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);
+ 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 */
+ 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);
+ 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);
+ memset(ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_addr,
+ 0,
+ IPA_NAT_INDEX_TABLE_ENTRY_SIZE * table_entries);
- /* Index expansion table */
+ /* Index expansion table */
IPADBG("memset() index expn table to 0, %p\n",
- ipv4_nat_cache.ip4_tbl[tbl_indx].index_table_expn_addr);
+ 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);
+ 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;
+ return;
}
int ipa_nati_add_ipv4_tbl(uint32_t public_ip_addr,
- uint16_t number_of_entries,
- uint32_t *tbl_hdl)
+ 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 -1;
- }
+ 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;
- /* 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 -1;
- }
+ *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;
+ }
- /* 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 -1;
- }
+ /* 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;
+ }
- ipa_nati_reset_tbl(tbl_indx);
+ /* 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;
+ }
- /* Return table handle */
- ipv4_nat_cache.table_cnt++;
- *tbl_hdl = ipv4_nat_cache.table_cnt;
+ ipa_nati_reset_tbl(tbl_indx);
+
+ /* 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);
+ ipa_nat_dump_ipv4_table(*tbl_hdl);
#endif
- return 0;
+ 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)
+ 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 */
- strcpy(mem->dev_name, NAT_DEV_NAME);
+ int fd = 0, ret;
+ uint16_t total_entries;
- /* 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(-1 == GetNearest2Power(*table_entries, table_entries))
- {
- IPAERR("unable to calculate power of 2\n");
- return -1;
- }
-
- *expn_table_entries = (uint16_t)(number_of_entries * IPA_NAT_EXPANSION_TABLE_PERCENTAGE);
+ /* 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: %d\n", mem->size);
- mem->size += (IPA_NAT_INDEX_TABLE_ENTRY_SIZE * total_entries);
- IPADBG("Nat Base and Index Table size: %d\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 -1;
- }
- ipv4_nat_cache.ipa_fd = fd;
- }
+ total_entries = (*table_entries)+(*expn_table_entries);
- ret = CreateNatDevice(mem);
- return ret;
-}
-
+ /* Calclate the memory size for both table and index table entries */
+ mem->size = (IPA_NAT_TABLE_ENTRY_SIZE * total_entries);
+ IPADBG("Nat Table size: %d\n", mem->size);
+ mem->size += (IPA_NAT_INDEX_TABLE_ENTRY_SIZE * total_entries);
+ IPADBG("Nat Base and Index Table size: %d\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;
+ }
+
+ 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)
+ uint32_t public_addr,
+ uint16_t tbl_entries,
+ uint16_t expn_tbl_entries)
{
- uint32_t index = ipv4_nat_cache.table_cnt;
- char *ipv4_rules_addr = NULL;
+ uint32_t index = ipv4_nat_cache.table_cnt;
+ char *ipv4_rules_addr = NULL;
- int fd = 0;
- int flags = MAP_SHARED;
- int prot = PROT_READ | PROT_WRITE;
- off_t offset = 0;
+ int fd = 0;
+ int flags = MAP_SHARED;
+ int prot = PROT_READ | PROT_WRITE;
+ off_t offset = 0;
#ifdef IPA_ON_R3PC
- int ret = 0;
- uint32_t nat_mem_offset = 0;
+ 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;
+ 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;
- ipv4_nat_cache.ip4_tbl[index].table_entries = tbl_entries;
- ipv4_nat_cache.ip4_tbl[index].expn_table_entries = expn_tbl_entries;
+ ipv4_nat_cache.ip4_tbl[index].table_entries = tbl_entries;
+ ipv4_nat_cache.ip4_tbl[index].expn_table_entries = expn_tbl_entries;
- IPADBG("num of ipv4 rules:%d\n",tbl_entries);
- IPADBG("num of ipv4 expn rules:%d\n",expn_tbl_entries);
+ IPADBG("num of ipv4 rules:%d\n", tbl_entries);
+ IPADBG("num of ipv4 expn rules:%d\n", expn_tbl_entries);
- /* 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);
+ /* 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);
- if (NULL == ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta)
- {
- IPAERR("Fail to allocate ipv4 index expansion table meta\n");
- return 0;
- }
+ 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);
- }
+ memset(ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta,
+ 0,
+ sizeof(struct ipa_nat_indx_tbl_meta_info) * expn_tbl_entries);
+ }
- /* 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 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));
- if (NULL == ipv4_nat_cache.ip4_tbl[index].rule_id_array)
- {
- IPAERR("Fail to allocate rule id array\n");
- return 0;
- }
+ 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) );
- }
+ memset(ipv4_nat_cache.ip4_tbl[index].rule_id_array,
+ 0,
+ sizeof(uint16_t) * (tbl_entries + expn_tbl_entries));
+ }
-
- /* open the nat table */
- strcpy(mem->dev_name, NAT_DEV_FULL_NAME);
- 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 -1;
- }
- /* copy the nat table name */
- strncpy(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 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;
+ }
- /* open the nat device Table */
+ /* 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);
+ 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);
+ IPADBG("user space r3pc \n");
+ ipv4_rules_addr = (void *)mmap((caddr_t)0, NAT_MMAP_MEM_SIZE,
+ prot, flags,
+ fd, offset);
#endif
- if(NULL == ipv4_rules_addr)
- {
- perror("unable to mmap the memory\n");
- return -1;
- }
+ if (NULL == ipv4_rules_addr) {
+ perror("unable to mmap the memory\n");
+ return -EINVAL;
+ }
#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 -1;
- }
- ipv4_rules_addr += nat_mem_offset;
+ 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;
+ }
+ ipv4_rules_addr += nat_mem_offset;
ipv4_nat_cache.ip4_tbl[index].mmap_offset = nat_mem_offset;
#endif
- IPADBG("mmap return value 0x%lx\n", (long unsigned int)ipv4_rules_addr);
+ IPADBG("mmap return value 0x%lx\n", (long unsigned int)ipv4_rules_addr);
- ipv4_nat_cache.ip4_tbl[index].ipv4_rules_addr = ipv4_rules_addr;
+ ipv4_nat_cache.ip4_tbl[index].ipv4_rules_addr = ipv4_rules_addr;
- ipv4_nat_cache.ip4_tbl[index].ipv4_expn_rules_addr =
- ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * tbl_entries);
-
- ipv4_nat_cache.ip4_tbl[index].index_table_addr =
- ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * (tbl_entries + expn_tbl_entries));
-
- 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);
-
- return 0;
+ ipv4_nat_cache.ip4_tbl[index].ipv4_expn_rules_addr =
+ ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * tbl_entries);
+
+ ipv4_nat_cache.ip4_tbl[index].index_table_addr =
+ ipv4_rules_addr + (IPA_NAT_TABLE_ENTRY_SIZE * (tbl_entries + expn_tbl_entries));
+
+ 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);
+
+ return 0;
}
/* comment: check the implementation once
- offset should be in terms of byes */
+ offset should be in terms of byes */
int ipa_nati_post_ipv4_init_cmd(uint8_t tbl_index)
{
- 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;
+ struct ipa_ioc_v4_nat_init cmd;
+ uint32_t offset = ipv4_nat_cache.ip4_tbl[tbl_index].tbl_addr_offset;
+ 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);
+ cmd.tbl_index = tbl_index;
- cmd.index_offset = cmd.expn_rules_offset +
- (ipv4_nat_cache.ip4_tbl[tbl_index].expn_table_entries * IPA_NAT_TABLE_ENTRY_SIZE);
+ 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);
- cmd.index_expn_offset = cmd.index_offset +
- (ipv4_nat_cache.ip4_tbl[tbl_index].table_entries * IPA_NAT_INDEX_TABLE_ENTRY_SIZE);
-
- 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.index_offset = cmd.expn_rules_offset +
+ (ipv4_nat_cache.ip4_tbl[tbl_index].expn_table_entries * IPA_NAT_TABLE_ENTRY_SIZE);
- cmd.ip_addr = ipv4_nat_cache.ip4_tbl[tbl_index].public_addr;
+ cmd.index_expn_offset = cmd.index_offset +
+ (ipv4_nat_cache.ip4_tbl[tbl_index].table_entries * IPA_NAT_INDEX_TABLE_ENTRY_SIZE);
- 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 -1;
- }
- IPADBG("Posted IPA_IOC_V4_INIT_NAT to kernel successfully \n");
+ 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;
- return 0;
+ cmd.ip_addr = ipv4_nat_cache.ip4_tbl[tbl_index].public_addr;
+
+ 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;
+ }
+ IPADBG("Posted IPA_IOC_V4_INIT_NAT to kernel successfully \n");
+
+ return 0;
}
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");
- return -1;
- }
+ 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;
- /* unmap the device memory from user space */
+ if (!ipv4_nat_cache.ip4_tbl[index].valid) {
+ IPAERR("invalid table handle passed\n");
+ return -EINVAL;
+ }
+
+ /* unmap the device memory from user space */
#ifndef IPA_ON_R3PC
- munmap(addr, ipv4_nat_cache.ip4_tbl[index].size);
+ 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);
+ 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");
- return -1;
- }
+ /* 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");
+ return -EINVAL;
+ }
- 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);
- return -1;
- }
- IPADBG("posted IPA_IOC_V4_DEL_NAT to kernel successfully \n");
+ 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);
+ return -EINVAL;
+ }
+ IPADBG("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]));
+ free(ipv4_nat_cache.ip4_tbl[index].index_expn_table_meta);
+ free(ipv4_nat_cache.ip4_tbl[index].rule_id_array);
- /* Decrease the table count by 1*/
- ipv4_nat_cache.table_cnt--;
+ memset(&ipv4_nat_cache.ip4_tbl[index],
+ 0,
+ sizeof(ipv4_nat_cache.ip4_tbl[index]));
- return 0;
+ /* Decrease the table count by 1*/
+ ipv4_nat_cache.table_cnt--;
+
+ return 0;
}
int ipa_nati_query_timestamp(uint32_t tbl_hdl,
- uint32_t rule_hdl,
- uint32_t *time_stamp)
+ uint32_t rule_hdl,
+ uint32_t *time_stamp)
{
- 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;
-
- if (!ipv4_nat_cache.ip4_tbl[tbl_index].valid)
- {
- IPAERR("invalid table handle\n");
- return -1;
- }
+ 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;
- ipa_nati_parse_ipv4_rule_hdl(tbl_index, (uint16_t)rule_hdl,
- &expn_tbl, &tbl_entry);
+ if (!ipv4_nat_cache.ip4_tbl[tbl_index].valid) {
+ IPAERR("invalid table handle\n");
+ return -EINVAL;
+ }
- 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;
- }
+ ipa_nati_parse_ipv4_rule_hdl(tbl_index, (uint16_t)rule_hdl,
+ &expn_tbl, &tbl_entry);
- *time_stamp = Read32BitFieldValue(tbl_ptr[tbl_entry].ts_proto,
+ 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;
+ }
+
+ *time_stamp = Read32BitFieldValue(tbl_ptr[tbl_entry].ts_proto,
TIME_STAMP_FIELD);
- return 0;
+ return 0;
}
int ipa_nati_add_ipv4_rule(uint32_t tbl_hdl,
- const ipa_nat_ipv4_rule *clnt_rule,
- uint32_t *rule_hdl)
+ const ipa_nat_ipv4_rule *clnt_rule,
+ uint32_t *rule_hdl)
{
- 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;
+ 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;
- memset(&sw_rule, 0, sizeof(sw_rule));
- memset(&index_sw_rule, 0, sizeof(index_sw_rule));
+ memset(&sw_rule, 0, sizeof(sw_rule));
+ memset(&index_sw_rule, 0, sizeof(index_sw_rule));
- /* Generate rule from client input */
- if (-1 == 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 -1;
- }
-
- 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,
+ /* 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;
+ }
+
+ 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));
- IPADBG("new entry:%d, new index entry: %d\n", new_entry, new_index_tbl_entry);
- if( -1 == ipa_nati_post_ipv4_dma_cmd((uint8_t)(tbl_hdl-1), new_entry))
- {
- IPAERR("unable to post dma command\n");
- return -1;
- }
-
- /* 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 -1;
- }
+ 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");
+ 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);
+ ipa_nat_dump_ipv4_table(tbl_hdl);
#endif
- return 0;
+ 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)
+ 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;
- 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;
+ }
- if (NULL == clnt_rule || NULL == index_sw_rule ||
- NULL == rule || NULL == tbl_entry ||
- NULL == indx_tbl_entry)
- {
- IPAERR("invalid parameters\n");
- return -1;
- }
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_hdl-1];
- 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;
+ }
- *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 -1;
- }
+ 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;
+ }
- 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 -1;
- }
-
rule->indx_tbl_entry = *indx_tbl_entry;
- if (*indx_tbl_entry >= tbl_ptr->table_entries)
- {
+ 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;
+ 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)
+ 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 = tbl_ptr->public_addr;
+ uint32_t pub_ip_addr;
+ uint16_t prev = 0, nxt_indx = 0, new_entry;
+ struct ipa_nat_rule *tbl = NULL, *expn_tbl = NULL;
- tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_rules_addr;
- expn_tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_expn_rules_addr;
+ pub_ip_addr = tbl_ptr->public_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;
+ tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_rules_addr;
+ expn_tbl = (struct ipa_nat_rule *)tbl_ptr->ipv4_expn_rules_addr;
- /* consider only public and private ip fields */
- sw_rule->ip_chksum = ipa_nati_calc_ip_cksum(pub_ip_addr,
- clnt_rule->private_ip);
+ /* 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;
- 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);
- }
+ /* consider only public and private ip fields */
+ sw_rule->ip_chksum = ipa_nati_calc_ip_cksum(pub_ip_addr,
+ clnt_rule->private_ip);
- 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->prev_index = 0;
- sw_rule->indx_tbl_entry = 0;
-
- new_entry = dst_hash(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;
+ 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);
}
- /* check for more than one collision */
- else
- {
- /* 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);
+ sw_rule->rsvd1 = 0;
+ sw_rule->enable = IPA_NAT_FLAG_DISABLE_BIT;
+ sw_rule->next_index = 0;
- /* 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;
- }
- }
+ /*
+ 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->prev_index = 0;
+ sw_rule->indx_tbl_entry = 0;
+
+ new_entry = dst_hash(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;
+ }
+ }
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);
+ /* 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");
- return IPA_NAT_INVALID_NAT_ENTRY;
- }
- new_entry += tbl_ptr->table_entries;
-
- IPADBG("new entry index %d\n",new_entry);
- return new_entry;
+ if (IPA_NAT_INVALID_NAT_ENTRY == new_entry) {
+ /* Expansion table is full return*/
+ IPAERR("expansion table is full\n");
+ 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)
+ uint16_t size)
{
- int cnt;
+ 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;
- }
- }
+ 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;
-
+ 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_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;
+ struct ipa_nat_indx_tbl_rule *indx_tbl, *indx_expn_tbl;
+ uint16_t prev = 0, nxt_indx = 0, new_entry;
- 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;
- }
+ 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;
- /* 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,
+ 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);
- //prev = nxt_indx;
- while(nxt_indx != IPA_NAT_INVALID_NAT_ENTRY)
- {
- prev = nxt_indx;
+ 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,
+ 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;
- }
+ /* 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;
+ }
+ }
- /* 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);
+ sw_rule->prev_index = prev;
+ }
- if ( IPA_NAT_INVALID_NAT_ENTRY == new_entry)
- {
- /* Expansion table is full return*/
- IPAERR("index expansion table is full\n");
- return IPA_NAT_INVALID_NAT_ENTRY;
- }
- new_entry += tbl_ptr->table_entries;
-
- IPADBG("index table entry %d\n", new_entry);
- return new_entry;
+ /* 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");
+ return IPA_NAT_INVALID_NAT_ENTRY;
+ }
+ new_entry += tbl_ptr->table_entries;
+
+ 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)
+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;
- }
- }
+ 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;
+ 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)
+ nat_table_type tbl_type,
+ uint16_t value,
+ uint32_t offset)
{
struct ipa_ioc_nat_dma_cmd *cmd;
@@ -1368,12 +1320,11 @@
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)
- {
+ 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;
+ return;
}
cmd->dma[0].table_index = tbl_indx;
@@ -1382,8 +1333,7 @@
cmd->dma[0].offset = offset;
cmd->entries = 1;
- if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd))
- {
+ 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);
@@ -1391,234 +1341,212 @@
}
fail:
- free(cmd);
+ 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_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;
+ 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));
- }
+ if (entry < ipv4_cache->table_entries) {
+ tbl_ptr = (struct ipa_nat_rule *)ipv4_cache->ipv4_rules_addr;
- /* Update the previos entry next_index */
- if(IPA_NAT_INVALID_NAT_ENTRY != prev_entry)
- {
-
- if (prev_entry < ipv4_cache->table_entries)
- {
+ 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_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;
- }
+ /* 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;
+ 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_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;
+ 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;
+ sw_rule.next_index = indx_sw_rule->next_index;
+ sw_rule.tbl_entry = indx_sw_rule->tbl_entry;
- 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));
- }
+ if (entry < ipv4_cache->table_entries) {
+ tbl_ptr = (struct ipa_nat_indx_tbl_rule *)ipv4_cache->index_table_addr;
- /* Update the next field of previous entry on collosion */
- if (IPA_NAT_INVALID_NAT_ENTRY != prev_entry)
- {
- if (prev_entry < ipv4_cache->table_entries)
- {
+ 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;
- }
+ 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");
+ 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;
+ return;
}
int ipa_nati_post_ipv4_dma_cmd(uint8_t tbl_indx,
- uint16_t entry)
+ 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;
+ 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)
- {
+ 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 -1;
+ 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;
+ 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].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].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->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->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 = -1;
- goto fail;
- }
- IPADBG("posted IPA_IOC_NAT_DMA to kernel successfully during add operation \n");
+ 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);
+ free(cmd);
- return ret;
+ return ret;
}
int ipa_nati_del_ipv4_rule(uint32_t tbl_hdl,
- uint32_t rule_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);
+ 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);
- /* 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");
- return -1;
- }
-
- IPADBG("Delete below rule\n");
- IPADBG("tbl_entry:%d expn_tbl:%d \n",tbl_entry, expn_tbl);
+ /* 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");
+ return -EINVAL;
+ }
- tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
- if (!tbl_ptr->valid)
- {
- IPAERR("invalid table handle\n");
- return -1;
- }
+ IPADBG("Delete below rule\n");
+ IPADBG("tbl_entry:%d expn_tbl:%d \n", tbl_entry, expn_tbl);
- ipa_nati_find_rule_pos(tbl_ptr, expn_tbl,
- tbl_entry, &rule_pos);
- IPADBG("rule_pos:%d\n", rule_pos);
+ tbl_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
+ if (!tbl_ptr->valid) {
+ IPAERR("invalid table handle\n");
+ return -EINVAL;
+ }
- if(0 != ipa_nati_post_del_dma_cmd(tbl_indx, tbl_entry,
- expn_tbl, rule_pos))
- {
- return -1;
- }
+ ipa_nati_find_rule_pos(tbl_ptr, expn_tbl,
+ tbl_entry, &rule_pos);
+ IPADBG("rule_pos:%d\n", rule_pos);
- ipa_nati_del_dead_ipv4_head_nodes(tbl_indx);
+ if (ipa_nati_post_del_dma_cmd(tbl_indx, tbl_entry,
+ expn_tbl, rule_pos)) {
+ return -EINVAL;
+ }
- /* Reset rule_id_array entry */
- ipv4_nat_cache.ip4_tbl[tbl_indx].rule_id_array[rule_hdl-1] =
- IPA_NAT_INVALID_NAT_ENTRY;
+ 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);
+ IPADBG("Dumping Table after deleting rule\n");
+ ipa_nat_dump_ipv4_table(tbl_hdl);
#endif
- return 0;
+ return 0;
}
void ReorderCmds(struct ipa_ioc_nat_dma_cmd *cmd, int size)
@@ -1627,40 +1555,34 @@
struct ipa_ioc_nat_dma_cmd *tmp;
IPADBG("called ReorderCmds() with entries :%d\n", cmd->entries);
-
- for (cnt=0; cnt<cmd->entries; cnt++)
- {
+
+ 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)
- {
+ cmd->dma[cnt].base_addr == IPA_NAT_INDEX_EXPN_TBL) {
indx_tbl_start = cnt;
break;
}
}
- if (indx_tbl_start == 0)
- {
+ if (indx_tbl_start == 0) {
IPADBG("Reorder not needed\n");
return;
}
tmp = (struct ipa_ioc_nat_dma_cmd *)malloc(size);
- if (tmp == NULL)
- {
+ if (tmp == NULL) {
IPAERR("unable to allocate memory\n");
return;
}
cnt1 = 0;
tmp->entries = cmd->entries;
- for (cnt=indx_tbl_start; cnt<cmd->entries; cnt++)
- {
- tmp->dma[cnt1] = cmd->dma[cnt];
+ for (cnt = indx_tbl_start; cnt < cmd->entries; cnt++) {
+ tmp->dma[cnt1] = cmd->dma[cnt];
cnt1++;
}
- for (cnt = 0; cnt<indx_tbl_start; cnt++)
- {
+ for (cnt = 0; cnt < indx_tbl_start; cnt++) {
tmp->dma[cnt1] = cmd->dma[cnt];
cnt1++;
}
@@ -1673,9 +1595,9 @@
}
int ipa_nati_post_del_dma_cmd(uint8_t tbl_indx,
- uint16_t cur_tbl_entry,
- uint8_t expn_tbl,
- del_type rule_pos)
+ uint16_t cur_tbl_entry,
+ uint8_t expn_tbl,
+ del_type rule_pos)
{
#define MAX_DMA_ENTRIES_FOR_DEL 3
@@ -1695,32 +1617,27 @@
uint16_t 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));
+ 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)
- {
+ if (NULL == cmd) {
IPAERR("unable to allocate memory\n");
- return -1;
+ return -ENOMEM;
}
cache_ptr = &ipv4_nat_cache.ip4_tbl[tbl_indx];
- if (!expn_tbl)
- {
+ if (!expn_tbl) {
tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_rules_addr;
- }
- else
- {
+ } else {
tbl_ptr = (struct ipa_nat_rule *)cache_ptr->ipv4_expn_rules_addr;
}
if (!Read16BitFieldValue(tbl_ptr[cur_tbl_entry].ip_cksm_enbl,
- ENABLE_FIELD))
- {
+ ENABLE_FIELD)) {
IPAERR("Deleting invalid(not enabled) rule\n");
- ret = -1;
+ ret = -EINVAL;
goto fail;
}
@@ -1730,8 +1647,7 @@
Base Table rule Deletion
================================================*/
/* Just delete the current rule by disabling the flag field */
- if (IPA_NAT_DEL_TYPE_ONLY_ONE == rule_pos)
- {
+ 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;
@@ -1744,8 +1660,7 @@
}
/* Just update the protocol field to invalid */
- else if (IPA_NAT_DEL_TYPE_HEAD == rule_pos)
- {
+ 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;
@@ -1759,12 +1674,11 @@
IPADBG("writing invalid proto: 0x%x\n", cmd->dma[no_of_cmds].data);
}
- /*
- Update the previous entry of next_index field value
- with current entry next_index field value
+ /*
+ 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)
- {
+ 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);
@@ -1773,8 +1687,7 @@
NEXT_INDEX_FIELD);
cmd->dma[no_of_cmds].base_addr = IPA_NAT_BASE_TBL;
- if (prev_entry >= cache_ptr->table_entries)
- {
+ if (prev_entry >= cache_ptr->table_entries) {
cmd->dma[no_of_cmds].base_addr = IPA_NAT_EXPN_TBL;
prev_entry -= cache_ptr->table_entries;
}
@@ -1786,11 +1699,10 @@
}
- /*
- Reset the previous entry of next_index field with 0
+ /*
+ Reset the previous entry of next_index field with 0
*/
- else if (IPA_NAT_DEL_TYPE_LAST == rule_pos)
- {
+ 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);
@@ -1798,8 +1710,7 @@
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)
- {
+ if (prev_entry >= cache_ptr->table_entries) {
cmd->dma[no_of_cmds].base_addr = IPA_NAT_EXPN_TBL;
prev_entry -= cache_ptr->table_entries;
}
@@ -1822,21 +1733,17 @@
&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)
- {
+ 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
- {
+ } 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)
- {
+ 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;
@@ -1849,8 +1756,7 @@
}
/* copy the next entry values to current entry */
- else if (IPA_NAT_DEL_TYPE_HEAD == indx_rule_pos)
- {
+ 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;
@@ -1883,12 +1789,11 @@
cmd->dma[no_of_cmds].offset += IPA_NAT_INDEX_RULE_NEXT_FIELD_OFFSET;
}
- /*
- Update the previous entry of next_index field value
- with current entry next_index field value
+ /*
+ 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)
- {
+ 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++;
@@ -1897,8 +1802,7 @@
INDX_TBL_NEXT_INDEX_FILED);
cmd->dma[no_of_cmds].base_addr = IPA_NAT_INDX_TBL;
- if (prev_entry >= cache_ptr->table_entries)
- {
+ 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;
}
@@ -1910,8 +1814,7 @@
}
/* Reset the previous entry next_index field with 0 */
- else if (IPA_NAT_DEL_TYPE_LAST == indx_rule_pos)
- {
+ 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++;
@@ -1919,8 +1822,7 @@
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)
- {
+ 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;
}
@@ -1937,24 +1839,21 @@
================================================*/
cmd->entries = no_of_cmds + 1;
- if (cmd->entries > 1)
- {
+ if (cmd->entries > 1) {
ReorderCmds(cmd, size);
}
- if (ioctl(ipv4_nat_cache.ipa_fd, IPA_IOC_NAT_DMA, cmd))
- {
+ 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 = -1;
+ ret = -EIO;
goto fail;
}
/* if entry exist in IPA_NAT_DEL_TYPE_MIDDLE of list
- Update the previous entry in sw specific parameters
+ Update the previous entry in sw specific parameters
*/
- if (IPA_NAT_DEL_TYPE_MIDDLE == rule_pos)
- {
+ 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);
@@ -1973,51 +1872,42 @@
}
/* 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)
- {
+ 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 (IPA_NAT_DEL_TYPE_HEAD == indx_rule_pos)
- {
+ if (IPA_NAT_DEL_TYPE_HEAD == indx_rule_pos) {
/* Reset the next entry to IPA_NAT_DEL_TYPE_HEAD as we copied
- the next entry to IPA_NAT_DEL_TYPE_HEAD */
+ the next entry to IPA_NAT_DEL_TYPE_HEAD */
indx_tbl_ptr[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
+ /*
+ 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)
- {
+ 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
- {
+ } 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
- {
+ } else {
/* Update the prev_entry value (in index_expn_table_meta)
- for the next_entry in list with current entry prev_entry value
+ for the next_entry in list with current entry prev_entry value
*/
- if (IPA_NAT_DEL_TYPE_MIDDLE == indx_rule_pos)
- {
+ 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)
- {
+ if (next_entry >= cache_ptr->table_entries) {
next_entry -= cache_ptr->table_entries;
}
@@ -2036,379 +1926,330 @@
}
-fail:
+ fail:
free(cmd);
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)
+ struct ipa_nat_ip4_table_cache *cache_ptr,
+ uint16_t tbl_entry,
+ del_type *rule_pos)
{
+ struct ipa_nat_indx_tbl_rule *tbl_ptr;
- struct ipa_nat_indx_tbl_rule *tbl_ptr;
-
- if(tbl_entry >= cache_ptr->table_entries)
- {
- tbl_ptr =
- (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
+ if (tbl_entry >= cache_ptr->table_entries) {
+ tbl_ptr =
+ (struct ipa_nat_indx_tbl_rule *)cache_ptr->index_table_expn_addr;
- tbl_entry -= cache_ptr->table_entries;
+ 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;
-
+ 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;
+
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;
- }
- }
+ 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;
+ }
+ }
}
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)
+ uint8_t expn_tbl,
+ uint16_t tbl_entry,
+ del_type *rule_pos)
{
+ struct ipa_nat_rule *tbl_ptr;
- struct ipa_nat_rule *tbl_ptr;
-
- 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;
- }
- }
+ 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;
+ }
+ }
}
void ipa_nati_del_dead_ipv4_head_nodes(uint8_t tbl_indx)
{
- struct ipa_nat_rule *tbl_ptr;
- uint16_t cnt;
+ struct ipa_nat_rule *tbl_ptr;
+ uint16_t cnt;
- tbl_ptr =
- (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr;
+ tbl_ptr =
+ (struct ipa_nat_rule *)ipv4_nat_cache.ip4_tbl[tbl_indx].ipv4_rules_addr;
- for(cnt=0;
- cnt<ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
- cnt++)
- {
+ for (cnt = 0;
+ cnt < ipv4_nat_cache.ip4_tbl[tbl_indx].table_entries;
+ cnt++) {
- if(Read8BitFieldValue(tbl_ptr[cnt].ts_proto,
- PROTOCOL_FIELD) == IPA_NAT_INVALID_PROTO_FIELD_CMP
- &&
- 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));
- }
- } /* end of for loop */
+ if (Read8BitFieldValue(tbl_ptr[cnt].ts_proto,
+ PROTOCOL_FIELD) == IPA_NAT_INVALID_PROTO_FIELD_CMP
+ &&
+ 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));
+ }
+ } /* end of for loop */
- return;
+ return;
}
/* ========================================================
- Debug functions
- ========================================================*/
+ Debug functions
+ ========================================================*/
#ifdef NAT_DUMP
void ipa_nat_dump_ipv4_table(uint32_t tbl_hdl)
{
- struct ipa_nat_rule *tbl_ptr;
- struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
- int cnt;
- uint8_t atl_one = 0;
+ struct ipa_nat_rule *tbl_ptr;
+ struct ipa_nat_indx_tbl_rule *indx_tbl_ptr;
+ int cnt;
+ uint8_t atl_one = 0;
- if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS)
- {
- IPAERR("invalid table handle passed \n");
- return;
- }
+ if (IPA_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
+ tbl_hdl > IPA_NAT_MAX_IP4_TBLS) {
+ IPAERR("invalid table handle passed \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;
-
- /* 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))
- {
+ /* 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 + 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;
+ 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;
- /* 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))
- {
+ /* 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;
+
+ /* 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);
- }
- }
- 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;
+ }
+ }
+ 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;
- /* 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))
- {
+ /* 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));
- }
- }
- 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;
+ ipa_nati_print_index_rule(&indx_tbl_ptr[cnt],
+ (cnt + ipv4_nat_cache.ip4_tbl[tbl_hdl - 1].table_entries));
+ }
+ }
+ 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;
}
-void ipa_nati_print_rule(struct ipa_nat_rule *param, uint32_t rule_id)
+void ipa_nati_print_rule(
+ struct ipa_nat_rule *param,
+ uint32_t rule_id)
{
- struct ipa_nat_sw_rule sw_rule;
- memcpy(&sw_rule, param, sizeof(sw_rule));
- uint32_t ip_addr = 0;
+ struct ipa_nat_sw_rule sw_rule;
+ memcpy(&sw_rule, param, sizeof(sw_rule));
+ uint32_t ip_addr;
- 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),
+ 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)));
- IPADUMP("Trgt-Port:%d Priv-Port:%d ",sw_rule.target_port, sw_rule.private_port);
+ IPADUMP("Trgt-Port:%d Priv-Port:%d ", sw_rule.target_port, sw_rule.private_port);
- ip_addr = sw_rule.private_ip;
- IPADUMP("Priv-IP:%d.%d.%d.%d ",
+ 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 Tcp-udp-cksum-delta:0x%x", sw_rule.prev_index, sw_rule.tcp_udp_chksum);
- IPADUMP("\n");
- IPANAT_DUMMY_USE(rule_id);
- return;
+ 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 Tcp-udp-cksum-delta:0x%x", sw_rule.prev_index, 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)
+void ipa_nati_print_index_rule(
+ struct ipa_nat_indx_tbl_rule *param,
+ uint32_t rule_id)
{
- struct ipa_nat_sw_indx_tbl_rule sw_rule;
- memcpy(&sw_rule, param, sizeof(sw_rule));
+ 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",
- rule_id, sw_rule.tbl_entry, sw_rule.next_index);
- IPADUMP("\n");
- IPANAT_DUMMY_USE(rule_id);
- return;
+ IPADUMP("rule-id:%d Table_entry:%d Next_index:%d",
+ rule_id, sw_rule.tbl_entry, sw_rule.next_index);
+ IPADUMP("\n");
+ return;
}
-int ipa_nati_query_nat_rules(uint32_t tbl_hdl, nat_table_type tbl_type)
+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;
- 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_NAT_INVALID_NAT_ENTRY == tbl_hdl ||
- tbl_hdl > IPA_NAT_MAX_IP4_TBLS)
- {
- IPAERR("invalid table handle passed \n");
- return ret;
- }
+ /* 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");
+ }
- /* 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("Number of active base rules: %d\n", ret);
+ }
- IPADBG("Number of active base rules: %d\n", ret);
- }
+ /* 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");
+ }
- /* 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);
- }
+ IPADBG("Number of active base expansion rules: %d\n", ret);
+ }
/* 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");
- }
+ 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");
+ }
- IPADBG("Number of active index table rules: %d\n", ret);
- }
+ IPADBG("Number of active index table rules: %d\n", ret);
+ }
- /* 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");
- }
+ /* 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++;
+ }
+ }
- IPADBG("Number of active index expansion rules: %d\n", ret);
- }
+ if (!ret)
+ IPADBG("No active index expansion rules\n");
- return ret;
+ IPADBG("Number of active index expansion rules: %d\n", ret);
+ }
+
+ return ret;
}
#endif