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