drivers/infiniband/sw/rxe/rxe_pool.c

   1 /*
   2  * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
   3  * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *         Redistribution and use in source and binary forms, with or
  12  *         without modification, are permitted provided that the following
  13  *         conditions are met:
  14  *
  15  *              - Redistributions of source code must retain the above
  16  *                copyright notice, this list of conditions and the following
  17  *                disclaimer.
  18  *
  19  *              - Redistributions in binary form must reproduce the above
  20  *                copyright notice, this list of conditions and the following
  21  *                disclaimer in the documentation and/or other materials
  22  *                provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #include "rxe.h"
  35 #include "rxe_loc.h"
  36
  37 /* info about object pools
  38  * note that mr and mw share a single index space
  39  * so that one can map an lkey to the correct type of object
  40  */
  41 struct rxe_type_info rxe_type_info[RXE_NUM_TYPES] = {
  42         [RXE_TYPE_UC] = {
  43                 .name           = "rxe-uc",
  44                 .size           = sizeof(struct rxe_ucontext),
  45         },
  46         [RXE_TYPE_PD] = {
  47                 .name           = "rxe-pd",
  48                 .size           = sizeof(struct rxe_pd),
  49                 .flags          = RXE_POOL_NO_ALLOC,
  50         },
  51         [RXE_TYPE_AH] = {
  52                 .name           = "rxe-ah",
  53                 .size           = sizeof(struct rxe_ah),
  54                 .flags          = RXE_POOL_ATOMIC,
  55         },
  56         [RXE_TYPE_SRQ] = {
  57                 .name           = "rxe-srq",
  58                 .size           = sizeof(struct rxe_srq),
  59                 .flags          = RXE_POOL_INDEX,
  60                 .min_index      = RXE_MIN_SRQ_INDEX,
  61                 .max_index      = RXE_MAX_SRQ_INDEX,
  62         },
  63         [RXE_TYPE_QP] = {
  64                 .name           = "rxe-qp",
  65                 .size           = sizeof(struct rxe_qp),
  66                 .cleanup        = rxe_qp_cleanup,
  67                 .flags          = RXE_POOL_INDEX,
  68                 .min_index      = RXE_MIN_QP_INDEX,
  69                 .max_index      = RXE_MAX_QP_INDEX,
  70         },
  71         [RXE_TYPE_CQ] = {
  72                 .name           = "rxe-cq",
  73                 .size           = sizeof(struct rxe_cq),
  74                 .cleanup        = rxe_cq_cleanup,
  75         },
  76         [RXE_TYPE_MR] = {
  77                 .name           = "rxe-mr",
  78                 .size           = sizeof(struct rxe_mem),
  79                 .cleanup        = rxe_mem_cleanup,
  80                 .flags          = RXE_POOL_INDEX,
  81                 .max_index      = RXE_MAX_MR_INDEX,
  82                 .min_index      = RXE_MIN_MR_INDEX,
  83         },
  84         [RXE_TYPE_MW] = {
  85                 .name           = "rxe-mw",
  86                 .size           = sizeof(struct rxe_mem),
  87                 .flags          = RXE_POOL_INDEX,
  88                 .max_index      = RXE_MAX_MW_INDEX,
  89                 .min_index      = RXE_MIN_MW_INDEX,
  90         },
  91         [RXE_TYPE_MC_GRP] = {
  92                 .name           = "rxe-mc_grp",
  93                 .size           = sizeof(struct rxe_mc_grp),
  94                 .cleanup        = rxe_mc_cleanup,
  95                 .flags          = RXE_POOL_KEY,
  96                 .key_offset     = offsetof(struct rxe_mc_grp, mgid),
  97                 .key_size       = sizeof(union ib_gid),
  98         },
  99         [RXE_TYPE_MC_ELEM] = {
 100                 .name           = "rxe-mc_elem",
 101                 .size           = sizeof(struct rxe_mc_elem),
 102                 .flags          = RXE_POOL_ATOMIC,
 103         },
 104 };
 105
 106 static inline const char *pool_name(struct rxe_pool *pool)
 107 {
 108         return rxe_type_info[pool->type].name;
 109 }
 110
 111 static inline struct kmem_cache *pool_cache(struct rxe_pool *pool)
 112 {
 113         return rxe_type_info[pool->type].cache;
 114 }
 115
 116 static void rxe_cache_clean(size_t cnt)
 117 {
 118         int i;
 119         struct rxe_type_info *type;
 120
 121         for (i = 0; i < cnt; i++) {
 122                 type = &rxe_type_info[i];
 123                 if (!(type->flags & RXE_POOL_NO_ALLOC)) {
 124                         kmem_cache_destroy(type->cache);
 125                         type->cache = NULL;
 126                 }
 127         }
 128 }
 129
 130 int rxe_cache_init(void)
 131 {
 132         int err;
 133         int i;
 134         size_t size;
 135         struct rxe_type_info *type;
 136
 137         for (i = 0; i < RXE_NUM_TYPES; i++) {
 138                 type = &rxe_type_info[i];
 139                 size = ALIGN(type->size, RXE_POOL_ALIGN);
 140                 if (!(type->flags & RXE_POOL_NO_ALLOC)) {
 141                         type->cache =
 142                                 kmem_cache_create(type->name, size,
 143                                                   RXE_POOL_ALIGN,
 144                                                   RXE_POOL_CACHE_FLAGS, NULL);
 145                         if (!type->cache) {
 146                                 pr_err("Unable to init kmem cache for %s\n",
 147                                        type->name);
 148                                 err = -ENOMEM;
 149                                 goto err1;
 150                         }
 151                 }
 152         }
 153
 154         return 0;
 155
 156 err1:
 157         rxe_cache_clean(i);
 158
 159         return err;
 160 }
 161
 162 void rxe_cache_exit(void)
 163 {
 164         rxe_cache_clean(RXE_NUM_TYPES);
 165 }
 166
 167 static int rxe_pool_init_index(struct rxe_pool *pool, u32 max, u32 min)
 168 {
 169         int err = 0;
 170         size_t size;
 171
 172         if ((max - min + 1) < pool->max_elem) {
 173                 pr_warn("not enough indices for max_elem\n");
 174                 err = -EINVAL;
 175                 goto out;
 176         }
 177
 178         pool->max_index = max;
 179         pool->min_index = min;
 180
 181         size = BITS_TO_LONGS(max - min + 1) * sizeof(long);
 182         pool->table = kmalloc(size, GFP_KERNEL);
 183         if (!pool->table) {
 184                 err = -ENOMEM;
 185                 goto out;
 186         }
 187
 188         pool->table_size = size;
 189         bitmap_zero(pool->table, max - min + 1);
 190
 191 out:
 192         return err;
 193 }
 194
 195 int rxe_pool_init(
 196         struct rxe_dev          *rxe,
 197         struct rxe_pool         *pool,
 198         enum rxe_elem_type      type,
 199         unsigned int            max_elem)
 200 {
 201         int                     err = 0;
 202         size_t                  size = rxe_type_info[type].size;
 203
 204         memset(pool, 0, sizeof(*pool));
 205
 206         pool->rxe               = rxe;
 207         pool->type              = type;
 208         pool->max_elem          = max_elem;
 209         pool->elem_size         = ALIGN(size, RXE_POOL_ALIGN);
 210         pool->flags             = rxe_type_info[type].flags;
 211         pool->tree              = RB_ROOT;
 212         pool->cleanup           = rxe_type_info[type].cleanup;
 213
 214         atomic_set(&pool->num_elem, 0);
 215
 216         kref_init(&pool->ref_cnt);
 217
 218         rwlock_init(&pool->pool_lock);
 219
 220         if (rxe_type_info[type].flags & RXE_POOL_INDEX) {
 221                 err = rxe_pool_init_index(pool,
 222                                           rxe_type_info[type].max_index,
 223                                           rxe_type_info[type].min_index);
 224                 if (err)
 225                         goto out;
 226         }
 227
 228         if (rxe_type_info[type].flags & RXE_POOL_KEY) {
 229                 pool->key_offset = rxe_type_info[type].key_offset;
 230                 pool->key_size = rxe_type_info[type].key_size;
 231         }
 232
 233         pool->state = RXE_POOL_STATE_VALID;
 234
 235 out:
 236         return err;
 237 }
 238
 239 static void rxe_pool_release(struct kref *kref)
 240 {
 241         struct rxe_pool *pool = container_of(kref, struct rxe_pool, ref_cnt);
 242
 243         pool->state = RXE_POOL_STATE_INVALID;
 244         kfree(pool->table);
 245 }
 246
 247 static void rxe_pool_put(struct rxe_pool *pool)
 248 {
 249         kref_put(&pool->ref_cnt, rxe_pool_release);
 250 }
 251
 252 void rxe_pool_cleanup(struct rxe_pool *pool)
 253 {
 254         unsigned long flags;
 255
 256         write_lock_irqsave(&pool->pool_lock, flags);
 257         pool->state = RXE_POOL_STATE_INVALID;
 258         if (atomic_read(&pool->num_elem) > 0)
 259                 pr_warn("%s pool destroyed with unfree'd elem\n",
 260                         pool_name(pool));
 261         write_unlock_irqrestore(&pool->pool_lock, flags);
 262
 263         rxe_pool_put(pool);
 264 }
 265
 266 static u32 alloc_index(struct rxe_pool *pool)
 267 {
 268         u32 index;
 269         u32 range = pool->max_index - pool->min_index + 1;
 270
 271         index = find_next_zero_bit(pool->table, range, pool->last);
 272         if (index >= range)
 273                 index = find_first_zero_bit(pool->table, range);
 274
 275         WARN_ON_ONCE(index >= range);
 276         set_bit(index, pool->table);
 277         pool->last = index;
 278         return index + pool->min_index;
 279 }
 280
 281 static void insert_index(struct rxe_pool *pool, struct rxe_pool_entry *new)
 282 {
 283         struct rb_node **link = &pool->tree.rb_node;
 284         struct rb_node *parent = NULL;
 285         struct rxe_pool_entry *elem;
 286
 287         while (*link) {
 288                 parent = *link;
 289                 elem = rb_entry(parent, struct rxe_pool_entry, node);
 290
 291                 if (elem->index == new->index) {
 292                         pr_warn("element already exists!\n");
 293                         goto out;
 294                 }
 295
 296                 if (elem->index > new->index)
 297                         link = &(*link)->rb_left;
 298                 else
 299                         link = &(*link)->rb_right;
 300         }
 301
 302         rb_link_node(&new->node, parent, link);
 303         rb_insert_color(&new->node, &pool->tree);
 304 out:
 305         return;
 306 }
 307
 308 static void insert_key(struct rxe_pool *pool, struct rxe_pool_entry *new)
 309 {
 310         struct rb_node **link = &pool->tree.rb_node;
 311         struct rb_node *parent = NULL;
 312         struct rxe_pool_entry *elem;
 313         int cmp;
 314
 315         while (*link) {
 316                 parent = *link;
 317                 elem = rb_entry(parent, struct rxe_pool_entry, node);
 318
 319                 cmp = memcmp((u8 *)elem + pool->key_offset,
 320                              (u8 *)new + pool->key_offset, pool->key_size);
 321
 322                 if (cmp == 0) {
 323                         pr_warn("key already exists!\n");
 324                         goto out;
 325                 }
 326
 327                 if (cmp > 0)
 328                         link = &(*link)->rb_left;
 329                 else
 330                         link = &(*link)->rb_right;
 331         }
 332
 333         rb_link_node(&new->node, parent, link);
 334         rb_insert_color(&new->node, &pool->tree);
 335 out:
 336         return;
 337 }
 338
 339 void rxe_add_key(void *arg, void *key)
 340 {
 341         struct rxe_pool_entry *elem = arg;
 342         struct rxe_pool *pool = elem->pool;
 343         unsigned long flags;
 344
 345         write_lock_irqsave(&pool->pool_lock, flags);
 346         memcpy((u8 *)elem + pool->key_offset, key, pool->key_size);
 347         insert_key(pool, elem);
 348         write_unlock_irqrestore(&pool->pool_lock, flags);
 349 }
 350
 351 void rxe_drop_key(void *arg)
 352 {
 353         struct rxe_pool_entry *elem = arg;
 354         struct rxe_pool *pool = elem->pool;
 355         unsigned long flags;
 356
 357         write_lock_irqsave(&pool->pool_lock, flags);
 358         rb_erase(&elem->node, &pool->tree);
 359         write_unlock_irqrestore(&pool->pool_lock, flags);
 360 }
 361
 362 void rxe_add_index(void *arg)
 363 {
 364         struct rxe_pool_entry *elem = arg;
 365         struct rxe_pool *pool = elem->pool;
 366         unsigned long flags;
 367
 368         write_lock_irqsave(&pool->pool_lock, flags);
 369         elem->index = alloc_index(pool);
 370         insert_index(pool, elem);
 371         write_unlock_irqrestore(&pool->pool_lock, flags);
 372 }
 373
 374 void rxe_drop_index(void *arg)
 375 {
 376         struct rxe_pool_entry *elem = arg;
 377         struct rxe_pool *pool = elem->pool;
 378         unsigned long flags;
 379
 380         write_lock_irqsave(&pool->pool_lock, flags);
 381         clear_bit(elem->index - pool->min_index, pool->table);
 382         rb_erase(&elem->node, &pool->tree);
 383         write_unlock_irqrestore(&pool->pool_lock, flags);
 384 }
 385
 386 void *rxe_alloc(struct rxe_pool *pool)
 387 {
 388         struct rxe_pool_entry *elem;
 389         unsigned long flags;
 390
 391         might_sleep_if(!(pool->flags & RXE_POOL_ATOMIC));
 392
 393         read_lock_irqsave(&pool->pool_lock, flags);
 394         if (pool->state != RXE_POOL_STATE_VALID) {
 395                 read_unlock_irqrestore(&pool->pool_lock, flags);
 396                 return NULL;
 397         }
 398         kref_get(&pool->ref_cnt);
 399         read_unlock_irqrestore(&pool->pool_lock, flags);
 400
 401         if (!ib_device_try_get(&pool->rxe->ib_dev))
 402                 goto out_put_pool;
 403
 404         if (atomic_inc_return(&pool->num_elem) > pool->max_elem)
 405                 goto out_cnt;
 406
 407         elem = kmem_cache_zalloc(pool_cache(pool),
 408                                  (pool->flags & RXE_POOL_ATOMIC) ?
 409                                  GFP_ATOMIC : GFP_KERNEL);
 410         if (!elem)
 411                 goto out_cnt;
 412
 413         elem->pool = pool;
 414         kref_init(&elem->ref_cnt);
 415
 416         return elem;
 417
 418 out_cnt:
 419         atomic_dec(&pool->num_elem);
 420         ib_device_put(&pool->rxe->ib_dev);
 421 out_put_pool:
 422         rxe_pool_put(pool);
 423         return NULL;
 424 }
 425
 426 int rxe_add_to_pool(struct rxe_pool *pool, struct rxe_pool_entry *elem)
 427 {
 428         unsigned long flags;
 429
 430         might_sleep_if(!(pool->flags & RXE_POOL_ATOMIC));
 431
 432         read_lock_irqsave(&pool->pool_lock, flags);
 433         if (pool->state != RXE_POOL_STATE_VALID) {
 434                 read_unlock_irqrestore(&pool->pool_lock, flags);
 435                 return -EINVAL;
 436         }
 437         kref_get(&pool->ref_cnt);
 438         read_unlock_irqrestore(&pool->pool_lock, flags);
 439
 440         if (!ib_device_try_get(&pool->rxe->ib_dev))
 441                 goto out_put_pool;
 442
 443         if (atomic_inc_return(&pool->num_elem) > pool->max_elem)
 444                 goto out_cnt;
 445
 446         elem->pool = pool;
 447         kref_init(&elem->ref_cnt);
 448
 449         return 0;
 450
 451 out_cnt:
 452         atomic_dec(&pool->num_elem);
 453         ib_device_put(&pool->rxe->ib_dev);
 454 out_put_pool:
 455         rxe_pool_put(pool);
 456         return -EINVAL;
 457 }
 458
 459 void rxe_elem_release(struct kref *kref)
 460 {
 461         struct rxe_pool_entry *elem =
 462                 container_of(kref, struct rxe_pool_entry, ref_cnt);
 463         struct rxe_pool *pool = elem->pool;
 464
 465         if (pool->cleanup)
 466                 pool->cleanup(elem);
 467
 468         if (!(pool->flags & RXE_POOL_NO_ALLOC))
 469                 kmem_cache_free(pool_cache(pool), elem);
 470         atomic_dec(&pool->num_elem);
 471         ib_device_put(&pool->rxe->ib_dev);
 472         rxe_pool_put(pool);
 473 }
 474
 475 void *rxe_pool_get_index(struct rxe_pool *pool, u32 index)
 476 {
 477         struct rb_node *node = NULL;
 478         struct rxe_pool_entry *elem = NULL;
 479         unsigned long flags;
 480
 481         read_lock_irqsave(&pool->pool_lock, flags);
 482
 483         if (pool->state != RXE_POOL_STATE_VALID)
 484                 goto out;
 485
 486         node = pool->tree.rb_node;
 487
 488         while (node) {
 489                 elem = rb_entry(node, struct rxe_pool_entry, node);
 490
 491                 if (elem->index > index)
 492                         node = node->rb_left;
 493                 else if (elem->index < index)
 494                         node = node->rb_right;
 495                 else {
 496                         kref_get(&elem->ref_cnt);
 497                         break;
 498                 }
 499         }
 500
 501 out:
 502         read_unlock_irqrestore(&pool->pool_lock, flags);
 503         return node ? elem : NULL;
 504 }
 505
 506 void *rxe_pool_get_key(struct rxe_pool *pool, void *key)
 507 {
 508         struct rb_node *node = NULL;
 509         struct rxe_pool_entry *elem = NULL;
 510         int cmp;
 511         unsigned long flags;
 512
 513         read_lock_irqsave(&pool->pool_lock, flags);
 514
 515         if (pool->state != RXE_POOL_STATE_VALID)
 516                 goto out;
 517
 518         node = pool->tree.rb_node;
 519
 520         while (node) {
 521                 elem = rb_entry(node, struct rxe_pool_entry, node);
 522
 523                 cmp = memcmp((u8 *)elem + pool->key_offset,
 524                              key, pool->key_size);
 525
 526                 if (cmp > 0)
 527                         node = node->rb_left;
 528                 else if (cmp < 0)
 529                         node = node->rb_right;
 530                 else
 531                         break;
 532         }
 533
 534         if (node)
 535                 kref_get(&elem->ref_cnt);
 536
 537 out:
 538         read_unlock_irqrestore(&pool->pool_lock, flags);
 539         return node ? elem : NULL;
 540 }