gve: Add header split ethtool stats

To record the stats of header split packets, three stats are added in
the driver's ethtool stats.

- rx_hsplit_pkt is the split packets count with header split
- rx_hsplit_bytes is the received header bytes count with header split
- rx_hsplit_unsplit_pkt is the unsplit packet count due to header buffer
  overflow or zero header length when header split is enabled

Currently, it's entering the stats_update critical section more than
once per packet. We have plans to avoid that in the future change to let
all the stats_update happen in one place at the end of
`gve_rx_poll_dqo`.

Co-developed-by: Ziwei Xiao <ziweixiao@google.com>
Signed-off-by: Ziwei Xiao <ziweixiao@google.com>
Signed-off-by: Jeroen de Borst <jeroendb@google.com>
Reviewed-by: Praveen Kaligineedi <pkaligineedi@google.com>
Reviewed-by: Harshitha Ramamurthy <hramamurthy@google.com>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/google/gve/gve.h b/drivers/net/ethernet/google/gve/gve.h
index 5f02b87d7feabd18a3c2f5e1ed96da09902a976d..4814c96d5fe764639f66b0e60d4d4b109841c232 100644 (file)
--- a/drivers/net/ethernet/google/gve/gve.h
+++ b/drivers/net/ethernet/google/gve/gve.h
@@ -269,15 +269,19 @@ struct gve_rx_ring {
        };
 
        u64 rbytes; /* free-running bytes received */
+       u64 rx_hsplit_bytes; /* free-running header bytes received */
        u64 rpackets; /* free-running packets received */
        u32 cnt; /* free-running total number of completed packets */
        u32 fill_cnt; /* free-running total number of descs and buffs posted */
        u32 mask; /* masks the cnt and fill_cnt to the size of the ring */
+       u64 rx_hsplit_pkt; /* free-running packets with headers split */
        u64 rx_copybreak_pkt; /* free-running count of copybreak packets */
        u64 rx_copied_pkt; /* free-running total number of copied packets */
        u64 rx_skb_alloc_fail; /* free-running count of skb alloc fails */
        u64 rx_buf_alloc_fail; /* free-running count of buffer alloc fails */
        u64 rx_desc_err_dropped_pkt; /* free-running count of packets dropped by descriptor error */
+       /* free-running count of unsplit packets due to header buffer overflow or hdr_len is 0 */
+       u64 rx_hsplit_unsplit_pkt;
        u64 rx_cont_packet_cnt; /* free-running multi-fragment packets received */
        u64 rx_frag_flip_cnt; /* free-running count of rx segments where page_flip was used */
        u64 rx_frag_copy_cnt; /* free-running count of rx segments copied */

diff --git a/drivers/net/ethernet/google/gve/gve_ethtool.c b/drivers/net/ethernet/google/gve/gve_ethtool.c
index 13c2901968e02e57697ad920ae7da23a5d717b95..9aebfb843d9d1180cbe6a5acb6fbde7c3288c4c7 100644 (file)
--- a/drivers/net/ethernet/google/gve/gve_ethtool.c
+++ b/drivers/net/ethernet/google/gve/gve_ethtool.c
@@ -39,17 +39,18 @@ static u32 gve_get_msglevel(struct net_device *netdev)
  * as declared in enum xdp_action inside file uapi/linux/bpf.h .
  */
 static const char gve_gstrings_main_stats[][ETH_GSTRING_LEN] = {
-       "rx_packets", "tx_packets", "rx_bytes", "tx_bytes",
-       "rx_dropped", "tx_dropped", "tx_timeouts",
+       "rx_packets", "rx_hsplit_pkt", "tx_packets", "rx_bytes",
+       "tx_bytes", "rx_dropped", "tx_dropped", "tx_timeouts",
        "rx_skb_alloc_fail", "rx_buf_alloc_fail", "rx_desc_err_dropped_pkt",
+       "rx_hsplit_unsplit_pkt",
        "interface_up_cnt", "interface_down_cnt", "reset_cnt",
        "page_alloc_fail", "dma_mapping_error", "stats_report_trigger_cnt",
 };
 
 static const char gve_gstrings_rx_stats[][ETH_GSTRING_LEN] = {
-       "rx_posted_desc[%u]", "rx_completed_desc[%u]", "rx_consumed_desc[%u]", "rx_bytes[%u]",
-       "rx_cont_packet_cnt[%u]", "rx_frag_flip_cnt[%u]", "rx_frag_copy_cnt[%u]",
-       "rx_frag_alloc_cnt[%u]",
+       "rx_posted_desc[%u]", "rx_completed_desc[%u]", "rx_consumed_desc[%u]",
+       "rx_bytes[%u]", "rx_hsplit_bytes[%u]", "rx_cont_packet_cnt[%u]",
+       "rx_frag_flip_cnt[%u]", "rx_frag_copy_cnt[%u]", "rx_frag_alloc_cnt[%u]",
        "rx_dropped_pkt[%u]", "rx_copybreak_pkt[%u]", "rx_copied_pkt[%u]",
        "rx_queue_drop_cnt[%u]", "rx_no_buffers_posted[%u]",
        "rx_drops_packet_over_mru[%u]", "rx_drops_invalid_checksum[%u]",
@@ -153,11 +154,13 @@ static void
 gve_get_ethtool_stats(struct net_device *netdev,
                      struct ethtool_stats *stats, u64 *data)
 {
-       u64 tmp_rx_pkts, tmp_rx_bytes, tmp_rx_skb_alloc_fail,
-               tmp_rx_buf_alloc_fail, tmp_rx_desc_err_dropped_pkt,
+       u64 tmp_rx_pkts, tmp_rx_hsplit_pkt, tmp_rx_bytes, tmp_rx_hsplit_bytes,
+               tmp_rx_skb_alloc_fail, tmp_rx_buf_alloc_fail,
+               tmp_rx_desc_err_dropped_pkt, tmp_rx_hsplit_unsplit_pkt,
                tmp_tx_pkts, tmp_tx_bytes;
-       u64 rx_buf_alloc_fail, rx_desc_err_dropped_pkt, rx_pkts,
-               rx_skb_alloc_fail, rx_bytes, tx_pkts, tx_bytes, tx_dropped;
+       u64 rx_buf_alloc_fail, rx_desc_err_dropped_pkt, rx_hsplit_unsplit_pkt,
+               rx_pkts, rx_hsplit_pkt, rx_skb_alloc_fail, rx_bytes, tx_pkts, tx_bytes,
+               tx_dropped;
        int stats_idx, base_stats_idx, max_stats_idx;
        struct stats *report_stats;
        int *rx_qid_to_stats_idx;
@@ -184,8 +187,10 @@ gve_get_ethtool_stats(struct net_device *netdev,
                kfree(rx_qid_to_stats_idx);
                return;
        }
-       for (rx_pkts = 0, rx_bytes = 0, rx_skb_alloc_fail = 0,
-            rx_buf_alloc_fail = 0, rx_desc_err_dropped_pkt = 0, ring = 0;
+       for (rx_pkts = 0, rx_bytes = 0, rx_hsplit_pkt = 0,
+            rx_skb_alloc_fail = 0, rx_buf_alloc_fail = 0,
+            rx_desc_err_dropped_pkt = 0, rx_hsplit_unsplit_pkt = 0,
+            ring = 0;
             ring < priv->rx_cfg.num_queues; ring++) {
                if (priv->rx) {
                        do {
@@ -194,18 +199,23 @@ gve_get_ethtool_stats(struct net_device *netdev,
                                start =
                                  u64_stats_fetch_begin(&priv->rx[ring].statss);
                                tmp_rx_pkts = rx->rpackets;
+                               tmp_rx_hsplit_pkt = rx->rx_hsplit_pkt;
                                tmp_rx_bytes = rx->rbytes;
                                tmp_rx_skb_alloc_fail = rx->rx_skb_alloc_fail;
                                tmp_rx_buf_alloc_fail = rx->rx_buf_alloc_fail;
                                tmp_rx_desc_err_dropped_pkt =
                                        rx->rx_desc_err_dropped_pkt;
+                               tmp_rx_hsplit_unsplit_pkt =
+                                       rx->rx_hsplit_unsplit_pkt;
                        } while (u64_stats_fetch_retry(&priv->rx[ring].statss,
                                                       start));
                        rx_pkts += tmp_rx_pkts;
+                       rx_hsplit_pkt += tmp_rx_hsplit_pkt;
                        rx_bytes += tmp_rx_bytes;
                        rx_skb_alloc_fail += tmp_rx_skb_alloc_fail;
                        rx_buf_alloc_fail += tmp_rx_buf_alloc_fail;
                        rx_desc_err_dropped_pkt += tmp_rx_desc_err_dropped_pkt;
+                       rx_hsplit_unsplit_pkt += tmp_rx_hsplit_unsplit_pkt;
                }
        }
        for (tx_pkts = 0, tx_bytes = 0, tx_dropped = 0, ring = 0;
@@ -226,6 +236,7 @@ gve_get_ethtool_stats(struct net_device *netdev,
 
        i = 0;
        data[i++] = rx_pkts;
+       data[i++] = rx_hsplit_pkt;
        data[i++] = tx_pkts;
        data[i++] = rx_bytes;
        data[i++] = tx_bytes;
@@ -237,6 +248,7 @@ gve_get_ethtool_stats(struct net_device *netdev,
        data[i++] = rx_skb_alloc_fail;
        data[i++] = rx_buf_alloc_fail;
        data[i++] = rx_desc_err_dropped_pkt;
+       data[i++] = rx_hsplit_unsplit_pkt;
        data[i++] = priv->interface_up_cnt;
        data[i++] = priv->interface_down_cnt;
        data[i++] = priv->reset_cnt;
@@ -276,6 +288,7 @@ gve_get_ethtool_stats(struct net_device *netdev,
                                start =
                                  u64_stats_fetch_begin(&priv->rx[ring].statss);
                                tmp_rx_bytes = rx->rbytes;
+                               tmp_rx_hsplit_bytes = rx->rx_hsplit_bytes;
                                tmp_rx_skb_alloc_fail = rx->rx_skb_alloc_fail;
                                tmp_rx_buf_alloc_fail = rx->rx_buf_alloc_fail;
                                tmp_rx_desc_err_dropped_pkt =
@@ -283,6 +296,7 @@ gve_get_ethtool_stats(struct net_device *netdev,
                        } while (u64_stats_fetch_retry(&priv->rx[ring].statss,
                                                       start));
                        data[i++] = tmp_rx_bytes;
+                       data[i++] = tmp_rx_hsplit_bytes;
                        data[i++] = rx->rx_cont_packet_cnt;
                        data[i++] = rx->rx_frag_flip_cnt;
                        data[i++] = rx->rx_frag_copy_cnt;

diff --git a/drivers/net/ethernet/google/gve/gve_rx_dqo.c b/drivers/net/ethernet/google/gve/gve_rx_dqo.c
index a12d776d4385692eb62627b3c4fc1f5bdfc35fa7..8e8071308aebee04b313d0767f5b5ab606ccdae5 100644 (file)
--- a/drivers/net/ethernet/google/gve/gve_rx_dqo.c
+++ b/drivers/net/ethernet/google/gve/gve_rx_dqo.c
@@ -720,6 +720,8 @@ static int gve_rx_dqo(struct napi_struct *napi, struct gve_rx_ring *rx,
 
        /* Copy the header into the skb in the case of header split */
        if (hsplit) {
+               int unsplit = 0;
+
                if (hdr_len && !hbo) {
                        rx->ctx.skb_head = gve_rx_copy_data(priv->dev, napi,
                                                            rx->dqo.hdr_bufs.data +
@@ -728,7 +730,14 @@ static int gve_rx_dqo(struct napi_struct *napi, struct gve_rx_ring *rx,
                        if (unlikely(!rx->ctx.skb_head))
                                goto error;
                        rx->ctx.skb_tail = rx->ctx.skb_head;
+               } else {
+                       unsplit = 1;
                }
+               u64_stats_update_begin(&rx->statss);
+               rx->rx_hsplit_pkt++;
+               rx->rx_hsplit_unsplit_pkt += unsplit;
+               rx->rx_hsplit_bytes += hdr_len;
+               u64_stats_update_end(&rx->statss);
        }
 
        /* Sync the portion of dma buffer for CPU to read. */