net: dsa: report and change port default priority using dcbnl

The port-based default QoS class is assigned to packets that lack a
VLAN PCP (or the port is configured to not trust the VLAN PCP),
an IP DSCP (or the port is configured to not trust IP DSCP), and packets
on which no tc-skbedit action has matched.

Similar to other drivers, this can be exposed to user space using the
DCB Application Priority Table. IEEE 802.1Q-2018 specifies in Table
D-8 - Sel field values that when the Selector is 1, the Protocol ID
value of 0 denotes the "Default application priority. For use when
application priority is not otherwise specified."

The way in which the dcbnl integration in DSA has been designed has to
do with its requirements. Andrew Lunn explains that SOHO switches are
expected to come with some sort of pre-configured QoS profile, and that
it is desirable for this to come pre-loaded into the DSA slave interfaces'
DCB application priority table.

In the dcbnl design, this is possible because calls to dcb_ieee_setapp()
can be initiated by anyone including being self-initiated by this device
driver.

However, what makes this challenging to implement in DSA is that the DSA
core manages the net_devices (effectively hiding them from drivers),
while drivers manage the hardware. The DSA core has no knowledge of what
individual drivers' QoS policies are. DSA could export to drivers a
wrapper over dcb_ieee_setapp() and these could call that function to
pre-populate the app priority table, however drivers don't have a good
moment in time to do this. The dsa_switch_ops :: setup() method gets
called before the net_devices are created (dsa_slave_create), and so is
dsa_switch_ops :: port_setup(). What remains is dsa_switch_ops ::
port_enable(), but this gets called upon each ndo_open. If we add app
table entries on every open, we'd need to remove them on close, to avoid
duplicate entry errors. But if we delete app priority entries on close,
what we delete may not be the initial, driver pre-populated entries, but
rather user-added entries.

So it is clear that letting drivers choose the timing of the
dcb_ieee_setapp() call is inappropriate. The alternative which was
chosen is to introduce hardware-specific ops in dsa_switch_ops, and
effectively hide dcbnl details from drivers as well. For pre-populating
the application table, dsa_slave_dcbnl_init() will call
ds->ops->port_get_default_prio() which is supposed to read from
hardware. If the operation succeeds, DSA creates a default-prio app
table entry. The method is called as soon as the slave_dev is
registered, but before we release the rtnl_mutex. This is done such that
user space sees the app table entries as soon as it sees the interface
being registered.

The fact that we populate slave_dev->dcbnl_ops with a non-NULL pointer
changes behavior in dcb_doit() from net/dcb/dcbnl.c, which used to
return -EOPNOTSUPP for any dcbnl operation where netdev->dcbnl_ops is
NULL. Because there are still dcbnl-unaware DSA drivers even if they
have dcbnl_ops populated, the way to restore the behavior is to make all
dcbnl_ops return -EOPNOTSUPP on absence of the hardware-specific
dsa_switch_ops method.

The dcbnl framework absurdly allows there to be more than one app table
entry for the same selector and protocol (in other words, more than one
port-based default priority). In the iproute2 dcb program, there is a
"replace" syntactical sugar command which performs an "add" and a "del"
to hide this away. But we choose the largest configured priority when we
call ds->ops->port_set_default_prio(), using __fls(). When there is no
default-prio app table entry left, the port-default priority is restored
to 0.

Link: https://patchwork.kernel.org/project/netdevbpf/patch/20210113154139.1803705-2-olteanv@gmail.com/
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/dsa.h b/include/net/dsa.h
index 9d16505..1220af7 100644 (file)
--- a/include/net/dsa.h
+++ b/include/net/dsa.h
@@ -893,6 +893,13 @@ struct dsa_switch_ops {
                               struct ethtool_ts_info *ts);
 
        /*
+        * DCB ops
+        */
+       int     (*port_get_default_prio)(struct dsa_switch *ds, int port);
+       int     (*port_set_default_prio)(struct dsa_switch *ds, int port,
+                                        u8 prio);
+
+       /*
         * Suspend and resume
         */
        int     (*suspend)(struct dsa_switch *ds);

diff --git a/net/dsa/slave.c b/net/dsa/slave.c
index a61a7c5..97f5da8 100644 (file)
--- a/net/dsa/slave.c
+++ b/net/dsa/slave.c
@@ -19,6 +19,7 @@
 #include <net/tc_act/tc_mirred.h>
 #include <linux/if_bridge.h>
 #include <linux/if_hsr.h>
+#include <net/dcbnl.h>
 #include <linux/netpoll.h>
 
 #include "dsa_priv.h"
@@ -1852,6 +1853,123 @@ out_master_failed:
        return err;
 }
 
+static int __maybe_unused
+dsa_slave_dcbnl_set_default_prio(struct net_device *dev, struct dcb_app *app)
+{
+       struct dsa_port *dp = dsa_slave_to_port(dev);
+       struct dsa_switch *ds = dp->ds;
+       unsigned long mask, new_prio;
+       int err, port = dp->index;
+
+       if (!ds->ops->port_set_default_prio)
+               return -EOPNOTSUPP;
+
+       err = dcb_ieee_setapp(dev, app);
+       if (err)
+               return err;
+
+       mask = dcb_ieee_getapp_mask(dev, app);
+       new_prio = __fls(mask);
+
+       err = ds->ops->port_set_default_prio(ds, port, new_prio);
+       if (err) {
+               dcb_ieee_delapp(dev, app);
+               return err;
+       }
+
+       return 0;
+}
+
+static int __maybe_unused dsa_slave_dcbnl_ieee_setapp(struct net_device *dev,
+                                                     struct dcb_app *app)
+{
+       switch (app->selector) {
+       case IEEE_8021QAZ_APP_SEL_ETHERTYPE:
+               switch (app->protocol) {
+               case 0:
+                       return dsa_slave_dcbnl_set_default_prio(dev, app);
+               default:
+                       return -EOPNOTSUPP;
+               }
+               break;
+       default:
+               return -EOPNOTSUPP;
+       }
+}
+
+static int __maybe_unused
+dsa_slave_dcbnl_del_default_prio(struct net_device *dev, struct dcb_app *app)
+{
+       struct dsa_port *dp = dsa_slave_to_port(dev);
+       struct dsa_switch *ds = dp->ds;
+       unsigned long mask, new_prio;
+       int err, port = dp->index;
+
+       if (!ds->ops->port_set_default_prio)
+               return -EOPNOTSUPP;
+
+       err = dcb_ieee_delapp(dev, app);
+       if (err)
+               return err;
+
+       mask = dcb_ieee_getapp_mask(dev, app);
+       new_prio = mask ? __fls(mask) : 0;
+
+       err = ds->ops->port_set_default_prio(ds, port, new_prio);
+       if (err) {
+               dcb_ieee_setapp(dev, app);
+               return err;
+       }
+
+       return 0;
+}
+
+static int __maybe_unused dsa_slave_dcbnl_ieee_delapp(struct net_device *dev,
+                                                     struct dcb_app *app)
+{
+       switch (app->selector) {
+       case IEEE_8021QAZ_APP_SEL_ETHERTYPE:
+               switch (app->protocol) {
+               case 0:
+                       return dsa_slave_dcbnl_del_default_prio(dev, app);
+               default:
+                       return -EOPNOTSUPP;
+               }
+               break;
+       default:
+               return -EOPNOTSUPP;
+       }
+}
+
+/* Pre-populate the DCB application priority table with the priorities
+ * configured during switch setup, which we read from hardware here.
+ */
+static int dsa_slave_dcbnl_init(struct net_device *dev)
+{
+       struct dsa_port *dp = dsa_slave_to_port(dev);
+       struct dsa_switch *ds = dp->ds;
+       int port = dp->index;
+       int err;
+
+       if (ds->ops->port_get_default_prio) {
+               int prio = ds->ops->port_get_default_prio(ds, port);
+               struct dcb_app app = {
+                       .selector = IEEE_8021QAZ_APP_SEL_ETHERTYPE,
+                       .protocol = 0,
+                       .priority = prio,
+               };
+
+               if (prio < 0)
+                       return prio;
+
+               err = dcb_ieee_setapp(dev, &app);
+               if (err)
+                       return err;
+       }
+
+       return 0;
+}
+
 static const struct ethtool_ops dsa_slave_ethtool_ops = {
        .get_drvinfo            = dsa_slave_get_drvinfo,
        .get_regs_len           = dsa_slave_get_regs_len,
@@ -1881,6 +1999,11 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = {
        .self_test              = dsa_slave_net_selftest,
 };
 
+static const struct dcbnl_rtnl_ops __maybe_unused dsa_slave_dcbnl_ops = {
+       .ieee_setapp            = dsa_slave_dcbnl_ieee_setapp,
+       .ieee_delapp            = dsa_slave_dcbnl_ieee_delapp,
+};
+
 static struct devlink_port *dsa_slave_get_devlink_port(struct net_device *dev)
 {
        struct dsa_port *dp = dsa_slave_to_port(dev);
@@ -2105,6 +2228,9 @@ int dsa_slave_create(struct dsa_port *port)
                return -ENOMEM;
 
        slave_dev->ethtool_ops = &dsa_slave_ethtool_ops;
+#if IS_ENABLED(CONFIG_DCB)
+       slave_dev->dcbnl_ops = &dsa_slave_dcbnl_ops;
+#endif
        if (!is_zero_ether_addr(port->mac))
                eth_hw_addr_set(slave_dev, port->mac);
        else
@@ -2162,6 +2288,17 @@ int dsa_slave_create(struct dsa_port *port)
                goto out_phy;
        }
 
+       if (IS_ENABLED(CONFIG_DCB)) {
+               ret = dsa_slave_dcbnl_init(slave_dev);
+               if (ret) {
+                       netdev_err(slave_dev,
+                                  "failed to initialize DCB: %pe\n",
+                                  ERR_PTR(ret));
+                       rtnl_unlock();
+                       goto out_unregister;
+               }
+       }
+
        ret = netdev_upper_dev_link(master, slave_dev, NULL);
 
        rtnl_unlock();