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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/ib/mgt/ibcm/ibcm_impl.h> 26 #include <sys/ib/ibtl/ibti.h> 27 #include <sys/ib/mgt/ibcm/ibcm_arp.h> 28 29 /* 30 * ibcm_ti.c 31 * These routines implement the Communication Manager's interfaces to IBTL. 32 */ 33 34 /* CM rc recycle task args structure definition */ 35 typedef struct ibcm_taskq_recycle_arg_s { 36 ibt_channel_hdl_t rc_chan; 37 ibt_cep_flags_t control; 38 uint8_t hca_port_num; 39 ibt_recycle_handler_t func; 40 void *arg; 41 } ibcm_taskq_recycle_arg_t; 42 43 _NOTE(READ_ONLY_DATA(ibcm_taskq_recycle_arg_s)) 44 45 static ibt_status_t ibcm_init_reply_addr(ibcm_hca_info_t *hcap, 46 ibcm_mad_addr_t *reply_addr, ibt_chan_open_args_t *chan_args, 47 ibt_chan_open_flags_t flags, ib_time_t *cm_pkt_lt, ib_lid_t prim_slid); 48 static void ibcm_process_abort_via_taskq(void *args); 49 static ibt_status_t ibcm_process_rc_recycle_ret(void *recycle_arg); 50 static ibt_status_t ibcm_process_join_mcg(void *taskq_arg); 51 static void ibcm_process_async_join_mcg(void *tq_arg); 52 53 ibt_status_t ibcm_get_node_rec(ibmf_saa_handle_t, sa_node_record_t *, 54 uint64_t c_mask, void *, size_t *); 55 56 static ibt_status_t ibcm_close_rc_channel(ibt_channel_hdl_t channel, 57 ibcm_state_data_t *statep, ibt_execution_mode_t mode); 58 59 /* Address Record management definitions */ 60 #define IBCM_DAPL_ATS_NAME "DAPL Address Translation Service" 61 #define IBCM_DAPL_ATS_SID 0x10000CE100415453ULL 62 #define IBCM_DAPL_ATS_NBYTES 16 63 ibcm_svc_info_t *ibcm_ar_svcinfop; 64 ibcm_ar_t *ibcm_ar_list; 65 66 /* 67 * Tunable parameter to turnoff the overriding of pi_path_mtu value. 68 * 1 By default override the path record's pi_path_mtu value to 69 * IB_MTU_1K for all RC channels. This is done only for the 70 * channels established on Tavor HCA and the path's pi_path_mtu 71 * is greater than IB_MTU_1K. 72 * 0 Do not override, use pi_path_mtu by default. 73 */ 74 int ibcm_override_path_mtu = 1; 75 76 #ifdef DEBUG 77 static void ibcm_print_reply_addr(ibt_channel_hdl_t channel, 78 ibcm_mad_addr_t *cm_reply_addr); 79 #endif 80 81 _NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_port_info_s::{port_ibmf_hdl})) 82 83 /* access is controlled between ibcm_sm.c and ibcm_ti.c by CVs */ 84 _NOTE(SCHEME_PROTECTS_DATA("Serialized access by CV", {ibt_rc_returns_t 85 ibt_ud_returns_t ibt_ap_returns_t ibt_ar_t})) 86 87 /* 88 * Typically, clients initialize these args in one api call, and use in 89 * another api 90 */ 91 _NOTE(SCHEME_PROTECTS_DATA("Expected usage of ibtl api by client", 92 {ibt_path_info_s ibt_cep_path_s ibt_adds_vect_s ibt_mcg_info_s ib_gid_s 93 ibt_ud_dest_attr_s ibt_ud_dest_s ibt_srv_data_s ibt_redirect_info_s})) 94 95 /* 96 * ibt_open_rc_channel() 97 * ibt_open_rc_channel opens a communication channel on the specified 98 * channel to the specified service. For connection service type qp's 99 * the CM initiates the CEP to establish the connection and transitions 100 * the QP/EEC to the "Ready to send" State modifying the QP/EEC's 101 * attributes as necessary. 102 * The implementation of this function assumes that alt path is different 103 * from primary path. It is assumed that the Path functions ensure that. 104 * 105 * RETURN VALUES: 106 * IBT_SUCCESS on success (or respective failure on error) 107 */ 108 ibt_status_t 109 ibt_open_rc_channel(ibt_channel_hdl_t channel, ibt_chan_open_flags_t flags, 110 ibt_execution_mode_t mode, ibt_chan_open_args_t *chan_args, 111 ibt_rc_returns_t *ret_args) 112 { 113 /* all fields that are related to REQ MAD formation */ 114 115 ib_pkey_t prim_pkey; 116 ib_lid_t primary_slid, alternate_slid; 117 ib_qpn_t local_qpn = 0; 118 ib_guid_t hca_guid; 119 ib_qkey_t local_qkey = 0; 120 ib_eecn_t local_eecn = 0; 121 ib_eecn_t remote_eecn = 0; 122 boolean_t primary_grh; 123 boolean_t alternate_grh = B_FALSE; 124 ib_lid_t base_lid; 125 ib_com_id_t local_comid; 126 ibmf_msg_t *ibmf_msg, *ibmf_msg_dreq; 127 ibcm_req_msg_t *req_msgp; 128 129 uint8_t rdma_in, rdma_out; 130 uint8_t cm_retries; 131 uint64_t local_cm_proc_time; /* In usec */ 132 uint8_t local_cm_resp_time; /* IB time */ 133 uint64_t remote_cm_resp_time; /* In usec */ 134 uint32_t starting_psn = 0; 135 136 /* CM path related fields */ 137 ibmf_handle_t ibmf_hdl; 138 ibcm_qp_list_t *cm_qp_entry; 139 ibcm_mad_addr_t cm_reply_addr; 140 141 uint8_t cm_pkt_lt; 142 143 /* Local args for ibtl/internal CM functions called within */ 144 ibt_status_t status; 145 ibcm_status_t lkup_status; 146 ibt_qp_query_attr_t qp_query_attr; 147 148 /* Other misc local args */ 149 ibt_priv_data_len_t len; 150 ibcm_hca_info_t *hcap; 151 ibcm_state_data_t *statep; 152 uint8_t port_no; 153 154 IBTF_DPRINTF_L3(cmlog, "ibt_open_rc_channel(chan %p, %X, %x, %p, %p)", 155 channel, flags, mode, chan_args, ret_args); 156 157 if (IBCM_INVALID_CHANNEL(channel)) { 158 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: invalid channel"); 159 return (IBT_CHAN_HDL_INVALID); 160 } 161 162 /* cm handler should always be specified */ 163 if (chan_args->oc_cm_handler == NULL) { 164 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 165 "CM handler is not be specified", channel); 166 return (IBT_INVALID_PARAM); 167 } 168 169 if (mode == IBT_NONBLOCKING) { 170 if (ret_args != NULL) { 171 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p" 172 " ret_args should be NULL when called in " 173 "non-blocking mode", channel); 174 return (IBT_INVALID_PARAM); 175 } 176 } else if (mode == IBT_BLOCKING) { 177 if (ret_args == NULL) { 178 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p" 179 " ret_args should be Non-NULL when called in " 180 "blocking mode", channel); 181 return (IBT_INVALID_PARAM); 182 } 183 if (ret_args->rc_priv_data_len > IBT_REP_PRIV_DATA_SZ) { 184 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p" 185 " private data length is too large", channel); 186 return (IBT_INVALID_PARAM); 187 } 188 if ((ret_args->rc_priv_data_len > 0) && 189 (ret_args->rc_priv_data == NULL)) { 190 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p" 191 " rc_priv_data_len > 0, but rc_priv_data NULL", 192 channel); 193 return (IBT_INVALID_PARAM); 194 } 195 } else { /* any other mode is not valid for ibt_open_rc_channel */ 196 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 197 "invalid mode %x specified", channel, mode); 198 return (IBT_INVALID_PARAM); 199 } 200 201 /* 202 * XXX: no support yet for ibt_chan_open_flags_t - IBT_OCHAN_DUP 203 */ 204 if (flags & IBT_OCHAN_DUP) { 205 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 206 "Unsupported Flags specified: 0x%X", channel, flags); 207 return (IBT_INVALID_PARAM); 208 } 209 210 if ((flags & IBT_OCHAN_REDIRECTED) && 211 (flags & IBT_OCHAN_PORT_REDIRECTED)) { 212 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 213 "Illegal to specify IBT_OCHAN_REDIRECTED and " 214 "IBT_OCHAN_PORT_REDIRECTED flags together", channel); 215 return (IBT_INVALID_PARAM); 216 } 217 218 if (((flags & IBT_OCHAN_REDIRECTED) && 219 (chan_args->oc_cm_redirect_info == NULL)) || 220 ((flags & IBT_OCHAN_PORT_REDIRECTED) && 221 (chan_args->oc_cm_cep_path == NULL))) { 222 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 223 "Redirect flag specified, but respective arg is NULL", 224 channel); 225 return (IBT_INVALID_PARAM); 226 } 227 228 if ((flags & IBT_OCHAN_REDIRECTED) && 229 (chan_args->oc_cm_redirect_info->rdi_dlid == 0) && 230 (chan_args->oc_cm_redirect_info->rdi_gid.gid_guid == 0)) { 231 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 232 "Either rdi_dlid or rdi_gid must be specified for" 233 " IBT_OCHAN_REDIRECTED", channel); 234 return (IBT_INVALID_PARAM); 235 } 236 237 /* primary dlid and hca_port_num should never be zero */ 238 port_no = IBCM_PRIM_CEP_PATH(chan_args).cep_hca_port_num; 239 240 if ((IBCM_PRIM_ADDS_VECT(chan_args).av_dlid == 0) && (port_no == 0)) { 241 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 242 "Primary Path's information is not valid", channel); 243 return (IBT_INVALID_PARAM); 244 } 245 246 /* validate SID */ 247 if (chan_args->oc_path->pi_sid == 0) { 248 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 249 "ERROR: Service ID in path information is 0", channel); 250 return (IBT_INVALID_PARAM); 251 } 252 IBTF_DPRINTF_L3(cmlog, "ibt_open_rc_channel: chan 0x%p SID %llX", 253 channel, chan_args->oc_path->pi_sid); 254 255 /* validate rnr_retry_cnt (enum has more than 3 bits) */ 256 if ((uint_t)chan_args->oc_path_rnr_retry_cnt > IBT_RNR_INFINITE_RETRY) { 257 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 258 "ERROR: oc_path_rnr_retry_cnt(%d) is out of range", 259 channel, chan_args->oc_path_rnr_retry_cnt); 260 return (IBT_INVALID_PARAM); 261 } 262 263 /* 264 * Ensure that client is not re-using a QP that is still associated 265 * with a statep 266 */ 267 IBCM_GET_CHAN_PRIVATE(channel, statep); 268 if (statep != NULL) { 269 IBCM_RELEASE_CHAN_PRIVATE(channel); 270 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 271 "Channel being re-used on active side", channel); 272 return (IBT_CHAN_IN_USE); 273 } 274 275 /* Get GUID from Channel */ 276 hca_guid = ibt_channel_to_hca_guid(channel); 277 278 /* validate QP's hca guid with that from primary path */ 279 if (hca_guid != chan_args->oc_path->pi_hca_guid) { 280 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 281 "GUID from Channel and primary path don't match", channel); 282 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 283 "Channel GUID %llX primary path GUID %llX", channel, 284 hca_guid, chan_args->oc_path->pi_hca_guid); 285 return (IBT_CHAN_HDL_INVALID); 286 } 287 288 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 289 "Local HCA GUID %llX", channel, hca_guid); 290 291 status = ibt_query_qp(channel, &qp_query_attr); 292 if (status != IBT_SUCCESS) { 293 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 294 "ibt_query_qp failed %d", channel, status); 295 return (status); 296 } 297 298 /* If client specified "no port change on QP" */ 299 if ((qp_query_attr.qp_info.qp_transport.rc.rc_path.cep_hca_port_num != 300 port_no) && (flags & IBT_OCHAN_PORT_FIXED)) { 301 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 302 "chan port %d and path port %d does not match", channel, 303 qp_query_attr.qp_info.qp_transport.rc.rc_path. \ 304 cep_hca_port_num, port_no); 305 return (IBT_INVALID_PARAM); 306 } 307 308 if (qp_query_attr.qp_info.qp_trans != IBT_RC_SRV) { 309 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 310 "Invalid Channel type: Applicable only to RC Channel", 311 channel); 312 return (IBT_CHAN_SRV_TYPE_INVALID); 313 } 314 315 /* Check if QP is in INIT state or not */ 316 if (qp_query_attr.qp_info.qp_state != IBT_STATE_INIT) { 317 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 318 "QP is not in INIT state %x", channel, 319 qp_query_attr.qp_info.qp_state); 320 return (IBT_CHAN_STATE_INVALID); 321 } 322 323 local_qpn = qp_query_attr.qp_qpn; 324 325 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p Active QPN 0x%x", 326 channel, local_qpn); 327 328 #ifdef NO_EEC_SUPPORT_YET 329 330 if (flags & IBT_OCHAN_RDC_EXISTS) { 331 ibt_eec_query_attr_t eec_query_attr; 332 333 local_qkey = qp_query_attr.qp_info.qp_transport.rd_qkey; 334 335 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: RD"); 336 337 status = ibt_query_eec(channel, &eec_query_attr); 338 if (status != IBT_SUCCESS) { 339 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p" 340 " ibt_query_eec failed %d", channel, status); 341 return (status); 342 } 343 local_eecn = eec_query_attr.eec_eecn; 344 } 345 346 #endif 347 if (chan_args->oc_path->pi_prim_pkt_lt > ibcm_max_ib_pkt_lt) { 348 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 349 "Huge PktLifeTime %d, Max is %d", channel, 350 chan_args->oc_path->pi_prim_pkt_lt, ibcm_max_ib_pkt_lt); 351 return (IBT_PATH_PKT_LT_TOO_HIGH); 352 } 353 354 /* If no HCA found return failure */ 355 if ((hcap = ibcm_find_hca_entry(hca_guid)) == NULL) { 356 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 357 "hcap is NULL. Probably hca is not in active state", 358 channel); 359 return (IBT_CHAN_HDL_INVALID); 360 } 361 362 rdma_out = chan_args->oc_rdma_ra_out; 363 rdma_in = chan_args->oc_rdma_ra_in; 364 365 if ((rdma_in > hcap->hca_max_rdma_in_qp) || 366 (rdma_out > hcap->hca_max_rdma_out_qp)) { 367 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 368 "rdma in %d/out %d values exceed hca limits(%d/%d)", 369 channel, rdma_in, rdma_out, hcap->hca_max_rdma_in_qp, 370 hcap->hca_max_rdma_out_qp); 371 ibcm_dec_hca_acc_cnt(hcap); 372 return (IBT_INVALID_PARAM); 373 } 374 375 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 376 "rdma_in %d rdma_out %d", channel, rdma_in, rdma_out); 377 378 status = ibt_get_port_state_byguid(hcap->hca_guid, port_no, 379 NULL, &base_lid); 380 if (status != IBT_SUCCESS) { 381 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 382 "primary port_num %d not active", channel, port_no); 383 ibcm_dec_hca_acc_cnt(hcap); 384 return (status); 385 } 386 387 /* Validate P_KEY Index */ 388 status = ibt_index2pkey_byguid(hcap->hca_guid, port_no, 389 IBCM_PRIM_CEP_PATH(chan_args).cep_pkey_ix, &prim_pkey); 390 if (status != IBT_SUCCESS) { 391 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 392 "Invalid Primary PKeyIx %x", channel, 393 IBCM_PRIM_CEP_PATH(chan_args).cep_pkey_ix); 394 ibcm_dec_hca_acc_cnt(hcap); 395 return (status); 396 } 397 398 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 399 "primary_port_num %d primary_pkey 0x%x", channel, port_no, 400 prim_pkey); 401 402 if ((hcap->hca_port_info[port_no - 1].port_ibmf_hdl == NULL) && 403 ((status = ibcm_hca_reinit_port(hcap, port_no - 1)) 404 != IBT_SUCCESS)) { 405 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 406 "ibmf reg or callback setup failed during re-initialize", 407 channel); 408 ibcm_dec_hca_acc_cnt(hcap); 409 return (status); 410 } 411 412 ibmf_hdl = hcap->hca_port_info[port_no - 1].port_ibmf_hdl; 413 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 414 "primary ibmf_hdl = 0x%p", channel, ibmf_hdl); 415 416 primary_slid = base_lid + IBCM_PRIM_ADDS_VECT(chan_args).av_src_path; 417 418 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: channel 0x%p " 419 "primary SLID = %x", channel, primary_slid); 420 421 /* check first if alternate path exists or not as it is OPTIONAL */ 422 if (IBCM_ALT_CEP_PATH(chan_args).cep_hca_port_num != 0) { 423 uint8_t alt_port_no; 424 425 alt_port_no = IBCM_ALT_CEP_PATH(chan_args).cep_hca_port_num; 426 427 if (chan_args->oc_path->pi_alt_pkt_lt > ibcm_max_ib_pkt_lt) { 428 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 429 "Huge Alt Pkt lt %d", channel, 430 chan_args->oc_path->pi_alt_pkt_lt); 431 ibcm_dec_hca_acc_cnt(hcap); 432 return (IBT_PATH_PKT_LT_TOO_HIGH); 433 } 434 435 if (port_no != alt_port_no) { 436 437 status = ibt_get_port_state_byguid(hcap->hca_guid, 438 alt_port_no, NULL, &base_lid); 439 if (status != IBT_SUCCESS) { 440 441 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: " 442 "chan 0x%p alt_port_num %d inactive %d", 443 channel, alt_port_no, status); 444 ibcm_dec_hca_acc_cnt(hcap); 445 return (status); 446 } 447 448 } 449 alternate_slid = 450 base_lid + IBCM_ALT_ADDS_VECT(chan_args).av_src_path; 451 452 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 453 "alternate SLID = %x", channel, alternate_slid); 454 } 455 456 /* 457 * only pkey needs to be zero'ed, because all other fields are set in 458 * in ibcm_init_reply_addr. But, let's bzero the complete struct for 459 * any future modifications. 460 */ 461 bzero(&cm_reply_addr, sizeof (cm_reply_addr)); 462 463 /* Initialize the MAD destination address in stored_reply_addr */ 464 if ((status = ibcm_init_reply_addr(hcap, &cm_reply_addr, chan_args, 465 flags, &cm_pkt_lt, primary_slid)) != IBT_SUCCESS) { 466 467 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 468 "ibcm_init_reply_addr failed status %d ", channel, status); 469 ibcm_dec_hca_acc_cnt(hcap); 470 return (status); 471 } 472 473 474 /* Initialize the pkey for CM MAD communication */ 475 if (cm_reply_addr.rcvd_addr.ia_p_key == 0) 476 cm_reply_addr.rcvd_addr.ia_p_key = prim_pkey; 477 478 #ifdef DEBUG 479 ibcm_print_reply_addr(channel, &cm_reply_addr); 480 #endif 481 482 /* Retrieve an ibmf qp for sending CM MADs */ 483 if ((cm_qp_entry = ibcm_find_qp(hcap, port_no, 484 cm_reply_addr.rcvd_addr.ia_p_key)) == NULL) { 485 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p " 486 "unable to allocate ibmf qp for CM MADs", channel); 487 ibcm_dec_hca_acc_cnt(hcap); 488 return (IBT_INSUFF_RESOURCE); 489 } 490 491 492 if (ibcm_alloc_comid(hcap, &local_comid) != IBCM_SUCCESS) { 493 ibcm_release_qp(cm_qp_entry); 494 ibcm_dec_hca_acc_cnt(hcap); 495 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan 0x%p" 496 " Unable to allocate comid", channel); 497 return (IBT_INSUFF_KERNEL_RESOURCE); 498 } 499 500 /* allocate an IBMF mad buffer (REQ) */ 501 if ((status = ibcm_alloc_out_msg(ibmf_hdl, &ibmf_msg, 502 MAD_METHOD_SEND)) != IBT_SUCCESS) { 503 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: " 504 "chan 0x%p ibcm_alloc_out_msg failed", channel); 505 ibcm_release_qp(cm_qp_entry); 506 ibcm_free_comid(hcap, local_comid); 507 ibcm_dec_hca_acc_cnt(hcap); 508 return (status); 509 } 510 511 /* allocate an IBMF mad buffer (DREQ) */ 512 if ((status = ibcm_alloc_out_msg(ibmf_hdl, &ibmf_msg_dreq, 513 MAD_METHOD_SEND)) != IBT_SUCCESS) { 514 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: " 515 "chan 0x%p ibcm_alloc_out_msg failed", channel); 516 (void) ibcm_free_out_msg(ibmf_hdl, &ibmf_msg); 517 ibcm_release_qp(cm_qp_entry); 518 ibcm_free_comid(hcap, local_comid); 519 ibcm_dec_hca_acc_cnt(hcap); 520 return (status); 521 } 522 523 /* Init to Init, if QP's port does not match with path information */ 524 if (qp_query_attr.qp_info.qp_transport.rc.rc_path.cep_hca_port_num != 525 IBCM_PRIM_CEP_PATH(chan_args).cep_hca_port_num) { 526 527 ibt_qp_info_t qp_info; 528 ibt_cep_modify_flags_t cep_flags; 529 530 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: " 531 "chan 0x%p chan port %d", channel, 532 qp_query_attr.qp_info.qp_transport.rc.rc_path.\ 533 cep_hca_port_num); 534 535 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: " 536 "chan 0x%p path port %d", channel, port_no); 537 538 bzero(&qp_info, sizeof (qp_info)); 539 /* For now, set it to RC type */ 540 541 qp_info.qp_trans = IBT_RC_SRV; 542 qp_info.qp_state = IBT_STATE_INIT; 543 qp_info.qp_transport.rc.rc_path.cep_hca_port_num = port_no; 544 545 cep_flags = IBT_CEP_SET_STATE | IBT_CEP_SET_PORT; 546 547 status = ibt_modify_qp(channel, cep_flags, &qp_info, NULL); 548 549 if (status != IBT_SUCCESS) { 550 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: " 551 "chan 0x%p ibt_modify_qp() = %d", channel, status); 552 ibcm_release_qp(cm_qp_entry); 553 ibcm_free_comid(hcap, local_comid); 554 ibcm_dec_hca_acc_cnt(hcap); 555 (void) ibcm_free_out_msg(ibmf_hdl, &ibmf_msg); 556 (void) ibcm_free_out_msg(ibmf_hdl, &ibmf_msg_dreq); 557 return (status); 558 } else 559 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: " 560 "chan 0x%p ibt_modify_qp() = %d", channel, status); 561 } 562 563 /* allocate ibcm_state_data_t before grabbing the WRITER lock */ 564 statep = kmem_zalloc(sizeof (ibcm_state_data_t), KM_SLEEP); 565 rw_enter(&hcap->hca_state_rwlock, RW_WRITER); 566 lkup_status = ibcm_lookup_msg(IBCM_OUTGOING_REQ, local_comid, 0, 0, 567 hcap, &statep); 568 rw_exit(&hcap->hca_state_rwlock); 569 570 /* CM should be seeing this for the first time */ 571 ASSERT(lkup_status == IBCM_LOOKUP_NEW); 572 573 /* Increment the hca's resource count */ 574 ibcm_inc_hca_res_cnt(hcap); 575 576 /* Once a resource created on hca, no need to hold the acc cnt */ 577 ibcm_dec_hca_acc_cnt(hcap); 578 579 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 580 581 statep->timerid = 0; 582 statep->local_hca_guid = hca_guid; 583 statep->local_qpn = local_qpn; 584 statep->stored_reply_addr.cm_qp_entry = cm_qp_entry; 585 statep->prim_port = IBCM_PRIM_CEP_PATH(chan_args).cep_hca_port_num; 586 statep->alt_port = IBCM_ALT_CEP_PATH(chan_args).cep_hca_port_num; 587 588 589 /* Save "statep" as channel's CM private data. */ 590 statep->channel = channel; 591 IBCM_SET_CHAN_PRIVATE(statep->channel, statep); 592 593 statep->stored_msg = ibmf_msg; 594 statep->dreq_msg = ibmf_msg_dreq; 595 596 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*req_msgp)) 597 598 /* Start filling in the REQ MAD */ 599 req_msgp = (ibcm_req_msg_t *)IBCM_OUT_MSGP(statep->stored_msg); 600 req_msgp->req_local_comm_id = h2b32(local_comid); 601 req_msgp->req_svc_id = h2b64(chan_args->oc_path->pi_sid); 602 req_msgp->req_local_ca_guid = h2b64(hca_guid); 603 req_msgp->req_local_qkey = h2b32(local_qkey); /* for EEC/RD */ 604 605 /* Bytes 32-35 are req_local_qpn and req_off_resp_resources */ 606 req_msgp->req_local_qpn_plus = h2b32(local_qpn << 8 | rdma_in); 607 608 /* Bytes 36-39 are req_local_eec_no and req_off_initiator_depth */ 609 req_msgp->req_local_eec_no_plus = h2b32(local_eecn << 8 | rdma_out); 610 611 if (flags & IBT_OCHAN_REMOTE_CM_TM) 612 remote_cm_resp_time = chan_args->oc_remote_cm_time; 613 else 614 remote_cm_resp_time = ibcm_remote_response_time; 615 616 /* 617 * Bytes 40-43 - remote_eecn, remote_cm_resp_time, tran_type, 618 * IBT_CM_FLOW_CONTROL is always set by default. 619 */ 620 req_msgp->req_remote_eecn_plus = h2b32( 621 remote_eecn << 8 | (ibt_usec2ib(remote_cm_resp_time) & 0x1f) << 3 | 622 IBT_RC_SRV << 1 | IBT_CM_FLOW_CONTROL); 623 624 if (flags & IBT_OCHAN_LOCAL_CM_TM) 625 local_cm_proc_time = chan_args->oc_local_cm_time; 626 else 627 local_cm_proc_time = ibcm_local_processing_time; 628 629 local_cm_resp_time = ibt_usec2ib(local_cm_proc_time + 630 2 * ibt_ib2usec(chan_args->oc_path->pi_prim_pkt_lt) + 631 ibcm_sw_delay); 632 633 /* save retry count */ 634 statep->cep_retry_cnt = chan_args->oc_path_retry_cnt; 635 636 if (flags & IBT_OCHAN_STARTING_PSN) 637 starting_psn = chan_args->oc_starting_psn; 638 639 if (local_cm_resp_time > 0x1f) 640 local_cm_resp_time = 0x1f; 641 642 /* Bytes 44-47 are req_starting_psn, local_cm_resp_time and retry_cnt */ 643 req_msgp->req_starting_psn_plus = h2b32(starting_psn << 8 | 644 local_cm_resp_time << 3 | statep->cep_retry_cnt); 645 646 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 647 "Prim Pkt lt (IB time) 0x%x", channel, 648 chan_args->oc_path->pi_prim_pkt_lt); 649 650 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 651 "local_cm_proc_time(usec) %d ", channel, local_cm_proc_time); 652 653 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 654 "local_cm_resp_time(ib_time) %d", channel, local_cm_resp_time); 655 656 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 657 "remote_cm_resp_time (usec) %d", channel, remote_cm_resp_time); 658 659 statep->starting_psn = starting_psn; 660 661 /* Pkey - bytes 48-49 */ 662 req_msgp->req_part_key = h2b16(prim_pkey); 663 664 if (flags & IBT_OCHAN_CM_RETRY) 665 cm_retries = chan_args->oc_cm_retry_cnt; 666 else 667 cm_retries = ibcm_max_retries; 668 669 statep->max_cm_retries = statep->remaining_retry_cnt = cm_retries; 670 req_msgp->req_max_cm_retries_plus = statep->max_cm_retries << 4; 671 672 /* 673 * Check whether SRQ is associated with this Channel, if yes, then 674 * set the SRQ Exists bit in the REQ. 675 */ 676 if (qp_query_attr.qp_srq != NULL) { 677 req_msgp->req_max_cm_retries_plus |= (1 << 3); 678 } 679 680 /* 681 * By default on Tavor, we override the PathMTU to 1K. 682 * To turn this off, set ibcm_override_path_mtu = 0. 683 */ 684 if (ibcm_override_path_mtu && IBCM_IS_HCA_TAVOR(hcap) && 685 (chan_args->oc_path->pi_path_mtu > IB_MTU_1K)) { 686 req_msgp->req_mtu_plus = IB_MTU_1K << 4 | 687 chan_args->oc_path_rnr_retry_cnt; 688 IBTF_DPRINTF_L3(cmlog, "ibt_open_rc_channel: chan 0x%p PathMTU" 689 " overridden to IB_MTU_1K(%d) from %d", channel, IB_MTU_1K, 690 chan_args->oc_path->pi_path_mtu); 691 } else 692 req_msgp->req_mtu_plus = chan_args->oc_path->pi_path_mtu << 4 | 693 chan_args->oc_path_rnr_retry_cnt; 694 695 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p CM retry cnt %d" 696 " staring PSN %x", channel, cm_retries, starting_psn); 697 698 699 #ifdef NO_EEC_SUPPORT_YET 700 if (flags & IBT_OCHAN_RDC_EXISTS) 701 req_msgp->req_mtu_plus |= 8; 702 #endif 703 704 /* Initialize the "primary" port stuff next - bytes 52-95 */ 705 req_msgp->req_primary_l_port_lid = h2b16(primary_slid); 706 req_msgp->req_primary_r_port_lid = 707 h2b16(IBCM_PRIM_ADDS_VECT(chan_args).av_dlid); 708 req_msgp->req_primary_l_port_gid.gid_prefix = 709 h2b64(IBCM_PRIM_ADDS_VECT(chan_args).av_sgid.gid_prefix); 710 req_msgp->req_primary_l_port_gid.gid_guid = 711 h2b64(IBCM_PRIM_ADDS_VECT(chan_args).av_sgid.gid_guid); 712 req_msgp->req_primary_r_port_gid.gid_prefix = 713 h2b64(IBCM_PRIM_ADDS_VECT(chan_args).av_dgid.gid_prefix); 714 req_msgp->req_primary_r_port_gid.gid_guid = 715 h2b64(IBCM_PRIM_ADDS_VECT(chan_args).av_dgid.gid_guid); 716 primary_grh = IBCM_PRIM_ADDS_VECT(chan_args).av_send_grh; 717 718 statep->remote_hca_guid = /* not correct, but helpful for debugging */ 719 IBCM_PRIM_ADDS_VECT(chan_args).av_dgid.gid_guid; 720 721 /* Bytes 88-91 - primary_flowlbl, and primary_srate */ 722 req_msgp->req_primary_flow_label_plus = 723 h2b32(((primary_grh == B_TRUE) ? 724 (IBCM_PRIM_ADDS_VECT(chan_args).av_flow << 12) : 0) | 725 IBCM_PRIM_ADDS_VECT(chan_args).av_srate); 726 req_msgp->req_primary_traffic_class = (primary_grh == B_TRUE) ? 727 IBCM_PRIM_ADDS_VECT(chan_args).av_tclass : 0; 728 req_msgp->req_primary_hop_limit = (primary_grh == B_TRUE) ? 729 IBCM_PRIM_ADDS_VECT(chan_args).av_hop : 1; 730 req_msgp->req_primary_sl_plus = 731 IBCM_PRIM_ADDS_VECT(chan_args).av_srvl << 4 | 732 ((primary_grh == B_TRUE) ? 0 : 8); 733 734 req_msgp->req_primary_localtime_plus = 735 ibt_usec2ib((2 * ibt_ib2usec(chan_args->oc_path->pi_prim_pkt_lt)) + 736 ibt_ib2usec(hcap->hca_ack_delay)) << 3; 737 738 IBTF_DPRINTF_L2(cmlog, "ibt_open_rc_channel: chan %p statep %p", 739 channel, statep); 740 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 741 "active hca_ack_delay (usec) %d", channel, 742 req_msgp->req_primary_localtime_plus); 743 744 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 745 "Sent primary cep timeout (IB Time) %d", channel, 746 hcap->hca_ack_delay); 747 748 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p prim_dlid %x ", 749 channel, IBCM_PRIM_ADDS_VECT(chan_args).av_dlid); 750 751 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 752 "prim GID %llX:%llX", channel, 753 IBCM_PRIM_ADDS_VECT(chan_args).av_dgid.gid_prefix, 754 IBCM_PRIM_ADDS_VECT(chan_args).av_dgid.gid_guid); 755 756 /* Initialize the "alternate" port stuff - optional */ 757 if (chan_args->oc_path->pi_alt_cep_path.cep_hca_port_num != 0) { 758 ib_gid_t tmp_gid; 759 760 req_msgp->req_alt_l_port_lid = h2b16(alternate_slid); 761 req_msgp->req_alt_r_port_lid = 762 h2b16(IBCM_ALT_ADDS_VECT(chan_args).av_dlid); 763 /* 764 * doing all this as req_alt_r/l_port_gid is at offset 765 * 100, 116 which is not divisible by 8 766 */ 767 768 tmp_gid.gid_prefix = 769 h2b64(IBCM_ALT_ADDS_VECT(chan_args).av_dgid.gid_prefix); 770 tmp_gid.gid_guid = 771 h2b64(IBCM_ALT_ADDS_VECT(chan_args).av_dgid.gid_guid); 772 bcopy(&tmp_gid, &req_msgp->req_alt_r_port_gid[0], 773 sizeof (ib_gid_t)); 774 tmp_gid.gid_prefix = 775 h2b64(IBCM_ALT_ADDS_VECT(chan_args).av_sgid.gid_prefix); 776 tmp_gid.gid_guid = 777 h2b64(IBCM_ALT_ADDS_VECT(chan_args).av_sgid.gid_guid); 778 779 bcopy(&tmp_gid, &req_msgp->req_alt_l_port_gid[0], 780 sizeof (ib_gid_t)); 781 alternate_grh = IBCM_ALT_ADDS_VECT(chan_args).av_send_grh; 782 783 /* Bytes 132-135 - alternate_flow_label, and alternate srate */ 784 req_msgp->req_alt_flow_label_plus = h2b32( 785 (((alternate_grh == B_TRUE) ? 786 (IBCM_ALT_ADDS_VECT(chan_args).av_flow << 12) : 0) | 787 IBCM_ALT_ADDS_VECT(chan_args).av_srate)); 788 req_msgp->req_alt_traffic_class = (alternate_grh == B_TRUE) ? 789 IBCM_ALT_ADDS_VECT(chan_args).av_tclass : 0; 790 req_msgp->req_alt_hop_limit = (alternate_grh == B_TRUE) ? 791 IBCM_ALT_ADDS_VECT(chan_args).av_hop : 1; 792 req_msgp->req_alt_sl_plus = 793 IBCM_ALT_ADDS_VECT(chan_args).av_srvl << 4 | 794 ((alternate_grh == B_TRUE) ? 0 : 8); 795 req_msgp->req_alt_localtime_plus = ibt_usec2ib((2 * 796 ibt_ib2usec(chan_args->oc_path->pi_alt_pkt_lt)) + 797 ibt_ib2usec(hcap->hca_ack_delay)) << 3; 798 799 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 800 "alt_dlid %x ", channel, 801 IBCM_ALT_ADDS_VECT(chan_args).av_dlid); 802 803 IBTF_DPRINTF_L5(cmlog, "ibt_open_rc_channel: chan 0x%p " 804 "alt GID %llX:%llX", channel, 805 IBCM_ALT_ADDS_VECT(chan_args).av_dgid.gid_prefix, 806 IBCM_ALT_ADDS_VECT(chan_args).av_dgid.gid_guid); 807 } 808 809 len = min(chan_args->oc_priv_data_len, IBT_REQ_PRIV_DATA_SZ); 810 if ((len > 0) && chan_args->oc_priv_data) 811 bcopy(chan_args->oc_priv_data, req_msgp->req_private_data, len); 812 813 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*req_msgp)) 814 815 /* return_data is filled up in the state machine code */ 816 if (ret_args != NULL) { 817 statep->open_return_data = ret_args; 818 } 819 820 /* initialize some statep fields here */ 821 statep->mode = IBCM_ACTIVE_MODE; 822 statep->hcap = hcap; 823 824 statep->cm_handler = chan_args->oc_cm_handler; 825 statep->state_cm_private = chan_args->oc_cm_clnt_private; 826 827 statep->pkt_life_time = 828 ibt_ib2usec(chan_args->oc_path->pi_prim_pkt_lt); 829 830 statep->timer_value = ibt_ib2usec(ibt_usec2ib( 831 2 * ibt_ib2usec(cm_pkt_lt) + remote_cm_resp_time)); 832 833 /* Initialize statep->stored_reply_addr */ 834 statep->stored_reply_addr.ibmf_hdl = ibmf_hdl; 835 836 /* Initialize stored reply addr fields */ 837 statep->stored_reply_addr.grh_hdr = cm_reply_addr.grh_hdr; 838 statep->stored_reply_addr.rcvd_addr = cm_reply_addr.rcvd_addr; 839 statep->stored_reply_addr.grh_exists = cm_reply_addr.grh_exists; 840 statep->stored_reply_addr.port_num = cm_reply_addr.port_num; 841 842 /* 843 * The IPD on local/active side is calculated by path functions, 844 * hence available in the args of ibt_open_rc_channel 845 */ 846 statep->local_srate = IBCM_PRIM_ADDS_VECT(chan_args).av_srate; 847 statep->local_alt_srate = IBCM_ALT_ADDS_VECT(chan_args).av_srate; 848 849 /* Store the source path bits for primary and alt paths */ 850 statep->prim_src_path_bits = IBCM_PRIM_ADDS_VECT(chan_args).av_src_path; 851 statep->alt_src_path_bits = IBCM_ALT_ADDS_VECT(chan_args).av_src_path; 852 853 statep->open_flow = 1; 854 statep->open_done = B_FALSE; 855 statep->state = statep->timer_stored_state = IBCM_STATE_REQ_SENT; 856 IBCM_REF_CNT_INCR(statep); /* Decremented before return */ 857 IBCM_REF_CNT_INCR(statep); /* Decremented after REQ is posted */ 858 statep->send_mad_flags |= IBCM_REQ_POST_BUSY; 859 860 /* 861 * Skip moving channel to error state during close, for OFUV clients. 862 * OFUV clients transition the channel to error state by itself. 863 */ 864 if (flags & IBT_OCHAN_OFUV) 865 statep->is_this_ofuv_chan = B_TRUE; 866 867 IBCM_OUT_HDRP(statep->stored_msg)->AttributeID = 868 h2b16(IBCM_INCOMING_REQ + IBCM_ATTR_BASE_ID); 869 870 IBCM_OUT_HDRP(statep->stored_msg)->TransactionID = 871 h2b64(ibcm_generate_tranid(IBCM_INCOMING_REQ, statep->local_comid, 872 0)); 873 874 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*statep)) 875 876 ibtl_cm_chan_is_opening(channel); 877 878 ibcm_open_enqueue(statep); 879 880 mutex_enter(&statep->state_mutex); 881 882 if (mode == IBT_BLOCKING) { 883 884 /* wait for REQ/REP/RTU */ 885 while (statep->open_done != B_TRUE) { 886 cv_wait(&statep->block_client_cv, &statep->state_mutex); 887 } 888 889 /* 890 * In the case that open_channel() fails because of a 891 * REJ or timeout, change retval to IBT_CM_FAILURE 892 */ 893 if (statep->open_return_data->rc_status != IBT_CM_SUCCESS) { 894 status = IBT_CM_FAILURE; 895 ibtl_cm_chan_open_is_aborted(channel); 896 } 897 898 IBTF_DPRINTF_L3(cmlog, "ibt_open_rc_channel: chan 0x%p " 899 "ret status %d cm status %d", channel, status, 900 statep->open_return_data->rc_status); 901 } 902 903 /* decrement the ref-count before leaving here */ 904 IBCM_REF_CNT_DECR(statep); 905 906 mutex_exit(&statep->state_mutex); 907 908 IBTF_DPRINTF_L4(cmlog, "ibt_open_rc_channel: chan 0x%p done", channel); 909 return (status); 910 } 911 912 /* 913 * ibcm_init_reply_addr: 914 * 915 * The brief description of functionality below. 916 * 917 * For IBT_OCHAN_PORT_REDIRECTED (ie., port redirected case): 918 * Build CM path from chan_args->oc_cm_cep_path 919 * Set CM pkt lt (ie.,life time) to chan_args->oc_cm_pkt_lt 920 * 921 * For IBT_OCHAN_REDIRECTED (ie., port and CM redirected case): 922 * If Redirect LID is specified, 923 * If Redirect GID is not specified or specified to be on the same 924 * subnet, then 925 * Build CM path from chan_args->oc_cm_redirect_info 926 * Set CM pkt lt to subnet timeout 927 * Else (ie., GID specified, but on a different subnet) 928 * Do a path lookup to build CM Path and set CM pkt lt 929 * 930 */ 931 static ibt_status_t 932 ibcm_init_reply_addr(ibcm_hca_info_t *hcap, ibcm_mad_addr_t *reply_addr, 933 ibt_chan_open_args_t *chan_args, ibt_chan_open_flags_t flags, 934 ib_time_t *cm_pkt_lt, ib_lid_t prim_slid) 935 { 936 ibt_adds_vect_t *cm_adds; 937 ibt_path_info_t path; 938 boolean_t cm_grh; 939 ibt_status_t status; 940 941 IBTF_DPRINTF_L5(cmlog, "ibcm_init_reply_addr:"); 942 943 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*reply_addr)) 944 945 /* 946 * sending side CM lid/gid/port num are not based on any redirect 947 * params. These values are set to primary RC path lid/gid/port num. 948 * In the future, these values can be set based on framework policy 949 * decisions ensuring reachability. 950 */ 951 reply_addr->grh_hdr.ig_sender_gid = 952 IBCM_PRIM_ADDS_VECT(chan_args).av_sgid; 953 reply_addr->rcvd_addr.ia_local_lid = prim_slid; 954 reply_addr->port_num = IBCM_PRIM_CEP_PATH(chan_args).cep_hca_port_num; 955 956 if (flags & IBT_OCHAN_PORT_REDIRECTED) { 957 IBTF_DPRINTF_L4(cmlog, "ibcm_init_rely_addr: " 958 "IBT_OCHAN_PORT_REDIRECTED specified"); 959 960 status = ibt_index2pkey_byguid(hcap->hca_guid, 961 chan_args->oc_cm_cep_path->cep_hca_port_num, 962 chan_args->oc_cm_cep_path->cep_pkey_ix, 963 &reply_addr->rcvd_addr.ia_p_key); 964 965 if (status != IBT_SUCCESS) { 966 IBTF_DPRINTF_L2(cmlog, "ibcm_init_rely_addr: Invalid " 967 "CM PKeyIx %x port_num %x", 968 chan_args->oc_cm_cep_path->cep_pkey_ix, 969 chan_args->oc_cm_cep_path->cep_hca_port_num); 970 return (status); 971 } 972 973 cm_adds = &(chan_args->oc_cm_cep_path->cep_adds_vect); 974 IBTF_DPRINTF_L4(cmlog, "ibcm_init_rely_addr: dlid = %x", 975 cm_adds->av_dlid); 976 977 reply_addr->rcvd_addr.ia_q_key = IB_GSI_QKEY; 978 reply_addr->rcvd_addr.ia_remote_qno = 1; 979 *cm_pkt_lt = chan_args->oc_cm_pkt_lt; 980 981 } else if (flags & IBT_OCHAN_REDIRECTED) { 982 ibt_redirect_info_t *redirect_info; 983 ibt_hca_portinfo_t *port_infop; 984 uint_t psize, nports; 985 986 IBTF_DPRINTF_L4(cmlog, "ibcm_init_rely_addr: " 987 "IBT_OCHAN_REDIRECTED specified"); 988 989 redirect_info = chan_args->oc_cm_redirect_info; 990 991 if ((redirect_info->rdi_gid.gid_prefix == 0) || 992 (redirect_info->rdi_gid.gid_guid == 0)) { 993 IBTF_DPRINTF_L2(cmlog, "ibcm_init_reply_addr: " 994 "ERROR: Re-direct GID value NOT Provided."); 995 return (IBT_INVALID_PARAM); 996 } 997 998 /* As per spec definition 1.1, it's always IB_GSI_QKEY */ 999 reply_addr->rcvd_addr.ia_q_key = redirect_info->rdi_qkey; 1000 reply_addr->rcvd_addr.ia_remote_qno = redirect_info->rdi_qpn; 1001 reply_addr->rcvd_addr.ia_p_key = redirect_info->rdi_pkey; 1002 1003 /* 1004 * if LID is non-zero in classportinfo then use classportinfo 1005 * fields to form CM MAD destination address. 1006 */ 1007 if (redirect_info->rdi_dlid != 0) { 1008 status = ibtl_cm_query_hca_ports_byguid(hcap->hca_guid, 1009 reply_addr->port_num, &port_infop, &nports, &psize); 1010 if ((status != IBT_SUCCESS) || (nports == 0)) { 1011 IBTF_DPRINTF_L2(cmlog, "ibcm_init_reply_addr: " 1012 "Query Ports Failed: %d", status); 1013 return (status); 1014 } else if (port_infop->p_subnet_timeout > 1015 ibcm_max_ib_pkt_lt) { 1016 IBTF_DPRINTF_L2(cmlog, "ibcm_init_reply_addr: " 1017 "large subnet timeout %x port_no %x", 1018 port_infop->p_subnet_timeout, 1019 reply_addr->port_num); 1020 ibt_free_portinfo(port_infop, psize); 1021 return (IBT_PATH_PKT_LT_TOO_HIGH); 1022 } else { 1023 IBTF_DPRINTF_L3(cmlog, "ibcm_init_reply_addr: " 1024 "subnet timeout %x port_no %x", 1025 port_infop->p_subnet_timeout, 1026 reply_addr->port_num); 1027 1028 *cm_pkt_lt = 1029 ibt_ib2usec(min(ibcm_max_ib_mad_pkt_lt, 1030 port_infop->p_subnet_timeout)); 1031 1032 ibt_free_portinfo(port_infop, psize); 1033 } 1034 1035 reply_addr->rcvd_addr.ia_remote_lid = 1036 redirect_info->rdi_dlid; 1037 reply_addr->rcvd_addr.ia_service_level = 1038 redirect_info->rdi_sl; 1039 reply_addr->grh_exists = B_TRUE; 1040 reply_addr->grh_hdr.ig_recver_gid = 1041 redirect_info->rdi_gid; 1042 reply_addr->grh_hdr.ig_tclass = 1043 redirect_info->rdi_tclass; 1044 reply_addr->grh_hdr.ig_flow_label = 1045 redirect_info->rdi_flow; 1046 1047 /* Classportinfo doesn't have hoplimit field */ 1048 reply_addr->grh_hdr.ig_hop_limit = 1; 1049 return (IBT_SUCCESS); 1050 1051 } else { 1052 ibt_path_attr_t path_attr; 1053 ib_gid_t path_dgid[1]; 1054 1055 /* 1056 * If GID is specified, and LID is zero in classportinfo 1057 * do a path lookup using specified GID, Pkey, 1058 * in classportinfo 1059 */ 1060 1061 bzero(&path_attr, sizeof (path_attr)); 1062 1063 path_attr.pa_dgids = &path_dgid[0]; 1064 path_attr.pa_dgids[0] = redirect_info->rdi_gid; 1065 1066 /* 1067 * use reply_addr below, as sender_gid in reply_addr 1068 * may have been set above based on some policy decision 1069 * for originating end point for CM MADs above 1070 */ 1071 path_attr.pa_sgid = reply_addr->grh_hdr.ig_sender_gid; 1072 path_attr.pa_num_dgids = 1; 1073 path_attr.pa_pkey = redirect_info->rdi_pkey; 1074 1075 if ((status = ibt_get_paths(ibcm_ibt_handle, 1076 IBT_PATH_PKEY, &path_attr, 1, &path, NULL)) != 1077 IBT_SUCCESS) 1078 return (status); 1079 1080 /* Initialize cm_adds */ 1081 cm_adds = &path.pi_prim_cep_path.cep_adds_vect; 1082 *cm_pkt_lt = path.pi_prim_pkt_lt; 1083 } 1084 1085 } else { /* cm_pkey initialized in ibt_open_rc_channel */ 1086 reply_addr->rcvd_addr.ia_q_key = IB_GSI_QKEY; 1087 reply_addr->rcvd_addr.ia_remote_qno = 1; 1088 *cm_pkt_lt = chan_args->oc_path->pi_prim_pkt_lt; 1089 cm_adds = &(IBCM_PRIM_ADDS_VECT(chan_args)); 1090 } 1091 1092 1093 cm_grh = cm_adds->av_send_grh; 1094 reply_addr->grh_exists = cm_grh; 1095 1096 reply_addr->rcvd_addr.ia_remote_lid = 1097 cm_adds->av_dlid; 1098 reply_addr->grh_hdr.ig_recver_gid = 1099 cm_adds->av_dgid; 1100 reply_addr->grh_hdr.ig_flow_label = 1101 cm_adds->av_flow & IB_GRH_FLOW_LABEL_MASK; 1102 reply_addr->grh_hdr.ig_tclass = 1103 (cm_grh == B_TRUE) ? cm_adds->av_tclass : 0; 1104 reply_addr->grh_hdr.ig_hop_limit = 1105 (cm_grh == B_TRUE) ? cm_adds->av_hop : 1; 1106 reply_addr->rcvd_addr.ia_service_level = 1107 cm_adds->av_srvl; 1108 1109 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*reply_addr)) 1110 1111 return (IBT_SUCCESS); 1112 } 1113 1114 1115 /* 1116 * ibt_prime_close_rc_channel() 1117 * It allocates resources required for close channel operation, so 1118 * ibt_close_rc_channel can be called from interrupt routine. 1119 * 1120 * INPUTS: 1121 * channel The address of an ibt_channel_t struct that 1122 * specifies the channel to open. 1123 * 1124 * RETURN VALUES: 1125 * IBT_SUCCESS on success(or respective failure on error) 1126 * 1127 * Clients are typically expected to call this function in established state 1128 */ 1129 ibt_status_t 1130 ibt_prime_close_rc_channel(ibt_channel_hdl_t channel) 1131 { 1132 ibcm_state_data_t *statep; 1133 ibt_status_t status = IBT_SUCCESS; 1134 1135 IBTF_DPRINTF_L3(cmlog, "ibt_prime_close_rc_channel(%p)", channel); 1136 1137 /* validate channel, first */ 1138 if (IBCM_INVALID_CHANNEL(channel)) { 1139 IBTF_DPRINTF_L2(cmlog, "ibt_prime_close_rc_channel: chan 0x%p " 1140 "invalid channel", channel); 1141 return (IBT_CHAN_HDL_INVALID); 1142 } 1143 1144 if (ibtl_cm_get_chan_type(channel) != IBT_RC_SRV) { 1145 IBTF_DPRINTF_L2(cmlog, "ibt_prime_close_rc_channel: chan 0x%p " 1146 "Invalid Channel type: Applicable only to RC Channel", 1147 channel); 1148 return (IBT_CHAN_SRV_TYPE_INVALID); 1149 } 1150 1151 /* get the statep */ 1152 IBCM_GET_CHAN_PRIVATE(channel, statep); 1153 1154 /* 1155 * This can happen, if the statep is already gone by a DREQ from 1156 * the remote side 1157 */ 1158 1159 if (statep == NULL) { 1160 IBTF_DPRINTF_L2(cmlog, "ibt_prime_close_rc_channel: chan 0x%p " 1161 "statep NULL", channel); 1162 return (IBT_SUCCESS); 1163 } 1164 1165 mutex_enter(&statep->state_mutex); 1166 IBCM_RELEASE_CHAN_PRIVATE(channel); 1167 if (statep->state != IBCM_STATE_ESTABLISHED) { 1168 mutex_exit(&statep->state_mutex); 1169 return (IBT_CHAN_STATE_INVALID); 1170 } 1171 IBCM_REF_CNT_INCR(statep); 1172 IBTF_DPRINTF_L4(cmlog, "ibt_prime_close_rc_channel: chan 0x%p statep %p" 1173 " state %x", channel, statep, statep->state); 1174 mutex_exit(&statep->state_mutex); 1175 1176 /* clients could pre-allocate dreq mad, even before connection est */ 1177 if (statep->dreq_msg == NULL) 1178 status = ibcm_alloc_out_msg(statep->stored_reply_addr.ibmf_hdl, 1179 &statep->dreq_msg, MAD_METHOD_SEND); 1180 1181 mutex_enter(&statep->state_mutex); 1182 IBCM_REF_CNT_DECR(statep); 1183 mutex_exit(&statep->state_mutex); 1184 1185 if (status != IBT_SUCCESS) { 1186 IBTF_DPRINTF_L2(cmlog, "ibt_prime_close_rc_channel: chan 0x%p " 1187 "ibcm_alloc_out_msg failed ", channel); 1188 return (status); 1189 } 1190 1191 /* If this message isn't seen then ibt_prime_close_rc_channel failed */ 1192 IBTF_DPRINTF_L5(cmlog, "ibt_prime_close_rc_channel: chan 0x%p done", 1193 channel); 1194 1195 return (IBT_SUCCESS); 1196 } 1197 1198 /* 1199 * ibt_close_rc_channel() 1200 * It closes an established channel. 1201 * 1202 * RETURN VALUES: 1203 * IBT_SUCCESS on success(or respective failure on error) 1204 */ 1205 ibt_status_t 1206 ibt_close_rc_channel(ibt_channel_hdl_t channel, ibt_execution_mode_t mode, 1207 void *priv_data, ibt_priv_data_len_t priv_data_len, uint8_t *ret_status, 1208 void *ret_priv_data, ibt_priv_data_len_t *ret_priv_data_len_p) 1209 { 1210 ibcm_state_data_t *statep; 1211 1212 IBTF_DPRINTF_L3(cmlog, "ibt_close_rc_channel(%p, %x, %p, %d, %p)", 1213 channel, mode, priv_data, priv_data_len, 1214 (ret_priv_data_len_p == NULL) ? 0 : *ret_priv_data_len_p); 1215 1216 /* validate channel, first */ 1217 if (IBCM_INVALID_CHANNEL(channel)) { 1218 IBTF_DPRINTF_L2(cmlog, "ibt_close_rc_channel: chan 0x%p " 1219 "invalid channel", channel); 1220 return (IBT_CHAN_HDL_INVALID); 1221 } 1222 1223 if (ibtl_cm_get_chan_type(channel) != IBT_RC_SRV) { 1224 IBTF_DPRINTF_L2(cmlog, "ibt_close_rc_channel: chan 0x%p " 1225 "Invalid Channel type: Applicable only to RC Channel", 1226 channel); 1227 return (IBT_CHAN_SRV_TYPE_INVALID); 1228 } 1229 1230 if (mode == IBT_BLOCKING) { 1231 /* valid only for BLOCKING MODE */ 1232 if ((ret_priv_data_len_p != NULL) && 1233 (*ret_priv_data_len_p > IBT_DREP_PRIV_DATA_SZ)) { 1234 IBTF_DPRINTF_L2(cmlog, "ibt_close_rc_channel: chan 0x%p" 1235 " private data len %d is too large", channel, 1236 *ret_priv_data_len_p); 1237 return (IBT_INVALID_PARAM); 1238 } 1239 } else if ((mode != IBT_NONBLOCKING) && (mode != IBT_NOCALLBACKS)) { 1240 IBTF_DPRINTF_L2(cmlog, "ibt_close_rc_channel: chan 0x%p " 1241 "invalid mode %x specified", channel, mode); 1242 return (IBT_INVALID_PARAM); 1243 } 1244 1245 if (ibtl_cm_is_chan_closing(channel) || 1246 ibtl_cm_is_chan_closed(channel)) { 1247 if (ret_status) 1248 *ret_status = IBT_CM_CLOSED_ALREADY; 1249 1250 /* No private data to return to the client */ 1251 if (ret_priv_data_len_p != NULL) 1252 *ret_priv_data_len_p = 0; 1253 1254 if ((mode == IBT_BLOCKING) || 1255 (mode == IBT_NOCALLBACKS)) { 1256 IBCM_GET_CHAN_PRIVATE(channel, statep); 1257 if (statep == NULL) 1258 return (IBT_SUCCESS); 1259 mutex_enter(&statep->state_mutex); 1260 IBCM_RELEASE_CHAN_PRIVATE(channel); 1261 IBCM_REF_CNT_INCR(statep); 1262 while (statep->close_done != B_TRUE) 1263 cv_wait(&statep->block_client_cv, 1264 &statep->state_mutex); 1265 IBCM_REF_CNT_DECR(statep); 1266 mutex_exit(&statep->state_mutex); 1267 } 1268 1269 IBTF_DPRINTF_L3(cmlog, "ibt_close_rc_channel: chan 0x%p " 1270 "already marked for closing", channel); 1271 1272 return (IBT_SUCCESS); 1273 } 1274 1275 /* get the statep */ 1276 IBCM_GET_CHAN_PRIVATE(channel, statep); 1277 if (statep == NULL) { 1278 IBTF_DPRINTF_L2(cmlog, "ibt_close_rc_channel: chan 0x%p " 1279 "statep NULL", channel); 1280 return (IBT_CHAN_STATE_INVALID); 1281 } 1282 1283 mutex_enter(&statep->state_mutex); 1284 1285 if (statep->dreq_msg == NULL) { 1286 IBTF_DPRINTF_L2(cmlog, "ibt_close_rc_channel: chan 0x%p " 1287 "Fatal Error: dreq_msg is NULL", channel); 1288 IBCM_RELEASE_CHAN_PRIVATE(channel); 1289 mutex_exit(&statep->state_mutex); 1290 return (IBT_CHAN_STATE_INVALID); 1291 } 1292 1293 if ((ret_priv_data == NULL) || (ret_priv_data_len_p == NULL)) { 1294 statep->close_ret_priv_data = NULL; 1295 statep->close_ret_priv_data_len = NULL; 1296 } else { 1297 statep->close_ret_priv_data = ret_priv_data; 1298 statep->close_ret_priv_data_len = ret_priv_data_len_p; 1299 } 1300 1301 priv_data_len = min(priv_data_len, IBT_DREQ_PRIV_DATA_SZ); 1302 if ((priv_data != NULL) && (priv_data_len > 0)) { 1303 bcopy(priv_data, ((ibcm_dreq_msg_t *) 1304 IBCM_OUT_MSGP(statep->dreq_msg))->dreq_private_data, 1305 priv_data_len); 1306 } 1307 statep->close_ret_status = ret_status; 1308 1309 IBCM_RELEASE_CHAN_PRIVATE(channel); 1310 IBCM_REF_CNT_INCR(statep); 1311 1312 if (mode != IBT_NONBLOCKING) { 1313 return (ibcm_close_rc_channel(channel, statep, mode)); 1314 } 1315 1316 /* IBT_NONBLOCKING */ 1317 ibcm_close_enqueue(statep); 1318 mutex_exit(&statep->state_mutex); 1319 1320 return (IBT_SUCCESS); 1321 } 1322 1323 void 1324 ibcm_close_start(ibcm_state_data_t *statep) 1325 { 1326 mutex_enter(&statep->state_mutex); 1327 (void) ibcm_close_rc_channel(statep->channel, statep, IBT_NONBLOCKING); 1328 } 1329 1330 static 1331 ibt_status_t 1332 ibcm_close_rc_channel(ibt_channel_hdl_t channel, ibcm_state_data_t *statep, 1333 ibt_execution_mode_t mode) 1334 { 1335 ibcm_hca_info_t *hcap; 1336 1337 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&statep->state_mutex)); 1338 ASSERT(MUTEX_HELD(&statep->state_mutex)); 1339 1340 IBTF_DPRINTF_L3(cmlog, "ibcm_close_rc_channel: chan 0x%p statep %p", 1341 channel, statep); 1342 1343 hcap = statep->hcap; 1344 1345 /* HCA must have been in active state. If not, it's a client bug */ 1346 if (!IBCM_ACCESS_HCA_OK(hcap)) { 1347 IBTF_DPRINTF_L2(cmlog, "ibcm_close_rc_channel: chan 0x%p " 1348 "hcap 0x%p not active", channel, hcap); 1349 IBCM_REF_CNT_DECR(statep); 1350 mutex_exit(&statep->state_mutex); 1351 return (IBT_CHAN_HDL_INVALID); 1352 } 1353 1354 if (statep->state == IBCM_STATE_TRANSIENT_ESTABLISHED) { 1355 while (statep->cep_in_rts == IBCM_BLOCK) 1356 cv_wait(&statep->block_mad_cv, &statep->state_mutex); 1357 } 1358 1359 /* Do TRANSIENT_DREQ check after TRANSIENT_ESTABLISHED check */ 1360 while (statep->state == IBCM_STATE_TRANSIENT_DREQ_SENT) 1361 cv_wait(&statep->block_mad_cv, &statep->state_mutex); 1362 1363 IBTF_DPRINTF_L4(cmlog, "ibcm_close_rc_channel: chan 0x%p " 1364 "connection state is %x", channel, statep->state); 1365 1366 /* If state is in pre-established states, abort the connection est */ 1367 if (statep->state != IBCM_STATE_ESTABLISHED) { 1368 statep->cm_retries++; /* ensure connection trace is dumped */ 1369 1370 /* No DREP private data possible */ 1371 if (statep->close_ret_priv_data_len != NULL) 1372 *statep->close_ret_priv_data_len = 0; 1373 1374 /* 1375 * If waiting for a response mad, then cancel the timer, 1376 * and delete the connection 1377 */ 1378 if (statep->state == IBCM_STATE_REQ_SENT || 1379 statep->state == IBCM_STATE_REP_SENT || 1380 statep->state == IBCM_STATE_REP_WAIT || 1381 statep->state == IBCM_STATE_MRA_REP_RCVD) { 1382 timeout_id_t timer_val = statep->timerid; 1383 ibcm_conn_state_t old_state; 1384 1385 IBTF_DPRINTF_L4(cmlog, "ibcm_close_rc_channel: " 1386 "chan 0x%p connection aborted in state %x", channel, 1387 statep->state); 1388 1389 old_state = statep->state; 1390 statep->state = IBCM_STATE_DELETE; 1391 1392 if (mode == IBT_NONBLOCKING) { 1393 if (taskq_dispatch(ibcm_taskq, 1394 ibcm_process_abort_via_taskq, statep, 1395 TQ_NOSLEEP) == 0) { 1396 1397 IBCM_REF_CNT_DECR(statep); 1398 statep->state = old_state; 1399 mutex_exit(&statep->state_mutex); 1400 return (IBT_INSUFF_KERNEL_RESOURCE); 1401 } /* if taskq_dispatch succeeds */ 1402 /* Cancel the timer */ 1403 statep->timerid = 0; 1404 mutex_exit(&statep->state_mutex); 1405 } else { 1406 /* Cancel the timer */ 1407 statep->timerid = 0; 1408 mutex_exit(&statep->state_mutex); 1409 (void) taskq_dispatch(ibcm_taskq, 1410 ibcm_process_abort_via_taskq, statep, 1411 TQ_SLEEP); 1412 } 1413 1414 /* cancel the currently running timer */ 1415 if (timer_val != 0) 1416 (void) untimeout(timer_val); 1417 1418 /* wait until cm handler returns for BLOCKING cases */ 1419 mutex_enter(&statep->state_mutex); 1420 if ((mode == IBT_BLOCKING) || 1421 (mode == IBT_NOCALLBACKS)) { 1422 while (statep->close_done != B_TRUE) 1423 cv_wait(&statep->block_client_cv, 1424 &statep->state_mutex); 1425 } 1426 1427 if (statep->close_ret_status) 1428 *statep->close_ret_status = IBT_CM_CLOSED_ABORT; 1429 mutex_exit(&statep->state_mutex); 1430 1431 /* 1432 * It would ideal to post a REJ MAD, but that would 1433 * be non-conformance to spec. Hence, delete the state 1434 * data. Assuming that happens quickly, any retransmits 1435 * from the remote are replied by CM with reject 1436 * reason " no valid com id". That would stop remote 1437 * sending any more MADs. 1438 */ 1439 ibcm_delete_state_data(statep); 1440 return (IBT_SUCCESS); 1441 1442 /* if CM busy in cm handler, wait until cm handler returns */ 1443 } else if (statep->state == IBCM_STATE_REQ_RCVD || 1444 statep->state == IBCM_STATE_REP_RCVD || 1445 statep->state == IBCM_STATE_MRA_SENT || 1446 statep->state == IBCM_STATE_MRA_REP_SENT) { 1447 1448 /* take control of statep */ 1449 statep->abort_flag |= IBCM_ABORT_CLIENT; 1450 1451 IBTF_DPRINTF_L4(cmlog, "ibcm_close_rc_channel: " 1452 "chan 0x%p connection aborted in state = %x", 1453 channel, statep->state); 1454 1455 /* 1456 * wait until state machine modifies qp state to error, 1457 * including disassociating statep and QP 1458 */ 1459 if ((mode == IBT_BLOCKING) || (mode == IBT_NOCALLBACKS)) 1460 while (statep->close_done != B_TRUE) 1461 cv_wait(&statep->block_client_cv, 1462 &statep->state_mutex); 1463 1464 /* a sanity setting */ 1465 if (mode == IBT_NOCALLBACKS) 1466 statep->cm_handler = NULL; 1467 IBCM_REF_CNT_DECR(statep); 1468 1469 /* 1470 * In rare situations, connection attempt could be 1471 * terminated for some other reason, before abort is 1472 * processed, but CM still returns ret_status as abort 1473 */ 1474 if (statep->close_ret_status) 1475 *statep->close_ret_status = IBT_CM_CLOSED_ABORT; 1476 mutex_exit(&statep->state_mutex); 1477 1478 /* 1479 * REJ MAD is posted by the CM state machine for this 1480 * case, hence state structure is deleted in the 1481 * state machine processing. 1482 */ 1483 return (IBT_SUCCESS); 1484 1485 } else if ((statep->state == IBCM_STATE_TIMEWAIT) || 1486 (statep->state == IBCM_STATE_DELETE)) { 1487 1488 /* State already in timewait, so no return priv data */ 1489 IBCM_REF_CNT_DECR(statep); 1490 1491 /* The teardown has already been done */ 1492 if (statep->close_ret_status) 1493 *statep->close_ret_status = 1494 IBT_CM_CLOSED_ALREADY; 1495 mutex_exit(&statep->state_mutex); 1496 1497 return (IBT_SUCCESS); 1498 1499 } else if ((statep->state == IBCM_STATE_DREQ_RCVD) || 1500 (statep->state == IBCM_STATE_DREQ_SENT) || 1501 (statep->state == IBCM_STATE_DREP_RCVD) || 1502 ((statep->state == IBCM_STATE_TIMED_OUT) && 1503 (statep->timedout_state == IBCM_STATE_DREQ_SENT))) { 1504 1505 /* 1506 * Either the remote or local client has already 1507 * initiated the teardown. IBCM_STATE_DREP_RCVD is 1508 * possible, if CM initiated teardown without client's 1509 * knowledge, for stale handling, etc., 1510 */ 1511 if (mode == IBT_NOCALLBACKS) { 1512 if (statep->close_nocb_state == IBCM_UNBLOCK) { 1513 statep->close_nocb_state = IBCM_FAIL; 1514 /* enable free qp after return */ 1515 ibtl_cm_chan_is_closing( 1516 statep->channel); 1517 } else while (statep->close_nocb_state == 1518 IBCM_BLOCK) 1519 cv_wait(&statep->block_client_cv, 1520 &statep->state_mutex); 1521 statep->cm_handler = NULL; /* sanity setting */ 1522 if (statep->close_ret_status) 1523 *statep->close_ret_status = 1524 IBT_CM_CLOSED_ALREADY; 1525 } else if (mode == IBT_BLOCKING) { 1526 /* wait until state is moved to timewait */ 1527 while (statep->close_done != B_TRUE) 1528 cv_wait(&statep->block_client_cv, 1529 &statep->state_mutex); 1530 } 1531 1532 IBCM_REF_CNT_DECR(statep); 1533 mutex_exit(&statep->state_mutex); 1534 1535 /* ret_status is set in state machine code */ 1536 return (IBT_SUCCESS); 1537 1538 } else if (statep->state == IBCM_STATE_TIMED_OUT) { 1539 1540 if ((mode == IBT_BLOCKING) || 1541 (mode == IBT_NOCALLBACKS)) { 1542 1543 /* 1544 * wait until cm handler invocation and 1545 * disassociation between statep and channel 1546 * is complete 1547 */ 1548 while (statep->close_done != B_TRUE) 1549 cv_wait(&statep->block_client_cv, 1550 &statep->state_mutex); 1551 } 1552 1553 if (statep->close_ret_status) 1554 *statep->close_ret_status = IBT_CM_CLOSED_ABORT; 1555 IBCM_REF_CNT_DECR(statep); 1556 mutex_exit(&statep->state_mutex); 1557 1558 return (IBT_SUCCESS); 1559 } else { 1560 IBCM_REF_CNT_DECR(statep); 1561 mutex_exit(&statep->state_mutex); 1562 1563 return (IBT_CM_FAILURE); 1564 } 1565 } 1566 1567 ASSERT(statep->close_nocb_state != IBCM_BLOCK); 1568 1569 if (mode == IBT_NOCALLBACKS) { 1570 statep->close_nocb_state = IBCM_FAIL; 1571 statep->cm_handler = NULL; 1572 ibtl_cm_chan_is_closing(statep->channel); 1573 IBTF_DPRINTF_L4(cmlog, "ibcm_close_rc_channel: " 1574 "NOCALLBACKS on in statep = %p", statep); 1575 } 1576 1577 if (statep->state != IBCM_STATE_ESTABLISHED) { 1578 goto lost_race; 1579 } 1580 1581 /* 1582 * Cancel/wait for any pending ibt_set_alt_path, and 1583 * release state mutex 1584 */ 1585 ibcm_sync_lapr_idle(statep); 1586 1587 ibcm_close_enter(); 1588 1589 mutex_enter(&statep->state_mutex); 1590 if (statep->state != IBCM_STATE_ESTABLISHED) { 1591 ibcm_close_exit(); 1592 goto lost_race; 1593 } 1594 1595 statep->state = IBCM_STATE_TRANSIENT_DREQ_SENT; 1596 statep->timerid = 0; 1597 statep->close_done = B_FALSE; 1598 statep->close_flow = 1; 1599 mutex_exit(&statep->state_mutex); 1600 1601 ibcm_post_dreq_mad(statep); 1602 1603 mutex_enter(&statep->state_mutex); 1604 1605 lost_race: 1606 if (mode == IBT_BLOCKING) { 1607 1608 /* wait for DREP */ 1609 while (statep->close_done != B_TRUE) 1610 cv_wait(&statep->block_client_cv, 1611 &statep->state_mutex); 1612 1613 IBTF_DPRINTF_L4(cmlog, "ibcm_close_rc_channel: chan 0x%p " 1614 "done blocking", channel); 1615 } 1616 1617 IBCM_REF_CNT_DECR(statep); 1618 mutex_exit(&statep->state_mutex); 1619 1620 /* If this message isn't seen then ibt_close_rc_channel failed */ 1621 IBTF_DPRINTF_L5(cmlog, "ibcm_close_rc_channel: chan 0x%p done", 1622 channel); 1623 1624 return (IBT_SUCCESS); 1625 } 1626 1627 ibt_status_t 1628 ibt_recycle_rc(ibt_channel_hdl_t rc_chan, ibt_cep_flags_t control, 1629 uint8_t hca_port_num, ibt_recycle_handler_t func, void *arg) 1630 { 1631 ibcm_state_data_t *statep; 1632 ibcm_taskq_recycle_arg_t *ibcm_tq_recycle_arg; 1633 ibt_qp_query_attr_t qp_attr; 1634 ibt_status_t retval; 1635 1636 IBTF_DPRINTF_L3(cmlog, "ibt_recycle_rc (%p, 0x%X, %d, %p, %p)", rc_chan, 1637 control, hca_port_num, func, arg); 1638 1639 if (IBCM_INVALID_CHANNEL(rc_chan)) { 1640 IBTF_DPRINTF_L2(cmlog, "ibt_recycle_rc: invalid channel"); 1641 return (IBT_CHAN_HDL_INVALID); 1642 } 1643 1644 /* check qp state */ 1645 retval = ibt_query_qp(rc_chan, &qp_attr); 1646 1647 if (retval != IBT_SUCCESS) 1648 return (retval); 1649 1650 if (qp_attr.qp_info.qp_trans != IBT_RC_SRV) 1651 return (IBT_CHAN_SRV_TYPE_INVALID); 1652 1653 if (qp_attr.qp_info.qp_state != IBT_STATE_ERROR) 1654 return (IBT_CHAN_STATE_INVALID); 1655 1656 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ibcm_tq_recycle_arg)) 1657 1658 ibcm_tq_recycle_arg = kmem_alloc(sizeof (ibcm_taskq_recycle_arg_t), 1659 KM_SLEEP); 1660 1661 ibcm_tq_recycle_arg->rc_chan = rc_chan; 1662 ibcm_tq_recycle_arg->control = control; 1663 ibcm_tq_recycle_arg->hca_port_num = hca_port_num; 1664 ibcm_tq_recycle_arg->func = func; 1665 ibcm_tq_recycle_arg->arg = arg; 1666 1667 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*ibcm_tq_recycle_arg)) 1668 1669 IBCM_GET_CHAN_PRIVATE(rc_chan, statep); 1670 1671 /* 1672 * If non-blocking ie., func specified and channel has not yet completed 1673 * the timewait, then schedule the work for later 1674 */ 1675 if ((func != NULL) && (statep != NULL)) { 1676 IBCM_RELEASE_CHAN_PRIVATE(rc_chan); 1677 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(statep->recycle_arg)) 1678 statep->recycle_arg = ibcm_tq_recycle_arg; 1679 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(statep->recycle_arg)) 1680 return (IBT_SUCCESS); 1681 } 1682 1683 /* 1684 * if blocking ie., func specified, and channel has not yet completed 1685 * the timewait, then block until the channel completes the timewait 1686 */ 1687 if (statep != NULL) 1688 IBCM_RELEASE_CHAN_PRIVATE(rc_chan); 1689 IBCM_WAIT_CHAN_PRIVATE(rc_chan); 1690 1691 if (func) { /* NON BLOCKING case. Taskq for QP state change */ 1692 (void) taskq_dispatch(ibcm_taskq, ibcm_process_rc_recycle, 1693 ibcm_tq_recycle_arg, TQ_SLEEP); 1694 return (IBT_SUCCESS); 1695 } else /* BLOCKING case */ 1696 return (ibcm_process_rc_recycle_ret(ibcm_tq_recycle_arg)); 1697 } 1698 1699 void 1700 ibcm_process_rc_recycle(void *recycle_arg) 1701 { 1702 (void) ibcm_process_rc_recycle_ret(recycle_arg); 1703 } 1704 1705 static ibt_status_t 1706 ibcm_process_rc_recycle_ret(void *recycle_arg) 1707 { 1708 ibt_qp_info_t qp_info; 1709 ibt_status_t ibt_status = IBT_SUCCESS; 1710 ibt_cep_modify_flags_t cep_flags; 1711 ibt_qp_query_attr_t qp_attr; 1712 ibcm_taskq_recycle_arg_t *ibcm_tq_recycle_arg = 1713 (ibcm_taskq_recycle_arg_t *)recycle_arg; 1714 1715 /* QP must have been in error state */ 1716 ibt_status = ibt_query_qp(ibcm_tq_recycle_arg->rc_chan, &qp_attr); 1717 if (ibt_status != IBT_SUCCESS) 1718 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rc_recycle_ret: " 1719 "chanp %p ibt_query_qp() = %d", 1720 ibcm_tq_recycle_arg->rc_chan, ibt_status); 1721 else { 1722 /* perform the QP state change from ERROR to RESET */ 1723 bzero(&qp_info, sizeof (qp_info)); 1724 1725 qp_info.qp_trans = IBT_RC_SRV; 1726 qp_info.qp_state = IBT_STATE_RESET; 1727 1728 /* Call modify_qp to move to RESET state */ 1729 ibt_status = ibt_modify_qp(ibcm_tq_recycle_arg->rc_chan, 1730 IBT_CEP_SET_STATE, &qp_info, NULL); 1731 1732 if (ibt_status != IBT_SUCCESS) 1733 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rc_recycle_ret: " 1734 "chanp %p ibt_modify_qp() = %d for ERROR to RESET", 1735 ibcm_tq_recycle_arg->rc_chan, ibt_status); 1736 } 1737 1738 if (ibt_status == IBT_SUCCESS) { 1739 1740 qp_info.qp_state = IBT_STATE_INIT; 1741 1742 /* set flags for all mandatory args from RESET to INIT */ 1743 cep_flags = IBT_CEP_SET_STATE | IBT_CEP_SET_PORT; 1744 cep_flags |= IBT_CEP_SET_RDMA_R | IBT_CEP_SET_RDMA_W; 1745 cep_flags |= IBT_CEP_SET_ATOMIC; 1746 1747 qp_info.qp_transport.rc.rc_path.cep_hca_port_num = 1748 ibcm_tq_recycle_arg->hca_port_num; 1749 qp_info.qp_flags |= 1750 ibcm_tq_recycle_arg->control & IBT_CEP_RDMA_RD; 1751 qp_info.qp_flags |= 1752 ibcm_tq_recycle_arg->control & IBT_CEP_RDMA_WR; 1753 qp_info.qp_flags |= 1754 ibcm_tq_recycle_arg->control & IBT_CEP_ATOMIC; 1755 1756 /* Always use the existing pkey */ 1757 qp_info.qp_transport.rc.rc_path.cep_pkey_ix = 1758 qp_attr. qp_info.qp_transport.rc.rc_path.cep_pkey_ix; 1759 1760 /* Call modify_qp to move to INIT state */ 1761 ibt_status = ibt_modify_qp(ibcm_tq_recycle_arg->rc_chan, 1762 cep_flags, &qp_info, NULL); 1763 1764 if (ibt_status != IBT_SUCCESS) 1765 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rc_recycle_ret: " 1766 "chanp %p ibt_modify_qp() = %d for RESET to INIT", 1767 ibcm_tq_recycle_arg->rc_chan, ibt_status); 1768 } 1769 1770 /* Change the QP CM state to indicate QP being re-used */ 1771 if (ibt_status == IBT_SUCCESS) 1772 ibtl_cm_chan_is_reused(ibcm_tq_recycle_arg->rc_chan); 1773 1774 /* Call func, if defined */ 1775 if (ibcm_tq_recycle_arg->func) 1776 (*(ibcm_tq_recycle_arg->func))(ibt_status, 1777 ibcm_tq_recycle_arg->arg); 1778 1779 kmem_free(ibcm_tq_recycle_arg, sizeof (ibcm_taskq_recycle_arg_t)); 1780 1781 return (ibt_status); 1782 } 1783 1784 static void 1785 ibcm_process_abort_via_taskq(void *args) 1786 { 1787 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 1788 1789 ibcm_process_abort(statep); 1790 mutex_enter(&statep->state_mutex); 1791 IBCM_REF_CNT_DECR(statep); 1792 mutex_exit(&statep->state_mutex); 1793 } 1794 1795 /* 1796 * Local UD CM Handler's private data, used during ibt_request_ud_dest() in 1797 * Non-Blocking mode operations. 1798 */ 1799 typedef struct ibcm_local_handler_s { 1800 ibt_cm_ud_handler_t actual_cm_handler; 1801 void *actual_cm_private; 1802 ibt_ud_dest_t *dest_hdl; 1803 } ibcm_local_handler_t; 1804 1805 _NOTE(READ_ONLY_DATA(ibcm_local_handler_s)) 1806 1807 /* 1808 * Local UD CM Handler, used when ibt_alloc_ud_dest() is issued in 1809 * NON-Blocking mode. 1810 * 1811 * Out here, we update the UD Destination handle with 1812 * the obtained DQPN and QKey (from SIDR REP) and invokes actual client 1813 * handler that was specified by the client. 1814 */ 1815 static ibt_cm_status_t 1816 ibcm_local_cm_handler(void *priv, ibt_cm_ud_event_t *event, 1817 ibt_cm_ud_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len) 1818 { 1819 ibcm_local_handler_t *handler_priv = (ibcm_local_handler_t *)priv; 1820 1821 IBTF_DPRINTF_L4(cmlog, "ibcm_local_cm_handler: event %d", 1822 event->cm_type); 1823 1824 ASSERT(handler_priv != NULL); 1825 1826 switch (event->cm_type) { 1827 case IBT_CM_UD_EVENT_SIDR_REP: 1828 /* Update QPN & QKey from event into destination handle. */ 1829 if (handler_priv->dest_hdl != NULL) { 1830 handler_priv->dest_hdl->ud_dst_qpn = 1831 event->cm_event.sidr_rep.srep_remote_qpn; 1832 handler_priv->dest_hdl->ud_qkey = 1833 event->cm_event.sidr_rep.srep_remote_qkey; 1834 } 1835 1836 /* Invoke the client handler - inform only, so ignore retval */ 1837 (void) handler_priv->actual_cm_handler( 1838 handler_priv->actual_cm_private, event, ret_args, priv_data, 1839 len); 1840 1841 /* Free memory allocated for local handler's private data. */ 1842 if (handler_priv != NULL) 1843 kmem_free(handler_priv, sizeof (*handler_priv)); 1844 1845 break; 1846 default: 1847 IBTF_DPRINTF_L2(cmlog, "ibcm_local_cm_handler: ERROR"); 1848 break; 1849 } 1850 1851 return (IBT_CM_ACCEPT); 1852 } 1853 1854 1855 /* Validate the input UD destination attributes. */ 1856 static ibt_status_t 1857 ibcm_validate_dqpn_data(ibt_ud_dest_attr_t *attr, ibt_execution_mode_t mode, 1858 ibt_ud_returns_t *ret_args) 1859 { 1860 /* cm handler must always be specified */ 1861 if (mode == IBT_NONBLOCKING && attr->ud_cm_handler == NULL) { 1862 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: " 1863 "CM handler is not specified "); 1864 return (IBT_INVALID_PARAM); 1865 } 1866 1867 if (mode == IBT_NONBLOCKING) { 1868 if (ret_args != NULL) { 1869 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: " 1870 "ret_args should be NULL when called in " 1871 "non-blocking mode"); 1872 return (IBT_INVALID_PARAM); 1873 } 1874 } else if (mode == IBT_BLOCKING) { 1875 if (ret_args == NULL) { 1876 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: " 1877 "ret_args should be Non-NULL when called in " 1878 "blocking mode"); 1879 return (IBT_INVALID_PARAM); 1880 } 1881 } else { 1882 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: " 1883 "invalid mode %x specified ", mode); 1884 return (IBT_INVALID_PARAM); 1885 } 1886 1887 if (attr->ud_sid == 0) { 1888 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: " 1889 "ServiceID must be specified. "); 1890 return (IBT_INVALID_PARAM); 1891 } 1892 1893 if (attr->ud_addr == NULL) { 1894 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: " 1895 "Address Info NULL"); 1896 return (IBT_INVALID_PARAM); 1897 } 1898 1899 /* Validate SGID */ 1900 if ((attr->ud_addr->av_sgid.gid_prefix == 0) || 1901 (attr->ud_addr->av_sgid.gid_guid == 0)) { 1902 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: Invalid SGID"); 1903 return (IBT_INVALID_PARAM); 1904 } 1905 IBTF_DPRINTF_L3(cmlog, "ibcm_validate_dqpn_data: SGID<%llX:%llX>", 1906 attr->ud_addr->av_sgid.gid_prefix, 1907 attr->ud_addr->av_sgid.gid_guid); 1908 1909 /* Validate DGID */ 1910 if ((attr->ud_addr->av_dgid.gid_prefix == 0) || 1911 (attr->ud_addr->av_dgid.gid_guid == 0)) { 1912 IBTF_DPRINTF_L2(cmlog, "ibcm_validate_dqpn_data: Invalid DGID"); 1913 return (IBT_INVALID_PARAM); 1914 } 1915 IBTF_DPRINTF_L3(cmlog, "ibcm_validate_dqpn_data: DGID<%llX:%llX>", 1916 attr->ud_addr->av_dgid.gid_prefix, 1917 attr->ud_addr->av_dgid.gid_guid); 1918 1919 return (IBT_SUCCESS); 1920 } 1921 1922 1923 /* Perform SIDR to retrieve DQPN and QKey. */ 1924 static ibt_status_t 1925 ibcm_ud_get_dqpn(ibt_ud_dest_attr_t *attr, ibt_execution_mode_t mode, 1926 ibt_ud_returns_t *ret_args) 1927 { 1928 ibt_status_t retval; 1929 ib_pkey_t ud_pkey; 1930 ibmf_handle_t ibmf_hdl; 1931 ibmf_msg_t *ibmf_msg; 1932 ibcm_hca_info_t *hcap; 1933 ibcm_sidr_req_msg_t *sidr_req_msgp; 1934 ibcm_ud_state_data_t *ud_statep; 1935 ibtl_cm_hca_port_t port; 1936 ibcm_sidr_srch_t sidr_entry; 1937 ibcm_qp_list_t *cm_qp_entry; 1938 1939 /* Retrieve HCA GUID value from the available SGID info. */ 1940 retval = ibtl_cm_get_hca_port(attr->ud_addr->av_sgid, 0, &port); 1941 if ((retval != IBT_SUCCESS) || (port.hp_port == 0)) { 1942 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: " 1943 "ibtl_cm_get_hca_port failed: %d", retval); 1944 return (retval); 1945 } 1946 1947 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: " 1948 "HCA GUID:%llX, port_num:%d", port.hp_hca_guid, port.hp_port); 1949 1950 /* Lookup the HCA info for this GUID */ 1951 if ((hcap = ibcm_find_hca_entry(port.hp_hca_guid)) == NULL) { 1952 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: hcap is NULL"); 1953 return (IBT_HCA_INVALID); 1954 } 1955 1956 /* Return failure if the HCA device or Port is not operational */ 1957 1958 if ((retval = ibt_get_port_state_byguid(port.hp_hca_guid, port.hp_port, 1959 NULL, NULL)) != IBT_SUCCESS) { 1960 /* Device Port is not in good state, don't use it. */ 1961 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: Invalid " 1962 "port specified or port not active"); 1963 ibcm_dec_hca_acc_cnt(hcap); 1964 return (retval); 1965 } 1966 1967 retval = ibt_index2pkey_byguid(port.hp_hca_guid, port.hp_port, 1968 attr->ud_pkey_ix, &ud_pkey); 1969 if (retval != IBT_SUCCESS) { 1970 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: " 1971 "Failed to convert index2pkey: %d", retval); 1972 ibcm_dec_hca_acc_cnt(hcap); 1973 return (retval); 1974 } 1975 1976 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(sidr_entry)) 1977 1978 /* Allocate a new request id */ 1979 if (ibcm_alloc_reqid(hcap, &sidr_entry.srch_req_id) == IBCM_FAILURE) { 1980 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: " 1981 "no req id available"); 1982 ibcm_dec_hca_acc_cnt(hcap); 1983 return (IBT_INSUFF_KERNEL_RESOURCE); 1984 } 1985 1986 if ((hcap->hca_port_info[port.hp_port - 1].port_ibmf_hdl == NULL) && 1987 ((retval = ibcm_hca_reinit_port(hcap, port.hp_port - 1)) 1988 != IBT_SUCCESS)) { 1989 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: " 1990 "ibmf reg or callback setup failed during re-initialize"); 1991 return (retval); 1992 } 1993 1994 ibmf_hdl = hcap->hca_port_info[port.hp_port - 1].port_ibmf_hdl; 1995 1996 /* find the ibmf QP to post the SIDR REQ */ 1997 if ((cm_qp_entry = ibcm_find_qp(hcap, port.hp_port, ud_pkey)) == 1998 NULL) { 1999 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: IBMF QP allocation" 2000 " failed"); 2001 ibcm_dec_hca_acc_cnt(hcap); 2002 return (IBT_INSUFF_RESOURCE); 2003 } 2004 2005 if ((retval = ibcm_alloc_out_msg(ibmf_hdl, &ibmf_msg, MAD_METHOD_SEND)) 2006 != IBT_SUCCESS) { 2007 IBTF_DPRINTF_L2(cmlog, "ibcm_ud_get_dqpn: IBMF MSG allocation" 2008 " failed"); 2009 ibcm_release_qp(cm_qp_entry); 2010 ibcm_dec_hca_acc_cnt(hcap); 2011 return (retval); 2012 } 2013 2014 sidr_entry.srch_lid = port.hp_base_lid; 2015 sidr_entry.srch_gid = attr->ud_addr->av_sgid; 2016 sidr_entry.srch_grh_exists = attr->ud_addr->av_send_grh; 2017 sidr_entry.srch_mode = IBCM_ACTIVE_MODE; 2018 2019 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(sidr_entry)) 2020 2021 /* do various allocations needed here */ 2022 rw_enter(&hcap->hca_sidr_list_lock, RW_WRITER); 2023 2024 (void) ibcm_find_sidr_entry(&sidr_entry, hcap, &ud_statep, 2025 IBCM_FLAG_ADD); 2026 rw_exit(&hcap->hca_sidr_list_lock); 2027 2028 /* Increment hca's resource count */ 2029 ibcm_inc_hca_res_cnt(hcap); 2030 2031 /* After a resource created on hca, no need to hold the acc cnt */ 2032 ibcm_dec_hca_acc_cnt(hcap); 2033 2034 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ud_statep)) 2035 2036 /* Initialize some ud_statep fields */ 2037 ud_statep->ud_stored_msg = ibmf_msg; 2038 ud_statep->ud_svc_id = attr->ud_sid; 2039 ud_statep->ud_pkt_life_time = 2040 ibt_ib2usec(attr->ud_pkt_lt); 2041 ud_statep->ud_stored_reply_addr.cm_qp_entry = cm_qp_entry; 2042 2043 /* set remaining retry cnt */ 2044 ud_statep->ud_remaining_retry_cnt = ud_statep->ud_max_cm_retries; 2045 2046 /* 2047 * Get UD handler and corresponding args which is pass it back 2048 * as first argument for the handler. 2049 */ 2050 ud_statep->ud_state_cm_private = attr->ud_cm_private; 2051 2052 if (mode == IBT_BLOCKING) 2053 ud_statep->ud_return_data = ret_args; 2054 else 2055 ud_statep->ud_cm_handler = attr->ud_cm_handler; 2056 2057 /* Initialize the fields of ud_statep->ud_stored_reply_addr */ 2058 ud_statep->ud_stored_reply_addr.grh_exists = attr->ud_addr->av_send_grh; 2059 ud_statep->ud_stored_reply_addr.ibmf_hdl = ibmf_hdl; 2060 ud_statep->ud_stored_reply_addr.grh_hdr.ig_hop_limit = 2061 attr->ud_addr->av_hop; 2062 ud_statep->ud_stored_reply_addr.grh_hdr.ig_sender_gid = 2063 attr->ud_addr->av_sgid; 2064 ud_statep->ud_stored_reply_addr.grh_hdr.ig_recver_gid = 2065 attr->ud_addr->av_dgid; 2066 ud_statep->ud_stored_reply_addr.grh_hdr.ig_tclass = 2067 attr->ud_addr->av_tclass; 2068 ud_statep->ud_stored_reply_addr.grh_hdr.ig_flow_label = 2069 attr->ud_addr->av_flow & IB_GRH_FLOW_LABEL_MASK; 2070 2071 /* needs to be derived based on the base LID and path bits */ 2072 ud_statep->ud_stored_reply_addr.rcvd_addr.ia_local_lid = 2073 port.hp_base_lid; 2074 ud_statep->ud_stored_reply_addr.rcvd_addr.ia_remote_lid = 2075 attr->ud_addr->av_dlid; 2076 ud_statep->ud_stored_reply_addr.rcvd_addr.ia_p_key = ud_pkey; 2077 ud_statep->ud_stored_reply_addr.rcvd_addr.ia_q_key = IB_GSI_QKEY; 2078 ud_statep->ud_stored_reply_addr.rcvd_addr.ia_service_level = 2079 attr->ud_addr->av_srvl; 2080 2081 /* 2082 * This may be enchanced later, to use a remote qno based on past 2083 * redirect rej mad responses. This would be the place to specify 2084 * appropriate remote qno 2085 */ 2086 ud_statep->ud_stored_reply_addr.rcvd_addr.ia_remote_qno = 1; 2087 2088 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sidr_req_msgp)) 2089 2090 /* Initialize the SIDR REQ message fields */ 2091 sidr_req_msgp = 2092 (ibcm_sidr_req_msg_t *)IBCM_OUT_MSGP(ud_statep->ud_stored_msg); 2093 2094 sidr_req_msgp->sidr_req_request_id = h2b32(ud_statep->ud_req_id); 2095 sidr_req_msgp->sidr_req_service_id = h2b64(attr->ud_sid); 2096 sidr_req_msgp->sidr_req_pkey = h2b16(ud_pkey); 2097 IBCM_OUT_HDRP(ud_statep->ud_stored_msg)->AttributeID = 2098 h2b16(IBCM_INCOMING_SIDR_REQ + IBCM_ATTR_BASE_ID); 2099 2100 if ((attr->ud_priv_data != NULL) && (attr->ud_priv_data_len > 0)) { 2101 bcopy(attr->ud_priv_data, sidr_req_msgp->sidr_req_private_data, 2102 min(attr->ud_priv_data_len, IBT_SIDR_REQ_PRIV_DATA_SZ)); 2103 } 2104 2105 /* Send out the SIDR REQ message */ 2106 ud_statep->ud_state = IBCM_STATE_SIDR_REQ_SENT; 2107 ud_statep->ud_timer_stored_state = IBCM_STATE_SIDR_REQ_SENT; 2108 IBCM_UD_REF_CNT_INCR(ud_statep); /* for non-blocking SIDR REQ post */ 2109 ud_statep->ud_timer_value = ibt_ib2usec(ibcm_max_sidr_rep_proctime) + 2110 (ud_statep->ud_pkt_life_time * 2); 2111 2112 IBCM_OUT_HDRP(ud_statep->ud_stored_msg)->TransactionID = 2113 h2b64(ibcm_generate_tranid(IBCM_INCOMING_SIDR_REQ, 2114 ud_statep->ud_req_id, 0)); 2115 2116 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: timer_value in HZ = %x", 2117 ud_statep->ud_timer_value); 2118 2119 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*ud_statep)) 2120 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*sidr_req_msgp)) 2121 2122 ibcm_post_ud_mad(ud_statep, ud_statep->ud_stored_msg, 2123 ibcm_post_sidr_req_complete, ud_statep); 2124 2125 mutex_enter(&ud_statep->ud_state_mutex); 2126 2127 /* Wait for SIDR_REP */ 2128 if (mode == IBT_BLOCKING) { 2129 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: blocking"); 2130 2131 while (ud_statep->ud_blocking_done != B_TRUE) { 2132 cv_wait(&ud_statep->ud_block_client_cv, 2133 &ud_statep->ud_state_mutex); 2134 } 2135 2136 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: finished blocking"); 2137 2138 if (ret_args->ud_status == IBT_CM_SREP_QPN_VALID) { 2139 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: DQPN = %x, " 2140 "status = %x, QKey = %x", ret_args->ud_dqpn, 2141 ret_args->ud_status, ret_args->ud_qkey); 2142 2143 } else { 2144 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: Status<%x>", 2145 ret_args->ud_status); 2146 retval = IBT_CM_FAILURE; 2147 } 2148 } 2149 2150 IBCM_UD_REF_CNT_DECR(ud_statep); 2151 mutex_exit(&ud_statep->ud_state_mutex); 2152 2153 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_get_dqpn: done"); 2154 2155 return (retval); 2156 } 2157 2158 2159 /* 2160 * Function: 2161 * ibt_request_ud_dest 2162 * Input: 2163 * ud_dest A previously allocated UD destination handle. 2164 * mode This function can execute in blocking or non blocking 2165 * modes. 2166 * attr UD destination attributes to be modified. 2167 * Output: 2168 * ud_ret_args If the function is called in blocking mode, ud_ret_args 2169 * should be a pointer to an ibt_ud_returns_t struct. 2170 * Returns: 2171 * IBT_SUCCESS 2172 * Description: 2173 * Modify a previously allocated UD destination handle based on the 2174 * results of doing the SIDR protocol. 2175 */ 2176 ibt_status_t 2177 ibt_request_ud_dest(ibt_ud_dest_hdl_t ud_dest, ibt_execution_mode_t mode, 2178 ibt_ud_dest_attr_t *attr, ibt_ud_returns_t *ud_ret_args) 2179 { 2180 ibt_status_t retval; 2181 ibt_ud_dest_t *ud_destp; 2182 ibcm_local_handler_t *local_handler_priv = NULL; 2183 2184 IBTF_DPRINTF_L3(cmlog, "ibt_request_ud_dest(%p, %x, %p, %p)", 2185 ud_dest, mode, attr, ud_ret_args); 2186 2187 retval = ibcm_validate_dqpn_data(attr, mode, ud_ret_args); 2188 if (retval != IBT_SUCCESS) { 2189 return (retval); 2190 } 2191 2192 ud_destp = ud_dest; 2193 2194 /* Allocate an Address handle. */ 2195 retval = ibt_modify_ah(ud_destp->ud_dest_hca, ud_destp->ud_ah, 2196 attr->ud_addr); 2197 if (retval != IBT_SUCCESS) { 2198 IBTF_DPRINTF_L2(cmlog, "ibt_request_ud_dest: " 2199 "Address Handle Modification failed: %d", retval); 2200 return (retval); 2201 } 2202 2203 if (mode == IBT_NONBLOCKING) { 2204 /* 2205 * In NON-BLOCKING mode, and we need to update the destination 2206 * handle with the DQPN and QKey that are obtained from 2207 * SIDR REP, hook-up our own handler, so that we can catch 2208 * the event, and we ourselves call the actual client's 2209 * ud_cm_handler, in our handler. 2210 */ 2211 2212 /* Allocate memory for local handler's private data. */ 2213 local_handler_priv = 2214 kmem_alloc(sizeof (*local_handler_priv), KM_SLEEP); 2215 2216 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*local_handler_priv)) 2217 2218 local_handler_priv->actual_cm_handler = attr->ud_cm_handler; 2219 local_handler_priv->actual_cm_private = attr->ud_cm_private; 2220 local_handler_priv->dest_hdl = ud_destp; 2221 2222 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*local_handler_priv)) 2223 2224 attr->ud_cm_handler = ibcm_local_cm_handler; 2225 attr->ud_cm_private = local_handler_priv; 2226 } 2227 2228 /* In order to get DQPN and Destination QKey, perform SIDR */ 2229 retval = ibcm_ud_get_dqpn(attr, mode, ud_ret_args); 2230 if (retval != IBT_SUCCESS) { 2231 IBTF_DPRINTF_L2(cmlog, "ibt_request_ud_dest: " 2232 "Failed to get DQPN: %d", retval); 2233 2234 /* Free memory allocated for local handler's private data. */ 2235 if (local_handler_priv != NULL) 2236 kmem_free(local_handler_priv, 2237 sizeof (*local_handler_priv)); 2238 return (retval); 2239 } 2240 2241 /* 2242 * Fill in the dqpn and dqkey as obtained from ud_ret_args, 2243 * values will be valid only on BLOCKING mode. 2244 */ 2245 if (mode == IBT_BLOCKING) { 2246 ud_destp->ud_dst_qpn = ud_ret_args->ud_dqpn; 2247 ud_destp->ud_qkey = ud_ret_args->ud_qkey; 2248 } 2249 2250 return (retval); 2251 } 2252 2253 /* 2254 * Function: 2255 * ibt_ud_get_dqpn 2256 * Input: 2257 * attr A pointer to an ibt_ud_dest_attr_t struct that are 2258 * required for SIDR REQ message. Not specified attributes 2259 * should be set to "NULL" or "0". 2260 * ud_sid, ud_addr and ud_pkt_lt must be specified. 2261 * mode This function can execute in blocking or non blocking 2262 * modes. 2263 * Output: 2264 * returns If the function is called in blocking mode, returns 2265 * should be a pointer to an ibt_ud_returns_t struct. 2266 * Return: 2267 * IBT_SUCCESS on success or respective failure on error. 2268 * Description: 2269 * Finds the destination QPN at the specified destination that the 2270 * specified service can be reached on. The IBTF CM initiates the 2271 * service ID resolution protocol (SIDR) to determine a destination QPN. 2272 * 2273 * NOTE: SIDR_REQ is initiated from active side. 2274 */ 2275 ibt_status_t 2276 ibt_ud_get_dqpn(ibt_ud_dest_attr_t *attr, ibt_execution_mode_t mode, 2277 ibt_ud_returns_t *returns) 2278 { 2279 ibt_status_t retval; 2280 2281 IBTF_DPRINTF_L3(cmlog, "ibt_ud_get_dqpn(%p, %x, %p)", 2282 attr, mode, returns); 2283 2284 retval = ibcm_validate_dqpn_data(attr, mode, returns); 2285 if (retval != IBT_SUCCESS) { 2286 return (retval); 2287 } 2288 2289 return (ibcm_ud_get_dqpn(attr, mode, returns)); 2290 } 2291 2292 2293 /* 2294 * ibt_cm_delay: 2295 * A client CM handler function can call this function 2296 * to extend its response time to a CM event. 2297 * INPUTS: 2298 * flags Indicates what CM message processing is being delayed 2299 * by the CM handler, valid values are: 2300 * IBT_CM_DELAY_REQ 2301 * IBT_CM_DELAY_REP 2302 * IBT_CM_DELAY_LAP 2303 * cm_session_id The session ID that was passed to client srv_handler 2304 * by the CM 2305 * service_time The extended service time 2306 * priv_data Vendor specific data to be sent in the CM generated 2307 * MRA message. Should be NULL if not specified. 2308 * len The number of bytes of data specified by priv_data. 2309 * 2310 * RETURN VALUES: 2311 * IBT_SUCCESS on success (or respective failure on error) 2312 */ 2313 ibt_status_t 2314 ibt_cm_delay(ibt_cmdelay_flags_t flags, void *cm_session_id, 2315 clock_t service_time, void *priv_data, ibt_priv_data_len_t len) 2316 { 2317 uint8_t msg_typ = 0; 2318 ibcm_mra_msg_t *mra_msgp; 2319 ibcm_state_data_t *statep; 2320 ibt_status_t status; 2321 2322 IBTF_DPRINTF_L3(cmlog, "ibt_cm_delay(0x%x, %p, 0x%x)", 2323 flags, cm_session_id, service_time); 2324 2325 /* 2326 * Make sure channel is associated with a statep 2327 */ 2328 statep = (ibcm_state_data_t *)cm_session_id; 2329 2330 if (statep == NULL) { 2331 IBTF_DPRINTF_L2(cmlog, "ibt_cm_delay: statep NULL"); 2332 return (IBT_INVALID_PARAM); 2333 } 2334 2335 IBTF_DPRINTF_L4(cmlog, "ibt_cm_delay: statep %p", statep); 2336 2337 /* Allocate an ibmf msg for mra, if not allocated yet */ 2338 if (statep->mra_msg == NULL) { 2339 if ((status = ibcm_alloc_out_msg( 2340 statep->stored_reply_addr.ibmf_hdl, &statep->mra_msg, 2341 MAD_METHOD_SEND)) != IBT_SUCCESS) { 2342 IBTF_DPRINTF_L2(cmlog, "ibt_cm_delay: chan 0x%p" 2343 "IBMF MSG allocation failed", statep->channel); 2344 return (status); 2345 } 2346 } 2347 2348 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mra_msgp)) 2349 2350 mra_msgp = (ibcm_mra_msg_t *)IBCM_OUT_MSGP(statep->mra_msg); 2351 mra_msgp->mra_local_comm_id = h2b32(statep->local_comid); 2352 mra_msgp->mra_remote_comm_id = h2b32(statep->remote_comid); 2353 2354 /* fill in rest of MRA's fields - Message MRAed and Service Timeout */ 2355 if (flags == IBT_CM_DELAY_REQ) { 2356 msg_typ = IBT_CM_MRA_TYPE_REQ; 2357 } else if (flags == IBT_CM_DELAY_REP) { 2358 msg_typ = IBT_CM_MRA_TYPE_REP; 2359 } else if (flags == IBT_CM_DELAY_LAP) { 2360 msg_typ = IBT_CM_MRA_TYPE_LAP; 2361 } 2362 2363 mra_msgp->mra_message_type_plus = msg_typ << 6; 2364 mra_msgp->mra_service_timeout_plus = ibt_usec2ib(service_time) << 3; 2365 2366 len = min(len, IBT_MRA_PRIV_DATA_SZ); 2367 if (priv_data && (len > 0)) 2368 bcopy(priv_data, mra_msgp->mra_private_data, len); 2369 2370 IBCM_OUT_HDRP(statep->mra_msg)->AttributeID = 2371 h2b16(IBCM_INCOMING_MRA + IBCM_ATTR_BASE_ID); 2372 2373 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mra_msgp)) 2374 2375 mutex_enter(&statep->state_mutex); 2376 2377 if ((statep->mode == IBCM_ACTIVE_MODE) && 2378 (statep->state == IBCM_STATE_REP_RCVD)) { 2379 statep->state = IBCM_STATE_MRA_REP_SENT; 2380 } else if (statep->mode == IBCM_PASSIVE_MODE) { 2381 if (statep->state == IBCM_STATE_REQ_RCVD) { 2382 statep->state = IBCM_STATE_MRA_SENT; 2383 } else if (statep->ap_state == IBCM_AP_STATE_LAP_RCVD) { 2384 statep->ap_state = IBCM_AP_STATE_MRA_LAP_RCVD; 2385 } else { 2386 IBTF_DPRINTF_L2(cmlog, "ibt_cm_delay: invalid state " 2387 "/ap_state/mode %x, %x, %x", statep->state, 2388 statep->ap_state, statep->mode); 2389 mutex_exit(&statep->state_mutex); 2390 return (IBT_CHAN_STATE_INVALID); 2391 } 2392 } else { 2393 IBTF_DPRINTF_L2(cmlog, "ibt_cm_delay: invalid state " 2394 "/ap_state/mode %x, %x, %x", statep->state, 2395 statep->ap_state, statep->mode); 2396 mutex_exit(&statep->state_mutex); 2397 2398 return (IBT_CHAN_STATE_INVALID); 2399 } 2400 /* service time is usecs, stale_clock is nsecs */ 2401 statep->stale_clock = gethrtime() + 2402 (hrtime_t)ibt_ib2usec(ibt_usec2ib(service_time)) * (1000 * 2403 statep->max_cm_retries); 2404 2405 statep->send_mad_flags |= IBCM_MRA_POST_BUSY; 2406 IBCM_REF_CNT_INCR(statep); /* for ibcm_post_mra_complete */ 2407 mutex_exit(&statep->state_mutex); 2408 2409 IBCM_OUT_HDRP(statep->mra_msg)->TransactionID = 2410 IBCM_OUT_HDRP(statep->stored_msg)->TransactionID; 2411 2412 /* post the MRA mad in blocking mode, as no timers involved */ 2413 ibcm_post_rc_mad(statep, statep->mra_msg, ibcm_post_mra_complete, 2414 statep); 2415 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_MRA); 2416 /* If this message isn't seen then ibt_cm_delay failed */ 2417 IBTF_DPRINTF_L3(cmlog, "ibt_cm_delay: done !!"); 2418 2419 return (IBT_SUCCESS); 2420 } 2421 2422 2423 /* 2424 * ibt_register_service() 2425 * Register a service with the IBCM 2426 * 2427 * INPUTS: 2428 * ibt_hdl The IBT client handle returned to the client 2429 * on an ibt_attach() call. 2430 * 2431 * srv The address of a ibt_srv_desc_t that describes 2432 * the service, containing the following: 2433 * 2434 * sd_ud_handler The Service CM UD event Handler. 2435 * sd_handler The Service CM RC/UC/RD event Handler. 2436 * sd_flags Service flags (peer-to-peer, or not). 2437 * 2438 * sid This tells CM if the service is local (sid is 0) or 2439 * wellknown (sid is the starting service id of the range). 2440 * 2441 * num_sids The number of contiguous service-ids to reserve. 2442 * 2443 * srv_hdl The address of a service identification handle, used 2444 * to deregister a service, and to bind GIDs to. 2445 * 2446 * ret_sid The address to store the Service ID return value. 2447 * If num_sids > 1, ret_sid is the first Service ID 2448 * in the range. 2449 * 2450 * ibt_register_service() returns: 2451 * IBT_SUCCESS - added a service successfully. 2452 * IBT_INVALID_PARAM - invalid input parameter. 2453 * IBT_CM_FAILURE - failed to add the service. 2454 * IBT_CM_SERVICE_EXISTS - service already exists. 2455 * IBT_INSUFF_KERNEL_RESOURCE - ran out of local service ids (should 2456 * never happen). 2457 */ 2458 ibt_status_t 2459 ibt_register_service(ibt_clnt_hdl_t ibt_hdl, ibt_srv_desc_t *srv, 2460 ib_svc_id_t sid, int num_sids, ibt_srv_hdl_t *srv_hdl, ib_svc_id_t *ret_sid) 2461 { 2462 ibcm_svc_info_t *svcinfop; 2463 2464 IBTF_DPRINTF_L2(cmlog, "ibt_register_service(%p (%s), %p, 0x%llX, %d)", 2465 ibt_hdl, ibtl_cm_get_clnt_name(ibt_hdl), srv, (longlong_t)sid, 2466 num_sids); 2467 2468 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*svcinfop)) 2469 2470 *srv_hdl = NULL; 2471 2472 if (num_sids <= 0) { 2473 IBTF_DPRINTF_L2(cmlog, "ibt_register_service: " 2474 "Invalid number of service-ids specified (%d)", num_sids); 2475 return (IBT_INVALID_PARAM); 2476 } 2477 2478 if (sid == 0) { 2479 if (ret_sid == NULL) 2480 return (IBT_INVALID_PARAM); 2481 sid = ibcm_alloc_local_sids(num_sids); 2482 if (sid == 0) 2483 return (IBT_INSUFF_KERNEL_RESOURCE); 2484 2485 /* Make sure that the ServiceId specified is not of LOCAL AGN type. */ 2486 } else if ((sid & IB_SID_AGN_MASK) == IB_SID_AGN_LOCAL) { 2487 IBTF_DPRINTF_L2(cmlog, "ibt_register_service: " 2488 "Invalid non-LOCAL SID specified: 0x%llX", 2489 (longlong_t)sid); 2490 return (IBT_INVALID_PARAM); 2491 } 2492 2493 svcinfop = ibcm_create_svc_entry(sid, num_sids); 2494 2495 if (svcinfop == NULL) { 2496 IBTF_DPRINTF_L2(cmlog, "ibt_register_service: " 2497 "Service-ID 0x%llx already registered", (longlong_t)sid); 2498 return (IBT_CM_SERVICE_EXISTS); 2499 } 2500 2501 /* 2502 * 'sid' and 'num_sids' are filled in ibcm_create_svc_entry() 2503 */ 2504 svcinfop->svc_flags = srv->sd_flags; 2505 svcinfop->svc_rc_handler = srv->sd_handler; 2506 svcinfop->svc_ud_handler = srv->sd_ud_handler; 2507 2508 if (ret_sid != NULL) 2509 *ret_sid = sid; 2510 2511 *srv_hdl = svcinfop; 2512 2513 ibtl_cm_change_service_cnt(ibt_hdl, num_sids); 2514 2515 /* If this message isn't seen, then ibt_register_service failed. */ 2516 IBTF_DPRINTF_L2(cmlog, "ibt_register_service: done (%p, %llX)", 2517 svcinfop, sid); 2518 2519 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*svcinfop)) 2520 2521 return (IBT_SUCCESS); 2522 } 2523 2524 2525 static ibt_status_t 2526 ibcm_write_service_record(ibmf_saa_handle_t saa_handle, 2527 sa_service_record_t *srv_recp, ibmf_saa_access_type_t saa_type) 2528 { 2529 int rval; 2530 int retry; 2531 2532 ibcm_sa_access_enter(); 2533 for (retry = 0; retry < ibcm_max_sa_retries; retry++) { 2534 rval = ibmf_saa_update_service_record( 2535 saa_handle, srv_recp, saa_type, 0); 2536 if (rval != IBMF_TRANS_TIMEOUT) { 2537 break; 2538 } 2539 IBTF_DPRINTF_L2(cmlog, "ibcm_write_service_record: " 2540 "ibmf_saa_update_service_record timed out" 2541 " SID = %llX, rval = %d, saa_type = %d", 2542 (longlong_t)srv_recp->ServiceID, rval, saa_type); 2543 delay(ibcm_sa_timeout_delay); 2544 } 2545 ibcm_sa_access_exit(); 2546 2547 if (rval != IBMF_SUCCESS) { 2548 IBTF_DPRINTF_L2(cmlog, "ibcm_write_service_record: " 2549 "ibmf_saa_update_service_record() : Failed - %d", rval); 2550 return (ibcm_ibmf_analyze_error(rval)); 2551 } else 2552 return (IBT_SUCCESS); 2553 } 2554 2555 2556 static void 2557 ibcm_rem_stale_srec(ibmf_saa_handle_t saa_handle, sa_service_record_t *srec) 2558 { 2559 ibt_status_t retval; 2560 uint_t num_found; 2561 size_t length; 2562 sa_service_record_t *srv_resp; 2563 void *results_p; 2564 uint_t i; 2565 uint64_t component_mask; 2566 ibmf_saa_access_args_t access_args; 2567 2568 component_mask = 2569 SA_SR_COMPMASK_PKEY | SA_SR_COMPMASK_NAME | SA_SR_COMPMASK_GID; 2570 2571 /* Call in SA Access retrieve routine to get Service Records. */ 2572 access_args.sq_attr_id = SA_SERVICERECORD_ATTRID; 2573 access_args.sq_access_type = IBMF_SAA_RETRIEVE; 2574 access_args.sq_component_mask = component_mask; 2575 access_args.sq_template = srec; 2576 access_args.sq_template_length = sizeof (sa_service_record_t); 2577 access_args.sq_callback = NULL; 2578 access_args.sq_callback_arg = NULL; 2579 2580 retval = ibcm_contact_sa_access(saa_handle, &access_args, &length, 2581 &results_p); 2582 if (retval != IBT_SUCCESS) { 2583 IBTF_DPRINTF_L2(cmlog, "ibcm_rem_stale_srec: " 2584 "SA Access Failure"); 2585 return; 2586 } 2587 2588 num_found = length / sizeof (sa_service_record_t); 2589 2590 if (num_found) 2591 IBTF_DPRINTF_L3(cmlog, "ibcm_rem_stale_srec: " 2592 "Found %d matching Service Records.", num_found); 2593 2594 /* Validate the returned number of records. */ 2595 if ((results_p != NULL) && (num_found > 0)) { 2596 2597 /* Remove all the records. */ 2598 for (i = 0; i < num_found; i++) { 2599 2600 srv_resp = (sa_service_record_t *) 2601 ((uchar_t *)results_p + 2602 i * sizeof (sa_service_record_t)); 2603 2604 /* 2605 * Found some matching records, but check out whether 2606 * this Record is really stale or just happens to match 2607 * the current session records. If yes, don't remove it. 2608 */ 2609 mutex_enter(&ibcm_svc_info_lock); 2610 if (ibcm_find_svc_entry(srv_resp->ServiceID) != NULL) { 2611 /* This record is NOT STALE. */ 2612 mutex_exit(&ibcm_svc_info_lock); 2613 IBTF_DPRINTF_L3(cmlog, "ibcm_rem_stale_srec: " 2614 "This is not Stale, it's an active record"); 2615 continue; 2616 } 2617 mutex_exit(&ibcm_svc_info_lock); 2618 2619 IBTF_DPRINTF_L2(cmlog, "ibcm_rem_stale_srec: " 2620 "Removing Stale Rec: %s, %llX", 2621 srv_resp->ServiceName, srv_resp->ServiceID); 2622 2623 IBCM_DUMP_SERVICE_REC(srv_resp); 2624 2625 /* 2626 * Remove the Service Record Entry from SA. 2627 * 2628 * Get ServiceID info from Response Buf, other 2629 * attributes are already filled-in. 2630 */ 2631 2632 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(srec->ServiceID)) 2633 2634 srec->ServiceID = srv_resp->ServiceID; 2635 2636 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(srec->ServiceID)) 2637 2638 (void) ibcm_write_service_record(saa_handle, srec, 2639 IBMF_SAA_DELETE); 2640 } 2641 2642 /* Deallocate the memory for results_p. */ 2643 kmem_free(results_p, length); 2644 } 2645 } 2646 2647 2648 2649 /* 2650 * ibt_bind_service() 2651 * Register a service with the IBCM 2652 * 2653 * INPUTS: 2654 * srv_hdl The service id handle returned to the client 2655 * on an ibt_service_register() call. 2656 * 2657 * gid The GID to which to bind the service. 2658 * 2659 * srv_bind The address of a ibt_srv_bind_t that describes 2660 * the service record. This should be NULL if there 2661 * is to be no service record. This contains: 2662 * 2663 * sb_lease Lease period 2664 * sb_pkey Partition 2665 * sb_name pointer to ASCII string Service Name, 2666 * NULL terminated. 2667 * sb_key[] Key to secure the service record. 2668 * sb_data Service Data structure (64-byte) 2669 * 2670 * cm_private First argument of Service handler. 2671 * 2672 * sb_hdl_p The address of a service bind handle, used 2673 * to undo the service binding. 2674 * 2675 * ibt_bind_service() returns: 2676 * IBT_SUCCESS - added a service successfully. 2677 * IBT_INVALID_PARAM - invalid input parameter. 2678 * IBT_CM_FAILURE - failed to add the service. 2679 * IBT_CM_SERVICE_EXISTS - service already exists. 2680 */ 2681 ibt_status_t 2682 ibt_bind_service(ibt_srv_hdl_t srv_hdl, ib_gid_t gid, ibt_srv_bind_t *srv_bind, 2683 void *cm_private, ibt_sbind_hdl_t *sb_hdl_p) 2684 { 2685 ibt_status_t status; 2686 ibtl_cm_hca_port_t port; 2687 ibcm_svc_bind_t *sbindp, *sbp; 2688 ibcm_hca_info_t *hcap; 2689 ib_svc_id_t sid, start_sid, end_sid; 2690 ibmf_saa_handle_t saa_handle; 2691 sa_service_record_t srv_rec; 2692 uint16_t pkey_ix; 2693 2694 if (sb_hdl_p != NULL) 2695 *sb_hdl_p = NULL; /* return value for error cases */ 2696 2697 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: srv_hdl %p, gid (%llX:%llX)", 2698 srv_hdl, (longlong_t)gid.gid_prefix, (longlong_t)gid.gid_guid); 2699 2700 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sbindp)) 2701 2702 /* Call ibtl_cm_get_hca_port to get the port number and the HCA GUID. */ 2703 if ((status = ibtl_cm_get_hca_port(gid, 0, &port)) != IBT_SUCCESS) { 2704 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: " 2705 "ibtl_cm_get_hca_port failed: %d", status); 2706 return (status); 2707 } 2708 IBTF_DPRINTF_L4(cmlog, "ibt_bind_service: Port:%d HCA GUID:%llX", 2709 port.hp_port, port.hp_hca_guid); 2710 2711 hcap = ibcm_find_hca_entry(port.hp_hca_guid); 2712 if (hcap == NULL) { 2713 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: NO HCA found"); 2714 return (IBT_HCA_BUSY_DETACHING); 2715 } 2716 IBTF_DPRINTF_L4(cmlog, "ibt_bind_service: hcap = %p", hcap); 2717 2718 if (srv_bind != NULL) { 2719 saa_handle = ibcm_get_saa_handle(hcap, port.hp_port); 2720 if (saa_handle == NULL) { 2721 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: " 2722 "saa_handle is NULL"); 2723 ibcm_dec_hca_acc_cnt(hcap); 2724 return (IBT_HCA_PORT_NOT_ACTIVE); 2725 } 2726 if (srv_bind->sb_pkey == 0) { 2727 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: " 2728 "P_Key must not be 0"); 2729 ibcm_dec_hca_acc_cnt(hcap); 2730 return (IBT_INVALID_PARAM); 2731 } 2732 if (strlen(srv_bind->sb_name) >= IB_SVC_NAME_LEN) { 2733 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: " 2734 "Service Name is too long"); 2735 ibcm_dec_hca_acc_cnt(hcap); 2736 return (IBT_INVALID_PARAM); 2737 } else 2738 IBTF_DPRINTF_L3(cmlog, "ibt_bind_service: " 2739 "Service Name='%s'", srv_bind->sb_name); 2740 status = ibt_pkey2index_byguid(port.hp_hca_guid, 2741 port.hp_port, srv_bind->sb_pkey, &pkey_ix); 2742 if (status != IBT_SUCCESS) { 2743 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: " 2744 "P_Key 0x%x not found in P_Key_Table", 2745 srv_bind->sb_pkey); 2746 ibcm_dec_hca_acc_cnt(hcap); 2747 return (status); 2748 } 2749 } 2750 2751 /* assume success - allocate before locking */ 2752 sbindp = kmem_zalloc(sizeof (*sbindp), KM_SLEEP); 2753 sbindp->sbind_cm_private = cm_private; 2754 sbindp->sbind_gid = gid; 2755 sbindp->sbind_hcaguid = port.hp_hca_guid; 2756 sbindp->sbind_port = port.hp_port; 2757 2758 mutex_enter(&ibcm_svc_info_lock); 2759 2760 sbp = srv_hdl->svc_bind_list; 2761 while (sbp != NULL) { 2762 if (sbp->sbind_gid.gid_guid == gid.gid_guid && 2763 sbp->sbind_gid.gid_prefix == gid.gid_prefix) { 2764 if (srv_bind == NULL || 2765 srv_bind->sb_pkey == sbp->sbind_pkey) { 2766 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: " 2767 "failed: GID %llX:%llX and PKEY %x is " 2768 "already bound", gid.gid_prefix, 2769 gid.gid_guid, sbp->sbind_pkey); 2770 mutex_exit(&ibcm_svc_info_lock); 2771 ibcm_dec_hca_acc_cnt(hcap); 2772 kmem_free(sbindp, sizeof (*sbindp)); 2773 return (IBT_CM_SERVICE_EXISTS); 2774 } 2775 } 2776 sbp = sbp->sbind_link; 2777 } 2778 /* no entry found */ 2779 2780 sbindp->sbind_link = srv_hdl->svc_bind_list; 2781 srv_hdl->svc_bind_list = sbindp; 2782 2783 mutex_exit(&ibcm_svc_info_lock); 2784 2785 if (srv_bind != NULL) { 2786 bzero(&srv_rec, sizeof (srv_rec)); 2787 2788 srv_rec.ServiceLease = 2789 sbindp->sbind_lease = srv_bind->sb_lease; 2790 srv_rec.ServiceP_Key = 2791 sbindp->sbind_pkey = srv_bind->sb_pkey; 2792 srv_rec.ServiceKey_hi = 2793 sbindp->sbind_key[0] = srv_bind->sb_key[0]; 2794 srv_rec.ServiceKey_lo = 2795 sbindp->sbind_key[1] = srv_bind->sb_key[1]; 2796 (void) strcpy(sbindp->sbind_name, srv_bind->sb_name); 2797 (void) strcpy((char *)srv_rec.ServiceName, srv_bind->sb_name); 2798 srv_rec.ServiceGID = gid; 2799 2800 /* 2801 * Find out whether we have any stale Local Service records 2802 * matching the current attributes. If yes, we shall try to 2803 * remove them from SA using the current request's ServiceKey. 2804 * 2805 * We will perform this operation only for Local Services, as 2806 * it is handled by SA automatically for WellKnown Services. 2807 * 2808 * Ofcourse, clients can specify NOT to do this clean-up by 2809 * setting IBT_SBIND_NO_CLEANUP flag (srv_bind->sb_flag). 2810 */ 2811 if ((srv_hdl->svc_id & IB_SID_AGN_LOCAL) && 2812 (!(srv_bind->sb_flag & IBT_SBIND_NO_CLEANUP))) { 2813 ibcm_rem_stale_srec(saa_handle, &srv_rec); 2814 } 2815 2816 /* Handle endianess for service data. */ 2817 ibcm_swizzle_from_srv(&srv_bind->sb_data, sbindp->sbind_data); 2818 2819 bcopy(sbindp->sbind_data, srv_rec.ServiceData, IB_SVC_DATA_LEN); 2820 2821 /* insert srv record into the SA */ 2822 start_sid = srv_hdl->svc_id; 2823 end_sid = start_sid + srv_hdl->svc_num_sids - 1; 2824 for (sid = start_sid; sid <= end_sid; sid++) { 2825 2826 srv_rec.ServiceID = sid; 2827 2828 IBCM_DUMP_SERVICE_REC(&srv_rec); 2829 2830 IBTF_DPRINTF_L4(cmlog, "ibt_bind_service: " 2831 "ibmf_saa_write_service_record, SvcId = %llX", 2832 (longlong_t)sid); 2833 2834 status = ibcm_write_service_record(saa_handle, &srv_rec, 2835 IBMF_SAA_UPDATE); 2836 if (status != IBT_SUCCESS) { 2837 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service:" 2838 " ibcm_write_service_record fails %d, " 2839 "sid %llX", status, (longlong_t)sid); 2840 2841 if (sid != start_sid) { 2842 /* 2843 * Bind failed while bind SID other than 2844 * first in the sid_range. So we need 2845 * to unbind those, which are passed. 2846 * 2847 * Need to increment svc count to 2848 * compensate for ibt_unbind_service(). 2849 */ 2850 ibcm_inc_hca_svc_cnt(hcap); 2851 ibcm_dec_hca_acc_cnt(hcap); 2852 2853 (void) ibt_unbind_service(srv_hdl, 2854 sbindp); 2855 } else { 2856 ibcm_svc_bind_t **sbpp; 2857 2858 /* 2859 * Bind failed for the first SID or the 2860 * only SID in question, then no need 2861 * to unbind, just free memory and 2862 * return error. 2863 */ 2864 mutex_enter(&ibcm_svc_info_lock); 2865 2866 sbpp = &srv_hdl->svc_bind_list; 2867 sbp = *sbpp; 2868 while (sbp != NULL) { 2869 if (sbp == sbindp) { 2870 *sbpp = sbp->sbind_link; 2871 break; 2872 } 2873 sbpp = &sbp->sbind_link; 2874 sbp = *sbpp; 2875 } 2876 mutex_exit(&ibcm_svc_info_lock); 2877 ibcm_dec_hca_acc_cnt(hcap); 2878 2879 kmem_free(sbindp, sizeof (*sbindp)); 2880 } 2881 return (status); 2882 } 2883 } 2884 } 2885 ibcm_inc_hca_svc_cnt(hcap); 2886 ibcm_dec_hca_acc_cnt(hcap); 2887 2888 /* If this message isn't seen then ibt_bind_service failed */ 2889 IBTF_DPRINTF_L2(cmlog, "ibt_bind_service: DONE (%p, %llX:%llX)", 2890 srv_hdl, gid.gid_prefix, gid.gid_guid); 2891 2892 if (sb_hdl_p != NULL) 2893 *sb_hdl_p = sbindp; 2894 2895 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*sbindp)) 2896 2897 return (IBT_SUCCESS); 2898 } 2899 2900 ibt_status_t 2901 ibt_unbind_service(ibt_srv_hdl_t srv_hdl, ibt_sbind_hdl_t sbindp) 2902 { 2903 ib_svc_id_t sid, end_sid; 2904 ibt_status_t rval; 2905 ibcm_hca_info_t *hcap; 2906 ibcm_svc_bind_t *sbp, **sbpp; 2907 2908 IBTF_DPRINTF_L2(cmlog, "ibt_unbind_service(%p, %p)", 2909 srv_hdl, sbindp); 2910 2911 hcap = ibcm_find_hca_entry(sbindp->sbind_hcaguid); 2912 2913 /* If there is a service on hca, respective hcap cannot go away */ 2914 ASSERT(hcap != NULL); 2915 2916 mutex_enter(&ibcm_svc_info_lock); 2917 2918 sbpp = &srv_hdl->svc_bind_list; 2919 sbp = *sbpp; 2920 while (sbp != NULL) { 2921 if (sbp == sbindp) { 2922 *sbpp = sbp->sbind_link; 2923 break; 2924 } 2925 sbpp = &sbp->sbind_link; 2926 sbp = *sbpp; 2927 } 2928 sid = srv_hdl->svc_id; 2929 end_sid = srv_hdl->svc_id + srv_hdl->svc_num_sids - 1; 2930 if (sbp != NULL) 2931 while (sbp->sbind_rewrite_state == IBCM_REWRITE_BUSY) 2932 cv_wait(&ibcm_svc_info_cv, &ibcm_svc_info_lock); 2933 mutex_exit(&ibcm_svc_info_lock); 2934 2935 if (sbp == NULL) { 2936 IBTF_DPRINTF_L2(cmlog, "ibt_unbind_service: " 2937 "service binding not found: srv_hdl %p, srv_bind %p", 2938 srv_hdl, sbindp); 2939 ibcm_dec_hca_acc_cnt(hcap); 2940 return (IBT_INVALID_PARAM); 2941 } 2942 2943 if (sbindp->sbind_pkey != 0) { /* Are there service records? */ 2944 ibtl_cm_hca_port_t port; 2945 sa_service_record_t srv_rec; 2946 ibmf_saa_handle_t saa_handle; 2947 ibt_status_t status; 2948 2949 /* get the default SGID of the port */ 2950 if ((status = ibtl_cm_get_hca_port(sbindp->sbind_gid, 0, &port)) 2951 != IBT_SUCCESS) { 2952 IBTF_DPRINTF_L2(cmlog, "ibt_unbind_service: " 2953 "ibtl_cm_get_hca_port failed: %d", status); 2954 /* we're done, but there may be stale service records */ 2955 goto done; 2956 } 2957 2958 saa_handle = ibcm_get_saa_handle(hcap, port.hp_port); 2959 if (saa_handle == NULL) { 2960 IBTF_DPRINTF_L2(cmlog, "ibt_unbind_service: " 2961 "saa_handle is NULL"); 2962 /* we're done, but there may be stale service records */ 2963 goto done; 2964 } 2965 2966 /* Fill in fields of srv_rec */ 2967 bzero(&srv_rec, sizeof (srv_rec)); 2968 2969 srv_rec.ServiceP_Key = sbindp->sbind_pkey; 2970 srv_rec.ServiceKey_hi = sbindp->sbind_key[0]; 2971 srv_rec.ServiceKey_lo = sbindp->sbind_key[1]; 2972 srv_rec.ServiceGID = sbindp->sbind_gid; 2973 (void) strcpy((char *)srv_rec.ServiceName, sbindp->sbind_name); 2974 2975 while (sid <= end_sid) { 2976 2977 srv_rec.ServiceID = sid; 2978 IBCM_DUMP_SERVICE_REC(&srv_rec); 2979 2980 rval = ibcm_write_service_record(saa_handle, &srv_rec, 2981 IBMF_SAA_DELETE); 2982 2983 IBTF_DPRINTF_L4(cmlog, "ibt_unbind_service: " 2984 "ibcm_write_service_record rval = %d, SID %llx", 2985 rval, sid); 2986 if (rval != IBT_SUCCESS) { 2987 /* this is not considered a reason to fail */ 2988 IBTF_DPRINTF_L2(cmlog, "ibt_unbind_service: " 2989 "ibcm_write_service_record fails %d, " 2990 "sid %llx", rval, sid); 2991 } 2992 sid++; 2993 } 2994 } 2995 done: 2996 ibcm_dec_hca_svc_cnt(hcap); 2997 ibcm_dec_hca_acc_cnt(hcap); 2998 kmem_free(sbindp, sizeof (*sbindp)); 2999 3000 /* If this message isn't seen then ibt_unbind_service failed */ 3001 IBTF_DPRINTF_L2(cmlog, "ibt_unbind_service: done !!"); 3002 3003 return (IBT_SUCCESS); 3004 } 3005 3006 /* 3007 * Simply pull off each binding from the list and unbind it. 3008 * If any of the unbind calls fail, we fail. 3009 */ 3010 ibt_status_t 3011 ibt_unbind_all_services(ibt_srv_hdl_t srv_hdl) 3012 { 3013 ibt_status_t status; 3014 ibcm_svc_bind_t *sbp; 3015 3016 mutex_enter(&ibcm_svc_info_lock); 3017 sbp = NULL; 3018 3019 /* this compare keeps the loop from being infinite */ 3020 while (sbp != srv_hdl->svc_bind_list) { 3021 sbp = srv_hdl->svc_bind_list; 3022 mutex_exit(&ibcm_svc_info_lock); 3023 status = ibt_unbind_service(srv_hdl, sbp); 3024 if (status != IBT_SUCCESS) 3025 return (status); 3026 mutex_enter(&ibcm_svc_info_lock); 3027 if (srv_hdl->svc_bind_list == NULL) 3028 break; 3029 } 3030 mutex_exit(&ibcm_svc_info_lock); 3031 return (IBT_SUCCESS); 3032 } 3033 3034 /* 3035 * ibt_deregister_service() 3036 * Deregister a service with the IBCM 3037 * 3038 * INPUTS: 3039 * ibt_hdl The IBT client handle returned to the client 3040 * on an ibt_attach() call. 3041 * 3042 * srv_hdl The address of a service identification handle, used 3043 * to de-register a service. 3044 * RETURN VALUES: 3045 * IBT_SUCCESS on success (or respective failure on error) 3046 */ 3047 ibt_status_t 3048 ibt_deregister_service(ibt_clnt_hdl_t ibt_hdl, ibt_srv_hdl_t srv_hdl) 3049 { 3050 ibcm_svc_info_t *svcp; 3051 ibcm_svc_lookup_t svc; 3052 3053 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_service(%p (%s), %p)", 3054 ibt_hdl, ibtl_cm_get_clnt_name(ibt_hdl), srv_hdl); 3055 3056 mutex_enter(&ibcm_svc_info_lock); 3057 3058 if (srv_hdl->svc_bind_list != NULL) { 3059 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_service:" 3060 " srv_hdl %p still has bindings", srv_hdl); 3061 mutex_exit(&ibcm_svc_info_lock); 3062 return (IBT_CM_SERVICE_BUSY); 3063 } 3064 svc.sid = srv_hdl->svc_id; 3065 svc.num_sids = 1; 3066 IBTF_DPRINTF_L3(cmlog, "ibt_deregister_service: SID 0x%llX, numsids %d", 3067 srv_hdl->svc_id, srv_hdl->svc_num_sids); 3068 3069 #ifdef __lock_lint 3070 ibcm_svc_compare(NULL, NULL); 3071 #endif 3072 svcp = avl_find(&ibcm_svc_avl_tree, &svc, NULL); 3073 if (svcp != srv_hdl) { 3074 mutex_exit(&ibcm_svc_info_lock); 3075 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_service(): " 3076 "srv_hdl %p not found", srv_hdl); 3077 return (IBT_INVALID_PARAM); 3078 } 3079 avl_remove(&ibcm_svc_avl_tree, svcp); 3080 3081 /* wait for active REQ/SREQ handling to be done */ 3082 svcp->svc_to_delete = 1; 3083 while (svcp->svc_ref_cnt != 0) 3084 cv_wait(&ibcm_svc_info_cv, &ibcm_svc_info_lock); 3085 3086 mutex_exit(&ibcm_svc_info_lock); 3087 3088 if ((srv_hdl->svc_id & IB_SID_AGN_MASK) == IB_SID_AGN_LOCAL) 3089 ibcm_free_local_sids(srv_hdl->svc_id, srv_hdl->svc_num_sids); 3090 3091 ibtl_cm_change_service_cnt(ibt_hdl, -srv_hdl->svc_num_sids); 3092 kmem_free(srv_hdl, sizeof (*srv_hdl)); 3093 3094 /* If this message isn't seen then ibt_deregister_service failed */ 3095 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_service: done !!"); 3096 3097 return (IBT_SUCCESS); 3098 } 3099 3100 ibcm_status_t 3101 ibcm_ar_init(void) 3102 { 3103 ib_svc_id_t sid = IBCM_DAPL_ATS_SID; 3104 ibcm_svc_info_t *tmp_svcp; 3105 3106 IBTF_DPRINTF_L3(cmlog, "ibcm_ar_init()"); 3107 3108 /* remove this special SID from the pool of available SIDs */ 3109 if ((tmp_svcp = ibcm_create_svc_entry(sid, 1)) == NULL) { 3110 IBTF_DPRINTF_L3(cmlog, "ibcm_ar_init: " 3111 "DAPL ATS SID 0x%llx already registered", (longlong_t)sid); 3112 return (IBCM_FAILURE); 3113 } 3114 mutex_enter(&ibcm_svc_info_lock); 3115 ibcm_ar_svcinfop = tmp_svcp; 3116 ibcm_ar_list = NULL; /* no address records registered yet */ 3117 mutex_exit(&ibcm_svc_info_lock); 3118 return (IBCM_SUCCESS); 3119 } 3120 3121 ibcm_status_t 3122 ibcm_ar_fini(void) 3123 { 3124 ibcm_ar_t *ar_list; 3125 ibcm_svc_info_t *tmp_svcp; 3126 3127 mutex_enter(&ibcm_svc_info_lock); 3128 ar_list = ibcm_ar_list; 3129 3130 if (ar_list == NULL && 3131 avl_numnodes(&ibcm_svc_avl_tree) == 1 && 3132 avl_first(&ibcm_svc_avl_tree) == ibcm_ar_svcinfop) { 3133 avl_remove(&ibcm_svc_avl_tree, ibcm_ar_svcinfop); 3134 tmp_svcp = ibcm_ar_svcinfop; 3135 mutex_exit(&ibcm_svc_info_lock); 3136 kmem_free(tmp_svcp, sizeof (*ibcm_ar_svcinfop)); 3137 return (IBCM_SUCCESS); 3138 } 3139 mutex_exit(&ibcm_svc_info_lock); 3140 return (IBCM_FAILURE); 3141 } 3142 3143 3144 /* 3145 * Return to the caller: 3146 * IBT_SUCCESS Found a perfect match. 3147 * *arpp is set to the record. 3148 * IBT_INCONSISTENT_AR Found a record that's inconsistent. 3149 * IBT_AR_NOT_REGISTERED Found no record with same GID/pkey and 3150 * found no record with same data. 3151 */ 3152 static ibt_status_t 3153 ibcm_search_ar(ibt_ar_t *arp, ibcm_ar_t **arpp) 3154 { 3155 ibcm_ar_t *tmp; 3156 int i; 3157 3158 ASSERT(MUTEX_HELD(&ibcm_svc_info_lock)); 3159 tmp = ibcm_ar_list; 3160 while (tmp != NULL) { 3161 if (tmp->ar.ar_gid.gid_prefix == arp->ar_gid.gid_prefix && 3162 tmp->ar.ar_gid.gid_guid == arp->ar_gid.gid_guid && 3163 tmp->ar.ar_pkey == arp->ar_pkey) { 3164 for (i = 0; i < IBCM_DAPL_ATS_NBYTES; i++) 3165 if (tmp->ar.ar_data[i] != arp->ar_data[i]) 3166 return (IBT_INCONSISTENT_AR); 3167 *arpp = tmp; 3168 return (IBT_SUCCESS); 3169 } else { 3170 /* if all the data bytes match, we have inconsistency */ 3171 for (i = 0; i < IBCM_DAPL_ATS_NBYTES; i++) 3172 if (tmp->ar.ar_data[i] != arp->ar_data[i]) 3173 break; 3174 if (i == IBCM_DAPL_ATS_NBYTES) 3175 return (IBT_INCONSISTENT_AR); 3176 /* try next address record */ 3177 } 3178 tmp = tmp->ar_link; 3179 } 3180 return (IBT_AR_NOT_REGISTERED); 3181 } 3182 3183 ibt_status_t 3184 ibt_register_ar(ibt_clnt_hdl_t ibt_hdl, ibt_ar_t *arp) 3185 { 3186 ibcm_ar_t *found; 3187 ibcm_ar_t *tmp; 3188 ibt_status_t status; 3189 ibt_status_t s1, s2; 3190 char *s; 3191 ibcm_ar_ref_t *hdlp; 3192 ibcm_ar_t *new; 3193 ibcm_ar_t **linkp; 3194 ibtl_cm_hca_port_t cm_port; 3195 uint16_t pkey_ix; 3196 ibcm_hca_info_t *hcap; 3197 ibmf_saa_handle_t saa_handle; 3198 sa_service_record_t *srv_recp; 3199 uint64_t gid_ored; 3200 3201 IBTF_DPRINTF_L3(cmlog, "ibt_register_ar: PKey 0x%X GID %llX:%llX", 3202 arp->ar_pkey, (longlong_t)arp->ar_gid.gid_prefix, 3203 (longlong_t)arp->ar_gid.gid_guid); 3204 3205 /* 3206 * If P_Key is 0, but GID is not, this query is invalid. 3207 * If GID is 0, but P_Key is not, this query is invalid. 3208 */ 3209 gid_ored = arp->ar_gid.gid_guid | arp->ar_gid.gid_prefix; 3210 if ((arp->ar_pkey == 0 && gid_ored != 0ULL) || 3211 (arp->ar_pkey != 0 && gid_ored == 0ULL)) { 3212 IBTF_DPRINTF_L2(cmlog, "ibt_register_ar: " 3213 "GID/P_Key is not valid"); 3214 return (IBT_INVALID_PARAM); 3215 } 3216 3217 /* assume success, so these might be needed */ 3218 hdlp = kmem_alloc(sizeof (*hdlp), KM_SLEEP); 3219 new = kmem_zalloc(sizeof (*new), KM_SLEEP); 3220 3221 mutex_enter(&ibcm_svc_info_lock); 3222 /* search for existing GID/pkey (there can be at most 1) */ 3223 status = ibcm_search_ar(arp, &found); 3224 if (status == IBT_INCONSISTENT_AR) { 3225 mutex_exit(&ibcm_svc_info_lock); 3226 kmem_free(new, sizeof (*new)); 3227 kmem_free(hdlp, sizeof (*hdlp)); 3228 IBTF_DPRINTF_L2(cmlog, "ibt_register_ar: " 3229 "address record is inconsistent with a known one"); 3230 return (IBT_INCONSISTENT_AR); 3231 } else if (status == IBT_SUCCESS) { 3232 if (found->ar_flags == IBCM_AR_INITING) { 3233 found->ar_waiters++; 3234 cv_wait(&found->ar_cv, &ibcm_svc_info_lock); 3235 found->ar_waiters--; 3236 } 3237 if (found->ar_flags == IBCM_AR_FAILED) { 3238 if (found->ar_waiters == 0) { 3239 cv_destroy(&found->ar_cv); 3240 kmem_free(found, sizeof (*found)); 3241 } 3242 mutex_exit(&ibcm_svc_info_lock); 3243 kmem_free(new, sizeof (*new)); 3244 kmem_free(hdlp, sizeof (*hdlp)); 3245 return (ibt_get_module_failure(IBT_FAILURE_IBCM, 0)); 3246 } 3247 hdlp->ar_ibt_hdl = ibt_hdl; 3248 hdlp->ar_ref_link = found->ar_ibt_hdl_list; 3249 found->ar_ibt_hdl_list = hdlp; 3250 mutex_exit(&ibcm_svc_info_lock); 3251 kmem_free(new, sizeof (*new)); 3252 ibtl_cm_change_service_cnt(ibt_hdl, 1); 3253 return (IBT_SUCCESS); 3254 } else { 3255 ASSERT(status == IBT_AR_NOT_REGISTERED); 3256 } 3257 hdlp->ar_ref_link = NULL; 3258 hdlp->ar_ibt_hdl = ibt_hdl; 3259 new->ar_ibt_hdl_list = hdlp; 3260 new->ar = *arp; 3261 new->ar_flags = IBCM_AR_INITING; 3262 new->ar_waiters = 0; 3263 cv_init(&new->ar_cv, NULL, CV_DEFAULT, NULL); 3264 new->ar_link = ibcm_ar_list; 3265 ibcm_ar_list = new; 3266 3267 /* verify GID/pkey is valid for a local port, etc. */ 3268 hcap = NULL; 3269 if ((s1 = ibtl_cm_get_hca_port(arp->ar_gid, 0, &cm_port)) 3270 != IBT_SUCCESS || 3271 (s2 = ibt_pkey2index_byguid(cm_port.hp_hca_guid, cm_port.hp_port, 3272 arp->ar_pkey, &pkey_ix)) != IBT_SUCCESS || 3273 (hcap = ibcm_find_hca_entry(cm_port.hp_hca_guid)) == NULL) { 3274 cv_destroy(&new->ar_cv); 3275 ibcm_ar_list = new->ar_link; 3276 mutex_exit(&ibcm_svc_info_lock); 3277 kmem_free(new, sizeof (*new)); 3278 kmem_free(hdlp, sizeof (*hdlp)); 3279 status = IBT_INVALID_PARAM; 3280 if (s1 == IBT_HCA_PORT_NOT_ACTIVE) { 3281 s = "PORT DOWN"; 3282 status = IBT_HCA_PORT_NOT_ACTIVE; 3283 } else if (s1 != IBT_SUCCESS) 3284 s = "GID not found"; 3285 else if (s2 != IBT_SUCCESS) 3286 s = "PKEY not found"; 3287 else 3288 s = "CM could not find its HCA entry"; 3289 IBTF_DPRINTF_L2(cmlog, "ibt_register_ar: %s, status = %d", 3290 s, status); 3291 return (status); 3292 } 3293 mutex_exit(&ibcm_svc_info_lock); 3294 saa_handle = ibcm_get_saa_handle(hcap, cm_port.hp_port); 3295 3296 /* create service record */ 3297 srv_recp = kmem_zalloc(sizeof (*srv_recp), KM_SLEEP); 3298 srv_recp->ServiceLease = 0xFFFFFFFF; /* infinite */ 3299 srv_recp->ServiceP_Key = arp->ar_pkey; 3300 srv_recp->ServiceKey_hi = 0xDA410000ULL; /* DAPL */ 3301 srv_recp->ServiceKey_lo = 0xA7500000ULL; /* ATS */ 3302 (void) strcpy((char *)srv_recp->ServiceName, IBCM_DAPL_ATS_NAME); 3303 srv_recp->ServiceGID = arp->ar_gid; 3304 bcopy(arp->ar_data, srv_recp->ServiceData, IBCM_DAPL_ATS_NBYTES); 3305 srv_recp->ServiceID = IBCM_DAPL_ATS_SID; 3306 3307 /* insert service record into the SA */ 3308 3309 IBCM_DUMP_SERVICE_REC(srv_recp); 3310 3311 if (saa_handle != NULL) 3312 status = ibcm_write_service_record(saa_handle, srv_recp, 3313 IBMF_SAA_UPDATE); 3314 else 3315 status = IBT_HCA_PORT_NOT_ACTIVE; 3316 3317 if (status != IBT_SUCCESS) { 3318 IBTF_DPRINTF_L2(cmlog, "ibt_register_ar: sa access fails %d, " 3319 "sid %llX", status, (longlong_t)srv_recp->ServiceID); 3320 IBTF_DPRINTF_L2(cmlog, "ibt_register_ar: FAILED for gid " 3321 "%llX:%llX pkey 0x%X", (longlong_t)arp->ar_gid.gid_prefix, 3322 (longlong_t)arp->ar_gid.gid_guid, arp->ar_pkey); 3323 3324 kmem_free(srv_recp, sizeof (*srv_recp)); 3325 kmem_free(hdlp, sizeof (*hdlp)); 3326 3327 mutex_enter(&ibcm_svc_info_lock); 3328 linkp = &ibcm_ar_list; 3329 tmp = *linkp; 3330 while (tmp != NULL) { 3331 if (tmp == new) { 3332 *linkp = new->ar_link; 3333 break; 3334 } 3335 linkp = &tmp->ar_link; 3336 tmp = *linkp; 3337 } 3338 if (new->ar_waiters > 0) { 3339 new->ar_flags = IBCM_AR_FAILED; 3340 cv_broadcast(&new->ar_cv); 3341 mutex_exit(&ibcm_svc_info_lock); 3342 } else { 3343 cv_destroy(&new->ar_cv); 3344 mutex_exit(&ibcm_svc_info_lock); 3345 kmem_free(new, sizeof (*new)); 3346 } 3347 ibcm_dec_hca_acc_cnt(hcap); 3348 IBTF_DPRINTF_L2(cmlog, "ibt_register_ar: " 3349 "IBMF_SAA failed to write address record"); 3350 } else { /* SUCCESS */ 3351 uint8_t *b; 3352 3353 IBTF_DPRINTF_L3(cmlog, "ibt_register_ar: SUCCESS for gid " 3354 "%llx:%llx pkey %x", (longlong_t)arp->ar_gid.gid_prefix, 3355 (longlong_t)arp->ar_gid.gid_guid, arp->ar_pkey); 3356 b = arp->ar_data; 3357 3358 IBTF_DPRINTF_L3(cmlog, "ibt_register_ar:" 3359 " data %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", 3360 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], 3361 b[10], b[11], b[12], b[13], b[14], b[15]); 3362 mutex_enter(&ibcm_svc_info_lock); 3363 new->ar_srv_recp = srv_recp; 3364 new->ar_saa_handle = saa_handle; 3365 new->ar_port = cm_port.hp_port; 3366 new->ar_hcap = hcap; 3367 new->ar_flags = IBCM_AR_SUCCESS; 3368 if (new->ar_waiters > 0) 3369 cv_broadcast(&new->ar_cv); 3370 mutex_exit(&ibcm_svc_info_lock); 3371 ibtl_cm_change_service_cnt(ibt_hdl, 1); 3372 /* do not call ibcm_dec_hca_acc_cnt(hcap) until deregister */ 3373 } 3374 return (status); 3375 } 3376 3377 ibt_status_t 3378 ibt_deregister_ar(ibt_clnt_hdl_t ibt_hdl, ibt_ar_t *arp) 3379 { 3380 ibcm_ar_t *found; 3381 ibcm_ar_t *tmp; 3382 ibcm_ar_t **linkp; 3383 ibcm_ar_ref_t *hdlp; 3384 ibcm_ar_ref_t **hdlpp; 3385 ibt_status_t status; 3386 ibmf_saa_handle_t saa_handle; 3387 sa_service_record_t *srv_recp; 3388 uint64_t gid_ored; 3389 3390 IBTF_DPRINTF_L3(cmlog, "ibt_deregister_ar: pkey %x", arp->ar_pkey); 3391 IBTF_DPRINTF_L3(cmlog, "ibt_deregister_ar: gid %llx:%llx", 3392 (longlong_t)arp->ar_gid.gid_prefix, 3393 (longlong_t)arp->ar_gid.gid_guid); 3394 3395 /* 3396 * If P_Key is 0, but GID is not, this query is invalid. 3397 * If GID is 0, but P_Key is not, this query is invalid. 3398 */ 3399 gid_ored = arp->ar_gid.gid_guid | arp->ar_gid.gid_prefix; 3400 if ((arp->ar_pkey == 0 && gid_ored != 0ULL) || 3401 (arp->ar_pkey != 0 && gid_ored == 0ULL)) { 3402 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_ar: " 3403 "GID/P_Key is not valid"); 3404 return (IBT_INVALID_PARAM); 3405 } 3406 3407 mutex_enter(&ibcm_svc_info_lock); 3408 /* search for existing GID/pkey (there can be at most 1) */ 3409 status = ibcm_search_ar(arp, &found); 3410 if (status == IBT_INCONSISTENT_AR || status == IBT_AR_NOT_REGISTERED) { 3411 mutex_exit(&ibcm_svc_info_lock); 3412 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_ar: " 3413 "address record not found"); 3414 return (IBT_AR_NOT_REGISTERED); 3415 } 3416 ASSERT(status == IBT_SUCCESS); 3417 3418 hdlpp = &found->ar_ibt_hdl_list; 3419 hdlp = *hdlpp; 3420 while (hdlp != NULL) { 3421 if (hdlp->ar_ibt_hdl == ibt_hdl) 3422 break; 3423 hdlpp = &hdlp->ar_ref_link; 3424 hdlp = *hdlpp; 3425 } 3426 if (hdlp == NULL) { /* could not find ibt_hdl on list */ 3427 mutex_exit(&ibcm_svc_info_lock); 3428 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_ar: " 3429 "address record found, but not for this client"); 3430 return (IBT_AR_NOT_REGISTERED); 3431 } 3432 *hdlpp = hdlp->ar_ref_link; /* remove ref for this client */ 3433 if (found->ar_ibt_hdl_list == NULL && found->ar_waiters == 0) { 3434 /* last entry was removed */ 3435 found->ar_flags = IBCM_AR_INITING; /* hold off register_ar */ 3436 saa_handle = found->ar_saa_handle; 3437 srv_recp = found->ar_srv_recp; 3438 3439 /* wait if this service record is being rewritten */ 3440 while (found->ar_rewrite_state == IBCM_REWRITE_BUSY) 3441 cv_wait(&ibcm_svc_info_cv, &ibcm_svc_info_lock); 3442 mutex_exit(&ibcm_svc_info_lock); 3443 3444 /* remove service record */ 3445 status = ibcm_write_service_record(saa_handle, srv_recp, 3446 IBMF_SAA_DELETE); 3447 if (status != IBT_SUCCESS) 3448 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_ar: " 3449 "IBMF_SAA failed to delete address record"); 3450 mutex_enter(&ibcm_svc_info_lock); 3451 if (found->ar_waiters == 0) { /* still no waiters */ 3452 linkp = &ibcm_ar_list; 3453 tmp = *linkp; 3454 while (tmp != found) { 3455 linkp = &tmp->ar_link; 3456 tmp = *linkp; 3457 } 3458 *linkp = tmp->ar_link; 3459 ibcm_dec_hca_acc_cnt(found->ar_hcap); 3460 kmem_free(srv_recp, sizeof (*srv_recp)); 3461 cv_destroy(&found->ar_cv); 3462 kmem_free(found, sizeof (*found)); 3463 } else { 3464 /* add service record back in for the waiters */ 3465 mutex_exit(&ibcm_svc_info_lock); 3466 status = ibcm_write_service_record(saa_handle, srv_recp, 3467 IBMF_SAA_UPDATE); 3468 mutex_enter(&ibcm_svc_info_lock); 3469 if (status == IBT_SUCCESS) 3470 found->ar_flags = IBCM_AR_SUCCESS; 3471 else { 3472 found->ar_flags = IBCM_AR_FAILED; 3473 IBTF_DPRINTF_L2(cmlog, "ibt_deregister_ar: " 3474 "IBMF_SAA failed to write address record"); 3475 } 3476 cv_broadcast(&found->ar_cv); 3477 } 3478 } 3479 mutex_exit(&ibcm_svc_info_lock); 3480 kmem_free(hdlp, sizeof (*hdlp)); 3481 ibtl_cm_change_service_cnt(ibt_hdl, -1); 3482 return (status); 3483 } 3484 3485 ibt_status_t 3486 ibt_query_ar(ib_gid_t *sgid, ibt_ar_t *queryp, ibt_ar_t *resultp) 3487 { 3488 sa_service_record_t svcrec_req; 3489 sa_service_record_t *svcrec_resp; 3490 void *results_p; 3491 uint64_t component_mask = 0; 3492 uint64_t gid_ored; 3493 size_t length; 3494 int num_rec; 3495 int i; 3496 ibmf_saa_access_args_t access_args; 3497 ibt_status_t retval; 3498 ibtl_cm_hca_port_t cm_port; 3499 ibcm_hca_info_t *hcap; 3500 ibmf_saa_handle_t saa_handle; 3501 3502 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar(%p, %p)", queryp, resultp); 3503 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: sgid %llx:%llx", 3504 (longlong_t)sgid->gid_prefix, (longlong_t)sgid->gid_guid); 3505 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: query_pkey %x", queryp->ar_pkey); 3506 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: query_gid %llx:%llx", 3507 (longlong_t)queryp->ar_gid.gid_prefix, 3508 (longlong_t)queryp->ar_gid.gid_guid); 3509 3510 /* 3511 * If P_Key is 0, but GID is not, this query is invalid. 3512 * If GID is 0, but P_Key is not, this query is invalid. 3513 */ 3514 gid_ored = queryp->ar_gid.gid_guid | queryp->ar_gid.gid_prefix; 3515 if ((queryp->ar_pkey == 0 && gid_ored != 0ULL) || 3516 (queryp->ar_pkey != 0 && gid_ored == 0ULL)) { 3517 IBTF_DPRINTF_L2(cmlog, "ibt_query_ar: GID/P_Key is not valid"); 3518 return (IBT_INVALID_PARAM); 3519 } 3520 3521 hcap = NULL; 3522 if (ibtl_cm_get_hca_port(*sgid, 0, &cm_port) != IBT_SUCCESS || 3523 (hcap = ibcm_find_hca_entry(cm_port.hp_hca_guid)) == NULL || 3524 (saa_handle = ibcm_get_saa_handle(hcap, cm_port.hp_port)) == NULL) { 3525 if (hcap != NULL) 3526 ibcm_dec_hca_acc_cnt(hcap); 3527 IBTF_DPRINTF_L2(cmlog, "ibt_query_ar: sgid is not valid"); 3528 return (IBT_INVALID_PARAM); 3529 } 3530 3531 bzero(&svcrec_req, sizeof (svcrec_req)); 3532 3533 /* Is GID/P_Key Specified. */ 3534 if (queryp->ar_pkey != 0) { /* GID is non-zero from check above */ 3535 svcrec_req.ServiceP_Key = queryp->ar_pkey; 3536 component_mask |= SA_SR_COMPMASK_PKEY; 3537 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: P_Key %X", 3538 queryp->ar_pkey); 3539 svcrec_req.ServiceGID = queryp->ar_gid; 3540 component_mask |= SA_SR_COMPMASK_GID; 3541 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: GID %llX:%llX", 3542 (longlong_t)queryp->ar_gid.gid_prefix, 3543 (longlong_t)queryp->ar_gid.gid_guid); 3544 } 3545 3546 /* Is ServiceData Specified. */ 3547 for (i = 0; i < IBCM_DAPL_ATS_NBYTES; i++) { 3548 if (queryp->ar_data[i] != 0) { 3549 bcopy(queryp->ar_data, svcrec_req.ServiceData, 3550 IBCM_DAPL_ATS_NBYTES); 3551 component_mask |= 0xFFFF << 7; /* all 16 Data8 */ 3552 /* components */ 3553 break; 3554 } 3555 } 3556 3557 /* Service Name */ 3558 (void) strcpy((char *)svcrec_req.ServiceName, IBCM_DAPL_ATS_NAME); 3559 component_mask |= SA_SR_COMPMASK_NAME; 3560 3561 svcrec_req.ServiceID = IBCM_DAPL_ATS_SID; 3562 component_mask |= SA_SR_COMPMASK_ID; 3563 3564 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: " 3565 "Perform SA Access: Mask: 0x%X", component_mask); 3566 3567 /* 3568 * Call in SA Access retrieve routine to get Service Records. 3569 * 3570 * SA Access framework allocated memory for the "results_p". 3571 * Make sure to deallocate once we are done with the results_p. 3572 * The size of the buffer allocated will be as returned in 3573 * "length" field. 3574 */ 3575 access_args.sq_attr_id = SA_SERVICERECORD_ATTRID; 3576 access_args.sq_access_type = IBMF_SAA_RETRIEVE; 3577 access_args.sq_component_mask = component_mask; 3578 access_args.sq_template = &svcrec_req; 3579 access_args.sq_template_length = sizeof (sa_service_record_t); 3580 access_args.sq_callback = NULL; 3581 access_args.sq_callback_arg = NULL; 3582 3583 retval = ibcm_contact_sa_access(saa_handle, &access_args, &length, 3584 &results_p); 3585 3586 ibcm_dec_hca_acc_cnt(hcap); 3587 if (retval != IBT_SUCCESS) { 3588 IBTF_DPRINTF_L2(cmlog, "ibt_query_ar: SA Access Failed"); 3589 return (retval); 3590 } 3591 3592 num_rec = length / sizeof (sa_service_record_t); 3593 3594 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: " 3595 "Found %d Service Records.", num_rec); 3596 3597 /* Validate the returned number of records. */ 3598 if ((results_p != NULL) && (num_rec > 0)) { 3599 uint8_t *b; 3600 3601 /* Just return info from the first service record. */ 3602 svcrec_resp = (sa_service_record_t *)results_p; 3603 3604 /* The Service GID and Service ID */ 3605 resultp->ar_gid = svcrec_resp->ServiceGID; 3606 resultp->ar_pkey = svcrec_resp->ServiceP_Key; 3607 bcopy(svcrec_resp->ServiceData, 3608 resultp->ar_data, IBCM_DAPL_ATS_NBYTES); 3609 3610 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar: " 3611 "Found: pkey %x dgid %llX:%llX", resultp->ar_pkey, 3612 (longlong_t)resultp->ar_gid.gid_prefix, 3613 (longlong_t)resultp->ar_gid.gid_guid); 3614 b = resultp->ar_data; 3615 IBTF_DPRINTF_L3(cmlog, "ibt_query_ar:" 3616 " data %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", 3617 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], 3618 b[10], b[11], b[12], b[13], b[14], b[15]); 3619 3620 /* Deallocate the memory for results_p. */ 3621 kmem_free(results_p, length); 3622 if (num_rec > 1) 3623 retval = IBT_MULTIPLE_AR; 3624 else 3625 retval = IBT_SUCCESS; 3626 } else { 3627 IBTF_DPRINTF_L2(cmlog, "ibt_query_ar: " 3628 "ibmf_sa_access found 0 matching records"); 3629 retval = IBT_AR_NOT_REGISTERED; 3630 } 3631 return (retval); 3632 } 3633 3634 /* mark all ATS service records associated with the port */ 3635 static void 3636 ibcm_mark_ar(ib_guid_t hca_guid, uint8_t port) 3637 { 3638 ibcm_ar_t *tmp; 3639 3640 ASSERT(MUTEX_HELD(&ibcm_svc_info_lock)); 3641 for (tmp = ibcm_ar_list; tmp != NULL; tmp = tmp->ar_link) { 3642 if (tmp->ar_hcap == NULL) 3643 continue; 3644 if (tmp->ar_hcap->hca_guid == hca_guid && 3645 tmp->ar_port == port) { 3646 /* even if it's busy, we mark it for rewrite */ 3647 tmp->ar_rewrite_state = IBCM_REWRITE_NEEDED; 3648 } 3649 } 3650 } 3651 3652 /* rewrite all ATS service records */ 3653 static int 3654 ibcm_rewrite_ar(void) 3655 { 3656 ibcm_ar_t *tmp; 3657 ibmf_saa_handle_t saa_handle; 3658 sa_service_record_t *srv_recp; 3659 ibt_status_t rval; 3660 int did_something = 0; 3661 3662 ASSERT(MUTEX_HELD(&ibcm_svc_info_lock)); 3663 check_for_work: 3664 for (tmp = ibcm_ar_list; tmp != NULL; tmp = tmp->ar_link) { 3665 if (tmp->ar_rewrite_state == IBCM_REWRITE_NEEDED) { 3666 tmp->ar_rewrite_state = IBCM_REWRITE_BUSY; 3667 saa_handle = tmp->ar_saa_handle; 3668 srv_recp = tmp->ar_srv_recp; 3669 mutex_exit(&ibcm_svc_info_lock); 3670 IBTF_DPRINTF_L3(cmlog, "ibcm_rewrite_ar: " 3671 "rewriting ar @ %p", tmp); 3672 did_something = 1; 3673 rval = ibcm_write_service_record(saa_handle, srv_recp, 3674 IBMF_SAA_UPDATE); 3675 if (rval != IBT_SUCCESS) 3676 IBTF_DPRINTF_L2(cmlog, "ibcm_rewrite_ar: " 3677 "ibcm_write_service_record failed: " 3678 "status = %d", rval); 3679 mutex_enter(&ibcm_svc_info_lock); 3680 /* if it got marked again, then we want to rewrite */ 3681 if (tmp->ar_rewrite_state == IBCM_REWRITE_BUSY) 3682 tmp->ar_rewrite_state = IBCM_REWRITE_IDLE; 3683 /* in case there was a waiter... */ 3684 cv_broadcast(&ibcm_svc_info_cv); 3685 goto check_for_work; 3686 } 3687 } 3688 return (did_something); 3689 } 3690 3691 static void 3692 ibcm_rewrite_svc_record(ibcm_svc_info_t *srv_hdl, ibcm_svc_bind_t *sbindp) 3693 { 3694 ibcm_hca_info_t *hcap; 3695 ib_svc_id_t sid, start_sid, end_sid; 3696 ibmf_saa_handle_t saa_handle; 3697 sa_service_record_t srv_rec; 3698 ibt_status_t rval; 3699 3700 hcap = ibcm_find_hca_entry(sbindp->sbind_hcaguid); 3701 if (hcap == NULL) { 3702 IBTF_DPRINTF_L2(cmlog, "ibcm_rewrite_svc_record: " 3703 "NO HCA found for HCA GUID %llX", sbindp->sbind_hcaguid); 3704 return; 3705 } 3706 3707 saa_handle = ibcm_get_saa_handle(hcap, sbindp->sbind_port); 3708 if (saa_handle == NULL) { 3709 IBTF_DPRINTF_L2(cmlog, "ibcm_rewrite_svc_record: " 3710 "saa_handle is NULL"); 3711 ibcm_dec_hca_acc_cnt(hcap); 3712 return; 3713 } 3714 3715 IBTF_DPRINTF_L3(cmlog, "ibcm_rewrite_svc_record: " 3716 "rewriting svc '%s', port_guid = %llX", sbindp->sbind_name, 3717 sbindp->sbind_gid.gid_guid); 3718 3719 bzero(&srv_rec, sizeof (srv_rec)); 3720 3721 srv_rec.ServiceLease = sbindp->sbind_lease; 3722 srv_rec.ServiceP_Key = sbindp->sbind_pkey; 3723 srv_rec.ServiceKey_hi = sbindp->sbind_key[0]; 3724 srv_rec.ServiceKey_lo = sbindp->sbind_key[1]; 3725 (void) strcpy((char *)srv_rec.ServiceName, sbindp->sbind_name); 3726 srv_rec.ServiceGID = sbindp->sbind_gid; 3727 3728 bcopy(sbindp->sbind_data, srv_rec.ServiceData, IB_SVC_DATA_LEN); 3729 3730 /* insert srv record into the SA */ 3731 start_sid = srv_hdl->svc_id; 3732 end_sid = start_sid + srv_hdl->svc_num_sids - 1; 3733 for (sid = start_sid; sid <= end_sid; sid++) { 3734 srv_rec.ServiceID = sid; 3735 3736 rval = ibcm_write_service_record(saa_handle, &srv_rec, 3737 IBMF_SAA_UPDATE); 3738 3739 IBTF_DPRINTF_L4(cmlog, "ibcm_rewrite_svc_record: " 3740 "ibcm_write_service_record, SvcId = %llX, " 3741 "rval = %d", (longlong_t)sid, rval); 3742 if (rval != IBT_SUCCESS) { 3743 IBTF_DPRINTF_L2(cmlog, "ibcm_rewrite_svc_record:" 3744 " ibcm_write_service_record fails %d sid %llX", 3745 rval, (longlong_t)sid); 3746 } 3747 } 3748 ibcm_dec_hca_acc_cnt(hcap); 3749 } 3750 3751 /* 3752 * Task to mark all service records as needing to be rewritten to the SM/SA. 3753 * This task does not return until all of them have been rewritten. 3754 */ 3755 void 3756 ibcm_service_record_rewrite_task(void *arg) 3757 { 3758 ibcm_port_up_t *pup = (ibcm_port_up_t *)arg; 3759 ib_guid_t hca_guid = pup->pup_hca_guid; 3760 uint8_t port = pup->pup_port; 3761 ibcm_svc_info_t *svcp; 3762 ibcm_svc_bind_t *sbp; 3763 avl_tree_t *avl_tree = &ibcm_svc_avl_tree; 3764 static int task_is_running = 0; 3765 3766 IBTF_DPRINTF_L3(cmlog, "ibcm_service_record_rewrite_task STARTED " 3767 "for hca_guid %llX, port %d", hca_guid, port); 3768 3769 mutex_enter(&ibcm_svc_info_lock); 3770 ibcm_mark_ar(hca_guid, port); 3771 for (svcp = avl_first(avl_tree); svcp != NULL; 3772 svcp = avl_walk(avl_tree, svcp, AVL_AFTER)) { 3773 sbp = svcp->svc_bind_list; 3774 while (sbp != NULL) { 3775 if (sbp->sbind_pkey != 0 && 3776 sbp->sbind_port == port && 3777 sbp->sbind_hcaguid == hca_guid) { 3778 /* even if it's busy, we mark it for rewrite */ 3779 sbp->sbind_rewrite_state = IBCM_REWRITE_NEEDED; 3780 } 3781 sbp = sbp->sbind_link; 3782 } 3783 } 3784 if (task_is_running) { 3785 /* let the other task thread finish the work */ 3786 mutex_exit(&ibcm_svc_info_lock); 3787 return; 3788 } 3789 task_is_running = 1; 3790 3791 (void) ibcm_rewrite_ar(); 3792 3793 check_for_work: 3794 for (svcp = avl_first(avl_tree); svcp != NULL; 3795 svcp = avl_walk(avl_tree, svcp, AVL_AFTER)) { 3796 sbp = svcp->svc_bind_list; 3797 while (sbp != NULL) { 3798 if (sbp->sbind_rewrite_state == IBCM_REWRITE_NEEDED) { 3799 sbp->sbind_rewrite_state = IBCM_REWRITE_BUSY; 3800 mutex_exit(&ibcm_svc_info_lock); 3801 ibcm_rewrite_svc_record(svcp, sbp); 3802 mutex_enter(&ibcm_svc_info_lock); 3803 /* if it got marked again, we want to rewrite */ 3804 if (sbp->sbind_rewrite_state == 3805 IBCM_REWRITE_BUSY) 3806 sbp->sbind_rewrite_state = 3807 IBCM_REWRITE_IDLE; 3808 /* in case there was a waiter... */ 3809 cv_broadcast(&ibcm_svc_info_cv); 3810 goto check_for_work; 3811 } 3812 sbp = sbp->sbind_link; 3813 } 3814 } 3815 /* 3816 * If there were no service records to write, and we failed to 3817 * have to rewrite any more ATS service records, then we're done. 3818 */ 3819 if (ibcm_rewrite_ar() != 0) 3820 goto check_for_work; 3821 task_is_running = 0; 3822 mutex_exit(&ibcm_svc_info_lock); 3823 3824 IBTF_DPRINTF_L3(cmlog, "ibcm_service_record_rewrite_task DONE"); 3825 kmem_free(pup, sizeof (ibcm_port_up_t)); 3826 } 3827 3828 ibt_status_t 3829 ibt_ofuvcm_get_req_data(void *session_id, ibt_ofuvcm_req_data_t *req_data) 3830 { 3831 ibcm_state_data_t *statep = (ibcm_state_data_t *)session_id; 3832 ibcm_req_msg_t *req_msgp; 3833 3834 IBTF_DPRINTF_L3(cmlog, "ibt_get_ofuvcm_req_data: session_id %p", 3835 session_id); 3836 mutex_enter(&statep->state_mutex); 3837 if ((statep->state != IBCM_STATE_REQ_RCVD) && 3838 (statep->state != IBCM_STATE_MRA_SENT)) { 3839 IBTF_DPRINTF_L2(cmlog, "ibt_get_ofuvcm_req_data: Invalid " 3840 "State %x", statep->state); 3841 mutex_exit(&statep->state_mutex); 3842 return (IBT_CHAN_STATE_INVALID); 3843 } 3844 if (statep->mode == IBCM_ACTIVE_MODE) { 3845 IBTF_DPRINTF_L2(cmlog, "ibt_get_ofuvcm_req_data: Active mode " 3846 "not supported"); 3847 mutex_exit(&statep->state_mutex); 3848 return (IBT_INVALID_PARAM); 3849 } 3850 ASSERT(statep->req_msgp); 3851 3852 /* 3853 * Fill in the additional req message values reqired for 3854 * RTR transition. 3855 * Should the PSN be same as the active side?? 3856 */ 3857 req_msgp = (ibcm_req_msg_t *)statep->req_msgp; 3858 req_data->req_rnr_nak_time = ibcm_default_rnr_nak_time; 3859 req_data->req_path_mtu = req_msgp->req_mtu_plus >> 4; 3860 req_data->req_rq_psn = b2h32(req_msgp->req_starting_psn_plus) >> 8; 3861 mutex_exit(&statep->state_mutex); 3862 return (IBT_SUCCESS); 3863 } 3864 3865 ibt_status_t 3866 ibt_ofuvcm_proceed(ibt_cm_event_type_t event, void *session_id, 3867 ibt_cm_status_t status, ibt_cm_proceed_reply_t *cm_event_data, 3868 void *priv_data, ibt_priv_data_len_t priv_data_len) 3869 { 3870 ibcm_state_data_t *statep = (ibcm_state_data_t *)session_id; 3871 ibt_status_t ret; 3872 3873 IBTF_DPRINTF_L3(cmlog, "ibt_ofuvcm_proceed chan 0x%p event %x " 3874 "status %x session_id %p", statep->channel, event, status, 3875 session_id); 3876 3877 IBTF_DPRINTF_L5(cmlog, "ibt_ofuvcm_proceed chan 0x%p " 3878 "cm_event_data %p, priv_data %p priv_data_len %x", 3879 statep->channel, cm_event_data, priv_data, priv_data_len); 3880 3881 /* validate session_id and status */ 3882 if ((statep == NULL) || (status == IBT_CM_DEFER)) { 3883 IBTF_DPRINTF_L2(cmlog, "ibt_ofuvcm_proceed : Invalid Args"); 3884 return (IBT_INVALID_PARAM); 3885 } 3886 3887 if (event != IBT_CM_EVENT_REQ_RCV) { 3888 IBTF_DPRINTF_L2(cmlog, "ibt_ofuvcm_proceed : only for REQ_RCV"); 3889 return (IBT_INVALID_PARAM); 3890 } 3891 mutex_enter(&statep->state_mutex); 3892 statep->is_this_ofuv_chan = B_TRUE; 3893 mutex_exit(&statep->state_mutex); 3894 3895 ret = ibt_cm_proceed(event, session_id, status, cm_event_data, 3896 priv_data, priv_data_len); 3897 return (ret); 3898 } 3899 3900 /* 3901 * Function: 3902 * ibt_cm_proceed 3903 * 3904 * Verifies the arguments and dispatches the cm state machine processing 3905 * via taskq 3906 */ 3907 3908 ibt_status_t 3909 ibt_cm_proceed(ibt_cm_event_type_t event, void *session_id, 3910 ibt_cm_status_t status, ibt_cm_proceed_reply_t *cm_event_data, 3911 void *priv_data, ibt_priv_data_len_t priv_data_len) 3912 { 3913 ibcm_state_data_t *statep = (ibcm_state_data_t *)session_id; 3914 ibcm_proceed_targs_t *proceed_targs; 3915 ibcm_proceed_error_t proceed_error; 3916 3917 IBTF_DPRINTF_L3(cmlog, "ibt_cm_proceed chan 0x%p event %x status %x " 3918 "session_id %p", statep->channel, event, status, session_id); 3919 3920 IBTF_DPRINTF_L5(cmlog, "ibt_cm_proceed chan 0x%p cm_event_data %p, " 3921 "priv_data %p priv_data_len %x", statep->channel, cm_event_data, 3922 priv_data, priv_data_len); 3923 3924 /* validate session_id and status */ 3925 if ((statep == NULL) || (status == IBT_CM_DEFER)) { 3926 IBTF_DPRINTF_L2(cmlog, "ibt_cm_proceed : Invalid Args"); 3927 return (IBT_INVALID_PARAM); 3928 } 3929 3930 /* If priv data len specified, then priv_data cannot be NULL */ 3931 if ((priv_data_len > 0) && (priv_data == NULL)) 3932 return (IBT_INVALID_PARAM); 3933 3934 proceed_error = IBCM_PROCEED_INVALID_NONE; 3935 3936 mutex_enter(&statep->state_mutex); 3937 if (event == IBT_CM_EVENT_REQ_RCV) { 3938 3939 if ((statep->state != IBCM_STATE_REQ_RCVD) && 3940 (statep->state != IBCM_STATE_MRA_SENT)) 3941 proceed_error = IBCM_PROCEED_INVALID_EVENT_STATE; 3942 else if (priv_data_len > IBT_REP_PRIV_DATA_SZ) 3943 proceed_error = IBCM_PROCEED_INVALID_PRIV_SZ; 3944 3945 } else if (event == IBT_CM_EVENT_REP_RCV) { 3946 if ((statep->state != IBCM_STATE_REP_RCVD) && 3947 (statep->state != IBCM_STATE_MRA_REP_SENT)) 3948 proceed_error = IBCM_PROCEED_INVALID_EVENT_STATE; 3949 else if (priv_data_len > IBT_RTU_PRIV_DATA_SZ) 3950 proceed_error = IBCM_PROCEED_INVALID_PRIV_SZ; 3951 } else if (event == IBT_CM_EVENT_LAP_RCV) { 3952 if ((statep->ap_state != IBCM_AP_STATE_LAP_RCVD) && 3953 (statep->ap_state != IBCM_AP_STATE_MRA_LAP_SENT)) 3954 proceed_error = IBCM_PROCEED_INVALID_EVENT_STATE; 3955 else if (priv_data_len > IBT_APR_PRIV_DATA_SZ) 3956 proceed_error = IBCM_PROCEED_INVALID_PRIV_SZ; 3957 } else if (event == IBT_CM_EVENT_CONN_CLOSED) { 3958 if (statep->state != IBCM_STATE_DREQ_RCVD) 3959 proceed_error = IBCM_PROCEED_INVALID_EVENT_STATE; 3960 else if (priv_data_len > IBT_DREP_PRIV_DATA_SZ) 3961 proceed_error = IBCM_PROCEED_INVALID_PRIV_SZ; 3962 } else { 3963 proceed_error = IBCM_PROCEED_INVALID_EVENT; 3964 } 3965 3966 /* if there is an error, print an error message and return */ 3967 if (proceed_error != IBCM_PROCEED_INVALID_NONE) { 3968 mutex_exit(&statep->state_mutex); 3969 if (proceed_error == IBCM_PROCEED_INVALID_EVENT_STATE) { 3970 IBTF_DPRINTF_L2(cmlog, "ibt_cm_proceed : chan 0x%p" 3971 "Invalid Event/State combination specified", 3972 statep->channel); 3973 return (IBT_INVALID_PARAM); 3974 } else if (proceed_error == IBCM_PROCEED_INVALID_PRIV_SZ) { 3975 IBTF_DPRINTF_L2(cmlog, "ibt_cm_proceed : chan 0x%p" 3976 "Invalid Event/priv len combination specified", 3977 statep->channel); 3978 return (IBT_INVALID_PARAM); 3979 } else if (proceed_error == IBCM_PROCEED_INVALID_EVENT) { 3980 IBTF_DPRINTF_L2(cmlog, "ibt_cm_proceed : chan 0x%p" 3981 "Invalid Event specified", statep->channel); 3982 return (IBT_INVALID_PARAM); 3983 } else { 3984 ASSERT(proceed_error == IBCM_PROCEED_INVALID_LAP); 3985 IBTF_DPRINTF_L2(cmlog, "ibt_cm_proceed : chan 0x%p" 3986 "IBT_CM_EVENT_LAP_RCV not supported", 3987 statep->channel); 3988 /* UNTIL HCA DRIVER ENABLES AP SUPPORT, FAIL THE CALL */ 3989 return (IBT_APM_NOT_SUPPORTED); 3990 } 3991 } 3992 3993 3994 /* wait until client's CM handler returns DEFER status back to CM */ 3995 3996 while (statep->clnt_proceed == IBCM_BLOCK) { 3997 IBTF_DPRINTF_L5(cmlog, "ibt_cm_proceed : chan 0x%p blocked for " 3998 "return of client's cm handler", statep->channel); 3999 cv_wait(&statep->block_client_cv, &statep->state_mutex); 4000 } 4001 4002 if (statep->clnt_proceed == IBCM_FAIL) { 4003 mutex_exit(&statep->state_mutex); 4004 IBTF_DPRINTF_L2(cmlog, "ibt_cm_proceed : chan 0x%p Failed as " 4005 "client returned non-DEFER status from cm handler", 4006 statep->channel); 4007 return (IBT_CHAN_STATE_INVALID); 4008 } 4009 4010 ASSERT(statep->clnt_proceed == IBCM_UNBLOCK); 4011 statep->clnt_proceed = IBCM_FAIL; 4012 mutex_exit(&statep->state_mutex); 4013 4014 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*proceed_targs)) 4015 4016 /* the state machine processing is done in a separate thread */ 4017 4018 /* proceed_targs is freed in ibcm_proceed_via_taskq */ 4019 proceed_targs = kmem_alloc(sizeof (ibcm_proceed_targs_t), 4020 KM_SLEEP); 4021 4022 proceed_targs->event = event; 4023 proceed_targs->status = status; 4024 proceed_targs->priv_data_len = priv_data_len; 4025 4026 bcopy(priv_data, proceed_targs->priv_data, priv_data_len); 4027 4028 proceed_targs->tst.rc.statep = statep; 4029 bcopy(cm_event_data, &proceed_targs->tst.rc.rc_cm_event_data, 4030 sizeof (ibt_cm_proceed_reply_t)); 4031 4032 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*proceed_targs)) 4033 4034 (void) taskq_dispatch(ibcm_taskq, ibcm_proceed_via_taskq, 4035 proceed_targs, TQ_SLEEP); 4036 4037 return (IBT_SUCCESS); 4038 } 4039 4040 /* 4041 * Function: 4042 * ibcm_proceed_via_taskq 4043 * 4044 * Called from taskq, dispatched by ibt_cm_proceed 4045 * Completes the cm state processing for ibt_cm_proceed 4046 */ 4047 void 4048 ibcm_proceed_via_taskq(void *targs) 4049 { 4050 ibcm_proceed_targs_t *proceed_targs = (ibcm_proceed_targs_t *)targs; 4051 ibcm_state_data_t *statep = proceed_targs->tst.rc.statep; 4052 ibt_cm_reason_t reject_reason; 4053 uint8_t arej_len; 4054 ibcm_status_t response; 4055 ibcm_clnt_reply_info_t clnt_info; 4056 4057 clnt_info.reply_event = &proceed_targs->tst.rc.rc_cm_event_data; 4058 clnt_info.priv_data = proceed_targs->priv_data; 4059 clnt_info.priv_data_len = proceed_targs->priv_data_len; 4060 4061 IBTF_DPRINTF_L4(cmlog, "ibcm_proceed_via_taskq chan 0x%p targs %x", 4062 statep->channel, targs); 4063 4064 if (proceed_targs->event == IBT_CM_EVENT_REQ_RCV) { 4065 response = 4066 ibcm_process_cep_req_cm_hdlr(statep, proceed_targs->status, 4067 &clnt_info, &reject_reason, &arej_len, 4068 (ibcm_req_msg_t *)statep->defer_cm_msg); 4069 4070 ibcm_handle_cep_req_response(statep, response, reject_reason, 4071 arej_len); 4072 4073 } else if (proceed_targs->event == IBT_CM_EVENT_REP_RCV) { 4074 response = 4075 ibcm_process_cep_rep_cm_hdlr(statep, proceed_targs->status, 4076 &clnt_info, &reject_reason, &arej_len, 4077 (ibcm_rep_msg_t *)statep->defer_cm_msg); 4078 4079 ibcm_handle_cep_rep_response(statep, response, reject_reason, 4080 arej_len, (ibcm_rep_msg_t *)statep->defer_cm_msg); 4081 4082 } else if (proceed_targs->event == IBT_CM_EVENT_LAP_RCV) { 4083 ibcm_process_cep_lap_cm_hdlr(statep, proceed_targs->status, 4084 &clnt_info, (ibcm_lap_msg_t *)statep->defer_cm_msg, 4085 (ibcm_apr_msg_t *)IBCM_OUT_MSGP(statep->lapr_msg)); 4086 4087 ibcm_post_apr_mad(statep); 4088 4089 } else { 4090 ASSERT(proceed_targs->event == IBT_CM_EVENT_CONN_CLOSED); 4091 ibcm_handle_cep_dreq_response(statep, proceed_targs->priv_data, 4092 proceed_targs->priv_data_len); 4093 } 4094 4095 kmem_free(targs, sizeof (ibcm_proceed_targs_t)); 4096 } 4097 4098 /* 4099 * Function: 4100 * ibt_cm_ud_proceed 4101 * 4102 * Verifies the arguments and dispatches the cm state machine processing 4103 * via taskq 4104 */ 4105 ibt_status_t 4106 ibt_cm_ud_proceed(void *session_id, ibt_channel_hdl_t ud_channel, 4107 ibt_cm_status_t status, ibt_redirect_info_t *redirect_infop, 4108 void *priv_data, ibt_priv_data_len_t priv_data_len) 4109 { 4110 ibcm_ud_state_data_t *ud_statep = (ibcm_ud_state_data_t *)session_id; 4111 ibcm_proceed_targs_t *proceed_targs; 4112 ibt_qp_query_attr_t qp_attr; 4113 ibt_status_t retval; 4114 4115 IBTF_DPRINTF_L3(cmlog, "ibt_cm_ud_proceed session_id %p " 4116 "ud_channel %p ", session_id, ud_channel); 4117 4118 IBTF_DPRINTF_L4(cmlog, "ibt_cm_ud_proceed status %x priv_data %p " 4119 "priv_data_len %x", status, priv_data, priv_data_len); 4120 4121 /* validate session_id and status */ 4122 if ((ud_statep == NULL) || (status == IBT_CM_DEFER)) { 4123 IBTF_DPRINTF_L2(cmlog, "ibt_cm_ud_proceed : Invalid Args"); 4124 return (IBT_INVALID_PARAM); 4125 } 4126 4127 /* If priv data len specified, then priv_data cannot be NULL */ 4128 if ((priv_data_len > 0) && (priv_data == NULL)) 4129 return (IBT_INVALID_PARAM); 4130 4131 if (priv_data_len > IBT_SIDR_REP_PRIV_DATA_SZ) 4132 return (IBT_INVALID_PARAM); 4133 4134 /* retrieve qpn and qkey from ud channel */ 4135 4136 /* validate event and statep's state */ 4137 4138 if (status == IBT_CM_ACCEPT) { 4139 retval = ibt_query_qp(ud_channel, &qp_attr); 4140 if ((retval != IBT_SUCCESS) || 4141 (qp_attr.qp_info.qp_trans != IBT_UD_SRV)) { 4142 IBTF_DPRINTF_L2(cmlog, "ibt_cm_ud_proceed: " 4143 "Failed to retrieve QPN from the channel: %d", 4144 retval); 4145 return (IBT_INVALID_PARAM); 4146 } 4147 } 4148 4149 4150 mutex_enter(&ud_statep->ud_state_mutex); 4151 4152 if (ud_statep->ud_state != IBCM_STATE_SIDR_REQ_RCVD) { 4153 mutex_exit(&ud_statep->ud_state_mutex); 4154 IBTF_DPRINTF_L2(cmlog, "ibt_cm_ud_proceed : Invalid State " 4155 "specified"); 4156 return (IBT_INVALID_PARAM); 4157 } 4158 4159 /* wait until client's CM handler returns DEFER status back to CM */ 4160 4161 while (ud_statep->ud_clnt_proceed == IBCM_BLOCK) { 4162 IBTF_DPRINTF_L5(cmlog, "ibt_cm_ud_proceed : Blocked for return" 4163 " of client's ud cm handler"); 4164 cv_wait(&ud_statep->ud_block_client_cv, 4165 &ud_statep->ud_state_mutex); 4166 } 4167 4168 if (ud_statep->ud_clnt_proceed == IBCM_FAIL) { 4169 mutex_exit(&ud_statep->ud_state_mutex); 4170 IBTF_DPRINTF_L2(cmlog, "ibt_cm_ud_proceed : Failed as client " 4171 "returned non-DEFER status from cm handler"); 4172 return (IBT_INVALID_PARAM); 4173 } 4174 4175 ASSERT(ud_statep->ud_clnt_proceed == IBCM_UNBLOCK); 4176 ud_statep->ud_clnt_proceed = IBCM_FAIL; 4177 mutex_exit(&ud_statep->ud_state_mutex); 4178 4179 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*proceed_targs)) 4180 4181 /* the state machine processing is done in a separate thread */ 4182 4183 /* proceed_targs is freed in ibcm_proceed_via_taskq */ 4184 proceed_targs = kmem_zalloc(sizeof (ibcm_proceed_targs_t), 4185 KM_SLEEP); 4186 4187 proceed_targs->status = status; 4188 proceed_targs->priv_data_len = priv_data_len; 4189 4190 bcopy(priv_data, proceed_targs->priv_data, priv_data_len); 4191 4192 if (status == IBT_CM_ACCEPT) { 4193 proceed_targs->tst.ud.ud_qkey = 4194 qp_attr.qp_info.qp_transport.ud.ud_qkey; 4195 proceed_targs->tst.ud.ud_qpn = qp_attr.qp_qpn; 4196 } 4197 4198 proceed_targs->tst.ud.ud_statep = ud_statep; 4199 4200 /* copy redirect info based on status */ 4201 if (status == IBT_CM_REDIRECT) 4202 bcopy(redirect_infop, &proceed_targs->tst.ud.ud_redirect_info, 4203 sizeof (ibt_redirect_info_t)); 4204 4205 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*proceed_targs)) 4206 4207 (void) taskq_dispatch(ibcm_taskq, ibcm_ud_proceed_via_taskq, 4208 proceed_targs, TQ_SLEEP); 4209 4210 return (IBT_SUCCESS); 4211 } 4212 4213 /* 4214 * Function: 4215 * ibcm_ud_proceed_via_taskq 4216 * 4217 * Called from taskq, dispatched by ibt_cm_ud_proceed 4218 * Completes the cm state processing for ibt_cm_ud_proceed 4219 */ 4220 void 4221 ibcm_ud_proceed_via_taskq(void *targs) 4222 { 4223 ibcm_proceed_targs_t *proceed_targs = (ibcm_proceed_targs_t *)targs; 4224 ibcm_ud_state_data_t *ud_statep = proceed_targs->tst.ud.ud_statep; 4225 ibcm_ud_clnt_reply_info_t ud_clnt_info; 4226 ibt_sidr_status_t sidr_status; 4227 4228 IBTF_DPRINTF_L4(cmlog, "ibcm_ud_proceed_via_taskq(%p)", targs); 4229 4230 ud_clnt_info.ud_qpn = proceed_targs->tst.ud.ud_qpn; 4231 ud_clnt_info.ud_qkey = proceed_targs->tst.ud.ud_qkey; 4232 ud_clnt_info.priv_data = proceed_targs->priv_data; 4233 ud_clnt_info.priv_data_len = proceed_targs->priv_data_len; 4234 ud_clnt_info.redirect_infop = &proceed_targs->tst.ud.ud_redirect_info; 4235 4236 /* validate event and statep's state */ 4237 ibcm_process_sidr_req_cm_hdlr(ud_statep, proceed_targs->status, 4238 &ud_clnt_info, &sidr_status, 4239 (ibcm_sidr_rep_msg_t *)IBCM_OUT_MSGP(ud_statep->ud_stored_msg)); 4240 4241 ibcm_post_sidr_rep_mad(ud_statep, sidr_status); 4242 4243 /* decr the statep ref cnt incremented in ibcm_process_sidr_req_msg */ 4244 mutex_enter(&ud_statep->ud_state_mutex); 4245 IBCM_UD_REF_CNT_DECR(ud_statep); 4246 mutex_exit(&ud_statep->ud_state_mutex); 4247 4248 kmem_free(targs, sizeof (ibcm_proceed_targs_t)); 4249 } 4250 4251 /* 4252 * Function: 4253 * ibt_set_alt_path 4254 * Input: 4255 * channel Channel handle returned from ibt_alloc_rc_channel(9F). 4256 * 4257 * mode Execute in blocking or non blocking mode. 4258 * 4259 * alt_path A pointer to an ibt_alt_path_info_t as returned from an 4260 * ibt_get_alt_path(9F) call that specifies the new 4261 * alternate path. 4262 * 4263 * priv_data A pointer to a buffer specified by caller for the 4264 * private data in the outgoing CM Load Alternate Path 4265 * (LAP) message sent to the remote host. This can be NULL 4266 * if no private data is available to communicate to the 4267 * remote node. 4268 * 4269 * priv_data_len Length of valid data in priv_data, this should be less 4270 * than or equal to IBT_LAP_PRIV_DATA_SZ. 4271 * 4272 * Output: 4273 * ret_args If called in blocking mode, points to a return argument 4274 * structure of type ibt_ap_returns_t. 4275 * 4276 * Returns: 4277 * IBT_SUCCESS on Success else appropriate error. 4278 * Description: 4279 * Load the specified alternate path. Causes the CM to send an LAP message 4280 * to the remote node. 4281 * Can only be called on a previously opened RC channel. 4282 */ 4283 ibt_status_t 4284 ibt_set_alt_path(ibt_channel_hdl_t channel, ibt_execution_mode_t mode, 4285 ibt_alt_path_info_t *alt_path, void *priv_data, 4286 ibt_priv_data_len_t priv_data_len, ibt_ap_returns_t *ret_args) 4287 { 4288 ibmf_handle_t ibmf_hdl; 4289 ibt_status_t status = IBT_SUCCESS; 4290 ibcm_lap_msg_t *lap_msgp; 4291 ibcm_hca_info_t *hcap; 4292 ibcm_state_data_t *statep; 4293 uint8_t port_no; 4294 ib_lid_t alternate_slid; 4295 ibt_priv_data_len_t len; 4296 ib_lid_t base_lid; 4297 boolean_t alt_grh; 4298 4299 IBTF_DPRINTF_L3(cmlog, "ibt_set_alt_path(%p, %x, %p, %p, %x, %p)", 4300 channel, mode, alt_path, priv_data, priv_data_len, ret_args); 4301 4302 /* validate channel */ 4303 if (IBCM_INVALID_CHANNEL(channel)) { 4304 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: invalid channel"); 4305 return (IBT_CHAN_HDL_INVALID); 4306 } 4307 4308 if (ibtl_cm_get_chan_type(channel) != IBT_RC_SRV) { 4309 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4310 "Invalid Channel type: Applicable only to RC Channel"); 4311 return (IBT_CHAN_SRV_TYPE_INVALID); 4312 } 4313 4314 if (mode == IBT_NONBLOCKING) { 4315 if (ret_args != NULL) { 4316 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4317 "ret_args should be NULL when called in " 4318 "non-blocking mode"); 4319 return (IBT_INVALID_PARAM); 4320 } 4321 } else if (mode == IBT_BLOCKING) { 4322 if (ret_args == NULL) { 4323 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4324 "ret_args should be Non-NULL when called in " 4325 "blocking mode"); 4326 return (IBT_INVALID_PARAM); 4327 } 4328 if (ret_args->ap_priv_data_len > IBT_APR_PRIV_DATA_SZ) { 4329 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4330 "expected private data length is too large"); 4331 return (IBT_INVALID_PARAM); 4332 } 4333 if ((ret_args->ap_priv_data_len > 0) && 4334 (ret_args->ap_priv_data == NULL)) { 4335 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4336 "apr_priv_data_len > 0, but apr_priv_data NULL"); 4337 return (IBT_INVALID_PARAM); 4338 } 4339 } else { /* any other mode is not valid for ibt_set_alt_path */ 4340 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4341 "invalid mode %x specified", mode); 4342 return (IBT_INVALID_PARAM); 4343 } 4344 4345 if ((port_no = alt_path->ap_alt_cep_path.cep_hca_port_num) == 0) 4346 return (IBT_INVALID_PARAM); 4347 4348 /* get the statep */ 4349 IBCM_GET_CHAN_PRIVATE(channel, statep); 4350 if (statep == NULL) { 4351 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: statep NULL"); 4352 return (IBT_CM_FAILURE); 4353 } 4354 4355 mutex_enter(&statep->state_mutex); 4356 IBCM_RELEASE_CHAN_PRIVATE(channel); 4357 IBCM_REF_CNT_INCR(statep); 4358 mutex_exit(&statep->state_mutex); 4359 4360 IBTF_DPRINTF_L4(cmlog, "ibt_set_alt_path: statep %p", statep); 4361 4362 hcap = statep->hcap; 4363 4364 /* HCA must have been in active state. If not, it's a client bug */ 4365 if (!IBCM_ACCESS_HCA_OK(hcap)) 4366 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: hca in error state"); 4367 4368 ASSERT(statep->cm_handler != NULL); 4369 4370 /* Check Alternate port */ 4371 status = ibt_get_port_state_byguid(hcap->hca_guid, port_no, NULL, 4372 &base_lid); 4373 if (status != IBT_SUCCESS) { 4374 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4375 "ibt_get_port_state_byguid status %d ", status); 4376 mutex_enter(&statep->state_mutex); 4377 IBCM_REF_CNT_DECR(statep); 4378 mutex_exit(&statep->state_mutex); 4379 return (status); 4380 } 4381 4382 if ((hcap->hca_port_info[port_no - 1].port_ibmf_hdl == NULL) && 4383 ((status = ibcm_hca_reinit_port(hcap, port_no - 1)) 4384 != IBT_SUCCESS)) { 4385 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4386 "ibmf reg or callback setup failed during re-initialize"); 4387 mutex_enter(&statep->state_mutex); 4388 IBCM_REF_CNT_DECR(statep); 4389 mutex_exit(&statep->state_mutex); 4390 return (status); 4391 } 4392 4393 ibmf_hdl = statep->stored_reply_addr.ibmf_hdl; 4394 4395 alternate_slid = base_lid + 4396 alt_path->ap_alt_cep_path.cep_adds_vect.av_src_path; 4397 4398 IBTF_DPRINTF_L4(cmlog, "ibt_set_alt_path: alternate SLID = %x", 4399 h2b16(alternate_slid)); 4400 4401 ibcm_lapr_enter(); /* limit how many run simultaneously */ 4402 4403 /* Allocate MAD for LAP */ 4404 if (statep->lapr_msg == NULL) 4405 if ((status = ibcm_alloc_out_msg(ibmf_hdl, &statep->lapr_msg, 4406 MAD_METHOD_SEND)) != IBT_SUCCESS) { 4407 ibcm_lapr_exit(); 4408 IBTF_DPRINTF_L2(cmlog, "ibt_set_alt_path: " 4409 "chan 0x%p ibcm_alloc_out_msg failed", channel); 4410 mutex_enter(&statep->state_mutex); 4411 IBCM_REF_CNT_DECR(statep); 4412 mutex_exit(&statep->state_mutex); 4413 return (status); 4414 } 4415 4416 mutex_enter(&statep->state_mutex); 4417 4418 IBTF_DPRINTF_L4(cmlog, "ibt_set_alt_path: connection state is" 4419 " %x", statep->state); 4420 4421 /* Check state */ 4422 if ((statep->state != IBCM_STATE_ESTABLISHED) || 4423 (statep->ap_state != IBCM_AP_STATE_IDLE)) { 4424 IBCM_REF_CNT_DECR(statep); 4425 mutex_exit(&statep->state_mutex); 4426 (void) ibcm_free_out_msg(ibmf_hdl, &statep->lapr_msg); 4427 ibcm_lapr_exit(); 4428 return (IBT_CHAN_STATE_INVALID); 4429 } else { 4430 /* Set to LAP Sent state */ 4431 statep->ap_state = IBCM_AP_STATE_LAP_SENT; 4432 statep->ap_done = B_FALSE; 4433 statep->remaining_retry_cnt = statep->max_cm_retries; 4434 statep->timer_stored_state = statep->state; 4435 statep->timer_stored_ap_state = statep->ap_state; 4436 IBCM_REF_CNT_INCR(statep); /* for ibcm_post_lap_complete */ 4437 } 4438 4439 mutex_exit(&statep->state_mutex); 4440 4441 /* No more failure returns below */ 4442 4443 /* Allocate MAD for LAP */ 4444 IBTF_DPRINTF_L5(cmlog, "ibt_set_alt_path:" 4445 " statep's mad addr = 0x%p", IBCM_OUT_HDRP(statep->lapr_msg)); 4446 4447 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lap_msgp)) 4448 4449 lap_msgp = (ibcm_lap_msg_t *)IBCM_OUT_MSGP(statep->lapr_msg); 4450 4451 lap_msgp->lap_alt_l_port_lid = h2b16(alternate_slid); 4452 lap_msgp->lap_alt_r_port_lid = 4453 h2b16(alt_path->ap_alt_cep_path.cep_adds_vect.av_dlid); 4454 4455 /* Fill in remote port gid */ 4456 lap_msgp->lap_alt_r_port_gid.gid_prefix = 4457 h2b64(alt_path->ap_alt_cep_path.cep_adds_vect.av_dgid.gid_prefix); 4458 lap_msgp->lap_alt_r_port_gid.gid_guid = 4459 h2b64(alt_path->ap_alt_cep_path.cep_adds_vect.av_dgid.gid_guid); 4460 4461 /* Fill in local port gid */ 4462 lap_msgp->lap_alt_l_port_gid.gid_prefix = 4463 h2b64(alt_path->ap_alt_cep_path.cep_adds_vect.av_sgid.gid_prefix); 4464 lap_msgp->lap_alt_l_port_gid.gid_guid = 4465 h2b64(alt_path->ap_alt_cep_path.cep_adds_vect.av_sgid.gid_guid); 4466 4467 alt_grh = alt_path->ap_alt_cep_path.cep_adds_vect.av_send_grh; 4468 4469 /* alternate_flow_label, and alternate srate, alternate traffic class */ 4470 lap_msgp->lap_alt_srate_plus = 4471 alt_path->ap_alt_cep_path.cep_adds_vect.av_srate & 0x3f; 4472 lap_msgp->lap_alt_flow_label_plus = h2b32(((alt_grh == B_TRUE) ? 4473 (alt_path->ap_alt_cep_path.cep_adds_vect.av_flow << 12) : 0) | 4474 alt_path->ap_alt_cep_path.cep_adds_vect.av_tclass); 4475 4476 /* Alternate hop limit, service level */ 4477 lap_msgp->lap_alt_hop_limit = (alt_grh == B_TRUE) ? 4478 alt_path->ap_alt_cep_path.cep_adds_vect.av_hop : 1; 4479 lap_msgp->lap_alt_sl_plus = 4480 alt_path->ap_alt_cep_path.cep_adds_vect.av_srvl << 4 | 4481 ((alt_grh == B_FALSE) ? 0x8 : 0); 4482 4483 lap_msgp->lap_alt_local_acktime_plus = ibt_usec2ib( 4484 (2 * statep->rc_alt_pkt_lt) + 4485 ibt_ib2usec(hcap->hca_ack_delay)) << 3; 4486 4487 lap_msgp->lap_local_comm_id = h2b32(statep->local_comid); 4488 lap_msgp->lap_remote_comm_id = h2b32(statep->remote_comid); 4489 4490 lap_msgp->lap_remote_qpn_eecn_plus = 4491 h2b32((statep->remote_qpn << 8) | 4492 ibt_usec2ib(ibcm_remote_response_time) << 3); 4493 4494 len = min(priv_data_len, IBT_LAP_PRIV_DATA_SZ); 4495 if ((len > 0) && priv_data) { 4496 bcopy(priv_data, lap_msgp->lap_private_data, len); 4497 } 4498 4499 /* only rc_alt_pkt_lt and ap_return_data fields are initialized */ 4500 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 4501 4502 statep->rc_alt_pkt_lt = ibt_ib2usec(alt_path->ap_alt_pkt_lt); 4503 4504 /* return_data is filled up in the state machine code */ 4505 statep->ap_return_data = ret_args; 4506 4507 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*statep)) 4508 4509 IBCM_OUT_HDRP(statep->lapr_msg)->AttributeID = 4510 h2b16(IBCM_INCOMING_LAP + IBCM_ATTR_BASE_ID); 4511 4512 IBCM_OUT_HDRP(statep->lapr_msg)->TransactionID = 4513 h2b64(ibcm_generate_tranid(IBCM_INCOMING_LAP, statep->local_comid, 4514 0)); 4515 IBTF_DPRINTF_L3(cmlog, "ibt_set_alt_path: statep %p, tid %llx", 4516 statep, IBCM_OUT_HDRP(statep->lapr_msg)->TransactionID); 4517 4518 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*lap_msgp)) 4519 4520 /* Send LAP */ 4521 ibcm_post_rc_mad(statep, statep->lapr_msg, ibcm_post_lap_complete, 4522 statep); 4523 4524 mutex_enter(&statep->state_mutex); 4525 4526 if (mode == IBT_BLOCKING) { 4527 IBTF_DPRINTF_L4(cmlog, "ibt_set_alt_path: blocking"); 4528 4529 /* wait for APR */ 4530 while (statep->ap_done != B_TRUE) { 4531 cv_wait(&statep->block_client_cv, 4532 &statep->state_mutex); 4533 } 4534 4535 IBTF_DPRINTF_L4(cmlog, "ibt_set_alt_path: done blocking"); 4536 4537 /* 4538 * In the case that ibt_set_alt_path fails, 4539 * change retval to IBT_CM_FAILURE 4540 */ 4541 if (statep->ap_return_data->ap_status != IBT_CM_AP_LOADED) 4542 status = IBT_CM_FAILURE; 4543 4544 } 4545 4546 /* decrement the ref-count before leaving here */ 4547 IBCM_REF_CNT_DECR(statep); 4548 4549 mutex_exit(&statep->state_mutex); 4550 4551 ibcm_lapr_exit(); 4552 4553 /* If this message isn't seen then ibt_set_alt_path failed */ 4554 IBTF_DPRINTF_L4(cmlog, "ibt_set_alt_path: done"); 4555 4556 return (status); 4557 } 4558 4559 4560 #ifdef DEBUG 4561 4562 /* 4563 * ibcm_query_classport_info: 4564 * Query classportinfo 4565 * 4566 * INPUTS: 4567 * channel - Channel that is associated with a statep 4568 * 4569 * RETURN VALUE: NONE 4570 * This function is currently used to generate a valid get method classport 4571 * info, and test CM functionality. There is no ibtl client interface to 4572 * generate a classportinfo. It is possible that CM may use classportinfo 4573 * from other nodes in the future, and most of the code below could be re-used. 4574 */ 4575 void 4576 ibcm_query_classport_info(ibt_channel_hdl_t channel) 4577 { 4578 ibcm_state_data_t *statep; 4579 ibmf_msg_t *msgp; 4580 4581 IBTF_DPRINTF_L3(cmlog, "ibcm_query_classport_info(%p)", channel); 4582 4583 /* validate channel, first */ 4584 if (IBCM_INVALID_CHANNEL(channel)) { 4585 IBTF_DPRINTF_L2(cmlog, "ibcm_query_classport_info: " 4586 "invalid channel (%p)", channel); 4587 return; 4588 } 4589 4590 /* get the statep */ 4591 IBCM_GET_CHAN_PRIVATE(channel, statep); 4592 4593 /* 4594 * This can happen, if the statep is already gone by a DREQ from 4595 * the remote side 4596 */ 4597 if (statep == NULL) { 4598 IBTF_DPRINTF_L2(cmlog, "ibcm_query_classport_info: " 4599 "statep NULL"); 4600 return; 4601 } 4602 4603 mutex_enter(&statep->state_mutex); 4604 IBCM_RELEASE_CHAN_PRIVATE(channel); 4605 IBCM_REF_CNT_INCR(statep); 4606 mutex_exit(&statep->state_mutex); 4607 4608 /* Debug/test code, so don't care about return status */ 4609 (void) ibcm_alloc_out_msg(statep->stored_reply_addr.ibmf_hdl, &msgp, 4610 MAD_METHOD_GET); 4611 4612 IBCM_OUT_HDRP(msgp)->TransactionID = h2b64(ibcm_generate_tranid( 4613 MAD_ATTR_ID_CLASSPORTINFO, statep->local_comid, 0)); 4614 IBCM_OUT_HDRP(msgp)->AttributeID = h2b16(MAD_ATTR_ID_CLASSPORTINFO); 4615 4616 (void) ibcm_post_mad(msgp, &statep->stored_reply_addr, NULL, NULL); 4617 4618 IBTF_DPRINTF_L3(cmlog, "ibcm_query_classport_info(%p) " 4619 "Get method MAD posted ", channel); 4620 4621 (void) ibcm_free_out_msg(statep->stored_reply_addr.ibmf_hdl, &msgp); 4622 4623 mutex_enter(&statep->state_mutex); 4624 IBCM_REF_CNT_DECR(statep); 4625 mutex_exit(&statep->state_mutex); 4626 } 4627 4628 static void 4629 ibcm_print_reply_addr(ibt_channel_hdl_t channel, ibcm_mad_addr_t *cm_reply_addr) 4630 { 4631 IBTF_DPRINTF_L4(cmlog, "ibcm_print_reply_addr: chan 0x%p, SLID %x, " 4632 "DLID %x", channel, cm_reply_addr->rcvd_addr.ia_local_lid, 4633 cm_reply_addr->rcvd_addr.ia_remote_lid); 4634 4635 IBTF_DPRINTF_L4(cmlog, "ibcm_print_reply_addr: QKEY %x, PKEY %x, " 4636 "RQPN %x SL %x", cm_reply_addr->rcvd_addr.ia_q_key, 4637 cm_reply_addr->rcvd_addr.ia_p_key, 4638 cm_reply_addr->rcvd_addr.ia_remote_qno, 4639 cm_reply_addr->rcvd_addr.ia_service_level); 4640 4641 IBTF_DPRINTF_L4(cmlog, "ibcm_print_reply_addr: CM SGID %llX:%llX ", 4642 cm_reply_addr->grh_hdr.ig_sender_gid.gid_prefix, 4643 cm_reply_addr->grh_hdr.ig_sender_gid.gid_guid); 4644 4645 IBTF_DPRINTF_L4(cmlog, "ibcm_print_reply_addr: CM DGID %llX:%llX", 4646 cm_reply_addr->grh_hdr.ig_recver_gid.gid_prefix, 4647 cm_reply_addr->grh_hdr.ig_recver_gid.gid_guid); 4648 4649 IBTF_DPRINTF_L4(cmlog, "ibcm_print_reply_addr: CM FL %x TC %x HL %x", 4650 cm_reply_addr->grh_hdr.ig_flow_label, 4651 cm_reply_addr->grh_hdr.ig_tclass, 4652 cm_reply_addr->grh_hdr.ig_hop_limit); 4653 } 4654 4655 #endif 4656 4657 /* For MCG List search */ 4658 typedef struct ibcm_mcg_list_s { 4659 struct ibcm_mcg_list_s *ml_next; 4660 ib_gid_t ml_sgid; 4661 ib_gid_t ml_mgid; 4662 ib_pkey_t ml_pkey; 4663 ib_qkey_t ml_qkey; 4664 uint_t ml_refcnt; 4665 uint8_t ml_jstate; 4666 } ibcm_mcg_list_t; 4667 4668 ibcm_mcg_list_t *ibcm_mcglist = NULL; 4669 4670 _NOTE(MUTEX_PROTECTS_DATA(ibcm_mcglist_lock, ibcm_mcg_list_s)) 4671 _NOTE(MUTEX_PROTECTS_DATA(ibcm_mcglist_lock, ibcm_mcglist)) 4672 4673 typedef struct ibcm_join_mcg_tqarg_s { 4674 ib_gid_t rgid; 4675 ibt_mcg_attr_t mcg_attr; 4676 ibt_mcg_info_t *mcg_infop; 4677 ibt_mcg_handler_t func; 4678 void *arg; 4679 } ibcm_join_mcg_tqarg_t; 4680 4681 _NOTE(READ_ONLY_DATA(ibcm_join_mcg_tqarg_s)) 4682 4683 void 4684 ibcm_add_incr_mcg_entry(sa_mcmember_record_t *mcg_req, 4685 sa_mcmember_record_t *mcg_resp) 4686 { 4687 ibcm_mcg_list_t *new = NULL; 4688 ibcm_mcg_list_t *head = NULL; 4689 4690 IBTF_DPRINTF_L3(cmlog, "ibcm_add_incr_mcg_entry: MGID %llX:%llX" 4691 "\n SGID %llX:%llX, JState %X)", mcg_req->MGID.gid_prefix, 4692 mcg_req->MGID.gid_guid, mcg_req->PortGID.gid_prefix, 4693 mcg_req->PortGID.gid_guid, mcg_req->JoinState); 4694 4695 mutex_enter(&ibcm_mcglist_lock); 4696 head = ibcm_mcglist; 4697 4698 while (head != NULL) { 4699 if ((head->ml_mgid.gid_guid == mcg_resp->MGID.gid_guid) && 4700 (head->ml_mgid.gid_prefix == mcg_resp->MGID.gid_prefix) && 4701 (head->ml_sgid.gid_guid == mcg_resp->PortGID.gid_guid)) { 4702 /* Increment the count */ 4703 head->ml_refcnt++; 4704 /* OR the join_state value, we need this during leave */ 4705 head->ml_jstate |= mcg_req->JoinState; 4706 4707 IBTF_DPRINTF_L3(cmlog, "ibcm_add_incr_mcg_entry: Entry " 4708 "FOUND: refcnt %d JState %X", head->ml_refcnt, 4709 head->ml_jstate); 4710 4711 mutex_exit(&ibcm_mcglist_lock); 4712 return; 4713 } 4714 head = head->ml_next; 4715 } 4716 mutex_exit(&ibcm_mcglist_lock); 4717 4718 IBTF_DPRINTF_L3(cmlog, "ibcm_add_incr_mcg_entry: Create NEW Entry "); 4719 4720 /* If we are here, either list is empty or match couldn't be found */ 4721 new = kmem_zalloc(sizeof (ibcm_mcg_list_t), KM_SLEEP); 4722 4723 mutex_enter(&ibcm_mcglist_lock); 4724 /* Initialize the fields */ 4725 new->ml_sgid = mcg_resp->PortGID; 4726 new->ml_mgid = mcg_resp->MGID; 4727 new->ml_qkey = mcg_req->Q_Key; 4728 new->ml_pkey = mcg_req->P_Key; 4729 new->ml_refcnt = 1; /* As this is the first entry */ 4730 new->ml_jstate = mcg_req->JoinState; 4731 new->ml_next = NULL; 4732 4733 new->ml_next = ibcm_mcglist; 4734 ibcm_mcglist = new; 4735 mutex_exit(&ibcm_mcglist_lock); 4736 } 4737 4738 /* 4739 * ibcm_del_decr_mcg_entry 4740 * 4741 * Return value: 4742 * IBCM_SUCCESS Entry found and ref_cnt is now zero. So go-ahead and 4743 * leave the MCG group. The return arg *jstate will have 4744 * a valid join_state value that needed to be used by 4745 * xxx_leave_mcg(). 4746 * IBCM_LOOKUP_EXISTS Entry found and ref_cnt is decremented but is NOT zero. 4747 * So do not leave the MCG group yet. 4748 * IBCM_LOOKUP_FAIL Entry is NOT found. 4749 */ 4750 ibcm_status_t 4751 ibcm_del_decr_mcg_entry(sa_mcmember_record_t *mcg_req, uint8_t *jstate) 4752 { 4753 ibcm_mcg_list_t *head, *prev; 4754 4755 IBTF_DPRINTF_L3(cmlog, "ibcm_del_decr_mcg_entry: MGID %llX:%llX" 4756 "\n SGID %llX:%llX, JState %X)", mcg_req->MGID.gid_prefix, 4757 mcg_req->MGID.gid_guid, mcg_req->PortGID.gid_prefix, 4758 mcg_req->PortGID.gid_guid, mcg_req->JoinState); 4759 4760 *jstate = 0; 4761 4762 mutex_enter(&ibcm_mcglist_lock); 4763 head = ibcm_mcglist; 4764 prev = NULL; 4765 4766 while (head != NULL) { 4767 if ((head->ml_mgid.gid_guid == mcg_req->MGID.gid_guid) && 4768 (head->ml_mgid.gid_prefix == mcg_req->MGID.gid_prefix) && 4769 (head->ml_sgid.gid_guid == mcg_req->PortGID.gid_guid)) { 4770 if (!(head->ml_jstate & mcg_req->JoinState)) { 4771 IBTF_DPRINTF_L2(cmlog, "ibcm_del_decr_mcg_entry" 4772 ": JoinState mismatch %X %X)", 4773 head->ml_jstate, mcg_req->JoinState); 4774 } 4775 /* Decrement the count */ 4776 head->ml_refcnt--; 4777 4778 if (head->ml_refcnt == 0) { 4779 *jstate = head->ml_jstate; 4780 4781 IBTF_DPRINTF_L3(cmlog, "ibcm_del_decr_mcg_entry" 4782 ": refcnt is ZERO, so delete the entry "); 4783 if ((head == ibcm_mcglist) || (prev == NULL)) { 4784 ibcm_mcglist = head->ml_next; 4785 } else if (prev != NULL) { 4786 prev->ml_next = head->ml_next; 4787 } 4788 mutex_exit(&ibcm_mcglist_lock); 4789 4790 kmem_free(head, sizeof (ibcm_mcg_list_t)); 4791 return (IBCM_SUCCESS); 4792 } 4793 mutex_exit(&ibcm_mcglist_lock); 4794 return (IBCM_LOOKUP_EXISTS); 4795 } 4796 prev = head; 4797 head = head->ml_next; 4798 } 4799 mutex_exit(&ibcm_mcglist_lock); 4800 4801 /* 4802 * If we are here, something went wrong, we don't have the entry 4803 * for that MCG being joined. 4804 */ 4805 IBTF_DPRINTF_L2(cmlog, "ibcm_del_decr_mcg_entry: Match NOT " 4806 "Found "); 4807 4808 return (IBCM_LOOKUP_FAIL); 4809 } 4810 4811 4812 /* 4813 * Function: 4814 * ibt_join_mcg 4815 * Input: 4816 * rgid The request GID that defines the HCA port from which a 4817 * contact to SA Access is performed to add the specified 4818 * endport GID ((mcg_attr->mc_pgid) to a multicast group. 4819 * If mcg_attr->mc_pgid is null, then this (rgid) will be 4820 * treated as endport GID that is to be added to the 4821 * multicast group. 4822 * 4823 * mcg_attr A pointer to an ibt_mcg_attr_t structure that defines 4824 * the attributes of the desired multicast group to be 4825 * created or joined. 4826 * 4827 * func NULL or a pointer to a function to call when 4828 * ibt_join_mcg() completes. If 'func' is not NULL then 4829 * ibt_join_mcg() will return as soon as possible after 4830 * initiating the multicast group join/create process. 4831 * 'func' is then called when the process completes. 4832 * 4833 * arg Argument to the 'func'. 4834 * 4835 * Output: 4836 * mcg_info_p A pointer to the ibt_mcg_info_t structure, allocated 4837 * by the caller, where the attributes of the created or 4838 * joined multicast group are copied. 4839 * Returns: 4840 * IBT_SUCCESS 4841 * IBT_INVALID_PARAM 4842 * IBT_MCG_RECORDS_NOT_FOUND 4843 * IBT_INSUFF_RESOURCE 4844 * Description: 4845 * Join a multicast group. The first full member "join" causes the MCG 4846 * to be created. 4847 */ 4848 ibt_status_t 4849 ibt_join_mcg(ib_gid_t rgid, ibt_mcg_attr_t *mcg_attr, 4850 ibt_mcg_info_t *mcg_info_p, ibt_mcg_handler_t func, void *arg) 4851 { 4852 ibcm_join_mcg_tqarg_t *mcg_tq; 4853 int flag = ((func == NULL) ? KM_SLEEP : KM_NOSLEEP); 4854 4855 IBTF_DPRINTF_L3(cmlog, "ibt_join_mcg(%llX:%llX, %p)", rgid.gid_prefix, 4856 rgid.gid_guid, mcg_attr); 4857 4858 if ((rgid.gid_prefix == 0) || (rgid.gid_guid == 0)) { 4859 IBTF_DPRINTF_L2(cmlog, "ibt_join_mcg: Request GID is required"); 4860 return (IBT_INVALID_PARAM); 4861 } 4862 4863 if ((mcg_attr->mc_pkey == IB_PKEY_INVALID_LIMITED) || 4864 (mcg_attr->mc_pkey == IB_PKEY_INVALID_FULL)) { 4865 IBTF_DPRINTF_L2(cmlog, "ibt_join_mcg: Invalid P_Key specified"); 4866 return (IBT_INVALID_PARAM); 4867 } 4868 4869 if (mcg_attr->mc_join_state == 0) { 4870 IBTF_DPRINTF_L2(cmlog, "ibt_join_mcg: JoinState not specified"); 4871 return (IBT_INVALID_PARAM); 4872 } 4873 4874 if (mcg_info_p == NULL) { 4875 IBTF_DPRINTF_L2(cmlog, "ibt_join_mcg: mcg_info_p is NULL"); 4876 return (IBT_INVALID_PARAM); 4877 } 4878 4879 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*mcg_tq)) 4880 4881 mcg_tq = kmem_alloc(sizeof (ibcm_join_mcg_tqarg_t), flag); 4882 if (mcg_tq == NULL) { 4883 IBTF_DPRINTF_L2(cmlog, "ibt_join_mcg: " 4884 "Unable to allocate memory for local usage."); 4885 return (IBT_INSUFF_KERNEL_RESOURCE); 4886 } 4887 4888 mcg_tq->rgid = rgid; 4889 bcopy(mcg_attr, &mcg_tq->mcg_attr, sizeof (ibt_mcg_attr_t)); 4890 mcg_tq->mcg_infop = mcg_info_p; 4891 mcg_tq->func = func; 4892 mcg_tq->arg = arg; 4893 4894 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*mcg_tq)) 4895 4896 if (func != NULL) { /* Non-Blocking */ 4897 IBTF_DPRINTF_L3(cmlog, "ibt_join_mcg: Non-Blocking Call"); 4898 if (taskq_dispatch(ibcm_taskq, ibcm_process_async_join_mcg, 4899 mcg_tq, TQ_NOSLEEP) == 0) { 4900 IBTF_DPRINTF_L2(cmlog, "ibt_join_mcg: Failed to " 4901 "Dispatch the TaskQ"); 4902 kmem_free(mcg_tq, sizeof (ibcm_join_mcg_tqarg_t)); 4903 return (IBT_INSUFF_KERNEL_RESOURCE); 4904 } else 4905 return (IBT_SUCCESS); 4906 } else { /* Blocking */ 4907 return (ibcm_process_join_mcg(mcg_tq)); 4908 } 4909 } 4910 4911 static void 4912 ibcm_process_async_join_mcg(void *tq_arg) 4913 { 4914 (void) ibcm_process_join_mcg(tq_arg); 4915 } 4916 4917 static ibt_status_t 4918 ibcm_process_join_mcg(void *taskq_arg) 4919 { 4920 sa_mcmember_record_t mcg_req; 4921 sa_mcmember_record_t *mcg_resp; 4922 ibmf_saa_access_args_t access_args; 4923 ibmf_saa_handle_t saa_handle; 4924 uint64_t component_mask = 0; 4925 ibt_status_t retval; 4926 ibtl_cm_hca_port_t hca_port; 4927 uint_t num_records; 4928 size_t length; 4929 ibcm_hca_info_t *hcap; 4930 ibcm_join_mcg_tqarg_t *mcg_arg = (ibcm_join_mcg_tqarg_t *)taskq_arg; 4931 ibt_mcg_info_t *mcg_info_p = mcg_arg->mcg_infop; 4932 4933 IBTF_DPRINTF_L3(cmlog, "ibcm_process_join_mcg(%p)", mcg_arg); 4934 4935 retval = ibtl_cm_get_hca_port(mcg_arg->rgid, 0, &hca_port); 4936 if (retval != IBT_SUCCESS) { 4937 IBTF_DPRINTF_L2(cmlog, "ibcm_process_join_mcg: Failed to get " 4938 "port info from specified RGID: status = %d", retval); 4939 goto ibcm_join_mcg_exit1; 4940 } 4941 4942 bzero(&mcg_req, sizeof (sa_mcmember_record_t)); 4943 4944 if ((mcg_arg->mcg_attr.mc_pgid.gid_prefix == 0) || 4945 (mcg_arg->mcg_attr.mc_pgid.gid_guid == 0)) { 4946 IBTF_DPRINTF_L3(cmlog, "ibcm_process_join_mcg: " 4947 "Request GID is Port GID"); 4948 mcg_req.PortGID = mcg_arg->rgid; 4949 } else { 4950 mcg_req.PortGID = mcg_arg->mcg_attr.mc_pgid; 4951 } 4952 component_mask |= SA_MC_COMPMASK_PORTGID; 4953 4954 mcg_req.Q_Key = mcg_arg->mcg_attr.mc_qkey; 4955 mcg_req.P_Key = mcg_arg->mcg_attr.mc_pkey; 4956 mcg_req.JoinState = mcg_arg->mcg_attr.mc_join_state; 4957 mcg_req.TClass = mcg_arg->mcg_attr.mc_tclass; 4958 mcg_req.FlowLabel = mcg_arg->mcg_attr.mc_flow; 4959 mcg_req.SL = mcg_arg->mcg_attr.mc_sl; 4960 4961 component_mask |= SA_MC_COMPMASK_QKEY | SA_MC_COMPMASK_PKEY | 4962 SA_MC_COMPMASK_JOINSTATE | SA_MC_COMPMASK_TCLASS | 4963 SA_MC_COMPMASK_FLOWLABEL | SA_MC_COMPMASK_SL; 4964 4965 /* If client has specified MGID, use it else SA will assign one. */ 4966 if ((mcg_arg->mcg_attr.mc_mgid.gid_prefix >> 56ULL & 0xFF) == 0xFF) { 4967 mcg_req.MGID = mcg_arg->mcg_attr.mc_mgid; 4968 component_mask |= SA_MC_COMPMASK_MGID; 4969 } 4970 4971 IBTF_DPRINTF_L3(cmlog, "ibcm_process_join_mcg: "); 4972 IBTF_DPRINTF_L3(cmlog, "PGID=%016llX:%016llX, ", 4973 mcg_req.PortGID.gid_prefix, mcg_req.PortGID.gid_guid); 4974 IBTF_DPRINTF_L3(cmlog, "MGID=%016llX:%016llX", 4975 mcg_req.MGID.gid_prefix, mcg_req.MGID.gid_guid); 4976 IBTF_DPRINTF_L3(cmlog, "JoinState = %X", 4977 mcg_arg->mcg_attr.mc_join_state); 4978 IBTF_DPRINTF_L5(cmlog, "QKey %lX, PKey %lX", 4979 mcg_arg->mcg_attr.mc_qkey, mcg_arg->mcg_attr.mc_pkey); 4980 IBTF_DPRINTF_L5(cmlog, "Scope %X, MLID %X", 4981 mcg_arg->mcg_attr.mc_scope, mcg_arg->mcg_attr.mc_mlid); 4982 4983 /* Is MTU specified. */ 4984 if (mcg_arg->mcg_attr.mc_mtu_req.r_mtu) { 4985 mcg_req.MTU = mcg_arg->mcg_attr.mc_mtu_req.r_mtu; 4986 mcg_req.MTUSelector = mcg_arg->mcg_attr.mc_mtu_req.r_selector; 4987 4988 component_mask |= SA_MC_COMPMASK_MTUSELECTOR | 4989 SA_MC_COMPMASK_MTU; 4990 } 4991 4992 /* Is RATE specified. */ 4993 if (mcg_arg->mcg_attr.mc_rate_req.r_srate) { 4994 mcg_req.Rate = mcg_arg->mcg_attr.mc_rate_req.r_srate; 4995 mcg_req.RateSelector = 4996 mcg_arg->mcg_attr.mc_rate_req.r_selector; 4997 4998 component_mask |= SA_MC_COMPMASK_RATESELECTOR | 4999 SA_MC_COMPMASK_RATE; 5000 } 5001 5002 /* Is Packet Life Time specified. */ 5003 if (mcg_arg->mcg_attr.mc_pkt_lt_req.p_pkt_lt) { 5004 mcg_req.Rate = mcg_arg->mcg_attr.mc_pkt_lt_req.p_pkt_lt; 5005 mcg_req.RateSelector = 5006 mcg_arg->mcg_attr.mc_pkt_lt_req.p_selector; 5007 5008 component_mask |= SA_MC_COMPMASK_PKTLTSELECTOR | 5009 SA_MC_COMPMASK_PKTLT; 5010 } 5011 5012 if (mcg_arg->mcg_attr.mc_hop) { 5013 mcg_req.HopLimit = mcg_arg->mcg_attr.mc_hop; 5014 component_mask |= SA_MC_COMPMASK_HOPLIMIT; 5015 } 5016 5017 if (mcg_arg->mcg_attr.mc_scope) { 5018 mcg_req.Scope = mcg_arg->mcg_attr.mc_scope; 5019 component_mask |= SA_MC_COMPMASK_SCOPE; 5020 } 5021 5022 if (mcg_arg->mcg_attr.mc_mlid) { 5023 mcg_req.MLID = mcg_arg->mcg_attr.mc_mlid; 5024 component_mask |= SA_MC_COMPMASK_MLID; 5025 } 5026 5027 /* Get SA Access Handle. */ 5028 hcap = ibcm_find_hca_entry(hca_port.hp_hca_guid); 5029 if (hcap == NULL) { 5030 IBTF_DPRINTF_L2(cmlog, "ibcm_process_join_mcg: NO HCA found"); 5031 5032 retval = IBT_HCA_BUSY_DETACHING; 5033 goto ibcm_join_mcg_exit1; 5034 } 5035 5036 saa_handle = ibcm_get_saa_handle(hcap, hca_port.hp_port); 5037 if (saa_handle == NULL) { 5038 IBTF_DPRINTF_L2(cmlog, "ibcm_process_join_mcg: SA Handle NULL"); 5039 5040 retval = IBT_HCA_PORT_NOT_ACTIVE; 5041 goto ibcm_join_mcg_exit; 5042 } 5043 5044 if ((mcg_arg->mcg_attr.mc_pgid.gid_prefix != 0) && 5045 (mcg_arg->mcg_attr.mc_pgid.gid_guid != 0)) { 5046 retval = ibtl_cm_get_hca_port(mcg_arg->mcg_attr.mc_pgid, 0, 5047 &hca_port); 5048 if (retval != IBT_SUCCESS) { 5049 IBTF_DPRINTF_L2(cmlog, "ibcm_process_join_mcg: Failed " 5050 "to get PortInfo of specified PGID: status = %d", 5051 retval); 5052 goto ibcm_join_mcg_exit1; 5053 } 5054 } 5055 5056 /* Contact SA Access */ 5057 access_args.sq_attr_id = SA_MCMEMBERRECORD_ATTRID; 5058 access_args.sq_access_type = IBMF_SAA_UPDATE; 5059 access_args.sq_component_mask = component_mask; 5060 access_args.sq_template = &mcg_req; 5061 access_args.sq_template_length = sizeof (sa_mcmember_record_t); 5062 access_args.sq_callback = NULL; 5063 access_args.sq_callback_arg = NULL; 5064 5065 retval = ibcm_contact_sa_access(saa_handle, &access_args, &length, 5066 (void **)&mcg_resp); 5067 if (retval != IBT_SUCCESS) { 5068 IBTF_DPRINTF_L2(cmlog, "ibcm_process_join_mcg: " 5069 "SA Access Failed"); 5070 goto ibcm_join_mcg_exit; 5071 } 5072 5073 num_records = length/sizeof (sa_mcmember_record_t); 5074 5075 IBTF_DPRINTF_L4(cmlog, "ibcm_process_join_mcg: " 5076 "Found %d MCMember Records", num_records); 5077 5078 /* Validate the returned number of records. */ 5079 if ((mcg_resp != NULL) && (num_records > 0)) { 5080 /* Update the return values. */ 5081 mcg_info_p->mc_adds_vect.av_dgid = mcg_resp->MGID; 5082 mcg_info_p->mc_adds_vect.av_sgid = mcg_resp->PortGID; 5083 mcg_info_p->mc_adds_vect.av_srate = mcg_resp->Rate; 5084 mcg_info_p->mc_adds_vect.av_srvl = mcg_resp->SL; 5085 mcg_info_p->mc_adds_vect.av_flow = mcg_resp->FlowLabel; 5086 mcg_info_p->mc_adds_vect.av_tclass = mcg_resp->TClass; 5087 mcg_info_p->mc_adds_vect.av_hop = mcg_resp->HopLimit; 5088 mcg_info_p->mc_adds_vect.av_send_grh = B_TRUE; 5089 mcg_info_p->mc_adds_vect.av_dlid = mcg_resp->MLID; 5090 mcg_info_p->mc_mtu = mcg_resp->MTU; 5091 mcg_info_p->mc_qkey = mcg_resp->Q_Key; 5092 5093 retval = ibt_pkey2index_byguid(hca_port.hp_hca_guid, 5094 hca_port.hp_port, mcg_resp->P_Key, &mcg_info_p->mc_pkey_ix); 5095 if (retval != IBT_SUCCESS) { 5096 IBTF_DPRINTF_L3(cmlog, "ibcm_process_join_mcg: " 5097 "Pkey2Index Conversion failed<%d>", retval); 5098 mcg_info_p->mc_pkey_ix = 0; 5099 } 5100 5101 mcg_info_p->mc_scope = mcg_resp->Scope; 5102 mcg_info_p->mc_pkt_lt = mcg_resp->PacketLifeTime; 5103 5104 mcg_info_p->mc_adds_vect.av_port_num = hca_port.hp_port; 5105 mcg_info_p->mc_adds_vect.av_sgid_ix = hca_port.hp_sgid_ix; 5106 mcg_info_p->mc_adds_vect.av_src_path = 0; 5107 5108 /* Add or Incr the matching MCG entry. */ 5109 ibcm_add_incr_mcg_entry(&mcg_req, mcg_resp); 5110 /* Deallocate the memory allocated by SA for mcg_resp. */ 5111 kmem_free(mcg_resp, length); 5112 5113 retval = IBT_SUCCESS; 5114 } else { 5115 retval = IBT_MCG_RECORDS_NOT_FOUND; 5116 IBTF_DPRINTF_L3(cmlog, "ibcm_process_join_mcg: " 5117 "MCG RECORDS NOT FOUND"); 5118 } 5119 5120 ibcm_join_mcg_exit: 5121 ibcm_dec_hca_acc_cnt(hcap); 5122 5123 ibcm_join_mcg_exit1: 5124 if (mcg_arg->func) 5125 (*(mcg_arg->func))(mcg_arg->arg, retval, mcg_info_p); 5126 5127 kmem_free(mcg_arg, sizeof (ibcm_join_mcg_tqarg_t)); 5128 5129 return (retval); 5130 } 5131 5132 5133 /* 5134 * Function: 5135 * ibt_leave_mcg 5136 * Input: 5137 * rgid The request GID that defines the HCA port upon which 5138 * to send the request to the Subnet Administrator, to 5139 * remove the specified port (port_gid) from the multicast 5140 * group. If 'port_gid' is the Reserved GID (i.e. 5141 * port_gid.gid_prefix = 0 and port_gid.gid_guid = 0), 5142 * then the end-port associated with 'rgid' is removed 5143 * from the multicast group. 5144 * 5145 * mc_gid A multicast group GID as returned from ibt_join_mcg() 5146 * call. This is optional, if not specified (i.e. 5147 * mc_gid.gid_prefix has 0xFF in its upper 8 bits to 5148 * identify this as being a multicast GID), then the 5149 * port is removed from all the multicast groups of 5150 * which it is a member. 5151 * 5152 * port_gid This is optional, if not the Reserved GID (gid_prefix 5153 * and gid_guid not equal to 0), then this specifies the 5154 * endport GID of the multicast group member being deleted 5155 * from the group. If it is the Reserved GID (gid_prefix 5156 * and gid_guid equal to 0) then the member endport GID is 5157 * determined from 'rgid'. 5158 * 5159 * mc_join_state The Join State attribute used when the group was joined 5160 * using ibt_join_mcg(). This Join State component must 5161 * contains at least one bit set to 1 in the same position 5162 * as that used during ibt_join_mcg(). i.e. the logical 5163 * AND of the two JoinState components is not all zeros. 5164 * This Join State component must not have some bits set 5165 * which are not set using ibt_join_mcg(). 5166 * Output: 5167 * None. 5168 * Returns: 5169 * IBT_SUCCESS 5170 * IBT_INVALID_PARAM 5171 * IBT_MC_GROUP_INVALID 5172 * IBT_INSUFF_RESOURCE 5173 * Description: 5174 * The port associated with the port GID shall be removed from the 5175 * multicast group specified by MGID (mc_gid) or from all the multicast 5176 * groups of which it is a member if the MGID (mc_gid) is not specified. 5177 * 5178 * The last full member to leave causes the destruction of the Multicast 5179 * Group. 5180 */ 5181 ibt_status_t 5182 ibt_leave_mcg(ib_gid_t rgid, ib_gid_t mc_gid, ib_gid_t port_gid, 5183 uint8_t mc_join_state) 5184 { 5185 sa_mcmember_record_t mcg_req; 5186 ibmf_saa_access_args_t access_args; 5187 ibmf_saa_handle_t saa_handle; 5188 uint64_t component_mask = 0; 5189 int sa_retval; 5190 ibt_status_t retval; 5191 ibcm_status_t ret; 5192 ibtl_cm_hca_port_t hca_port; 5193 size_t length; 5194 void *results_p; 5195 ibcm_hca_info_t *hcap; 5196 uint8_t jstate = 0; 5197 5198 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg(%llX:%llX, %llX:%llX)", 5199 rgid.gid_prefix, rgid.gid_guid, mc_gid.gid_prefix, mc_gid.gid_guid); 5200 5201 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg(%llX:%llX, 0x%X)", 5202 port_gid.gid_prefix, port_gid.gid_guid, mc_join_state); 5203 5204 if ((rgid.gid_prefix == 0) || (rgid.gid_guid == 0)) { 5205 IBTF_DPRINTF_L2(cmlog, "ibt_leave_mcg: RequestGID is required"); 5206 return (IBT_INVALID_PARAM); 5207 } 5208 5209 bzero(&mcg_req, sizeof (sa_mcmember_record_t)); 5210 5211 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg: MGID: %llX%llX", 5212 mc_gid.gid_prefix, mc_gid.gid_guid); 5213 5214 /* Validate MGID */ 5215 if ((mc_gid.gid_prefix >> 56ULL & 0xFF) == 0xFF) { 5216 mcg_req.MGID = mc_gid; 5217 component_mask |= SA_MC_COMPMASK_MGID; 5218 } else if ((mc_gid.gid_prefix != 0) || (mc_gid.gid_guid != 0)) { 5219 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg: Invalid MGID specified"); 5220 return (IBT_MC_MGID_INVALID); 5221 } 5222 5223 if ((port_gid.gid_prefix == 0) || (port_gid.gid_guid == 0)) { 5224 mcg_req.PortGID = rgid; 5225 } else { 5226 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg: Performing PROXY Leave"); 5227 mcg_req.PortGID = port_gid; 5228 } 5229 component_mask |= SA_MC_COMPMASK_PORTGID; 5230 5231 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg: Port GID <%llX:%llX>", 5232 mcg_req.PortGID.gid_prefix, mcg_req.PortGID.gid_guid); 5233 5234 /* Join State */ 5235 mcg_req.JoinState = mc_join_state; 5236 component_mask |= SA_MC_COMPMASK_JOINSTATE; 5237 5238 ret = ibcm_del_decr_mcg_entry(&mcg_req, &jstate); 5239 if (ret == IBCM_LOOKUP_EXISTS) { 5240 IBTF_DPRINTF_L3(cmlog, "ibt_leave_mcg: Multiple JoinMCG record " 5241 " still exists, we shall leave for last leave_mcg call"); 5242 return (IBT_SUCCESS); 5243 } else if (ret == IBCM_LOOKUP_FAIL) { 5244 IBTF_DPRINTF_L2(cmlog, "ibt_leave_mcg: No Record found, " 5245 "continue with leave_mcg call"); 5246 } else if ((ret == IBCM_SUCCESS) && (jstate != 0)) { 5247 /* 5248 * Update with cached "jstate", as this will be OR'ed of 5249 * all ibt_join_mcg() calls for this record. 5250 */ 5251 mcg_req.JoinState = jstate; 5252 } 5253 5254 retval = ibtl_cm_get_hca_port(rgid, 0, &hca_port); 5255 if (retval != IBT_SUCCESS) { 5256 IBTF_DPRINTF_L2(cmlog, "ibt_leave_mcg: Failed to get port info " 5257 "from specified RGID : status = %d", retval); 5258 return (retval); 5259 } 5260 5261 /* Get SA Access Handle. */ 5262 hcap = ibcm_find_hca_entry(hca_port.hp_hca_guid); 5263 if (hcap == NULL) { 5264 IBTF_DPRINTF_L2(cmlog, "ibt_leave_mcg: " 5265 "NO HCA found"); 5266 return (IBT_HCA_BUSY_DETACHING); 5267 } 5268 5269 saa_handle = ibcm_get_saa_handle(hcap, hca_port.hp_port); 5270 if (saa_handle == NULL) { 5271 IBTF_DPRINTF_L2(cmlog, "ibt_leave_mcg: saa_handle is NULL"); 5272 ibcm_dec_hca_acc_cnt(hcap); 5273 return (IBT_HCA_PORT_NOT_ACTIVE); 5274 } 5275 5276 /* Contact SA Access */ 5277 access_args.sq_attr_id = SA_MCMEMBERRECORD_ATTRID; 5278 access_args.sq_access_type = IBMF_SAA_DELETE; 5279 access_args.sq_component_mask = component_mask; 5280 access_args.sq_template = &mcg_req; 5281 access_args.sq_template_length = sizeof (sa_mcmember_record_t); 5282 access_args.sq_callback = NULL; 5283 access_args.sq_callback_arg = NULL; 5284 5285 ibcm_sa_access_enter(); 5286 5287 sa_retval = ibmf_sa_access(saa_handle, &access_args, 0, &length, 5288 &results_p); 5289 if (sa_retval != IBMF_SUCCESS) { 5290 IBTF_DPRINTF_L2(cmlog, "ibt_leave_mcg: SA access Failed: %d", 5291 sa_retval); 5292 (void) ibcm_ibmf_analyze_error(sa_retval); 5293 retval = IBT_MC_GROUP_INVALID; 5294 } 5295 5296 ibcm_sa_access_exit(); 5297 5298 ibcm_dec_hca_acc_cnt(hcap); 5299 5300 return (retval); 5301 } 5302 5303 5304 /* 5305 * Function: 5306 * ibt_query_mcg 5307 * Input: 5308 * rgid The request GID that defines the HCA port upon which 5309 * to send the request to the Subnet Administrator, to 5310 * retrieve Multicast Records matching attributes as 5311 * specified through 'mcg_attr' argument. 5312 * 5313 * mcg_attr NULL or a pointer to an ibt_mcg_attr_t structure that 5314 * specifies MCG attributes that are to be matched. 5315 * Attributes that are not required can be wild carded 5316 * by specifying as '0'. 5317 * 5318 * mcgs_max_num The maximum number of matching multicast groups to 5319 * return. If zero, then all available matching multicast 5320 * groups are returned. 5321 * Output: 5322 * mcgs_info_p The address of an ibt_mcg_info_t pointer, where 5323 * multicast group information is returned. The actual 5324 * number of entries filled in the array is returned in 5325 * entries_p. 5326 * 5327 * entries_p The number of ibt_mcg_attr_t entries returned. 5328 * Returns: 5329 * IBT_SUCCESS 5330 * IBT_INVALID_PARAM 5331 * IBT_MCG_RECORDS_NOT_FOUND 5332 * Description: 5333 * Request information on multicast groups that match the parameters 5334 * specified in mcg_attr. Information on each multicast group is returned 5335 * to the caller in the form of an array of ibt_mcg_info_t. 5336 * ibt_query_mcg() allocates the memory for this array and returns a 5337 * pointer to the array (mcgs_p) and the number of entries in the array 5338 * (entries_p). This memory should be freed by the client using 5339 * ibt_free_mcg_info(). 5340 */ 5341 ibt_status_t 5342 ibt_query_mcg(ib_gid_t rgid, ibt_mcg_attr_t *mcg_attr, uint_t mcgs_max_num, 5343 ibt_mcg_info_t **mcgs_info_p, uint_t *entries_p) 5344 { 5345 sa_mcmember_record_t mcg_req; 5346 sa_mcmember_record_t *mcg_resp; 5347 ibt_mcg_info_t *mcg_infop; 5348 ibmf_saa_access_args_t access_args; 5349 ibmf_saa_handle_t saa_handle; 5350 uint64_t component_mask = 0; 5351 ibt_status_t retval; 5352 ibtl_cm_hca_port_t hport; 5353 uint_t num_records; 5354 size_t length; 5355 void *results_p; 5356 ib_gid_t port_gid; 5357 ibcm_hca_info_t *hcap; 5358 5359 IBTF_DPRINTF_L3(cmlog, "ibt_query_mcg(%p, %d)", mcg_attr, mcgs_max_num); 5360 5361 if ((entries_p == NULL) || (mcgs_info_p == NULL)) { 5362 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: " 5363 "entries_p or mcgs_info_p is NULL"); 5364 return (IBT_INVALID_PARAM); 5365 } 5366 5367 if ((rgid.gid_prefix == 0) || (rgid.gid_guid == 0)) { 5368 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: RequestGID is required"); 5369 return (IBT_INVALID_PARAM); 5370 } 5371 IBTF_DPRINTF_L4(cmlog, "ibt_query_mcg: Request GID <%llX:%llX>", 5372 rgid.gid_prefix, rgid.gid_guid); 5373 5374 bzero(&mcg_req, sizeof (sa_mcmember_record_t)); 5375 port_gid.gid_prefix = port_gid.gid_guid = 0; 5376 5377 if (mcg_attr != NULL) { 5378 port_gid = mcg_attr->mc_pgid; 5379 5380 if ((port_gid.gid_prefix != 0) && (port_gid.gid_guid != 0)) { 5381 mcg_req.PortGID = mcg_attr->mc_pgid; 5382 component_mask |= SA_MC_COMPMASK_PORTGID; 5383 5384 IBTF_DPRINTF_L4(cmlog, "ibt_query_mcg: PGID %llX:%llX", 5385 port_gid.gid_prefix, port_gid.gid_guid); 5386 } 5387 5388 /* Is Q_Key specified. */ 5389 if (mcg_attr->mc_qkey != 0) { 5390 mcg_req.Q_Key = mcg_attr->mc_qkey; 5391 component_mask |= SA_MC_COMPMASK_QKEY; 5392 } 5393 5394 /* Is P_Key specified. */ 5395 if (mcg_attr->mc_pkey != 0) { 5396 mcg_req.P_Key = mcg_attr->mc_pkey; 5397 component_mask |= SA_MC_COMPMASK_PKEY; 5398 } 5399 5400 /* Is MGID specified. */ 5401 if ((mcg_attr->mc_mgid.gid_prefix >> 56ULL & 0xFF) == 0xFF) { 5402 mcg_req.MGID = mcg_attr->mc_mgid; 5403 component_mask |= SA_MC_COMPMASK_MGID; 5404 } 5405 5406 /* Is MTU specified. */ 5407 if (mcg_attr->mc_mtu_req.r_mtu) { 5408 mcg_req.MTU = mcg_attr->mc_mtu_req.r_mtu; 5409 mcg_req.MTUSelector = mcg_attr->mc_mtu_req.r_selector; 5410 5411 component_mask |= SA_MC_COMPMASK_MTUSELECTOR | 5412 SA_MC_COMPMASK_MTU; 5413 } 5414 5415 if (mcg_attr->mc_tclass) { 5416 mcg_req.TClass = mcg_attr->mc_tclass; 5417 component_mask |= SA_MC_COMPMASK_TCLASS; 5418 } 5419 5420 /* Is RATE specified. */ 5421 if (mcg_attr->mc_rate_req.r_srate) { 5422 mcg_req.Rate = mcg_attr->mc_rate_req.r_srate; 5423 mcg_req.RateSelector = mcg_attr->mc_rate_req.r_selector; 5424 5425 component_mask |= SA_MC_COMPMASK_RATESELECTOR | 5426 SA_MC_COMPMASK_RATE; 5427 } 5428 5429 /* Is Packet Life Time specified. */ 5430 if (mcg_attr->mc_pkt_lt_req.p_pkt_lt) { 5431 mcg_req.Rate = mcg_attr->mc_pkt_lt_req.p_pkt_lt; 5432 mcg_req.RateSelector = 5433 mcg_attr->mc_pkt_lt_req.p_selector; 5434 5435 component_mask |= SA_MC_COMPMASK_PKTLTSELECTOR | 5436 SA_MC_COMPMASK_PKTLT; 5437 } 5438 5439 if (mcg_attr->mc_hop) { 5440 mcg_req.HopLimit = mcg_attr->mc_hop; 5441 component_mask |= SA_MC_COMPMASK_HOPLIMIT; 5442 } 5443 5444 if (mcg_attr->mc_flow) { 5445 mcg_req.FlowLabel = mcg_attr->mc_flow; 5446 component_mask |= SA_MC_COMPMASK_FLOWLABEL; 5447 } 5448 5449 if (mcg_attr->mc_sl) { 5450 mcg_req.SL = mcg_attr->mc_sl; 5451 component_mask |= SA_MC_COMPMASK_SL; 5452 } 5453 5454 if (mcg_attr->mc_scope) { 5455 mcg_req.Scope = mcg_attr->mc_scope; 5456 component_mask |= SA_MC_COMPMASK_SCOPE; 5457 } 5458 5459 if (mcg_attr->mc_join_state) { 5460 mcg_req.JoinState = mcg_attr->mc_join_state; 5461 component_mask |= SA_MC_COMPMASK_JOINSTATE; 5462 } 5463 5464 if (mcg_attr->mc_mlid) { 5465 mcg_req.MLID = mcg_attr->mc_mlid; 5466 component_mask |= SA_MC_COMPMASK_MLID; 5467 } 5468 } 5469 5470 retval = ibtl_cm_get_hca_port(rgid, 0, &hport); 5471 if (retval != IBT_SUCCESS) { 5472 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: Failed to get port info " 5473 "from specified RGID : status = %d", retval); 5474 return (retval); 5475 } 5476 5477 /* Get SA Access Handle. */ 5478 hcap = ibcm_find_hca_entry(hport.hp_hca_guid); 5479 if (hcap == NULL) { 5480 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: NO HCA found"); 5481 return (IBT_HCA_BUSY_DETACHING); 5482 } 5483 5484 saa_handle = ibcm_get_saa_handle(hcap, hport.hp_port); 5485 if (saa_handle == NULL) { 5486 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: saa_handle is NULL"); 5487 ibcm_dec_hca_acc_cnt(hcap); 5488 return (IBT_HCA_PORT_NOT_ACTIVE); 5489 } 5490 5491 /* Contact SA Access */ 5492 access_args.sq_attr_id = SA_MCMEMBERRECORD_ATTRID; 5493 access_args.sq_access_type = IBMF_SAA_RETRIEVE; 5494 access_args.sq_component_mask = component_mask; 5495 access_args.sq_template = &mcg_req; 5496 access_args.sq_template_length = sizeof (sa_mcmember_record_t); 5497 access_args.sq_callback = NULL; 5498 access_args.sq_callback_arg = NULL; 5499 5500 retval = ibcm_contact_sa_access(saa_handle, &access_args, &length, 5501 &results_p); 5502 if (retval != IBT_SUCCESS) { 5503 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: SA access Failed"); 5504 ibcm_dec_hca_acc_cnt(hcap); 5505 return (retval); 5506 } 5507 5508 num_records = length/sizeof (sa_mcmember_record_t); 5509 5510 IBTF_DPRINTF_L4(cmlog, "ibt_query_mcg: Found %d MCMember Records", 5511 num_records); 5512 5513 /* Validate the returned number of records. */ 5514 if ((results_p != NULL) && (num_records > 0)) { 5515 uint_t i; 5516 5517 /* 5518 * If mcgs_max_num is zero, then return all records else 5519 * return only requested number of records 5520 */ 5521 if ((mcgs_max_num != 0) && (num_records > mcgs_max_num)) { 5522 /* we are interested in only mcgs_max_num records */ 5523 num_records = mcgs_max_num; 5524 } 5525 5526 /* 5527 * The SGID returned in "mcg_info_p" buffer should be PortGID, 5528 * (mcg_attr->mc_pgid), if 'mcg_attr->mc_pgid' was specified, 5529 * else RequestGID (rgid) should be returned. 5530 */ 5531 if ((port_gid.gid_prefix != 0) && (port_gid.gid_guid != 0)) { 5532 5533 /* Get sgid_ix and port number of 'port_gid' */ 5534 retval = ibtl_cm_get_hca_port(port_gid, 0, &hport); 5535 if (retval != IBT_SUCCESS) { 5536 IBTF_DPRINTF_L2(cmlog, "ibt_query_mcg: " 5537 "Failed to Get Portinfo for PortGID :" 5538 "status = %d", retval); 5539 return (retval); 5540 } 5541 } else { 5542 /* 5543 * The sgid_ix and port number related to RequestGID 5544 * are already obtained at the beginning. 5545 */ 5546 port_gid = rgid; 5547 } 5548 5549 /* 5550 * Allocate memory for return buffer, to be freed in 5551 * ibt_free_mcg_info(). 5552 */ 5553 mcg_infop = kmem_alloc((num_records * sizeof (ibt_mcg_info_t)), 5554 KM_SLEEP); 5555 5556 *mcgs_info_p = mcg_infop; 5557 *entries_p = num_records; 5558 5559 /* Update the return values. */ 5560 for (i = 0; i < num_records; i++) { 5561 5562 mcg_resp = (sa_mcmember_record_t *)((uchar_t *) 5563 results_p + i * sizeof (sa_mcmember_record_t)); 5564 5565 mcg_infop[i].mc_adds_vect.av_dgid = mcg_resp->MGID; 5566 mcg_infop[i].mc_adds_vect.av_sgid = port_gid; 5567 mcg_infop[i].mc_adds_vect.av_srate = mcg_resp->Rate; 5568 mcg_infop[i].mc_adds_vect.av_srvl = mcg_resp->SL; 5569 mcg_infop[i].mc_adds_vect.av_flow = mcg_resp->FlowLabel; 5570 mcg_infop[i].mc_adds_vect.av_tclass = mcg_resp->TClass; 5571 mcg_infop[i].mc_adds_vect.av_hop = mcg_resp->HopLimit; 5572 mcg_infop[i].mc_adds_vect.av_port_num = hport.hp_port; 5573 mcg_infop[i].mc_adds_vect.av_send_grh = B_TRUE; 5574 mcg_infop[i].mc_adds_vect.av_dlid = mcg_resp->MLID; 5575 mcg_infop[i].mc_adds_vect.av_sgid_ix = hport.hp_sgid_ix; 5576 mcg_infop[i].mc_adds_vect.av_src_path = 0; 5577 mcg_infop[i].mc_mtu = mcg_resp->MTU; 5578 mcg_infop[i].mc_qkey = mcg_resp->Q_Key; 5579 mcg_infop[i].mc_scope = mcg_resp->Scope; 5580 mcg_infop[i].mc_pkt_lt = mcg_resp->PacketLifeTime; 5581 5582 if (ibt_pkey2index_byguid(hport.hp_hca_guid, 5583 hport.hp_port, mcg_resp->P_Key, 5584 &mcg_infop[i].mc_pkey_ix) != IBT_SUCCESS) { 5585 IBTF_DPRINTF_L3(cmlog, "ibt_query_mcg: " 5586 "Pkey2Index Conversion failed"); 5587 mcg_infop[i].mc_pkey_ix = 0; 5588 } 5589 } 5590 5591 /* 5592 * Deallocate the memory allocated by SA for results_p. 5593 */ 5594 kmem_free(results_p, length); 5595 retval = IBT_SUCCESS; 5596 5597 IBTF_DPRINTF_L3(cmlog, "ibt_query_mcg: returning %d MCGRecords", 5598 num_records); 5599 5600 } else { 5601 retval = IBT_MCG_RECORDS_NOT_FOUND; 5602 *entries_p = 0; 5603 5604 IBTF_DPRINTF_L3(cmlog, "ibt_query_mcg: MCG RECORDS NOT FOUND"); 5605 } 5606 5607 ibcm_dec_hca_acc_cnt(hcap); 5608 5609 return (retval); 5610 } 5611 5612 5613 /* 5614 * ibt_free_mcg_info() 5615 * Free the memory allocated by successful ibt_query_mcg() 5616 * 5617 * mcgs_info Pointer returned by ibt_query_mcg(). 5618 * 5619 * entries The number of ibt_mcg_info_t entries to free. 5620 */ 5621 void 5622 ibt_free_mcg_info(ibt_mcg_info_t *mcgs_info, uint_t entries) 5623 { 5624 IBTF_DPRINTF_L3(cmlog, "ibt_free_mcg_info: " 5625 "Free <%d> entries from 0x%p", entries, mcgs_info); 5626 5627 if ((mcgs_info != NULL) && (entries > 0)) 5628 kmem_free(mcgs_info, entries * sizeof (ibt_mcg_info_t)); 5629 else 5630 IBTF_DPRINTF_L2(cmlog, "ibt_free_mcg_info: " 5631 "ERROR: NULL buf pointer or length specified."); 5632 } 5633 5634 5635 /* 5636 * Function: 5637 * ibt_gid_to_node_info() 5638 * Input: 5639 * gid Identifies the IB Node and port for which to obtain 5640 * Node information. 5641 * Output: 5642 * node_info_p A pointer to an ibt_node_info_t structure (allocated 5643 * by the caller) in which to return the node information. 5644 * Returns: 5645 * IBT_SUCCESS 5646 * IBT_INVALID_PARAM 5647 * IBT_NODE_RECORDS_NOT_FOUND 5648 * IBT_NO_HCAS_AVAILABLE 5649 * Description: 5650 * Retrieve Node Information for the specified GID. 5651 */ 5652 ibt_status_t 5653 ibt_gid_to_node_info(ib_gid_t gid, ibt_node_info_t *node_info_p) 5654 { 5655 sa_node_record_t nr_req, *nr_resp; 5656 ibmf_saa_handle_t saa_handle; 5657 ibt_status_t retval; 5658 ibcm_hca_info_t *hcap; 5659 ibtl_cm_hca_port_t hport; 5660 int i, j; 5661 uint_t num_rec; 5662 ib_guid_t *guid_array = NULL; 5663 sa_path_record_t *path; 5664 size_t len; 5665 uint8_t npaths; 5666 uint32_t num_hcas = 0; 5667 ib_lid_t node_lid; 5668 boolean_t local_node = B_FALSE; 5669 void *res_p; 5670 uint8_t num_ports = 0; 5671 5672 5673 IBTF_DPRINTF_L4(cmlog, "ibt_gid_to_node_info(%llX:%llX, %p)", 5674 gid.gid_prefix, gid.gid_guid, node_info_p); 5675 5676 if ((gid.gid_prefix == 0) || (gid.gid_guid == 0)) { 5677 IBTF_DPRINTF_L2(cmlog, "ibt_gid_to_node_info: GID is required"); 5678 return (IBT_INVALID_PARAM); 5679 } 5680 5681 if (node_info_p == NULL) { 5682 IBTF_DPRINTF_L2(cmlog, "ibt_gid_to_node_info: " 5683 "Return Buf (node_info_p) is NULL."); 5684 return (IBT_INVALID_PARAM); 5685 } 5686 5687 /* 5688 * If 'gid' is on local node, then get node lid (i.e. base lid of the 5689 * associated port) info via ibtl_cm_get_hca_port() call. 5690 */ 5691 bzero(&hport, sizeof (ibtl_cm_hca_port_t)); 5692 if (ibtl_cm_get_hca_port(gid, 0, &hport) == IBT_SUCCESS) { 5693 5694 hcap = ibcm_find_hca_entry(hport.hp_hca_guid); 5695 if (hcap == NULL) { 5696 IBTF_DPRINTF_L3(cmlog, "ibt_gid_to_node_info: " 5697 "HCA(%llX) info not found", hport.hp_hca_guid); 5698 return (IBT_NO_HCAS_AVAILABLE); 5699 } 5700 num_ports = 1; 5701 num_hcas = 1; 5702 node_lid = hport.hp_base_lid; 5703 local_node = B_TRUE; 5704 IBTF_DPRINTF_L4(cmlog, "ibt_gid_to_node_info: Local Node: " 5705 "LID = 0x%X", node_lid); 5706 } else { 5707 /* Get the number of HCAs and their GUIDs */ 5708 num_hcas = ibt_get_hca_list(&guid_array); 5709 IBTF_DPRINTF_L4(cmlog, "ibt_gid_to_node_info: ibt_get_hca_list " 5710 "returned %d hcas", num_hcas); 5711 5712 if (num_hcas == 0) { 5713 IBTF_DPRINTF_L2(cmlog, "ibt_gid_to_node_info: " 5714 "NO HCA's Found on this system"); 5715 return (IBT_NO_HCAS_AVAILABLE); 5716 } 5717 } 5718 5719 for (i = 0; i < num_hcas; i++) { 5720 if (local_node == B_FALSE) { 5721 hcap = ibcm_find_hca_entry(guid_array[i]); 5722 if (hcap == NULL) { 5723 IBTF_DPRINTF_L3(cmlog, "ibt_gid_to_node_info: " 5724 "HCA(%llX) info not found", guid_array[i]); 5725 retval = IBT_NO_HCAS_AVAILABLE; 5726 continue; 5727 } 5728 num_ports = hcap->hca_num_ports; 5729 } 5730 5731 for (j = 0; j < num_ports; j++) { 5732 uint8_t port = 0; 5733 5734 if (local_node == B_TRUE) 5735 port = hport.hp_port; 5736 else 5737 port = j + 1; 5738 5739 /* Get SA Access Handle. */ 5740 saa_handle = ibcm_get_saa_handle(hcap, port); 5741 if (saa_handle == NULL) { 5742 IBTF_DPRINTF_L3(cmlog, "ibt_gid_to_node_info: " 5743 "Port %d of HCA (%llX) is NOT ACTIVE", 5744 port, hport.hp_hca_guid); 5745 retval = IBT_NODE_RECORDS_NOT_FOUND; 5746 continue; 5747 } 5748 5749 if (local_node == B_FALSE) { 5750 ib_gid_t sgid; 5751 int sa_ret; 5752 5753 /* 5754 * Check whether 'gid' and this port has same 5755 * subnet prefix. If not, then there is no use 5756 * in searching from this port. 5757 */ 5758 sgid = hcap->hca_port_info[j].port_sgid0; 5759 if (gid.gid_prefix != sgid.gid_prefix) { 5760 IBTF_DPRINTF_L3(cmlog, 5761 "ibt_gid_to_node_info:Sn_Prefix of " 5762 "GID(%llX) and Port's(%llX) differ", 5763 gid.gid_prefix, sgid.gid_prefix); 5764 retval = IBT_NODE_RECORDS_NOT_FOUND; 5765 continue; 5766 } 5767 5768 /* 5769 * First Get Path Records for the specified DGID 5770 * from this port (SGID). From Path Records, 5771 * note down DLID, then use this DLID as Input 5772 * attribute to get NodeRecords from SA Access. 5773 */ 5774 npaths = 1; 5775 path = NULL; 5776 5777 sa_ret = ibmf_saa_gid_to_pathrecords(saa_handle, 5778 sgid, gid, 0, 0, B_TRUE, &npaths, 0, &len, 5779 &path); 5780 if (sa_ret != IBMF_SUCCESS) { 5781 IBTF_DPRINTF_L2(cmlog, 5782 "ibt_gid_to_node_info: " 5783 "ibmf_saa_gid_to_pathrecords() " 5784 "returned error: %d ", sa_ret); 5785 retval = 5786 ibcm_ibmf_analyze_error(sa_ret); 5787 continue; 5788 } else if ((npaths == 0) || (path == NULL)) { 5789 IBTF_DPRINTF_L3(cmlog, 5790 "ibt_gid_to_node_info: failed (%d) " 5791 "to get path records for the DGID " 5792 "0x%llX from SGID 0x%llX", sa_ret, 5793 gid.gid_guid, sgid.gid_guid); 5794 retval = IBT_NODE_RECORDS_NOT_FOUND; 5795 continue; 5796 } 5797 node_lid = path->DLID; /* LID */ 5798 5799 IBTF_DPRINTF_L3(cmlog, "ibt_gid_to_node_info: " 5800 "Remote Node: LID = 0x%X", node_lid); 5801 5802 /* Free SA_Access memory for path record. */ 5803 kmem_free(path, len); 5804 } 5805 5806 /* Retrieve Node Records from SA Access. */ 5807 bzero(&nr_req, sizeof (sa_node_record_t)); 5808 5809 nr_req.LID = node_lid; /* LID */ 5810 5811 retval = ibcm_get_node_rec(saa_handle, &nr_req, 5812 SA_NODEINFO_COMPMASK_NODELID, &res_p, &len); 5813 if (retval == IBT_NODE_RECORDS_NOT_FOUND) { 5814 IBTF_DPRINTF_L2(cmlog, "ibt_gid_to_node_info: " 5815 "failed (%d) to get Node records", retval); 5816 continue; 5817 } else if (retval != IBT_SUCCESS) { 5818 IBTF_DPRINTF_L2(cmlog, "ibt_gid_to_node_info: " 5819 "failed (%d) to get Node records", retval); 5820 ibcm_dec_hca_acc_cnt(hcap); 5821 goto gid_to_ni_exit; 5822 } 5823 5824 num_rec = len/sizeof (sa_node_record_t); 5825 nr_resp = (sa_node_record_t *)(uchar_t *)res_p; 5826 5827 /* Validate the returned number of records. */ 5828 if ((nr_resp != NULL) && (num_rec > 0)) { 5829 5830 IBCM_DUMP_NODE_REC(nr_resp); 5831 5832 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS( 5833 *node_info_p)) 5834 5835 node_info_p->n_sys_img_guid = 5836 nr_resp->NodeInfo.SystemImageGUID; 5837 node_info_p->n_node_guid = 5838 nr_resp->NodeInfo.NodeGUID; 5839 node_info_p->n_port_guid = 5840 nr_resp->NodeInfo.PortGUID; 5841 node_info_p->n_dev_id = 5842 nr_resp->NodeInfo.DeviceID; 5843 node_info_p->n_revision = 5844 nr_resp->NodeInfo.Revision; 5845 node_info_p->n_vendor_id = 5846 nr_resp->NodeInfo.VendorID; 5847 node_info_p->n_num_ports = 5848 nr_resp->NodeInfo.NumPorts; 5849 node_info_p->n_port_num = 5850 nr_resp->NodeInfo.LocalPortNum; 5851 node_info_p->n_node_type = 5852 nr_resp->NodeInfo.NodeType; 5853 (void) strncpy(node_info_p->n_description, 5854 (char *)&nr_resp->NodeDescription, 64); 5855 5856 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS( 5857 *node_info_p)) 5858 5859 /* 5860 * Deallocate the memory allocated by SA for 5861 * 'nr_resp'. 5862 */ 5863 ibcm_dec_hca_acc_cnt(hcap); 5864 kmem_free(nr_resp, len); 5865 retval = IBT_SUCCESS; 5866 5867 goto gid_to_ni_exit; 5868 } else { 5869 retval = IBT_NODE_RECORDS_NOT_FOUND; 5870 IBTF_DPRINTF_L3(cmlog, "ibt_gid_to_node_info: " 5871 "Node Records NOT found - PortGUID %016llX", 5872 gid.gid_guid); 5873 } 5874 } 5875 ibcm_dec_hca_acc_cnt(hcap); 5876 5877 if (local_node == B_TRUE) 5878 break; 5879 } 5880 5881 gid_to_ni_exit: 5882 if (guid_array) 5883 ibt_free_hca_list(guid_array, num_hcas); 5884 5885 IBTF_DPRINTF_L3(cmlog, "ibt_gid_to_node_info: done. Status %d", retval); 5886 5887 return (retval); 5888 } 5889 5890 5891 ibt_status_t 5892 ibcm_get_node_rec(ibmf_saa_handle_t saa_handle, sa_node_record_t *nr_req, 5893 uint64_t component_mask, void *result_p, size_t *len) 5894 { 5895 ibmf_saa_access_args_t args; 5896 size_t length; 5897 ibt_status_t retval; 5898 5899 args.sq_attr_id = SA_NODERECORD_ATTRID; 5900 args.sq_template = nr_req; 5901 args.sq_access_type = IBMF_SAA_RETRIEVE; 5902 args.sq_template_length = sizeof (sa_node_record_t); 5903 args.sq_component_mask = component_mask; 5904 args.sq_callback = NULL; 5905 args.sq_callback_arg = NULL; 5906 5907 retval = ibcm_contact_sa_access(saa_handle, &args, &length, result_p); 5908 if (retval != IBT_SUCCESS) { 5909 IBTF_DPRINTF_L2(cmlog, "ibcm_get_node_rec: SA Call Failed"); 5910 return (retval); 5911 } 5912 5913 *len = length; 5914 5915 /* Validate the returned number of records. */ 5916 if ((result_p != NULL) && (length > 0)) { 5917 IBTF_DPRINTF_L3(cmlog, "ibcm_get_node_rec: Node Records FOUND"); 5918 5919 /* Got it, done!. */ 5920 return (IBT_SUCCESS); 5921 } else { 5922 IBTF_DPRINTF_L2(cmlog, "ibcm_get_node_rec: Node Rec NOT found"); 5923 return (IBT_NODE_RECORDS_NOT_FOUND); 5924 } 5925 } 5926 5927 5928 /* 5929 * Function: 5930 * ibt_lid_to_node_info() 5931 * Input: 5932 * lid Identifies the IB Node and port for which to obtain 5933 * Node information. 5934 * Output: 5935 * node_info_p A pointer to an ibt_node_info_t structure (allocated 5936 * by the caller) in which to return the node information. 5937 * Returns: 5938 * IBT_SUCCESS 5939 * IBT_INVALID_PARAM 5940 * IBT_NODE_RECORDS_NOT_FOUND 5941 * IBT_NO_HCAS_AVAILABLE 5942 * Description: 5943 * Retrieve Node Information for the specified LID. 5944 */ 5945 ibt_status_t 5946 ibt_lid_to_node_info(ib_lid_t lid, ibt_node_info_t *node_info_p) 5947 { 5948 ibt_status_t retval; 5949 ibcm_hca_info_t *hcap; 5950 uint8_t i, j; 5951 ib_guid_t *guid_array = NULL; 5952 uint_t num_hcas = 0; 5953 5954 5955 IBTF_DPRINTF_L4(cmlog, "ibt_lid_to_node_info(0x%lX, %p)", 5956 lid, node_info_p); 5957 5958 if ((lid == 0) || (node_info_p == NULL)) { 5959 IBTF_DPRINTF_L2(cmlog, "ibt_lid_to_node_info: " 5960 "Lid is zero, or node_info_p is NULL."); 5961 return (IBT_INVALID_PARAM); 5962 } 5963 5964 /* Get the number of HCAs and their GUIDs */ 5965 num_hcas = ibt_get_hca_list(&guid_array); 5966 IBTF_DPRINTF_L4(cmlog, "ibt_lid_to_node_info: ibt_get_hca_list " 5967 "returned %d hcas", num_hcas); 5968 5969 if (num_hcas == 0) { 5970 IBTF_DPRINTF_L2(cmlog, "ibt_lid_to_node_info: " 5971 "NO HCA's Found on this system"); 5972 return (IBT_NO_HCAS_AVAILABLE); 5973 } 5974 5975 for (i = 0; i < num_hcas; i++) { 5976 hcap = ibcm_find_hca_entry(guid_array[i]); 5977 if (hcap == NULL) { 5978 IBTF_DPRINTF_L3(cmlog, "ibt_lid_to_node_info: " 5979 "HCA(%llX) info not found", guid_array[i]); 5980 retval = IBT_NO_HCAS_AVAILABLE; 5981 continue; 5982 } 5983 5984 for (j = 0; j < hcap->hca_num_ports; j++) { 5985 uint8_t port; 5986 ibmf_saa_handle_t saa_handle; 5987 uint_t num_rec; 5988 size_t len; 5989 void *res_p; 5990 sa_node_record_t nr_req, *nr_resp; 5991 5992 port = j + 1; 5993 5994 /* Get SA Access Handle. */ 5995 saa_handle = ibcm_get_saa_handle(hcap, port); 5996 if (saa_handle == NULL) { 5997 IBTF_DPRINTF_L3(cmlog, "ibt_lid_to_node_info: " 5998 "Port %d of HCA (%llX) is NOT ACTIVE", 5999 port, guid_array[i]); 6000 retval = IBT_NODE_RECORDS_NOT_FOUND; 6001 continue; 6002 } 6003 6004 /* Retrieve Node Records from SA Access. */ 6005 bzero(&nr_req, sizeof (sa_node_record_t)); 6006 6007 nr_req.LID = lid; /* LID */ 6008 6009 retval = ibcm_get_node_rec(saa_handle, &nr_req, 6010 SA_NODEINFO_COMPMASK_NODELID, &res_p, &len); 6011 if (retval == IBT_NODE_RECORDS_NOT_FOUND) { 6012 IBTF_DPRINTF_L2(cmlog, "ibt_lid_to_node_info: " 6013 "failed (%d) to get Node records", retval); 6014 continue; 6015 } else if (retval != IBT_SUCCESS) { 6016 IBTF_DPRINTF_L2(cmlog, "ibt_lid_to_node_info: " 6017 "failed (%d) to get Node records", retval); 6018 ibcm_dec_hca_acc_cnt(hcap); 6019 goto lid_to_ni_exit; 6020 } 6021 6022 num_rec = len/sizeof (sa_node_record_t); 6023 nr_resp = (sa_node_record_t *)(uchar_t *)res_p; 6024 6025 /* Validate the returned number of records. */ 6026 if ((nr_resp != NULL) && (num_rec > 0)) { 6027 6028 IBCM_DUMP_NODE_REC(nr_resp); 6029 6030 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS( 6031 *node_info_p)) 6032 6033 node_info_p->n_sys_img_guid = 6034 nr_resp->NodeInfo.SystemImageGUID; 6035 node_info_p->n_node_guid = 6036 nr_resp->NodeInfo.NodeGUID; 6037 node_info_p->n_port_guid = 6038 nr_resp->NodeInfo.PortGUID; 6039 node_info_p->n_dev_id = 6040 nr_resp->NodeInfo.DeviceID; 6041 node_info_p->n_revision = 6042 nr_resp->NodeInfo.Revision; 6043 node_info_p->n_vendor_id = 6044 nr_resp->NodeInfo.VendorID; 6045 node_info_p->n_num_ports = 6046 nr_resp->NodeInfo.NumPorts; 6047 node_info_p->n_port_num = 6048 nr_resp->NodeInfo.LocalPortNum; 6049 node_info_p->n_node_type = 6050 nr_resp->NodeInfo.NodeType; 6051 (void) strncpy(node_info_p->n_description, 6052 (char *)&nr_resp->NodeDescription, 64); 6053 6054 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS( 6055 *node_info_p)) 6056 6057 /* 6058 * Deallocate the memory allocated by SA for 6059 * 'nr_resp'. 6060 */ 6061 ibcm_dec_hca_acc_cnt(hcap); 6062 kmem_free(nr_resp, len); 6063 retval = IBT_SUCCESS; 6064 6065 goto lid_to_ni_exit; 6066 } else { 6067 retval = IBT_NODE_RECORDS_NOT_FOUND; 6068 IBTF_DPRINTF_L3(cmlog, "ibt_lid_to_node_info: " 6069 "Node Records NOT found - LID 0x%lX", 6070 lid); 6071 } 6072 } 6073 ibcm_dec_hca_acc_cnt(hcap); 6074 } 6075 6076 lid_to_ni_exit: 6077 if (guid_array) 6078 ibt_free_hca_list(guid_array, num_hcas); 6079 6080 IBTF_DPRINTF_L3(cmlog, "ibt_lid_to_node_info: done. Status %d", retval); 6081 6082 return (retval); 6083 } 6084 6085 /* 6086 * Function: 6087 * ibt_get_companion_port_gids() 6088 * Description: 6089 * Get list of GID's available on a companion port(s) of the specified 6090 * GID or list of GIDs available on a specified Node GUID/SystemImage GUID. 6091 */ 6092 ibt_status_t 6093 ibt_get_companion_port_gids(ib_gid_t gid, ib_guid_t hca_guid, 6094 ib_guid_t sysimg_guid, ib_gid_t **gids_p, uint_t *num_gids_p) 6095 { 6096 sa_node_record_t nr_req, *nr_resp; 6097 void *res_p; 6098 ibmf_saa_handle_t saa_handle; 6099 int sa_ret; 6100 ibt_status_t retval = IBT_SUCCESS; 6101 ibcm_hca_info_t *hcap; 6102 ibtl_cm_hca_port_t hport; 6103 int i, j; 6104 uint_t num_rec; 6105 ib_guid_t *guid_array = NULL; 6106 sa_path_record_t *path; 6107 size_t len; 6108 uint8_t npaths; 6109 uint32_t num_hcas = 0; 6110 boolean_t local_node = B_FALSE; 6111 boolean_t local_hca = B_FALSE; 6112 ib_guid_t h_guid = hca_guid; 6113 ib_gid_t *gidp = NULL, *t_gidp = NULL; 6114 int multi_hca_loop = 0; 6115 6116 IBTF_DPRINTF_L4(cmlog, "ibt_get_companion_port_gids(%llX:%llX, %llX, " 6117 "%llX)", gid.gid_prefix, gid.gid_guid, hca_guid, sysimg_guid); 6118 6119 if (((gid.gid_prefix == 0) || (gid.gid_guid == 0)) && (hca_guid == 0) && 6120 (sysimg_guid == 0)) { 6121 IBTF_DPRINTF_L2(cmlog, "ibt_get_companion_port_gids: " 6122 "Null Input attribute specified."); 6123 return (IBT_INVALID_PARAM); 6124 } 6125 6126 if ((num_gids_p == NULL) || (gids_p == NULL)) { 6127 IBTF_DPRINTF_L2(cmlog, "ibt_get_companion_port_gids: " 6128 "num_gids_p or gids_p is NULL"); 6129 return (IBT_INVALID_PARAM); 6130 } 6131 6132 *num_gids_p = 0; 6133 6134 /* Get the number of HCAs and their GUIDs */ 6135 if ((num_hcas = ibt_get_hca_list(&guid_array)) == 0) { 6136 IBTF_DPRINTF_L2(cmlog, "ibt_get_companion_port_gids: " 6137 "NO HCA's Found on this system"); 6138 return (IBT_NO_HCAS_AVAILABLE); 6139 } 6140 6141 IBTF_DPRINTF_L4(cmlog, "ibt_get_companion_port_gids: " 6142 "ibt_get_hca_list() returned %d hcas", num_hcas); 6143 6144 /* 6145 * If 'gid' is on local node, then get node lid (i.e. base lid of the 6146 * associated port) info via ibtl_cm_get_hca_port() call. 6147 */ 6148 bzero(&hport, sizeof (ibtl_cm_hca_port_t)); 6149 if ((gid.gid_prefix != 0) && (gid.gid_guid != 0) && 6150 (ibtl_cm_get_hca_port(gid, 0, &hport) == IBT_SUCCESS)) { 6151 6152 if ((hca_guid != 0) && (hca_guid != hport.hp_hca_guid)) { 6153 IBTF_DPRINTF_L2(cmlog, "ibt_get_companion_port_gids: " 6154 "Invalid GID<->HCAGUID combination specified."); 6155 retval = IBT_INVALID_PARAM; 6156 goto get_comp_pgid_exit; 6157 } 6158 h_guid = hport.hp_hca_guid; 6159 local_node = B_TRUE; 6160 6161 IBTF_DPRINTF_L4(cmlog, "ibt_get_companion_port_gids: " 6162 "Local Node: HCA (0x%llX)", h_guid); 6163 } else if (h_guid) { /* Is specified HCA GUID - local? */ 6164 for (i = 0; i < num_hcas; i++) { 6165 if (h_guid == guid_array[i]) { 6166 local_hca = B_TRUE; 6167 break; 6168 } 6169 } 6170 } else if (sysimg_guid) { /* Is specified SystemImage GUID - local? */ 6171 for (i = 0; i < num_hcas; i++) { 6172 ibt_status_t ret; 6173 ibt_hca_attr_t hca_attr; 6174 6175 ret = ibt_query_hca_byguid(guid_array[i], &hca_attr); 6176 if (ret != IBT_SUCCESS) { 6177 IBTF_DPRINTF_L2(cmlog, 6178 "ibt_get_companion_port_gids: HCA(%llX) " 6179 "info not found", guid_array[i]); 6180 retval = IBT_NO_HCAS_AVAILABLE; 6181 continue; 6182 } 6183 if (hca_attr.hca_si_guid == sysimg_guid) { 6184 if ((hca_guid != 0) && 6185 (hca_guid != hca_attr.hca_node_guid)) { 6186 IBTF_DPRINTF_L2(cmlog, 6187 "ibt_get_companion_port_gids: " 6188 "Invalid SysImg<->HCA GUID " 6189 "combination specified."); 6190 retval = IBT_INVALID_PARAM; 6191 goto get_comp_pgid_exit; 6192 } 6193 local_hca = B_TRUE; 6194 h_guid = hca_attr.hca_node_guid; 6195 break; 6196 } 6197 } 6198 } 6199 6200 if ((local_node == B_TRUE) || (local_hca == B_TRUE)) { 6201 retval = ibtl_cm_get_local_comp_gids(h_guid, gid, gids_p, 6202 num_gids_p); 6203 goto get_comp_pgid_exit; 6204 } 6205 6206 get_comp_for_multihca: 6207 /* We will be here, if request is for remote node */ 6208 for (i = 0; i < num_hcas; i++) { 6209 int multism; 6210 uint_t count = 0; 6211 int multi_sm_loop = 0; 6212 uint_t k = 0, l; 6213 6214 hcap = ibcm_find_hca_entry(guid_array[i]); 6215 if (hcap == NULL) { 6216 IBTF_DPRINTF_L3(cmlog, "ibt_get_companion_port_gids: " 6217 "HCA(%llX) info not found", guid_array[i]); 6218 retval = IBT_NO_HCAS_AVAILABLE; 6219 continue; 6220 } 6221 6222 /* 1 - MultiSM, 0 - Single SM */ 6223 multism = ibtl_cm_is_multi_sm(guid_array[i]); 6224 6225 for (j = 0; j < hcap->hca_num_ports; j++) { 6226 ib_gid_t sgid; 6227 uint64_t c_mask = 0; 6228 ib_guid_t pg; 6229 uint_t port = j; 6230 6231 get_comp_for_multism: 6232 IBTF_DPRINTF_L3(cmlog, "ibt_get_companion_port_gids: " 6233 "Port %d, HCA %llX, MultiSM= %d, Loop=%d", 6234 port + 1, h_guid, multism, multi_sm_loop); 6235 6236 /* Get SA Access Handle. */ 6237 saa_handle = ibcm_get_saa_handle(hcap, port + 1); 6238 if (saa_handle == NULL) { 6239 IBTF_DPRINTF_L2(cmlog, 6240 "ibt_get_companion_port_gids: " 6241 "Port (%d) - NOT ACTIVE", port + 1); 6242 retval = IBT_GIDS_NOT_FOUND; 6243 continue; 6244 } 6245 6246 /* 6247 * Check whether 'gid' and this port has same subnet 6248 * prefix. If not, then there is no use in searching 6249 * from this port. 6250 */ 6251 sgid = hcap->hca_port_info[port].port_sgid0; 6252 if ((h_guid == 0) && (gid.gid_prefix != 0) && 6253 (multi_sm_loop == 0) && 6254 (gid.gid_prefix != sgid.gid_prefix)) { 6255 IBTF_DPRINTF_L2(cmlog, 6256 "ibt_get_companion_port_gids: SnPrefix of " 6257 "GID(%llX) and Port SN_Pfx(%llX) differ", 6258 gid.gid_prefix, sgid.gid_prefix); 6259 retval = IBT_GIDS_NOT_FOUND; 6260 continue; 6261 } 6262 6263 /* 6264 * If HCA GUID or System Image GUID is specified, then 6265 * we can achieve our goal sooner!. 6266 */ 6267 if ((h_guid == 0) && (sysimg_guid == 0)) { 6268 /* So only GID info is provided. */ 6269 6270 /* 6271 * First Get Path Records for the specified DGID 6272 * from this port (SGID). From Path Records, 6273 * note down DLID, then use this DLID as Input 6274 * attribute to get NodeRecords. 6275 */ 6276 npaths = 1; 6277 path = NULL; 6278 6279 sa_ret = ibmf_saa_gid_to_pathrecords(saa_handle, 6280 sgid, gid, 0, 0, B_TRUE, &npaths, 0, &len, 6281 &path); 6282 if (sa_ret != IBMF_SUCCESS) { 6283 IBTF_DPRINTF_L2(cmlog, 6284 "ibt_get_companion_port_gids: " 6285 "ibmf_saa_gid_to_pathrecords() " 6286 "returned error: %d ", sa_ret); 6287 retval = 6288 ibcm_ibmf_analyze_error(sa_ret); 6289 ibcm_dec_hca_acc_cnt(hcap); 6290 goto get_comp_pgid_exit; 6291 } else if ((npaths == 0) || (path == NULL)) { 6292 IBTF_DPRINTF_L2(cmlog, 6293 "ibt_get_companion_port_gids: " 6294 "failed (%d) to get path records " 6295 "for the DGID (0x%llX) from SGID " 6296 "(0x%llX)", sa_ret, gid.gid_guid, 6297 sgid.gid_guid); 6298 retval = IBT_GIDS_NOT_FOUND; 6299 continue; 6300 } 6301 6302 bzero(&nr_req, sizeof (sa_node_record_t)); 6303 nr_req.LID = path->DLID; /* LID */ 6304 6305 IBTF_DPRINTF_L3(cmlog, 6306 "ibt_get_companion_port_gids: " 6307 "Remote Node: LID = 0x%X", nr_req.LID); 6308 6309 /* Free SA_Access memory for path record. */ 6310 kmem_free(path, len); 6311 6312 IBTF_DPRINTF_L3(cmlog, 6313 "ibt_get_companion_port_gids: SAA Call: " 6314 "based on LID "); 6315 6316 retval = ibcm_get_node_rec(saa_handle, &nr_req, 6317 SA_NODEINFO_COMPMASK_NODELID, &res_p, &len); 6318 if (retval == IBT_NODE_RECORDS_NOT_FOUND) { 6319 IBTF_DPRINTF_L2(cmlog, 6320 "ibt_get_companion_port_gids: " 6321 "failed (%d) to get Node records", 6322 retval); 6323 continue; 6324 } else if (retval != IBT_SUCCESS) { 6325 IBTF_DPRINTF_L2(cmlog, 6326 "ibt_get_companion_port_gids: " 6327 "failed (%d) to get Node records", 6328 retval); 6329 ibcm_dec_hca_acc_cnt(hcap); 6330 goto get_comp_pgid_exit; 6331 } 6332 6333 nr_resp = (sa_node_record_t *)(uchar_t *)res_p; 6334 /* Note down HCA GUID info. */ 6335 h_guid = nr_resp->NodeInfo.NodeGUID; 6336 6337 IBTF_DPRINTF_L3(cmlog, 6338 "ibt_get_companion_port_gids: " 6339 "Remote HCA GUID: 0x%llX", h_guid); 6340 6341 IBCM_DUMP_NODE_REC(nr_resp); 6342 6343 kmem_free(res_p, len); 6344 } 6345 6346 bzero(&nr_req, sizeof (sa_node_record_t)); 6347 if (h_guid != 0) { 6348 nr_req.NodeInfo.NodeGUID = h_guid; 6349 c_mask = SA_NODEINFO_COMPMASK_NODEGUID; 6350 } 6351 6352 if (sysimg_guid != 0) { 6353 nr_req.NodeInfo.SystemImageGUID = sysimg_guid; 6354 c_mask |= SA_NODEINFO_COMPMASK_SYSIMAGEGUID; 6355 } 6356 6357 IBTF_DPRINTF_L3(cmlog, "ibt_get_companion_port_gids: " 6358 "SAA Call: CMASK= 0x%llX", c_mask); 6359 6360 retval = ibcm_get_node_rec(saa_handle, &nr_req, c_mask, 6361 &res_p, &len); 6362 if (retval == IBT_NODE_RECORDS_NOT_FOUND) { 6363 IBTF_DPRINTF_L3(cmlog, 6364 "ibt_get_companion_port_gids: " 6365 "failed (%d) to get Node records", retval); 6366 continue; 6367 } else if (retval != IBT_SUCCESS) { 6368 IBTF_DPRINTF_L2(cmlog, 6369 "ibt_get_companion_port_gids: Error: (%d) " 6370 "while getting Node records", retval); 6371 ibcm_dec_hca_acc_cnt(hcap); 6372 goto get_comp_pgid_exit; 6373 } 6374 6375 num_rec = len/sizeof (sa_node_record_t); 6376 6377 /* We will be here, only if we found some NodeRec */ 6378 if (gid.gid_prefix && gid.gid_guid) { 6379 nr_resp = (sa_node_record_t *)res_p; 6380 for (l = 0; l < num_rec; l++, nr_resp++) { 6381 pg = nr_resp->NodeInfo.PortGUID; 6382 if (gid.gid_guid != pg) 6383 count++; 6384 } 6385 } else { 6386 count = num_rec; 6387 } 6388 6389 if (count != 0) { 6390 if (multi_sm_loop == 1) { 6391 count += k; 6392 t_gidp = kmem_zalloc(count * 6393 sizeof (ib_gid_t), KM_SLEEP); 6394 6395 if ((k != 0) && (gidp != NULL)) { 6396 bcopy(gidp, t_gidp, 6397 k * sizeof (ib_gid_t)); 6398 kmem_free(gidp, 6399 k * sizeof (ib_gid_t)); 6400 } 6401 gidp = t_gidp; 6402 } else { 6403 gidp = kmem_zalloc(count * 6404 sizeof (ib_gid_t), KM_SLEEP); 6405 } 6406 *num_gids_p = count; 6407 *gids_p = gidp; 6408 6409 nr_resp = (sa_node_record_t *)res_p; 6410 for (l = 0; l < num_rec; l++, nr_resp++) { 6411 IBCM_DUMP_NODE_REC(nr_resp); 6412 6413 pg = nr_resp->NodeInfo.PortGUID; 6414 IBTF_DPRINTF_L4(cmlog, 6415 "ibt_get_companion_port_gids: " 6416 "PortGID %llX", pg); 6417 6418 if (pg != gid.gid_guid) { 6419 gidp[k].gid_prefix = 6420 sgid.gid_prefix; 6421 gidp[k].gid_guid = pg; 6422 6423 IBTF_DPRINTF_L3(cmlog, 6424 "ibt_get_companion_pgids: " 6425 "GID[%d] = %llX:%llX", k, 6426 gidp[k].gid_prefix, 6427 gidp[k].gid_guid); 6428 6429 k++; 6430 if (k == count) 6431 break; 6432 } 6433 } 6434 retval = IBT_SUCCESS; /* done!. */ 6435 kmem_free(res_p, len); 6436 ibcm_dec_hca_acc_cnt(hcap); 6437 goto get_comp_pgid_exit; 6438 } else { 6439 IBTF_DPRINTF_L2(cmlog, 6440 "ibt_get_companion_port_gids: " 6441 "Companion PortGIDs not available"); 6442 retval = IBT_GIDS_NOT_FOUND; 6443 } 6444 /* Deallocate the memory for 'res_p'. */ 6445 kmem_free(res_p, len); 6446 6447 /* 6448 * If we are on MultiSM setup, then we need to lookout 6449 * from that subnet port too. 6450 */ 6451 if (multism) { 6452 /* break if already searched both the subnet */ 6453 if (multi_sm_loop == 1) 6454 break; 6455 6456 port = (j == 0) ? 1 : 0; 6457 multi_sm_loop = 1; 6458 goto get_comp_for_multism; 6459 } else { 6460 break; 6461 } 6462 } 6463 ibcm_dec_hca_acc_cnt(hcap); 6464 6465 /* 6466 * We may be on dual HCA with dual SM configured system. And 6467 * the input attr GID was visible from second HCA. So in order 6468 * to get the companion portgid we need to re-look from the 6469 * first HCA ports. 6470 */ 6471 if ((num_hcas > 1) && (i > 0) && (h_guid != 0) && 6472 (multi_hca_loop != 1)) { 6473 multi_hca_loop = 1; 6474 goto get_comp_for_multihca; 6475 } 6476 } 6477 if (*num_gids_p == 0) 6478 retval = IBT_GIDS_NOT_FOUND; 6479 6480 get_comp_pgid_exit: 6481 if (guid_array) 6482 ibt_free_hca_list(guid_array, num_hcas); 6483 6484 if ((retval != IBT_SUCCESS) && (*num_gids_p != 0)) { 6485 retval = IBT_SUCCESS; 6486 } 6487 6488 IBTF_DPRINTF_L3(cmlog, "ibt_get_companion_port_gids: done. Status %d, " 6489 "Found %d GIDs", retval, *num_gids_p); 6490 6491 return (retval); 6492 } 6493 6494 /* RDMA IP CM Support routines */ 6495 ibt_status_t 6496 ibt_get_src_ip(ibt_srcip_attr_t *sattr, ibt_srcip_info_t **src_info_p, 6497 uint_t *entries_p) 6498 { 6499 ibt_srcip_info_t *s_ip; 6500 ibcm_arp_ip_t *ipp; 6501 ibcm_arp_ibd_insts_t ibds; 6502 uint8_t i, j; 6503 uint_t count; 6504 ibt_status_t retval = IBT_SUCCESS; 6505 6506 IBTF_DPRINTF_L4(cmlog, "ibt_get_src_ip(%p, %p, %p)", 6507 sattr, src_info_p, entries_p); 6508 6509 if (sattr == NULL || entries_p == NULL) { 6510 IBTF_DPRINTF_L3(cmlog, "ibt_get_src_ip: Invalid I/P Args."); 6511 return (IBT_INVALID_PARAM); 6512 } 6513 6514 if (sattr->sip_gid.gid_prefix == 0 || sattr->sip_gid.gid_guid == 0) { 6515 IBTF_DPRINTF_L3(cmlog, "ibt_get_src_ip: Invalid GID."); 6516 return (IBT_INVALID_PARAM); 6517 } 6518 6519 /* TBD: Zoneid */ 6520 retval = ibcm_arp_get_ibds(&ibds, sattr->sip_family); 6521 if (retval != IBT_SUCCESS) { 6522 IBTF_DPRINTF_L2(cmlog, "ibt_get_src_ip: ibcm_arp_get_ibds " 6523 "failed to get IBD Instances: ret 0x%x", retval); 6524 goto get_src_ip_end; 6525 } 6526 6527 count = 0; 6528 for (i = 0, ipp = ibds.ibcm_arp_ip; i < ibds.ibcm_arp_ibd_cnt; 6529 i++, ipp++) { 6530 if (ipp->ip_inet_family == AF_UNSPEC) 6531 continue; 6532 if (ipp->ip_port_gid.gid_prefix == sattr->sip_gid.gid_prefix && 6533 ipp->ip_port_gid.gid_guid == sattr->sip_gid.gid_guid) { 6534 if ((sattr->sip_pkey) && 6535 (ipp->ip_pkey != sattr->sip_pkey)) 6536 continue; 6537 6538 if ((sattr->sip_zoneid != ALL_ZONES) && 6539 (sattr->sip_zoneid != ipp->ip_zoneid)) 6540 continue; 6541 6542 count++; 6543 break; 6544 } 6545 } 6546 6547 if (count) { 6548 /* 6549 * Allocate memory for return buffer, to be freed by 6550 * ibt_free_srcip_info(). 6551 */ 6552 s_ip = kmem_alloc((count * sizeof (ibt_srcip_info_t)), 6553 KM_SLEEP); 6554 6555 *src_info_p = s_ip; 6556 *entries_p = count; 6557 6558 j = 0; 6559 for (i = 0, ipp = ibds.ibcm_arp_ip; i < ibds.ibcm_arp_ibd_cnt; 6560 i++, ipp++) { 6561 if (ipp->ip_inet_family == AF_UNSPEC) 6562 continue; 6563 if ((ipp->ip_port_gid.gid_prefix == 6564 sattr->sip_gid.gid_prefix) && 6565 (ipp->ip_port_gid.gid_guid == 6566 sattr->sip_gid.gid_guid)) { 6567 if ((sattr->sip_pkey) && 6568 (ipp->ip_pkey != sattr->sip_pkey)) 6569 continue; 6570 6571 if ((sattr->sip_zoneid != ALL_ZONES) && 6572 (sattr->sip_zoneid != ipp->ip_zoneid)) 6573 continue; 6574 6575 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*s_ip)) 6576 s_ip[j].ip_addr.family = ipp->ip_inet_family; 6577 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*s_ip)) 6578 if (s_ip[j].ip_addr.family == AF_INET) { 6579 bcopy(&ipp->ip_cm_sin.sin_addr, 6580 &s_ip[j].ip_addr.un.ip4addr, 6581 sizeof (in_addr_t)); 6582 } else if (s_ip[j].ip_addr.family == AF_INET6) { 6583 bcopy(&ipp->ip_cm_sin6.sin6_addr, 6584 &s_ip[j].ip_addr.un.ip6addr, 6585 sizeof (in6_addr_t)); 6586 /* TBD: scope_id */ 6587 } 6588 IBCM_PRINT_IP("ibt_get_src_ip", 6589 &s_ip[j].ip_addr); 6590 j++; 6591 } 6592 } 6593 } else { 6594 retval = IBT_SRC_IP_NOT_FOUND; 6595 } 6596 6597 get_src_ip_end: 6598 ibcm_arp_free_ibds(&ibds); 6599 return (retval); 6600 } 6601 6602 /* 6603 * ibt_free_srcip_info() 6604 * Free the memory allocated by successful ibt_get_src_ip() 6605 * 6606 * src_info Pointer returned by ibt_get_src_ip(). 6607 * 6608 * entries The number of ibt_ip_addr_t entries to free. 6609 */ 6610 void 6611 ibt_free_srcip_info(ibt_srcip_info_t *src_info, uint_t entries) 6612 { 6613 IBTF_DPRINTF_L3(cmlog, "ibt_free_srcip_info: " 6614 "Free <%d> entries from 0x%p", entries, src_info); 6615 6616 if ((src_info != NULL) && (entries > 0)) 6617 kmem_free(src_info, entries * sizeof (ibt_srcip_info_t)); 6618 else 6619 IBTF_DPRINTF_L2(cmlog, "ibt_free_srcip_info: " 6620 "ERROR: NULL buf pointer or ZERO length specified."); 6621 } 6622 6623 6624 ib_svc_id_t 6625 ibt_get_ip_sid(uint8_t protocol_num, in_port_t dst_port) 6626 { 6627 ib_svc_id_t sid; 6628 6629 IBTF_DPRINTF_L4(cmlog, "ibt_get_ip_sid(%X, %lX)", protocol_num, 6630 dst_port); 6631 6632 /* 6633 * If protocol_num is non-zero, then formulate the SID and return it. 6634 * If protocol_num is zero, then we need to assign a locally generated 6635 * IP SID with IB_SID_IPADDR_PREFIX. 6636 */ 6637 if (protocol_num) { 6638 sid = IB_SID_IPADDR_PREFIX | protocol_num << 16 | dst_port; 6639 } else { 6640 sid = ibcm_alloc_ip_sid(); 6641 } 6642 6643 IBTF_DPRINTF_L3(cmlog, "ibt_get_ip_sid: SID: 0x%016llX", sid); 6644 return (sid); 6645 } 6646 6647 ibt_status_t 6648 ibt_release_ip_sid(ib_svc_id_t ip_sid) 6649 { 6650 IBTF_DPRINTF_L4(cmlog, "ibt_release_ip_sid(%llX)", ip_sid); 6651 6652 if (((ip_sid & IB_SID_IPADDR_PREFIX_MASK) != 0) || 6653 (!(ip_sid & IB_SID_IPADDR_PREFIX))) { 6654 IBTF_DPRINTF_L2(cmlog, "ibt_release_ip_sid(0x%016llX): ERROR: " 6655 "Called for Non-RDMA IP SID", ip_sid); 6656 return (IBT_INVALID_PARAM); 6657 } 6658 6659 /* 6660 * If protocol_num in ip_sid are all ZEROs, then this SID is allocated 6661 * by IBTF. If not, then the specified ip_sid is invalid. 6662 */ 6663 if (ip_sid & IB_SID_IPADDR_IPNUM_MASK) { 6664 IBTF_DPRINTF_L2(cmlog, "ibt_release_ip_sid(0x%016llX): ERROR: " 6665 "Called for Non-IBTF assigned RDMA IP SID", ip_sid); 6666 return (IBT_INVALID_PARAM); 6667 } 6668 6669 ibcm_free_ip_sid(ip_sid); 6670 6671 return (IBT_SUCCESS); 6672 } 6673 6674 6675 uint8_t 6676 ibt_get_ip_protocol_num(ib_svc_id_t sid) 6677 { 6678 return ((sid & IB_SID_IPADDR_IPNUM_MASK) >> 16); 6679 } 6680 6681 in_port_t 6682 ibt_get_ip_dst_port(ib_svc_id_t sid) 6683 { 6684 return (sid & IB_SID_IPADDR_PORTNUM_MASK); 6685 } 6686 6687 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", ibt_ip_cm_info_t)) 6688 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", ibcm_ip_pvtdata_t)) 6689 6690 ibt_status_t 6691 ibt_format_ip_private_data(ibt_ip_cm_info_t *ip_cm_info, 6692 ibt_priv_data_len_t priv_data_len, void *priv_data_p) 6693 { 6694 ibcm_ip_pvtdata_t ip_data; 6695 6696 IBTF_DPRINTF_L4(cmlog, "ibt_format_ip_private_data(%p, %d, %p)", 6697 ip_cm_info, priv_data_len, priv_data_p); 6698 6699 if ((ip_cm_info == NULL) || (priv_data_p == NULL) || 6700 (priv_data_len < IBT_IP_HDR_PRIV_DATA_SZ)) { 6701 IBTF_DPRINTF_L2(cmlog, "ibt_format_ip_private_data: ERROR " 6702 "Invalid Inputs."); 6703 return (IBT_INVALID_PARAM); 6704 } 6705 6706 bzero(&ip_data, sizeof (ibcm_ip_pvtdata_t)); 6707 ip_data.ip_srcport = ip_cm_info->src_port; /* Source Port */ 6708 6709 IBCM_PRINT_IP("format_ip_pvt: src", &ip_cm_info->src_addr); 6710 IBCM_PRINT_IP("format_ip_pvt: dst", &ip_cm_info->dst_addr); 6711 /* IPV = 0x4, if IP-Addr are IPv4 format, else 0x6 for IPv6 */ 6712 if (ip_cm_info->src_addr.family == AF_INET) { 6713 ip_data.ip_ipv = IBT_CM_IP_IPV_V4; 6714 ip_data.ip_srcv4 = ip_cm_info->src_addr.un.ip4addr; 6715 ip_data.ip_dstv4 = ip_cm_info->dst_addr.un.ip4addr; 6716 } else if (ip_cm_info->src_addr.family == AF_INET6) { 6717 ip_data.ip_ipv = IBT_CM_IP_IPV_V6; 6718 bcopy(&ip_cm_info->src_addr.un.ip6addr, 6719 &ip_data.ip_srcv6, sizeof (in6_addr_t)); 6720 bcopy(&ip_cm_info->dst_addr.un.ip6addr, 6721 &ip_data.ip_dstv6, sizeof (in6_addr_t)); 6722 } else { 6723 IBTF_DPRINTF_L2(cmlog, "ibt_format_ip_private_data: ERROR " 6724 "IP Addr needs to be either AF_INET or AF_INET6 family."); 6725 return (IBT_INVALID_PARAM); 6726 } 6727 6728 ip_data.ip_MajV = IBT_CM_IP_MAJ_VER; 6729 ip_data.ip_MinV = IBT_CM_IP_MIN_VER; 6730 6731 bcopy(&ip_data, priv_data_p, IBT_IP_HDR_PRIV_DATA_SZ); 6732 6733 return (IBT_SUCCESS); 6734 } 6735 6736 6737 ibt_status_t 6738 ibt_get_ip_data(ibt_priv_data_len_t priv_data_len, void *priv_data, 6739 ibt_ip_cm_info_t *ip_cm_infop) 6740 { 6741 ibcm_ip_pvtdata_t ip_data; 6742 6743 IBTF_DPRINTF_L4(cmlog, "ibt_get_ip_data(%d, %p, %p)", 6744 priv_data_len, priv_data, ip_cm_infop); 6745 6746 if ((ip_cm_infop == NULL) || (priv_data == NULL) || 6747 (priv_data_len < IBT_IP_HDR_PRIV_DATA_SZ)) { 6748 IBTF_DPRINTF_L2(cmlog, "ibt_get_ip_data: ERROR Invalid Inputs"); 6749 return (IBT_INVALID_PARAM); 6750 } 6751 6752 bcopy(priv_data, &ip_data, IBT_IP_HDR_PRIV_DATA_SZ); 6753 ip_cm_infop->src_port = ip_data.ip_srcport; /* Source Port */ 6754 6755 /* IPV = 0x4, if IP Address are IPv4 format, else 0x6 for IPv6 */ 6756 if (ip_data.ip_ipv == IBT_CM_IP_IPV_V4) { 6757 /* Copy IPv4 Addr */ 6758 ip_cm_infop->src_addr.family = ip_cm_infop->dst_addr.family = 6759 AF_INET; 6760 ip_cm_infop->src_addr.un.ip4addr = ip_data.ip_srcv4; 6761 ip_cm_infop->dst_addr.un.ip4addr = ip_data.ip_dstv4; 6762 } else if (ip_data.ip_ipv == IBT_CM_IP_IPV_V6) { 6763 /* Copy IPv6 Addr */ 6764 ip_cm_infop->src_addr.family = ip_cm_infop->dst_addr.family = 6765 AF_INET6; 6766 bcopy(&ip_data.ip_srcv6, &ip_cm_infop->src_addr.un.ip6addr, 6767 sizeof (in6_addr_t)); 6768 bcopy(&ip_data.ip_dstv6, &ip_cm_infop->dst_addr.un.ip6addr, 6769 sizeof (in6_addr_t)); 6770 } else { 6771 IBTF_DPRINTF_L2(cmlog, "ibt_get_ip_data: ERROR: IP Addr needs" 6772 " to be either AF_INET or AF_INET6 family."); 6773 return (IBT_INVALID_PARAM); 6774 } 6775 IBCM_PRINT_IP("ibt_get_ip_data: src", &ip_cm_infop->src_addr); 6776 IBCM_PRINT_IP("ibt_get_ip_data: dst", &ip_cm_infop->dst_addr); 6777 6778 return (IBT_SUCCESS); 6779 } 6780 6781 6782 /* Routines for warlock */ 6783 6784 /* ARGSUSED */ 6785 static void 6786 ibcm_dummy_mcg_handler(void *arg, ibt_status_t retval, ibt_mcg_info_t *minfo) 6787 { 6788 ibcm_join_mcg_tqarg_t dummy_mcg; 6789 6790 dummy_mcg.func = ibcm_dummy_mcg_handler; 6791 6792 IBTF_DPRINTF_L5(cmlog, "ibcm_dummy_mcg_handler: " 6793 "dummy_mcg.func %p", dummy_mcg.func); 6794 } 6795 6796 6797 /* ARGSUSED */ 6798 static void 6799 ibcm_dummy_recycle_rc_handler(ibt_status_t retval, void *arg) 6800 { 6801 ibcm_taskq_recycle_arg_t dummy_rc_recycle; 6802 6803 dummy_rc_recycle.func = ibcm_dummy_recycle_rc_handler; 6804 6805 IBTF_DPRINTF_L5(cmlog, "ibcm_dummy_recycle_rc_handler: " 6806 "dummy_rc_recycle.func %p", dummy_rc_recycle.func); 6807 } 6808 6809 6810 /* ARGSUSED */ 6811 static ibt_cm_status_t 6812 ibcm_dummy_ud_handler(void *priv, ibt_cm_ud_event_t *event, 6813 ibt_cm_ud_return_args_t *ret_args, 6814 void *priv_data, ibt_priv_data_len_t len) 6815 { 6816 /* 6817 * Let warlock see that ibcm_local_handler_s::actual_cm_handler 6818 * points to this routine. 6819 */ 6820 ibcm_local_handler_t p; 6821 ibcm_ud_state_data_t dummy_ud; 6822 6823 p.actual_cm_handler = ibcm_dummy_ud_handler; 6824 dummy_ud.ud_cm_handler = ibcm_dummy_ud_handler; 6825 6826 IBTF_DPRINTF_L5(cmlog, "ibcm_dummy_ud_handler: p.actual_cm_handler %p" 6827 "dummy_ud.ud_cm_handler %p", p.actual_cm_handler, 6828 dummy_ud.ud_cm_handler); 6829 /* 6830 * Call all routines that the client's callback routine could call. 6831 */ 6832 6833 return (IBT_CM_ACCEPT); 6834 } 6835 6836 /* ARGSUSED */ 6837 static ibt_cm_status_t 6838 ibcm_dummy_rc_handler(void *priv, ibt_cm_event_t *event, 6839 ibt_cm_return_args_t *ret_args, void *priv_data, ibt_priv_data_len_t len) 6840 { 6841 ibcm_state_data_t dummy_rc; 6842 6843 dummy_rc.cm_handler = ibcm_dummy_rc_handler; 6844 6845 IBTF_DPRINTF_L5(cmlog, "ibcm_dummy_rc_handler: " 6846 "dummy_ud.ud_cm_handler %p", dummy_rc.cm_handler); 6847 /* 6848 * Call all routines that the client's callback routine could call. 6849 */ 6850 6851 return (IBT_CM_ACCEPT); 6852 } 6853