qca-nss-ecm/ecm_classifier_mscs.c - manifest_repos/sdk - Git at Google

 /*
  **************************************************************************
  * Copyright (c) 2020-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.
  **************************************************************************
  */

 #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/string.h>
 #include <net/route.h>
 #include <net/ip.h>
 #include <net/tcp.h>
 #include <asm/unaligned.h>
 #include <asm/uaccess.h>	/* for put_user */
 #include <net/ipv6.h>
 #include <linux/inet.h>
 #include <linux/in.h>
 #include <linux/udp.h>
 #include <linux/tcp.h>

 #include <linux/netfilter_ipv4.h>
 #include <linux/netfilter_bridge.h>
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_helper.h>
 #include <net/netfilter/nf_conntrack_l4proto.h>
 #include <net/netfilter/nf_conntrack_core.h>

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

 #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_udp.h"
 #include "ecm_tracker_tcp.h"
 #include "ecm_db.h"
 #include "ecm_classifier_mscs.h"
 #include "exports/ecm_classifier_mscs_public.h"

 /*
  * Magic numbers
  */
 #define ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC 0x1234

 /*
  * struct ecm_classifier_mscs_instance
  * 	State to allow tracking of MSCS QoS tag for a connection
  */
 struct ecm_classifier_mscs_instance {
 	struct ecm_classifier_instance base;			/* Base type */

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

 	uint32_t ci_serial;					/* RO: Serial of the connection */
 	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_mscs_enabled = 0;			/* Operational behaviour */

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

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

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

 /*
  * List of our classifier instances
  */
 static struct ecm_classifier_mscs_instance *ecm_classifier_mscs_instances;
 								/* list of all active instances */
 static int ecm_classifier_mscs_count;			/* Tracks number of instances allocated */

 /*
  * Callback structure to support MSCS peer lookup in external module
  */
 static struct ecm_classifier_mscs_callbacks ecm_mscs;

 /*
  * ecm_classifier_mscs_ref()
  *	Ref
  */
 static void ecm_classifier_mscs_ref(struct ecm_classifier_instance *ci)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;
 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;

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

 /*
  * ecm_classifier_mscs_deref()
  *	Deref
  */
 static int ecm_classifier_mscs_deref(struct ecm_classifier_instance *ci)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;
 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;

 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);
 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	cmscsi->refs--;
 	DEBUG_ASSERT(cmscsi->refs >= 0, "%px: refs wrapped\n", cmscsi);
 	DEBUG_TRACE("%px: MSCS classifier deref %d\n", cmscsi, cmscsi->refs);
 	if (cmscsi->refs) {
 		int refs = cmscsi->refs;
 		spin_unlock_bh(&ecm_classifier_mscs_lock);
 		return refs;
 	}

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

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

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

 	return 0;
 }

 /*
  * ecm_classifier_mscs_process()
  *	Process new data for connection
  */
 static void ecm_classifier_mscs_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_mscs_instance *cmscsi;
 	ecm_classifier_relevence_t relevance;
 	struct ecm_db_connection_instance *ci = NULL;
 	struct ecm_front_end_connection_instance *feci;
 	ecm_front_end_acceleration_mode_t accel_mode;
 	int protocol;
 	uint32_t became_relevant = 0;
 	ecm_classifier_mscs_process_callback_t cb = NULL;
 	ecm_classifier_mscs_result_t result = 0;
 	uint8_t smac[ETH_ALEN];
 	uint8_t dmac[ETH_ALEN];
 #ifdef ECM_MULTICAST_ENABLE
 	ip_addr_t dst_ip;
 #endif

 	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

 	/*
 	 * Are we yet to decide if this instance is relevant to the connection?
 	 */
 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	relevance = cmscsi->process_response.relevance;

 	/*
 	 * Are we relevant?
 	 */
 	if (relevance == ECM_CLASSIFIER_RELEVANCE_NO) {
 		/*
 		 * Lock still held
 		 */
 		goto mscs_classifier_out;
 	}

 	if (!ecm_classifier_mscs_enabled) {
 		/*
 		 * Lock still held
 		 */
 		cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
 		goto mscs_classifier_out;
 	}
 	spin_unlock_bh(&ecm_classifier_mscs_lock);

 	/*
 	 * Can we accelerate?
 	 */
 	ci = ecm_db_connection_serial_find_and_ref(cmscsi->ci_serial);
 	if (!ci) {
 		DEBUG_TRACE("%px: No ci found for %u\n", cmscsi, cmscsi->ci_serial);
 		spin_lock_bh(&ecm_classifier_mscs_lock);
 		cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
 		goto mscs_classifier_out;
 	}

 	feci = ecm_db_connection_front_end_get_and_ref(ci);
 	accel_mode = feci->accel_state_get(feci);
 	feci->deref(feci);
 	protocol = ecm_db_connection_protocol_get(ci);

 	/*
 	 * MSCS classifier is not applicable for Multicast Traffic
 	 */
 #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)) {
 		DEBUG_TRACE("%px: Multicast Traffic, skip MSCS classification\n", ci);
 		ecm_db_connection_deref(ci);
 		spin_lock_bh(&ecm_classifier_mscs_lock);
 		cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
 		goto mscs_classifier_out;
 	}
 #endif

 	/*
 	 * Get the source mac address for this connection
 	 */
 	if (sender == ECM_TRACKER_SENDER_TYPE_SRC) {
 		DEBUG_TRACE("%px: sender is SRC\n", aci);
 		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);
 	} else {
 		DEBUG_TRACE("%px: sender is DEST\n", aci);
 		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, smac);
 		ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, dmac);
 	}
 	ecm_db_connection_deref(ci);

 	spin_lock_bh(&ecm_classifier_mscs_lock);

 	/*
 	 * Get the WiFi datapath callback registered with MSCS client to check
 	 * if MSCS QoS tag is valid for WiFi peer corresponding to
 	 * skb->src_mac_addr
 	 */
 	cb = ecm_mscs.get_peer_priority;
 	if (!cb) {
 		cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
 		goto mscs_classifier_out;
 	}

 	spin_unlock_bh(&ecm_classifier_mscs_lock);

 	/*
 	 * Invoke callback registered to classifier for peer look up
 	 */
 	result = cb(smac, dmac, skb);

 	/*
 	 * check the result of callback
 	 */
 	if (result == ECM_CLASSIFIER_MSCS_RESULT_DENY_PRIORITY) {
 		spin_lock_bh(&ecm_classifier_mscs_lock);
 		cmscsi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
 		goto mscs_classifier_out;
 	}

 	/*
 	 * We are relevant to the connection
 	 */
 	became_relevant = ecm_db_time_get();
 	DEBUG_TRACE("MSCS Flow Priority: Flow priority: %d, Return priority: %d sender: %d\n",
 			skb->priority, skb->priority, sender);

 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
 	cmscsi->process_response.became_relevant = became_relevant;

 	cmscsi->process_response.process_actions = ECM_CLASSIFIER_PROCESS_ACTION_QOS_TAG;

 	if (result == ECM_CLASSIFIER_MSCS_RESULT_UPDATE_PRIORITY) {
 		cmscsi->process_response.flow_qos_tag = skb->priority;
 		cmscsi->process_response.return_qos_tag = skb->priority;
 	} else if (result == ECM_CLASSIFIER_MSCS_RESULT_UPDATE_INVALID_TAG) {
 		cmscsi->process_response.flow_qos_tag = ECM_CLASSIFIER_MSCS_INVALID_QOS_TAG;
 		cmscsi->process_response.return_qos_tag = ECM_CLASSIFIER_MSCS_INVALID_QOS_TAG;
 	}

 mscs_classifier_out:

 	/*
 	 * Return our process response
 	 */
 	*process_response = cmscsi->process_response;
 	spin_unlock_bh(&ecm_classifier_mscs_lock);
 }

 /*
  * ecm_classifier_mscs_sync_to_v4()
  *	Front end is pushing accel engine state to us
  */
 static void ecm_classifier_mscs_sync_to_v4(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_sync *sync)
 {
 	struct ecm_classifier_mscs_instance *cmscsi __attribute__((unused));

 	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
 }

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

 	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
 }

 /*
  * ecm_classifier_mscs_sync_to_v6()
  *	Front end is pushing accel engine state to us
  */
 static void ecm_classifier_mscs_sync_to_v6(struct ecm_classifier_instance *aci, struct ecm_classifier_rule_sync *sync)
 {
 	struct ecm_classifier_mscs_instance *cmscsi __attribute__((unused));

 	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
 }

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

 	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
 }

 /*
  * ecm_classifier_mscs_type_get()
  *	Get type of classifier this is
  */
 static ecm_classifier_type_t ecm_classifier_mscs_type_get(struct ecm_classifier_instance *ci)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;
 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;

 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);
 	return ECM_CLASSIFIER_TYPE_MSCS;
 }

 /*
  * ecm_classifier_mscs_last_process_response_get()
  *	Get result code returned by the last process call
  */
 static void ecm_classifier_mscs_last_process_response_get(struct ecm_classifier_instance *ci,
 							struct ecm_classifier_process_response *process_response)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;

 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	*process_response = cmscsi->process_response;
 	spin_unlock_bh(&ecm_classifier_mscs_lock);
 }

 /*
  * ecm_classifier_mscs_reclassify_allowed()
  *	Indicate if reclassify is allowed
  */
 static bool ecm_classifier_mscs_reclassify_allowed(struct ecm_classifier_instance *ci)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;
 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

 	return false;
 }

 /*
  * ecm_classifier_mscs_reclassify()
  *	Reclassify
  */
 static void ecm_classifier_mscs_reclassify(struct ecm_classifier_instance *ci)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;
 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

 }

 #ifdef ECM_STATE_OUTPUT_ENABLE
 /*
  * ecm_classifier_mscs_state_get()
  *	Return state
  */
 static int ecm_classifier_mscs_state_get(struct ecm_classifier_instance *ci, struct ecm_state_file_instance *sfi)
 {
 	int result;
 	struct ecm_classifier_mscs_instance *cmscsi;
 	struct ecm_classifier_process_response process_response;

 	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
 	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);

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

 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	process_response = cmscsi->process_response;
 	spin_unlock_bh(&ecm_classifier_mscs_lock);

 	/*
 	 * Output our last process response
 	 */
 	if ((result = ecm_classifier_process_response_state_get(sfi, &process_response))) {
 		return result;
 	}

 	return ecm_state_prefix_remove(sfi);
 }
 #endif

 /*
  * ecm_classifier_mscs_instance_alloc()
  *	Allocate an instance of the mscs classifier
  */
 struct ecm_classifier_mscs_instance *ecm_classifier_mscs_instance_alloc(struct ecm_db_connection_instance *ci)
 {
 	struct ecm_classifier_mscs_instance *cmscsi;

 	/*
 	 * Allocate the instance
 	 */
 	cmscsi = (struct ecm_classifier_mscs_instance *)kzalloc(sizeof(struct ecm_classifier_mscs_instance), GFP_ATOMIC | __GFP_NOWARN);
 	if (!cmscsi) {
 		DEBUG_WARN("Failed to allocate mscs instance\n");
 		return NULL;
 	}

 	DEBUG_SET_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC);
 	cmscsi->refs = 1;
 	cmscsi->base.process = ecm_classifier_mscs_process;
 	cmscsi->base.sync_from_v4 = ecm_classifier_mscs_sync_from_v4;
 	cmscsi->base.sync_to_v4 = ecm_classifier_mscs_sync_to_v4;
 	cmscsi->base.sync_from_v6 = ecm_classifier_mscs_sync_from_v6;
 	cmscsi->base.sync_to_v6 = ecm_classifier_mscs_sync_to_v6;
 	cmscsi->base.type_get = ecm_classifier_mscs_type_get;
 	cmscsi->base.last_process_response_get = ecm_classifier_mscs_last_process_response_get;
 	cmscsi->base.reclassify_allowed = ecm_classifier_mscs_reclassify_allowed;
 	cmscsi->base.reclassify = ecm_classifier_mscs_reclassify;
 #ifdef ECM_STATE_OUTPUT_ENABLE
 	cmscsi->base.state_get = ecm_classifier_mscs_state_get;
 #endif
 	cmscsi->base.ref = ecm_classifier_mscs_ref;
 	cmscsi->base.deref = ecm_classifier_mscs_deref;
 	cmscsi->ci_serial = ecm_db_connection_serial_get(ci);
 	cmscsi->process_response.process_actions = 0;
 	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_MAYBE;

 	spin_lock_bh(&ecm_classifier_mscs_lock);

 	/*
 	 * Final check if we are pending termination
 	 */
 	if (ecm_classifier_mscs_terminate_pending) {
 		spin_unlock_bh(&ecm_classifier_mscs_lock);
 		DEBUG_INFO("%px: Terminating\n", ci);
 		kfree(cmscsi);
 		return NULL;
 	}

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

 	/*
 	 * Increment stats
 	 */
 	ecm_classifier_mscs_count++;
 	DEBUG_ASSERT(ecm_classifier_mscs_count > 0, "%px: ecm_classifier_mscs_count wrap\n", cmscsi);
 	spin_unlock_bh(&ecm_classifier_mscs_lock);

 	DEBUG_INFO("mscs instance alloc: %px\n", cmscsi);
 	return cmscsi;
 }
 EXPORT_SYMBOL(ecm_classifier_mscs_instance_alloc);

 /*
  * ecm_classifier_mscs_rul_get_enabled()
  */
 static int ecm_classifier_mscs_rule_get_enabled(void *data, u64 *val)
 {
 	*val = ecm_classifier_mscs_enabled;

 	return 0;
 }

 /*
  * ecm_classifier_mscs_rule_set_enabled()
  */
 static int ecm_classifier_mscs_rule_set_enabled(void *data, u64 val)
 {
 	DEBUG_TRACE("ecm_classifier_mscs_enabled = %u\n", (uint32_t)val);

 	if ((val != 0) && (val != 1)) {
 		DEBUG_WARN("Invalid value: %u. Valid values are 0 and 1.\n", (uint32_t)val);
 		return -EINVAL;
 	}

 	ecm_classifier_mscs_enabled = (uint32_t)val;

 	return 0;
 }

 /*
  * Debugfs attribute for Emesh Enabled parameter.
  */
 DEFINE_SIMPLE_ATTRIBUTE(ecm_classifier_mscs_enabled_fops, ecm_classifier_mscs_rule_get_enabled, ecm_classifier_mscs_rule_set_enabled, "%llu\n");

 /*
  * ecm_interface_ovpn_register
  */
 int ecm_classifier_mscs_callback_register(struct ecm_classifier_mscs_callbacks *mscs_cb)
 {
 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	if (ecm_mscs.get_peer_priority) {
 		spin_unlock_bh(&ecm_classifier_mscs_lock);
 		DEBUG_ERROR("MSCS callbacks are registered\n");
 		return -1;
 	}

 	ecm_mscs.get_peer_priority = mscs_cb->get_peer_priority;
 	spin_unlock_bh(&ecm_classifier_mscs_lock);

 	return 0;
 }
 EXPORT_SYMBOL(ecm_classifier_mscs_callback_register);

 /*
  * ecm_interface_ovpn_unregister
  */
 void ecm_classifier_mscs_callback_unregister (void)
 {
 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	ecm_mscs.get_peer_priority = NULL;
 	spin_unlock_bh(&ecm_classifier_mscs_lock);
 }
 EXPORT_SYMBOL(ecm_classifier_mscs_callback_unregister);

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

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

 	if (!debugfs_create_file("enabled", S_IRUGO | S_IWUSR, ecm_classifier_mscs_dentry,
 				NULL, &ecm_classifier_mscs_enabled_fops)) {
 		DEBUG_ERROR("Failed to create ecm nl classifier enabled file in debugfs\n");
 		debugfs_remove_recursive(ecm_classifier_mscs_dentry);
 		return -1;
 	}

 	return 0;
 }
 EXPORT_SYMBOL(ecm_classifier_mscs_init);

 /*
  * ecm_classifier_mscs_exit()
  */
 void ecm_classifier_mscs_exit(void)
 {
 	DEBUG_INFO("mscs classifier Module exit\n");

 	spin_lock_bh(&ecm_classifier_mscs_lock);
 	ecm_classifier_mscs_terminate_pending = true;
 	spin_unlock_bh(&ecm_classifier_mscs_lock);

 	/*
 	 * Remove the debugfs files recursively.
 	 */
 	if (ecm_classifier_mscs_dentry) {
 		debugfs_remove_recursive(ecm_classifier_mscs_dentry);
 	}
 }
 EXPORT_SYMBOL(ecm_classifier_mscs_exit);
	/*
	**************************************************************************
	* Copyright (c) 2020-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.
	**************************************************************************
	*/

	#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/string.h>
	#include <net/route.h>
	#include <net/ip.h>
	#include <net/tcp.h>
	#include <asm/unaligned.h>
	#include <asm/uaccess.h> /* for put_user */
	#include <net/ipv6.h>
	#include <linux/inet.h>
	#include <linux/in.h>
	#include <linux/udp.h>
	#include <linux/tcp.h>

	#include <linux/netfilter_ipv4.h>
	#include <linux/netfilter_bridge.h>
	#include <net/netfilter/nf_conntrack.h>
	#include <net/netfilter/nf_conntrack_helper.h>
	#include <net/netfilter/nf_conntrack_l4proto.h>
	#include <net/netfilter/nf_conntrack_core.h>

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

	#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_udp.h"
	#include "ecm_tracker_tcp.h"
	#include "ecm_db.h"
	#include "ecm_classifier_mscs.h"
	#include "exports/ecm_classifier_mscs_public.h"

	/*
	* Magic numbers
	*/
	#define ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC 0x1234

	/*
	* struct ecm_classifier_mscs_instance
	* State to allow tracking of MSCS QoS tag for a connection
	*/
	struct ecm_classifier_mscs_instance {
	struct ecm_classifier_instance base; /* Base type */

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

	uint32_t ci_serial; /* RO: Serial of the connection */
	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_mscs_enabled = 0; /* Operational behaviour */

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

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

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

	/*
	* List of our classifier instances
	*/
	static struct ecm_classifier_mscs_instance *ecm_classifier_mscs_instances;
	/* list of all active instances */
	static int ecm_classifier_mscs_count; /* Tracks number of instances allocated */

	/*
	* Callback structure to support MSCS peer lookup in external module
	*/
	static struct ecm_classifier_mscs_callbacks ecm_mscs;

	/*
	* ecm_classifier_mscs_ref()
	* Ref
	*/
	static void ecm_classifier_mscs_ref(struct ecm_classifier_instance *ci)
	{
	struct ecm_classifier_mscs_instance *cmscsi;
	cmscsi = (struct ecm_classifier_mscs_instance *)ci;

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

	/*
	* ecm_classifier_mscs_deref()
	* Deref
	*/
	static int ecm_classifier_mscs_deref(struct ecm_classifier_instance *ci)
	{
	struct ecm_classifier_mscs_instance *cmscsi;
	cmscsi = (struct ecm_classifier_mscs_instance *)ci;

	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);
	spin_lock_bh(&ecm_classifier_mscs_lock);
	cmscsi->refs--;
	DEBUG_ASSERT(cmscsi->refs >= 0, "%px: refs wrapped\n", cmscsi);
	DEBUG_TRACE("%px: MSCS classifier deref %d\n", cmscsi, cmscsi->refs);
	if (cmscsi->refs) {
	int refs = cmscsi->refs;
	spin_unlock_bh(&ecm_classifier_mscs_lock);
	return refs;
	}

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

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

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

	return 0;
	}

	/*
	* ecm_classifier_mscs_process()
	* Process new data for connection
	*/
	static void ecm_classifier_mscs_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_mscs_instance *cmscsi;
	ecm_classifier_relevence_t relevance;
	struct ecm_db_connection_instance *ci = NULL;
	struct ecm_front_end_connection_instance *feci;
	ecm_front_end_acceleration_mode_t accel_mode;
	int protocol;
	uint32_t became_relevant = 0;
	ecm_classifier_mscs_process_callback_t cb = NULL;
	ecm_classifier_mscs_result_t result = 0;
	uint8_t smac[ETH_ALEN];
	uint8_t dmac[ETH_ALEN];
	#ifdef ECM_MULTICAST_ENABLE
	ip_addr_t dst_ip;
	#endif

	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

	/*
	* Are we yet to decide if this instance is relevant to the connection?
	*/
	spin_lock_bh(&ecm_classifier_mscs_lock);
	relevance = cmscsi->process_response.relevance;

	/*
	* Are we relevant?
	*/
	if (relevance == ECM_CLASSIFIER_RELEVANCE_NO) {
	/*
	* Lock still held
	*/
	goto mscs_classifier_out;
	}

	if (!ecm_classifier_mscs_enabled) {
	/*
	* Lock still held
	*/
	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
	goto mscs_classifier_out;
	}
	spin_unlock_bh(&ecm_classifier_mscs_lock);

	/*
	* Can we accelerate?
	*/
	ci = ecm_db_connection_serial_find_and_ref(cmscsi->ci_serial);
	if (!ci) {
	DEBUG_TRACE("%px: No ci found for %u\n", cmscsi, cmscsi->ci_serial);
	spin_lock_bh(&ecm_classifier_mscs_lock);
	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
	goto mscs_classifier_out;
	}

	feci = ecm_db_connection_front_end_get_and_ref(ci);
	accel_mode = feci->accel_state_get(feci);
	feci->deref(feci);
	protocol = ecm_db_connection_protocol_get(ci);

	/*
	* MSCS classifier is not applicable for Multicast Traffic
	*/
	#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)) {
	DEBUG_TRACE("%px: Multicast Traffic, skip MSCS classification\n", ci);
	ecm_db_connection_deref(ci);
	spin_lock_bh(&ecm_classifier_mscs_lock);
	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
	goto mscs_classifier_out;
	}
	#endif

	/*
	* Get the source mac address for this connection
	*/
	if (sender == ECM_TRACKER_SENDER_TYPE_SRC) {
	DEBUG_TRACE("%px: sender is SRC\n", aci);
	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);
	} else {
	DEBUG_TRACE("%px: sender is DEST\n", aci);
	ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_TO, smac);
	ecm_db_connection_node_address_get(ci, ECM_DB_OBJ_DIR_FROM, dmac);
	}
	ecm_db_connection_deref(ci);

	spin_lock_bh(&ecm_classifier_mscs_lock);

	/*
	* Get the WiFi datapath callback registered with MSCS client to check
	* if MSCS QoS tag is valid for WiFi peer corresponding to
	* skb->src_mac_addr
	*/
	cb = ecm_mscs.get_peer_priority;
	if (!cb) {
	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_NO;
	goto mscs_classifier_out;
	}

	spin_unlock_bh(&ecm_classifier_mscs_lock);

	/*
	* Invoke callback registered to classifier for peer look up
	*/
	result = cb(smac, dmac, skb);

	/*
	* check the result of callback
	*/
	if (result == ECM_CLASSIFIER_MSCS_RESULT_DENY_PRIORITY) {
	spin_lock_bh(&ecm_classifier_mscs_lock);
	cmscsi->process_response.accel_mode = ECM_CLASSIFIER_ACCELERATION_MODE_NO;
	goto mscs_classifier_out;
	}

	/*
	* We are relevant to the connection
	*/
	became_relevant = ecm_db_time_get();
	DEBUG_TRACE("MSCS Flow Priority: Flow priority: %d, Return priority: %d sender: %d\n",
	skb->priority, skb->priority, sender);

	spin_lock_bh(&ecm_classifier_mscs_lock);
	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_YES;
	cmscsi->process_response.became_relevant = became_relevant;

	cmscsi->process_response.process_actions = ECM_CLASSIFIER_PROCESS_ACTION_QOS_TAG;

	if (result == ECM_CLASSIFIER_MSCS_RESULT_UPDATE_PRIORITY) {
	cmscsi->process_response.flow_qos_tag = skb->priority;
	cmscsi->process_response.return_qos_tag = skb->priority;
	} else if (result == ECM_CLASSIFIER_MSCS_RESULT_UPDATE_INVALID_TAG) {
	cmscsi->process_response.flow_qos_tag = ECM_CLASSIFIER_MSCS_INVALID_QOS_TAG;
	cmscsi->process_response.return_qos_tag = ECM_CLASSIFIER_MSCS_INVALID_QOS_TAG;
	}

	mscs_classifier_out:

	/*
	* Return our process response
	*/
	*process_response = cmscsi->process_response;
	spin_unlock_bh(&ecm_classifier_mscs_lock);
	}

	/*
	* ecm_classifier_mscs_sync_to_v4()
	* Front end is pushing accel engine state to us
	*/
	static void ecm_classifier_mscs_sync_to_v4(struct ecm_classifier_instance aci, struct ecm_classifier_rule_sync sync)
	{
	struct ecm_classifier_mscs_instance *cmscsi __attribute__((unused));

	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
	}

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

	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
	}

	/*
	* ecm_classifier_mscs_sync_to_v6()
	* Front end is pushing accel engine state to us
	*/
	static void ecm_classifier_mscs_sync_to_v6(struct ecm_classifier_instance aci, struct ecm_classifier_rule_sync sync)
	{
	struct ecm_classifier_mscs_instance *cmscsi __attribute__((unused));

	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
	}

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

	cmscsi = (struct ecm_classifier_mscs_instance *)aci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);
	}

	/*
	* ecm_classifier_mscs_type_get()
	* Get type of classifier this is
	*/
	static ecm_classifier_type_t ecm_classifier_mscs_type_get(struct ecm_classifier_instance *ci)
	{
	struct ecm_classifier_mscs_instance *cmscsi;
	cmscsi = (struct ecm_classifier_mscs_instance *)ci;

	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);
	return ECM_CLASSIFIER_TYPE_MSCS;
	}

	/*
	* ecm_classifier_mscs_last_process_response_get()
	* Get result code returned by the last process call
	*/
	static void ecm_classifier_mscs_last_process_response_get(struct ecm_classifier_instance *ci,
	struct ecm_classifier_process_response *process_response)
	{
	struct ecm_classifier_mscs_instance *cmscsi;

	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

	spin_lock_bh(&ecm_classifier_mscs_lock);
	*process_response = cmscsi->process_response;
	spin_unlock_bh(&ecm_classifier_mscs_lock);
	}

	/*
	* ecm_classifier_mscs_reclassify_allowed()
	* Indicate if reclassify is allowed
	*/
	static bool ecm_classifier_mscs_reclassify_allowed(struct ecm_classifier_instance *ci)
	{
	struct ecm_classifier_mscs_instance *cmscsi;
	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

	return false;
	}

	/*
	* ecm_classifier_mscs_reclassify()
	* Reclassify
	*/
	static void ecm_classifier_mscs_reclassify(struct ecm_classifier_instance *ci)
	{
	struct ecm_classifier_mscs_instance *cmscsi;
	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed\n", cmscsi);

	}

	#ifdef ECM_STATE_OUTPUT_ENABLE
	/*
	* ecm_classifier_mscs_state_get()
	* Return state
	*/
	static int ecm_classifier_mscs_state_get(struct ecm_classifier_instance ci, struct ecm_state_file_instance sfi)
	{
	int result;
	struct ecm_classifier_mscs_instance *cmscsi;
	struct ecm_classifier_process_response process_response;

	cmscsi = (struct ecm_classifier_mscs_instance *)ci;
	DEBUG_CHECK_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC, "%px: magic failed", cmscsi);

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

	spin_lock_bh(&ecm_classifier_mscs_lock);
	process_response = cmscsi->process_response;
	spin_unlock_bh(&ecm_classifier_mscs_lock);

	/*
	* Output our last process response
	*/
	if ((result = ecm_classifier_process_response_state_get(sfi, &process_response))) {
	return result;
	}

	return ecm_state_prefix_remove(sfi);
	}
	#endif

	/*
	* ecm_classifier_mscs_instance_alloc()
	* Allocate an instance of the mscs classifier
	*/
	struct ecm_classifier_mscs_instance ecm_classifier_mscs_instance_alloc(struct ecm_db_connection_instance ci)
	{
	struct ecm_classifier_mscs_instance *cmscsi;

	/*
	* Allocate the instance
	*/
	cmscsi = (struct ecm_classifier_mscs_instance *)kzalloc(sizeof(struct ecm_classifier_mscs_instance), GFP_ATOMIC \| __GFP_NOWARN);
	if (!cmscsi) {
	DEBUG_WARN("Failed to allocate mscs instance\n");
	return NULL;
	}

	DEBUG_SET_MAGIC(cmscsi, ECM_CLASSIFIER_MSCS_INSTANCE_MAGIC);
	cmscsi->refs = 1;
	cmscsi->base.process = ecm_classifier_mscs_process;
	cmscsi->base.sync_from_v4 = ecm_classifier_mscs_sync_from_v4;
	cmscsi->base.sync_to_v4 = ecm_classifier_mscs_sync_to_v4;
	cmscsi->base.sync_from_v6 = ecm_classifier_mscs_sync_from_v6;
	cmscsi->base.sync_to_v6 = ecm_classifier_mscs_sync_to_v6;
	cmscsi->base.type_get = ecm_classifier_mscs_type_get;
	cmscsi->base.last_process_response_get = ecm_classifier_mscs_last_process_response_get;
	cmscsi->base.reclassify_allowed = ecm_classifier_mscs_reclassify_allowed;
	cmscsi->base.reclassify = ecm_classifier_mscs_reclassify;
	#ifdef ECM_STATE_OUTPUT_ENABLE
	cmscsi->base.state_get = ecm_classifier_mscs_state_get;
	#endif
	cmscsi->base.ref = ecm_classifier_mscs_ref;
	cmscsi->base.deref = ecm_classifier_mscs_deref;
	cmscsi->ci_serial = ecm_db_connection_serial_get(ci);
	cmscsi->process_response.process_actions = 0;
	cmscsi->process_response.relevance = ECM_CLASSIFIER_RELEVANCE_MAYBE;

	spin_lock_bh(&ecm_classifier_mscs_lock);

	/*
	* Final check if we are pending termination
	*/
	if (ecm_classifier_mscs_terminate_pending) {
	spin_unlock_bh(&ecm_classifier_mscs_lock);
	DEBUG_INFO("%px: Terminating\n", ci);
	kfree(cmscsi);
	return NULL;
	}

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

	/*
	* Increment stats
	*/
	ecm_classifier_mscs_count++;
	DEBUG_ASSERT(ecm_classifier_mscs_count > 0, "%px: ecm_classifier_mscs_count wrap\n", cmscsi);
	spin_unlock_bh(&ecm_classifier_mscs_lock);

	DEBUG_INFO("mscs instance alloc: %px\n", cmscsi);
	return cmscsi;
	}
	EXPORT_SYMBOL(ecm_classifier_mscs_instance_alloc);

	/*
	* ecm_classifier_mscs_rul_get_enabled()
	*/
	static int ecm_classifier_mscs_rule_get_enabled(void data, u64 val)
	{
	*val = ecm_classifier_mscs_enabled;

	return 0;
	}

	/*
	* ecm_classifier_mscs_rule_set_enabled()
	*/
	static int ecm_classifier_mscs_rule_set_enabled(void *data, u64 val)
	{
	DEBUG_TRACE("ecm_classifier_mscs_enabled = %u\n", (uint32_t)val);

	if ((val != 0) && (val != 1)) {
	DEBUG_WARN("Invalid value: %u. Valid values are 0 and 1.\n", (uint32_t)val);
	return -EINVAL;
	}

	ecm_classifier_mscs_enabled = (uint32_t)val;

	return 0;
	}

	/*
	* Debugfs attribute for Emesh Enabled parameter.
	*/
	DEFINE_SIMPLE_ATTRIBUTE(ecm_classifier_mscs_enabled_fops, ecm_classifier_mscs_rule_get_enabled, ecm_classifier_mscs_rule_set_enabled, "%llu\n");

	/*
	* ecm_interface_ovpn_register
	*/
	int ecm_classifier_mscs_callback_register(struct ecm_classifier_mscs_callbacks *mscs_cb)
	{
	spin_lock_bh(&ecm_classifier_mscs_lock);
	if (ecm_mscs.get_peer_priority) {
	spin_unlock_bh(&ecm_classifier_mscs_lock);
	DEBUG_ERROR("MSCS callbacks are registered\n");
	return -1;
	}

	ecm_mscs.get_peer_priority = mscs_cb->get_peer_priority;
	spin_unlock_bh(&ecm_classifier_mscs_lock);

	return 0;
	}
	EXPORT_SYMBOL(ecm_classifier_mscs_callback_register);

	/*
	* ecm_interface_ovpn_unregister
	*/
	void ecm_classifier_mscs_callback_unregister (void)
	{
	spin_lock_bh(&ecm_classifier_mscs_lock);
	ecm_mscs.get_peer_priority = NULL;
	spin_unlock_bh(&ecm_classifier_mscs_lock);
	}
	EXPORT_SYMBOL(ecm_classifier_mscs_callback_unregister);

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

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

	if (!debugfs_create_file("enabled", S_IRUGO \| S_IWUSR, ecm_classifier_mscs_dentry,
	NULL, &ecm_classifier_mscs_enabled_fops)) {
	DEBUG_ERROR("Failed to create ecm nl classifier enabled file in debugfs\n");
	debugfs_remove_recursive(ecm_classifier_mscs_dentry);
	return -1;
	}

	return 0;
	}
	EXPORT_SYMBOL(ecm_classifier_mscs_init);

	/*
	* ecm_classifier_mscs_exit()
	*/
	void ecm_classifier_mscs_exit(void)
	{
	DEBUG_INFO("mscs classifier Module exit\n");

	spin_lock_bh(&ecm_classifier_mscs_lock);
	ecm_classifier_mscs_terminate_pending = true;
	spin_unlock_bh(&ecm_classifier_mscs_lock);

	/*
	* Remove the debugfs files recursively.
	*/
	if (ecm_classifier_mscs_dentry) {
	debugfs_remove_recursive(ecm_classifier_mscs_dentry);
	}
	}
	EXPORT_SYMBOL(ecm_classifier_mscs_exit);