ice: put Rx buffers after being done with current frame

Introduce a new helper ice_put_rx_mbuf() that will go through gathered
frags from current frame and will call ice_put_rx_buf() on them. Current
logic that was supposed to simplify and optimize the driver where we go
through a batch of all buffers processed in current NAPI instance turned
out to be broken for jumbo frames and very heavy load that was coming
from both multi-thread iperf and nginx/wrk pair between server and
client. The delay introduced by approach that we are dropping is simply
too big and we need to take the decision regarding page
recycling/releasing as quick as we can.

While at it, address an error path of ice_add_xdp_frag() - we were
missing buffer putting from day 1 there.

As a nice side effect we get rid of annoying and repetitive three-liner:

	xdp->data = NULL;
	rx_ring->first_desc = ntc;
	rx_ring->nr_frags = 0;

by embedding it within introduced routine.

Fixes: 1dc1a7e7f410 ("ice: Centrallize Rx buffer recycling")
Reported-and-tested-by: Xu Du <xudu@redhat.com>
Reviewed-by: Przemek Kitszel <przemyslaw.kitszel@intel.com>
Reviewed-by: Simon Horman <horms@kernel.org>
Co-developed-by: Jacob Keller <jacob.e.keller@intel.com>
Signed-off-by: Jacob Keller <jacob.e.keller@intel.com>
Signed-off-by: Maciej Fijalkowski <maciej.fijalkowski@intel.com>
Tested-by: Chandan Kumar Rout <chandanx.rout@intel.com> (A Contingent Worker at Intel)
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>

diff --git a/drivers/net/ethernet/intel/ice/ice_txrx.c b/drivers/net/ethernet/intel/ice/ice_txrx.c
index 5d2d7736fd5f129407a2b58756b8985ef1b1eb6a..e173d9c98988387352a072393325d66e031fc4aa 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_txrx.c
+++ b/drivers/net/ethernet/intel/ice/ice_txrx.c
@@ -1103,6 +1103,49 @@ ice_put_rx_buf(struct ice_rx_ring *rx_ring, struct ice_rx_buf *rx_buf)
        rx_buf->page = NULL;
 }
 
+/**
+ * ice_put_rx_mbuf - ice_put_rx_buf() caller, for all frame frags
+ * @rx_ring: Rx ring with all the auxiliary data
+ * @xdp: XDP buffer carrying linear + frags part
+ * @xdp_xmit: XDP_TX/XDP_REDIRECT verdict storage
+ * @ntc: a current next_to_clean value to be stored at rx_ring
+ *
+ * Walk through gathered fragments and satisfy internal page
+ * recycle mechanism; we take here an action related to verdict
+ * returned by XDP program;
+ */
+static void ice_put_rx_mbuf(struct ice_rx_ring *rx_ring, struct xdp_buff *xdp,
+                           u32 *xdp_xmit, u32 ntc)
+{
+       u32 nr_frags = rx_ring->nr_frags + 1;
+       u32 idx = rx_ring->first_desc;
+       u32 cnt = rx_ring->count;
+       struct ice_rx_buf *buf;
+       int i;
+
+       for (i = 0; i < nr_frags; i++) {
+               buf = &rx_ring->rx_buf[idx];
+
+               if (buf->act & (ICE_XDP_TX | ICE_XDP_REDIR)) {
+                       ice_rx_buf_adjust_pg_offset(buf, xdp->frame_sz);
+                       *xdp_xmit |= buf->act;
+               } else if (buf->act & ICE_XDP_CONSUMED) {
+                       buf->pagecnt_bias++;
+               } else if (buf->act == ICE_XDP_PASS) {
+                       ice_rx_buf_adjust_pg_offset(buf, xdp->frame_sz);
+               }
+
+               ice_put_rx_buf(rx_ring, buf);
+
+               if (++idx == cnt)
+                       idx = 0;
+       }
+
+       xdp->data = NULL;
+       rx_ring->first_desc = ntc;
+       rx_ring->nr_frags = 0;
+}
+
 /**
  * ice_clean_rx_irq - Clean completed descriptors from Rx ring - bounce buf
  * @rx_ring: Rx descriptor ring to transact packets on
@@ -1120,7 +1163,6 @@ int ice_clean_rx_irq(struct ice_rx_ring *rx_ring, int budget)
        unsigned int total_rx_bytes = 0, total_rx_pkts = 0;
        unsigned int offset = rx_ring->rx_offset;
        struct xdp_buff *xdp = &rx_ring->xdp;
-       u32 cached_ntc = rx_ring->first_desc;
        struct ice_tx_ring *xdp_ring = NULL;
        struct bpf_prog *xdp_prog = NULL;
        u32 ntc = rx_ring->next_to_clean;
@@ -1128,7 +1170,6 @@ int ice_clean_rx_irq(struct ice_rx_ring *rx_ring, int budget)
        u32 xdp_xmit = 0;
        u32 cached_ntu;
        bool failure;
-       u32 first;
 
        xdp_prog = READ_ONCE(rx_ring->xdp_prog);
        if (xdp_prog) {
@@ -1190,6 +1231,7 @@ int ice_clean_rx_irq(struct ice_rx_ring *rx_ring, int budget)
                        xdp_prepare_buff(xdp, hard_start, offset, size, !!offset);
                        xdp_buff_clear_frags_flag(xdp);
                } else if (ice_add_xdp_frag(rx_ring, xdp, rx_buf, size)) {
+                       ice_put_rx_mbuf(rx_ring, xdp, NULL, ntc);
                        break;
                }
                if (++ntc == cnt)
@@ -1205,9 +1247,8 @@ int ice_clean_rx_irq(struct ice_rx_ring *rx_ring, int budget)
                total_rx_bytes += xdp_get_buff_len(xdp);
                total_rx_pkts++;
 
-               xdp->data = NULL;
-               rx_ring->first_desc = ntc;
-               rx_ring->nr_frags = 0;
+               ice_put_rx_mbuf(rx_ring, xdp, &xdp_xmit, ntc);
+
                continue;
 construct_skb:
                if (likely(ice_ring_uses_build_skb(rx_ring)))
@@ -1221,14 +1262,11 @@ construct_skb:
                        if (unlikely(xdp_buff_has_frags(xdp)))
                                ice_set_rx_bufs_act(xdp, rx_ring,
                                                    ICE_XDP_CONSUMED);
-                       xdp->data = NULL;
-                       rx_ring->first_desc = ntc;
-                       rx_ring->nr_frags = 0;
-                       break;
                }
-               xdp->data = NULL;
-               rx_ring->first_desc = ntc;
-               rx_ring->nr_frags = 0;
+               ice_put_rx_mbuf(rx_ring, xdp, &xdp_xmit, ntc);
+
+               if (!skb)
+                       break;
 
                stat_err_bits = BIT(ICE_RX_FLEX_DESC_STATUS0_RXE_S);
                if (unlikely(ice_test_staterr(rx_desc->wb.status_error0,
@@ -1257,23 +1295,6 @@ construct_skb:
                total_rx_pkts++;
        }
 
-       first = rx_ring->first_desc;
-       while (cached_ntc != first) {
-               struct ice_rx_buf *buf = &rx_ring->rx_buf[cached_ntc];
-
-               if (buf->act & (ICE_XDP_TX | ICE_XDP_REDIR)) {
-                       ice_rx_buf_adjust_pg_offset(buf, xdp->frame_sz);
-                       xdp_xmit |= buf->act;
-               } else if (buf->act & ICE_XDP_CONSUMED) {
-                       buf->pagecnt_bias++;
-               } else if (buf->act == ICE_XDP_PASS) {
-                       ice_rx_buf_adjust_pg_offset(buf, xdp->frame_sz);
-               }
-
-               ice_put_rx_buf(rx_ring, buf);
-               if (++cached_ntc >= cnt)
-                       cached_ntc = 0;
-       }
        rx_ring->next_to_clean = ntc;
        /* return up to cleaned_count buffers to hardware */
        failure = ice_alloc_rx_bufs(rx_ring, ICE_RX_DESC_UNUSED(rx_ring));