Commit 4e500251 authored by Vladimir Oltean's avatar Vladimir Oltean Committed by David S. Miller
Browse files

net: dsa: generalize overhead for taggers that use both headers and trailers 



Some really really weird switches just couldn't decide whether to use a
normal or a tail tagger, so they just did both.

This creates problems for DSA, because we only have the concept of an
'overhead' which can be applied to the headroom or to the tailroom of
the skb (like for example during the central TX reallocation procedure),
depending on the value of bool tail_tag, but not to both.

We need to generalize DSA to cater for these odd switches by
transforming the 'overhead / tail_tag' pair into 'needed_headroom /
needed_tailroom'.

The DSA master's MTU is increased to account for both.

The flow dissector code is modified such that it only calls the DSA
adjustment callback if the tagger has a non-zero header length.

Taggers are trivially modified to declare either needed_headroom or
needed_tailroom, based on the tail_tag value that they currently
declare.

Signed-off-by: default avatarVladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 6c0de59b

Documentation/networking/dsa/dsa.rst

+11 −10
Original line number Diff line number Diff line
@@ -93,14 +93,15 @@ A tagging protocol may tag all packets with switch tags of the same length, or 
the tag length might vary (for example packets with PTP timestamps might

require an extended switch tag, or there might be one tag length on TX and a

different one on RX). Either way, the tagging protocol driver must populate the

``struct dsa_device_ops::overhead`` with the length in octets of the longest

switch frame header. The DSA framework will automatically adjust the MTU of the

master interface to accomodate for this extra size in order for DSA user ports

to support the standard MTU (L2 payload length) of 1500 octets. The ``overhead``

is also used to request from the network stack, on a best-effort basis, the

allocation of packets with a ``needed_headroom`` or ``needed_tailroom``

sufficient such that the act of pushing the switch tag on transmission of a

packet does not cause it to reallocate due to lack of memory.

``struct dsa_device_ops::needed_headroom`` and/or ``struct dsa_device_ops::needed_tailroom``

with the length in octets of the longest switch frame header/trailer. The DSA

framework will automatically adjust the MTU of the master interface to

accommodate for this extra size in order for DSA user ports to support the

standard MTU (L2 payload length) of 1500 octets. The ``needed_headroom`` and

``needed_tailroom`` properties are also used to request from the network stack,

on a best-effort basis, the allocation of packets with enough extra space such

that the act of pushing the switch tag on transmission of a packet does not

cause it to reallocate due to lack of memory.



Even though applications are not expected to parse DSA-specific frame headers,

the format on the wire of the tagging protocol represents an Application Binary
@@ -169,8 +170,8 @@ The job of this method is to prepare the skb in a way that the switch will 
understand what egress port the packet is for (and not deliver it towards other

ports). Typically this is fulfilled by pushing a frame header. Checking for

insufficient size in the skb headroom or tailroom is unnecessary provided that

the ``overhead`` and ``tail_tag`` properties were filled out properly, because

DSA ensures there is enough space before calling this method.

the ``needed_headroom`` and ``needed_tailroom`` properties were filled out

properly, because DSA ensures there is enough space before calling this method.



The reception of a packet goes through the tagger's ``rcv`` function. The

passed ``struct sk_buff *skb`` has ``skb->data`` pointing at

include/net/dsa.h

+3 −3
Original line number Diff line number Diff line
@@ -91,7 +91,8 @@ struct dsa_device_ops { 
	 * as regular on the master net device.

	 */

	bool (*filter)(const struct sk_buff *skb, struct net_device *dev);

	unsigned int overhead;

	unsigned int needed_headroom;

	unsigned int needed_tailroom;

	const char *name;

	enum dsa_tag_protocol proto;

	/* Some tagging protocols either mangle or shift the destination MAC
@@ -100,7 +101,6 @@ struct dsa_device_ops { 
	 * its RX filter.

	 */

	bool promisc_on_master;

	bool tail_tag;

};



/* This structure defines the control interfaces that are overlayed by the
@@ -926,7 +926,7 @@ static inline void dsa_tag_generic_flow_dissect(const struct sk_buff *skb, 
{

#if IS_ENABLED(CONFIG_NET_DSA)

	const struct dsa_device_ops *ops = skb->dev->dsa_ptr->tag_ops;

	int tag_len = ops->overhead;

	int tag_len = ops->needed_headroom;



	*offset = tag_len;

	*proto = ((__be16 *)skb->data)[(tag_len / 2) - 1];

net/core/flow_dissector.c

+1 −1
Original line number Diff line number Diff line
@@ -944,7 +944,7 @@ bool __skb_flow_dissect(const struct net *net, 


			ops = skb->dev->dsa_ptr->tag_ops;

			/* Tail taggers don't break flow dissection */

			if (!ops->tail_tag) {

			if (!ops->needed_headroom) {

				if (ops->flow_dissect)

					ops->flow_dissect(skb, &proto, &offset);

				else

net/dsa/dsa_priv.h

+5 −0
Original line number Diff line number Diff line
@@ -154,6 +154,11 @@ const struct dsa_device_ops *dsa_find_tagger_by_name(const char *buf); 
bool dsa_schedule_work(struct work_struct *work);

const char *dsa_tag_protocol_to_str(const struct dsa_device_ops *ops);



static inline int dsa_tag_protocol_overhead(const struct dsa_device_ops *ops)

{

	return ops->needed_headroom + ops->needed_tailroom;

}



/* master.c */

int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp);

void dsa_master_teardown(struct net_device *dev);

net/dsa/master.c

+4 −2
Original line number Diff line number Diff line
@@ -346,10 +346,12 @@ static struct lock_class_key dsa_master_addr_list_lock_key; 


int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp)

{

	int mtu = ETH_DATA_LEN + cpu_dp->tag_ops->overhead;

	const struct dsa_device_ops *tag_ops = cpu_dp->tag_ops;

	struct dsa_switch *ds = cpu_dp->ds;

	struct device_link *consumer_link;

	int ret;

	int mtu, ret;



	mtu = ETH_DATA_LEN + dsa_tag_protocol_overhead(tag_ops);



	/* The DSA master must use SET_NETDEV_DEV for this to work. */

	consumer_link = device_link_add(ds->dev, dev->dev.parent,