[qemu.git] / hw / net / net_rx_pkt.c

/*
 * QEMU RX packets abstractions
 *
 * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
 *
 * Developed by Daynix Computing LTD (http://www.daynix.com)
 *
 * Authors:
 * Dmitry Fleytman <[email protected]>
 * Tamir Shomer <[email protected]>
 * Yan Vugenfirer <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 *
 */

#include "qemu/osdep.h"
#include "trace.h"
#include "net_rx_pkt.h"
#include "net/checksum.h"
#include "net/tap.h"

struct NetRxPkt {
    struct virtio_net_hdr virt_hdr;
    uint8_t ehdr_buf[sizeof(struct eth_header)];
    struct iovec *vec;
    uint16_t vec_len_total;
    uint16_t vec_len;
    uint32_t tot_len;
    uint16_t tci;
    bool vlan_stripped;
    bool has_virt_hdr;
    eth_pkt_types_e packet_type;

    /* Analysis results */
    bool isip4;
    bool isip6;
    bool isudp;
    bool istcp;

    size_t l3hdr_off;
    size_t l4hdr_off;
    size_t l5hdr_off;

    eth_ip6_hdr_info ip6hdr_info;
    eth_ip4_hdr_info ip4hdr_info;
    eth_l4_hdr_info  l4hdr_info;
};

void net_rx_pkt_init(struct NetRxPkt **pkt, bool has_virt_hdr)
{
    struct NetRxPkt *p = g_malloc0(sizeof *p);
    p->has_virt_hdr = has_virt_hdr;
    p->vec = NULL;
    p->vec_len_total = 0;
    *pkt = p;
}

void net_rx_pkt_uninit(struct NetRxPkt *pkt)
{
    if (pkt->vec_len_total != 0) {
        g_free(pkt->vec);
    }

    g_free(pkt);
}

struct virtio_net_hdr *net_rx_pkt_get_vhdr(struct NetRxPkt *pkt)
{
    assert(pkt);
    return &pkt->virt_hdr;
}

static inline void
net_rx_pkt_iovec_realloc(struct NetRxPkt *pkt,
                            int new_iov_len)
{
    if (pkt->vec_len_total < new_iov_len) {
        g_free(pkt->vec);
        pkt->vec = g_malloc(sizeof(*pkt->vec) * new_iov_len);
        pkt->vec_len_total = new_iov_len;
    }
}

static void
net_rx_pkt_pull_data(struct NetRxPkt *pkt,
                        const struct iovec *iov, int iovcnt,
                        size_t ploff)
{
    if (pkt->vlan_stripped) {
        net_rx_pkt_iovec_realloc(pkt, iovcnt + 1);

        pkt->vec[0].iov_base = pkt->ehdr_buf;
        pkt->vec[0].iov_len = sizeof(pkt->ehdr_buf);

        pkt->tot_len =
            iov_size(iov, iovcnt) - ploff + sizeof(struct eth_header);

        pkt->vec_len = iov_copy(pkt->vec + 1, pkt->vec_len_total - 1,
                                iov, iovcnt, ploff, pkt->tot_len);
    } else {
        net_rx_pkt_iovec_realloc(pkt, iovcnt);

        pkt->tot_len = iov_size(iov, iovcnt) - ploff;
        pkt->vec_len = iov_copy(pkt->vec, pkt->vec_len_total,
                                iov, iovcnt, ploff, pkt->tot_len);
    }

    eth_get_protocols(pkt->vec, pkt->vec_len, &pkt->isip4, &pkt->isip6,
                      &pkt->isudp, &pkt->istcp,
                      &pkt->l3hdr_off, &pkt->l4hdr_off, &pkt->l5hdr_off,
                      &pkt->ip6hdr_info, &pkt->ip4hdr_info, &pkt->l4hdr_info);

    trace_net_rx_pkt_parsed(pkt->isip4, pkt->isip6, pkt->isudp, pkt->istcp,
                            pkt->l3hdr_off, pkt->l4hdr_off, pkt->l5hdr_off);
}

void net_rx_pkt_attach_iovec(struct NetRxPkt *pkt,
                                const struct iovec *iov, int iovcnt,
                                size_t iovoff, bool strip_vlan)
{
    uint16_t tci = 0;
    uint16_t ploff = iovoff;
    assert(pkt);
    pkt->vlan_stripped = false;

    if (strip_vlan) {
        pkt->vlan_stripped = eth_strip_vlan(iov, iovcnt, iovoff, pkt->ehdr_buf,
                                            &ploff, &tci);
    }

    pkt->tci = tci;

    net_rx_pkt_pull_data(pkt, iov, iovcnt, ploff);
}

void net_rx_pkt_attach_iovec_ex(struct NetRxPkt *pkt,
                                const struct iovec *iov, int iovcnt,
                                size_t iovoff, bool strip_vlan,
                                uint16_t vet)
{
    uint16_t tci = 0;
    uint16_t ploff = iovoff;
    assert(pkt);
    pkt->vlan_stripped = false;

    if (strip_vlan) {
        pkt->vlan_stripped = eth_strip_vlan_ex(iov, iovcnt, iovoff, vet,
                                               pkt->ehdr_buf,
                                               &ploff, &tci);
    }

    pkt->tci = tci;

    net_rx_pkt_pull_data(pkt, iov, iovcnt, ploff);
}

void net_rx_pkt_dump(struct NetRxPkt *pkt)
{
#ifdef NET_RX_PKT_DEBUG
    NetRxPkt *pkt = (NetRxPkt *)pkt;
    assert(pkt);

    printf("RX PKT: tot_len: %d, vlan_stripped: %d, vlan_tag: %d\n",
              pkt->tot_len, pkt->vlan_stripped, pkt->tci);
#endif
}

void net_rx_pkt_set_packet_type(struct NetRxPkt *pkt,
    eth_pkt_types_e packet_type)
{
    assert(pkt);

    pkt->packet_type = packet_type;

}

eth_pkt_types_e net_rx_pkt_get_packet_type(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->packet_type;
}

size_t net_rx_pkt_get_total_len(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->tot_len;
}

void net_rx_pkt_set_protocols(struct NetRxPkt *pkt, const void *data,
                              size_t len)
{
    const struct iovec iov = {
        .iov_base = (void *)data,
        .iov_len = len
    };

    assert(pkt);

    eth_get_protocols(&iov, 1, &pkt->isip4, &pkt->isip6,
                      &pkt->isudp, &pkt->istcp,
                      &pkt->l3hdr_off, &pkt->l4hdr_off, &pkt->l5hdr_off,
                      &pkt->ip6hdr_info, &pkt->ip4hdr_info, &pkt->l4hdr_info);
}

void net_rx_pkt_get_protocols(struct NetRxPkt *pkt,
                              bool *isip4, bool *isip6,
                              bool *isudp, bool *istcp)
{
    assert(pkt);

    *isip4 = pkt->isip4;
    *isip6 = pkt->isip6;
    *isudp = pkt->isudp;
    *istcp = pkt->istcp;
}

size_t net_rx_pkt_get_l3_hdr_offset(struct NetRxPkt *pkt)
{
    assert(pkt);
    return pkt->l3hdr_off;
}

size_t net_rx_pkt_get_l4_hdr_offset(struct NetRxPkt *pkt)
{
    assert(pkt);
    return pkt->l4hdr_off;
}

size_t net_rx_pkt_get_l5_hdr_offset(struct NetRxPkt *pkt)
{
    assert(pkt);
    return pkt->l5hdr_off;
}

eth_ip6_hdr_info *net_rx_pkt_get_ip6_info(struct NetRxPkt *pkt)
{
    return &pkt->ip6hdr_info;
}

eth_ip4_hdr_info *net_rx_pkt_get_ip4_info(struct NetRxPkt *pkt)
{
    return &pkt->ip4hdr_info;
}

eth_l4_hdr_info *net_rx_pkt_get_l4_info(struct NetRxPkt *pkt)
{
    return &pkt->l4hdr_info;
}

static inline void
_net_rx_rss_add_chunk(uint8_t *rss_input, size_t *bytes_written,
                      void *ptr, size_t size)
{
    memcpy(&rss_input[*bytes_written], ptr, size);
    trace_net_rx_pkt_rss_add_chunk(ptr, size, *bytes_written);
    *bytes_written += size;
}

static inline void
_net_rx_rss_prepare_ip4(uint8_t *rss_input,
                        struct NetRxPkt *pkt,
                        size_t *bytes_written)
{
    struct ip_header *ip4_hdr = &pkt->ip4hdr_info.ip4_hdr;

    _net_rx_rss_add_chunk(rss_input, bytes_written,
                          &ip4_hdr->ip_src, sizeof(uint32_t));

    _net_rx_rss_add_chunk(rss_input, bytes_written,
                          &ip4_hdr->ip_dst, sizeof(uint32_t));
}

static inline void
_net_rx_rss_prepare_ip6(uint8_t *rss_input,
                        struct NetRxPkt *pkt,
                        bool ipv6ex, size_t *bytes_written)
{
    eth_ip6_hdr_info *ip6info = &pkt->ip6hdr_info;

    _net_rx_rss_add_chunk(rss_input, bytes_written,
           (ipv6ex && ip6info->rss_ex_src_valid) ? &ip6info->rss_ex_src
                                                 : &ip6info->ip6_hdr.ip6_src,
           sizeof(struct in6_address));

    _net_rx_rss_add_chunk(rss_input, bytes_written,
           (ipv6ex && ip6info->rss_ex_dst_valid) ? &ip6info->rss_ex_dst
                                                 : &ip6info->ip6_hdr.ip6_dst,
           sizeof(struct in6_address));
}

static inline void
_net_rx_rss_prepare_tcp(uint8_t *rss_input,
                        struct NetRxPkt *pkt,
                        size_t *bytes_written)
{
    struct tcp_header *tcphdr = &pkt->l4hdr_info.hdr.tcp;

    _net_rx_rss_add_chunk(rss_input, bytes_written,
                          &tcphdr->th_sport, sizeof(uint16_t));

    _net_rx_rss_add_chunk(rss_input, bytes_written,
                          &tcphdr->th_dport, sizeof(uint16_t));
}

uint32_t
net_rx_pkt_calc_rss_hash(struct NetRxPkt *pkt,
                         NetRxPktRssType type,
                         uint8_t *key)
{
    uint8_t rss_input[36];
    size_t rss_length = 0;
    uint32_t rss_hash = 0;
    net_toeplitz_key key_data;

    switch (type) {
    case NetPktRssIpV4:
        assert(pkt->isip4);
        trace_net_rx_pkt_rss_ip4();
        _net_rx_rss_prepare_ip4(&rss_input[0], pkt, &rss_length);
        break;
    case NetPktRssIpV4Tcp:
        assert(pkt->isip4);
        assert(pkt->istcp);
        trace_net_rx_pkt_rss_ip4_tcp();
        _net_rx_rss_prepare_ip4(&rss_input[0], pkt, &rss_length);
        _net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
        break;
    case NetPktRssIpV6Tcp:
        assert(pkt->isip6);
        assert(pkt->istcp);
        trace_net_rx_pkt_rss_ip6_tcp();
        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
        _net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
        break;
    case NetPktRssIpV6:
        assert(pkt->isip6);
        trace_net_rx_pkt_rss_ip6();
        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, false, &rss_length);
        break;
    case NetPktRssIpV6Ex:
        assert(pkt->isip6);
        trace_net_rx_pkt_rss_ip6_ex();
        _net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
        break;
    default:
        assert(false);
        break;
    }

    net_toeplitz_key_init(&key_data, key);
    net_toeplitz_add(&rss_hash, rss_input, rss_length, &key_data);

    trace_net_rx_pkt_rss_hash(rss_length, rss_hash);

    return rss_hash;
}

uint16_t net_rx_pkt_get_ip_id(struct NetRxPkt *pkt)
{
    assert(pkt);

    if (pkt->isip4) {
        return be16_to_cpu(pkt->ip4hdr_info.ip4_hdr.ip_id);
    }

    return 0;
}

bool net_rx_pkt_is_tcp_ack(struct NetRxPkt *pkt)
{
    assert(pkt);

    if (pkt->istcp) {
        return TCP_HEADER_FLAGS(&pkt->l4hdr_info.hdr.tcp) & TCP_FLAG_ACK;
    }

    return false;
}

bool net_rx_pkt_has_tcp_data(struct NetRxPkt *pkt)
{
    assert(pkt);

    if (pkt->istcp) {
        return pkt->l4hdr_info.has_tcp_data;
    }

    return false;
}

struct iovec *net_rx_pkt_get_iovec(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->vec;
}

uint16_t net_rx_pkt_get_iovec_len(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->vec_len;
}

void net_rx_pkt_set_vhdr(struct NetRxPkt *pkt,
                            struct virtio_net_hdr *vhdr)
{
    assert(pkt);

    memcpy(&pkt->virt_hdr, vhdr, sizeof pkt->virt_hdr);
}

void net_rx_pkt_set_vhdr_iovec(struct NetRxPkt *pkt,
    const struct iovec *iov, int iovcnt)
{
    assert(pkt);

    iov_to_buf(iov, iovcnt, 0, &pkt->virt_hdr, sizeof pkt->virt_hdr);
}

bool net_rx_pkt_is_vlan_stripped(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->vlan_stripped;
}

bool net_rx_pkt_has_virt_hdr(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->has_virt_hdr;
}

uint16_t net_rx_pkt_get_vlan_tag(struct NetRxPkt *pkt)
{
    assert(pkt);

    return pkt->tci;
}

bool net_rx_pkt_validate_l3_csum(struct NetRxPkt *pkt, bool *csum_valid)
{
    uint32_t cntr;
    uint16_t csum;
    uint32_t csl;

    trace_net_rx_pkt_l3_csum_validate_entry();

    if (!pkt->isip4) {
        trace_net_rx_pkt_l3_csum_validate_not_ip4();
        return false;
    }

    csl = pkt->l4hdr_off - pkt->l3hdr_off;

    cntr = net_checksum_add_iov(pkt->vec, pkt->vec_len,
                                pkt->l3hdr_off,
                                csl, 0);

    csum = net_checksum_finish(cntr);

    *csum_valid = (csum == 0);

    trace_net_rx_pkt_l3_csum_validate_csum(pkt->l3hdr_off, csl,
                                           cntr, csum, *csum_valid);

    return true;
}

static uint16_t
_net_rx_pkt_calc_l4_csum(struct NetRxPkt *pkt)
{
    uint32_t cntr;
    uint16_t csum;
    uint16_t csl;
    uint32_t cso;

    trace_net_rx_pkt_l4_csum_calc_entry();

    if (pkt->isip4) {
        if (pkt->isudp) {
            csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
            trace_net_rx_pkt_l4_csum_calc_ip4_udp();
        } else {
            csl = be16_to_cpu(pkt->ip4hdr_info.ip4_hdr.ip_len) -
                  IP_HDR_GET_LEN(&pkt->ip4hdr_info.ip4_hdr);
            trace_net_rx_pkt_l4_csum_calc_ip4_tcp();
        }

        cntr = eth_calc_ip4_pseudo_hdr_csum(&pkt->ip4hdr_info.ip4_hdr,
                                            csl, &cso);
        trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
    } else {
        if (pkt->isudp) {
            csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
            trace_net_rx_pkt_l4_csum_calc_ip6_udp();
        } else {
            struct ip6_header *ip6hdr = &pkt->ip6hdr_info.ip6_hdr;
            size_t full_ip6hdr_len = pkt->l4hdr_off - pkt->l3hdr_off;
            size_t ip6opts_len = full_ip6hdr_len - sizeof(struct ip6_header);

            csl = be16_to_cpu(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen) -
                  ip6opts_len;
            trace_net_rx_pkt_l4_csum_calc_ip6_tcp();
        }

        cntr = eth_calc_ip6_pseudo_hdr_csum(&pkt->ip6hdr_info.ip6_hdr, csl,
                                            pkt->ip6hdr_info.l4proto, &cso);
        trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
    }

    cntr += net_checksum_add_iov(pkt->vec, pkt->vec_len,
                                 pkt->l4hdr_off, csl, cso);

    csum = net_checksum_finish(cntr);

    trace_net_rx_pkt_l4_csum_calc_csum(pkt->l4hdr_off, csl, cntr, csum);

    return csum;
}

bool net_rx_pkt_validate_l4_csum(struct NetRxPkt *pkt, bool *csum_valid)
{
    uint16_t csum;

    trace_net_rx_pkt_l4_csum_validate_entry();

    if (!pkt->istcp && !pkt->isudp) {
        trace_net_rx_pkt_l4_csum_validate_not_xxp();
        return false;
    }

    if (pkt->isudp && (pkt->l4hdr_info.hdr.udp.uh_sum == 0)) {
        trace_net_rx_pkt_l4_csum_validate_udp_with_no_checksum();
        return false;
    }

    if (pkt->isip4 && pkt->ip4hdr_info.fragment) {
        trace_net_rx_pkt_l4_csum_validate_ip4_fragment();
        return false;
    }

    csum = _net_rx_pkt_calc_l4_csum(pkt);

    *csum_valid = ((csum == 0) || (csum == 0xFFFF));

    trace_net_rx_pkt_l4_csum_validate_csum(*csum_valid);

    return true;
}

bool net_rx_pkt_fix_l4_csum(struct NetRxPkt *pkt)
{
    uint16_t csum = 0;
    uint32_t l4_cso;

    trace_net_rx_pkt_l4_csum_fix_entry();

    if (pkt->istcp) {
        l4_cso = offsetof(struct tcp_header, th_sum);
        trace_net_rx_pkt_l4_csum_fix_tcp(l4_cso);
    } else if (pkt->isudp) {
        if (pkt->l4hdr_info.hdr.udp.uh_sum == 0) {
            trace_net_rx_pkt_l4_csum_fix_udp_with_no_checksum();
            return false;
        }
        l4_cso = offsetof(struct udp_header, uh_sum);
        trace_net_rx_pkt_l4_csum_fix_udp(l4_cso);
    } else {
        trace_net_rx_pkt_l4_csum_fix_not_xxp();
        return false;
    }

    if (pkt->isip4 && pkt->ip4hdr_info.fragment) {
            trace_net_rx_pkt_l4_csum_fix_ip4_fragment();
            return false;
    }

    /* Set zero to checksum word */
    iov_from_buf(pkt->vec, pkt->vec_len,
                 pkt->l4hdr_off + l4_cso,
                 &csum, sizeof(csum));

    /* Calculate L4 checksum */
    csum = cpu_to_be16(_net_rx_pkt_calc_l4_csum(pkt));

    /* Set calculated checksum to checksum word */
    iov_from_buf(pkt->vec, pkt->vec_len,
                 pkt->l4hdr_off + l4_cso,
                 &csum, sizeof(csum));

    trace_net_rx_pkt_l4_csum_fix_csum(pkt->l4hdr_off + l4_cso, csum);

    return true;
}
Commit	Line	Data
e263cd49	1	/*
605d52e6	2	* QEMU RX packets abstractions
e263cd49 DF	3	*
	4	* Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
	5	*
	6	* Developed by Daynix Computing LTD (http://www.daynix.com)
	7	*
	8	* Authors:
	9	* Dmitry Fleytman <[email protected]>
	10	* Tamir Shomer <[email protected]>
	11	* Yan Vugenfirer <[email protected]>
	12	*
	13	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	14	* See the COPYING file in the top-level directory.
	15	*
	16	*/
	17
e8d40465	18	#include "qemu/osdep.h"
eb700029	19	#include "trace.h"
605d52e6	20	#include "net_rx_pkt.h"
e263cd49 DF	21	#include "net/checksum.h"
	22	#include "net/tap.h"
	23
605d52e6	24	struct NetRxPkt {
e263cd49	25	struct virtio_net_hdr virt_hdr;
eb700029 DF	26	uint8_t ehdr_buf[sizeof(struct eth_header)];
	27	struct iovec *vec;
	28	uint16_t vec_len_total;
e263cd49 DF	29	uint16_t vec_len;
	30	uint32_t tot_len;
	31	uint16_t tci;
	32	bool vlan_stripped;
	33	bool has_virt_hdr;
	34	eth_pkt_types_e packet_type;
	35
	36	/* Analysis results */
	37	bool isip4;
	38	bool isip6;
	39	bool isudp;
	40	bool istcp;
eb700029 DF	41
	42	size_t l3hdr_off;
	43	size_t l4hdr_off;
	44	size_t l5hdr_off;
	45
	46	eth_ip6_hdr_info ip6hdr_info;
	47	eth_ip4_hdr_info ip4hdr_info;
	48	eth_l4_hdr_info l4hdr_info;
e263cd49 DF	49	};
e263cd49 DF	50
605d52e6	51	void net_rx_pkt_init(struct NetRxPkt **pkt, bool has_virt_hdr)
e263cd49	52	{
605d52e6	53	struct NetRxPkt p = g_malloc0(sizeof p);
e263cd49	54	p->has_virt_hdr = has_virt_hdr;
eb700029 DF	55	p->vec = NULL;
eb700029 DF	56	p->vec_len_total = 0;
e263cd49 DF	57	*pkt = p;
	58	}
	59
605d52e6	60	void net_rx_pkt_uninit(struct NetRxPkt *pkt)
e263cd49	61	{
eb700029 DF	62	if (pkt->vec_len_total != 0) {
	63	g_free(pkt->vec);
	64	}
	65
e263cd49 DF	66	g_free(pkt);
	67	}
	68
605d52e6	69	struct virtio_net_hdr net_rx_pkt_get_vhdr(struct NetRxPkt pkt)
e263cd49 DF	70	{
	71	assert(pkt);
	72	return &pkt->virt_hdr;
	73	}
	74
eb700029 DF	75	static inline void
	76	net_rx_pkt_iovec_realloc(struct NetRxPkt *pkt,
	77	int new_iov_len)
	78	{
	79	if (pkt->vec_len_total < new_iov_len) {
	80	g_free(pkt->vec);
	81	pkt->vec = g_malloc(sizeof(pkt->vec) new_iov_len);
	82	pkt->vec_len_total = new_iov_len;
	83	}
	84	}
	85
	86	static void
	87	net_rx_pkt_pull_data(struct NetRxPkt *pkt,
	88	const struct iovec *iov, int iovcnt,
	89	size_t ploff)
	90	{
	91	if (pkt->vlan_stripped) {
	92	net_rx_pkt_iovec_realloc(pkt, iovcnt + 1);
	93
	94	pkt->vec[0].iov_base = pkt->ehdr_buf;
	95	pkt->vec[0].iov_len = sizeof(pkt->ehdr_buf);
	96
	97	pkt->tot_len =
	98	iov_size(iov, iovcnt) - ploff + sizeof(struct eth_header);
	99
	100	pkt->vec_len = iov_copy(pkt->vec + 1, pkt->vec_len_total - 1,
	101	iov, iovcnt, ploff, pkt->tot_len);
	102	} else {
	103	net_rx_pkt_iovec_realloc(pkt, iovcnt);
	104
	105	pkt->tot_len = iov_size(iov, iovcnt) - ploff;
	106	pkt->vec_len = iov_copy(pkt->vec, pkt->vec_len_total,
	107	iov, iovcnt, ploff, pkt->tot_len);
	108	}
	109
	110	eth_get_protocols(pkt->vec, pkt->vec_len, &pkt->isip4, &pkt->isip6,
	111	&pkt->isudp, &pkt->istcp,
	112	&pkt->l3hdr_off, &pkt->l4hdr_off, &pkt->l5hdr_off,
	113	&pkt->ip6hdr_info, &pkt->ip4hdr_info, &pkt->l4hdr_info);
	114
	115	trace_net_rx_pkt_parsed(pkt->isip4, pkt->isip6, pkt->isudp, pkt->istcp,
	116	pkt->l3hdr_off, pkt->l4hdr_off, pkt->l5hdr_off);
	117	}
	118
	119	void net_rx_pkt_attach_iovec(struct NetRxPkt *pkt,
	120	const struct iovec *iov, int iovcnt,
	121	size_t iovoff, bool strip_vlan)
e263cd49 DF	122	{
e263cd49 DF	123	uint16_t tci = 0;
eb700029	124	uint16_t ploff = iovoff;
e263cd49 DF	125	assert(pkt);
	126	pkt->vlan_stripped = false;
	127
	128	if (strip_vlan) {
eb700029 DF	129	pkt->vlan_stripped = eth_strip_vlan(iov, iovcnt, iovoff, pkt->ehdr_buf,
eb700029 DF	130	&ploff, &tci);
e263cd49 DF	131	}
e263cd49 DF	132
eb700029 DF	133	pkt->tci = tci;
	134
	135	net_rx_pkt_pull_data(pkt, iov, iovcnt, ploff);
	136	}
	137
	138	void net_rx_pkt_attach_iovec_ex(struct NetRxPkt *pkt,
	139	const struct iovec *iov, int iovcnt,
	140	size_t iovoff, bool strip_vlan,
	141	uint16_t vet)
	142	{
	143	uint16_t tci = 0;
	144	uint16_t ploff = iovoff;
	145	assert(pkt);
	146	pkt->vlan_stripped = false;
	147
	148	if (strip_vlan) {
	149	pkt->vlan_stripped = eth_strip_vlan_ex(iov, iovcnt, iovoff, vet,
	150	pkt->ehdr_buf,
	151	&ploff, &tci);
e263cd49 DF	152	}
	153
	154	pkt->tci = tci;
eb700029 DF	155
eb700029 DF	156	net_rx_pkt_pull_data(pkt, iov, iovcnt, ploff);
e263cd49 DF	157	}
e263cd49 DF	158
605d52e6	159	void net_rx_pkt_dump(struct NetRxPkt *pkt)
e263cd49	160	{
605d52e6 DF	161	#ifdef NET_RX_PKT_DEBUG
605d52e6 DF	162	NetRxPkt pkt = (NetRxPkt )pkt;
e263cd49 DF	163	assert(pkt);
	164
	165	printf("RX PKT: tot_len: %d, vlan_stripped: %d, vlan_tag: %d\n",
	166	pkt->tot_len, pkt->vlan_stripped, pkt->tci);
	167	#endif
	168	}
	169
605d52e6	170	void net_rx_pkt_set_packet_type(struct NetRxPkt *pkt,
e263cd49 DF	171	eth_pkt_types_e packet_type)
	172	{
	173	assert(pkt);
	174
	175	pkt->packet_type = packet_type;
	176
	177	}
	178
605d52e6	179	eth_pkt_types_e net_rx_pkt_get_packet_type(struct NetRxPkt *pkt)
e263cd49 DF	180	{
	181	assert(pkt);
	182
	183	return pkt->packet_type;
	184	}
	185
605d52e6	186	size_t net_rx_pkt_get_total_len(struct NetRxPkt *pkt)
e263cd49 DF	187	{
	188	assert(pkt);
	189
	190	return pkt->tot_len;
	191	}
	192
605d52e6 DF	193	void net_rx_pkt_set_protocols(struct NetRxPkt pkt, const void data,
605d52e6 DF	194	size_t len)
fcf0cdc3	195	{
eb700029 DF	196	const struct iovec iov = {
	197	.iov_base = (void *)data,
	198	.iov_len = len
	199	};
	200
fcf0cdc3 SL	201	assert(pkt);
fcf0cdc3 SL	202
eb700029 DF	203	eth_get_protocols(&iov, 1, &pkt->isip4, &pkt->isip6,
	204	&pkt->isudp, &pkt->istcp,
	205	&pkt->l3hdr_off, &pkt->l4hdr_off, &pkt->l5hdr_off,
	206	&pkt->ip6hdr_info, &pkt->ip4hdr_info, &pkt->l4hdr_info);
fcf0cdc3 SL	207	}
fcf0cdc3 SL	208
605d52e6 DF	209	void net_rx_pkt_get_protocols(struct NetRxPkt *pkt,
	210	bool isip4, bool isip6,
	211	bool isudp, bool istcp)
e263cd49 DF	212	{
	213	assert(pkt);
	214
	215	*isip4 = pkt->isip4;
	216	*isip6 = pkt->isip6;
	217	*isudp = pkt->isudp;
	218	*istcp = pkt->istcp;
	219	}
	220
eb700029 DF	221	size_t net_rx_pkt_get_l3_hdr_offset(struct NetRxPkt *pkt)
	222	{
	223	assert(pkt);
	224	return pkt->l3hdr_off;
	225	}
	226
	227	size_t net_rx_pkt_get_l4_hdr_offset(struct NetRxPkt *pkt)
	228	{
	229	assert(pkt);
	230	return pkt->l4hdr_off;
	231	}
	232
	233	size_t net_rx_pkt_get_l5_hdr_offset(struct NetRxPkt *pkt)
	234	{
	235	assert(pkt);
	236	return pkt->l5hdr_off;
	237	}
	238
	239	eth_ip6_hdr_info net_rx_pkt_get_ip6_info(struct NetRxPkt pkt)
	240	{
	241	return &pkt->ip6hdr_info;
	242	}
	243
	244	eth_ip4_hdr_info net_rx_pkt_get_ip4_info(struct NetRxPkt pkt)
	245	{
	246	return &pkt->ip4hdr_info;
	247	}
	248
	249	eth_l4_hdr_info net_rx_pkt_get_l4_info(struct NetRxPkt pkt)
	250	{
	251	return &pkt->l4hdr_info;
	252	}
	253
	254	static inline void
	255	_net_rx_rss_add_chunk(uint8_t rss_input, size_t bytes_written,
	256	void *ptr, size_t size)
	257	{
	258	memcpy(&rss_input[*bytes_written], ptr, size);
	259	trace_net_rx_pkt_rss_add_chunk(ptr, size, *bytes_written);
	260	*bytes_written += size;
	261	}
	262
	263	static inline void
	264	_net_rx_rss_prepare_ip4(uint8_t *rss_input,
	265	struct NetRxPkt *pkt,
	266	size_t *bytes_written)
	267	{
	268	struct ip_header *ip4_hdr = &pkt->ip4hdr_info.ip4_hdr;
	269
	270	_net_rx_rss_add_chunk(rss_input, bytes_written,
	271	&ip4_hdr->ip_src, sizeof(uint32_t));
	272
	273	_net_rx_rss_add_chunk(rss_input, bytes_written,
	274	&ip4_hdr->ip_dst, sizeof(uint32_t));
	275	}
	276
	277	static inline void
	278	_net_rx_rss_prepare_ip6(uint8_t *rss_input,
	279	struct NetRxPkt *pkt,
	280	bool ipv6ex, size_t *bytes_written)
	281	{
	282	eth_ip6_hdr_info *ip6info = &pkt->ip6hdr_info;
	283
	284	_net_rx_rss_add_chunk(rss_input, bytes_written,
285	(ipv6ex && ip6info->rss_ex_src_valid) ? &ip6info->rss_ex_src
286	: &ip6info->ip6_hdr.ip6_src,
287	sizeof(struct in6_address));
288
289	_net_rx_rss_add_chunk(rss_input, bytes_written,
290	(ipv6ex && ip6info->rss_ex_dst_valid) ? &ip6info->rss_ex_dst
291	: &ip6info->ip6_hdr.ip6_dst,
292	sizeof(struct in6_address));
293	}
294
295	static inline void
296	_net_rx_rss_prepare_tcp(uint8_t *rss_input,
297	struct NetRxPkt *pkt,
298	size_t *bytes_written)
299	{
300	struct tcp_header *tcphdr = &pkt->l4hdr_info.hdr.tcp;
301
302	_net_rx_rss_add_chunk(rss_input, bytes_written,
303	&tcphdr->th_sport, sizeof(uint16_t));
304
305	_net_rx_rss_add_chunk(rss_input, bytes_written,
306	&tcphdr->th_dport, sizeof(uint16_t));
307	}
308
309	uint32_t
310	net_rx_pkt_calc_rss_hash(struct NetRxPkt *pkt,
311	NetRxPktRssType type,
312	uint8_t *key)
313	{
314	uint8_t rss_input[36];
315	size_t rss_length = 0;
316	uint32_t rss_hash = 0;
317	net_toeplitz_key key_data;
318
319	switch (type) {
320	case NetPktRssIpV4:
321	assert(pkt->isip4);
322	trace_net_rx_pkt_rss_ip4();
323	_net_rx_rss_prepare_ip4(&rss_input[0], pkt, &rss_length);
324	break;
325	case NetPktRssIpV4Tcp:
326	assert(pkt->isip4);
327	assert(pkt->istcp);
328	trace_net_rx_pkt_rss_ip4_tcp();
329	_net_rx_rss_prepare_ip4(&rss_input[0], pkt, &rss_length);
330	_net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
331	break;
332	case NetPktRssIpV6Tcp:
333	assert(pkt->isip6);
334	assert(pkt->istcp);
335	trace_net_rx_pkt_rss_ip6_tcp();
336	_net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
337	_net_rx_rss_prepare_tcp(&rss_input[0], pkt, &rss_length);
338	break;
339	case NetPktRssIpV6:
340	assert(pkt->isip6);
341	trace_net_rx_pkt_rss_ip6();
342	_net_rx_rss_prepare_ip6(&rss_input[0], pkt, false, &rss_length);
343	break;
344	case NetPktRssIpV6Ex:
345	assert(pkt->isip6);
346	trace_net_rx_pkt_rss_ip6_ex();
347	_net_rx_rss_prepare_ip6(&rss_input[0], pkt, true, &rss_length);
348	break;
349	default:
350	assert(false);
351	break;
352	}
353
354	net_toeplitz_key_init(&key_data, key);
355	net_toeplitz_add(&rss_hash, rss_input, rss_length, &key_data);
356
357	trace_net_rx_pkt_rss_hash(rss_length, rss_hash);
358
359	return rss_hash;
360	}
361
362	uint16_t net_rx_pkt_get_ip_id(struct NetRxPkt *pkt)
363	{
364	assert(pkt);
365
366	if (pkt->isip4) {
367	return be16_to_cpu(pkt->ip4hdr_info.ip4_hdr.ip_id);
368	}
369
370	return 0;
371	}
372
373	bool net_rx_pkt_is_tcp_ack(struct NetRxPkt *pkt)
374	{
375	assert(pkt);
376
377	if (pkt->istcp) {
378	return TCP_HEADER_FLAGS(&pkt->l4hdr_info.hdr.tcp) & TCP_FLAG_ACK;
379	}
380
381	return false;
382	}
383
384	bool net_rx_pkt_has_tcp_data(struct NetRxPkt *pkt)
385	{
386	assert(pkt);
387
388	if (pkt->istcp) {
389	return pkt->l4hdr_info.has_tcp_data;
390	}
391
392	return false;
393	}
394
605d52e6	395	struct iovec net_rx_pkt_get_iovec(struct NetRxPkt pkt)
e263cd49 DF	396	{
	397	assert(pkt);
	398
	399	return pkt->vec;
	400	}
	401
eb700029 DF	402	uint16_t net_rx_pkt_get_iovec_len(struct NetRxPkt *pkt)
	403	{
	404	assert(pkt);
	405
	406	return pkt->vec_len;
	407	}
	408
605d52e6	409	void net_rx_pkt_set_vhdr(struct NetRxPkt *pkt,
e263cd49 DF	410	struct virtio_net_hdr *vhdr)
	411	{
	412	assert(pkt);
	413
	414	memcpy(&pkt->virt_hdr, vhdr, sizeof pkt->virt_hdr);
	415	}
	416
eb700029 DF	417	void net_rx_pkt_set_vhdr_iovec(struct NetRxPkt *pkt,
	418	const struct iovec *iov, int iovcnt)
	419	{
	420	assert(pkt);
	421
	422	iov_to_buf(iov, iovcnt, 0, &pkt->virt_hdr, sizeof pkt->virt_hdr);
	423	}
	424
605d52e6	425	bool net_rx_pkt_is_vlan_stripped(struct NetRxPkt *pkt)
e263cd49 DF	426	{
	427	assert(pkt);
	428
	429	return pkt->vlan_stripped;
	430	}
	431
605d52e6	432	bool net_rx_pkt_has_virt_hdr(struct NetRxPkt *pkt)
e263cd49 DF	433	{
	434	assert(pkt);
	435
	436	return pkt->has_virt_hdr;
	437	}
	438
605d52e6	439	uint16_t net_rx_pkt_get_vlan_tag(struct NetRxPkt *pkt)
e263cd49 DF	440	{
	441	assert(pkt);
	442
	443	return pkt->tci;
	444	}
eb700029 DF	445
	446	bool net_rx_pkt_validate_l3_csum(struct NetRxPkt pkt, bool csum_valid)
	447	{
	448	uint32_t cntr;
	449	uint16_t csum;
	450	uint32_t csl;
	451
	452	trace_net_rx_pkt_l3_csum_validate_entry();
	453
	454	if (!pkt->isip4) {
	455	trace_net_rx_pkt_l3_csum_validate_not_ip4();
	456	return false;
	457	}
	458
	459	csl = pkt->l4hdr_off - pkt->l3hdr_off;
	460
	461	cntr = net_checksum_add_iov(pkt->vec, pkt->vec_len,
	462	pkt->l3hdr_off,
	463	csl, 0);
	464
	465	csum = net_checksum_finish(cntr);
	466
	467	*csum_valid = (csum == 0);
	468
	469	trace_net_rx_pkt_l3_csum_validate_csum(pkt->l3hdr_off, csl,
	470	cntr, csum, *csum_valid);
	471
	472	return true;
	473	}
	474
	475	static uint16_t
	476	_net_rx_pkt_calc_l4_csum(struct NetRxPkt *pkt)
	477	{
	478	uint32_t cntr;
	479	uint16_t csum;
	480	uint16_t csl;
	481	uint32_t cso;
	482
	483	trace_net_rx_pkt_l4_csum_calc_entry();
	484
	485	if (pkt->isip4) {
	486	if (pkt->isudp) {
	487	csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
	488	trace_net_rx_pkt_l4_csum_calc_ip4_udp();
	489	} else {
	490	csl = be16_to_cpu(pkt->ip4hdr_info.ip4_hdr.ip_len) -
	491	IP_HDR_GET_LEN(&pkt->ip4hdr_info.ip4_hdr);
	492	trace_net_rx_pkt_l4_csum_calc_ip4_tcp();
	493	}
	494
	495	cntr = eth_calc_ip4_pseudo_hdr_csum(&pkt->ip4hdr_info.ip4_hdr,
	496	csl, &cso);
	497	trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
	498	} else {
	499	if (pkt->isudp) {
	500	csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
	501	trace_net_rx_pkt_l4_csum_calc_ip6_udp();
	502	} else {
	503	struct ip6_header *ip6hdr = &pkt->ip6hdr_info.ip6_hdr;
	504	size_t full_ip6hdr_len = pkt->l4hdr_off - pkt->l3hdr_off;
	505	size_t ip6opts_len = full_ip6hdr_len - sizeof(struct ip6_header);
	506
	507	csl = be16_to_cpu(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen) -
	508	ip6opts_len;
509	trace_net_rx_pkt_l4_csum_calc_ip6_tcp();
510	}
511
512	cntr = eth_calc_ip6_pseudo_hdr_csum(&pkt->ip6hdr_info.ip6_hdr, csl,
513	pkt->ip6hdr_info.l4proto, &cso);
514	trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
515	}
516
517	cntr += net_checksum_add_iov(pkt->vec, pkt->vec_len,
518	pkt->l4hdr_off, csl, cso);
519
520	csum = net_checksum_finish(cntr);
521
522	trace_net_rx_pkt_l4_csum_calc_csum(pkt->l4hdr_off, csl, cntr, csum);
523
524	return csum;
525	}
526
527	bool net_rx_pkt_validate_l4_csum(struct NetRxPkt pkt, bool csum_valid)
528	{
529	uint16_t csum;
530
531	trace_net_rx_pkt_l4_csum_validate_entry();
532
533	if (!pkt->istcp && !pkt->isudp) {
534	trace_net_rx_pkt_l4_csum_validate_not_xxp();
535	return false;
536	}
537
538	if (pkt->isudp && (pkt->l4hdr_info.hdr.udp.uh_sum == 0)) {
539	trace_net_rx_pkt_l4_csum_validate_udp_with_no_checksum();
540	return false;
541	}
542
543	if (pkt->isip4 && pkt->ip4hdr_info.fragment) {
544	trace_net_rx_pkt_l4_csum_validate_ip4_fragment();
545	return false;
546	}
547
548	csum = _net_rx_pkt_calc_l4_csum(pkt);
549
550	*csum_valid = ((csum == 0) \|\| (csum == 0xFFFF));
551
552	trace_net_rx_pkt_l4_csum_validate_csum(*csum_valid);
553
554	return true;
555	}
556
557	bool net_rx_pkt_fix_l4_csum(struct NetRxPkt *pkt)
558	{
559	uint16_t csum = 0;
560	uint32_t l4_cso;
561
562	trace_net_rx_pkt_l4_csum_fix_entry();
563
564	if (pkt->istcp) {
565	l4_cso = offsetof(struct tcp_header, th_sum);
566	trace_net_rx_pkt_l4_csum_fix_tcp(l4_cso);
567	} else if (pkt->isudp) {
568	if (pkt->l4hdr_info.hdr.udp.uh_sum == 0) {
569	trace_net_rx_pkt_l4_csum_fix_udp_with_no_checksum();
570	return false;
571	}
572	l4_cso = offsetof(struct udp_header, uh_sum);
573	trace_net_rx_pkt_l4_csum_fix_udp(l4_cso);
574	} else {
575	trace_net_rx_pkt_l4_csum_fix_not_xxp();
576	return false;
577	}
578
579	if (pkt->isip4 && pkt->ip4hdr_info.fragment) {
580	trace_net_rx_pkt_l4_csum_fix_ip4_fragment();
581	return false;
582	}
583
584	/* Set zero to checksum word */
585	iov_from_buf(pkt->vec, pkt->vec_len,
586	pkt->l4hdr_off + l4_cso,
587	&csum, sizeof(csum));
588
589	/* Calculate L4 checksum */
590	csum = cpu_to_be16(_net_rx_pkt_calc_l4_csum(pkt));
591
592	/* Set calculated checksum to checksum word */
593	iov_from_buf(pkt->vec, pkt->vec_len,
594	pkt->l4hdr_off + l4_cso,
595	&csum, sizeof(csum));
596
597	trace_net_rx_pkt_l4_csum_fix_csum(pkt->l4hdr_off + l4_cso, csum);
598
599	return true;
600	}