net: dsa: felix: purge skb from TX timestamping queue if it cannot be sent

At present, when a PTP packet which requires TX timestamping gets
dropped under congestion by the switch, things go downhill very fast.
The driver keeps a clone of that skb in a queue of packets awaiting TX
timestamp interrupts, but interrupts will never be raised for the
dropped packets.

Moreover, matching timestamped packets to timestamps is done by a 2-bit
timestamp ID, and this can wrap around and we can match on the wrong skb.

Since with the default NPI-based tagging protocol, we get no notification
about packet drops, the best we can do is eventually recover from the
drop of a PTP frame: its skb will be dead memory until another skb which
was assigned the same timestamp ID happens to find it.

However, with the ocelot-8021q tagger which injects packets using the
manual register interface, it appears that we can check for more
information, such as:

- whether the input queue has reached the high watermark or not
- whether the injection group's FIFO can accept additional data or not

so we know that a PTP frame is likely to get dropped before actually
sending it, and drop it ourselves (because DSA uses NETIF_F_LLTX, so it
can't return NETDEV_TX_BUSY to ask the qdisc to requeue the packet).

But when we do that, we can also remove the skb from the timestamping
queue, because there surely won't be any timestamp that matches it.

Fixes: 0a6f17c6ae21 ("net: dsa: tag_ocelot_8021q: add support for PTP timestamping")
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/dsa/ocelot/felix.c b/drivers/net/dsa/ocelot/felix.c
index f8603e068e7c0cf00346273434457f25f774c03f..9af8f900aa56d4648c42829ce1c090967d6cb9a7 100644 (file)
--- a/drivers/net/dsa/ocelot/felix.c
+++ b/drivers/net/dsa/ocelot/felix.c
@@ -1074,6 +1074,33 @@ static int felix_init_structs(struct felix *felix, int num_phys_ports)
        return 0;
 }
 
+static void ocelot_port_purge_txtstamp_skb(struct ocelot *ocelot, int port,
+                                          struct sk_buff *skb)
+{
+       struct ocelot_port *ocelot_port = ocelot->ports[port];
+       struct sk_buff *clone = OCELOT_SKB_CB(skb)->clone;
+       struct sk_buff *skb_match = NULL, *skb_tmp;
+       unsigned long flags;
+
+       if (!clone)
+               return;
+
+       spin_lock_irqsave(&ocelot_port->tx_skbs.lock, flags);
+
+       skb_queue_walk_safe(&ocelot_port->tx_skbs, skb, skb_tmp) {
+               if (skb != clone)
+                       continue;
+               __skb_unlink(skb, &ocelot_port->tx_skbs);
+               skb_match = skb;
+               break;
+       }
+
+       spin_unlock_irqrestore(&ocelot_port->tx_skbs.lock, flags);
+
+       WARN_ONCE(!skb_match,
+                 "Could not find skb clone in TX timestamping list\n");
+}
+
 #define work_to_xmit_work(w) \
                container_of((w), struct felix_deferred_xmit_work, work)
 
@@ -1097,6 +1124,7 @@ static void felix_port_deferred_xmit(struct kthread_work *work)
        if (!retries) {
                dev_err(ocelot->dev, "port %d failed to inject skb\n",
                        port);
+               ocelot_port_purge_txtstamp_skb(ocelot, port, skb);
                kfree_skb(skb);
                return;
        }