qca-nss-clients/nss_qdisc/nss_tbl.c - manifest_repos/sdk - Git at Google

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

 #include "nss_qdisc.h"

 struct nss_tbl_sched_data {
 	struct nss_qdisc nq;	/* Common base class for all nss qdiscs */
 	u32 rate;		/* Limiting rate of TBL */
 	u32 peakrate;		/* Maximum rate to control bursts */
 	u32 burst;		/* Maximum allowed burst size */
 	u32 mtu;		/* MTU of the interface attached to */
 	struct Qdisc *qdisc;	/* Qdisc to which it is attached to */
 };

 static struct nla_policy nss_tbl_policy[TCA_NSSTBL_MAX + 1] = {
 	[TCA_NSSTBL_PARMS] = { .len = sizeof(struct tc_nsstbl_qopt) },
 };

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
 static int nss_tbl_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 #else
 static int nss_tbl_enqueue(struct sk_buff *skb, struct Qdisc *sch,
 				struct sk_buff **to_free)
 #endif
 {
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
 	return nss_qdisc_enqueue(skb, sch);
 #else
 	return nss_qdisc_enqueue(skb, sch, to_free);
 #endif
 }

 static struct sk_buff *nss_tbl_dequeue(struct Qdisc *sch)
 {
 	return nss_qdisc_dequeue(sch);
 }

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
 static unsigned int nss_tbl_drop(struct Qdisc *sch)
 {
 	return nss_qdisc_drop(sch);
 }
 #endif

 static struct sk_buff *nss_tbl_peek(struct Qdisc *sch)
 {
 	return nss_qdisc_peek(sch);
 }

 static void nss_tbl_reset(struct Qdisc *sch)
 {
 	nss_qdisc_reset(sch);
 }

 static void nss_tbl_destroy(struct Qdisc *sch)
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	struct nss_qdisc *nq_child = (struct nss_qdisc *)qdisc_priv(q->qdisc);
 	struct nss_if_msg nim;

 	/*
 	 * We must always detach our child node in NSS before destroying it.
 	 * Also, we make sure we dont send down the command for noop qdiscs.
 	 */
 	if (q->qdisc != &noop_qdisc) {
 		nim.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
 		if (nss_qdisc_node_detach(&q->nq, nq_child, &nim,
 				NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_DETACH) < 0) {
 			nss_qdisc_error("Failed to detach child %x from nss_tbl %x\n",
 					q->qdisc->handle, q->nq.qos_tag);
 			return;
 		}
 	}

 	/*
 	 * Now we can destroy our child qdisc
 	 */
 	 nss_qdisc_put(q->qdisc);

 	/*
 	 * Stop the polling of basic stats and destroy qdisc.
 	 */
 	nss_qdisc_stop_basic_stats_polling(&q->nq);
 	nss_qdisc_destroy(&q->nq);
 }

 #if defined(NSS_QDISC_PPE_SUPPORT)
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 static int nss_tbl_ppe_change(struct Qdisc *sch, struct nlattr *opt)
 #else
 static int nss_tbl_ppe_change(struct Qdisc *sch, struct nlattr *opt, struct netlink_ext_ack *extack)
 #endif
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	struct nss_qdisc *nq = &q->nq;
 	struct nss_ppe_qdisc prev_npq;

 	/*
 	 * Save previous configuration for reset purpose
 	 */
 	if (nq->npq.is_configured) {
 		prev_npq = nq->npq;
 	}

 	nq->npq.shaper_present = true;
 	nq->npq.shaper.rate = q->rate;
 	nq->npq.shaper.burst = q->burst;
 	nq->npq.shaper.crate = q->rate;
 	nq->npq.shaper.cburst = q->burst;
 	nq->npq.shaper.overhead = 0;

 	if (nss_ppe_configure(nq, &prev_npq) != 0) {
 		nss_qdisc_warning("nss_tbl %x SSDK scheduler configuration failed\n", sch->handle);
 		goto fail;
 	}

 	return 0;

 fail:
 	if (nq->npq.is_configured) {
 		nss_qdisc_warning("nss_tbl %x SSDK scheduler configuration failed\n", sch->handle);
 		return -EINVAL;
 	}

 	/*
 	 * PPE qdisc config failed, try to initialize in NSS.
 	 */
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 	if (nss_ppe_fallback_to_nss(nq, opt)) {
 #else
 	if (nss_ppe_fallback_to_nss(nq, opt, extack)) {
 #endif
 	nss_qdisc_warning("nss_tbl %x fallback to nss failed\n", sch->handle);
 		return -EINVAL;
 	}

 	return 0;
 }
 #endif

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 static int nss_tbl_change(struct Qdisc *sch, struct nlattr *opt)
 #else
 static int nss_tbl_change(struct Qdisc *sch, struct nlattr *opt,
 				struct netlink_ext_ack *extack)
 #endif
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	struct nlattr *tb[TCA_NSSTBL_MAX + 1];
 	struct tc_nsstbl_qopt *qopt;
 	struct nss_if_msg nim;
 	struct net_device *dev = qdisc_dev(sch);

 	if (!opt) {
 		return -EINVAL;
 	}

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS);
 #else
 	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS, extack);
 #endif
 	if (!qopt) {
 		return -EINVAL;
 	}

 	/*
 	 * Set MTU if it wasn't specified explicitely
 	 */
 	if (!qopt->mtu) {
 		qopt->mtu = psched_mtu(dev);
 		nss_qdisc_info("MTU not provided for nss_tbl. Setting it to %s's default %u bytes\n", dev->name, qopt->mtu);
 	}

 	/*
 	 * Burst size cannot be less than MTU
 	 */
 	if (qopt->burst < qopt->mtu) {
 		nss_qdisc_error("Burst size: %u is less than the specified MTU: %u\n", qopt->burst, qopt->mtu);
 		return -EINVAL;
 	}

 	/*
 	 * Rate can be zero. Therefore we dont do a check on it.
 	 */
 	q->rate = qopt->rate;
 	nss_qdisc_info("Rate = %u", qopt->rate);
 	q->burst = qopt->burst;
 	nss_qdisc_info("Burst = %u", qopt->burst);
 	q->mtu = qopt->mtu;
 	nss_qdisc_info("MTU = %u", qopt->mtu);
 	q->peakrate = qopt->peakrate;
 	nss_qdisc_info("Peak Rate = %u", qopt->peakrate);

 #if defined(NSS_QDISC_PPE_SUPPORT)
 	if (q->nq.mode == NSS_QDISC_MODE_PPE) {
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 		if (nss_tbl_ppe_change(sch, opt) < 0) {
 #else
 		if (nss_tbl_ppe_change(sch, opt, extack) < 0) {
 #endif
 			nss_qdisc_warning("nss_tbl %x SSDK scheduler config failed\n", sch->handle);
 			return -EINVAL;
 		}
 		return 0;
 	}
 #endif

 	nim.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.rate = q->rate;
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.burst = q->burst;
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.max_size = q->mtu;
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.short_circuit = false;
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.rate = q->peakrate;

 	/*
 	 * It is important to set these two parameters to be the same as MTU.
 	 * This ensures bursts from CIR dont go above the specified peakrate.
 	 */
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.burst = q->mtu;
 	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.max_size = q->mtu;

 	/*
 	 * We can short circuit peakrate limiter if it is not being configured.
 	 */
 	if (q->peakrate) {
 		nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.short_circuit = false;
 	} else {
 		nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.short_circuit = true;
 	}

 	if (nss_qdisc_configure(&q->nq, &nim, NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_CHANGE_PARAM) < 0) {
 		return -EINVAL;
 	}

 	return 0;
 }

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 static int nss_tbl_init(struct Qdisc *sch, struct nlattr *opt)
 {
 	struct netlink_ext_ack *extack = NULL;
 #else
 static int nss_tbl_init(struct Qdisc *sch, struct nlattr *opt,
 				struct netlink_ext_ack *extack)
 {
 #endif
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	struct nlattr *tb[TCA_NSSTBL_MAX + 1];
 	struct tc_nsstbl_qopt *qopt;

 	if (!opt) {
 		return -EINVAL;
 	}

 	q->qdisc = &noop_qdisc;

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS);
 #else
 	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS, extack);
 #endif
 	if (!qopt) {
 		return -EINVAL;
 	}

 	if (nss_qdisc_init(sch, &q->nq, NSS_SHAPER_NODE_TYPE_TBL, 0, qopt->accel_mode, extack) < 0)
 	{
 		return -EINVAL;
 	}

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 	if (nss_tbl_change(sch, opt) < 0) {
 #else
 	if (nss_tbl_change(sch, opt, extack) < 0) {
 #endif
 		nss_qdisc_info("Failed to configure tbl\n");
 		nss_qdisc_destroy(&q->nq);
 		return -EINVAL;
 	}

 	/*
 	 * Start the stats polling timer
 	 */
 	nss_qdisc_start_basic_stats_polling(&q->nq);

 	return 0;
 }

 static int nss_tbl_dump(struct Qdisc *sch, struct sk_buff *skb)
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	struct nlattr *opts = NULL;
 	struct tc_nsstbl_qopt opt;

 	opt.rate = q->rate;
 	opt.peakrate = q->peakrate;
 	opt.burst = q->burst;
 	opt.mtu = q->mtu;
 	opt.accel_mode = nss_qdisc_accel_mode_get(&q->nq);

 	nss_qdisc_info("Nsstbl dumping");

 	opts = nss_qdisc_nla_nest_start(skb, TCA_OPTIONS);
 	if (opts == NULL || nla_put(skb, TCA_NSSTBL_PARMS, sizeof(opt), &opt)) {
 		goto nla_put_failure;
 	}

 	return nla_nest_end(skb, opts);

 nla_put_failure:
 	nla_nest_cancel(skb, opts);
 	return -EMSGSIZE;
 }

 static int nss_tbl_dump_class(struct Qdisc *sch, unsigned long cl,
 			     struct sk_buff *skb, struct tcmsg *tcm)
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	nss_qdisc_info("Nsstbl dumping class");

 	tcm->tcm_handle |= TC_H_MIN(1);
 	tcm->tcm_info = q->qdisc->handle;

 	return 0;
 }

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
 static int nss_tbl_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
 			struct Qdisc **old)
 #else
 static int nss_tbl_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
 			struct Qdisc **old, struct netlink_ext_ack *extack)
 #endif
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	struct nss_qdisc *nq_new = (struct nss_qdisc *)qdisc_priv(new);
 	struct nss_if_msg nim_attach;
 	struct nss_if_msg nim_detach;

 	if (new == NULL)
 		new = &noop_qdisc;

 	sch_tree_lock(sch);
 	*old = q->qdisc;
 	sch_tree_unlock(sch);

 	nss_qdisc_info("Grafting old: %px with new: %px\n", *old, new);
 	if (*old != &noop_qdisc) {
 		struct nss_qdisc *nq_old = (struct nss_qdisc *)qdisc_priv(*old);
 		nss_qdisc_info("Detaching old: %px\n", *old);
 		nim_detach.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
 		if (nss_qdisc_node_detach(&q->nq, nq_old, &nim_detach,
 				NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_DETACH) < 0) {
 			return -EINVAL;
 		}
 	}

 	if (new != &noop_qdisc) {
 		nss_qdisc_info("Attaching new: %px\n", new);
 		nim_attach.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
 		nim_attach.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_attach.child_qos_tag = nq_new->qos_tag;
 		if (nss_qdisc_node_attach(&q->nq, nq_new, &nim_attach,
 				NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_ATTACH) < 0) {
 			return -EINVAL;
 		}
 	}

 	/*
 	 * Replaced in NSS, now replace in Linux.
 	 */
 	nss_qdisc_replace(sch, new, &q->qdisc);

 	nss_qdisc_info("Nsstbl grafted");

 	return 0;
 }

 static struct Qdisc *nss_tbl_leaf(struct Qdisc *sch, unsigned long arg)
 {
 	struct nss_tbl_sched_data *q = qdisc_priv(sch);
 	nss_qdisc_info("Nsstbl returns leaf");
 	return q->qdisc;
 }

 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 0))
 static unsigned long nss_tbl_get(struct Qdisc *sch, u32 classid)
 {
 	return 1;
 }

 static void nss_tbl_put(struct Qdisc *sch, unsigned long arg)
 {
 }
 #else
 static unsigned long nss_tbl_search(struct Qdisc *sch, u32 classid)
 {
 	return 1;
 }
 #endif

 static void nss_tbl_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 {
 	nss_qdisc_info("Nsstbl walk called");
 	if (!walker->stop) {
 		if (walker->count >= walker->skip)
 			if (walker->fn(sch, 1, walker) < 0) {
 				walker->stop = 1;
 				return;
 			}
 		walker->count++;
 	}
 }

 const struct Qdisc_class_ops nss_tbl_class_ops = {
 	.graft		=	nss_tbl_graft,
 	.leaf		=	nss_tbl_leaf,
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 0))
 	.get		=	nss_tbl_get,
 	.put		=	nss_tbl_put,
 #else
 	.find       =   nss_tbl_search,
 #endif
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 4, 0))
 	.tcf_chain	=	nss_qdisc_tcf_chain,
 #else
 	.tcf_block	=	nss_qdisc_tcf_block,
 #endif
 	.bind_tcf	=	nss_qdisc_tcf_bind,
 	.unbind_tcf	=	nss_qdisc_tcf_unbind,
 	.walk		=	nss_tbl_walk,
 	.dump		=	nss_tbl_dump_class,
 };

 struct Qdisc_ops nss_tbl_qdisc_ops __read_mostly = {
 	.next		=	NULL,
 	.id		=	"nsstbl",
 	.priv_size	=	sizeof(struct nss_tbl_sched_data),
 	.cl_ops		=	&nss_tbl_class_ops,
 	.enqueue	=	nss_tbl_enqueue,
 	.dequeue	=	nss_tbl_dequeue,
 	.peek		=	nss_tbl_peek,
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
 	.drop		=	nss_tbl_drop,
 #endif
 	.init		=	nss_tbl_init,
 	.reset		=	nss_tbl_reset,
 	.destroy	=	nss_tbl_destroy,
 	.change		=	nss_tbl_change,
 	.dump		=	nss_tbl_dump,
 	.owner		=	THIS_MODULE,
 };
	/*
	**************************************************************************
	* Copyright (c) 2014-2017, 2019-2020, The Linux Foundation. All rights reserved.
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all copies.
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	**************************************************************************
	*/

	#include "nss_qdisc.h"

	struct nss_tbl_sched_data {
	struct nss_qdisc nq; /* Common base class for all nss qdiscs */
	u32 rate; /* Limiting rate of TBL */
	u32 peakrate; /* Maximum rate to control bursts */
	u32 burst; /* Maximum allowed burst size */
	u32 mtu; /* MTU of the interface attached to */
	struct Qdisc qdisc; / Qdisc to which it is attached to */
	};

	static struct nla_policy nss_tbl_policy[TCA_NSSTBL_MAX + 1] = {
	[TCA_NSSTBL_PARMS] = { .len = sizeof(struct tc_nsstbl_qopt) },
	};

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
	static int nss_tbl_enqueue(struct sk_buff skb, struct Qdisc sch)
	#else
	static int nss_tbl_enqueue(struct sk_buff skb, struct Qdisc sch,
	struct sk_buff **to_free)
	#endif
	{
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
	return nss_qdisc_enqueue(skb, sch);
	#else
	return nss_qdisc_enqueue(skb, sch, to_free);
	#endif
	}

	static struct sk_buff nss_tbl_dequeue(struct Qdisc sch)
	{
	return nss_qdisc_dequeue(sch);
	}

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
	static unsigned int nss_tbl_drop(struct Qdisc *sch)
	{
	return nss_qdisc_drop(sch);
	}
	#endif

	static struct sk_buff nss_tbl_peek(struct Qdisc sch)
	{
	return nss_qdisc_peek(sch);
	}

	static void nss_tbl_reset(struct Qdisc *sch)
	{
	nss_qdisc_reset(sch);
	}

	static void nss_tbl_destroy(struct Qdisc *sch)
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	struct nss_qdisc nq_child = (struct nss_qdisc )qdisc_priv(q->qdisc);
	struct nss_if_msg nim;

	/*
	* We must always detach our child node in NSS before destroying it.
	* Also, we make sure we dont send down the command for noop qdiscs.
	*/
	if (q->qdisc != &noop_qdisc) {
	nim.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
	if (nss_qdisc_node_detach(&q->nq, nq_child, &nim,
	NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_DETACH) < 0) {
	nss_qdisc_error("Failed to detach child %x from nss_tbl %x\n",
	q->qdisc->handle, q->nq.qos_tag);
	return;
	}
	}

	/*
	* Now we can destroy our child qdisc
	*/
	nss_qdisc_put(q->qdisc);

	/*
	* Stop the polling of basic stats and destroy qdisc.
	*/
	nss_qdisc_stop_basic_stats_polling(&q->nq);
	nss_qdisc_destroy(&q->nq);
	}

	#if defined(NSS_QDISC_PPE_SUPPORT)
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	static int nss_tbl_ppe_change(struct Qdisc sch, struct nlattr opt)
	#else
	static int nss_tbl_ppe_change(struct Qdisc sch, struct nlattr opt, struct netlink_ext_ack *extack)
	#endif
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	struct nss_qdisc *nq = &q->nq;
	struct nss_ppe_qdisc prev_npq;

	/*
	* Save previous configuration for reset purpose
	*/
	if (nq->npq.is_configured) {
	prev_npq = nq->npq;
	}

	nq->npq.shaper_present = true;
	nq->npq.shaper.rate = q->rate;
	nq->npq.shaper.burst = q->burst;
	nq->npq.shaper.crate = q->rate;
	nq->npq.shaper.cburst = q->burst;
	nq->npq.shaper.overhead = 0;

	if (nss_ppe_configure(nq, &prev_npq) != 0) {
	nss_qdisc_warning("nss_tbl %x SSDK scheduler configuration failed\n", sch->handle);
	goto fail;
	}

	return 0;

	fail:
	if (nq->npq.is_configured) {
	nss_qdisc_warning("nss_tbl %x SSDK scheduler configuration failed\n", sch->handle);
	return -EINVAL;
	}

	/*
	* PPE qdisc config failed, try to initialize in NSS.
	*/
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	if (nss_ppe_fallback_to_nss(nq, opt)) {
	#else
	if (nss_ppe_fallback_to_nss(nq, opt, extack)) {
	#endif
	nss_qdisc_warning("nss_tbl %x fallback to nss failed\n", sch->handle);
	return -EINVAL;
	}

	return 0;
	}
	#endif

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	static int nss_tbl_change(struct Qdisc sch, struct nlattr opt)
	#else
	static int nss_tbl_change(struct Qdisc sch, struct nlattr opt,
	struct netlink_ext_ack *extack)
	#endif
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	struct nlattr *tb[TCA_NSSTBL_MAX + 1];
	struct tc_nsstbl_qopt *qopt;
	struct nss_if_msg nim;
	struct net_device *dev = qdisc_dev(sch);

	if (!opt) {
	return -EINVAL;
	}

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS);
	#else
	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS, extack);
	#endif
	if (!qopt) {
	return -EINVAL;
	}

	/*
	* Set MTU if it wasn't specified explicitely
	*/
	if (!qopt->mtu) {
	qopt->mtu = psched_mtu(dev);
	nss_qdisc_info("MTU not provided for nss_tbl. Setting it to %s's default %u bytes\n", dev->name, qopt->mtu);
	}

	/*
	* Burst size cannot be less than MTU
	*/
	if (qopt->burst < qopt->mtu) {
	nss_qdisc_error("Burst size: %u is less than the specified MTU: %u\n", qopt->burst, qopt->mtu);
	return -EINVAL;
	}

	/*
	* Rate can be zero. Therefore we dont do a check on it.
	*/
	q->rate = qopt->rate;
	nss_qdisc_info("Rate = %u", qopt->rate);
	q->burst = qopt->burst;
	nss_qdisc_info("Burst = %u", qopt->burst);
	q->mtu = qopt->mtu;
	nss_qdisc_info("MTU = %u", qopt->mtu);
	q->peakrate = qopt->peakrate;
	nss_qdisc_info("Peak Rate = %u", qopt->peakrate);

	#if defined(NSS_QDISC_PPE_SUPPORT)
	if (q->nq.mode == NSS_QDISC_MODE_PPE) {
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	if (nss_tbl_ppe_change(sch, opt) < 0) {
	#else
	if (nss_tbl_ppe_change(sch, opt, extack) < 0) {
	#endif
	nss_qdisc_warning("nss_tbl %x SSDK scheduler config failed\n", sch->handle);
	return -EINVAL;
	}
	return 0;
	}
	#endif

	nim.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.rate = q->rate;
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.burst = q->burst;
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.max_size = q->mtu;
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_cir.short_circuit = false;
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.rate = q->peakrate;

	/*
	* It is important to set these two parameters to be the same as MTU.
	* This ensures bursts from CIR dont go above the specified peakrate.
	*/
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.burst = q->mtu;
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.max_size = q->mtu;

	/*
	* We can short circuit peakrate limiter if it is not being configured.
	*/
	if (q->peakrate) {
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.short_circuit = false;
	} else {
	nim.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_param.lap_pir.short_circuit = true;
	}

	if (nss_qdisc_configure(&q->nq, &nim, NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_CHANGE_PARAM) < 0) {
	return -EINVAL;
	}

	return 0;
	}

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	static int nss_tbl_init(struct Qdisc sch, struct nlattr opt)
	{
	struct netlink_ext_ack *extack = NULL;
	#else
	static int nss_tbl_init(struct Qdisc sch, struct nlattr opt,
	struct netlink_ext_ack *extack)
	{
	#endif
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	struct nlattr *tb[TCA_NSSTBL_MAX + 1];
	struct tc_nsstbl_qopt *qopt;

	if (!opt) {
	return -EINVAL;
	}

	q->qdisc = &noop_qdisc;

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS);
	#else
	qopt = nss_qdisc_qopt_get(opt, nss_tbl_policy, tb, TCA_NSSTBL_MAX, TCA_NSSTBL_PARMS, extack);
	#endif
	if (!qopt) {
	return -EINVAL;
	}

	if (nss_qdisc_init(sch, &q->nq, NSS_SHAPER_NODE_TYPE_TBL, 0, qopt->accel_mode, extack) < 0)
	{
	return -EINVAL;
	}

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	if (nss_tbl_change(sch, opt) < 0) {
	#else
	if (nss_tbl_change(sch, opt, extack) < 0) {
	#endif
	nss_qdisc_info("Failed to configure tbl\n");
	nss_qdisc_destroy(&q->nq);
	return -EINVAL;
	}

	/*
	* Start the stats polling timer
	*/
	nss_qdisc_start_basic_stats_polling(&q->nq);

	return 0;
	}

	static int nss_tbl_dump(struct Qdisc sch, struct sk_buff skb)
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	struct nlattr *opts = NULL;
	struct tc_nsstbl_qopt opt;

	opt.rate = q->rate;
	opt.peakrate = q->peakrate;
	opt.burst = q->burst;
	opt.mtu = q->mtu;
	opt.accel_mode = nss_qdisc_accel_mode_get(&q->nq);

	nss_qdisc_info("Nsstbl dumping");

	opts = nss_qdisc_nla_nest_start(skb, TCA_OPTIONS);
	if (opts == NULL \|\| nla_put(skb, TCA_NSSTBL_PARMS, sizeof(opt), &opt)) {
	goto nla_put_failure;
	}

	return nla_nest_end(skb, opts);

	nla_put_failure:
	nla_nest_cancel(skb, opts);
	return -EMSGSIZE;
	}

	static int nss_tbl_dump_class(struct Qdisc *sch, unsigned long cl,
	struct sk_buff skb, struct tcmsg tcm)
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	nss_qdisc_info("Nsstbl dumping class");

	tcm->tcm_handle \|= TC_H_MIN(1);
	tcm->tcm_info = q->qdisc->handle;

	return 0;
	}

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0))
	static int nss_tbl_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
	struct Qdisc **old)
	#else
	static int nss_tbl_graft(struct Qdisc sch, unsigned long arg, struct Qdisc new,
	struct Qdisc *old, struct netlink_ext_ack extack)
	#endif
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	struct nss_qdisc nq_new = (struct nss_qdisc )qdisc_priv(new);
	struct nss_if_msg nim_attach;
	struct nss_if_msg nim_detach;

	if (new == NULL)
	new = &noop_qdisc;

	sch_tree_lock(sch);
	*old = q->qdisc;
	sch_tree_unlock(sch);

	nss_qdisc_info("Grafting old: %px with new: %px\n", *old, new);
	if (*old != &noop_qdisc) {
	struct nss_qdisc nq_old = (struct nss_qdisc )qdisc_priv(*old);
	nss_qdisc_info("Detaching old: %px\n", *old);
	nim_detach.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
	if (nss_qdisc_node_detach(&q->nq, nq_old, &nim_detach,
	NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_DETACH) < 0) {
	return -EINVAL;
	}
	}

	if (new != &noop_qdisc) {
	nss_qdisc_info("Attaching new: %px\n", new);
	nim_attach.msg.shaper_configure.config.msg.shaper_node_config.qos_tag = q->nq.qos_tag;
	nim_attach.msg.shaper_configure.config.msg.shaper_node_config.snc.tbl_attach.child_qos_tag = nq_new->qos_tag;
	if (nss_qdisc_node_attach(&q->nq, nq_new, &nim_attach,
	NSS_SHAPER_CONFIG_TYPE_SHAPER_NODE_ATTACH) < 0) {
	return -EINVAL;
	}
	}

	/*
	* Replaced in NSS, now replace in Linux.
	*/
	nss_qdisc_replace(sch, new, &q->qdisc);

	nss_qdisc_info("Nsstbl grafted");

	return 0;
	}

	static struct Qdisc nss_tbl_leaf(struct Qdisc sch, unsigned long arg)
	{
	struct nss_tbl_sched_data *q = qdisc_priv(sch);
	nss_qdisc_info("Nsstbl returns leaf");
	return q->qdisc;
	}

	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 0))
	static unsigned long nss_tbl_get(struct Qdisc *sch, u32 classid)
	{
	return 1;
	}

	static void nss_tbl_put(struct Qdisc *sch, unsigned long arg)
	{
	}
	#else
	static unsigned long nss_tbl_search(struct Qdisc *sch, u32 classid)
	{
	return 1;
	}
	#endif

	static void nss_tbl_walk(struct Qdisc sch, struct qdisc_walker walker)
	{
	nss_qdisc_info("Nsstbl walk called");
	if (!walker->stop) {
	if (walker->count >= walker->skip)
	if (walker->fn(sch, 1, walker) < 0) {
	walker->stop = 1;
	return;
	}
	walker->count++;
	}
	}

	const struct Qdisc_class_ops nss_tbl_class_ops = {
	.graft = nss_tbl_graft,
	.leaf = nss_tbl_leaf,
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 0))
	.get = nss_tbl_get,
	.put = nss_tbl_put,
	#else
	.find = nss_tbl_search,
	#endif
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 4, 0))
	.tcf_chain = nss_qdisc_tcf_chain,
	#else
	.tcf_block = nss_qdisc_tcf_block,
	#endif
	.bind_tcf = nss_qdisc_tcf_bind,
	.unbind_tcf = nss_qdisc_tcf_unbind,
	.walk = nss_tbl_walk,
	.dump = nss_tbl_dump_class,
	};

	struct Qdisc_ops nss_tbl_qdisc_ops __read_mostly = {
	.next = NULL,
	.id = "nsstbl",
	.priv_size = sizeof(struct nss_tbl_sched_data),
	.cl_ops = &nss_tbl_class_ops,
	.enqueue = nss_tbl_enqueue,
	.dequeue = nss_tbl_dequeue,
	.peek = nss_tbl_peek,
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
	.drop = nss_tbl_drop,
	#endif
	.init = nss_tbl_init,
	.reset = nss_tbl_reset,
	.destroy = nss_tbl_destroy,
	.change = nss_tbl_change,
	.dump = nss_tbl_dump,
	.owner = THIS_MODULE,
	};