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