diff mbox series

[net-next,v2,2/8] taprio: Add support for frame preemption offload

Message ID 20210119004028.2809425-3-vinicius.gomes@intel.com
State Superseded
Headers show
Series None | expand

Commit Message

Vinicius Costa Gomes Jan. 19, 2021, 12:40 a.m. UTC 
Adds a way to configure which traffic classes are marked as
preemptible and which are marked as express.

Even if frame preemption is not a "real" offload, because it can't be
executed purely in software, having this information near where the
mapping of traffic classes to queues is specified, makes it,
hopefully, easier to use.

taprio will receive the information of which traffic classes are
marked as express/preemptible, and when offloading frame preemption to
the driver will convert the information, so the driver receives which
queues are marked as express/preemptible.

Signed-off-by: Vinicius Costa Gomes <vinicius.gomes@intel.com>
---
 include/linux/netdevice.h      |  1 +
 include/net/pkt_sched.h        |  4 ++++
 include/uapi/linux/pkt_sched.h |  1 +
 net/sched/sch_taprio.c         | 41 ++++++++++++++++++++++++++++++----
 4 files changed, 43 insertions(+), 4 deletions(-)

Comments

Jakub Kicinski Jan. 20, 2021, 2:21 a.m. UTC | #1 
On Mon, 18 Jan 2021 16:40:22 -0800 Vinicius Costa Gomes wrote:
> Adds a way to configure which traffic classes are marked as

> preemptible and which are marked as express.

> 

> Even if frame preemption is not a "real" offload, because it can't be

> executed purely in software, having this information near where the

> mapping of traffic classes to queues is specified, makes it,

> hopefully, easier to use.

> 

> taprio will receive the information of which traffic classes are

> marked as express/preemptible, and when offloading frame preemption to

> the driver will convert the information, so the driver receives which

> queues are marked as express/preemptible.

> 

> Signed-off-by: Vinicius Costa Gomes <vinicius.gomes@intel.com>


> @@ -1286,13 +1289,15 @@ static int taprio_disable_offload(struct net_device *dev,

>  	offload->enable = 0;

>  

>  	err = ops->ndo_setup_tc(dev, TC_SETUP_QDISC_TAPRIO, offload);

> -	if (err < 0) {

> +	if (err < 0)

> +		NL_SET_ERR_MSG(extack,

> +			       "Device failed to disable offload");

> +

> +	err = ops->ndo_setup_tc(dev, TC_SETUP_PREEMPT, &preempt);

> +	if (err < 0)

>  		NL_SET_ERR_MSG(extack,

>  			       "Device failed to disable offload");


This was meant to say something else?

> -		goto out;

> -	}

>  

> -out:

>  	taprio_offload_free(offload);

>  

>  	return err;
Vinicius Costa Gomes Jan. 21, 2021, 11:17 p.m. UTC | #2 
Jakub Kicinski <kuba@kernel.org> writes:

> On Mon, 18 Jan 2021 16:40:22 -0800 Vinicius Costa Gomes wrote:

>> Adds a way to configure which traffic classes are marked as

>> preemptible and which are marked as express.

>> 

>> Even if frame preemption is not a "real" offload, because it can't be

>> executed purely in software, having this information near where the

>> mapping of traffic classes to queues is specified, makes it,

>> hopefully, easier to use.

>> 

>> taprio will receive the information of which traffic classes are

>> marked as express/preemptible, and when offloading frame preemption to

>> the driver will convert the information, so the driver receives which

>> queues are marked as express/preemptible.

>> 

>> Signed-off-by: Vinicius Costa Gomes <vinicius.gomes@intel.com>

>

>> @@ -1286,13 +1289,15 @@ static int taprio_disable_offload(struct net_device *dev,

>>  	offload->enable = 0;

>>  

>>  	err = ops->ndo_setup_tc(dev, TC_SETUP_QDISC_TAPRIO, offload);

>> -	if (err < 0) {

>> +	if (err < 0)

>> +		NL_SET_ERR_MSG(extack,

>> +			       "Device failed to disable offload");

>> +

>> +	err = ops->ndo_setup_tc(dev, TC_SETUP_PREEMPT, &preempt);

>> +	if (err < 0)

>>  		NL_SET_ERR_MSG(extack,

>>  			       "Device failed to disable offload");

>

> This was meant to say something else?


Yeah, better to say which offload failed to be disabled. Will fix.


Cheers,
-- 
Vinicius
diff mbox series

Patch

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 5b949076ed23..7388c20c07a8 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -858,6 +858,7 @@  enum tc_setup_type {
 	TC_SETUP_QDISC_ETS,
 	TC_SETUP_QDISC_TBF,
 	TC_SETUP_QDISC_FIFO,
+	TC_SETUP_PREEMPT,
 };
 
 /* These structures hold the attributes of bpf state that are being passed
diff --git a/include/net/pkt_sched.h b/include/net/pkt_sched.h
index 15b1b30f454e..be5ff1535332 100644
--- a/include/net/pkt_sched.h
+++ b/include/net/pkt_sched.h
@@ -183,6 +183,10 @@  struct tc_taprio_qopt_offload {
 	struct tc_taprio_sched_entry entries[];
 };
 
+struct tc_preempt_qopt_offload {
+	u32 preemptible_queues;
+};
+
 /* Reference counting */
 struct tc_taprio_qopt_offload *taprio_offload_get(struct tc_taprio_qopt_offload
 						  *offload);
diff --git a/include/uapi/linux/pkt_sched.h b/include/uapi/linux/pkt_sched.h
index 9e7c2c607845..9ca9d2e55557 100644
--- a/include/uapi/linux/pkt_sched.h
+++ b/include/uapi/linux/pkt_sched.h
@@ -1240,6 +1240,7 @@  enum {
 	TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME_EXTENSION, /* s64 */
 	TCA_TAPRIO_ATTR_FLAGS, /* u32 */
 	TCA_TAPRIO_ATTR_TXTIME_DELAY, /* u32 */
+	TCA_TAPRIO_ATTR_PREEMPT_TCS, /* u32 */
 	__TCA_TAPRIO_ATTR_MAX,
 };
 
diff --git a/net/sched/sch_taprio.c b/net/sched/sch_taprio.c
index 6f775275826a..e4b511a0ee38 100644
--- a/net/sched/sch_taprio.c
+++ b/net/sched/sch_taprio.c
@@ -64,6 +64,7 @@  struct taprio_sched {
 	struct Qdisc **qdiscs;
 	struct Qdisc *root;
 	u32 flags;
+	u32 preemptible_tcs;
 	enum tk_offsets tk_offset;
 	int clockid;
 	atomic64_t picos_per_byte; /* Using picoseconds because for 10Gbps+
@@ -776,6 +777,7 @@  static const struct nla_policy taprio_policy[TCA_TAPRIO_ATTR_MAX + 1] = {
 	[TCA_TAPRIO_ATTR_SCHED_CYCLE_TIME_EXTENSION] = { .type = NLA_S64 },
 	[TCA_TAPRIO_ATTR_FLAGS]                      = { .type = NLA_U32 },
 	[TCA_TAPRIO_ATTR_TXTIME_DELAY]		     = { .type = NLA_U32 },
+	[TCA_TAPRIO_ATTR_PREEMPT_TCS]                = { .type = NLA_U32 },
 };
 
 static int fill_sched_entry(struct taprio_sched *q, struct nlattr **tb,
@@ -1268,6 +1270,7 @@  static int taprio_disable_offload(struct net_device *dev,
 				  struct netlink_ext_ack *extack)
 {
 	const struct net_device_ops *ops = dev->netdev_ops;
+	struct tc_preempt_qopt_offload preempt = { };
 	struct tc_taprio_qopt_offload *offload;
 	int err;
 
@@ -1286,13 +1289,15 @@  static int taprio_disable_offload(struct net_device *dev,
 	offload->enable = 0;
 
 	err = ops->ndo_setup_tc(dev, TC_SETUP_QDISC_TAPRIO, offload);
-	if (err < 0) {
+	if (err < 0)
+		NL_SET_ERR_MSG(extack,
+			       "Device failed to disable offload");
+
+	err = ops->ndo_setup_tc(dev, TC_SETUP_PREEMPT, &preempt);
+	if (err < 0)
 		NL_SET_ERR_MSG(extack,
 			       "Device failed to disable offload");
-		goto out;
-	}
 
-out:
 	taprio_offload_free(offload);
 
 	return err;
@@ -1509,6 +1514,29 @@  static int taprio_change(struct Qdisc *sch, struct nlattr *opt,
 					       mqprio->prio_tc_map[i]);
 	}
 
+	/* It's valid to enable frame preemption without any kind of
+	 * offloading being enabled, so keep it separated.
+	 */
+	if (tb[TCA_TAPRIO_ATTR_PREEMPT_TCS]) {
+		u32 preempt = nla_get_u32(tb[TCA_TAPRIO_ATTR_PREEMPT_TCS]);
+		struct tc_preempt_qopt_offload qopt = { };
+
+		if (preempt == U32_MAX) {
+			NL_SET_ERR_MSG(extack, "At least one queue must be not be preemptible");
+			err = -EINVAL;
+			goto free_sched;
+		}
+
+		qopt.preemptible_queues = tc_map_to_queue_mask(dev, preempt);
+
+		err = dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_PREEMPT,
+						    &qopt);
+		if (err)
+			goto free_sched;
+
+		q->preemptible_tcs = preempt;
+	}
+
 	if (FULL_OFFLOAD_IS_ENABLED(q->flags))
 		err = taprio_enable_offload(dev, q, new_admin, extack);
 	else
@@ -1665,6 +1693,7 @@  static int taprio_init(struct Qdisc *sch, struct nlattr *opt,
 	 */
 	q->clockid = -1;
 	q->flags = TAPRIO_FLAGS_INVALID;
+	q->preemptible_tcs = U32_MAX;
 
 	spin_lock(&taprio_list_lock);
 	list_add(&q->taprio_list, &taprio_list);
@@ -1848,6 +1877,10 @@  static int taprio_dump(struct Qdisc *sch, struct sk_buff *skb)
 	if (q->flags && nla_put_u32(skb, TCA_TAPRIO_ATTR_FLAGS, q->flags))
 		goto options_error;
 
+	if (q->preemptible_tcs != U32_MAX &&
+	    nla_put_u32(skb, TCA_TAPRIO_ATTR_PREEMPT_TCS, q->preemptible_tcs))
+		goto options_error;
+
 	if (q->txtime_delay &&
 	    nla_put_u32(skb, TCA_TAPRIO_ATTR_TXTIME_DELAY, q->txtime_delay))
 		goto options_error;