drivers/net/mlx5/mlx5_utils.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2019 Mellanox Technologies, Ltd
   3  */
   4
   5 #include <rte_malloc.h>
   6 #include <rte_hash_crc.h>
   7
   8 #include "mlx5_utils.h"
   9
  10 struct mlx5_hlist *
  11 mlx5_hlist_create(const char *name, uint32_t size)
  12 {
  13         struct mlx5_hlist *h;
  14         uint32_t act_size;
  15         uint32_t alloc_size;
  16
  17         if (!size)
  18                 return NULL;
  19         /* Align to the next power of 2, 32bits integer is enough now. */
  20         if (!rte_is_power_of_2(size)) {
  21                 act_size = rte_align32pow2(size);
  22                 DRV_LOG(WARNING, "Size 0x%" PRIX32 " is not power of 2, will "
  23                         "be aligned to 0x%" PRIX32 ".", size, act_size);
  24         } else {
  25                 act_size = size;
  26         }
  27         alloc_size = sizeof(struct mlx5_hlist) +
  28                      sizeof(struct mlx5_hlist_head) * act_size;
  29         /* Using zmalloc, then no need to initialize the heads. */
  30         h = rte_zmalloc(name, alloc_size, RTE_CACHE_LINE_SIZE);
  31         if (!h) {
  32                 DRV_LOG(ERR, "No memory for hash list %s creation",
  33                         name ? name : "None");
  34                 return NULL;
  35         }
  36         if (name)
  37                 snprintf(h->name, MLX5_HLIST_NAMESIZE, "%s", name);
  38         h->table_sz = act_size;
  39         h->mask = act_size - 1;
  40         DRV_LOG(DEBUG, "Hash list with %s size 0x%" PRIX32 " is created.",
  41                 h->name, act_size);
  42         return h;
  43 }
  44
  45 struct mlx5_hlist_entry *
  46 mlx5_hlist_lookup(struct mlx5_hlist *h, uint64_t key)
  47 {
  48         uint32_t idx;
  49         struct mlx5_hlist_head *first;
  50         struct mlx5_hlist_entry *node;
  51
  52         MLX5_ASSERT(h);
  53         idx = rte_hash_crc_8byte(key, 0) & h->mask;
  54         first = &h->heads[idx];
  55         LIST_FOREACH(node, first, next) {
  56                 if (node->key == key)
  57                         return node;
  58         }
  59         return NULL;
  60 }
  61
  62 int
  63 mlx5_hlist_insert(struct mlx5_hlist *h, struct mlx5_hlist_entry *entry)
  64 {
  65         uint32_t idx;
  66         struct mlx5_hlist_head *first;
  67         struct mlx5_hlist_entry *node;
  68
  69         MLX5_ASSERT(h && entry);
  70         idx = rte_hash_crc_8byte(entry->key, 0) & h->mask;
  71         first = &h->heads[idx];
  72         /* No need to reuse the lookup function. */
  73         LIST_FOREACH(node, first, next) {
  74                 if (node->key == entry->key)
  75                         return -EEXIST;
  76         }
  77         LIST_INSERT_HEAD(first, entry, next);
  78         return 0;
  79 }
  80
  81 void
  82 mlx5_hlist_remove(struct mlx5_hlist *h __rte_unused,
  83                   struct mlx5_hlist_entry *entry)
  84 {
  85         MLX5_ASSERT(entry && entry->next.le_prev);
  86         LIST_REMOVE(entry, next);
  87         /* Set to NULL to get rid of removing action for more than once. */
  88         entry->next.le_prev = NULL;
  89 }
  90
  91 void
  92 mlx5_hlist_destroy(struct mlx5_hlist *h,
  93                    mlx5_hlist_destroy_callback_fn cb, void *ctx)
  94 {
  95         uint32_t idx;
  96         struct mlx5_hlist_entry *entry;
  97
  98         MLX5_ASSERT(h);
  99         for (idx = 0; idx < h->table_sz; ++idx) {
 100                 /* no LIST_FOREACH_SAFE, using while instead */
 101                 while (!LIST_EMPTY(&h->heads[idx])) {
 102                         entry = LIST_FIRST(&h->heads[idx]);
 103                         LIST_REMOVE(entry, next);
 104                         /*
 105                          * The owner of whole element which contains data entry
 106                          * is the user, so it's the user's duty to do the clean
 107                          * up and the free work because someone may not put the
 108                          * hlist entry at the beginning(suggested to locate at
 109                          * the beginning). Or else the default free function
 110                          * will be used.
 111                          */
 112                         if (cb)
 113                                 cb(entry, ctx);
 114                         else
 115                                 rte_free(entry);
 116                 }
 117         }
 118         rte_free(h);
 119 }
 120
 121 static inline void
 122 mlx5_ipool_lock(struct mlx5_indexed_pool *pool)
 123 {
 124         if (pool->cfg.need_lock)
 125                 rte_spinlock_lock(&pool->lock);
 126 }
 127
 128 static inline void
 129 mlx5_ipool_unlock(struct mlx5_indexed_pool *pool)
 130 {
 131         if (pool->cfg.need_lock)
 132                 rte_spinlock_unlock(&pool->lock);
 133 }
 134
 135 static inline uint32_t
 136 mlx5_trunk_idx_get(struct mlx5_indexed_pool *pool, uint32_t entry_idx)
 137 {
 138         struct mlx5_indexed_pool_config *cfg = &pool->cfg;
 139         uint32_t trunk_idx = 0;
 140         uint32_t i;
 141
 142         if (!cfg->grow_trunk)
 143                 return entry_idx / cfg->trunk_size;
 144         if (entry_idx >= pool->grow_tbl[cfg->grow_trunk - 1]) {
 145                 trunk_idx = (entry_idx - pool->grow_tbl[cfg->grow_trunk - 1]) /
 146                             (cfg->trunk_size << (cfg->grow_shift *
 147                             cfg->grow_trunk)) + cfg->grow_trunk;
 148         } else {
 149                 for (i = 0; i < cfg->grow_trunk; i++) {
 150                         if (entry_idx < pool->grow_tbl[i])
 151                                 break;
 152                 }
 153                 trunk_idx = i;
 154         }
 155         return trunk_idx;
 156 }
 157
 158 static inline uint32_t
 159 mlx5_trunk_size_get(struct mlx5_indexed_pool *pool, uint32_t trunk_idx)
 160 {
 161         struct mlx5_indexed_pool_config *cfg = &pool->cfg;
 162
 163         return cfg->trunk_size << (cfg->grow_shift *
 164                (trunk_idx > cfg->grow_trunk ? cfg->grow_trunk : trunk_idx));
 165 }
 166
 167 static inline uint32_t
 168 mlx5_trunk_idx_offset_get(struct mlx5_indexed_pool *pool, uint32_t trunk_idx)
 169 {
 170         struct mlx5_indexed_pool_config *cfg = &pool->cfg;
 171         uint32_t offset = 0;
 172
 173         if (!trunk_idx)
 174                 return 0;
 175         if (!cfg->grow_trunk)
 176                 return cfg->trunk_size * trunk_idx;
 177         if (trunk_idx < cfg->grow_trunk)
 178                 offset = pool->grow_tbl[trunk_idx - 1];
 179         else
 180                 offset = pool->grow_tbl[cfg->grow_trunk - 1] +
 181                          (cfg->trunk_size << (cfg->grow_shift *
 182                          cfg->grow_trunk)) * (trunk_idx - cfg->grow_trunk);
 183         return offset;
 184 }
 185
 186 struct mlx5_indexed_pool *
 187 mlx5_ipool_create(struct mlx5_indexed_pool_config *cfg)
 188 {
 189         struct mlx5_indexed_pool *pool;
 190         uint32_t i;
 191
 192         if (!cfg || !cfg->size || (!cfg->malloc ^ !cfg->free) ||
 193             (cfg->trunk_size && ((cfg->trunk_size & (cfg->trunk_size - 1)) ||
 194             ((__builtin_ffs(cfg->trunk_size) + TRUNK_IDX_BITS) > 32))))
 195                 return NULL;
 196         pool = rte_zmalloc("mlx5_ipool", sizeof(*pool) + cfg->grow_trunk *
 197                                 sizeof(pool->grow_tbl[0]), RTE_CACHE_LINE_SIZE);
 198         if (!pool)
 199                 return NULL;
 200         pool->cfg = *cfg;
 201         if (!pool->cfg.trunk_size)
 202                 pool->cfg.trunk_size = MLX5_IPOOL_DEFAULT_TRUNK_SIZE;
 203         if (!cfg->malloc && !cfg->free) {
 204                 pool->cfg.malloc = rte_malloc_socket;
 205                 pool->cfg.free = rte_free;
 206         }
 207         pool->free_list = TRUNK_INVALID;
 208         if (pool->cfg.need_lock)
 209                 rte_spinlock_init(&pool->lock);
 210         /*
 211          * Initialize the dynamic grow trunk size lookup table to have a quick
 212          * lookup for the trunk entry index offset.
 213          */
 214         for (i = 0; i < cfg->grow_trunk; i++) {
 215                 pool->grow_tbl[i] = cfg->trunk_size << (cfg->grow_shift * i);
 216                 if (i > 0)
 217                         pool->grow_tbl[i] += pool->grow_tbl[i - 1];
 218         }
 219         return pool;
 220 }
 221
 222 static int
 223 mlx5_ipool_grow(struct mlx5_indexed_pool *pool)
 224 {
 225         struct mlx5_indexed_trunk *trunk;
 226         struct mlx5_indexed_trunk **trunk_tmp;
 227         struct mlx5_indexed_trunk **p;
 228         size_t trunk_size = 0;
 229         size_t data_size;
 230         size_t bmp_size;
 231         uint32_t idx;
 232
 233         if (pool->n_trunk_valid == TRUNK_MAX_IDX)
 234                 return -ENOMEM;
 235         if (pool->n_trunk_valid == pool->n_trunk) {
 236                 /* No free trunk flags, expand trunk list. */
 237                 int n_grow = pool->n_trunk_valid ? pool->n_trunk :
 238                              RTE_CACHE_LINE_SIZE / sizeof(void *);
 239
 240                 p = pool->cfg.malloc(pool->cfg.type,
 241                                  (pool->n_trunk_valid + n_grow) *
 242                                  sizeof(struct mlx5_indexed_trunk *),
 243                                  RTE_CACHE_LINE_SIZE, rte_socket_id());
 244                 if (!p)
 245                         return -ENOMEM;
 246                 if (pool->trunks)
 247                         memcpy(p, pool->trunks, pool->n_trunk_valid *
 248                                sizeof(struct mlx5_indexed_trunk *));
 249                 memset(RTE_PTR_ADD(p, pool->n_trunk_valid * sizeof(void *)), 0,
 250                        n_grow * sizeof(void *));
 251                 trunk_tmp = pool->trunks;
 252                 pool->trunks = p;
 253                 if (trunk_tmp)
 254                         pool->cfg.free(trunk_tmp);
 255                 pool->n_trunk += n_grow;
 256         }
 257         if (!pool->cfg.release_mem_en) {
 258                 idx = pool->n_trunk_valid;
 259         } else {
 260                 /* Find the first available slot in trunk list */
 261                 for (idx = 0; idx < pool->n_trunk; idx++)
 262                         if (pool->trunks[idx] == NULL)
 263                                 break;
 264         }
 265         trunk_size += sizeof(*trunk);
 266         data_size = mlx5_trunk_size_get(pool, idx);
 267         bmp_size = rte_bitmap_get_memory_footprint(data_size);
 268         /* rte_bitmap requires memory cacheline aligned. */
 269         trunk_size += RTE_CACHE_LINE_ROUNDUP(data_size * pool->cfg.size);
 270         trunk_size += bmp_size;
 271         trunk = pool->cfg.malloc(pool->cfg.type, trunk_size,
 272                                  RTE_CACHE_LINE_SIZE, rte_socket_id());
 273         if (!trunk)
 274                 return -ENOMEM;
 275         pool->trunks[idx] = trunk;
 276         trunk->idx = idx;
 277         trunk->free = data_size;
 278         trunk->prev = TRUNK_INVALID;
 279         trunk->next = TRUNK_INVALID;
 280         MLX5_ASSERT(pool->free_list == TRUNK_INVALID);
 281         pool->free_list = idx;
 282         /* Mark all entries as available. */
 283         trunk->bmp = rte_bitmap_init_with_all_set(data_size, &trunk->data
 284                      [RTE_CACHE_LINE_ROUNDUP(data_size * pool->cfg.size)],
 285                      bmp_size);
 286         MLX5_ASSERT(trunk->bmp);
 287         pool->n_trunk_valid++;
 288 #ifdef POOL_DEBUG
 289         pool->trunk_new++;
 290         pool->trunk_avail++;
 291 #endif
 292         return 0;
 293 }
 294
 295 void *
 296 mlx5_ipool_malloc(struct mlx5_indexed_pool *pool, uint32_t *idx)
 297 {
 298         struct mlx5_indexed_trunk *trunk;
 299         uint64_t slab = 0;
 300         uint32_t iidx = 0;
 301         void *p;
 302
 303         mlx5_ipool_lock(pool);
 304         if (pool->free_list == TRUNK_INVALID) {
 305                 /* If no available trunks, grow new. */
 306                 if (mlx5_ipool_grow(pool)) {
 307                         mlx5_ipool_unlock(pool);
 308                         return NULL;
 309                 }
 310         }
 311         MLX5_ASSERT(pool->free_list != TRUNK_INVALID);
 312         trunk = pool->trunks[pool->free_list];
 313         MLX5_ASSERT(trunk->free);
 314         if (!rte_bitmap_scan(trunk->bmp, &iidx, &slab)) {
 315                 mlx5_ipool_unlock(pool);
 316                 return NULL;
 317         }
 318         MLX5_ASSERT(slab);
 319         iidx += __builtin_ctzll(slab);
 320         MLX5_ASSERT(iidx != UINT32_MAX);
 321         MLX5_ASSERT(iidx < mlx5_trunk_size_get(pool, trunk->idx));
 322         rte_bitmap_clear(trunk->bmp, iidx);
 323         p = &trunk->data[iidx * pool->cfg.size];
 324         iidx += mlx5_trunk_idx_offset_get(pool, trunk->idx);
 325         iidx += 1; /* non-zero index. */
 326         trunk->free--;
 327 #ifdef POOL_DEBUG
 328         pool->n_entry++;
 329 #endif
 330         if (!trunk->free) {
 331                 /* Full trunk will be removed from free list in imalloc. */
 332                 MLX5_ASSERT(pool->free_list == trunk->idx);
 333                 pool->free_list = trunk->next;
 334                 if (trunk->next != TRUNK_INVALID)
 335                         pool->trunks[trunk->next]->prev = TRUNK_INVALID;
 336                 trunk->prev = TRUNK_INVALID;
 337                 trunk->next = TRUNK_INVALID;
 338 #ifdef POOL_DEBUG
 339                 pool->trunk_empty++;
 340                 pool->trunk_avail--;
 341 #endif
 342         }
 343         *idx = iidx;
 344         mlx5_ipool_unlock(pool);
 345         return p;
 346 }
 347
 348 void *
 349 mlx5_ipool_zmalloc(struct mlx5_indexed_pool *pool, uint32_t *idx)
 350 {
 351         void *entry = mlx5_ipool_malloc(pool, idx);
 352
 353         if (entry)
 354                 memset(entry, 0, pool->cfg.size);
 355         return entry;
 356 }
 357
 358 void
 359 mlx5_ipool_free(struct mlx5_indexed_pool *pool, uint32_t idx)
 360 {
 361         struct mlx5_indexed_trunk *trunk;
 362         uint32_t trunk_idx;
 363         uint32_t entry_idx;
 364
 365         if (!idx)
 366                 return;
 367         idx -= 1;
 368         mlx5_ipool_lock(pool);
 369         trunk_idx = mlx5_trunk_idx_get(pool, idx);
 370         if ((!pool->cfg.release_mem_en && trunk_idx >= pool->n_trunk_valid) ||
 371             (pool->cfg.release_mem_en && trunk_idx >= pool->n_trunk))
 372                 goto out;
 373         trunk = pool->trunks[trunk_idx];
 374         if (!trunk)
 375                 goto out;
 376         entry_idx = idx - mlx5_trunk_idx_offset_get(pool, trunk->idx);
 377         if (trunk_idx != trunk->idx ||
 378             rte_bitmap_get(trunk->bmp, entry_idx))
 379                 goto out;
 380         rte_bitmap_set(trunk->bmp, entry_idx);
 381         trunk->free++;
 382         if (pool->cfg.release_mem_en && trunk->free == mlx5_trunk_size_get
 383            (pool, trunk->idx)) {
 384                 if (pool->free_list == trunk->idx)
 385                         pool->free_list = trunk->next;
 386                 if (trunk->next != TRUNK_INVALID)
 387                         pool->trunks[trunk->next]->prev = trunk->prev;
 388                 if (trunk->prev != TRUNK_INVALID)
 389                         pool->trunks[trunk->prev]->next = trunk->next;
 390                 pool->cfg.free(trunk);
 391                 pool->trunks[trunk_idx] = NULL;
 392                 pool->n_trunk_valid--;
 393 #ifdef POOL_DEBUG
 394                 pool->trunk_avail--;
 395                 pool->trunk_free++;
 396 #endif
 397                 if (pool->n_trunk_valid == 0) {
 398                         pool->cfg.free(pool->trunks);
 399                         pool->trunks = NULL;
 400                         pool->n_trunk = 0;
 401                 }
 402         } else if (trunk->free == 1) {
 403                 /* Put into free trunk list head. */
 404                 MLX5_ASSERT(pool->free_list != trunk->idx);
 405                 trunk->next = pool->free_list;
 406                 trunk->prev = TRUNK_INVALID;
 407                 if (pool->free_list != TRUNK_INVALID)
 408                         pool->trunks[pool->free_list]->prev = trunk->idx;
 409                 pool->free_list = trunk->idx;
 410 #ifdef POOL_DEBUG
 411                 pool->trunk_empty--;
 412                 pool->trunk_avail++;
 413 #endif
 414         }
 415 #ifdef POOL_DEBUG
 416         pool->n_entry--;
 417 #endif
 418 out:
 419         mlx5_ipool_unlock(pool);
 420 }
 421
 422 void *
 423 mlx5_ipool_get(struct mlx5_indexed_pool *pool, uint32_t idx)
 424 {
 425         struct mlx5_indexed_trunk *trunk;
 426         void *p = NULL;
 427         uint32_t trunk_idx;
 428         uint32_t entry_idx;
 429
 430         if (!idx)
 431                 return NULL;
 432         idx -= 1;
 433         mlx5_ipool_lock(pool);
 434         trunk_idx = mlx5_trunk_idx_get(pool, idx);
 435         if ((!pool->cfg.release_mem_en && trunk_idx >= pool->n_trunk_valid) ||
 436             (pool->cfg.release_mem_en && trunk_idx >= pool->n_trunk))
 437                 goto out;
 438         trunk = pool->trunks[trunk_idx];
 439         if (!trunk)
 440                 goto out;
 441         entry_idx = idx - mlx5_trunk_idx_offset_get(pool, trunk->idx);
 442         if (trunk_idx != trunk->idx ||
 443             rte_bitmap_get(trunk->bmp, entry_idx))
 444                 goto out;
 445         p = &trunk->data[entry_idx * pool->cfg.size];
 446 out:
 447         mlx5_ipool_unlock(pool);
 448         return p;
 449 }
 450
 451 int
 452 mlx5_ipool_destroy(struct mlx5_indexed_pool *pool)
 453 {
 454         struct mlx5_indexed_trunk **trunks;
 455         uint32_t i;
 456
 457         MLX5_ASSERT(pool);
 458         mlx5_ipool_lock(pool);
 459         trunks = pool->trunks;
 460         for (i = 0; i < pool->n_trunk; i++) {
 461                 if (trunks[i])
 462                         pool->cfg.free(trunks[i]);
 463         }
 464         if (!pool->trunks)
 465                 pool->cfg.free(pool->trunks);
 466         mlx5_ipool_unlock(pool);
 467         rte_free(pool);
 468         return 0;
 469 }
 470
 471 void
 472 mlx5_ipool_dump(struct mlx5_indexed_pool *pool)
 473 {
 474         printf("Pool %s entry size %u, trunks %u, %d entry per trunk, "
 475                "total: %d\n",
 476                pool->cfg.type, pool->cfg.size, pool->n_trunk_valid,
 477                pool->cfg.trunk_size, pool->n_trunk_valid);
 478 #ifdef POOL_DEBUG
 479         printf("Pool %s entry %u, trunk alloc %u, empty: %u, "
 480                "available %u free %u\n",
 481                pool->cfg.type, pool->n_entry, pool->trunk_new,
 482                pool->trunk_empty, pool->trunk_avail, pool->trunk_free);
 483 #endif
 484 }
 485
 486 struct mlx5_l3t_tbl *
 487 mlx5_l3t_create(enum mlx5_l3t_type type)
 488 {
 489         struct mlx5_l3t_tbl *tbl;
 490         struct mlx5_indexed_pool_config l3t_ip_cfg = {
 491                 .trunk_size = 16,
 492                 .grow_trunk = 6,
 493                 .grow_shift = 1,
 494                 .need_lock = 0,
 495                 .release_mem_en = 1,
 496                 .malloc = rte_malloc_socket,
 497                 .free = rte_free,
 498         };
 499
 500         if (type >= MLX5_L3T_TYPE_MAX) {
 501                 rte_errno = EINVAL;
 502                 return NULL;
 503         }
 504         tbl = rte_zmalloc(NULL, sizeof(struct mlx5_l3t_tbl), 1);
 505         if (!tbl) {
 506                 rte_errno = ENOMEM;
 507                 return NULL;
 508         }
 509         tbl->type = type;
 510         switch (type) {
 511         case MLX5_L3T_TYPE_WORD:
 512                 l3t_ip_cfg.size = sizeof(struct mlx5_l3t_entry_word) +
 513                                   sizeof(uint16_t) * MLX5_L3T_ET_SIZE;
 514                 l3t_ip_cfg.type = "mlx5_l3t_e_tbl_w";
 515                 break;
 516         case MLX5_L3T_TYPE_DWORD:
 517                 l3t_ip_cfg.size = sizeof(struct mlx5_l3t_entry_dword) +
 518                                   sizeof(uint32_t) * MLX5_L3T_ET_SIZE;
 519                 l3t_ip_cfg.type = "mlx5_l3t_e_tbl_dw";
 520                 break;
 521         case MLX5_L3T_TYPE_QWORD:
 522                 l3t_ip_cfg.size = sizeof(struct mlx5_l3t_entry_qword) +
 523                                   sizeof(uint64_t) * MLX5_L3T_ET_SIZE;
 524                 l3t_ip_cfg.type = "mlx5_l3t_e_tbl_qw";
 525                 break;
 526         default:
 527                 l3t_ip_cfg.size = sizeof(struct mlx5_l3t_entry_ptr) +
 528                                   sizeof(void *) * MLX5_L3T_ET_SIZE;
 529                 l3t_ip_cfg.type = "mlx5_l3t_e_tbl_tpr";
 530                 break;
 531         }
 532         tbl->eip = mlx5_ipool_create(&l3t_ip_cfg);
 533         if (!tbl->eip) {
 534                 rte_errno = ENOMEM;
 535                 rte_free(tbl);
 536                 tbl = NULL;
 537         }
 538         return tbl;
 539 }
 540
 541 void
 542 mlx5_l3t_destroy(struct mlx5_l3t_tbl *tbl)
 543 {
 544         struct mlx5_l3t_level_tbl *g_tbl, *m_tbl;
 545         uint32_t i, j;
 546
 547         if (!tbl)
 548                 return;
 549         g_tbl = tbl->tbl;
 550         if (g_tbl) {
 551                 for (i = 0; i < MLX5_L3T_GT_SIZE; i++) {
 552                         m_tbl = g_tbl->tbl[i];
 553                         if (!m_tbl)
 554                                 continue;
 555                         for (j = 0; j < MLX5_L3T_MT_SIZE; j++) {
 556                                 if (!m_tbl->tbl[j])
 557                                         continue;
 558                                 MLX5_ASSERT(!((struct mlx5_l3t_entry_word *)
 559                                             m_tbl->tbl[j])->ref_cnt);
 560                                 mlx5_ipool_free(tbl->eip,
 561                                                 ((struct mlx5_l3t_entry_word *)
 562                                                 m_tbl->tbl[j])->idx);
 563                                 m_tbl->tbl[j] = 0;
 564                                 if (!(--m_tbl->ref_cnt))
 565                                         break;
 566                         }
 567                         MLX5_ASSERT(!m_tbl->ref_cnt);
 568                         rte_free(g_tbl->tbl[i]);
 569                         g_tbl->tbl[i] = 0;
 570                         if (!(--g_tbl->ref_cnt))
 571                                 break;
 572                 }
 573                 MLX5_ASSERT(!g_tbl->ref_cnt);
 574                 rte_free(tbl->tbl);
 575                 tbl->tbl = 0;
 576         }
 577         mlx5_ipool_destroy(tbl->eip);
 578         rte_free(tbl);
 579 }
 580
 581 uint32_t
 582 mlx5_l3t_get_entry(struct mlx5_l3t_tbl *tbl, uint32_t idx,
 583                    union mlx5_l3t_data *data)
 584 {
 585         struct mlx5_l3t_level_tbl *g_tbl, *m_tbl;
 586         void *e_tbl;
 587         uint32_t entry_idx;
 588
 589         g_tbl = tbl->tbl;
 590         if (!g_tbl)
 591                 return -1;
 592         m_tbl = g_tbl->tbl[(idx >> MLX5_L3T_GT_OFFSET) & MLX5_L3T_GT_MASK];
 593         if (!m_tbl)
 594                 return -1;
 595         e_tbl = m_tbl->tbl[(idx >> MLX5_L3T_MT_OFFSET) & MLX5_L3T_MT_MASK];
 596         if (!e_tbl)
 597                 return -1;
 598         entry_idx = idx & MLX5_L3T_ET_MASK;
 599         switch (tbl->type) {
 600         case MLX5_L3T_TYPE_WORD:
 601                 data->word = ((struct mlx5_l3t_entry_word *)e_tbl)->entry
 602                              [entry_idx];
 603                 break;
 604         case MLX5_L3T_TYPE_DWORD:
 605                 data->dword = ((struct mlx5_l3t_entry_dword *)e_tbl)->entry
 606                              [entry_idx];
 607                 break;
 608         case MLX5_L3T_TYPE_QWORD:
 609                 data->qword = ((struct mlx5_l3t_entry_qword *)e_tbl)->entry
 610                               [entry_idx];
 611                 break;
 612         default:
 613                 data->ptr = ((struct mlx5_l3t_entry_ptr *)e_tbl)->entry
 614                             [entry_idx];
 615                 break;
 616         }
 617         return 0;
 618 }
 619
 620 void
 621 mlx5_l3t_clear_entry(struct mlx5_l3t_tbl *tbl, uint32_t idx)
 622 {
 623         struct mlx5_l3t_level_tbl *g_tbl, *m_tbl;
 624         struct mlx5_l3t_entry_word *w_e_tbl;
 625         struct mlx5_l3t_entry_dword *dw_e_tbl;
 626         struct mlx5_l3t_entry_qword *qw_e_tbl;
 627         struct mlx5_l3t_entry_ptr *ptr_e_tbl;
 628         void *e_tbl;
 629         uint32_t entry_idx;
 630         uint64_t ref_cnt;
 631
 632         g_tbl = tbl->tbl;
 633         if (!g_tbl)
 634                 return;
 635         m_tbl = g_tbl->tbl[(idx >> MLX5_L3T_GT_OFFSET) & MLX5_L3T_GT_MASK];
 636         if (!m_tbl)
 637                 return;
 638         e_tbl = m_tbl->tbl[(idx >> MLX5_L3T_MT_OFFSET) & MLX5_L3T_MT_MASK];
 639         if (!e_tbl)
 640                 return;
 641         entry_idx = idx & MLX5_L3T_ET_MASK;
 642         switch (tbl->type) {
 643         case MLX5_L3T_TYPE_WORD:
 644                 w_e_tbl = (struct mlx5_l3t_entry_word *)e_tbl;
 645                 w_e_tbl->entry[entry_idx] = 0;
 646                 ref_cnt = --w_e_tbl->ref_cnt;
 647                 break;
 648         case MLX5_L3T_TYPE_DWORD:
 649                 dw_e_tbl = (struct mlx5_l3t_entry_dword *)e_tbl;
 650                 dw_e_tbl->entry[entry_idx] = 0;
 651                 ref_cnt = --dw_e_tbl->ref_cnt;
 652                 break;
 653         case MLX5_L3T_TYPE_QWORD:
 654                 qw_e_tbl = (struct mlx5_l3t_entry_qword *)e_tbl;
 655                 qw_e_tbl->entry[entry_idx] = 0;
 656                 ref_cnt = --qw_e_tbl->ref_cnt;
 657                 break;
 658         default:
 659                 ptr_e_tbl = (struct mlx5_l3t_entry_ptr *)e_tbl;
 660                 ptr_e_tbl->entry[entry_idx] = NULL;
 661                 ref_cnt = --ptr_e_tbl->ref_cnt;
 662                 break;
 663         }
 664         if (!ref_cnt) {
 665                 mlx5_ipool_free(tbl->eip,
 666                                 ((struct mlx5_l3t_entry_word *)e_tbl)->idx);
 667                 m_tbl->tbl[(idx >> MLX5_L3T_MT_OFFSET) & MLX5_L3T_MT_MASK] =
 668                                                                         NULL;
 669                 if (!(--m_tbl->ref_cnt)) {
 670                         rte_free(m_tbl);
 671                         g_tbl->tbl
 672                         [(idx >> MLX5_L3T_GT_OFFSET) & MLX5_L3T_GT_MASK] = NULL;
 673                         if (!(--g_tbl->ref_cnt)) {
 674                                 rte_free(g_tbl);
 675                                 tbl->tbl = 0;
 676                         }
 677                 }
 678         }
 679 }
 680
 681 uint32_t
 682 mlx5_l3t_set_entry(struct mlx5_l3t_tbl *tbl, uint32_t idx,
 683                    union mlx5_l3t_data *data)
 684 {
 685         struct mlx5_l3t_level_tbl *g_tbl, *m_tbl;
 686         struct mlx5_l3t_entry_word *w_e_tbl;
 687         struct mlx5_l3t_entry_dword *dw_e_tbl;
 688         struct mlx5_l3t_entry_qword *qw_e_tbl;
 689         struct mlx5_l3t_entry_ptr *ptr_e_tbl;
 690         void *e_tbl;
 691         uint32_t entry_idx, tbl_idx = 0;
 692
 693         /* Check the global table, create it if empty. */
 694         g_tbl = tbl->tbl;
 695         if (!g_tbl) {
 696                 g_tbl = rte_zmalloc(NULL, sizeof(struct mlx5_l3t_level_tbl) +
 697                                     sizeof(void *) * MLX5_L3T_GT_SIZE, 1);
 698                 if (!g_tbl) {
 699                         rte_errno = ENOMEM;
 700                         return -1;
 701                 }
 702                 tbl->tbl = g_tbl;
 703         }
 704         /*
 705          * Check the middle table, create it if empty. Ref_cnt will be
 706          * increased if new sub table created.
 707          */
 708         m_tbl = g_tbl->tbl[(idx >> MLX5_L3T_GT_OFFSET) & MLX5_L3T_GT_MASK];
 709         if (!m_tbl) {
 710                 m_tbl = rte_zmalloc(NULL, sizeof(struct mlx5_l3t_level_tbl) +
 711                                     sizeof(void *) * MLX5_L3T_MT_SIZE, 1);
 712                 if (!m_tbl) {
 713                         rte_errno = ENOMEM;
 714                         return -1;
 715                 }
 716                 g_tbl->tbl[(idx >> MLX5_L3T_GT_OFFSET) & MLX5_L3T_GT_MASK] =
 717                                                                         m_tbl;
 718                 g_tbl->ref_cnt++;
 719         }
 720         /*
 721          * Check the entry table, create it if empty. Ref_cnt will be
 722          * increased if new sub entry table created.
 723          */
 724         e_tbl = m_tbl->tbl[(idx >> MLX5_L3T_MT_OFFSET) & MLX5_L3T_MT_MASK];
 725         if (!e_tbl) {
 726                 e_tbl = mlx5_ipool_zmalloc(tbl->eip, &tbl_idx);
 727                 if (!e_tbl) {
 728                         rte_errno = ENOMEM;
 729                         return -1;
 730                 }
 731                 ((struct mlx5_l3t_entry_word *)e_tbl)->idx = tbl_idx;
 732                 m_tbl->tbl[(idx >> MLX5_L3T_MT_OFFSET) & MLX5_L3T_MT_MASK] =
 733                                                                         e_tbl;
 734                 m_tbl->ref_cnt++;
 735         }
 736         entry_idx = idx & MLX5_L3T_ET_MASK;
 737         switch (tbl->type) {
 738         case MLX5_L3T_TYPE_WORD:
 739                 w_e_tbl = (struct mlx5_l3t_entry_word *)e_tbl;
 740                 w_e_tbl->entry[entry_idx] = data->word;
 741                 w_e_tbl->ref_cnt++;
 742                 break;
 743         case MLX5_L3T_TYPE_DWORD:
 744                 dw_e_tbl = (struct mlx5_l3t_entry_dword *)e_tbl;
 745                 dw_e_tbl->entry[entry_idx] = data->dword;
 746                 dw_e_tbl->ref_cnt++;
 747                 break;
 748         case MLX5_L3T_TYPE_QWORD:
 749                 qw_e_tbl = (struct mlx5_l3t_entry_qword *)e_tbl;
 750                 qw_e_tbl->entry[entry_idx] = data->qword;
 751                 qw_e_tbl->ref_cnt++;
 752                 break;
 753         default:
 754                 ptr_e_tbl = (struct mlx5_l3t_entry_ptr *)e_tbl;
 755                 ptr_e_tbl->entry[entry_idx] = data->ptr;
 756                 ptr_e_tbl->ref_cnt++;
 757                 break;
 758         }
 759         return 0;
 760 }