drivers/infiniband/core/rdma_core.c

   1 /*
   2  * Copyright (c) 2016, Mellanox Technologies inc.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/file.h>
  34 #include <linux/anon_inodes.h>
  35 #include <linux/sched/mm.h>
  36 #include <rdma/ib_verbs.h>
  37 #include <rdma/uverbs_types.h>
  38 #include <linux/rcupdate.h>
  39 #include <rdma/uverbs_ioctl.h>
  40 #include <rdma/rdma_user_ioctl.h>
  41 #include "uverbs.h"
  42 #include "core_priv.h"
  43 #include "rdma_core.h"
  44
  45 static void uverbs_uobject_free(struct kref *ref)
  46 {
  47         kfree_rcu(container_of(ref, struct ib_uobject, ref), rcu);
  48 }
  49
  50 /*
  51  * In order to indicate we no longer needs this uobject, uverbs_uobject_put
  52  * is called. When the reference count is decreased, the uobject is freed.
  53  * For example, this is used when attaching a completion channel to a CQ.
  54  */
  55 void uverbs_uobject_put(struct ib_uobject *uobject)
  56 {
  57         kref_put(&uobject->ref, uverbs_uobject_free);
  58 }
  59 EXPORT_SYMBOL(uverbs_uobject_put);
  60
  61 static int uverbs_try_lock_object(struct ib_uobject *uobj,
  62                                   enum rdma_lookup_mode mode)
  63 {
  64         /*
  65          * When a shared access is required, we use a positive counter. Each
  66          * shared access request checks that the value != -1 and increment it.
  67          * Exclusive access is required for operations like write or destroy.
  68          * In exclusive access mode, we check that the counter is zero (nobody
  69          * claimed this object) and we set it to -1. Releasing a shared access
  70          * lock is done simply by decreasing the counter. As for exclusive
  71          * access locks, since only a single one of them is is allowed
  72          * concurrently, setting the counter to zero is enough for releasing
  73          * this lock.
  74          */
  75         switch (mode) {
  76         case UVERBS_LOOKUP_READ:
  77                 return atomic_fetch_add_unless(&uobj->usecnt, 1, -1) == -1 ?
  78                         -EBUSY : 0;
  79         case UVERBS_LOOKUP_WRITE:
  80                 /* lock is exclusive */
  81                 return atomic_cmpxchg(&uobj->usecnt, 0, -1) == 0 ? 0 : -EBUSY;
  82         case UVERBS_LOOKUP_DESTROY:
  83                 return 0;
  84         }
  85         return 0;
  86 }
  87
  88 static void assert_uverbs_usecnt(struct ib_uobject *uobj,
  89                                  enum rdma_lookup_mode mode)
  90 {
  91 #ifdef CONFIG_LOCKDEP
  92         switch (mode) {
  93         case UVERBS_LOOKUP_READ:
  94                 WARN_ON(atomic_read(&uobj->usecnt) <= 0);
  95                 break;
  96         case UVERBS_LOOKUP_WRITE:
  97                 WARN_ON(atomic_read(&uobj->usecnt) != -1);
  98                 break;
  99         case UVERBS_LOOKUP_DESTROY:
 100                 break;
 101         }
 102 #endif
 103 }
 104
 105 /*
 106  * This must be called with the hw_destroy_rwsem locked for read or write,
 107  * also the uobject itself must be locked for write.
 108  *
 109  * Upon return the HW object is guaranteed to be destroyed.
 110  *
 111  * For RDMA_REMOVE_ABORT, the hw_destroy_rwsem is not required to be held,
 112  * however the type's allocat_commit function cannot have been called and the
 113  * uobject cannot be on the uobjects_lists
 114  *
 115  * For RDMA_REMOVE_DESTROY the caller shold be holding a kref (eg via
 116  * rdma_lookup_get_uobject) and the object is left in a state where the caller
 117  * needs to call rdma_lookup_put_uobject.
 118  *
 119  * For all other destroy modes this function internally unlocks the uobject
 120  * and consumes the kref on the uobj.
 121  */
 122 static int uverbs_destroy_uobject(struct ib_uobject *uobj,
 123                                   enum rdma_remove_reason reason,
 124                                   struct uverbs_attr_bundle *attrs)
 125 {
 126         struct ib_uverbs_file *ufile = attrs->ufile;
 127         unsigned long flags;
 128         int ret;
 129
 130         lockdep_assert_held(&ufile->hw_destroy_rwsem);
 131         assert_uverbs_usecnt(uobj, UVERBS_LOOKUP_WRITE);
 132
 133         if (reason == RDMA_REMOVE_ABORT_HWOBJ) {
 134                 reason = RDMA_REMOVE_ABORT;
 135                 ret = uobj->uapi_object->type_class->destroy_hw(uobj, reason,
 136                                                                 attrs);
 137                 /*
 138                  * Drivers are not permitted to ignore RDMA_REMOVE_ABORT, see
 139                  * ib_is_destroy_retryable, cleanup_retryable == false here.
 140                  */
 141                 WARN_ON(ret);
 142         }
 143
 144         if (reason == RDMA_REMOVE_ABORT) {
 145                 WARN_ON(!list_empty(&uobj->list));
 146                 WARN_ON(!uobj->context);
 147                 uobj->uapi_object->type_class->alloc_abort(uobj);
 148         } else if (uobj->object) {
 149                 ret = uobj->uapi_object->type_class->destroy_hw(uobj, reason,
 150                                                                 attrs);
 151                 if (ret) {
 152                         if (ib_is_destroy_retryable(ret, reason, uobj))
 153                                 return ret;
 154
 155                         /* Nothing to be done, dangle the memory and move on */
 156                         WARN(true,
 157                              "ib_uverbs: failed to remove uobject id %d, driver err=%d",
 158                              uobj->id, ret);
 159                 }
 160
 161                 uobj->object = NULL;
 162         }
 163
 164         uobj->context = NULL;
 165
 166         /*
 167          * For DESTROY the usecnt is not changed, the caller is expected to
 168          * manage it via uobj_put_destroy(). Only DESTROY can remove the IDR
 169          * handle.
 170          */
 171         if (reason != RDMA_REMOVE_DESTROY)
 172                 atomic_set(&uobj->usecnt, 0);
 173         else
 174                 uobj->uapi_object->type_class->remove_handle(uobj);
 175
 176         if (!list_empty(&uobj->list)) {
 177                 spin_lock_irqsave(&ufile->uobjects_lock, flags);
 178                 list_del_init(&uobj->list);
 179                 spin_unlock_irqrestore(&ufile->uobjects_lock, flags);
 180
 181                 /*
 182                  * Pairs with the get in rdma_alloc_commit_uobject(), could
 183                  * destroy uobj.
 184                  */
 185                 uverbs_uobject_put(uobj);
 186         }
 187
 188         /*
 189          * When aborting the stack kref remains owned by the core code, and is
 190          * not transferred into the type. Pairs with the get in alloc_uobj
 191          */
 192         if (reason == RDMA_REMOVE_ABORT)
 193                 uverbs_uobject_put(uobj);
 194
 195         return 0;
 196 }
 197
 198 /*
 199  * This calls uverbs_destroy_uobject() using the RDMA_REMOVE_DESTROY
 200  * sequence. It should only be used from command callbacks. On success the
 201  * caller must pair this with uobj_put_destroy(). This
 202  * version requires the caller to have already obtained an
 203  * LOOKUP_DESTROY uobject kref.
 204  */
 205 int uobj_destroy(struct ib_uobject *uobj, struct uverbs_attr_bundle *attrs)
 206 {
 207         struct ib_uverbs_file *ufile = attrs->ufile;
 208         int ret;
 209
 210         down_read(&ufile->hw_destroy_rwsem);
 211
 212         /*
 213          * Once the uobject is destroyed by RDMA_REMOVE_DESTROY then it is left
 214          * write locked as the callers put it back with UVERBS_LOOKUP_DESTROY.
 215          * This is because any other concurrent thread can still see the object
 216          * in the xarray due to RCU. Leaving it locked ensures nothing else will
 217          * touch it.
 218          */
 219         ret = uverbs_try_lock_object(uobj, UVERBS_LOOKUP_WRITE);
 220         if (ret)
 221                 goto out_unlock;
 222
 223         ret = uverbs_destroy_uobject(uobj, RDMA_REMOVE_DESTROY, attrs);
 224         if (ret) {
 225                 atomic_set(&uobj->usecnt, 0);
 226                 goto out_unlock;
 227         }
 228
 229 out_unlock:
 230         up_read(&ufile->hw_destroy_rwsem);
 231         return ret;
 232 }
 233
 234 /*
 235  * uobj_get_destroy destroys the HW object and returns a handle to the uobj
 236  * with a NULL object pointer. The caller must pair this with
 237  * uobj_put_destroy().
 238  */
 239 struct ib_uobject *__uobj_get_destroy(const struct uverbs_api_object *obj,
 240                                       u32 id, struct uverbs_attr_bundle *attrs)
 241 {
 242         struct ib_uobject *uobj;
 243         int ret;
 244
 245         uobj = rdma_lookup_get_uobject(obj, attrs->ufile, id,
 246                                        UVERBS_LOOKUP_DESTROY, attrs);
 247         if (IS_ERR(uobj))
 248                 return uobj;
 249
 250         ret = uobj_destroy(uobj, attrs);
 251         if (ret) {
 252                 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_DESTROY);
 253                 return ERR_PTR(ret);
 254         }
 255
 256         return uobj;
 257 }
 258
 259 /*
 260  * Does both uobj_get_destroy() and uobj_put_destroy().  Returns 0 on success
 261  * (negative errno on failure). For use by callers that do not need the uobj.
 262  */
 263 int __uobj_perform_destroy(const struct uverbs_api_object *obj, u32 id,
 264                            struct uverbs_attr_bundle *attrs)
 265 {
 266         struct ib_uobject *uobj;
 267
 268         uobj = __uobj_get_destroy(obj, id, attrs);
 269         if (IS_ERR(uobj))
 270                 return PTR_ERR(uobj);
 271         uobj_put_destroy(uobj);
 272         return 0;
 273 }
 274
 275 /* alloc_uobj must be undone by uverbs_destroy_uobject() */
 276 static struct ib_uobject *alloc_uobj(struct uverbs_attr_bundle *attrs,
 277                                      const struct uverbs_api_object *obj)
 278 {
 279         struct ib_uverbs_file *ufile = attrs->ufile;
 280         struct ib_uobject *uobj;
 281
 282         if (!attrs->context) {
 283                 struct ib_ucontext *ucontext =
 284                         ib_uverbs_get_ucontext_file(ufile);
 285
 286                 if (IS_ERR(ucontext))
 287                         return ERR_CAST(ucontext);
 288                 attrs->context = ucontext;
 289         }
 290
 291         uobj = kzalloc(obj->type_attrs->obj_size, GFP_KERNEL);
 292         if (!uobj)
 293                 return ERR_PTR(-ENOMEM);
 294         /*
 295          * user_handle should be filled by the handler,
 296          * The object is added to the list in the commit stage.
 297          */
 298         uobj->ufile = ufile;
 299         uobj->context = attrs->context;
 300         INIT_LIST_HEAD(&uobj->list);
 301         uobj->uapi_object = obj;
 302         /*
 303          * Allocated objects start out as write locked to deny any other
 304          * syscalls from accessing them until they are committed. See
 305          * rdma_alloc_commit_uobject
 306          */
 307         atomic_set(&uobj->usecnt, -1);
 308         kref_init(&uobj->ref);
 309
 310         return uobj;
 311 }
 312
 313 static int idr_add_uobj(struct ib_uobject *uobj)
 314 {
 315        /*
 316         * We start with allocating an idr pointing to NULL. This represents an
 317         * object which isn't initialized yet. We'll replace it later on with
 318         * the real object once we commit.
 319         */
 320         return xa_alloc(&uobj->ufile->idr, &uobj->id, NULL, xa_limit_32b,
 321                         GFP_KERNEL);
 322 }
 323
 324 /* Returns the ib_uobject or an error. The caller should check for IS_ERR. */
 325 static struct ib_uobject *
 326 lookup_get_idr_uobject(const struct uverbs_api_object *obj,
 327                        struct ib_uverbs_file *ufile, s64 id,
 328                        enum rdma_lookup_mode mode)
 329 {
 330         struct ib_uobject *uobj;
 331
 332         if (id < 0 || id > ULONG_MAX)
 333                 return ERR_PTR(-EINVAL);
 334
 335         rcu_read_lock();
 336         /*
 337          * The idr_find is guaranteed to return a pointer to something that
 338          * isn't freed yet, or NULL, as the free after idr_remove goes through
 339          * kfree_rcu(). However the object may still have been released and
 340          * kfree() could be called at any time.
 341          */
 342         uobj = xa_load(&ufile->idr, id);
 343         if (!uobj || !kref_get_unless_zero(&uobj->ref))
 344                 uobj = ERR_PTR(-ENOENT);
 345         rcu_read_unlock();
 346         return uobj;
 347 }
 348
 349 static struct ib_uobject *
 350 lookup_get_fd_uobject(const struct uverbs_api_object *obj,
 351                       struct ib_uverbs_file *ufile, s64 id,
 352                       enum rdma_lookup_mode mode)
 353 {
 354         const struct uverbs_obj_fd_type *fd_type;
 355         struct file *f;
 356         struct ib_uobject *uobject;
 357         int fdno = id;
 358
 359         if (fdno != id)
 360                 return ERR_PTR(-EINVAL);
 361
 362         if (mode != UVERBS_LOOKUP_READ)
 363                 return ERR_PTR(-EOPNOTSUPP);
 364
 365         if (!obj->type_attrs)
 366                 return ERR_PTR(-EIO);
 367         fd_type =
 368                 container_of(obj->type_attrs, struct uverbs_obj_fd_type, type);
 369
 370         f = fget(fdno);
 371         if (!f)
 372                 return ERR_PTR(-EBADF);
 373
 374         uobject = f->private_data;
 375         /*
 376          * fget(id) ensures we are not currently running
 377          * uverbs_uobject_fd_release(), and the caller is expected to ensure
 378          * that release is never done while a call to lookup is possible.
 379          */
 380         if (f->f_op != fd_type->fops || uobject->ufile != ufile) {
 381                 fput(f);
 382                 return ERR_PTR(-EBADF);
 383         }
 384
 385         uverbs_uobject_get(uobject);
 386         return uobject;
 387 }
 388
 389 struct ib_uobject *rdma_lookup_get_uobject(const struct uverbs_api_object *obj,
 390                                            struct ib_uverbs_file *ufile, s64 id,
 391                                            enum rdma_lookup_mode mode,
 392                                            struct uverbs_attr_bundle *attrs)
 393 {
 394         struct ib_uobject *uobj;
 395         int ret;
 396
 397         if (obj == ERR_PTR(-ENOMSG)) {
 398                 /* must be UVERBS_IDR_ANY_OBJECT, see uapi_get_object() */
 399                 uobj = lookup_get_idr_uobject(NULL, ufile, id, mode);
 400                 if (IS_ERR(uobj))
 401                         return uobj;
 402         } else {
 403                 if (IS_ERR(obj))
 404                         return ERR_PTR(-EINVAL);
 405
 406                 uobj = obj->type_class->lookup_get(obj, ufile, id, mode);
 407                 if (IS_ERR(uobj))
 408                         return uobj;
 409
 410                 if (uobj->uapi_object != obj) {
 411                         ret = -EINVAL;
 412                         goto free;
 413                 }
 414         }
 415
 416         /*
 417          * If we have been disassociated block every command except for
 418          * DESTROY based commands.
 419          */
 420         if (mode != UVERBS_LOOKUP_DESTROY &&
 421             !srcu_dereference(ufile->device->ib_dev,
 422                               &ufile->device->disassociate_srcu)) {
 423                 ret = -EIO;
 424                 goto free;
 425         }
 426
 427         ret = uverbs_try_lock_object(uobj, mode);
 428         if (ret)
 429                 goto free;
 430         if (attrs)
 431                 attrs->context = uobj->context;
 432
 433         return uobj;
 434 free:
 435         uobj->uapi_object->type_class->lookup_put(uobj, mode);
 436         uverbs_uobject_put(uobj);
 437         return ERR_PTR(ret);
 438 }
 439
 440 static struct ib_uobject *
 441 alloc_begin_idr_uobject(const struct uverbs_api_object *obj,
 442                         struct uverbs_attr_bundle *attrs)
 443 {
 444         int ret;
 445         struct ib_uobject *uobj;
 446
 447         uobj = alloc_uobj(attrs, obj);
 448         if (IS_ERR(uobj))
 449                 return uobj;
 450
 451         ret = idr_add_uobj(uobj);
 452         if (ret)
 453                 goto uobj_put;
 454
 455         ret = ib_rdmacg_try_charge(&uobj->cg_obj, uobj->context->device,
 456                                    RDMACG_RESOURCE_HCA_OBJECT);
 457         if (ret)
 458                 goto remove;
 459
 460         return uobj;
 461
 462 remove:
 463         xa_erase(&attrs->ufile->idr, uobj->id);
 464 uobj_put:
 465         uverbs_uobject_put(uobj);
 466         return ERR_PTR(ret);
 467 }
 468
 469 static struct ib_uobject *
 470 alloc_begin_fd_uobject(const struct uverbs_api_object *obj,
 471                        struct uverbs_attr_bundle *attrs)
 472 {
 473         const struct uverbs_obj_fd_type *fd_type;
 474         int new_fd;
 475         struct ib_uobject *uobj, *ret;
 476         struct file *filp;
 477
 478         uobj = alloc_uobj(attrs, obj);
 479         if (IS_ERR(uobj))
 480                 return uobj;
 481
 482         fd_type =
 483                 container_of(obj->type_attrs, struct uverbs_obj_fd_type, type);
 484         if (WARN_ON(fd_type->fops->release != &uverbs_uobject_fd_release &&
 485                     fd_type->fops->release != &uverbs_async_event_release)) {
 486                 ret = ERR_PTR(-EINVAL);
 487                 goto err_fd;
 488         }
 489
 490         new_fd = get_unused_fd_flags(O_CLOEXEC);
 491         if (new_fd < 0) {
 492                 ret = ERR_PTR(new_fd);
 493                 goto err_fd;
 494         }
 495
 496         /* Note that uverbs_uobject_fd_release() is called during abort */
 497         filp = anon_inode_getfile(fd_type->name, fd_type->fops, NULL,
 498                                   fd_type->flags);
 499         if (IS_ERR(filp)) {
 500                 ret = ERR_CAST(filp);
 501                 goto err_getfile;
 502         }
 503         uobj->object = filp;
 504
 505         uobj->id = new_fd;
 506         return uobj;
 507
 508 err_getfile:
 509         put_unused_fd(new_fd);
 510 err_fd:
 511         uverbs_uobject_put(uobj);
 512         return ret;
 513 }
 514
 515 struct ib_uobject *rdma_alloc_begin_uobject(const struct uverbs_api_object *obj,
 516                                             struct uverbs_attr_bundle *attrs)
 517 {
 518         struct ib_uverbs_file *ufile = attrs->ufile;
 519         struct ib_uobject *ret;
 520
 521         if (IS_ERR(obj))
 522                 return ERR_PTR(-EINVAL);
 523
 524         /*
 525          * The hw_destroy_rwsem is held across the entire object creation and
 526          * released during rdma_alloc_commit_uobject or
 527          * rdma_alloc_abort_uobject
 528          */
 529         if (!down_read_trylock(&ufile->hw_destroy_rwsem))
 530                 return ERR_PTR(-EIO);
 531
 532         ret = obj->type_class->alloc_begin(obj, attrs);
 533         if (IS_ERR(ret)) {
 534                 up_read(&ufile->hw_destroy_rwsem);
 535                 return ret;
 536         }
 537         return ret;
 538 }
 539
 540 static void alloc_abort_idr_uobject(struct ib_uobject *uobj)
 541 {
 542         ib_rdmacg_uncharge(&uobj->cg_obj, uobj->context->device,
 543                            RDMACG_RESOURCE_HCA_OBJECT);
 544
 545         xa_erase(&uobj->ufile->idr, uobj->id);
 546 }
 547
 548 static int __must_check destroy_hw_idr_uobject(struct ib_uobject *uobj,
 549                                                enum rdma_remove_reason why,
 550                                                struct uverbs_attr_bundle *attrs)
 551 {
 552         const struct uverbs_obj_idr_type *idr_type =
 553                 container_of(uobj->uapi_object->type_attrs,
 554                              struct uverbs_obj_idr_type, type);
 555         int ret = idr_type->destroy_object(uobj, why, attrs);
 556
 557         /*
 558          * We can only fail gracefully if the user requested to destroy the
 559          * object or when a retry may be called upon an error.
 560          * In the rest of the cases, just remove whatever you can.
 561          */
 562         if (ib_is_destroy_retryable(ret, why, uobj))
 563                 return ret;
 564
 565         if (why == RDMA_REMOVE_ABORT)
 566                 return 0;
 567
 568         ib_rdmacg_uncharge(&uobj->cg_obj, uobj->context->device,
 569                            RDMACG_RESOURCE_HCA_OBJECT);
 570
 571         return 0;
 572 }
 573
 574 static void remove_handle_idr_uobject(struct ib_uobject *uobj)
 575 {
 576         xa_erase(&uobj->ufile->idr, uobj->id);
 577         /* Matches the kref in alloc_commit_idr_uobject */
 578         uverbs_uobject_put(uobj);
 579 }
 580
 581 static void alloc_abort_fd_uobject(struct ib_uobject *uobj)
 582 {
 583         struct file *filp = uobj->object;
 584
 585         fput(filp);
 586         put_unused_fd(uobj->id);
 587 }
 588
 589 static int __must_check destroy_hw_fd_uobject(struct ib_uobject *uobj,
 590                                               enum rdma_remove_reason why,
 591                                               struct uverbs_attr_bundle *attrs)
 592 {
 593         const struct uverbs_obj_fd_type *fd_type = container_of(
 594                 uobj->uapi_object->type_attrs, struct uverbs_obj_fd_type, type);
 595         int ret = fd_type->destroy_object(uobj, why);
 596
 597         if (ib_is_destroy_retryable(ret, why, uobj))
 598                 return ret;
 599
 600         return 0;
 601 }
 602
 603 static void remove_handle_fd_uobject(struct ib_uobject *uobj)
 604 {
 605 }
 606
 607 static void alloc_commit_idr_uobject(struct ib_uobject *uobj)
 608 {
 609         struct ib_uverbs_file *ufile = uobj->ufile;
 610         void *old;
 611
 612         /*
 613          * We already allocated this IDR with a NULL object, so
 614          * this shouldn't fail.
 615          *
 616          * NOTE: Storing the uobj transfers our kref on uobj to the XArray.
 617          * It will be put by remove_commit_idr_uobject()
 618          */
 619         old = xa_store(&ufile->idr, uobj->id, uobj, GFP_KERNEL);
 620         WARN_ON(old != NULL);
 621 }
 622
 623 static void alloc_commit_fd_uobject(struct ib_uobject *uobj)
 624 {
 625         int fd = uobj->id;
 626         struct file *filp = uobj->object;
 627
 628         /* Matching put will be done in uverbs_uobject_fd_release() */
 629         kref_get(&uobj->ufile->ref);
 630
 631         /* This shouldn't be used anymore. Use the file object instead */
 632         uobj->id = 0;
 633
 634         /*
 635          * NOTE: Once we install the file we loose ownership of our kref on
 636          * uobj. It will be put by uverbs_uobject_fd_release()
 637          */
 638         filp->private_data = uobj;
 639         fd_install(fd, filp);
 640 }
 641
 642 /*
 643  * In all cases rdma_alloc_commit_uobject() consumes the kref to uobj and the
 644  * caller can no longer assume uobj is valid. If this function fails it
 645  * destroys the uboject, including the attached HW object.
 646  */
 647 void rdma_alloc_commit_uobject(struct ib_uobject *uobj,
 648                                struct uverbs_attr_bundle *attrs)
 649 {
 650         struct ib_uverbs_file *ufile = attrs->ufile;
 651
 652         /* kref is held so long as the uobj is on the uobj list. */
 653         uverbs_uobject_get(uobj);
 654         spin_lock_irq(&ufile->uobjects_lock);
 655         list_add(&uobj->list, &ufile->uobjects);
 656         spin_unlock_irq(&ufile->uobjects_lock);
 657
 658         /* matches atomic_set(-1) in alloc_uobj */
 659         atomic_set(&uobj->usecnt, 0);
 660
 661         /* alloc_commit consumes the uobj kref */
 662         uobj->uapi_object->type_class->alloc_commit(uobj);
 663
 664         /* Matches the down_read in rdma_alloc_begin_uobject */
 665         up_read(&ufile->hw_destroy_rwsem);
 666 }
 667
 668 /*
 669  * This consumes the kref for uobj. It is up to the caller to unwind the HW
 670  * object and anything else connected to uobj before calling this.
 671  */
 672 void rdma_alloc_abort_uobject(struct ib_uobject *uobj,
 673                               struct uverbs_attr_bundle *attrs,
 674                               bool hw_obj_valid)
 675 {
 676         struct ib_uverbs_file *ufile = uobj->ufile;
 677
 678         uverbs_destroy_uobject(uobj,
 679                                hw_obj_valid ? RDMA_REMOVE_ABORT_HWOBJ :
 680                                               RDMA_REMOVE_ABORT,
 681                                attrs);
 682
 683         /* Matches the down_read in rdma_alloc_begin_uobject */
 684         up_read(&ufile->hw_destroy_rwsem);
 685 }
 686
 687 static void lookup_put_idr_uobject(struct ib_uobject *uobj,
 688                                    enum rdma_lookup_mode mode)
 689 {
 690 }
 691
 692 static void lookup_put_fd_uobject(struct ib_uobject *uobj,
 693                                   enum rdma_lookup_mode mode)
 694 {
 695         struct file *filp = uobj->object;
 696
 697         WARN_ON(mode != UVERBS_LOOKUP_READ);
 698         /*
 699          * This indirectly calls uverbs_uobject_fd_release() and free the
 700          * object
 701          */
 702         fput(filp);
 703 }
 704
 705 void rdma_lookup_put_uobject(struct ib_uobject *uobj,
 706                              enum rdma_lookup_mode mode)
 707 {
 708         assert_uverbs_usecnt(uobj, mode);
 709         /*
 710          * In order to unlock an object, either decrease its usecnt for
 711          * read access or zero it in case of exclusive access. See
 712          * uverbs_try_lock_object for locking schema information.
 713          */
 714         switch (mode) {
 715         case UVERBS_LOOKUP_READ:
 716                 atomic_dec(&uobj->usecnt);
 717                 break;
 718         case UVERBS_LOOKUP_WRITE:
 719                 atomic_set(&uobj->usecnt, 0);
 720                 break;
 721         case UVERBS_LOOKUP_DESTROY:
 722                 break;
 723         }
 724
 725         uobj->uapi_object->type_class->lookup_put(uobj, mode);
 726         /* Pairs with the kref obtained by type->lookup_get */
 727         uverbs_uobject_put(uobj);
 728 }
 729
 730 void setup_ufile_idr_uobject(struct ib_uverbs_file *ufile)
 731 {
 732         xa_init_flags(&ufile->idr, XA_FLAGS_ALLOC);
 733 }
 734
 735 void release_ufile_idr_uobject(struct ib_uverbs_file *ufile)
 736 {
 737         struct ib_uobject *entry;
 738         unsigned long id;
 739
 740         /*
 741          * At this point uverbs_cleanup_ufile() is guaranteed to have run, and
 742          * there are no HW objects left, however the xarray is still populated
 743          * with anything that has not been cleaned up by userspace. Since the
 744          * kref on ufile is 0, nothing is allowed to call lookup_get.
 745          *
 746          * This is an optimized equivalent to remove_handle_idr_uobject
 747          */
 748         xa_for_each(&ufile->idr, id, entry) {
 749                 WARN_ON(entry->object);
 750                 uverbs_uobject_put(entry);
 751         }
 752
 753         xa_destroy(&ufile->idr);
 754 }
 755
 756 const struct uverbs_obj_type_class uverbs_idr_class = {
 757         .alloc_begin = alloc_begin_idr_uobject,
 758         .lookup_get = lookup_get_idr_uobject,
 759         .alloc_commit = alloc_commit_idr_uobject,
 760         .alloc_abort = alloc_abort_idr_uobject,
 761         .lookup_put = lookup_put_idr_uobject,
 762         .destroy_hw = destroy_hw_idr_uobject,
 763         .remove_handle = remove_handle_idr_uobject,
 764 };
 765 EXPORT_SYMBOL(uverbs_idr_class);
 766
 767 /*
 768  * Users of UVERBS_TYPE_ALLOC_FD should set this function as the struct
 769  * file_operations release method.
 770  */
 771 int uverbs_uobject_fd_release(struct inode *inode, struct file *filp)
 772 {
 773         struct ib_uverbs_file *ufile;
 774         struct ib_uobject *uobj;
 775
 776         /*
 777          * This can only happen if the fput came from alloc_abort_fd_uobject()
 778          */
 779         if (!filp->private_data)
 780                 return 0;
 781         uobj = filp->private_data;
 782         ufile = uobj->ufile;
 783
 784         if (down_read_trylock(&ufile->hw_destroy_rwsem)) {
 785                 struct uverbs_attr_bundle attrs = {
 786                         .context = uobj->context,
 787                         .ufile = ufile,
 788                 };
 789
 790                 /*
 791                  * lookup_get_fd_uobject holds the kref on the struct file any
 792                  * time a FD uobj is locked, which prevents this release
 793                  * method from being invoked. Meaning we can always get the
 794                  * write lock here, or we have a kernel bug.
 795                  */
 796                 WARN_ON(uverbs_try_lock_object(uobj, UVERBS_LOOKUP_WRITE));
 797                 uverbs_destroy_uobject(uobj, RDMA_REMOVE_CLOSE, &attrs);
 798                 up_read(&ufile->hw_destroy_rwsem);
 799         }
 800
 801         /* Matches the get in alloc_commit_fd_uobject() */
 802         kref_put(&ufile->ref, ib_uverbs_release_file);
 803
 804         /* Pairs with filp->private_data in alloc_begin_fd_uobject */
 805         uverbs_uobject_put(uobj);
 806         return 0;
 807 }
 808 EXPORT_SYMBOL(uverbs_uobject_fd_release);
 809
 810 /*
 811  * Drop the ucontext off the ufile and completely disconnect it from the
 812  * ib_device
 813  */
 814 static void ufile_destroy_ucontext(struct ib_uverbs_file *ufile,
 815                                    enum rdma_remove_reason reason)
 816 {
 817         struct ib_ucontext *ucontext = ufile->ucontext;
 818         struct ib_device *ib_dev = ucontext->device;
 819
 820         /*
 821          * If we are closing the FD then the user mmap VMAs must have
 822          * already been destroyed as they hold on to the filep, otherwise
 823          * they need to be zap'd.
 824          */
 825         if (reason == RDMA_REMOVE_DRIVER_REMOVE) {
 826                 uverbs_user_mmap_disassociate(ufile);
 827                 if (ib_dev->ops.disassociate_ucontext)
 828                         ib_dev->ops.disassociate_ucontext(ucontext);
 829         }
 830
 831         ib_rdmacg_uncharge(&ucontext->cg_obj, ib_dev,
 832                            RDMACG_RESOURCE_HCA_HANDLE);
 833
 834         rdma_restrack_del(&ucontext->res);
 835
 836         ib_dev->ops.dealloc_ucontext(ucontext);
 837         WARN_ON(!xa_empty(&ucontext->mmap_xa));
 838         kfree(ucontext);
 839
 840         ufile->ucontext = NULL;
 841 }
 842
 843 static int __uverbs_cleanup_ufile(struct ib_uverbs_file *ufile,
 844                                   enum rdma_remove_reason reason)
 845 {
 846         struct ib_uobject *obj, *next_obj;
 847         int ret = -EINVAL;
 848         struct uverbs_attr_bundle attrs = { .ufile = ufile };
 849
 850         /*
 851          * This shouldn't run while executing other commands on this
 852          * context. Thus, the only thing we should take care of is
 853          * releasing a FD while traversing this list. The FD could be
 854          * closed and released from the _release fop of this FD.
 855          * In order to mitigate this, we add a lock.
 856          * We take and release the lock per traversal in order to let
 857          * other threads (which might still use the FDs) chance to run.
 858          */
 859         list_for_each_entry_safe(obj, next_obj, &ufile->uobjects, list) {
 860                 attrs.context = obj->context;
 861                 /*
 862                  * if we hit this WARN_ON, that means we are
 863                  * racing with a lookup_get.
 864                  */
 865                 WARN_ON(uverbs_try_lock_object(obj, UVERBS_LOOKUP_WRITE));
 866                 if (!uverbs_destroy_uobject(obj, reason, &attrs))
 867                         ret = 0;
 868                 else
 869                         atomic_set(&obj->usecnt, 0);
 870         }
 871         return ret;
 872 }
 873
 874 /*
 875  * Destroy the uncontext and every uobject associated with it.
 876  *
 877  * This is internally locked and can be called in parallel from multiple
 878  * contexts.
 879  */
 880 void uverbs_destroy_ufile_hw(struct ib_uverbs_file *ufile,
 881                              enum rdma_remove_reason reason)
 882 {
 883         down_write(&ufile->hw_destroy_rwsem);
 884
 885         /*
 886          * If a ucontext was never created then we can't have any uobjects to
 887          * cleanup, nothing to do.
 888          */
 889         if (!ufile->ucontext)
 890                 goto done;
 891
 892         ufile->ucontext->closing = true;
 893         ufile->ucontext->cleanup_retryable = true;
 894         while (!list_empty(&ufile->uobjects))
 895                 if (__uverbs_cleanup_ufile(ufile, reason)) {
 896                         /*
 897                          * No entry was cleaned-up successfully during this
 898                          * iteration
 899                          */
 900                         break;
 901                 }
 902
 903         ufile->ucontext->cleanup_retryable = false;
 904         if (!list_empty(&ufile->uobjects))
 905                 __uverbs_cleanup_ufile(ufile, reason);
 906
 907         ufile_destroy_ucontext(ufile, reason);
 908
 909 done:
 910         up_write(&ufile->hw_destroy_rwsem);
 911 }
 912
 913 const struct uverbs_obj_type_class uverbs_fd_class = {
 914         .alloc_begin = alloc_begin_fd_uobject,
 915         .lookup_get = lookup_get_fd_uobject,
 916         .alloc_commit = alloc_commit_fd_uobject,
 917         .alloc_abort = alloc_abort_fd_uobject,
 918         .lookup_put = lookup_put_fd_uobject,
 919         .destroy_hw = destroy_hw_fd_uobject,
 920         .remove_handle = remove_handle_fd_uobject,
 921 };
 922 EXPORT_SYMBOL(uverbs_fd_class);
 923
 924 struct ib_uobject *
 925 uverbs_get_uobject_from_file(u16 object_id, enum uverbs_obj_access access,
 926                              s64 id, struct uverbs_attr_bundle *attrs)
 927 {
 928         const struct uverbs_api_object *obj =
 929                 uapi_get_object(attrs->ufile->device->uapi, object_id);
 930
 931         switch (access) {
 932         case UVERBS_ACCESS_READ:
 933                 return rdma_lookup_get_uobject(obj, attrs->ufile, id,
 934                                                UVERBS_LOOKUP_READ, attrs);
 935         case UVERBS_ACCESS_DESTROY:
 936                 /* Actual destruction is done inside uverbs_handle_method */
 937                 return rdma_lookup_get_uobject(obj, attrs->ufile, id,
 938                                                UVERBS_LOOKUP_DESTROY, attrs);
 939         case UVERBS_ACCESS_WRITE:
 940                 return rdma_lookup_get_uobject(obj, attrs->ufile, id,
 941                                                UVERBS_LOOKUP_WRITE, attrs);
 942         case UVERBS_ACCESS_NEW:
 943                 return rdma_alloc_begin_uobject(obj, attrs);
 944         default:
 945                 WARN_ON(true);
 946                 return ERR_PTR(-EOPNOTSUPP);
 947         }
 948 }
 949
 950 void uverbs_finalize_object(struct ib_uobject *uobj,
 951                             enum uverbs_obj_access access, bool hw_obj_valid,
 952                             bool commit, struct uverbs_attr_bundle *attrs)
 953 {
 954         /*
 955          * refcounts should be handled at the object level and not at the
 956          * uobject level. Refcounts of the objects themselves are done in
 957          * handlers.
 958          */
 959
 960         switch (access) {
 961         case UVERBS_ACCESS_READ:
 962                 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_READ);
 963                 break;
 964         case UVERBS_ACCESS_WRITE:
 965                 rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_WRITE);
 966                 break;
 967         case UVERBS_ACCESS_DESTROY:
 968                 if (uobj)
 969                         rdma_lookup_put_uobject(uobj, UVERBS_LOOKUP_DESTROY);
 970                 break;
 971         case UVERBS_ACCESS_NEW:
 972                 if (commit)
 973                         rdma_alloc_commit_uobject(uobj, attrs);
 974                 else
 975                         rdma_alloc_abort_uobject(uobj, attrs, hw_obj_valid);
 976                 break;
 977         default:
 978                 WARN_ON(true);
 979         }
 980 }