1 // SPDX-License-Identifier: GPL-2.0 2 #include <test_progs.h> 3 #include <network_helpers.h> 4 5 void test_xdp_adjust_tail_shrink(void) 6 { 7 const char *file = "./test_xdp_adjust_tail_shrink.o"; 8 __u32 duration, retval, size, expect_sz; 9 struct bpf_object *obj; 10 int err, prog_fd; 11 char buf[128]; 12 13 err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 14 if (CHECK_FAIL(err)) 15 return; 16 17 err = bpf_prog_test_run(prog_fd, 1, &pkt_v4, sizeof(pkt_v4), 18 buf, &size, &retval, &duration); 19 20 CHECK(err || retval != XDP_DROP, 21 "ipv4", "err %d errno %d retval %d size %d\n", 22 err, errno, retval, size); 23 24 expect_sz = sizeof(pkt_v6) - 20; /* Test shrink with 20 bytes */ 25 err = bpf_prog_test_run(prog_fd, 1, &pkt_v6, sizeof(pkt_v6), 26 buf, &size, &retval, &duration); 27 CHECK(err || retval != XDP_TX || size != expect_sz, 28 "ipv6", "err %d errno %d retval %d size %d expect-size %d\n", 29 err, errno, retval, size, expect_sz); 30 bpf_object__close(obj); 31 } 32 33 void test_xdp_adjust_tail_grow(void) 34 { 35 const char *file = "./test_xdp_adjust_tail_grow.o"; 36 struct bpf_object *obj; 37 char buf[4096]; /* avoid segfault: large buf to hold grow results */ 38 __u32 duration, retval, size, expect_sz; 39 int err, prog_fd; 40 41 err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd); 42 if (CHECK_FAIL(err)) 43 return; 44 45 err = bpf_prog_test_run(prog_fd, 1, &pkt_v4, sizeof(pkt_v4), 46 buf, &size, &retval, &duration); 47 CHECK(err || retval != XDP_DROP, 48 "ipv4", "err %d errno %d retval %d size %d\n", 49 err, errno, retval, size); 50 51 expect_sz = sizeof(pkt_v6) + 40; /* Test grow with 40 bytes */ 52 err = bpf_prog_test_run(prog_fd, 1, &pkt_v6, sizeof(pkt_v6) /* 74 */, 53 buf, &size, &retval, &duration); 54 CHECK(err || retval != XDP_TX || size != expect_sz, 55 "ipv6", "err %d errno %d retval %d size %d expect-size %d\n", 56 err, errno, retval, size, expect_sz); 57 58 bpf_object__close(obj); 59 } 60 61 void test_xdp_adjust_tail_grow2(void) 62 { 63 const char *file = "./test_xdp_adjust_tail_grow.o"; 64 char buf[4096]; /* avoid segfault: large buf to hold grow results */ 65 int tailroom = 320; /* SKB_DATA_ALIGN(sizeof(struct skb_shared_info))*/; 66 struct bpf_object *obj; 67 int err, cnt, i; 68 int max_grow; 69 70 struct bpf_prog_test_run_attr tattr = { 71 .repeat = 1, 72 .data_in = &buf, 73 .data_out = &buf, 74 .data_size_in = 0, /* Per test */ 75 .data_size_out = 0, /* Per test */ 76 }; 77 78 err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &tattr.prog_fd); 79 if (CHECK_ATTR(err, "load", "err %d errno %d\n", err, errno)) 80 return; 81 82 /* Test case-64 */ 83 memset(buf, 1, sizeof(buf)); 84 tattr.data_size_in = 64; /* Determine test case via pkt size */ 85 tattr.data_size_out = 128; /* Limit copy_size */ 86 /* Kernel side alloc packet memory area that is zero init */ 87 err = bpf_prog_test_run_xattr(&tattr); 88 89 CHECK_ATTR(errno != ENOSPC /* Due limit copy_size in bpf_test_finish */ 90 || tattr.retval != XDP_TX 91 || tattr.data_size_out != 192, /* Expected grow size */ 92 "case-64", 93 "err %d errno %d retval %d size %d\n", 94 err, errno, tattr.retval, tattr.data_size_out); 95 96 /* Extra checks for data contents */ 97 CHECK_ATTR(tattr.data_size_out != 192 98 || buf[0] != 1 || buf[63] != 1 /* 0-63 memset to 1 */ 99 || buf[64] != 0 || buf[127] != 0 /* 64-127 memset to 0 */ 100 || buf[128] != 1 || buf[191] != 1, /*128-191 memset to 1 */ 101 "case-64-data", 102 "err %d errno %d retval %d size %d\n", 103 err, errno, tattr.retval, tattr.data_size_out); 104 105 /* Test case-128 */ 106 memset(buf, 2, sizeof(buf)); 107 tattr.data_size_in = 128; /* Determine test case via pkt size */ 108 tattr.data_size_out = sizeof(buf); /* Copy everything */ 109 err = bpf_prog_test_run_xattr(&tattr); 110 111 max_grow = 4096 - XDP_PACKET_HEADROOM - tailroom; /* 3520 */ 112 CHECK_ATTR(err 113 || tattr.retval != XDP_TX 114 || tattr.data_size_out != max_grow,/* Expect max grow size */ 115 "case-128", 116 "err %d errno %d retval %d size %d expect-size %d\n", 117 err, errno, tattr.retval, tattr.data_size_out, max_grow); 118 119 /* Extra checks for data content: Count grow size, will contain zeros */ 120 for (i = 0, cnt = 0; i < sizeof(buf); i++) { 121 if (buf[i] == 0) 122 cnt++; 123 } 124 CHECK_ATTR((cnt != (max_grow - tattr.data_size_in)) /* Grow increase */ 125 || tattr.data_size_out != max_grow, /* Total grow size */ 126 "case-128-data", 127 "err %d errno %d retval %d size %d grow-size %d\n", 128 err, errno, tattr.retval, tattr.data_size_out, cnt); 129 130 bpf_object__close(obj); 131 } 132 133 void test_xdp_adjust_tail(void) 134 { 135 if (test__start_subtest("xdp_adjust_tail_shrink")) 136 test_xdp_adjust_tail_shrink(); 137 if (test__start_subtest("xdp_adjust_tail_grow")) 138 test_xdp_adjust_tail_grow(); 139 if (test__start_subtest("xdp_adjust_tail_grow2")) 140 test_xdp_adjust_tail_grow2(); 141 } 142