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