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: Amritha Nambiar <amritha.nambiar@intel.com>
Tested-by: Andrew Bowers <andrewx.bowers@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>

diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
index f5263743076b8fadfc187a36b650343f7e7b7eea..60d39789e4f07d19269df1acf2c57d1d6058b348 100644 (file)
--- a/include/net/pkt_cls.h
+++ b/include/net/pkt_cls.h
@@ -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

diff --git a/include/uapi/linux/pkt_sched.h b/include/uapi/linux/pkt_sched.h
index 099bf5528fed30008bfbde3529315be35c0411f9..e95b5c9b9fad9ad5eabb62fbdb707fd9def05cfb 100644 (file)
--- a/include/uapi/linux/pkt_sched.h
+++ b/include/uapi/linux/pkt_sched.h
@@ -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 {

diff --git a/net/sched/sch_mqprio.c b/net/sched/sch_mqprio.c
index 6bcdfe6e7b63a39e1c697043375fc3c4995a4a50..f1ae9be83934643c12a3b63a4a4779d3f43c44a7 100644 (file)
--- a/net/sched/sch_mqprio.c
+++ b/net/sched/sch_mqprio.c
@@ -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;
 }