selftests/net: add flush id selftests

Added flush id selftests to test different cases where DF flag is set or
unset and id value changes in the following packets. All cases where the
packets should coalesce or should not coalesce are tested.

Signed-off-by: Richard Gobert <richardbgobert@gmail.com>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Link: https://lore.kernel.org/r/20240509190819.2985-4-richardbgobert@gmail.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/tools/testing/selftests/net/gro.c b/tools/testing/selftests/net/gro.c
index 6038b96ecee88d2ddd122c7b79574096dcf35e53..b2184847e3881275576a91e9be082eb066929b32 100644 (file)
--- a/tools/testing/selftests/net/gro.c
+++ b/tools/testing/selftests/net/gro.c
@@ -93,6 +93,7 @@ static bool tx_socket = true;
 static int tcp_offset = -1;
 static int total_hdr_len = -1;
 static int ethhdr_proto = -1;
+static const int num_flush_id_cases = 6;
 
 static void vlog(const char *fmt, ...)
 {
@@ -620,6 +621,113 @@ static void add_ipv6_exthdr(void *buf, void *optpkt, __u8 exthdr_type, char *ext
        iph->payload_len = htons(ntohs(iph->payload_len) + MIN_EXTHDR_SIZE);
 }
 
+static void fix_ip4_checksum(struct iphdr *iph)
+{
+       iph->check = 0;
+       iph->check = checksum_fold(iph, sizeof(struct iphdr), 0);
+}
+
+static void send_flush_id_case(int fd, struct sockaddr_ll *daddr, int tcase)
+{
+       static char buf1[MAX_HDR_LEN + PAYLOAD_LEN];
+       static char buf2[MAX_HDR_LEN + PAYLOAD_LEN];
+       static char buf3[MAX_HDR_LEN + PAYLOAD_LEN];
+       bool send_three = false;
+       struct iphdr *iph1;
+       struct iphdr *iph2;
+       struct iphdr *iph3;
+
+       iph1 = (struct iphdr *)(buf1 + ETH_HLEN);
+       iph2 = (struct iphdr *)(buf2 + ETH_HLEN);
+       iph3 = (struct iphdr *)(buf3 + ETH_HLEN);
+
+       create_packet(buf1, 0, 0, PAYLOAD_LEN, 0);
+       create_packet(buf2, PAYLOAD_LEN, 0, PAYLOAD_LEN, 0);
+       create_packet(buf3, PAYLOAD_LEN * 2, 0, PAYLOAD_LEN, 0);
+
+       switch (tcase) {
+       case 0: /* DF=1, Incrementing - should coalesce */
+               iph1->frag_off |= htons(IP_DF);
+               iph1->id = htons(8);
+
+               iph2->frag_off |= htons(IP_DF);
+               iph2->id = htons(9);
+               break;
+
+       case 1: /* DF=1, Fixed - should coalesce */
+               iph1->frag_off |= htons(IP_DF);
+               iph1->id = htons(8);
+
+               iph2->frag_off |= htons(IP_DF);
+               iph2->id = htons(8);
+               break;
+
+       case 2: /* DF=0, Incrementing - should coalesce */
+               iph1->frag_off &= ~htons(IP_DF);
+               iph1->id = htons(8);
+
+               iph2->frag_off &= ~htons(IP_DF);
+               iph2->id = htons(9);
+               break;
+
+       case 3: /* DF=0, Fixed - should not coalesce */
+               iph1->frag_off &= ~htons(IP_DF);
+               iph1->id = htons(8);
+
+               iph2->frag_off &= ~htons(IP_DF);
+               iph2->id = htons(8);
+               break;
+
+       case 4: /* DF=1, two packets incrementing, and one fixed - should
+                * coalesce only the first two packets
+                */
+               iph1->frag_off |= htons(IP_DF);
+               iph1->id = htons(8);
+
+               iph2->frag_off |= htons(IP_DF);
+               iph2->id = htons(9);
+
+               iph3->frag_off |= htons(IP_DF);
+               iph3->id = htons(9);
+               send_three = true;
+               break;
+
+       case 5: /* DF=1, two packets fixed, and one incrementing - should
+                * coalesce only the first two packets
+                */
+               iph1->frag_off |= htons(IP_DF);
+               iph1->id = htons(8);
+
+               iph2->frag_off |= htons(IP_DF);
+               iph2->id = htons(8);
+
+               iph3->frag_off |= htons(IP_DF);
+               iph3->id = htons(9);
+               send_three = true;
+               break;
+       }
+
+       fix_ip4_checksum(iph1);
+       fix_ip4_checksum(iph2);
+       write_packet(fd, buf1, total_hdr_len + PAYLOAD_LEN, daddr);
+       write_packet(fd, buf2, total_hdr_len + PAYLOAD_LEN, daddr);
+
+       if (send_three) {
+               fix_ip4_checksum(iph3);
+               write_packet(fd, buf3, total_hdr_len + PAYLOAD_LEN, daddr);
+       }
+}
+
+static void test_flush_id(int fd, struct sockaddr_ll *daddr, char *fin_pkt)
+{
+       for (int i = 0; i < num_flush_id_cases; i++) {
+               sleep(1);
+               send_flush_id_case(fd, daddr, i);
+               sleep(1);
+               write_packet(fd, fin_pkt, total_hdr_len, daddr);
+       }
+}
+
 static void send_ipv6_exthdr(int fd, struct sockaddr_ll *daddr, char *ext_data1, char *ext_data2)
 {
        static char buf[MAX_HDR_LEN + PAYLOAD_LEN];
@@ -938,6 +1046,8 @@ static void gro_sender(void)
                        send_fragment4(txfd, &daddr);
                        sleep(1);
                        write_packet(txfd, fin_pkt, total_hdr_len, &daddr);
+
+                       test_flush_id(txfd, &daddr, fin_pkt);
                } else if (proto == PF_INET6) {
                        sleep(1);
                        send_fragment6(txfd, &daddr);
@@ -1064,6 +1174,34 @@ static void gro_receiver(void)
 
                        printf("fragmented ip4 doesn't coalesce: ");
                        check_recv_pkts(rxfd, correct_payload, 2);
+
+                       /* is_atomic checks */
+                       printf("DF=1, Incrementing - should coalesce: ");
+                       correct_payload[0] = PAYLOAD_LEN * 2;
+                       check_recv_pkts(rxfd, correct_payload, 1);
+
+                       printf("DF=1, Fixed - should coalesce: ");
+                       correct_payload[0] = PAYLOAD_LEN * 2;
+                       check_recv_pkts(rxfd, correct_payload, 1);
+
+                       printf("DF=0, Incrementing - should coalesce: ");
+                       correct_payload[0] = PAYLOAD_LEN * 2;
+                       check_recv_pkts(rxfd, correct_payload, 1);
+
+                       printf("DF=0, Fixed - should not coalesce: ");
+                       correct_payload[0] = PAYLOAD_LEN;
+                       correct_payload[1] = PAYLOAD_LEN;
+                       check_recv_pkts(rxfd, correct_payload, 2);
+
+                       printf("DF=1, 2 Incrementing and one fixed - should coalesce only first 2 packets: ");
+                       correct_payload[0] = PAYLOAD_LEN * 2;
+                       correct_payload[1] = PAYLOAD_LEN;
+                       check_recv_pkts(rxfd, correct_payload, 2);
+
+                       printf("DF=1, 2 Fixed and one incrementing - should coalesce only first 2 packets: ");
+                       correct_payload[0] = PAYLOAD_LEN * 2;
+                       correct_payload[1] = PAYLOAD_LEN;
+                       check_recv_pkts(rxfd, correct_payload, 2);
                } else if (proto == PF_INET6) {
                        /* GRO doesn't check for ipv6 hop limit when flushing.
                         * Hence no corresponding test to the ipv4 case.