app/test/test_ipfrag.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Red Hat, Inc.
   3  */
   4
   5 #include "test.h"
   6
   7 #include <time.h>
   8
   9 #include <rte_common.h>
  10 #include <rte_cycles.h>
  11 #include <rte_hexdump.h>
  12 #include <rte_ip.h>
  13
  14 #ifdef RTE_EXEC_ENV_WINDOWS
  15 static int
  16 test_ipfrag(void)
  17 {
  18         printf("ipfrag not supported on Windows, skipping test\n");
  19         return TEST_SKIPPED;
  20 }
  21
  22 #else
  23
  24 #include <rte_ip_frag.h>
  25 #include <rte_mbuf.h>
  26 #include <rte_memcpy.h>
  27 #include <rte_random.h>
  28
  29 #define NUM_MBUFS 128
  30 #define BURST 32
  31
  32 uint8_t expected_first_frag_ipv4_opts_copied[] = {
  33         0x07, 0x0b, 0x04, 0x00,
  34         0x00, 0x00, 0x00, 0x00,
  35         0x00, 0x00, 0x00, 0x83,
  36         0x07, 0x04, 0xc0, 0xa8,
  37         0xe3, 0x96, 0x00, 0x00,
  38 };
  39
  40 uint8_t expected_sub_frag_ipv4_opts_copied[] = {
  41         0x83, 0x07, 0x04, 0xc0,
  42         0xa8, 0xe3, 0x96, 0x00,
  43 };
  44
  45 uint8_t expected_first_frag_ipv4_opts_nocopied[] = {
  46         0x07, 0x0b, 0x04, 0x00,
  47         0x00, 0x00, 0x00, 0x00,
  48         0x00, 0x00, 0x00, 0x00,
  49 };
  50
  51 uint8_t expected_sub_frag_ipv4_opts_nocopied[0];
  52
  53 struct test_opt_data {
  54         bool is_first_frag;              /**< offset is 0 */
  55         bool opt_copied;                 /**< ip option copied flag */
  56         uint16_t len;                    /**< option data len */
  57         uint8_t data[RTE_IPV4_HDR_OPT_MAX_LEN]; /**< option data */
  58 };
  59
  60 static struct rte_mempool *pkt_pool,
  61                           *direct_pool,
  62                           *indirect_pool;
  63
  64 static inline void
  65 hex_to_str(uint8_t *hex, uint16_t len, char *str)
  66 {
  67         int i;
  68
  69         for (i = 0; i < len; i++) {
  70                 sprintf(str, "%02x", hex[i]);
  71                 str += 2;
  72         }
  73         *str = 0;
  74 }
  75
  76 static int
  77 setup_buf_pool(void)
  78 {
  79         pkt_pool = rte_pktmbuf_pool_create("FRAG_MBUF_POOL",
  80                                            NUM_MBUFS, BURST, 0,
  81                                            RTE_MBUF_DEFAULT_BUF_SIZE,
  82                                            SOCKET_ID_ANY);
  83         if (pkt_pool == NULL) {
  84                 printf("%s: Error creating pkt mempool\n", __func__);
  85                 goto bad_setup;
  86         }
  87
  88         direct_pool = rte_pktmbuf_pool_create("FRAG_D_MBUF_POOL",
  89                                               NUM_MBUFS, BURST, 0,
  90                                               RTE_MBUF_DEFAULT_BUF_SIZE,
  91                                               SOCKET_ID_ANY);
  92         if (direct_pool == NULL) {
  93                 printf("%s: Error creating direct mempool\n", __func__);
  94                 goto bad_setup;
  95         }
  96
  97         indirect_pool = rte_pktmbuf_pool_create("FRAG_I_MBUF_POOL",
  98                                                 NUM_MBUFS, BURST, 0,
  99                                                 0, SOCKET_ID_ANY);
 100         if (indirect_pool == NULL) {
 101                 printf("%s: Error creating indirect mempool\n", __func__);
 102                 goto bad_setup;
 103         }
 104
 105         return TEST_SUCCESS;
 106
 107 bad_setup:
 108         rte_mempool_free(pkt_pool);
 109         pkt_pool = NULL;
 110
 111         rte_mempool_free(direct_pool);
 112         direct_pool = NULL;
 113
 114         return TEST_FAILED;
 115 }
 116
 117 static int testsuite_setup(void)
 118 {
 119         return setup_buf_pool();
 120 }
 121
 122 static void testsuite_teardown(void)
 123 {
 124         rte_mempool_free(pkt_pool);
 125         rte_mempool_free(direct_pool);
 126         rte_mempool_free(indirect_pool);
 127
 128         pkt_pool = NULL;
 129         direct_pool = NULL;
 130         indirect_pool = NULL;
 131 }
 132
 133 static int ut_setup(void)
 134 {
 135         return TEST_SUCCESS;
 136 }
 137
 138 static void ut_teardown(void)
 139 {
 140 }
 141
 142 static inline void
 143 test_get_ipv4_opt(bool is_first_frag, bool opt_copied,
 144         struct test_opt_data *expected_opt)
 145 {
 146         if (is_first_frag) {
 147                 if (opt_copied) {
 148                         expected_opt->len =
 149                                 sizeof(expected_first_frag_ipv4_opts_copied);
 150                         rte_memcpy(expected_opt->data,
 151                                 expected_first_frag_ipv4_opts_copied,
 152                                 sizeof(expected_first_frag_ipv4_opts_copied));
 153                 } else {
 154                         expected_opt->len =
 155                                 sizeof(expected_first_frag_ipv4_opts_nocopied);
 156                         rte_memcpy(expected_opt->data,
 157                                 expected_first_frag_ipv4_opts_nocopied,
 158                                 sizeof(expected_first_frag_ipv4_opts_nocopied));
 159                 }
 160         } else {
 161                 if (opt_copied) {
 162                         expected_opt->len =
 163                                 sizeof(expected_sub_frag_ipv4_opts_copied);
 164                         rte_memcpy(expected_opt->data,
 165                                 expected_sub_frag_ipv4_opts_copied,
 166                                 sizeof(expected_sub_frag_ipv4_opts_copied));
 167                 } else {
 168                         expected_opt->len =
 169                                 sizeof(expected_sub_frag_ipv4_opts_nocopied);
 170                         rte_memcpy(expected_opt->data,
 171                                 expected_sub_frag_ipv4_opts_nocopied,
 172                                 sizeof(expected_sub_frag_ipv4_opts_nocopied));
 173                 }
 174         }
 175 }
 176
 177 static void
 178 v4_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s,
 179         int df, uint8_t mf, uint16_t off, uint8_t ttl, uint8_t proto,
 180         uint16_t pktid, bool have_opt, bool is_first_frag, bool opt_copied)
 181 {
 182         /* Create a packet, 2k bytes long */
 183         b->data_off = 0;
 184         char *data = rte_pktmbuf_mtod(b, char *);
 185         rte_be16_t fragment_offset = 0; /* fragmentation offset */
 186         uint16_t iph_len;
 187         struct test_opt_data opt;
 188
 189         opt.len = 0;
 190
 191         if (have_opt)
 192                 test_get_ipv4_opt(is_first_frag, opt_copied, &opt);
 193
 194         iph_len = sizeof(struct rte_ipv4_hdr) + opt.len;
 195         memset(data, fill, iph_len + s);
 196
 197         struct rte_ipv4_hdr *hdr = (struct rte_ipv4_hdr *)data;
 198
 199         hdr->version_ihl = 0x40; /* ipv4 */
 200         hdr->version_ihl += (iph_len / 4);
 201         hdr->type_of_service = 0;
 202         b->pkt_len = s + iph_len;
 203         b->data_len = b->pkt_len;
 204         hdr->total_length = rte_cpu_to_be_16(b->pkt_len);
 205         hdr->packet_id = rte_cpu_to_be_16(pktid);
 206
 207         if (df)
 208                 fragment_offset |= 0x4000;
 209
 210         if (mf)
 211                 fragment_offset |= 0x2000;
 212
 213         if (off)
 214                 fragment_offset |= off;
 215
 216         hdr->fragment_offset = rte_cpu_to_be_16(fragment_offset);
 217
 218         if (!ttl)
 219                 ttl = 64; /* default to 64 */
 220
 221         if (!proto)
 222                 proto = 1; /* icmp */
 223
 224         hdr->time_to_live = ttl;
 225         hdr->next_proto_id = proto;
 226         hdr->hdr_checksum = 0;
 227         hdr->src_addr = rte_cpu_to_be_32(0x8080808);
 228         hdr->dst_addr = rte_cpu_to_be_32(0x8080404);
 229
 230         rte_memcpy(hdr + 1, opt.data, opt.len);
 231 }
 232
 233 static void
 234 v6_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s, uint8_t ttl,
 235                       uint8_t proto, uint16_t pktid)
 236 {
 237         /* Create a packet, 2k bytes long */
 238         b->data_off = 0;
 239         char *data = rte_pktmbuf_mtod(b, char *);
 240
 241         memset(data, fill, sizeof(struct rte_ipv6_hdr) + s);
 242
 243         struct rte_ipv6_hdr *hdr = (struct rte_ipv6_hdr *)data;
 244         b->pkt_len = s + sizeof(struct rte_ipv6_hdr);
 245         b->data_len = b->pkt_len;
 246
 247         /* basic v6 header */
 248         hdr->vtc_flow = rte_cpu_to_be_32(0x60 << 24 | pktid);
 249         hdr->payload_len = rte_cpu_to_be_16(b->pkt_len);
 250         hdr->proto = proto;
 251         hdr->hop_limits = ttl;
 252
 253         memset(hdr->src_addr, 0x08, sizeof(hdr->src_addr));
 254         memset(hdr->dst_addr, 0x04, sizeof(hdr->src_addr));
 255 }
 256
 257 static inline void
 258 test_free_fragments(struct rte_mbuf *mb[], uint32_t num)
 259 {
 260         uint32_t i;
 261         for (i = 0; i < num; i++)
 262                 rte_pktmbuf_free(mb[i]);
 263 }
 264
 265 static inline void
 266 test_get_offset(struct rte_mbuf **mb, int32_t len,
 267         uint16_t *offset, int ipv)
 268 {
 269         int32_t i;
 270
 271         for (i = 0; i < len; i++) {
 272                 if (ipv == 4) {
 273                         struct rte_ipv4_hdr *iph =
 274                             rte_pktmbuf_mtod(mb[i], struct rte_ipv4_hdr *);
 275                         offset[i] = iph->fragment_offset;
 276                 } else if (ipv == 6) {
 277                         struct ipv6_extension_fragment *fh =
 278                             rte_pktmbuf_mtod_offset(
 279                                         mb[i],
 280                                         struct ipv6_extension_fragment *,
 281                                         sizeof(struct rte_ipv6_hdr));
 282                         offset[i] = fh->frag_data;
 283                 }
 284         }
 285 }
 286
 287 static inline void
 288 test_get_frag_opt(struct rte_mbuf **mb, int32_t num,
 289         struct test_opt_data *opt, int ipv, bool opt_copied)
 290 {
 291         int32_t i;
 292
 293         for (i = 0; i < num; i++) {
 294                 if (ipv == 4) {
 295                         struct rte_ipv4_hdr *iph =
 296                             rte_pktmbuf_mtod(mb[i], struct rte_ipv4_hdr *);
 297                         uint16_t header_len = (iph->version_ihl &
 298                                 RTE_IPV4_HDR_IHL_MASK) *
 299                                 RTE_IPV4_IHL_MULTIPLIER;
 300                         uint16_t opt_len = header_len -
 301                                 sizeof(struct rte_ipv4_hdr);
 302
 303                         opt->opt_copied = opt_copied;
 304
 305                         if ((rte_be_to_cpu_16(iph->fragment_offset) &
 306                                     RTE_IPV4_HDR_OFFSET_MASK) == 0)
 307                                 opt->is_first_frag = true;
 308                         else
 309                                 opt->is_first_frag = false;
 310
 311                         if (likely(opt_len <= RTE_IPV4_HDR_OPT_MAX_LEN)) {
 312                                 char *iph_opt = rte_pktmbuf_mtod_offset(mb[i],
 313                                     char *, sizeof(struct rte_ipv4_hdr));
 314                                 opt->len = opt_len;
 315                                 rte_memcpy(opt->data, iph_opt, opt_len);
 316                         } else {
 317                                 opt->len = RTE_IPV4_HDR_OPT_MAX_LEN;
 318                                 memset(opt->data, RTE_IPV4_HDR_OPT_EOL,
 319                                     sizeof(opt->data));
 320                         }
 321                         opt++;
 322                 }
 323         }
 324 }
 325
 326 static int
 327 test_ip_frag(void)
 328 {
 329         static const uint16_t RND_ID = UINT16_MAX;
 330         int result = TEST_SUCCESS;
 331         size_t i, j;
 332
 333         struct test_ip_frags {
 334                 int      ipv;
 335                 size_t   mtu_size;
 336                 size_t   pkt_size;
 337                 int      set_df;
 338                 uint8_t  set_mf;
 339                 uint16_t set_of;
 340                 uint8_t  ttl;
 341                 uint8_t  proto;
 342                 uint16_t pkt_id;
 343                 int      expected_frags;
 344                 uint16_t expected_fragment_offset[BURST];
 345                 bool have_opt;
 346                 bool is_first_frag;
 347                 bool opt_copied;
 348         } tests[] = {
 349                  {4, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       2,
 350                   {0x2000, 0x009D}, false},
 351                  {4, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, 0,            2,
 352                   {0x2000, 0x009D}, false},
 353                  {4,  600, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       3,
 354                   {0x2000, 0x2048, 0x0090}, false},
 355                  {4, 4, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,    -EINVAL},
 356                  {4, 600, 1400, 1, 0, 0, 64, IPPROTO_ICMP, RND_ID, -ENOTSUP},
 357                  {4, 600, 1400, 0, 0, 0, 0, IPPROTO_ICMP, RND_ID,         3,
 358                   {0x2000, 0x2046, 0x008C}, true, true, true},
 359                  /* The first fragment */
 360                  {4, 68, 104, 0, 1, 0, 0, IPPROTO_ICMP, RND_ID,           5,
 361                   {0x2000, 0x2003, 0x2006, 0x2009, 0x200C}, true, true, true},
 362                  /* The middle fragment */
 363                  {4, 68, 104, 0, 1, 13, 0, IPPROTO_ICMP, RND_ID,          3,
 364                   {0x200D, 0x2012, 0x2017}, true, false, true},
 365                  /* The last fragment */
 366                  {4, 68, 104, 0, 0, 26, 0, IPPROTO_ICMP, RND_ID,          3,
 367                   {0x201A, 0x201F, 0x0024}, true, false, true},
 368                  /* The first fragment */
 369                  {4, 68, 104, 0, 1, 0, 0, IPPROTO_ICMP, RND_ID,           4,
 370                   {0x2000, 0x2004, 0x2008, 0x200C}, true, true, false},
 371                  /* The middle fragment */
 372                  {4, 68, 104, 0, 1, 13, 0, IPPROTO_ICMP, RND_ID,          3,
 373                   {0x200D, 0x2013, 0x2019}, true, false, false},
 374                  /* The last fragment */
 375                  {4, 68, 104, 0, 0, 26, 0, IPPROTO_ICMP, RND_ID,          3,
 376                   {0x201A, 0x2020, 0x0026}, true, false, false},
 377                  {6, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       2,
 378                   {0x0001, 0x04D0}, false},
 379                  {6, 1300, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       2,
 380                   {0x0001, 0x04E0}, false},
 381                  {6, 4, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,    -EINVAL},
 382                  {6, 1300, 1400, 0, 0, 0, 0, IPPROTO_ICMP, RND_ID,        2,
 383                   {0x0001, 0x04E0}, false},
 384         };
 385
 386         for (i = 0; i < RTE_DIM(tests); i++) {
 387                 int32_t len = 0;
 388                 uint16_t fragment_offset[BURST];
 389                 struct test_opt_data opt_res[BURST];
 390                 struct test_opt_data opt_exp;
 391                 uint16_t pktid = tests[i].pkt_id;
 392                 struct rte_mbuf *pkts_out[BURST];
 393                 struct rte_mbuf *b = rte_pktmbuf_alloc(pkt_pool);
 394
 395                 RTE_TEST_ASSERT_NOT_EQUAL(b, NULL,
 396                                           "Failed to allocate pkt.");
 397
 398                 if (tests[i].pkt_id == RND_ID)
 399                         pktid = rte_rand_max(UINT16_MAX);
 400
 401                 if (tests[i].ipv == 4) {
 402                         v4_allocate_packet_of(b, 0x41414141,
 403                                               tests[i].pkt_size,
 404                                               tests[i].set_df,
 405                                               tests[i].set_mf,
 406                                               tests[i].set_of,
 407                                               tests[i].ttl,
 408                                               tests[i].proto,
 409                                               pktid,
 410                                               tests[i].have_opt,
 411                                               tests[i].is_first_frag,
 412                                               tests[i].opt_copied);
 413                 } else if (tests[i].ipv == 6) {
 414                         v6_allocate_packet_of(b, 0x41414141,
 415                                               tests[i].pkt_size,
 416                                               tests[i].ttl,
 417                                               tests[i].proto,
 418                                               pktid);
 419                 }
 420
 421                 if (tests[i].ipv == 4)
 422                         len = rte_ipv4_fragment_packet(b, pkts_out, BURST,
 423                                                        tests[i].mtu_size,
 424                                                        direct_pool,
 425                                                        indirect_pool);
 426                 else if (tests[i].ipv == 6)
 427                         len = rte_ipv6_fragment_packet(b, pkts_out, BURST,
 428                                                        tests[i].mtu_size,
 429                                                        direct_pool,
 430                                                        indirect_pool);
 431
 432                 rte_pktmbuf_free(b);
 433
 434                 if (len > 0) {
 435                         test_get_offset(pkts_out, len,
 436                             fragment_offset, tests[i].ipv);
 437                         if (tests[i].have_opt)
 438                                 test_get_frag_opt(pkts_out, len, opt_res,
 439                                         tests[i].ipv, tests[i].opt_copied);
 440                         test_free_fragments(pkts_out, len);
 441                 }
 442
 443                 printf("[check frag number]%zd: checking %d with %d\n", i, len,
 444                        tests[i].expected_frags);
 445                 RTE_TEST_ASSERT_EQUAL(len, tests[i].expected_frags,
 446                                       "Failed case %zd.\n", i);
 447
 448                 if (len > 0) {
 449                         for (j = 0; j < (size_t)len; j++) {
 450                                 printf("[check offset]%zd-%zd: checking %d with %d\n",
 451                                     i, j, fragment_offset[j],
 452                                     rte_cpu_to_be_16(
 453                                         tests[i].expected_fragment_offset[j]));
 454                                 RTE_TEST_ASSERT_EQUAL(fragment_offset[j],
 455                                     rte_cpu_to_be_16(
 456                                         tests[i].expected_fragment_offset[j]),
 457                                     "Failed case %zd.\n", i);
 458                         }
 459
 460                         if (tests[i].have_opt && (tests[i].ipv == 4)) {
 461                                 for (j = 0; j < (size_t)len; j++) {
 462                                         char opt_res_str[2 *
 463                                                 RTE_IPV4_HDR_OPT_MAX_LEN + 1];
 464                                         char opt_exp_str[2 *
 465                                                 RTE_IPV4_HDR_OPT_MAX_LEN + 1];
 466
 467                                         test_get_ipv4_opt(
 468                                                 opt_res[j].is_first_frag,
 469                                                 opt_res[j].opt_copied,
 470                                                 &opt_exp);
 471                                         hex_to_str(opt_res[j].data,
 472                                                 opt_res[j].len,
 473                                                 opt_res_str);
 474                                         hex_to_str(opt_exp.data,
 475                                                 opt_exp.len,
 476                                                 opt_exp_str);
 477
 478                                         printf(
 479                                                 "[check ipv4 option]%zd-%zd: checking (len:%u)%s with (len:%u)%s\n",
 480                                                 i, j,
 481                                                 opt_res[j].len, opt_res_str,
 482                                                 opt_exp.len, opt_exp_str);
 483                                                 RTE_TEST_ASSERT_SUCCESS(
 484                                                         strcmp(opt_res_str,
 485                                                                 opt_exp_str),
 486                                                 "Failed case %zd.\n", i);
 487                                 }
 488                         }
 489                 }
 490
 491         }
 492
 493         return result;
 494 }
 495
 496 static struct unit_test_suite ipfrag_testsuite  = {
 497         .suite_name = "IP Frag Unit Test Suite",
 498         .setup = testsuite_setup,
 499         .teardown = testsuite_teardown,
 500         .unit_test_cases = {
 501                 TEST_CASE_ST(ut_setup, ut_teardown,
 502                              test_ip_frag),
 503
 504                 TEST_CASES_END() /**< NULL terminate unit test array */
 505         }
 506 };
 507
 508 static int
 509 test_ipfrag(void)
 510 {
 511         rte_log_set_global_level(RTE_LOG_DEBUG);
 512         rte_log_set_level(RTE_LOGTYPE_EAL, RTE_LOG_DEBUG);
 513
 514         return unit_test_suite_runner(&ipfrag_testsuite);
 515 }
 516
 517 #endif /* !RTE_EXEC_ENV_WINDOWS */
 518
 519 REGISTER_TEST_COMMAND(ipfrag_autotest, test_ipfrag);