Commit 4e8b86c0 authored by Amritha Nambiar's avatar Amritha Nambiar Committed by Jeff Kirsher
Browse files

mqprio: Introduce new hardware offload mode and shaper in mqprio 



The offload types currently supported in mqprio are 0 (no offload) and
1 (offload only TCs) by setting these values for the 'hw' option. If
offloads are supported by setting the 'hw' option to 1, the default
offload mode is 'dcb' where only the TC values are offloaded to the
device. This patch introduces a new hardware offload mode called
'channel' with 'hw' set to 1 in mqprio which makes full use of the
mqprio options, the TCs, the queue configurations and the QoS parameters
for the TCs. This is achieved through a new netlink attribute for the
'mode' option which takes values such as 'dcb' (default) and 'channel'.
The 'channel' mode also supports QoS attributes for traffic class such as
minimum and maximum values for bandwidth rate limits.

This patch enables configuring additional HW shaper attributes associated
with a traffic class. Currently the shaper for bandwidth rate limiting is
supported which takes options such as minimum and maximum bandwidth rates
and are offloaded to the hardware in the 'channel' mode. The min and max
limits for bandwidth rates are provided by the user along with the TCs
and the queue configurations when creating the mqprio qdisc. The interface
can be extended to support new HW shapers in future through the 'shaper'
attribute.

Introduces a new data structure 'tc_mqprio_qopt_offload' for offloading
mqprio queue options and use this to be shared between the kernel and
device driver. This contains a copy of the existing data structure
for mqprio queue options. This new data structure can be extended when
adding new attributes for traffic class such as mode, shaper, shaper
parameters (bandwidth rate limits). The existing data structure for mqprio
queue options will be shared between the kernel and userspace.

Example:
  queues 4@0 4@4 hw 1 mode channel shaper bw_rlimit\
  min_rate 1Gbit 2Gbit max_rate 4Gbit 5Gbit

To dump the bandwidth rates:

qdisc mqprio 804a: root  tc 2 map 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0
             queues:(0:3) (4:7)
             mode:channel
             shaper:bw_rlimit   min_rate:1Gbit 2Gbit   max_rate:4Gbit 5Gbit

Signed-off-by: default avatarAmritha Nambiar <amritha.nambiar@intel.com>
Tested-by: default avatarAndrew Bowers <andrewx.bowers@intel.com>
Signed-off-by: default avatarJeff Kirsher <jeffrey.t.kirsher@intel.com>
parent a00344bd

include/net/pkt_cls.h

+9 −0
Original line number Diff line number Diff line
@@ -546,6 +546,15 @@ struct tc_cls_bpf_offload { 
	u32 gen_flags;

};



struct tc_mqprio_qopt_offload {

	/* struct tc_mqprio_qopt must always be the first element */

	struct tc_mqprio_qopt qopt;

	u16 mode;

	u16 shaper;

	u32 flags;

	u64 min_rate[TC_QOPT_MAX_QUEUE];

	u64 max_rate[TC_QOPT_MAX_QUEUE];

};



/* This structure holds cookie structure that is passed from user

 * to the kernel for actions and classifiers

include/uapi/linux/pkt_sched.h

+32 −0
Original line number Diff line number Diff line
@@ -625,6 +625,22 @@ enum { 


#define TC_MQPRIO_HW_OFFLOAD_MAX (__TC_MQPRIO_HW_OFFLOAD_MAX - 1)



enum {

	TC_MQPRIO_MODE_DCB,

	TC_MQPRIO_MODE_CHANNEL,

	__TC_MQPRIO_MODE_MAX

};



#define __TC_MQPRIO_MODE_MAX (__TC_MQPRIO_MODE_MAX - 1)



enum {

	TC_MQPRIO_SHAPER_DCB,

	TC_MQPRIO_SHAPER_BW_RATE,	/* Add new shapers below */

	__TC_MQPRIO_SHAPER_MAX

};



#define __TC_MQPRIO_SHAPER_MAX (__TC_MQPRIO_SHAPER_MAX - 1)



struct tc_mqprio_qopt {

	__u8	num_tc;

	__u8	prio_tc_map[TC_QOPT_BITMASK + 1];
@@ -633,6 +649,22 @@ struct tc_mqprio_qopt { 
	__u16	offset[TC_QOPT_MAX_QUEUE];

};



#define TC_MQPRIO_F_MODE		0x1

#define TC_MQPRIO_F_SHAPER		0x2

#define TC_MQPRIO_F_MIN_RATE		0x4

#define TC_MQPRIO_F_MAX_RATE		0x8



enum {

	TCA_MQPRIO_UNSPEC,

	TCA_MQPRIO_MODE,

	TCA_MQPRIO_SHAPER,

	TCA_MQPRIO_MIN_RATE64,

	TCA_MQPRIO_MAX_RATE64,

	__TCA_MQPRIO_MAX,

};



#define TCA_MQPRIO_MAX (__TCA_MQPRIO_MAX - 1)



/* SFB */



enum {

net/sched/sch_mqprio.c

+174 −9
Original line number Diff line number Diff line
@@ -18,10 +18,16 @@ 
#include <net/netlink.h>

#include <net/pkt_sched.h>

#include <net/sch_generic.h>

#include <net/pkt_cls.h>



struct mqprio_sched {

	struct Qdisc		**qdiscs;

	u16 mode;

	u16 shaper;

	int hw_offload;

	u32 flags;

	u64 min_rate[TC_QOPT_MAX_QUEUE];

	u64 max_rate[TC_QOPT_MAX_QUEUE];

};



static void mqprio_destroy(struct Qdisc *sch)
@@ -39,9 +45,17 @@ static void mqprio_destroy(struct Qdisc *sch) 
	}



	if (priv->hw_offload && dev->netdev_ops->ndo_setup_tc) {

		struct tc_mqprio_qopt mqprio = {};

		struct tc_mqprio_qopt_offload mqprio = { { 0 } };



		dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_MQPRIO, &mqprio);

		switch (priv->mode) {

		case TC_MQPRIO_MODE_DCB:

		case TC_MQPRIO_MODE_CHANNEL:

			dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_MQPRIO,

						      &mqprio);

			break;

		default:

			return;

		}

	} else {

		netdev_set_num_tc(dev, 0);

	}
@@ -97,6 +111,26 @@ static int mqprio_parse_opt(struct net_device *dev, struct tc_mqprio_qopt *qopt) 
	return 0;

}



static const struct nla_policy mqprio_policy[TCA_MQPRIO_MAX + 1] = {

	[TCA_MQPRIO_MODE]	= { .len = sizeof(u16) },

	[TCA_MQPRIO_SHAPER]	= { .len = sizeof(u16) },

	[TCA_MQPRIO_MIN_RATE64]	= { .type = NLA_NESTED },

	[TCA_MQPRIO_MAX_RATE64]	= { .type = NLA_NESTED },

};



static int parse_attr(struct nlattr *tb[], int maxtype, struct nlattr *nla,

		      const struct nla_policy *policy, int len)

{

	int nested_len = nla_len(nla) - NLA_ALIGN(len);



	if (nested_len >= nla_attr_size(0))

		return nla_parse(tb, maxtype, nla_data(nla) + NLA_ALIGN(len),

				 nested_len, policy, NULL);



	memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));

	return 0;

}



static int mqprio_init(struct Qdisc *sch, struct nlattr *opt)

{

	struct net_device *dev = qdisc_dev(sch);
@@ -105,6 +139,10 @@ static int mqprio_init(struct Qdisc *sch, struct nlattr *opt) 
	struct Qdisc *qdisc;

	int i, err = -EOPNOTSUPP;

	struct tc_mqprio_qopt *qopt = NULL;

	struct nlattr *tb[TCA_MQPRIO_MAX + 1];

	struct nlattr *attr;

	int rem;

	int len = nla_len(opt) - NLA_ALIGN(sizeof(*qopt));



	BUILD_BUG_ON(TC_MAX_QUEUE != TC_QOPT_MAX_QUEUE);

	BUILD_BUG_ON(TC_BITMASK != TC_QOPT_BITMASK);
@@ -122,6 +160,58 @@ static int mqprio_init(struct Qdisc *sch, struct nlattr *opt) 
	if (mqprio_parse_opt(dev, qopt))

		return -EINVAL;



	if (len > 0) {

		err = parse_attr(tb, TCA_MQPRIO_MAX, opt, mqprio_policy,

				 sizeof(*qopt));

		if (err < 0)

			return err;



		if (!qopt->hw)

			return -EINVAL;



		if (tb[TCA_MQPRIO_MODE]) {

			priv->flags |= TC_MQPRIO_F_MODE;

			priv->mode = *(u16 *)nla_data(tb[TCA_MQPRIO_MODE]);

		}



		if (tb[TCA_MQPRIO_SHAPER]) {

			priv->flags |= TC_MQPRIO_F_SHAPER;

			priv->shaper = *(u16 *)nla_data(tb[TCA_MQPRIO_SHAPER]);

		}



		if (tb[TCA_MQPRIO_MIN_RATE64]) {

			if (priv->shaper != TC_MQPRIO_SHAPER_BW_RATE)

				return -EINVAL;

			i = 0;

			nla_for_each_nested(attr, tb[TCA_MQPRIO_MIN_RATE64],

					    rem) {

				if (nla_type(attr) != TCA_MQPRIO_MIN_RATE64)

					return -EINVAL;

				if (i >= qopt->num_tc)

					break;

				priv->min_rate[i] = *(u64 *)nla_data(attr);

				i++;

			}

			priv->flags |= TC_MQPRIO_F_MIN_RATE;

		}



		if (tb[TCA_MQPRIO_MAX_RATE64]) {

			if (priv->shaper != TC_MQPRIO_SHAPER_BW_RATE)

				return -EINVAL;

			i = 0;

			nla_for_each_nested(attr, tb[TCA_MQPRIO_MAX_RATE64],

					    rem) {

				if (nla_type(attr) != TCA_MQPRIO_MAX_RATE64)

					return -EINVAL;

				if (i >= qopt->num_tc)

					break;

				priv->max_rate[i] = *(u64 *)nla_data(attr);

				i++;

			}

			priv->flags |= TC_MQPRIO_F_MAX_RATE;

		}

	}



	/* pre-allocate qdisc, attachment can't fail */

	priv->qdiscs = kcalloc(dev->num_tx_queues, sizeof(priv->qdiscs[0]),

			       GFP_KERNEL);
@@ -146,14 +236,36 @@ static int mqprio_init(struct Qdisc *sch, struct nlattr *opt) 
	 * supplied and verified mapping

	 */

	if (qopt->hw) {

		struct tc_mqprio_qopt mqprio = *qopt;

		struct tc_mqprio_qopt_offload mqprio = {.qopt = *qopt};



		err = dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_MQPRIO,

		switch (priv->mode) {

		case TC_MQPRIO_MODE_DCB:

			if (priv->shaper != TC_MQPRIO_SHAPER_DCB)

				return -EINVAL;

			break;

		case TC_MQPRIO_MODE_CHANNEL:

			mqprio.flags = priv->flags;

			if (priv->flags & TC_MQPRIO_F_MODE)

				mqprio.mode = priv->mode;

			if (priv->flags & TC_MQPRIO_F_SHAPER)

				mqprio.shaper = priv->shaper;

			if (priv->flags & TC_MQPRIO_F_MIN_RATE)

				for (i = 0; i < mqprio.qopt.num_tc; i++)

					mqprio.min_rate[i] = priv->min_rate[i];

			if (priv->flags & TC_MQPRIO_F_MAX_RATE)

				for (i = 0; i < mqprio.qopt.num_tc; i++)

					mqprio.max_rate[i] = priv->max_rate[i];

			break;

		default:

			return -EINVAL;

		}

		err = dev->netdev_ops->ndo_setup_tc(dev,

						    TC_SETUP_MQPRIO,

						    &mqprio);

		if (err)

			return err;



		priv->hw_offload = mqprio.hw;

		priv->hw_offload = mqprio.qopt.hw;

	} else {

		netdev_set_num_tc(dev, qopt->num_tc);

		for (i = 0; i < qopt->num_tc; i++)
@@ -223,11 +335,51 @@ static int mqprio_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new, 
	return 0;

}



static int dump_rates(struct mqprio_sched *priv,

		      struct tc_mqprio_qopt *opt, struct sk_buff *skb)

{

	struct nlattr *nest;

	int i;



	if (priv->flags & TC_MQPRIO_F_MIN_RATE) {

		nest = nla_nest_start(skb, TCA_MQPRIO_MIN_RATE64);

		if (!nest)

			goto nla_put_failure;



		for (i = 0; i < opt->num_tc; i++) {

			if (nla_put(skb, TCA_MQPRIO_MIN_RATE64,

				    sizeof(priv->min_rate[i]),

				    &priv->min_rate[i]))

				goto nla_put_failure;

		}

		nla_nest_end(skb, nest);

	}



	if (priv->flags & TC_MQPRIO_F_MAX_RATE) {

		nest = nla_nest_start(skb, TCA_MQPRIO_MAX_RATE64);

		if (!nest)

			goto nla_put_failure;



		for (i = 0; i < opt->num_tc; i++) {

			if (nla_put(skb, TCA_MQPRIO_MAX_RATE64,

				    sizeof(priv->max_rate[i]),

				    &priv->max_rate[i]))

				goto nla_put_failure;

		}

		nla_nest_end(skb, nest);

	}

	return 0;



nla_put_failure:

	nla_nest_cancel(skb, nest);

	return -1;

}



static int mqprio_dump(struct Qdisc *sch, struct sk_buff *skb)

{

	struct net_device *dev = qdisc_dev(sch);

	struct mqprio_sched *priv = qdisc_priv(sch);

	unsigned char *b = skb_tail_pointer(skb);

	struct nlattr *nla = (struct nlattr *)skb_tail_pointer(skb);

	struct tc_mqprio_qopt opt = { 0 };

	struct Qdisc *qdisc;

	unsigned int i;
@@ -258,12 +410,25 @@ static int mqprio_dump(struct Qdisc *sch, struct sk_buff *skb) 
		opt.offset[i] = dev->tc_to_txq[i].offset;

	}



	if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))

	if (nla_put(skb, TCA_OPTIONS, NLA_ALIGN(sizeof(opt)), &opt))

		goto nla_put_failure;



	if ((priv->flags & TC_MQPRIO_F_MODE) &&

	    nla_put_u16(skb, TCA_MQPRIO_MODE, priv->mode))

		goto nla_put_failure;



	if ((priv->flags & TC_MQPRIO_F_SHAPER) &&

	    nla_put_u16(skb, TCA_MQPRIO_SHAPER, priv->shaper))

		goto nla_put_failure;



	if ((priv->flags & TC_MQPRIO_F_MIN_RATE ||

	     priv->flags & TC_MQPRIO_F_MAX_RATE) &&

	    (dump_rates(priv, &opt, skb) != 0))

		goto nla_put_failure;



	return skb->len;

	return nla_nest_end(skb, nla);

nla_put_failure:

	nlmsg_trim(skb, b);

	nlmsg_trim(skb, nla);

	return -1;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE