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

 /*
  **************************************************************************
  * Copyright (c) 2014-2016, 2018, 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/module.h>
 #include <linux/of.h>
 #include <linux/debugfs.h>
 #include <linux/inet.h>
 #include <linux/etherdevice.h>
 #include <net/netfilter/nf_conntrack.h>
 #include <net/ip.h>
 #include <net/ipv6.h>
 /*
  * Debug output levels
  * 0 = OFF
  * 1 = ASSERTS / ERRORS
  * 2 = 1 + WARN
  * 3 = 2 + INFO
  * 4 = 3 + TRACE
  */
 #define DEBUG_LEVEL ECM_INIT_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_db.h"
 #include "ecm_front_end_ipv4.h"
 #ifdef ECM_IPV6_ENABLE
 #include "ecm_front_end_ipv6.h"
 #endif
 #include "ecm_front_end_common.h"
 #include "ecm_conntrack_notifier.h"

 enum ecm_front_end_type selected_front_end;

 int front_end_selection;
 module_param(front_end_selection, int, 0);
 MODULE_PARM_DESC(front_end_selection, "Select front end for ECM");

 struct dentry *ecm_dentry;	/* Dentry object for top level ecm debugfs directory */

 extern int ecm_db_init(struct dentry *dentry);
 extern void ecm_db_connection_defunct_all(void);
 extern void ecm_db_exit(void);

 extern int ecm_classifier_default_init(struct dentry *dentry);
 extern void ecm_classifier_default_exit(void);

 #ifdef ECM_CLASSIFIER_OVS_ENABLE
 extern int ecm_classifier_ovs_init(struct dentry *dentry);
 extern void ecm_classifier_ovs_exit(void);
 #endif

 #ifdef ECM_CLASSIFIER_MARK_ENABLE
 extern int ecm_classifier_mark_init(struct dentry *dentry);
 extern void ecm_classifier_mark_exit(void);
 #endif

 #ifdef ECM_CLASSIFIER_NL_ENABLE
 extern int ecm_classifier_nl_rules_init(struct dentry *dentry);
 extern void ecm_classifier_nl_rules_exit(void);
 #endif

 #ifdef ECM_CLASSIFIER_HYFI_ENABLE
 extern int ecm_classifier_hyfi_rules_init(struct dentry *dentry);
 extern void ecm_classifier_hyfi_rules_exit(void);
 #endif

 extern int ecm_interface_init(void);
 extern void ecm_interface_exit(void);

 #ifdef ECM_CLASSIFIER_DSCP_ENABLE
 extern int ecm_classifier_dscp_init(struct dentry *dentry);
 extern void ecm_classifier_dscp_exit(void);
 #endif

 #ifdef ECM_STATE_OUTPUT_ENABLE
 extern int ecm_state_init(struct dentry *dentry);
 extern void ecm_state_exit(void);
 #endif

 #ifdef ECM_CLASSIFIER_PCC_ENABLE
 extern int ecm_classifier_pcc_init(struct dentry *dentry);
 extern void ecm_classifier_pcc_exit(void);
 #endif

 #ifdef ECM_CLASSIFIER_EMESH_ENABLE
 extern int ecm_classifier_emesh_init(struct dentry *dentry);
 extern void ecm_classifier_emesh_exit(void);
 #endif
 #ifdef ECM_CLASSIFIER_MSCS_ENABLE
 extern int ecm_classifier_mscs_init(struct dentry *dentry);
 extern void ecm_classifier_mscs_exit(void);
 #endif

 /*
  * ecm_init()
  */
 static int __init ecm_init(void)
 {
 	int ret;

 	printk(KERN_INFO "ECM init\n");

 	selected_front_end = ecm_front_end_type_select();
 	if (selected_front_end == ECM_FRONT_END_TYPE_MAX) {
 		DEBUG_ERROR("Front-end couldn't be selected\n");
 		return -1;
 	}

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

 	ret = ecm_db_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_db;
 	}

 	ret = ecm_classifier_default_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_default;
 	}

 #ifdef ECM_CLASSIFIER_NL_ENABLE
 	ret = ecm_classifier_nl_rules_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_nl;
 	}
 #endif

 #ifdef ECM_CLASSIFIER_HYFI_ENABLE
 	ret = ecm_classifier_hyfi_rules_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_hyfi;
 	}
 #endif

 #ifdef ECM_CLASSIFIER_DSCP_ENABLE
 	ret = ecm_classifier_dscp_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_dscp;
 	}
 #endif

 #ifdef ECM_CLASSIFIER_PCC_ENABLE
 	ret = ecm_classifier_pcc_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_pcc;
 	}
 #endif
 #ifdef ECM_CLASSIFIER_MARK_ENABLE
 	ret = ecm_classifier_mark_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_mark;
 	}
 #endif

 #ifdef ECM_CLASSIFIER_OVS_ENABLE
 	ret = ecm_classifier_ovs_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_ovs;
 	}
 #endif

 #ifdef ECM_CLASSIFIER_EMESH_ENABLE
 	ret = ecm_classifier_emesh_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_emesh;
 	}
 #endif

 #ifdef ECM_CLASSIFIER_MSCS_ENABLE
 	ret = ecm_classifier_mscs_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_cls_mscs;
 	}
 #endif

 	ret = ecm_interface_init();
 	if (0 != ret) {
 		goto err_iface;
 	}

 #ifdef ECM_INTERFACE_BOND_ENABLE
 	ret = ecm_front_end_bond_notifier_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_bond;
 	}
 #endif

 	ret = ecm_front_end_ipv4_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_fe_ipv4;
 	}

 #ifdef ECM_IPV6_ENABLE
 	ret = ecm_front_end_ipv6_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_fe_ipv6;
 	}
 #endif

 	ret = ecm_conntrack_notifier_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_ct;
 	}

 #ifdef ECM_STATE_OUTPUT_ENABLE
 	ret = ecm_state_init(ecm_dentry);
 	if (0 != ret) {
 		goto err_state;
 	}
 #endif

 	ecm_front_end_common_sysctl_register();

 	printk(KERN_INFO "ECM init complete\n");
 	return 0;

 #ifdef ECM_STATE_OUTPUT_ENABLE
 err_state:
 	ecm_conntrack_notifier_exit();
 #endif
 err_ct:
 #ifdef ECM_IPV6_ENABLE
 	ecm_front_end_ipv6_exit();
 err_fe_ipv6:
 #endif
 	ecm_front_end_ipv4_exit();
 err_fe_ipv4:
 #ifdef ECM_INTERFACE_BOND_ENABLE
 	ecm_front_end_bond_notifier_exit();
 err_bond:
 #endif
 	ecm_interface_exit();
 err_iface:
 #ifdef ECM_CLASSIFIER_EMESH_ENABLE
 	ecm_classifier_emesh_exit();
 err_cls_emesh:
 #endif
 #ifdef ECM_CLASSIFIER_OVS_ENABLE
 	ecm_classifier_ovs_exit();
 err_cls_ovs:
 #endif
 #ifdef ECM_CLASSIFIER_MARK_ENABLE
 	ecm_classifier_mark_exit();
 err_cls_mark:
 #endif
 #ifdef ECM_CLASSIFIER_PCC_ENABLE
 	ecm_classifier_pcc_exit();
 err_cls_pcc:
 #endif
 #ifdef ECM_CLASSIFIER_DSCP_ENABLE
 	ecm_classifier_dscp_exit();
 err_cls_dscp:
 #endif
 #ifdef ECM_CLASSIFIER_HYFI_ENABLE
 	ecm_classifier_hyfi_rules_exit();
 err_cls_hyfi:
 #endif
 #ifdef ECM_CLASSIFIER_NL_ENABLE
 	ecm_classifier_nl_rules_exit();
 err_cls_nl:
 #endif
 #ifdef ECM_CLASSIFIER_MSCS_ENABLE
 	ecm_classifier_mscs_exit();
 err_cls_mscs:
 #endif
 	ecm_classifier_default_exit();
 err_cls_default:
 	ecm_db_exit();
 err_db:
 	debugfs_remove_recursive(ecm_dentry);

 	printk(KERN_INFO "ECM init failed: %d\n", ret);
 	return ret;
 }

 /*
  * ecm_exit()
  */
 static void __exit ecm_exit(void)
 {
 	printk(KERN_INFO "ECM exit\n");

 	/* call stop on anything that requires a prepare-to-exit signal */
 	DEBUG_INFO("stop conntrack notifier\n");
 	ecm_conntrack_notifier_stop(1);
 	DEBUG_INFO("stop front_end_ipv4\n");
 	ecm_front_end_ipv4_stop(1);
 #ifdef ECM_IPV6_ENABLE
 	DEBUG_INFO("stop front_end_ipv6\n");
 	ecm_front_end_ipv6_stop(1);
 #endif
 #ifdef ECM_INTERFACE_BOND_ENABLE
 	DEBUG_INFO("stop bond notifier\n");
 	ecm_front_end_bond_notifier_stop(1);
 #endif
 	DEBUG_INFO("defunct all db connections\n");
 	ecm_db_connection_defunct_all();

 	/* now call exit on each module */
 #ifdef ECM_STATE_OUTPUT_ENABLE
 	DEBUG_INFO("stop state\n");
 	ecm_state_exit();
 #endif
 	DEBUG_INFO("exit conntrack notifier\n");
 	ecm_conntrack_notifier_exit();
 	DEBUG_INFO("exit front_end_ipv4\n");
 	ecm_front_end_ipv4_exit();
 #ifdef ECM_IPV6_ENABLE
 	DEBUG_INFO("exit front_end_ipv6\n");
 	ecm_front_end_ipv6_exit();
 #endif
 #ifdef ECM_INTERFACE_BOND_ENABLE
 	DEBUG_INFO("exit bond notifier\n");
 	ecm_front_end_bond_notifier_exit();
 #endif
 	DEBUG_INFO("exit interface\n");
 	ecm_interface_exit();

 #ifdef ECM_CLASSIFIER_PCC_ENABLE
 	DEBUG_INFO("exit pcc classifier\n");
 	ecm_classifier_pcc_exit();
 #endif
 #ifdef ECM_CLASSIFIER_DSCP_ENABLE
 	DEBUG_INFO("exit dscp classifier\n");
 	ecm_classifier_dscp_exit();
 #endif
 #ifdef ECM_CLASSIFIER_HYFI_ENABLE
 	DEBUG_INFO("exit hyfi classifier\n");
 	ecm_classifier_hyfi_rules_exit();
 #endif
 #ifdef ECM_CLASSIFIER_NL_ENABLE
 	DEBUG_INFO("exit nl classifier\n");
 	ecm_classifier_nl_rules_exit();
 #endif
 #ifdef ECM_CLASSIFIER_MARK_ENABLE
 	DEBUG_INFO("exit mark classifier\n");
 	ecm_classifier_mark_exit();
 #endif
 #ifdef ECM_CLASSIFIER_OVS_ENABLE
 	DEBUG_INFO("exit ovs classifier\n");
 	ecm_classifier_ovs_exit();
 #endif
 #ifdef ECM_CLASSIFIER_EMESH_ENABLE
 	DEBUG_INFO("exit emesh classifier\n");
 	ecm_classifier_emesh_exit();
 #endif
 #ifdef ECM_CLASSIFIER_MSCS_ENABLE
 	DEBUG_INFO("exit mscs classifier\n");
 	ecm_classifier_mscs_exit();
 #endif
 	DEBUG_INFO("exit default classifier\n");
 	ecm_classifier_default_exit();
 	DEBUG_INFO("exit db\n");
 	ecm_db_exit();

 	if (ecm_dentry != NULL) {
 		DEBUG_INFO("remove ecm debugfs\n");
 		debugfs_remove_recursive(ecm_dentry);
 	}

 	ecm_front_end_common_sysctl_unregister();

 	printk(KERN_INFO "ECM exit complete\n");
 }

 module_init(ecm_init)
 module_exit(ecm_exit)

 MODULE_DESCRIPTION("ECM Core");
 MODULE_LICENSE("Dual BSD/GPL");
	/*
	**************************************************************************
	* Copyright (c) 2014-2016, 2018, 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/module.h>
	#include <linux/of.h>
	#include <linux/debugfs.h>
	#include <linux/inet.h>
	#include <linux/etherdevice.h>
	#include <net/netfilter/nf_conntrack.h>
	#include <net/ip.h>
	#include <net/ipv6.h>
	/*
	* Debug output levels
	* 0 = OFF
	* 1 = ASSERTS / ERRORS
	* 2 = 1 + WARN
	* 3 = 2 + INFO
	* 4 = 3 + TRACE
	*/
	#define DEBUG_LEVEL ECM_INIT_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_db.h"
	#include "ecm_front_end_ipv4.h"
	#ifdef ECM_IPV6_ENABLE
	#include "ecm_front_end_ipv6.h"
	#endif
	#include "ecm_front_end_common.h"
	#include "ecm_conntrack_notifier.h"

	enum ecm_front_end_type selected_front_end;

	int front_end_selection;
	module_param(front_end_selection, int, 0);
	MODULE_PARM_DESC(front_end_selection, "Select front end for ECM");

	struct dentry ecm_dentry; / Dentry object for top level ecm debugfs directory */

	extern int ecm_db_init(struct dentry *dentry);
	extern void ecm_db_connection_defunct_all(void);
	extern void ecm_db_exit(void);

	extern int ecm_classifier_default_init(struct dentry *dentry);
	extern void ecm_classifier_default_exit(void);

	#ifdef ECM_CLASSIFIER_OVS_ENABLE
	extern int ecm_classifier_ovs_init(struct dentry *dentry);
	extern void ecm_classifier_ovs_exit(void);
	#endif

	#ifdef ECM_CLASSIFIER_MARK_ENABLE
	extern int ecm_classifier_mark_init(struct dentry *dentry);
	extern void ecm_classifier_mark_exit(void);
	#endif

	#ifdef ECM_CLASSIFIER_NL_ENABLE
	extern int ecm_classifier_nl_rules_init(struct dentry *dentry);
	extern void ecm_classifier_nl_rules_exit(void);
	#endif

	#ifdef ECM_CLASSIFIER_HYFI_ENABLE
	extern int ecm_classifier_hyfi_rules_init(struct dentry *dentry);
	extern void ecm_classifier_hyfi_rules_exit(void);
	#endif

	extern int ecm_interface_init(void);
	extern void ecm_interface_exit(void);

	#ifdef ECM_CLASSIFIER_DSCP_ENABLE
	extern int ecm_classifier_dscp_init(struct dentry *dentry);
	extern void ecm_classifier_dscp_exit(void);
	#endif

	#ifdef ECM_STATE_OUTPUT_ENABLE
	extern int ecm_state_init(struct dentry *dentry);
	extern void ecm_state_exit(void);
	#endif

	#ifdef ECM_CLASSIFIER_PCC_ENABLE
	extern int ecm_classifier_pcc_init(struct dentry *dentry);
	extern void ecm_classifier_pcc_exit(void);
	#endif

	#ifdef ECM_CLASSIFIER_EMESH_ENABLE
	extern int ecm_classifier_emesh_init(struct dentry *dentry);
	extern void ecm_classifier_emesh_exit(void);
	#endif
	#ifdef ECM_CLASSIFIER_MSCS_ENABLE
	extern int ecm_classifier_mscs_init(struct dentry *dentry);
	extern void ecm_classifier_mscs_exit(void);
	#endif

	/*
	* ecm_init()
	*/
	static int __init ecm_init(void)
	{
	int ret;

	printk(KERN_INFO "ECM init\n");

	selected_front_end = ecm_front_end_type_select();
	if (selected_front_end == ECM_FRONT_END_TYPE_MAX) {
	DEBUG_ERROR("Front-end couldn't be selected\n");
	return -1;
	}

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

	ret = ecm_db_init(ecm_dentry);
	if (0 != ret) {
	goto err_db;
	}

	ret = ecm_classifier_default_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_default;
	}

	#ifdef ECM_CLASSIFIER_NL_ENABLE
	ret = ecm_classifier_nl_rules_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_nl;
	}
	#endif

	#ifdef ECM_CLASSIFIER_HYFI_ENABLE
	ret = ecm_classifier_hyfi_rules_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_hyfi;
	}
	#endif

	#ifdef ECM_CLASSIFIER_DSCP_ENABLE
	ret = ecm_classifier_dscp_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_dscp;
	}
	#endif

	#ifdef ECM_CLASSIFIER_PCC_ENABLE
	ret = ecm_classifier_pcc_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_pcc;
	}
	#endif
	#ifdef ECM_CLASSIFIER_MARK_ENABLE
	ret = ecm_classifier_mark_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_mark;
	}
	#endif

	#ifdef ECM_CLASSIFIER_OVS_ENABLE
	ret = ecm_classifier_ovs_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_ovs;
	}
	#endif

	#ifdef ECM_CLASSIFIER_EMESH_ENABLE
	ret = ecm_classifier_emesh_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_emesh;
	}
	#endif

	#ifdef ECM_CLASSIFIER_MSCS_ENABLE
	ret = ecm_classifier_mscs_init(ecm_dentry);
	if (0 != ret) {
	goto err_cls_mscs;
	}
	#endif

	ret = ecm_interface_init();
	if (0 != ret) {
	goto err_iface;
	}

	#ifdef ECM_INTERFACE_BOND_ENABLE
	ret = ecm_front_end_bond_notifier_init(ecm_dentry);
	if (0 != ret) {
	goto err_bond;
	}
	#endif

	ret = ecm_front_end_ipv4_init(ecm_dentry);
	if (0 != ret) {
	goto err_fe_ipv4;
	}

	#ifdef ECM_IPV6_ENABLE
	ret = ecm_front_end_ipv6_init(ecm_dentry);
	if (0 != ret) {
	goto err_fe_ipv6;
	}
	#endif

	ret = ecm_conntrack_notifier_init(ecm_dentry);
	if (0 != ret) {
	goto err_ct;
	}

	#ifdef ECM_STATE_OUTPUT_ENABLE
	ret = ecm_state_init(ecm_dentry);
	if (0 != ret) {
	goto err_state;
	}
	#endif

	ecm_front_end_common_sysctl_register();

	printk(KERN_INFO "ECM init complete\n");
	return 0;

	#ifdef ECM_STATE_OUTPUT_ENABLE
	err_state:
	ecm_conntrack_notifier_exit();
	#endif
	err_ct:
	#ifdef ECM_IPV6_ENABLE
	ecm_front_end_ipv6_exit();
	err_fe_ipv6:
	#endif
	ecm_front_end_ipv4_exit();
	err_fe_ipv4:
	#ifdef ECM_INTERFACE_BOND_ENABLE
	ecm_front_end_bond_notifier_exit();
	err_bond:
	#endif
	ecm_interface_exit();
	err_iface:
	#ifdef ECM_CLASSIFIER_EMESH_ENABLE
	ecm_classifier_emesh_exit();
	err_cls_emesh:
	#endif
	#ifdef ECM_CLASSIFIER_OVS_ENABLE
	ecm_classifier_ovs_exit();
	err_cls_ovs:
	#endif
	#ifdef ECM_CLASSIFIER_MARK_ENABLE
	ecm_classifier_mark_exit();
	err_cls_mark:
	#endif
	#ifdef ECM_CLASSIFIER_PCC_ENABLE
	ecm_classifier_pcc_exit();
	err_cls_pcc:
	#endif
	#ifdef ECM_CLASSIFIER_DSCP_ENABLE
	ecm_classifier_dscp_exit();
	err_cls_dscp:
	#endif
	#ifdef ECM_CLASSIFIER_HYFI_ENABLE
	ecm_classifier_hyfi_rules_exit();
	err_cls_hyfi:
	#endif
	#ifdef ECM_CLASSIFIER_NL_ENABLE
	ecm_classifier_nl_rules_exit();
	err_cls_nl:
	#endif
	#ifdef ECM_CLASSIFIER_MSCS_ENABLE
	ecm_classifier_mscs_exit();
	err_cls_mscs:
	#endif
	ecm_classifier_default_exit();
	err_cls_default:
	ecm_db_exit();
	err_db:
	debugfs_remove_recursive(ecm_dentry);

	printk(KERN_INFO "ECM init failed: %d\n", ret);
	return ret;
	}

	/*
	* ecm_exit()
	*/
	static void __exit ecm_exit(void)
	{
	printk(KERN_INFO "ECM exit\n");

	/* call stop on anything that requires a prepare-to-exit signal */
	DEBUG_INFO("stop conntrack notifier\n");
	ecm_conntrack_notifier_stop(1);
	DEBUG_INFO("stop front_end_ipv4\n");
	ecm_front_end_ipv4_stop(1);
	#ifdef ECM_IPV6_ENABLE
	DEBUG_INFO("stop front_end_ipv6\n");
	ecm_front_end_ipv6_stop(1);
	#endif
	#ifdef ECM_INTERFACE_BOND_ENABLE
	DEBUG_INFO("stop bond notifier\n");
	ecm_front_end_bond_notifier_stop(1);
	#endif
	DEBUG_INFO("defunct all db connections\n");
	ecm_db_connection_defunct_all();

	/* now call exit on each module */
	#ifdef ECM_STATE_OUTPUT_ENABLE
	DEBUG_INFO("stop state\n");
	ecm_state_exit();
	#endif
	DEBUG_INFO("exit conntrack notifier\n");
	ecm_conntrack_notifier_exit();
	DEBUG_INFO("exit front_end_ipv4\n");
	ecm_front_end_ipv4_exit();
	#ifdef ECM_IPV6_ENABLE
	DEBUG_INFO("exit front_end_ipv6\n");
	ecm_front_end_ipv6_exit();
	#endif
	#ifdef ECM_INTERFACE_BOND_ENABLE
	DEBUG_INFO("exit bond notifier\n");
	ecm_front_end_bond_notifier_exit();
	#endif
	DEBUG_INFO("exit interface\n");
	ecm_interface_exit();

	#ifdef ECM_CLASSIFIER_PCC_ENABLE
	DEBUG_INFO("exit pcc classifier\n");
	ecm_classifier_pcc_exit();
	#endif
	#ifdef ECM_CLASSIFIER_DSCP_ENABLE
	DEBUG_INFO("exit dscp classifier\n");
	ecm_classifier_dscp_exit();
	#endif
	#ifdef ECM_CLASSIFIER_HYFI_ENABLE
	DEBUG_INFO("exit hyfi classifier\n");
	ecm_classifier_hyfi_rules_exit();
	#endif
	#ifdef ECM_CLASSIFIER_NL_ENABLE
	DEBUG_INFO("exit nl classifier\n");
	ecm_classifier_nl_rules_exit();
	#endif
	#ifdef ECM_CLASSIFIER_MARK_ENABLE
	DEBUG_INFO("exit mark classifier\n");
	ecm_classifier_mark_exit();
	#endif
	#ifdef ECM_CLASSIFIER_OVS_ENABLE
	DEBUG_INFO("exit ovs classifier\n");
	ecm_classifier_ovs_exit();
	#endif
	#ifdef ECM_CLASSIFIER_EMESH_ENABLE
	DEBUG_INFO("exit emesh classifier\n");
	ecm_classifier_emesh_exit();
	#endif
	#ifdef ECM_CLASSIFIER_MSCS_ENABLE
	DEBUG_INFO("exit mscs classifier\n");
	ecm_classifier_mscs_exit();
	#endif
	DEBUG_INFO("exit default classifier\n");
	ecm_classifier_default_exit();
	DEBUG_INFO("exit db\n");
	ecm_db_exit();

	if (ecm_dentry != NULL) {
	DEBUG_INFO("remove ecm debugfs\n");
	debugfs_remove_recursive(ecm_dentry);
	}

	ecm_front_end_common_sysctl_unregister();

	printk(KERN_INFO "ECM exit complete\n");
	}

	module_init(ecm_init)
	module_exit(ecm_exit)

	MODULE_DESCRIPTION("ECM Core");
	MODULE_LICENSE("Dual BSD/GPL");