l4p: refactor rx checksum check

For rx checksum check, we put HW and SW ways into one function, with
some code clean up.
As now we do have CKSUM_UNKNOWN, no need to have dev->rx.ol_flags
at all.

Change-Id: Ied77e63e1ec6f5569d16d4ba666fcc968479197d
Signed-off-by: Jianfeng Tan <henry.tjf@antfin.com>
Signed-off-by: Konstantin Ananyev <konstantin.ananyev@intel.com>

diff --git a/lib/libtle_l4p/ctx.c b/lib/libtle_l4p/ctx.c
index 910fc88..b8067f0 100644 (file)
--- a/lib/libtle_l4p/ctx.c
+++ b/lib/libtle_l4p/ctx.c
@@ -239,20 +239,6 @@ tle_add_dev(struct tle_ctx *ctx, const struct tle_dev_param *dev_prm)
                return NULL;
        }
 
-       /* setup RX data. */
-       if (dev_prm->local_addr4.s_addr != INADDR_ANY &&
-                       (dev_prm->rx_offload & DEV_RX_OFFLOAD_IPV4_CKSUM) == 0)
-               dev->rx.ol_flags[TLE_V4] |= PKT_RX_IP_CKSUM_BAD;
-
-       if (((dev_prm->rx_offload & DEV_RX_OFFLOAD_UDP_CKSUM) == 0 &&
-                       ctx->prm.proto == TLE_PROTO_UDP) ||
-                       ((dev_prm->rx_offload &
-                       DEV_RX_OFFLOAD_TCP_CKSUM) == 0 &&
-                       ctx->prm.proto == TLE_PROTO_TCP)) {
-               dev->rx.ol_flags[TLE_V4] |= PKT_RX_L4_CKSUM_BAD;
-               dev->rx.ol_flags[TLE_V6] |= PKT_RX_L4_CKSUM_BAD;
-       }
-
        /* setup TX data. */
        df = ((ctx->prm.flags & TLE_CTX_FLAG_ST) == 0) ? 0 :
                RING_F_SP_ENQ | RING_F_SC_DEQ;

diff --git a/lib/libtle_l4p/ctx.h b/lib/libtle_l4p/ctx.h
index 389d646..f18060b 100644 (file)
--- a/lib/libtle_l4p/ctx.h
+++ b/lib/libtle_l4p/ctx.h
@@ -36,9 +36,6 @@ struct tle_dport {
 
 struct tle_dev {
        struct tle_ctx *ctx;
-       struct {
-               uint64_t ol_flags[TLE_VNUM];
-       } rx;
        struct {
                /* used by FE. */
                uint64_t ol_flags[TLE_VNUM];

diff --git a/lib/libtle_l4p/misc.h b/lib/libtle_l4p/misc.h
index 9bff459..8be5dfe 100644 (file)
--- a/lib/libtle_l4p/misc.h
+++ b/lib/libtle_l4p/misc.h
@@ -286,6 +286,9 @@ _ipv4x_cksum(const void *iph, size_t len)
        return (cksum == 0xffff) ? cksum : ~cksum;
 }
 
+/*
+ * helper function to check csum.
+ */
 static inline int
 check_pkt_csum(const struct rte_mbuf *m, uint64_t ol_flags, uint32_t type,
        uint32_t proto)
@@ -293,19 +296,33 @@ check_pkt_csum(const struct rte_mbuf *m, uint64_t ol_flags, uint32_t type,
        const struct ipv4_hdr *l3h4;
        const struct ipv6_hdr *l3h6;
        const struct udp_hdr *l4h;
-       int32_t ret;
+       uint64_t fl3, fl4;
        uint16_t csum;
+       int32_t ret;
 
-       ret = 0;
+       fl4 = ol_flags & PKT_RX_L4_CKSUM_MASK;
+       fl3 = (type == TLE_V4) ?
+               (ol_flags & PKT_RX_IP_CKSUM_MASK) : PKT_RX_IP_CKSUM_GOOD;
+
+       /* case 0: both ip and l4 cksum is verified or data is valid */
+       if ((fl3 | fl4) == (PKT_RX_IP_CKSUM_GOOD | PKT_RX_L4_CKSUM_GOOD))
+               return 0;
+
+       /* case 1: either ip or l4 cksum bad */
+       if (fl3 == PKT_RX_IP_CKSUM_BAD || fl4 == PKT_RX_L4_CKSUM_BAD)
+               return 1;
+
+       /* case 2: either ip or l4 or both cksum is unknown */
        l3h4 = rte_pktmbuf_mtod_offset(m, const struct ipv4_hdr *, m->l2_len);
        l3h6 = rte_pktmbuf_mtod_offset(m, const struct ipv6_hdr *, m->l2_len);
 
-       if ((ol_flags & PKT_RX_IP_CKSUM_BAD) != 0) {
+       ret = 0;
+       if (fl3 == PKT_RX_IP_CKSUM_UNKNOWN && l3h4->hdr_checksum != 0) {
                csum = _ipv4x_cksum(l3h4, m->l3_len);
                ret = (csum != UINT16_MAX);
        }
 
-       if (ret == 0 && (ol_flags & PKT_RX_L4_CKSUM_BAD) != 0) {
+       if (ret == 0 && fl4 == PKT_RX_L4_CKSUM_UNKNOWN) {
 
                /*
                 * for IPv4 it is allowed to have zero UDP cksum,

diff --git a/lib/libtle_l4p/tcp_misc.h b/lib/libtle_l4p/tcp_misc.h
index 0ca5429..1b15dc5 100644 (file)
--- a/lib/libtle_l4p/tcp_misc.h
+++ b/lib/libtle_l4p/tcp_misc.h
@@ -441,7 +441,7 @@ get_pkt_info(const struct rte_mbuf *m, union pkt_info *pi, union seg_info *si)
                ((uintptr_t)tcph + offsetof(struct tcp_hdr, src_port));
        pi->tf.flags = tcph->tcp_flags;
        pi->tf.type = type;
-       pi->csf = m->ol_flags & (PKT_RX_IP_CKSUM_BAD | PKT_RX_L4_CKSUM_BAD);
+       pi->csf = m->ol_flags & (PKT_RX_IP_CKSUM_MASK | PKT_RX_L4_CKSUM_MASK);
        pi->port.raw = prt->raw;
 
        get_seg_info(tcph, si);

diff --git a/lib/libtle_l4p/tcp_rxtx.c b/lib/libtle_l4p/tcp_rxtx.c
index e785b9a..d1d2a16 100644 (file)
--- a/lib/libtle_l4p/tcp_rxtx.c
+++ b/lib/libtle_l4p/tcp_rxtx.c
@@ -1883,7 +1883,6 @@ tle_tcp_rx_bulk(struct tle_dev *dev, struct rte_mbuf *pkt[],
        struct stbl *st;
        struct tle_ctx *ctx;
        uint32_t i, j, k, mt, n, t, ts;
-       uint64_t csf;
        union pkt_info pi[num];
        union seg_info si[num];
        union {
@@ -1904,14 +1903,7 @@ tle_tcp_rx_bulk(struct tle_dev *dev, struct rte_mbuf *pkt[],
                get_pkt_info(pkt[i], &pi[i], &si[i]);
 
                t = pi[i].tf.type;
-               csf = dev->rx.ol_flags[t] &
-                       (PKT_RX_IP_CKSUM_BAD | PKT_RX_L4_CKSUM_BAD);
-
-               /* check csums in SW */
-               if (pi[i].csf == 0 && csf != 0 && check_pkt_csum(pkt[i], csf,
-                               pi[i].tf.type, IPPROTO_TCP) != 0)
-                       pi[i].csf = csf;
-
+               pi[i].csf = check_pkt_csum(pkt[i], pi[i].csf, t, IPPROTO_TCP);
                stu.t[t] = mt;
        }
 

diff --git a/lib/libtle_l4p/udp_rxtx.c b/lib/libtle_l4p/udp_rxtx.c
index ab746d1..76f6316 100644 (file)
--- a/lib/libtle_l4p/udp_rxtx.c
+++ b/lib/libtle_l4p/udp_rxtx.c
@@ -57,8 +57,7 @@ get_pkt_type(const struct rte_mbuf *m)
 }
 
 static inline union l4_ports
-pkt_info(const struct tle_dev *dev, struct rte_mbuf *m,
-       union l4_ports *ports, union ipv4_addrs *addr4,
+pkt_info(struct rte_mbuf *m, union l4_ports *ports, union ipv4_addrs *addr4,
        union ipv6_addrs **addr6)
 {
        uint32_t len;
@@ -72,11 +71,9 @@ pkt_info(const struct tle_dev *dev, struct rte_mbuf *m,
                pa4 = rte_pktmbuf_mtod_offset(m, union ipv4_addrs *,
                        len + offsetof(struct ipv4_hdr, src_addr));
                addr4->raw = pa4->raw;
-               m->ol_flags |= dev->rx.ol_flags[TLE_V4];
        } else if (ret.src == TLE_V6) {
                *addr6 = rte_pktmbuf_mtod_offset(m, union ipv6_addrs *,
                        len + offsetof(struct ipv6_hdr, src_addr));
-               m->ol_flags |= dev->rx.ol_flags[TLE_V6];
        }
 
        len += m->l3_len;
@@ -178,7 +175,7 @@ tle_udp_rx_bulk(struct tle_dev *dev, struct rte_mbuf *pkt[],
        union ipv6_addrs *pa6[num];
 
        for (i = 0; i != num; i++)
-               tp[i] = pkt_info(dev, pkt[i], &port[i], &a4[i], &pa6[i]);
+               tp[i] = pkt_info(pkt[i], &port[i], &a4[i], &pa6[i]);
 
        k = 0;
        for (i = 0; i != num; i = j) {
@@ -276,7 +273,7 @@ static inline uint32_t
 recv_pkt_process(struct rte_mbuf *m[], uint32_t num, uint32_t type)
 {
        uint32_t i, k;
-       uint64_t f, flg[num], ofl[num];
+       uint64_t flg[num], ofl[num];
 
        for (i = 0; i != num; i++) {
                flg[i] = m[i]->ol_flags;
@@ -286,18 +283,13 @@ recv_pkt_process(struct rte_mbuf *m[], uint32_t num, uint32_t type)
        k = 0;
        for (i = 0; i != num; i++) {
 
-               f = flg[i] & (PKT_RX_IP_CKSUM_BAD | PKT_RX_L4_CKSUM_BAD);
-
                /* drop packets with invalid cksum(s). */
-               if (f != 0 && check_pkt_csum(m[i], m[i]->ol_flags, type,
-                               IPPROTO_UDP) != 0) {
+               if (check_pkt_csum(m[i], flg[i], type, IPPROTO_UDP) != 0) {
                        rte_pktmbuf_free(m[i]);
                        m[i] = NULL;
                        k++;
-               } else {
-                       m[i]->ol_flags ^= f;
+               } else
                        rte_pktmbuf_adj(m[i], _tx_offload_l4_offset(ofl[i]));
-               }
        }
 
        return k;