1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2016 6WIND S.A. 3 */ 4 5 #ifndef _RTE_NET_PTYPE_H_ 6 #define _RTE_NET_PTYPE_H_ 7 8 #ifdef __cplusplus 9 extern "C" { 10 #endif 11 12 #include <rte_ip.h> 13 #include <rte_udp.h> 14 #include <rte_tcp.h> 15 #include <rte_sctp.h> 16 17 /** 18 * Structure containing header lengths associated to a packet, filled 19 * by rte_net_get_ptype(). 20 */ 21 struct rte_net_hdr_lens { 22 uint8_t l2_len; 23 uint8_t inner_l2_len; 24 uint16_t l3_len; 25 uint16_t inner_l3_len; 26 uint16_t tunnel_len; 27 uint8_t l4_len; 28 uint8_t inner_l4_len; 29 }; 30 31 /** 32 * Skip IPv6 header extensions. 33 * 34 * This function skips all IPv6 extensions, returning size of 35 * complete header including options and final protocol value. 36 * 37 * @param proto 38 * Protocol field of IPv6 header. 39 * @param m 40 * The packet mbuf to be parsed. 41 * @param off 42 * On input, must contain the offset to the first byte following 43 * IPv6 header, on output, contains offset to the first byte 44 * of next layer (after any IPv6 extension header) 45 * @param frag 46 * Contains 1 in output if packet is an IPv6 fragment. 47 * @return 48 * Protocol that follows IPv6 header. 49 * -1 if an error occurs during mbuf parsing. 50 */ 51 int 52 rte_net_skip_ip6_ext(uint16_t proto, const struct rte_mbuf *m, uint32_t *off, 53 int *frag); 54 55 /** 56 * Parse an Ethernet packet to get its packet type. 57 * 58 * This function parses the network headers in mbuf data and return its 59 * packet type. 60 * 61 * If it is provided by the user, it also fills a rte_net_hdr_lens 62 * structure that contains the lengths of the parsed network 63 * headers. Each length field is valid only if the associated packet 64 * type is set. For instance, hdr_lens->l2_len is valid only if 65 * (retval & RTE_PTYPE_L2_MASK) != RTE_PTYPE_UNKNOWN. 66 * 67 * Supported packet types are: 68 * L2: Ether, Vlan, QinQ 69 * L3: IPv4, IPv6 70 * L4: TCP, UDP, SCTP 71 * Tunnels: IPv4, IPv6, Gre, Nvgre 72 * 73 * @param m 74 * The packet mbuf to be parsed. 75 * @param hdr_lens 76 * A pointer to a structure where the header lengths will be returned, 77 * or NULL. 78 * @param layers 79 * List of layers to parse. The function will stop at the first 80 * empty layer. Examples: 81 * - To parse all known layers, use RTE_PTYPE_ALL_MASK. 82 * - To parse only L2 and L3, use RTE_PTYPE_L2_MASK | RTE_PTYPE_L3_MASK 83 * @return 84 * The packet type of the packet. 85 */ 86 uint32_t rte_net_get_ptype(const struct rte_mbuf *m, 87 struct rte_net_hdr_lens *hdr_lens, uint32_t layers); 88 89 /** 90 * Prepare pseudo header checksum 91 * 92 * This function prepares pseudo header checksum for TSO and non-TSO tcp/udp in 93 * provided mbufs packet data and based on the requested offload flags. 94 * 95 * - for non-TSO tcp/udp packets full pseudo-header checksum is counted and set 96 * in packet data, 97 * - for TSO the IP payload length is not included in pseudo header. 98 * 99 * This function expects that used headers are in the first data segment of 100 * mbuf, are not fragmented and can be safely modified. 101 * 102 * @param m 103 * The packet mbuf to be fixed. 104 * @param ol_flags 105 * TX offloads flags to use with this packet. 106 * @return 107 * 0 if checksum is initialized properly 108 */ 109 static inline int 110 rte_net_intel_cksum_flags_prepare(struct rte_mbuf *m, uint64_t ol_flags) 111 { 112 /* Initialise ipv4_hdr to avoid false positive compiler warnings. */ 113 struct rte_ipv4_hdr *ipv4_hdr = NULL; 114 struct rte_ipv6_hdr *ipv6_hdr; 115 struct rte_tcp_hdr *tcp_hdr; 116 struct rte_udp_hdr *udp_hdr; 117 uint64_t inner_l3_offset = m->l2_len; 118 119 /* 120 * Does packet set any of available offloads? 121 * Mainly it is required to avoid fragmented headers check if 122 * no offloads are requested. 123 */ 124 if (!(ol_flags & (RTE_MBUF_F_TX_IP_CKSUM | RTE_MBUF_F_TX_L4_MASK | RTE_MBUF_F_TX_TCP_SEG | 125 RTE_MBUF_F_TX_OUTER_IP_CKSUM))) 126 return 0; 127 128 if (ol_flags & (RTE_MBUF_F_TX_OUTER_IPV4 | RTE_MBUF_F_TX_OUTER_IPV6)) { 129 inner_l3_offset += m->outer_l2_len + m->outer_l3_len; 130 /* 131 * prepare outer IPv4 header checksum by setting it to 0, 132 * in order to be computed by hardware NICs. 133 */ 134 if (ol_flags & RTE_MBUF_F_TX_OUTER_IP_CKSUM) { 135 ipv4_hdr = rte_pktmbuf_mtod_offset(m, 136 struct rte_ipv4_hdr *, m->outer_l2_len); 137 ipv4_hdr->hdr_checksum = 0; 138 } 139 } 140 141 /* 142 * Check if headers are fragmented. 143 * The check could be less strict depending on which offloads are 144 * requested and headers to be used, but let's keep it simple. 145 */ 146 if (unlikely(rte_pktmbuf_data_len(m) < 147 inner_l3_offset + m->l3_len + m->l4_len)) 148 return -ENOTSUP; 149 150 if (ol_flags & RTE_MBUF_F_TX_IPV4) { 151 ipv4_hdr = rte_pktmbuf_mtod_offset(m, struct rte_ipv4_hdr *, 152 inner_l3_offset); 153 154 if (ol_flags & RTE_MBUF_F_TX_IP_CKSUM) 155 ipv4_hdr->hdr_checksum = 0; 156 } 157 158 if ((ol_flags & RTE_MBUF_F_TX_L4_MASK) == RTE_MBUF_F_TX_UDP_CKSUM) { 159 if (ol_flags & RTE_MBUF_F_TX_IPV4) { 160 udp_hdr = (struct rte_udp_hdr *)((char *)ipv4_hdr + 161 m->l3_len); 162 udp_hdr->dgram_cksum = rte_ipv4_phdr_cksum(ipv4_hdr, 163 ol_flags); 164 } else { 165 ipv6_hdr = rte_pktmbuf_mtod_offset(m, 166 struct rte_ipv6_hdr *, inner_l3_offset); 167 /* non-TSO udp */ 168 udp_hdr = rte_pktmbuf_mtod_offset(m, 169 struct rte_udp_hdr *, 170 inner_l3_offset + m->l3_len); 171 udp_hdr->dgram_cksum = rte_ipv6_phdr_cksum(ipv6_hdr, 172 ol_flags); 173 } 174 } else if ((ol_flags & RTE_MBUF_F_TX_L4_MASK) == RTE_MBUF_F_TX_TCP_CKSUM || 175 (ol_flags & RTE_MBUF_F_TX_TCP_SEG)) { 176 if (ol_flags & RTE_MBUF_F_TX_IPV4) { 177 /* non-TSO tcp or TSO */ 178 tcp_hdr = (struct rte_tcp_hdr *)((char *)ipv4_hdr + 179 m->l3_len); 180 tcp_hdr->cksum = rte_ipv4_phdr_cksum(ipv4_hdr, 181 ol_flags); 182 } else { 183 ipv6_hdr = rte_pktmbuf_mtod_offset(m, 184 struct rte_ipv6_hdr *, inner_l3_offset); 185 /* non-TSO tcp or TSO */ 186 tcp_hdr = rte_pktmbuf_mtod_offset(m, 187 struct rte_tcp_hdr *, 188 inner_l3_offset + m->l3_len); 189 tcp_hdr->cksum = rte_ipv6_phdr_cksum(ipv6_hdr, 190 ol_flags); 191 } 192 } 193 194 return 0; 195 } 196 197 /** 198 * Prepare pseudo header checksum 199 * 200 * This function prepares pseudo header checksum for TSO and non-TSO tcp/udp in 201 * provided mbufs packet data. 202 * 203 * - for non-TSO tcp/udp packets full pseudo-header checksum is counted and set 204 * in packet data, 205 * - for TSO the IP payload length is not included in pseudo header. 206 * 207 * This function expects that used headers are in the first data segment of 208 * mbuf, are not fragmented and can be safely modified. 209 * 210 * @param m 211 * The packet mbuf to be fixed. 212 * @return 213 * 0 if checksum is initialized properly 214 */ 215 static inline int 216 rte_net_intel_cksum_prepare(struct rte_mbuf *m) 217 { 218 return rte_net_intel_cksum_flags_prepare(m, m->ol_flags); 219 } 220 221 #ifdef __cplusplus 222 } 223 #endif 224 225 226 #endif /* _RTE_NET_PTYPE_H_ */ 227