qca-nss-clients/netlink/nss_nlgre_redir_lag.c - manifest_repos/sdk - Git at Google

 /*
  ***************************************************************************
  * Copyright (c) 2015-2016,2018-2020, The Linux Foundation. All rights reserved.
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
  * above copyright notice and this permission notice appear in all copies.
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************
  */

 #include <linux/version.h>
 #include <linux/etherdevice.h>
 #include <linux/if_ether.h>
 #include <net/genetlink.h>
 #include <nss_api_if.h>
 #include <nss_nl_if.h>
 #include "nss_nlcmn_if.h"
 #include "nss_nl.h"
 #include "nss_nlgre_redir_if.h"
 #include "nss_nlgre_redir_cmn.h"
 #include "nss_nlgre_redir_lag.h"

 /*
  * Spin_lock for lag_pvt_data
  */
 static DEFINE_SPINLOCK(lock);

 static struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 static const struct net_device_ops dummy_netdev_ops;

 /*
  * nss_nlgre_redir_lag_msg_completion_cb()
  * 	HLOS->NSS message completion callback.
  */
 static void nss_nlgre_redir_lag_msg_completion_cb(void *app_data, struct nss_cmn_msg *cmnmsg)
 {
 	struct nss_ctx_instance *nss_ctx = nss_gre_redir_get_context();
 	nss_nl_info("%px: callback gre_redir tunnel msg from NSS\n", nss_ctx);
 }

 /*
  * nss_nlgre_redir_lag_us_data_cb()
  *	Exception handler for LAG_US node.
  */
 static void nss_nlgre_redir_lag_us_data_cb(struct net_device *netdev, struct sk_buff *skb, struct napi_struct *napi)
 {
 	nss_nl_trace("Exception packet on lag_us node:\n");
 	nss_nlgre_redir_cmn_print_hex_dump(skb);
 	dev_kfree_skb_any(skb);
 }

 /*
  * nss_nlgre_redir_lag_ds_data_cb()
  *	Exception handler for LAG_DS node.
  */
 static void nss_nlgre_redir_lag_ds_data_cb(struct net_device *netdev, struct sk_buff *skb, struct napi_struct *napi)
 {
 	nss_nl_trace("Exception packet on lag_ds node:\n");
 	nss_nlgre_redir_cmn_print_hex_dump(skb);
 	dev_kfree_skb_any(skb);
 }

 /*
  * nss_nlgre_redir_lag_us_msg_cb()
  *	GRE LAG upstream  NSS->HLOS message callback.
  */
 static void nss_nlgre_redir_lag_us_msg_cb(void *app_data, struct nss_cmn_msg *cmnmsg)
 {
 	struct nss_gre_redir_lag_us_msg *tunmsg = (struct nss_gre_redir_lag_us_msg *)cmnmsg;
 	int i;

 	if (tunmsg->cm.type != NSS_GRE_REDIR_LAG_US_DB_HASH_NODE_MSG) {
 		return;
 	}

 	nss_nl_trace("%px: callback_stats: count = %u index = %u\n", tunmsg,
 			tunmsg->msg.hash_stats.count, tunmsg->msg.hash_stats.db_entry_idx);
 	for (i = 0; i < tunmsg->msg.hash_stats.count; i++) {
 		nss_nl_trace("%px: hits = %llu smac = %pM dmac = %pM\n", tunmsg,
 				tunmsg->msg.hash_stats.hstats[i].hits,
 				&(tunmsg->msg.hash_stats.hstats[i].src_mac),
 				&(tunmsg->msg.hash_stats.hstats[i].dest_mac));
 	}
 }

 /*
  * nss_nlgre_redir_lag_ds_msg_cb()
  *	GRE LAG upstream  NSS->HLOS message callback.
  */
 static void nss_nlgre_redir_lag_ds_msg_cb(void *app_data, struct nss_cmn_msg *cmnmsg)
 {
 	struct nss_gre_redir_lag_ds_msg *tunmsg = (struct nss_gre_redir_lag_ds_msg *)cmnmsg;

 	if (tunmsg->cm.type != NSS_GRE_REDIR_LAG_DS_STATS_SYNC_MSG) {
 		return;
 	}

 	nss_nl_trace("%px: callback_stats: invalid_dest: %u, exception_cnt: %u\n", tunmsg,
 			tunmsg->msg.ds_sync_stats.ds_stats.dst_invalid,
 			tunmsg->msg.ds_sync_stats.ds_stats.exception_cnt);

 }

 /*
  * nss_nlgre_redir_lag_get_lag_pvt_data()
  * 	Return lag_pvt_data after lock checking
  */
 static struct nss_nlgre_redir_lag_pvt_data nss_nlgre_redir_lag_get_lag_pvt_data(void)
 {
 	struct nss_nlgre_redir_lag_pvt_data ret_lag_pvt_data;

 	spin_lock(&lock);
 	ret_lag_pvt_data = lag_pvt_data;
 	spin_unlock(&lock);
 	return ret_lag_pvt_data;
 }

 /*
  * nss_nlgre_redir_lag_set_lag_pvt_data()
  * 	Return lag_pvt_data after lock checking
  */
 static void nss_nlgre_redir_lag_set_lag_pvt_data(struct nss_nlgre_redir_lag_pvt_data *data)
 {
 	spin_lock(&lock);
 	lag_pvt_data = *data;
 	spin_unlock(&lock);
 }

 /*
  * nss_nlgre_redir_lag_destroy_tun()
  *	Destroy tunnel in LAG mode.
  */
 int nss_nlgre_redir_lag_destroy_tun(struct net_device *dev)
 {
 	struct nss_ctx_instance *nss_ctx = nss_gre_redir_get_context();
 	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 	uint8_t tun_idx;
 	int ret;

 	if (!dev) {
 		nss_nl_error("%px: Dev is null\n", nss_ctx);
 		return -1;
 	}

 	dev_hold(dev);

 	/*
 	 * Unregister and deallocate the lag US and DS interfaces
 	 */
 	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
 	ret = nss_gre_redir_lag_us_unregister_and_dealloc(lag_pvt_data.inner_ifnum);
 	if (ret) {
 		nss_nl_error("%px: Unable to deallocate node %d\n", dev, lag_pvt_data.inner_ifnum);
 	}

 	ret = nss_gre_redir_lag_ds_unregister_and_dealloc(lag_pvt_data.outer_ifnum);
 	if (ret) {
 		nss_nl_error("%px: Unable to deallocate node %d\n", dev, lag_pvt_data.outer_ifnum);
 	}

 	for (tun_idx = 0; tun_idx < NSS_NLGRE_REDIR_LAG_SLAVES; tun_idx++) {
 		if (!lag_pvt_data.slaves[tun_idx]) {
 			nss_nl_error("%px: Slave tunnel index out of range\n", nss_ctx);
 			ret = -1;
 			goto done;
 		}

 		ret = nss_nlgre_redir_cmn_destroy_tun(lag_pvt_data.slaves[tun_idx]);
 		if (ret == -1) {
 			nss_nl_error("%px: Unable to destroy tunnel associated with slave %d\n", nss_ctx, tun_idx+1);
 			goto done;
 		}

 		nss_nl_info("%px: Successfully destroyed slave tunnel %d\n", nss_ctx, tun_idx+1);
 	}

 done:
 	/*
 	 * Free the lag dummy dev resources
 	 */
 	dev_put(dev);
 	unregister_netdev(dev);
 	free_netdev(dev);
 	lag_pvt_data.dev = NULL;
 	return ret;
 }

 /*
  * nss_nlgre_redir_lag_create_tun()
  * 	Cretate GRE redir tunnel in LAG mode.
  */
 int nss_nlgre_redir_lag_create_tun(struct nss_nlgre_redir_create_tun *create_params)
 {
 	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 	struct nss_gre_redir_lag_us_config_msg config;
 	struct nss_gre_redir_cmn_ndev_priv *gr;
 	struct nss_ctx_instance *nss_ctx;
 	struct net_device *dummy_dev;
 	bool status;
 	int iter;

 	nss_ctx = nss_gre_redir_get_context();
 	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
 	lag_pvt_data.slaves[0] = nss_nlgre_redir_cmn_create_tun(create_params->sip, create_params->dip, create_params->iptype);
 	if (!lag_pvt_data.slaves[0]) {
 		nss_nl_error("%px: Unable to create tunnel for %dst slave\n", nss_ctx, 1);
 		goto fail0;
 	}

 	lag_pvt_data.slaves[1] = nss_nlgre_redir_cmn_create_tun(create_params->ssip, create_params->sdip, create_params->iptype);
 	if (!lag_pvt_data.slaves[1]) {
 		nss_nl_error("%px: Unable to create tunnel for %dnd slave\n", nss_ctx, 2);
 		goto fail0;
 	}

 	dummy_dev = alloc_netdev(sizeof(*gr), "grelag%d", NET_NAME_UNKNOWN, ether_setup);
 	if (!dummy_dev) {
 		nss_nl_error("%px: Unable to allocate net_dev for dummy_dev\n", nss_ctx);
 		goto fail0;
 	}

 	dummy_dev->needed_headroom = NSS_NLGRE_REDIR_CMN_NEEDED_HEADROOM;
 	dummy_dev->netdev_ops = &dummy_netdev_ops;
 	lag_pvt_data.inner_ifnum = nss_gre_redir_lag_us_alloc_and_register_node(dummy_dev,
 			nss_nlgre_redir_lag_us_data_cb, nss_nlgre_redir_lag_us_msg_cb, dummy_dev);

 	if (lag_pvt_data.inner_ifnum == -1) {
 		nss_nl_error("%px: Unable to allocate or register LAG US dynamic node.\n", nss_ctx);
 		goto fail1;
 	}

 	nss_nl_info("%px: LAG US interface number = %d\n", nss_ctx, lag_pvt_data.inner_ifnum);
 	lag_pvt_data.outer_ifnum = nss_gre_redir_lag_ds_alloc_and_register_node(dummy_dev,
 			nss_nlgre_redir_lag_ds_data_cb, nss_nlgre_redir_lag_ds_msg_cb, dummy_dev);

 	if (lag_pvt_data.outer_ifnum == -1) {
 		nss_nl_error("%px: Unable to allocate or register LAG DS dynamic node.\n", nss_ctx);
 		goto fail2;
 	}

 	nss_nl_info("%px: LAG DS interface number = %d\n", nss_ctx, lag_pvt_data.outer_ifnum);

 	config.hash_mode = create_params->hash_mode;
 	config.num_slaves = NSS_NLGRE_REDIR_LAG_SLAVES;

 	for (iter = 0; iter < NSS_NLGRE_REDIR_LAG_SLAVES; iter++) {
 		config.if_num[iter] = nss_nlgre_redir_cmn_get_tun_ifnum(NSS_NLGRE_REDIR_CMN_MODE_TYPE_WIFI, lag_pvt_data.slaves[iter]);
 	}

 	status = nss_gre_redir_lag_us_configure_node(lag_pvt_data.inner_ifnum, &config);
 	if (!status) {
 		nss_nl_info("%px: Unable to configure LAG US node.\n", nss_ctx);
 		goto fail3;
 	}

 	if (register_netdev(dummy_dev)) {
 		nss_nl_error("%px: Unable to register dummy_dev\n", nss_ctx);
 		goto fail3;
 	}

 	lag_pvt_data.dev = dummy_dev;
 	nss_nlgre_redir_lag_set_lag_pvt_data(&lag_pvt_data);
 	return 0;

 fail3:
 	nss_nlgre_redir_cmn_unregister_and_deallocate(dummy_dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_REDIR_LAG_DS);
 fail2:
 	nss_nlgre_redir_cmn_unregister_and_deallocate(dummy_dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_REDIR_LAG_US);
 fail1:
 	free_netdev(dummy_dev);
 fail0:
 	for (iter = 0; iter < NSS_NLGRE_REDIR_LAG_SLAVES; iter++) {
 		if (!lag_pvt_data.slaves[iter]) {
 			nss_nlgre_redir_cmn_destroy_tun(lag_pvt_data.slaves[iter]);
 			continue;
 		}

 		break;
 	}

 	return -1;
 }

 /*
  * nss_nlgre_redir_lag_map_interface()
  * 	Maps the nss interface to tunnel ID
  */
 int nss_nlgre_redir_lag_map_interface(struct nss_nlgre_redir_map *map_params)
 {
 	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 	struct nss_ctx_instance *nss_ctx;
 	uint32_t nexthop_nssif;
 	int ret;

 	nss_ctx = nss_gre_redir_get_context();
 	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
 	nexthop_nssif = lag_pvt_data.outer_ifnum;
 	ret = nss_nlgre_redir_cmn_map_interface(nexthop_nssif, 1, map_params);
 	if (ret == -1) {
 		nss_nl_error("%px: Unable to map nss interface\n", nss_ctx);
 		return -1;
 	}

 	nss_nl_info("Successfully mapped the nss interface to tunnel ID\n");
 	return 0;
 }

 /*
  * nss_nlgre_redir_lag_set_next_hop()
  * 	Sets the next hop of ath0 interface as lag US node's interface
  */
 int nss_nlgre_redir_lag_set_next_hop(struct nss_nlgre_redir_set_next *set_next_params)
 {
 	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 	struct nss_ctx_instance *nss_ctx;
 	uint32_t nexthop_ifnum;
 	int ret;

 	nss_ctx = nss_gre_redir_get_context();
 	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
 	nexthop_ifnum = lag_pvt_data.inner_ifnum;
 	ret = nss_nlgre_redir_cmn_set_next_hop(nexthop_ifnum, set_next_params);
 	if (ret == -1) {
 		nss_nl_error("%px: Unable to set the next hop as lag US node's interface\n", nss_ctx);
 		return -1;
 	}

 	nss_nl_info("Successfully set the next hop as lag US node's interface\n");
 	return 0;
 }

 /*
  * nss_nlgre_redir_lag_add_hash()
  *	Add hash entry.
  */
 int nss_nlgre_redir_lag_add_hash(struct nss_nlgre_redir_hash_ops *hash_ops)
 {
 	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 	struct nss_gre_redir_lag_us_msg *nglm;
 	struct nss_ctx_instance *nss_ctx;
 	nss_tx_status_t status;
 	uint32_t len;
 	int i;

 	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
 	nss_ctx = nss_gre_redir_lag_us_get_context();
 	if (!nss_ctx) {
 		nss_nl_error("Unable to get nss context\n");
 		return -1;
 	}

 	nglm = kmalloc(sizeof(struct nss_gre_redir_lag_us_msg), GFP_KERNEL);
 	if (!nglm) {
 		nss_nl_error("%px: Unable to allocate memory to send add hash msg.\n", nss_ctx);
 		return -1;
 	}

 	len = sizeof(struct nss_gre_redir_lag_us_msg) - sizeof(struct nss_cmn_msg);
 	nss_cmn_msg_init(&nglm->cm, lag_pvt_data.inner_ifnum, NSS_GRE_REDIR_LAG_US_ADD_HASH_NODE_MSG, len,
 			nss_nlgre_redir_lag_msg_completion_cb, NULL);
 	memcpy((void *)(nglm->msg.add_hash.src_mac), (void *)hash_ops->smac, sizeof(nglm->msg.add_hash.src_mac));
 	memcpy((void *)(nglm->msg.add_hash.dest_mac), (void *)hash_ops->dmac, sizeof(nglm->msg.add_hash.dest_mac));
 	for (i = 0; i < NSS_NLGRE_REDIR_LAG_SLAVES; i++) {
 		if (hash_ops->slave != i) {
 			continue;
 		}

 		nglm->msg.add_hash.if_num = nss_nlgre_redir_cmn_get_tun_ifnum(NSS_NLGRE_REDIR_CMN_MODE_TYPE_WIFI,
 				lag_pvt_data.slaves[i]);
 		break;
 	}

 	if (i == NSS_NLGRE_REDIR_LAG_SLAVES || nglm->msg.add_hash.if_num == -1) {
 		nss_nl_error("%px: Invalid value for index, valid slaves: [%s, %s]\n", nss_ctx,
 				lag_pvt_data.slaves[0]->name, lag_pvt_data.slaves[1]->name);
 		return -1;
 	}

 	nss_nl_info("smac = %pM dmac = %pM ifnum = %d\n", &(nglm->msg.add_hash.src_mac),
 			&(nglm->msg.add_hash.dest_mac), nglm->msg.add_hash.if_num);
 	status = nss_gre_redir_lag_us_tx_msg_sync(nss_ctx, nglm);
 	kfree(nglm);
 	if (status != NSS_TX_SUCCESS) {
 		nss_nl_error("%px: Unable to add hash entry.\n", nss_ctx);
 		return -1;
 	}

 	return 0;
 }

 /*
  * nss_nlgre_redir_lag_del_hash()
  *	Delete hash entry.
  */
 int nss_nlgre_redir_lag_del_hash(struct nss_nlgre_redir_hash_ops *hash_ops)
 {
 	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
 	struct nss_gre_redir_lag_us_msg *nglm;
 	struct nss_ctx_instance *nss_ctx;
 	nss_tx_status_t status;
 	uint32_t len;

 	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
 	nss_ctx = nss_gre_redir_lag_us_get_context();
 	if (!nss_ctx) {
 		nss_nl_error("Unable to get nss context\n");
 		return -1;
 	}

 	nglm = kmalloc(sizeof(struct nss_gre_redir_lag_us_msg), GFP_KERNEL);
 	if (!nglm) {
 		nss_nl_error("%px: Unable to allocate memory to send del hash msg.\n", nss_ctx);
 		return -1;
 	}

 	len = sizeof(struct nss_gre_redir_lag_us_msg) - sizeof(struct nss_cmn_msg);
 	nss_cmn_msg_init(&nglm->cm, lag_pvt_data.inner_ifnum, NSS_GRE_REDIR_LAG_US_DEL_HASH_NODE_MSG, len,
 			nss_nlgre_redir_lag_msg_completion_cb, NULL);
 	memcpy((void *)(nglm->msg.del_hash.src_mac), (void *)hash_ops->smac, sizeof(nglm->msg.del_hash.src_mac));
 	memcpy((void *)(nglm->msg.del_hash.dest_mac), (void *)hash_ops->dmac, sizeof(nglm->msg.del_hash.dest_mac));
 	nss_nl_info("smac = %pM dmac = %pM\n", &(nglm->msg.del_hash.src_mac), &(nglm->msg.del_hash.dest_mac));
 	status = nss_gre_redir_lag_us_tx_msg_sync(nss_ctx, nglm);
 	kfree(nglm);
 	if (status != NSS_TX_SUCCESS) {
 		nss_nl_error("%px: Unable to delete hash entry.\n", nss_ctx);
 		return -1;
 	}

 	return 0;
 }
	/*
	***************************************************************************
	* Copyright (c) 2015-2016,2018-2020, The Linux Foundation. All rights reserved.
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all copies.
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	***************************************************************************
	*/

	#include <linux/version.h>
	#include <linux/etherdevice.h>
	#include <linux/if_ether.h>
	#include <net/genetlink.h>
	#include <nss_api_if.h>
	#include <nss_nl_if.h>
	#include "nss_nlcmn_if.h"
	#include "nss_nl.h"
	#include "nss_nlgre_redir_if.h"
	#include "nss_nlgre_redir_cmn.h"
	#include "nss_nlgre_redir_lag.h"

	/*
	* Spin_lock for lag_pvt_data
	*/
	static DEFINE_SPINLOCK(lock);

	static struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	static const struct net_device_ops dummy_netdev_ops;

	/*
	* nss_nlgre_redir_lag_msg_completion_cb()
	* HLOS->NSS message completion callback.
	*/
	static void nss_nlgre_redir_lag_msg_completion_cb(void app_data, struct nss_cmn_msg cmnmsg)
	{
	struct nss_ctx_instance *nss_ctx = nss_gre_redir_get_context();
	nss_nl_info("%px: callback gre_redir tunnel msg from NSS\n", nss_ctx);
	}

	/*
	* nss_nlgre_redir_lag_us_data_cb()
	* Exception handler for LAG_US node.
	*/
	static void nss_nlgre_redir_lag_us_data_cb(struct net_device netdev, struct sk_buff skb, struct napi_struct *napi)
	{
	nss_nl_trace("Exception packet on lag_us node:\n");
	nss_nlgre_redir_cmn_print_hex_dump(skb);
	dev_kfree_skb_any(skb);
	}

	/*
	* nss_nlgre_redir_lag_ds_data_cb()
	* Exception handler for LAG_DS node.
	*/
	static void nss_nlgre_redir_lag_ds_data_cb(struct net_device netdev, struct sk_buff skb, struct napi_struct *napi)
	{
	nss_nl_trace("Exception packet on lag_ds node:\n");
	nss_nlgre_redir_cmn_print_hex_dump(skb);
	dev_kfree_skb_any(skb);
	}

	/*
	* nss_nlgre_redir_lag_us_msg_cb()
	* GRE LAG upstream NSS->HLOS message callback.
	*/
	static void nss_nlgre_redir_lag_us_msg_cb(void app_data, struct nss_cmn_msg cmnmsg)
	{
	struct nss_gre_redir_lag_us_msg tunmsg = (struct nss_gre_redir_lag_us_msg )cmnmsg;
	int i;

	if (tunmsg->cm.type != NSS_GRE_REDIR_LAG_US_DB_HASH_NODE_MSG) {
	return;
	}

	nss_nl_trace("%px: callback_stats: count = %u index = %u\n", tunmsg,
	tunmsg->msg.hash_stats.count, tunmsg->msg.hash_stats.db_entry_idx);
	for (i = 0; i < tunmsg->msg.hash_stats.count; i++) {
	nss_nl_trace("%px: hits = %llu smac = %pM dmac = %pM\n", tunmsg,
	tunmsg->msg.hash_stats.hstats[i].hits,
	&(tunmsg->msg.hash_stats.hstats[i].src_mac),
	&(tunmsg->msg.hash_stats.hstats[i].dest_mac));
	}
	}

	/*
	* nss_nlgre_redir_lag_ds_msg_cb()
	* GRE LAG upstream NSS->HLOS message callback.
	*/
	static void nss_nlgre_redir_lag_ds_msg_cb(void app_data, struct nss_cmn_msg cmnmsg)
	{
	struct nss_gre_redir_lag_ds_msg tunmsg = (struct nss_gre_redir_lag_ds_msg )cmnmsg;

	if (tunmsg->cm.type != NSS_GRE_REDIR_LAG_DS_STATS_SYNC_MSG) {
	return;
	}

	nss_nl_trace("%px: callback_stats: invalid_dest: %u, exception_cnt: %u\n", tunmsg,
	tunmsg->msg.ds_sync_stats.ds_stats.dst_invalid,
	tunmsg->msg.ds_sync_stats.ds_stats.exception_cnt);

	}

	/*
	* nss_nlgre_redir_lag_get_lag_pvt_data()
	* Return lag_pvt_data after lock checking
	*/
	static struct nss_nlgre_redir_lag_pvt_data nss_nlgre_redir_lag_get_lag_pvt_data(void)
	{
	struct nss_nlgre_redir_lag_pvt_data ret_lag_pvt_data;

	spin_lock(&lock);
	ret_lag_pvt_data = lag_pvt_data;
	spin_unlock(&lock);
	return ret_lag_pvt_data;
	}

	/*
	* nss_nlgre_redir_lag_set_lag_pvt_data()
	* Return lag_pvt_data after lock checking
	*/
	static void nss_nlgre_redir_lag_set_lag_pvt_data(struct nss_nlgre_redir_lag_pvt_data *data)
	{
	spin_lock(&lock);
	lag_pvt_data = *data;
	spin_unlock(&lock);
	}

	/*
	* nss_nlgre_redir_lag_destroy_tun()
	* Destroy tunnel in LAG mode.
	*/
	int nss_nlgre_redir_lag_destroy_tun(struct net_device *dev)
	{
	struct nss_ctx_instance *nss_ctx = nss_gre_redir_get_context();
	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	uint8_t tun_idx;
	int ret;

	if (!dev) {
	nss_nl_error("%px: Dev is null\n", nss_ctx);
	return -1;
	}

	dev_hold(dev);

	/*
	* Unregister and deallocate the lag US and DS interfaces
	*/
	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
	ret = nss_gre_redir_lag_us_unregister_and_dealloc(lag_pvt_data.inner_ifnum);
	if (ret) {
	nss_nl_error("%px: Unable to deallocate node %d\n", dev, lag_pvt_data.inner_ifnum);
	}

	ret = nss_gre_redir_lag_ds_unregister_and_dealloc(lag_pvt_data.outer_ifnum);
	if (ret) {
	nss_nl_error("%px: Unable to deallocate node %d\n", dev, lag_pvt_data.outer_ifnum);
	}

	for (tun_idx = 0; tun_idx < NSS_NLGRE_REDIR_LAG_SLAVES; tun_idx++) {
	if (!lag_pvt_data.slaves[tun_idx]) {
	nss_nl_error("%px: Slave tunnel index out of range\n", nss_ctx);
	ret = -1;
	goto done;
	}

	ret = nss_nlgre_redir_cmn_destroy_tun(lag_pvt_data.slaves[tun_idx]);
	if (ret == -1) {
	nss_nl_error("%px: Unable to destroy tunnel associated with slave %d\n", nss_ctx, tun_idx+1);
	goto done;
	}

	nss_nl_info("%px: Successfully destroyed slave tunnel %d\n", nss_ctx, tun_idx+1);
	}

	done:
	/*
	* Free the lag dummy dev resources
	*/
	dev_put(dev);
	unregister_netdev(dev);
	free_netdev(dev);
	lag_pvt_data.dev = NULL;
	return ret;
	}

	/*
	* nss_nlgre_redir_lag_create_tun()
	* Cretate GRE redir tunnel in LAG mode.
	*/
	int nss_nlgre_redir_lag_create_tun(struct nss_nlgre_redir_create_tun *create_params)
	{
	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	struct nss_gre_redir_lag_us_config_msg config;
	struct nss_gre_redir_cmn_ndev_priv *gr;
	struct nss_ctx_instance *nss_ctx;
	struct net_device *dummy_dev;
	bool status;
	int iter;

	nss_ctx = nss_gre_redir_get_context();
	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
	lag_pvt_data.slaves[0] = nss_nlgre_redir_cmn_create_tun(create_params->sip, create_params->dip, create_params->iptype);
	if (!lag_pvt_data.slaves[0]) {
	nss_nl_error("%px: Unable to create tunnel for %dst slave\n", nss_ctx, 1);
	goto fail0;
	}

	lag_pvt_data.slaves[1] = nss_nlgre_redir_cmn_create_tun(create_params->ssip, create_params->sdip, create_params->iptype);
	if (!lag_pvt_data.slaves[1]) {
	nss_nl_error("%px: Unable to create tunnel for %dnd slave\n", nss_ctx, 2);
	goto fail0;
	}

	dummy_dev = alloc_netdev(sizeof(*gr), "grelag%d", NET_NAME_UNKNOWN, ether_setup);
	if (!dummy_dev) {
	nss_nl_error("%px: Unable to allocate net_dev for dummy_dev\n", nss_ctx);
	goto fail0;
	}

	dummy_dev->needed_headroom = NSS_NLGRE_REDIR_CMN_NEEDED_HEADROOM;
	dummy_dev->netdev_ops = &dummy_netdev_ops;
	lag_pvt_data.inner_ifnum = nss_gre_redir_lag_us_alloc_and_register_node(dummy_dev,
	nss_nlgre_redir_lag_us_data_cb, nss_nlgre_redir_lag_us_msg_cb, dummy_dev);

	if (lag_pvt_data.inner_ifnum == -1) {
	nss_nl_error("%px: Unable to allocate or register LAG US dynamic node.\n", nss_ctx);
	goto fail1;
	}

	nss_nl_info("%px: LAG US interface number = %d\n", nss_ctx, lag_pvt_data.inner_ifnum);
	lag_pvt_data.outer_ifnum = nss_gre_redir_lag_ds_alloc_and_register_node(dummy_dev,
	nss_nlgre_redir_lag_ds_data_cb, nss_nlgre_redir_lag_ds_msg_cb, dummy_dev);

	if (lag_pvt_data.outer_ifnum == -1) {
	nss_nl_error("%px: Unable to allocate or register LAG DS dynamic node.\n", nss_ctx);
	goto fail2;
	}

	nss_nl_info("%px: LAG DS interface number = %d\n", nss_ctx, lag_pvt_data.outer_ifnum);

	config.hash_mode = create_params->hash_mode;
	config.num_slaves = NSS_NLGRE_REDIR_LAG_SLAVES;

	for (iter = 0; iter < NSS_NLGRE_REDIR_LAG_SLAVES; iter++) {
	config.if_num[iter] = nss_nlgre_redir_cmn_get_tun_ifnum(NSS_NLGRE_REDIR_CMN_MODE_TYPE_WIFI, lag_pvt_data.slaves[iter]);
	}

	status = nss_gre_redir_lag_us_configure_node(lag_pvt_data.inner_ifnum, &config);
	if (!status) {
	nss_nl_info("%px: Unable to configure LAG US node.\n", nss_ctx);
	goto fail3;
	}

	if (register_netdev(dummy_dev)) {
	nss_nl_error("%px: Unable to register dummy_dev\n", nss_ctx);
	goto fail3;
	}

	lag_pvt_data.dev = dummy_dev;
	nss_nlgre_redir_lag_set_lag_pvt_data(&lag_pvt_data);
	return 0;

	fail3:
	nss_nlgre_redir_cmn_unregister_and_deallocate(dummy_dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_REDIR_LAG_DS);
	fail2:
	nss_nlgre_redir_cmn_unregister_and_deallocate(dummy_dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_REDIR_LAG_US);
	fail1:
	free_netdev(dummy_dev);
	fail0:
	for (iter = 0; iter < NSS_NLGRE_REDIR_LAG_SLAVES; iter++) {
	if (!lag_pvt_data.slaves[iter]) {
	nss_nlgre_redir_cmn_destroy_tun(lag_pvt_data.slaves[iter]);
	continue;
	}

	break;
	}

	return -1;
	}

	/*
	* nss_nlgre_redir_lag_map_interface()
	* Maps the nss interface to tunnel ID
	*/
	int nss_nlgre_redir_lag_map_interface(struct nss_nlgre_redir_map *map_params)
	{
	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	struct nss_ctx_instance *nss_ctx;
	uint32_t nexthop_nssif;
	int ret;

	nss_ctx = nss_gre_redir_get_context();
	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
	nexthop_nssif = lag_pvt_data.outer_ifnum;
	ret = nss_nlgre_redir_cmn_map_interface(nexthop_nssif, 1, map_params);
	if (ret == -1) {
	nss_nl_error("%px: Unable to map nss interface\n", nss_ctx);
	return -1;
	}

	nss_nl_info("Successfully mapped the nss interface to tunnel ID\n");
	return 0;
	}

	/*
	* nss_nlgre_redir_lag_set_next_hop()
	* Sets the next hop of ath0 interface as lag US node's interface
	*/
	int nss_nlgre_redir_lag_set_next_hop(struct nss_nlgre_redir_set_next *set_next_params)
	{
	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	struct nss_ctx_instance *nss_ctx;
	uint32_t nexthop_ifnum;
	int ret;

	nss_ctx = nss_gre_redir_get_context();
	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
	nexthop_ifnum = lag_pvt_data.inner_ifnum;
	ret = nss_nlgre_redir_cmn_set_next_hop(nexthop_ifnum, set_next_params);
	if (ret == -1) {
	nss_nl_error("%px: Unable to set the next hop as lag US node's interface\n", nss_ctx);
	return -1;
	}

	nss_nl_info("Successfully set the next hop as lag US node's interface\n");
	return 0;
	}

	/*
	* nss_nlgre_redir_lag_add_hash()
	* Add hash entry.
	*/
	int nss_nlgre_redir_lag_add_hash(struct nss_nlgre_redir_hash_ops *hash_ops)
	{
	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	struct nss_gre_redir_lag_us_msg *nglm;
	struct nss_ctx_instance *nss_ctx;
	nss_tx_status_t status;
	uint32_t len;
	int i;

	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
	nss_ctx = nss_gre_redir_lag_us_get_context();
	if (!nss_ctx) {
	nss_nl_error("Unable to get nss context\n");
	return -1;
	}

	nglm = kmalloc(sizeof(struct nss_gre_redir_lag_us_msg), GFP_KERNEL);
	if (!nglm) {
	nss_nl_error("%px: Unable to allocate memory to send add hash msg.\n", nss_ctx);
	return -1;
	}

	len = sizeof(struct nss_gre_redir_lag_us_msg) - sizeof(struct nss_cmn_msg);
	nss_cmn_msg_init(&nglm->cm, lag_pvt_data.inner_ifnum, NSS_GRE_REDIR_LAG_US_ADD_HASH_NODE_MSG, len,
	nss_nlgre_redir_lag_msg_completion_cb, NULL);
	memcpy((void )(nglm->msg.add_hash.src_mac), (void )hash_ops->smac, sizeof(nglm->msg.add_hash.src_mac));
	memcpy((void )(nglm->msg.add_hash.dest_mac), (void )hash_ops->dmac, sizeof(nglm->msg.add_hash.dest_mac));
	for (i = 0; i < NSS_NLGRE_REDIR_LAG_SLAVES; i++) {
	if (hash_ops->slave != i) {
	continue;
	}

	nglm->msg.add_hash.if_num = nss_nlgre_redir_cmn_get_tun_ifnum(NSS_NLGRE_REDIR_CMN_MODE_TYPE_WIFI,
	lag_pvt_data.slaves[i]);
	break;
	}

	if (i == NSS_NLGRE_REDIR_LAG_SLAVES \|\| nglm->msg.add_hash.if_num == -1) {
	nss_nl_error("%px: Invalid value for index, valid slaves: [%s, %s]\n", nss_ctx,
	lag_pvt_data.slaves[0]->name, lag_pvt_data.slaves[1]->name);
	return -1;
	}

	nss_nl_info("smac = %pM dmac = %pM ifnum = %d\n", &(nglm->msg.add_hash.src_mac),
	&(nglm->msg.add_hash.dest_mac), nglm->msg.add_hash.if_num);
	status = nss_gre_redir_lag_us_tx_msg_sync(nss_ctx, nglm);
	kfree(nglm);
	if (status != NSS_TX_SUCCESS) {
	nss_nl_error("%px: Unable to add hash entry.\n", nss_ctx);
	return -1;
	}

	return 0;
	}

	/*
	* nss_nlgre_redir_lag_del_hash()
	* Delete hash entry.
	*/
	int nss_nlgre_redir_lag_del_hash(struct nss_nlgre_redir_hash_ops *hash_ops)
	{
	struct nss_nlgre_redir_lag_pvt_data lag_pvt_data;
	struct nss_gre_redir_lag_us_msg *nglm;
	struct nss_ctx_instance *nss_ctx;
	nss_tx_status_t status;
	uint32_t len;

	lag_pvt_data = nss_nlgre_redir_lag_get_lag_pvt_data();
	nss_ctx = nss_gre_redir_lag_us_get_context();
	if (!nss_ctx) {
	nss_nl_error("Unable to get nss context\n");
	return -1;
	}

	nglm = kmalloc(sizeof(struct nss_gre_redir_lag_us_msg), GFP_KERNEL);
	if (!nglm) {
	nss_nl_error("%px: Unable to allocate memory to send del hash msg.\n", nss_ctx);
	return -1;
	}

	len = sizeof(struct nss_gre_redir_lag_us_msg) - sizeof(struct nss_cmn_msg);
	nss_cmn_msg_init(&nglm->cm, lag_pvt_data.inner_ifnum, NSS_GRE_REDIR_LAG_US_DEL_HASH_NODE_MSG, len,
	nss_nlgre_redir_lag_msg_completion_cb, NULL);
	memcpy((void )(nglm->msg.del_hash.src_mac), (void )hash_ops->smac, sizeof(nglm->msg.del_hash.src_mac));
	memcpy((void )(nglm->msg.del_hash.dest_mac), (void )hash_ops->dmac, sizeof(nglm->msg.del_hash.dest_mac));
	nss_nl_info("smac = %pM dmac = %pM\n", &(nglm->msg.del_hash.src_mac), &(nglm->msg.del_hash.dest_mac));
	status = nss_gre_redir_lag_us_tx_msg_sync(nss_ctx, nglm);
	kfree(nglm);
	if (status != NSS_TX_SUCCESS) {
	nss_nl_error("%px: Unable to delete hash entry.\n", nss_ctx);
	return -1;
	}

	return 0;
	}