net/ice: fix memory leak when releasing VSI
[dpdk.git] / examples / l3fwd / l3fwd_common.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2016-2018 Intel Corporation.
3  * Copyright(c) 2017-2018 Linaro Limited.
4  */
5
6
7 #ifndef _L3FWD_COMMON_H_
8 #define _L3FWD_COMMON_H_
9
10 #ifdef DO_RFC_1812_CHECKS
11
12 #define IPV4_MIN_VER_IHL        0x45
13 #define IPV4_MAX_VER_IHL        0x4f
14 #define IPV4_MAX_VER_IHL_DIFF   (IPV4_MAX_VER_IHL - IPV4_MIN_VER_IHL)
15
16 /* Minimum value of IPV4 total length (20B) in network byte order. */
17 #define IPV4_MIN_LEN_BE (sizeof(struct rte_ipv4_hdr) << 8)
18
19 /*
20  * From http://www.rfc-editor.org/rfc/rfc1812.txt section 5.2.2:
21  * - The IP version number must be 4.
22  * - The IP header length field must be large enough to hold the
23  *    minimum length legal IP datagram (20 bytes = 5 words).
24  * - The IP total length field must be large enough to hold the IP
25  *   datagram header, whose length is specified in the IP header length
26  *   field.
27  * If we encounter invalid IPV4 packet, then set destination port for it
28  * to BAD_PORT value.
29  */
30 static __rte_always_inline void
31 rfc1812_process(struct rte_ipv4_hdr *ipv4_hdr, uint16_t *dp, uint32_t ptype)
32 {
33         uint8_t ihl;
34
35         if (RTE_ETH_IS_IPV4_HDR(ptype)) {
36                 ihl = ipv4_hdr->version_ihl - IPV4_MIN_VER_IHL;
37
38                 ipv4_hdr->time_to_live--;
39                 ipv4_hdr->hdr_checksum++;
40
41                 if (ihl > IPV4_MAX_VER_IHL_DIFF ||
42                                 ((uint8_t)ipv4_hdr->total_length == 0 &&
43                                 ipv4_hdr->total_length < IPV4_MIN_LEN_BE))
44                         dp[0] = BAD_PORT;
45
46         }
47 }
48
49 #else
50 #define rfc1812_process(mb, dp, ptype)  do { } while (0)
51 #endif /* DO_RFC_1812_CHECKS */
52
53 /*
54  * We group consecutive packets with the same destionation port into one burst.
55  * To avoid extra latency this is done together with some other packet
56  * processing, but after we made a final decision about packet's destination.
57  * To do this we maintain:
58  * pnum - array of number of consecutive packets with the same dest port for
59  * each packet in the input burst.
60  * lp - pointer to the last updated element in the pnum.
61  * dlp - dest port value lp corresponds to.
62  */
63
64 #define GRPSZ   (1 << FWDSTEP)
65 #define GRPMSK  (GRPSZ - 1)
66
67 #define GROUP_PORT_STEP(dlp, dcp, lp, pn, idx)  do { \
68         if (likely((dlp) == (dcp)[(idx)])) {             \
69                 (lp)[0]++;                                   \
70         } else {                                         \
71                 (dlp) = (dcp)[idx];                          \
72                 (lp) = (pn) + (idx);                         \
73                 (lp)[0] = 1;                                 \
74         }                                                \
75 } while (0)
76
77 static const struct {
78         uint64_t pnum; /* prebuild 4 values for pnum[]. */
79         int32_t  idx;  /* index for new last updated elemnet. */
80         uint16_t lpv;  /* add value to the last updated element. */
81 } gptbl[GRPSZ] = {
82         {
83                 /* 0: a != b, b != c, c != d, d != e */
84                 .pnum = UINT64_C(0x0001000100010001),
85                 .idx = 4,
86                 .lpv = 0,
87         },
88         {
89                 /* 1: a == b, b != c, c != d, d != e */
90                 .pnum = UINT64_C(0x0001000100010002),
91                 .idx = 4,
92                 .lpv = 1,
93         },
94         {
95                 /* 2: a != b, b == c, c != d, d != e */
96                 .pnum = UINT64_C(0x0001000100020001),
97                 .idx = 4,
98                 .lpv = 0,
99         },
100         {
101                 /* 3: a == b, b == c, c != d, d != e */
102                 .pnum = UINT64_C(0x0001000100020003),
103                 .idx = 4,
104                 .lpv = 2,
105         },
106         {
107                 /* 4: a != b, b != c, c == d, d != e */
108                 .pnum = UINT64_C(0x0001000200010001),
109                 .idx = 4,
110                 .lpv = 0,
111         },
112         {
113                 /* 5: a == b, b != c, c == d, d != e */
114                 .pnum = UINT64_C(0x0001000200010002),
115                 .idx = 4,
116                 .lpv = 1,
117         },
118         {
119                 /* 6: a != b, b == c, c == d, d != e */
120                 .pnum = UINT64_C(0x0001000200030001),
121                 .idx = 4,
122                 .lpv = 0,
123         },
124         {
125                 /* 7: a == b, b == c, c == d, d != e */
126                 .pnum = UINT64_C(0x0001000200030004),
127                 .idx = 4,
128                 .lpv = 3,
129         },
130         {
131                 /* 8: a != b, b != c, c != d, d == e */
132                 .pnum = UINT64_C(0x0002000100010001),
133                 .idx = 3,
134                 .lpv = 0,
135         },
136         {
137                 /* 9: a == b, b != c, c != d, d == e */
138                 .pnum = UINT64_C(0x0002000100010002),
139                 .idx = 3,
140                 .lpv = 1,
141         },
142         {
143                 /* 0xa: a != b, b == c, c != d, d == e */
144                 .pnum = UINT64_C(0x0002000100020001),
145                 .idx = 3,
146                 .lpv = 0,
147         },
148         {
149                 /* 0xb: a == b, b == c, c != d, d == e */
150                 .pnum = UINT64_C(0x0002000100020003),
151                 .idx = 3,
152                 .lpv = 2,
153         },
154         {
155                 /* 0xc: a != b, b != c, c == d, d == e */
156                 .pnum = UINT64_C(0x0002000300010001),
157                 .idx = 2,
158                 .lpv = 0,
159         },
160         {
161                 /* 0xd: a == b, b != c, c == d, d == e */
162                 .pnum = UINT64_C(0x0002000300010002),
163                 .idx = 2,
164                 .lpv = 1,
165         },
166         {
167                 /* 0xe: a != b, b == c, c == d, d == e */
168                 .pnum = UINT64_C(0x0002000300040001),
169                 .idx = 1,
170                 .lpv = 0,
171         },
172         {
173                 /* 0xf: a == b, b == c, c == d, d == e */
174                 .pnum = UINT64_C(0x0002000300040005),
175                 .idx = 0,
176                 .lpv = 4,
177         },
178 };
179
180 static __rte_always_inline void
181 send_packetsx4(struct lcore_conf *qconf, uint16_t port, struct rte_mbuf *m[],
182                 uint32_t num)
183 {
184         uint32_t len, j, n;
185
186         len = qconf->tx_mbufs[port].len;
187
188         /*
189          * If TX buffer for that queue is empty, and we have enough packets,
190          * then send them straightway.
191          */
192         if (num >= MAX_TX_BURST && len == 0) {
193                 n = rte_eth_tx_burst(port, qconf->tx_queue_id[port], m, num);
194                 if (unlikely(n < num)) {
195                         do {
196                                 rte_pktmbuf_free(m[n]);
197                         } while (++n < num);
198                 }
199                 return;
200         }
201
202         /*
203          * Put packets into TX buffer for that queue.
204          */
205
206         n = len + num;
207         n = (n > MAX_PKT_BURST) ? MAX_PKT_BURST - len : num;
208
209         j = 0;
210         switch (n % FWDSTEP) {
211         while (j < n) {
212         case 0:
213                 qconf->tx_mbufs[port].m_table[len + j] = m[j];
214                 j++;
215                 /* fallthrough */
216         case 3:
217                 qconf->tx_mbufs[port].m_table[len + j] = m[j];
218                 j++;
219                 /* fallthrough */
220         case 2:
221                 qconf->tx_mbufs[port].m_table[len + j] = m[j];
222                 j++;
223                 /* fallthrough */
224         case 1:
225                 qconf->tx_mbufs[port].m_table[len + j] = m[j];
226                 j++;
227         }
228         }
229
230         len += n;
231
232         /* enough pkts to be sent */
233         if (unlikely(len == MAX_PKT_BURST)) {
234
235                 send_burst(qconf, MAX_PKT_BURST, port);
236
237                 /* copy rest of the packets into the TX buffer. */
238                 len = num - n;
239                 j = 0;
240                 switch (len % FWDSTEP) {
241                 while (j < len) {
242                 case 0:
243                         qconf->tx_mbufs[port].m_table[j] = m[n + j];
244                         j++;
245                         /* fallthrough */
246                 case 3:
247                         qconf->tx_mbufs[port].m_table[j] = m[n + j];
248                         j++;
249                         /* fallthrough */
250                 case 2:
251                         qconf->tx_mbufs[port].m_table[j] = m[n + j];
252                         j++;
253                         /* fallthrough */
254                 case 1:
255                         qconf->tx_mbufs[port].m_table[j] = m[n + j];
256                         j++;
257                 }
258                 }
259         }
260
261         qconf->tx_mbufs[port].len = len;
262 }
263
264 #endif /* _L3FWD_COMMON_H_ */