Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * This testsuite provides conformance testing for GRO coalescing.
4 *
5 * Test cases:
6 *
7 * data_*:
8 * Data packets of the same size and same header setup with correct
9 * sequence numbers coalesce. The one exception being the last data
10 * packet coalesced: it can be smaller than the rest and coalesced
11 * as long as it is in the same flow.
12 * - data_same: same size packets coalesce
13 * - data_lrg_sml: large then small coalesces
14 * - data_lrg_1byte: large then 1 byte coalesces (Ethernet padding)
15 * - data_sml_lrg: small then large doesn't coalesce
16 * - data_burst: two bursts of two, separated by 100ms
17 *
18 * ack:
19 * Pure ACK does not coalesce.
20 *
21 * flags_*:
22 * No packets with PSH, SYN, URG, RST, CWR set will be coalesced.
23 * - flags_psh, flags_syn, flags_rst, flags_urg, flags_cwr
24 *
25 * tcp_*:
26 * Packets with incorrect checksum, non-consecutive seqno and
27 * different TCP header options shouldn't coalesce. Nit: given that
28 * some extension headers have paddings, such as timestamp, headers
29 * that are padded differently would not be coalesced.
30 * - tcp_csum: incorrect checksum
31 * - tcp_seq: non-consecutive sequence numbers
32 * - tcp_ts: different timestamps
33 * - tcp_opt: different TCP options
34 *
35 * ip_*:
36 * Packets with different (ECN, TTL, TOS) header, IP options or
37 * IP fragments shouldn't coalesce.
38 * - ip_ecn, ip_tos: shared between IPv4/IPv6
39 * - ip_csum: IPv4 only, bad IP header checksum
40 * - ip_ttl, ip_opt, ip_frag4: IPv4 only
41 * - ip_id_df*: IPv4 IP ID field coalescing tests
42 * - ip_frag6, ip_v6ext_*: IPv6 only
43 *
44 * large_*:
45 * Packets larger than GRO_MAX_SIZE packets shouldn't coalesce.
46 * - large_max: exceeding max size
47 * - large_rem: remainder handling
48 *
49 * single, capacity:
50 * Boring cases used to test coalescing machinery itself and stats
51 * more than protocol behavior.
52 *
53 * MSS is defined as 4096 - header because if it is too small
54 * (i.e. 1500 MTU - header), it will result in many packets,
55 * increasing the "large" test case's flakiness. This is because
56 * due to time sensitivity in the coalescing window, the receiver
57 * may not coalesce all of the packets.
58 *
59 * Note the timing issue applies to all of the test cases, so some
60 * flakiness is to be expected.
61 *
62 */
63
64#define _GNU_SOURCE
65
66#include <arpa/inet.h>
67#include <errno.h>
68#include <error.h>
69#include <getopt.h>
70#include <linux/filter.h>
71#include <linux/if_packet.h>
72#include <linux/ipv6.h>
73#include <linux/net_tstamp.h>
74#include <net/ethernet.h>
75#include <net/if.h>
76#include <netinet/in.h>
77#include <netinet/ip.h>
78#include <netinet/ip6.h>
79#include <netinet/tcp.h>
80#include <stdbool.h>
81#include <stddef.h>
82#include <stdio.h>
83#include <stdarg.h>
84#include <string.h>
85#include <time.h>
86#include <unistd.h>
87
88#include "kselftest.h"
89#include "ksft.h"
90
91#define DPORT 8000
92#define SPORT 1500
93#define PAYLOAD_LEN 100
94#define NUM_PACKETS 4
95#define START_SEQ 100
96#define START_ACK 100
97#define ETH_P_NONE 0
98#define ASSUMED_MTU 4096
99#define MAX_MSS (ASSUMED_MTU - sizeof(struct iphdr) - sizeof(struct tcphdr))
100#define MAX_HDR_LEN \
101 (ETH_HLEN + sizeof(struct ipv6hdr) * 2 + sizeof(struct tcphdr))
102#define MAX_LARGE_PKT_CNT ((IP_MAXPACKET - (MAX_HDR_LEN - ETH_HLEN)) / \
103 (ASSUMED_MTU - (MAX_HDR_LEN - ETH_HLEN)))
104#define MIN_EXTHDR_SIZE 8
105#define EXT_PAYLOAD_1 "\x00\x00\x00\x00\x00\x00"
106#define EXT_PAYLOAD_2 "\x11\x11\x11\x11\x11\x11"
107
108#define ipv6_optlen(p) (((p)->hdrlen+1) << 3) /* calculate IPv6 extension header len */
109#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
110
111enum flush_id_case {
112 FLUSH_ID_DF1_INC,
113 FLUSH_ID_DF1_FIXED,
114 FLUSH_ID_DF0_INC,
115 FLUSH_ID_DF0_FIXED,
116 FLUSH_ID_DF1_INC_FIXED,
117 FLUSH_ID_DF1_FIXED_INC,
118};
119
120static const char *addr6_src = "fdaa::2";
121static const char *addr6_dst = "fdaa::1";
122static const char *addr4_src = "192.168.1.200";
123static const char *addr4_dst = "192.168.1.100";
124static int proto = -1;
125static uint8_t src_mac[ETH_ALEN], dst_mac[ETH_ALEN];
126static char *testname = "data";
127static char *ifname = "eth0";
128static char *smac = "aa:00:00:00:00:02";
129static char *dmac = "aa:00:00:00:00:01";
130static bool verbose;
131static bool tx_socket = true;
132static int tcp_offset = -1;
133static int total_hdr_len = -1;
134static int ethhdr_proto = -1;
135static bool ipip;
136static bool ip6ip6;
137static uint64_t txtime_ns;
138static int num_flows = 4;
139static bool order_check;
140
141#define CAPACITY_PAYLOAD_LEN 200
142
143#define TXTIME_DELAY_MS 5
144
145/* Max TCP payload that GRO will coalesce. The outer header overhead
146 * varies by encapsulation, reducing the effective max payload.
147 */
148static int max_payload(void)
149{
150 return IP_MAXPACKET - (total_hdr_len - ETH_HLEN);
151}
152
153static int calc_mss(void)
154{
155 return ASSUMED_MTU - (total_hdr_len - ETH_HLEN);
156}
157
158static int num_large_pkt(void)
159{
160 return max_payload() / calc_mss();
161}
162
163static void vlog(const char *fmt, ...)
164{
165 va_list args;
166
167 if (verbose) {
168 va_start(args, fmt);
169 vfprintf(stderr, fmt, args);
170 va_end(args);
171 }
172}
173
174static void setup_sock_filter(int fd)
175{
176 const int dport_off = tcp_offset + offsetof(struct tcphdr, dest);
177 const int ethproto_off = offsetof(struct ethhdr, h_proto);
178 int optlen = 0;
179 int ipproto_off, opt_ipproto_off;
180
181 if (proto == PF_INET)
182 ipproto_off = tcp_offset - sizeof(struct iphdr) +
183 offsetof(struct iphdr, protocol);
184 else
185 ipproto_off = tcp_offset - sizeof(struct ipv6hdr) +
186 offsetof(struct ipv6hdr, nexthdr);
187
188 /* Overridden later if exthdrs are used: */
189 opt_ipproto_off = ipproto_off;
190
191 if (strcmp(testname, "ip_opt") == 0) {
192 optlen = sizeof(struct ip_timestamp);
193 } else if (strcmp(testname, "ip_frag6") == 0 ||
194 strcmp(testname, "ip_v6ext_same") == 0 ||
195 strcmp(testname, "ip_v6ext_diff") == 0) {
196 BUILD_BUG_ON(sizeof(struct ip6_hbh) > MIN_EXTHDR_SIZE);
197 BUILD_BUG_ON(sizeof(struct ip6_dest) > MIN_EXTHDR_SIZE);
198 BUILD_BUG_ON(sizeof(struct ip6_frag) > MIN_EXTHDR_SIZE);
199
200 /* same size for HBH and Fragment extension header types */
201 optlen = MIN_EXTHDR_SIZE;
202 opt_ipproto_off = ETH_HLEN + sizeof(struct ipv6hdr)
203 + offsetof(struct ip6_ext, ip6e_nxt);
204 }
205
206 /* this filter validates the following:
207 * - packet is IPv4/IPv6 according to the running test.
208 * - packet is TCP. Also handles the case of one extension header and then TCP.
209 * - checks the packet tcp dport equals to DPORT. Also handles the case of one
210 * extension header and then TCP.
211 */
212 struct sock_filter filter[] = {
213 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, ethproto_off),
214 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ntohs(ethhdr_proto), 0, 9),
215 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, ipproto_off),
216 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_TCP, 2, 0),
217 BPF_STMT(BPF_LD + BPF_B + BPF_ABS, opt_ipproto_off),
218 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_TCP, 0, 5),
219 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, dport_off),
220 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, DPORT, 2, 0),
221 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, dport_off + optlen),
222 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, DPORT, 0, 1),
223 BPF_STMT(BPF_RET + BPF_K, 0xFFFFFFFF),
224 BPF_STMT(BPF_RET + BPF_K, 0),
225 };
226
227 struct sock_fprog bpf = {
228 .len = ARRAY_SIZE(filter),
229 .filter = filter,
230 };
231
232 if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf)) < 0)
233 error(1, errno, "error setting filter");
234}
235
236static uint32_t checksum_nofold(void *data, size_t len, uint32_t sum)
237{
238 uint16_t *words = data;
239 int i;
240
241 for (i = 0; i < len / 2; i++)
242 sum += words[i];
243 if (len & 1)
244 sum += ((char *)data)[len - 1];
245 return sum;
246}
247
248static uint16_t checksum_fold(void *data, size_t len, uint32_t sum)
249{
250 sum = checksum_nofold(data, len, sum);
251 while (sum > 0xFFFF)
252 sum = (sum & 0xFFFF) + (sum >> 16);
253 return ~sum;
254}
255
256static uint16_t tcp_checksum(void *buf, int payload_len)
257{
258 struct pseudo_header6 {
259 struct in6_addr saddr;
260 struct in6_addr daddr;
261 uint16_t protocol;
262 uint16_t payload_len;
263 } ph6;
264 struct pseudo_header4 {
265 struct in_addr saddr;
266 struct in_addr daddr;
267 uint16_t protocol;
268 uint16_t payload_len;
269 } ph4;
270 uint32_t sum = 0;
271
272 if (proto == PF_INET6) {
273 if (inet_pton(AF_INET6, addr6_src, &ph6.saddr) != 1)
274 error(1, errno, "inet_pton6 source ip pseudo");
275 if (inet_pton(AF_INET6, addr6_dst, &ph6.daddr) != 1)
276 error(1, errno, "inet_pton6 dest ip pseudo");
277 ph6.protocol = htons(IPPROTO_TCP);
278 ph6.payload_len = htons(sizeof(struct tcphdr) + payload_len);
279
280 sum = checksum_nofold(&ph6, sizeof(ph6), 0);
281 } else if (proto == PF_INET) {
282 if (inet_pton(AF_INET, addr4_src, &ph4.saddr) != 1)
283 error(1, errno, "inet_pton source ip pseudo");
284 if (inet_pton(AF_INET, addr4_dst, &ph4.daddr) != 1)
285 error(1, errno, "inet_pton dest ip pseudo");
286 ph4.protocol = htons(IPPROTO_TCP);
287 ph4.payload_len = htons(sizeof(struct tcphdr) + payload_len);
288
289 sum = checksum_nofold(&ph4, sizeof(ph4), 0);
290 }
291
292 return checksum_fold(buf, sizeof(struct tcphdr) + payload_len, sum);
293}
294
295static void read_MAC(uint8_t *mac_addr, char *mac)
296{
297 if (sscanf(mac, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
298 &mac_addr[0], &mac_addr[1], &mac_addr[2],
299 &mac_addr[3], &mac_addr[4], &mac_addr[5]) != 6)
300 error(1, 0, "sscanf");
301}
302
303static void fill_datalinklayer(void *buf)
304{
305 struct ethhdr *eth = buf;
306
307 memcpy(eth->h_dest, dst_mac, ETH_ALEN);
308 memcpy(eth->h_source, src_mac, ETH_ALEN);
309 eth->h_proto = ethhdr_proto;
310}
311
312static void fill_networklayer(void *buf, int payload_len, int protocol)
313{
314 struct ipv6hdr *ip6h = buf;
315 struct iphdr *iph = buf;
316
317 if (proto == PF_INET6) {
318 memset(ip6h, 0, sizeof(*ip6h));
319
320 ip6h->version = 6;
321 ip6h->payload_len = htons(sizeof(struct tcphdr) + payload_len);
322 ip6h->nexthdr = protocol;
323 ip6h->hop_limit = 8;
324 if (inet_pton(AF_INET6, addr6_src, &ip6h->saddr) != 1)
325 error(1, errno, "inet_pton source ip6");
326 if (inet_pton(AF_INET6, addr6_dst, &ip6h->daddr) != 1)
327 error(1, errno, "inet_pton dest ip6");
328 } else if (proto == PF_INET) {
329 memset(iph, 0, sizeof(*iph));
330
331 iph->version = 4;
332 iph->ihl = 5;
333 iph->ttl = 8;
334 iph->protocol = protocol;
335 iph->tot_len = htons(sizeof(struct tcphdr) +
336 payload_len + sizeof(struct iphdr));
337 iph->frag_off = htons(0x4000); /* DF = 1, MF = 0 */
338 if (inet_pton(AF_INET, addr4_src, &iph->saddr) != 1)
339 error(1, errno, "inet_pton source ip");
340 if (inet_pton(AF_INET, addr4_dst, &iph->daddr) != 1)
341 error(1, errno, "inet_pton dest ip");
342 iph->check = checksum_fold(buf, sizeof(struct iphdr), 0);
343 }
344}
345
346static void fill_transportlayer(void *buf, int seq_offset, int ack_offset,
347 int payload_len, int fin)
348{
349 struct tcphdr *tcph = buf;
350
351 memset(tcph, 0, sizeof(*tcph));
352
353 tcph->source = htons(SPORT);
354 tcph->dest = htons(DPORT);
355 tcph->seq = ntohl(START_SEQ + seq_offset);
356 tcph->ack_seq = ntohl(START_ACK + ack_offset);
357 tcph->ack = 1;
358 tcph->fin = fin;
359 tcph->doff = 5;
360 tcph->window = htons(TCP_MAXWIN);
361 tcph->urg_ptr = 0;
362 tcph->check = tcp_checksum(tcph, payload_len);
363}
364
365static void write_packet(int fd, char *buf, int len, struct sockaddr_ll *daddr)
366{
367 char control[CMSG_SPACE(sizeof(uint64_t))];
368 struct msghdr msg = {};
369 struct iovec iov = {};
370 struct cmsghdr *cm;
371 int ret = -1;
372
373 iov.iov_base = buf;
374 iov.iov_len = len;
375
376 msg.msg_iov = &iov;
377 msg.msg_iovlen = 1;
378 msg.msg_name = daddr;
379 msg.msg_namelen = sizeof(*daddr);
380
381 if (txtime_ns) {
382 memset(control, 0, sizeof(control));
383 msg.msg_control = control;
384 msg.msg_controllen = sizeof(control);
385
386 cm = CMSG_FIRSTHDR(&msg);
387 cm->cmsg_level = SOL_SOCKET;
388 cm->cmsg_type = SCM_TXTIME;
389 cm->cmsg_len = CMSG_LEN(sizeof(uint64_t));
390 memcpy(CMSG_DATA(cm), &txtime_ns, sizeof(txtime_ns));
391 }
392
393 ret = sendmsg(fd, &msg, 0);
394 if (ret == -1)
395 error(1, errno, "sendmsg failure");
396 if (ret != len)
397 error(1, 0, "sendmsg wrong length: %d vs %d", ret, len);
398}
399
400static void create_packet(void *buf, int seq_offset, int ack_offset,
401 int payload_len, int fin)
402{
403 int ip_hdr_len = (proto == PF_INET) ?
404 sizeof(struct iphdr) : sizeof(struct ipv6hdr);
405 int inner_ip_off = tcp_offset - ip_hdr_len;
406
407 memset(buf, 0, total_hdr_len);
408 memset(buf + total_hdr_len, 'a', payload_len);
409
410 fill_transportlayer(buf + tcp_offset, seq_offset, ack_offset,
411 payload_len, fin);
412
413 fill_networklayer(buf + inner_ip_off, payload_len, IPPROTO_TCP);
414 if (inner_ip_off > ETH_HLEN) {
415 int encap_proto = (proto == PF_INET) ?
416 IPPROTO_IPIP : IPPROTO_IPV6;
417
418 fill_networklayer(buf + ETH_HLEN,
419 payload_len + ip_hdr_len, encap_proto);
420 }
421
422 fill_datalinklayer(buf);
423}
424
425static void create_capacity_packet(void *buf, int flow_id, int pkt_idx, int psh)
426{
427 int seq_offset = pkt_idx * CAPACITY_PAYLOAD_LEN;
428 struct tcphdr *tcph;
429
430 create_packet(buf, seq_offset, 0, CAPACITY_PAYLOAD_LEN, 0);
431
432 /* Customize for this flow id */
433 memset(buf + total_hdr_len, 'a' + flow_id, CAPACITY_PAYLOAD_LEN);
434
435 tcph = buf + tcp_offset;
436 tcph->source = htons(SPORT + flow_id);
437 tcph->psh = psh;
438 tcph->check = 0;
439 tcph->check = tcp_checksum(tcph, CAPACITY_PAYLOAD_LEN);
440}
441
442/* Send a capacity test, 2 packets per flow, all first packets then all second:
443 * A1 B1 C1 D1 ... A2 B2 C2 D2 ...
444 */
445static void send_capacity(int fd, struct sockaddr_ll *daddr)
446{
447 static char buf[MAX_HDR_LEN + CAPACITY_PAYLOAD_LEN];
448 int pkt_size = total_hdr_len + CAPACITY_PAYLOAD_LEN;
449 int i;
450
451 /* Send first packet of each flow (no PSH) */
452 for (i = 0; i < num_flows; i++) {
453 create_capacity_packet(buf, i, 0, 0);
454 write_packet(fd, buf, pkt_size, daddr);
455 }
456
457 /* Send second packet of each flow (with PSH to flush) */
458 for (i = 0; i < num_flows; i++) {
459 create_capacity_packet(buf, i, 1, 1);
460 write_packet(fd, buf, pkt_size, daddr);
461 }
462}
463
464#ifndef TH_CWR
465#define TH_CWR 0x80
466#endif
467static void set_flags(struct tcphdr *tcph, int payload_len, int psh, int syn,
468 int rst, int urg, int cwr)
469{
470 tcph->psh = psh;
471 tcph->syn = syn;
472 tcph->rst = rst;
473 tcph->urg = urg;
474 if (cwr)
475 tcph->th_flags |= TH_CWR;
476 else
477 tcph->th_flags &= ~TH_CWR;
478 tcph->check = 0;
479 tcph->check = tcp_checksum(tcph, payload_len);
480}
481
482/* send extra flags of the (NUM_PACKETS / 2) and (NUM_PACKETS / 2 - 1)
483 * pkts, not first and not last pkt
484 */
485static void send_flags(int fd, struct sockaddr_ll *daddr, int psh, int syn,
486 int rst, int urg, int cwr)
487{
488 static char flag_buf[2][MAX_HDR_LEN + PAYLOAD_LEN];
489 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
490 int payload_len, pkt_size, i;
491 struct tcphdr *tcph;
492 int flag[2];
493
494 payload_len = PAYLOAD_LEN * (psh || cwr);
495 pkt_size = total_hdr_len + payload_len;
496 flag[0] = NUM_PACKETS / 2;
497 flag[1] = NUM_PACKETS / 2 - 1;
498
499 /* Create and configure packets with flags
500 */
501 for (i = 0; i < 2; i++) {
502 if (flag[i] > 0) {
503 create_packet(flag_buf[i], flag[i] * payload_len, 0,
504 payload_len, 0);
505 tcph = (struct tcphdr *)(flag_buf[i] + tcp_offset);
506 set_flags(tcph, payload_len, psh, syn, rst, urg, cwr);
507 }
508 }
509
510 for (i = 0; i < NUM_PACKETS + 1; i++) {
511 if (i == flag[0]) {
512 write_packet(fd, flag_buf[0], pkt_size, daddr);
513 continue;
514 } else if (i == flag[1] && cwr) {
515 write_packet(fd, flag_buf[1], pkt_size, daddr);
516 continue;
517 }
518 create_packet(buf, i * PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
519 write_packet(fd, buf, total_hdr_len + PAYLOAD_LEN, daddr);
520 }
521}
522
523/* Test for data of same length, smaller than previous
524 * and of different lengths
525 */
526static void send_data_pkts(int fd, struct sockaddr_ll *daddr,
527 int payload_len1, int payload_len2)
528{
529 static char buf[ETH_HLEN + IP_MAXPACKET];
530
531 create_packet(buf, 0, 0, payload_len1, 0);
532 write_packet(fd, buf, total_hdr_len + payload_len1, daddr);
533 create_packet(buf, payload_len1, 0, payload_len2, 0);
534 write_packet(fd, buf, total_hdr_len + payload_len2, daddr);
535}
536
537/* If incoming segments make tracked segment length exceed
538 * legal IP datagram length, do not coalesce
539 */
540static void send_large(int fd, struct sockaddr_ll *daddr, int remainder)
541{
542 static char pkts[MAX_LARGE_PKT_CNT][MAX_HDR_LEN + MAX_MSS];
543 static char new_seg[MAX_HDR_LEN + MAX_MSS];
544 static char last[MAX_HDR_LEN + MAX_MSS];
545 const int num_pkt = num_large_pkt();
546 const int mss = calc_mss();
547 int i;
548
549 for (i = 0; i < num_pkt; i++)
550 create_packet(pkts[i], i * mss, 0, mss, 0);
551 create_packet(last, num_pkt * mss, 0, remainder, 0);
552 create_packet(new_seg, (num_pkt + 1) * mss, 0, remainder, 0);
553
554 for (i = 0; i < num_pkt; i++)
555 write_packet(fd, pkts[i], total_hdr_len + mss, daddr);
556 write_packet(fd, last, total_hdr_len + remainder, daddr);
557 write_packet(fd, new_seg, total_hdr_len + remainder, daddr);
558}
559
560/* Pure acks and dup acks don't coalesce */
561static void send_ack(int fd, struct sockaddr_ll *daddr)
562{
563 static char buf[MAX_HDR_LEN];
564
565 create_packet(buf, 0, 0, 0, 0);
566 write_packet(fd, buf, total_hdr_len, daddr);
567 write_packet(fd, buf, total_hdr_len, daddr);
568 create_packet(buf, 0, 1, 0, 0);
569 write_packet(fd, buf, total_hdr_len, daddr);
570}
571
572static void recompute_packet(char *buf, char *no_ext, int extlen)
573{
574 struct tcphdr *tcphdr = (struct tcphdr *)(buf + tcp_offset);
575 int off;
576
577 memmove(buf, no_ext, total_hdr_len);
578 memmove(buf + total_hdr_len + extlen,
579 no_ext + total_hdr_len, PAYLOAD_LEN);
580
581 tcphdr->doff = tcphdr->doff + (extlen / 4);
582 tcphdr->check = 0;
583 tcphdr->check = tcp_checksum(tcphdr, PAYLOAD_LEN + extlen);
584 if (proto == PF_INET) {
585 for (off = ETH_HLEN; off < tcp_offset;
586 off += sizeof(struct iphdr)) {
587 struct iphdr *iph = (struct iphdr *)(buf + off);
588
589 iph->tot_len = htons(ntohs(iph->tot_len) + extlen);
590 iph->check = 0;
591 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
592 }
593 } else {
594 for (off = ETH_HLEN; off < tcp_offset;
595 off += sizeof(struct ipv6hdr)) {
596 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buf + off);
597
598 ip6h->payload_len =
599 htons(ntohs(ip6h->payload_len) + extlen);
600 }
601 }
602}
603
604static void tcp_write_options(char *buf, int kind, int ts)
605{
606 struct tcp_option_ts {
607 uint8_t kind;
608 uint8_t len;
609 uint32_t tsval;
610 uint32_t tsecr;
611 } *opt_ts = (void *)buf;
612 struct tcp_option_window {
613 uint8_t kind;
614 uint8_t len;
615 uint8_t shift;
616 } *opt_window = (void *)buf;
617
618 switch (kind) {
619 case TCPOPT_NOP:
620 buf[0] = TCPOPT_NOP;
621 break;
622 case TCPOPT_WINDOW:
623 memset(opt_window, 0, sizeof(struct tcp_option_window));
624 opt_window->kind = TCPOPT_WINDOW;
625 opt_window->len = TCPOLEN_WINDOW;
626 opt_window->shift = 0;
627 break;
628 case TCPOPT_TIMESTAMP:
629 memset(opt_ts, 0, sizeof(struct tcp_option_ts));
630 opt_ts->kind = TCPOPT_TIMESTAMP;
631 opt_ts->len = TCPOLEN_TIMESTAMP;
632 opt_ts->tsval = ts;
633 opt_ts->tsecr = 0;
634 break;
635 default:
636 error(1, 0, "unimplemented TCP option");
637 break;
638 }
639}
640
641/* TCP with options is always a permutation of {TS, NOP, NOP}.
642 * Implement different orders to verify coalescing stops.
643 */
644static void add_standard_tcp_options(char *buf, char *no_ext, int ts, int order)
645{
646 switch (order) {
647 case 0:
648 tcp_write_options(buf + total_hdr_len, TCPOPT_NOP, 0);
649 tcp_write_options(buf + total_hdr_len + 1, TCPOPT_NOP, 0);
650 tcp_write_options(buf + total_hdr_len + 2 /* two NOP opts */,
651 TCPOPT_TIMESTAMP, ts);
652 break;
653 case 1:
654 tcp_write_options(buf + total_hdr_len, TCPOPT_NOP, 0);
655 tcp_write_options(buf + total_hdr_len + 1,
656 TCPOPT_TIMESTAMP, ts);
657 tcp_write_options(buf + total_hdr_len + 1 + TCPOLEN_TIMESTAMP,
658 TCPOPT_NOP, 0);
659 break;
660 case 2:
661 tcp_write_options(buf + total_hdr_len, TCPOPT_TIMESTAMP, ts);
662 tcp_write_options(buf + total_hdr_len + TCPOLEN_TIMESTAMP + 1,
663 TCPOPT_NOP, 0);
664 tcp_write_options(buf + total_hdr_len + TCPOLEN_TIMESTAMP + 2,
665 TCPOPT_NOP, 0);
666 break;
667 default:
668 error(1, 0, "unknown order");
669 break;
670 }
671 recompute_packet(buf, no_ext, TCPOLEN_TSTAMP_APPA);
672}
673
674/* Packets with invalid checksum don't coalesce. */
675static void send_changed_checksum(int fd, struct sockaddr_ll *daddr)
676{
677 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
678 struct tcphdr *tcph = (struct tcphdr *)(buf + tcp_offset);
679 int pkt_size = total_hdr_len + PAYLOAD_LEN;
680
681 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
682 write_packet(fd, buf, pkt_size, daddr);
683
684 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
685 tcph->check = tcph->check - 1;
686 write_packet(fd, buf, pkt_size, daddr);
687}
688
689/* Packets with incorrect IPv4 header checksum don't coalesce. */
690static void send_changed_ip_checksum(int fd, struct sockaddr_ll *daddr)
691{
692 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
693 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN);
694 int pkt_size = total_hdr_len + PAYLOAD_LEN;
695
696 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
697 write_packet(fd, buf, pkt_size, daddr);
698
699 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
700 iph->check = iph->check - 1;
701 write_packet(fd, buf, pkt_size, daddr);
702
703 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
704 write_packet(fd, buf, pkt_size, daddr);
705}
706
707 /* Packets with non-consecutive sequence number don't coalesce.*/
708static void send_changed_seq(int fd, struct sockaddr_ll *daddr)
709{
710 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
711 struct tcphdr *tcph = (struct tcphdr *)(buf + tcp_offset);
712 int pkt_size = total_hdr_len + PAYLOAD_LEN;
713
714 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
715 write_packet(fd, buf, pkt_size, daddr);
716
717 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
718 tcph->seq = ntohl(htonl(tcph->seq) + 1);
719 tcph->check = 0;
720 tcph->check = tcp_checksum(tcph, PAYLOAD_LEN);
721 write_packet(fd, buf, pkt_size, daddr);
722}
723
724 /* Packet with different timestamp option or different timestamps
725 * don't coalesce.
726 */
727static void send_changed_ts(int fd, struct sockaddr_ll *daddr)
728{
729 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
730 static char extpkt[sizeof(buf) + TCPOLEN_TSTAMP_APPA];
731 int pkt_size = total_hdr_len + PAYLOAD_LEN + TCPOLEN_TSTAMP_APPA;
732
733 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
734 add_standard_tcp_options(extpkt, buf, 0, 0);
735 write_packet(fd, extpkt, pkt_size, daddr);
736
737 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
738 add_standard_tcp_options(extpkt, buf, 0, 0);
739 write_packet(fd, extpkt, pkt_size, daddr);
740
741 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
742 add_standard_tcp_options(extpkt, buf, 100, 0);
743 write_packet(fd, extpkt, pkt_size, daddr);
744
745 create_packet(buf, PAYLOAD_LEN * 3, 0, PAYLOAD_LEN, 0);
746 add_standard_tcp_options(extpkt, buf, 100, 1);
747 write_packet(fd, extpkt, pkt_size, daddr);
748
749 create_packet(buf, PAYLOAD_LEN * 4, 0, PAYLOAD_LEN, 0);
750 add_standard_tcp_options(extpkt, buf, 100, 2);
751 write_packet(fd, extpkt, pkt_size, daddr);
752}
753
754/* Packet with different tcp options don't coalesce. */
755static void send_diff_opt(int fd, struct sockaddr_ll *daddr)
756{
757 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
758 static char extpkt1[sizeof(buf) + TCPOLEN_TSTAMP_APPA];
759 static char extpkt2[sizeof(buf) + TCPOLEN_MAXSEG];
760 int extpkt1_size = total_hdr_len + PAYLOAD_LEN + TCPOLEN_TSTAMP_APPA;
761 int extpkt2_size = total_hdr_len + PAYLOAD_LEN + TCPOLEN_MAXSEG;
762
763 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
764 add_standard_tcp_options(extpkt1, buf, 0, 0);
765 write_packet(fd, extpkt1, extpkt1_size, daddr);
766
767 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
768 add_standard_tcp_options(extpkt1, buf, 0, 0);
769 write_packet(fd, extpkt1, extpkt1_size, daddr);
770
771 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
772 tcp_write_options(extpkt2 + MAX_HDR_LEN, TCPOPT_NOP, 0);
773 tcp_write_options(extpkt2 + MAX_HDR_LEN + 1, TCPOPT_WINDOW, 0);
774 recompute_packet(extpkt2, buf, TCPOLEN_WINDOW + 1);
775 write_packet(fd, extpkt2, extpkt2_size, daddr);
776}
777
778static void add_ipv4_ts_option(void *buf, void *optpkt)
779{
780 struct ip_timestamp *ts = (struct ip_timestamp *)(optpkt + tcp_offset);
781 int optlen = sizeof(struct ip_timestamp);
782 struct iphdr *iph;
783
784 if (optlen % 4)
785 error(1, 0, "ipv4 timestamp length is not a multiple of 4B");
786
787 ts->ipt_code = IPOPT_TS;
788 ts->ipt_len = optlen;
789 ts->ipt_ptr = 5;
790 ts->ipt_flg = IPOPT_TS_TSONLY;
791
792 memcpy(optpkt, buf, tcp_offset);
793 memcpy(optpkt + tcp_offset + optlen, buf + tcp_offset,
794 sizeof(struct tcphdr) + PAYLOAD_LEN);
795
796 iph = (struct iphdr *)(optpkt + ETH_HLEN);
797 iph->ihl = 5 + (optlen / 4);
798 iph->tot_len = htons(ntohs(iph->tot_len) + optlen);
799 iph->check = 0;
800 iph->check = checksum_fold(iph, sizeof(struct iphdr) + optlen, 0);
801}
802
803static void add_ipv6_exthdr(void *buf, void *optpkt, __u8 exthdr_type, char *ext_payload)
804{
805 struct ipv6_opt_hdr *exthdr = (struct ipv6_opt_hdr *)(optpkt + tcp_offset);
806 struct ipv6hdr *iph = (struct ipv6hdr *)(optpkt + ETH_HLEN);
807 char *exthdr_payload_start = (char *)(exthdr + 1);
808
809 exthdr->hdrlen = 0;
810 exthdr->nexthdr = IPPROTO_TCP;
811
812 memcpy(exthdr_payload_start, ext_payload, MIN_EXTHDR_SIZE - sizeof(*exthdr));
813
814 memcpy(optpkt, buf, tcp_offset);
815 memcpy(optpkt + tcp_offset + MIN_EXTHDR_SIZE, buf + tcp_offset,
816 sizeof(struct tcphdr) + PAYLOAD_LEN);
817
818 iph->nexthdr = exthdr_type;
819 iph->payload_len = htons(ntohs(iph->payload_len) + MIN_EXTHDR_SIZE);
820}
821
822static void fix_ip4_checksum(struct iphdr *iph)
823{
824 iph->check = 0;
825 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
826}
827
828static void send_flush_id_case(int fd, struct sockaddr_ll *daddr,
829 enum flush_id_case tcase)
830{
831 static char buf1[MAX_HDR_LEN + PAYLOAD_LEN];
832 static char buf2[MAX_HDR_LEN + PAYLOAD_LEN];
833 static char buf3[MAX_HDR_LEN + PAYLOAD_LEN];
834 bool send_three = false;
835 struct iphdr *iph1;
836 struct iphdr *iph2;
837 struct iphdr *iph3;
838
839 iph1 = (struct iphdr *)(buf1 + ETH_HLEN);
840 iph2 = (struct iphdr *)(buf2 + ETH_HLEN);
841 iph3 = (struct iphdr *)(buf3 + ETH_HLEN);
842
843 create_packet(buf1, 0, 0, PAYLOAD_LEN, 0);
844 create_packet(buf2, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
845 create_packet(buf3, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
846
847 switch (tcase) {
848 case FLUSH_ID_DF1_INC: /* DF=1, Incrementing - should coalesce */
849 iph1->frag_off |= htons(IP_DF);
850 iph1->id = htons(8);
851
852 iph2->frag_off |= htons(IP_DF);
853 iph2->id = htons(9);
854 break;
855
856 case FLUSH_ID_DF1_FIXED: /* DF=1, Fixed - should coalesce */
857 iph1->frag_off |= htons(IP_DF);
858 iph1->id = htons(8);
859
860 iph2->frag_off |= htons(IP_DF);
861 iph2->id = htons(8);
862 break;
863
864 case FLUSH_ID_DF0_INC: /* DF=0, Incrementing - should coalesce */
865 iph1->frag_off &= ~htons(IP_DF);
866 iph1->id = htons(8);
867
868 iph2->frag_off &= ~htons(IP_DF);
869 iph2->id = htons(9);
870 break;
871
872 case FLUSH_ID_DF0_FIXED: /* DF=0, Fixed - should coalesce */
873 iph1->frag_off &= ~htons(IP_DF);
874 iph1->id = htons(8);
875
876 iph2->frag_off &= ~htons(IP_DF);
877 iph2->id = htons(8);
878 break;
879
880 case FLUSH_ID_DF1_INC_FIXED: /* DF=1, two packets incrementing, and
881 * one fixed - should coalesce only the
882 * first two packets
883 */
884 iph1->frag_off |= htons(IP_DF);
885 iph1->id = htons(8);
886
887 iph2->frag_off |= htons(IP_DF);
888 iph2->id = htons(9);
889
890 iph3->frag_off |= htons(IP_DF);
891 iph3->id = htons(9);
892 send_three = true;
893 break;
894
895 case FLUSH_ID_DF1_FIXED_INC: /* DF=1, two packets fixed, and one
896 * incrementing - should coalesce only
897 * the first two packets
898 */
899 iph1->frag_off |= htons(IP_DF);
900 iph1->id = htons(8);
901
902 iph2->frag_off |= htons(IP_DF);
903 iph2->id = htons(8);
904
905 iph3->frag_off |= htons(IP_DF);
906 iph3->id = htons(9);
907 send_three = true;
908 break;
909 }
910
911 fix_ip4_checksum(iph1);
912 fix_ip4_checksum(iph2);
913 write_packet(fd, buf1, total_hdr_len + PAYLOAD_LEN, daddr);
914 write_packet(fd, buf2, total_hdr_len + PAYLOAD_LEN, daddr);
915
916 if (send_three) {
917 fix_ip4_checksum(iph3);
918 write_packet(fd, buf3, total_hdr_len + PAYLOAD_LEN, daddr);
919 }
920}
921
922static void send_ipv6_exthdr(int fd, struct sockaddr_ll *daddr, char *ext_data1, char *ext_data2)
923{
924 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
925 static char exthdr_pck[sizeof(buf) + MIN_EXTHDR_SIZE];
926
927 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
928 add_ipv6_exthdr(buf, exthdr_pck, IPPROTO_DSTOPTS, ext_data1);
929 write_packet(fd, exthdr_pck, total_hdr_len + PAYLOAD_LEN + MIN_EXTHDR_SIZE, daddr);
930
931 create_packet(buf, PAYLOAD_LEN * 1, 0, PAYLOAD_LEN, 0);
932 add_ipv6_exthdr(buf, exthdr_pck, IPPROTO_DSTOPTS, ext_data2);
933 write_packet(fd, exthdr_pck, total_hdr_len + PAYLOAD_LEN + MIN_EXTHDR_SIZE, daddr);
934}
935
936/* IPv4 options shouldn't coalesce */
937static void send_ip_options(int fd, struct sockaddr_ll *daddr)
938{
939 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
940 static char optpkt[sizeof(buf) + sizeof(struct ip_timestamp)];
941 int optlen = sizeof(struct ip_timestamp);
942 int pkt_size = total_hdr_len + PAYLOAD_LEN + optlen;
943
944 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
945 write_packet(fd, buf, total_hdr_len + PAYLOAD_LEN, daddr);
946
947 create_packet(buf, PAYLOAD_LEN * 1, 0, PAYLOAD_LEN, 0);
948 add_ipv4_ts_option(buf, optpkt);
949 write_packet(fd, optpkt, pkt_size, daddr);
950
951 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
952 write_packet(fd, buf, total_hdr_len + PAYLOAD_LEN, daddr);
953}
954
955/* IPv4 fragments shouldn't coalesce */
956static void send_fragment4(int fd, struct sockaddr_ll *daddr)
957{
958 static char buf[IP_MAXPACKET];
959 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN);
960 int pkt_size = total_hdr_len + PAYLOAD_LEN;
961
962 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
963 write_packet(fd, buf, pkt_size, daddr);
964
965 /* Once fragmented, packet would retain the total_len.
966 * Tcp header is prepared as if rest of data is in follow-up frags,
967 * but follow up frags aren't actually sent.
968 */
969 memset(buf + total_hdr_len, 'a', PAYLOAD_LEN * 2);
970 fill_transportlayer(buf + tcp_offset, PAYLOAD_LEN, 0, PAYLOAD_LEN * 2, 0);
971 fill_networklayer(buf + ETH_HLEN, PAYLOAD_LEN, IPPROTO_TCP);
972 fill_datalinklayer(buf);
973
974 iph->frag_off = htons(0x6000); // DF = 1, MF = 1
975 iph->check = 0;
976 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
977 write_packet(fd, buf, pkt_size, daddr);
978}
979
980/* IPv4 packets with different ttl don't coalesce.*/
981static void send_changed_ttl(int fd, struct sockaddr_ll *daddr)
982{
983 int pkt_size = total_hdr_len + PAYLOAD_LEN;
984 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
985 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN);
986
987 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
988 write_packet(fd, buf, pkt_size, daddr);
989
990 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
991 iph->ttl = 7;
992 iph->check = 0;
993 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
994 write_packet(fd, buf, pkt_size, daddr);
995}
996
997/* Packets with different tos don't coalesce.*/
998static void send_changed_tos(int fd, struct sockaddr_ll *daddr)
999{
1000 int pkt_size = total_hdr_len + PAYLOAD_LEN;
1001 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
1002 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN);
1003 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buf + ETH_HLEN);
1004
1005 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
1006 write_packet(fd, buf, pkt_size, daddr);
1007
1008 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
1009 if (proto == PF_INET) {
1010 iph->tos = 1;
1011 iph->check = 0;
1012 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
1013 } else if (proto == PF_INET6) {
1014 ip6h->priority = 0xf;
1015 }
1016 write_packet(fd, buf, pkt_size, daddr);
1017}
1018
1019/* Packets with different ECN don't coalesce.*/
1020static void send_changed_ECN(int fd, struct sockaddr_ll *daddr)
1021{
1022 int pkt_size = total_hdr_len + PAYLOAD_LEN;
1023 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
1024 struct iphdr *iph = (struct iphdr *)(buf + ETH_HLEN);
1025
1026 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
1027 write_packet(fd, buf, pkt_size, daddr);
1028
1029 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
1030 if (proto == PF_INET) {
1031 buf[ETH_HLEN + 1] ^= 0x2; // ECN set to 10
1032 iph->check = 0;
1033 iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
1034 } else {
1035 buf[ETH_HLEN + 1] ^= 0x20; // ECN set to 10
1036 }
1037 write_packet(fd, buf, pkt_size, daddr);
1038}
1039
1040/* IPv6 fragments and packets with extensions don't coalesce.*/
1041static void send_fragment6(int fd, struct sockaddr_ll *daddr)
1042{
1043 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
1044 static char extpkt[MAX_HDR_LEN + PAYLOAD_LEN +
1045 sizeof(struct ip6_frag)];
1046 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buf + ETH_HLEN);
1047 struct ip6_frag *frag = (void *)(extpkt + tcp_offset);
1048 int extlen = sizeof(struct ip6_frag);
1049 int bufpkt_len = total_hdr_len + PAYLOAD_LEN;
1050 int extpkt_len = bufpkt_len + extlen;
1051 int i;
1052
1053 for (i = 0; i < 2; i++) {
1054 create_packet(buf, PAYLOAD_LEN * i, 0, PAYLOAD_LEN, 0);
1055 write_packet(fd, buf, bufpkt_len, daddr);
1056 }
1057 sleep(1);
1058 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
1059 memset(extpkt, 0, extpkt_len);
1060
1061 ip6h->nexthdr = IPPROTO_FRAGMENT;
1062 ip6h->payload_len = htons(ntohs(ip6h->payload_len) + extlen);
1063 frag->ip6f_nxt = IPPROTO_TCP;
1064
1065 memcpy(extpkt, buf, tcp_offset);
1066 memcpy(extpkt + tcp_offset + extlen, buf + tcp_offset,
1067 sizeof(struct tcphdr) + PAYLOAD_LEN);
1068 write_packet(fd, extpkt, extpkt_len, daddr);
1069
1070 create_packet(buf, PAYLOAD_LEN * 3, 0, PAYLOAD_LEN, 0);
1071 write_packet(fd, buf, bufpkt_len, daddr);
1072}
1073
1074static void bind_packetsocket(int fd)
1075{
1076 struct sockaddr_ll daddr = {};
1077
1078 daddr.sll_family = AF_PACKET;
1079 daddr.sll_protocol = ethhdr_proto;
1080 daddr.sll_ifindex = if_nametoindex(ifname);
1081 if (daddr.sll_ifindex == 0)
1082 error(1, errno, "if_nametoindex");
1083
1084 if (bind(fd, (void *)&daddr, sizeof(daddr)) < 0)
1085 error(1, errno, "could not bind socket");
1086}
1087
1088static void set_timeout(int fd)
1089{
1090 struct timeval timeout;
1091
1092 timeout.tv_sec = 3;
1093 timeout.tv_usec = 0;
1094 if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout,
1095 sizeof(timeout)) < 0)
1096 error(1, errno, "cannot set timeout, setsockopt failed");
1097}
1098
1099static void set_rcvbuf(int fd)
1100{
1101 int bufsize = 1 * 1024 * 1024; /* 1 MB */
1102
1103 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize)))
1104 error(1, errno, "cannot set rcvbuf size, setsockopt failed");
1105}
1106
1107static void recv_error(int fd, int rcv_errno)
1108{
1109 struct tpacket_stats stats;
1110 socklen_t len;
1111
1112 len = sizeof(stats);
1113 if (getsockopt(fd, SOL_PACKET, PACKET_STATISTICS, &stats, &len))
1114 error(1, errno, "can't get stats");
1115
1116 fprintf(stderr, "Socket stats: packets=%u, drops=%u\n",
1117 stats.tp_packets, stats.tp_drops);
1118 error(1, rcv_errno, "could not receive");
1119}
1120
1121static void check_recv_pkts(int fd, int *correct_payload,
1122 int correct_num_pkts)
1123{
1124 static char buffer[IP_MAXPACKET + ETH_HLEN + 1];
1125 struct iphdr *iph = (struct iphdr *)(buffer + ETH_HLEN);
1126 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buffer + ETH_HLEN);
1127 struct tcphdr *tcph;
1128 bool bad_packet = false;
1129 int tcp_ext_len = 0;
1130 int ip_ext_len = 0;
1131 int pkt_size = -1;
1132 int data_len = 0;
1133 int num_pkt = 0;
1134 int i;
1135
1136 vlog("Expected {");
1137 for (i = 0; i < correct_num_pkts; i++)
1138 vlog("%d ", correct_payload[i]);
1139 vlog("}, Total %d packets\nReceived {", correct_num_pkts);
1140
1141 while (1) {
1142 ip_ext_len = 0;
1143 pkt_size = recv(fd, buffer, IP_MAXPACKET + ETH_HLEN + 1, 0);
1144 if (pkt_size < 0)
1145 recv_error(fd, errno);
1146
1147 if (iph->version == 4)
1148 ip_ext_len = (iph->ihl - 5) * 4;
1149 else if (ip6h->version == 6 && !ip6ip6 &&
1150 ip6h->nexthdr != IPPROTO_TCP)
1151 ip_ext_len = MIN_EXTHDR_SIZE;
1152
1153 tcph = (struct tcphdr *)(buffer + tcp_offset + ip_ext_len);
1154
1155 if (tcph->fin)
1156 break;
1157
1158 tcp_ext_len = (tcph->doff - 5) * 4;
1159 data_len = pkt_size - total_hdr_len - tcp_ext_len - ip_ext_len;
1160 /* Min ethernet frame payload is 46(ETH_ZLEN - ETH_HLEN) by RFC 802.3.
1161 * Ipv4/tcp packets without at least 6 bytes of data will be padded.
1162 * Packet sockets are protocol agnostic, and will not trim the padding.
1163 */
1164 if (pkt_size == ETH_ZLEN && iph->version == 4) {
1165 data_len = ntohs(iph->tot_len)
1166 - sizeof(struct tcphdr) - sizeof(struct iphdr);
1167 }
1168 vlog("%d ", data_len);
1169 if (data_len != correct_payload[num_pkt]) {
1170 vlog("[!=%d]", correct_payload[num_pkt]);
1171 bad_packet = true;
1172 }
1173 num_pkt++;
1174 }
1175 vlog("}, Total %d packets.\n", num_pkt);
1176 if (num_pkt != correct_num_pkts)
1177 error(1, 0, "incorrect number of packets");
1178 if (bad_packet)
1179 error(1, 0, "incorrect packet geometry");
1180
1181 printf("Test succeeded\n\n");
1182}
1183
1184static void check_capacity_pkts(int fd)
1185{
1186 static char buffer[IP_MAXPACKET + ETH_HLEN + 1];
1187 struct iphdr *iph = (struct iphdr *)(buffer + ETH_HLEN);
1188 struct ipv6hdr *ip6h = (struct ipv6hdr *)(buffer + ETH_HLEN);
1189 int num_pkt = 0, num_coal = 0, pkt_idx;
1190 const char *fail_reason = NULL;
1191 int flow_order[num_flows * 2];
1192 int coalesced[num_flows];
1193 struct tcphdr *tcph;
1194 int ip_ext_len = 0;
1195 int total_data = 0;
1196 int pkt_size = -1;
1197 int data_len = 0;
1198 int flow_id;
1199 int sport;
1200
1201 memset(coalesced, 0, sizeof(coalesced));
1202 memset(flow_order, -1, sizeof(flow_order));
1203
1204 while (1) {
1205 ip_ext_len = 0;
1206 pkt_size = recv(fd, buffer, IP_MAXPACKET + ETH_HLEN + 1, 0);
1207 if (pkt_size < 0)
1208 recv_error(fd, errno);
1209
1210 if (iph->version == 4)
1211 ip_ext_len = (iph->ihl - 5) * 4;
1212 else if (ip6h->version == 6 && !ip6ip6 &&
1213 ip6h->nexthdr != IPPROTO_TCP)
1214 ip_ext_len = MIN_EXTHDR_SIZE;
1215
1216 tcph = (struct tcphdr *)(buffer + tcp_offset + ip_ext_len);
1217
1218 if (tcph->fin)
1219 break;
1220
1221 sport = ntohs(tcph->source);
1222 flow_id = sport - SPORT;
1223
1224 if (flow_id < 0 || flow_id >= num_flows) {
1225 vlog("Invalid flow_id %d from sport %d\n",
1226 flow_id, sport);
1227 fail_reason = fail_reason ?: "invalid packet";
1228 continue;
1229 }
1230
1231 /* Calculate payload length */
1232 if (pkt_size == ETH_ZLEN && iph->version == 4) {
1233 data_len = ntohs(iph->tot_len)
1234 - sizeof(struct tcphdr) - sizeof(struct iphdr);
1235 } else {
1236 data_len = pkt_size - total_hdr_len - ip_ext_len;
1237 }
1238
1239 if (num_pkt < num_flows * 2) {
1240 flow_order[num_pkt] = flow_id;
1241 } else if (num_pkt == num_flows * 2) {
1242 vlog("More packets than expected (%d)\n",
1243 num_flows * 2);
1244 fail_reason = fail_reason ?: "too many packets";
1245 }
1246 coalesced[flow_id] = data_len;
1247
1248 if (data_len == CAPACITY_PAYLOAD_LEN * 2) {
1249 num_coal++;
1250 } else {
1251 vlog("Pkt %d: flow %d, sport %d, len %d (expected %d)\n",
1252 num_pkt, flow_id, sport, data_len,
1253 CAPACITY_PAYLOAD_LEN * 2);
1254 fail_reason = fail_reason ?: "not coalesced";
1255 }
1256
1257 num_pkt++;
1258 total_data += data_len;
1259 }
1260
1261 /* Check flow ordering. We expect to see all non-coalesced first segs
1262 * then interleaved coalesced and non-coalesced second frames.
1263 */
1264 pkt_idx = 0;
1265 for (flow_id = 0; order_check && flow_id < num_flows; flow_id++) {
1266 bool coaled = coalesced[flow_id] > CAPACITY_PAYLOAD_LEN;
1267
1268 if (coaled)
1269 continue;
1270
1271 if (flow_order[pkt_idx] != flow_id) {
1272 vlog("Flow order mismatch (non-coalesced) at position %d: expected flow %d, got flow %d\n",
1273 pkt_idx, flow_id, flow_order[pkt_idx]);
1274 fail_reason = fail_reason ?: "bad packet order (1)";
1275 }
1276 pkt_idx++;
1277 }
1278 for (flow_id = 0; order_check && flow_id < num_flows; flow_id++) {
1279 bool coaled = coalesced[flow_id] > CAPACITY_PAYLOAD_LEN;
1280
1281 if (flow_order[pkt_idx] != flow_id) {
1282 vlog("Flow order mismatch at position %d: expected flow %d, got flow %d, coalesced: %d\n",
1283 pkt_idx, flow_id, flow_order[pkt_idx], coaled);
1284 fail_reason = fail_reason ?: "bad packet order (2)";
1285 }
1286 pkt_idx++;
1287 }
1288
1289 if (!fail_reason) {
1290 vlog("All %d flows coalesced correctly\n", num_flows);
1291 printf("Test succeeded\n\n");
1292 } else {
1293 printf("FAILED\n");
1294 }
1295
1296 /* Always print stats for external validation */
1297 printf("STATS: received=%d wire=%d coalesced=%d\n",
1298 num_pkt, num_pkt + num_coal, num_coal);
1299
1300 if (fail_reason)
1301 error(1, 0, "capacity test failed %s", fail_reason);
1302}
1303
1304static void gro_sender(void)
1305{
1306 int bufsize = 4 * 1024 * 1024; /* 4 MB */
1307 const int fin_delay_us = 100 * 1000;
1308 static char fin_pkt[MAX_HDR_LEN];
1309 struct sockaddr_ll daddr = {};
1310 int txfd = -1;
1311
1312 txfd = socket(PF_PACKET, SOCK_RAW, IPPROTO_RAW);
1313 if (txfd < 0)
1314 error(1, errno, "socket creation");
1315
1316 if (setsockopt(txfd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize)))
1317 error(1, errno, "cannot set sndbuf size, setsockopt failed");
1318
1319 /* Enable SO_TXTIME unless test case generates more than one flow
1320 * SO_TXTIME could result in qdisc layer sorting the packets at sender.
1321 */
1322 if (strcmp(testname, "single") && strcmp(testname, "capacity")) {
1323 struct sock_txtime so_txtime = { .clockid = CLOCK_MONOTONIC, };
1324 struct timespec ts;
1325
1326 if (setsockopt(txfd, SOL_SOCKET, SO_TXTIME,
1327 &so_txtime, sizeof(so_txtime)))
1328 error(1, errno, "setsockopt SO_TXTIME");
1329
1330 if (clock_gettime(CLOCK_MONOTONIC, &ts))
1331 error(1, errno, "clock_gettime");
1332
1333 txtime_ns = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
1334 txtime_ns += TXTIME_DELAY_MS * 1000000ULL;
1335 }
1336
1337 memset(&daddr, 0, sizeof(daddr));
1338 daddr.sll_ifindex = if_nametoindex(ifname);
1339 if (daddr.sll_ifindex == 0)
1340 error(1, errno, "if_nametoindex");
1341 daddr.sll_family = AF_PACKET;
1342 memcpy(daddr.sll_addr, dst_mac, ETH_ALEN);
1343 daddr.sll_halen = ETH_ALEN;
1344 create_packet(fin_pkt, PAYLOAD_LEN * 2, 0, 0, 1);
1345
1346 /* data sub-tests */
1347 if (strcmp(testname, "data_same") == 0) {
1348 send_data_pkts(txfd, &daddr, PAYLOAD_LEN, PAYLOAD_LEN);
1349 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1350 } else if (strcmp(testname, "data_lrg_sml") == 0) {
1351 send_data_pkts(txfd, &daddr, PAYLOAD_LEN, PAYLOAD_LEN / 2);
1352 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1353 } else if (strcmp(testname, "data_lrg_1byte") == 0) {
1354 send_data_pkts(txfd, &daddr, PAYLOAD_LEN, 1);
1355 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1356 } else if (strcmp(testname, "data_sml_lrg") == 0) {
1357 send_data_pkts(txfd, &daddr, PAYLOAD_LEN / 2, PAYLOAD_LEN);
1358 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1359 } else if (strcmp(testname, "data_burst") == 0) {
1360 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
1361
1362 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
1363 write_packet(txfd, buf, total_hdr_len + PAYLOAD_LEN, &daddr);
1364 create_packet(buf, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
1365 write_packet(txfd, buf, total_hdr_len + PAYLOAD_LEN, &daddr);
1366
1367 usleep(100 * 1000); /* 100ms */
1368 create_packet(buf, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
1369 write_packet(txfd, buf, total_hdr_len + PAYLOAD_LEN, &daddr);
1370 create_packet(buf, PAYLOAD_LEN * 3, 0, PAYLOAD_LEN, 0);
1371 write_packet(txfd, buf, total_hdr_len + PAYLOAD_LEN, &daddr);
1372
1373 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1374
1375 /* ack test */
1376 } else if (strcmp(testname, "ack") == 0) {
1377 send_ack(txfd, &daddr);
1378 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1379
1380 /* flags sub-tests */
1381 } else if (strcmp(testname, "flags_psh") == 0) {
1382 send_flags(txfd, &daddr, 1, 0, 0, 0, 0);
1383 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1384 } else if (strcmp(testname, "flags_syn") == 0) {
1385 send_flags(txfd, &daddr, 0, 1, 0, 0, 0);
1386 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1387 } else if (strcmp(testname, "flags_rst") == 0) {
1388 send_flags(txfd, &daddr, 0, 0, 1, 0, 0);
1389 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1390 } else if (strcmp(testname, "flags_urg") == 0) {
1391 send_flags(txfd, &daddr, 0, 0, 0, 1, 0);
1392 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1393 } else if (strcmp(testname, "flags_cwr") == 0) {
1394 send_flags(txfd, &daddr, 0, 0, 0, 0, 1);
1395 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1396
1397 /* tcp sub-tests */
1398 } else if (strcmp(testname, "tcp_csum") == 0) {
1399 send_changed_checksum(txfd, &daddr);
1400 usleep(fin_delay_us);
1401 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1402 } else if (strcmp(testname, "tcp_seq") == 0) {
1403 send_changed_seq(txfd, &daddr);
1404 usleep(fin_delay_us);
1405 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1406 } else if (strcmp(testname, "tcp_ts") == 0) {
1407 send_changed_ts(txfd, &daddr);
1408 usleep(fin_delay_us);
1409 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1410 } else if (strcmp(testname, "tcp_opt") == 0) {
1411 send_diff_opt(txfd, &daddr);
1412 usleep(fin_delay_us);
1413 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1414
1415 /* ip sub-tests - shared between IPv4 and IPv6 */
1416 } else if (strcmp(testname, "ip_ecn") == 0) {
1417 send_changed_ECN(txfd, &daddr);
1418 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1419 } else if (strcmp(testname, "ip_tos") == 0) {
1420 send_changed_tos(txfd, &daddr);
1421 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1422
1423 /* ip sub-tests - IPv4 only */
1424 } else if (strcmp(testname, "ip_csum") == 0) {
1425 send_changed_ip_checksum(txfd, &daddr);
1426 usleep(fin_delay_us);
1427 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1428 } else if (strcmp(testname, "ip_ttl") == 0) {
1429 send_changed_ttl(txfd, &daddr);
1430 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1431 } else if (strcmp(testname, "ip_opt") == 0) {
1432 send_ip_options(txfd, &daddr);
1433 usleep(fin_delay_us);
1434 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1435 } else if (strcmp(testname, "ip_frag4") == 0) {
1436 send_fragment4(txfd, &daddr);
1437 usleep(fin_delay_us);
1438 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1439 } else if (strcmp(testname, "ip_id_df1_inc") == 0) {
1440 send_flush_id_case(txfd, &daddr, FLUSH_ID_DF1_INC);
1441 usleep(fin_delay_us);
1442 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1443 } else if (strcmp(testname, "ip_id_df1_fixed") == 0) {
1444 send_flush_id_case(txfd, &daddr, FLUSH_ID_DF1_FIXED);
1445 usleep(fin_delay_us);
1446 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1447 } else if (strcmp(testname, "ip_id_df0_inc") == 0) {
1448 send_flush_id_case(txfd, &daddr, FLUSH_ID_DF0_INC);
1449 usleep(fin_delay_us);
1450 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1451 } else if (strcmp(testname, "ip_id_df0_fixed") == 0) {
1452 send_flush_id_case(txfd, &daddr, FLUSH_ID_DF0_FIXED);
1453 usleep(fin_delay_us);
1454 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1455 } else if (strcmp(testname, "ip_id_df1_inc_fixed") == 0) {
1456 send_flush_id_case(txfd, &daddr, FLUSH_ID_DF1_INC_FIXED);
1457 usleep(fin_delay_us);
1458 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1459 } else if (strcmp(testname, "ip_id_df1_fixed_inc") == 0) {
1460 send_flush_id_case(txfd, &daddr, FLUSH_ID_DF1_FIXED_INC);
1461 usleep(fin_delay_us);
1462 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1463
1464 /* ip sub-tests - IPv6 only */
1465 } else if (strcmp(testname, "ip_frag6") == 0) {
1466 send_fragment6(txfd, &daddr);
1467 usleep(fin_delay_us);
1468 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1469 } else if (strcmp(testname, "ip_v6ext_same") == 0) {
1470 send_ipv6_exthdr(txfd, &daddr, EXT_PAYLOAD_1, EXT_PAYLOAD_1);
1471 usleep(fin_delay_us);
1472 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1473 } else if (strcmp(testname, "ip_v6ext_diff") == 0) {
1474 send_ipv6_exthdr(txfd, &daddr, EXT_PAYLOAD_1, EXT_PAYLOAD_2);
1475 usleep(fin_delay_us);
1476 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1477
1478 /* large sub-tests */
1479 } else if (strcmp(testname, "large_max") == 0) {
1480 int remainder = max_payload() % calc_mss();
1481
1482 send_large(txfd, &daddr, remainder);
1483 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1484 } else if (strcmp(testname, "large_rem") == 0) {
1485 int remainder = max_payload() % calc_mss();
1486
1487 send_large(txfd, &daddr, remainder + 1);
1488 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1489
1490 /* machinery sub-tests */
1491 } else if (strcmp(testname, "single") == 0) {
1492 static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
1493
1494 create_packet(buf, 0, 0, PAYLOAD_LEN, 0);
1495 write_packet(txfd, buf, total_hdr_len + PAYLOAD_LEN, &daddr);
1496 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1497 } else if (strcmp(testname, "capacity") == 0) {
1498 send_capacity(txfd, &daddr);
1499 usleep(fin_delay_us);
1500 write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
1501
1502 } else {
1503 error(1, 0, "Unknown testcase: %s", testname);
1504 }
1505
1506 if (close(txfd))
1507 error(1, errno, "socket close");
1508}
1509
1510static void gro_receiver(void)
1511{
1512 static int correct_payload[NUM_PACKETS];
1513 int rxfd = -1;
1514
1515 rxfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_NONE));
1516 if (rxfd < 0)
1517 error(1, 0, "socket creation");
1518 setup_sock_filter(rxfd);
1519 set_timeout(rxfd);
1520 set_rcvbuf(rxfd);
1521 bind_packetsocket(rxfd);
1522
1523 ksft_ready();
1524
1525 memset(correct_payload, 0, sizeof(correct_payload));
1526
1527 /* data sub-tests */
1528 if (strcmp(testname, "data_same") == 0) {
1529 printf("pure data packet of same size: ");
1530 correct_payload[0] = PAYLOAD_LEN * 2;
1531 check_recv_pkts(rxfd, correct_payload, 1);
1532 } else if (strcmp(testname, "data_lrg_sml") == 0) {
1533 printf("large data packets followed by a smaller one: ");
1534 correct_payload[0] = PAYLOAD_LEN * 1.5;
1535 check_recv_pkts(rxfd, correct_payload, 1);
1536 } else if (strcmp(testname, "data_lrg_1byte") == 0) {
1537 printf("large data packet followed by a 1 byte one: ");
1538 correct_payload[0] = PAYLOAD_LEN + 1;
1539 check_recv_pkts(rxfd, correct_payload, 1);
1540 } else if (strcmp(testname, "data_sml_lrg") == 0) {
1541 printf("small data packets followed by a larger one: ");
1542 correct_payload[0] = PAYLOAD_LEN / 2;
1543 correct_payload[1] = PAYLOAD_LEN;
1544 check_recv_pkts(rxfd, correct_payload, 2);
1545 } else if (strcmp(testname, "data_burst") == 0) {
1546 printf("two bursts of two data packets: ");
1547 correct_payload[0] = PAYLOAD_LEN * 2;
1548 correct_payload[1] = PAYLOAD_LEN * 2;
1549 check_recv_pkts(rxfd, correct_payload, 2);
1550
1551 /* ack test */
1552 } else if (strcmp(testname, "ack") == 0) {
1553 printf("duplicate ack and pure ack: ");
1554 check_recv_pkts(rxfd, correct_payload, 3);
1555
1556 /* flags sub-tests */
1557 } else if (strcmp(testname, "flags_psh") == 0) {
1558 correct_payload[0] = PAYLOAD_LEN * 3;
1559 correct_payload[1] = PAYLOAD_LEN * 2;
1560 printf("psh flag ends coalescing: ");
1561 check_recv_pkts(rxfd, correct_payload, 2);
1562 } else if (strcmp(testname, "flags_syn") == 0) {
1563 correct_payload[0] = PAYLOAD_LEN * 2;
1564 correct_payload[1] = 0;
1565 correct_payload[2] = PAYLOAD_LEN * 2;
1566 printf("syn flag ends coalescing: ");
1567 check_recv_pkts(rxfd, correct_payload, 3);
1568 } else if (strcmp(testname, "flags_rst") == 0) {
1569 correct_payload[0] = PAYLOAD_LEN * 2;
1570 correct_payload[1] = 0;
1571 correct_payload[2] = PAYLOAD_LEN * 2;
1572 printf("rst flag ends coalescing: ");
1573 check_recv_pkts(rxfd, correct_payload, 3);
1574 } else if (strcmp(testname, "flags_urg") == 0) {
1575 correct_payload[0] = PAYLOAD_LEN * 2;
1576 correct_payload[1] = 0;
1577 correct_payload[2] = PAYLOAD_LEN * 2;
1578 printf("urg flag ends coalescing: ");
1579 check_recv_pkts(rxfd, correct_payload, 3);
1580 } else if (strcmp(testname, "flags_cwr") == 0) {
1581 correct_payload[0] = PAYLOAD_LEN;
1582 correct_payload[1] = PAYLOAD_LEN * 2;
1583 correct_payload[2] = PAYLOAD_LEN * 2;
1584 printf("cwr flag ends coalescing: ");
1585 check_recv_pkts(rxfd, correct_payload, 3);
1586
1587 /* tcp sub-tests */
1588 } else if (strcmp(testname, "tcp_csum") == 0) {
1589 correct_payload[0] = PAYLOAD_LEN;
1590 correct_payload[1] = PAYLOAD_LEN;
1591 printf("changed checksum does not coalesce: ");
1592 check_recv_pkts(rxfd, correct_payload, 2);
1593 } else if (strcmp(testname, "tcp_seq") == 0) {
1594 correct_payload[0] = PAYLOAD_LEN;
1595 correct_payload[1] = PAYLOAD_LEN;
1596 printf("Wrong Seq number doesn't coalesce: ");
1597 check_recv_pkts(rxfd, correct_payload, 2);
1598 } else if (strcmp(testname, "tcp_ts") == 0) {
1599 correct_payload[0] = PAYLOAD_LEN * 2;
1600 correct_payload[1] = PAYLOAD_LEN;
1601 correct_payload[2] = PAYLOAD_LEN;
1602 correct_payload[3] = PAYLOAD_LEN;
1603 printf("Different timestamp doesn't coalesce: ");
1604 check_recv_pkts(rxfd, correct_payload, 4);
1605 } else if (strcmp(testname, "tcp_opt") == 0) {
1606 correct_payload[0] = PAYLOAD_LEN * 2;
1607 correct_payload[1] = PAYLOAD_LEN;
1608 printf("Different options doesn't coalesce: ");
1609 check_recv_pkts(rxfd, correct_payload, 2);
1610
1611 /* ip sub-tests - shared between IPv4 and IPv6 */
1612 } else if (strcmp(testname, "ip_ecn") == 0) {
1613 correct_payload[0] = PAYLOAD_LEN;
1614 correct_payload[1] = PAYLOAD_LEN;
1615 printf("different ECN doesn't coalesce: ");
1616 check_recv_pkts(rxfd, correct_payload, 2);
1617 } else if (strcmp(testname, "ip_tos") == 0) {
1618 correct_payload[0] = PAYLOAD_LEN;
1619 correct_payload[1] = PAYLOAD_LEN;
1620 printf("different tos doesn't coalesce: ");
1621 check_recv_pkts(rxfd, correct_payload, 2);
1622
1623 /* ip sub-tests - IPv4 only */
1624 } else if (strcmp(testname, "ip_csum") == 0) {
1625 correct_payload[0] = PAYLOAD_LEN;
1626 correct_payload[1] = PAYLOAD_LEN;
1627 correct_payload[2] = PAYLOAD_LEN;
1628 printf("bad ip checksum doesn't coalesce: ");
1629 check_recv_pkts(rxfd, correct_payload, 3);
1630 } else if (strcmp(testname, "ip_ttl") == 0) {
1631 correct_payload[0] = PAYLOAD_LEN;
1632 correct_payload[1] = PAYLOAD_LEN;
1633 printf("different ttl doesn't coalesce: ");
1634 check_recv_pkts(rxfd, correct_payload, 2);
1635 } else if (strcmp(testname, "ip_opt") == 0) {
1636 correct_payload[0] = PAYLOAD_LEN;
1637 correct_payload[1] = PAYLOAD_LEN;
1638 correct_payload[2] = PAYLOAD_LEN;
1639 printf("ip options doesn't coalesce: ");
1640 check_recv_pkts(rxfd, correct_payload, 3);
1641 } else if (strcmp(testname, "ip_frag4") == 0) {
1642 correct_payload[0] = PAYLOAD_LEN;
1643 correct_payload[1] = PAYLOAD_LEN;
1644 printf("fragmented ip4 doesn't coalesce: ");
1645 check_recv_pkts(rxfd, correct_payload, 2);
1646 } else if (strcmp(testname, "ip_id_df1_inc") == 0) {
1647 printf("DF=1, Incrementing - should coalesce: ");
1648 correct_payload[0] = PAYLOAD_LEN * 2;
1649 check_recv_pkts(rxfd, correct_payload, 1);
1650 } else if (strcmp(testname, "ip_id_df1_fixed") == 0) {
1651 printf("DF=1, Fixed - should coalesce: ");
1652 correct_payload[0] = PAYLOAD_LEN * 2;
1653 check_recv_pkts(rxfd, correct_payload, 1);
1654 } else if (strcmp(testname, "ip_id_df0_inc") == 0) {
1655 printf("DF=0, Incrementing - should coalesce: ");
1656 correct_payload[0] = PAYLOAD_LEN * 2;
1657 check_recv_pkts(rxfd, correct_payload, 1);
1658 } else if (strcmp(testname, "ip_id_df0_fixed") == 0) {
1659 printf("DF=0, Fixed - should coalesce: ");
1660 correct_payload[0] = PAYLOAD_LEN * 2;
1661 check_recv_pkts(rxfd, correct_payload, 1);
1662 } else if (strcmp(testname, "ip_id_df1_inc_fixed") == 0) {
1663 printf("DF=1, 2 Incrementing and one fixed - should coalesce only first 2 packets: ");
1664 correct_payload[0] = PAYLOAD_LEN * 2;
1665 correct_payload[1] = PAYLOAD_LEN;
1666 check_recv_pkts(rxfd, correct_payload, 2);
1667 } else if (strcmp(testname, "ip_id_df1_fixed_inc") == 0) {
1668 printf("DF=1, 2 Fixed and one incrementing - should coalesce only first 2 packets: ");
1669 correct_payload[0] = PAYLOAD_LEN * 2;
1670 correct_payload[1] = PAYLOAD_LEN;
1671 check_recv_pkts(rxfd, correct_payload, 2);
1672
1673 /* ip sub-tests - IPv6 only */
1674 } else if (strcmp(testname, "ip_frag6") == 0) {
1675 /* GRO doesn't check for ipv6 hop limit when flushing.
1676 * Hence no corresponding test to the ipv4 case.
1677 */
1678 printf("fragmented ip6 doesn't coalesce: ");
1679 correct_payload[0] = PAYLOAD_LEN * 2;
1680 correct_payload[1] = PAYLOAD_LEN;
1681 correct_payload[2] = PAYLOAD_LEN;
1682 check_recv_pkts(rxfd, correct_payload, 3);
1683 } else if (strcmp(testname, "ip_v6ext_same") == 0) {
1684 printf("ipv6 with ext header does coalesce: ");
1685 correct_payload[0] = PAYLOAD_LEN * 2;
1686 check_recv_pkts(rxfd, correct_payload, 1);
1687 } else if (strcmp(testname, "ip_v6ext_diff") == 0) {
1688 printf("ipv6 with ext header with different payloads doesn't coalesce: ");
1689 correct_payload[0] = PAYLOAD_LEN;
1690 correct_payload[1] = PAYLOAD_LEN;
1691 check_recv_pkts(rxfd, correct_payload, 2);
1692
1693 /* large sub-tests */
1694 } else if (strcmp(testname, "large_max") == 0) {
1695 int remainder = max_payload() % calc_mss();
1696
1697 correct_payload[0] = max_payload();
1698 correct_payload[1] = remainder;
1699 printf("Shouldn't coalesce if exceed IP max pkt size: ");
1700 check_recv_pkts(rxfd, correct_payload, 2);
1701 } else if (strcmp(testname, "large_rem") == 0) {
1702 int remainder = max_payload() % calc_mss();
1703
1704 /* last segment sent individually, doesn't start new segment */
1705 correct_payload[0] = max_payload() - remainder;
1706 correct_payload[1] = remainder + 1;
1707 correct_payload[2] = remainder + 1;
1708 printf("last segment sent individually: ");
1709 check_recv_pkts(rxfd, correct_payload, 3);
1710
1711 /* machinery sub-tests */
1712 } else if (strcmp(testname, "single") == 0) {
1713 printf("single data packet: ");
1714 correct_payload[0] = PAYLOAD_LEN;
1715 check_recv_pkts(rxfd, correct_payload, 1);
1716 } else if (strcmp(testname, "capacity") == 0) {
1717 check_capacity_pkts(rxfd);
1718
1719 } else {
1720 error(1, 0, "Test case error: unknown testname %s", testname);
1721 }
1722
1723 if (close(rxfd))
1724 error(1, 0, "socket close");
1725}
1726
1727static void parse_args(int argc, char **argv)
1728{
1729 static const struct option opts[] = {
1730 { "daddr", required_argument, NULL, 'd' },
1731 { "dmac", required_argument, NULL, 'D' },
1732 { "iface", required_argument, NULL, 'i' },
1733 { "ipv4", no_argument, NULL, '4' },
1734 { "ipv6", no_argument, NULL, '6' },
1735 { "ipip", no_argument, NULL, 'e' },
1736 { "ip6ip6", no_argument, NULL, 'E' },
1737 { "num-flows", required_argument, NULL, 'n' },
1738 { "rx", no_argument, NULL, 'r' },
1739 { "saddr", required_argument, NULL, 's' },
1740 { "smac", required_argument, NULL, 'S' },
1741 { "test", required_argument, NULL, 't' },
1742 { "order-check", no_argument, NULL, 'o' },
1743 { "verbose", no_argument, NULL, 'v' },
1744 { 0, 0, 0, 0 }
1745 };
1746 int c;
1747
1748 while ((c = getopt_long(argc, argv, "46d:D:eEi:n:rs:S:t:ov", opts, NULL)) != -1) {
1749 switch (c) {
1750 case '4':
1751 proto = PF_INET;
1752 ethhdr_proto = htons(ETH_P_IP);
1753 break;
1754 case '6':
1755 proto = PF_INET6;
1756 ethhdr_proto = htons(ETH_P_IPV6);
1757 break;
1758 case 'e':
1759 ipip = true;
1760 proto = PF_INET;
1761 ethhdr_proto = htons(ETH_P_IP);
1762 break;
1763 case 'E':
1764 ip6ip6 = true;
1765 proto = PF_INET6;
1766 ethhdr_proto = htons(ETH_P_IPV6);
1767 break;
1768 case 'd':
1769 addr4_dst = addr6_dst = optarg;
1770 break;
1771 case 'D':
1772 dmac = optarg;
1773 break;
1774 case 'i':
1775 ifname = optarg;
1776 break;
1777 case 'n':
1778 num_flows = atoi(optarg);
1779 break;
1780 case 'r':
1781 tx_socket = false;
1782 break;
1783 case 's':
1784 addr4_src = addr6_src = optarg;
1785 break;
1786 case 'S':
1787 smac = optarg;
1788 break;
1789 case 't':
1790 testname = optarg;
1791 break;
1792 case 'o':
1793 order_check = true;
1794 break;
1795 case 'v':
1796 verbose = true;
1797 break;
1798 default:
1799 error(1, 0, "%s invalid option %c\n", __func__, c);
1800 break;
1801 }
1802 }
1803}
1804
1805int main(int argc, char **argv)
1806{
1807 parse_args(argc, argv);
1808
1809 if (ipip) {
1810 tcp_offset = ETH_HLEN + sizeof(struct iphdr) * 2;
1811 total_hdr_len = tcp_offset + sizeof(struct tcphdr);
1812 } else if (ip6ip6) {
1813 tcp_offset = ETH_HLEN + sizeof(struct ipv6hdr) * 2;
1814 total_hdr_len = tcp_offset + sizeof(struct tcphdr);
1815 } else if (proto == PF_INET) {
1816 tcp_offset = ETH_HLEN + sizeof(struct iphdr);
1817 total_hdr_len = tcp_offset + sizeof(struct tcphdr);
1818 } else if (proto == PF_INET6) {
1819 tcp_offset = ETH_HLEN + sizeof(struct ipv6hdr);
1820 total_hdr_len = tcp_offset + sizeof(struct tcphdr);
1821 } else {
1822 error(1, 0, "Protocol family is not ipv4 or ipv6");
1823 }
1824
1825 read_MAC(src_mac, smac);
1826 read_MAC(dst_mac, dmac);
1827
1828 if (tx_socket) {
1829 gro_sender();
1830 } else {
1831 /* Only the receiver exit status determines test success. */
1832 gro_receiver();
1833 fprintf(stderr, "Gro::%s test passed.\n", testname);
1834 }
1835
1836 return 0;
1837}