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