sfc: process RX event inner checksum flags

Add support for RX checksum offload of encapsulated packets. This
 essentially just means paying attention to the inner checksum flags
 in the RX event, and if *either* checksum flag indicates a fail then
 don't tell the kernel that checksum offload was successful.
Also, count these checksum errors and export the counts to ethtool -S.

Test the most common "good" case of RX events with a single bitmask
 instead of a series of ifs.  Move the more specific error checking
 in to a separate function for clarity, and don't use unlikely() there
 since we know at least one of the bits is bad.

Signed-off-by: Edward Cree <ecree@solarflare.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/sfc/bitfield.h b/drivers/net/ethernet/sfc/bitfield.h
index 17d83f37fbf26cbeee5e7aa4fe1c66d923d41a58..41ad07d45144ec79f373052e3ee5742545ba5eed 100644 (file)
--- a/drivers/net/ethernet/sfc/bitfield.h
+++ b/drivers/net/ethernet/sfc/bitfield.h
@@ -433,6 +433,9 @@ typedef union efx_oword {
                (oword).u64[1] = (from).u64[1] & (mask).u64[1]; \
        } while (0)
 
+#define EFX_AND_QWORD(qword, from, mask)                       \
+               (qword).u64[0] = (from).u64[0] & (mask).u64[0]
+
 #define EFX_OR_OWORD(oword, from, mask)                                \
        do {                                                    \
                (oword).u64[0] = (from).u64[0] | (mask).u64[0]; \

diff --git a/drivers/net/ethernet/sfc/ef10.c b/drivers/net/ethernet/sfc/ef10.c
index dec0c8083ff33db5365416c220a1d66b7162ee75..fd1008daf1e378ffc8a18f13ae31eec9453e3240 100644 (file)
--- a/drivers/net/ethernet/sfc/ef10.c
+++ b/drivers/net/ethernet/sfc/ef10.c
@@ -3154,13 +3154,103 @@ static void efx_ef10_handle_rx_abort(struct efx_rx_queue *rx_queue)
        ++efx_rx_queue_channel(rx_queue)->n_rx_nodesc_trunc;
 }
 
+static u16 efx_ef10_handle_rx_event_errors(struct efx_channel *channel,
+                                          unsigned int n_packets,
+                                          unsigned int rx_encap_hdr,
+                                          unsigned int rx_l3_class,
+                                          unsigned int rx_l4_class,
+                                          const efx_qword_t *event)
+{
+       struct efx_nic *efx = channel->efx;
+
+       if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_ECRC_ERR)) {
+               if (!efx->loopback_selftest)
+                       channel->n_rx_eth_crc_err += n_packets;
+               return EFX_RX_PKT_DISCARD;
+       }
+       if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_IPCKSUM_ERR)) {
+               if (unlikely(rx_encap_hdr != ESE_EZ_ENCAP_HDR_VXLAN &&
+                            rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&
+                            rx_l3_class != ESE_DZ_L3_CLASS_IP4_FRAG &&
+                            rx_l3_class != ESE_DZ_L3_CLASS_IP6 &&
+                            rx_l3_class != ESE_DZ_L3_CLASS_IP6_FRAG))
+                       netdev_WARN(efx->net_dev,
+                                   "invalid class for RX_IPCKSUM_ERR: event="
+                                   EFX_QWORD_FMT "\n",
+                                   EFX_QWORD_VAL(*event));
+               if (!efx->loopback_selftest)
+                       *(rx_encap_hdr ?
+                         &channel->n_rx_outer_ip_hdr_chksum_err :
+                         &channel->n_rx_ip_hdr_chksum_err) += n_packets;
+               return 0;
+       }
+       if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_TCPUDP_CKSUM_ERR)) {
+               if (unlikely(rx_encap_hdr != ESE_EZ_ENCAP_HDR_VXLAN &&
+                            ((rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&
+                              rx_l3_class != ESE_DZ_L3_CLASS_IP6) ||
+                             (rx_l4_class != ESE_DZ_L4_CLASS_TCP &&
+                              rx_l4_class != ESE_DZ_L4_CLASS_UDP))))
+                       netdev_WARN(efx->net_dev,
+                                   "invalid class for RX_TCPUDP_CKSUM_ERR: event="
+                                   EFX_QWORD_FMT "\n",
+                                   EFX_QWORD_VAL(*event));
+               if (!efx->loopback_selftest)
+                       *(rx_encap_hdr ?
+                         &channel->n_rx_outer_tcp_udp_chksum_err :
+                         &channel->n_rx_tcp_udp_chksum_err) += n_packets;
+               return 0;
+       }
+       if (EFX_QWORD_FIELD(*event, ESF_EZ_RX_IP_INNER_CHKSUM_ERR)) {
+               if (unlikely(!rx_encap_hdr))
+                       netdev_WARN(efx->net_dev,
+                                   "invalid encapsulation type for RX_IP_INNER_CHKSUM_ERR: event="
+                                   EFX_QWORD_FMT "\n",
+                                   EFX_QWORD_VAL(*event));
+               else if (unlikely(rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&
+                                 rx_l3_class != ESE_DZ_L3_CLASS_IP4_FRAG &&
+                                 rx_l3_class != ESE_DZ_L3_CLASS_IP6 &&
+                                 rx_l3_class != ESE_DZ_L3_CLASS_IP6_FRAG))
+                       netdev_WARN(efx->net_dev,
+                                   "invalid class for RX_IP_INNER_CHKSUM_ERR: event="
+                                   EFX_QWORD_FMT "\n",
+                                   EFX_QWORD_VAL(*event));
+               if (!efx->loopback_selftest)
+                       channel->n_rx_inner_ip_hdr_chksum_err += n_packets;
+               return 0;
+       }
+       if (EFX_QWORD_FIELD(*event, ESF_EZ_RX_TCP_UDP_INNER_CHKSUM_ERR)) {
+               if (unlikely(!rx_encap_hdr))
+                       netdev_WARN(efx->net_dev,
+                                   "invalid encapsulation type for RX_TCP_UDP_INNER_CHKSUM_ERR: event="
+                                   EFX_QWORD_FMT "\n",
+                                   EFX_QWORD_VAL(*event));
+               else if (unlikely((rx_l3_class != ESE_DZ_L3_CLASS_IP4 &&
+                                  rx_l3_class != ESE_DZ_L3_CLASS_IP6) ||
+                                 (rx_l4_class != ESE_DZ_L4_CLASS_TCP &&
+                                  rx_l4_class != ESE_DZ_L4_CLASS_UDP)))
+                       netdev_WARN(efx->net_dev,
+                                   "invalid class for RX_TCP_UDP_INNER_CHKSUM_ERR: event="
+                                   EFX_QWORD_FMT "\n",
+                                   EFX_QWORD_VAL(*event));
+               if (!efx->loopback_selftest)
+                       channel->n_rx_inner_tcp_udp_chksum_err += n_packets;
+               return 0;
+       }
+
+       WARN_ON(1); /* No error bits were recognised */
+       return 0;
+}
+
 static int efx_ef10_handle_rx_event(struct efx_channel *channel,
                                    const efx_qword_t *event)
 {
-       unsigned int rx_bytes, next_ptr_lbits, rx_queue_label, rx_l4_class;
+       unsigned int rx_bytes, next_ptr_lbits, rx_queue_label;
+       unsigned int rx_l3_class, rx_l4_class, rx_encap_hdr;
        unsigned int n_descs, n_packets, i;
        struct efx_nic *efx = channel->efx;
+       struct efx_ef10_nic_data *nic_data = efx->nic_data;
        struct efx_rx_queue *rx_queue;
+       efx_qword_t errors;
        bool rx_cont;
        u16 flags = 0;
 
@@ -3171,8 +3261,14 @@ static int efx_ef10_handle_rx_event(struct efx_channel *channel,
        rx_bytes = EFX_QWORD_FIELD(*event, ESF_DZ_RX_BYTES);
        next_ptr_lbits = EFX_QWORD_FIELD(*event, ESF_DZ_RX_DSC_PTR_LBITS);
        rx_queue_label = EFX_QWORD_FIELD(*event, ESF_DZ_RX_QLABEL);
+       rx_l3_class = EFX_QWORD_FIELD(*event, ESF_DZ_RX_L3_CLASS);
        rx_l4_class = EFX_QWORD_FIELD(*event, ESF_DZ_RX_L4_CLASS);
        rx_cont = EFX_QWORD_FIELD(*event, ESF_DZ_RX_CONT);
+       rx_encap_hdr =
+               nic_data->datapath_caps &
+                       (1 << MC_CMD_GET_CAPABILITIES_OUT_VXLAN_NVGRE_LBN) ?
+               EFX_QWORD_FIELD(*event, ESF_EZ_RX_ENCAP_HDR) :
+               ESE_EZ_ENCAP_HDR_NONE;
 
        if (EFX_QWORD_FIELD(*event, ESF_DZ_RX_DROP_EVENT))
                netdev_WARN(efx->net_dev, "saw RX_DROP_EVENT: event="
@@ -3232,17 +3328,20 @@ static int efx_ef10_handle_rx_event(struct efx_channel *channel,
                n_packets = 1;
        }
 
-       if (unlikely(EFX_QWORD_FIELD(*event, ESF_DZ_RX_ECRC_ERR)))
-               flags |= EFX_RX_PKT_DISCARD;
-
-       if (unlikely(EFX_QWORD_FIELD(*event, ESF_DZ_RX_IPCKSUM_ERR))) {
-               channel->n_rx_ip_hdr_chksum_err += n_packets;
-       } else if (unlikely(EFX_QWORD_FIELD(*event,
-                                           ESF_DZ_RX_TCPUDP_CKSUM_ERR))) {
-               channel->n_rx_tcp_udp_chksum_err += n_packets;
-       } else if (rx_l4_class == ESE_DZ_L4_CLASS_TCP ||
-                  rx_l4_class == ESE_DZ_L4_CLASS_UDP) {
-               flags |= EFX_RX_PKT_CSUMMED;
+       EFX_POPULATE_QWORD_5(errors, ESF_DZ_RX_ECRC_ERR, 1,
+                                    ESF_DZ_RX_IPCKSUM_ERR, 1,
+                                    ESF_DZ_RX_TCPUDP_CKSUM_ERR, 1,
+                                    ESF_EZ_RX_IP_INNER_CHKSUM_ERR, 1,
+                                    ESF_EZ_RX_TCP_UDP_INNER_CHKSUM_ERR, 1);
+       EFX_AND_QWORD(errors, *event, errors);
+       if (unlikely(!EFX_QWORD_IS_ZERO(errors))) {
+               flags |= efx_ef10_handle_rx_event_errors(channel, n_packets,
+                                                        rx_l3_class, rx_l4_class,
+                                                        rx_encap_hdr, event);
+       } else {
+               if (rx_l4_class == ESE_DZ_L4_CLASS_TCP ||
+                   rx_l4_class == ESE_DZ_L4_CLASS_UDP)
+                       flags |= EFX_RX_PKT_CSUMMED;
        }
 
        if (rx_l4_class == ESE_DZ_L4_CLASS_TCP)

diff --git a/drivers/net/ethernet/sfc/ethtool.c b/drivers/net/ethernet/sfc/ethtool.c
index adddf70780adcba76b76905701d8572787350421..3747b564411073350c930305c941df8e713edd8c 100644 (file)
--- a/drivers/net/ethernet/sfc/ethtool.c
+++ b/drivers/net/ethernet/sfc/ethtool.c
@@ -77,6 +77,11 @@ static const struct efx_sw_stat_desc efx_sw_stat_desc[] = {
        EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc),
        EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err),
        EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err),
+       EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_inner_ip_hdr_chksum_err),
+       EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_inner_tcp_udp_chksum_err),
+       EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_outer_ip_hdr_chksum_err),
+       EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_outer_tcp_udp_chksum_err),
+       EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_eth_crc_err),
        EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch),
        EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc),
        EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_merge_events),

diff --git a/drivers/net/ethernet/sfc/net_driver.h b/drivers/net/ethernet/sfc/net_driver.h
index 73810d2d630ccf4b410002b2d3a72e04c955a7f9..3b151109278168038a4b6a926b26a161e27035e8 100644 (file)
--- a/drivers/net/ethernet/sfc/net_driver.h
+++ b/drivers/net/ethernet/sfc/net_driver.h
@@ -469,13 +469,18 @@ struct efx_channel {
        u32 *rps_flow_id;
 #endif
 
-       unsigned n_rx_tobe_disc;
-       unsigned n_rx_ip_hdr_chksum_err;
-       unsigned n_rx_tcp_udp_chksum_err;
-       unsigned n_rx_mcast_mismatch;
-       unsigned n_rx_frm_trunc;
-       unsigned n_rx_overlength;
-       unsigned n_skbuff_leaks;
+       unsigned int n_rx_tobe_disc;
+       unsigned int n_rx_ip_hdr_chksum_err;
+       unsigned int n_rx_tcp_udp_chksum_err;
+       unsigned int n_rx_outer_ip_hdr_chksum_err;
+       unsigned int n_rx_outer_tcp_udp_chksum_err;
+       unsigned int n_rx_inner_ip_hdr_chksum_err;
+       unsigned int n_rx_inner_tcp_udp_chksum_err;
+       unsigned int n_rx_eth_crc_err;
+       unsigned int n_rx_mcast_mismatch;
+       unsigned int n_rx_frm_trunc;
+       unsigned int n_rx_overlength;
+       unsigned int n_skbuff_leaks;
        unsigned int n_rx_nodesc_trunc;
        unsigned int n_rx_merge_events;
        unsigned int n_rx_merge_packets;