octeon_ep_vf: avoid compiler and IQ/OQ reordering

Utilize READ_ONCE and WRITE_ONCE APIs for IO queue Tx/Rx
variable access to prevent compiler optimization and reordering.
Additionally, ensure IO queue OUT/IN_CNT registers are flushed
by performing a read-back after writing.

The compiler could reorder reads/writes to pkts_pending, last_pkt_count,
etc., causing stale values to be used when calculating packets to process
or register updates to send to hardware. The Octeon hardware requires a
read-back after writing to OUT_CNT/IN_CNT registers to ensure the write
has been flushed through any posted write buffers before the interrupt
resend bit is set. Without this, we have observed cases where the hardware
didn't properly update its internal state.

wmb/rmb only provides ordering guarantees but doesn't prevent the compiler
from performing optimizations like caching in registers, load tearing etc.

Fixes: 1cd3b407977c3 ("octeon_ep_vf: add Tx/Rx processing and interrupt support")
Signed-off-by: Sathesh Edara <sedara@marvell.com>
Signed-off-by: Shinas Rasheed <srasheed@marvell.com>
Signed-off-by: Vimlesh Kumar <vimleshk@marvell.com>
Link: https://patch.msgid.link/20260227091402.1773833-5-vimleshk@marvell.com
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

diff --git a/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_main.c b/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_main.c
index 0e76f671a226f0a763c5e1a57d3691be2be92790..7f1b93cffb98bd324ccb879935fc20b6bbc064f2 100644 (file)
--- a/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_main.c
+++ b/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_main.c
@@ -294,17 +294,22 @@ static void octep_vf_clean_irqs(struct octep_vf_device *oct)
 
 static void octep_vf_update_pkt(struct octep_vf_iq *iq, struct octep_vf_oq *oq)
 {
-       u32 pkts_pend = oq->pkts_pending;
+       u32 pkts_pend = READ_ONCE(oq->pkts_pending);
+       u32 last_pkt_count = READ_ONCE(oq->last_pkt_count);
+       u32 pkts_processed = READ_ONCE(iq->pkts_processed);
+       u32 pkt_in_done = READ_ONCE(iq->pkt_in_done);
 
        netdev_dbg(iq->netdev, "enabling intr for Q-%u\n", iq->q_no);
-       if (iq->pkts_processed) {
-               writel(iq->pkts_processed, iq->inst_cnt_reg);
-               iq->pkt_in_done -= iq->pkts_processed;
-               iq->pkts_processed = 0;
+       if (pkts_processed) {
+               writel(pkts_processed, iq->inst_cnt_reg);
+               readl(iq->inst_cnt_reg);
+               WRITE_ONCE(iq->pkt_in_done, (pkt_in_done - pkts_processed));
+               WRITE_ONCE(iq->pkts_processed, 0);
        }
-       if (oq->last_pkt_count - pkts_pend) {
-               writel(oq->last_pkt_count - pkts_pend, oq->pkts_sent_reg);
-               oq->last_pkt_count = pkts_pend;
+       if (last_pkt_count - pkts_pend) {
+               writel(last_pkt_count - pkts_pend, oq->pkts_sent_reg);
+               readl(oq->pkts_sent_reg);
+               WRITE_ONCE(oq->last_pkt_count, pkts_pend);
        }
 
        /* Flush the previous wrties before writing to RESEND bit */

diff --git a/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_rx.c b/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_rx.c
index 6f865dbbba6c67030bb9b84626460618ac185c07..b579d5b545c46d4d82456e8df36ccbfc118d212d 100644 (file)
--- a/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_rx.c
+++ b/drivers/net/ethernet/marvell/octeon_ep_vf/octep_vf_rx.c
@@ -325,9 +325,16 @@ static int octep_vf_oq_check_hw_for_pkts(struct octep_vf_device *oct,
                                         struct octep_vf_oq *oq)
 {
        u32 pkt_count, new_pkts;
+       u32 last_pkt_count, pkts_pending;
 
        pkt_count = readl(oq->pkts_sent_reg);
-       new_pkts = pkt_count - oq->last_pkt_count;
+       last_pkt_count = READ_ONCE(oq->last_pkt_count);
+       new_pkts = pkt_count - last_pkt_count;
+
+       if (pkt_count < last_pkt_count) {
+               dev_err(oq->dev, "OQ-%u pkt_count(%u) < oq->last_pkt_count(%u)\n",
+                       oq->q_no, pkt_count, last_pkt_count);
+       }
 
        /* Clear the hardware packets counter register if the rx queue is
         * being processed continuously with-in a single interrupt and
@@ -339,8 +346,9 @@ static int octep_vf_oq_check_hw_for_pkts(struct octep_vf_device *oct,
                pkt_count = readl(oq->pkts_sent_reg);
                new_pkts += pkt_count;
        }
-       oq->last_pkt_count = pkt_count;
-       oq->pkts_pending += new_pkts;
+       WRITE_ONCE(oq->last_pkt_count, pkt_count);
+       pkts_pending = READ_ONCE(oq->pkts_pending);
+       WRITE_ONCE(oq->pkts_pending, (pkts_pending + new_pkts));
        return new_pkts;
 }
 
@@ -369,7 +377,7 @@ static int __octep_vf_oq_process_rx(struct octep_vf_device *oct,
        struct sk_buff *skb;
        u32 read_idx;
 
-       read_idx = oq->host_read_idx;
+       read_idx = READ_ONCE(oq->host_read_idx);
        rx_bytes = 0;
        desc_used = 0;
        for (pkt = 0; pkt < pkts_to_process; pkt++) {
@@ -463,7 +471,7 @@ static int __octep_vf_oq_process_rx(struct octep_vf_device *oct,
                napi_gro_receive(oq->napi, skb);
        }
 
-       oq->host_read_idx = read_idx;
+       WRITE_ONCE(oq->host_read_idx, read_idx);
        oq->refill_count += desc_used;
        oq->stats->packets += pkt;
        oq->stats->bytes += rx_bytes;
@@ -486,22 +494,26 @@ int octep_vf_oq_process_rx(struct octep_vf_oq *oq, int budget)
 {
        u32 pkts_available, pkts_processed, total_pkts_processed;
        struct octep_vf_device *oct = oq->octep_vf_dev;
+       u32 pkts_pending;
 
        pkts_available = 0;
        pkts_processed = 0;
        total_pkts_processed = 0;
        while (total_pkts_processed < budget) {
                 /* update pending count only when current one exhausted */
-               if (oq->pkts_pending == 0)
+               pkts_pending = READ_ONCE(oq->pkts_pending);
+               if (pkts_pending == 0)
                        octep_vf_oq_check_hw_for_pkts(oct, oq);
+               pkts_pending = READ_ONCE(oq->pkts_pending);
                pkts_available = min(budget - total_pkts_processed,
-                                    oq->pkts_pending);
+                                    pkts_pending);
                if (!pkts_available)
                        break;
 
                pkts_processed = __octep_vf_oq_process_rx(oct, oq,
                                                          pkts_available);
-               oq->pkts_pending -= pkts_processed;
+               pkts_pending = READ_ONCE(oq->pkts_pending);
+               WRITE_ONCE(oq->pkts_pending, (pkts_pending - pkts_processed));
                total_pkts_processed += pkts_processed;
        }