r8152: use napi_gro_frags

Use napi_gro_frags() for the skb of fragments when the work_done is less
than budget.

Signed-off-by: Hayes Wang <hayeswang@realtek.com>
Link: https://lore.kernel.org/r/20230926111714.9448-434-nic_swsd@realtek.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c
index c4038def193f90faf7bb7c75704d3f23f828d809..1231bf3657965dbbc3ba5bece743904941dc9108 100644 (file)
--- a/drivers/net/usb/r8152.c
+++ b/drivers/net/usb/r8152.c
@@ -2490,8 +2490,9 @@ static int rx_bottom(struct r8152 *tp, int budget)
                while (urb->actual_length > len_used) {
                        struct net_device *netdev = tp->netdev;
                        struct net_device_stats *stats = &netdev->stats;
-                       unsigned int pkt_len, rx_frag_head_sz;
+                       unsigned int pkt_len, rx_frag_head_sz, len;
                        struct sk_buff *skb;
+                       bool use_frags;
 
                        WARN_ON_ONCE(skb_queue_len(&tp->rx_queue) >= 1000);
 
@@ -2504,45 +2505,77 @@ static int rx_bottom(struct r8152 *tp, int budget)
                                break;
 
                        pkt_len -= ETH_FCS_LEN;
+                       len = pkt_len;
                        rx_data += sizeof(struct rx_desc);
 
-                       if (!agg_free || tp->rx_copybreak > pkt_len)
-                               rx_frag_head_sz = pkt_len;
+                       if (!agg_free || tp->rx_copybreak > len)
+                               use_frags = false;
                        else
-                               rx_frag_head_sz = tp->rx_copybreak;
+                               use_frags = true;
+
+                       if (use_frags) {
+                               /* If the budget is exhausted, the packet
+                                * would be queued in the driver. That is,
+                                * napi_gro_frags() wouldn't be called, so
+                                * we couldn't use napi_get_frags().
+                                */
+                               if (work_done >= budget) {
+                                       rx_frag_head_sz = tp->rx_copybreak;
+                                       skb = napi_alloc_skb(napi,
+                                                            rx_frag_head_sz);
+                               } else {
+                                       rx_frag_head_sz = 0;
+                                       skb = napi_get_frags(napi);
+                               }
+                       } else {
+                               rx_frag_head_sz = 0;
+                               skb = napi_alloc_skb(napi, len);
+                       }
 
-                       skb = napi_alloc_skb(napi, rx_frag_head_sz);
                        if (!skb) {
                                stats->rx_dropped++;
                                goto find_next_rx;
                        }
 
                        skb->ip_summed = r8152_rx_csum(tp, rx_desc);
-                       memcpy(skb->data, rx_data, rx_frag_head_sz);
-                       skb_put(skb, rx_frag_head_sz);
-                       pkt_len -= rx_frag_head_sz;
-                       rx_data += rx_frag_head_sz;
-                       if (pkt_len) {
+                       rtl_rx_vlan_tag(rx_desc, skb);
+
+                       if (use_frags) {
+                               if (rx_frag_head_sz) {
+                                       memcpy(skb->data, rx_data,
+                                              rx_frag_head_sz);
+                                       skb_put(skb, rx_frag_head_sz);
+                                       len -= rx_frag_head_sz;
+                                       rx_data += rx_frag_head_sz;
+                                       skb->protocol = eth_type_trans(skb,
+                                                                      netdev);
+                               }
+
                                skb_add_rx_frag(skb, 0, agg->page,
                                                agg_offset(agg, rx_data),
-                                               pkt_len,
-                                               SKB_DATA_ALIGN(pkt_len));
+                                               len, SKB_DATA_ALIGN(len));
                                get_page(agg->page);
+                       } else {
+                               memcpy(skb->data, rx_data, len);
+                               skb_put(skb, len);
+                               skb->protocol = eth_type_trans(skb, netdev);
                        }
 
-                       skb->protocol = eth_type_trans(skb, netdev);
-                       rtl_rx_vlan_tag(rx_desc, skb);
                        if (work_done < budget) {
+                               if (use_frags)
+                                       napi_gro_frags(napi);
+                               else
+                                       napi_gro_receive(napi, skb);
+
                                work_done++;
                                stats->rx_packets++;
-                               stats->rx_bytes += skb->len;
-                               napi_gro_receive(napi, skb);
+                               stats->rx_bytes += pkt_len;
                        } else {
                                __skb_queue_tail(&tp->rx_queue, skb);
                        }
 
 find_next_rx:
-                       rx_data = rx_agg_align(rx_data + pkt_len + ETH_FCS_LEN);
+                       rx_data = rx_agg_align(rx_data + len + ETH_FCS_LEN);
                        rx_desc = (struct rx_desc *)rx_data;
                        len_used = agg_offset(agg, rx_data);
                        len_used += sizeof(struct rx_desc);