net/core/gso_test.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <kunit/test.h>
   4 #include <linux/skbuff.h>
   5
   6 static const char hdr[] = "abcdefgh";
   7 #define GSO_TEST_SIZE 1000
   8
   9 static void __init_skb(struct sk_buff *skb)
  10 {
  11         skb_reset_mac_header(skb);
  12         memcpy(skb_mac_header(skb), hdr, sizeof(hdr));
  13
  14         /* skb_segment expects skb->data at start of payload */
  15         skb_pull(skb, sizeof(hdr));
  16         skb_reset_network_header(skb);
  17         skb_reset_transport_header(skb);
  18
  19         /* proto is arbitrary, as long as not ETH_P_TEB or vlan */
  20         skb->protocol = htons(ETH_P_ATALK);
  21         skb_shinfo(skb)->gso_size = GSO_TEST_SIZE;
  22 }
  23
  24 enum gso_test_nr {
  25         GSO_TEST_LINEAR,
  26         GSO_TEST_NO_GSO,
  27         GSO_TEST_FRAGS,
  28         GSO_TEST_FRAGS_PURE,
  29         GSO_TEST_GSO_PARTIAL,
  30         GSO_TEST_FRAG_LIST,
  31         GSO_TEST_FRAG_LIST_PURE,
  32         GSO_TEST_FRAG_LIST_NON_UNIFORM,
  33         GSO_TEST_GSO_BY_FRAGS,
  34 };
  35
  36 struct gso_test_case {
  37         enum gso_test_nr id;
  38         const char *name;
  39
  40         /* input */
  41         unsigned int linear_len;
  42         unsigned int nr_frags;
  43         const unsigned int *frags;
  44         unsigned int nr_frag_skbs;
  45         const unsigned int *frag_skbs;
  46
  47         /* output as expected */
  48         unsigned int nr_segs;
  49         const unsigned int *segs;
  50 };
  51
  52 static struct gso_test_case cases[] = {
  53         {
  54                 .id = GSO_TEST_NO_GSO,
  55                 .name = "no_gso",
  56                 .linear_len = GSO_TEST_SIZE,
  57                 .nr_segs = 1,
  58                 .segs = (const unsigned int[]) { GSO_TEST_SIZE },
  59         },
  60         {
  61                 .id = GSO_TEST_LINEAR,
  62                 .name = "linear",
  63                 .linear_len = GSO_TEST_SIZE + GSO_TEST_SIZE + 1,
  64                 .nr_segs = 3,
  65                 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 },
  66         },
  67         {
  68                 .id = GSO_TEST_FRAGS,
  69                 .name = "frags",
  70                 .linear_len = GSO_TEST_SIZE,
  71                 .nr_frags = 2,
  72                 .frags = (const unsigned int[]) { GSO_TEST_SIZE, 1 },
  73                 .nr_segs = 3,
  74                 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 1 },
  75         },
  76         {
  77                 .id = GSO_TEST_FRAGS_PURE,
  78                 .name = "frags_pure",
  79                 .nr_frags = 3,
  80                 .frags = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 },
  81                 .nr_segs = 3,
  82                 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, 2 },
  83         },
  84         {
  85                 .id = GSO_TEST_GSO_PARTIAL,
  86                 .name = "gso_partial",
  87                 .linear_len = GSO_TEST_SIZE,
  88                 .nr_frags = 2,
  89                 .frags = (const unsigned int[]) { GSO_TEST_SIZE, 3 },
  90                 .nr_segs = 2,
  91                 .segs = (const unsigned int[]) { 2 * GSO_TEST_SIZE, 3 },
  92         },
  93         {
  94                 /* commit 89319d3801d1: frag_list on mss boundaries */
  95                 .id = GSO_TEST_FRAG_LIST,
  96                 .name = "frag_list",
  97                 .linear_len = GSO_TEST_SIZE,
  98                 .nr_frag_skbs = 2,
  99                 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },
 100                 .nr_segs = 3,
 101                 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE },
 102         },
 103         {
 104                 .id = GSO_TEST_FRAG_LIST_PURE,
 105                 .name = "frag_list_pure",
 106                 .nr_frag_skbs = 2,
 107                 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },
 108                 .nr_segs = 2,
 109                 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE },
 110         },
 111         {
 112                 /* commit 43170c4e0ba7: GRO of frag_list trains */
 113                 .id = GSO_TEST_FRAG_LIST_NON_UNIFORM,
 114                 .name = "frag_list_non_uniform",
 115                 .linear_len = GSO_TEST_SIZE,
 116                 .nr_frag_skbs = 4,
 117                 .frag_skbs = (const unsigned int[]) { GSO_TEST_SIZE, 1, GSO_TEST_SIZE, 2 },
 118                 .nr_segs = 4,
 119                 .segs = (const unsigned int[]) { GSO_TEST_SIZE, GSO_TEST_SIZE, GSO_TEST_SIZE, 3 },
 120         },
 121         {
 122                 /* commit 3953c46c3ac7 ("sk_buff: allow segmenting based on frag sizes") and
 123                  * commit 90017accff61 ("sctp: Add GSO support")
 124                  *
 125                  * "there will be a cover skb with protocol headers and
 126                  *  children ones containing the actual segments"
 127                  */
 128                 .id = GSO_TEST_GSO_BY_FRAGS,
 129                 .name = "gso_by_frags",
 130                 .nr_frag_skbs = 4,
 131                 .frag_skbs = (const unsigned int[]) { 100, 200, 300, 400 },
 132                 .nr_segs = 4,
 133                 .segs = (const unsigned int[]) { 100, 200, 300, 400 },
 134         },
 135 };
 136
 137 static void gso_test_case_to_desc(struct gso_test_case *t, char *desc)
 138 {
 139         sprintf(desc, "%s", t->name);
 140 }
 141
 142 KUNIT_ARRAY_PARAM(gso_test, cases, gso_test_case_to_desc);
 143
 144 static void gso_test_func(struct kunit *test)
 145 {
 146         const int shinfo_size = SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 147         struct sk_buff *skb, *segs, *cur, *next, *last;
 148         const struct gso_test_case *tcase;
 149         netdev_features_t features;
 150         struct page *page;
 151         int i;
 152
 153         tcase = test->param_value;
 154
 155         page = alloc_page(GFP_KERNEL);
 156         KUNIT_ASSERT_NOT_NULL(test, page);
 157         skb = build_skb(page_address(page), sizeof(hdr) + tcase->linear_len + shinfo_size);
 158         KUNIT_ASSERT_NOT_NULL(test, skb);
 159         __skb_put(skb, sizeof(hdr) + tcase->linear_len);
 160
 161         __init_skb(skb);
 162
 163         if (tcase->nr_frags) {
 164                 unsigned int pg_off = 0;
 165
 166                 page = alloc_page(GFP_KERNEL);
 167                 KUNIT_ASSERT_NOT_NULL(test, page);
 168                 page_ref_add(page, tcase->nr_frags - 1);
 169
 170                 for (i = 0; i < tcase->nr_frags; i++) {
 171                         skb_fill_page_desc(skb, i, page, pg_off, tcase->frags[i]);
 172                         pg_off += tcase->frags[i];
 173                 }
 174
 175                 KUNIT_ASSERT_LE(test, pg_off, PAGE_SIZE);
 176
 177                 skb->data_len = pg_off;
 178                 skb->len += skb->data_len;
 179                 skb->truesize += skb->data_len;
 180         }
 181
 182         if (tcase->frag_skbs) {
 183                 unsigned int total_size = 0, total_true_size = 0;
 184                 struct sk_buff *frag_skb, *prev = NULL;
 185
 186                 for (i = 0; i < tcase->nr_frag_skbs; i++) {
 187                         unsigned int frag_size;
 188
 189                         page = alloc_page(GFP_KERNEL);
 190                         KUNIT_ASSERT_NOT_NULL(test, page);
 191
 192                         frag_size = tcase->frag_skbs[i];
 193                         frag_skb = build_skb(page_address(page),
 194                                              frag_size + shinfo_size);
 195                         KUNIT_ASSERT_NOT_NULL(test, frag_skb);
 196                         __skb_put(frag_skb, frag_size);
 197
 198                         if (prev)
 199                                 prev->next = frag_skb;
 200                         else
 201                                 skb_shinfo(skb)->frag_list = frag_skb;
 202                         prev = frag_skb;
 203
 204                         total_size += frag_size;
 205                         total_true_size += frag_skb->truesize;
 206                 }
 207
 208                 skb->len += total_size;
 209                 skb->data_len += total_size;
 210                 skb->truesize += total_true_size;
 211
 212                 if (tcase->id == GSO_TEST_GSO_BY_FRAGS)
 213                         skb_shinfo(skb)->gso_size = GSO_BY_FRAGS;
 214         }
 215
 216         features = NETIF_F_SG | NETIF_F_HW_CSUM;
 217         if (tcase->id == GSO_TEST_GSO_PARTIAL)
 218                 features |= NETIF_F_GSO_PARTIAL;
 219
 220         /* TODO: this should also work with SG,
 221          * rather than hit BUG_ON(i >= nfrags)
 222          */
 223         if (tcase->id == GSO_TEST_FRAG_LIST_NON_UNIFORM)
 224                 features &= ~NETIF_F_SG;
 225
 226         segs = skb_segment(skb, features);
 227         if (IS_ERR(segs)) {
 228                 KUNIT_FAIL(test, "segs error %pe", segs);
 229                 goto free_gso_skb;
 230         } else if (!segs) {
 231                 KUNIT_FAIL(test, "no segments");
 232                 goto free_gso_skb;
 233         }
 234
 235         last = segs->prev;
 236         for (cur = segs, i = 0; cur; cur = next, i++) {
 237                 next = cur->next;
 238
 239                 KUNIT_ASSERT_EQ(test, cur->len, sizeof(hdr) + tcase->segs[i]);
 240
 241                 /* segs have skb->data pointing to the mac header */
 242                 KUNIT_ASSERT_PTR_EQ(test, skb_mac_header(cur), cur->data);
 243                 KUNIT_ASSERT_PTR_EQ(test, skb_network_header(cur), cur->data + sizeof(hdr));
 244
 245                 /* header was copied to all segs */
 246                 KUNIT_ASSERT_EQ(test, memcmp(skb_mac_header(cur), hdr, sizeof(hdr)), 0);
 247
 248                 /* last seg can be found through segs->prev pointer */
 249                 if (!next)
 250                         KUNIT_ASSERT_PTR_EQ(test, cur, last);
 251
 252                 consume_skb(cur);
 253         }
 254
 255         KUNIT_ASSERT_EQ(test, i, tcase->nr_segs);
 256
 257 free_gso_skb:
 258         consume_skb(skb);
 259 }
 260
 261 static struct kunit_case gso_test_cases[] = {
 262         KUNIT_CASE_PARAM(gso_test_func, gso_test_gen_params),
 263         {}
 264 };
 265
 266 static struct kunit_suite gso_test_suite = {
 267         .name = "net_core_gso",
 268         .test_cases = gso_test_cases,
 269 };
 270
 271 kunit_test_suite(gso_test_suite);
 272
 273 MODULE_LICENSE("GPL");
 274 MODULE_DESCRIPTION("KUnit tests for segmentation offload");