target/linux/generic/backport-6.1/795-v6.7-16-r8152-use-napi_gro_frags.patch

   1 From 788d30daa8f97f06166b6a63f0e51f2a4c2f036a Mon Sep 17 00:00:00 2001
   2 From: Hayes Wang <hayeswang@realtek.com>
   3 Date: Tue, 26 Sep 2023 19:17:14 +0800
   4 Subject: [PATCH] r8152: use napi_gro_frags
   5
   6 Use napi_gro_frags() for the skb of fragments when the work_done is less
   7 than budget.
   8
   9 Signed-off-by: Hayes Wang <hayeswang@realtek.com>
  10 Link: https://lore.kernel.org/r/20230926111714.9448-434-nic_swsd@realtek.com
  11 Signed-off-by: Jakub Kicinski <kuba@kernel.org>
  12 ---
  13  drivers/net/usb/r8152.c | 67 ++++++++++++++++++++++++++++++-----------
  14  1 file changed, 50 insertions(+), 17 deletions(-)
  15
  16 --- a/drivers/net/usb/r8152.c
  17 +++ b/drivers/net/usb/r8152.c
  18 @@ -2583,8 +2583,9 @@ static int rx_bottom(struct r8152 *tp, i
  19                 while (urb->actual_length > len_used) {
  20                         struct net_device *netdev = tp->netdev;
  21                         struct net_device_stats *stats = &netdev->stats;
  22 -                       unsigned int pkt_len, rx_frag_head_sz;
  23 +                       unsigned int pkt_len, rx_frag_head_sz, len;
  24                         struct sk_buff *skb;
  25 +                       bool use_frags;
  26
  27                         WARN_ON_ONCE(skb_queue_len(&tp->rx_queue) >= 1000);
  28
  29 @@ -2597,45 +2598,77 @@ static int rx_bottom(struct r8152 *tp, i
  30                                 break;
  31
  32                         pkt_len -= ETH_FCS_LEN;
  33 +                       len = pkt_len;
  34                         rx_data += sizeof(struct rx_desc);
  35
  36 -                       if (!agg_free || tp->rx_copybreak > pkt_len)
  37 -                               rx_frag_head_sz = pkt_len;
  38 +                       if (!agg_free || tp->rx_copybreak > len)
  39 +                               use_frags = false;
  40                         else
  41 -                               rx_frag_head_sz = tp->rx_copybreak;
  42 +                               use_frags = true;
  43 +
  44 +                       if (use_frags) {
  45 +                               /* If the budget is exhausted, the packet
  46 +                                * would be queued in the driver. That is,
  47 +                                * napi_gro_frags() wouldn't be called, so
  48 +                                * we couldn't use napi_get_frags().
  49 +                                */
  50 +                               if (work_done >= budget) {
  51 +                                       rx_frag_head_sz = tp->rx_copybreak;
  52 +                                       skb = napi_alloc_skb(napi,
  53 +                                                            rx_frag_head_sz);
  54 +                               } else {
  55 +                                       rx_frag_head_sz = 0;
  56 +                                       skb = napi_get_frags(napi);
  57 +                               }
  58 +                       } else {
  59 +                               rx_frag_head_sz = 0;
  60 +                               skb = napi_alloc_skb(napi, len);
  61 +                       }
  62
  63 -                       skb = napi_alloc_skb(napi, rx_frag_head_sz);
  64                         if (!skb) {
  65                                 stats->rx_dropped++;
  66                                 goto find_next_rx;
  67                         }
  68
  69                         skb->ip_summed = r8152_rx_csum(tp, rx_desc);
  70 -                       memcpy(skb->data, rx_data, rx_frag_head_sz);
  71 -                       skb_put(skb, rx_frag_head_sz);
  72 -                       pkt_len -= rx_frag_head_sz;
  73 -                       rx_data += rx_frag_head_sz;
  74 -                       if (pkt_len) {
  75 +                       rtl_rx_vlan_tag(rx_desc, skb);
  76 +
  77 +                       if (use_frags) {
  78 +                               if (rx_frag_head_sz) {
  79 +                                       memcpy(skb->data, rx_data,
  80 +                                              rx_frag_head_sz);
  81 +                                       skb_put(skb, rx_frag_head_sz);
  82 +                                       len -= rx_frag_head_sz;
  83 +                                       rx_data += rx_frag_head_sz;
  84 +                                       skb->protocol = eth_type_trans(skb,
  85 +                                                                      netdev);
  86 +                               }
  87 +
  88                                 skb_add_rx_frag(skb, 0, agg->page,
  89                                                 agg_offset(agg, rx_data),
  90 -                                               pkt_len,
  91 -                                               SKB_DATA_ALIGN(pkt_len));
  92 +                                               len, SKB_DATA_ALIGN(len));
  93                                 get_page(agg->page);
  94 +                       } else {
  95 +                               memcpy(skb->data, rx_data, len);
  96 +                               skb_put(skb, len);
  97 +                               skb->protocol = eth_type_trans(skb, netdev);
  98                         }
  99
 100 -                       skb->protocol = eth_type_trans(skb, netdev);
 101 -                       rtl_rx_vlan_tag(rx_desc, skb);
 102                         if (work_done < budget) {
 103 +                               if (use_frags)
 104 +                                       napi_gro_frags(napi);
 105 +                               else
 106 +                                       napi_gro_receive(napi, skb);
 107 +
 108                                 work_done++;
 109                                 stats->rx_packets++;
 110 -                               stats->rx_bytes += skb->len;
 111 -                               napi_gro_receive(napi, skb);
 112 +                               stats->rx_bytes += pkt_len;
 113                         } else {
 114                                 __skb_queue_tail(&tp->rx_queue, skb);
 115                         }
 116
 117  find_next_rx:
 118 -                       rx_data = rx_agg_align(rx_data + pkt_len + ETH_FCS_LEN);
 119 +                       rx_data = rx_agg_align(rx_data + len + ETH_FCS_LEN);
 120                         rx_desc = (struct rx_desc *)rx_data;
 121                         len_used = agg_offset(agg, rx_data);
 122                         len_used += sizeof(struct rx_desc);