It seems csum is more common and shorter. Signed-off-by: Flavio Leitner <f...@sysclose.org> --- lib/dp-packet.h | 72 +++++++++++++++++++++---------------------- lib/netdev-dpdk.c | 16 +++++----- lib/netdev-linux.c | 8 ++--- lib/netdev-provider.h | 8 ++--- lib/netdev.c | 6 ++-- 5 files changed, 55 insertions(+), 55 deletions(-)
diff --git a/lib/dp-packet.h b/lib/dp-packet.h index ee8451496..18faa79c0 100644 --- a/lib/dp-packet.h +++ b/lib/dp-packet.h @@ -62,13 +62,13 @@ enum dp_packet_offload_mask { /* Is the 'flow_mark' valid? */ DEF_OL_FLAG(DP_PACKET_OL_FLOW_MARK, PKT_RX_FDIR_ID, 0x2), /* Bad L4 checksum in the packet. */ - DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CKSUM_BAD, PKT_RX_L4_CKSUM_BAD, 0x4), + DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CSUM_BAD, PKT_RX_L4_CKSUM_BAD, 0x4), /* Bad IP checksum in the packet. */ - DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CKSUM_BAD, PKT_RX_IP_CKSUM_BAD, 0x8), + DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CSUM_BAD, PKT_RX_IP_CKSUM_BAD, 0x8), /* Valid L4 checksum in the packet. */ - DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CKSUM_GOOD, PKT_RX_L4_CKSUM_GOOD, 0x10), + DEF_OL_FLAG(DP_PACKET_OL_RX_L4_CSUM_GOOD, PKT_RX_L4_CKSUM_GOOD, 0x10), /* Valid IP checksum in the packet. */ - DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CKSUM_GOOD, PKT_RX_IP_CKSUM_GOOD, 0x20), + DEF_OL_FLAG(DP_PACKET_OL_RX_IP_CSUM_GOOD, PKT_RX_IP_CKSUM_GOOD, 0x20), /* TCP Segmentation Offload. */ DEF_OL_FLAG(DP_PACKET_OL_TX_TCP_SEG, PKT_TX_TCP_SEG, 0x40), /* Offloaded packet is IPv4. */ @@ -76,34 +76,34 @@ enum dp_packet_offload_mask { /* Offloaded packet is IPv6. */ DEF_OL_FLAG(DP_PACKET_OL_TX_IPV6, PKT_TX_IPV6, 0x100), /* Offload TCP checksum. */ - DEF_OL_FLAG(DP_PACKET_OL_TX_TCP_CKSUM, PKT_TX_TCP_CKSUM, 0x200), + DEF_OL_FLAG(DP_PACKET_OL_TX_TCP_CSUM, PKT_TX_TCP_CKSUM, 0x200), /* Offload UDP checksum. */ - DEF_OL_FLAG(DP_PACKET_OL_TX_UDP_CKSUM, PKT_TX_UDP_CKSUM, 0x400), + DEF_OL_FLAG(DP_PACKET_OL_TX_UDP_CSUM, PKT_TX_UDP_CKSUM, 0x400), /* Offload SCTP checksum. */ - DEF_OL_FLAG(DP_PACKET_OL_TX_SCTP_CKSUM, PKT_TX_SCTP_CKSUM, 0x800), + DEF_OL_FLAG(DP_PACKET_OL_TX_SCTP_CSUM, PKT_TX_SCTP_CKSUM, 0x800), /* Adding new field requires adding to DP_PACKET_OL_SUPPORTED_MASK. */ }; #define DP_PACKET_OL_SUPPORTED_MASK (DP_PACKET_OL_RSS_HASH | \ DP_PACKET_OL_FLOW_MARK | \ - DP_PACKET_OL_RX_L4_CKSUM_BAD | \ - DP_PACKET_OL_RX_IP_CKSUM_BAD | \ - DP_PACKET_OL_RX_L4_CKSUM_GOOD | \ - DP_PACKET_OL_RX_IP_CKSUM_GOOD | \ + DP_PACKET_OL_RX_L4_CSUM_BAD | \ + DP_PACKET_OL_RX_IP_CSUM_BAD | \ + DP_PACKET_OL_RX_L4_CSUM_GOOD | \ + DP_PACKET_OL_RX_IP_CSUM_GOOD | \ DP_PACKET_OL_TX_TCP_SEG | \ DP_PACKET_OL_TX_IPV4 | \ DP_PACKET_OL_TX_IPV6 | \ - DP_PACKET_OL_TX_TCP_CKSUM | \ - DP_PACKET_OL_TX_UDP_CKSUM | \ - DP_PACKET_OL_TX_SCTP_CKSUM) - -#define DP_PACKET_OL_TX_L4_MASK (DP_PACKET_OL_TX_TCP_CKSUM | \ - DP_PACKET_OL_TX_UDP_CKSUM | \ - DP_PACKET_OL_TX_SCTP_CKSUM) -#define DP_PACKET_OL_RX_IP_CKSUM_MASK (DP_PACKET_OL_RX_IP_CKSUM_GOOD | \ - DP_PACKET_OL_RX_IP_CKSUM_BAD) -#define DP_PACKET_OL_RX_L4_CKSUM_MASK (DP_PACKET_OL_RX_L4_CKSUM_GOOD | \ - DP_PACKET_OL_RX_L4_CKSUM_BAD) + DP_PACKET_OL_TX_TCP_CSUM | \ + DP_PACKET_OL_TX_UDP_CSUM | \ + DP_PACKET_OL_TX_SCTP_CSUM) + +#define DP_PACKET_OL_TX_L4_MASK (DP_PACKET_OL_TX_TCP_CSUM | \ + DP_PACKET_OL_TX_UDP_CSUM | \ + DP_PACKET_OL_TX_SCTP_CSUM) +#define DP_PACKET_OL_RX_IP_CSUM_MASK (DP_PACKET_OL_RX_IP_CSUM_GOOD | \ + DP_PACKET_OL_RX_IP_CSUM_BAD) +#define DP_PACKET_OL_RX_L4_CSUM_MASK (DP_PACKET_OL_RX_L4_CSUM_GOOD | \ + DP_PACKET_OL_RX_L4_CSUM_BAD) /* Buffer for holding packet data. A dp_packet is automatically reallocated * as necessary if it grows too large for the available memory. @@ -989,7 +989,7 @@ static inline bool dp_packet_hwol_l4_is_tcp(const struct dp_packet *b) { return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) == - DP_PACKET_OL_TX_TCP_CKSUM; + DP_PACKET_OL_TX_TCP_CSUM; } /* Returns 'true' if packet 'b' is marked for UDP checksum offloading. */ @@ -997,7 +997,7 @@ static inline bool dp_packet_hwol_l4_is_udp(struct dp_packet *b) { return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) == - DP_PACKET_OL_TX_UDP_CKSUM; + DP_PACKET_OL_TX_UDP_CSUM; } /* Returns 'true' if packet 'b' is marked for SCTP checksum offloading. */ @@ -1005,7 +1005,7 @@ static inline bool dp_packet_hwol_l4_is_sctp(struct dp_packet *b) { return (*dp_packet_ol_flags_ptr(b) & DP_PACKET_OL_TX_L4_MASK) == - DP_PACKET_OL_TX_SCTP_CKSUM; + DP_PACKET_OL_TX_SCTP_CSUM; } /* Mark packet 'b' for IPv4 checksum offloading. */ @@ -1027,7 +1027,7 @@ dp_packet_hwol_set_tx_ipv6(struct dp_packet *b) static inline void dp_packet_hwol_set_csum_tcp(struct dp_packet *b) { - *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_TCP_CKSUM; + *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_TCP_CSUM; } /* Mark packet 'b' for UDP checksum offloading. It implies that either @@ -1035,7 +1035,7 @@ dp_packet_hwol_set_csum_tcp(struct dp_packet *b) static inline void dp_packet_hwol_set_csum_udp(struct dp_packet *b) { - *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_UDP_CKSUM; + *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_UDP_CSUM; } /* Mark packet 'b' for SCTP checksum offloading. It implies that either @@ -1043,7 +1043,7 @@ dp_packet_hwol_set_csum_udp(struct dp_packet *b) static inline void dp_packet_hwol_set_csum_sctp(struct dp_packet *b) { - *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_SCTP_CKSUM; + *dp_packet_ol_flags_ptr(b) |= DP_PACKET_OL_TX_SCTP_CSUM; } /* Mark packet 'b' for TCP segmentation offloading. It implies that @@ -1058,29 +1058,29 @@ dp_packet_hwol_set_tcp_seg(struct dp_packet *b) static inline bool dp_packet_ip_csum_valid(const struct dp_packet *p) { - return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CKSUM_MASK) == - DP_PACKET_OL_RX_IP_CKSUM_GOOD; + return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CSUM_MASK) == + DP_PACKET_OL_RX_IP_CSUM_GOOD; } static inline bool dp_packet_ip_csum_bad(const struct dp_packet *p) { - return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CKSUM_MASK) == - DP_PACKET_OL_RX_IP_CKSUM_BAD; + return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_IP_CSUM_MASK) == + DP_PACKET_OL_RX_IP_CSUM_BAD; } static inline bool dp_packet_l4_csum_valid(const struct dp_packet *p) { - return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CKSUM_MASK) == - DP_PACKET_OL_RX_L4_CKSUM_GOOD; + return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CSUM_MASK) == + DP_PACKET_OL_RX_L4_CSUM_GOOD; } static inline bool dp_packet_l4_csum_bad(const struct dp_packet *p) { - return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CKSUM_MASK) == - DP_PACKET_OL_RX_L4_CKSUM_BAD; + return (*dp_packet_ol_flags_ptr(p) & DP_PACKET_OL_RX_L4_CSUM_MASK) == + DP_PACKET_OL_RX_L4_CSUM_BAD; } #ifdef __cplusplus diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c index ca92c947a..6fbf19ada 100644 --- a/lib/netdev-dpdk.c +++ b/lib/netdev-dpdk.c @@ -5007,11 +5007,11 @@ netdev_dpdk_reconfigure(struct netdev *netdev) err = dpdk_eth_dev_init(dev); if (dev->hw_ol_features & NETDEV_TX_TSO_OFFLOAD) { netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_TSO; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CKSUM; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CKSUM; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CKSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CSUM; if (dev->hw_ol_features & NETDEV_TX_SCTP_CHECKSUM_OFFLOAD) { - netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CKSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CSUM; } } @@ -5154,10 +5154,10 @@ netdev_dpdk_vhost_client_reconfigure(struct netdev *netdev) if (userspace_tso_enabled()) { netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_TSO; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CKSUM; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CKSUM; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CKSUM; - netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CKSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CSUM; + netdev->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CSUM; vhost_unsup_flags = 1ULL << VIRTIO_NET_F_HOST_ECN | 1ULL << VIRTIO_NET_F_HOST_UFO; } else { diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c index 97bd21be4..e4b7c72f8 100644 --- a/lib/netdev-linux.c +++ b/lib/netdev-linux.c @@ -929,10 +929,10 @@ netdev_linux_common_construct(struct netdev *netdev_) if (userspace_tso_enabled()) { netdev_->ol_flags |= NETDEV_TX_OFFLOAD_TCP_TSO; - netdev_->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CKSUM; - netdev_->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CKSUM; - netdev_->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CKSUM; - netdev_->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CKSUM; + netdev_->ol_flags |= NETDEV_TX_OFFLOAD_TCP_CSUM; + netdev_->ol_flags |= NETDEV_TX_OFFLOAD_UDP_CSUM; + netdev_->ol_flags |= NETDEV_TX_OFFLOAD_SCTP_CSUM; + netdev_->ol_flags |= NETDEV_TX_OFFLOAD_IPV4_CSUM; } return 0; diff --git a/lib/netdev-provider.h b/lib/netdev-provider.h index b5420947d..08bf8b871 100644 --- a/lib/netdev-provider.h +++ b/lib/netdev-provider.h @@ -38,10 +38,10 @@ struct netdev_tnl_build_header_params; #define NETDEV_NUMA_UNSPEC OVS_NUMA_UNSPEC enum netdev_ol_flags { - NETDEV_TX_OFFLOAD_IPV4_CKSUM = 1 << 0, - NETDEV_TX_OFFLOAD_TCP_CKSUM = 1 << 1, - NETDEV_TX_OFFLOAD_UDP_CKSUM = 1 << 2, - NETDEV_TX_OFFLOAD_SCTP_CKSUM = 1 << 3, + NETDEV_TX_OFFLOAD_IPV4_CSUM = 1 << 0, + NETDEV_TX_OFFLOAD_TCP_CSUM = 1 << 1, + NETDEV_TX_OFFLOAD_UDP_CSUM = 1 << 2, + NETDEV_TX_OFFLOAD_SCTP_CSUM = 1 << 3, NETDEV_TX_OFFLOAD_TCP_TSO = 1 << 4, }; diff --git a/lib/netdev.c b/lib/netdev.c index 8305f6c42..e9b2bbe83 100644 --- a/lib/netdev.c +++ b/lib/netdev.c @@ -804,19 +804,19 @@ netdev_send_prepare_packet(const uint64_t netdev_flags, l4_mask = dp_packet_hwol_l4_mask(packet); if (l4_mask) { if (dp_packet_hwol_l4_is_tcp(packet)) { - if (!(netdev_flags & NETDEV_TX_OFFLOAD_TCP_CKSUM)) { + if (!(netdev_flags & NETDEV_TX_OFFLOAD_TCP_CSUM)) { /* Fall back to TCP csum in software. */ VLOG_ERR_BUF(errormsg, "No TCP checksum support"); return false; } } else if (dp_packet_hwol_l4_is_udp(packet)) { - if (!(netdev_flags & NETDEV_TX_OFFLOAD_UDP_CKSUM)) { + if (!(netdev_flags & NETDEV_TX_OFFLOAD_UDP_CSUM)) { /* Fall back to UDP csum in software. */ VLOG_ERR_BUF(errormsg, "No UDP checksum support"); return false; } } else if (dp_packet_hwol_l4_is_sctp(packet)) { - if (!(netdev_flags & NETDEV_TX_OFFLOAD_SCTP_CKSUM)) { + if (!(netdev_flags & NETDEV_TX_OFFLOAD_SCTP_CSUM)) { /* Fall back to SCTP csum in software. */ VLOG_ERR_BUF(errormsg, "No SCTP checksum support"); return false; -- 2.31.1 _______________________________________________ dev mailing list d...@openvswitch.org https://mail.openvswitch.org/mailman/listinfo/ovs-dev