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