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
rte_net_intel_cksum_flags_prepare(struct rte_mbuf * m,uint64_t ol_flags)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
rte_net_intel_cksum_prepare(struct rte_mbuf * m)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