1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/ib/ibtl/impl/ibtl.h> 27 #include <sys/ib/ibtl/impl/ibtl_cm.h> 28 29 /* 30 * ibtl_cm.c 31 * These routines tie the Communication Manager into IBTL. 32 */ 33 34 /* 35 * Globals. 36 */ 37 static char ibtf_cm[] = "ibtl_cm"; 38 boolean_t ibtl_fast_gid_cache_valid = B_FALSE; 39 40 /* 41 * Function: 42 * ibtl_cm_set_chan_private 43 * Input: 44 * chan Channel Handle. 45 * cm_private CM private data. 46 * Output: 47 * none. 48 * Returns: 49 * none. 50 * Description: 51 * A helper function to store CM's Private data in the specified channel. 52 */ 53 void 54 ibtl_cm_set_chan_private(ibt_channel_hdl_t chan, void *cm_private) 55 { 56 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_set_chan_private(%p, %p)", 57 chan, cm_private); 58 59 mutex_enter(&chan->ch_cm_mutex); 60 chan->ch_cm_private = cm_private; 61 if (cm_private == NULL) 62 cv_signal(&chan->ch_cm_cv); 63 mutex_exit(&chan->ch_cm_mutex); 64 } 65 66 67 /* 68 * Function: 69 * ibtl_cm_get_chan_private 70 * Input: 71 * chan Channel Handle. 72 * Output: 73 * cm_private_p The CM private data. 74 * Returns: 75 * CM private data. 76 * Description: 77 * A helper function to get CM's Private data for the specified channel. 78 */ 79 void * 80 ibtl_cm_get_chan_private(ibt_channel_hdl_t chan) 81 { 82 void *cm_private; 83 84 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_chan_private(%p)", chan); 85 mutex_enter(&chan->ch_cm_mutex); 86 cm_private = chan->ch_cm_private; 87 #ifndef __lock_lint 88 /* IBCM will call the release function if cm_private is non-NULL */ 89 if (cm_private == NULL) 90 #endif 91 mutex_exit(&chan->ch_cm_mutex); 92 return (cm_private); 93 } 94 95 void 96 ibtl_cm_release_chan_private(ibt_channel_hdl_t chan) 97 { 98 #ifndef __lock_lint 99 mutex_exit(&chan->ch_cm_mutex); 100 #endif 101 } 102 103 void 104 ibtl_cm_wait_chan_private(ibt_channel_hdl_t chan) 105 { 106 mutex_enter(&chan->ch_cm_mutex); 107 if (chan->ch_cm_private != NULL) 108 cv_wait(&chan->ch_cm_cv, &chan->ch_cm_mutex); 109 mutex_exit(&chan->ch_cm_mutex); 110 delay(drv_usectohz(50000)); 111 } 112 113 114 /* 115 * Function: 116 * ibtl_cm_get_chan_type 117 * Input: 118 * chan Channel Handle. 119 * Output: 120 * none. 121 * Returns: 122 * Channel transport type. 123 * Description: 124 * A helper function to get channel transport type. 125 */ 126 ibt_tran_srv_t 127 ibtl_cm_get_chan_type(ibt_channel_hdl_t chan) 128 { 129 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_chan_type(%p)", chan); 130 131 return (chan->ch_qp.qp_type); 132 } 133 134 /* 135 * Function: 136 * ibtl_cm_change_service_cnt 137 * Input: 138 * ibt_hdl Client's IBT Handle. 139 * delta_num_sids The change in the number of service ids 140 * (positive for ibt_register_service() and 141 * negative fo ibt_service_deregister()). 142 */ 143 void 144 ibtl_cm_change_service_cnt(ibt_clnt_hdl_t ibt_hdl, int delta_num_sids) 145 { 146 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_change_service_cnt(%p. %d)", 147 ibt_hdl, delta_num_sids); 148 149 mutex_enter(&ibtl_clnt_list_mutex); 150 if ((delta_num_sids < 0) && (-delta_num_sids > ibt_hdl->clnt_srv_cnt)) { 151 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_change_service_cnt: " 152 "ERROR: service registration counter underflow\n" 153 "current count = %d, requested delta = %d", 154 ibt_hdl->clnt_srv_cnt, delta_num_sids); 155 } 156 ibt_hdl->clnt_srv_cnt += delta_num_sids; 157 mutex_exit(&ibtl_clnt_list_mutex); 158 } 159 160 161 /* 162 * Function: 163 * ibtl_cm_get_hca_port 164 * Input: 165 * gid Source GID. 166 * hca_guid Optional source HCA GUID on which SGID is available. 167 * Ignored if zero. 168 * Output: 169 * hca_port Pointer to ibtl_cm_hca_port_t struct. 170 * Returns: 171 * IBT_SUCCESS. 172 * Description: 173 * A helper function to get HCA node GUID, Base LID, SGID Index, 174 * port number, LMC and MTU for the specified SGID. 175 * Also filling default SGID, to be used in ibmf_sa_session_open. 176 */ 177 ibt_status_t 178 ibtl_cm_get_hca_port(ib_gid_t gid, ib_guid_t hca_guid, 179 ibtl_cm_hca_port_t *hca_port) 180 { 181 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 182 ibt_hca_portinfo_t *portinfop; 183 uint_t ports, port; 184 uint_t i; 185 ib_gid_t *sgid; 186 static ib_gid_t fast_gid; /* fast_gid_cache data */ 187 static uint8_t fast_sgid_ix; 188 static ibt_hca_portinfo_t *fast_portinfop; 189 static ib_guid_t fast_node_guid; 190 static ib_guid_t fast_port_guid; 191 192 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_hca_port(%llX:%llX, %llX)", 193 gid.gid_prefix, gid.gid_guid, hca_guid); 194 195 if ((gid.gid_prefix == 0) || (gid.gid_guid == 0)) { 196 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_get_hca_port: " 197 "NULL SGID specified."); 198 return (IBT_INVALID_PARAM); 199 } 200 201 mutex_enter(&ibtl_clnt_list_mutex); 202 203 if ((ibtl_fast_gid_cache_valid == B_TRUE) && 204 (gid.gid_guid == fast_gid.gid_guid) && 205 (gid.gid_prefix == fast_gid.gid_prefix)) { 206 207 if ((hca_guid != 0) && (hca_guid != fast_node_guid)) { 208 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_hca_port: " 209 "Mis-match hca_guid v/s sgid combination."); 210 mutex_exit(&ibtl_clnt_list_mutex); 211 return (IBT_INVALID_PARAM); 212 } 213 214 portinfop = fast_portinfop; 215 hca_port->hp_base_lid = portinfop->p_base_lid; 216 hca_port->hp_port = portinfop->p_port_num; 217 hca_port->hp_sgid_ix = fast_sgid_ix; 218 hca_port->hp_lmc = portinfop->p_lmc; 219 hca_port->hp_mtu = portinfop->p_mtu; 220 hca_port->hp_hca_guid = fast_node_guid; 221 hca_port->hp_port_guid = fast_port_guid; 222 223 mutex_exit(&ibtl_clnt_list_mutex); 224 225 return (IBT_SUCCESS); 226 } 227 228 /* If HCA GUID is specified, then lookup in that device only. */ 229 if (hca_guid) { 230 hca_devp = ibtl_get_hcadevinfo(hca_guid); 231 } else { 232 hca_devp = ibtl_hca_list; 233 } 234 235 while (hca_devp != NULL) { 236 237 ports = hca_devp->hd_hca_attr->hca_nports; 238 portinfop = hca_devp->hd_portinfop; 239 240 for (port = 0; port < ports; port++, portinfop++) { 241 if (portinfop->p_linkstate != IBT_PORT_ACTIVE) 242 continue; 243 sgid = &portinfop->p_sgid_tbl[0]; 244 for (i = 0; i < portinfop->p_sgid_tbl_sz; i++, sgid++) { 245 if ((gid.gid_guid != sgid->gid_guid) || 246 (gid.gid_prefix != sgid->gid_prefix)) 247 continue; 248 249 /* 250 * Found the matching GID. 251 */ 252 ibtl_fast_gid_cache_valid = B_TRUE; 253 fast_gid = gid; 254 fast_portinfop = portinfop; 255 fast_node_guid = hca_port->hp_hca_guid = 256 hca_devp->hd_hca_attr->hca_node_guid; 257 fast_sgid_ix = hca_port->hp_sgid_ix = i; 258 fast_port_guid = 259 portinfop->p_sgid_tbl[0].gid_guid; 260 hca_port->hp_port_guid = fast_port_guid; 261 hca_port->hp_base_lid = portinfop->p_base_lid; 262 hca_port->hp_port = portinfop->p_port_num; 263 hca_port->hp_lmc = portinfop->p_lmc; 264 hca_port->hp_mtu = portinfop->p_mtu; 265 266 mutex_exit(&ibtl_clnt_list_mutex); 267 268 return (IBT_SUCCESS); 269 } 270 } 271 272 /* Asked to look in the specified HCA device only?. */ 273 if (hca_guid) 274 break; 275 276 /* Get next in the list */ 277 hca_devp = hca_devp->hd_hca_dev_link; 278 } 279 280 mutex_exit(&ibtl_clnt_list_mutex); 281 282 /* If we are here, then we failed to get a match, so return error. */ 283 return (IBT_INVALID_PARAM); 284 } 285 286 287 static ibt_status_t 288 ibtl_cm_get_cnt(ibt_path_attr_t *attr, ibt_path_flags_t flags, 289 ibtl_cm_port_list_t *plistp, uint_t *count) 290 { 291 ibtl_hca_devinfo_t *hdevp; 292 ibt_hca_portinfo_t *pinfop; 293 ib_guid_t hca_guid, tmp_hca_guid = 0; 294 ib_gid_t gid; 295 uint_t pcount = 0, tmp_pcount = 0; 296 uint_t cnt = *count; 297 ibt_status_t retval = IBT_SUCCESS; 298 uint_t i, j; 299 300 *count = 0; 301 302 /* If HCA GUID is specified, then lookup in that device only. */ 303 if (attr->pa_hca_guid) { 304 hdevp = ibtl_get_hcadevinfo(attr->pa_hca_guid); 305 } else { 306 hdevp = ibtl_hca_list; 307 } 308 309 while (hdevp != NULL) { 310 hca_guid = hdevp->hd_hca_attr->hca_node_guid; 311 312 if ((flags & IBT_PATH_APM) && 313 (!(hdevp->hd_hca_attr->hca_flags & 314 IBT_HCA_AUTO_PATH_MIG))) { 315 316 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_get_cnt: " 317 "HCA (%llX) - APM NOT SUPPORTED ", hca_guid); 318 319 retval = IBT_APM_NOT_SUPPORTED; 320 321 if (attr->pa_hca_guid) 322 break; 323 goto search_next; 324 } 325 326 for (i = 0; i < hdevp->hd_hca_attr->hca_nports; i++) { 327 328 if ((attr->pa_hca_port_num) && 329 (attr->pa_hca_port_num != (i + 1))) { 330 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_cnt: " 331 "Asked only on Port# %d, so skip this " 332 "port(%d)", attr->pa_hca_port_num, (i + 1)); 333 continue; 334 } 335 pinfop = hdevp->hd_portinfop + i; 336 337 if (pinfop->p_linkstate != IBT_PORT_ACTIVE) { 338 retval = IBT_HCA_PORT_NOT_ACTIVE; 339 continue; 340 } 341 if (attr->pa_mtu.r_mtu) { 342 if ((attr->pa_mtu.r_selector == IBT_GT) && 343 (attr->pa_mtu.r_mtu >= pinfop->p_mtu)) 344 continue; 345 else if ((attr->pa_mtu.r_selector == IBT_EQU) && 346 (attr->pa_mtu.r_mtu > pinfop->p_mtu)) 347 continue; 348 } 349 350 if ((flags & IBT_PATH_APM) && (!attr->pa_hca_guid) && 351 attr->pa_sgid.gid_prefix && 352 attr->pa_sgid.gid_guid) { 353 for (j = 0; j < pinfop->p_sgid_tbl_sz; j++) { 354 gid = pinfop->p_sgid_tbl[j]; 355 if (gid.gid_prefix && gid.gid_guid) { 356 if ((attr->pa_sgid.gid_prefix != 357 gid.gid_prefix) || 358 (attr->pa_sgid.gid_guid != 359 gid.gid_guid)) { 360 continue; 361 } else { 362 attr->pa_hca_guid = 363 hca_guid; 364 goto got_apm_hca_info; 365 } 366 } 367 } 368 continue; 369 } 370 got_apm_hca_info: 371 for (j = 0; j < pinfop->p_sgid_tbl_sz; j++) { 372 gid = pinfop->p_sgid_tbl[j]; 373 if (gid.gid_prefix && gid.gid_guid) { 374 if (!(flags & IBT_PATH_APM) && 375 attr->pa_sgid.gid_prefix && 376 attr->pa_sgid.gid_guid) { 377 if ((attr->pa_sgid.gid_prefix != 378 gid.gid_prefix) || 379 (attr->pa_sgid.gid_guid != 380 gid.gid_guid)) 381 continue; 382 } 383 pcount++; 384 if (plistp) { 385 plistp->p_hca_guid = hca_guid; 386 plistp->p_mtu = pinfop->p_mtu; 387 plistp->p_base_lid = 388 pinfop->p_base_lid; 389 plistp->p_port_num = 390 pinfop->p_port_num; 391 plistp->p_sgid_ix = j; 392 plistp->p_sgid = gid; 393 plistp->p_count = cnt; 394 if (hdevp->hd_multism) 395 plistp->p_multi |= 396 IBTL_CM_MULTI_SM; 397 398 IBTF_DPRINTF_L3(ibtf_cm, 399 "ibtl_cm_get_cnt: HCA" 400 "(%llX,%d) SGID(%llX:%llX)", 401 plistp->p_hca_guid, 402 plistp->p_port_num, 403 plistp->p_sgid.gid_prefix, 404 plistp->p_sgid.gid_guid); 405 406 plistp++; 407 } 408 } 409 } 410 } 411 /* Asked to look in the specified HCA device only?. */ 412 if (attr->pa_hca_guid) 413 break; 414 415 if (flags & IBT_PATH_APM) { 416 if (pcount == 2) { 417 attr->pa_hca_guid = hca_guid; 418 break; 419 } else if (pcount == 1) { 420 if (hdevp->hd_hca_dev_link) { 421 tmp_hca_guid = hca_guid; 422 tmp_pcount = pcount; 423 pcount = 0; 424 } else if (tmp_hca_guid) { 425 attr->pa_hca_guid = tmp_hca_guid; 426 } else { 427 attr->pa_hca_guid = hca_guid; 428 } 429 } else if ((pcount == 0) && (tmp_hca_guid)) { 430 attr->pa_hca_guid = tmp_hca_guid; 431 pcount = tmp_pcount; 432 } 433 } 434 search_next: 435 hdevp = hdevp->hd_hca_dev_link; 436 } 437 438 *count = pcount; 439 440 if (pcount) { 441 retval = IBT_SUCCESS; 442 } else { 443 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_get_cnt: " 444 "Appropriate Source Points NOT found"); 445 if (retval == IBT_SUCCESS) 446 retval = IBT_NO_HCAS_AVAILABLE; 447 } 448 449 return (retval); 450 } 451 452 453 ibt_status_t 454 ibtl_cm_get_active_plist(ibt_path_attr_t *attr, ibt_path_flags_t flags, 455 ibtl_cm_port_list_t **port_list_p) 456 { 457 ibtl_cm_port_list_t *p_listp, tmp; 458 uint_t i, j; 459 uint_t count, rcount; 460 boolean_t multi_hca = B_FALSE; 461 ibt_status_t retval = IBT_SUCCESS; 462 463 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_active_plist(%p, %X)", 464 attr, flags); 465 466 get_plist_start: 467 *port_list_p = NULL; 468 469 /* Get "number of active src points" so that we can allocate memory. */ 470 mutex_enter(&ibtl_clnt_list_mutex); 471 retval = ibtl_cm_get_cnt(attr, flags, NULL, &count); 472 mutex_exit(&ibtl_clnt_list_mutex); 473 474 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_active_plist: Found %d SrcPoint", 475 count); 476 if (retval != IBT_SUCCESS) 477 return (retval); 478 479 /* Allocate Memory to hold Src Point information. */ 480 p_listp = kmem_zalloc(count * sizeof (ibtl_cm_port_list_t), KM_SLEEP); 481 482 /* 483 * Verify that the count we got previously is still valid, as we had 484 * dropped mutex to allocate memory. If not, restart the process. 485 */ 486 mutex_enter(&ibtl_clnt_list_mutex); 487 retval = ibtl_cm_get_cnt(attr, flags, NULL, &rcount); 488 if (retval != IBT_SUCCESS) { 489 mutex_exit(&ibtl_clnt_list_mutex); 490 kmem_free(p_listp, count * sizeof (ibtl_cm_port_list_t)); 491 return (retval); 492 } else if (rcount != count) { 493 mutex_exit(&ibtl_clnt_list_mutex); 494 kmem_free(p_listp, count * sizeof (ibtl_cm_port_list_t)); 495 goto get_plist_start; 496 } 497 498 *port_list_p = p_listp; 499 /* 500 * Src count hasn't changed, still holding the lock fill-in the 501 * required source point information. 502 */ 503 retval = ibtl_cm_get_cnt(attr, flags, p_listp, &rcount); 504 mutex_exit(&ibtl_clnt_list_mutex); 505 if (retval != IBT_SUCCESS) { 506 kmem_free(p_listp, count * sizeof (ibtl_cm_port_list_t)); 507 *port_list_p = NULL; 508 return (retval); 509 } 510 511 p_listp = *port_list_p; 512 513 _NOTE(NO_COMPETING_THREADS_NOW) 514 515 for (i = 0; i < count - 1; i++) { 516 for (j = 0; j < count - 1 - i; j++) { 517 if (p_listp[j].p_hca_guid != p_listp[j+1].p_hca_guid) { 518 multi_hca = B_TRUE; 519 break; 520 } 521 } 522 if (multi_hca == B_TRUE) 523 break; 524 } 525 526 if (multi_hca == B_TRUE) 527 for (i = 0; i < count; i++) 528 p_listp[i].p_multi |= IBTL_CM_MULTI_HCA; 529 530 /* 531 * Sort (bubble sort) the list based on MTU quality (higher on top). 532 * Sorting is only performed, if IBT_PATH_AVAIL is set. 533 */ 534 if (((attr->pa_mtu.r_selector == IBT_GT) || (flags & IBT_PATH_AVAIL)) && 535 (!(flags & IBT_PATH_APM))) { 536 for (i = 0; i < count - 1; i++) { 537 for (j = 0; j < count - 1 - i; j++) { 538 if (p_listp[j].p_mtu < p_listp[j+1].p_mtu) { 539 tmp = p_listp[j]; 540 p_listp[j] = p_listp[j+1]; 541 p_listp[j+1] = tmp; 542 } 543 } 544 } 545 } 546 547 if ((p_listp->p_multi & IBTL_CM_MULTI_HCA) && 548 (flags & IBT_PATH_AVAIL) && (!(flags & IBT_PATH_APM))) { 549 /* Avoid having same HCA next to each other in the list. */ 550 for (i = 0; i < count - 1; i++) { 551 for (j = 0; j < (count - 1 - i); j++) { 552 if ((p_listp[j].p_hca_guid == 553 p_listp[j+1].p_hca_guid) && 554 (j+2 < count)) { 555 tmp = p_listp[j+1]; 556 p_listp[j+1] = p_listp[j+2]; 557 p_listp[j+2] = tmp; 558 } 559 } 560 } 561 } 562 563 /* 564 * If SGID is specified, then make sure that SGID info is first 565 * in the array. 566 */ 567 if (attr->pa_sgid.gid_guid && (p_listp->p_count > 1) && 568 (p_listp[0].p_sgid.gid_guid != attr->pa_sgid.gid_guid)) { 569 for (i = 1; i < count; i++) { 570 if (p_listp[i].p_sgid.gid_guid == 571 attr->pa_sgid.gid_guid) { 572 tmp = p_listp[i]; 573 p_listp[i] = p_listp[0]; 574 p_listp[0] = tmp; 575 } 576 } 577 } 578 579 #ifndef lint 580 _NOTE(COMPETING_THREADS_NOW) 581 #endif 582 583 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_active_plist: " 584 "Returned <%d> entries @0x%p", count, *port_list_p); 585 586 return (retval); 587 } 588 589 590 void 591 ibtl_cm_free_active_plist(ibtl_cm_port_list_t *plist) 592 { 593 int count; 594 595 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_free_active_plist(%p)", plist); 596 597 if (plist != NULL) { 598 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*plist)) 599 count = plist->p_count; 600 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*plist)) 601 602 kmem_free(plist, count * sizeof (ibtl_cm_port_list_t)); 603 } 604 } 605 606 /* 607 * Function: 608 * ibtl_cm_get_1st_full_pkey_ix 609 * Input: 610 * hca_guid HCA GUID. 611 * port Port Number. 612 * Output: 613 * None. 614 * Returns: 615 * P_Key Index of the first full member available from the P_Key table 616 * of the specified HCA<->Port. 617 * Description: 618 * A helper function to get P_Key Index of the first full member P_Key 619 * available on the specified HCA and Port combination. 620 */ 621 uint16_t 622 ibtl_cm_get_1st_full_pkey_ix(ib_guid_t hca_guid, uint8_t port) 623 { 624 ibtl_hca_devinfo_t *hca_devp; /* HCA Dev Info */ 625 uint16_t pkey_ix = 0; 626 627 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_1st_full_pkey_ix(%llX, %d)", 628 hca_guid, port); 629 630 mutex_enter(&ibtl_clnt_list_mutex); 631 hca_devp = ibtl_get_hcadevinfo(hca_guid); 632 633 if ((hca_devp != NULL) && (port <= hca_devp->hd_hca_attr->hca_nports) && 634 (port != 0)) { 635 pkey_ix = hca_devp->hd_portinfop[port - 1].p_def_pkey_ix; 636 } else { 637 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_get_1st_full_pkey_ix: " 638 "Invalid HCA (%llX), Port (%d) specified.", hca_guid, port); 639 } 640 mutex_exit(&ibtl_clnt_list_mutex); 641 642 return (pkey_ix); 643 } 644 645 646 ibt_status_t 647 ibtl_cm_get_local_comp_gids(ib_guid_t hca_guid, ib_gid_t gid, ib_gid_t **gids_p, 648 uint_t *num_gids_p) 649 { 650 ibtl_hca_devinfo_t *hdevp; /* HCA Dev Info */ 651 ibt_hca_portinfo_t *pinfop; 652 ib_gid_t sgid; 653 ib_gid_t *gidp = NULL; 654 int i, j, k; 655 int count = 0; 656 int gid_specified; 657 658 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_local_comp_gids(%llX, %llX:%llX)", 659 hca_guid, gid.gid_prefix, gid.gid_guid); 660 661 mutex_enter(&ibtl_clnt_list_mutex); 662 hdevp = ibtl_get_hcadevinfo(hca_guid); 663 664 if (hdevp == NULL) { 665 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_get_local_comp_gids: ", 666 "NO HCA (%llX) availble", hca_guid); 667 mutex_exit(&ibtl_clnt_list_mutex); 668 return (IBT_NO_HCAS_AVAILABLE); 669 } 670 671 if (gid.gid_prefix && gid.gid_guid) 672 gid_specified = 1; 673 else 674 gid_specified = 0; 675 676 for (i = 0; i < hdevp->hd_hca_attr->hca_nports; i++) { 677 pinfop = hdevp->hd_portinfop + i; 678 679 if (pinfop->p_linkstate != IBT_PORT_ACTIVE) 680 continue; 681 682 for (j = 0; j < pinfop->p_sgid_tbl_sz; j++) { 683 sgid = pinfop->p_sgid_tbl[j]; 684 if (sgid.gid_prefix && sgid.gid_guid) { 685 if (gid_specified && 686 ((gid.gid_prefix == sgid.gid_prefix) && 687 (gid.gid_guid == sgid.gid_guid))) { 688 /* 689 * Don't return the input specified 690 * GID 691 */ 692 continue; 693 } 694 count++; 695 } 696 } 697 } 698 699 if (count == 0) { 700 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_get_local_comp_gids: " 701 "Companion GIDs not available"); 702 mutex_exit(&ibtl_clnt_list_mutex); 703 return (IBT_GIDS_NOT_FOUND); 704 } 705 706 gidp = kmem_zalloc(count * sizeof (ib_gid_t), KM_SLEEP); 707 *num_gids_p = count; 708 *gids_p = gidp; 709 k = 0; 710 711 for (i = 0; i < hdevp->hd_hca_attr->hca_nports; i++) { 712 pinfop = hdevp->hd_portinfop + i; 713 714 if (pinfop->p_linkstate != IBT_PORT_ACTIVE) 715 continue; 716 717 for (j = 0; j < pinfop->p_sgid_tbl_sz; j++) { 718 sgid = pinfop->p_sgid_tbl[j]; 719 if (sgid.gid_prefix && sgid.gid_guid) { 720 if (gid_specified && 721 ((gid.gid_prefix == sgid.gid_prefix) && 722 (gid.gid_guid == sgid.gid_guid))) 723 continue; 724 725 gidp[k].gid_prefix = sgid.gid_prefix; 726 gidp[k].gid_guid = sgid.gid_guid; 727 728 IBTF_DPRINTF_L3(ibtf_cm, 729 "ibtl_cm_get_local_comp_gids: GID[%d]=" 730 "%llX:%llX", k, gidp[k].gid_prefix, 731 gidp[k].gid_guid); 732 k++; 733 if (k == count) 734 break; 735 } 736 } 737 if (k == count) 738 break; 739 } 740 mutex_exit(&ibtl_clnt_list_mutex); 741 742 return (IBT_SUCCESS); 743 } 744 745 746 int 747 ibtl_cm_is_multi_sm(ib_guid_t hca_guid) 748 { 749 ibtl_hca_devinfo_t *hdevp; /* HCA Dev Info */ 750 uint_t multi_sm; 751 752 mutex_enter(&ibtl_clnt_list_mutex); 753 hdevp = ibtl_get_hcadevinfo(hca_guid); 754 if (hdevp == NULL) { 755 IBTF_DPRINTF_L2(ibtf_cm, "ibtl_cm_is_multi_sm: NO HCA (%llX) " 756 "availble", hca_guid); 757 mutex_exit(&ibtl_clnt_list_mutex); 758 return (-1); 759 } 760 multi_sm = hdevp->hd_multism; 761 mutex_exit(&ibtl_clnt_list_mutex); 762 763 IBTF_DPRINTF_L3(ibtf_cm, "ibtl_cm_is_multi_sm(%llX): %d", hca_guid, 764 multi_sm); 765 766 return (multi_sm); 767 } 768 769 char * 770 ibtl_cm_get_clnt_name(ibt_clnt_hdl_t ibt_hdl) 771 { 772 if (ibt_hdl) 773 return (ibt_hdl->clnt_name); 774 else 775 return (NULL); 776 } 777