/*
 **************************************************************************
 * Copyright (c) 2019-2021, 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.
 **************************************************************************
 */

/*
 * OVS Classifier.
 * This classifier is called for the connections which are created
 * on OVS interfaces. The connections can be routed or bridged connections.
 * The classifier processes these connection flows and decides if the connection
 * is ready to be accelerated. Moreover, it has an interface to an external classifier
 * to make smart decisions on the flows, such as extracting the VLAN information from the
 * OVS flow tables and gives it to the ECM front end to be passed to the acceleration engine.
 */
#include <linux/version.h>
#include <linux/types.h>
#include <linux/ip.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/debugfs.h>
#include <linux/ctype.h>
#include <net/tcp.h>
#include <net/ipv6.h>
#include <linux/inet.h>
#include <linux/in.h>
#include <linux/etherdevice.h>
#include <linux/netfilter/xt_dscp.h>

/*
 * Debug output levels
 * 0 = OFF
 * 1 = ASSERTS / ERRORS
 * 2 = 1 + WARN
 * 3 = 2 + INFO
 * 4 = 3 + TRACE
 */
#define DEBUG_LEVEL ECM_CLASSIFIER_OVS_DEBUG_LEVEL

#include <ovsmgr.h>
#include "ecm_types.h"
#include "ecm_db_types.h"
#include "ecm_state.h"
#include "ecm_tracker.h"
#include "ecm_classifier.h"
#include "ecm_front_end_types.h"
#include "ecm_tracker_datagram.h"
#include "ecm_tracker_udp.h"
#include "ecm_tracker_tcp.h"
#include "ecm_db.h"
#include "ecm_classifier_ovs.h"
#include "ecm_classifier_ovs_public.h"
#include "ecm_front_end_common.h"
#include "ecm_front_end_ipv4.h"
#ifdef ECM_IPV6_ENABLE
#include "ecm_front_end_ipv6.h"
#endif
#include "ecm_interface.h"

/*
 * Magic numbers
 */
#define ECM_CLASSIFIER_OVS_INSTANCE_MAGIC 0x2568

/*
 * struct ecm_classifier_ovs_instance
 * 	State per connection for OVS classifier
 */
struct ecm_classifier_ovs_instance {
	struct ecm_classifier_instance base;			/* Base type */

	uint32_t ci_serial;					/* RO: Serial of the connection */

	struct ecm_classifier_ovs_instance *next;		/* Next classifier state instance (for accouting and reporting purposes) */
	struct ecm_classifier_ovs_instance *prev;		/* Next classifier state instance (for accouting and reporting purposes) */

	struct ecm_classifier_process_response process_response;
								/* Last process response computed */
	int refs;						/* Integer to trap we never go negative */
#if (DEBUG_LEVEL > 0)
	uint16_t magic;
#endif
};

/*
 * Operational control.
 */
static int ecm_classifier_ovs_enabled = 1;			/* Operational behaviour */

/*
 * Management thread control
 */
static bool ecm_classifier_ovs_terminate_pending;	/* True when the user wants us to terminate */

/*
 * Debugfs dentry object.
 */
static struct dentry *ecm_classifier_ovs_dentry;

/*
 * Locking of the classifier structures
 */
static DEFINE_SPINLOCK(ecm_classifier_ovs_lock);			/* Protect SMP access. */

/*
 * List of our classifier instances
 */
static struct ecm_classifier_ovs_instance *ecm_classifier_ovs_instances = NULL;
								/* list of all active instances */
static int ecm_classifier_ovs_count = 0;			/* Tracks number of instances allocated */

/*
 * Callback object.
 */
static struct ecm_classifier_ovs_callbacks ovs;

/*
 * ecm_classifier_ovs_ref()
 *	Ref
 */
static void ecm_classifier_ovs_ref(struct ecm_classifier_instance *ci)
{
	struct ecm_classifier_ovs_instance *ecvi;
	ecvi = (struct ecm_classifier_ovs_instance *)ci;

	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->refs++;
	DEBUG_ASSERT(ecvi->refs > 0, "%px: ref wrap\n", ecvi);
	DEBUG_TRACE("%px: ecvi ref %d\n", ecvi, ecvi->refs);
	spin_unlock_bh(&ecm_classifier_ovs_lock);
}

/*
 * ecm_classifier_ovs_deref()
 *	Deref
 */
static int ecm_classifier_ovs_deref(struct ecm_classifier_instance *ci)
{
	struct ecm_classifier_ovs_instance *ecvi;
	ecvi = (struct ecm_classifier_ovs_instance *)ci;

	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->refs--;
	DEBUG_ASSERT(ecvi->refs >= 0, "%px: refs wrapped\n", ecvi);
	DEBUG_TRACE("%px: ecvi deref %d\n", ecvi, ecvi->refs);
	if (ecvi->refs) {
		int refs = ecvi->refs;
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		return refs;
	}

	/*
	 * Object to be destroyed
	 */
	ecm_classifier_ovs_count--;
	DEBUG_ASSERT(ecm_classifier_ovs_count >= 0, "%px: ecm_classifier_ovs_count wrap\n", ecvi);

	/*
	 * UnLink the instance from our list
	 */
	if (ecvi->next) {
		ecvi->next->prev = ecvi->prev;
	}
	if (ecvi->prev) {
		ecvi->prev->next = ecvi->next;
	} else {
		DEBUG_ASSERT(ecm_classifier_ovs_instances == ecvi, "%px: list bad %px\n", ecvi, ecm_classifier_ovs_instances);
		ecm_classifier_ovs_instances = ecvi->next;
	}
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	/*
	 * Final
	 */
	DEBUG_INFO("%px: Final ovs classifier instance\n", ecvi);
	kfree(ecvi);

	return 0;
}

/*
 * ecm_classifier_ovs_interface_get_and_ref()
 *	Gets the OVS bridge port in the specified direction hierarchy.
 */
static inline struct net_device *ecm_classifier_ovs_interface_get_and_ref(struct ecm_db_connection_instance *ci,
									   ecm_db_obj_dir_t dir, bool ovs_port)
{
	int32_t if_first;
	struct ecm_db_iface_instance *interfaces[ECM_DB_IFACE_HEIRARCHY_MAX];
	int32_t i;

	/*
	 * Get the interface hierarchy.
	 */
	if_first = ecm_db_connection_interfaces_get_and_ref(ci, interfaces, dir);
	if (if_first == ECM_DB_IFACE_HEIRARCHY_MAX) {
		DEBUG_WARN("%px: Failed to get %s interfaces list\n", ci, ecm_db_obj_dir_strings[dir]);
		return NULL;
	}

	/*
	 * Go through the hierarchy and get the OVS port.
	 */
	for (i = ECM_DB_IFACE_HEIRARCHY_MAX - 1; i >= if_first; i--) {
		struct net_device *dev = dev_get_by_index(&init_net,
							  ecm_db_iface_interface_identifier_get(interfaces[i]));
		if (!dev) {
			DEBUG_WARN("%px: Failed to get net device with %d index\n", ci, i);
			continue;
		}

		if (ovs_port) {
			if (ecm_interface_is_ovs_bridge_port(dev)) {
				ecm_db_connection_interfaces_deref(interfaces, if_first);
				DEBUG_TRACE("%px: %s_dev: %s at %d index is an OVS bridge port\n", ci, ecm_db_obj_dir_strings[dir], dev->name, i);
				return dev;
			}

		} else {
			if (ovsmgr_is_ovs_master(dev)) {
				ecm_db_connection_interfaces_deref(interfaces, if_first);
				DEBUG_TRACE("%px: %s_dev: %s at %d index is an OVS bridge dev\n", ci, ecm_db_obj_dir_strings[dir], dev->name, i);
				return dev;
			}
		}

		DEBUG_TRACE("%px: dev: %s index: %d\n", ci, dev->name, i);
		dev_put(dev);
	}

	DEBUG_TRACE("%px: No OVS bridge port on the %s direction\n", ci, ecm_db_obj_dir_strings[dir]);
	ecm_db_connection_interfaces_deref(interfaces, if_first);
	return NULL;
}

#ifdef ECM_MULTICAST_ENABLE
/*
 * ecm_classifier_ovs_process_multicast()
 * 	Process multicast packet
 */
static void ecm_classifier_ovs_process_multicast(struct ecm_db_connection_instance *ci, struct sk_buff *skb,
							struct ecm_classifier_ovs_instance *ecvi,
							struct ecm_classifier_process_response *process_response)
{
	struct ecm_classifier_ovs_process_response resp;
	ecm_classifier_ovs_process_callback_t cb;
	struct ecm_db_iface_instance *to_mc_ifaces;
	struct net_device *from_dev = NULL, *indev_master = NULL;
	struct net_device *to_dev[ECM_DB_MULTICAST_IF_MAX] = {NULL};
	struct ovsmgr_dp_flow flow;
	ip_addr_t src_ip;
	ip_addr_t dst_ip;
	int32_t *to_mc_ifaces_first;
	int if_cnt, i;
	bool valid_ovs_ports = false;

	/*
	 * Classifier is always relevant for multicast
	 * if we have enabled OVS support in ECM.
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	/*
	 * No multicast port found, drop the connection.
	 */
	if_cnt = ecm_db_multicast_connection_to_interfaces_get_and_ref_all(ci, &to_mc_ifaces, &to_mc_ifaces_first);
	if (unlikely(!if_cnt)) {
		spin_lock_bh(&ecm_classifier_ovs_lock);
		ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_DROP;
		ecvi->process_response.drop = true;
		*process_response = ecvi->process_response;
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		DEBUG_WARN("%px: No multicast 'to' interface found\n", ci);
		goto done;
	}

	for (i = 0; i < ECM_DB_MULTICAST_IF_MAX; i++) {
		int32_t *to_iface_first;
		int j;

		/*
		 * Get to interface list, skip if the list is invalid.
		 */
		to_iface_first = ecm_db_multicast_if_first_get_at_index(to_mc_ifaces_first, i);
		if (*to_iface_first == ECM_DB_IFACE_HEIRARCHY_MAX) {
			continue;
		}

		for (j = to_mc_ifaces_first[i]; j < ECM_DB_IFACE_HEIRARCHY_MAX; j++) {
			struct ecm_db_iface_instance **ifaces;
			struct ecm_db_iface_instance *ii_temp;
			struct net_device *to_dev_temp;

			ii_temp = ecm_db_multicast_if_heirarchy_get(to_mc_ifaces, i);
			ifaces = (struct ecm_db_iface_instance **)ecm_db_multicast_if_instance_get_at_index(ii_temp, j);
			to_dev_temp = dev_get_by_index(&init_net, ecm_db_iface_interface_identifier_get(*ifaces));
			if (unlikely(!to_dev_temp)) {
				continue;
			}

			/*
			 * Get the physical OVS port.
			 */
			if (!ecm_interface_is_ovs_bridge_port(to_dev_temp)) {
				dev_put(to_dev_temp);
				continue;
			}

			to_dev[i] = to_dev_temp;
			valid_ovs_ports = true;
		}
	}
	ecm_db_multicast_connection_to_interfaces_deref_all(to_mc_ifaces, to_mc_ifaces_first);

	from_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, true);
	if (!from_dev && !valid_ovs_ports) {
		spin_lock_bh(&ecm_classifier_ovs_lock);
		*process_response = ecvi->process_response;
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		DEBUG_WARN("%px: None of the from/to interfaces are OVS bridge port\n", ci);
		goto done;
	}

	/*
	 * Below are the possible multicast flows.
	 *
	 * 1. L2 Multicast (Bridge)
	 * 	ovsbr (eth0, eth1,eth2)
	 * 	a. sender: eth0, receiver: eth1, eth2
	 *
	 * 2. L3 Multicast (Route)
	 * 	Upstream: br-wan (eth0)
	 * 	Downstream: br-home (eth1, eth2)
	 * 	a. Downstream flow => sender: eth0, receiver: eth1, eth2
	 * 	b. Upstream flow => sender: eth1, receiver: eth0
	 *
	 * 3. L2 + L3 Multicast (Bridge + Route)
	 * 	Upstream: br-wan (eth0)
	 * 	Downstream: br-home (eth1, eth2)
	 * 	a. sender: eth1, receiver: eth0, eth2
	 */

	/*
	 * Is there an external callback to get the ovs value from the packet?
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	cb = ovs.ovs_process;
	if (!cb) {
		/*
		 * Allow acceleration.
		 * Keep the classifier relevant to connection for stats update..
		 */
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		DEBUG_WARN("%px: No external process callback set\n", ci);
		goto allow_accel;
	}
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	memset(&flow, 0, sizeof(struct ovsmgr_dp_flow));

	if (from_dev) {
		flow.indev = from_dev;
		indev_master = ovsmgr_dev_get_master(flow.indev);
		DEBUG_ASSERT(indev_master, "%px: Expected a master\n", ci);
	}

	flow.is_routed = ecm_db_connection_is_routed_get(ci);
	flow.tuple.ip_version = ecm_db_connection_ip_version_get(ci);
	flow.tuple.protocol = ecm_db_connection_protocol_get(ci);
	flow.tuple.src_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
	flow.tuple.dst_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

	ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, flow.smac);
	ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, flow.dmac);
	ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);
	ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);

	if (flow.tuple.ip_version == 4) {
		ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.src, src_ip);
		ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.dst, dst_ip);
	} else if (flow.tuple.ip_version == 6) {
		ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.src, src_ip);
		ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.dst, dst_ip);
	} else {
		DEBUG_ASSERT(NULL, "%px: unexpected ip_version: %d", ci, flow.tuple.ip_version );
	}

	/*
	 * Check if the connection is a "bridge + route"
	 * flow.
	 */
	if (flow.is_routed) {
		/*
		 * Get the ingress VLAN information from ovs-mgr
		 */
		if (from_dev) {
			struct net_device *br_dev;
			ecm_classifier_ovs_result_t result;

			/*
			 * from_dev = eth1
			 * br_dev = ovs-br1
			 */
			br_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, false);
			DEBUG_TRACE("%px: processing route flow from_dev = %s, br_dev = %s", ecvi, from_dev->name, br_dev->name);

			/*
			 * We always take the flow from bridge to port, so indev is port device and outdev is bridge device.
			 */
			flow.indev = from_dev;
			flow.outdev = br_dev;

			DEBUG_TRACE("%px: Route Flow Process (from): src MAC: %pM src_dev: %s src: %pI4:%d proto: %d dest: %pI4:%d dest_dev: %s dest MAC: %pM\n",
					&flow, flow.smac, flow.indev->name, &flow.tuple.ipv4.src, flow.tuple.src_port, flow.tuple.protocol,
					&flow.tuple.ipv4.dst, flow.tuple.dst_port, flow.outdev->name, flow.dmac);

			memset(&resp, 0, sizeof(struct ecm_classifier_ovs_process_response));

			/*
			 * Call the external callback and get the result.
			 */
			result = cb(&flow, skb, &resp);

			dev_put(br_dev);

			/*
			 * Handle the result
			 */
			switch (result) {
			case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_ACCEL:
			case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL:
				/*
				 * Allow accel after setting the external module response.
				 */
				DEBUG_WARN("%px: External callback process succeeded\n", ecvi);
				spin_lock_bh(&ecm_classifier_ovs_lock);
				ecvi->process_response.ingress_vlan_tag[0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
				ecvi->process_response.ingress_vlan_tag[1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
				if (resp.egress_vlan[0].h_vlan_TCI) {
					ecvi->process_response.ingress_vlan_tag[0] = resp.egress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[0].h_vlan_TCI;
				}

				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_TAG;
				if (result == ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL) {
					if (resp.egress_vlan[1].h_vlan_TCI) {
						ecvi->process_response.ingress_vlan_tag[1] = resp.egress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[1].h_vlan_TCI;
					}

					ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_QINQ_TAG;
				}
				spin_unlock_bh(&ecm_classifier_ovs_lock);
				DEBUG_TRACE("%px: Multicast ingress vlan tag[0]: %x tag[1]: %x\n", ecvi, ecvi->process_response.ingress_vlan_tag[0],
						ecvi->process_response.ingress_vlan_tag[1]);
				break;

			case ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL:
				/*
				 * External callback failed to process VLAN process. So, let's deny the acceleration
				 * and try more with the subsequent packets.
				 */
				DEBUG_WARN("%px: External callback failed to process VLAN tags\n", ecvi);
				spin_lock_bh(&ecm_classifier_ovs_lock);
				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_MCAST_DENY_ACCEL;
				ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
				*process_response = ecvi->process_response;
				spin_unlock_bh(&ecm_classifier_ovs_lock);
				goto done;

			case ECM_CLASSIFIER_OVS_RESULT_ALLOW_ACCEL:
				/*
				 * There is no VLAN tag in the flow. Just allow the acceleration.
				 */
				DEBUG_WARN("%px: External callback didn't find any VLAN relation\n", ecvi);
				break;

			default:
				DEBUG_ASSERT(false, "%px: Unhandled result: %d\n", ci, result);
			}
		}
	}

	/*
	 * During multicast update path, skb is passed as NULL.
	 * We need to fill the ingress_vlan with the same vlan
	 * information that we have stored during connection instance
	 * creation. OVS manager needs this information to provide the
	 * right response.
	 */
	if (!skb) {
		flow.ingress_vlan = ecm_db_multicast_tuple_get_ovs_ingress_vlan(ci->ti);
	}

	/*
	 * Call the external callback and get the result.
	 */
	for (i = 0; i < ECM_DB_MULTICAST_IF_MAX; i++) {
		ecm_classifier_ovs_result_t result = 0;

		if (!to_dev[i]) {
			continue;
		}

		flow.outdev = to_dev[i];

		/*
		 * For routed flows, indev should be the OVS bridge of the
		 * corresponding port.
		 */
		if (flow.is_routed) {
			struct net_device *outdev_master;

			/*
			 * During bridge+route scenario, the indev can be
			 * an ovs bridge port or and ovs bridge. if master device
			 * for indev and outdev are same then it a bridged traffic.
			 * Otherwise, set the indev to master of the egress port.
			 */
			outdev_master = ovsmgr_dev_get_master(flow.outdev);
			DEBUG_ASSERT(outdev_master, "%px: Expected a master\n", ci);
			if (indev_master && (indev_master->ifindex == outdev_master->ifindex)) {
				flow.indev = from_dev;
				ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, flow.smac);
			} else {
				flow.indev = outdev_master;
				ether_addr_copy(flow.smac, flow.indev->dev_addr);
			}
		}

		DEBUG_TRACE("%px: src MAC: %pM src_dev: %s src: %pI4:%d proto: %d dest: %pI4:%d dest_dev: %s dest MAC: %pM\n",
				ci, flow.smac, flow.indev->name, &flow.tuple.ipv4.src, flow.tuple.src_port, flow.tuple.protocol,
				&flow.tuple.ipv4.dst, flow.tuple.dst_port, flow.outdev->name, flow.dmac);

		memset(&resp, 0, sizeof(struct ecm_classifier_ovs_process_response));
		result = cb(&flow, skb, &resp);

		switch(result) {
		case ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL_EGRESS:
			DEBUG_TRACE("%px: %s is not a valid OVS port\n", ci, to_dev[i]->name);
			ecm_db_multicast_connection_to_interfaces_clear_at_index(ci, i);
			break;

		case ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL:
			/*
			 * If we receive "ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL"
			 * for any of the OVS port, then the connection should be
			 * deleted.
			 */
			DEBUG_TRACE("%px: flow does not exist for the OVS port: %s\n", ci, to_dev[i]->name);
			spin_lock_bh(&ecm_classifier_ovs_lock);
			ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_MCAST_DENY_ACCEL;
			ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
			*process_response = ecvi->process_response;
			spin_unlock_bh(&ecm_classifier_ovs_lock);
			goto done;

		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_ACCEL:
			DEBUG_TRACE("%px: Acceleration allowed for multicast OVS port: %s\n", ci, to_dev[i]->name);
			break;

		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_ACCEL:
		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL:
			/*
			 * Allow accel after setting the external module response.
			 * Primary VLAN tag is always present even it is QinQ.
			 */
			DEBUG_WARN("%px: External callback process succeeded\n", ci);

			/*
			 * Initialize the VLAN entries since the ports can join/leave
			 * in-between and that will change the position of an existing port
			 * in the "egress_mc_vlan_tag" array.
			 */
			spin_lock_bh(&ecm_classifier_ovs_lock);
			ecvi->process_response.egress_mc_vlan_tag[i][0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
			ecvi->process_response.egress_mc_vlan_tag[i][1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
			ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_TAG;
			ecvi->process_response.egress_netdev_index[i] = flow.outdev->ifindex;

			/*
			 * If we have a valid TCI for ingress VLAN then we assume
			 * the flow is bridged. Because for routed flows, ingress VLAN
			 * will not be available.
			 */
			if (resp.ingress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.ingress_vlan_tag[0] = resp.ingress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.ingress_vlan[0].h_vlan_TCI;
			}

			if (resp.egress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.egress_mc_vlan_tag[i][0] = resp.egress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[0].h_vlan_TCI;
			}

			if (result == ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL) {
				if (resp.ingress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.ingress_vlan_tag[1] = resp.ingress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.ingress_vlan[1].h_vlan_TCI;
				}

				if (resp.egress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.egress_mc_vlan_tag[i][1] = resp.egress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[1].h_vlan_TCI;
				}

				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_QINQ_TAG;
			}

			spin_unlock_bh(&ecm_classifier_ovs_lock);
			DEBUG_TRACE("%px: Multicast ingress vlan tag[0] : 0x%x tag[1] : 0x%x\n", ci, ecvi->process_response.ingress_vlan_tag[0],
					ecvi->process_response.ingress_vlan_tag[1]);
			DEBUG_TRACE("%px: Multicast egress vlan tag[%d][0] : 0x%x tag[%d][1] : 0x%x\n", ci, i, ecvi->process_response.egress_mc_vlan_tag[i][0],
					i, ecvi->process_response.egress_mc_vlan_tag[i][1]);
			break;

		default:
			DEBUG_ASSERT(false, "Unhandled result: %d\n", result);
		}
	}

	/*
	 * It is possible that after verifying each egress port with ovs manager,
	 * no egress ovs ports are allowed for acceleration.
	 *
	 * Deny the multicast connection as there are no active 'to' interface.
	 */
	if (!ecm_db_multicast_connection_to_interfaces_get_count(ci)) {
		DEBUG_TRACE("%px: No valid multicast 'to' interfaces found\n", ci);
		spin_lock_bh(&ecm_classifier_ovs_lock);
		ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_MCAST_DENY_ACCEL;
		ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
		*process_response = ecvi->process_response;
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		goto done;
	}

allow_accel:
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_ACCEL_MODE;
	ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_ACCEL;
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

done:
	if (from_dev)
		dev_put(from_dev);

	/*
	 * Deref the ovs net devices
	 */
	if (valid_ovs_ports) {
		for (i = 0; i < ECM_DB_MULTICAST_IF_MAX; i++) {
			if (to_dev[i]) {
				dev_put(to_dev[i]);
			}
		}
	}

	return;
}
#endif

/*
 * ecm_classifier_ovs_process_route_flow()
 *	Process routed flows.
 */
static void ecm_classifier_ovs_process_route_flow(struct ecm_classifier_ovs_instance *ecvi, struct ecm_db_connection_instance *ci,
							struct sk_buff *skb, struct net_device *from_dev, struct net_device *to_dev,
							struct ecm_classifier_process_response *process_response,
							ecm_classifier_ovs_process_callback_t cb)
{
	ecm_classifier_ovs_result_t result;
	struct ecm_classifier_ovs_process_response resp;
	struct ovsmgr_dp_flow flow;
	struct net_device *br_dev;
	ip_addr_t src_ip, dst_ip;

	memset(&flow, 0, sizeof(flow));

	flow.is_routed = true;
	flow.tuple.ip_version = ecm_db_connection_ip_version_get(ci);
	flow.tuple.protocol = ecm_db_connection_protocol_get(ci);

	/*
	 * For routed flows both from and to side can be OVS bridge port, if there
	 * is a routed flow between two OVS bridges. (e.g: ovs-br1 and ovs-br2)
	 *
	 * Connection Direction:
	 * 				PC1 -----> eth1-ovs-br1 (DUT) ovs-br2-eth2 -----> PC2
							from_dev	to_dev
	 *
	 * 1. SNAT/DNAT Enabled:	FROM				FROM_NAT	TO/TO_NAT
	 * 2. SNAT/DNAT Disabled:	FROM/FROM_NAT					TO/TO_NAT
	 *
	 * Connection Direction:
	 * 				PC1 <----- eth1-ovs-br1 (DUT) ovs-br2-eth2 <----- PC2
	 *						to_dev		from_dev
	 *
	 * 3. SNAT/DNAT Enabled:	TO				TO_NAT		FROM/FROM_NAT
	 * 4. SNAT/DNAT Disabled:	TO/TO_NAT					FROM/FROM_NAT
	 *
	 * 5. Tunnelled packet:  PC1 ------------> eth1---[ovs-br1]---gretap (DUT) eth0----->[gretap device]
	 * 	After the packet is encapsulated, the packet is routed and the
	 * 	flow is not relavant flow.
	 */
	if (from_dev) {
		/*
		 * Case 1/2
		 * from_dev = eth1
		 * br_dev = ovs-br1
		 *
		 * Case 3/4
		 * from_dev = eth2
		 * br_dev = ovs-br2
		 *
		 * case 5
		 * from_dev = greptap
		 * br_dev = NULL
		 */
		br_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, false);
		if (!br_dev) {
			DEBUG_WARN("%px: from_dev = %s is a OVS bridge port, bridge interface is not found\n",
					ecvi, from_dev->name);
			goto route_not_relevant;
		}

		DEBUG_TRACE("%px: processing route flow from_dev = %s, br_dev = %s", ecvi, from_dev->name, br_dev->name);

		/*
		 * We always take the flow from bridge to port, so indev is brdige and outdev is port device.
		 */
		flow.indev = br_dev;
		flow.outdev = from_dev;

		flow.tuple.src_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO_NAT));
		flow.tuple.dst_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO_NAT, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, dst_ip);

		if (flow.tuple.ip_version == 4) {
			ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.src, src_ip);
			ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.dst, dst_ip);
		} else if (flow.tuple.ip_version == 6) {
			ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.src, src_ip);
			ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.dst, dst_ip);
		} else {
			DEBUG_ASSERT(NULL, "%px: unexpected ip_version: %d", ecvi, flow.tuple.ip_version );
		}

		ether_addr_copy(flow.smac, br_dev->dev_addr);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, flow.dmac);

		memset(&resp, 0, sizeof(struct ecm_classifier_ovs_process_response));

		/*
		 * Initialize the dscp with the default value.
		 */
		resp.dscp = OVSMGR_INVALID_DSCP;

		DEBUG_TRACE("%px: Route Flow Process (from): src MAC: %pM src_dev: %s src: %pI4:%d proto: %d dest: %pI4:%d dest_dev: %s dest MAC: %pM\n",
				&flow, flow.smac, flow.indev->name, &flow.tuple.ipv4.src, flow.tuple.src_port, flow.tuple.protocol,
				&flow.tuple.ipv4.dst, flow.tuple.dst_port, flow.outdev->name, flow.dmac);
		/*
		 * Call the external callback and get the result.
		 */
		result = cb(&flow, skb, &resp);

		dev_put(br_dev);

		if (resp.dscp != OVSMGR_INVALID_DSCP) {
			/*
			 * Copy DSCP value to the classifier's process response's flow_dscp field,
			 * because this is the from_dev and the direction of the flow is flow direction.
			 */
			spin_lock_bh(&ecm_classifier_ovs_lock);
			ecvi->process_response.flow_dscp = resp.dscp >> XT_DSCP_SHIFT;
			ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_DSCP;
			spin_unlock_bh(&ecm_classifier_ovs_lock);
			DEBUG_TRACE("FLOW DSCP : 0x%x\n", ecvi->process_response.flow_dscp);
		}

		/*
		 * Handle the result
		 */
		switch (result) {
		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_ACCEL:
		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL:
			/*
			 * Allow accel after setting the external module response.
			 */
			DEBUG_WARN("%px: External callback process succeeded\n", ecvi);

			spin_lock_bh(&ecm_classifier_ovs_lock);
			if (resp.egress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.ingress_vlan_tag[0] = resp.egress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[0].h_vlan_TCI;
				DEBUG_TRACE("Ingress vlan tag[0] set : %x\n", ecvi->process_response.ingress_vlan_tag[0]);
			}

			ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_TAG;

			if (result == ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL) {
				if (resp.egress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.ingress_vlan_tag[1] = resp.egress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[1].h_vlan_TCI;
					DEBUG_TRACE("Ingress vlan tag[0] set : %x\n", ecvi->process_response.ingress_vlan_tag[1]);
				}

				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_QINQ_TAG;
			}
			spin_unlock_bh(&ecm_classifier_ovs_lock);
			break;

		case ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL:
			/*
			 * External callback failed to process VLAN process. So, let's deny the acceleration
			 * and try more with the subsequent packets.
			 */
			DEBUG_WARN("%px: External callback failed to process VLAN tags\n", ecvi);
			goto route_deny_accel;

		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_ACCEL:

			/*
			 * There is no VLAN tag in the flow. Just allow the acceleration.
			 */
			DEBUG_WARN("%px: External callback didn't find any VLAN relation\n", ecvi);
			break;

		default:
			DEBUG_ASSERT(false, "Unhandled result: %d\n", result);
		}
	}

	if (to_dev) {
		/*
		 * Case 1/2
		 * from_dev = eth2
		 * br_dev = ovs-br2
		 *
		 * Case 3/4
		 * from_dev = eth1
		 * br_dev = ovs-br1
		 */
		br_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_TO, false);
		if (!br_dev) {
			DEBUG_WARN("%px: to_dev = %s is a OVS bridge port, bridge interface is not found\n",
					ecvi, to_dev->name);
			goto route_deny_accel;
		}

		DEBUG_TRACE("%px: processing route flow to_dev = %s, br_dev = %s", ecvi, to_dev->name, br_dev->name);

		flow.indev = br_dev;
		flow.outdev = to_dev;

		flow.tuple.src_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM_NAT));
		flow.tuple.dst_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM_NAT, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);

		if (flow.tuple.ip_version == 4) {
			ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.src, src_ip);
			ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.dst, dst_ip);
		} else if (flow.tuple.ip_version == 6) {
			ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.src, src_ip);
			ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.dst, dst_ip);
		} else {
			DEBUG_ASSERT(NULL, "%px: unexpected ip_version: %d", ecvi, flow.tuple.ip_version );
		}

		ether_addr_copy(flow.smac, br_dev->dev_addr);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, flow.dmac);

		memset(&resp, 0, sizeof(struct ecm_classifier_ovs_process_response));

		/*
		 * Initialize the dscp with the default value.
		 */
		resp.dscp = OVSMGR_INVALID_DSCP;

		DEBUG_TRACE("%px: Route Flow Process (to): src MAC: %pM src_dev: %s src: %pI4:%d proto: %d dest: %pI4:%d dest_dev: %s dest MAC: %pM\n",
				&flow, flow.smac, flow.indev->name, &flow.tuple.ipv4.src, flow.tuple.src_port, flow.tuple.protocol,
				&flow.tuple.ipv4.dst, flow.tuple.dst_port, flow.outdev->name, flow.dmac);
		/*
		 * Call the external callback and get the result.
		 */
		result = cb(&flow, skb, &resp);

		dev_put(br_dev);

		if (resp.dscp != OVSMGR_INVALID_DSCP) {
			/*
			 * Copy DSCP value to the classifier's process response's return_dscp field,
			 * because this is the to_dev and the direction of the flow is reply direction.
			 */
			spin_lock_bh(&ecm_classifier_ovs_lock);
			ecvi->process_response.return_dscp = resp.dscp >> XT_DSCP_SHIFT;
			ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_DSCP;
			spin_unlock_bh(&ecm_classifier_ovs_lock);
			DEBUG_TRACE("RETURN DSCP : 0x%x\n", ecvi->process_response.return_dscp);
		}

		/*
		 * Handle the result
		 */
		switch (result) {
		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_ACCEL:
		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL:
			/*
			 * Allow accel after setting the external module response.
			 */
			DEBUG_WARN("%px: External callback process succeeded\n", ecvi);

			spin_lock_bh(&ecm_classifier_ovs_lock);
			if (resp.egress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.egress_vlan_tag[0] = resp.egress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[0].h_vlan_TCI;
				DEBUG_TRACE("Egress vlan tag[0] set : %x\n", ecvi->process_response.egress_vlan_tag[0]);
			}

			ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_TAG;

			if (result == ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL) {
				if (resp.egress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.egress_vlan_tag[1] = resp.egress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[1].h_vlan_TCI;
					DEBUG_TRACE("Ingress vlan tag[0] set : %x\n", ecvi->process_response.ingress_vlan_tag[1]);
				}

				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_QINQ_TAG;
			}
			spin_unlock_bh(&ecm_classifier_ovs_lock);
			break;

		case ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL:
			/*
			 * External callback failed to process VLAN process. So, let's deny the acceleration
			 * and try more with the subsequent packets.
			 */
			DEBUG_WARN("%px: External callback failed to process VLAN tags\n", ecvi);
			goto route_deny_accel;

		case ECM_CLASSIFIER_OVS_RESULT_ALLOW_ACCEL:

			/*
			 * There is no VLAN tag in the flow. Just allow the acceleration.
			 */
			DEBUG_WARN("%px: External callback didn't find any VLAN relation\n", ecvi);
			break;

		default:
			DEBUG_ASSERT(false, "Unhandled result: %d\n", result);
		}
	}

	/*
	 * Acceleration is permitted
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
	ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_ACCEL_MODE;
	ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_ACCEL;
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	return;

route_deny_accel:
	/*
	 * ecm_classifier_ovs_lock MUST be held
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
	ecvi->process_response.process_actions = ECM_CLASSIFIER_PROCESS_ACTION_ACCEL_MODE;
	ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	return;

route_not_relevant:
	/*
	 * ecm_classifier_ovs_lock MUST be held
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
}

/*
 * ecm_classifier_ovs_process()
 *	Process new packet
 *
 * NOTE: This function would only ever be called if all other classifiers have failed.
 */
static void ecm_classifier_ovs_process(struct ecm_classifier_instance *aci, ecm_tracker_sender_type_t sender,
									struct ecm_tracker_ip_header *ip_hdr, struct sk_buff *skb,
									struct ecm_classifier_process_response *process_response)
{
	struct ecm_classifier_ovs_instance *ecvi = (struct ecm_classifier_ovs_instance *)aci;
	ecm_classifier_ovs_result_t result = 0;
	struct ecm_db_connection_instance *ci;
	ecm_classifier_ovs_process_callback_t cb = NULL;
	ip_addr_t src_ip;
	ip_addr_t dst_ip;
	struct ecm_classifier_ovs_process_response resp;
	struct ovsmgr_dp_flow flow;
	struct net_device *from_dev = NULL;
	struct net_device *to_dev = NULL;

	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: invalid state magic\n", ecvi);

	/*
	 * Not relevant to the connection if not enabled.
	 */
	if (unlikely(!ecm_classifier_ovs_enabled)) {
		/*
		 * Not relevant.
		 */
		DEBUG_WARN("%px: ovs classifier is not enabled\n", aci);
		goto not_relevant;
	}

	/*
	 * Get connection
	 */
	ci = ecm_db_connection_serial_find_and_ref(ecvi->ci_serial);
	if (!ci) {
		/*
		 * Connection has gone from under us
		 */
		DEBUG_WARN("%px: connection instance gone while processing classifier\n", aci);
		goto not_relevant;
	}

#ifdef ECM_MULTICAST_ENABLE
	ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);
	if (ecm_ip_addr_is_multicast(dst_ip)) {
		ecm_classifier_ovs_process_multicast(ci, skb, ecvi, process_response);
		ecm_db_connection_deref(ci);
		return;
	}
#endif

	/*
	 * Get the possible OVS bridge ports. If both are NULL, the classifier is not
	 * relevant to this connection.
	 */
	from_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, true);
	to_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_TO, true);
	if (!from_dev && !to_dev) {
		/*
		 * So, the classifier is not relevant to this connection.
		 */
		DEBUG_WARN("%px: None of the from/to interfaces are OVS bridge port\n", aci);
		ecm_db_connection_deref(ci);
		goto not_relevant;
	}

	/*
	 * Is there an external callback to get the ovs value from the packet?
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	cb = ovs.ovs_process;
	if (!cb) {
		/*
		 * Allow acceleration.
		 * Keep the classifier relevant to connection for stats update..
		 */
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		DEBUG_WARN("%px: No external process callback set\n", aci);
		if (from_dev)
			dev_put(from_dev);

		if (to_dev)
			dev_put(to_dev);

		spin_lock_bh(&ecm_classifier_ovs_lock);
		goto allow_accel;
	}
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	/*
	 * If the flow is a routed flow, set the is_routed flag of the flow.
	 */
	if (ecm_db_connection_is_routed_get(ci)) {
		ecm_classifier_ovs_process_route_flow(ecvi, ci, skb, from_dev, to_dev, process_response, cb);

		if (from_dev)
			dev_put(from_dev);

		if (to_dev)
			dev_put(to_dev);

		ecm_db_connection_deref(ci);
		return;
	}

	memset(&flow, 0, sizeof(struct ovsmgr_dp_flow));

	/*
	 * If the connection is a bridge flow, both devices should be present.
	 * TODO: This is an unexpected situation and should be assertion.
	 * We should also make sure that both devices are on the same OVS bridge.
	 */
	if (!from_dev || !to_dev) {
		DEBUG_ERROR("%px: One of the ports is NULL from_dev: %px to_dev: %px\n", aci, from_dev, to_dev);

		if (from_dev)
			dev_put(from_dev);

		if (to_dev)
			dev_put(to_dev);

		ecm_db_connection_deref(ci);
		goto not_relevant;
	}

	/*
	 * Flow is an OVS bridge flow.
	 */
	flow.tuple.ip_version = ecm_db_connection_ip_version_get(ci);
	flow.tuple.protocol = ecm_db_connection_protocol_get(ci);

	/*
	 * For the flow lookup, we need to use the  proper 5-tuple, in/out dev and
	 * src/dest MAC address. If the packet is coming from the destination side of the connection
	 * (e.g: ACK packets of the TCP connection) these values should be reversed.
	 */
	if (sender == ECM_TRACKER_SENDER_TYPE_SRC) {
		DEBUG_TRACE("%px: sender is SRC\n", aci);
		flow.indev = from_dev;
		flow.outdev = to_dev;

		flow.tuple.src_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
		flow.tuple.dst_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, flow.smac);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, flow.dmac);
	} else {
		DEBUG_TRACE("%px: sender is DEST\n", aci);
		flow.indev = to_dev;
		flow.outdev = from_dev;

		flow.tuple.src_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));
		flow.tuple.dst_port = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, dst_ip);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, flow.smac);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, flow.dmac);

	}

	if (flow.tuple.ip_version == 4) {
		ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.src, src_ip);
		ECM_IP_ADDR_TO_NIN4_ADDR(flow.tuple.ipv4.dst, dst_ip);
	} else if (flow.tuple.ip_version == 6) {
		ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.src, src_ip);
		ECM_IP_ADDR_TO_NIN6_ADDR(flow.tuple.ipv6.dst, dst_ip);
	} else {
		DEBUG_ASSERT(NULL, "%px: unexpected ip_version: %d", aci, flow.tuple.ip_version );
	}

	memset(&resp, 0, sizeof(struct ecm_classifier_ovs_process_response));

	/*
	 * Set default values for flow and return DSCP.
	 * External module will call the DSCP query twice to
	 * find both directions' values.
	 */
	resp.flow_dscp = OVSMGR_INVALID_DSCP;
	resp.return_dscp = OVSMGR_INVALID_DSCP;

	/*
	 * Call the external callback and get the result.
	 */
	result = cb(&flow, skb, &resp);

	if (from_dev)
		dev_put(from_dev);

	if (to_dev)
		dev_put(to_dev);

	/*
	 * Handle the result
	 */
	switch (result) {
	case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_ACCEL:
	case ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL:
		/*
		 * Allow accel after setting the external module response.
		 */
		DEBUG_WARN("%px: External callback process succeeded\n", aci);

		spin_lock_bh(&ecm_classifier_ovs_lock);
		ecvi->process_response.ingress_vlan_tag[0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
		ecvi->process_response.egress_vlan_tag[0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
		ecvi->process_response.ingress_vlan_tag[1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
		ecvi->process_response.egress_vlan_tag[1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;

		/*
		 * Primary VLAN tag is always present even it is QinQ.
		 */
		ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_TAG;

		/*
		 * If the sender type is source, which means the packet is coming from the originator,
		 * we assign the ECM-ingress<>OVS-ingress, ECM-egress<>OVS-egress values.
		 */
		if (sender == ECM_TRACKER_SENDER_TYPE_SRC) {
			if (resp.ingress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.ingress_vlan_tag[0] = resp.ingress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.ingress_vlan[0].h_vlan_TCI;
				DEBUG_TRACE("Ingress vlan tag[0] set : 0x%x\n", ecvi->process_response.ingress_vlan_tag[0]);
			}

			if (resp.egress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.egress_vlan_tag[0] = resp.egress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[0].h_vlan_TCI;
				DEBUG_TRACE("Egress vlan tag[0] set : 0x%x\n", ecvi->process_response.egress_vlan_tag[0]);
			}

			if (result == ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL) {
				if (resp.ingress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.ingress_vlan_tag[1] = resp.ingress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.ingress_vlan[1].h_vlan_TCI;
					DEBUG_TRACE("Ingress vlan tag[0] set : 0x%x\n", ecvi->process_response.ingress_vlan_tag[1]);
				}

				if (resp.egress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.egress_vlan_tag[1] = resp.egress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[1].h_vlan_TCI;
					DEBUG_TRACE("Egress vlan tag[1] set : 0x%x\n", ecvi->process_response.egress_vlan_tag[1]);
				}

				/*
				 * QinQ tag is present. Let's pass this information to the frontend through the process action flag.
				 */
				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_QINQ_TAG;
			}
		} else {
			/*
			 * Sender type is destination, which means packet si coming from the counter originator side,
			 * we assign the ECM-ingress<>OVS-egress and ECM-egress<>OVS-ingress values.
			 */
			if (resp.ingress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.egress_vlan_tag[0] = resp.ingress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.ingress_vlan[0].h_vlan_TCI;
				DEBUG_TRACE("Egress vlan tag[0] set : 0x%x\n", ecvi->process_response.egress_vlan_tag[0]);
			}

			if (resp.egress_vlan[0].h_vlan_TCI) {
				ecvi->process_response.ingress_vlan_tag[0] = resp.egress_vlan[0].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[0].h_vlan_TCI;
				DEBUG_TRACE("Ingress vlan tag[0] set : 0x%x\n", ecvi->process_response.ingress_vlan_tag[0]);
			}

			if (result == ECM_CLASSIFIER_OVS_RESULT_ALLOW_VLAN_QINQ_ACCEL) {
				if (resp.ingress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.egress_vlan_tag[1] = resp.ingress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.ingress_vlan[1].h_vlan_TCI;
					DEBUG_TRACE("Egress vlan tag[0] set : 0x%x\n", ecvi->process_response.egress_vlan_tag[1]);
				}

				if (resp.egress_vlan[1].h_vlan_TCI) {
					ecvi->process_response.ingress_vlan_tag[1] = resp.egress_vlan[1].h_vlan_encapsulated_proto << 16 | resp.egress_vlan[1].h_vlan_TCI;
					DEBUG_TRACE("Ingress vlan tag[1] set : 0x%x\n", ecvi->process_response.ingress_vlan_tag[1]);
				}

				/*
				 * QinQ tag is present. Let's pass this information to the frontend through the process action flag.
				 */
				ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_QINQ_TAG;
			}
		}

		break;

	case ECM_CLASSIFIER_OVS_RESULT_DENY_ACCEL:
		/*
		 * External callback failed to process VLAN process. So, let's deny the acceleration
		 * and try more with the subsequent packets.
		 */
		DEBUG_WARN("%px: External callback failed to process VLAN tags\n", aci);
		goto deny_accel;

	case ECM_CLASSIFIER_OVS_RESULT_ALLOW_ACCEL:

		/*
		 * There is no VLAN tag in the flow. Just allow the acceleration.
		 */
		DEBUG_WARN("%px: External callback didn't find any VLAN relation\n", aci);
		spin_lock_bh(&ecm_classifier_ovs_lock);
		break;

	default:
		DEBUG_ASSERT(false, "Unhandled result: %d\n", result);
	}

	/*
	 * If external module set any of the flow or return DSCP,
	 * we copy them to the classifier's process response based
	 * on the direction of the traffic. The external module
	 * should always set first the flow and then the return values.
	 */
	if ((resp.flow_dscp != OVSMGR_INVALID_DSCP) || (resp.return_dscp != OVSMGR_INVALID_DSCP)) {
		if (sender == ECM_TRACKER_SENDER_TYPE_SRC) {
			/*
			 * Copy DSCP values
			 */
			ecvi->process_response.flow_dscp = (resp.flow_dscp != OVSMGR_INVALID_DSCP) ? resp.flow_dscp >> XT_DSCP_SHIFT : 0;
			ecvi->process_response.return_dscp = (resp.return_dscp != OVSMGR_INVALID_DSCP) ? resp.return_dscp >> XT_DSCP_SHIFT : ecvi->process_response.flow_dscp;
			DEBUG_TRACE("FLOW DSCP: 0x%x RETURN DSCP: 0x%x\n",
					ecvi->process_response.flow_dscp, ecvi->process_response.return_dscp);
		} else {
			/*
			 * Copy DSCP values
			 */
			ecvi->process_response.flow_dscp = (resp.return_dscp != OVSMGR_INVALID_DSCP) ? resp.return_dscp >> XT_DSCP_SHIFT : 0;
			ecvi->process_response.return_dscp = (resp.flow_dscp != OVSMGR_INVALID_DSCP) ? resp.flow_dscp >> XT_DSCP_SHIFT : ecvi->process_response.flow_dscp;
			DEBUG_TRACE("FLOW DSCP: 0x%x RETURN DSCP: 0x%x\n",
					ecvi->process_response.flow_dscp, ecvi->process_response.return_dscp);
		}
		ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_DSCP;
	}

allow_accel:
	/*
	 * Acceleration is permitted
	 */
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
	ecvi->process_response.process_actions |= ECM_CLASSIFIER_PROCESS_ACTION_ACCEL_MODE;
	ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_ACCEL;

	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
	ecm_db_connection_deref(ci);
	return;

not_relevant:
	/*
	 * ecm_classifier_ovs_lock MUST be held
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
	return;

deny_accel:
	/*
	 * ecm_classifier_ovs_lock MUST be held
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
	ecvi->process_response.process_actions = ECM_CLASSIFIER_PROCESS_ACTION_ACCEL_MODE;
	ecvi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
	ecm_db_connection_deref(ci);
}

/*
 * ecm_classifier_ovs_type_get()
 *	Get type of classifier this is
 */
static ecm_classifier_type_t ecm_classifier_ovs_type_get(struct ecm_classifier_instance *aci)
{
	struct ecm_classifier_ovs_instance *ecvi;
	ecvi = (struct ecm_classifier_ovs_instance *)aci;

	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);
	return ECM_CLASSIFIER_TYPE_OVS;
}

/*
 * ecm_classifier_ovs_reclassify_allowed()
 *	Get whether reclassification is allowed
 */
static bool ecm_classifier_ovs_reclassify_allowed(struct ecm_classifier_instance *aci)
{
	struct ecm_classifier_ovs_instance *ecvi;
	ecvi = (struct ecm_classifier_ovs_instance *)aci;

	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);
	return true;
}

/*
 * ecm_classifier_ovs_reclassify()
 *	Reclassify
 */
static void ecm_classifier_ovs_reclassify(struct ecm_classifier_instance *aci)
{
	struct ecm_classifier_ovs_instance *ecvi;
	ecvi = (struct ecm_classifier_ovs_instance *)aci;
	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);

	/*
	 * Revert back to MAYBE relevant - we will evaluate when we get the next process() call.
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_MAYBE;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
}

/*
 * ecm_classifier_ovs_last_process_response_get()
 *	Get result code returned by the last process call
 */
static void ecm_classifier_ovs_last_process_response_get(struct ecm_classifier_instance *aci,
	struct ecm_classifier_process_response *process_response)
{
	struct ecm_classifier_ovs_instance *ecvi;
	ecvi = (struct ecm_classifier_ovs_instance *)aci;
	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);

	spin_lock_bh(&ecm_classifier_ovs_lock);
	*process_response = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
}

/*
 * ecm_classifier_ovs_stats_sync()
 *	Sync the stats of the OVS flow.
 */
static inline void ecm_classifier_ovs_stats_sync(struct ovsmgr_dp_flow *flow,
					  uint32_t pkts, uint32_t bytes,
					  struct net_device *indev, struct net_device *outdev,
					  uint8_t *smac, uint8_t *dmac,
					  ip_addr_t sip, ip_addr_t dip,
					  uint16_t sport, uint16_t dport, uint16_t tci, uint16_t tpid)
{
	struct ovsmgr_dp_flow_stats stats;

	flow->indev = indev;
	flow->outdev = outdev;

	ether_addr_copy(flow->smac, smac);
	ether_addr_copy(flow->dmac, dmac);

	/*
	 * Set default VLAN tci and vlan encapsulated proto.
	 */
	flow->ingress_vlan.h_vlan_TCI = 0;
	flow->ingress_vlan.h_vlan_encapsulated_proto = 0;

	if (tci) {
		flow->ingress_vlan.h_vlan_TCI = tci;
		flow->ingress_vlan.h_vlan_encapsulated_proto = tpid;
	}

	flow->tuple.src_port = sport;
	flow->tuple.dst_port = dport;

	if (flow->tuple.ip_version == 4) {
		ECM_IP_ADDR_TO_NIN4_ADDR(flow->tuple.ipv4.src, sip);
		ECM_IP_ADDR_TO_NIN4_ADDR(flow->tuple.ipv4.dst, dip);
		DEBUG_TRACE("%px: STATS: src MAC: %pM src_dev: %s src: %pI4:%d proto: %d dest: %pI4:%d dest_dev: %s dest MAC: %pM TCI: %x, TPID: %x\n",
				flow, flow->smac, flow->indev->name, &flow->tuple.ipv4.src, flow->tuple.src_port, flow->tuple.protocol,
				&flow->tuple.ipv4.dst, flow->tuple.dst_port, flow->outdev->name, flow->dmac,
				flow->ingress_vlan.h_vlan_TCI, flow->ingress_vlan.h_vlan_encapsulated_proto);
	} else {
		ECM_IP_ADDR_TO_NIN6_ADDR(flow->tuple.ipv6.src, sip);
		ECM_IP_ADDR_TO_NIN6_ADDR(flow->tuple.ipv6.dst, dip);
		DEBUG_TRACE("%px: STATS: src MAC: %pM src_dev: %s src: %pI6:%d proto: %d dest: %pI6:%d dest_dev: %s dest MAC: %pM, TCI: %x, TPID: %x\n",
				flow, flow->smac, flow->indev->name, &flow->tuple.ipv6.src, flow->tuple.src_port, flow->tuple.protocol,
				&flow->tuple.ipv6.dst, flow->tuple.dst_port, flow->outdev->name, flow->dmac,
				flow->ingress_vlan.h_vlan_TCI, flow->ingress_vlan.h_vlan_encapsulated_proto);
	}

	/*
	 * Set the flow stats and update the flow database.
	 */
	stats.pkts = pkts;
	stats.bytes = bytes;

	ovsmgr_flow_stats_update(flow, &stats);
}

#ifdef ECM_MULTICAST_ENABLE
/*
 * ecm_classifier_ovs_multicast_sync_to_stats()
 *	Common multicast sync_to function for IPv4 and IPv6.
 */
static void ecm_classifier_ovs_multicast_sync_to_stats(struct ecm_classifier_ovs_instance *ecvi,
					struct ecm_db_connection_instance *ci, struct ecm_classifier_rule_sync *sync)
{
	struct net_device *from_dev;
	struct net_device *to_ovs_port[ECM_DB_MULTICAST_IF_MAX];
	struct net_device *to_ovs_brdev[ECM_DB_MULTICAST_IF_MAX];
	struct net_device *br_dev;
	ip_addr_t src_ip;
	ip_addr_t dst_ip;
	uint8_t smac[ETH_ALEN];
	uint8_t dmac[ETH_ALEN];
	uint16_t sport;
	uint16_t dport;
	struct ovsmgr_dp_flow flow;
	int if_cnt, i, valid_ifcnt = 0, ifindex;
	uint16_t tpid = 0, tci = 0;

	/*
	 * Get the possible OVS bridge ports.
	 */
	from_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, true);
	if_cnt = ecm_interface_multicast_ovs_to_interface_get_and_ref(ci, to_ovs_port, to_ovs_brdev);
	if (!from_dev && !if_cnt) {
		DEBUG_WARN("%px: None of the from/to interfaces is OVS bridge port\n", ci);
		return;
	}

	memset(&flow, 0, sizeof(flow));

	/*
	 * IP version and protocol are common for routed and bridge flows.
	 */
	flow.tuple.ip_version = ecm_db_connection_ip_version_get(ci);
	flow.tuple.protocol = ecm_db_connection_protocol_get(ci);
	flow.is_routed = ecm_db_connection_is_routed_get(ci);
	if (!flow.is_routed) {
		/* For multicast bridge flows, ovs creates a single rule with multiple
		 * egress interfaces. We need only one egress interface to sync the flow statistics.
		 *
		 * Sync the flow direction.
		 * eth1 to eth2
		 */
		sport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
		dport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);

		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, smac);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, dmac);

		if (ecvi->process_response.ingress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			tci = ecvi->process_response.ingress_vlan_tag[0] & 0xffff;
			tpid = (ecvi->process_response.ingress_vlan_tag[0] >> 16) & 0xffff;
			DEBUG_TRACE("%px: Ingress VLAN : %x:%x\n", ci, tci, tpid);
		}

		ecm_classifier_ovs_stats_sync(&flow,
				sync->rx_packet_count[ECM_CONN_DIR_FLOW], sync->rx_byte_count[ECM_CONN_DIR_FLOW],
				from_dev, to_ovs_port[0],
				smac, dmac,
				src_ip, dst_ip,
				sport, dport, tci, tpid);

		goto done;
	}

	/*
	 * The 'to' interfaces ports can be part of different OVS bridges.
	 * ovs-br1-(eth0, eth1, eth2)
	 * ovs-br2-(eth3)
	 * ovs-br3 (eth4, eth5)
	 *
	 * Find unique ovs port and ovs bridge combination, as for statistics
	 * update we need only one port from each OVS bridge.
	 *
	 * The logic will derive the below output for the
	 * above mentioned ovs 'to' interface list.
	 * to_ovs_port: eth0, eth3, eth4
	 * to_ovs_brdev: ovs-br1, ovs-br2, ovs-br3
	 *
	 */
	if (if_cnt) {
		ifindex = to_ovs_brdev[0]->ifindex;
		for (i = 1, valid_ifcnt = 1; i < if_cnt; i++) {
			if (ifindex == to_ovs_brdev[i]->ifindex) {
				dev_put(to_ovs_port[i]);
				continue;
			}

			to_ovs_port[valid_ifcnt] = to_ovs_port[i];
			to_ovs_brdev[valid_ifcnt] = to_ovs_brdev[i];
			valid_ifcnt++;
		}
	}

	/*
	 * For routed flows below configurations are possible.
	 *
	 * 1. From interface is OVS bridge port, to interface is
	 * another OVS bridge port
	 * PC1 -----> eth1-ovs-br1--->ovs-br2-eth2----->PC2
	 *
	 * 2. From interface is OVS bridge port, multiple to
	 * OVS bridge port (OVS master is same).
	 * PC1 -----> eth1-ovs-br1--->ovs-br2-eth2,eth3----->PC2
	 *
	 * 3. From interface is OVS bridge port, multiple to
	 * OVS bridge port (OVS masters are different).
	 * PC1 -----> eth1-ovs-br1--->ovs-br2-eth2/ovs-br3-eth3----->PC2
	 */
	if (from_dev) {
		/*
		 * from_dev = eth1
		 * br_dev = ovs-br1
		 */
		br_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, false);
		if (!br_dev) {
			DEBUG_WARN("%px: from_dev = %s is a OVS bridge port, bridge interface is not found\n",
					ci, from_dev->name);
			goto done;
		}

		/*
		 * Sync the flow direction.
		 * eth1 to ovs-br1
		 */
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, smac);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, dmac);

		sport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
		dport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);

		if (ecvi->process_response.ingress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			tci = ecvi->process_response.ingress_vlan_tag[0] & 0xffff;
			tpid = (ecvi->process_response.ingress_vlan_tag[0] >> 16) & 0xffff;
			DEBUG_TRACE("%px: Ingress VLAN : %x:%x\n", ci, tci, tpid);
		}

		ecm_classifier_ovs_stats_sync(&flow,
				sync->rx_packet_count[ECM_CONN_DIR_FLOW], sync->rx_byte_count[ECM_CONN_DIR_FLOW],
				from_dev, br_dev,
				smac, dmac,
				src_ip, dst_ip,
				sport, dport, tci, tpid);
		dev_put(br_dev);
	}

	/*
	 * For routed flow, to side can be multiple OVS bridge ports and
	 * the ports can be part of different OVS bridge master.
	 *
	 * 1. outdev = eth2
	 * indev = ovs-br2
	 * Sync the flow direction.
	 * ovs-br2 to eth2
	 *
	 * 2. outdev = eth3
	 * indev = ovs-br2
	 * Sync the flow direction.
	 * ovs-br2 to eth3
	 *
	 * 3. outdev = eth3
	 * indev = ovs-br3
	 * Sync the flow direction.
	 * ovs-br3 to eth3
	 *
	 */
	ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, dmac);
	ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);
	for (i = 0; i < valid_ifcnt; i++) {
		ether_addr_copy(smac, to_ovs_brdev[i]->dev_addr);

		sport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
		dport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);

		/*
		 * tci and tpid is 0 for pkts received from ovs bridge
		 */
		tci = tpid = 0;

		ecm_classifier_ovs_stats_sync(&flow,
				sync->rx_packet_count[ECM_CONN_DIR_FLOW], sync->rx_byte_count[ECM_CONN_DIR_FLOW],
				to_ovs_brdev[i], to_ovs_port[i],
				smac, dmac,
				src_ip, dst_ip,
				sport, dport, tci, tpid);
	}

done:
	if (from_dev)
		dev_put(from_dev);

	for (i = 0; i < valid_ifcnt; i++) {
		dev_put(to_ovs_port[i]);
	}
}
#endif

/*
 * ecm_classifier_ovs_sync_to_stats()
 *	Common sync_to function for IPv4 and IPv6.
 */
static void ecm_classifier_ovs_sync_to_stats(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_sync *sync)
{
	ip_addr_t src_ip;
	ip_addr_t dst_ip;
	struct ecm_db_connection_instance *ci;
	struct ovsmgr_dp_flow flow;
	struct net_device *from_dev;
	struct net_device *to_dev;
	struct net_device *br_dev;
	uint8_t smac[ETH_ALEN];
	uint8_t dmac[ETH_ALEN];
	uint16_t sport;
	uint16_t dport;
	uint16_t tpid = 0, tci = 0;

	struct ecm_classifier_ovs_instance *ecvi = (struct ecm_classifier_ovs_instance *)aci;

	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);

	ci = ecm_db_connection_serial_find_and_ref(ecvi->ci_serial);
	if (!ci) {
		DEBUG_TRACE("%px: No ci found for %u\n", ecvi, ecvi->ci_serial);
		return;
	}

#ifdef ECM_MULTICAST_ENABLE
	/*
	 * Check for multicast connection.
	 */
	ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);
	if (ecm_ip_addr_is_multicast(dst_ip)) {
		ecm_classifier_ovs_multicast_sync_to_stats(ecvi, ci, sync);
		ecm_db_connection_deref(ci);
		return;
	}
#endif
	memset(&flow, 0, sizeof(flow));

	/*
	 * Get the possible OVS bridge ports.
	 */
	from_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, true);
	to_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_TO, true);

	/*
	 * IP version and protocol are common for routed and bridge flows.
	 */
	flow.tuple.ip_version = ecm_db_connection_ip_version_get(ci);
	flow.tuple.protocol = ecm_db_connection_protocol_get(ci);
	flow.is_routed = ecm_db_connection_is_routed_get(ci);

	/*
	 * Get the tci and tpid values of the ingress side of the flow.
	 */
	if (ecvi->process_response.ingress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
		tci = ecvi->process_response.ingress_vlan_tag[0] & 0xffff;
		tpid = (ecvi->process_response.ingress_vlan_tag[0] >> 16) & 0xffff;
		DEBUG_TRACE("%px: Ingress VLAN : %x:%x\n", aci, tci, tpid);
	}

	/*
	 * Bridge flow
	 */
	if (!flow.is_routed) {
		/*
		 * Sync the flow direction (eth1 to eth2)
		 *
		 * ECM depends on netdev private flags to identify
		 * if it is an OVS port, if the port is removed from
		 * bridge while traffic is running then the device is
		 * not part of bridge.  Do not update statistics if ports
		 * are removed from bridge.
		 */
		if (!from_dev || !to_dev) {
			ecm_db_connection_deref(ci);
			return;
		}

		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, smac);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, dmac);

		sport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
		dport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);

		DEBUG_TRACE("%px: Flow direction stats update\n", aci);
		ecm_classifier_ovs_stats_sync(&flow,
				  sync->rx_packet_count[ECM_CONN_DIR_FLOW], sync->rx_byte_count[ECM_CONN_DIR_FLOW],
				  from_dev, to_dev,
				  smac, dmac,
				  src_ip, dst_ip,
				  sport, dport, tci, tpid);

		/*
		 * Sync the return direction (eth2 to eth1)
		 * All the flow parameters are reversed.
		 */
		DEBUG_TRACE("%px: Return direction stats update\n", aci);

		/*
		 * Reset the tci and tpid values and get the egress side of the flow.
		 */
		tci = tpid = 0;
		if (ecvi->process_response.egress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			tci = ecvi->process_response.egress_vlan_tag[0] & 0xffff;
			tpid = (ecvi->process_response.egress_vlan_tag[0] >> 16) & 0xffff;
			DEBUG_TRACE("%px: Egress VLAN : %x:%x\n", aci, tci, tpid);
		}

		ecm_classifier_ovs_stats_sync(&flow,
				  sync->rx_packet_count[ECM_CONN_DIR_RETURN], sync->rx_byte_count[ECM_CONN_DIR_RETURN],
				  to_dev, from_dev,
				  dmac, smac,
				  dst_ip, src_ip,
				  dport, sport, tci, tpid);
		goto done;
	}

	/*
	 * For routed flows both from and to side can be OVS bridge port, if there
	 * is a routed flow between two OVS bridges. (e.g: ovs-br1 and ovs-br2)
	 *
	 * These are the netdevice places and the IP address values based on the
	 * 4 different NAT cases.
	 *
	 * SNAT:
	 * PC1 -----> eth1-ovs-br1--->ovs-br2-eth2 -----> PC2
	 *		(from_dev)	(to_dev)
	 * src_ip			src_ip_nat	dest_ip/dest_ip_nat
	 *
	 * DNAT
	 * PC1 <----- eth1-ovs-br1<---ovs-br2-eth2 <----- PC2
	 *		(to_dev)	(from_dev)
	 * dest_ip			dest_ip_nat	src_ip/src_ip_nat
	 *
	 * Non-NAT - Egress
	 * PC1 -----> eth1-ovs-br1--->ovs-br2-eth2 -----> PC2
	 *		(from_dev)	(to_dev)
	 * src_ip/src_ip_nat				dest_ip/dest_ip_nat
	 *
	 * Non-NAT - Ingress
	 * PC1 <----- eth1-ovs-br1<---ovs-br2-eth2 <----- PC2
	 *		(to_dev)	(from_dev)
	 * dest_ip/dest_ip_nat				src_ip/src_ip_nat
	 */
	if (from_dev) {
		/*
		 * from_dev = eth1/eth2  (can be tagged)
		 * br_dev = ovs-br1/ovs_br2 (untagged)
		 */
		br_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_FROM, false);
		if (!br_dev) {
			DEBUG_WARN("%px: from_dev = %s is a OVS bridge port, bridge interface is not found\n",
					aci, from_dev->name);
			goto done;
		}

		/*
		 * Sync the flow direction (eth1/eth2 to ovs-br1/ovs_br2) based on the NAT case.
		 */
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, smac);
		ether_addr_copy(dmac, br_dev->dev_addr);

		/*
		 * If from_dev is a bridge port, dest_ip_nat and dest_port_nat satisfies all the NAT cases.
		 * So, we need to get the ECM_DB_OBJ_DIR_TO_NAT direction's IP and port number from the connection.
		 */
		sport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM));
		dport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO_NAT));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO_NAT, dst_ip);

		ecm_classifier_ovs_stats_sync(&flow,
				  sync->rx_packet_count[ECM_CONN_DIR_FLOW], sync->rx_byte_count[ECM_CONN_DIR_FLOW],
				  from_dev, br_dev,
				  smac, dmac,
				  src_ip, dst_ip,
				  sport, dport, tci, tpid);

		/*
		 * Sync the return direction (ovs-br1/ovs_br2 to eth1/eth2) based on the NAT case.
		 * All the flow parameters are reversed.
		 */
		ecm_classifier_ovs_stats_sync(&flow,
				  sync->tx_packet_count[ECM_CONN_DIR_FLOW], sync->tx_byte_count[ECM_CONN_DIR_FLOW],
				  br_dev, from_dev,
				  dmac, smac,
				  dst_ip, src_ip,
				  dport, sport, 0, 0);
		dev_put(br_dev);
	}

	if (to_dev) {
		/*
		 * to_dev = eth2/eth1 (can be tagged)
		 * br_dev = ovs-br2/ovs-br1 (untagged)
		 */
		br_dev = ecm_classifier_ovs_interface_get_and_ref(ci, ECM_DB_OBJ_DIR_TO, false);
		if (!br_dev) {
			DEBUG_WARN("%px: to_dev = %s is a OVS bridge port, bridge interface is not found\n",
					aci, to_dev->name);
			goto done;
		}

		/*
		 * Reset the tci and tpid values and get the egress side of the flow.
		 */
		tci = tpid = 0;
		if (ecvi->process_response.egress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			tci = ecvi->process_response.egress_vlan_tag[0] & 0xffff;
			tpid = (ecvi->process_response.egress_vlan_tag[0] >> 16) & 0xffff;
			DEBUG_TRACE("%px: Egress VLAN : %x:%x\n", aci, tci, tpid);
		}

		/*
		 * Sync the flow direction (ovs-br2/ovs_br1 to eth2/eth1) based on the NAT case.
		 */
		ether_addr_copy(smac, br_dev->dev_addr);
		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, dmac);

		/*
		 * If to_dev is a bridge port, src_ip_nat and src_port_nat satisfies all the NAT cases.
		 * So, we need to get the ECM_DB_OBJ_DIR_FROM_NAT direction's IP and port number from the connection.
		 */
		sport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_FROM_NAT));
		dport = htons(ecm_db_connection_port_get(ci, ECM_DB_OBJ_DIR_TO));

		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_FROM_NAT, src_ip);
		ecm_db_connection_address_get(ci, ECM_DB_OBJ_DIR_TO, dst_ip);

		ecm_classifier_ovs_stats_sync(&flow,
				  sync->tx_packet_count[ECM_CONN_DIR_RETURN], sync->tx_byte_count[ECM_CONN_DIR_RETURN],
				  br_dev, to_dev,
				  smac, dmac,
				  src_ip, dst_ip,
				  sport, dport, 0, 0);
		/*
		 * Sync the return direction (eth2/eth1 to ovs-br2/ovs-br1) based on the NAT case.
		 * All the flow parameters are reversed.
		 */
		ecm_classifier_ovs_stats_sync(&flow,
				  sync->rx_packet_count[ECM_CONN_DIR_RETURN], sync->rx_byte_count[ECM_CONN_DIR_RETURN],
				  to_dev, br_dev,
				  dmac, smac,
				  dst_ip, src_ip,
				  dport, sport, tci, tpid);
		dev_put(br_dev);
	}

done:
	ecm_db_connection_deref(ci);

	if (from_dev)
		dev_put(from_dev);
	if (to_dev)
		dev_put(to_dev);
}

/*
 * ecm_classifier_ovs_sync_to_v4()
 *	Front end is pushing accel engine state to us
 */
static void ecm_classifier_ovs_sync_to_v4(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_sync *sync)
{
	/*
	 * Nothing to update.
	 * We only care about flows that are actively being accelerated.
	 */
	if (!(sync->tx_packet_count[ECM_CONN_DIR_FLOW] || sync->tx_packet_count[ECM_CONN_DIR_RETURN])) {
		return;
	}

	/*
	 * Handle only the stats sync. We don't care about the evict or flush syncs.
	 */
	if (sync->reason != ECM_FRONT_END_IPV4_RULE_SYNC_REASON_STATS) {
		return;
	}

	/*
	 * Common sync_to function call.
	 */
	ecm_classifier_ovs_sync_to_stats(aci, sync);
}

/*
 * ecm_classifier_ovs_sync_from_v4()
 *	Front end is retrieving accel engine state from us
 */
static void ecm_classifier_ovs_sync_from_v4(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_create *ecrc)
{
	struct ecm_classifier_ovs_instance *ecvi __attribute__((unused));

	ecvi = (struct ecm_classifier_ovs_instance *)aci;
	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);
}

/*
 * ecm_classifier_ovs_sync_to_v6()
 *	Front end is pushing accel engine state to us
 */
static void ecm_classifier_ovs_sync_to_v6(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_sync *sync)
{
	/*
	 * Nothing to update.
	 * We only care about flows that are actively being accelerated.
	 */
	if (!(sync->tx_packet_count[ECM_CONN_DIR_FLOW] || sync->tx_packet_count[ECM_CONN_DIR_RETURN])) {
		return;
	}

	/*
	 * Handle only the stats sync. We don't care about the evict or flush syncs.
	 */
	if (sync->reason != ECM_FRONT_END_IPV6_RULE_SYNC_REASON_STATS) {
		return;
	}

	/*
	 * Common sync_to function call.
	 */
	ecm_classifier_ovs_sync_to_stats(aci, sync);
}

/*
 * ecm_classifier_ovs_sync_from_v6()
 *	Front end is retrieving accel engine state from us
 */
static void ecm_classifier_ovs_sync_from_v6(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_create *ecrc)
{
	struct ecm_classifier_ovs_instance *ecvi __attribute__((unused));

	ecvi = (struct ecm_classifier_ovs_instance *)aci;
	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);
}

#ifdef ECM_STATE_OUTPUT_ENABLE
/*
 * ecm_classifier_ovs_state_get()
 *	Gets the state of this classfier and outputs it to debugfs.
 */
static int ecm_classifier_ovs_state_get(struct ecm_classifier_instance *ci, struct ecm_state_file_instance *sfi)
{
	int result;
	struct ecm_classifier_ovs_instance *ecvi;
	struct ecm_classifier_process_response pr;

	ecvi = (struct ecm_classifier_ovs_instance *)ci;
	DEBUG_CHECK_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC, "%px: magic failed", ecvi);

	if ((result = ecm_state_prefix_add(sfi, "ovs"))) {
		return result;
	}

	spin_lock_bh(&ecm_classifier_ovs_lock);
	pr = ecvi->process_response;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	/*
	 * Output our last process response
	 */
	if ((result = ecm_classifier_process_response_state_get(sfi, &pr))) {
		goto done;
	}


	if (pr.process_actions & ECM_CLASSIFIER_PROCESS_ACTION_OVS_VLAN_TAG) {
#ifdef ECM_MULTICAST_ENABLE
		int i;
#endif
		/*
		 * TODO: Clean up the function later to print classifier
		 * specific data in each classifier’s state_get function.
		 */
		if (pr.ingress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			if ((result = ecm_state_write(sfi, "ingress_vlan_tag[0]", "0x%x", pr.ingress_vlan_tag[0]))) {
				goto done;
			}
		}

		if (pr.ingress_vlan_tag[1] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			if ((result = ecm_state_write(sfi, "ingress_vlan_tag[1]", "0x%x", pr.ingress_vlan_tag[1]))) {
				goto done;
			}
		}

		if (pr.egress_vlan_tag[0] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			if ((result = ecm_state_write(sfi, "egress_vlan_tag[0]", "0x%x", pr.egress_vlan_tag[0]))) {
				goto done;
			}
		}

		if (pr.egress_vlan_tag[1] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
			if ((result = ecm_state_write(sfi, "egress_vlan_tag[1]", "0x%x", pr.egress_vlan_tag[1]))) {
				goto done;
			}
		}

#ifdef ECM_MULTICAST_ENABLE
		for (i = 0; i < ECM_DB_MULTICAST_IF_MAX; i++) {
			struct net_device *dev;

			if (pr.egress_mc_vlan_tag[i][0] == ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
				continue;
			}

			dev = dev_get_by_index(&init_net, pr.egress_netdev_index[i]);
			if (dev) {
				if ((result = ecm_state_write(sfi, "port_egress", "%s", dev->name))) {
					dev_put(dev);
					goto done;
				}
				dev_put(dev);
			}

			if ((result = ecm_state_write(sfi, "port_egress_vlan_tag[0]", "0x%x", pr.egress_mc_vlan_tag[i][0]))) {
				goto done;
			}

			if (pr.egress_mc_vlan_tag[i][1] != ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED) {
				if ((result = ecm_state_write(sfi, "port_egress_vlan_tag[1]", "0x%x", pr.egress_mc_vlan_tag[i][1]))) {
					goto done;
				}
			}
		}
#endif
	}

done:
	ecm_state_prefix_remove(sfi);
	return result;
}
#endif

/*
 * ecm_classifier_ovs_instance_alloc()
 *	Allocate an instance of the ovs classifier
 */
struct ecm_classifier_ovs_instance *ecm_classifier_ovs_instance_alloc(struct ecm_db_connection_instance *ci)
{
	struct ecm_classifier_ovs_instance *ecvi;
#ifdef ECM_MULTICAST_ENABLE
	int i;
#endif

	/*
	 * Allocate the instance
	 */
	ecvi = (struct ecm_classifier_ovs_instance *)kzalloc(sizeof(struct ecm_classifier_ovs_instance), GFP_ATOMIC | __GFP_NOWARN);
	if (!ecvi) {
		DEBUG_WARN("i%px: Failed to allocate ovs Classifier instance\n", ci);
		return NULL;
	}

	DEBUG_SET_MAGIC(ecvi, ECM_CLASSIFIER_OVS_INSTANCE_MAGIC);
	ecvi->refs = 1;

	/*
	 * Methods generic to all classifiers.
	 */
	ecvi->base.process = ecm_classifier_ovs_process;
	ecvi->base.sync_from_v4 = ecm_classifier_ovs_sync_from_v4;
	ecvi->base.sync_to_v4 = ecm_classifier_ovs_sync_to_v4;
	ecvi->base.sync_from_v6 = ecm_classifier_ovs_sync_from_v6;
	ecvi->base.sync_to_v6 = ecm_classifier_ovs_sync_to_v6;
	ecvi->base.type_get = ecm_classifier_ovs_type_get;
	ecvi->base.reclassify_allowed = ecm_classifier_ovs_reclassify_allowed;
	ecvi->base.reclassify = ecm_classifier_ovs_reclassify;
	ecvi->base.last_process_response_get = ecm_classifier_ovs_last_process_response_get;
#ifdef ECM_STATE_OUTPUT_ENABLE
	ecvi->base.state_get = ecm_classifier_ovs_state_get;
#endif
	ecvi->base.ref = ecm_classifier_ovs_ref;
	ecvi->base.deref = ecm_classifier_ovs_deref;
	ecvi->ci_serial = ecm_db_connection_serial_get(ci);

	ecvi->process_response.process_actions = 0;
	ecvi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_MAYBE;
	ecvi->process_response.ingress_vlan_tag[0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
	ecvi->process_response.egress_vlan_tag[0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
	ecvi->process_response.ingress_vlan_tag[1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
	ecvi->process_response.egress_vlan_tag[1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;

#ifdef ECM_MULTICAST_ENABLE
	for (i = 0; i < ECM_DB_MULTICAST_IF_MAX; i++) {
		ecvi->process_response.egress_mc_vlan_tag[i][0] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
		ecvi->process_response.egress_mc_vlan_tag[i][1] = ECM_FRONT_END_VLAN_ID_NOT_CONFIGURED;
	}
#endif

	/*
	 * Final check if we are pending termination
	 */
	spin_lock_bh(&ecm_classifier_ovs_lock);
	if (ecm_classifier_ovs_terminate_pending) {
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		DEBUG_WARN("%px: Terminating\n", ci);
		kfree(ecvi);
		return NULL;
	}

	/*
	 * Link the new instance into our list at the head
	 */
	ecvi->next = ecm_classifier_ovs_instances;
	if (ecm_classifier_ovs_instances) {
		ecm_classifier_ovs_instances->prev = ecvi;
	}
	ecm_classifier_ovs_instances = ecvi;

	/*
	 * Increment stats
	 */
	ecm_classifier_ovs_count++;
	DEBUG_ASSERT(ecm_classifier_ovs_count > 0, "%px: ecm_classifier_ovs_count wrap for instance: %px\n", ci, ecvi);
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	DEBUG_INFO("%px: ovs classifier instance alloc: %px\n", ci, ecvi);
	return ecvi;
}
EXPORT_SYMBOL(ecm_classifier_ovs_instance_alloc);

/*
 * ecm_classifier_ovs_register_callbacks()
 */
int ecm_classifier_ovs_register_callbacks(struct ecm_classifier_ovs_callbacks *ovs_cbs)
{
	spin_lock_bh(&ecm_classifier_ovs_lock);

	if (unlikely(!ecm_classifier_ovs_enabled)) {
		spin_unlock_bh(&ecm_classifier_ovs_lock);
		return -1;
	}

	ovs.ovs_process = ovs_cbs->ovs_process;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	return 0;
}
EXPORT_SYMBOL(ecm_classifier_ovs_register_callbacks);

/*
 * ecm_classifier_ovs_unregister_callbacks()
 */
void ecm_classifier_ovs_unregister_callbacks(void)
{
	spin_lock_bh(&ecm_classifier_ovs_lock);
	ovs.ovs_process = NULL;
	spin_unlock_bh(&ecm_classifier_ovs_lock);
}
EXPORT_SYMBOL(ecm_classifier_ovs_unregister_callbacks);

/*
 * ecm_classifier_ovs_init()
 */
int ecm_classifier_ovs_init(struct dentry *dentry)
{
	DEBUG_INFO("ovs classifier Module init\n");

	ecm_classifier_ovs_dentry = debugfs_create_dir("ecm_classifier_ovs", dentry);
	if (!ecm_classifier_ovs_dentry) {
		DEBUG_ERROR("Failed to create ecm ovs directory in debugfs\n");
		return -1;
	}

	if (!debugfs_create_u32("enabled", S_IRUGO | S_IWUSR, ecm_classifier_ovs_dentry,
					(u32 *)&ecm_classifier_ovs_enabled)) {
		DEBUG_ERROR("Failed to create ovs enabled file in debugfs\n");
		debugfs_remove_recursive(ecm_classifier_ovs_dentry);
		return -1;
	}

	return 0;
}
EXPORT_SYMBOL(ecm_classifier_ovs_init);

/*
 * ecm_classifier_ovs_exit()
 */
void ecm_classifier_ovs_exit(void)
{
	DEBUG_INFO("ovs classifier Module exit\n");

	spin_lock_bh(&ecm_classifier_ovs_lock);
	ecm_classifier_ovs_terminate_pending = true;
	spin_unlock_bh(&ecm_classifier_ovs_lock);

	/*
	 * Remove the debugfs files recursively.
	 */
	if (ecm_classifier_ovs_dentry) {
		debugfs_remove_recursive(ecm_classifier_ovs_dentry);
	}

}
EXPORT_SYMBOL(ecm_classifier_ovs_exit);