app/test/test_mempool.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <stdint.h>
   9 #include <inttypes.h>
  10 #include <stdarg.h>
  11 #include <errno.h>
  12 #include <sys/queue.h>
  13
  14 #include <rte_common.h>
  15 #include <rte_eal_paging.h>
  16 #include <rte_log.h>
  17 #include <rte_debug.h>
  18 #include <rte_errno.h>
  19 #include <rte_memory.h>
  20 #include <rte_launch.h>
  21 #include <rte_cycles.h>
  22 #include <rte_eal.h>
  23 #include <rte_per_lcore.h>
  24 #include <rte_lcore.h>
  25 #include <rte_branch_prediction.h>
  26 #include <rte_mempool.h>
  27 #include <rte_spinlock.h>
  28 #include <rte_malloc.h>
  29 #include <rte_mbuf_pool_ops.h>
  30 #include <rte_mbuf.h>
  31
  32 #include "test.h"
  33
  34 /*
  35  * Mempool
  36  * =======
  37  *
  38  * Basic tests: done on one core with and without cache:
  39  *
  40  *    - Get one object, put one object
  41  *    - Get two objects, put two objects
  42  *    - Get all objects, test that their content is not modified and
  43  *      put them back in the pool.
  44  */
  45
  46 #define MEMPOOL_ELT_SIZE 2048
  47 #define MAX_KEEP 16
  48 #define MEMPOOL_SIZE ((rte_lcore_count()*(MAX_KEEP+RTE_MEMPOOL_CACHE_MAX_SIZE))-1)
  49
  50 #define LOG_ERR() printf("test failed at %s():%d\n", __func__, __LINE__)
  51 #define RET_ERR() do {                                                  \
  52                 LOG_ERR();                                              \
  53                 return -1;                                              \
  54         } while (0)
  55 #define GOTO_ERR(var, label) do {                                       \
  56                 LOG_ERR();                                              \
  57                 var = -1;                                               \
  58                 goto label;                                             \
  59         } while (0)
  60
  61 /*
  62  * save the object number in the first 4 bytes of object data. All
  63  * other bytes are set to 0.
  64  */
  65 static void
  66 my_obj_init(struct rte_mempool *mp, __rte_unused void *arg,
  67             void *obj, unsigned i)
  68 {
  69         uint32_t *objnum = obj;
  70
  71         memset(obj, 0, mp->elt_size);
  72         *objnum = i;
  73 }
  74
  75 /* basic tests (done on one core) */
  76 static int
  77 test_mempool_basic(struct rte_mempool *mp, int use_external_cache)
  78 {
  79         uint32_t *objnum;
  80         void **objtable;
  81         void *obj, *obj2;
  82         char *obj_data;
  83         int ret = 0;
  84         unsigned i, j;
  85         int offset;
  86         struct rte_mempool_cache *cache;
  87
  88         if (use_external_cache) {
  89                 /* Create a user-owned mempool cache. */
  90                 cache = rte_mempool_cache_create(RTE_MEMPOOL_CACHE_MAX_SIZE,
  91                                                  SOCKET_ID_ANY);
  92                 if (cache == NULL)
  93                         RET_ERR();
  94         } else {
  95                 /* May be NULL if cache is disabled. */
  96                 cache = rte_mempool_default_cache(mp, rte_lcore_id());
  97         }
  98
  99         /* dump the mempool status */
 100         rte_mempool_dump(stdout, mp);
 101
 102         printf("get an object\n");
 103         if (rte_mempool_generic_get(mp, &obj, 1, cache) < 0)
 104                 GOTO_ERR(ret, out);
 105         rte_mempool_dump(stdout, mp);
 106
 107         /* tests that improve coverage */
 108         printf("get object count\n");
 109         /* We have to count the extra caches, one in this case. */
 110         offset = use_external_cache ? 1 * cache->len : 0;
 111         if (rte_mempool_avail_count(mp) + offset != MEMPOOL_SIZE - 1)
 112                 GOTO_ERR(ret, out);
 113
 114         printf("get private data\n");
 115         if (rte_mempool_get_priv(mp) != (char *)mp +
 116                         RTE_MEMPOOL_HEADER_SIZE(mp, mp->cache_size))
 117                 GOTO_ERR(ret, out);
 118
 119 #ifndef RTE_EXEC_ENV_FREEBSD /* rte_mem_virt2iova() not supported on bsd */
 120         printf("get physical address of an object\n");
 121         if (rte_mempool_virt2iova(obj) != rte_mem_virt2iova(obj))
 122                 GOTO_ERR(ret, out);
 123 #endif
 124
 125         printf("put the object back\n");
 126         rte_mempool_generic_put(mp, &obj, 1, cache);
 127         rte_mempool_dump(stdout, mp);
 128
 129         printf("get 2 objects\n");
 130         if (rte_mempool_generic_get(mp, &obj, 1, cache) < 0)
 131                 GOTO_ERR(ret, out);
 132         if (rte_mempool_generic_get(mp, &obj2, 1, cache) < 0) {
 133                 rte_mempool_generic_put(mp, &obj, 1, cache);
 134                 GOTO_ERR(ret, out);
 135         }
 136         rte_mempool_dump(stdout, mp);
 137
 138         printf("put the objects back\n");
 139         rte_mempool_generic_put(mp, &obj, 1, cache);
 140         rte_mempool_generic_put(mp, &obj2, 1, cache);
 141         rte_mempool_dump(stdout, mp);
 142
 143         /*
 144          * get many objects: we cannot get them all because the cache
 145          * on other cores may not be empty.
 146          */
 147         objtable = malloc(MEMPOOL_SIZE * sizeof(void *));
 148         if (objtable == NULL)
 149                 GOTO_ERR(ret, out);
 150
 151         for (i = 0; i < MEMPOOL_SIZE; i++) {
 152                 if (rte_mempool_generic_get(mp, &objtable[i], 1, cache) < 0)
 153                         break;
 154         }
 155
 156         /*
 157          * for each object, check that its content was not modified,
 158          * and put objects back in pool
 159          */
 160         while (i--) {
 161                 obj = objtable[i];
 162                 obj_data = obj;
 163                 objnum = obj;
 164                 if (*objnum > MEMPOOL_SIZE) {
 165                         printf("bad object number(%d)\n", *objnum);
 166                         ret = -1;
 167                         break;
 168                 }
 169                 for (j = sizeof(*objnum); j < mp->elt_size; j++) {
 170                         if (obj_data[j] != 0)
 171                                 ret = -1;
 172                 }
 173
 174                 rte_mempool_generic_put(mp, &objtable[i], 1, cache);
 175         }
 176
 177         free(objtable);
 178         if (ret == -1)
 179                 printf("objects were modified!\n");
 180
 181 out:
 182         if (use_external_cache) {
 183                 rte_mempool_cache_flush(cache, mp);
 184                 rte_mempool_cache_free(cache);
 185         }
 186
 187         return ret;
 188 }
 189
 190 static int test_mempool_creation_with_exceeded_cache_size(void)
 191 {
 192         struct rte_mempool *mp_cov;
 193
 194         mp_cov = rte_mempool_create("test_mempool_cache_too_big",
 195                 MEMPOOL_SIZE,
 196                 MEMPOOL_ELT_SIZE,
 197                 RTE_MEMPOOL_CACHE_MAX_SIZE + 32, 0,
 198                 NULL, NULL,
 199                 my_obj_init, NULL,
 200                 SOCKET_ID_ANY, 0);
 201
 202         if (mp_cov != NULL) {
 203                 rte_mempool_free(mp_cov);
 204                 RET_ERR();
 205         }
 206
 207         return 0;
 208 }
 209
 210 static int test_mempool_creation_with_invalid_flags(void)
 211 {
 212         struct rte_mempool *mp_cov;
 213
 214         mp_cov = rte_mempool_create("test_mempool_invalid_flags", MEMPOOL_SIZE,
 215                 MEMPOOL_ELT_SIZE, 0, 0,
 216                 NULL, NULL,
 217                 NULL, NULL,
 218                 SOCKET_ID_ANY, ~RTE_MEMPOOL_VALID_USER_FLAGS);
 219
 220         if (mp_cov != NULL) {
 221                 rte_mempool_free(mp_cov);
 222                 RET_ERR();
 223         }
 224
 225         return 0;
 226 }
 227
 228 static struct rte_mempool *mp_spsc;
 229 static rte_spinlock_t scsp_spinlock;
 230 static void *scsp_obj_table[MAX_KEEP];
 231
 232 /*
 233  * single producer function
 234  */
 235 static int test_mempool_single_producer(void)
 236 {
 237         unsigned int i;
 238         void *obj = NULL;
 239         uint64_t start_cycles, end_cycles;
 240         uint64_t duration = rte_get_timer_hz() / 4;
 241
 242         start_cycles = rte_get_timer_cycles();
 243         while (1) {
 244                 end_cycles = rte_get_timer_cycles();
 245                 /* duration uses up, stop producing */
 246                 if (start_cycles + duration < end_cycles)
 247                         break;
 248                 rte_spinlock_lock(&scsp_spinlock);
 249                 for (i = 0; i < MAX_KEEP; i ++) {
 250                         if (NULL != scsp_obj_table[i]) {
 251                                 obj = scsp_obj_table[i];
 252                                 break;
 253                         }
 254                 }
 255                 rte_spinlock_unlock(&scsp_spinlock);
 256                 if (i >= MAX_KEEP) {
 257                         continue;
 258                 }
 259                 if (rte_mempool_from_obj(obj) != mp_spsc) {
 260                         printf("obj not owned by this mempool\n");
 261                         RET_ERR();
 262                 }
 263                 rte_mempool_put(mp_spsc, obj);
 264                 rte_spinlock_lock(&scsp_spinlock);
 265                 scsp_obj_table[i] = NULL;
 266                 rte_spinlock_unlock(&scsp_spinlock);
 267         }
 268
 269         return 0;
 270 }
 271
 272 /*
 273  * single consumer function
 274  */
 275 static int test_mempool_single_consumer(void)
 276 {
 277         unsigned int i;
 278         void * obj;
 279         uint64_t start_cycles, end_cycles;
 280         uint64_t duration = rte_get_timer_hz() / 8;
 281
 282         start_cycles = rte_get_timer_cycles();
 283         while (1) {
 284                 end_cycles = rte_get_timer_cycles();
 285                 /* duration uses up, stop consuming */
 286                 if (start_cycles + duration < end_cycles)
 287                         break;
 288                 rte_spinlock_lock(&scsp_spinlock);
 289                 for (i = 0; i < MAX_KEEP; i ++) {
 290                         if (NULL == scsp_obj_table[i])
 291                                 break;
 292                 }
 293                 rte_spinlock_unlock(&scsp_spinlock);
 294                 if (i >= MAX_KEEP)
 295                         continue;
 296                 if (rte_mempool_get(mp_spsc, &obj) < 0)
 297                         break;
 298                 rte_spinlock_lock(&scsp_spinlock);
 299                 scsp_obj_table[i] = obj;
 300                 rte_spinlock_unlock(&scsp_spinlock);
 301         }
 302
 303         return 0;
 304 }
 305
 306 /*
 307  * test function for mempool test based on singple consumer and single producer,
 308  * can run on one lcore only
 309  */
 310 static int
 311 test_mempool_launch_single_consumer(__rte_unused void *arg)
 312 {
 313         return test_mempool_single_consumer();
 314 }
 315
 316 static void
 317 my_mp_init(struct rte_mempool *mp, __rte_unused void *arg)
 318 {
 319         printf("mempool name is %s\n", mp->name);
 320         /* nothing to be implemented here*/
 321         return ;
 322 }
 323
 324 /*
 325  * it tests the mempool operations based on singple producer and single consumer
 326  */
 327 static int
 328 test_mempool_sp_sc(void)
 329 {
 330         int ret = 0;
 331         unsigned lcore_id = rte_lcore_id();
 332         unsigned lcore_next;
 333
 334         /* create a mempool with single producer/consumer ring */
 335         if (mp_spsc == NULL) {
 336                 mp_spsc = rte_mempool_create("test_mempool_sp_sc", MEMPOOL_SIZE,
 337                         MEMPOOL_ELT_SIZE, 0, 0,
 338                         my_mp_init, NULL,
 339                         my_obj_init, NULL,
 340                         SOCKET_ID_ANY,
 341                         RTE_MEMPOOL_F_NO_CACHE_ALIGN | RTE_MEMPOOL_F_SP_PUT |
 342                         RTE_MEMPOOL_F_SC_GET);
 343                 if (mp_spsc == NULL)
 344                         RET_ERR();
 345         }
 346         if (rte_mempool_lookup("test_mempool_sp_sc") != mp_spsc) {
 347                 printf("Cannot lookup mempool from its name\n");
 348                 ret = -1;
 349                 goto err;
 350         }
 351         lcore_next = rte_get_next_lcore(lcore_id, 0, 1);
 352         if (lcore_next >= RTE_MAX_LCORE) {
 353                 ret = -1;
 354                 goto err;
 355         }
 356         if (rte_eal_lcore_role(lcore_next) != ROLE_RTE) {
 357                 ret = -1;
 358                 goto err;
 359         }
 360         rte_spinlock_init(&scsp_spinlock);
 361         memset(scsp_obj_table, 0, sizeof(scsp_obj_table));
 362         rte_eal_remote_launch(test_mempool_launch_single_consumer, NULL,
 363                 lcore_next);
 364         if (test_mempool_single_producer() < 0)
 365                 ret = -1;
 366
 367         if (rte_eal_wait_lcore(lcore_next) < 0)
 368                 ret = -1;
 369
 370 err:
 371         rte_mempool_free(mp_spsc);
 372         mp_spsc = NULL;
 373
 374         return ret;
 375 }
 376
 377 /*
 378  * it tests some more basic of mempool
 379  */
 380 static int
 381 test_mempool_basic_ex(struct rte_mempool *mp)
 382 {
 383         unsigned i;
 384         void **obj;
 385         void *err_obj;
 386         int ret = -1;
 387
 388         if (mp == NULL)
 389                 return ret;
 390
 391         obj = rte_calloc("test_mempool_basic_ex", MEMPOOL_SIZE,
 392                 sizeof(void *), 0);
 393         if (obj == NULL) {
 394                 printf("test_mempool_basic_ex fail to rte_malloc\n");
 395                 return ret;
 396         }
 397         printf("test_mempool_basic_ex now mempool (%s) has %u free entries\n",
 398                 mp->name, rte_mempool_in_use_count(mp));
 399         if (rte_mempool_full(mp) != 1) {
 400                 printf("test_mempool_basic_ex the mempool should be full\n");
 401                 goto fail_mp_basic_ex;
 402         }
 403
 404         for (i = 0; i < MEMPOOL_SIZE; i ++) {
 405                 if (rte_mempool_get(mp, &obj[i]) < 0) {
 406                         printf("test_mp_basic_ex fail to get object for [%u]\n",
 407                                 i);
 408                         goto fail_mp_basic_ex;
 409                 }
 410         }
 411         if (rte_mempool_get(mp, &err_obj) == 0) {
 412                 printf("test_mempool_basic_ex get an impossible obj\n");
 413                 goto fail_mp_basic_ex;
 414         }
 415         printf("number: %u\n", i);
 416         if (rte_mempool_empty(mp) != 1) {
 417                 printf("test_mempool_basic_ex the mempool should be empty\n");
 418                 goto fail_mp_basic_ex;
 419         }
 420
 421         for (i = 0; i < MEMPOOL_SIZE; i++)
 422                 rte_mempool_put(mp, obj[i]);
 423
 424         if (rte_mempool_full(mp) != 1) {
 425                 printf("test_mempool_basic_ex the mempool should be full\n");
 426                 goto fail_mp_basic_ex;
 427         }
 428
 429         ret = 0;
 430
 431 fail_mp_basic_ex:
 432         if (obj != NULL)
 433                 rte_free((void *)obj);
 434
 435         return ret;
 436 }
 437
 438 static int
 439 test_mempool_same_name_twice_creation(void)
 440 {
 441         struct rte_mempool *mp_tc, *mp_tc2;
 442
 443         mp_tc = rte_mempool_create("test_mempool_same_name", MEMPOOL_SIZE,
 444                 MEMPOOL_ELT_SIZE, 0, 0,
 445                 NULL, NULL,
 446                 NULL, NULL,
 447                 SOCKET_ID_ANY, 0);
 448
 449         if (mp_tc == NULL)
 450                 RET_ERR();
 451
 452         mp_tc2 = rte_mempool_create("test_mempool_same_name", MEMPOOL_SIZE,
 453                 MEMPOOL_ELT_SIZE, 0, 0,
 454                 NULL, NULL,
 455                 NULL, NULL,
 456                 SOCKET_ID_ANY, 0);
 457
 458         if (mp_tc2 != NULL) {
 459                 rte_mempool_free(mp_tc);
 460                 rte_mempool_free(mp_tc2);
 461                 RET_ERR();
 462         }
 463
 464         rte_mempool_free(mp_tc);
 465         return 0;
 466 }
 467
 468 static void
 469 walk_cb(struct rte_mempool *mp, void *userdata __rte_unused)
 470 {
 471         printf("\t%s\n", mp->name);
 472 }
 473
 474 struct mp_data {
 475         int16_t ret;
 476 };
 477
 478 static void
 479 test_mp_mem_init(struct rte_mempool *mp,
 480                 __rte_unused void *opaque,
 481                 __rte_unused struct rte_mempool_memhdr *memhdr,
 482                 __rte_unused unsigned int mem_idx)
 483 {
 484         struct mp_data *data = opaque;
 485
 486         if (mp == NULL) {
 487                 data->ret = -1;
 488                 return;
 489         }
 490         /* nothing to be implemented here*/
 491         data->ret = 0;
 492 }
 493
 494 struct test_mempool_events_data {
 495         struct rte_mempool *mp;
 496         enum rte_mempool_event event;
 497         bool invoked;
 498 };
 499
 500 static void
 501 test_mempool_events_cb(enum rte_mempool_event event,
 502                        struct rte_mempool *mp, void *user_data)
 503 {
 504         struct test_mempool_events_data *data = user_data;
 505
 506         data->mp = mp;
 507         data->event = event;
 508         data->invoked = true;
 509 }
 510
 511 static int
 512 test_mempool_events(int (*populate)(struct rte_mempool *mp))
 513 {
 514 #pragma push_macro("RTE_TEST_TRACE_FAILURE")
 515 #undef RTE_TEST_TRACE_FAILURE
 516 #define RTE_TEST_TRACE_FAILURE(...) do { goto fail; } while (0)
 517
 518         static const size_t CB_NUM = 3;
 519         static const size_t MP_NUM = 2;
 520
 521         struct test_mempool_events_data data[CB_NUM];
 522         struct rte_mempool *mp[MP_NUM], *freed;
 523         char name[RTE_MEMPOOL_NAMESIZE];
 524         size_t i, j;
 525         int ret;
 526
 527         memset(mp, 0, sizeof(mp));
 528         for (i = 0; i < CB_NUM; i++) {
 529                 ret = rte_mempool_event_callback_register
 530                                 (test_mempool_events_cb, &data[i]);
 531                 RTE_TEST_ASSERT_EQUAL(ret, 0, "Failed to register the callback %zu: %s",
 532                                       i, rte_strerror(rte_errno));
 533         }
 534         ret = rte_mempool_event_callback_unregister(test_mempool_events_cb, mp);
 535         RTE_TEST_ASSERT_NOT_EQUAL(ret, 0, "Unregistered a non-registered callback");
 536         /* NULL argument has no special meaning in this API. */
 537         ret = rte_mempool_event_callback_unregister(test_mempool_events_cb,
 538                                                     NULL);
 539         RTE_TEST_ASSERT_NOT_EQUAL(ret, 0, "Unregistered a non-registered callback with NULL argument");
 540
 541         /* Create mempool 0 that will be observed by all callbacks. */
 542         memset(&data, 0, sizeof(data));
 543         strcpy(name, "empty0");
 544         mp[0] = rte_mempool_create_empty(name, MEMPOOL_SIZE,
 545                                          MEMPOOL_ELT_SIZE, 0, 0,
 546                                          SOCKET_ID_ANY, 0);
 547         RTE_TEST_ASSERT_NOT_NULL(mp[0], "Cannot create mempool %s: %s",
 548                                  name, rte_strerror(rte_errno));
 549         for (j = 0; j < CB_NUM; j++)
 550                 RTE_TEST_ASSERT_EQUAL(data[j].invoked, false,
 551                                       "Callback %zu invoked on %s mempool creation",
 552                                       j, name);
 553
 554         rte_mempool_set_ops_byname(mp[0], rte_mbuf_best_mempool_ops(), NULL);
 555         ret = populate(mp[0]);
 556         RTE_TEST_ASSERT_EQUAL(ret, (int)mp[0]->size, "Failed to populate mempool %s: %s",
 557                               name, rte_strerror(-ret));
 558         for (j = 0; j < CB_NUM; j++) {
 559                 RTE_TEST_ASSERT_EQUAL(data[j].invoked, true,
 560                                         "Callback %zu not invoked on mempool %s population",
 561                                         j, name);
 562                 RTE_TEST_ASSERT_EQUAL(data[j].event,
 563                                         RTE_MEMPOOL_EVENT_READY,
 564                                         "Wrong callback invoked, expected READY");
 565                 RTE_TEST_ASSERT_EQUAL(data[j].mp, mp[0],
 566                                         "Callback %zu invoked for a wrong mempool instead of %s",
 567                                         j, name);
 568         }
 569
 570         /* Check that unregistered callback 0 observes no events. */
 571         ret = rte_mempool_event_callback_unregister(test_mempool_events_cb,
 572                                                     &data[0]);
 573         RTE_TEST_ASSERT_EQUAL(ret, 0, "Failed to unregister callback 0: %s",
 574                               rte_strerror(rte_errno));
 575         memset(&data, 0, sizeof(data));
 576         strcpy(name, "empty1");
 577         mp[1] = rte_mempool_create_empty(name, MEMPOOL_SIZE,
 578                                          MEMPOOL_ELT_SIZE, 0, 0,
 579                                          SOCKET_ID_ANY, 0);
 580         RTE_TEST_ASSERT_NOT_NULL(mp[1], "Cannot create mempool %s: %s",
 581                                  name, rte_strerror(rte_errno));
 582         rte_mempool_set_ops_byname(mp[1], rte_mbuf_best_mempool_ops(), NULL);
 583         ret = populate(mp[1]);
 584         RTE_TEST_ASSERT_EQUAL(ret, (int)mp[1]->size, "Failed to populate mempool %s: %s",
 585                               name, rte_strerror(-ret));
 586         RTE_TEST_ASSERT_EQUAL(data[0].invoked, false,
 587                               "Unregistered callback 0 invoked on %s mempool populaton",
 588                               name);
 589
 590         for (i = 0; i < MP_NUM; i++) {
 591                 memset(&data, 0, sizeof(data));
 592                 sprintf(name, "empty%zu", i);
 593                 rte_mempool_free(mp[i]);
 594                 /*
 595                  * Save pointer to check that it was passed to the callback,
 596                  * but put NULL into the array in case cleanup is called early.
 597                  */
 598                 freed = mp[i];
 599                 mp[i] = NULL;
 600                 for (j = 1; j < CB_NUM; j++) {
 601                         RTE_TEST_ASSERT_EQUAL(data[j].invoked, true,
 602                                               "Callback %zu not invoked on mempool %s destruction",
 603                                               j, name);
 604                         RTE_TEST_ASSERT_EQUAL(data[j].event,
 605                                               RTE_MEMPOOL_EVENT_DESTROY,
 606                                               "Wrong callback invoked, expected DESTROY");
 607                         RTE_TEST_ASSERT_EQUAL(data[j].mp, freed,
 608                                               "Callback %zu invoked for a wrong mempool instead of %s",
 609                                               j, name);
 610                 }
 611                 RTE_TEST_ASSERT_EQUAL(data[0].invoked, false,
 612                                       "Unregistered callback 0 invoked on %s mempool destruction",
 613                                       name);
 614         }
 615
 616         for (j = 1; j < CB_NUM; j++) {
 617                 ret = rte_mempool_event_callback_unregister
 618                                         (test_mempool_events_cb, &data[j]);
 619                 RTE_TEST_ASSERT_EQUAL(ret, 0, "Failed to unregister the callback %zu: %s",
 620                                       j, rte_strerror(rte_errno));
 621         }
 622         return TEST_SUCCESS;
 623
 624 fail:
 625         for (j = 0; j < CB_NUM; j++)
 626                 rte_mempool_event_callback_unregister
 627                                         (test_mempool_events_cb, &data[j]);
 628         for (i = 0; i < MP_NUM; i++)
 629                 rte_mempool_free(mp[i]);
 630         return TEST_FAILED;
 631
 632 #pragma pop_macro("RTE_TEST_TRACE_FAILURE")
 633 }
 634
 635 struct test_mempool_events_safety_data {
 636         bool invoked;
 637         int (*api_func)(rte_mempool_event_callback *func, void *user_data);
 638         rte_mempool_event_callback *cb_func;
 639         void *cb_user_data;
 640         int ret;
 641 };
 642
 643 static void
 644 test_mempool_events_safety_cb(enum rte_mempool_event event,
 645                               struct rte_mempool *mp, void *user_data)
 646 {
 647         struct test_mempool_events_safety_data *data = user_data;
 648
 649         RTE_SET_USED(event);
 650         RTE_SET_USED(mp);
 651         data->invoked = true;
 652         data->ret = data->api_func(data->cb_func, data->cb_user_data);
 653 }
 654
 655 static int
 656 test_mempool_events_safety(void)
 657 {
 658 #pragma push_macro("RTE_TEST_TRACE_FAILURE")
 659 #undef RTE_TEST_TRACE_FAILURE
 660 #define RTE_TEST_TRACE_FAILURE(...) do { \
 661                 ret = TEST_FAILED; \
 662                 goto exit; \
 663         } while (0)
 664
 665         struct test_mempool_events_data data;
 666         struct test_mempool_events_safety_data sdata[2];
 667         struct rte_mempool *mp;
 668         size_t i;
 669         int ret;
 670
 671         /* removes itself */
 672         sdata[0].api_func = rte_mempool_event_callback_unregister;
 673         sdata[0].cb_func = test_mempool_events_safety_cb;
 674         sdata[0].cb_user_data = &sdata[0];
 675         sdata[0].ret = -1;
 676         rte_mempool_event_callback_register(test_mempool_events_safety_cb,
 677                                             &sdata[0]);
 678         /* inserts a callback after itself */
 679         sdata[1].api_func = rte_mempool_event_callback_register;
 680         sdata[1].cb_func = test_mempool_events_cb;
 681         sdata[1].cb_user_data = &data;
 682         sdata[1].ret = -1;
 683         rte_mempool_event_callback_register(test_mempool_events_safety_cb,
 684                                             &sdata[1]);
 685
 686         mp = rte_mempool_create_empty("empty", MEMPOOL_SIZE,
 687                                       MEMPOOL_ELT_SIZE, 0, 0,
 688                                       SOCKET_ID_ANY, 0);
 689         RTE_TEST_ASSERT_NOT_NULL(mp, "Cannot create mempool: %s",
 690                                  rte_strerror(rte_errno));
 691         memset(&data, 0, sizeof(data));
 692         ret = rte_mempool_populate_default(mp);
 693         RTE_TEST_ASSERT_EQUAL(ret, (int)mp->size, "Failed to populate mempool: %s",
 694                               rte_strerror(-ret));
 695
 696         RTE_TEST_ASSERT_EQUAL(sdata[0].ret, 0, "Callback failed to unregister itself: %s",
 697                               rte_strerror(rte_errno));
 698         RTE_TEST_ASSERT_EQUAL(sdata[1].ret, 0, "Failed to insert a new callback: %s",
 699                               rte_strerror(rte_errno));
 700         RTE_TEST_ASSERT_EQUAL(data.invoked, false,
 701                               "Inserted callback is invoked on mempool population");
 702
 703         memset(&data, 0, sizeof(data));
 704         sdata[0].invoked = false;
 705         rte_mempool_free(mp);
 706         mp = NULL;
 707         RTE_TEST_ASSERT_EQUAL(sdata[0].invoked, false,
 708                               "Callback that unregistered itself was called");
 709         RTE_TEST_ASSERT_EQUAL(sdata[1].ret, -EEXIST,
 710                               "New callback inserted twice");
 711         RTE_TEST_ASSERT_EQUAL(data.invoked, true,
 712                               "Inserted callback is not invoked on mempool destruction");
 713
 714         rte_mempool_event_callback_unregister(test_mempool_events_cb, &data);
 715         for (i = 0; i < RTE_DIM(sdata); i++)
 716                 rte_mempool_event_callback_unregister
 717                                 (test_mempool_events_safety_cb, &sdata[i]);
 718         ret = TEST_SUCCESS;
 719
 720 exit:
 721         /* cleanup, don't care which callbacks are already removed */
 722         rte_mempool_event_callback_unregister(test_mempool_events_cb, &data);
 723         for (i = 0; i < RTE_DIM(sdata); i++)
 724                 rte_mempool_event_callback_unregister
 725                                 (test_mempool_events_safety_cb, &sdata[i]);
 726         /* in case of failure before the planned destruction */
 727         rte_mempool_free(mp);
 728         return ret;
 729
 730 #pragma pop_macro("RTE_TEST_TRACE_FAILURE")
 731 }
 732
 733 #pragma push_macro("RTE_TEST_TRACE_FAILURE")
 734 #undef RTE_TEST_TRACE_FAILURE
 735 #define RTE_TEST_TRACE_FAILURE(...) do { \
 736                 ret = TEST_FAILED; \
 737                 goto exit; \
 738         } while (0)
 739
 740 static int
 741 test_mempool_flag_non_io_set_when_no_iova_contig_set(void)
 742 {
 743         const struct rte_memzone *mz = NULL;
 744         void *virt;
 745         rte_iova_t iova;
 746         size_t size = MEMPOOL_ELT_SIZE * 16;
 747         struct rte_mempool *mp = NULL;
 748         int ret;
 749
 750         mz = rte_memzone_reserve("test_mempool", size, SOCKET_ID_ANY, 0);
 751         RTE_TEST_ASSERT_NOT_NULL(mz, "Cannot allocate memory");
 752         virt = mz->addr;
 753         iova = mz->iova;
 754         mp = rte_mempool_create_empty("empty", MEMPOOL_SIZE,
 755                                       MEMPOOL_ELT_SIZE, 0, 0,
 756                                       SOCKET_ID_ANY, RTE_MEMPOOL_F_NO_IOVA_CONTIG);
 757         RTE_TEST_ASSERT_NOT_NULL(mp, "Cannot create mempool: %s",
 758                                  rte_strerror(rte_errno));
 759         rte_mempool_set_ops_byname(mp, rte_mbuf_best_mempool_ops(), NULL);
 760
 761         RTE_TEST_ASSERT(mp->flags & RTE_MEMPOOL_F_NON_IO,
 762                         "NON_IO flag is not set on an empty mempool");
 763
 764         /*
 765          * Always use valid IOVA so that populate() has no other reason
 766          * to infer that the mempool cannot be used for IO.
 767          */
 768         ret = rte_mempool_populate_iova(mp, virt, iova, size, NULL, NULL);
 769         RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
 770                         rte_strerror(-ret));
 771         RTE_TEST_ASSERT(mp->flags & RTE_MEMPOOL_F_NON_IO,
 772                         "NON_IO flag is not set when NO_IOVA_CONTIG is set");
 773         ret = TEST_SUCCESS;
 774 exit:
 775         rte_mempool_free(mp);
 776         rte_memzone_free(mz);
 777         return ret;
 778 }
 779
 780 static int
 781 test_mempool_flag_non_io_unset_when_populated_with_valid_iova(void)
 782 {
 783         const struct rte_memzone *mz = NULL;
 784         void *virt;
 785         rte_iova_t iova;
 786         size_t total_size = MEMPOOL_ELT_SIZE * MEMPOOL_SIZE;
 787         size_t block_size = total_size / 3;
 788         struct rte_mempool *mp = NULL;
 789         int ret;
 790
 791         /*
 792          * Since objects from the pool are never used in the test,
 793          * we don't care for contiguous IOVA, on the other hand,
 794          * requiring it could cause spurious test failures.
 795          */
 796         mz = rte_memzone_reserve("test_mempool", total_size, SOCKET_ID_ANY, 0);
 797         RTE_TEST_ASSERT_NOT_NULL(mz, "Cannot allocate memory");
 798         virt = mz->addr;
 799         iova = mz->iova;
 800         mp = rte_mempool_create_empty("empty", MEMPOOL_SIZE,
 801                                       MEMPOOL_ELT_SIZE, 0, 0,
 802                                       SOCKET_ID_ANY, 0);
 803         RTE_TEST_ASSERT_NOT_NULL(mp, "Cannot create mempool: %s",
 804                                  rte_strerror(rte_errno));
 805
 806         RTE_TEST_ASSERT(mp->flags & RTE_MEMPOOL_F_NON_IO,
 807                         "NON_IO flag is not set on an empty mempool");
 808
 809         ret = rte_mempool_populate_iova(mp, RTE_PTR_ADD(virt, 1 * block_size),
 810                                         RTE_BAD_IOVA, block_size, NULL, NULL);
 811         RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
 812                         rte_strerror(-ret));
 813         RTE_TEST_ASSERT(mp->flags & RTE_MEMPOOL_F_NON_IO,
 814                         "NON_IO flag is not set when mempool is populated with only RTE_BAD_IOVA");
 815
 816         ret = rte_mempool_populate_iova(mp, virt, iova, block_size, NULL, NULL);
 817         RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
 818                         rte_strerror(-ret));
 819         RTE_TEST_ASSERT(!(mp->flags & RTE_MEMPOOL_F_NON_IO),
 820                         "NON_IO flag is not unset when mempool is populated with valid IOVA");
 821
 822         ret = rte_mempool_populate_iova(mp, RTE_PTR_ADD(virt, 2 * block_size),
 823                                         RTE_BAD_IOVA, block_size, NULL, NULL);
 824         RTE_TEST_ASSERT(ret > 0, "Failed to populate mempool: %s",
 825                         rte_strerror(-ret));
 826         RTE_TEST_ASSERT(!(mp->flags & RTE_MEMPOOL_F_NON_IO),
 827                         "NON_IO flag is set even when some objects have valid IOVA");
 828         ret = TEST_SUCCESS;
 829
 830 exit:
 831         rte_mempool_free(mp);
 832         rte_memzone_free(mz);
 833         return ret;
 834 }
 835
 836 #pragma pop_macro("RTE_TEST_TRACE_FAILURE")
 837
 838 static int
 839 test_mempool(void)
 840 {
 841         int ret = -1;
 842         uint32_t nb_objs = 0;
 843         uint32_t nb_mem_chunks = 0;
 844         struct rte_mempool *mp_cache = NULL;
 845         struct rte_mempool *mp_nocache = NULL;
 846         struct rte_mempool *mp_stack_anon = NULL;
 847         struct rte_mempool *mp_stack_mempool_iter = NULL;
 848         struct rte_mempool *mp_stack = NULL;
 849         struct rte_mempool *default_pool = NULL;
 850         struct mp_data cb_arg = {
 851                 .ret = -1
 852         };
 853         const char *default_pool_ops = rte_mbuf_best_mempool_ops();
 854
 855         /* create a mempool (without cache) */
 856         mp_nocache = rte_mempool_create("test_nocache", MEMPOOL_SIZE,
 857                 MEMPOOL_ELT_SIZE, 0, 0,
 858                 NULL, NULL,
 859                 my_obj_init, NULL,
 860                 SOCKET_ID_ANY, 0);
 861
 862         if (mp_nocache == NULL) {
 863                 printf("cannot allocate mp_nocache mempool\n");
 864                 GOTO_ERR(ret, err);
 865         }
 866
 867         /* create a mempool (with cache) */
 868         mp_cache = rte_mempool_create("test_cache", MEMPOOL_SIZE,
 869                 MEMPOOL_ELT_SIZE,
 870                 RTE_MEMPOOL_CACHE_MAX_SIZE, 0,
 871                 NULL, NULL,
 872                 my_obj_init, NULL,
 873                 SOCKET_ID_ANY, 0);
 874
 875         if (mp_cache == NULL) {
 876                 printf("cannot allocate mp_cache mempool\n");
 877                 GOTO_ERR(ret, err);
 878         }
 879
 880         /* create an empty mempool  */
 881         mp_stack_anon = rte_mempool_create_empty("test_stack_anon",
 882                 MEMPOOL_SIZE,
 883                 MEMPOOL_ELT_SIZE,
 884                 RTE_MEMPOOL_CACHE_MAX_SIZE, 0,
 885                 SOCKET_ID_ANY, 0);
 886
 887         if (mp_stack_anon == NULL)
 888                 GOTO_ERR(ret, err);
 889
 890         /* populate an empty mempool */
 891         ret = rte_mempool_populate_anon(mp_stack_anon);
 892         printf("%s ret = %d\n", __func__, ret);
 893         if (ret < 0)
 894                 GOTO_ERR(ret, err);
 895
 896         /* Try to populate when already populated */
 897         ret = rte_mempool_populate_anon(mp_stack_anon);
 898         if (ret != 0)
 899                 GOTO_ERR(ret, err);
 900
 901         /* create a mempool  */
 902         mp_stack_mempool_iter = rte_mempool_create("test_iter_obj",
 903                 MEMPOOL_SIZE,
 904                 MEMPOOL_ELT_SIZE,
 905                 RTE_MEMPOOL_CACHE_MAX_SIZE, 0,
 906                 NULL, NULL,
 907                 my_obj_init, NULL,
 908                 SOCKET_ID_ANY, 0);
 909
 910         if (mp_stack_mempool_iter == NULL)
 911                 GOTO_ERR(ret, err);
 912
 913         /* test to initialize mempool objects and memory */
 914         nb_objs = rte_mempool_obj_iter(mp_stack_mempool_iter, my_obj_init,
 915                         NULL);
 916         if (nb_objs == 0)
 917                 GOTO_ERR(ret, err);
 918
 919         nb_mem_chunks = rte_mempool_mem_iter(mp_stack_mempool_iter,
 920                         test_mp_mem_init, &cb_arg);
 921         if (nb_mem_chunks == 0 || cb_arg.ret < 0)
 922                 GOTO_ERR(ret, err);
 923
 924         /* create a mempool with an external handler */
 925         mp_stack = rte_mempool_create_empty("test_stack",
 926                 MEMPOOL_SIZE,
 927                 MEMPOOL_ELT_SIZE,
 928                 RTE_MEMPOOL_CACHE_MAX_SIZE, 0,
 929                 SOCKET_ID_ANY, 0);
 930
 931         if (mp_stack == NULL) {
 932                 printf("cannot allocate mp_stack mempool\n");
 933                 GOTO_ERR(ret, err);
 934         }
 935         if (rte_mempool_set_ops_byname(mp_stack, "stack", NULL) < 0) {
 936                 printf("cannot set stack handler\n");
 937                 GOTO_ERR(ret, err);
 938         }
 939         if (rte_mempool_populate_default(mp_stack) < 0) {
 940                 printf("cannot populate mp_stack mempool\n");
 941                 GOTO_ERR(ret, err);
 942         }
 943         rte_mempool_obj_iter(mp_stack, my_obj_init, NULL);
 944
 945         /* Create a mempool based on Default handler */
 946         printf("Testing %s mempool handler\n", default_pool_ops);
 947         default_pool = rte_mempool_create_empty("default_pool",
 948                                                 MEMPOOL_SIZE,
 949                                                 MEMPOOL_ELT_SIZE,
 950                                                 RTE_MEMPOOL_CACHE_MAX_SIZE, 0,
 951                                                 SOCKET_ID_ANY, 0);
 952
 953         if (default_pool == NULL) {
 954                 printf("cannot allocate default mempool\n");
 955                 GOTO_ERR(ret, err);
 956         }
 957         if (rte_mempool_set_ops_byname(default_pool,
 958                                 default_pool_ops, NULL) < 0) {
 959                 printf("cannot set %s handler\n", default_pool_ops);
 960                 GOTO_ERR(ret, err);
 961         }
 962         if (rte_mempool_populate_default(default_pool) < 0) {
 963                 printf("cannot populate %s mempool\n", default_pool_ops);
 964                 GOTO_ERR(ret, err);
 965         }
 966         rte_mempool_obj_iter(default_pool, my_obj_init, NULL);
 967
 968         /* retrieve the mempool from its name */
 969         if (rte_mempool_lookup("test_nocache") != mp_nocache) {
 970                 printf("Cannot lookup mempool from its name\n");
 971                 GOTO_ERR(ret, err);
 972         }
 973
 974         printf("Walk into mempools:\n");
 975         rte_mempool_walk(walk_cb, NULL);
 976
 977         rte_mempool_list_dump(stdout);
 978
 979         /* basic tests without cache */
 980         if (test_mempool_basic(mp_nocache, 0) < 0)
 981                 GOTO_ERR(ret, err);
 982
 983         /* basic tests with cache */
 984         if (test_mempool_basic(mp_cache, 0) < 0)
 985                 GOTO_ERR(ret, err);
 986
 987         /* basic tests with user-owned cache */
 988         if (test_mempool_basic(mp_nocache, 1) < 0)
 989                 GOTO_ERR(ret, err);
 990
 991         /* more basic tests without cache */
 992         if (test_mempool_basic_ex(mp_nocache) < 0)
 993                 GOTO_ERR(ret, err);
 994
 995         /* mempool operation test based on single producer and single comsumer */
 996         if (test_mempool_sp_sc() < 0)
 997                 GOTO_ERR(ret, err);
 998
 999         if (test_mempool_creation_with_exceeded_cache_size() < 0)
1000                 GOTO_ERR(ret, err);
1001
1002         if (test_mempool_creation_with_invalid_flags() < 0)
1003                 GOTO_ERR(ret, err);
1004
1005         if (test_mempool_same_name_twice_creation() < 0)
1006                 GOTO_ERR(ret, err);
1007
1008         /* test the stack handler */
1009         if (test_mempool_basic(mp_stack, 1) < 0)
1010                 GOTO_ERR(ret, err);
1011
1012         if (test_mempool_basic(default_pool, 1) < 0)
1013                 GOTO_ERR(ret, err);
1014
1015         /* test mempool event callbacks */
1016         if (test_mempool_events(rte_mempool_populate_default) < 0)
1017                 GOTO_ERR(ret, err);
1018         if (test_mempool_events(rte_mempool_populate_anon) < 0)
1019                 GOTO_ERR(ret, err);
1020         if (test_mempool_events_safety() < 0)
1021                 GOTO_ERR(ret, err);
1022
1023         /* test NON_IO flag inference */
1024         if (test_mempool_flag_non_io_set_when_no_iova_contig_set() < 0)
1025                 GOTO_ERR(ret, err);
1026         if (test_mempool_flag_non_io_unset_when_populated_with_valid_iova() < 0)
1027                 GOTO_ERR(ret, err);
1028
1029         rte_mempool_list_dump(stdout);
1030
1031         ret = 0;
1032
1033 err:
1034         rte_mempool_free(mp_nocache);
1035         rte_mempool_free(mp_cache);
1036         rte_mempool_free(mp_stack_anon);
1037         rte_mempool_free(mp_stack_mempool_iter);
1038         rte_mempool_free(mp_stack);
1039         rte_mempool_free(default_pool);
1040
1041         return ret;
1042 }
1043
1044 REGISTER_TEST_COMMAND(mempool_autotest, test_mempool);