drivers/infiniband/core/uverbs_uapi.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /*
   3  * Copyright (c) 2017, Mellanox Technologies inc.  All rights reserved.
   4  */
   5 #include <rdma/uverbs_ioctl.h>
   6 #include <rdma/rdma_user_ioctl.h>
   7 #include <linux/bitops.h>
   8 #include "rdma_core.h"
   9 #include "uverbs.h"
  10
  11 static int ib_uverbs_notsupp(struct uverbs_attr_bundle *attrs)
  12 {
  13         return -EOPNOTSUPP;
  14 }
  15
  16 static void *uapi_add_elm(struct uverbs_api *uapi, u32 key, size_t alloc_size)
  17 {
  18         void *elm;
  19         int rc;
  20
  21         if (key == UVERBS_API_KEY_ERR)
  22                 return ERR_PTR(-EOVERFLOW);
  23
  24         elm = kzalloc(alloc_size, GFP_KERNEL);
  25         rc = radix_tree_insert(&uapi->radix, key, elm);
  26         if (rc) {
  27                 kfree(elm);
  28                 return ERR_PTR(rc);
  29         }
  30
  31         return elm;
  32 }
  33
  34 static void *uapi_add_get_elm(struct uverbs_api *uapi, u32 key,
  35                               size_t alloc_size, bool *exists)
  36 {
  37         void *elm;
  38
  39         elm = uapi_add_elm(uapi, key, alloc_size);
  40         if (!IS_ERR(elm)) {
  41                 *exists = false;
  42                 return elm;
  43         }
  44
  45         if (elm != ERR_PTR(-EEXIST))
  46                 return elm;
  47
  48         elm = radix_tree_lookup(&uapi->radix, key);
  49         if (WARN_ON(!elm))
  50                 return ERR_PTR(-EINVAL);
  51         *exists = true;
  52         return elm;
  53 }
  54
  55 static int uapi_create_write(struct uverbs_api *uapi,
  56                              struct ib_device *ibdev,
  57                              const struct uapi_definition *def,
  58                              u32 obj_key,
  59                              u32 *cur_method_key)
  60 {
  61         struct uverbs_api_write_method *method_elm;
  62         u32 method_key = obj_key;
  63         bool exists;
  64
  65         if (def->write.is_ex)
  66                 method_key |= uapi_key_write_ex_method(def->write.command_num);
  67         else
  68                 method_key |= uapi_key_write_method(def->write.command_num);
  69
  70         method_elm = uapi_add_get_elm(uapi, method_key, sizeof(*method_elm),
  71                                       &exists);
  72         if (IS_ERR(method_elm))
  73                 return PTR_ERR(method_elm);
  74
  75         if (WARN_ON(exists && (def->write.is_ex != method_elm->is_ex)))
  76                 return -EINVAL;
  77
  78         method_elm->is_ex = def->write.is_ex;
  79         method_elm->handler = def->func_write;
  80         if (def->write.is_ex)
  81                 method_elm->disabled = !(ibdev->uverbs_ex_cmd_mask &
  82                                          BIT_ULL(def->write.command_num));
  83         else
  84                 method_elm->disabled = !(ibdev->uverbs_cmd_mask &
  85                                          BIT_ULL(def->write.command_num));
  86
  87         if (!def->write.is_ex && def->func_write) {
  88                 method_elm->has_udata = def->write.has_udata;
  89                 method_elm->has_resp = def->write.has_resp;
  90                 method_elm->req_size = def->write.req_size;
  91                 method_elm->resp_size = def->write.resp_size;
  92         }
  93
  94         *cur_method_key = method_key;
  95         return 0;
  96 }
  97
  98 static int uapi_merge_method(struct uverbs_api *uapi,
  99                              struct uverbs_api_object *obj_elm, u32 obj_key,
 100                              const struct uverbs_method_def *method,
 101                              bool is_driver)
 102 {
 103         u32 method_key = obj_key | uapi_key_ioctl_method(method->id);
 104         struct uverbs_api_ioctl_method *method_elm;
 105         unsigned int i;
 106         bool exists;
 107
 108         if (!method->attrs)
 109                 return 0;
 110
 111         method_elm = uapi_add_get_elm(uapi, method_key, sizeof(*method_elm),
 112                                       &exists);
 113         if (IS_ERR(method_elm))
 114                 return PTR_ERR(method_elm);
 115         if (exists) {
 116                 /*
 117                  * This occurs when a driver uses ADD_UVERBS_ATTRIBUTES_SIMPLE
 118                  */
 119                 if (WARN_ON(method->handler))
 120                         return -EINVAL;
 121         } else {
 122                 WARN_ON(!method->handler);
 123                 rcu_assign_pointer(method_elm->handler, method->handler);
 124                 if (method->handler != uverbs_destroy_def_handler)
 125                         method_elm->driver_method = is_driver;
 126         }
 127
 128         for (i = 0; i != method->num_attrs; i++) {
 129                 const struct uverbs_attr_def *attr = (*method->attrs)[i];
 130                 struct uverbs_api_attr *attr_slot;
 131
 132                 if (!attr)
 133                         continue;
 134
 135                 /*
 136                  * ENUM_IN contains the 'ids' pointer to the driver's .rodata,
 137                  * so if it is specified by a driver then it always makes this
 138                  * into a driver method.
 139                  */
 140                 if (attr->attr.type == UVERBS_ATTR_TYPE_ENUM_IN)
 141                         method_elm->driver_method |= is_driver;
 142
 143                 /*
 144                  * Like other uobject based things we only support a single
 145                  * uobject being NEW'd or DESTROY'd
 146                  */
 147                 if (attr->attr.type == UVERBS_ATTR_TYPE_IDRS_ARRAY) {
 148                         u8 access = attr->attr.u2.objs_arr.access;
 149
 150                         if (WARN_ON(access == UVERBS_ACCESS_NEW ||
 151                                     access == UVERBS_ACCESS_DESTROY))
 152                                 return -EINVAL;
 153                 }
 154
 155                 attr_slot =
 156                         uapi_add_elm(uapi, method_key | uapi_key_attr(attr->id),
 157                                      sizeof(*attr_slot));
 158                 /* Attributes are not allowed to be modified by drivers */
 159                 if (IS_ERR(attr_slot))
 160                         return PTR_ERR(attr_slot);
 161
 162                 attr_slot->spec = attr->attr;
 163         }
 164
 165         return 0;
 166 }
 167
 168 static int uapi_merge_obj_tree(struct uverbs_api *uapi,
 169                                const struct uverbs_object_def *obj,
 170                                bool is_driver)
 171 {
 172         struct uverbs_api_object *obj_elm;
 173         unsigned int i;
 174         u32 obj_key;
 175         bool exists;
 176         int rc;
 177
 178         obj_key = uapi_key_obj(obj->id);
 179         obj_elm = uapi_add_get_elm(uapi, obj_key, sizeof(*obj_elm), &exists);
 180         if (IS_ERR(obj_elm))
 181                 return PTR_ERR(obj_elm);
 182
 183         if (obj->type_attrs) {
 184                 if (WARN_ON(obj_elm->type_attrs))
 185                         return -EINVAL;
 186
 187                 obj_elm->id = obj->id;
 188                 obj_elm->type_attrs = obj->type_attrs;
 189                 obj_elm->type_class = obj->type_attrs->type_class;
 190                 /*
 191                  * Today drivers are only permitted to use idr_class and
 192                  * fd_class types. We can revoke the IDR types during
 193                  * disassociation, and the FD types require the driver to use
 194                  * struct file_operations.owner to prevent the driver module
 195                  * code from unloading while the file is open. This provides
 196                  * enough safety that uverbs_close_fd() will continue to work.
 197                  * Drivers using FD are responsible to handle disassociation of
 198                  * the device on their own.
 199                  */
 200                 if (WARN_ON(is_driver &&
 201                             obj->type_attrs->type_class != &uverbs_idr_class &&
 202                             obj->type_attrs->type_class != &uverbs_fd_class))
 203                         return -EINVAL;
 204         }
 205
 206         if (!obj->methods)
 207                 return 0;
 208
 209         for (i = 0; i != obj->num_methods; i++) {
 210                 const struct uverbs_method_def *method = (*obj->methods)[i];
 211
 212                 if (!method)
 213                         continue;
 214
 215                 rc = uapi_merge_method(uapi, obj_elm, obj_key, method,
 216                                        is_driver);
 217                 if (rc)
 218                         return rc;
 219         }
 220
 221         return 0;
 222 }
 223
 224 static int uapi_disable_elm(struct uverbs_api *uapi,
 225                             const struct uapi_definition *def,
 226                             u32 obj_key,
 227                             u32 method_key)
 228 {
 229         bool exists;
 230
 231         if (def->scope == UAPI_SCOPE_OBJECT) {
 232                 struct uverbs_api_object *obj_elm;
 233
 234                 obj_elm = uapi_add_get_elm(
 235                         uapi, obj_key, sizeof(*obj_elm), &exists);
 236                 if (IS_ERR(obj_elm))
 237                         return PTR_ERR(obj_elm);
 238                 obj_elm->disabled = 1;
 239                 return 0;
 240         }
 241
 242         if (def->scope == UAPI_SCOPE_METHOD &&
 243             uapi_key_is_ioctl_method(method_key)) {
 244                 struct uverbs_api_ioctl_method *method_elm;
 245
 246                 method_elm = uapi_add_get_elm(uapi, method_key,
 247                                               sizeof(*method_elm), &exists);
 248                 if (IS_ERR(method_elm))
 249                         return PTR_ERR(method_elm);
 250                 method_elm->disabled = 1;
 251                 return 0;
 252         }
 253
 254         if (def->scope == UAPI_SCOPE_METHOD &&
 255             (uapi_key_is_write_method(method_key) ||
 256              uapi_key_is_write_ex_method(method_key))) {
 257                 struct uverbs_api_write_method *write_elm;
 258
 259                 write_elm = uapi_add_get_elm(uapi, method_key,
 260                                              sizeof(*write_elm), &exists);
 261                 if (IS_ERR(write_elm))
 262                         return PTR_ERR(write_elm);
 263                 write_elm->disabled = 1;
 264                 return 0;
 265         }
 266
 267         WARN_ON(true);
 268         return -EINVAL;
 269 }
 270
 271 static int uapi_merge_def(struct uverbs_api *uapi, struct ib_device *ibdev,
 272                           const struct uapi_definition *def_list,
 273                           bool is_driver)
 274 {
 275         const struct uapi_definition *def = def_list;
 276         u32 cur_obj_key = UVERBS_API_KEY_ERR;
 277         u32 cur_method_key = UVERBS_API_KEY_ERR;
 278         bool exists;
 279         int rc;
 280
 281         if (!def_list)
 282                 return 0;
 283
 284         for (;; def++) {
 285                 switch ((enum uapi_definition_kind)def->kind) {
 286                 case UAPI_DEF_CHAIN:
 287                         rc = uapi_merge_def(uapi, ibdev, def->chain, is_driver);
 288                         if (rc)
 289                                 return rc;
 290                         continue;
 291
 292                 case UAPI_DEF_CHAIN_OBJ_TREE:
 293                         if (WARN_ON(def->object_start.object_id !=
 294                                     def->chain_obj_tree->id))
 295                                 return -EINVAL;
 296
 297                         cur_obj_key = uapi_key_obj(def->object_start.object_id);
 298                         rc = uapi_merge_obj_tree(uapi, def->chain_obj_tree,
 299                                                  is_driver);
 300                         if (rc)
 301                                 return rc;
 302                         continue;
 303
 304                 case UAPI_DEF_END:
 305                         return 0;
 306
 307                 case UAPI_DEF_IS_SUPPORTED_DEV_FN: {
 308                         void **ibdev_fn =
 309                                 (void *)(&ibdev->ops) + def->needs_fn_offset;
 310
 311                         if (*ibdev_fn)
 312                                 continue;
 313                         rc = uapi_disable_elm(
 314                                 uapi, def, cur_obj_key, cur_method_key);
 315                         if (rc)
 316                                 return rc;
 317                         continue;
 318                 }
 319
 320                 case UAPI_DEF_IS_SUPPORTED_FUNC:
 321                         if (def->func_is_supported(ibdev))
 322                                 continue;
 323                         rc = uapi_disable_elm(
 324                                 uapi, def, cur_obj_key, cur_method_key);
 325                         if (rc)
 326                                 return rc;
 327                         continue;
 328
 329                 case UAPI_DEF_OBJECT_START: {
 330                         struct uverbs_api_object *obj_elm;
 331
 332                         cur_obj_key = uapi_key_obj(def->object_start.object_id);
 333                         obj_elm = uapi_add_get_elm(uapi, cur_obj_key,
 334                                                    sizeof(*obj_elm), &exists);
 335                         if (IS_ERR(obj_elm))
 336                                 return PTR_ERR(obj_elm);
 337                         continue;
 338                 }
 339
 340                 case UAPI_DEF_WRITE:
 341                         rc = uapi_create_write(
 342                                 uapi, ibdev, def, cur_obj_key, &cur_method_key);
 343                         if (rc)
 344                                 return rc;
 345                         continue;
 346                 }
 347                 WARN_ON(true);
 348                 return -EINVAL;
 349         }
 350 }
 351
 352 static int
 353 uapi_finalize_ioctl_method(struct uverbs_api *uapi,
 354                            struct uverbs_api_ioctl_method *method_elm,
 355                            u32 method_key)
 356 {
 357         struct radix_tree_iter iter;
 358         unsigned int num_attrs = 0;
 359         unsigned int max_bkey = 0;
 360         bool single_uobj = false;
 361         void __rcu **slot;
 362
 363         method_elm->destroy_bkey = UVERBS_API_ATTR_BKEY_LEN;
 364         radix_tree_for_each_slot (slot, &uapi->radix, &iter,
 365                                   uapi_key_attrs_start(method_key)) {
 366                 struct uverbs_api_attr *elm =
 367                         rcu_dereference_protected(*slot, true);
 368                 u32 attr_key = iter.index & UVERBS_API_ATTR_KEY_MASK;
 369                 u32 attr_bkey = uapi_bkey_attr(attr_key);
 370                 u8 type = elm->spec.type;
 371
 372                 if (uapi_key_attr_to_ioctl_method(iter.index) !=
 373                     uapi_key_attr_to_ioctl_method(method_key))
 374                         break;
 375
 376                 if (elm->spec.mandatory)
 377                         __set_bit(attr_bkey, method_elm->attr_mandatory);
 378
 379                 if (elm->spec.is_udata)
 380                         method_elm->has_udata = true;
 381
 382                 if (type == UVERBS_ATTR_TYPE_IDR ||
 383                     type == UVERBS_ATTR_TYPE_FD) {
 384                         u8 access = elm->spec.u.obj.access;
 385
 386                         /*
 387                          * Verbs specs may only have one NEW/DESTROY, we don't
 388                          * have the infrastructure to abort multiple NEW's or
 389                          * cope with multiple DESTROY failure.
 390                          */
 391                         if (access == UVERBS_ACCESS_NEW ||
 392                             access == UVERBS_ACCESS_DESTROY) {
 393                                 if (WARN_ON(single_uobj))
 394                                         return -EINVAL;
 395
 396                                 single_uobj = true;
 397                                 if (WARN_ON(!elm->spec.mandatory))
 398                                         return -EINVAL;
 399                         }
 400
 401                         if (access == UVERBS_ACCESS_DESTROY)
 402                                 method_elm->destroy_bkey = attr_bkey;
 403                 }
 404
 405                 max_bkey = max(max_bkey, attr_bkey);
 406                 num_attrs++;
 407         }
 408
 409         method_elm->key_bitmap_len = max_bkey + 1;
 410         WARN_ON(method_elm->key_bitmap_len > UVERBS_API_ATTR_BKEY_LEN);
 411
 412         uapi_compute_bundle_size(method_elm, num_attrs);
 413         return 0;
 414 }
 415
 416 static int uapi_finalize(struct uverbs_api *uapi)
 417 {
 418         const struct uverbs_api_write_method **data;
 419         unsigned long max_write_ex = 0;
 420         unsigned long max_write = 0;
 421         struct radix_tree_iter iter;
 422         void __rcu **slot;
 423         int rc;
 424         int i;
 425
 426         radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {
 427                 struct uverbs_api_ioctl_method *method_elm =
 428                         rcu_dereference_protected(*slot, true);
 429
 430                 if (uapi_key_is_ioctl_method(iter.index)) {
 431                         rc = uapi_finalize_ioctl_method(uapi, method_elm,
 432                                                         iter.index);
 433                         if (rc)
 434                                 return rc;
 435                 }
 436
 437                 if (uapi_key_is_write_method(iter.index))
 438                         max_write = max(max_write,
 439                                         iter.index & UVERBS_API_ATTR_KEY_MASK);
 440                 if (uapi_key_is_write_ex_method(iter.index))
 441                         max_write_ex =
 442                                 max(max_write_ex,
 443                                     iter.index & UVERBS_API_ATTR_KEY_MASK);
 444         }
 445
 446         uapi->notsupp_method.handler = ib_uverbs_notsupp;
 447         uapi->num_write = max_write + 1;
 448         uapi->num_write_ex = max_write_ex + 1;
 449         data = kmalloc_array(uapi->num_write + uapi->num_write_ex,
 450                              sizeof(*uapi->write_methods), GFP_KERNEL);
 451         for (i = 0; i != uapi->num_write + uapi->num_write_ex; i++)
 452                 data[i] = &uapi->notsupp_method;
 453         uapi->write_methods = data;
 454         uapi->write_ex_methods = data + uapi->num_write;
 455
 456         radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {
 457                 if (uapi_key_is_write_method(iter.index))
 458                         uapi->write_methods[iter.index &
 459                                             UVERBS_API_ATTR_KEY_MASK] =
 460                                 rcu_dereference_protected(*slot, true);
 461                 if (uapi_key_is_write_ex_method(iter.index))
 462                         uapi->write_ex_methods[iter.index &
 463                                                UVERBS_API_ATTR_KEY_MASK] =
 464                                 rcu_dereference_protected(*slot, true);
 465         }
 466
 467         return 0;
 468 }
 469
 470 static void uapi_remove_range(struct uverbs_api *uapi, u32 start, u32 last)
 471 {
 472         struct radix_tree_iter iter;
 473         void __rcu **slot;
 474
 475         radix_tree_for_each_slot (slot, &uapi->radix, &iter, start) {
 476                 if (iter.index > last)
 477                         return;
 478                 kfree(rcu_dereference_protected(*slot, true));
 479                 radix_tree_iter_delete(&uapi->radix, &iter, slot);
 480         }
 481 }
 482
 483 static void uapi_remove_object(struct uverbs_api *uapi, u32 obj_key)
 484 {
 485         uapi_remove_range(uapi, obj_key,
 486                           obj_key | UVERBS_API_METHOD_KEY_MASK |
 487                                   UVERBS_API_ATTR_KEY_MASK);
 488 }
 489
 490 static void uapi_remove_method(struct uverbs_api *uapi, u32 method_key)
 491 {
 492         uapi_remove_range(uapi, method_key,
 493                           method_key | UVERBS_API_ATTR_KEY_MASK);
 494 }
 495
 496
 497 static u32 uapi_get_obj_id(struct uverbs_attr_spec *spec)
 498 {
 499         if (spec->type == UVERBS_ATTR_TYPE_IDR ||
 500             spec->type == UVERBS_ATTR_TYPE_FD)
 501                 return spec->u.obj.obj_type;
 502         if (spec->type == UVERBS_ATTR_TYPE_IDRS_ARRAY)
 503                 return spec->u2.objs_arr.obj_type;
 504         return UVERBS_API_KEY_ERR;
 505 }
 506
 507 static void uapi_key_okay(u32 key)
 508 {
 509         unsigned int count = 0;
 510
 511         if (uapi_key_is_object(key))
 512                 count++;
 513         if (uapi_key_is_ioctl_method(key))
 514                 count++;
 515         if (uapi_key_is_write_method(key))
 516                 count++;
 517         if (uapi_key_is_write_ex_method(key))
 518                 count++;
 519         if (uapi_key_is_attr(key))
 520                 count++;
 521         WARN(count != 1, "Bad count %d key=%x", count, key);
 522 }
 523
 524 static void uapi_finalize_disable(struct uverbs_api *uapi)
 525 {
 526         struct radix_tree_iter iter;
 527         u32 starting_key = 0;
 528         bool scan_again = false;
 529         void __rcu **slot;
 530
 531 again:
 532         radix_tree_for_each_slot (slot, &uapi->radix, &iter, starting_key) {
 533                 uapi_key_okay(iter.index);
 534
 535                 if (uapi_key_is_object(iter.index)) {
 536                         struct uverbs_api_object *obj_elm =
 537                                 rcu_dereference_protected(*slot, true);
 538
 539                         if (obj_elm->disabled) {
 540                                 /* Have to check all the attrs again */
 541                                 scan_again = true;
 542                                 starting_key = iter.index;
 543                                 uapi_remove_object(uapi, iter.index);
 544                                 goto again;
 545                         }
 546                         continue;
 547                 }
 548
 549                 if (uapi_key_is_ioctl_method(iter.index)) {
 550                         struct uverbs_api_ioctl_method *method_elm =
 551                                 rcu_dereference_protected(*slot, true);
 552
 553                         if (method_elm->disabled) {
 554                                 starting_key = iter.index;
 555                                 uapi_remove_method(uapi, iter.index);
 556                                 goto again;
 557                         }
 558                         continue;
 559                 }
 560
 561                 if (uapi_key_is_write_method(iter.index) ||
 562                     uapi_key_is_write_ex_method(iter.index)) {
 563                         struct uverbs_api_write_method *method_elm =
 564                                 rcu_dereference_protected(*slot, true);
 565
 566                         if (method_elm->disabled) {
 567                                 kfree(method_elm);
 568                                 radix_tree_iter_delete(&uapi->radix, &iter, slot);
 569                         }
 570                         continue;
 571                 }
 572
 573                 if (uapi_key_is_attr(iter.index)) {
 574                         struct uverbs_api_attr *attr_elm =
 575                                 rcu_dereference_protected(*slot, true);
 576                         const struct uverbs_api_object *tmp_obj;
 577                         u32 obj_key;
 578
 579                         /*
 580                          * If the method has a mandatory object handle
 581                          * attribute which relies on an object which is not
 582                          * present then the entire method is uncallable.
 583                          */
 584                         if (!attr_elm->spec.mandatory)
 585                                 continue;
 586                         obj_key = uapi_get_obj_id(&attr_elm->spec);
 587                         if (obj_key == UVERBS_API_KEY_ERR)
 588                                 continue;
 589                         tmp_obj = uapi_get_object(uapi, obj_key);
 590                         if (IS_ERR(tmp_obj)) {
 591                                 if (PTR_ERR(tmp_obj) == -ENOMSG)
 592                                         continue;
 593                         } else {
 594                                 if (!tmp_obj->disabled)
 595                                         continue;
 596                         }
 597
 598                         starting_key = iter.index;
 599                         uapi_remove_method(
 600                                 uapi,
 601                                 iter.index & (UVERBS_API_OBJ_KEY_MASK |
 602                                               UVERBS_API_METHOD_KEY_MASK));
 603                         goto again;
 604                 }
 605
 606                 WARN_ON(false);
 607         }
 608
 609         if (!scan_again)
 610                 return;
 611         scan_again = false;
 612         starting_key = 0;
 613         goto again;
 614 }
 615
 616 void uverbs_destroy_api(struct uverbs_api *uapi)
 617 {
 618         if (!uapi)
 619                 return;
 620
 621         uapi_remove_range(uapi, 0, U32_MAX);
 622         kfree(uapi->write_methods);
 623         kfree(uapi);
 624 }
 625
 626 static const struct uapi_definition uverbs_core_api[] = {
 627         UAPI_DEF_CHAIN(uverbs_def_obj_counters),
 628         UAPI_DEF_CHAIN(uverbs_def_obj_cq),
 629         UAPI_DEF_CHAIN(uverbs_def_obj_device),
 630         UAPI_DEF_CHAIN(uverbs_def_obj_dm),
 631         UAPI_DEF_CHAIN(uverbs_def_obj_flow_action),
 632         UAPI_DEF_CHAIN(uverbs_def_obj_intf),
 633         UAPI_DEF_CHAIN(uverbs_def_obj_mr),
 634         UAPI_DEF_CHAIN(uverbs_def_write_intf),
 635         {},
 636 };
 637
 638 struct uverbs_api *uverbs_alloc_api(struct ib_device *ibdev)
 639 {
 640         struct uverbs_api *uapi;
 641         int rc;
 642
 643         uapi = kzalloc(sizeof(*uapi), GFP_KERNEL);
 644         if (!uapi)
 645                 return ERR_PTR(-ENOMEM);
 646
 647         INIT_RADIX_TREE(&uapi->radix, GFP_KERNEL);
 648         uapi->driver_id = ibdev->driver_id;
 649
 650         rc = uapi_merge_def(uapi, ibdev, uverbs_core_api, false);
 651         if (rc)
 652                 goto err;
 653         rc = uapi_merge_def(uapi, ibdev, ibdev->driver_def, true);
 654         if (rc)
 655                 goto err;
 656
 657         uapi_finalize_disable(uapi);
 658         rc = uapi_finalize(uapi);
 659         if (rc)
 660                 goto err;
 661
 662         return uapi;
 663 err:
 664         if (rc != -ENOMEM)
 665                 dev_err(&ibdev->dev,
 666                         "Setup of uverbs_api failed, kernel parsing tree description is not valid (%d)??\n",
 667                         rc);
 668
 669         uverbs_destroy_api(uapi);
 670         return ERR_PTR(rc);
 671 }
 672
 673 /*
 674  * The pre version is done before destroying the HW objects, it only blocks
 675  * off method access. All methods that require the ib_dev or the module data
 676  * must test one of these assignments prior to continuing.
 677  */
 678 void uverbs_disassociate_api_pre(struct ib_uverbs_device *uverbs_dev)
 679 {
 680         struct uverbs_api *uapi = uverbs_dev->uapi;
 681         struct radix_tree_iter iter;
 682         void __rcu **slot;
 683
 684         rcu_assign_pointer(uverbs_dev->ib_dev, NULL);
 685
 686         radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {
 687                 if (uapi_key_is_ioctl_method(iter.index)) {
 688                         struct uverbs_api_ioctl_method *method_elm =
 689                                 rcu_dereference_protected(*slot, true);
 690
 691                         if (method_elm->driver_method)
 692                                 rcu_assign_pointer(method_elm->handler, NULL);
 693                 }
 694         }
 695
 696         synchronize_srcu(&uverbs_dev->disassociate_srcu);
 697 }
 698
 699 /*
 700  * Called when a driver disassociates from the ib_uverbs_device. The
 701  * assumption is that the driver module will unload after. Replace everything
 702  * related to the driver with NULL as a safety measure.
 703  */
 704 void uverbs_disassociate_api(struct uverbs_api *uapi)
 705 {
 706         struct radix_tree_iter iter;
 707         void __rcu **slot;
 708
 709         radix_tree_for_each_slot (slot, &uapi->radix, &iter, 0) {
 710                 if (uapi_key_is_object(iter.index)) {
 711                         struct uverbs_api_object *object_elm =
 712                                 rcu_dereference_protected(*slot, true);
 713
 714                         /*
 715                          * Some type_attrs are in the driver module. We don't
 716                          * bother to keep track of which since there should be
 717                          * no use of this after disassociate.
 718                          */
 719                         object_elm->type_attrs = NULL;
 720                 } else if (uapi_key_is_attr(iter.index)) {
 721                         struct uverbs_api_attr *elm =
 722                                 rcu_dereference_protected(*slot, true);
 723
 724                         if (elm->spec.type == UVERBS_ATTR_TYPE_ENUM_IN)
 725                                 elm->spec.u2.enum_def.ids = NULL;
 726                 }
 727         }
 728 }