1 /* 2 * Copyright (c) 2016 Mellanox Technologies Ltd. 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/security.h> 34 #include <linux/completion.h> 35 #include <linux/list.h> 36 37 #include <rdma/ib_verbs.h> 38 #include <rdma/ib_cache.h> 39 #include "core_priv.h" 40 #include "mad_priv.h" 41 42 static LIST_HEAD(mad_agent_list); 43 /* Lock to protect mad_agent_list */ 44 static DEFINE_SPINLOCK(mad_agent_list_lock); 45 46 static struct pkey_index_qp_list *get_pkey_idx_qp_list(struct ib_port_pkey *pp) 47 { 48 struct pkey_index_qp_list *pkey = NULL; 49 struct pkey_index_qp_list *tmp_pkey; 50 struct ib_device *dev = pp->sec->dev; 51 52 spin_lock(&dev->port_data[pp->port_num].pkey_list_lock); 53 list_for_each_entry (tmp_pkey, &dev->port_data[pp->port_num].pkey_list, 54 pkey_index_list) { 55 if (tmp_pkey->pkey_index == pp->pkey_index) { 56 pkey = tmp_pkey; 57 break; 58 } 59 } 60 spin_unlock(&dev->port_data[pp->port_num].pkey_list_lock); 61 return pkey; 62 } 63 64 static int get_pkey_and_subnet_prefix(struct ib_port_pkey *pp, 65 u16 *pkey, 66 u64 *subnet_prefix) 67 { 68 struct ib_device *dev = pp->sec->dev; 69 int ret; 70 71 ret = ib_get_cached_pkey(dev, pp->port_num, pp->pkey_index, pkey); 72 if (ret) 73 return ret; 74 75 ret = ib_get_cached_subnet_prefix(dev, pp->port_num, subnet_prefix); 76 77 return ret; 78 } 79 80 static int enforce_qp_pkey_security(u16 pkey, 81 u64 subnet_prefix, 82 struct ib_qp_security *qp_sec) 83 { 84 struct ib_qp_security *shared_qp_sec; 85 int ret; 86 87 ret = security_ib_pkey_access(qp_sec->security, subnet_prefix, pkey); 88 if (ret) 89 return ret; 90 91 list_for_each_entry(shared_qp_sec, 92 &qp_sec->shared_qp_list, 93 shared_qp_list) { 94 ret = security_ib_pkey_access(shared_qp_sec->security, 95 subnet_prefix, 96 pkey); 97 if (ret) 98 return ret; 99 } 100 return 0; 101 } 102 103 /* The caller of this function must hold the QP security 104 * mutex of the QP of the security structure in *pps. 105 * 106 * It takes separate ports_pkeys and security structure 107 * because in some cases the pps will be for a new settings 108 * or the pps will be for the real QP and security structure 109 * will be for a shared QP. 110 */ 111 static int check_qp_port_pkey_settings(struct ib_ports_pkeys *pps, 112 struct ib_qp_security *sec) 113 { 114 u64 subnet_prefix; 115 u16 pkey; 116 int ret = 0; 117 118 if (!pps) 119 return 0; 120 121 if (pps->main.state != IB_PORT_PKEY_NOT_VALID) { 122 ret = get_pkey_and_subnet_prefix(&pps->main, 123 &pkey, 124 &subnet_prefix); 125 if (ret) 126 return ret; 127 128 ret = enforce_qp_pkey_security(pkey, 129 subnet_prefix, 130 sec); 131 if (ret) 132 return ret; 133 } 134 135 if (pps->alt.state != IB_PORT_PKEY_NOT_VALID) { 136 ret = get_pkey_and_subnet_prefix(&pps->alt, 137 &pkey, 138 &subnet_prefix); 139 if (ret) 140 return ret; 141 142 ret = enforce_qp_pkey_security(pkey, 143 subnet_prefix, 144 sec); 145 } 146 147 return ret; 148 } 149 150 /* The caller of this function must hold the QP security 151 * mutex. 152 */ 153 static void qp_to_error(struct ib_qp_security *sec) 154 { 155 struct ib_qp_security *shared_qp_sec; 156 struct ib_qp_attr attr = { 157 .qp_state = IB_QPS_ERR 158 }; 159 struct ib_event event = { 160 .event = IB_EVENT_QP_FATAL 161 }; 162 163 /* If the QP is in the process of being destroyed 164 * the qp pointer in the security structure is 165 * undefined. It cannot be modified now. 166 */ 167 if (sec->destroying) 168 return; 169 170 ib_modify_qp(sec->qp, 171 &attr, 172 IB_QP_STATE); 173 174 if (sec->qp->event_handler && sec->qp->qp_context) { 175 event.element.qp = sec->qp; 176 sec->qp->event_handler(&event, 177 sec->qp->qp_context); 178 } 179 180 list_for_each_entry(shared_qp_sec, 181 &sec->shared_qp_list, 182 shared_qp_list) { 183 struct ib_qp *qp = shared_qp_sec->qp; 184 185 if (qp->event_handler && qp->qp_context) { 186 event.element.qp = qp; 187 event.device = qp->device; 188 qp->event_handler(&event, 189 qp->qp_context); 190 } 191 } 192 } 193 194 static inline void check_pkey_qps(struct pkey_index_qp_list *pkey, 195 struct ib_device *device, 196 u8 port_num, 197 u64 subnet_prefix) 198 { 199 struct ib_port_pkey *pp, *tmp_pp; 200 bool comp; 201 LIST_HEAD(to_error_list); 202 u16 pkey_val; 203 204 if (!ib_get_cached_pkey(device, 205 port_num, 206 pkey->pkey_index, 207 &pkey_val)) { 208 spin_lock(&pkey->qp_list_lock); 209 list_for_each_entry(pp, &pkey->qp_list, qp_list) { 210 if (atomic_read(&pp->sec->error_list_count)) 211 continue; 212 213 if (enforce_qp_pkey_security(pkey_val, 214 subnet_prefix, 215 pp->sec)) { 216 atomic_inc(&pp->sec->error_list_count); 217 list_add(&pp->to_error_list, 218 &to_error_list); 219 } 220 } 221 spin_unlock(&pkey->qp_list_lock); 222 } 223 224 list_for_each_entry_safe(pp, 225 tmp_pp, 226 &to_error_list, 227 to_error_list) { 228 mutex_lock(&pp->sec->mutex); 229 qp_to_error(pp->sec); 230 list_del(&pp->to_error_list); 231 atomic_dec(&pp->sec->error_list_count); 232 comp = pp->sec->destroying; 233 mutex_unlock(&pp->sec->mutex); 234 235 if (comp) 236 complete(&pp->sec->error_complete); 237 } 238 } 239 240 /* The caller of this function must hold the QP security 241 * mutex. 242 */ 243 static int port_pkey_list_insert(struct ib_port_pkey *pp) 244 { 245 struct pkey_index_qp_list *tmp_pkey; 246 struct pkey_index_qp_list *pkey; 247 struct ib_device *dev; 248 u8 port_num = pp->port_num; 249 int ret = 0; 250 251 if (pp->state != IB_PORT_PKEY_VALID) 252 return 0; 253 254 dev = pp->sec->dev; 255 256 pkey = get_pkey_idx_qp_list(pp); 257 258 if (!pkey) { 259 bool found = false; 260 261 pkey = kzalloc(sizeof(*pkey), GFP_KERNEL); 262 if (!pkey) 263 return -ENOMEM; 264 265 spin_lock(&dev->port_data[port_num].pkey_list_lock); 266 /* Check for the PKey again. A racing process may 267 * have created it. 268 */ 269 list_for_each_entry(tmp_pkey, 270 &dev->port_data[port_num].pkey_list, 271 pkey_index_list) { 272 if (tmp_pkey->pkey_index == pp->pkey_index) { 273 kfree(pkey); 274 pkey = tmp_pkey; 275 found = true; 276 break; 277 } 278 } 279 280 if (!found) { 281 pkey->pkey_index = pp->pkey_index; 282 spin_lock_init(&pkey->qp_list_lock); 283 INIT_LIST_HEAD(&pkey->qp_list); 284 list_add(&pkey->pkey_index_list, 285 &dev->port_data[port_num].pkey_list); 286 } 287 spin_unlock(&dev->port_data[port_num].pkey_list_lock); 288 } 289 290 spin_lock(&pkey->qp_list_lock); 291 list_add(&pp->qp_list, &pkey->qp_list); 292 spin_unlock(&pkey->qp_list_lock); 293 294 pp->state = IB_PORT_PKEY_LISTED; 295 296 return ret; 297 } 298 299 /* The caller of this function must hold the QP security 300 * mutex. 301 */ 302 static void port_pkey_list_remove(struct ib_port_pkey *pp) 303 { 304 struct pkey_index_qp_list *pkey; 305 306 if (pp->state != IB_PORT_PKEY_LISTED) 307 return; 308 309 pkey = get_pkey_idx_qp_list(pp); 310 311 spin_lock(&pkey->qp_list_lock); 312 list_del(&pp->qp_list); 313 spin_unlock(&pkey->qp_list_lock); 314 315 /* The setting may still be valid, i.e. after 316 * a destroy has failed for example. 317 */ 318 pp->state = IB_PORT_PKEY_VALID; 319 } 320 321 static void destroy_qp_security(struct ib_qp_security *sec) 322 { 323 security_ib_free_security(sec->security); 324 kfree(sec->ports_pkeys); 325 kfree(sec); 326 } 327 328 /* The caller of this function must hold the QP security 329 * mutex. 330 */ 331 static struct ib_ports_pkeys *get_new_pps(const struct ib_qp *qp, 332 const struct ib_qp_attr *qp_attr, 333 int qp_attr_mask) 334 { 335 struct ib_ports_pkeys *new_pps; 336 struct ib_ports_pkeys *qp_pps = qp->qp_sec->ports_pkeys; 337 338 new_pps = kzalloc(sizeof(*new_pps), GFP_KERNEL); 339 if (!new_pps) 340 return NULL; 341 342 if (qp_attr_mask & (IB_QP_PKEY_INDEX | IB_QP_PORT)) { 343 if (!qp_pps) { 344 new_pps->main.port_num = qp_attr->port_num; 345 new_pps->main.pkey_index = qp_attr->pkey_index; 346 } else { 347 new_pps->main.port_num = (qp_attr_mask & IB_QP_PORT) ? 348 qp_attr->port_num : 349 qp_pps->main.port_num; 350 351 new_pps->main.pkey_index = 352 (qp_attr_mask & IB_QP_PKEY_INDEX) ? 353 qp_attr->pkey_index : 354 qp_pps->main.pkey_index; 355 } 356 new_pps->main.state = IB_PORT_PKEY_VALID; 357 } else if (qp_pps) { 358 new_pps->main.port_num = qp_pps->main.port_num; 359 new_pps->main.pkey_index = qp_pps->main.pkey_index; 360 if (qp_pps->main.state != IB_PORT_PKEY_NOT_VALID) 361 new_pps->main.state = IB_PORT_PKEY_VALID; 362 } 363 364 if (qp_attr_mask & IB_QP_ALT_PATH) { 365 new_pps->alt.port_num = qp_attr->alt_port_num; 366 new_pps->alt.pkey_index = qp_attr->alt_pkey_index; 367 new_pps->alt.state = IB_PORT_PKEY_VALID; 368 } else if (qp_pps) { 369 new_pps->alt.port_num = qp_pps->alt.port_num; 370 new_pps->alt.pkey_index = qp_pps->alt.pkey_index; 371 if (qp_pps->alt.state != IB_PORT_PKEY_NOT_VALID) 372 new_pps->alt.state = IB_PORT_PKEY_VALID; 373 } 374 375 new_pps->main.sec = qp->qp_sec; 376 new_pps->alt.sec = qp->qp_sec; 377 return new_pps; 378 } 379 380 int ib_open_shared_qp_security(struct ib_qp *qp, struct ib_device *dev) 381 { 382 struct ib_qp *real_qp = qp->real_qp; 383 int ret; 384 385 ret = ib_create_qp_security(qp, dev); 386 387 if (ret) 388 return ret; 389 390 if (!qp->qp_sec) 391 return 0; 392 393 mutex_lock(&real_qp->qp_sec->mutex); 394 ret = check_qp_port_pkey_settings(real_qp->qp_sec->ports_pkeys, 395 qp->qp_sec); 396 397 if (ret) 398 goto ret; 399 400 if (qp != real_qp) 401 list_add(&qp->qp_sec->shared_qp_list, 402 &real_qp->qp_sec->shared_qp_list); 403 ret: 404 mutex_unlock(&real_qp->qp_sec->mutex); 405 if (ret) 406 destroy_qp_security(qp->qp_sec); 407 408 return ret; 409 } 410 411 void ib_close_shared_qp_security(struct ib_qp_security *sec) 412 { 413 struct ib_qp *real_qp = sec->qp->real_qp; 414 415 mutex_lock(&real_qp->qp_sec->mutex); 416 list_del(&sec->shared_qp_list); 417 mutex_unlock(&real_qp->qp_sec->mutex); 418 419 destroy_qp_security(sec); 420 } 421 422 int ib_create_qp_security(struct ib_qp *qp, struct ib_device *dev) 423 { 424 unsigned int i; 425 bool is_ib = false; 426 int ret; 427 428 rdma_for_each_port (dev, i) { 429 is_ib = rdma_protocol_ib(dev, i); 430 if (is_ib) 431 break; 432 } 433 434 /* If this isn't an IB device don't create the security context */ 435 if (!is_ib) 436 return 0; 437 438 qp->qp_sec = kzalloc(sizeof(*qp->qp_sec), GFP_KERNEL); 439 if (!qp->qp_sec) 440 return -ENOMEM; 441 442 qp->qp_sec->qp = qp; 443 qp->qp_sec->dev = dev; 444 mutex_init(&qp->qp_sec->mutex); 445 INIT_LIST_HEAD(&qp->qp_sec->shared_qp_list); 446 atomic_set(&qp->qp_sec->error_list_count, 0); 447 init_completion(&qp->qp_sec->error_complete); 448 ret = security_ib_alloc_security(&qp->qp_sec->security); 449 if (ret) { 450 kfree(qp->qp_sec); 451 qp->qp_sec = NULL; 452 } 453 454 return ret; 455 } 456 EXPORT_SYMBOL(ib_create_qp_security); 457 458 void ib_destroy_qp_security_begin(struct ib_qp_security *sec) 459 { 460 /* Return if not IB */ 461 if (!sec) 462 return; 463 464 mutex_lock(&sec->mutex); 465 466 /* Remove the QP from the lists so it won't get added to 467 * a to_error_list during the destroy process. 468 */ 469 if (sec->ports_pkeys) { 470 port_pkey_list_remove(&sec->ports_pkeys->main); 471 port_pkey_list_remove(&sec->ports_pkeys->alt); 472 } 473 474 /* If the QP is already in one or more of those lists 475 * the destroying flag will ensure the to error flow 476 * doesn't operate on an undefined QP. 477 */ 478 sec->destroying = true; 479 480 /* Record the error list count to know how many completions 481 * to wait for. 482 */ 483 sec->error_comps_pending = atomic_read(&sec->error_list_count); 484 485 mutex_unlock(&sec->mutex); 486 } 487 488 void ib_destroy_qp_security_abort(struct ib_qp_security *sec) 489 { 490 int ret; 491 int i; 492 493 /* Return if not IB */ 494 if (!sec) 495 return; 496 497 /* If a concurrent cache update is in progress this 498 * QP security could be marked for an error state 499 * transition. Wait for this to complete. 500 */ 501 for (i = 0; i < sec->error_comps_pending; i++) 502 wait_for_completion(&sec->error_complete); 503 504 mutex_lock(&sec->mutex); 505 sec->destroying = false; 506 507 /* Restore the position in the lists and verify 508 * access is still allowed in case a cache update 509 * occurred while attempting to destroy. 510 * 511 * Because these setting were listed already 512 * and removed during ib_destroy_qp_security_begin 513 * we know the pkey_index_qp_list for the PKey 514 * already exists so port_pkey_list_insert won't fail. 515 */ 516 if (sec->ports_pkeys) { 517 port_pkey_list_insert(&sec->ports_pkeys->main); 518 port_pkey_list_insert(&sec->ports_pkeys->alt); 519 } 520 521 ret = check_qp_port_pkey_settings(sec->ports_pkeys, sec); 522 if (ret) 523 qp_to_error(sec); 524 525 mutex_unlock(&sec->mutex); 526 } 527 528 void ib_destroy_qp_security_end(struct ib_qp_security *sec) 529 { 530 int i; 531 532 /* Return if not IB */ 533 if (!sec) 534 return; 535 536 /* If a concurrent cache update is occurring we must 537 * wait until this QP security structure is processed 538 * in the QP to error flow before destroying it because 539 * the to_error_list is in use. 540 */ 541 for (i = 0; i < sec->error_comps_pending; i++) 542 wait_for_completion(&sec->error_complete); 543 544 destroy_qp_security(sec); 545 } 546 547 void ib_security_cache_change(struct ib_device *device, 548 u8 port_num, 549 u64 subnet_prefix) 550 { 551 struct pkey_index_qp_list *pkey; 552 553 list_for_each_entry (pkey, &device->port_data[port_num].pkey_list, 554 pkey_index_list) { 555 check_pkey_qps(pkey, 556 device, 557 port_num, 558 subnet_prefix); 559 } 560 } 561 562 void ib_security_release_port_pkey_list(struct ib_device *device) 563 { 564 struct pkey_index_qp_list *pkey, *tmp_pkey; 565 unsigned int i; 566 567 rdma_for_each_port (device, i) { 568 list_for_each_entry_safe(pkey, 569 tmp_pkey, 570 &device->port_data[i].pkey_list, 571 pkey_index_list) { 572 list_del(&pkey->pkey_index_list); 573 kfree(pkey); 574 } 575 } 576 } 577 578 int ib_security_modify_qp(struct ib_qp *qp, 579 struct ib_qp_attr *qp_attr, 580 int qp_attr_mask, 581 struct ib_udata *udata) 582 { 583 int ret = 0; 584 struct ib_ports_pkeys *tmp_pps; 585 struct ib_ports_pkeys *new_pps = NULL; 586 struct ib_qp *real_qp = qp->real_qp; 587 bool special_qp = (real_qp->qp_type == IB_QPT_SMI || 588 real_qp->qp_type == IB_QPT_GSI || 589 real_qp->qp_type >= IB_QPT_RESERVED1); 590 bool pps_change = ((qp_attr_mask & (IB_QP_PKEY_INDEX | IB_QP_PORT)) || 591 (qp_attr_mask & IB_QP_ALT_PATH)); 592 593 WARN_ONCE((qp_attr_mask & IB_QP_PORT && 594 rdma_protocol_ib(real_qp->device, qp_attr->port_num) && 595 !real_qp->qp_sec), 596 "%s: QP security is not initialized for IB QP: %d\n", 597 __func__, real_qp->qp_num); 598 599 /* The port/pkey settings are maintained only for the real QP. Open 600 * handles on the real QP will be in the shared_qp_list. When 601 * enforcing security on the real QP all the shared QPs will be 602 * checked as well. 603 */ 604 605 if (pps_change && !special_qp && real_qp->qp_sec) { 606 mutex_lock(&real_qp->qp_sec->mutex); 607 new_pps = get_new_pps(real_qp, 608 qp_attr, 609 qp_attr_mask); 610 if (!new_pps) { 611 mutex_unlock(&real_qp->qp_sec->mutex); 612 return -ENOMEM; 613 } 614 /* Add this QP to the lists for the new port 615 * and pkey settings before checking for permission 616 * in case there is a concurrent cache update 617 * occurring. Walking the list for a cache change 618 * doesn't acquire the security mutex unless it's 619 * sending the QP to error. 620 */ 621 ret = port_pkey_list_insert(&new_pps->main); 622 623 if (!ret) 624 ret = port_pkey_list_insert(&new_pps->alt); 625 626 if (!ret) 627 ret = check_qp_port_pkey_settings(new_pps, 628 real_qp->qp_sec); 629 } 630 631 if (!ret) 632 ret = real_qp->device->ops.modify_qp(real_qp, 633 qp_attr, 634 qp_attr_mask, 635 udata); 636 637 if (new_pps) { 638 /* Clean up the lists and free the appropriate 639 * ports_pkeys structure. 640 */ 641 if (ret) { 642 tmp_pps = new_pps; 643 } else { 644 tmp_pps = real_qp->qp_sec->ports_pkeys; 645 real_qp->qp_sec->ports_pkeys = new_pps; 646 } 647 648 if (tmp_pps) { 649 port_pkey_list_remove(&tmp_pps->main); 650 port_pkey_list_remove(&tmp_pps->alt); 651 } 652 kfree(tmp_pps); 653 mutex_unlock(&real_qp->qp_sec->mutex); 654 } 655 return ret; 656 } 657 658 static int ib_security_pkey_access(struct ib_device *dev, 659 u8 port_num, 660 u16 pkey_index, 661 void *sec) 662 { 663 u64 subnet_prefix; 664 u16 pkey; 665 int ret; 666 667 if (!rdma_protocol_ib(dev, port_num)) 668 return 0; 669 670 ret = ib_get_cached_pkey(dev, port_num, pkey_index, &pkey); 671 if (ret) 672 return ret; 673 674 ret = ib_get_cached_subnet_prefix(dev, port_num, &subnet_prefix); 675 676 if (ret) 677 return ret; 678 679 return security_ib_pkey_access(sec, subnet_prefix, pkey); 680 } 681 682 void ib_mad_agent_security_change(void) 683 { 684 struct ib_mad_agent *ag; 685 686 spin_lock(&mad_agent_list_lock); 687 list_for_each_entry(ag, 688 &mad_agent_list, 689 mad_agent_sec_list) 690 WRITE_ONCE(ag->smp_allowed, 691 !security_ib_endport_manage_subnet(ag->security, 692 dev_name(&ag->device->dev), ag->port_num)); 693 spin_unlock(&mad_agent_list_lock); 694 } 695 696 int ib_mad_agent_security_setup(struct ib_mad_agent *agent, 697 enum ib_qp_type qp_type) 698 { 699 int ret; 700 701 if (!rdma_protocol_ib(agent->device, agent->port_num)) 702 return 0; 703 704 INIT_LIST_HEAD(&agent->mad_agent_sec_list); 705 706 ret = security_ib_alloc_security(&agent->security); 707 if (ret) 708 return ret; 709 710 if (qp_type != IB_QPT_SMI) 711 return 0; 712 713 spin_lock(&mad_agent_list_lock); 714 ret = security_ib_endport_manage_subnet(agent->security, 715 dev_name(&agent->device->dev), 716 agent->port_num); 717 if (ret) 718 goto free_security; 719 720 WRITE_ONCE(agent->smp_allowed, true); 721 list_add(&agent->mad_agent_sec_list, &mad_agent_list); 722 spin_unlock(&mad_agent_list_lock); 723 return 0; 724 725 free_security: 726 spin_unlock(&mad_agent_list_lock); 727 security_ib_free_security(agent->security); 728 return ret; 729 } 730 731 void ib_mad_agent_security_cleanup(struct ib_mad_agent *agent) 732 { 733 if (!rdma_protocol_ib(agent->device, agent->port_num)) 734 return; 735 736 if (agent->qp->qp_type == IB_QPT_SMI) { 737 spin_lock(&mad_agent_list_lock); 738 list_del(&agent->mad_agent_sec_list); 739 spin_unlock(&mad_agent_list_lock); 740 } 741 742 security_ib_free_security(agent->security); 743 } 744 745 int ib_mad_enforce_security(struct ib_mad_agent_private *map, u16 pkey_index) 746 { 747 if (!rdma_protocol_ib(map->agent.device, map->agent.port_num)) 748 return 0; 749 750 if (map->agent.qp->qp_type == IB_QPT_SMI) { 751 if (!READ_ONCE(map->agent.smp_allowed)) 752 return -EACCES; 753 return 0; 754 } 755 756 return ib_security_pkey_access(map->agent.device, 757 map->agent.port_num, 758 pkey_index, 759 map->agent.security); 760 } 761