[linux-block.git] / net / sched / sch_fq_pie.c

// SPDX-License-Identifier: GPL-2.0-only
/* Flow Queue PIE discipline
 *
 * Copyright (C) 2019 Mohit P. Tahiliani <tahiliani@nitk.edu.in>
 * Copyright (C) 2019 Sachin D. Patil <sdp.sachin@gmail.com>
 * Copyright (C) 2019 V. Saicharan <vsaicharan1998@gmail.com>
 * Copyright (C) 2019 Mohit Bhasi <mohitbhasi1998@gmail.com>
 * Copyright (C) 2019 Leslie Monis <lesliemonis@gmail.com>
 * Copyright (C) 2019 Gautam Ramakrishnan <gautamramk@gmail.com>
 */

#include <linux/jhash.h>
#include <linux/module.h>
#include <linux/sizes.h>
#include <linux/vmalloc.h>
#include <net/pkt_cls.h>
#include <net/pie.h>

/* Flow Queue PIE
 *
 * Principles:
 *   - Packets are classified on flows.
 *   - This is a Stochastic model (as we use a hash, several flows might
 *                                 be hashed to the same slot)
 *   - Each flow has a PIE managed queue.
 *   - Flows are linked onto two (Round Robin) lists,
 *     so that new flows have priority on old ones.
 *   - For a given flow, packets are not reordered.
 *   - Drops during enqueue only.
 *   - ECN capability is off by default.
 *   - ECN threshold (if ECN is enabled) is at 10% by default.
 *   - Uses timestamps to calculate queue delay by default.
 */

/**
 * struct fq_pie_flow - contains data for each flow
 * @vars:	pie vars associated with the flow
 * @deficit:	number of remaining byte credits
 * @backlog:	size of data in the flow
 * @qlen:	number of packets in the flow
 * @flowchain:	flowchain for the flow
 * @head:	first packet in the flow
 * @tail:	last packet in the flow
 */
struct fq_pie_flow {
	struct pie_vars vars;
	s32 deficit;
	u32 backlog;
	u32 qlen;
	struct list_head flowchain;
	struct sk_buff *head;
	struct sk_buff *tail;
};

struct fq_pie_sched_data {
	struct tcf_proto __rcu *filter_list; /* optional external classifier */
	struct tcf_block *block;
	struct fq_pie_flow *flows;
	struct Qdisc *sch;
	struct list_head old_flows;
	struct list_head new_flows;
	struct pie_params p_params;
	u32 ecn_prob;
	u32 flows_cnt;
	u32 flows_cursor;
	u32 quantum;
	u32 memory_limit;
	u32 new_flow_count;
	u32 memory_usage;
	u32 overmemory;
	struct pie_stats stats;
	struct timer_list adapt_timer;
};

static unsigned int fq_pie_hash(const struct fq_pie_sched_data *q,
				struct sk_buff *skb)
{
	return reciprocal_scale(skb_get_hash(skb), q->flows_cnt);
}

static unsigned int fq_pie_classify(struct sk_buff *skb, struct Qdisc *sch,
				    int *qerr)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	struct tcf_proto *filter;
	struct tcf_result res;
	int result;

	if (TC_H_MAJ(skb->priority) == sch->handle &&
	    TC_H_MIN(skb->priority) > 0 &&
	    TC_H_MIN(skb->priority) <= q->flows_cnt)
		return TC_H_MIN(skb->priority);

	filter = rcu_dereference_bh(q->filter_list);
	if (!filter)
		return fq_pie_hash(q, skb) + 1;

	*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
	result = tcf_classify(skb, NULL, filter, &res, false);
	if (result >= 0) {
#ifdef CONFIG_NET_CLS_ACT
		switch (result) {
		case TC_ACT_STOLEN:
		case TC_ACT_QUEUED:
		case TC_ACT_TRAP:
			*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
			fallthrough;
		case TC_ACT_SHOT:
			return 0;
		}
#endif
		if (TC_H_MIN(res.classid) <= q->flows_cnt)
			return TC_H_MIN(res.classid);
	}
	return 0;
}

/* add skb to flow queue (tail add) */
static inline void flow_queue_add(struct fq_pie_flow *flow,
				  struct sk_buff *skb)
{
	if (!flow->head)
		flow->head = skb;
	else
		flow->tail->next = skb;
	flow->tail = skb;
	skb->next = NULL;
}

static int fq_pie_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
				struct sk_buff **to_free)
{
	enum skb_drop_reason reason = SKB_DROP_REASON_QDISC_OVERLIMIT;
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	struct fq_pie_flow *sel_flow;
	int ret;
	u8 memory_limited = false;
	u8 enqueue = false;
	u32 pkt_len;
	u32 idx;

	/* Classifies packet into corresponding flow */
	idx = fq_pie_classify(skb, sch, &ret);
	if (idx == 0) {
		if (ret & __NET_XMIT_BYPASS)
			qdisc_qstats_drop(sch);
		__qdisc_drop(skb, to_free);
		return ret;
	}
	idx--;

	sel_flow = &q->flows[idx];
	/* Checks whether adding a new packet would exceed memory limit */
	get_pie_cb(skb)->mem_usage = skb->truesize;
	memory_limited = q->memory_usage > q->memory_limit + skb->truesize;

	/* Checks if the qdisc is full */
	if (unlikely(qdisc_qlen(sch) >= sch->limit)) {
		q->stats.overlimit++;
		goto out;
	} else if (unlikely(memory_limited)) {
		q->overmemory++;
	}

	reason = SKB_DROP_REASON_QDISC_CONGESTED;

	if (!pie_drop_early(sch, &q->p_params, &sel_flow->vars,
			    sel_flow->backlog, skb->len)) {
		enqueue = true;
	} else if (q->p_params.ecn &&
		   sel_flow->vars.prob <= (MAX_PROB / 100) * q->ecn_prob &&
		   INET_ECN_set_ce(skb)) {
		/* If packet is ecn capable, mark it if drop probability
		 * is lower than the parameter ecn_prob, else drop it.
		 */
		q->stats.ecn_mark++;
		enqueue = true;
	}
	if (enqueue) {
		/* Set enqueue time only when dq_rate_estimator is disabled. */
		if (!q->p_params.dq_rate_estimator)
			pie_set_enqueue_time(skb);

		pkt_len = qdisc_pkt_len(skb);
		q->stats.packets_in++;
		q->memory_usage += skb->truesize;
		sch->qstats.backlog += pkt_len;
		sch->q.qlen++;
		flow_queue_add(sel_flow, skb);
		if (list_empty(&sel_flow->flowchain)) {
			list_add_tail(&sel_flow->flowchain, &q->new_flows);
			q->new_flow_count++;
			sel_flow->deficit = q->quantum;
			sel_flow->qlen = 0;
			sel_flow->backlog = 0;
		}
		sel_flow->qlen++;
		sel_flow->backlog += pkt_len;
		return NET_XMIT_SUCCESS;
	}
out:
	q->stats.dropped++;
	sel_flow->vars.accu_prob = 0;
	qdisc_drop_reason(skb, sch, to_free, reason);
	return NET_XMIT_CN;
}

static const struct netlink_range_validation fq_pie_q_range = {
	.min = 1,
	.max = 1 << 20,
};

static const struct nla_policy fq_pie_policy[TCA_FQ_PIE_MAX + 1] = {
	[TCA_FQ_PIE_LIMIT]		= {.type = NLA_U32},
	[TCA_FQ_PIE_FLOWS]		= {.type = NLA_U32},
	[TCA_FQ_PIE_TARGET]		= {.type = NLA_U32},
	[TCA_FQ_PIE_TUPDATE]		= {.type = NLA_U32},
	[TCA_FQ_PIE_ALPHA]		= {.type = NLA_U32},
	[TCA_FQ_PIE_BETA]		= {.type = NLA_U32},
	[TCA_FQ_PIE_QUANTUM]		=
			NLA_POLICY_FULL_RANGE(NLA_U32, &fq_pie_q_range),
	[TCA_FQ_PIE_MEMORY_LIMIT]	= {.type = NLA_U32},
	[TCA_FQ_PIE_ECN_PROB]		= {.type = NLA_U32},
	[TCA_FQ_PIE_ECN]		= {.type = NLA_U32},
	[TCA_FQ_PIE_BYTEMODE]		= {.type = NLA_U32},
	[TCA_FQ_PIE_DQ_RATE_ESTIMATOR]	= {.type = NLA_U32},
};

static inline struct sk_buff *dequeue_head(struct fq_pie_flow *flow)
{
	struct sk_buff *skb = flow->head;

	flow->head = skb->next;
	skb->next = NULL;
	return skb;
}

static struct sk_buff *fq_pie_qdisc_dequeue(struct Qdisc *sch)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	struct sk_buff *skb = NULL;
	struct fq_pie_flow *flow;
	struct list_head *head;
	u32 pkt_len;

begin:
	head = &q->new_flows;
	if (list_empty(head)) {
		head = &q->old_flows;
		if (list_empty(head))
			return NULL;
	}

	flow = list_first_entry(head, struct fq_pie_flow, flowchain);
	/* Flow has exhausted all its credits */
	if (flow->deficit <= 0) {
		flow->deficit += q->quantum;
		list_move_tail(&flow->flowchain, &q->old_flows);
		goto begin;
	}

	if (flow->head) {
		skb = dequeue_head(flow);
		pkt_len = qdisc_pkt_len(skb);
		sch->qstats.backlog -= pkt_len;
		sch->q.qlen--;
		qdisc_bstats_update(sch, skb);
	}

	if (!skb) {
		/* force a pass through old_flows to prevent starvation */
		if (head == &q->new_flows && !list_empty(&q->old_flows))
			list_move_tail(&flow->flowchain, &q->old_flows);
		else
			list_del_init(&flow->flowchain);
		goto begin;
	}

	flow->qlen--;
	flow->deficit -= pkt_len;
	flow->backlog -= pkt_len;
	q->memory_usage -= get_pie_cb(skb)->mem_usage;
	pie_process_dequeue(skb, &q->p_params, &flow->vars, flow->backlog);
	return skb;
}

static int fq_pie_change(struct Qdisc *sch, struct nlattr *opt,
			 struct netlink_ext_ack *extack)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	struct nlattr *tb[TCA_FQ_PIE_MAX + 1];
	unsigned int len_dropped = 0;
	unsigned int num_dropped = 0;
	int err;

	err = nla_parse_nested(tb, TCA_FQ_PIE_MAX, opt, fq_pie_policy, extack);
	if (err < 0)
		return err;

	sch_tree_lock(sch);
	if (tb[TCA_FQ_PIE_LIMIT]) {
		u32 limit = nla_get_u32(tb[TCA_FQ_PIE_LIMIT]);

		WRITE_ONCE(q->p_params.limit, limit);
		WRITE_ONCE(sch->limit, limit);
	}
	if (tb[TCA_FQ_PIE_FLOWS]) {
		if (q->flows) {
			NL_SET_ERR_MSG_MOD(extack,
					   "Number of flows cannot be changed");
			goto flow_error;
		}
		q->flows_cnt = nla_get_u32(tb[TCA_FQ_PIE_FLOWS]);
		if (!q->flows_cnt || q->flows_cnt > 65536) {
			NL_SET_ERR_MSG_MOD(extack,
					   "Number of flows must range in [1..65536]");
			goto flow_error;
		}
	}

	/* convert from microseconds to pschedtime */
	if (tb[TCA_FQ_PIE_TARGET]) {
		/* target is in us */
		u32 target = nla_get_u32(tb[TCA_FQ_PIE_TARGET]);

		/* convert to pschedtime */
		WRITE_ONCE(q->p_params.target,
			   PSCHED_NS2TICKS((u64)target * NSEC_PER_USEC));
	}

	/* tupdate is in jiffies */
	if (tb[TCA_FQ_PIE_TUPDATE])
		WRITE_ONCE(q->p_params.tupdate,
			usecs_to_jiffies(nla_get_u32(tb[TCA_FQ_PIE_TUPDATE])));

	if (tb[TCA_FQ_PIE_ALPHA])
		WRITE_ONCE(q->p_params.alpha,
			   nla_get_u32(tb[TCA_FQ_PIE_ALPHA]));

	if (tb[TCA_FQ_PIE_BETA])
		WRITE_ONCE(q->p_params.beta,
			   nla_get_u32(tb[TCA_FQ_PIE_BETA]));

	if (tb[TCA_FQ_PIE_QUANTUM])
		WRITE_ONCE(q->quantum, nla_get_u32(tb[TCA_FQ_PIE_QUANTUM]));

	if (tb[TCA_FQ_PIE_MEMORY_LIMIT])
		WRITE_ONCE(q->memory_limit,
			   nla_get_u32(tb[TCA_FQ_PIE_MEMORY_LIMIT]));

	if (tb[TCA_FQ_PIE_ECN_PROB])
		WRITE_ONCE(q->ecn_prob,
			   nla_get_u32(tb[TCA_FQ_PIE_ECN_PROB]));

	if (tb[TCA_FQ_PIE_ECN])
		WRITE_ONCE(q->p_params.ecn,
			   nla_get_u32(tb[TCA_FQ_PIE_ECN]));

	if (tb[TCA_FQ_PIE_BYTEMODE])
		WRITE_ONCE(q->p_params.bytemode,
			   nla_get_u32(tb[TCA_FQ_PIE_BYTEMODE]));

	if (tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR])
		WRITE_ONCE(q->p_params.dq_rate_estimator,
			   nla_get_u32(tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR]));

	/* Drop excess packets if new limit is lower */
	while (sch->q.qlen > sch->limit) {
		struct sk_buff *skb = qdisc_dequeue_internal(sch, false);

		len_dropped += qdisc_pkt_len(skb);
		num_dropped += 1;
		rtnl_kfree_skbs(skb, skb);
	}
	qdisc_tree_reduce_backlog(sch, num_dropped, len_dropped);

	sch_tree_unlock(sch);
	return 0;

flow_error:
	sch_tree_unlock(sch);
	return -EINVAL;
}

static void fq_pie_timer(struct timer_list *t)
{
	struct fq_pie_sched_data *q = timer_container_of(q, t, adapt_timer);
	unsigned long next, tupdate;
	struct Qdisc *sch = q->sch;
	spinlock_t *root_lock; /* to lock qdisc for probability calculations */
	int max_cnt, i;

	rcu_read_lock();
	root_lock = qdisc_lock(qdisc_root_sleeping(sch));
	spin_lock(root_lock);

	/* Limit this expensive loop to 2048 flows per round. */
	max_cnt = min_t(int, q->flows_cnt - q->flows_cursor, 2048);
	for (i = 0; i < max_cnt; i++) {
		pie_calculate_probability(&q->p_params,
					  &q->flows[q->flows_cursor].vars,
					  q->flows[q->flows_cursor].backlog);
		q->flows_cursor++;
	}

	tupdate = q->p_params.tupdate;
	next = 0;
	if (q->flows_cursor >= q->flows_cnt) {
		q->flows_cursor = 0;
		next = tupdate;
	}
	if (tupdate)
		mod_timer(&q->adapt_timer, jiffies + next);
	spin_unlock(root_lock);
	rcu_read_unlock();
}

static int fq_pie_init(struct Qdisc *sch, struct nlattr *opt,
		       struct netlink_ext_ack *extack)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	int err;
	u32 idx;

	pie_params_init(&q->p_params);
	sch->limit = 10 * 1024;
	q->p_params.limit = sch->limit;
	q->quantum = psched_mtu(qdisc_dev(sch));
	q->sch = sch;
	q->ecn_prob = 10;
	q->flows_cnt = 1024;
	q->memory_limit = SZ_32M;

	INIT_LIST_HEAD(&q->new_flows);
	INIT_LIST_HEAD(&q->old_flows);
	timer_setup(&q->adapt_timer, fq_pie_timer, 0);

	if (opt) {
		err = fq_pie_change(sch, opt, extack);

		if (err)
			return err;
	}

	err = tcf_block_get(&q->block, &q->filter_list, sch, extack);
	if (err)
		goto init_failure;

	q->flows = kvcalloc(q->flows_cnt, sizeof(struct fq_pie_flow),
			    GFP_KERNEL);
	if (!q->flows) {
		err = -ENOMEM;
		goto init_failure;
	}
	for (idx = 0; idx < q->flows_cnt; idx++) {
		struct fq_pie_flow *flow = q->flows + idx;

		INIT_LIST_HEAD(&flow->flowchain);
		pie_vars_init(&flow->vars);
	}

	mod_timer(&q->adapt_timer, jiffies + HZ / 2);

	return 0;

init_failure:
	q->flows_cnt = 0;

	return err;
}

static int fq_pie_dump(struct Qdisc *sch, struct sk_buff *skb)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	struct nlattr *opts;

	opts = nla_nest_start(skb, TCA_OPTIONS);
	if (!opts)
		return -EMSGSIZE;

	/* convert target from pschedtime to us */
	if (nla_put_u32(skb, TCA_FQ_PIE_LIMIT, READ_ONCE(sch->limit)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_FLOWS, READ_ONCE(q->flows_cnt)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_TARGET,
			((u32)PSCHED_TICKS2NS(READ_ONCE(q->p_params.target))) /
			NSEC_PER_USEC) ||
	    nla_put_u32(skb, TCA_FQ_PIE_TUPDATE,
			jiffies_to_usecs(READ_ONCE(q->p_params.tupdate))) ||
	    nla_put_u32(skb, TCA_FQ_PIE_ALPHA, READ_ONCE(q->p_params.alpha)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_BETA, READ_ONCE(q->p_params.beta)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_QUANTUM, READ_ONCE(q->quantum)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_MEMORY_LIMIT,
			READ_ONCE(q->memory_limit)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_ECN_PROB, READ_ONCE(q->ecn_prob)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_ECN, READ_ONCE(q->p_params.ecn)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_BYTEMODE, READ_ONCE(q->p_params.bytemode)) ||
	    nla_put_u32(skb, TCA_FQ_PIE_DQ_RATE_ESTIMATOR,
			READ_ONCE(q->p_params.dq_rate_estimator)))
		goto nla_put_failure;

	return nla_nest_end(skb, opts);

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

static int fq_pie_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	struct tc_fq_pie_xstats st = {
		.packets_in	= q->stats.packets_in,
		.overlimit	= q->stats.overlimit,
		.overmemory	= q->overmemory,
		.dropped	= q->stats.dropped,
		.ecn_mark	= q->stats.ecn_mark,
		.new_flow_count = q->new_flow_count,
		.memory_usage   = q->memory_usage,
	};
	struct list_head *pos;

	sch_tree_lock(sch);
	list_for_each(pos, &q->new_flows)
		st.new_flows_len++;

	list_for_each(pos, &q->old_flows)
		st.old_flows_len++;
	sch_tree_unlock(sch);

	return gnet_stats_copy_app(d, &st, sizeof(st));
}

static void fq_pie_reset(struct Qdisc *sch)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);
	u32 idx;

	INIT_LIST_HEAD(&q->new_flows);
	INIT_LIST_HEAD(&q->old_flows);
	for (idx = 0; idx < q->flows_cnt; idx++) {
		struct fq_pie_flow *flow = q->flows + idx;

		/* Removes all packets from flow */
		rtnl_kfree_skbs(flow->head, flow->tail);
		flow->head = NULL;

		INIT_LIST_HEAD(&flow->flowchain);
		pie_vars_init(&flow->vars);
	}
}

static void fq_pie_destroy(struct Qdisc *sch)
{
	struct fq_pie_sched_data *q = qdisc_priv(sch);

	tcf_block_put(q->block);
	q->p_params.tupdate = 0;
	timer_delete_sync(&q->adapt_timer);
	kvfree(q->flows);
}

static struct Qdisc_ops fq_pie_qdisc_ops __read_mostly = {
	.id		= "fq_pie",
	.priv_size	= sizeof(struct fq_pie_sched_data),
	.enqueue	= fq_pie_qdisc_enqueue,
	.dequeue	= fq_pie_qdisc_dequeue,
	.peek		= qdisc_peek_dequeued,
	.init		= fq_pie_init,
	.destroy	= fq_pie_destroy,
	.reset		= fq_pie_reset,
	.change		= fq_pie_change,
	.dump		= fq_pie_dump,
	.dump_stats	= fq_pie_dump_stats,
	.owner		= THIS_MODULE,
};
MODULE_ALIAS_NET_SCH("fq_pie");

static int __init fq_pie_module_init(void)
{
	return register_qdisc(&fq_pie_qdisc_ops);
}

static void __exit fq_pie_module_exit(void)
{
	unregister_qdisc(&fq_pie_qdisc_ops);
}

module_init(fq_pie_module_init);
module_exit(fq_pie_module_exit);

MODULE_DESCRIPTION("Flow Queue Proportional Integral controller Enhanced (FQ-PIE)");
MODULE_AUTHOR("Mohit P. Tahiliani");
MODULE_LICENSE("GPL");
Commit	Line	Data
ec97ecf1 MT	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/* Flow Queue PIE discipline
	3	*
	4	* Copyright (C) 2019 Mohit P. Tahiliani <tahiliani@nitk.edu.in>
	5	* Copyright (C) 2019 Sachin D. Patil <sdp.sachin@gmail.com>
	6	* Copyright (C) 2019 V. Saicharan <vsaicharan1998@gmail.com>
	7	* Copyright (C) 2019 Mohit Bhasi <mohitbhasi1998@gmail.com>
	8	* Copyright (C) 2019 Leslie Monis <lesliemonis@gmail.com>
	9	* Copyright (C) 2019 Gautam Ramakrishnan <gautamramk@gmail.com>
	10	*/
	11
	12	#include <linux/jhash.h>
9474c62a	13	#include <linux/module.h>
ec97ecf1 MT	14	#include <linux/sizes.h>
	15	#include <linux/vmalloc.h>
	16	#include <net/pkt_cls.h>
	17	#include <net/pie.h>
	18
	19	/* Flow Queue PIE
	20	*
	21	* Principles:
	22	* - Packets are classified on flows.
	23	* - This is a Stochastic model (as we use a hash, several flows might
	24	* be hashed to the same slot)
	25	* - Each flow has a PIE managed queue.
	26	* - Flows are linked onto two (Round Robin) lists,
	27	* so that new flows have priority on old ones.
	28	* - For a given flow, packets are not reordered.
	29	* - Drops during enqueue only.
	30	* - ECN capability is off by default.
	31	* - ECN threshold (if ECN is enabled) is at 10% by default.
	32	* - Uses timestamps to calculate queue delay by default.
	33	*/
	34
	35	/**
	36	* struct fq_pie_flow - contains data for each flow
	37	* @vars: pie vars associated with the flow
	38	* @deficit: number of remaining byte credits
	39	* @backlog: size of data in the flow
	40	* @qlen: number of packets in the flow
	41	* @flowchain: flowchain for the flow
	42	* @head: first packet in the flow
	43	* @tail: last packet in the flow
	44	*/
	45	struct fq_pie_flow {
	46	struct pie_vars vars;
	47	s32 deficit;
	48	u32 backlog;
	49	u32 qlen;
	50	struct list_head flowchain;
	51	struct sk_buff *head;
	52	struct sk_buff *tail;
	53	};
	54
	55	struct fq_pie_sched_data {
	56	struct tcf_proto __rcu filter_list; / optional external classifier */
	57	struct tcf_block *block;
	58	struct fq_pie_flow *flows;
	59	struct Qdisc *sch;
	60	struct list_head old_flows;
	61	struct list_head new_flows;
	62	struct pie_params p_params;
	63	u32 ecn_prob;
	64	u32 flows_cnt;
8c21ab1b	65	u32 flows_cursor;
ec97ecf1 MT	66	u32 quantum;
	67	u32 memory_limit;
	68	u32 new_flow_count;
	69	u32 memory_usage;
	70	u32 overmemory;
	71	struct pie_stats stats;
	72	struct timer_list adapt_timer;
	73	};
	74
	75	static unsigned int fq_pie_hash(const struct fq_pie_sched_data *q,
	76	struct sk_buff *skb)
	77	{
	78	return reciprocal_scale(skb_get_hash(skb), q->flows_cnt);
	79	}
	80
	81	static unsigned int fq_pie_classify(struct sk_buff skb, struct Qdisc sch,
	82	int *qerr)
	83	{
	84	struct fq_pie_sched_data *q = qdisc_priv(sch);
	85	struct tcf_proto *filter;
	86	struct tcf_result res;
	87	int result;
	88
	89	if (TC_H_MAJ(skb->priority) == sch->handle &&
	90	TC_H_MIN(skb->priority) > 0 &&
	91	TC_H_MIN(skb->priority) <= q->flows_cnt)
	92	return TC_H_MIN(skb->priority);
	93
	94	filter = rcu_dereference_bh(q->filter_list);
	95	if (!filter)
	96	return fq_pie_hash(q, skb) + 1;
	97
	98	*qerr = NET_XMIT_SUCCESS \| __NET_XMIT_BYPASS;
3aa26055	99	result = tcf_classify(skb, NULL, filter, &res, false);
ec97ecf1 MT	100	if (result >= 0) {
	101	#ifdef CONFIG_NET_CLS_ACT
	102	switch (result) {
	103	case TC_ACT_STOLEN:
	104	case TC_ACT_QUEUED:
	105	case TC_ACT_TRAP:
	106	*qerr = NET_XMIT_SUCCESS \| __NET_XMIT_STOLEN;
964201de	107	fallthrough;
ec97ecf1 MT	108	case TC_ACT_SHOT:
	109	return 0;
	110	}
	111	#endif
	112	if (TC_H_MIN(res.classid) <= q->flows_cnt)
	113	return TC_H_MIN(res.classid);
	114	}
	115	return 0;
	116	}
	117
	118	/* add skb to flow queue (tail add) */
	119	static inline void flow_queue_add(struct fq_pie_flow *flow,
	120	struct sk_buff *skb)
	121	{
	122	if (!flow->head)
	123	flow->head = skb;
	124	else
	125	flow->tail->next = skb;
	126	flow->tail = skb;
	127	skb->next = NULL;
	128	}
	129
	130	static int fq_pie_qdisc_enqueue(struct sk_buff skb, struct Qdisc sch,
	131	struct sk_buff **to_free)
	132	{
ff9f17ce	133	enum skb_drop_reason reason = SKB_DROP_REASON_QDISC_OVERLIMIT;
ec97ecf1 MT	134	struct fq_pie_sched_data *q = qdisc_priv(sch);
ec97ecf1 MT	135	struct fq_pie_flow *sel_flow;
3f649ab7	136	int ret;
ec97ecf1 MT	137	u8 memory_limited = false;
	138	u8 enqueue = false;
	139	u32 pkt_len;
	140	u32 idx;
	141
	142	/* Classifies packet into corresponding flow */
	143	idx = fq_pie_classify(skb, sch, &ret);
e70f7a11 DC	144	if (idx == 0) {
	145	if (ret & __NET_XMIT_BYPASS)
	146	qdisc_qstats_drop(sch);
	147	__qdisc_drop(skb, to_free);
	148	return ret;
	149	}
	150	idx--;
ec97ecf1	151
e70f7a11	152	sel_flow = &q->flows[idx];
ec97ecf1 MT	153	/* Checks whether adding a new packet would exceed memory limit */
	154	get_pie_cb(skb)->mem_usage = skb->truesize;
	155	memory_limited = q->memory_usage > q->memory_limit + skb->truesize;
	156
	157	/* Checks if the qdisc is full */
	158	if (unlikely(qdisc_qlen(sch) >= sch->limit)) {
	159	q->stats.overlimit++;
	160	goto out;
	161	} else if (unlikely(memory_limited)) {
	162	q->overmemory++;
	163	}
	164
ff9f17ce THJ	165	reason = SKB_DROP_REASON_QDISC_CONGESTED;
ff9f17ce THJ	166
ec97ecf1 MT	167	if (!pie_drop_early(sch, &q->p_params, &sel_flow->vars,
	168	sel_flow->backlog, skb->len)) {
	169	enqueue = true;
	170	} else if (q->p_params.ecn &&
	171	sel_flow->vars.prob <= (MAX_PROB / 100) * q->ecn_prob &&
	172	INET_ECN_set_ce(skb)) {
	173	/* If packet is ecn capable, mark it if drop probability
	174	* is lower than the parameter ecn_prob, else drop it.
	175	*/
	176	q->stats.ecn_mark++;
	177	enqueue = true;
	178	}
	179	if (enqueue) {
	180	/* Set enqueue time only when dq_rate_estimator is disabled. */
	181	if (!q->p_params.dq_rate_estimator)
	182	pie_set_enqueue_time(skb);
	183
	184	pkt_len = qdisc_pkt_len(skb);
	185	q->stats.packets_in++;
	186	q->memory_usage += skb->truesize;
	187	sch->qstats.backlog += pkt_len;
	188	sch->q.qlen++;
	189	flow_queue_add(sel_flow, skb);
	190	if (list_empty(&sel_flow->flowchain)) {
	191	list_add_tail(&sel_flow->flowchain, &q->new_flows);
	192	q->new_flow_count++;
	193	sel_flow->deficit = q->quantum;
	194	sel_flow->qlen = 0;
	195	sel_flow->backlog = 0;
	196	}
	197	sel_flow->qlen++;
	198	sel_flow->backlog += pkt_len;
	199	return NET_XMIT_SUCCESS;
	200	}
	201	out:
	202	q->stats.dropped++;
	203	sel_flow->vars.accu_prob = 0;
ff9f17ce	204	qdisc_drop_reason(skb, sch, to_free, reason);
ec97ecf1 MT	205	return NET_XMIT_CN;
	206	}
	207
ea23fbd2	208	static const struct netlink_range_validation fq_pie_q_range = {
cd2b8113 ED	209	.min = 1,
	210	.max = 1 << 20,
	211	};
	212
ec97ecf1 MT	213	static const struct nla_policy fq_pie_policy[TCA_FQ_PIE_MAX + 1] = {
	214	[TCA_FQ_PIE_LIMIT] = {.type = NLA_U32},
	215	[TCA_FQ_PIE_FLOWS] = {.type = NLA_U32},
	216	[TCA_FQ_PIE_TARGET] = {.type = NLA_U32},
	217	[TCA_FQ_PIE_TUPDATE] = {.type = NLA_U32},
	218	[TCA_FQ_PIE_ALPHA] = {.type = NLA_U32},
	219	[TCA_FQ_PIE_BETA] = {.type = NLA_U32},
cd2b8113 ED	220	[TCA_FQ_PIE_QUANTUM] =
cd2b8113 ED	221	NLA_POLICY_FULL_RANGE(NLA_U32, &fq_pie_q_range),
ec97ecf1 MT	222	[TCA_FQ_PIE_MEMORY_LIMIT] = {.type = NLA_U32},
	223	[TCA_FQ_PIE_ECN_PROB] = {.type = NLA_U32},
	224	[TCA_FQ_PIE_ECN] = {.type = NLA_U32},
	225	[TCA_FQ_PIE_BYTEMODE] = {.type = NLA_U32},
	226	[TCA_FQ_PIE_DQ_RATE_ESTIMATOR] = {.type = NLA_U32},
	227	};
	228
	229	static inline struct sk_buff dequeue_head(struct fq_pie_flow flow)
	230	{
	231	struct sk_buff *skb = flow->head;
	232
	233	flow->head = skb->next;
	234	skb->next = NULL;
	235	return skb;
	236	}
	237
	238	static struct sk_buff fq_pie_qdisc_dequeue(struct Qdisc sch)
	239	{
	240	struct fq_pie_sched_data *q = qdisc_priv(sch);
	241	struct sk_buff *skb = NULL;
	242	struct fq_pie_flow *flow;
	243	struct list_head *head;
	244	u32 pkt_len;
	245
	246	begin:
	247	head = &q->new_flows;
	248	if (list_empty(head)) {
	249	head = &q->old_flows;
	250	if (list_empty(head))
	251	return NULL;
	252	}
	253
	254	flow = list_first_entry(head, struct fq_pie_flow, flowchain);
	255	/* Flow has exhausted all its credits */
	256	if (flow->deficit <= 0) {
	257	flow->deficit += q->quantum;
	258	list_move_tail(&flow->flowchain, &q->old_flows);
	259	goto begin;
	260	}
	261
	262	if (flow->head) {
	263	skb = dequeue_head(flow);
	264	pkt_len = qdisc_pkt_len(skb);
	265	sch->qstats.backlog -= pkt_len;
	266	sch->q.qlen--;
	267	qdisc_bstats_update(sch, skb);
	268	}
	269
	270	if (!skb) {
	271	/* force a pass through old_flows to prevent starvation */
	272	if (head == &q->new_flows && !list_empty(&q->old_flows))
	273	list_move_tail(&flow->flowchain, &q->old_flows);
	274	else
	275	list_del_init(&flow->flowchain);
	276	goto begin;
	277	}
	278
	279	flow->qlen--;
	280	flow->deficit -= pkt_len;
	281	flow->backlog -= pkt_len;
	282	q->memory_usage -= get_pie_cb(skb)->mem_usage;
	283	pie_process_dequeue(skb, &q->p_params, &flow->vars, flow->backlog);
	284	return skb;
	285	}
286
287	static int fq_pie_change(struct Qdisc sch, struct nlattr opt,
288	struct netlink_ext_ack *extack)
289	{
290	struct fq_pie_sched_data *q = qdisc_priv(sch);
291	struct nlattr *tb[TCA_FQ_PIE_MAX + 1];
292	unsigned int len_dropped = 0;
293	unsigned int num_dropped = 0;
294	int err;
295
ec97ecf1 MT	296	err = nla_parse_nested(tb, TCA_FQ_PIE_MAX, opt, fq_pie_policy, extack);
	297	if (err < 0)
	298	return err;
	299
	300	sch_tree_lock(sch);
	301	if (tb[TCA_FQ_PIE_LIMIT]) {
	302	u32 limit = nla_get_u32(tb[TCA_FQ_PIE_LIMIT]);
	303
13a9965d ED	304	WRITE_ONCE(q->p_params.limit, limit);
13a9965d ED	305	WRITE_ONCE(sch->limit, limit);
ec97ecf1 MT	306	}
	307	if (tb[TCA_FQ_PIE_FLOWS]) {
	308	if (q->flows) {
	309	NL_SET_ERR_MSG_MOD(extack,
	310	"Number of flows cannot be changed");
	311	goto flow_error;
	312	}
	313	q->flows_cnt = nla_get_u32(tb[TCA_FQ_PIE_FLOWS]);
3a62fed2	314	if (!q->flows_cnt \|\| q->flows_cnt > 65536) {
ec97ecf1	315	NL_SET_ERR_MSG_MOD(extack,
3a62fed2	316	"Number of flows must range in [1..65536]");
ec97ecf1 MT	317	goto flow_error;
	318	}
	319	}
	320
	321	/* convert from microseconds to pschedtime */
	322	if (tb[TCA_FQ_PIE_TARGET]) {
	323	/* target is in us */
	324	u32 target = nla_get_u32(tb[TCA_FQ_PIE_TARGET]);
	325
	326	/* convert to pschedtime */
13a9965d ED	327	WRITE_ONCE(q->p_params.target,
13a9965d ED	328	PSCHED_NS2TICKS((u64)target * NSEC_PER_USEC));
ec97ecf1 MT	329	}
	330
	331	/* tupdate is in jiffies */
	332	if (tb[TCA_FQ_PIE_TUPDATE])
13a9965d ED	333	WRITE_ONCE(q->p_params.tupdate,
13a9965d ED	334	usecs_to_jiffies(nla_get_u32(tb[TCA_FQ_PIE_TUPDATE])));
ec97ecf1 MT	335
ec97ecf1 MT	336	if (tb[TCA_FQ_PIE_ALPHA])
13a9965d ED	337	WRITE_ONCE(q->p_params.alpha,
13a9965d ED	338	nla_get_u32(tb[TCA_FQ_PIE_ALPHA]));
ec97ecf1 MT	339
ec97ecf1 MT	340	if (tb[TCA_FQ_PIE_BETA])
13a9965d ED	341	WRITE_ONCE(q->p_params.beta,
13a9965d ED	342	nla_get_u32(tb[TCA_FQ_PIE_BETA]));
ec97ecf1 MT	343
ec97ecf1 MT	344	if (tb[TCA_FQ_PIE_QUANTUM])
13a9965d	345	WRITE_ONCE(q->quantum, nla_get_u32(tb[TCA_FQ_PIE_QUANTUM]));
ec97ecf1 MT	346
ec97ecf1 MT	347	if (tb[TCA_FQ_PIE_MEMORY_LIMIT])
13a9965d ED	348	WRITE_ONCE(q->memory_limit,
13a9965d ED	349	nla_get_u32(tb[TCA_FQ_PIE_MEMORY_LIMIT]));
ec97ecf1 MT	350
ec97ecf1 MT	351	if (tb[TCA_FQ_PIE_ECN_PROB])
13a9965d ED	352	WRITE_ONCE(q->ecn_prob,
13a9965d ED	353	nla_get_u32(tb[TCA_FQ_PIE_ECN_PROB]));
ec97ecf1 MT	354
ec97ecf1 MT	355	if (tb[TCA_FQ_PIE_ECN])
13a9965d ED	356	WRITE_ONCE(q->p_params.ecn,
13a9965d ED	357	nla_get_u32(tb[TCA_FQ_PIE_ECN]));
ec97ecf1 MT	358
ec97ecf1 MT	359	if (tb[TCA_FQ_PIE_BYTEMODE])
13a9965d ED	360	WRITE_ONCE(q->p_params.bytemode,
13a9965d ED	361	nla_get_u32(tb[TCA_FQ_PIE_BYTEMODE]));
ec97ecf1 MT	362
ec97ecf1 MT	363	if (tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR])
13a9965d ED	364	WRITE_ONCE(q->p_params.dq_rate_estimator,
13a9965d ED	365	nla_get_u32(tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR]));
ec97ecf1 MT	366
	367	/* Drop excess packets if new limit is lower */
	368	while (sch->q.qlen > sch->limit) {
2d3cbfd6	369	struct sk_buff *skb = qdisc_dequeue_internal(sch, false);
ec97ecf1	370
ec97ecf1 MT	371	len_dropped += qdisc_pkt_len(skb);
ec97ecf1 MT	372	num_dropped += 1;
7a02ea65	373	rtnl_kfree_skbs(skb, skb);
ec97ecf1 MT	374	}
	375	qdisc_tree_reduce_backlog(sch, num_dropped, len_dropped);
	376
	377	sch_tree_unlock(sch);
	378	return 0;
	379
	380	flow_error:
	381	sch_tree_unlock(sch);
	382	return -EINVAL;
	383	}
	384
	385	static void fq_pie_timer(struct timer_list *t)
	386	{
41cb0855	387	struct fq_pie_sched_data *q = timer_container_of(q, t, adapt_timer);
8c21ab1b	388	unsigned long next, tupdate;
ec97ecf1 MT	389	struct Qdisc *sch = q->sch;
ec97ecf1 MT	390	spinlock_t root_lock; / to lock qdisc for probability calculations */
8c21ab1b	391	int max_cnt, i;
ec97ecf1	392
d636fc5d	393	rcu_read_lock();
ec97ecf1 MT	394	root_lock = qdisc_lock(qdisc_root_sleeping(sch));
	395	spin_lock(root_lock);
	396
8c21ab1b ED	397	/* Limit this expensive loop to 2048 flows per round. */
	398	max_cnt = min_t(int, q->flows_cnt - q->flows_cursor, 2048);
	399	for (i = 0; i < max_cnt; i++) {
	400	pie_calculate_probability(&q->p_params,
	401	&q->flows[q->flows_cursor].vars,
	402	q->flows[q->flows_cursor].backlog);
	403	q->flows_cursor++;
	404	}
ec97ecf1	405
8c21ab1b ED	406	tupdate = q->p_params.tupdate;
	407	next = 0;
	408	if (q->flows_cursor >= q->flows_cnt) {
	409	q->flows_cursor = 0;
	410	next = tupdate;
	411	}
	412	if (tupdate)
	413	mod_timer(&q->adapt_timer, jiffies + next);
ec97ecf1	414	spin_unlock(root_lock);
d636fc5d	415	rcu_read_unlock();
ec97ecf1 MT	416	}
	417
	418	static int fq_pie_init(struct Qdisc sch, struct nlattr opt,
	419	struct netlink_ext_ack *extack)
	420	{
	421	struct fq_pie_sched_data *q = qdisc_priv(sch);
	422	int err;
3a62fed2	423	u32 idx;
ec97ecf1 MT	424
	425	pie_params_init(&q->p_params);
	426	sch->limit = 10 * 1024;
	427	q->p_params.limit = sch->limit;
	428	q->quantum = psched_mtu(qdisc_dev(sch));
	429	q->sch = sch;
	430	q->ecn_prob = 10;
	431	q->flows_cnt = 1024;
	432	q->memory_limit = SZ_32M;
	433
	434	INIT_LIST_HEAD(&q->new_flows);
	435	INIT_LIST_HEAD(&q->old_flows);
4eef8b1f	436	timer_setup(&q->adapt_timer, fq_pie_timer, 0);
ec97ecf1 MT	437
	438	if (opt) {
	439	err = fq_pie_change(sch, opt, extack);
	440
	441	if (err)
	442	return err;
	443	}
	444
	445	err = tcf_block_get(&q->block, &q->filter_list, sch, extack);
	446	if (err)
	447	goto init_failure;
	448
	449	q->flows = kvcalloc(q->flows_cnt, sizeof(struct fq_pie_flow),
	450	GFP_KERNEL);
	451	if (!q->flows) {
	452	err = -ENOMEM;
	453	goto init_failure;
	454	}
	455	for (idx = 0; idx < q->flows_cnt; idx++) {
	456	struct fq_pie_flow *flow = q->flows + idx;
	457
	458	INIT_LIST_HEAD(&flow->flowchain);
	459	pie_vars_init(&flow->vars);
	460	}
	461
ec97ecf1 MT	462	mod_timer(&q->adapt_timer, jiffies + HZ / 2);
	463
	464	return 0;
	465
	466	init_failure:
	467	q->flows_cnt = 0;
	468
	469	return err;
	470	}
	471
	472	static int fq_pie_dump(struct Qdisc sch, struct sk_buff skb)
	473	{
	474	struct fq_pie_sched_data *q = qdisc_priv(sch);
	475	struct nlattr *opts;
	476
	477	opts = nla_nest_start(skb, TCA_OPTIONS);
	478	if (!opts)
	479	return -EMSGSIZE;
	480
	481	/* convert target from pschedtime to us */
13a9965d ED	482	if (nla_put_u32(skb, TCA_FQ_PIE_LIMIT, READ_ONCE(sch->limit)) \|\|
13a9965d ED	483	nla_put_u32(skb, TCA_FQ_PIE_FLOWS, READ_ONCE(q->flows_cnt)) \|\|
ec97ecf1	484	nla_put_u32(skb, TCA_FQ_PIE_TARGET,
13a9965d	485	((u32)PSCHED_TICKS2NS(READ_ONCE(q->p_params.target))) /
ec97ecf1 MT	486	NSEC_PER_USEC) \|\|
ec97ecf1 MT	487	nla_put_u32(skb, TCA_FQ_PIE_TUPDATE,
13a9965d ED	488	jiffies_to_usecs(READ_ONCE(q->p_params.tupdate))) \|\|
	489	nla_put_u32(skb, TCA_FQ_PIE_ALPHA, READ_ONCE(q->p_params.alpha)) \|\|
	490	nla_put_u32(skb, TCA_FQ_PIE_BETA, READ_ONCE(q->p_params.beta)) \|\|
	491	nla_put_u32(skb, TCA_FQ_PIE_QUANTUM, READ_ONCE(q->quantum)) \|\|
	492	nla_put_u32(skb, TCA_FQ_PIE_MEMORY_LIMIT,
	493	READ_ONCE(q->memory_limit)) \|\|
	494	nla_put_u32(skb, TCA_FQ_PIE_ECN_PROB, READ_ONCE(q->ecn_prob)) \|\|
	495	nla_put_u32(skb, TCA_FQ_PIE_ECN, READ_ONCE(q->p_params.ecn)) \|\|
	496	nla_put_u32(skb, TCA_FQ_PIE_BYTEMODE, READ_ONCE(q->p_params.bytemode)) \|\|
ec97ecf1	497	nla_put_u32(skb, TCA_FQ_PIE_DQ_RATE_ESTIMATOR,
13a9965d	498	READ_ONCE(q->p_params.dq_rate_estimator)))
ec97ecf1 MT	499	goto nla_put_failure;
	500
	501	return nla_nest_end(skb, opts);
	502
	503	nla_put_failure:
	504	nla_nest_cancel(skb, opts);
	505	return -EMSGSIZE;
	506	}
	507
	508	static int fq_pie_dump_stats(struct Qdisc sch, struct gnet_dump d)
	509	{
	510	struct fq_pie_sched_data *q = qdisc_priv(sch);
	511	struct tc_fq_pie_xstats st = {
	512	.packets_in = q->stats.packets_in,
	513	.overlimit = q->stats.overlimit,
	514	.overmemory = q->overmemory,
	515	.dropped = q->stats.dropped,
	516	.ecn_mark = q->stats.ecn_mark,
	517	.new_flow_count = q->new_flow_count,
	518	.memory_usage = q->memory_usage,
	519	};
	520	struct list_head *pos;
	521
	522	sch_tree_lock(sch);
	523	list_for_each(pos, &q->new_flows)
	524	st.new_flows_len++;
	525
	526	list_for_each(pos, &q->old_flows)
	527	st.old_flows_len++;
	528	sch_tree_unlock(sch);
	529
	530	return gnet_stats_copy_app(d, &st, sizeof(st));
	531	}
	532
	533	static void fq_pie_reset(struct Qdisc *sch)
	534	{
	535	struct fq_pie_sched_data *q = qdisc_priv(sch);
3a62fed2	536	u32 idx;
ec97ecf1 MT	537
	538	INIT_LIST_HEAD(&q->new_flows);
	539	INIT_LIST_HEAD(&q->old_flows);
	540	for (idx = 0; idx < q->flows_cnt; idx++) {
	541	struct fq_pie_flow *flow = q->flows + idx;
	542
	543	/* Removes all packets from flow */
	544	rtnl_kfree_skbs(flow->head, flow->tail);
	545	flow->head = NULL;
	546
	547	INIT_LIST_HEAD(&flow->flowchain);
	548	pie_vars_init(&flow->vars);
	549	}
ec97ecf1 MT	550	}
	551
	552	static void fq_pie_destroy(struct Qdisc *sch)
	553	{
	554	struct fq_pie_sched_data *q = qdisc_priv(sch);
	555
	556	tcf_block_put(q->block);
61c24026	557	q->p_params.tupdate = 0;
8fa7292f	558	timer_delete_sync(&q->adapt_timer);
ec97ecf1 MT	559	kvfree(q->flows);
	560	}
	561
	562	static struct Qdisc_ops fq_pie_qdisc_ops __read_mostly = {
	563	.id = "fq_pie",
	564	.priv_size = sizeof(struct fq_pie_sched_data),
	565	.enqueue = fq_pie_qdisc_enqueue,
	566	.dequeue = fq_pie_qdisc_dequeue,
	567	.peek = qdisc_peek_dequeued,
	568	.init = fq_pie_init,
	569	.destroy = fq_pie_destroy,
	570	.reset = fq_pie_reset,
	571	.change = fq_pie_change,
	572	.dump = fq_pie_dump,
	573	.dump_stats = fq_pie_dump_stats,
	574	.owner = THIS_MODULE,
	575	};
9474c62a	576	MODULE_ALIAS_NET_SCH("fq_pie");
ec97ecf1 MT	577
	578	static int __init fq_pie_module_init(void)
	579	{
	580	return register_qdisc(&fq_pie_qdisc_ops);
	581	}
	582
	583	static void __exit fq_pie_module_exit(void)
	584	{
	585	unregister_qdisc(&fq_pie_qdisc_ops);
	586	}
	587
	588	module_init(fq_pie_module_init);
	589	module_exit(fq_pie_module_exit);
	590
	591	MODULE_DESCRIPTION("Flow Queue Proportional Integral controller Enhanced (FQ-PIE)");
	592	MODULE_AUTHOR("Mohit P. Tahiliani");
	593	MODULE_LICENSE("GPL");