app/test/test_ipfrag.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2020 Red Hat, Inc.
   3  */
   4
   5 #include <time.h>
   6
   7 #include <rte_common.h>
   8 #include <rte_cycles.h>
   9 #include <rte_hexdump.h>
  10 #include <rte_ip.h>
  11 #include <rte_ip_frag.h>
  12 #include <rte_mbuf.h>
  13 #include <rte_memcpy.h>
  14 #include <rte_random.h>
  15
  16 #include "test.h"
  17
  18 #define NUM_MBUFS 128
  19 #define BURST 32
  20
  21 static struct rte_mempool *pkt_pool,
  22                           *direct_pool,
  23                           *indirect_pool;
  24
  25 static int
  26 setup_buf_pool(void)
  27 {
  28         pkt_pool = rte_pktmbuf_pool_create("FRAG_MBUF_POOL",
  29                                            NUM_MBUFS, BURST, 0,
  30                                            RTE_MBUF_DEFAULT_BUF_SIZE,
  31                                            SOCKET_ID_ANY);
  32         if (pkt_pool == NULL) {
  33                 printf("%s: Error creating pkt mempool\n", __func__);
  34                 goto bad_setup;
  35         }
  36
  37         direct_pool = rte_pktmbuf_pool_create("FRAG_D_MBUF_POOL",
  38                                               NUM_MBUFS, BURST, 0,
  39                                               RTE_MBUF_DEFAULT_BUF_SIZE,
  40                                               SOCKET_ID_ANY);
  41         if (direct_pool == NULL) {
  42                 printf("%s: Error creating direct mempool\n", __func__);
  43                 goto bad_setup;
  44         }
  45
  46         indirect_pool = rte_pktmbuf_pool_create("FRAG_I_MBUF_POOL",
  47                                                 NUM_MBUFS, BURST, 0,
  48                                                 0, SOCKET_ID_ANY);
  49         if (indirect_pool == NULL) {
  50                 printf("%s: Error creating indirect mempool\n", __func__);
  51                 goto bad_setup;
  52         }
  53
  54         return TEST_SUCCESS;
  55
  56 bad_setup:
  57         rte_mempool_free(pkt_pool);
  58         pkt_pool = NULL;
  59
  60         rte_mempool_free(direct_pool);
  61         direct_pool = NULL;
  62
  63         return TEST_FAILED;
  64 }
  65
  66 static int testsuite_setup(void)
  67 {
  68         return setup_buf_pool();
  69 }
  70
  71 static void testsuite_teardown(void)
  72 {
  73         rte_mempool_free(pkt_pool);
  74         rte_mempool_free(direct_pool);
  75         rte_mempool_free(indirect_pool);
  76
  77         pkt_pool = NULL;
  78         direct_pool = NULL;
  79         indirect_pool = NULL;
  80 }
  81
  82 static int ut_setup(void)
  83 {
  84         return TEST_SUCCESS;
  85 }
  86
  87 static void ut_teardown(void)
  88 {
  89 }
  90
  91 static void
  92 v4_allocate_packet_of(struct rte_mbuf *b, int fill,
  93                       size_t s, int df, uint8_t mf, uint16_t off,
  94                       uint8_t ttl, uint8_t proto, uint16_t pktid)
  95 {
  96         /* Create a packet, 2k bytes long */
  97         b->data_off = 0;
  98         char *data = rte_pktmbuf_mtod(b, char *);
  99         rte_be16_t fragment_offset = 0; /**< fragmentation offset */
 100
 101         memset(data, fill, sizeof(struct rte_ipv4_hdr) + s);
 102
 103         struct rte_ipv4_hdr *hdr = (struct rte_ipv4_hdr *)data;
 104
 105         hdr->version_ihl = 0x45; /* standard IP header... */
 106         hdr->type_of_service = 0;
 107         b->pkt_len = s + sizeof(struct rte_ipv4_hdr);
 108         b->data_len = b->pkt_len;
 109         hdr->total_length = rte_cpu_to_be_16(b->pkt_len);
 110         hdr->packet_id = rte_cpu_to_be_16(pktid);
 111
 112         if (df)
 113                 fragment_offset |= 0x4000;
 114
 115         if (mf)
 116                 fragment_offset |= 0x2000;
 117
 118         if (off)
 119                 fragment_offset |= off;
 120
 121         hdr->fragment_offset = rte_cpu_to_be_16(fragment_offset);
 122
 123         if (!ttl)
 124                 ttl = 64; /* default to 64 */
 125
 126         if (!proto)
 127                 proto = 1; /* icmp */
 128
 129         hdr->time_to_live = ttl;
 130         hdr->next_proto_id = proto;
 131         hdr->hdr_checksum = 0;
 132         hdr->src_addr = rte_cpu_to_be_32(0x8080808);
 133         hdr->dst_addr = rte_cpu_to_be_32(0x8080404);
 134 }
 135
 136 static void
 137 v6_allocate_packet_of(struct rte_mbuf *b, int fill, size_t s, uint8_t ttl,
 138                       uint8_t proto, uint16_t pktid)
 139 {
 140         /* Create a packet, 2k bytes long */
 141         b->data_off = 0;
 142         char *data = rte_pktmbuf_mtod(b, char *);
 143
 144         memset(data, fill, sizeof(struct rte_ipv6_hdr) + s);
 145
 146         struct rte_ipv6_hdr *hdr = (struct rte_ipv6_hdr *)data;
 147         b->pkt_len = s + sizeof(struct rte_ipv6_hdr);
 148         b->data_len = b->pkt_len;
 149
 150         /* basic v6 header */
 151         hdr->vtc_flow = rte_cpu_to_be_32(0x60 << 24 | pktid);
 152         hdr->payload_len = rte_cpu_to_be_16(b->pkt_len);
 153         hdr->proto = proto;
 154         hdr->hop_limits = ttl;
 155
 156         memset(hdr->src_addr, 0x08, sizeof(hdr->src_addr));
 157         memset(hdr->dst_addr, 0x04, sizeof(hdr->src_addr));
 158 }
 159
 160 static inline void
 161 test_free_fragments(struct rte_mbuf *mb[], uint32_t num)
 162 {
 163         uint32_t i;
 164         for (i = 0; i < num; i++)
 165                 rte_pktmbuf_free(mb[i]);
 166 }
 167
 168 static inline void
 169 test_get_offset(struct rte_mbuf **mb, int32_t len,
 170         uint16_t *offset, int ipv)
 171 {
 172         int32_t i;
 173
 174         for (i = 0; i < len; i++) {
 175                 if (ipv == 4) {
 176                         struct rte_ipv4_hdr *iph =
 177                             rte_pktmbuf_mtod(mb[i], struct rte_ipv4_hdr *);
 178                         offset[i] = iph->fragment_offset;
 179                 } else if (ipv == 6) {
 180                         struct ipv6_extension_fragment *fh =
 181                             rte_pktmbuf_mtod_offset(
 182                                         mb[i],
 183                                         struct ipv6_extension_fragment *,
 184                                         sizeof(struct rte_ipv6_hdr));
 185                         offset[i] = fh->frag_data;
 186                 }
 187         }
 188 }
 189
 190 static int
 191 test_ip_frag(void)
 192 {
 193         static const uint16_t RND_ID = UINT16_MAX;
 194         int result = TEST_SUCCESS;
 195         size_t i, j;
 196
 197         struct test_ip_frags {
 198                 int      ipv;
 199                 size_t   mtu_size;
 200                 size_t   pkt_size;
 201                 int      set_df;
 202                 uint8_t  set_mf;
 203                 uint16_t set_of;
 204                 uint8_t  ttl;
 205                 uint8_t  proto;
 206                 uint16_t pkt_id;
 207                 int      expected_frags;
 208                 uint16_t expected_fragment_offset[BURST];
 209         } tests[] = {
 210                  {4, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       2,
 211                   {0x2000, 0x009D}},
 212                  {4, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, 0,            2,
 213                   {0x2000, 0x009D}},
 214                  {4,  600, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       3,
 215                   {0x2000, 0x2048, 0x0090}},
 216                  {4, 4, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,    -EINVAL},
 217                  {4, 600, 1400, 1, 0, 0, 64, IPPROTO_ICMP, RND_ID, -ENOTSUP},
 218                  {4, 600, 1400, 0, 0, 0, 0, IPPROTO_ICMP, RND_ID,         3,
 219                   {0x2000, 0x2048, 0x0090}},
 220                  {4, 68, 104, 0, 1, 13, 0, IPPROTO_ICMP, RND_ID,          3,
 221                   {0x200D, 0x2013, 0x2019}},
 222
 223                  {6, 1280, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       2,
 224                   {0x0001, 0x04D0}},
 225                  {6, 1300, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,       2,
 226                   {0x0001, 0x04E0}},
 227                  {6, 4, 1400, 0, 0, 0, 64, IPPROTO_ICMP, RND_ID,    -EINVAL},
 228                  {6, 1300, 1400, 0, 0, 0, 0, IPPROTO_ICMP, RND_ID,        2,
 229                   {0x0001, 0x04E0}},
 230         };
 231
 232         for (i = 0; i < RTE_DIM(tests); i++) {
 233                 int32_t len = 0;
 234                 uint16_t fragment_offset[BURST];
 235                 uint16_t pktid = tests[i].pkt_id;
 236                 struct rte_mbuf *pkts_out[BURST];
 237                 struct rte_mbuf *b = rte_pktmbuf_alloc(pkt_pool);
 238
 239                 RTE_TEST_ASSERT_NOT_EQUAL(b, NULL,
 240                                           "Failed to allocate pkt.");
 241
 242                 if (tests[i].pkt_id == RND_ID)
 243                         pktid = rte_rand_max(UINT16_MAX);
 244
 245                 if (tests[i].ipv == 4) {
 246                         v4_allocate_packet_of(b, 0x41414141,
 247                                               tests[i].pkt_size,
 248                                               tests[i].set_df,
 249                                               tests[i].set_mf,
 250                                               tests[i].set_of,
 251                                               tests[i].ttl,
 252                                               tests[i].proto,
 253                                               pktid);
 254                 } else if (tests[i].ipv == 6) {
 255                         v6_allocate_packet_of(b, 0x41414141,
 256                                               tests[i].pkt_size,
 257                                               tests[i].ttl,
 258                                               tests[i].proto,
 259                                               pktid);
 260                 }
 261
 262                 if (tests[i].ipv == 4)
 263                         len = rte_ipv4_fragment_packet(b, pkts_out, BURST,
 264                                                        tests[i].mtu_size,
 265                                                        direct_pool,
 266                                                        indirect_pool);
 267                 else if (tests[i].ipv == 6)
 268                         len = rte_ipv6_fragment_packet(b, pkts_out, BURST,
 269                                                        tests[i].mtu_size,
 270                                                        direct_pool,
 271                                                        indirect_pool);
 272
 273                 rte_pktmbuf_free(b);
 274
 275                 if (len > 0) {
 276                         test_get_offset(pkts_out, len,
 277                             fragment_offset, tests[i].ipv);
 278                         test_free_fragments(pkts_out, len);
 279                 }
 280
 281                 printf("%zd: checking %d with %d\n", i, len,
 282                        tests[i].expected_frags);
 283                 RTE_TEST_ASSERT_EQUAL(len, tests[i].expected_frags,
 284                                       "Failed case %zd.\n", i);
 285
 286                 if (len > 0) {
 287                         for (j = 0; j < (size_t)len; j++) {
 288                                 printf("%zd-%zd: checking %d with %d\n",
 289                                     i, j, fragment_offset[j],
 290                                     rte_cpu_to_be_16(
 291                                         tests[i].expected_fragment_offset[j]));
 292                                 RTE_TEST_ASSERT_EQUAL(fragment_offset[j],
 293                                     rte_cpu_to_be_16(
 294                                         tests[i].expected_fragment_offset[j]),
 295                                     "Failed case %zd.\n", i);
 296                         }
 297                 }
 298
 299         }
 300
 301         return result;
 302 }
 303
 304 static struct unit_test_suite ipfrag_testsuite  = {
 305         .suite_name = "IP Frag Unit Test Suite",
 306         .setup = testsuite_setup,
 307         .teardown = testsuite_teardown,
 308         .unit_test_cases = {
 309                 TEST_CASE_ST(ut_setup, ut_teardown,
 310                              test_ip_frag),
 311
 312                 TEST_CASES_END() /**< NULL terminate unit test array */
 313         }
 314 };
 315
 316 static int
 317 test_ipfrag(void)
 318 {
 319         rte_log_set_global_level(RTE_LOG_DEBUG);
 320         rte_log_set_level(RTE_LOGTYPE_EAL, RTE_LOG_DEBUG);
 321
 322         return unit_test_suite_runner(&ipfrag_testsuite);
 323 }
 324
 325 REGISTER_TEST_COMMAND(ipfrag_autotest, test_ipfrag);