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/callb.h> 27 28 /* 29 * ibcm_sm.c 30 * These routines implement the CM state machine (both ACTIVE and PASSIVE) 31 * 32 * Points to Note : 33 * 34 * o CM uses one ibcm_hca_info_t entry per HCA to store all the 35 * connection state data belonging to that HCA in the AVL trees, etc., 36 * 37 * o There is one state structure per RC, referenced from three AVL trees 38 * ie. the HCA active AVL tree, and the HCA passive AVL tree and HCA 39 * passive comid tree 40 * 41 * o SIDR state structures are stored in a linked list 42 * 43 * o The term statep generally refers to RC, until explicitly mentioned 44 * in the notes below 45 * 46 * o Any thread that may access statep increments the ref_cnt. This ensures 47 * that statep is not deleted when it is still being accessed and modified 48 * by other threads 49 * 50 * o Any thread that may want to search the AVL tree(s) holds the hca state 51 * table reader lock. If it shall insert/delete a new state structure, then 52 * the lock held is writer lock. 53 * 54 * o Incrementing and Decrementing the ref_cnt can happen only after acquiring 55 * statep mutex 56 * 57 * o Deleting a statep can happen only by acquiring the hca state writer lock 58 * and statep mutex and if ref_cnt is zero. 59 * 60 * o Statep mutexes are used to decrease the hca state table lock holding 61 * times. thus increasing more number of threads that can access hca 62 * global data structures 63 * 64 * o Statep mutexes cannot be hold for long time. They are primarily used to 65 * check the state of statep, change it and exit the lock. Other threads 66 * checking this statep find statep's new state, and may exit without 67 * further processing (as the statep->state has changed). 68 * 69 * o Statep mutex must be held while setting and unsetting the timer id 70 * values and during untimeout 71 * 72 * Re-stating, the overall purpose of these various locks are: 73 * - Minimize the time state table locks are held 74 * - Writer locks are held only while inserting/deleting into trees, 75 * so multiple readers can traverse data structures in parallel 76 * - Minimize the time statep mutex held, so other threads entering the same 77 * statep mutex are not held for long 78 * 79 * The CM state machine logic ensures that the statep is valid and exists 80 * when timeout callback (ibcm_timeout_cb) is called. This is ensured by 81 * cancelling timeouts on state changes, where appropriate 82 * 83 * 84 * The timeout processing is handled in the context in which the 85 * timeout callback is invoked. 86 * 87 * The CM STATE MACHINE logic flow: 88 * 89 * On an incoming MAD:- 90 * 91 * IBMF -> ibcm_process_incoming_mad 92 * Verify and branch to one of the below connection state routines. 93 * The callback arg from ibmf has the pointer to ibcm_hca_info_t 94 * 95 * 1. INCOMING REQ MAD 96 * 97 * Acquire hca state table WRITER lock 98 * Do lookup in passive AVL tree by remote qpn and remote hca guid 99 * 100 * If (new lookup) 101 * 102 * create new statep, initialize key fields 103 * obtain new local com id, insert into hca state AVL tree 104 * release hca state table WRITER lock 105 * 106 * Initialize remaining fields 107 * If invalid service id, 108 * send a REJ reply, 109 * decr ref_cnt holding state mutex 110 * If existing peer conn, check guids, and break the tie 111 * Call the cep state transition function 112 * Send an RTU/REJ reply 113 * Check and handle for any incoming REJ's during REQ RCVD state 114 * 115 * else if (existing lookup) 116 * 117 * increment refcnt holding state mutex 118 * release hca state table WRITER lock 119 * 120 * re-acquire the statep mutex 121 * if (statep->state is REP SENT/REJ SENT/ MRA SENT) 122 * resend the mad 123 * else if established 124 * handle the stale detection 125 * else 126 * drop the mad (no processing required) 127 * decr statep->ref_cnt, release state mutex 128 * 129 * 130 * 2. INCOMING REP MAD 131 * 132 * Acquire hca state READER lock 133 * Do lookup in hca state tree by local com id 134 * Release hca state table READER lock 135 * 136 * if lookup does not exist 137 * return 138 * 139 * if look up exists 140 * incr statep->ref_cnt holding state mutex 141 * 142 * acquire the statep lock 143 * if (state == ESTABLISHED or REJ SENt or MRA REP SENT) 144 * resend the MAD 145 * release state mutex, cancel req sent timer 146 * decrement ref_cnt holding the statep lock 147 * return 148 * 149 * if (state == REQ_SENT or REP_WAIT) 150 * first, change state to REP_RCVD 151 * release statep lock 152 * cancel timers 153 * lookup in the passive tree by remote qpn and remote hca guid 154 * if entry already exists 155 * handle the stale detection 156 * else 157 * add to the passive tree 158 * 159 * Initialize fields of statep 160 * Call the qp state transition function 161 * Post RTU/REJ reply 162 * Acquire the state mutex 163 * decrement the ref cnt 164 * release the statep lock 165 * 166 * 3. INCOMING MRA 167 * 168 * Acquire hca state table READER lock 169 * Do lookup in active hca state tree by local com id 170 * Release hca state table READER lock 171 * 172 * If lookup does not exist 173 * return 174 * 175 * if look up exists 176 * incr statep->ref_cnt holding state mutex 177 * 178 * acquire state mutex 179 * if (state is REQ_SENT or REP_SENT) 180 * change state to REP WAIT or MRA REP RCVD 181 * release state mutex 182 * cancel the current timer 183 * 184 * reacquire state mutex 185 * if (state is REP_WAIT or MRA_REP_RCVD) 186 * set new timer, using service timeout for the first timeout 187 * decr ref cnt, release state mutex 188 * 189 * 4. INCOMING RTU 190 * 191 * Acquire hca state table READER lock 192 * Do lookup in active hca state tree by local com id 193 * Release hca state table READER lock 194 * 195 * If lookup does not exist 196 * return 197 * 198 * if look up exists 199 * incr statep->ref_cnt holding state mutex 200 * 201 * acquire statep mutex 202 * if (state == REP_SENT or MRA REP RCVD)) 203 * change state to ESTABLISHED 204 * release statep mutex 205 * cancel timer 206 * 207 * Change QP state 208 * 209 * acquire the statep mutex 210 * decrement the ref count 211 * release statep mutex 212 * 213 * 5. INCOMING REJ 214 * 215 * Acquire hca state table READER lock 216 * Do lookup in active hca state tree by local com id 217 * Release hca state table READER lock 218 * 219 * If lookup does not exist 220 * return 221 * 222 * if look up exists 223 * incr statep->ref_cnt holding state mutex 224 * 225 * if (state == REQ RCVD or REP RCVD MRA_SENT or MRA_REP_SNET) 226 * set statep->delete = true 227 * decrement the ref_cnt 228 * release statep mutex; 229 * 230 * else if (state == REQ_SENT or REP SENT or MRA REP Rcvd) 231 * state = IBCM_STATE_DELETE 232 * Cancel running timers 233 * decrement the ref_cnt 234 * release state mutex 235 * Call the client QP handler 236 * delete the state data 237 * 238 * 6. INCOMING DREQ 239 * 240 * Acquire hca state table READER lock 241 * Do lookup in active hca state tree by local com id 242 * Release hca state table READER lock 243 * 244 * If lookup does not exist 245 * return 246 * 247 * if look up exists 248 * incr statep->ref_cnt holding state mutex 249 * 250 * acquire state mutex 251 * if (state is ESTABLISHED/DREQ SENT/TIMEWAIT) 252 * if state is ESTABLISHED/DREQ SENT, 253 * change state to DREQ RECVD 254 * start timers 255 * 256 * send DREP reply 257 * decr ref_cnt 258 * release state mutex 259 * 260 * 7. Incoming DREP 261 * 262 * Acquire hca state table READER lock 263 * Do lookup in active hca state tree by local com id 264 * Release hca state table READER lock 265 * 266 * If lookup does not exist 267 * return 268 * 269 * if look up exists 270 * incr statep->ref_cnt holding state mutex 271 * 272 * acquire state mutex 273 * if state is DREQ_SENT 274 * change state to DREP_RCVD 275 * cancel timer 276 * change state to TIMEWAIT 277 * set timewait timer 278 * decr ref_cnt 279 * release state mutex 280 * 281 * 8. Timeout handler 282 * 283 * (for states REQ SENT/REP SENT/REJ SENT/DREQ SENT/DREP SENT/TIMEWAIT) 284 * 285 * acquire the statep mutex 286 * 287 * if (set state != stored_state) 288 * The thread that changed the state is responsible for any cleanup 289 * decrement ref cnt 290 * release statep mutex 291 * return 292 * else if (statep's state == REJ SENT) 293 * change state to DELETE 294 * decrement ref cnt 295 * release statep mutex 296 * delete statep 297 * return 298 * else if (state == TIME WAIT) 299 * do the time wait state processing 300 * decrement ref cnt 301 * change state to DELETE 302 * release statep mutex 303 * delete statep, and also QP 304 * else if (remaining retry cnt > 0) 305 * resend the mad 306 * decrement ref cnt 307 * release statep mutex 308 * else if (state == rep sent or req sent or mra rep rcvd or rep wait) 309 * (retry counter expired) 310 * change state to REJ SENT (No one shall delete in REJ SENT) 311 * decrement the ref_cnt 312 * release the statep mutex 313 * Post REJ MAD 314 * cv_signal anyone blocking 315 * Invoke client handler 316 * else if state == DREQ_SENT 317 * change state to TIME WAIT 318 * decrement the ref cnt 319 * set a timer for time wait time 320 * release the statep mutex 321 * 322 * 323 * SIDR processing 324 * 325 * 9. INCOMING SIDR_REQ MAD 326 * 327 * Figure out LID/GID 328 * Do lookup in SIDR LIST based on LID, GID, grh_exists and req_id 329 * increment ud_statep->ud_ref_cnt 330 * 331 * If (new lookup) 332 * 333 * validate service id, and the create new statep, 334 * initialize key fields 335 * do a lookup based on service id 336 * if service_id_lookup returns exists 337 * set sidr_status to QPN_VALID 338 * else 339 * set sidr_status to SID_INVALID 340 * post SIDR_REP mad 341 * decr ud_statep->ud_ref_cnt, release ud_state_mutex 342 * 343 * else if (existing lookup) 344 * 345 * if (ud_statep->ud_state is SIDR_REP_SENT) 346 * resend the mad 347 * 348 * decr ud_statep->ud_ref_cnt, release ud_state_mutex 349 * 350 * 351 * 10. INCOMING SIDR_REP MAD 352 * 353 * Figure out LID/GID 354 * Do lookup in SIDR LIST based on LID, GID, grh_exists and req_id 355 * increment ud_statep->ud_ref_cnt 356 * 357 * if look up doesn't exists 358 * return 359 * 360 * if (state == SIDR_REQ_SENT) 361 * first, change state to SIDR_REP_RCVD 362 * release statep lock 363 * cancel timers 364 * cv_signal anyone blocking 365 * release the statep lock 366 * extract return args 367 * destroy the statep 368 * 369 * 11. Timeout handler 370 * 371 * (for states SIDR_REQ_SENT/SIDR_REP_SENT) 372 * 373 * acquire the statep mutex 374 * 375 * if (statep's state == SIDR_REP_SENT SENT) 376 * change state to DELETE 377 * decrement ref cnt 378 * release statep mutex 379 * delete statep 380 * return 381 * else if (remaining retry cnt > 0 and state is SIDR_REQ_SENT) 382 * resend the mad 383 * decrement ref cnt 384 * release statep mutex 385 * else if (state == SIDR_REQ_SENT) 386 * (retry counter expired) 387 * change state to DELETE 388 * decrement the ref_cnt 389 * the statep mutex 390 * cv_signal anyone blocking 391 * Invoke client handler 392 * delete statep 393 */ 394 395 /* Function prototypes */ 396 static void ibcm_set_primary_adds_vect(ibcm_state_data_t *, 397 ibt_adds_vect_t *, ibcm_req_msg_t *); 398 static void ibcm_set_alt_adds_vect(ibcm_state_data_t *, 399 ibt_adds_vect_t *, ibcm_req_msg_t *); 400 static ibt_status_t ibcm_set_primary_cep_path(ibcm_state_data_t *, 401 ibt_cep_path_t *, ibcm_req_msg_t *); 402 static ibt_status_t ibcm_set_alt_cep_path(ibcm_state_data_t *, 403 ibt_cep_path_t *, ibcm_req_msg_t *); 404 static ibt_status_t ibcm_invoke_qp_modify(ibcm_state_data_t *, 405 ibcm_req_msg_t *, ibcm_rep_msg_t *); 406 static ibt_status_t ibcm_invoke_rtu_qp_modify(ibcm_state_data_t *, 407 ib_time_t, ibcm_rep_msg_t *); 408 static ibcm_status_t ibcm_sidr_req_ud_handler(ibcm_ud_state_data_t *, 409 ibcm_sidr_req_msg_t *, ibcm_mad_addr_t *, 410 ibt_sidr_status_t *); 411 static void ibcm_sidr_rep_ud_handler(ibcm_ud_state_data_t *, 412 ibcm_sidr_rep_msg_t *); 413 static void ibcm_handler_conn_fail(ibcm_state_data_t *, 414 uint8_t cf_code, uint8_t cf_msg, 415 ibt_cm_reason_t rej_reason, uint8_t *, 416 ibt_priv_data_len_t); 417 static void ibcm_build_n_post_rej_mad(uint8_t *input_madp, 418 ib_com_id_t, ibcm_mad_addr_t *, int, uint16_t); 419 static void ibcm_post_drep_mad(ibcm_state_data_t *); 420 421 static ibcm_status_t ibcm_verify_req_gids_and_svcid( 422 ibcm_state_data_t *statep, 423 ibcm_req_msg_t *cm_req_msgp); 424 425 static void ibcm_timeout_client_cb(ibcm_state_data_t *statep); 426 static void ibcm_ud_timeout_client_cb( 427 ibcm_ud_state_data_t *ud_statep); 428 429 static void ibcm_process_dreq_timeout(ibcm_state_data_t *statep); 430 431 static void ibcm_fill_adds_from_lap(ibt_adds_vect_t *adds, 432 ibcm_lap_msg_t *lap_msg, ibcm_mode_t mode); 433 434 static void ibcm_post_stored_apr_mad(ibcm_state_data_t *statep, 435 uint8_t *input_madp); 436 437 static ibcm_status_t ibcm_set_qp_from_apr(ibcm_state_data_t *statep, 438 ibcm_lap_msg_t *lap_msg); 439 440 static boolean_t ibcm_compare_prim_alt_paths(ibt_adds_vect_t *prim, 441 ibt_adds_vect_t *alt); 442 443 static void ibcm_process_get_classport_info(ibcm_hca_info_t *hcap, 444 uint8_t *input_madp, ibcm_mad_addr_t *cm_mad_addr); 445 446 static void ibcm_decode_classport_info(ibcm_hca_info_t *hcap, 447 uint8_t *input_madp, ibcm_mad_addr_t *cm_mad_addr); 448 449 static void ibcm_post_rej_ver_mismatch(uint8_t *input_madp, 450 ibcm_mad_addr_t *cm_mad_addr); 451 452 static void ibcm_init_clp_to_mad(ibcm_classportinfo_msg_t *clp, 453 ibt_redirect_info_t *rinfo); 454 455 static void ibcm_init_clp_from_mad(ibcm_classportinfo_msg_t *clp, 456 ibt_redirect_info_t *rinfo); 457 458 static void ibcm_copy_addl_rej(ibcm_state_data_t *statep, 459 ibcm_rej_msg_t *rej_msgp, 460 ibt_cm_conn_failed_t *failed); 461 462 static void ibcm_return_open_data(ibcm_state_data_t *statep, 463 ibcm_rep_msg_t *rep_msgp, 464 ibt_cm_reason_t reject_reason); 465 466 /* limit the number of taskq threads to handle received MADs. */ 467 int ibcm_recv_tasks = 0; 468 int ibcm_max_recv_tasks = 24; 469 int ibcm_recv_timeouts = 0; 470 471 /* 472 * Tunable MAX MRA Service Timeout value in MicroSECONDS. 473 * 0 - Tunable parameter not used. 474 * 475 * Ex: 60000000 - Max MRA Service Delay is 60 Seconds. 476 */ 477 clock_t ibcm_mra_service_timeout_max = 0; 478 479 #ifdef DEBUG 480 481 static void print_modify_qp(char *prefix, 482 ibt_qp_hdl_t ibt_qp, 483 ibt_cep_modify_flags_t flags, 484 ibt_qp_info_t *qp_attr); 485 #endif 486 487 /* Warlock annotations */ 488 489 _NOTE(READ_ONLY_DATA(ibt_arej_info_u)) 490 491 /* 492 * ibcm_process_incoming_mad: 493 * The CM callback that is invoked by IBMF, when a valid CM MAD arrives 494 * on any of the registered ibmf handles by CM. 495 * 496 * It is assumed that the incoming MAD (except for incoming REQ) belongs 497 * to a connection on the HCA, on which the MAD is received. 498 * The IBMF callback arg specifies ibcm_hca_info_t 499 * 500 * NOTE: IBMF always invokes ibcm_recv_cb() in a taskq. CM does some memory 501 * allocations and invoke ibcm_sm_funcs_tbl[i]() in the same taskq. 502 * 503 * INPUTS: 504 * ibmf_handle - IBMF Handle 505 * args - from IBMF. Is a ptr to ibcm_hca_info_t 506 * status - Callback status. Is mostly IBMF_SUCCESS 507 * madbuf - IBMF allocated MAD buffer (CM should free it) 508 * madaddr - IBMF MAD's address 509 * grhvalid - If GRH is valid or not 510 * 511 * RETURN VALUES: NONE 512 */ 513 void 514 ibcm_process_incoming_mad(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 515 void *args) 516 { 517 uint8_t method; /* Method type in MAD hdr */ 518 ib_mad_hdr_t *in_mad_hdr; /* Incoming MAD's header */ 519 ibcm_hca_info_t *hcap; /* pointer to HCA entry */ 520 ibcm_port_info_t *portp; 521 ibcm_mad_addr_t *cm_mad_addr; /* MAD address information */ 522 ibcm_event_type_t attr_id; /* Attribute ID in MAD hdr */ 523 ibcm_mad_addr_t loc_mad_addr; /* MAD address information */ 524 ibcm_qp_list_t *cm_qp_entry; 525 int ibmf_status; 526 527 528 /* Noticed that IBMF always calls with IBMF_SUCCESS, but still check */ 529 if (msgp->im_msg_status != IBMF_SUCCESS) { 530 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 531 "bad status %x", msgp->im_msg_status); 532 /* IBMF allocates Input MAD, so free it here */ 533 if ((ibmf_status = ibmf_free_msg(ibmf_handle, &msgp)) != 534 IBMF_SUCCESS) 535 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 536 "ibmf_free_msg failed %d", ibmf_status); 537 return; 538 } 539 540 /* Get the HCA entry pointer */ 541 cm_qp_entry = (ibcm_qp_list_t *)args; 542 543 IBTF_DPRINTF_L5(cmlog, "ibcm_process_incoming_mad: ibmf_hdl %p " 544 "msg %p args %p", ibmf_handle, msgp, args); 545 546 #ifdef DEBUG 547 if (ibcm_test_mode > 1) 548 ibcm_query_qp(ibmf_handle, cm_qp_entry->qp_cm); 549 #endif 550 551 portp = cm_qp_entry->qp_port; 552 hcap = portp->port_hcap; 553 554 IBTF_DPRINTF_L4(cmlog, "ibcm_process_incoming_mad: CM MAD on " 555 "port %d", portp->port_num); 556 557 /* Increment hca ref cnt, if HCA is in attached state, else fail */ 558 if (ibcm_inc_hca_acc_cnt(hcap) != IBCM_SUCCESS) { 559 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 560 "hca not in attach state"); 561 /* IBMF allocates Input MAD, and ibcm free's it */ 562 if ((ibmf_status = ibmf_free_msg(ibmf_handle, &msgp)) != 563 IBMF_SUCCESS) 564 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 565 "ibmf_free_msg failed %d", ibmf_status); 566 return; 567 } 568 569 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cm_mad_addr)) 570 571 /* allocate memory for internal MAD address buffer */ 572 cm_mad_addr = &loc_mad_addr; 573 bzero(cm_mad_addr, sizeof (ibcm_mad_addr_t)); 574 575 cm_mad_addr->port_num = portp->port_num; 576 577 /* initialize cm_mad_addr field(s) */ 578 in_mad_hdr = msgp->im_msgbufs_recv.im_bufs_mad_hdr; 579 580 if (in_mad_hdr->MgmtClass != MAD_MGMT_CLASS_COMM_MGT) { 581 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 582 "bad mgmt class %x", in_mad_hdr->MgmtClass); 583 if ((ibmf_status = ibmf_free_msg(ibmf_handle, &msgp)) != 584 IBMF_SUCCESS) 585 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 586 "ibmf_free_msg failed %d", ibmf_status); 587 ibcm_dec_hca_acc_cnt(hcap); 588 return; 589 } 590 591 cm_mad_addr->rcvd_addr = msgp->im_local_addr; 592 if (msgp->im_msg_flags & IBMF_MSG_FLAGS_GLOBAL_ADDRESS) { 593 cm_mad_addr->grh_hdr = msgp->im_global_addr; 594 cm_mad_addr->grh_exists = B_TRUE; 595 IBTF_DPRINTF_L3(cmlog, "ibcm_process_incoming_mad: " 596 "CM recv GID GUID %llX sender GID GUID %llX", 597 msgp->im_global_addr.ig_recver_gid.gid_guid, 598 msgp->im_global_addr.ig_sender_gid.gid_guid); 599 } 600 601 /* Save IBMF handle and ibmf qp related information */ 602 cm_mad_addr->ibmf_hdl = ibmf_handle; 603 cm_mad_addr->cm_qp_entry = cm_qp_entry; 604 605 /* IBMF does not initialize ia_p_key for non-QP1's */ 606 if (cm_qp_entry->qp_cm != IBMF_QP_HANDLE_DEFAULT) 607 cm_mad_addr->rcvd_addr.ia_p_key = cm_qp_entry->qp_pkey; 608 609 if (cm_mad_addr->rcvd_addr.ia_p_key & 0x8000) 610 IBTF_DPRINTF_L5(cmlog, "ibcm_process_incoming_mad: PKEY %x", 611 cm_mad_addr->rcvd_addr.ia_p_key); 612 else 613 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: CM MAD " 614 "arrived from limited PKEY %x", 615 cm_mad_addr->rcvd_addr.ia_p_key); 616 617 /* Retrieve the method and Attr-Id from generic mad header */ 618 method = in_mad_hdr->R_Method; 619 attr_id = b2h16(in_mad_hdr->AttributeID); 620 621 IBTF_DPRINTF_L4(cmlog, "ibcm_process_incoming_mad: " 622 "Method %x Attribute %x", method, attr_id); 623 624 if (in_mad_hdr->ClassVersion != IBCM_MAD_CLASS_VERSION) { 625 626 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 627 "unsupported ibcm class version %x", 628 in_mad_hdr->ClassVersion); 629 630 if (attr_id == (IBCM_INCOMING_REQ + IBCM_ATTR_BASE_ID)) 631 ibcm_post_rej_ver_mismatch( 632 (uint8_t *)IBCM_IN_HDRP(msgp), cm_mad_addr); 633 634 if ((ibmf_status = ibmf_free_msg(ibmf_handle, &msgp)) != 635 IBMF_SUCCESS) 636 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 637 "ibmf_free_msg failed %d", ibmf_status); 638 ibcm_dec_hca_acc_cnt(hcap); 639 return; 640 } 641 642 IBTF_DPRINTF_L4(cmlog, "ibcm_process_incoming_mad: " 643 "Transaction Id 0x%llX", b2h64(in_mad_hdr->TransactionID)); 644 645 #ifdef DEBUG 646 ibcm_decode_tranid(b2h64(in_mad_hdr->TransactionID), NULL); 647 #endif 648 649 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cm_mad_addr)) 650 651 /* 652 * The following are valid combination of Method type 653 * and attribute id in the received MAD :- 654 * o ClassPortInfo with Get method 655 * o CM messages with Send method 656 */ 657 if ((attr_id == MAD_ATTR_ID_CLASSPORTINFO) && 658 ((method == MAD_METHOD_GET) || 659 (method == MAD_METHOD_GET_RESPONSE))) { 660 if (method == MAD_METHOD_GET) 661 ibcm_process_get_classport_info(hcap, 662 (uint8_t *)IBCM_IN_HDRP(msgp), cm_mad_addr); 663 else if (method == MAD_METHOD_GET_RESPONSE) 664 ibcm_decode_classport_info(hcap, 665 (uint8_t *)IBCM_IN_HDRP(msgp), cm_mad_addr); 666 } else if ((attr_id >= IBCM_ATTR_BASE_ID) && 667 (attr_id < (IBCM_ATTR_BASE_ID + IBCM_MAX_EVENTS)) && 668 (method == MAD_METHOD_SEND)) { 669 670 attr_id -= IBCM_ATTR_BASE_ID; /* figure out CM message id */ 671 672 ASSERT(msgp->im_msgbufs_recv.im_bufs_mad_hdr != NULL); 673 674 /* Call the CM process connection state function */ 675 ibcm_sm_funcs_tbl[attr_id](hcap, 676 (uint8_t *)IBCM_IN_HDRP(msgp), cm_mad_addr); 677 } else { 678 /* 679 * Any other combination of method and attribute are invalid, 680 * hence drop the MAD 681 */ 682 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 683 "unknown Method %x or Attribute %x", method, attr_id); 684 } 685 686 /* decrement the hcap access reference count */ 687 ibcm_dec_hca_acc_cnt(hcap); 688 689 /* ASSERT(NO_LOCKS_HELD); */ 690 691 /* free up ibmf msgp */ 692 if ((ibmf_status = ibmf_free_msg(ibmf_handle, &msgp)) != IBMF_SUCCESS) 693 IBTF_DPRINTF_L2(cmlog, "ibcm_process_incoming_mad: " 694 "ibmf_free_msg failed %d", ibmf_status); 695 } 696 697 /* 698 * Structure to carry the arguments from ibcm_recv_cb() to 699 * ibcm_recv_incoming_mad() via taskq_dispatch 700 */ 701 typedef struct ibcm_taskq_args_s { 702 ibmf_handle_t tq_ibmf_handle; 703 ibmf_msg_t *tq_ibmf_msgp; 704 void *tq_args; 705 } ibcm_taskq_args_t; 706 707 #define IBCM_RECV_MAX 128 708 ibcm_taskq_args_t ibcm_recv_array[IBCM_RECV_MAX + 1]; 709 int ibcm_get, ibcm_put; 710 int ibcm_recv_total; 711 int ibcm_recv_queued; 712 713 _NOTE(READ_ONLY_DATA(ibcm_taskq_args_t)) 714 715 static int 716 ibcm_recv_dequeue(ibmf_handle_t *ibmf_handlep, ibmf_msg_t **msgpp, void **argsp) 717 { 718 ibcm_taskq_args_t *tq; 719 720 if (ibcm_put == ibcm_get) 721 return (0); 722 723 if (++ibcm_get >= IBCM_RECV_MAX) 724 ibcm_get = 0; 725 tq = ibcm_recv_array + ibcm_get; 726 *ibmf_handlep = tq->tq_ibmf_handle; 727 *msgpp = tq->tq_ibmf_msgp; 728 *argsp = tq->tq_args; 729 return (1); 730 } 731 732 static int 733 ibcm_recv_enqueue(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 734 { 735 int next; 736 ibcm_taskq_args_t *tq; 737 738 ASSERT(MUTEX_HELD(&ibcm_recv_mutex)); 739 next = ibcm_put + 1; 740 if (next >= IBCM_RECV_MAX) 741 next = 0; 742 if (next != ibcm_get) { 743 ibcm_recv_queued++; 744 ibcm_put = next; 745 tq = ibcm_recv_array + next; 746 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*tq)) 747 tq->tq_ibmf_handle = ibmf_handle; 748 tq->tq_ibmf_msgp = msgp; 749 tq->tq_args = args; 750 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*tq)) 751 return (1); 752 } else { 753 return (0); 754 } 755 } 756 757 void 758 ibcm_drop_msg(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp) 759 { 760 int ibmf_status; 761 762 IBTF_DPRINTF_L2(cmlog, "ibcm_drop_msg: discarding MAD"); 763 764 if ((ibmf_status = ibmf_free_msg(ibmf_handle, &msgp)) != IBMF_SUCCESS) 765 IBTF_DPRINTF_L2(cmlog, "ibcm_drop_msg: " 766 "ibmf_free_msg failed %d", ibmf_status); 767 } 768 769 /* 770 * Processing done in taskq thread. 771 * 772 * Calls ibcm_process_incoming_mad with all function arguments extracted 773 * from args. Afterwards, check for queued requests. 774 */ 775 static void 776 ibcm_recv_task(void *args) 777 { 778 ibcm_taskq_args_t *taskq_args; 779 ibmf_handle_t ibmf_handle; 780 ibmf_msg_t *msgp; 781 782 taskq_args = (ibcm_taskq_args_t *)args; 783 784 IBTF_DPRINTF_L4(cmlog, "ibcm_recv_task: Processing incoming MAD" 785 " via taskq"); 786 787 ibcm_process_incoming_mad(taskq_args->tq_ibmf_handle, 788 taskq_args->tq_ibmf_msgp, taskq_args->tq_args); 789 790 kmem_free(taskq_args, sizeof (ibcm_taskq_args_t)); 791 792 /* process queued entries before giving up this thread */ 793 mutex_enter(&ibcm_recv_mutex); 794 while (ibcm_recv_dequeue(&ibmf_handle, &msgp, &args)) { 795 mutex_exit(&ibcm_recv_mutex); 796 ibcm_process_incoming_mad(ibmf_handle, msgp, args); 797 mutex_enter(&ibcm_recv_mutex); 798 } 799 --ibcm_recv_tasks; 800 mutex_exit(&ibcm_recv_mutex); 801 } 802 803 static void 804 ibcm_recv_timeout_cb(void *args) 805 { 806 ibcm_taskq_args_t *tq = (ibcm_taskq_args_t *)args; 807 int rv = 1; 808 809 mutex_enter(&ibcm_recv_mutex); 810 ibcm_recv_timeouts--; 811 if (ibcm_recv_tasks == 0) { 812 ibcm_recv_tasks++; 813 mutex_exit(&ibcm_recv_mutex); 814 if (taskq_dispatch(ibcm_taskq, ibcm_recv_task, tq, 815 TQ_NOQUEUE | TQ_NOSLEEP) == 0) { 816 mutex_enter(&ibcm_recv_mutex); 817 if (--ibcm_recv_tasks == 0) { 818 (void) timeout(ibcm_recv_timeout_cb, tq, 1); 819 ibcm_recv_timeouts++; 820 } else { 821 rv = ibcm_recv_enqueue(tq->tq_ibmf_handle, 822 tq->tq_ibmf_msgp, tq->tq_args); 823 kmem_free(tq, sizeof (*tq)); 824 } 825 mutex_exit(&ibcm_recv_mutex); 826 } 827 } else { 828 /* 829 * one or more taskq threads are running now 830 * so just try to enqueue this one. 831 */ 832 rv = ibcm_recv_enqueue(tq->tq_ibmf_handle, 833 tq->tq_ibmf_msgp, tq->tq_args); 834 kmem_free(tq, sizeof (*tq)); 835 mutex_exit(&ibcm_recv_mutex); 836 } 837 if (rv == 0) 838 ibcm_drop_msg(tq->tq_ibmf_handle, tq->tq_ibmf_msgp); 839 } 840 841 /* 842 * Dispatch to taskq if we're not using many, else just queue it 843 * and have the taskq thread pick it up. Return 0 if we're dropping it. 844 */ 845 static int 846 ibcm_recv_add_one(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 847 { 848 int rv; 849 ibcm_taskq_args_t *tq; 850 851 mutex_enter(&ibcm_recv_mutex); 852 ibcm_recv_total++; 853 if (ibcm_recv_tasks >= ibcm_max_recv_tasks) { /* just queue this one */ 854 rv = ibcm_recv_enqueue(ibmf_handle, msgp, args); 855 mutex_exit(&ibcm_recv_mutex); 856 return (rv); 857 } else { 858 ibcm_recv_tasks++; /* dispatch this one to a taskq thread */ 859 mutex_exit(&ibcm_recv_mutex); 860 tq = kmem_alloc(sizeof (*tq), KM_NOSLEEP); 861 if (tq == NULL) { 862 mutex_enter(&ibcm_recv_mutex); 863 if (--ibcm_recv_tasks > 0) 864 rv = ibcm_recv_enqueue(ibmf_handle, msgp, args); 865 else /* don't enqueue if no threads are running */ 866 rv = 0; 867 mutex_exit(&ibcm_recv_mutex); 868 return (rv); 869 } 870 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*tq)) 871 tq->tq_ibmf_handle = ibmf_handle; 872 tq->tq_ibmf_msgp = msgp; 873 tq->tq_args = args; 874 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*tq)) 875 if (taskq_dispatch(ibcm_taskq, ibcm_recv_task, tq, 876 TQ_NOQUEUE | TQ_NOSLEEP) == 0) { /* dispatch failed */ 877 mutex_enter(&ibcm_recv_mutex); 878 if (--ibcm_recv_tasks == 0) { 879 /* try the dispatch again, after a tick */ 880 (void) timeout(ibcm_recv_timeout_cb, tq, 1); 881 ibcm_recv_timeouts++; 882 rv = 1; /* indicate success */ 883 } else { 884 rv = ibcm_recv_enqueue(ibmf_handle, msgp, args); 885 kmem_free(tq, sizeof (*tq)); 886 } 887 mutex_exit(&ibcm_recv_mutex); 888 return (rv); 889 } else { 890 return (1); 891 } 892 } 893 } 894 895 /* 896 * ibcm_recv_cb: 897 * The CM callback that is invoked by IBMF, when a valid CM MAD arrives 898 * on any of the registered ibmf handles by CM. 899 * 900 * INPUTS: 901 * ibmf_handle - IBMF Handle 902 * msgp - IBMF msg containing the MAD (allocated by IBMF) 903 * args - Ptr to ibcm_hca_info_t 904 * 905 * RETURN VALUES: NONE 906 */ 907 void 908 ibcm_recv_cb(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 909 { 910 if (ibcm_recv_add_one(ibmf_handle, msgp, args) == 0) 911 ibcm_drop_msg(ibmf_handle, msgp); 912 } 913 914 /* 915 * ibcm_process_req_msg: 916 * PASSIVE SIDE CM 917 * Called from ibcm_process_incoming_mad on reception of a REQ message 918 * 919 * Description: 920 * If it a new REQ (not duplicate) 921 * creates a new state structure in passive connection mode 922 * populate state structure fields 923 * inserts state structure in hca active and passive trees 924 * validates service id 925 * validates primary and alternate lid/gid in REQ, 926 * calls QP state transition function 927 * generates REP/REJ response 928 * stores the response MAD in state structure for future re-sends 929 * initializes timers as required 930 * If a duplicate REQ, action depends upon current state in the state 931 * structure 932 * 933 * INPUTS: 934 * hcap - HCA entry ptr 935 * input_madp - CM MAD that is input to this function 936 * cm_mad_addr - Address information for the MAD 937 * 938 * RETURN VALUE: 939 * NONE 940 */ 941 void 942 ibcm_process_req_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 943 ibcm_mad_addr_t *cm_mad_addr) 944 { 945 ibt_priv_data_len_t arej_info_len = 0; 946 ib_qpn_t remote_qpn; 947 ib_guid_t remote_hca_guid; 948 ib_com_id_t remote_comid; 949 ib_com_id_t local_comid; 950 ibcm_status_t state_lookup_status; 951 ibcm_status_t comid_lookup_status; 952 ibcm_status_t response; 953 ibcm_req_msg_t *req_msgp = 954 (ibcm_req_msg_t *)&input_madp[IBCM_MAD_HDR_SIZE]; 955 ibt_cm_reason_t reject_reason = IBT_CM_SUCCESS; 956 ibcm_state_data_t *statep; 957 ibcm_state_data_t *stale_statep = NULL; 958 ibcm_status_t svc_gid_check; 959 uint32_t psn24_timeout5_retry3; 960 ibt_tran_srv_t trans; 961 962 IBTF_DPRINTF_L5(cmlog, "ibcm_process_req_msg(%p, %p, %p)", 963 hcap, input_madp, cm_mad_addr); 964 965 /* 966 * Lookup for an existing state structure or create a new state struct 967 * If there is no entry, the lookup function also allocates a new 968 * state structure and inserts in the table, initializes remote qpn 969 * and hca guid from REQ 970 */ 971 remote_hca_guid = b2h64(req_msgp->req_local_ca_guid); 972 remote_qpn = b2h32(req_msgp->req_local_qpn_plus) >> 8; 973 remote_comid = b2h32(req_msgp->req_local_comm_id); 974 975 IBCM_DUMP_RAW_MSG((uchar_t *)input_madp); 976 977 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: remote_comid = %x" 978 " remote_qpn = %x", remote_comid, remote_qpn); 979 980 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: remote_hcaguid = %llX", 981 remote_hca_guid); 982 983 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 984 985 new_req: 986 /* allocate the local_comid before proceeding */ 987 if (ibcm_alloc_comid(hcap, &local_comid) != IBCM_SUCCESS) { 988 ibcm_build_n_post_rej_mad(input_madp, 989 b2h32(req_msgp->req_local_comm_id), cm_mad_addr, 990 IBT_CM_FAILURE_REQ, IBT_CM_NO_RESC); 991 return; 992 } 993 994 /* allocate ibcm_state_data_t before grabbing the WRITER lock */ 995 statep = kmem_zalloc(sizeof (*statep), KM_SLEEP); 996 997 rw_enter(&hcap->hca_state_rwlock, RW_WRITER); 998 999 /* NOTE that only a writer lock is held here */ 1000 1001 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_REQ, 1002 local_comid, remote_qpn, remote_hca_guid, hcap, &statep); 1003 1004 if (state_lookup_status == IBCM_LOOKUP_NEW) { 1005 /* seeing the REQ request for the first time */ 1006 1007 mutex_enter(&statep->state_mutex); 1008 /* Release the state table lock */ 1009 rw_exit(&hcap->hca_state_rwlock); 1010 1011 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: New statep 0x%p" 1012 " created", statep); 1013 1014 psn24_timeout5_retry3 = b2h32(req_msgp->req_starting_psn_plus); 1015 1016 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 1017 1018 /* if ibmf msg allocation fails, delete the statep */ 1019 if (ibcm_alloc_out_msg(cm_mad_addr->ibmf_hdl, 1020 &statep->stored_msg, MAD_METHOD_SEND) != IBT_SUCCESS) { 1021 1022 IBCM_REF_CNT_DECR(statep); 1023 statep->state = IBCM_STATE_DELETE; 1024 mutex_exit(&statep->state_mutex); 1025 /* HCA res cnt decremented via ibcm_delete_state_data */ 1026 ibcm_inc_hca_res_cnt(hcap); 1027 ibcm_delete_state_data(statep); 1028 return; 1029 } 1030 1031 /* Allocate dreq_msg buf to be used during teardown. */ 1032 if (ibcm_alloc_out_msg(cm_mad_addr->ibmf_hdl, 1033 &statep->dreq_msg, MAD_METHOD_SEND) != IBT_SUCCESS) { 1034 1035 IBCM_REF_CNT_DECR(statep); 1036 statep->state = IBCM_STATE_DELETE; 1037 mutex_exit(&statep->state_mutex); 1038 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_msg: " 1039 "statep 0x%p: Failed to allocate dreq_msg", statep); 1040 1041 /* HCA res cnt decremented via ibcm_delete_state_data */ 1042 ibcm_inc_hca_res_cnt(hcap); 1043 ibcm_delete_state_data(statep); 1044 return; 1045 } 1046 1047 /* initialize some "statep" fields */ 1048 statep->mode = IBCM_PASSIVE_MODE; 1049 statep->hcap = hcap; 1050 statep->remote_comid = remote_comid; 1051 statep->svcid = b2h64(req_msgp->req_svc_id); 1052 statep->local_qp_rnr_cnt = 1053 req_msgp->req_mtu_plus & 0x7; 1054 1055 /* 1056 * get the remote_ack_delay, etc. 1057 */ 1058 statep->remote_ack_delay = 1059 ibt_ib2usec(req_msgp->req_primary_localtime_plus >> 3); 1060 statep->cep_retry_cnt = psn24_timeout5_retry3 & 0x7; 1061 1062 /* 1063 * get the req_max_cm_retries 1064 */ 1065 statep->max_cm_retries = req_msgp->req_max_cm_retries_plus >> 4; 1066 statep->remaining_retry_cnt = statep->max_cm_retries; 1067 1068 /* Approximate pkt life time for now */ 1069 statep->pkt_life_time = statep->remote_ack_delay/2; 1070 1071 /* Passive side timer is set to LocalCMRespTime in REQ */ 1072 statep->timer_value = 1073 ibt_ib2usec(psn24_timeout5_retry3 >> 3 & 0x1f); 1074 1075 statep->starting_psn = psn24_timeout5_retry3 >> 8; 1076 1077 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: statep 0x%p " 1078 "active cep timeout(usec) = %u", 1079 statep, statep->remote_ack_delay); 1080 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: " 1081 "passive timer(usec) = %u", statep->timer_value); 1082 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: " 1083 "approx pkt lt(usec)= %u ", statep->pkt_life_time); 1084 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: " 1085 "max cm retries %u", statep->max_cm_retries); 1086 1087 /* The reply ie., REP/REJ transaction id copied from REQ */ 1088 IBCM_OUT_HDRP(statep->stored_msg)->TransactionID = 1089 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 1090 1091 /* 1092 * Initialize the stale clock. Any other REQ 1093 * messages on this statep are considered as duplicate 1094 * if they arrive within stale clock 1095 * ibcm_adj_btime is used to offset for retry REQ's 1096 * arriving just after expected retry clock 1097 */ 1098 statep->stale_clock = gethrtime() + 1099 (hrtime_t)(ibcm_adj_btime * 1000000000) + 1100 (hrtime_t)statep->remote_ack_delay * 1101 (statep->max_cm_retries * (1000 / 2)); 1102 1103 mutex_exit(&statep->state_mutex); 1104 1105 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_REQ); 1106 1107 /* Increment the hca's resource count */ 1108 ibcm_inc_hca_res_cnt(hcap); 1109 1110 ibcm_build_reply_mad_addr(cm_mad_addr, 1111 &statep->stored_reply_addr); 1112 1113 if (statep->stored_reply_addr.cm_qp_entry == NULL) { 1114 1115 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_msg: " 1116 "statep 0x%p cm_qp_entry alloc failed", statep); 1117 1118 /* 1119 * Not much choice. CM MADs cannot go on QP1, not even 1120 * REJ. Hence delete state data and go away silently. 1121 * The remote will timeout after repeated attempts 1122 */ 1123 mutex_enter(&statep->state_mutex); 1124 IBCM_REF_CNT_DECR(statep); 1125 statep->state = IBCM_STATE_DELETE; 1126 mutex_exit(&statep->state_mutex); 1127 1128 ibcm_delete_state_data(statep); 1129 return; 1130 } 1131 1132 stale_statep = statep; 1133 rw_enter(&hcap->hca_state_rwlock, RW_WRITER); 1134 comid_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_REQ_STALE, 1135 remote_comid, 0, remote_hca_guid, hcap, &stale_statep); 1136 rw_exit(&hcap->hca_state_rwlock); 1137 1138 if (comid_lookup_status == IBCM_LOOKUP_EXISTS) { 1139 1140 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_msg: " 1141 "dup comid %x stale_statep 0x%p statep 0x%p", 1142 remote_comid, stale_statep, statep); 1143 1144 ibcm_insert_trace(stale_statep, 1145 IBCM_TRACE_STALE_DETECT); 1146 1147 /* Send a REJ with duplicate com id */ 1148 ibcm_post_rej_mad(statep, IBT_CM_DUP_COM_ID, 1149 IBT_CM_FAILURE_REQ, NULL, 0); 1150 1151 /* 1152 * Don't free the ibmf msg, if stale_statep is not in 1153 * ESTABLISHED state, because probability is very less. 1154 * ibmf msg shall be deleted along with statep 1155 */ 1156 1157 /* 1158 * if stale_statep is in established state, process 1159 * stale connection handling on stale_statep 1160 */ 1161 mutex_enter(&stale_statep->state_mutex); 1162 if (stale_statep->state == IBCM_STATE_ESTABLISHED) { 1163 1164 stale_statep->state = 1165 IBCM_STATE_TRANSIENT_DREQ_SENT; 1166 stale_statep->stale = B_TRUE; 1167 1168 /* Cancel pending ibt_set_alt_path */ 1169 ibcm_sync_lapr_idle(stale_statep); 1170 /* The above call releases the state mutex */ 1171 1172 if (stale_statep->dreq_msg == NULL) 1173 (void) ibcm_alloc_out_msg(stale_statep-> 1174 stored_reply_addr.ibmf_hdl, 1175 &stale_statep->dreq_msg, 1176 MAD_METHOD_SEND); 1177 1178 /* 1179 * Spec says, post DREQ MAD on the stale 1180 * channel. This moves channel into timewait 1181 */ 1182 if (stale_statep->dreq_msg != NULL) { 1183 ibcm_post_dreq_mad(stale_statep); 1184 mutex_enter(&stale_statep->state_mutex); 1185 } else { 1186 mutex_enter(&stale_statep->state_mutex); 1187 /* Set it back to original state. */ 1188 stale_statep->state = 1189 IBCM_STATE_ESTABLISHED; 1190 cv_broadcast( 1191 &stale_statep->block_mad_cv); 1192 } 1193 } 1194 1195 IBCM_REF_CNT_DECR(stale_statep); 1196 mutex_exit(&stale_statep->state_mutex); 1197 1198 mutex_enter(&statep->state_mutex); 1199 IBCM_REF_CNT_DECR(statep); 1200 mutex_exit(&statep->state_mutex); 1201 return; 1202 } 1203 1204 /* If unknown service type, just post a REJ */ 1205 trans = ((uint8_t *)&req_msgp->req_remote_eecn_plus)[3] >> 1 & 1206 0x3; 1207 if ((trans != IBT_RC_SRV) && (trans != IBT_UC_SRV) && 1208 (trans != IBT_RD_SRV)) { 1209 1210 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_msg: " 1211 "statep 0x%p invalid transport type %x", statep, 1212 trans); 1213 1214 /* Send a REJ with invalid transport type */ 1215 ibcm_post_rej_mad(statep, IBT_CM_INVALID_SRV_TYPE, 1216 IBT_CM_FAILURE_REQ, NULL, 0); 1217 1218 mutex_enter(&statep->state_mutex); 1219 IBCM_REF_CNT_DECR(statep); 1220 mutex_exit(&statep->state_mutex); 1221 return; 1222 } 1223 1224 /* Validate the gids, lids and service id */ 1225 svc_gid_check = ibcm_verify_req_gids_and_svcid(statep, 1226 req_msgp); 1227 1228 if (svc_gid_check == IBCM_FAILURE) { 1229 1230 IBTF_DPRINTF_L3(cmlog, "ibcm_process_req_msg: Either " 1231 "gid or sid invalid for statep 0x%p", statep); 1232 mutex_enter(&statep->state_mutex); 1233 IBCM_REF_CNT_DECR(statep); 1234 mutex_exit(&statep->state_mutex); 1235 1236 /* REJ posted from ibcm_verify_req_gids_and_svcid */ 1237 return; 1238 } 1239 1240 /* Call the QP state transition processing function */ 1241 response = ibcm_cep_state_req(statep, req_msgp, 1242 &reject_reason, &arej_info_len); 1243 1244 /* If defer, return holding the statep ref cnt */ 1245 if (response == IBCM_DEFER) { 1246 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: " 1247 "statep %0xp client returned DEFER response", 1248 statep); 1249 return; 1250 } 1251 1252 /* statep ref cnt decremented in the func below */ 1253 ibcm_handle_cep_req_response(statep, response, 1254 reject_reason, arej_info_len); 1255 1256 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*statep)) 1257 1258 return; 1259 1260 } else { 1261 rw_exit(&hcap->hca_state_rwlock); 1262 ibcm_free_comid(hcap, local_comid); 1263 } 1264 1265 if (state_lookup_status == IBCM_LOOKUP_EXISTS) { 1266 hrtime_t cur_time; 1267 1268 mutex_enter(&statep->state_mutex); 1269 1270 /* 1271 * There is an existing state structure entry 1272 * with the same active comid 1273 * Resending REP MAD is necessary only for REP/REJ/MRA Sent 1274 * states 1275 * Any other state implies the active has already received 1276 * the REP/REJ response, and this REQ is an old MAD popping 1277 * out of the fabric, hence no resend is required 1278 */ 1279 cur_time = gethrtime(); 1280 1281 if ((remote_comid == statep->remote_comid) && 1282 (IBCM_OUT_HDRP(statep->stored_msg)->TransactionID == 1283 ((ib_mad_hdr_t *)(input_madp))->TransactionID) && 1284 (cur_time <= statep->stale_clock)) { 1285 1286 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_REQ); 1287 1288 if (statep->state == IBCM_STATE_REP_SENT) 1289 ibcm_resend_rep_mad(statep); 1290 else if (statep->state == IBCM_STATE_REJ_SENT) 1291 ibcm_resend_rej_mad(statep); 1292 else if (statep->state == IBCM_STATE_MRA_SENT) 1293 ibcm_resend_mra_mad(statep); 1294 1295 /* decrementing ref cnt and returning from below */ 1296 1297 } else if ((statep->state == IBCM_STATE_REJ_SENT) && 1298 remote_comid != statep->remote_comid) { 1299 timeout_id_t timer_val; 1300 1301 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_msg: " 1302 "statep 0x%p being retired, REMOTE_QPN %x", 1303 statep, remote_qpn); 1304 /* 1305 * OK, this is reuse of the QPN on the active side 1306 * that was not connected last time. This REQ is 1307 * considered NEW. We delete the statep here, 1308 * then start over from the top. 1309 */ 1310 statep->state = IBCM_STATE_DELETE; 1311 timer_val = statep->timerid; 1312 statep->timerid = 0; 1313 mutex_exit(&statep->state_mutex); 1314 if (timer_val) 1315 (void) untimeout(timer_val); 1316 IBCM_REF_CNT_DECR(statep); 1317 ibcm_delete_state_data(statep); 1318 goto new_req; 1319 1320 /* 1321 * The statep is stale in the following cases :- 1322 * 1) if incoming REQ's comid's doesn't match with what is 1323 * stored in statep 1324 * 2) incoming REQ's local comid matches with statep's 1325 * remote comid, but the REQ is for a new connection. 1326 * This is verified that by comparing the current time 1327 * with stale clock in statep 1328 */ 1329 } else { 1330 /* This is a stale connection on passive side */ 1331 1332 ibcm_insert_trace(statep, IBCM_TRACE_STALE_DETECT); 1333 1334 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_msg: " 1335 "stale detected statep %p state %x", 1336 statep, statep->state); 1337 1338 IBTF_DPRINTF_L4(cmlog, "ibcm_process_req_msg: " 1339 "cur_time 0x%llX stale_clock 0x%llX", cur_time, 1340 statep->stale_clock); 1341 1342 if (statep->state == IBCM_STATE_ESTABLISHED) { 1343 1344 statep->state = IBCM_STATE_TRANSIENT_DREQ_SENT; 1345 statep->stale = B_TRUE; 1346 1347 /* Cancel pending ibt_set_alt_path */ 1348 ibcm_sync_lapr_idle(statep); 1349 /* The above call releases the state mutex */ 1350 1351 if (statep->dreq_msg == NULL) 1352 (void) ibcm_alloc_out_msg( 1353 statep->stored_reply_addr.ibmf_hdl, 1354 &statep->dreq_msg, MAD_METHOD_SEND); 1355 1356 /* 1357 * Spec says, post DREQ MAD on the stale 1358 * channel. This moves channel into timewait 1359 */ 1360 if (statep->dreq_msg != NULL) 1361 ibcm_post_dreq_mad(statep); 1362 else { 1363 mutex_enter(&statep->state_mutex); 1364 statep->state = IBCM_STATE_ESTABLISHED; 1365 cv_broadcast(&statep->block_mad_cv); 1366 mutex_exit(&statep->state_mutex); 1367 } 1368 } else { 1369 /* 1370 * If not in established state, the CM 1371 * protocol would timeout and delete the 1372 * statep that is stale, eventually 1373 */ 1374 mutex_exit(&statep->state_mutex); 1375 } 1376 1377 /* Post a REJ MAD to the incoming REQ's sender */ 1378 ibcm_build_n_post_rej_mad(input_madp, 1379 b2h32(req_msgp->req_local_comm_id), 1380 cm_mad_addr, IBT_CM_FAILURE_REQ, IBT_CM_CONN_STALE); 1381 1382 mutex_enter(&statep->state_mutex); 1383 } 1384 IBCM_REF_CNT_DECR(statep); /* decrement the ref count */ 1385 mutex_exit(&statep->state_mutex); 1386 } 1387 } 1388 1389 /* 1390 * ibcm_handle_cep_req_response: 1391 * Processes the response from ibcm_cep_state_req. Called holding a 1392 * statep ref cnt. The statep ref cnt is decremented before returning. 1393 */ 1394 void 1395 ibcm_handle_cep_req_response(ibcm_state_data_t *statep, ibcm_status_t response, 1396 ibt_cm_reason_t reject_reason, uint8_t arej_info_len) 1397 { 1398 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 1399 1400 if (response == IBCM_SEND_REP) 1401 ibcm_post_rep_mad(statep); 1402 else { 1403 ASSERT(response == IBCM_SEND_REJ); 1404 IBTF_DPRINTF_L4(cmlog, "ibcm_handle_cep_req_response: statep %p" 1405 " posting REJ reject_reason = %d", statep, reject_reason); 1406 1407 ibcm_post_rej_mad(statep, 1408 reject_reason, IBT_CM_FAILURE_REQ, 1409 NULL, arej_info_len); 1410 } 1411 1412 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*statep)) 1413 1414 mutex_enter(&statep->state_mutex); 1415 IBCM_REF_CNT_DECR(statep); 1416 mutex_exit(&statep->state_mutex); 1417 } 1418 1419 1420 /* 1421 * ibcm_process_rep_msg: 1422 * ACTIVE SIDE CM 1423 * Called from ibcm_process_incoming_mad on reception of a REP message 1424 * 1425 * INPUTS: 1426 * hcap - HCA entry pointer 1427 * input_madp - CM MAD that is input to this function 1428 * cm_mad_addr - Address information for the MAD 1429 * 1430 * RETURN VALUE: NONE 1431 */ 1432 void 1433 ibcm_process_rep_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 1434 ibcm_mad_addr_t *cm_mad_addr) 1435 { 1436 ibt_priv_data_len_t arej_info_len = 0; 1437 ib_com_id_t local_comid; 1438 timeout_id_t timer_val; 1439 ibcm_status_t lookup_status; /* state lookup status */ 1440 ibcm_status_t stale_lookup_status; 1441 ibcm_status_t stale_comid_lookup_status; 1442 ibcm_status_t response; 1443 ibcm_rep_msg_t *rep_msgp; /* Response REP mesg */ 1444 ibt_cm_reason_t reject_reason; 1445 ibcm_state_data_t *statep = NULL; 1446 ibcm_state_data_t *stale_qpn = NULL; 1447 ibcm_state_data_t *stale_comid = NULL; 1448 ib_guid_t remote_ca_guid; 1449 1450 IBTF_DPRINTF_L3(cmlog, "ibcm_process_rep_msg:"); 1451 1452 /* Lookup for an existing state structure */ 1453 rep_msgp = (ibcm_rep_msg_t *)(&input_madp[IBCM_MAD_HDR_SIZE]); 1454 1455 IBCM_DUMP_RAW_MSG((uchar_t *)input_madp); 1456 1457 IBTF_DPRINTF_L5(cmlog, "ibcm_process_rep_msg: active comid: %x", 1458 rep_msgp->rep_remote_comm_id); 1459 1460 local_comid = b2h32(rep_msgp->rep_remote_comm_id); 1461 1462 /* lookup message holding a reader lock */ 1463 rw_enter(&hcap->hca_state_rwlock, RW_READER); 1464 lookup_status = ibcm_lookup_msg(IBCM_INCOMING_REP, local_comid, 0, 0, 1465 hcap, &statep); 1466 rw_exit(&hcap->hca_state_rwlock); 1467 1468 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rep_msg: lkup status %x, " 1469 "statep 0x%p active comid %x", lookup_status, statep, local_comid); 1470 1471 if (lookup_status == IBCM_LOOKUP_FAIL) { 1472 ibcm_build_n_post_rej_mad(input_madp, 1473 b2h32(rep_msgp->rep_local_comm_id), cm_mad_addr, 1474 IBT_CM_FAILURE_REP, IBT_CM_INVALID_CID); 1475 1476 return; 1477 } 1478 1479 /* if transaction id is not as expected, drop the REP mad */ 1480 if (IBCM_OUT_HDRP(statep->stored_msg)->TransactionID != 1481 ((ib_mad_hdr_t *)(input_madp))->TransactionID) { 1482 1483 IBTF_DPRINTF_L3(cmlog, "ibcm_process_rep_msg: statep 0x%p, " 1484 "An REP MAD with tid expected 0x%llX tid found 0x%llX ", 1485 statep, 1486 b2h64(IBCM_OUT_HDRP(statep->stored_msg)->TransactionID), 1487 b2h64(((ib_mad_hdr_t *)(input_madp))->TransactionID)); 1488 1489 mutex_enter(&statep->state_mutex); 1490 IBCM_REF_CNT_DECR(statep); 1491 mutex_exit(&statep->state_mutex); 1492 return; 1493 } 1494 1495 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_REP); 1496 1497 /* grab mutex first */ 1498 mutex_enter(&statep->state_mutex); 1499 1500 /* 1501 * There is a state structure entry with active comid 1502 * First, handle the re-send cases 1503 * The resend routines below release the state mutex 1504 */ 1505 if (statep->state == IBCM_STATE_ESTABLISHED || 1506 statep->state == IBCM_STATE_DREQ_SENT) 1507 ibcm_resend_rtu_mad(statep); 1508 else if (statep->state == IBCM_STATE_REJ_SENT) 1509 ibcm_resend_rej_mad(statep); 1510 else if (statep->state == IBCM_STATE_MRA_REP_SENT) 1511 ibcm_resend_mra_mad(statep); 1512 else if ((statep->state == IBCM_STATE_REQ_SENT) || 1513 (statep->state == IBCM_STATE_REP_WAIT)) { 1514 1515 /* change state */ 1516 statep->state = IBCM_STATE_REP_RCVD; 1517 statep->clnt_proceed = IBCM_BLOCK; 1518 statep->local_qp_rnr_cnt = 1519 rep_msgp->rep_rnr_retry_cnt_plus >> 5; 1520 1521 /* cancel the REQ timer */ 1522 if (statep->timerid != 0) { 1523 timer_val = statep->timerid; 1524 statep->timerid = 0; 1525 mutex_exit(&statep->state_mutex); 1526 (void) untimeout(timer_val); 1527 } else { 1528 mutex_exit(&statep->state_mutex); 1529 } 1530 1531 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 1532 1533 /* Initialize the remote destination QPN for further MADs */ 1534 statep->stored_reply_addr.rcvd_addr.ia_remote_qno = 1535 cm_mad_addr->rcvd_addr.ia_remote_qno; 1536 statep->remote_qpn = b2h32(rep_msgp->rep_local_qpn_plus) >> 8; 1537 statep->remote_comid = b2h32(rep_msgp->rep_local_comm_id); 1538 bcopy(rep_msgp->rep_local_ca_guid, &remote_ca_guid, 1539 sizeof (ib_guid_t)); 1540 statep->remote_hca_guid = b2h64(remote_ca_guid); 1541 1542 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rep_msg: statep 0x%p " 1543 "passive cid = %x passive qpn = %x", statep, 1544 statep->remote_comid, statep->remote_qpn); 1545 1546 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rep_msg: statep 0x%p " 1547 "passive hcaguid = %llX", statep, statep->remote_hca_guid); 1548 1549 stale_qpn = statep; 1550 stale_comid = statep; 1551 1552 /* Handle stale connection detection on active side */ 1553 rw_enter(&hcap->hca_state_rwlock, RW_WRITER); 1554 1555 stale_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_REP_STALE, 1556 0, statep->remote_qpn, statep->remote_hca_guid, hcap, 1557 &stale_qpn); 1558 1559 stale_comid_lookup_status = ibcm_lookup_msg( 1560 IBCM_INCOMING_REQ_STALE, statep->remote_comid, 0, 1561 statep->remote_hca_guid, hcap, &stale_comid); 1562 1563 rw_exit(&hcap->hca_state_rwlock); 1564 1565 /* 1566 * Check for other side reusing QPN that was attempted 1567 * to be used, but somehow we sent a REJ. 1568 */ 1569 mutex_enter(&stale_qpn->state_mutex); 1570 if ((stale_lookup_status == IBCM_LOOKUP_EXISTS) && 1571 (stale_comid_lookup_status != IBCM_LOOKUP_EXISTS) && 1572 (stale_qpn->state == IBCM_STATE_REJ_SENT)) { 1573 1574 timeout_id_t timer_val; 1575 1576 IBTF_DPRINTF_L3(cmlog, "ibcm_process_rep_msg: " 1577 "statep 0x%p being retired, REMOTE_QPN %x", 1578 stale_qpn, statep->remote_qpn); 1579 /* 1580 * OK, this is reuse of the QPN on the active side 1581 * that was not connected last time. This REQ is 1582 * considered NEW. We delete the statep here, 1583 * then start over from the top. 1584 */ 1585 stale_qpn->state = IBCM_STATE_DELETE; 1586 timer_val = stale_qpn->timerid; 1587 stale_qpn->timerid = 0; 1588 mutex_exit(&stale_qpn->state_mutex); 1589 if (timer_val) 1590 (void) untimeout(timer_val); 1591 IBCM_REF_CNT_DECR(stale_qpn); 1592 ibcm_delete_state_data(stale_qpn); 1593 stale_qpn = statep; 1594 rw_enter(&hcap->hca_state_rwlock, RW_WRITER); 1595 stale_lookup_status = ibcm_lookup_msg( 1596 IBCM_INCOMING_REP_STALE, 0, statep->remote_qpn, 1597 statep->remote_hca_guid, hcap, &stale_qpn); 1598 rw_exit(&hcap->hca_state_rwlock); 1599 /* OK to continue now */ 1600 } else 1601 mutex_exit(&stale_qpn->state_mutex); 1602 1603 /* 1604 * lookup exists implies that there is already an entry with 1605 * the remote qpn/comid and remote hca guid 1606 */ 1607 if ((stale_lookup_status == IBCM_LOOKUP_EXISTS) || 1608 (stale_comid_lookup_status == IBCM_LOOKUP_EXISTS)) { 1609 1610 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rep_msg: " 1611 "statep 0x%p stale detected " 1612 "qpn_lkup %d comid_lkup %d", statep, 1613 stale_lookup_status, stale_comid_lookup_status); 1614 1615 /* Disassociate statep and QP */ 1616 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 1617 1618 if (stale_lookup_status == IBCM_LOOKUP_EXISTS) 1619 reject_reason = IBT_CM_CONN_STALE; 1620 else 1621 reject_reason = IBT_CM_DUP_COM_ID; 1622 1623 ibcm_handler_conn_fail(statep, 1624 IBT_CM_FAILURE_REJ_SENT, IBT_CM_FAILURE_REP, 1625 reject_reason, 1626 IBCM_REJ_PRIV(statep->stored_msg), 1627 IBT_REJ_PRIV_DATA_SZ); 1628 1629 /* Send a REJ with stale reason for statep */ 1630 ibcm_post_rej_mad(statep, reject_reason, 1631 IBT_CM_FAILURE_REP, NULL, 0); 1632 1633 /* Now let's handle the logic for stale connections */ 1634 /* If in established state, stale_statep is stale */ 1635 if (stale_lookup_status == IBCM_LOOKUP_EXISTS) { 1636 1637 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rep_msg: " 1638 "state_qpn 0x%p stale QPN detected " 1639 "state %X", stale_qpn, stale_qpn->state); 1640 1641 ibcm_insert_trace(stale_qpn, 1642 IBCM_TRACE_STALE_DETECT); 1643 1644 mutex_enter(&stale_qpn->state_mutex); 1645 if (stale_qpn->state == 1646 IBCM_STATE_ESTABLISHED) { 1647 /* change state to DREQ sent */ 1648 stale_qpn->state = 1649 IBCM_STATE_TRANSIENT_DREQ_SENT; 1650 stale_qpn->stale = B_TRUE; 1651 1652 /* wait for/cancel pending LAP/APR */ 1653 ibcm_sync_lapr_idle(stale_qpn); 1654 /* above call releases state mutex */ 1655 1656 if (stale_qpn->dreq_msg == NULL) 1657 (void) ibcm_alloc_out_msg( 1658 stale_qpn-> 1659 stored_reply_addr.ibmf_hdl, 1660 &stale_qpn->dreq_msg, 1661 MAD_METHOD_SEND); 1662 1663 if (stale_qpn->dreq_msg != NULL) { 1664 ibcm_post_dreq_mad(stale_qpn); 1665 mutex_enter( 1666 &stale_qpn->state_mutex); 1667 } else { 1668 mutex_enter( 1669 &stale_qpn->state_mutex); 1670 stale_qpn->state = 1671 IBCM_STATE_ESTABLISHED; 1672 cv_broadcast( 1673 &stale_qpn->block_mad_cv); 1674 } 1675 } 1676 IBCM_REF_CNT_DECR(stale_qpn); 1677 mutex_exit(&stale_qpn->state_mutex); 1678 } 1679 1680 if (stale_comid_lookup_status == IBCM_LOOKUP_EXISTS) { 1681 1682 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rep_msg: " 1683 "state_comid 0x%p stale COMID detected " 1684 "state %X", stale_comid, 1685 stale_comid->state); 1686 1687 mutex_enter(&stale_comid->state_mutex); 1688 if (!((stale_lookup_status == 1689 IBCM_LOOKUP_EXISTS) && 1690 (stale_qpn == stale_comid)) && 1691 (stale_comid->state == 1692 IBCM_STATE_ESTABLISHED)) { 1693 1694 ibcm_insert_trace(stale_comid, 1695 IBCM_TRACE_STALE_DETECT); 1696 1697 /* change state to DREQ sent */ 1698 stale_comid->state = 1699 IBCM_STATE_TRANSIENT_DREQ_SENT; 1700 stale_comid->stale = B_TRUE; 1701 1702 /* wait for/cancel pending LAP/APR */ 1703 ibcm_sync_lapr_idle(stale_comid); 1704 1705 /* above call releases state mutex */ 1706 1707 if (stale_comid->dreq_msg == NULL) 1708 (void) ibcm_alloc_out_msg( 1709 stale_comid-> 1710 stored_reply_addr.ibmf_hdl, 1711 &stale_comid->dreq_msg, 1712 MAD_METHOD_SEND); 1713 1714 if (stale_comid->dreq_msg != NULL) { 1715 ibcm_post_dreq_mad(stale_comid); 1716 mutex_enter( 1717 &stale_comid->state_mutex); 1718 } else { 1719 mutex_enter( 1720 &stale_comid->state_mutex); 1721 stale_comid->state = 1722 IBCM_STATE_ESTABLISHED; 1723 cv_broadcast( 1724 &stale_comid->block_mad_cv); 1725 } 1726 } 1727 IBCM_REF_CNT_DECR(stale_comid); 1728 mutex_exit(&stale_comid->state_mutex); 1729 } 1730 ibcm_return_open_data(statep, rep_msgp, reject_reason); 1731 return; 1732 } 1733 1734 /* 1735 * No need to handle out of memory conditions as we called 1736 * ibcm_lookup_msg() with IBT_CHAN_BLOCKING flags. 1737 */ 1738 ASSERT(stale_lookup_status == IBCM_LOOKUP_NEW); 1739 1740 /* Initialize the remote ack delay */ 1741 statep->remote_ack_delay = 1742 ibt_ib2usec(rep_msgp->rep_target_delay_plus >> 3); 1743 1744 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rep_msg: statep 0x%p" 1745 " passive hca_ack_delay= %x ", statep, 1746 statep->remote_ack_delay); 1747 1748 response = ibcm_cep_state_rep(statep, rep_msgp, 1749 &reject_reason, &arej_info_len); 1750 1751 if (response == IBCM_DEFER) { 1752 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rep_msg: " 1753 "statep 0x%p client returned DEFER response", 1754 statep); 1755 return; 1756 } 1757 ibcm_handle_cep_rep_response(statep, response, 1758 reject_reason, arej_info_len, rep_msgp); 1759 1760 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*statep)) 1761 1762 return; 1763 1764 } else if (statep->state == IBCM_STATE_DELETE) { 1765 1766 mutex_exit(&statep->state_mutex); 1767 ibcm_build_n_post_rej_mad(input_madp, 1768 b2h32(rep_msgp->rep_local_comm_id), cm_mad_addr, 1769 IBT_CM_FAILURE_REP, IBT_CM_INVALID_CID); 1770 mutex_enter(&statep->state_mutex); 1771 } else { 1772 1773 #ifdef DEBUG 1774 if (ibcm_test_mode > 0) 1775 if (statep->state == IBCM_STATE_REP_RCVD) 1776 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rep_msg: " 1777 "REP re-send from passive for statep 0x%p" 1778 " in state %d", statep, statep->state); 1779 else 1780 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rep_msg: " 1781 "Unexpected REP for statep 0x%p in " 1782 "state %d", statep, statep->state); 1783 #endif 1784 } 1785 /* decrement ref count and return for LOOKUP_EXISTS */ 1786 IBCM_REF_CNT_DECR(statep); 1787 mutex_exit(&statep->state_mutex); 1788 1789 } 1790 1791 /* 1792 * ibcm_handle_cep_req_response: 1793 * Processes the response from ibcm_cep_state_rep. Called holding a 1794 * statep ref cnt. The statep ref cnt is decremented before returning. 1795 */ 1796 void 1797 ibcm_handle_cep_rep_response(ibcm_state_data_t *statep, ibcm_status_t response, 1798 ibt_cm_reason_t reject_reason, uint8_t arej_info_len, 1799 ibcm_rep_msg_t *rep_msgp) 1800 { 1801 /* wait until the send completion callback is invoked for REQ post */ 1802 mutex_enter(&statep->state_mutex); 1803 while (statep->send_mad_flags & IBCM_REQ_POST_BUSY) 1804 cv_wait(&statep->block_mad_cv, &statep->state_mutex); 1805 mutex_exit(&statep->state_mutex); 1806 1807 if (response == IBCM_SEND_RTU) { 1808 /* if connection aborted, return */ 1809 if (ibcm_post_rtu_mad(statep) != IBCM_SUCCESS) { 1810 mutex_enter(&statep->state_mutex); 1811 IBCM_REF_CNT_DECR(statep); 1812 mutex_exit(&statep->state_mutex); 1813 return; 1814 } 1815 1816 /* 1817 * Call client handler with cm event IBT_CM_EVENT_CONN_EST to 1818 * indicate RTU posted 1819 */ 1820 ibcm_cep_send_rtu(statep); 1821 } else { 1822 IBTF_DPRINTF_L4(cmlog, "ibcm_handle_cep_rep_response: statep %p" 1823 " posting REJ reject_reason = %d", statep, reject_reason); 1824 1825 ASSERT(response == IBCM_SEND_REJ); 1826 ibcm_post_rej_mad(statep, reject_reason, IBT_CM_FAILURE_REP, 1827 NULL, arej_info_len); 1828 } 1829 1830 ibcm_return_open_data(statep, rep_msgp, reject_reason); 1831 } 1832 1833 /* 1834 * ibcm_return_open_data: 1835 * Initializes the ibt_open_rc_channel return data. The statep ref cnt is 1836 * decremented before returning. 1837 */ 1838 static void 1839 ibcm_return_open_data(ibcm_state_data_t *statep, ibcm_rep_msg_t *rep_msgp, 1840 ibt_cm_reason_t reject_reason) 1841 { 1842 /* signal waiting CV - blocking in ibt_open_channel() */ 1843 if (statep->open_return_data != NULL) { 1844 if (statep->open_return_data->rc_priv_data_len > 0) 1845 bcopy(rep_msgp->rep_private_data, 1846 statep->open_return_data->rc_priv_data, 1847 statep->open_return_data->rc_priv_data_len); 1848 statep->open_return_data->rc_rdma_ra_in = 1849 rep_msgp->rep_initiator_depth; 1850 statep->open_return_data->rc_rdma_ra_out = 1851 rep_msgp->rep_resp_resources; 1852 statep->open_return_data->rc_failover_status = 1853 rep_msgp->rep_target_delay_plus >> 1 & 3; 1854 statep->open_return_data->rc_status = reject_reason; 1855 1856 mutex_enter(&statep->state_mutex); 1857 statep->open_done = B_TRUE; 1858 cv_broadcast(&statep->block_client_cv); 1859 } else mutex_enter(&statep->state_mutex); 1860 1861 /* decrement ref count and return for LOOKUP_EXISTS */ 1862 IBCM_REF_CNT_DECR(statep); 1863 mutex_exit(&statep->state_mutex); 1864 } 1865 1866 1867 /* 1868 * ibcm_process_mra_msg: 1869 * Called from ibcm_process_incoming_mad on reception of a MRA message 1870 * 1871 * Cancels existing timer, and sets a new timer based on timeout 1872 * value from MRA message. The remaining retry count of statep is 1873 * not changed, and timer value for the remaining retry timers is 1874 * also not changed 1875 * 1876 * INPUTS: 1877 * hcap - HCA entry pointer 1878 * input_madp - CM MAD that is input to this function 1879 * cm_mad_addr - Address information for the MAD 1880 * 1881 * RETURN VALUE: NONE 1882 */ 1883 void 1884 ibcm_process_mra_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 1885 ibcm_mad_addr_t *cm_mad_addr) 1886 { 1887 ibcm_status_t state_lookup_status; 1888 ibcm_mra_msg_t *mra_msgp = 1889 (ibcm_mra_msg_t *)(&input_madp[IBCM_MAD_HDR_SIZE]); 1890 ibcm_state_data_t *statep = NULL; 1891 uint8_t mra_msg; 1892 1893 IBTF_DPRINTF_L4(cmlog, "ibcm_process_mra_msg:"); 1894 1895 /* Lookup for an existing state structure (as a READER) */ 1896 rw_enter(&hcap->hca_state_rwlock, RW_READER); 1897 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_MRA, 1898 b2h32(mra_msgp->mra_remote_comm_id), 0, 0, hcap, &statep); 1899 rw_exit(&hcap->hca_state_rwlock); 1900 1901 /* if state doesn't exist just return */ 1902 if (state_lookup_status != IBCM_LOOKUP_EXISTS) { 1903 ibcm_build_n_post_rej_mad(input_madp, 1904 b2h32(mra_msgp->mra_local_comm_id), cm_mad_addr, 1905 IBT_CM_FAILURE_UNKNOWN, IBT_CM_INVALID_CID); 1906 return; 1907 } 1908 1909 if (IBCM_OUT_HDRP(statep->stored_msg)->TransactionID != 1910 ((ib_mad_hdr_t *)(input_madp))->TransactionID) { 1911 mutex_enter(&statep->state_mutex); 1912 IBCM_REF_CNT_DECR(statep); 1913 mutex_exit(&statep->state_mutex); 1914 IBTF_DPRINTF_L3(cmlog, "ibcm_process_mra_msg: statep 0x%p " 1915 "MRA MAD with tid expected 0x%llX tid found 0x%llX " 1916 "com id 0x%x arrived", statep, 1917 b2h64(IBCM_OUT_HDRP(statep->stored_msg)->TransactionID), 1918 b2h64(((ib_mad_hdr_t *)(input_madp))->TransactionID), 1919 b2h32(mra_msgp->mra_local_comm_id)); 1920 return; 1921 } 1922 1923 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_MRA); 1924 1925 mutex_enter(&statep->state_mutex); 1926 1927 /* 1928 * Only allow for REQ/REP "mra_msg_typ" ONLY 1929 * (to validate MRA message received)? 1930 */ 1931 mra_msg = mra_msgp->mra_message_type_plus >> 6; 1932 if ((mra_msg != IBT_CM_MRA_TYPE_REQ) && 1933 (mra_msg != IBT_CM_MRA_TYPE_REP) && 1934 (mra_msg != IBT_CM_MRA_TYPE_LAP)) { 1935 1936 IBTF_DPRINTF_L2(cmlog, "ibcm_process_mra_msg: statep 0x%p " 1937 "Unexpected MRA MSG Type %x", statep, mra_msg); 1938 IBCM_REF_CNT_DECR(statep); 1939 mutex_exit(&statep->state_mutex); 1940 return; 1941 } 1942 1943 if ((statep->state == IBCM_STATE_REQ_SENT) || 1944 (statep->state == IBCM_STATE_REP_SENT) || 1945 ((statep->state == IBCM_STATE_ESTABLISHED) && 1946 (statep->ap_state == IBCM_AP_STATE_LAP_SENT))) { 1947 timeout_id_t timer_val = statep->timerid; 1948 clock_t service_timeout; 1949 1950 if (statep->state == IBCM_STATE_REQ_SENT) { 1951 mra_msg = IBT_CM_MRA_TYPE_REQ; 1952 statep->state = IBCM_STATE_REP_WAIT; 1953 } else if (statep->state == IBCM_STATE_REP_SENT) { 1954 mra_msg = IBT_CM_MRA_TYPE_REP; 1955 statep->state = IBCM_STATE_MRA_REP_RCVD; 1956 } else { /* statep->state == IBCM_STATE_LAP_SENT */ 1957 mra_msg = IBT_CM_MRA_TYPE_LAP; 1958 statep->ap_state = IBCM_AP_STATE_MRA_LAP_RCVD; 1959 } 1960 1961 /* cancel the timer */ 1962 statep->timerid = 0; 1963 mutex_exit(&statep->state_mutex); 1964 1965 (void) untimeout(timer_val); 1966 1967 service_timeout = 1968 ibt_ib2usec(mra_msgp->mra_service_timeout_plus >> 3); 1969 1970 /* 1971 * If tunable MAX MRA Service Timeout parameter is set, then 1972 * verify whether the requested timer value exceeds the MAX 1973 * value and reset the timer value to the MAX value. 1974 */ 1975 if (ibcm_mra_service_timeout_max && 1976 ibcm_mra_service_timeout_max < service_timeout) { 1977 IBTF_DPRINTF_L2(cmlog, "ibcm_process_mra_msg: " 1978 "Unexpected MRA Service Timeout value (%ld), Max " 1979 "allowed is (%ld)", service_timeout, 1980 ibcm_mra_service_timeout_max); 1981 service_timeout = ibcm_mra_service_timeout_max; 1982 } 1983 1984 /* 1985 * Invoke client handler to pass the MRA private data 1986 */ 1987 if (statep->cm_handler != NULL) { 1988 ibt_cm_event_t event; 1989 1990 bzero(&event, sizeof (event)); 1991 1992 event.cm_type = IBT_CM_EVENT_MRA_RCV; 1993 event.cm_channel = statep->channel; 1994 event.cm_session_id = NULL; 1995 event.cm_priv_data = mra_msgp->mra_private_data; 1996 event.cm_priv_data_len = IBT_MRA_PRIV_DATA_SZ; 1997 1998 event.cm_event.mra.mra_msg_type = mra_msg; 1999 2000 event.cm_event.mra.mra_service_time = service_timeout; 2001 2002 /* Client cannot return private data */ 2003 (void) statep->cm_handler(statep->state_cm_private, 2004 &event, NULL, NULL, 0); 2005 } 2006 2007 /* 2008 * Must re-check state, as an RTU could have come 2009 * after the above mutex_exit and mutex_enter below 2010 */ 2011 mutex_enter(&statep->state_mutex); 2012 if ((statep->state == IBCM_STATE_REP_WAIT) || 2013 (statep->state == IBCM_STATE_MRA_REP_RCVD) || 2014 (statep->ap_state == IBCM_AP_STATE_MRA_LAP_RCVD)) { 2015 2016 statep->remaining_retry_cnt = statep->max_cm_retries; 2017 2018 /* 2019 * The timeout interval is changed only for the first 2020 * retry. The later retries use the timeout from 2021 * statep->timer_value 2022 */ 2023 statep->timer_stored_state = statep->state; 2024 statep->timer_value = statep->pkt_life_time + 2025 service_timeout; 2026 statep->timerid = IBCM_TIMEOUT(statep, 2027 statep->timer_value); 2028 } 2029 2030 } else if (statep->state == IBCM_STATE_DELETE) { 2031 2032 mutex_exit(&statep->state_mutex); 2033 ibcm_build_n_post_rej_mad(input_madp, 2034 b2h32(mra_msgp->mra_local_comm_id), cm_mad_addr, 2035 IBT_CM_FAILURE_UNKNOWN, IBT_CM_INVALID_CID); 2036 mutex_enter(&statep->state_mutex); 2037 } else { 2038 2039 #ifdef DEBUG 2040 if (ibcm_test_mode > 0) 2041 IBTF_DPRINTF_L2(cmlog, "ibcm_process_mra_msg: " 2042 "Unexpected mra for statep 0x%p in state %d", 2043 statep, statep->state); 2044 #endif 2045 } 2046 2047 IBCM_REF_CNT_DECR(statep); 2048 mutex_exit(&statep->state_mutex); 2049 } 2050 2051 2052 /* 2053 * ibcm_process_rtu_msg: 2054 * Called from ibcm_process_incoming_mad on reception of a RTU message 2055 * 2056 * Changes connection state to established if in REP SENT state 2057 * 2058 * INPUTS: 2059 * hcap - HCA entry pointer 2060 * input_madp - CM MAD that is input to this function 2061 * cm_mad_addr - Address information for the MAD 2062 * 2063 * RETURN VALUE: NONE 2064 */ 2065 void 2066 ibcm_process_rtu_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 2067 ibcm_mad_addr_t *cm_mad_addr) 2068 { 2069 timeout_id_t timer_val; 2070 ibcm_status_t status; 2071 ibcm_rtu_msg_t *rtu_msg = 2072 (ibcm_rtu_msg_t *)(&input_madp[IBCM_MAD_HDR_SIZE]); 2073 ibcm_state_data_t *statep = NULL; 2074 2075 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rtu_msg:"); 2076 2077 /* Lookup for an existing state structure - using a reader lock */ 2078 rw_enter(&hcap->hca_state_rwlock, RW_READER); 2079 status = ibcm_lookup_msg(IBCM_INCOMING_RTU, 2080 b2h32(rtu_msg->rtu_remote_comm_id), 0, 0, hcap, &statep); 2081 rw_exit(&hcap->hca_state_rwlock); 2082 2083 /* if state doesn't exist just return */ 2084 if (status != IBCM_LOOKUP_EXISTS) { 2085 ibcm_build_n_post_rej_mad(input_madp, 2086 b2h32(rtu_msg->rtu_local_comm_id), cm_mad_addr, 2087 IBT_CM_FAILURE_UNKNOWN, IBT_CM_INVALID_CID); 2088 return; 2089 } 2090 2091 if (IBCM_OUT_HDRP(statep->stored_msg)->TransactionID != 2092 ((ib_mad_hdr_t *)(input_madp))->TransactionID) { 2093 mutex_enter(&statep->state_mutex); 2094 IBCM_REF_CNT_DECR(statep); 2095 mutex_exit(&statep->state_mutex); 2096 IBTF_DPRINTF_L3(cmlog, "ibcm_process_rtu_msg: statep 0x%p " 2097 "An RTU MAD with tid expected 0x%llX tid found 0x%llX " 2098 "com id 0x%x arrived", statep, 2099 b2h64(IBCM_OUT_HDRP(statep->stored_msg)->TransactionID), 2100 b2h64(((ib_mad_hdr_t *)(input_madp))->TransactionID), 2101 b2h32(rtu_msg->rtu_remote_comm_id)); 2102 return; 2103 } 2104 2105 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_RTU); 2106 2107 mutex_enter(&statep->state_mutex); 2108 2109 if ((statep->state == IBCM_STATE_REP_SENT) || 2110 (statep->state == IBCM_STATE_MRA_REP_RCVD)) { 2111 2112 /* transient until ibt_modify_qp succeeds to RTS */ 2113 statep->state = IBCM_STATE_TRANSIENT_ESTABLISHED; 2114 2115 timer_val = statep->timerid; 2116 statep->timerid = 0; 2117 mutex_exit(&statep->state_mutex); 2118 2119 (void) untimeout(timer_val); 2120 2121 ibcm_cep_state_rtu(statep, rtu_msg); 2122 2123 mutex_enter(&statep->state_mutex); 2124 2125 } else if (statep->state == IBCM_STATE_REJ_SENT) { 2126 ibcm_resend_rej_mad(statep); 2127 } else if (statep->state == IBCM_STATE_DELETE) { 2128 2129 mutex_exit(&statep->state_mutex); 2130 ibcm_build_n_post_rej_mad(input_madp, 2131 b2h32(rtu_msg->rtu_local_comm_id), cm_mad_addr, 2132 IBT_CM_FAILURE_UNKNOWN, IBT_CM_INVALID_CID); 2133 mutex_enter(&statep->state_mutex); 2134 } else { 2135 2136 #ifdef DEBUG 2137 if ((ibcm_test_mode > 0) && 2138 (statep->state != IBCM_STATE_ESTABLISHED)) 2139 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rtu_msg: " 2140 "Unexpected rtu for statep 0x%p in state %d", 2141 statep, statep->state); 2142 #endif 2143 } 2144 2145 IBCM_REF_CNT_DECR(statep); 2146 mutex_exit(&statep->state_mutex); 2147 } 2148 2149 2150 /* 2151 * ibcm_process_rej_msg: 2152 * Called from ibcm_process_incoming_mad on reception of a REJ message. 2153 * 2154 * INPUTS: 2155 * hcap - HCA entry pointer 2156 * input_madp - CM MAD that is input to this function 2157 * cm_mad_addr - Address information for the MAD 2158 * 2159 * RETURN VALUE: NONE 2160 */ 2161 /* ARGSUSED */ 2162 void 2163 ibcm_process_rej_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 2164 ibcm_mad_addr_t *cm_mad_addr) 2165 { 2166 ibcm_status_t state_lookup_status; 2167 ibcm_rej_msg_t *rej_msg = 2168 (ibcm_rej_msg_t *)(&input_madp[IBCM_MAD_HDR_SIZE]); 2169 ibcm_state_data_t *statep = NULL; 2170 ib_guid_t remote_hca_guid; 2171 ibcm_conn_state_t rej_state; 2172 2173 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rej_msg:"); 2174 2175 /* Lookup for an existing state structure */ 2176 rw_enter(&hcap->hca_state_rwlock, RW_READER); /* grab READER lock */ 2177 2178 if ((b2h32(rej_msg->rej_remote_comm_id) == 0) && 2179 ((rej_msg->rej_reject_info_len_plus >> 1) >= sizeof (ib_guid_t)) && 2180 (b2h16(rej_msg->rej_rejection_reason) == IBT_CM_TIMEOUT)) { 2181 bcopy(rej_msg->rej_addl_rej_info, &remote_hca_guid, 2182 sizeof (ib_guid_t)); 2183 remote_hca_guid = b2h64(remote_hca_guid); 2184 2185 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rej_msg: " 2186 "hca guid in REJ's ARI = %llX", remote_hca_guid); 2187 2188 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_REJ_RCOMID, 2189 b2h32(rej_msg->rej_local_comm_id), 0, remote_hca_guid, 2190 hcap, &statep); 2191 } else 2192 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_REJ, 2193 b2h32(rej_msg->rej_remote_comm_id), 0, 0, hcap, &statep); 2194 2195 rw_exit(&hcap->hca_state_rwlock); 2196 2197 2198 /* if state doesn't exist just return */ 2199 if (state_lookup_status != IBCM_LOOKUP_EXISTS) { 2200 2201 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rej_msg: no statep with " 2202 "local com id %x remote com id %x reason %d", 2203 b2h32(rej_msg->rej_remote_comm_id), 2204 b2h32(rej_msg->rej_local_comm_id), 2205 b2h16(rej_msg->rej_rejection_reason)); 2206 2207 /* Do NOT respond with invalid comid REJ */ 2208 return; 2209 } 2210 2211 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rej_msg: statep 0x%p INCOMING_REJ", 2212 statep); 2213 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_REJ); 2214 if (ibcm_enable_trace & 2) 2215 ibcm_dump_conn_trace(statep); 2216 2217 mutex_enter(&statep->state_mutex); 2218 2219 rej_state = statep->state; 2220 2221 if ((statep->state == IBCM_STATE_REP_SENT) || 2222 (statep->state == IBCM_STATE_REQ_SENT) || 2223 (statep->state == IBCM_STATE_REP_WAIT) || 2224 (statep->state == IBCM_STATE_MRA_REP_RCVD)) { 2225 timeout_id_t timer_val = statep->timerid; 2226 2227 statep->state = IBCM_STATE_DELETE; 2228 2229 /* cancel the REQ/REP timer */ 2230 if (timer_val != 0) { 2231 statep->timerid = 0; 2232 mutex_exit(&statep->state_mutex); 2233 2234 (void) untimeout(timer_val); 2235 } else { 2236 mutex_exit(&statep->state_mutex); 2237 } 2238 2239 /* 2240 * Call the QP state transition processing function 2241 * NOTE: Input MAD is the REJ received, there is no output MAD 2242 */ 2243 ibcm_cep_state_rej(statep, rej_msg, rej_state); 2244 2245 /* signal waiting CV - blocking in ibt_open_channel() */ 2246 if (statep->open_return_data != NULL) { 2247 statep->open_return_data->rc_status = 2248 b2h16(rej_msg->rej_rejection_reason); 2249 2250 if (statep->open_return_data->rc_priv_data_len > 0) 2251 bcopy(rej_msg->rej_private_data, 2252 statep->open_return_data->rc_priv_data, 2253 min( 2254 statep->open_return_data->rc_priv_data_len, 2255 IBT_REJ_PRIV_DATA_SZ)); 2256 mutex_enter(&statep->state_mutex); 2257 statep->open_done = B_TRUE; 2258 cv_broadcast(&statep->block_client_cv); 2259 } else { 2260 mutex_enter(&statep->state_mutex); 2261 } 2262 2263 IBCM_REF_CNT_DECR(statep); 2264 mutex_exit(&statep->state_mutex); 2265 2266 /* Now delete the statep */ 2267 ibcm_delete_state_data(statep); 2268 2269 } else if ((statep->state == IBCM_STATE_ESTABLISHED) && 2270 (statep->mode == IBCM_ACTIVE_MODE)) { 2271 2272 IBTF_DPRINTF_L4(cmlog, "ibcm_process_rej_msg: statep 0x%p " 2273 "REJ in established state", statep); 2274 2275 statep->state = IBCM_STATE_TIMEWAIT; 2276 2277 /* wait for/cancel pending LAP/APR, release state mutex */ 2278 ibcm_sync_lapr_idle(statep); 2279 2280 /* wait until client is informed CONN EST event */ 2281 mutex_enter(&statep->state_mutex); 2282 while (statep->cep_in_rts == IBCM_BLOCK) 2283 cv_wait(&statep->block_mad_cv, &statep->state_mutex); 2284 mutex_exit(&statep->state_mutex); 2285 2286 /* 2287 * Call the QP state transition processing function 2288 * NOTE: Input MAD is the REJ received, there is no output MAD 2289 */ 2290 ibcm_cep_state_rej_est(statep); 2291 2292 /* 2293 * Start the timewait state timer, as connection is in 2294 * established state 2295 */ 2296 2297 /* 2298 * For passive side CM set it to remote_ack_delay 2299 * For active side CM add the pkt_life_time * 2 2300 */ 2301 mutex_enter(&statep->state_mutex); 2302 statep->timer_value = statep->remote_ack_delay; 2303 /* statep->mode == IBCM_ACTIVE_MODE) */ 2304 statep->timer_value += (2 * statep->pkt_life_time); 2305 2306 statep->remaining_retry_cnt = 0; 2307 statep->timer_stored_state = statep->state; 2308 2309 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 2310 2311 IBCM_REF_CNT_DECR(statep); 2312 mutex_exit(&statep->state_mutex); 2313 2314 } else if (((statep->state == IBCM_STATE_REQ_RCVD) || 2315 (statep->state == IBCM_STATE_REP_RCVD) || 2316 (statep->state == IBCM_STATE_MRA_SENT) || 2317 (statep->state == IBCM_STATE_MRA_REP_SENT)) && 2318 (b2h16(rej_msg->rej_rejection_reason) == IBT_CM_TIMEOUT)) { 2319 2320 if (statep->abort_flag == IBCM_ABORT_INIT) 2321 statep->abort_flag = IBCM_ABORT_REJ; 2322 2323 IBCM_REF_CNT_DECR(statep); 2324 mutex_exit(&statep->state_mutex); 2325 } else { 2326 2327 #ifdef DEBUG 2328 if ((ibcm_test_mode > 0) && 2329 (statep->state != IBCM_STATE_DELETE)) 2330 IBTF_DPRINTF_L2(cmlog, "ibcm_process_rej_msg: " 2331 "Unexpected rej for statep 0x%p in state %d", 2332 statep, statep->state); 2333 #endif 2334 IBCM_REF_CNT_DECR(statep); 2335 mutex_exit(&statep->state_mutex); 2336 } 2337 } 2338 2339 2340 /* 2341 * ibcm_process_dreq_msg: 2342 * Processes incoming DREQ message on active/passive side 2343 * 2344 * INPUTS: 2345 * hcap - HCA entry pointer 2346 * input_madp - CM MAD that is input to this function 2347 * cm_mad_addr - Address information for the MAD 2348 * 2349 * RETURN VALUE: NONE 2350 */ 2351 /*ARGSUSED*/ 2352 void 2353 ibcm_process_dreq_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 2354 ibcm_mad_addr_t *cm_mad_addr) 2355 { 2356 void *priv_data = NULL; 2357 ibcm_status_t state_lookup_status; 2358 ib_qpn_t local_qpn; 2359 ibcm_dreq_msg_t *dreq_msgp = 2360 (ibcm_dreq_msg_t *)(&input_madp[IBCM_MAD_HDR_SIZE]); 2361 ibcm_state_data_t *statep = NULL; 2362 uint8_t close_event_type; 2363 ibt_cm_status_t cb_status; 2364 2365 IBTF_DPRINTF_L4(cmlog, "ibcm_process_dreq_msg:"); 2366 2367 /* Lookup for an existing state structure */ 2368 rw_enter(&hcap->hca_state_rwlock, RW_READER); 2369 2370 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_DREQ, 2371 b2h32(dreq_msgp->dreq_remote_comm_id), 0, 0, hcap, &statep); 2372 rw_exit(&hcap->hca_state_rwlock); 2373 2374 local_qpn = b2h32(dreq_msgp->dreq_remote_qpn_eecn_plus) >> 8; 2375 2376 if (state_lookup_status != IBCM_LOOKUP_EXISTS) { 2377 IBTF_DPRINTF_L3(cmlog, "ibcm_process_dreq_msg: no statep with" 2378 "com id %x", b2h32(dreq_msgp->dreq_remote_comm_id)); 2379 /* implies a bogus message */ 2380 return; 2381 } 2382 2383 IBTF_DPRINTF_L4(cmlog, "ibcm_process_dreq_msg: statep 0x%p " 2384 "lookup status %x dreq qpn = %x", statep, state_lookup_status, 2385 local_qpn); 2386 2387 /* 2388 * Local QPN check is necessary. There could be a DREQ from 2389 * a remote stale connection processing with the same com id, but 2390 * not intended for this statep 2391 */ 2392 mutex_enter(&statep->state_mutex); 2393 if ((statep->local_qpn != local_qpn) || 2394 (statep->remote_comid != b2h32(dreq_msgp->dreq_local_comm_id))) { 2395 2396 IBTF_DPRINTF_L3(cmlog, "ibcm_process_dreq_msg:" 2397 "statep->local_qpn = %x qpn in dreq = %x" 2398 "statep->remote_comid = %x local comid in dreq = %x", 2399 statep->local_qpn, local_qpn, statep->remote_comid, 2400 b2h32(dreq_msgp->dreq_local_comm_id)); 2401 2402 IBCM_REF_CNT_DECR(statep); 2403 mutex_exit(&statep->state_mutex); 2404 return; 2405 } 2406 /* 2407 * If another thread is processing a copy of this same DREQ, 2408 * bail out here. 2409 */ 2410 if (statep->state == IBCM_STATE_TRANSIENT_DREQ_SENT || 2411 statep->drep_in_progress) { 2412 IBCM_REF_CNT_DECR(statep); 2413 mutex_exit(&statep->state_mutex); 2414 return; 2415 } 2416 switch (statep->state) { 2417 case IBCM_STATE_ESTABLISHED: 2418 case IBCM_STATE_DREQ_SENT: 2419 case IBCM_STATE_TIMEWAIT: 2420 break; 2421 default: 2422 /* All other states ignore DREQ */ 2423 IBCM_REF_CNT_DECR(statep); 2424 mutex_exit(&statep->state_mutex); 2425 return; 2426 } 2427 statep->drep_in_progress = 1; 2428 2429 /* 2430 * If drep msg wasn't really required, it shall be deleted finally 2431 * when statep goes away 2432 */ 2433 if (statep->drep_msg == NULL) { 2434 mutex_exit(&statep->state_mutex); 2435 if (ibcm_alloc_out_msg(statep->stored_reply_addr.ibmf_hdl, 2436 &statep->drep_msg, MAD_METHOD_SEND) != IBT_SUCCESS) { 2437 IBTF_DPRINTF_L2(cmlog, "ibcm_process_dreq_msg: " 2438 "statep 0x%p ibcm_alloc_out_msg failed", statep); 2439 mutex_enter(&statep->state_mutex); 2440 statep->drep_in_progress = 0; 2441 IBCM_REF_CNT_DECR(statep); 2442 mutex_exit(&statep->state_mutex); 2443 return; 2444 } 2445 mutex_enter(&statep->state_mutex); 2446 } 2447 2448 if (statep->state == IBCM_STATE_TRANSIENT_DREQ_SENT) { 2449 IBCM_REF_CNT_DECR(statep); 2450 statep->drep_in_progress = 0; 2451 mutex_exit(&statep->state_mutex); 2452 return; 2453 } 2454 2455 /* 2456 * Need to generate drep, as time wait can be reached either by an 2457 * outgoing dreq or an incoming dreq 2458 */ 2459 if ((statep->state == IBCM_STATE_ESTABLISHED) || 2460 (statep->state == IBCM_STATE_DREQ_SENT)) { 2461 timeout_id_t timer_val = statep->timerid; 2462 2463 if (statep->state == IBCM_STATE_DREQ_SENT) { 2464 statep->state = IBCM_STATE_DREQ_RCVD; 2465 statep->timerid = 0; 2466 ibcm_close_done(statep, 0); 2467 mutex_exit(&statep->state_mutex); 2468 2469 close_event_type = IBT_CM_CLOSED_DUP; 2470 if (timer_val != 0) { 2471 /* Cancel the timer set for DREP reception */ 2472 (void) untimeout(timer_val); 2473 } 2474 } else { /* In ESTABLISHED State */ 2475 boolean_t is_ofuv = statep->is_this_ofuv_chan; 2476 2477 statep->state = IBCM_STATE_DREQ_RCVD; 2478 statep->clnt_proceed = IBCM_BLOCK; 2479 2480 /* Cancel or wait for LAP/APR to complete */ 2481 ibcm_sync_lapr_idle(statep); 2482 /* The above function releases the state mutex */ 2483 2484 /* wait until client knows CONN EST event */ 2485 mutex_enter(&statep->state_mutex); 2486 while (statep->cep_in_rts == IBCM_BLOCK) 2487 cv_wait(&statep->block_mad_cv, 2488 &statep->state_mutex); 2489 mutex_exit(&statep->state_mutex); 2490 2491 close_event_type = IBT_CM_CLOSED_DREQ_RCVD; 2492 /* Move CEP to error state */ 2493 if (is_ofuv == B_FALSE) /* Skip for OFUV channel */ 2494 (void) ibcm_cep_to_error_state(statep); 2495 } 2496 mutex_enter(&statep->state_mutex); 2497 statep->drep_in_progress = 0; 2498 2499 IBCM_OUT_HDRP(statep->drep_msg)->TransactionID = 2500 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 2501 2502 priv_data = &(((ibcm_drep_msg_t *) 2503 IBCM_OUT_MSGP(statep->drep_msg))->drep_private_data[0]); 2504 2505 if (statep->close_ret_status) 2506 *statep->close_ret_status = close_event_type; 2507 2508 if (statep->close_nocb_state != IBCM_FAIL) { 2509 ibtl_cm_chan_is_closing(statep->channel); 2510 statep->close_nocb_state = IBCM_BLOCK; 2511 } 2512 mutex_exit(&statep->state_mutex); 2513 2514 /* 2515 * if close_nocb_state is IBCM_FAIL, then cm_handler is NULL 2516 * if close_nocb_state is IBCM_BLOCK, client cannot go away 2517 */ 2518 if (statep->cm_handler != NULL) { 2519 ibt_cm_event_t event; 2520 ibt_cm_return_args_t ret_args; 2521 2522 bzero(&event, sizeof (event)); 2523 bzero(&ret_args, sizeof (ret_args)); 2524 2525 event.cm_type = IBT_CM_EVENT_CONN_CLOSED; 2526 event.cm_channel = statep->channel; 2527 event.cm_session_id = statep; 2528 event.cm_priv_data = dreq_msgp->dreq_private_data; 2529 event.cm_priv_data_len = IBT_DREQ_PRIV_DATA_SZ; 2530 event.cm_event.closed = close_event_type; 2531 2532 ibcm_insert_trace(statep, 2533 IBCM_TRACE_CALLED_CONN_CLOSE_EVENT); 2534 2535 cb_status = statep->cm_handler(statep->state_cm_private, 2536 &event, &ret_args, priv_data, 2537 IBT_DREP_PRIV_DATA_SZ); 2538 2539 ibcm_insert_trace(statep, 2540 IBCM_TRACE_RET_CONN_CLOSE_EVENT); 2541 2542 if (cb_status == IBT_CM_DEFER) { 2543 mutex_enter(&statep->state_mutex); 2544 statep->clnt_proceed = 2545 IBCM_UNBLOCK; 2546 cv_broadcast(&statep->block_client_cv); 2547 mutex_exit(&statep->state_mutex); 2548 2549 IBTF_DPRINTF_L4(cmlog, "ibcm_process_dreq_msg:" 2550 " statep 0x%p client returned DEFER " 2551 "response", statep); 2552 return; 2553 } 2554 } 2555 2556 /* fail/resume any blocked cm api call */ 2557 mutex_enter(&statep->state_mutex); 2558 2559 /* Signal for cm proceed api */ 2560 statep->clnt_proceed = IBCM_FAIL; 2561 2562 /* Signal for close with no callbacks */ 2563 statep->close_nocb_state = IBCM_FAIL; 2564 2565 /* Signal any waiting close channel thread */ 2566 statep->close_done = B_TRUE; 2567 2568 cv_broadcast(&statep->block_client_cv); 2569 mutex_exit(&statep->state_mutex); 2570 2571 ibcm_handle_cep_dreq_response(statep, NULL, 0); 2572 2573 } else if (statep->state == IBCM_STATE_TIMEWAIT) { 2574 statep->drep_in_progress = 0; 2575 if (statep->send_mad_flags & IBCM_DREP_POST_BUSY) { 2576 IBCM_REF_CNT_DECR(statep); 2577 mutex_exit(&statep->state_mutex); 2578 return; 2579 } 2580 statep->send_mad_flags |= IBCM_DREP_POST_BUSY; 2581 2582 /* Release statep mutex before posting the MAD */ 2583 mutex_exit(&statep->state_mutex); 2584 2585 IBCM_OUT_HDRP(statep->drep_msg)->TransactionID = 2586 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 2587 2588 ibcm_post_drep_mad(statep); 2589 /* ref cnt decremented in ibcm_post_drep_complete */ 2590 } else { 2591 #ifdef DEBUG 2592 if ((ibcm_test_mode > 0) && 2593 (statep->state != IBCM_STATE_DELETE)) 2594 IBTF_DPRINTF_L2(cmlog, "ibcm_process_dreq_msg: " 2595 "Unexpected dreq for statep 0x%p in state %d", 2596 statep, statep->state); 2597 #endif 2598 IBCM_REF_CNT_DECR(statep); 2599 statep->drep_in_progress = 0; 2600 mutex_exit(&statep->state_mutex); 2601 } 2602 } 2603 2604 /* 2605 * ibcm_handle_cep_dreq_response: 2606 * Processes the response from client handler for an incoming DREQ. 2607 * The statep ref cnt is decremented before returning. 2608 */ 2609 void 2610 ibcm_handle_cep_dreq_response(ibcm_state_data_t *statep, void *priv_data, 2611 ibt_priv_data_len_t priv_data_len) 2612 { 2613 if ((priv_data != NULL) && (priv_data_len > 0)) 2614 bcopy(priv_data, 2615 &(((ibcm_drep_msg_t *) 2616 IBCM_OUT_MSGP(statep->drep_msg))->drep_private_data[0]), 2617 min(priv_data_len, IBT_DREP_PRIV_DATA_SZ)); 2618 2619 ibcm_post_drep_mad(statep); 2620 } 2621 2622 2623 /* 2624 * ibcm_post_dreq_mad: 2625 * Posts a DREQ MAD 2626 * Post DREQ now for TIMEWAIT state and DREQ_RCVD 2627 * 2628 * INPUTS: 2629 * statep - state pointer 2630 * 2631 * RETURN VALUE: 2632 * NONE 2633 */ 2634 void 2635 ibcm_post_dreq_mad(void *vstatep) 2636 { 2637 ibcm_state_data_t *statep = vstatep; 2638 ibcm_dreq_msg_t *dreq_msgp; 2639 2640 ASSERT(statep->dreq_msg != NULL); 2641 2642 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*dreq_msgp)) 2643 2644 /* Fill in the DREQ message */ 2645 dreq_msgp = (ibcm_dreq_msg_t *)IBCM_OUT_MSGP(statep->dreq_msg); 2646 dreq_msgp->dreq_local_comm_id = h2b32(statep->local_comid); 2647 dreq_msgp->dreq_remote_comm_id = h2b32(statep->remote_comid); 2648 dreq_msgp->dreq_remote_qpn_eecn_plus = h2b32(statep->remote_qpn << 8); 2649 2650 IBCM_OUT_HDRP(statep->dreq_msg)->AttributeID = 2651 h2b16(IBCM_INCOMING_DREQ + IBCM_ATTR_BASE_ID); 2652 2653 /* wait until client knows CONN EST event */ 2654 mutex_enter(&statep->state_mutex); 2655 while (statep->cep_in_rts == IBCM_BLOCK) 2656 cv_wait(&statep->block_mad_cv, &statep->state_mutex); 2657 mutex_exit(&statep->state_mutex); 2658 2659 /* Transition QP/EEC state to ERROR state */ 2660 (void) ibcm_cep_to_error_state(statep); 2661 2662 IBCM_OUT_HDRP(statep->dreq_msg)->TransactionID = 2663 h2b64(ibcm_generate_tranid(IBCM_INCOMING_DREQ, statep->local_comid, 2664 0)); 2665 2666 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*dreq_msgp)) 2667 2668 /* post the first DREQ via timeout callback */ 2669 mutex_enter(&statep->state_mutex); 2670 2671 statep->state = IBCM_STATE_DREQ_SENT; 2672 cv_broadcast(&statep->block_mad_cv); 2673 2674 statep->timer_stored_state = statep->state; 2675 /* client cannot specify more than 16 retries */ 2676 statep->timer_value = statep->remote_ack_delay; 2677 if (statep->mode == IBCM_ACTIVE_MODE) { 2678 statep->timer_value += (2 * statep->pkt_life_time); 2679 } 2680 statep->remaining_retry_cnt = statep->max_cm_retries + 1; 2681 statep->timerid = IBCM_TIMEOUT(statep, 0); 2682 mutex_exit(&statep->state_mutex); 2683 } 2684 2685 /* 2686 * ibcm_post_drep_mad: 2687 * Posts a DREP MAD 2688 * Post DREP now for TIMEWAIT state and DREQ_RCVD 2689 * 2690 * INPUTS: 2691 * statep - state pointer 2692 * 2693 * RETURN VALUE: 2694 * NONE 2695 */ 2696 static void 2697 ibcm_post_drep_mad(ibcm_state_data_t *statep) 2698 { 2699 ibcm_drep_msg_t *drep_msgp; 2700 2701 drep_msgp = (ibcm_drep_msg_t *)IBCM_OUT_MSGP(statep->drep_msg); 2702 2703 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*drep_msgp)) 2704 2705 IBTF_DPRINTF_L4(cmlog, "ibcm_post_drep_mad:"); 2706 2707 /* Fill up DREP fields */ 2708 drep_msgp->drep_local_comm_id = h2b32(statep->local_comid); 2709 drep_msgp->drep_remote_comm_id = h2b32(statep->remote_comid); 2710 IBCM_OUT_HDRP(statep->drep_msg)->AttributeID = 2711 h2b16(IBCM_INCOMING_DREP + IBCM_ATTR_BASE_ID); 2712 2713 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*drep_msgp)) 2714 2715 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_DREP); 2716 2717 /* Post the DREP MAD now. */ 2718 ibcm_post_rc_mad(statep, statep->drep_msg, ibcm_post_drep_complete, 2719 statep); 2720 } 2721 2722 /* 2723 * ibcm_process_drep_msg: 2724 * Processes incoming DREP message on active/passive side 2725 * 2726 * INPUTS: 2727 * hcap - HCA entry pointer 2728 * input_madp - CM MAD that is input to this function 2729 * cm_mad_addr - Address information for the MAD 2730 * 2731 * RETURN VALUE: NONE 2732 */ 2733 /* ARGSUSED */ 2734 void 2735 ibcm_process_drep_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 2736 ibcm_mad_addr_t *cm_mad_addr) 2737 { 2738 ibcm_status_t state_lookup_status; 2739 ibcm_drep_msg_t *drep_msgp = 2740 (ibcm_drep_msg_t *)(&input_madp[IBCM_MAD_HDR_SIZE]); 2741 ibcm_state_data_t *statep = NULL; 2742 2743 IBTF_DPRINTF_L4(cmlog, "ibcm_process_drep_msg:"); 2744 2745 /* Lookup for an existing state structure */ 2746 rw_enter(&hcap->hca_state_rwlock, RW_READER); 2747 2748 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_DREP, 2749 b2h32(drep_msgp->drep_remote_comm_id), 0, 0, hcap, &statep); 2750 rw_exit(&hcap->hca_state_rwlock); 2751 2752 if (state_lookup_status != IBCM_LOOKUP_EXISTS) { 2753 IBTF_DPRINTF_L3(cmlog, "ibcm_process_drep_msg: no statep with" 2754 "com id %x", b2h32(drep_msgp->drep_remote_comm_id)); 2755 return; 2756 } 2757 2758 /* if transaction id is not as expected, drop the DREP mad */ 2759 if (IBCM_OUT_HDRP(statep->dreq_msg)->TransactionID != 2760 ((ib_mad_hdr_t *)(input_madp))->TransactionID) { 2761 mutex_enter(&statep->state_mutex); 2762 IBCM_REF_CNT_DECR(statep); 2763 mutex_exit(&statep->state_mutex); 2764 IBTF_DPRINTF_L3(cmlog, "ibcm_process_drep_msg: statep 0x%p " 2765 "DREP with tid expected 0x%llX tid found 0x%llX", statep, 2766 b2h64(IBCM_OUT_HDRP(statep->dreq_msg)->TransactionID), 2767 b2h64(((ib_mad_hdr_t *)(input_madp))->TransactionID)); 2768 return; 2769 } 2770 2771 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_DREP); 2772 2773 mutex_enter(&statep->state_mutex); 2774 2775 if (statep->state == IBCM_STATE_DREQ_SENT) { 2776 timeout_id_t timer_val = statep->timerid; 2777 2778 statep->state = IBCM_STATE_DREP_RCVD; 2779 2780 statep->timerid = 0; 2781 mutex_exit(&statep->state_mutex); 2782 (void) untimeout(timer_val); 2783 2784 if (statep->stale == B_TRUE) 2785 IBTF_DPRINTF_L2(cmlog, "ibcm_process_drep_msg: " 2786 "statep 0x%p Unexpected DREP received for a stale " 2787 "DREQ sent", statep); 2788 2789 mutex_enter(&statep->state_mutex); 2790 /* allow free qp, if close channel with NOCALLBACKS didn't */ 2791 if (statep->close_nocb_state != IBCM_FAIL) { 2792 ibtl_cm_chan_is_closing(statep->channel); 2793 statep->close_nocb_state = IBCM_BLOCK; 2794 } 2795 mutex_exit(&statep->state_mutex); 2796 2797 /* if close_nocb_state is IBCM_FAIL, then cm_handler is NULL */ 2798 if (statep->cm_handler != NULL) { 2799 ibt_cm_event_t event; 2800 ibt_cm_return_args_t ret_args; 2801 2802 bzero(&event, sizeof (event)); 2803 bzero(&ret_args, sizeof (ret_args)); 2804 2805 event.cm_type = IBT_CM_EVENT_CONN_CLOSED; 2806 event.cm_channel = statep->channel; 2807 event.cm_session_id = NULL; 2808 2809 if (statep->stale == B_TRUE) { 2810 event.cm_event.closed = IBT_CM_CLOSED_STALE; 2811 event.cm_priv_data = NULL; 2812 event.cm_priv_data_len = 0; 2813 } else { 2814 event.cm_event.closed = IBT_CM_CLOSED_DREP_RCVD; 2815 event.cm_priv_data = 2816 drep_msgp->drep_private_data; 2817 event.cm_priv_data_len = IBT_DREP_PRIV_DATA_SZ; 2818 } 2819 2820 ibcm_insert_trace(statep, 2821 IBCM_TRACE_CALLED_CONN_CLOSE_EVENT); 2822 2823 (void) statep->cm_handler(statep->state_cm_private, 2824 &event, &ret_args, NULL, 0); 2825 2826 ibcm_insert_trace(statep, 2827 IBCM_TRACE_RET_CONN_CLOSE_EVENT); 2828 } 2829 2830 /* copy the private to close channel, if specified */ 2831 if ((statep->close_ret_priv_data != NULL) && 2832 (statep->close_ret_priv_data_len != NULL) && 2833 (*statep->close_ret_priv_data_len > 0)) { 2834 bcopy(drep_msgp->drep_private_data, 2835 statep->close_ret_priv_data, 2836 min(*statep->close_ret_priv_data_len, 2837 IBT_DREP_PRIV_DATA_SZ)); 2838 } 2839 2840 mutex_enter(&statep->state_mutex); 2841 if (statep->close_ret_status) 2842 *statep->close_ret_status = IBT_CM_CLOSED_DREP_RCVD; 2843 /* signal waiting CV - blocking in ibt_close_channel() */ 2844 statep->close_done = B_TRUE; 2845 2846 /* signal any blocked close channels with no callbacks */ 2847 statep->close_nocb_state = IBCM_FAIL; 2848 2849 cv_broadcast(&statep->block_client_cv); 2850 2851 /* Set the timer wait state timer */ 2852 statep->state = statep->timer_stored_state = 2853 IBCM_STATE_TIMEWAIT; 2854 ibcm_close_done(statep, 0); 2855 2856 statep->remaining_retry_cnt = 0; 2857 /* 2858 * For passive side CM set it to remote_ack_delay 2859 * For active side CM add the pkt_life_time * 2 2860 */ 2861 statep->timer_value = statep->remote_ack_delay; 2862 if (statep->mode == IBCM_ACTIVE_MODE) { 2863 statep->timer_value += (2 * statep->pkt_life_time); 2864 } 2865 2866 /* start TIMEWAIT processing */ 2867 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 2868 } 2869 2870 /* There is no processing required for other states */ 2871 IBCM_REF_CNT_DECR(statep); 2872 mutex_exit(&statep->state_mutex); 2873 } 2874 2875 /* 2876 * Following are the routines used to resend various CM MADs as a response to 2877 * incoming MADs 2878 */ 2879 void 2880 ibcm_resend_rtu_mad(ibcm_state_data_t *statep) 2881 { 2882 ASSERT(MUTEX_HELD(&statep->state_mutex)); 2883 2884 IBTF_DPRINTF_L3(cmlog, "ibcm_resend_rtu_mad statep %p ", statep); 2885 2886 /* don't care, if timer is running or not. Timer may be from LAP */ 2887 2888 if (!(statep->send_mad_flags & IBCM_RTU_POST_BUSY)) { 2889 statep->send_mad_flags |= IBCM_RTU_POST_BUSY; 2890 IBCM_REF_CNT_INCR(statep); /* for non-blocking RTU post */ 2891 mutex_exit(&statep->state_mutex); 2892 2893 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_RTU); 2894 2895 ibcm_post_rc_mad(statep, statep->stored_msg, 2896 ibcm_post_rtu_complete, statep); 2897 mutex_enter(&statep->state_mutex); 2898 } 2899 /* ref cnt is decremented in ibcm_post_rtu_complete */ 2900 } 2901 2902 void 2903 ibcm_resend_rej_mad(ibcm_state_data_t *statep) 2904 { 2905 timeout_id_t timer_val = statep->timerid; 2906 2907 ASSERT(MUTEX_HELD(&statep->state_mutex)); 2908 2909 IBTF_DPRINTF_L3(cmlog, "ibcm_resend_rej_mad statep %p ", statep); 2910 2911 /* It's a too fast of a REQ or REP */ 2912 if (timer_val == 0) 2913 return; 2914 2915 statep->timerid = 0; 2916 if (!(statep->send_mad_flags & IBCM_REJ_POST_BUSY)) { 2917 statep->send_mad_flags |= IBCM_REJ_POST_BUSY; 2918 IBCM_REF_CNT_INCR(statep); /* for nonblocking REJ post */ 2919 mutex_exit(&statep->state_mutex); 2920 (void) untimeout(timer_val); 2921 2922 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_REJ); 2923 if (ibcm_enable_trace & 2) 2924 ibcm_dump_conn_trace(statep); 2925 else 2926 IBTF_DPRINTF_L2(cmlog, "ibcm_resend_rej_mad statep %p " 2927 "OUTGOING_REJ", statep); 2928 2929 ibcm_post_rc_mad(statep, statep->stored_msg, 2930 ibcm_post_rej_complete, statep); 2931 mutex_enter(&statep->state_mutex); 2932 } 2933 /* return, holding the state mutex */ 2934 } 2935 2936 void 2937 ibcm_resend_rep_mad(ibcm_state_data_t *statep) 2938 { 2939 timeout_id_t timer_val = statep->timerid; 2940 2941 ASSERT(MUTEX_HELD(&statep->state_mutex)); 2942 2943 IBTF_DPRINTF_L3(cmlog, "ibcm_resend_rep_mad statep %p ", statep); 2944 2945 /* REP timer that is set by ibcm_post_rep_mad */ 2946 if (timer_val != 0) { 2947 /* Re-start REP timeout */ 2948 statep->remaining_retry_cnt = statep->max_cm_retries; 2949 if (!(statep->send_mad_flags & IBCM_REP_POST_BUSY)) { 2950 statep->send_mad_flags |= IBCM_REP_POST_BUSY; 2951 /* for nonblocking REP post */ 2952 IBCM_REF_CNT_INCR(statep); 2953 mutex_exit(&statep->state_mutex); 2954 2955 ibcm_insert_trace(statep, IBCM_TRACE_OUT_REP_RETRY); 2956 2957 ibcm_post_rc_mad(statep, statep->stored_msg, 2958 ibcm_resend_post_rep_complete, statep); 2959 mutex_enter(&statep->state_mutex); 2960 } 2961 } 2962 2963 /* 2964 * else, timer is not yet set by ibcm_post_rep_mad. This is too fast 2965 * of a REQ being re-transmitted. 2966 */ 2967 } 2968 2969 void 2970 ibcm_resend_mra_mad(ibcm_state_data_t *statep) 2971 { 2972 ASSERT(MUTEX_HELD(&statep->state_mutex)); 2973 2974 IBTF_DPRINTF_L3(cmlog, "ibcm_resend_mra_mad statep %p ", statep); 2975 2976 if (statep->send_mad_flags & IBCM_MRA_POST_BUSY) 2977 return; 2978 2979 statep->send_mad_flags |= IBCM_MRA_POST_BUSY; 2980 2981 statep->mra_time = gethrtime(); 2982 IBCM_REF_CNT_INCR(statep); /* for non-blocking MRA post */ 2983 /* Exit the statep mutex, before sending the MAD */ 2984 mutex_exit(&statep->state_mutex); 2985 2986 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_MRA); 2987 2988 /* Always resend the response MAD to the original reply destination */ 2989 ibcm_post_rc_mad(statep, statep->mra_msg, ibcm_post_mra_complete, 2990 statep); 2991 2992 mutex_enter(&statep->state_mutex); 2993 2994 /* return, holding the state mutex */ 2995 } 2996 2997 2998 /* 2999 * ibcm_post_rej_mad: 3000 * Posts a REJ MAD and starts timer 3001 * 3002 * INPUTS: 3003 * statep - state pointer 3004 * which_msg - which message is being MRAed 3005 * reject_reason - Rejection reason See Section 12.6.7.2 rev1.0a IB Spec 3006 * addl_rej_info - Additional rej Information 3007 * arej_info_len - Additional rej Info length 3008 * 3009 * RETURN VALUE: 3010 * NONE 3011 * Notes 3012 * There is no need to hold the statep->mutex and call ibcm_post_rej_mad 3013 * REJ can be posted either in IBCM_STATE_REQ_RCVD or IBCM_STATE_REP_RCVD 3014 * In these states, there is no timer active, and an incoming REJ shall 3015 * not modify the state or cancel timers 3016 * An incoming REJ doesn't affect statep in state = IBCM_STATE_REJ_SENT/BUSY 3017 */ 3018 void 3019 ibcm_post_rej_mad(ibcm_state_data_t *statep, ibt_cm_reason_t reject_reason, 3020 int which_msg, void *addl_rej_info, ibt_priv_data_len_t arej_info_len) 3021 { 3022 ibcm_rej_msg_t *rej_msg = 3023 (ibcm_rej_msg_t *)IBCM_OUT_MSGP(statep->stored_msg); 3024 3025 /* Message printed if connection gets REJed */ 3026 IBTF_DPRINTF_L3(cmlog, "ibcm_post_rej_mad: " 3027 "statep = %p, reject_reason = %d", statep, reject_reason); 3028 3029 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rej_msg)) 3030 3031 /* Initialize rej_msg fields */ 3032 rej_msg->rej_local_comm_id = h2b32(statep->local_comid); 3033 rej_msg->rej_remote_comm_id = h2b32(statep->remote_comid); 3034 rej_msg->rej_msg_type_plus = (which_msg & 0x3) << 6; 3035 rej_msg->rej_reject_info_len_plus = arej_info_len << 1; 3036 rej_msg->rej_rejection_reason = h2b16((uint16_t)reject_reason); 3037 3038 if ((arej_info_len != 0) && (addl_rej_info != NULL)) 3039 bcopy(addl_rej_info, rej_msg->rej_addl_rej_info, arej_info_len); 3040 3041 IBCM_OUT_HDRP(statep->stored_msg)->AttributeID = 3042 h2b16(IBCM_INCOMING_REJ + IBCM_ATTR_BASE_ID); 3043 3044 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rej_msg)) 3045 3046 mutex_enter(&statep->state_mutex); 3047 3048 /* signal any waiting close channels with blocking or no callbacks */ 3049 statep->close_done = B_TRUE; 3050 statep->close_nocb_state = IBCM_FAIL; 3051 3052 cv_signal(&statep->block_client_cv); 3053 3054 statep->timer_stored_state = statep->state = IBCM_STATE_REJ_SENT; 3055 statep->send_mad_flags |= IBCM_REJ_POST_BUSY; 3056 3057 IBCM_REF_CNT_INCR(statep); /* for non-blocking post */ 3058 mutex_exit(&statep->state_mutex); 3059 3060 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_REJ); 3061 if (ibcm_enable_trace & 2) 3062 ibcm_dump_conn_trace(statep); 3063 else 3064 IBTF_DPRINTF_L2(cmlog, "ibcm_post_rej_mad statep %p " 3065 "OUTGOING_REJ", statep); 3066 3067 ibcm_post_rc_mad(statep, statep->stored_msg, ibcm_post_rej_complete, 3068 statep); 3069 } 3070 3071 3072 /* 3073 * ibcm_build_n_post_rej_mad: 3074 * Builds and posts a REJ MAD for "reject_reason" 3075 * Doesn't set a timer, and doesn't need statep 3076 * 3077 * INPUTS: 3078 * input_madp - Incoming MAD 3079 * remote_comid - Local comid in the message being rejected 3080 * cm_mad_addr - Address information for the MAD to be posted 3081 * which_msg - REJ message type ie., REJ for REQ/REP 3082 * 3083 * RETURN VALUE: 3084 * NONE 3085 */ 3086 static void 3087 ibcm_build_n_post_rej_mad(uint8_t *input_madp, ib_com_id_t remote_comid, 3088 ibcm_mad_addr_t *cm_mad_addr, int which_msg, uint16_t reject_reason) 3089 { 3090 ibcm_rej_msg_t *rej_msg; 3091 ibmf_msg_t *cm_rej_msg; 3092 ibcm_mad_addr_t rej_reply_addr; 3093 3094 IBTF_DPRINTF_L3(cmlog, "ibcm_build_n_post_rej_mad: " 3095 "remote_comid: %x reject_reason %d", remote_comid, reject_reason); 3096 3097 if (ibcm_alloc_out_msg(cm_mad_addr->ibmf_hdl, &cm_rej_msg, 3098 MAD_METHOD_SEND) != IBT_SUCCESS) { 3099 IBTF_DPRINTF_L2(cmlog, "ibcm_build_n_post_rej_mad: " 3100 "ibcm_alloc_out_msg failed"); 3101 return; 3102 } 3103 3104 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rej_msg)) 3105 3106 IBCM_OUT_HDRP(cm_rej_msg)->TransactionID = 3107 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 3108 3109 /* Initialize rej_msg fields */ 3110 rej_msg = (ibcm_rej_msg_t *)IBCM_OUT_MSGP(cm_rej_msg); 3111 rej_msg->rej_local_comm_id = 0; 3112 rej_msg->rej_remote_comm_id = h2b32(remote_comid); 3113 rej_msg->rej_msg_type_plus = (which_msg & 0x3) << 6; 3114 rej_msg->rej_reject_info_len_plus = 0; 3115 rej_msg->rej_rejection_reason = h2b16(reject_reason); 3116 3117 IBCM_OUT_HDRP(cm_rej_msg)->AttributeID = 3118 h2b16(IBCM_INCOMING_REJ + IBCM_ATTR_BASE_ID); 3119 3120 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rej_msg)) 3121 3122 ibcm_build_reply_mad_addr(cm_mad_addr, &rej_reply_addr); 3123 3124 if (rej_reply_addr.cm_qp_entry != NULL) { 3125 (void) ibcm_post_mad(cm_rej_msg, &rej_reply_addr, NULL, NULL); 3126 ibcm_release_qp(rej_reply_addr.cm_qp_entry); 3127 } 3128 3129 (void) ibcm_free_out_msg(cm_mad_addr->ibmf_hdl, &cm_rej_msg); 3130 } 3131 3132 /* posts a REJ for an incoming REQ with unsupported class version */ 3133 3134 static void 3135 ibcm_post_rej_ver_mismatch(uint8_t *input_madp, ibcm_mad_addr_t *cm_mad_addr) 3136 { 3137 ibcm_req_msg_t *req_msgp = 3138 (ibcm_req_msg_t *)&input_madp[IBCM_MAD_HDR_SIZE]; 3139 ibcm_rej_msg_t *rej_msg; 3140 ibmf_msg_t *cm_rej_msg; 3141 ibcm_mad_addr_t rej_reply_addr; 3142 3143 IBTF_DPRINTF_L3(cmlog, "ibcm_post_rej_ver_mismatch: remote comid %x", 3144 b2h32(req_msgp->req_local_comm_id)); 3145 3146 if (ibcm_alloc_out_msg(cm_mad_addr->ibmf_hdl, &cm_rej_msg, 3147 MAD_METHOD_SEND) != IBT_SUCCESS) { 3148 IBTF_DPRINTF_L2(cmlog, "ibcm_post_rej_ver_mismatch: " 3149 "ibcm_alloc_out_msg failed"); 3150 return; 3151 } 3152 3153 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rej_msg)) 3154 3155 IBCM_OUT_HDRP(cm_rej_msg)->TransactionID = 3156 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 3157 3158 /* Initialize rej_msg fields */ 3159 rej_msg = (ibcm_rej_msg_t *)IBCM_OUT_MSGP(cm_rej_msg); 3160 rej_msg->rej_local_comm_id = 0; 3161 rej_msg->rej_remote_comm_id = req_msgp->req_local_comm_id; 3162 rej_msg->rej_msg_type_plus = IBT_CM_FAILURE_REQ << 6; 3163 rej_msg->rej_rejection_reason = h2b16(IBT_CM_CLASS_NO_SUPPORT); 3164 rej_msg->rej_reject_info_len_plus = 1 << 1; 3165 rej_msg->rej_addl_rej_info[0] = IBCM_MAD_CLASS_VERSION; 3166 3167 IBCM_OUT_HDRP(cm_rej_msg)->AttributeID = 3168 h2b16(IBCM_INCOMING_REJ + IBCM_ATTR_BASE_ID); 3169 IBCM_OUT_HDRP(cm_rej_msg)->Status = h2b16(MAD_STATUS_BAD_VERSION); 3170 3171 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rej_msg)) 3172 3173 ibcm_build_reply_mad_addr(cm_mad_addr, &rej_reply_addr); 3174 if (rej_reply_addr.cm_qp_entry != NULL) { 3175 (void) ibcm_post_mad(cm_rej_msg, &rej_reply_addr, NULL, NULL); 3176 ibcm_release_qp(rej_reply_addr.cm_qp_entry); 3177 } 3178 (void) ibcm_free_out_msg(cm_mad_addr->ibmf_hdl, &cm_rej_msg); 3179 } 3180 3181 3182 /* 3183 * ibcm_post_rep_mad: 3184 * Posts a REP MAD and starts timer 3185 * 3186 * INPUTS: 3187 * statep - state pointer 3188 * 3189 * RETURN VALUE: 3190 * NONE 3191 */ 3192 void 3193 ibcm_post_rep_mad(ibcm_state_data_t *statep) 3194 { 3195 ibcm_rep_msg_t *rep_msgp = 3196 (ibcm_rep_msg_t *)IBCM_OUT_MSGP(statep->stored_msg); 3197 ibmf_msg_t *mra_msg = NULL; 3198 boolean_t ret = B_FALSE; 3199 3200 IBTF_DPRINTF_L4(cmlog, "ibcm_post_rep_mad: statep 0x%p", statep); 3201 3202 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rep_msgp)) 3203 3204 /* 3205 * All other REP fields, other that the 2 below, are filled in 3206 * the ibcm_cep_state_req() function. 3207 */ 3208 rep_msgp->rep_local_comm_id = h2b32(statep->local_comid); 3209 rep_msgp->rep_remote_comm_id = h2b32(statep->remote_comid); 3210 IBCM_OUT_HDRP(statep->stored_msg)->AttributeID = 3211 h2b16(IBCM_INCOMING_REP + IBCM_ATTR_BASE_ID); 3212 3213 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rep_msgp)) 3214 3215 /* 3216 * Changing state and attempt to delete the mra msg must be done 3217 * together holding the state_mutex 3218 */ 3219 mutex_enter(&statep->state_mutex); 3220 3221 /* Now, attempt to delete the mra_msg, if there is one allocated */ 3222 if (statep->mra_msg != NULL) { 3223 if (!(statep->send_mad_flags & IBCM_MRA_POST_BUSY)) { 3224 mra_msg = statep->mra_msg; 3225 statep->mra_msg = NULL; 3226 } else statep->delete_mra_msg = B_TRUE; 3227 } 3228 3229 if (statep->abort_flag == IBCM_ABORT_CLIENT) { 3230 statep->state = IBCM_STATE_ABORTED; 3231 mutex_exit(&statep->state_mutex); 3232 ibcm_process_abort(statep); 3233 3234 /* Now post a REJ MAD, rej reason consumer abort */ 3235 ibcm_post_rej_mad(statep, IBT_CM_CONSUMER, IBT_CM_FAILURE_REQ, 3236 NULL, 0); 3237 ret = B_TRUE; 3238 } else if (statep->abort_flag & IBCM_ABORT_REJ) { 3239 3240 statep->state = IBCM_STATE_DELETE; 3241 mutex_exit(&statep->state_mutex); 3242 3243 ibcm_process_abort(statep); 3244 ibcm_delete_state_data(statep); 3245 ret = B_TRUE; 3246 } else { 3247 3248 statep->state = statep->timer_stored_state = 3249 IBCM_STATE_REP_SENT; 3250 statep->remaining_retry_cnt = statep->max_cm_retries; 3251 statep->send_mad_flags |= IBCM_REP_POST_BUSY; 3252 IBCM_REF_CNT_INCR(statep); /* for nonblocking REP Post */ 3253 mutex_exit(&statep->state_mutex); 3254 } 3255 3256 if (mra_msg != NULL) 3257 (void) ibcm_free_out_msg(statep->stored_reply_addr.ibmf_hdl, 3258 &mra_msg); 3259 if (ret == B_TRUE) 3260 return; 3261 3262 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_REP); 3263 3264 ibcm_post_rc_mad(statep, statep->stored_msg, ibcm_post_rep_complete, 3265 statep); 3266 } 3267 3268 3269 /* 3270 * ibcm_post_rtu_mad: 3271 * From active side post RTU MAD 3272 * 3273 * INPUTS: 3274 * statep - state pointer 3275 * 3276 * RETURN VALUE: NONE 3277 * 3278 * NOTE: No timer set after posting RTU 3279 */ 3280 ibcm_status_t 3281 ibcm_post_rtu_mad(ibcm_state_data_t *statep) 3282 { 3283 ibcm_rtu_msg_t *rtu_msg; 3284 ibmf_msg_t *mra_msg = NULL; 3285 boolean_t ret = B_FALSE; 3286 3287 IBTF_DPRINTF_L4(cmlog, "ibcm_post_rtu_mad: statep 0x%p", statep); 3288 3289 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rtu_msg)) 3290 3291 rtu_msg = (ibcm_rtu_msg_t *)IBCM_OUT_MSGP(statep->stored_msg); 3292 3293 rtu_msg->rtu_local_comm_id = h2b32(statep->local_comid); 3294 rtu_msg->rtu_remote_comm_id = h2b32(statep->remote_comid); 3295 IBCM_OUT_HDRP(statep->stored_msg)->AttributeID = 3296 h2b16(IBCM_INCOMING_RTU + IBCM_ATTR_BASE_ID); 3297 3298 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rtu_msg)) 3299 3300 mutex_enter(&statep->state_mutex); 3301 3302 /* Now, attempt to delete the mra_msg, if there is one allocated */ 3303 if (statep->mra_msg != NULL) { 3304 if (!(statep->send_mad_flags & IBCM_MRA_POST_BUSY)) { 3305 mra_msg = statep->mra_msg; 3306 statep->mra_msg = NULL; 3307 } else statep->delete_mra_msg = B_TRUE; 3308 } 3309 3310 if (statep->abort_flag == IBCM_ABORT_CLIENT) { 3311 statep->state = IBCM_STATE_ABORTED; 3312 mutex_exit(&statep->state_mutex); 3313 3314 ibcm_process_abort(statep); 3315 3316 /* Now post a REJ MAD */ 3317 ibcm_post_rej_mad(statep, IBT_CM_CONSUMER, IBT_CM_FAILURE_REP, 3318 NULL, 0); 3319 ret = B_TRUE; 3320 } else if (statep->abort_flag & IBCM_ABORT_REJ) { 3321 statep->state = IBCM_STATE_DELETE; 3322 mutex_exit(&statep->state_mutex); 3323 3324 ibcm_process_abort(statep); 3325 ibcm_delete_state_data(statep); 3326 ret = B_TRUE; 3327 } else { 3328 statep->state = IBCM_STATE_ESTABLISHED; 3329 ibtl_cm_chan_is_open(statep->channel); 3330 statep->send_mad_flags |= IBCM_RTU_POST_BUSY; 3331 IBCM_REF_CNT_INCR(statep); /* for nonblocking RTU post */ 3332 mutex_exit(&statep->state_mutex); 3333 } 3334 3335 if (mra_msg != NULL) 3336 (void) ibcm_free_out_msg(statep->stored_reply_addr.ibmf_hdl, 3337 &mra_msg); 3338 3339 if (ret == B_TRUE) /* Abort case, no RTU posted */ 3340 return (IBCM_FAILURE); 3341 3342 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_RTU); 3343 3344 ibcm_post_rc_mad(statep, statep->stored_msg, ibcm_post_rtu_complete, 3345 statep); 3346 return (IBCM_SUCCESS); 3347 } 3348 3349 3350 /* 3351 * ibcm_process_abort: 3352 * Processes abort, if client requested abort connection attempt 3353 * 3354 * INPUTS: 3355 * statep - pointer to ibcm_state_data_t is passed 3356 * 3357 * RETURN VALUES: None 3358 */ 3359 void 3360 ibcm_process_abort(ibcm_state_data_t *statep) 3361 { 3362 IBTF_DPRINTF_L3(cmlog, "ibcm_process_abort: statep 0x%p", statep); 3363 3364 /* move CEP to error state, before calling client handler */ 3365 (void) ibcm_cep_to_error_state(statep); 3366 3367 /* Now disassociate the link between statep and qp */ 3368 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 3369 3370 /* invoke cm handler, for non-blocking open/close rc channel calls */ 3371 if (statep->cm_handler) { /* cannot be NULL, but still .. */ 3372 ibt_cm_event_t event; 3373 ibt_cm_return_args_t ret_args; 3374 3375 bzero(&event, sizeof (event)); 3376 bzero(&ret_args, sizeof (ret_args)); 3377 3378 if (statep->abort_flag & IBCM_ABORT_REJ) 3379 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_RCV, 3380 IBT_CM_FAILURE_UNKNOWN, IBT_CM_TIMEOUT, NULL, 0); 3381 else { 3382 ibcm_path_cache_purge(); 3383 3384 event.cm_type = IBT_CM_EVENT_CONN_CLOSED; 3385 event.cm_channel = statep->channel; 3386 event.cm_event.closed = IBT_CM_CLOSED_ABORT; 3387 3388 ibcm_insert_trace(statep, 3389 IBCM_TRACE_CALLED_CONN_CLOSE_EVENT); 3390 3391 if (statep->channel) 3392 ibtl_cm_chan_open_is_aborted(statep->channel); 3393 3394 (void) statep->cm_handler(statep->state_cm_private, 3395 &event, &ret_args, NULL, 0); 3396 3397 ibcm_insert_trace(statep, 3398 IBCM_TRACE_RET_CONN_CLOSE_EVENT); 3399 3400 mutex_enter(&statep->state_mutex); 3401 ibcm_open_done(statep); 3402 mutex_exit(&statep->state_mutex); 3403 } 3404 } 3405 3406 /* 3407 * Unblock an ibt_open_rc_channel called in a blocking mode, though 3408 * it is an unlikely scenario 3409 */ 3410 mutex_enter(&statep->state_mutex); 3411 3412 statep->cm_retries++; /* cause connection trace to be printed */ 3413 statep->open_done = B_TRUE; 3414 statep->close_done = B_TRUE; 3415 statep->close_nocb_state = IBCM_FAIL; /* sanity sake */ 3416 3417 if (statep->open_return_data != NULL) { 3418 /* REJ came first, and then client aborted connection */ 3419 if (statep->abort_flag & IBCM_ABORT_REJ) 3420 statep->open_return_data->rc_status = IBT_CM_TIMEOUT; 3421 else statep->open_return_data->rc_status = IBT_CM_ABORT; 3422 } 3423 3424 cv_broadcast(&statep->block_client_cv); 3425 mutex_exit(&statep->state_mutex); 3426 if (ibcm_enable_trace != 0) 3427 ibcm_dump_conn_trace(statep); 3428 } 3429 3430 /* 3431 * ibcm_timeout_cb: 3432 * Called when the timer expires 3433 * 3434 * INPUTS: 3435 * arg - ibcm_state_data_t is passed 3436 * 3437 * RETURN VALUES: NONE 3438 */ 3439 void 3440 ibcm_timeout_cb(void *arg) 3441 { 3442 ibcm_state_data_t *statep = (ibcm_state_data_t *)arg; 3443 3444 mutex_enter(&statep->state_mutex); 3445 3446 /* 3447 * The blocking operations are handled in a separate thread. 3448 * All other non-blocking operations, including ibmf non-blocking 3449 * posts are done from timeout context 3450 */ 3451 3452 if ((statep->timer_stored_state != statep->state) || 3453 ((statep->timer_stored_state == IBCM_STATE_ESTABLISHED) && 3454 (statep->ap_state != statep->timer_stored_ap_state))) { 3455 mutex_exit(&statep->state_mutex); 3456 return; 3457 } 3458 3459 IBTF_DPRINTF_L3(cmlog, "ibcm_timeout_cb: statep 0x%p state %x " 3460 "ap_state %x", statep, statep->state, statep->ap_state); 3461 3462 /* Processing depends upon current state */ 3463 3464 if (statep->state == IBCM_STATE_REJ_SENT) { 3465 statep->state = IBCM_STATE_DELETE; 3466 mutex_exit(&statep->state_mutex); 3467 3468 /* Deallocate the CM state structure */ 3469 ibcm_delete_state_data(statep); 3470 return; 3471 3472 } else if (statep->state == IBCM_STATE_TIMEWAIT) { 3473 statep->state = IBCM_STATE_DELETE; 3474 3475 /* TIME_WAIT timer expired, so cleanup */ 3476 mutex_exit(&statep->state_mutex); 3477 3478 if (statep->channel) 3479 ibtl_cm_chan_is_closed(statep->channel); 3480 3481 if (statep->recycle_arg) { 3482 struct ibcm_taskq_recycle_arg_s *recycle_arg; 3483 3484 recycle_arg = statep->recycle_arg; 3485 3486 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS( 3487 statep->recycle_arg)) 3488 statep->recycle_arg = NULL; 3489 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(statep->recycle_arg)) 3490 3491 /* if possible, do not slow down calling recycle func */ 3492 if (taskq_dispatch(ibcm_taskq, ibcm_process_rc_recycle, 3493 recycle_arg, TQ_NOQUEUE | TQ_NOSLEEP) == 0) { 3494 3495 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS( 3496 statep->recycle_arg)) 3497 statep->recycle_arg = recycle_arg; 3498 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS( 3499 statep->recycle_arg)) 3500 ibcm_add_tlist(statep); 3501 return; 3502 } 3503 } 3504 3505 ibcm_delete_state_data(statep); 3506 return; 3507 } else if (statep->remaining_retry_cnt > 0) { 3508 ibcm_conn_state_t stored_state; 3509 ibcm_ap_state_t stored_ap_state; 3510 3511 statep->remaining_retry_cnt--; 3512 IBTF_DPRINTF_L3(cmlog, "ibcm_timeout_cb: statep 0x%p " 3513 "attr-id= 0x%x, retries remaining = 0x%x", statep, 3514 b2h16(IBCM_OUT_HDRP(statep->stored_msg)->AttributeID), 3515 statep->remaining_retry_cnt); 3516 3517 /* 3518 * REP could be resent, either because of timeout or an 3519 * incoming REQ. Any other MAD below can be resent, because 3520 * of timeout only, hence send_mad_flag manipulation not 3521 * required for those cases. 3522 * If REP is already being retransmitted, then just set the 3523 * timer and return. Else post REP in non-blocking mode 3524 */ 3525 if (statep->timer_stored_state == IBCM_STATE_REP_SENT) { 3526 if (statep->send_mad_flags & IBCM_REP_POST_BUSY) { 3527 statep->timerid = IBCM_TIMEOUT(statep, 3528 statep->timer_value); 3529 mutex_exit(&statep->state_mutex); 3530 ibcm_insert_trace(statep, 3531 IBCM_TRACE_TIMEOUT_REP); 3532 return; 3533 } 3534 3535 /* 3536 * Set REP busy flag, so any incoming REQ's will not 3537 * initiate new REP transmissions 3538 */ 3539 statep->send_mad_flags |= IBCM_REP_POST_BUSY; 3540 3541 /* Since REQ/RTU/REJ on active side use same MAD, synchronize */ 3542 } else if (statep->timer_stored_state == IBCM_STATE_REQ_SENT) { 3543 ASSERT((statep->send_mad_flags & IBCM_REQ_POST_BUSY) 3544 == 0); 3545 statep->send_mad_flags |= IBCM_REQ_POST_BUSY; 3546 } 3547 3548 IBCM_REF_CNT_INCR(statep); /* for non-blocking post */ 3549 stored_state = statep->timer_stored_state; 3550 stored_ap_state = statep->timer_stored_ap_state; 3551 mutex_exit(&statep->state_mutex); 3552 3553 /* Post REQ MAD in non-blocking mode */ 3554 if (stored_state == IBCM_STATE_REQ_SENT) { 3555 ibcm_insert_trace(statep, IBCM_TRACE_OUT_REQ_RETRY); 3556 ibcm_post_rc_mad(statep, statep->stored_msg, 3557 ibcm_post_req_complete, statep); 3558 /* Post REQ MAD in non-blocking mode */ 3559 } else if (stored_state == IBCM_STATE_REP_WAIT) { 3560 ibcm_insert_trace(statep, IBCM_TRACE_OUT_REQ_RETRY); 3561 ibcm_post_rc_mad(statep, statep->stored_msg, 3562 ibcm_post_rep_wait_complete, statep); 3563 /* Post REP MAD in non-blocking mode */ 3564 } else if (stored_state == IBCM_STATE_REP_SENT) { 3565 ibcm_insert_trace(statep, IBCM_TRACE_OUT_REP_RETRY); 3566 ibcm_post_rc_mad(statep, statep->stored_msg, 3567 ibcm_post_rep_complete, statep); 3568 /* Post REP MAD in non-blocking mode */ 3569 } else if (stored_state == IBCM_STATE_MRA_REP_RCVD) { 3570 ibcm_insert_trace(statep, IBCM_TRACE_OUT_REP_RETRY); 3571 mutex_enter(&statep->state_mutex); 3572 statep->mra_time = gethrtime(); 3573 mutex_exit(&statep->state_mutex); 3574 ibcm_post_rc_mad(statep, statep->stored_msg, 3575 ibcm_post_mra_rep_complete, statep); 3576 /* Post DREQ MAD in non-blocking mode */ 3577 } else if (stored_state == IBCM_STATE_DREQ_SENT) { 3578 mutex_enter(&statep->state_mutex); 3579 if (statep->remaining_retry_cnt == 3580 statep->max_cm_retries) 3581 ibcm_insert_trace(statep, 3582 IBCM_TRACE_OUTGOING_DREQ); 3583 else { 3584 ibcm_insert_trace(statep, 3585 IBCM_TRACE_OUT_DREQ_RETRY); 3586 statep->cm_retries++; 3587 ibcm_close_done(statep, 0); 3588 } 3589 mutex_exit(&statep->state_mutex); 3590 ibcm_post_rc_mad(statep, statep->dreq_msg, 3591 ibcm_post_dreq_complete, statep); 3592 /* post LAP MAD in non-blocking mode */ 3593 } else if (stored_ap_state == IBCM_AP_STATE_LAP_SENT) { 3594 ibcm_insert_trace(statep, IBCM_TRACE_OUT_LAP_RETRY); 3595 ibcm_post_rc_mad(statep, statep->lapr_msg, 3596 ibcm_post_lap_complete, statep); 3597 /* post LAP MAD in non-blocking mode */ 3598 } else if (stored_ap_state == IBCM_AP_STATE_MRA_LAP_RCVD) { 3599 ibcm_insert_trace(statep, IBCM_TRACE_OUT_LAP_RETRY); 3600 mutex_enter(&statep->state_mutex); 3601 statep->mra_time = gethrtime(); 3602 mutex_exit(&statep->state_mutex); 3603 ibcm_post_rc_mad(statep, statep->lapr_msg, 3604 ibcm_post_mra_lap_complete, statep); 3605 } 3606 return; 3607 3608 } else if ((statep->state == IBCM_STATE_REQ_SENT) || 3609 (statep->state == IBCM_STATE_REP_SENT) || 3610 (statep->state == IBCM_STATE_MRA_REP_RCVD) || 3611 (statep->state == IBCM_STATE_REP_WAIT)) { 3612 3613 /* 3614 * MAX retries reached, send a REJ to the remote, 3615 * and close the connection 3616 */ 3617 statep->timedout_state = statep->state; 3618 statep->state = IBCM_STATE_TIMED_OUT; 3619 3620 IBTF_DPRINTF_L3(cmlog, "ibcm_timeout_cb: " 3621 "max retries done for statep 0x%p", statep); 3622 statep->cm_retries++; /* cause conn trace to print */ 3623 mutex_exit(&statep->state_mutex); 3624 3625 if ((statep->timedout_state == IBCM_STATE_REP_SENT) || 3626 (statep->timedout_state == IBCM_STATE_MRA_REP_RCVD)) 3627 (void) ibcm_cep_to_error_state(statep); 3628 3629 /* Disassociate statep from QP */ 3630 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 3631 3632 /* 3633 * statep is in REJ SENT state, the only way to get deleted is 3634 * the timeout callback that is set after posting REJ 3635 * The thread processing is required where cm handler is 3636 * specified 3637 */ 3638 3639 if (statep->cm_handler != NULL) { 3640 /* Attach the statep to timeout list */ 3641 ibcm_add_tlist(statep); 3642 } else { 3643 ib_guid_t local_hca_guid; 3644 3645 mutex_enter(&statep->state_mutex); 3646 3647 /* 3648 * statep->open_return_data is set for blocking 3649 * No handler specified, hence signal blocked 3650 * ibt_open_rc_channel from here 3651 */ 3652 if (statep->open_return_data != NULL) { 3653 statep->open_return_data->rc_status = 3654 IBT_CM_TIMEOUT; 3655 statep->open_done = B_TRUE; 3656 cv_broadcast(&statep->block_client_cv); 3657 } 3658 3659 mutex_exit(&statep->state_mutex); 3660 3661 local_hca_guid = h2b64(statep->local_hca_guid); 3662 ibcm_post_rej_mad(statep, IBT_CM_TIMEOUT, 3663 (statep->timedout_state == IBCM_STATE_REP_SENT || 3664 statep->timedout_state == IBCM_STATE_MRA_REP_RCVD) ? 3665 IBT_CM_FAILURE_REP: IBT_CM_FAILURE_REQ, 3666 &local_hca_guid, sizeof (ib_guid_t)); 3667 } 3668 3669 } else if ((statep->ap_state == IBCM_AP_STATE_LAP_SENT) || 3670 (statep->ap_state == IBCM_AP_STATE_MRA_LAP_RCVD)) { 3671 3672 IBTF_DPRINTF_L4(cmlog, "ibcm_timeout_cb: statep 0x%p " 3673 "LAP timed out", statep); 3674 statep->timedout_state = statep->state; 3675 /* 3676 * This state setting ensures that the processing of DREQ is 3677 * sequentialized, once this ap_state is set. If statep is 3678 * attached to timeout list, it cannot be re-attached as long 3679 * as in this state 3680 */ 3681 statep->ap_state = IBCM_AP_STATE_TIMED_OUT; 3682 ibcm_open_done(statep); 3683 3684 if (statep->cm_handler != NULL) { 3685 /* Attach statep to timeout list - thread handling */ 3686 ibcm_add_tlist(statep); 3687 } else if (statep->ap_return_data != NULL) { 3688 /* 3689 * statep->ap_return_data is initialized for blocking in 3690 * ibt_set_alt_path(), signal the waiting CV 3691 */ 3692 statep->ap_return_data->ap_status = IBT_CM_AP_TIMEOUT; 3693 statep->ap_done = B_TRUE; 3694 cv_broadcast(&statep->block_client_cv); 3695 3696 statep->ap_state = IBCM_AP_STATE_IDLE; 3697 /* Wake up threads waiting for LAP/APR to complete */ 3698 cv_broadcast(&statep->block_mad_cv); 3699 } 3700 mutex_exit(&statep->state_mutex); 3701 3702 } else if (statep->state == IBCM_STATE_DREQ_SENT) { 3703 3704 statep->timedout_state = statep->state; 3705 statep->state = IBCM_STATE_TIMED_OUT; 3706 3707 /* 3708 * The logic below is necessary, for a race situation between 3709 * ibt_close_rc_channel with no callbacks option and CM's 3710 * internal stale connection handling on the same connection 3711 */ 3712 if (statep->close_nocb_state != IBCM_FAIL) { 3713 ASSERT(statep->close_nocb_state == IBCM_UNBLOCK); 3714 ibtl_cm_chan_is_closing(statep->channel); 3715 statep->close_nocb_state = IBCM_BLOCK; 3716 } 3717 3718 mutex_exit(&statep->state_mutex); 3719 3720 /* 3721 * If cm handler is specified, then invoke handler for 3722 * the DREQ timeout 3723 */ 3724 if (statep->cm_handler != NULL) { 3725 ibcm_add_tlist(statep); 3726 return; 3727 } 3728 3729 ibcm_process_dreq_timeout(statep); 3730 } else { 3731 3732 #ifdef DEBUG 3733 if (ibcm_test_mode > 0) 3734 IBTF_DPRINTF_L2(cmlog, "ibcm_timeout_cb: " 3735 "Unexpected unhandled timeout for statep 0x%p " 3736 "state %d", statep, statep->state); 3737 #endif 3738 mutex_exit(&statep->state_mutex); 3739 } 3740 } 3741 3742 /* 3743 * Following are set of ibmf send callback routines that are used when posting 3744 * various CM MADs in non-blocking post mode 3745 */ 3746 3747 /*ARGSUSED*/ 3748 void 3749 ibcm_post_req_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 3750 { 3751 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3752 3753 IBTF_DPRINTF_L4(cmlog, "ibcm_post_req_complete statep %p ", statep); 3754 3755 mutex_enter(&statep->state_mutex); 3756 ibcm_flow_dec(statep->post_time, "REQ"); 3757 ibcm_insert_trace(statep, IBCM_TRACE_REQ_POST_COMPLETE); 3758 3759 statep->send_mad_flags &= ~IBCM_REQ_POST_BUSY; 3760 3761 /* signal any waiting threads for REQ MAD to become available */ 3762 cv_signal(&statep->block_mad_cv); 3763 3764 if (statep->state == IBCM_STATE_REQ_SENT) 3765 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3766 3767 IBCM_REF_CNT_DECR(statep); 3768 mutex_exit(&statep->state_mutex); 3769 } 3770 3771 /*ARGSUSED*/ 3772 void 3773 ibcm_post_rep_wait_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3774 void *args) 3775 { 3776 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3777 3778 IBTF_DPRINTF_L4(cmlog, "ibcm_post_rep_wait_complete statep %p", statep); 3779 3780 mutex_enter(&statep->state_mutex); 3781 ibcm_flow_dec(statep->post_time, "REQ_RETRY"); 3782 ibcm_insert_trace(statep, IBCM_TRACE_REQ_POST_COMPLETE); 3783 if (statep->state == IBCM_STATE_REP_WAIT) 3784 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3785 IBCM_REF_CNT_DECR(statep); 3786 mutex_exit(&statep->state_mutex); 3787 } 3788 3789 /*ARGSUSED*/ 3790 void 3791 ibcm_post_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 3792 { 3793 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3794 3795 IBTF_DPRINTF_L4(cmlog, "ibcm_post_rep_complete statep %p", statep); 3796 3797 mutex_enter(&statep->state_mutex); 3798 ibcm_flow_dec(statep->post_time, "REP"); 3799 ibcm_insert_trace(statep, IBCM_TRACE_REP_POST_COMPLETE); 3800 statep->send_mad_flags &= ~IBCM_REP_POST_BUSY; 3801 if (statep->state == IBCM_STATE_REP_SENT) 3802 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3803 IBCM_REF_CNT_DECR(statep); 3804 mutex_exit(&statep->state_mutex); 3805 } 3806 3807 /*ARGSUSED*/ 3808 void 3809 ibcm_resend_post_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3810 void *args) 3811 { 3812 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3813 3814 IBTF_DPRINTF_L4(cmlog, "ibcm_resend_post_rep_complete(%p)", statep); 3815 3816 mutex_enter(&statep->state_mutex); 3817 ibcm_flow_dec(statep->post_time, "REP_RETRY"); 3818 ibcm_insert_trace(statep, IBCM_TRACE_REP_POST_COMPLETE); 3819 statep->send_mad_flags &= ~IBCM_REP_POST_BUSY; 3820 3821 /* No new timeout is set for resending a REP MAD for an incoming REQ */ 3822 IBCM_REF_CNT_DECR(statep); 3823 mutex_exit(&statep->state_mutex); 3824 } 3825 3826 /*ARGSUSED*/ 3827 void 3828 ibcm_post_mra_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3829 void *args) 3830 { 3831 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3832 3833 IBTF_DPRINTF_L4(cmlog, "ibcm_post_mra_rep_complete statep %p", statep); 3834 3835 mutex_enter(&statep->state_mutex); 3836 ibcm_flow_dec(statep->mra_time, "MRA_REP"); 3837 ibcm_insert_trace(statep, IBCM_TRACE_REP_POST_COMPLETE); 3838 if (statep->state == IBCM_STATE_MRA_REP_RCVD) 3839 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3840 IBCM_REF_CNT_DECR(statep); 3841 mutex_exit(&statep->state_mutex); 3842 } 3843 3844 3845 /*ARGSUSED*/ 3846 void 3847 ibcm_post_mra_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3848 void *args) 3849 { 3850 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3851 3852 IBTF_DPRINTF_L4(cmlog, "ibcm_post_mra_complete statep %p", statep); 3853 3854 mutex_enter(&statep->state_mutex); 3855 ibcm_flow_dec(statep->mra_time, "MRA"); 3856 ibcm_insert_trace(statep, IBCM_TRACE_MRA_POST_COMPLETE); 3857 3858 if (statep->delete_mra_msg == B_TRUE) { 3859 ibmf_msg_t *mra_msg; 3860 3861 mra_msg = statep->mra_msg; 3862 statep->mra_msg = NULL; 3863 mutex_exit(&statep->state_mutex); 3864 (void) ibcm_free_out_msg(statep->stored_reply_addr.ibmf_hdl, 3865 &mra_msg); 3866 mutex_enter(&statep->state_mutex); 3867 } 3868 statep->send_mad_flags &= ~IBCM_MRA_POST_BUSY; 3869 IBCM_REF_CNT_DECR(statep); 3870 mutex_exit(&statep->state_mutex); 3871 } 3872 3873 /*ARGSUSED*/ 3874 void 3875 ibcm_post_dreq_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 3876 { 3877 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3878 3879 IBTF_DPRINTF_L4(cmlog, "ibcm_post_dreq_complete statep %p", statep); 3880 3881 mutex_enter(&statep->state_mutex); 3882 ibcm_flow_dec(statep->post_time, "DREQ"); 3883 ibcm_insert_trace(statep, IBCM_TRACE_DREQ_POST_COMPLETE); 3884 if (statep->state == IBCM_STATE_DREQ_SENT) 3885 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3886 ibcm_close_done(statep, 1); 3887 IBCM_REF_CNT_DECR(statep); 3888 mutex_exit(&statep->state_mutex); 3889 } 3890 3891 /*ARGSUSED*/ 3892 void 3893 ibcm_post_lap_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args) 3894 { 3895 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3896 3897 IBTF_DPRINTF_L4(cmlog, "ibcm_post_lap_complete statep %p", statep); 3898 3899 mutex_enter(&statep->state_mutex); 3900 ibcm_flow_dec(statep->post_time, "LAP"); 3901 ibcm_insert_trace(statep, IBCM_TRACE_LAP_POST_COMPLETE); 3902 if (statep->ap_state == IBCM_AP_STATE_LAP_SENT) 3903 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3904 IBCM_REF_CNT_DECR(statep); 3905 mutex_exit(&statep->state_mutex); 3906 } 3907 3908 /*ARGSUSED*/ 3909 void 3910 ibcm_post_mra_lap_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3911 void *args) 3912 { 3913 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3914 3915 IBTF_DPRINTF_L4(cmlog, "ibcm_post_mra_lap_complete statep %p", statep); 3916 3917 mutex_enter(&statep->state_mutex); 3918 ibcm_flow_dec(statep->mra_time, "MRA_LAP"); 3919 ibcm_insert_trace(statep, IBCM_TRACE_LAP_POST_COMPLETE); 3920 if (statep->ap_state == IBCM_AP_STATE_MRA_LAP_RCVD) 3921 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 3922 IBCM_REF_CNT_DECR(statep); 3923 mutex_exit(&statep->state_mutex); 3924 } 3925 3926 /*ARGSUSED*/ 3927 void 3928 ibcm_post_rej_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3929 void *args) 3930 { 3931 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3932 3933 IBTF_DPRINTF_L4(cmlog, "ibcm_post_rej_complete statep %p", statep); 3934 3935 mutex_enter(&statep->state_mutex); 3936 ibcm_flow_dec(statep->post_time, "REJ"); 3937 ibcm_insert_trace(statep, IBCM_TRACE_REJ_POST_COMPLETE); 3938 statep->send_mad_flags &= ~IBCM_REJ_POST_BUSY; 3939 if (statep->state == IBCM_STATE_REJ_SENT) { 3940 statep->remaining_retry_cnt = 0; 3941 3942 /* wait until all possible retransmits of REQ/REP happened */ 3943 statep->timerid = IBCM_TIMEOUT(statep, 3944 statep->timer_value * statep->max_cm_retries); 3945 } 3946 3947 IBCM_REF_CNT_DECR(statep); 3948 mutex_exit(&statep->state_mutex); 3949 } 3950 3951 /*ARGSUSED*/ 3952 void 3953 ibcm_post_rtu_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3954 void *args) 3955 { 3956 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3957 3958 IBTF_DPRINTF_L4(cmlog, "ibcm_post_rtu_complete statep %p", statep); 3959 3960 mutex_enter(&statep->state_mutex); 3961 ibcm_flow_dec(statep->post_time, "RTU"); 3962 ibcm_insert_trace(statep, IBCM_TRACE_RTU_POST_COMPLETE); 3963 statep->send_mad_flags &= ~IBCM_RTU_POST_BUSY; 3964 IBCM_REF_CNT_DECR(statep); 3965 ibcm_open_done(statep); 3966 mutex_exit(&statep->state_mutex); 3967 } 3968 3969 /*ARGSUSED*/ 3970 void 3971 ibcm_post_apr_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3972 void *args) 3973 { 3974 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 3975 3976 IBTF_DPRINTF_L4(cmlog, "ibcm_post_apr_complete statep %p", statep); 3977 3978 mutex_enter(&statep->state_mutex); 3979 ibcm_flow_dec(statep->post_time, "APR"); 3980 ibcm_insert_trace(statep, IBCM_TRACE_APR_POST_COMPLETE); 3981 /* As long as one APR mad in transit, no retransmits are allowed */ 3982 statep->ap_state = IBCM_AP_STATE_IDLE; 3983 3984 /* unblock any DREQ threads and close channels */ 3985 cv_broadcast(&statep->block_mad_cv); 3986 IBCM_REF_CNT_DECR(statep); /* decrement the ref count */ 3987 mutex_exit(&statep->state_mutex); 3988 3989 } 3990 3991 /*ARGSUSED*/ 3992 void 3993 ibcm_post_stored_apr_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 3994 void *args) 3995 { 3996 ibmf_msg_t *ibmf_apr_msg = (ibmf_msg_t *)args; 3997 3998 IBTF_DPRINTF_L4(cmlog, "ibcm_post_stored_apr_complete args %p", args); 3999 4000 ibcm_flow_dec(0, "APR_RESEND"); 4001 (void) ibcm_free_out_msg(ibmf_handle, &ibmf_apr_msg); 4002 } 4003 4004 /*ARGSUSED*/ 4005 void 4006 ibcm_post_drep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 4007 void *args) 4008 { 4009 ibcm_state_data_t *statep = (ibcm_state_data_t *)args; 4010 4011 IBTF_DPRINTF_L4(cmlog, "ibcm_post_drep_complete statep %p", statep); 4012 4013 mutex_enter(&statep->state_mutex); 4014 ibcm_flow_dec(statep->post_time, "DREP"); 4015 ibcm_insert_trace(statep, IBCM_TRACE_DREP_POST_COMPLETE); 4016 statep->send_mad_flags &= ~IBCM_REJ_POST_BUSY; 4017 4018 if (statep->state == IBCM_STATE_DREQ_RCVD) { 4019 4020 ibcm_close_done(statep, 1); 4021 statep->state = IBCM_STATE_TIMEWAIT; 4022 4023 /* 4024 * For passive side CM set it to remote_ack_delay 4025 * For active side CM add the pkt_life_time * 2 4026 */ 4027 statep->timer_value = statep->remote_ack_delay; 4028 if (statep->mode == IBCM_ACTIVE_MODE) 4029 statep->timer_value += (2 * statep->pkt_life_time); 4030 statep->remaining_retry_cnt = 0; 4031 statep->timer_stored_state = statep->state; 4032 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 4033 } 4034 4035 IBCM_REF_CNT_DECR(statep); 4036 mutex_exit(&statep->state_mutex); 4037 } 4038 4039 /*ARGSUSED*/ 4040 void 4041 ibcm_post_sidr_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 4042 void *args) 4043 { 4044 ibcm_ud_state_data_t *ud_statep = (ibcm_ud_state_data_t *)args; 4045 4046 IBTF_DPRINTF_L4(cmlog, "ibcm_post_sidr_rep_complete ud_statep %p", 4047 ud_statep); 4048 4049 ibcm_flow_dec(0, "SIDR_REP"); 4050 mutex_enter(&ud_statep->ud_state_mutex); 4051 ud_statep->ud_send_mad_flags &= ~IBCM_SREP_POST_BUSY; 4052 ud_statep->ud_remaining_retry_cnt = 0; 4053 if (ud_statep->ud_state == IBCM_STATE_SIDR_REP_SENT) 4054 ud_statep->ud_timerid = IBCM_UD_TIMEOUT(ud_statep, 4055 ud_statep->ud_timer_value); 4056 IBCM_UD_REF_CNT_DECR(ud_statep); 4057 mutex_exit(&ud_statep->ud_state_mutex); 4058 4059 } 4060 4061 /*ARGSUSED*/ 4062 void 4063 ibcm_post_sidr_req_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 4064 void *args) 4065 { 4066 ibcm_ud_state_data_t *ud_statep = (ibcm_ud_state_data_t *)args; 4067 4068 IBTF_DPRINTF_L4(cmlog, "ibcm_post_sidr_req_complete ud_statep %p", 4069 ud_statep); 4070 4071 ibcm_flow_dec(0, "SIDR_REQ"); 4072 mutex_enter(&ud_statep->ud_state_mutex); 4073 if (ud_statep->ud_state == IBCM_STATE_SIDR_REQ_SENT) 4074 ud_statep->ud_timerid = IBCM_UD_TIMEOUT(ud_statep, 4075 ud_statep->ud_timer_value); 4076 IBCM_UD_REF_CNT_DECR(ud_statep); 4077 mutex_exit(&ud_statep->ud_state_mutex); 4078 4079 } 4080 4081 /* 4082 * ibcm_process_dreq_timeout: 4083 * Called when the timer expires on DREP 4084 * 4085 * INPUTS: 4086 * arg - ibcm_state_data_t is passed 4087 * 4088 * RETURN VALUES: NONE 4089 */ 4090 void 4091 ibcm_process_dreq_timeout(ibcm_state_data_t *statep) 4092 { 4093 mutex_enter(&statep->state_mutex); 4094 4095 /* Max retries reached, move to the time wait state */ 4096 statep->state = statep->timer_stored_state = 4097 IBCM_STATE_TIMEWAIT; 4098 ibcm_close_done(statep, 0); 4099 4100 /* Set the TIME_WAIT state timer value */ 4101 statep->timer_value = statep->remote_ack_delay; 4102 if (statep->mode == IBCM_ACTIVE_MODE) { 4103 statep->timer_value += (2 * statep->pkt_life_time); 4104 } 4105 4106 statep->timerid = IBCM_TIMEOUT(statep, statep->timer_value); 4107 4108 if (statep->close_ret_status) 4109 if (statep->stale == B_TRUE) 4110 *statep->close_ret_status = IBT_CM_CLOSED_STALE; 4111 else *statep->close_ret_status = IBT_CM_CLOSED_DREQ_TIMEOUT; 4112 4113 /* signal waiting CVs - blocking in ibt_close_channel() */ 4114 statep->close_done = B_TRUE; 4115 if (statep->close_ret_priv_data_len != NULL) 4116 *statep->close_ret_priv_data_len = 0; 4117 4118 /* unblock any close channel with no callbacks option */ 4119 statep->close_nocb_state = IBCM_FAIL; 4120 4121 cv_broadcast(&statep->block_client_cv); 4122 mutex_exit(&statep->state_mutex); 4123 } 4124 4125 /* 4126 * ibcm_add_tlist: 4127 * Adds the given RC statep to timeout list 4128 * 4129 * INPUTS: 4130 * arg - ibcm_state_data_t is passed 4131 * 4132 * RETURN VALUES: NONE 4133 */ 4134 void 4135 ibcm_add_tlist(ibcm_state_data_t *statep) 4136 { 4137 mutex_enter(&ibcm_timeout_list_lock); 4138 4139 statep->timeout_next = NULL; 4140 if (ibcm_timeout_list_hdr == NULL) { 4141 ibcm_timeout_list_hdr = statep; 4142 } else { 4143 ibcm_timeout_list_tail->timeout_next = statep; 4144 } 4145 4146 ibcm_timeout_list_tail = statep; 4147 4148 cv_signal(&ibcm_timeout_list_cv); 4149 4150 mutex_exit(&ibcm_timeout_list_lock); 4151 IBTF_DPRINTF_L3(cmlog, "ibcm_add_tlist: " 4152 "attached state = %p to timeout list", statep); 4153 } 4154 4155 void 4156 ibcm_run_tlist_thread(void) 4157 { 4158 mutex_enter(&ibcm_timeout_list_lock); 4159 cv_signal(&ibcm_timeout_list_cv); 4160 mutex_exit(&ibcm_timeout_list_lock); 4161 } 4162 4163 /* 4164 * ibcm_add_ud_tlist: 4165 * Adds the given UD statep to timeout list 4166 * 4167 * INPUTS: 4168 * arg - ibcm_ud_state_data_t is passed 4169 * 4170 * RETURN VALUES: NONE 4171 */ 4172 void 4173 ibcm_add_ud_tlist(ibcm_ud_state_data_t *ud_statep) 4174 { 4175 mutex_enter(&ibcm_timeout_list_lock); 4176 4177 ud_statep->ud_timeout_next = NULL; 4178 if (ibcm_ud_timeout_list_hdr == NULL) { 4179 ibcm_ud_timeout_list_hdr = ud_statep; 4180 } else { 4181 ibcm_ud_timeout_list_tail->ud_timeout_next = ud_statep; 4182 } 4183 4184 ibcm_ud_timeout_list_tail = ud_statep; 4185 4186 cv_signal(&ibcm_timeout_list_cv); 4187 4188 mutex_exit(&ibcm_timeout_list_lock); 4189 IBTF_DPRINTF_L3(cmlog, "ibcm_add_ud_tlist: " 4190 "attached state = %p to ud timeout list", ud_statep); 4191 } 4192 4193 /* 4194 * ibcm_process_tlist: 4195 * Thread that processes all the RC and UD statep's from 4196 * the appropriate lists 4197 * 4198 * INPUTS: 4199 * NONE 4200 * 4201 * RETURN VALUES: NONE 4202 */ 4203 void 4204 ibcm_process_tlist() 4205 { 4206 ibcm_state_data_t *statep; 4207 ibcm_ud_state_data_t *ud_statep; 4208 callb_cpr_t cprinfo; 4209 4210 IBTF_DPRINTF_L5(cmlog, "ibcm_process_tlist: thread started"); 4211 4212 mutex_enter(&ibcm_timeout_list_lock); 4213 4214 CALLB_CPR_INIT(&cprinfo, &ibcm_timeout_list_lock, callb_generic_cpr, 4215 "ibcm_process_tlist"); 4216 4217 for (;;) { 4218 if (ibcm_timeout_list_flags & IBCM_TIMEOUT_THREAD_EXIT) { 4219 /* The thread needs to exit */ 4220 cv_signal(&ibcm_timeout_thread_done_cv); 4221 break; 4222 } 4223 mutex_exit(&ibcm_timeout_list_lock); 4224 ibcm_check_for_opens(); 4225 ibcm_check_for_async_close(); 4226 mutex_enter(&ibcm_timeout_list_lock); 4227 4228 /* First, handle pending RC statep's, followed by UD's */ 4229 if (ibcm_timeout_list_hdr != NULL) { 4230 statep = ibcm_timeout_list_hdr; 4231 ibcm_timeout_list_hdr = statep->timeout_next; 4232 4233 if (ibcm_timeout_list_hdr == NULL) 4234 ibcm_timeout_list_tail = NULL; 4235 4236 statep->timeout_next = NULL; 4237 4238 mutex_exit(&ibcm_timeout_list_lock); 4239 IBTF_DPRINTF_L3(cmlog, "ibcm_process_tlist: " 4240 "scheduling state = %p", statep); 4241 ibcm_timeout_client_cb(statep); 4242 mutex_enter(&ibcm_timeout_list_lock); 4243 } else if (ibcm_ud_timeout_list_hdr != NULL) { 4244 ud_statep = ibcm_ud_timeout_list_hdr; 4245 ibcm_ud_timeout_list_hdr = ud_statep->ud_timeout_next; 4246 4247 if (ibcm_ud_timeout_list_hdr == NULL) 4248 ibcm_ud_timeout_list_tail = NULL; 4249 4250 ud_statep->ud_timeout_next = NULL; 4251 4252 mutex_exit(&ibcm_timeout_list_lock); 4253 IBTF_DPRINTF_L3(cmlog, "ibcm_process_tlist: " 4254 "ud scheduling state = %p", ud_statep); 4255 ibcm_ud_timeout_client_cb(ud_statep); 4256 mutex_enter(&ibcm_timeout_list_lock); 4257 } else { 4258 CALLB_CPR_SAFE_BEGIN(&cprinfo); 4259 cv_wait(&ibcm_timeout_list_cv, &ibcm_timeout_list_lock); 4260 CALLB_CPR_SAFE_END(&cprinfo, &ibcm_timeout_list_lock); 4261 } 4262 } 4263 4264 #ifndef __lock_lint 4265 CALLB_CPR_EXIT(&cprinfo); /* mutex_exit */ 4266 #endif 4267 } 4268 4269 4270 /* 4271 * ibcm_timeout_client_cb: 4272 * Called from timeout thread processing 4273 * Primary purpose is to call client handler 4274 * 4275 * INPUTS: 4276 * arg - ibcm_state_data_t is passed 4277 * 4278 * RETURN VALUES: NONE 4279 */ 4280 void 4281 ibcm_timeout_client_cb(ibcm_state_data_t *statep) 4282 { 4283 mutex_enter(&statep->state_mutex); 4284 4285 if ((statep->state == IBCM_STATE_DELETE) && 4286 (statep->recycle_arg != NULL)) { 4287 struct ibcm_taskq_recycle_arg_s *recycle_arg; 4288 4289 recycle_arg = statep->recycle_arg; 4290 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(statep->recycle_arg)) 4291 statep->recycle_arg = NULL; 4292 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(statep->recycle_arg)) 4293 mutex_exit(&statep->state_mutex); 4294 (void) ibcm_process_rc_recycle(recycle_arg); 4295 ibcm_delete_state_data(statep); 4296 return; 4297 } 4298 4299 if ((statep->state == IBCM_STATE_DELETE) && 4300 (statep->delete_state_data == B_TRUE)) { 4301 mutex_exit(&statep->state_mutex); 4302 ibcm_dealloc_state_data(statep); 4303 return; 4304 } 4305 4306 /* Else, it must be in TIMEOUT state, do the necessary processing */ 4307 if (statep->state == IBCM_STATE_TIMED_OUT) { 4308 void *data; 4309 uint8_t cf_msg; 4310 ib_guid_t local_hca_guid; 4311 4312 mutex_exit(&statep->state_mutex); 4313 4314 if (statep->timedout_state == IBCM_STATE_DREQ_SENT) { 4315 ibt_cm_event_t event; 4316 ibt_cm_return_args_t ret_args; 4317 4318 bzero(&event, sizeof (event)); 4319 bzero(&ret_args, sizeof (ret_args)); 4320 4321 event.cm_type = IBT_CM_EVENT_CONN_CLOSED; 4322 event.cm_channel = statep->channel; 4323 event.cm_session_id = NULL; 4324 event.cm_priv_data = NULL; 4325 event.cm_priv_data_len = 0; 4326 4327 if (statep->stale == B_TRUE) 4328 event.cm_event.closed = IBT_CM_CLOSED_STALE; 4329 else event.cm_event.closed = IBT_CM_CLOSED_DREQ_TIMEOUT; 4330 4331 /* 4332 * cm handler cannot be non-NULL, as that check is 4333 * already made in ibcm_timeout_cb 4334 */ 4335 ibcm_insert_trace(statep, 4336 IBCM_TRACE_CALLED_CONN_CLOSE_EVENT); 4337 4338 (void) statep->cm_handler(statep->state_cm_private, 4339 &event, &ret_args, NULL, 0); 4340 4341 ibcm_insert_trace(statep, 4342 IBCM_TRACE_RET_CONN_CLOSE_EVENT); 4343 4344 ibcm_process_dreq_timeout(statep); 4345 return; 4346 } 4347 4348 data = ((ibcm_rej_msg_t *) 4349 IBCM_OUT_MSGP(statep->stored_msg))->rej_private_data; 4350 4351 if ((statep->timedout_state == IBCM_STATE_REQ_SENT) || 4352 (statep->timedout_state == IBCM_STATE_REP_WAIT)) { 4353 cf_msg = IBT_CM_FAILURE_REQ; 4354 } else { 4355 ASSERT( 4356 (statep->timedout_state == IBCM_STATE_REP_SENT) || 4357 (statep->timedout_state == 4358 IBCM_STATE_MRA_REP_RCVD)); 4359 cf_msg = IBT_CM_FAILURE_REP; 4360 } 4361 4362 /* 4363 * Invoke the CM handler w/ event IBT_CM_EVENT_TIMEOUT 4364 * This callback happens for only active non blocking or 4365 * passive client 4366 */ 4367 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_TIMEOUT, 4368 cf_msg, IBT_CM_TIMEOUT, data, IBT_REJ_PRIV_DATA_SZ); 4369 4370 /* signal the blocked ibt_open_rc_channel */ 4371 mutex_enter(&statep->state_mutex); 4372 4373 /* 4374 * statep->open_return_data is set for blocking 4375 * signal the blocked ibt_open_rc_channel 4376 */ 4377 if (statep->open_return_data != NULL) { 4378 statep->open_return_data->rc_status = IBT_CM_TIMEOUT; 4379 statep->open_done = B_TRUE; 4380 cv_broadcast(&statep->block_client_cv); 4381 } 4382 4383 mutex_exit(&statep->state_mutex); 4384 4385 local_hca_guid = h2b64(statep->local_hca_guid); 4386 ibcm_post_rej_mad(statep, IBT_CM_TIMEOUT, 4387 IBT_CM_FAILURE_UNKNOWN, &local_hca_guid, 4388 sizeof (ib_guid_t)); 4389 } else if (statep->ap_state == IBCM_AP_STATE_TIMED_OUT) { 4390 4391 mutex_exit(&statep->state_mutex); 4392 4393 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_TIMEOUT, 4394 IBT_CM_FAILURE_LAP, IBT_CM_TIMEOUT, NULL, 0); 4395 4396 /* Now wake up threads waiting for LAP/APR to complete */ 4397 mutex_enter(&statep->state_mutex); 4398 /* 4399 * statep->ap_return_data is initialized for blocking in 4400 * ibt_set_alt_path(), signal the waiting CV 4401 */ 4402 if (statep->ap_return_data != NULL) { 4403 statep->ap_return_data->ap_status = IBT_CM_AP_TIMEOUT; 4404 statep->ap_done = B_TRUE; 4405 cv_broadcast(&statep->block_client_cv); 4406 } 4407 statep->ap_state = IBCM_AP_STATE_IDLE; 4408 cv_broadcast(&statep->block_mad_cv); 4409 mutex_exit(&statep->state_mutex); 4410 } else { 4411 IBTF_DPRINTF_L2(cmlog, "ibcm_timeout_client_cb " 4412 "Unexpected else path statep %p state %d ap_state %d", 4413 statep, statep->state, statep->ap_state); 4414 mutex_exit(&statep->state_mutex); 4415 4416 } 4417 } 4418 4419 /* 4420 * ibcm_ud_timeout_client_cb: 4421 * Called from UD timeout thread processing 4422 * Primary purpose is to call client handler 4423 * 4424 * INPUTS: 4425 * arg - ibcm_ud_state_data_t is passed 4426 * 4427 * RETURN VALUES: NONE 4428 */ 4429 void 4430 ibcm_ud_timeout_client_cb(ibcm_ud_state_data_t *ud_statep) 4431 { 4432 ibt_cm_ud_event_t ud_event; 4433 4434 mutex_enter(&ud_statep->ud_state_mutex); 4435 4436 if ((ud_statep->ud_state == IBCM_STATE_DELETE) && 4437 (ud_statep->ud_delete_state_data == B_TRUE)) { 4438 4439 mutex_exit(&ud_statep->ud_state_mutex); 4440 ibcm_dealloc_ud_state_data(ud_statep); 4441 return; 4442 } else 4443 mutex_exit(&ud_statep->ud_state_mutex); 4444 4445 /* Fill in ibt_cm_ud_event_t */ 4446 ud_event.cm_type = IBT_CM_UD_EVENT_SIDR_REP; 4447 ud_event.cm_session_id = NULL; 4448 ud_event.cm_event.sidr_rep.srep_status = IBT_CM_SREP_TIMEOUT; 4449 4450 (void) ud_statep->ud_cm_handler(ud_statep->ud_state_cm_private, 4451 &ud_event, NULL, NULL, 0); 4452 4453 /* Delete UD state data now, finally done with it */ 4454 ibcm_delete_ud_state_data(ud_statep); 4455 } 4456 4457 4458 /* 4459 * ibcm_process_sidr_req_msg: 4460 * This call processes an incoming SIDR REQ 4461 * 4462 * INPUTS: 4463 * hcap - HCA entry pointer 4464 * input_madp - Incoming CM SIDR REQ MAD 4465 * cm_mad_addr - Address information for the MAD to be posted 4466 * 4467 * RETURN VALUE: 4468 * NONE 4469 */ 4470 void 4471 ibcm_process_sidr_req_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 4472 ibcm_mad_addr_t *cm_mad_addr) 4473 { 4474 ib_gid_t gid; 4475 ib_lid_t lid; 4476 uint32_t req_id; 4477 ibcm_status_t state_lookup_status; 4478 ibcm_status_t cm_status; 4479 ibt_sidr_status_t sidr_status; 4480 ibcm_svc_info_t *svc_infop; 4481 ibcm_svc_bind_t *svc_bindp; 4482 ibcm_svc_bind_t *tmp_bindp; 4483 ibcm_sidr_req_msg_t *sidr_reqp = (ibcm_sidr_req_msg_t *) 4484 (&input_madp[IBCM_MAD_HDR_SIZE]); 4485 ibcm_ud_state_data_t *ud_statep = NULL; 4486 ibcm_sidr_srch_t srch_sidr; 4487 ib_pkey_t pkey; 4488 uint8_t port_num; 4489 ib_guid_t hca_guid; 4490 4491 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_req_msg:"); 4492 4493 hca_guid = hcap->hca_guid; 4494 port_num = cm_mad_addr->port_num; 4495 4496 /* Figure out LID, GID, RequestId for svc_id lookup */ 4497 lid = cm_mad_addr->rcvd_addr.ia_remote_lid; 4498 req_id = b2h32(sidr_reqp->sidr_req_request_id); 4499 pkey = b2h16(sidr_reqp->sidr_req_pkey); 4500 if (cm_mad_addr->grh_exists == B_TRUE) 4501 gid = cm_mad_addr->grh_hdr.ig_sender_gid; 4502 else 4503 gid.gid_prefix = gid.gid_guid = 0; 4504 4505 /* 4506 * Lookup for an existing state structure 4507 * - if lookup fails it creates a new ud_state struct 4508 * No need to hold a lock across the call to ibcm_find_sidr_entry() as 4509 * the list lock is held in that function to find the matching entry. 4510 */ 4511 4512 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(srch_sidr)) 4513 4514 srch_sidr.srch_lid = lid; 4515 srch_sidr.srch_gid = gid; 4516 srch_sidr.srch_grh_exists = cm_mad_addr->grh_exists; 4517 srch_sidr.srch_req_id = req_id; 4518 srch_sidr.srch_mode = IBCM_PASSIVE_MODE; 4519 4520 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(srch_sidr)) 4521 4522 rw_enter(&hcap->hca_sidr_list_lock, RW_WRITER); 4523 state_lookup_status = ibcm_find_sidr_entry(&srch_sidr, hcap, &ud_statep, 4524 IBCM_FLAG_LOOKUP_AND_ADD); 4525 rw_exit(&hcap->hca_sidr_list_lock); 4526 4527 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_req_msg: ud_statep 0x%p " 4528 "lookup status %x", ud_statep, state_lookup_status); 4529 4530 if (state_lookup_status == IBCM_LOOKUP_NEW) { 4531 4532 /* Increment hca's resource count */ 4533 ibcm_inc_hca_res_cnt(hcap); 4534 4535 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ud_statep)) 4536 4537 /* 4538 * Allocate CM MAD for a response 4539 * This MAD is deallocated on state structure delete 4540 * and re-used for all outgoing MADs for this connection. 4541 * If MAD allocation fails, delete the ud statep 4542 */ 4543 if (ibcm_alloc_out_msg(cm_mad_addr->ibmf_hdl, 4544 &ud_statep->ud_stored_msg, MAD_METHOD_SEND) != 4545 IBT_SUCCESS) { 4546 mutex_enter(&ud_statep->ud_state_mutex); 4547 IBCM_UD_REF_CNT_DECR(ud_statep); 4548 mutex_exit(&ud_statep->ud_state_mutex); 4549 ibcm_delete_ud_state_data(ud_statep); 4550 return; 4551 } 4552 4553 /* Lookup for service */ 4554 ud_statep->ud_svc_id = b2h64(sidr_reqp->sidr_req_service_id); 4555 ud_statep->ud_state = IBCM_STATE_SIDR_REQ_RCVD; 4556 ud_statep->ud_clnt_proceed = IBCM_BLOCK; 4557 4558 mutex_enter(&ibcm_svc_info_lock); 4559 4560 svc_infop = ibcm_find_svc_entry(ud_statep->ud_svc_id); 4561 4562 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_req_msg: " 4563 " ud_statep 0x%p svc_info %p", ud_statep, svc_infop); 4564 4565 /* 4566 * No need to hold the ud state mutex, as no other thread 4567 * modifies ud statep in IBCM_STATE_SIDR_REQ_RCVD state 4568 */ 4569 4570 if (svc_infop != NULL) { 4571 /* find the "bind" entry that enables this port */ 4572 4573 svc_bindp = NULL; 4574 tmp_bindp = svc_infop->svc_bind_list; 4575 while (tmp_bindp) { 4576 if (tmp_bindp->sbind_hcaguid == hca_guid && 4577 tmp_bindp->sbind_port == port_num) { 4578 if (gid.gid_guid == 4579 tmp_bindp->sbind_gid.gid_guid && 4580 gid.gid_prefix == 4581 tmp_bindp->sbind_gid.gid_prefix) { 4582 /* a really good match */ 4583 svc_bindp = tmp_bindp; 4584 if (pkey == 4585 tmp_bindp->sbind_pkey) 4586 /* absolute best */ 4587 break; 4588 } else if (svc_bindp == NULL) { 4589 /* port match => a good match */ 4590 svc_bindp = tmp_bindp; 4591 } 4592 } 4593 tmp_bindp = tmp_bindp->sbind_link; 4594 } 4595 if (svc_bindp == NULL) { 4596 svc_infop = NULL; 4597 } 4598 } 4599 4600 IBCM_OUT_HDRP(ud_statep->ud_stored_msg)->TransactionID = 4601 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 4602 4603 ibcm_build_reply_mad_addr(cm_mad_addr, 4604 &ud_statep->ud_stored_reply_addr); 4605 4606 if (ud_statep->ud_stored_reply_addr.cm_qp_entry == NULL) { 4607 4608 mutex_exit(&ibcm_svc_info_lock); 4609 4610 /* Not much choice. CM MADs cannot go on QP1 */ 4611 mutex_enter(&ud_statep->ud_state_mutex); 4612 IBCM_UD_REF_CNT_DECR(ud_statep); 4613 ud_statep->ud_state = IBCM_STATE_DELETE; 4614 mutex_exit(&ud_statep->ud_state_mutex); 4615 4616 ibcm_delete_ud_state_data(ud_statep); 4617 return; 4618 } 4619 4620 if (svc_infop == NULL || svc_infop->svc_ud_handler == NULL) { 4621 /* 4622 * Don't have a record of Service ID in CM's 4623 * internal list registered at this gid/lid. 4624 * So, send out Service ID not supported SIDR REP msg 4625 */ 4626 sidr_status = IBT_CM_SREP_SID_INVALID; 4627 } else { 4628 ud_statep->ud_cm_handler = svc_infop->svc_ud_handler; 4629 ud_statep->ud_state_cm_private = 4630 svc_bindp->sbind_cm_private; 4631 IBCM_SVC_INCR(svc_infop); 4632 mutex_exit(&ibcm_svc_info_lock); 4633 4634 /* Call Client's UD handler */ 4635 cm_status = ibcm_sidr_req_ud_handler(ud_statep, 4636 sidr_reqp, cm_mad_addr, &sidr_status); 4637 4638 mutex_enter(&ibcm_svc_info_lock); 4639 IBCM_SVC_DECR(svc_infop); 4640 } 4641 4642 mutex_exit(&ibcm_svc_info_lock); 4643 4644 if (cm_status == IBCM_DEFER) { 4645 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_req_msg: " 4646 "ud_statep 0x%p client returned DEFER response", 4647 ud_statep); 4648 return; 4649 } 4650 4651 ibcm_post_sidr_rep_mad(ud_statep, sidr_status); 4652 4653 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*ud_statep)) 4654 4655 mutex_enter(&ud_statep->ud_state_mutex); 4656 IBCM_UD_REF_CNT_DECR(ud_statep); 4657 mutex_exit(&ud_statep->ud_state_mutex); 4658 } else { 4659 ASSERT(state_lookup_status == IBCM_LOOKUP_EXISTS); 4660 4661 mutex_enter(&ud_statep->ud_state_mutex); 4662 4663 if (ud_statep->ud_state == IBCM_STATE_SIDR_REP_SENT) 4664 ibcm_resend_srep_mad(ud_statep); 4665 4666 IBCM_UD_REF_CNT_DECR(ud_statep); 4667 mutex_exit(&ud_statep->ud_state_mutex); 4668 } 4669 } 4670 4671 4672 /* 4673 * ibcm_process_sidr_rep_msg: 4674 * This call processes an incoming SIDR REP 4675 * 4676 * INPUTS: 4677 * hcap - HCA entry pointer 4678 * input_madp - incoming CM SIDR REP MAD 4679 * cm_mad_addr - Address information for the MAD to be posted 4680 * 4681 * RETURN VALUE: 4682 * NONE 4683 */ 4684 void 4685 ibcm_process_sidr_rep_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 4686 ibcm_mad_addr_t *cm_mad_addr) 4687 { 4688 ib_lid_t lid; 4689 ib_gid_t gid; 4690 ibcm_status_t status; 4691 ib_svc_id_t tmp_svc_id; 4692 ibcm_sidr_rep_msg_t *sidr_repp = (ibcm_sidr_rep_msg_t *) 4693 (&input_madp[IBCM_MAD_HDR_SIZE]); 4694 ibcm_ud_state_data_t *ud_statep = NULL; 4695 ibcm_sidr_srch_t srch_sidr; 4696 4697 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_rep_msg:"); 4698 4699 lid = cm_mad_addr->rcvd_addr.ia_local_lid; 4700 if (cm_mad_addr->grh_exists == B_TRUE) 4701 gid = cm_mad_addr->grh_hdr.ig_recver_gid; 4702 else 4703 gid.gid_prefix = gid.gid_guid = 0; 4704 4705 IBTF_DPRINTF_L3(cmlog, "ibcm_process_sidr_rep_msg: QPN rcvd = %x", 4706 h2b32(sidr_repp->sidr_rep_qpn_plus) >> 8); 4707 4708 /* 4709 * Lookup for an existing state structure. 4710 * No need to hold a lock as ibcm_find_sidr_entry() holds the 4711 * list lock to find the matching entry. 4712 */ 4713 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_rep: lid=%x, (%llX, %llX), " 4714 "grh = %x, id = %x", lid, gid.gid_prefix, gid.gid_guid, 4715 cm_mad_addr->grh_exists, sidr_repp->sidr_rep_request_id); 4716 4717 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(srch_sidr)) 4718 4719 srch_sidr.srch_lid = lid; 4720 srch_sidr.srch_gid = gid; 4721 srch_sidr.srch_grh_exists = cm_mad_addr->grh_exists; 4722 srch_sidr.srch_req_id = b2h32(sidr_repp->sidr_rep_request_id); 4723 srch_sidr.srch_mode = IBCM_ACTIVE_MODE; 4724 4725 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(srch_sidr)) 4726 4727 rw_enter(&hcap->hca_sidr_list_lock, RW_READER); 4728 status = ibcm_find_sidr_entry(&srch_sidr, hcap, &ud_statep, 4729 IBCM_FLAG_LOOKUP); 4730 rw_exit(&hcap->hca_sidr_list_lock); 4731 4732 IBTF_DPRINTF_L4(cmlog, "ibcm_process_sidr_rep_msg: ud_statep 0x%p " 4733 "find sidr entry status = %x", ud_statep, status); 4734 4735 if (status != IBCM_LOOKUP_EXISTS) { 4736 IBTF_DPRINTF_L2(cmlog, "ibcm_process_sidr_rep_msg: " 4737 "No matching ud_statep for SIDR REP"); 4738 return; 4739 } 4740 4741 if (IBCM_OUT_HDRP(ud_statep->ud_stored_msg)->TransactionID != 4742 ((ib_mad_hdr_t *)(input_madp))->TransactionID) { 4743 mutex_enter(&ud_statep->ud_state_mutex); 4744 IBCM_UD_REF_CNT_DECR(ud_statep); 4745 mutex_exit(&ud_statep->ud_state_mutex); 4746 IBTF_DPRINTF_L2(cmlog, "ibcm_process_sidr_rep_msg: " 4747 "ud_statep 0x%p. A SIDR REP MAD with tid expected 0x%llX " 4748 "tid found 0x%llX req_id %x arrived", ud_statep, 4749 b2h64( 4750 IBCM_OUT_HDRP(ud_statep->ud_stored_msg)->TransactionID), 4751 b2h64(((ib_mad_hdr_t *)(input_madp))->TransactionID), 4752 b2h32(sidr_repp->sidr_rep_request_id)); 4753 return; 4754 } 4755 4756 mutex_enter(&ud_statep->ud_state_mutex); 4757 4758 /* 4759 * We need to check service ID received against the one sent? 4760 * If they don't match just return. 4761 */ 4762 bcopy(sidr_repp->sidr_rep_service_id, &tmp_svc_id, sizeof (tmp_svc_id)); 4763 bcopy(&tmp_svc_id, sidr_repp->sidr_rep_service_id, sizeof (tmp_svc_id)); 4764 if (ud_statep->ud_svc_id != b2h64(tmp_svc_id)) { 4765 IBTF_DPRINTF_L2(cmlog, "ibcm_process_sidr_rep_msg: " 4766 "ud_statep -0x%p svcids do not match %llx %llx", 4767 ud_statep, ud_statep->ud_svc_id, b2h64(tmp_svc_id)); 4768 4769 IBCM_UD_REF_CNT_DECR(ud_statep); 4770 mutex_exit(&ud_statep->ud_state_mutex); 4771 return; 4772 } 4773 4774 if (ud_statep->ud_state == IBCM_STATE_SIDR_REQ_SENT) { 4775 timeout_id_t timer_val = ud_statep->ud_timerid; 4776 4777 ud_statep->ud_state = IBCM_STATE_SIDR_REP_RCVD; 4778 ud_statep->ud_timerid = 0; 4779 mutex_exit(&ud_statep->ud_state_mutex); 4780 4781 /* Cancel timer set after sending SIDR REQ */ 4782 (void) untimeout(timer_val); 4783 4784 /* 4785 * Call Client's UD handler 4786 */ 4787 ibcm_sidr_rep_ud_handler(ud_statep, sidr_repp); 4788 4789 mutex_enter(&ud_statep->ud_state_mutex); 4790 4791 ud_statep->ud_state = IBCM_STATE_DELETE; 4792 4793 /* 4794 * ud_statep->ud_return_data is initialized for blocking in 4795 * ibt_ud_get_dqpn(). Initialize its fields and 4796 * signal the blocking call in ibt_ud_get_dqpn(). 4797 */ 4798 if (ud_statep->ud_return_data != NULL) { 4799 /* get rep_qpn and rep_status */ 4800 ibt_priv_data_len_t len; 4801 4802 /* Copy the SIDR private data */ 4803 len = min(ud_statep->ud_return_data->ud_priv_data_len, 4804 IBT_SIDR_REP_PRIV_DATA_SZ); 4805 4806 if ((ud_statep->ud_return_data->ud_priv_data != NULL) && 4807 (len > 0)) { 4808 bcopy(sidr_repp->sidr_rep_private_data, 4809 ud_statep->ud_return_data->ud_priv_data, 4810 len); 4811 } 4812 4813 /* get status first */ 4814 ud_statep->ud_return_data->ud_status = 4815 sidr_repp->sidr_rep_rep_status; 4816 4817 if (ud_statep->ud_return_data->ud_status == 4818 IBT_CM_SREP_QPN_VALID) { 4819 ud_statep->ud_return_data->ud_dqpn = 4820 h2b32(sidr_repp->sidr_rep_qpn_plus) >> 8; 4821 ud_statep->ud_return_data->ud_qkey = 4822 b2h32(sidr_repp->sidr_rep_qkey); 4823 } 4824 4825 ud_statep->ud_blocking_done = B_TRUE; 4826 cv_broadcast(&ud_statep->ud_block_client_cv); 4827 } 4828 4829 IBCM_UD_REF_CNT_DECR(ud_statep); 4830 mutex_exit(&ud_statep->ud_state_mutex); 4831 4832 /* Delete UD state data now, finally done with it */ 4833 ibcm_delete_ud_state_data(ud_statep); 4834 } else { 4835 IBTF_DPRINTF_L3(cmlog, "ibcm_process_sidr_rep_msg: " 4836 "ud state is = 0x%x", ud_statep->ud_state); 4837 IBCM_UD_REF_CNT_DECR(ud_statep); 4838 mutex_exit(&ud_statep->ud_state_mutex); 4839 } 4840 } 4841 4842 4843 /* 4844 * ibcm_post_sidr_rep_mad: 4845 * This call posts a SIDR REP MAD 4846 * 4847 * INPUTS: 4848 * ud_statep - pointer to ibcm_ud_state_data_t 4849 * status - Status information 4850 * 4851 * RETURN VALUE: NONE 4852 */ 4853 void 4854 ibcm_post_sidr_rep_mad(ibcm_ud_state_data_t *ud_statep, 4855 ibt_sidr_status_t status) 4856 { 4857 ib_svc_id_t tmp_svc_id; 4858 ibcm_sidr_rep_msg_t *sidr_repp = 4859 (ibcm_sidr_rep_msg_t *)IBCM_OUT_MSGP(ud_statep->ud_stored_msg); 4860 clock_t timer_value; 4861 4862 IBTF_DPRINTF_L5(cmlog, "ibcm_post_sidr_rep_mad:"); 4863 4864 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sidr_repp)) 4865 4866 IBCM_OUT_HDRP(ud_statep->ud_stored_msg)->AttributeID = 4867 h2b16(IBCM_INCOMING_SIDR_REP + IBCM_ATTR_BASE_ID); 4868 4869 /* 4870 * Initialize SIDR REP message. (Other fields were 4871 * already filled up in ibcm_sidr_req_ud_handler() 4872 */ 4873 sidr_repp->sidr_rep_request_id = h2b32(ud_statep->ud_req_id); 4874 tmp_svc_id = h2b64(ud_statep->ud_svc_id); 4875 bcopy(&tmp_svc_id, sidr_repp->sidr_rep_service_id, sizeof (tmp_svc_id)); 4876 4877 sidr_repp->sidr_rep_rep_status = (uint8_t)status; 4878 4879 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*sidr_repp)) 4880 4881 /* post the SIDR REP MAD */ 4882 ibcm_post_ud_mad(ud_statep, ud_statep->ud_stored_msg, NULL, NULL); 4883 4884 timer_value = ibt_ib2usec(ibcm_max_sidr_rep_store_time); 4885 /* 4886 * Hold the statep lock, as a SIDR REQ may come in after setting state 4887 * but before timeout. This can result in a dangling timeout ie., 4888 * the incoming SIDR REQ would be unable to cancel this timeout 4889 */ 4890 mutex_enter(&ud_statep->ud_state_mutex); 4891 4892 ud_statep->ud_remaining_retry_cnt = 1; 4893 ud_statep->ud_timer_value = timer_value; 4894 4895 ud_statep->ud_timer_stored_state = ud_statep->ud_state = 4896 IBCM_STATE_SIDR_REP_SENT; 4897 ud_statep->ud_timerid = IBCM_UD_TIMEOUT(ud_statep, 4898 ud_statep->ud_timer_value); 4899 4900 mutex_exit(&ud_statep->ud_state_mutex); 4901 } 4902 4903 4904 /* 4905 * ibcm_sidr_timeout_cb: 4906 * Called when the timer expires on SIDR request 4907 * 4908 * INPUTS: 4909 * arg - ibcm_ud_state_data_t with all the info 4910 * 4911 * RETURN VALUE: NONE 4912 */ 4913 void 4914 ibcm_sidr_timeout_cb(void *arg) 4915 { 4916 ibcm_ud_state_data_t *ud_statep = (ibcm_ud_state_data_t *)arg; 4917 4918 mutex_enter(&ud_statep->ud_state_mutex); 4919 ud_statep->ud_timerid = 0; 4920 4921 IBTF_DPRINTF_L3(cmlog, "ibcm_sidr_timeout_cb: ud_statep 0x%p " 4922 "state = 0x%x", ud_statep, ud_statep->ud_state); 4923 4924 /* Processing depends upon current state */ 4925 if (ud_statep->ud_state == IBCM_STATE_SIDR_REP_SENT) { 4926 ud_statep->ud_state = IBCM_STATE_DELETE; 4927 4928 mutex_exit(&ud_statep->ud_state_mutex); 4929 4930 /* Deallocate the CM state structure */ 4931 ibcm_delete_ud_state_data(ud_statep); 4932 4933 } else if ((ud_statep->ud_remaining_retry_cnt > 0) && 4934 (ud_statep->ud_state == IBCM_STATE_SIDR_REQ_SENT)) { 4935 4936 ud_statep->ud_remaining_retry_cnt--; 4937 IBCM_UD_REF_CNT_INCR(ud_statep); /* for non-blocking post */ 4938 IBTF_DPRINTF_L4(cmlog, "ibcm_sidr_timeout_cb: " 4939 "ud_statep = %p, retries remaining = 0x%x", 4940 ud_statep, ud_statep->ud_remaining_retry_cnt); 4941 mutex_exit(&ud_statep->ud_state_mutex); 4942 4943 /* Post mad in non blocking mode */ 4944 ibcm_post_ud_mad(ud_statep, ud_statep->ud_stored_msg, 4945 ibcm_post_sidr_req_complete, ud_statep); 4946 4947 } else if (ud_statep->ud_state == IBCM_STATE_SIDR_REQ_SENT) { 4948 4949 /* This is on SIDR REQ Sender side processing */ 4950 4951 /* set state to IBCM_STATE_DELETE */ 4952 ud_statep->ud_state = IBCM_STATE_DELETE; 4953 4954 /* 4955 * retry counter expired, clean up 4956 * 4957 * Invoke the client/server handler with a "status" of 4958 * IBT_CM_SREP_TIMEOUT. 4959 */ 4960 4961 if (ud_statep->ud_return_data != NULL) { 4962 ud_statep->ud_return_data->ud_status = 4963 IBT_CM_SREP_TIMEOUT; 4964 ud_statep->ud_blocking_done = B_TRUE; 4965 cv_broadcast(&ud_statep->ud_block_client_cv); 4966 } 4967 4968 mutex_exit(&ud_statep->ud_state_mutex); 4969 4970 /* Invoke the client handler in a separate thread */ 4971 if (ud_statep->ud_cm_handler != NULL) { 4972 /* UD state data is delete in timeout thread */ 4973 ibcm_add_ud_tlist(ud_statep); 4974 return; 4975 } 4976 4977 /* Delete UD state data now, finally done with it */ 4978 ibcm_delete_ud_state_data(ud_statep); 4979 } else { 4980 4981 #ifdef DEBUG 4982 if (ibcm_test_mode > 0) 4983 IBTF_DPRINTF_L2(cmlog, "ibcm_sidr_timeout_cb: " 4984 "Nop timeout for ud_statep 0x%p in ud_state %d", 4985 ud_statep, ud_statep->ud_state); 4986 #endif 4987 mutex_exit(&ud_statep->ud_state_mutex); 4988 } 4989 } 4990 4991 4992 /* 4993 * ibcm_resend_srep_mad: 4994 * Called on a duplicate incoming SIDR REQ on server side 4995 * Posts the stored MAD from ud state structure using ud_stored_reply_addr 4996 * Cancels any running timer, and then re-starts the timer 4997 * This routine must be called with state structure table lock held 4998 * 4999 * INPUTS: 5000 * ud_statep - ibcm_ud_state_data_t 5001 * 5002 * RETURN VALUE: NONE 5003 */ 5004 void 5005 ibcm_resend_srep_mad(ibcm_ud_state_data_t *ud_statep) 5006 { 5007 timeout_id_t timer_val; 5008 5009 ASSERT(MUTEX_HELD(&ud_statep->ud_state_mutex)); 5010 5011 IBTF_DPRINTF_L3(cmlog, "ibcm_resend_srep_mad: ud_statep 0x%p", 5012 ud_statep); 5013 5014 if (ud_statep->ud_send_mad_flags & IBCM_SREP_POST_BUSY) 5015 return; 5016 5017 ud_statep->ud_send_mad_flags |= IBCM_SREP_POST_BUSY; 5018 5019 /* for nonblocking SIDR REP Post */ 5020 IBCM_UD_REF_CNT_INCR(ud_statep); 5021 5022 /* Cancel currently running timer */ 5023 timer_val = ud_statep->ud_timerid; 5024 5025 if (ud_statep->ud_timerid != 0) { 5026 ud_statep->ud_timerid = 0; 5027 mutex_exit(&ud_statep->ud_state_mutex); 5028 (void) untimeout(timer_val); 5029 } else { 5030 mutex_exit(&ud_statep->ud_state_mutex); 5031 } 5032 5033 /* Always resend the response MAD to the original reply destination */ 5034 ibcm_post_ud_mad(ud_statep, ud_statep->ud_stored_msg, 5035 ibcm_post_sidr_rep_complete, ud_statep); 5036 5037 mutex_enter(&ud_statep->ud_state_mutex); 5038 } 5039 5040 5041 /* 5042 * ibcm_build_reply_mad_addr: 5043 * Forms the reply MAD address based on "incoming mad addr" that is 5044 * supplied as an arg. 5045 * 5046 * Swaps the source and destination gids in ib_grh_t 5047 * 5048 * INPUTS: 5049 * inp_mad_addr: Address information in the incoming MAD 5050 * out_mad_addr: Derived address for the reply MAD 5051 * The reply MAD address is derived based 5052 * address information of incoming CM MAD 5053 * RETURN VALUE: NONE 5054 */ 5055 void 5056 ibcm_build_reply_mad_addr(ibcm_mad_addr_t *inp_mad_addr, 5057 ibcm_mad_addr_t *out_mad_addr) 5058 { 5059 IBTF_DPRINTF_L5(cmlog, "ibcm_build_reply_mad_addr:"); 5060 5061 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*out_mad_addr)) 5062 5063 bcopy(inp_mad_addr, out_mad_addr, sizeof (ibcm_mad_addr_t)); 5064 5065 /* Swap the GIDs in the GRH */ 5066 if (inp_mad_addr->grh_exists == B_TRUE) { 5067 ib_gid_t sgid = inp_mad_addr->grh_hdr.ig_sender_gid; 5068 5069 /* swap the SGID and DGID */ 5070 out_mad_addr->grh_hdr.ig_sender_gid = 5071 inp_mad_addr->grh_hdr.ig_recver_gid; 5072 out_mad_addr->grh_hdr.ig_recver_gid = sgid; 5073 } 5074 5075 /* 5076 * CM posts response MAD on a new/existing internal QP on the same port 5077 * and pkey 5078 */ 5079 out_mad_addr->cm_qp_entry = 5080 ibcm_find_qp(inp_mad_addr->cm_qp_entry->qp_port->port_hcap, 5081 inp_mad_addr->port_num, inp_mad_addr->rcvd_addr.ia_p_key); 5082 5083 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*out_mad_addr)) 5084 } 5085 5086 5087 /* 5088 * ibcm_post_rc_mad 5089 * Posts a CM MAD associated with a RC statep 5090 * 5091 * INPUTS: 5092 * statep : RC statep associated with the post 5093 * msgp : CM MAD to be posted 5094 * post_cb : non-NULL callback address implies non-blocking post 5095 * args : Args to ibmf send callback 5096 * 5097 * RETURN VALUE: based on ibmf_send_mad 5098 */ 5099 void 5100 ibcm_post_rc_mad(ibcm_state_data_t *statep, ibmf_msg_t *msgp, 5101 ibmf_msg_cb_t post_cb, void *args) 5102 { 5103 ibt_status_t status; 5104 5105 mutex_enter(&statep->state_mutex); 5106 statep->post_time = gethrtime(); 5107 mutex_exit(&statep->state_mutex); 5108 status = ibcm_post_mad(msgp, &statep->stored_reply_addr, post_cb, 5109 args); 5110 if ((status != IBT_SUCCESS) && (post_cb != NULL)) 5111 /* Call ibmf callback directly */ 5112 (*post_cb)(NULL, msgp, args); 5113 } 5114 5115 5116 /* 5117 * ibcm_post_ud_mad 5118 * Posts a CM MAD associated with a UD statep 5119 * 5120 * INPUTS: 5121 * ud_statep : UD statep associated with the post 5122 * msgp : CM MAD to be posted 5123 * post_cb : non-NULL callback address implies non-blocking post 5124 * args : Args to ibmf send callback 5125 * 5126 * RETURN VALUE: based on ibmf_send_mad 5127 */ 5128 void 5129 ibcm_post_ud_mad(ibcm_ud_state_data_t *ud_statep, ibmf_msg_t *msgp, 5130 ibmf_msg_cb_t ud_post_cb, void *args) 5131 { 5132 ibt_status_t status; 5133 status = ibcm_post_mad(msgp, &ud_statep->ud_stored_reply_addr, 5134 ud_post_cb, args); 5135 if ((status != IBT_SUCCESS) && (ud_post_cb != NULL)) 5136 /* Call ibmf callback directly */ 5137 (*ud_post_cb)(NULL, msgp, args); 5138 } 5139 5140 /* 5141 * ibcm_post_mad: 5142 * Posts CM MAD using IBMF in blocking mode 5143 * 5144 * INPUTS: 5145 * msgp : CM MAD to be posted 5146 * cm_mad_addr : Address information for the MAD to be posted 5147 * post_cb : non-NULL callback address implies non-blocking post 5148 * args : Args to ibmf send callback 5149 * 5150 * RETURN VALUE: based on ibmf_send_mad 5151 */ 5152 ibt_status_t 5153 ibcm_post_mad(ibmf_msg_t *msgp, ibcm_mad_addr_t *cm_mad_addr, 5154 ibmf_msg_cb_t post_cb, void *args) 5155 { 5156 int post_status; 5157 5158 IBTF_DPRINTF_L5(cmlog, "ibcm_post_mad: " 5159 "ibmf_msg_t = %p, cm_madd_adr = %p", msgp, cm_mad_addr); 5160 5161 IBTF_DPRINTF_L4(cmlog, "ibcm_post_mad: dlid = %x, d_qno= %x", 5162 cm_mad_addr->rcvd_addr.ia_remote_lid, 5163 cm_mad_addr->rcvd_addr.ia_remote_qno); 5164 IBTF_DPRINTF_L4(cmlog, "ibcm_post_mad: p_key = %x, q_key = %x, " 5165 "sl = %x, grh_exists = %x", 5166 cm_mad_addr->rcvd_addr.ia_p_key, cm_mad_addr->rcvd_addr.ia_q_key, 5167 cm_mad_addr->rcvd_addr.ia_service_level, cm_mad_addr->grh_exists); 5168 5169 /* Copy local addressing info */ 5170 msgp->im_local_addr = cm_mad_addr->rcvd_addr; 5171 5172 /* Copy global/GRH addressing info */ 5173 if (cm_mad_addr->grh_exists == B_TRUE) 5174 msgp->im_global_addr = cm_mad_addr->grh_hdr; 5175 5176 if (post_cb) 5177 ibcm_flow_inc(); 5178 post_status = ibmf_msg_transport( 5179 cm_mad_addr->ibmf_hdl, cm_mad_addr->cm_qp_entry->qp_cm, msgp, 5180 NULL, post_cb, args, 0); 5181 if (post_status != IBMF_SUCCESS) { 5182 IBTF_DPRINTF_L2(cmlog, "ibcm_post_mad: ibmf_msg_transport " 5183 "failed: status %d, cb = %p", post_status, post_cb); 5184 /* Analyze the reason for failure */ 5185 return (ibcm_ibmf_analyze_error(post_status)); 5186 } 5187 5188 return (IBT_SUCCESS); 5189 } 5190 5191 5192 /* 5193 * ibcm_process_get_classport_info: 5194 * Get classportinfo 5195 * 5196 * INPUTS: 5197 * hcap - HCA entry pointer 5198 * input_madp - Input MAD pointer 5199 * cm_mad_addr - Address information for the MAD to be posted 5200 * 5201 * RETURN VALUE: NONE 5202 */ 5203 static void 5204 ibcm_process_get_classport_info(ibcm_hca_info_t *hcap, uint8_t *input_madp, 5205 ibcm_mad_addr_t *cm_mad_addr) 5206 { 5207 ibmf_msg_t *msgp; 5208 5209 IBTF_DPRINTF_L5(cmlog, "ibcm_process_get_classport_info: (%p, %p, %p)", 5210 hcap, input_madp, cm_mad_addr); 5211 5212 if (ibcm_alloc_out_msg(cm_mad_addr->ibmf_hdl, &msgp, 5213 MAD_METHOD_GET_RESPONSE) != IBT_SUCCESS) { 5214 IBTF_DPRINTF_L2(cmlog, "ibcm_process_get_classport_info: " 5215 "ibcm_alloc_out_msg failed"); 5216 return; 5217 } 5218 5219 /* copy the transaction id from input get mad */ 5220 IBCM_OUT_HDRP(msgp)->TransactionID = 5221 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 5222 IBCM_OUT_HDRP(msgp)->AttributeID = h2b16(MAD_ATTR_ID_CLASSPORTINFO); 5223 5224 bcopy(&ibcm_clpinfo, IBCM_OUT_MSGP(msgp), sizeof (ibcm_clpinfo)); 5225 5226 (void) ibcm_post_mad(msgp, cm_mad_addr, NULL, NULL); 5227 (void) ibcm_free_out_msg(cm_mad_addr->ibmf_hdl, &msgp); 5228 5229 IBTF_DPRINTF_L4(cmlog, "ibcm_process_get_classport_info: done"); 5230 } 5231 5232 /* 5233 * ibcm_decode_classport_info: 5234 * Decode classportinfo 5235 * 5236 * INPUTS: 5237 * hcap - HCA entry pointer 5238 * cm_mad_addr - Address information for the MAD to be posted 5239 * input_madp - Input MAD pointer 5240 * 5241 * RETURN VALUE: NONE 5242 */ 5243 static void 5244 ibcm_decode_classport_info(ibcm_hca_info_t *hcap, uint8_t *input_madp, 5245 ibcm_mad_addr_t *cm_mad_addr) 5246 { 5247 ibcm_classportinfo_msg_t *portinfop = (ibcm_classportinfo_msg_t *) 5248 (&input_madp[IBCM_MAD_HDR_SIZE]); 5249 IBTF_DPRINTF_L5(cmlog, "ibcm_decode_classport_info: (%p, %p, %p)", 5250 hcap, input_madp, cm_mad_addr); 5251 5252 /* Print various fields of received classportinfo in debuf buf */ 5253 5254 IBTF_DPRINTF_L4(cmlog, "ibcm_decode_classport_info: " 5255 "Base version %d Class version %d", portinfop->BaseVersion, 5256 portinfop->ClassVersion); 5257 IBTF_DPRINTF_L4(cmlog, "ibcm_decode_classport_info: " 5258 "Cap Mask %d Resp Time %d", portinfop->CapabilityMask, 5259 portinfop->RespTimeValue_plus); 5260 } 5261 5262 5263 /* 5264 * ibcm_handler_conn_fail: 5265 * Helper function used to call client handler for Conn fail event 5266 * 5267 * INPUTS: 5268 * statep: The connection state pointer 5269 * rej_type: Message being rejected 5270 * rej_reason: Reason why CM is sending the REJ message 5271 * client_data: Private data returned by the client for REJ 5272 * client_data_len: Length of above client's private data. 5273 * 5274 * RETURN VALUE: Client Handler's return status 5275 */ 5276 static void 5277 ibcm_handler_conn_fail(ibcm_state_data_t *statep, uint8_t cf_code, 5278 uint8_t cf_msg, ibt_cm_reason_t cf_reason, uint8_t *client_data, 5279 ibt_priv_data_len_t client_data_len) 5280 { 5281 ibt_cm_event_t event; 5282 5283 ibcm_path_cache_purge(); 5284 5285 if (statep->channel) 5286 ibtl_cm_chan_open_is_aborted(statep->channel); 5287 5288 /* Invoke CM handler w/ event passed as arg */ 5289 if (statep->cm_handler != NULL) { 5290 bzero(&event, sizeof (ibt_cm_event_t)); 5291 5292 event.cm_type = IBT_CM_EVENT_FAILURE; 5293 event.cm_channel = statep->channel; 5294 event.cm_session_id = NULL; 5295 event.cm_priv_data = NULL; 5296 event.cm_priv_data_len = 0; 5297 5298 event.cm_event.failed.cf_code = cf_code; 5299 event.cm_event.failed.cf_msg = cf_msg; 5300 event.cm_event.failed.cf_reason = cf_reason; 5301 5302 ibcm_insert_trace(statep, IBCM_TRACE_CALLED_CONN_FAIL_EVENT); 5303 5304 (void) statep->cm_handler(statep->state_cm_private, &event, 5305 NULL, client_data, client_data_len); 5306 5307 ibcm_insert_trace(statep, IBCM_TRACE_RET_CONN_FAIL_EVENT); 5308 } 5309 if (ibcm_enable_trace != 0) 5310 ibcm_dump_conn_trace(statep); 5311 mutex_enter(&statep->state_mutex); 5312 ibcm_open_done(statep); 5313 mutex_exit(&statep->state_mutex); 5314 } 5315 5316 /* 5317 * QP State transition functions here 5318 * 5319 * The brief description of these functions : 5320 * Validate QP related attributes in the messages 5321 * Call client/server callback handlers 5322 * Change QP state 5323 * Set QP attributes (modify QP) 5324 * Fill up the response MADs 5325 */ 5326 5327 /* 5328 * ibcm_set_primary_adds_vect: 5329 * Helper function used to fill up ibt_adds_vect_t PRIMARY PATH 5330 * (called from ibcm_cep_state_*() functions) 5331 * 5332 * INPUTS: 5333 * statep : The connection state pointer 5334 * adds_vectp : The ibt_adds_vect_t ptr that is being filled up 5335 * msgp : CM REQ message that is the source of information 5336 * 5337 * RETURN VALUE: NONE 5338 */ 5339 static void 5340 ibcm_set_primary_adds_vect(ibcm_state_data_t *statep, 5341 ibt_adds_vect_t *adds_vectp, ibcm_req_msg_t *msgp) 5342 { 5343 uint32_t flow_label20_res6_rate6; 5344 5345 flow_label20_res6_rate6 = b2h32(msgp->req_primary_flow_label_plus); 5346 5347 /* first setup the srvl, srate, dlid and dgid */ 5348 adds_vectp->av_srvl = msgp->req_primary_sl_plus >> 4; 5349 adds_vectp->av_src_path = statep->prim_src_path_bits; 5350 5351 if (statep->mode == IBCM_PASSIVE_MODE) { 5352 adds_vectp->av_dlid = b2h16(msgp->req_primary_l_port_lid); 5353 adds_vectp->av_dgid.gid_prefix = 5354 b2h64(msgp->req_primary_l_port_gid.gid_prefix); 5355 adds_vectp->av_dgid.gid_guid = 5356 b2h64(msgp->req_primary_l_port_gid.gid_guid); 5357 adds_vectp->av_sgid.gid_prefix = 5358 b2h64(msgp->req_primary_r_port_gid.gid_prefix); 5359 adds_vectp->av_sgid.gid_guid = 5360 b2h64(msgp->req_primary_r_port_gid.gid_guid); 5361 adds_vectp->av_srate = flow_label20_res6_rate6 & 0x3f; 5362 } else { 5363 adds_vectp->av_dlid = b2h16(msgp->req_primary_r_port_lid); 5364 adds_vectp->av_dgid.gid_prefix = 5365 b2h64(msgp->req_primary_r_port_gid.gid_prefix); 5366 adds_vectp->av_dgid.gid_guid = 5367 b2h64(msgp->req_primary_r_port_gid.gid_guid); 5368 adds_vectp->av_sgid.gid_prefix = 5369 b2h64(msgp->req_primary_l_port_gid.gid_prefix); 5370 adds_vectp->av_sgid.gid_guid = 5371 b2h64(msgp->req_primary_l_port_gid.gid_guid); 5372 adds_vectp->av_srate = statep->local_srate; 5373 } 5374 5375 /* next copy off the GRH info if it exists */ 5376 if ((msgp->req_primary_sl_plus & 0x8) == 0) { 5377 adds_vectp->av_send_grh = B_TRUE; 5378 adds_vectp->av_flow = flow_label20_res6_rate6 >> 12; 5379 adds_vectp->av_tclass = msgp->req_primary_traffic_class; 5380 adds_vectp->av_hop = msgp->req_primary_hop_limit; 5381 } else { 5382 adds_vectp->av_send_grh = B_FALSE; 5383 } 5384 } 5385 5386 5387 /* 5388 * ibcm_set_alt_adds_vect: 5389 * Helper function used to fill up ibt_adds_vect_t ALTERNATE PATH 5390 * (called from ibcm_cep_state_*() functions) 5391 * 5392 * INPUTS: 5393 * statep : The connection state pointer 5394 * adds_vectp : The ibt_adds_vect_t ptr that is being filled up 5395 * msgp : CM REQ message that is the source of information 5396 * 5397 * RETURN VALUE: NONE 5398 */ 5399 static void 5400 ibcm_set_alt_adds_vect(ibcm_state_data_t *statep, 5401 ibt_adds_vect_t *adds_vectp, ibcm_req_msg_t *msgp) 5402 { 5403 ib_gid_t dgid; 5404 ib_gid_t sgid; 5405 uint32_t flow_label20_res6_rate6; 5406 5407 flow_label20_res6_rate6 = b2h32(msgp->req_alt_flow_label_plus); 5408 5409 /* first setup the srvl, srate, dlid and dgid */ 5410 adds_vectp->av_srvl = msgp->req_alt_sl_plus >> 4; 5411 adds_vectp->av_src_path = statep->alt_src_path_bits; 5412 5413 if (statep->mode == IBCM_PASSIVE_MODE) { 5414 adds_vectp->av_dlid = b2h16(msgp->req_alt_l_port_lid); 5415 bcopy(&msgp->req_alt_l_port_gid[0], &dgid, sizeof (ib_gid_t)); 5416 bcopy(&msgp->req_alt_r_port_gid[0], &sgid, sizeof (ib_gid_t)); 5417 adds_vectp->av_srate = flow_label20_res6_rate6 & 0x3f; 5418 } else { 5419 adds_vectp->av_dlid = b2h16(msgp->req_alt_r_port_lid); 5420 bcopy(&msgp->req_alt_r_port_gid[0], &dgid, sizeof (ib_gid_t)); 5421 bcopy(&msgp->req_alt_l_port_gid[0], &sgid, sizeof (ib_gid_t)); 5422 adds_vectp->av_srate = statep->local_alt_srate; 5423 } 5424 adds_vectp->av_dgid.gid_prefix = b2h64(dgid.gid_prefix); 5425 adds_vectp->av_dgid.gid_guid = b2h64(dgid.gid_guid); 5426 adds_vectp->av_sgid.gid_prefix = b2h64(sgid.gid_prefix); 5427 adds_vectp->av_sgid.gid_guid = b2h64(sgid.gid_guid); 5428 5429 /* next copy off the GRH info if it exists */ 5430 if ((msgp->req_alt_sl_plus & 0x8) == 0) { 5431 adds_vectp->av_send_grh = B_TRUE; 5432 adds_vectp->av_flow = flow_label20_res6_rate6 >> 12; 5433 adds_vectp->av_tclass = msgp->req_alt_traffic_class; 5434 adds_vectp->av_hop = msgp->req_alt_hop_limit; 5435 } else { 5436 adds_vectp->av_send_grh = B_FALSE; /* no GRH */ 5437 } 5438 } 5439 5440 5441 /* 5442 * ibcm_set_primary_cep_path: 5443 * Helper function used to fill up ibt_cep_path_t PRIMARY PATH 5444 * (called from ibcm_cep_state_*() functions) 5445 * 5446 * INPUTS: 5447 * statep : The connection state pointer 5448 * adds_vectp : The ibt_cep_path_t ptr that is being filled up 5449 * msgp : CM REQ message that is the source of information 5450 * 5451 * RETURN VALUE: NONE 5452 */ 5453 static ibt_status_t 5454 ibcm_set_primary_cep_path(ibcm_state_data_t *statep, ibt_cep_path_t *pathp, 5455 ibcm_req_msg_t *msgp) 5456 { 5457 ibt_status_t status; 5458 5459 /* validate the PKEY in REQ for prim port */ 5460 status = ibt_pkey2index_byguid(statep->local_hca_guid, 5461 statep->prim_port, b2h16(msgp->req_part_key), &pathp->cep_pkey_ix); 5462 5463 if (status != IBT_SUCCESS) { 5464 IBTF_DPRINTF_L2(cmlog, "ibcm_set_primary_cep_path: " 5465 "statep 0x%p pkey %x prim_port %d ", statep, 5466 b2h16(msgp->req_part_key), statep->prim_port); 5467 IBTF_DPRINTF_L2(cmlog, "ibcm_set_primary_cep_path: " 5468 "statep 0x%p Invalid PKEY on prim_port, status %d ", 5469 statep, status); 5470 return (status); 5471 } 5472 statep->pkey = b2h16(msgp->req_part_key); 5473 ibcm_set_primary_adds_vect(statep, &pathp->cep_adds_vect, msgp); 5474 return (IBT_SUCCESS); 5475 } 5476 5477 5478 /* 5479 * ibcm_set_alt_cep_path: 5480 * Helper function used to fill up ibt_cep_path_t ALTERNATE PATH 5481 * (called from ibcm_cep_state_*() functions) 5482 * 5483 * INPUTS: 5484 * statep : The connection state pointer 5485 * adds_vectp : The ibt_cep_path_t ptr that is being filled up 5486 * msgp : CM REQ message that is the source of information 5487 * 5488 * RETURN VALUE: NONE 5489 */ 5490 static ibt_status_t 5491 ibcm_set_alt_cep_path(ibcm_state_data_t *statep, ibt_cep_path_t *pathp, 5492 ibcm_req_msg_t *msgp) 5493 { 5494 ibt_status_t status; 5495 5496 if (b2h16(msgp->req_alt_l_port_lid) == 0) { 5497 /* no alternate path specified */ 5498 return (IBT_SUCCESS); 5499 } 5500 5501 /* validate the PKEY in REQ for alt port */ 5502 status = ibt_pkey2index_byguid(statep->local_hca_guid, 5503 statep->alt_port, b2h16(msgp->req_part_key), &pathp->cep_pkey_ix); 5504 5505 if (status != IBT_SUCCESS) { 5506 IBTF_DPRINTF_L2(cmlog, "ibcm_set_alt_cep_path: " 5507 "statep 0x%p pkey %x alt_port %d ", statep, 5508 b2h16(msgp->req_part_key), statep->alt_port); 5509 IBTF_DPRINTF_L2(cmlog, "ibcm_set_alt_cep_path: " 5510 "statep 0x%p Invalid PKEY on alt_port, status %d ", 5511 statep, status); 5512 return (status); 5513 } 5514 pathp->cep_hca_port_num = statep->alt_port; 5515 ibcm_set_alt_adds_vect(statep, &pathp->cep_adds_vect, msgp); 5516 return (IBT_SUCCESS); 5517 5518 } 5519 5520 /* 5521 * ibcm_compare_prim_alt_paths: 5522 * Helper function used to find if primary and alternate paths are 5523 * identical 5524 * (called from ibcm_cep_state_req) 5525 * 5526 * INPUTS: 5527 * req: Pointer to ibt_cm_req_rcv_t, filled before invoking 5528 * the function 5529 * 5530 * RETURN VALUE: NONE 5531 */ 5532 5533 static boolean_t 5534 ibcm_compare_prim_alt_paths(ibt_adds_vect_t *prim, ibt_adds_vect_t *alt) 5535 { 5536 5537 if ((alt->av_dlid == prim->av_dlid) && 5538 (alt->av_dgid.gid_prefix == prim->av_dgid.gid_prefix) && 5539 (alt->av_dgid.gid_guid == prim->av_dgid.gid_guid) && 5540 (alt->av_sgid.gid_prefix == prim->av_sgid.gid_prefix) && 5541 (alt->av_sgid.gid_guid == prim->av_sgid.gid_guid) && 5542 (alt->av_src_path == prim->av_src_path)) { 5543 5544 return (B_TRUE); 5545 } 5546 return (B_FALSE); 5547 } 5548 5549 5550 /* 5551 * ibcm_invoke_qp_modify: 5552 * Helper function used to call ibt_modify_qp() 5553 * called from ibcm_cep_state_req()/ibcm_cep_state_rep() 5554 * It sets up qp_info/eec_info 5555 * 5556 * Sets state to RTR as well. 5557 * 5558 * 5559 * INPUTS: 5560 * statep: The connection state pointer 5561 * req_msgp: The CM REQ message 5562 * 5563 * RETURN VALUE: 5564 * IBT_SUCCESS - call succeeded 5565 */ 5566 static ibt_status_t 5567 ibcm_invoke_qp_modify(ibcm_state_data_t *statep, ibcm_req_msg_t *req_msgp, 5568 ibcm_rep_msg_t *rep_msgp) 5569 { 5570 ibt_status_t status; 5571 ibt_qp_info_t qp_info; 5572 ibt_cep_modify_flags_t cep_flags; 5573 ibt_tran_srv_t trans; 5574 5575 cep_flags = IBT_CEP_SET_INIT_RTR | IBT_CEP_SET_PKEY_IX; 5576 trans = ((uint8_t *)&req_msgp->req_remote_eecn_plus)[3] >> 1 & 0x3; 5577 5578 ASSERT(statep->channel != NULL); 5579 5580 /* 5581 * If alternate path is present in REQ message then 5582 * OR in IBT_CEP_SET_ALT_PATH, if APM supported on hca 5583 */ 5584 if (b2h16(req_msgp->req_alt_l_port_lid) != 0) { 5585 5586 if (statep->hcap->hca_caps & IBT_HCA_AUTO_PATH_MIG) 5587 cep_flags |= IBT_CEP_SET_ALT_PATH; 5588 /* default value of rep_failover is ACCEPT */ 5589 else { 5590 rep_msgp->rep_target_delay_plus |= 5591 IBT_CM_FAILOVER_REJ_NOTSUPP << 1; 5592 IBTF_DPRINTF_L3(cmlog, "ibcm_invoke_qp_modify" 5593 " Alt Path specified in REQ, but not supported"); 5594 } 5595 } 5596 5597 /* If transport type is RD OR in IBC_CEP_SET_QKEY */ 5598 if (trans == IBT_RD_SRV) { 5599 cep_flags |= IBT_CEP_SET_QKEY; 5600 } 5601 5602 /* Start filling up ibt_qp_info_t. */ 5603 bzero(&qp_info, sizeof (qp_info)); 5604 qp_info.qp_trans = trans; 5605 qp_info.qp_state = IBT_STATE_RTR; 5606 qp_info.qp_flags = IBT_CEP_NO_FLAGS; 5607 5608 switch (trans) { 5609 case IBT_RC_SRV: 5610 5611 if (statep->mode == IBCM_ACTIVE_MODE) { 5612 /* Setting PSN on RQ */ 5613 5614 IBCM_QPINFO_RC(qp_info).rc_rq_psn = 5615 b2h32(req_msgp->req_starting_psn_plus) >> 8; 5616 5617 IBCM_QPINFO_RC(qp_info).rc_dst_qpn = 5618 b2h32(rep_msgp->rep_local_qpn_plus) >> 8; 5619 5620 /* RDMA resources taken from negotiated REP values */ 5621 IBCM_QPINFO_RC(qp_info).rc_rdma_ra_in = 5622 rep_msgp->rep_initiator_depth; 5623 5624 } else { /* Passive side CM */ 5625 /* Setting PSN on SQ and RQ */ 5626 IBCM_QPINFO_RC(qp_info).rc_sq_psn = 5627 IBCM_QPINFO_RC(qp_info).rc_rq_psn = 5628 b2h32(rep_msgp->rep_starting_psn_plus) >> 8; 5629 5630 IBCM_QPINFO_RC(qp_info).rc_dst_qpn = 5631 b2h32(req_msgp->req_local_qpn_plus) >> 8; 5632 5633 /* RDMA resources taken from negotiated REP values */ 5634 IBCM_QPINFO_RC(qp_info).rc_rdma_ra_in = 5635 rep_msgp->rep_resp_resources; 5636 } 5637 5638 /* XXX, Oh!, ibtl doesn't have interface for setting this */ 5639 IBCM_QPINFO_RC(qp_info).rc_min_rnr_nak = 5640 ibcm_default_rnr_nak_time; 5641 IBCM_QPINFO_RC(qp_info).rc_path_mtu = 5642 req_msgp->req_mtu_plus >> 4; 5643 IBCM_QPINFO_RC(qp_info).rc_retry_cnt = 5644 ((uint8_t *)&req_msgp->req_starting_psn_plus)[3] & 0x7; 5645 IBCM_QPINFO_RC(qp_info).rc_rnr_retry_cnt = 5646 req_msgp->req_mtu_plus & 0x7; 5647 5648 if ((status = ibcm_set_primary_cep_path(statep, 5649 &IBCM_QPINFO_RC(qp_info).rc_path, req_msgp)) != 5650 IBT_SUCCESS) 5651 return (status); 5652 5653 if ((status = ibcm_set_alt_cep_path(statep, 5654 &IBCM_QPINFO_RC(qp_info).rc_alt_path, req_msgp)) != 5655 IBT_SUCCESS) 5656 return (status); 5657 5658 break; 5659 case IBT_RD_SRV: 5660 if (statep->mode == IBCM_ACTIVE_MODE) { /* look at REP msg */ 5661 IBCM_QPINFO(qp_info).rd.rd_qkey = 5662 b2h32(rep_msgp->rep_local_qkey); 5663 } else { 5664 IBCM_QPINFO(qp_info).rd.rd_qkey = 5665 b2h32(req_msgp->req_local_qkey); 5666 } 5667 5668 break; 5669 5670 case IBT_UC_SRV: 5671 if (statep->mode == IBCM_ACTIVE_MODE) { /* look at REP msg */ 5672 IBCM_QPINFO_UC(qp_info).uc_sq_psn = 5673 b2h32(req_msgp->req_starting_psn_plus) >> 8; 5674 IBCM_QPINFO_UC(qp_info).uc_dst_qpn = 5675 b2h32(rep_msgp->rep_local_qpn_plus) >> 8; 5676 } else { 5677 IBCM_QPINFO_UC(qp_info).uc_rq_psn = 5678 IBCM_QPINFO_UC(qp_info).uc_sq_psn = 5679 b2h32(rep_msgp->rep_starting_psn_plus) >> 8; 5680 IBCM_QPINFO_UC(qp_info).uc_dst_qpn = 5681 b2h32(req_msgp->req_local_qpn_plus) >> 8; 5682 } 5683 IBCM_QPINFO_UC(qp_info).uc_path_mtu = 5684 req_msgp->req_mtu_plus >> 4; 5685 5686 if ((status = ibcm_set_primary_cep_path(statep, 5687 &IBCM_QPINFO_UC(qp_info).uc_path, req_msgp)) != 5688 IBT_SUCCESS) 5689 return (status); 5690 5691 if ((status = ibcm_set_alt_cep_path(statep, 5692 &IBCM_QPINFO_UC(qp_info).uc_alt_path, req_msgp)) != 5693 IBT_SUCCESS) 5694 return (status); 5695 5696 break; 5697 default: 5698 IBTF_DPRINTF_L2(cmlog, "ibcm_invoke_qp_modify: " 5699 "unknown svc_type = %x", trans); 5700 break; 5701 } 5702 5703 /* Call modify_qp */ 5704 status = ibt_modify_qp(statep->channel, cep_flags, &qp_info, NULL); 5705 IBTF_DPRINTF_L4(cmlog, "ibcm_invoke_qp_modify: statep 0x%p" 5706 " ibt_modify_qp() Init to RTR returned = %d", statep, status); 5707 5708 if (status == IBT_SUCCESS) 5709 ibcm_insert_trace(statep, IBCM_TRACE_INIT_RTR); 5710 else 5711 ibcm_insert_trace(statep, IBCM_TRACE_INIT_RTR_FAIL); 5712 5713 #ifdef DEBUG 5714 5715 print_modify_qp("Init to RTR", statep->channel, cep_flags, &qp_info); 5716 5717 if (statep->channel != NULL) { 5718 ibt_qp_query_attr_t qp_attrs; 5719 5720 (void) ibt_query_qp(statep->channel, &qp_attrs); 5721 IBTF_DPRINTF_L4(cmlog, "ibcm_invoke_qp_modify: " 5722 "qp_info.qp_state = %x", qp_attrs.qp_info.qp_state); 5723 } 5724 #endif 5725 5726 return (status); 5727 } 5728 5729 5730 /* 5731 * ibcm_verify_req_gids_and_svcid 5732 * Validation of LIDs, GIDs and SVC ID 5733 * 5734 * INPUTS: 5735 * statep - state pointer 5736 * cm_req_msgp - REQ message pointer 5737 * 5738 * RETURN VALUE: IBCM_SUCCESS/IBCM_FAILURE 5739 * 5740 */ 5741 ibcm_status_t 5742 ibcm_verify_req_gids_and_svcid(ibcm_state_data_t *statep, 5743 ibcm_req_msg_t *cm_req_msgp) 5744 { 5745 ib_gid_t gid; 5746 ib_gid_t agid; 5747 ib_lid_t lid; 5748 ibt_status_t status; 5749 ibtl_cm_hca_port_t port; 5750 ibt_cm_reason_t reject_reason = IBT_CM_SUCCESS; 5751 ibcm_svc_info_t *svc_infop; 5752 ibcm_svc_bind_t *svc_bindp; 5753 ibcm_svc_bind_t *tmp_bindp; 5754 ib_pkey_t pkey; 5755 uint8_t port_num; 5756 ib_guid_t hca_guid; 5757 ibcm_ip_pvtdata_t *ip_data; 5758 5759 /* Verify LID and GID of primary port */ 5760 5761 gid.gid_prefix = b2h64(cm_req_msgp->req_primary_r_port_gid.gid_prefix); 5762 gid.gid_guid = b2h64(cm_req_msgp->req_primary_r_port_gid.gid_guid); 5763 5764 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: statep 0x%p" 5765 " PRIM _r_gid (%llx, %llx)", statep, gid.gid_prefix, 5766 gid.gid_guid); 5767 5768 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: statep 0x%p " 5769 "PRIM passive lid %x", statep, 5770 b2h16(cm_req_msgp->req_primary_r_port_lid)); 5771 5772 /* Verify GID validity, if specified */ 5773 if ((status = ibtl_cm_get_hca_port(gid, 0, &port)) == IBT_SUCCESS) { 5774 5775 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: statep 0x%p " 5776 "prim_port_num %d", statep, port.hp_port); 5777 5778 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: statep 0x%p " 5779 "passive hca_guid 0x%llX", statep, port.hp_hca_guid); 5780 5781 port_num = port.hp_port; 5782 hca_guid = port.hp_hca_guid; 5783 } 5784 5785 if (status != IBT_SUCCESS) { 5786 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids: statep 0x%p " 5787 "ibtl_cm_get_hca_port() primary port failed = %d", statep, 5788 status); 5789 reject_reason = IBT_CM_PRIM_GID; 5790 /* we will search for an acceptable GID to this port */ 5791 port_num = statep->stored_reply_addr.port_num; 5792 hca_guid = statep->hcap->hca_guid; 5793 5794 } else if (port.hp_base_lid != 5795 (b2h16(cm_req_msgp->req_primary_r_port_lid) & 5796 (~((1 << port.hp_lmc) - 1)))) { 5797 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids: statep 0x%p " 5798 "primary port lid invalid (%x, %x, %x)", statep, 5799 port.hp_base_lid, 5800 b2h16(cm_req_msgp->req_primary_r_port_lid), port.hp_lmc); 5801 reject_reason = IBT_CM_PRIM_LID; 5802 } else { 5803 5804 statep->local_hca_guid = port.hp_hca_guid; 5805 statep->prim_port = port.hp_port; 5806 statep->prim_src_path_bits = 5807 b2h16(cm_req_msgp->req_primary_r_port_lid) - 5808 port.hp_base_lid; 5809 5810 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: " 5811 "statep 0x%p prim_port_path_bits %d ", 5812 statep, statep->prim_src_path_bits); 5813 5814 /* Verify LID and GID of alternate port. Post REJ if invalid */ 5815 5816 /* Need a bcopy, as alt port gid is unaligned in req message */ 5817 bcopy(&cm_req_msgp->req_alt_r_port_gid[0], &agid, 5818 sizeof (ib_gid_t)); 5819 agid.gid_prefix = b2h64(agid.gid_prefix); 5820 agid.gid_guid = b2h64(agid.gid_guid); 5821 5822 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: statep 0x%p" 5823 " Alt port_gid is (%llX:%llX)", statep, agid.gid_prefix, 5824 agid.gid_guid); 5825 5826 if ((agid.gid_prefix != 0) || (agid.gid_guid != 0)) { 5827 5828 /* Verify GID validity, if specified */ 5829 if ((status = ibtl_cm_get_hca_port(agid, 5830 statep->local_hca_guid, &port)) != IBT_SUCCESS) { 5831 IBTF_DPRINTF_L2(cmlog, 5832 "ibcm_verify_req_gids: ibtl_cm_get_hca_port" 5833 " statep 0x%p alternate port failed = %d", 5834 statep, status); 5835 reject_reason = IBT_CM_ALT_GID; 5836 5837 } else if (port.hp_base_lid != 5838 (b2h16(cm_req_msgp->req_alt_r_port_lid) & 5839 (~((1 << port.hp_lmc) - 1)))) { 5840 5841 IBTF_DPRINTF_L2(cmlog, 5842 "ibcm_verify_req_gids: statep 0x%p " 5843 "alternate port lid invalid (%x, %x, %x)", 5844 statep, port.hp_base_lid, 5845 cm_req_msgp->req_alt_r_port_lid, 5846 port.hp_lmc); 5847 reject_reason = IBT_CM_ALT_LID; 5848 } else { /* Alt LID and GID are valid */ 5849 statep->alt_port = port.hp_port; 5850 statep->alt_src_path_bits = 5851 b2h16(cm_req_msgp->req_alt_r_port_lid) - 5852 port.hp_base_lid; 5853 5854 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: " 5855 "statep 0x%p alt_port_num %d " 5856 "alt_rc_hca_guid 0x%llX", statep, 5857 port.hp_port, port.hp_hca_guid); 5858 5859 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: " 5860 "statep 0x%p alt_port_path_bits %d ", 5861 statep, statep->alt_src_path_bits); 5862 } 5863 } 5864 } 5865 5866 mutex_enter(&ibcm_svc_info_lock); 5867 svc_infop = ibcm_find_svc_entry(statep->svcid); 5868 5869 /* 5870 * Note: When we return SUCCESS, the reader lock won't get dropped 5871 * until after the cm_handler is called from ibcm_cep_state_req(). 5872 */ 5873 5874 IBTF_DPRINTF_L4(cmlog, "ibcm_verify_req_gids: " 5875 "ibcm_find_svc_entry found svc_infop %p", svc_infop); 5876 5877 /* 5878 * Send REJ with reject reason "invalid service id" for the 5879 * the following cases :- 5880 * Service id is valid, but not available at gid/lid of REQ 5881 * Service id is invalid 5882 */ 5883 5884 if (svc_infop == NULL || svc_infop->svc_bind_list == NULL) { 5885 mutex_exit(&ibcm_svc_info_lock); 5886 5887 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids_and_svcid: " 5888 "statep 0x%p svc_id %llX svc_infop NULL", statep, 5889 statep->svcid); 5890 5891 /* Send a REJ with invalid SID reason */ 5892 ibcm_post_rej_mad(statep, 5893 IBT_CM_INVALID_SID, IBT_CM_FAILURE_REQ, NULL, 0); 5894 return (IBCM_FAILURE); 5895 } 5896 5897 if (svc_infop->svc_rc_handler == NULL) { 5898 mutex_exit(&ibcm_svc_info_lock); 5899 5900 /* Send a REJ with invalid SID reason */ 5901 ibcm_post_rej_mad(statep, 5902 IBT_CM_INVALID_SRV_TYPE, IBT_CM_FAILURE_REQ, NULL, 0); 5903 return (IBCM_FAILURE); 5904 } 5905 5906 /* 5907 * Check if ServiceID is in RDMA IP CM SID range, if yes, we parse 5908 * the REQ's Private Data and verify for it's goodness. 5909 */ 5910 if (((statep->svcid & IB_SID_IPADDR_PREFIX_MASK) == 0) && 5911 (statep->svcid & IB_SID_IPADDR_PREFIX)) { 5912 ibt_ari_ip_t ari_ip; 5913 boolean_t rdma_rej_mad = B_FALSE; 5914 5915 if (cm_req_msgp->req_private_data == NULL) { 5916 mutex_exit(&ibcm_svc_info_lock); 5917 5918 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids_and_svcid:" 5919 " RDMA CM IP REQ Priv Data is NULL"); 5920 5921 /* Send a REJ with CONSUMER REJ */ 5922 ibcm_post_rej_mad(statep, IBT_CM_CONSUMER, 5923 IBT_CM_FAILURE_REQ, NULL, 0); 5924 return (IBCM_FAILURE); 5925 } 5926 ip_data = (ibcm_ip_pvtdata_t *)cm_req_msgp->req_private_data; 5927 5928 bzero(&ari_ip, sizeof (ibt_ari_ip_t)); 5929 5930 /* RDMA IP CM Layer Rejects this */ 5931 if (ip_data->ip_MajV != IBT_CM_IP_MAJ_VER) { 5932 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids_and_svcid:" 5933 "IP MajorVer mis-match %d", ip_data->ip_MajV); 5934 ari_ip.ip_reason = IBT_ARI_IP_MAJOR_VERSION; 5935 ari_ip.ip_suggested_version = IBT_CM_IP_MAJ_VER; 5936 ari_ip.ip_suggested = B_TRUE; 5937 rdma_rej_mad = B_TRUE; 5938 } else if (ip_data->ip_MinV != IBT_CM_IP_MIN_VER) { 5939 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids_and_svcid:" 5940 "IP MinorVer mis-match %d", ip_data->ip_MinV); 5941 ari_ip.ip_reason = IBT_ARI_IP_MINOR_VERSION; 5942 ari_ip.ip_suggested_version = IBT_CM_IP_MIN_VER; 5943 ari_ip.ip_suggested = B_TRUE; 5944 rdma_rej_mad = B_TRUE; 5945 } else if ((ip_data->ip_ipv != IBT_CM_IP_IPV_V4) && 5946 (ip_data->ip_ipv != IBT_CM_IP_IPV_V6)) { 5947 IBTF_DPRINTF_L2(cmlog, "ibcm_verify_req_gids_and_svcid:" 5948 " Invalid IPV specified %d", ip_data->ip_ipv); 5949 ari_ip.ip_reason = IBT_ARI_IP_IPV; 5950 ari_ip.ip_suggested_version = IBT_CM_IP_IPV_V4; 5951 ari_ip.ip_suggested = B_TRUE; 5952 rdma_rej_mad = B_TRUE; 5953 } else { 5954 /* 5955 * Validate whether ip_addr specified are non-NULL. 5956 * 5957 * NOTE: 5958 * RDMA ULP which is servicing this SID, should validate 5959 * the correctness of srcip/dstip and accordingly post 5960 * REJ related to ibt_ari_ip_reason_t of 5961 * IBT_ARI_IP_SRC_ADDR, IBT_ARI_IP_DST_ADDR and 5962 * IBT_ARI_IP_UNKNOWN_ADDR. 5963 */ 5964 if (ip_data->ip_ipv == IBT_CM_IP_IPV_V4) { 5965 if (ip_data->ip_srcv4 == 0) { 5966 IBTF_DPRINTF_L2(cmlog, 5967 "ibcm_verify_req_gids_and_svcid: " 5968 "Invalid NULL V4 SrcIp specified"); 5969 rdma_rej_mad = B_TRUE; 5970 ari_ip.ip_reason = IBT_ARI_IP_SRC_ADDR; 5971 ari_ip.ip_suggested = B_TRUE; 5972 ari_ip.ip_suggested_version = 5973 IBT_CM_IP_IPV_V4; 5974 } else if (ip_data->ip_dstv4 == 0) { 5975 IBTF_DPRINTF_L2(cmlog, 5976 "ibcm_verify_req_gids_and_svcid: " 5977 "Invalid NULL V4 DstIp specified"); 5978 rdma_rej_mad = B_TRUE; 5979 ari_ip.ip_reason = IBT_ARI_IP_DST_ADDR; 5980 ari_ip.ip_suggested = B_TRUE; 5981 ari_ip.ip_suggested_version = 5982 IBT_CM_IP_IPV_V4; 5983 } 5984 } else if (ip_data->ip_ipv == IBT_CM_IP_IPV_V6) { 5985 if (IN6_IS_ADDR_UNSPECIFIED( 5986 &ip_data->ip_srcv6)) { 5987 IBTF_DPRINTF_L2(cmlog, 5988 "ibcm_verify_req_gids_and_svcid: " 5989 "Invalid NULL V6 SrcIp specified"); 5990 rdma_rej_mad = B_TRUE; 5991 ari_ip.ip_reason = IBT_ARI_IP_SRC_ADDR; 5992 ari_ip.ip_suggested = B_TRUE; 5993 ari_ip.ip_suggested_version = 5994 IBT_CM_IP_IPV_V6; 5995 } else if (IN6_IS_ADDR_UNSPECIFIED( 5996 &ip_data->ip_dstv6)) { 5997 IBTF_DPRINTF_L2(cmlog, 5998 "ibcm_verify_req_gids_and_svcid: " 5999 "Invalid NULL V6 DstIp specified"); 6000 rdma_rej_mad = B_TRUE; 6001 ari_ip.ip_reason = IBT_ARI_IP_DST_ADDR; 6002 ari_ip.ip_suggested = B_TRUE; 6003 ari_ip.ip_suggested_version = 6004 IBT_CM_IP_IPV_V6; 6005 } 6006 } 6007 /* TBD: IBT_ARI_IP_UNKNOWN_ADDR */ 6008 } 6009 if (rdma_rej_mad == B_TRUE) { 6010 ibt_ari_con_t cons_rej; 6011 6012 mutex_exit(&ibcm_svc_info_lock); 6013 6014 cons_rej.rej_ari_len = 1 + sizeof (ibt_ari_ip_t); 6015 cons_rej.rej_ari[0] = 0; /* Rejected by CM Layer */ 6016 bcopy(&ari_ip, &cons_rej.rej_ari[1], 6017 sizeof (ibt_ari_ip_t)); 6018 /* Send a REJ with CONSUMER REJ */ 6019 ibcm_post_rej_mad(statep, IBT_CM_CONSUMER, 6020 IBT_CM_FAILURE_REQ, &cons_rej, 6021 sizeof (ibt_ari_con_t)); 6022 return (IBCM_FAILURE); 6023 } 6024 } 6025 6026 /* find the best "bind" entry that enables this port */ 6027 6028 pkey = b2h16(cm_req_msgp->req_part_key); 6029 svc_bindp = NULL; 6030 tmp_bindp = svc_infop->svc_bind_list; 6031 while (tmp_bindp) { 6032 if (tmp_bindp->sbind_hcaguid == hca_guid && 6033 tmp_bindp->sbind_port == port_num) { 6034 if (gid.gid_guid == 6035 tmp_bindp->sbind_gid.gid_guid && 6036 gid.gid_prefix == 6037 tmp_bindp->sbind_gid.gid_prefix) { 6038 /* gid match => really good match */ 6039 svc_bindp = tmp_bindp; 6040 if (pkey == tmp_bindp->sbind_pkey) 6041 /* absolute best match */ 6042 break; 6043 } else if (svc_bindp == NULL) { 6044 /* port match => a good match */ 6045 svc_bindp = tmp_bindp; 6046 } 6047 } 6048 tmp_bindp = tmp_bindp->sbind_link; 6049 } 6050 if (svc_bindp == NULL) { /* port not enabled for this SID */ 6051 mutex_exit(&ibcm_svc_info_lock); 6052 IBTF_DPRINTF_L2(cmlog, 6053 "ibcm_verify_req_gids_and_svcid: statep 0x%p " 6054 "no binding found", statep); 6055 ibcm_post_rej_mad(statep, 6056 IBT_CM_INVALID_SID, IBT_CM_FAILURE_REQ, NULL, 0); 6057 return (IBCM_FAILURE); 6058 } 6059 /* copy the GID in case we need it in REJ below */ 6060 gid.gid_prefix = b2h64(svc_bindp->sbind_gid.gid_prefix); 6061 gid.gid_guid = b2h64(svc_bindp->sbind_gid.gid_guid); 6062 6063 statep->state_cm_private = svc_bindp->sbind_cm_private; 6064 statep->state_svc_infop = svc_infop; 6065 statep->cm_handler = svc_infop->svc_rc_handler; 6066 if (reject_reason == IBT_CM_SUCCESS) 6067 IBCM_SVC_INCR(svc_infop); 6068 mutex_exit(&ibcm_svc_info_lock); 6069 6070 /* 6071 * If the service id is valid, but gid in REQ is invalid, 6072 * then send a REJ with invalid gid 6073 * For Invalid primary gid, the ARI field is filled with 6074 * with gid from svcinfo 6075 * For invalid prim/alt gid reject, CM uses one of the gids 6076 * registered in ARI. 6077 * For invalid prim/alt lid reject, CM uses the base lid in ARI 6078 */ 6079 if (reject_reason != IBT_CM_SUCCESS) { 6080 6081 switch (reject_reason) { 6082 6083 case IBT_CM_PRIM_GID : 6084 case IBT_CM_ALT_GID : 6085 ibcm_post_rej_mad(statep, 6086 reject_reason, IBT_CM_FAILURE_REQ, 6087 &gid, sizeof (ib_gid_t)); 6088 break; 6089 6090 case IBT_CM_PRIM_LID : 6091 case IBT_CM_ALT_LID : 6092 6093 lid = h2b16(port.hp_base_lid); 6094 ibcm_post_rej_mad(statep, 6095 reject_reason, IBT_CM_FAILURE_REQ, 6096 &lid, sizeof (ib_lid_t)); 6097 break; 6098 } 6099 6100 return (IBCM_FAILURE); 6101 } 6102 6103 /* Service, primary/alt gid and lid are all valid */ 6104 6105 return (IBCM_SUCCESS); 6106 } 6107 6108 /* 6109 * ibcm_cep_state_req: 6110 * QP state transition function called for an incoming REQ on passive side 6111 * LIDs and GIDs should be maintained and validated by the client handler 6112 * 6113 * INPUTS: 6114 * statep - state pointer 6115 * cm_req_msgp - REQ message pointer 6116 * reject_reason - Rejection reason See Section 12.6.7.2 rev1.0a IB Spec 6117 * arej_info_len - Additional Rejection reason info length 6118 * 6119 * RETURN VALUE: IBCM_SEND_REP/IBCM_SEND_REJ 6120 */ 6121 ibcm_status_t 6122 ibcm_cep_state_req(ibcm_state_data_t *statep, ibcm_req_msg_t *cm_req_msgp, 6123 ibt_cm_reason_t *reject_reason, uint8_t *arej_len) 6124 { 6125 void *priv_data = NULL; 6126 ibt_cm_event_t event; 6127 ibt_cm_status_t cb_status; 6128 ibcm_status_t status; 6129 ibt_cm_return_args_t ret_args; 6130 ibcm_clnt_reply_info_t clnt_info; 6131 6132 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_req: statep 0x%p", statep); 6133 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_req: SID 0x%lX", 6134 b2h64(cm_req_msgp->req_svc_id)); 6135 /* client handler should be valid */ 6136 ASSERT(statep->cm_handler != NULL); 6137 6138 bzero(&event, sizeof (event)); 6139 6140 /* Fill in ibt_cm_event_t */ 6141 event.cm_type = IBT_CM_EVENT_REQ_RCV; 6142 event.cm_session_id = statep; 6143 IBCM_EVT_REQ(event).req_service_id = b2h64(cm_req_msgp->req_svc_id); 6144 IBCM_EVT_REQ(event).req_transport = 6145 ((uint8_t *)&cm_req_msgp->req_remote_eecn_plus)[3] >> 1 & 0x3; 6146 IBCM_EVT_REQ(event).req_timeout = ibt_ib2usec( 6147 (((uint8_t *)&cm_req_msgp->req_remote_eecn_plus)[3] >> 3) & 0x1F); 6148 IBCM_EVT_REQ(event).req_retry_cnt = 6149 ((uint8_t *)&cm_req_msgp->req_starting_psn_plus)[3] & 0x7; 6150 IBCM_EVT_REQ(event).req_rnr_retry_cnt = cm_req_msgp->req_mtu_plus & 0x7; 6151 IBCM_EVT_REQ(event).req_pkey = b2h16(cm_req_msgp->req_part_key); 6152 IBCM_EVT_REQ(event).req_rdma_ra_in = 6153 ((uint8_t *)&cm_req_msgp->req_local_qpn_plus)[3]; 6154 IBCM_EVT_REQ(event).req_rdma_ra_out = 6155 ((uint8_t *)&cm_req_msgp->req_local_eec_no_plus)[3]; 6156 6157 /* Check for HCA limits for RDMA Resources */ 6158 if (IBCM_EVT_REQ(event).req_rdma_ra_in > 6159 statep->hcap->hca_max_rdma_in_qp) { 6160 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_state_req: statep 0x%p, REQ " 6161 "req_rdma_ra_in %d is greater than HCA Limit %d, resetting" 6162 "it to HCA limit", statep, 6163 IBCM_EVT_REQ(event).req_rdma_ra_in, 6164 statep->hcap->hca_max_rdma_in_qp); 6165 IBCM_EVT_REQ(event).req_rdma_ra_in = 6166 statep->hcap->hca_max_rdma_in_qp; 6167 } 6168 6169 if (IBCM_EVT_REQ(event).req_rdma_ra_out > 6170 statep->hcap->hca_max_rdma_out_qp) { 6171 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_state_req: statep 0x%p, REQ " 6172 "req_rdma_ra_out %d is greater than HCA Limit %d, resetting" 6173 "it to HCA limit", statep, 6174 IBCM_EVT_REQ(event).req_rdma_ra_out, 6175 statep->hcap->hca_max_rdma_out_qp); 6176 IBCM_EVT_REQ(event).req_rdma_ra_out = 6177 statep->hcap->hca_max_rdma_out_qp; 6178 } 6179 6180 /* Account for CM and other software delays */ 6181 if (IBCM_EVT_REQ(event).req_timeout > ibcm_sw_delay) { 6182 IBCM_EVT_REQ(event).req_timeout -= ibcm_sw_delay; 6183 IBTF_DPRINTF_L5(cmlog, "ibcm_cep_state_req: statep 0x%p" 6184 "Avail resp time %d (usec)", statep, 6185 IBCM_EVT_REQ(event).req_timeout); 6186 } else { 6187 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_state_req: statep 0x%p " 6188 "REQ rem_resp_time < local sw delay 0x%x", statep, 6189 IBCM_EVT_REQ(event).req_timeout); 6190 6191 IBCM_EVT_REQ(event).req_timeout = 0; 6192 } 6193 6194 IBCM_EVT_REQ(event).req_prim_hca_port = statep->prim_port; 6195 IBCM_EVT_REQ(event).req_alt_hca_port = statep->alt_port; 6196 IBCM_EVT_REQ(event).req_hca_guid = statep->local_hca_guid; 6197 IBCM_EVT_REQ(event).req_remote_qpn = statep->remote_qpn; 6198 6199 if (((uint8_t *)&cm_req_msgp->req_remote_eecn_plus)[3] & 6200 IBT_CM_FLOW_CONTROL) 6201 IBCM_EVT_REQ(event).req_flags |= IBT_CM_FLOW_CONTROL; 6202 6203 if ((cm_req_msgp->req_max_cm_retries_plus >> 3) & 0x1) 6204 IBCM_EVT_REQ(event).req_flags |= IBT_CM_SRQ_EXISTS; 6205 6206 /* Initialize req.req_prim_addr */ 6207 ibcm_set_primary_adds_vect(statep, &IBCM_EVT_REQ(event).req_prim_addr, 6208 cm_req_msgp); 6209 6210 /* Initialize req.req_alternate_path if they exist */ 6211 if (b2h16(cm_req_msgp->req_alt_l_port_lid) != 0) { 6212 ibcm_set_alt_adds_vect(statep, 6213 &IBCM_EVT_REQ(event).req_alt_addr, cm_req_msgp); 6214 6215 /* Verify, alt path is not same as primary */ 6216 if (ibcm_compare_prim_alt_paths( 6217 &event.cm_event.req.req_prim_addr, 6218 &event.cm_event.req.req_alt_addr) == B_TRUE) { 6219 /* XXX New REJ code needed */ 6220 *reject_reason = IBT_CM_NO_RESC; 6221 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_state_req: statep 0x%p" 6222 " Alt and prim paths are same", statep); 6223 mutex_enter(&ibcm_svc_info_lock); 6224 IBCM_SVC_DECR(statep->state_svc_infop); 6225 mutex_exit(&ibcm_svc_info_lock); 6226 return (IBCM_SEND_REJ); 6227 } 6228 } 6229 6230 #ifdef NO_EEC_SUPPORT_YET 6231 IBCM_EVT_REQ(event).req_rdc_exists = cm_req_msgp->req_mtu_plus >> 3 & 1; 6232 IBCM_EVT_REQ(event).req_remote_eecn = 6233 b2h32(cm_req_msgp->req_remote_eecn_plus) >> 8; 6234 IBCM_EVT_REQ(event).req_local_eecn = 6235 b2h32(cm_req_msgp->req_local_eec_no_plus) >> 8; 6236 IBCM_EVT_REQ(event).req_remote_qkey = 6237 b2h32(cm_req_msgp->req_local_qkey); 6238 #endif 6239 6240 /* cm_req_msgp->req_private_data to event.cm_event.cm_priv_data */ 6241 event.cm_priv_data = cm_req_msgp->req_private_data; 6242 6243 event.cm_priv_data_len = IBT_REQ_PRIV_DATA_SZ; 6244 6245 /* 6246 * Allocate priv_data of size IBT_MAX_PRIV_DATA_SZ 6247 */ 6248 priv_data = kmem_zalloc(IBT_MAX_PRIV_DATA_SZ, KM_SLEEP); 6249 6250 bzero(&ret_args, sizeof (ret_args)); 6251 6252 /* Fill in the default values from REQ, that client can modify */ 6253 ret_args.cm_ret.rep.cm_rdma_ra_in = IBCM_EVT_REQ(event).req_rdma_ra_out; 6254 ret_args.cm_ret.rep.cm_rdma_ra_out = IBCM_EVT_REQ(event).req_rdma_ra_in; 6255 ret_args.cm_ret.rep.cm_rnr_retry_cnt = cm_req_msgp->req_mtu_plus & 0x7; 6256 6257 ibcm_insert_trace(statep, IBCM_TRACE_CALLED_REQ_RCVD_EVENT); 6258 6259 /* Invoke the client handler */ 6260 statep->req_msgp = cm_req_msgp; 6261 cb_status = statep->cm_handler(statep->state_cm_private, &event, 6262 &ret_args, priv_data, IBT_REP_PRIV_DATA_SZ); 6263 statep->req_msgp = NULL; 6264 6265 ibcm_insert_trace(statep, IBCM_TRACE_RET_REQ_RCVD_EVENT); 6266 6267 mutex_enter(&ibcm_svc_info_lock); 6268 IBCM_SVC_DECR(statep->state_svc_infop); 6269 mutex_exit(&ibcm_svc_info_lock); 6270 6271 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_req: Client handler returned %d" 6272 " statep 0x%p", cb_status, statep); 6273 6274 if (cb_status == IBT_CM_DEFER) { 6275 6276 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(statep->defer_cm_msg)) 6277 6278 if (statep->defer_cm_msg == NULL) 6279 statep->defer_cm_msg = 6280 kmem_zalloc(IBCM_MSG_SIZE, KM_SLEEP); 6281 bcopy(cm_req_msgp, statep->defer_cm_msg, IBCM_MSG_SIZE); 6282 6283 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(statep->defer_cm_msg)) 6284 6285 /* 6286 * unblock any blocked cm proceed api calls. Do not access 6287 * statep after cv_signal 6288 */ 6289 mutex_enter(&statep->state_mutex); 6290 statep->clnt_proceed = IBCM_UNBLOCK; 6291 cv_broadcast(&statep->block_client_cv); 6292 mutex_exit(&statep->state_mutex); 6293 6294 kmem_free(priv_data, IBT_MAX_PRIV_DATA_SZ); 6295 return (IBCM_DEFER); 6296 } 6297 6298 /* fail any blocked cm proceed api call - client bug */ 6299 mutex_enter(&statep->state_mutex); 6300 statep->clnt_proceed = IBCM_FAIL; 6301 cv_broadcast(&statep->block_client_cv); 6302 mutex_exit(&statep->state_mutex); 6303 6304 clnt_info.reply_event = (ibt_cm_proceed_reply_t *)&ret_args.cm_ret; 6305 clnt_info.priv_data = priv_data; 6306 clnt_info.priv_data_len = ret_args.cm_ret_len; 6307 6308 status = 6309 ibcm_process_cep_req_cm_hdlr(statep, cb_status, 6310 &clnt_info, reject_reason, arej_len, cm_req_msgp); 6311 kmem_free(priv_data, IBT_MAX_PRIV_DATA_SZ); 6312 return (status); 6313 } 6314 6315 /* 6316 * ibcm_process_cep_req_cm_hdlr: 6317 * Processes the response from client handler for an incoming REQ. 6318 */ 6319 ibcm_status_t 6320 ibcm_process_cep_req_cm_hdlr(ibcm_state_data_t *statep, 6321 ibt_cm_status_t cb_status, ibcm_clnt_reply_info_t *clnt_info, 6322 ibt_cm_reason_t *reject_reason, uint8_t *arej_len, 6323 ibcm_req_msg_t *cm_req_msg) 6324 { 6325 ibt_status_t status; 6326 ibt_qp_query_attr_t qp_attrs; 6327 ibcm_state_data_t *old_statep; 6328 ibt_channel_hdl_t channel; 6329 ib_guid_t local_ca_guid; 6330 ibcm_rej_msg_t *rej_msgp; 6331 #ifdef NO_EEC_SUPPORT_YET 6332 ibt_eec_query_attr_t eec_attrs; 6333 #endif 6334 6335 if (cb_status == IBT_CM_DEFAULT) 6336 cb_status = IBT_CM_REJECT; 6337 6338 /* verify status */ 6339 if (cb_status == IBT_CM_ACCEPT) { 6340 *reject_reason = IBT_CM_SUCCESS; 6341 } else if (cb_status == IBT_CM_REJECT) { 6342 *reject_reason = IBT_CM_CONSUMER; 6343 } else if (cb_status == IBT_CM_REDIRECT_PORT) { 6344 *reject_reason = IBT_CM_PORT_REDIRECT; 6345 } else if (cb_status == IBT_CM_REDIRECT) { 6346 *reject_reason = IBT_CM_REDIRECT_CM; 6347 } else if (cb_status == IBT_CM_NO_CHANNEL) { 6348 *reject_reason = IBT_CM_NO_CHAN; 6349 } else if (cb_status == IBT_CM_NO_RESOURCE) { 6350 *reject_reason = IBT_CM_NO_RESC; 6351 } else { 6352 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_req_cm_hdlr: statep %p" 6353 " Client handler unexpected return %x", statep, cb_status); 6354 *reject_reason = IBT_CM_CONSUMER; 6355 } 6356 6357 /* client handler gave CM ok */ 6358 if (cb_status == IBT_CM_ACCEPT) { 6359 ibcm_rep_msg_t *rep_msgp = (ibcm_rep_msg_t *) 6360 IBCM_OUT_MSGP(statep->stored_msg); 6361 6362 6363 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 6364 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rep_msgp)) 6365 6366 /* 6367 * Check first if ret_args make sense. If not, bailout 6368 * here rather than going along and panicing later. 6369 */ 6370 channel = clnt_info->reply_event->rep.cm_channel; 6371 if (IBCM_INVALID_CHANNEL(channel)) { 6372 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6373 "statep 0x%p server's QP handle is NULL", statep); 6374 *reject_reason = IBT_CM_NO_CHAN; 6375 } 6376 6377 IBCM_GET_CHAN_PRIVATE(channel, old_statep); 6378 6379 if ((*reject_reason == IBT_CM_SUCCESS) && 6380 (old_statep != NULL)) { 6381 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6382 "statep 0x%p Channel being re-used on passive side", 6383 statep); 6384 *reject_reason = IBT_CM_NO_CHAN; 6385 } 6386 if (old_statep != NULL) 6387 IBCM_RELEASE_CHAN_PRIVATE(channel); 6388 6389 if (*reject_reason != IBT_CM_SUCCESS) { 6390 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6391 IBT_CM_FAILURE_REQ, *reject_reason, NULL, 0); 6392 return (IBCM_SEND_REJ); 6393 } 6394 6395 statep->channel = channel; 6396 status = ibt_query_qp(channel, &qp_attrs); 6397 6398 if (status != IBT_SUCCESS) { 6399 IBTF_DPRINTF_L3(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6400 "statep %p ibt_query_qp failed %d", statep, status); 6401 *reject_reason = IBT_CM_NO_RESC; 6402 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6403 IBT_CM_FAILURE_REQ, IBT_CM_CI_FAILURE, NULL, 0); 6404 return (IBCM_SEND_REJ); 6405 } 6406 6407 if (qp_attrs.qp_info.qp_trans != IBT_RC_SRV) { 6408 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6409 "statep %p qp is not RC channel on server", statep); 6410 *reject_reason = IBT_CM_INVALID_SRV_TYPE; 6411 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6412 IBT_CM_FAILURE_REQ, IBT_CM_CHAN_INVALID_STATE, 6413 NULL, 0); 6414 return (IBCM_SEND_REJ); 6415 } 6416 6417 if (qp_attrs.qp_info.qp_state != IBT_STATE_INIT && 6418 statep->is_this_ofuv_chan == B_FALSE) { 6419 IBTF_DPRINTF_L3(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6420 "qp state != INIT on server"); 6421 *reject_reason = IBT_CM_CHAN_INVALID_STATE; 6422 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6423 IBT_CM_FAILURE_REQ, IBT_CM_CHAN_INVALID_STATE, 6424 NULL, 0); 6425 return (IBCM_SEND_REJ); 6426 } else if (statep->is_this_ofuv_chan && 6427 qp_attrs.qp_info.qp_state != IBT_STATE_RTR && 6428 qp_attrs.qp_info.qp_state != IBT_STATE_INIT) { 6429 IBTF_DPRINTF_L3(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6430 "qp state != INIT or RTR on server"); 6431 *reject_reason = IBT_CM_CHAN_INVALID_STATE; 6432 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6433 IBT_CM_FAILURE_REQ, IBT_CM_CHAN_INVALID_STATE, 6434 NULL, 0); 6435 return (IBCM_SEND_REJ); 6436 } 6437 6438 if (statep->is_this_ofuv_chan && 6439 qp_attrs.qp_info.qp_state == IBT_STATE_RTR && 6440 qp_attrs.qp_info.qp_transport.rc.rc_path.cep_hca_port_num != 6441 statep->prim_port) { 6442 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6443 "QP port invalid"); 6444 *reject_reason = IBT_CM_CHAN_INVALID_STATE; 6445 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6446 IBT_CM_FAILURE_REQ, IBT_CM_CHAN_INVALID_STATE, 6447 NULL, 0); 6448 return (IBCM_SEND_REJ); 6449 } else if (statep->is_this_ofuv_chan && 6450 qp_attrs.qp_info.qp_state == IBT_STATE_RTR) { 6451 goto skip_init_trans; 6452 } 6453 6454 /* Init to Init, if required */ 6455 if (qp_attrs.qp_info.qp_transport.rc.rc_path.cep_hca_port_num != 6456 statep->prim_port) { 6457 6458 ibt_qp_info_t qp_info; 6459 ibt_cep_modify_flags_t cep_flags; 6460 6461 IBTF_DPRINTF_L5(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6462 "chan 0x%p chan port %d", channel, 6463 qp_attrs.qp_info.qp_transport.rc.rc_path.\ 6464 cep_hca_port_num); 6465 6466 IBTF_DPRINTF_L5(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6467 "chan 0x%p d path port %d", channel, 6468 statep->prim_port); 6469 6470 bzero(&qp_info, sizeof (qp_info)); 6471 qp_info.qp_trans = IBT_RC_SRV; 6472 qp_info.qp_state = IBT_STATE_INIT; 6473 qp_info.qp_transport.rc.rc_path.cep_hca_port_num = 6474 statep->prim_port; 6475 6476 cep_flags = IBT_CEP_SET_STATE | IBT_CEP_SET_PORT; 6477 6478 status = ibt_modify_qp(statep->channel, cep_flags, 6479 &qp_info, NULL); 6480 6481 if (status != IBT_SUCCESS) { 6482 IBTF_DPRINTF_L2(cmlog, 6483 "ibcm_process_cep_req_cm_hdlr: " 6484 "chan 0x%p ibt_modify_qp() = %d", channel, 6485 status); 6486 *reject_reason = IBT_CM_NO_RESC; 6487 6488 ibcm_insert_trace(statep, 6489 IBCM_TRACE_INIT_INIT_FAIL); 6490 6491 ibcm_handler_conn_fail(statep, 6492 IBT_CM_FAILURE_REJ_SENT, IBT_CM_FAILURE_REQ, 6493 IBT_CM_CI_FAILURE, NULL, 0); 6494 return (IBCM_SEND_REJ); 6495 } else { 6496 ibcm_insert_trace(statep, 6497 IBCM_TRACE_INIT_INIT); 6498 6499 IBTF_DPRINTF_L5(cmlog, 6500 "ibcm_process_cep_req_cm_hdlr: " 6501 "chan 0x%p ibt_modify_qp() = %d", channel, 6502 status); 6503 } 6504 } 6505 skip_init_trans: 6506 /* Do sanity tests even if we are skipping RTR */ 6507 6508 /* fill in the REP msg based on ret_args from client */ 6509 if (clnt_info->reply_event->rep.cm_rdma_ra_out > 6510 ((uint8_t *)&cm_req_msg->req_local_qpn_plus)[3]) { 6511 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_cm_hdlr " 6512 "statep 0x%p ERROR: InitiatorDepth(%d) is Greater " 6513 "than ResponderResource(%d)", statep, 6514 clnt_info->reply_event->rep.cm_rdma_ra_out, 6515 ((uint8_t *)&cm_req_msg->req_local_qpn_plus)[3]); 6516 *reject_reason = IBT_CM_NOT_SUPPORTED; 6517 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6518 IBT_CM_FAILURE_REQ, IBT_CM_NOT_SUPPORTED, NULL, 0); 6519 return (IBCM_SEND_REJ); 6520 } 6521 6522 /* Check for HCA limits for RDMA Resources */ 6523 if (clnt_info->reply_event->rep.cm_rdma_ra_in > 6524 statep->hcap->hca_max_rdma_in_qp) { 6525 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_cm_hdlr: " 6526 "statep %p, ERROR: client specified rdma_ra_in %d " 6527 "is greater than HCA Limit %d, rejecting MAD", 6528 statep, clnt_info->reply_event->rep.cm_rdma_ra_in, 6529 statep->hcap->hca_max_rdma_in_qp); 6530 *reject_reason = IBT_CM_NOT_SUPPORTED; 6531 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6532 IBT_CM_FAILURE_REQ, IBT_CM_NOT_SUPPORTED, NULL, 0); 6533 return (IBCM_SEND_REJ); 6534 } 6535 6536 if (clnt_info->reply_event->rep.cm_rdma_ra_out > 6537 statep->hcap->hca_max_rdma_out_qp) { 6538 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_cm_hdlr: " 6539 "statep %p, ERROR: client specified rdma_ra_out %d " 6540 "is greater than HCA Limit %d, rejecting MAD", 6541 statep, clnt_info->reply_event->rep.cm_rdma_ra_out, 6542 statep->hcap->hca_max_rdma_out_qp); 6543 *reject_reason = IBT_CM_NOT_SUPPORTED; 6544 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6545 IBT_CM_FAILURE_REQ, IBT_CM_NOT_SUPPORTED, NULL, 0); 6546 return (IBCM_SEND_REJ); 6547 } 6548 6549 rep_msgp->rep_resp_resources = 6550 clnt_info->reply_event->rep.cm_rdma_ra_in; 6551 rep_msgp->rep_initiator_depth = 6552 clnt_info->reply_event->rep.cm_rdma_ra_out; 6553 6554 /* IBT_CM_FLOW_CONTROL is always set by default. */ 6555 rep_msgp->rep_target_delay_plus |= IBT_CM_FLOW_CONTROL; 6556 6557 rep_msgp->rep_rnr_retry_cnt_plus = 6558 (clnt_info->reply_event->rep.cm_rnr_retry_cnt & 0x7) << 5; 6559 6560 /* 6561 * Check out whether SRQ is associated with this channel. 6562 * If yes, then set the appropriate bit. 6563 */ 6564 if (qp_attrs.qp_srq != NULL) { 6565 rep_msgp->rep_rnr_retry_cnt_plus |= (1 << 4); 6566 } 6567 6568 local_ca_guid = h2b64(statep->local_hca_guid); 6569 bcopy(&local_ca_guid, rep_msgp->rep_local_ca_guid, 6570 sizeof (ib_guid_t)); 6571 6572 if (statep->is_this_ofuv_chan && 6573 qp_attrs.qp_info.qp_state == IBT_STATE_RTR) 6574 goto skip_rtr_trans; 6575 6576 /* Transition QP from Init to RTR state */ 6577 if (ibcm_invoke_qp_modify(statep, cm_req_msg, rep_msgp) != 6578 IBT_SUCCESS) { 6579 6580 IBTF_DPRINTF_L2(cmlog, "ibcm_process_req_cm_hdlr " 6581 "statep 0x%p ibcm_invoke_qp_modify failed because " 6582 "of invalid data", statep); 6583 *reject_reason = IBT_CM_NO_RESC; 6584 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6585 IBT_CM_FAILURE_REQ, IBT_CM_CI_FAILURE, NULL, 0); 6586 return (IBCM_SEND_REJ); 6587 } 6588 skip_rtr_trans: 6589 6590 /* 6591 * Link statep and channel, once CM determines it is 6592 * post REP definitely. 6593 */ 6594 IBCM_SET_CHAN_PRIVATE(statep->channel, statep); 6595 6596 /* 6597 * Fill up the REP fields from ret_args 6598 * failover status, from ret_args 6599 * 6600 * Fill up local QPN and EECN from ret_args->channel 6601 */ 6602 6603 /* fill in REP msg bytes Qkey, Starting PSN, 12-15, and 16-19 */ 6604 IBTF_DPRINTF_L4(cmlog, "ibcm_process_cep_req_cm_hdlr: " 6605 "qp_info.qp_state = %x", qp_attrs.qp_info.qp_state); 6606 6607 rep_msgp->rep_local_qpn_plus = h2b32(qp_attrs.qp_qpn << 8); 6608 6609 statep->local_qpn = qp_attrs.qp_qpn; 6610 6611 switch (qp_attrs.qp_info.qp_trans) { 6612 case IBT_RD_SRV: 6613 rep_msgp->rep_local_qkey = h2b32( 6614 qp_attrs.qp_info.qp_transport.rd.rd_qkey); 6615 break; 6616 case IBT_RC_SRV: 6617 rep_msgp->rep_starting_psn_plus = 6618 h2b32(IBCM_QP_RC(qp_attrs).rc_rq_psn << 8); 6619 break; 6620 case IBT_UC_SRV: 6621 rep_msgp->rep_starting_psn_plus = 6622 h2b32(IBCM_QP_UC(qp_attrs).uc_sq_psn << 8); 6623 break; 6624 } 6625 6626 #ifdef NO_EEC_SUPPORT_YET 6627 if (ret_args.cm_channel.ch_eec != NULL) { 6628 status = ibt_query_eec(ret_args.cm_channel.ch_eec, 6629 &eec_attrs); 6630 if (status == IBT_SUCCESS) { 6631 rep_msgp->rep_local_eecn_plus = 6632 h2b32(((uint32_t)eec_attrs.eec_eecn << 8)); 6633 } 6634 } 6635 #endif 6636 6637 /* figure out Target ACK delay */ 6638 rep_msgp->rep_target_delay_plus |= (status == IBT_SUCCESS) ? 6639 statep->hcap->hca_ack_delay << 3 : 0; 6640 6641 IBTF_DPRINTF_L4(cmlog, "ibcm_process_cep_req_cm_hdlr:statep %p " 6642 "REP priv len %x", statep, clnt_info->priv_data_len); 6643 /* Copy PrivateData from priv_data */ 6644 if (clnt_info->priv_data_len != 0) { 6645 bcopy(clnt_info->priv_data, rep_msgp->rep_private_data, 6646 min(IBT_REP_PRIV_DATA_SZ, 6647 clnt_info->priv_data_len)); 6648 } 6649 6650 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*statep)) 6651 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rep_msgp)) 6652 6653 return (IBCM_SEND_REP); 6654 } 6655 6656 /* REJ message */ 6657 rej_msgp = (ibcm_rej_msg_t *)IBCM_OUT_MSGP(statep->stored_msg); 6658 6659 IBTF_DPRINTF_L4(cmlog, "ibcm_process_cep_req_cm_hdlr: statep %p REJ " 6660 "priv len %x", statep, clnt_info->priv_data_len); 6661 6662 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rej_msgp)) 6663 6664 /* if priv_data_len != 0 use priv_data to copy back to rej_priv_data */ 6665 if (clnt_info->priv_data_len != 0) { 6666 bcopy(clnt_info->priv_data, rej_msgp->rej_private_data, 6667 min(IBT_REJ_PRIV_DATA_SZ, clnt_info->priv_data_len)); 6668 } 6669 6670 if (cb_status == IBT_CM_REDIRECT_PORT) { 6671 ib_gid_t tgid; 6672 6673 tgid.gid_guid = 6674 h2b64(clnt_info->reply_event->rej.ari_gid.gid_guid); 6675 tgid.gid_prefix = 6676 h2b64(clnt_info->reply_event->rej.ari_gid.gid_prefix); 6677 6678 *arej_len = sizeof (ib_gid_t); 6679 bcopy(&tgid, &rej_msgp->rej_addl_rej_info, sizeof (ib_gid_t)); 6680 6681 IBTF_DPRINTF_L3(cmlog, "ibcm_process_cep_req_cm_hdlr: ari_gid= " 6682 "%llX:%llX", tgid.gid_prefix, tgid.gid_guid); 6683 6684 } else if (cb_status == IBT_CM_REDIRECT) { 6685 ibcm_classportinfo_msg_t tclp; 6686 6687 ibcm_init_clp_to_mad(&tclp, 6688 &clnt_info->reply_event->rej.ari_redirect); 6689 bcopy(&tclp, rej_msgp->rej_addl_rej_info, sizeof (tclp)); 6690 6691 *arej_len = sizeof (ibcm_classportinfo_msg_t); 6692 6693 } else if (cb_status == IBT_CM_REJECT) { 6694 6695 /* Fill up the REJ fields, from ret_args */ 6696 *arej_len = min( 6697 clnt_info->reply_event->rej.ari_consumer.rej_ari_len, 6698 IBT_CM_ADDL_REJ_LEN); 6699 bcopy(clnt_info->reply_event->rej.ari_consumer.rej_ari, 6700 &rej_msgp->rej_addl_rej_info, *arej_len); 6701 6702 /* 6703 * RDMA IP REQ was passed up to the ULP, the ULP decided to do 6704 * a "normal" consumer REJ, by the returning IBT_CM_REJECT in 6705 * the cm handler. 6706 * CM has to do some extra stuff too, it has to 6707 * a) return REJ code 28 (consumer) and b) put 0x1 in the first 6708 * byte of the ARI data, to indicate that this is a RDMA aware 6709 * ULP that is doing a consumer reject. The ULP should have 6710 * put its consumer specific data into ibt_arej_info_t(9s) at 6711 * byte 1 of the rej_ari[] array. 6712 */ 6713 if (((statep->svcid & IB_SID_IPADDR_PREFIX_MASK) == 0) && 6714 (statep->svcid & IB_SID_IPADDR_PREFIX)) { 6715 rej_msgp->rej_addl_rej_info[0] = 1; 6716 } 6717 } 6718 6719 rej_msgp->rej_msg_type_plus = IBT_CM_FAILURE_REQ << 6; 6720 6721 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rej_msgp)) 6722 6723 return (IBCM_SEND_REJ); 6724 } 6725 6726 /* 6727 * ibcm_cep_state_rep: 6728 * QP state transition function called for an incoming REP on active side 6729 * 6730 * INPUTS: 6731 * statep - state pointer 6732 * cm_rep_msg - REP message pointer 6733 * reject_reason - Rejection reason See Section 12.6.7.2 rev1.0a IB Spec 6734 * 6735 * RETURN VALUE: 6736 */ 6737 ibcm_status_t 6738 ibcm_cep_state_rep(ibcm_state_data_t *statep, ibcm_rep_msg_t *cm_rep_msgp, 6739 ibt_cm_reason_t *reject_reason, uint8_t *arej_len) 6740 { 6741 void *priv_data = NULL; 6742 ibcm_status_t rval = IBCM_SEND_RTU; 6743 ibt_cm_event_t event; 6744 ibt_cm_status_t cb_status = IBT_CM_ACCEPT; 6745 ibt_cm_return_args_t ret_args; 6746 ibcm_clnt_reply_info_t clnt_info; 6747 uint8_t req_init_depth; 6748 6749 IBTF_DPRINTF_L3(cmlog, "ibcm_cep_state_rep: statep 0x%p", statep); 6750 6751 /* Check first if client handler is valid */ 6752 if (statep->cm_handler != NULL) { 6753 /* initialize fields in ibt_cm_event_t */ 6754 bzero(&event, sizeof (event)); 6755 event.cm_type = IBT_CM_EVENT_REP_RCV; 6756 event.cm_channel = statep->channel; 6757 event.cm_session_id = statep; 6758 6759 IBCM_EVT_REP(event).rep_rdma_ra_in = 6760 cm_rep_msgp->rep_initiator_depth; 6761 req_init_depth = 6762 ((uint8_t *)&(((ibcm_req_msg_t *)IBCM_OUT_MSGP( 6763 statep->stored_msg))->req_local_eec_no_plus))[3]; 6764 IBCM_EVT_REP(event).rep_rdma_ra_out = 6765 min(cm_rep_msgp->rep_resp_resources, req_init_depth); 6766 6767 IBTF_DPRINTF_L3(cmlog, "ibcm_cep_state_rep: statep 0x%p, " 6768 "InitDepth %d, RespResr %d", statep, 6769 cm_rep_msgp->rep_initiator_depth, 6770 IBCM_EVT_REP(event).rep_rdma_ra_out); 6771 6772 IBCM_EVT_REP(event).rep_service_time = ibt_ib2usec( 6773 ((uint8_t *)&(((ibcm_req_msg_t *)IBCM_OUT_MSGP( 6774 statep->stored_msg))->req_starting_psn_plus))[3] >> 3); 6775 6776 IBCM_EVT_REP(event).rep_service_time -= 6777 2 * statep->pkt_life_time - ibcm_sw_delay; 6778 6779 IBCM_EVT_REP(event).rep_failover_status = 6780 cm_rep_msgp->rep_target_delay_plus >> 1 & 3; 6781 6782 if (cm_rep_msgp->rep_target_delay_plus & 0x1) 6783 IBCM_EVT_REP(event).rep_flags |= IBT_CM_FLOW_CONTROL; 6784 6785 if ((cm_rep_msgp->rep_rnr_retry_cnt_plus >> 4) & 0x1) 6786 IBCM_EVT_REP(event).rep_flags |= IBT_CM_SRQ_EXISTS; 6787 6788 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_rep: statep 0x%p " 6789 "rep_service_time %d", statep, 6790 IBCM_EVT_REP(event).rep_service_time); 6791 6792 event.cm_priv_data = &(cm_rep_msgp->rep_private_data[0]); 6793 event.cm_priv_data_len = IBT_REP_PRIV_DATA_SZ; 6794 6795 /* 6796 * Allocate priv_data of size IBT_MAX_PRIV_DATA_SZ 6797 */ 6798 priv_data = kmem_zalloc(IBT_MAX_PRIV_DATA_SZ, KM_SLEEP); 6799 bzero(&ret_args, sizeof (ret_args)); 6800 6801 6802 ibcm_insert_trace(statep, IBCM_TRACE_CALLED_REP_RCVD_EVENT); 6803 6804 /* invoke the CM handler */ 6805 cb_status = statep->cm_handler(statep->state_cm_private, &event, 6806 &ret_args, priv_data, IBT_RTU_PRIV_DATA_SZ); 6807 6808 ibcm_insert_trace(statep, IBCM_TRACE_RET_REP_RCVD_EVENT); 6809 6810 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_rep: statep 0x%p " 6811 "Client handler returned %x", statep, cb_status); 6812 6813 if (cb_status == IBT_CM_DEFER) { 6814 if (statep->defer_cm_msg == NULL) 6815 statep->defer_cm_msg = 6816 kmem_zalloc(IBCM_MSG_SIZE, KM_SLEEP); 6817 bcopy(cm_rep_msgp, statep->defer_cm_msg, IBCM_MSG_SIZE); 6818 6819 /* unblock any blocked cm proceed api calls */ 6820 mutex_enter(&statep->state_mutex); 6821 statep->clnt_proceed = IBCM_UNBLOCK; 6822 cv_broadcast(&statep->block_client_cv); 6823 mutex_exit(&statep->state_mutex); 6824 6825 kmem_free(priv_data, IBT_MAX_PRIV_DATA_SZ); 6826 return (IBCM_DEFER); 6827 } 6828 } 6829 6830 /* fail any blocked cm proceed api calls - client bug */ 6831 mutex_enter(&statep->state_mutex); 6832 statep->clnt_proceed = IBCM_FAIL; 6833 cv_broadcast(&statep->block_client_cv); 6834 mutex_exit(&statep->state_mutex); 6835 6836 clnt_info.reply_event = (ibt_cm_proceed_reply_t *)&ret_args.cm_ret; 6837 clnt_info.priv_data = priv_data; 6838 clnt_info.priv_data_len = ret_args.cm_ret_len; 6839 6840 rval = 6841 ibcm_process_cep_rep_cm_hdlr(statep, cb_status, &clnt_info, 6842 reject_reason, arej_len, cm_rep_msgp); 6843 6844 if (priv_data != NULL) 6845 kmem_free(priv_data, IBT_MAX_PRIV_DATA_SZ); 6846 return (rval); 6847 } 6848 6849 6850 /* 6851 * ibcm_process_cep_rep_cm_hdlr: 6852 * Processes the response from client handler for an incoming REP. 6853 */ 6854 ibcm_status_t 6855 ibcm_process_cep_rep_cm_hdlr(ibcm_state_data_t *statep, 6856 ibt_cm_status_t cb_status, ibcm_clnt_reply_info_t *clnt_info, 6857 ibt_cm_reason_t *reject_reason, uint8_t *arej_len, 6858 ibcm_rep_msg_t *cm_rep_msgp) 6859 { 6860 ibcm_status_t rval = IBCM_SEND_RTU; 6861 ibcm_rej_msg_t *rej_msgp; 6862 6863 if (cb_status == IBT_CM_DEFAULT) 6864 cb_status = IBT_CM_ACCEPT; 6865 6866 if (cb_status == IBT_CM_REJECT) { 6867 *reject_reason = IBT_CM_CONSUMER; 6868 } else if (cb_status == IBT_CM_REDIRECT_PORT) { 6869 *reject_reason = IBT_CM_PORT_REDIRECT; 6870 } else if (cb_status == IBT_CM_REDIRECT) { 6871 *reject_reason = IBT_CM_REDIRECT_CM; 6872 } else if (cb_status == IBT_CM_NO_RESOURCE) { 6873 *reject_reason = IBT_CM_NO_RESC; 6874 } else if (cb_status != IBT_CM_ACCEPT) { 6875 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_rep_cm_hdlr: statep " 6876 "0x%p, Client handler returned unexpected value %d", 6877 statep, cb_status); 6878 *reject_reason = IBT_CM_CONSUMER; 6879 } else 6880 *reject_reason = IBT_CM_SUCCESS; 6881 6882 6883 /* We come here if status is ACCEPT or CM handler is NULL */ 6884 if (cb_status == IBT_CM_ACCEPT) { 6885 ib_time_t time; 6886 6887 time = ibt_usec2ib(statep->pkt_life_time * 2 + 6888 ibt_ib2usec(cm_rep_msgp->rep_target_delay_plus >> 3)); 6889 6890 IBTF_DPRINTF_L5(cmlog, "ibcm_process_cep_rep_cm_hdlr: statep %p" 6891 " active cep_timeout(usec) 0x%x ", statep, time); 6892 6893 IBTF_DPRINTF_L4(cmlog, "ibcm_process_cep_rep_cm_hdlr: statep %p" 6894 " passive hca_ack_delay(ib_time) = 0x%x, ", statep, 6895 cm_rep_msgp->rep_target_delay_plus >> 3); 6896 6897 IBTF_DPRINTF_L5(cmlog, "ibcm_process_cep_rep_cm_hdlr: statep %p" 6898 " rnr_retry_cnt = 0x%x", statep, 6899 cm_rep_msgp->rep_rnr_retry_cnt_plus >> 5); 6900 6901 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 6902 statep->starting_psn = 6903 b2h32(cm_rep_msgp->rep_starting_psn_plus) >> 8; 6904 6905 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*statep)) 6906 6907 /* Call IBTL CM's qp modify function from Init to RTR */ 6908 if (ibcm_invoke_qp_modify(statep, 6909 (ibcm_req_msg_t *)IBCM_OUT_MSGP(statep->stored_msg), 6910 cm_rep_msgp) != IBT_SUCCESS) { 6911 6912 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_rep_cm_hdlr: " 6913 "statep %p, ibcm_invoke_qp_modify to RTR failed", 6914 statep); 6915 *reject_reason = IBT_CM_NO_RESC; 6916 /* 6917 * Call modify qp function from RTR to RTS 6918 * RDMA initiator depth on active is same as negotiated 6919 * passive REP's responder resources 6920 */ 6921 } else if (ibcm_invoke_rtu_qp_modify(statep, time, cm_rep_msgp) 6922 != IBT_SUCCESS) { 6923 6924 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_rep_cm_hdlr: " 6925 "statep %p ibcm_invoke_rtu_qp_modify to RTS failed", 6926 statep); 6927 (void) ibcm_cep_to_error_state(statep); 6928 *reject_reason = IBT_CM_NO_RESC; 6929 } 6930 6931 if (*reject_reason == IBT_CM_NO_RESC) { 6932 6933 /* Disassociate statep and QP */ 6934 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 6935 6936 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6937 IBT_CM_FAILURE_REP, IBT_CM_CI_FAILURE, NULL, 0); 6938 return (IBCM_SEND_REJ); /* send REJ */ 6939 } 6940 6941 if (clnt_info->priv_data_len != 0) { 6942 ibcm_rtu_msg_t *rtu_msgp; 6943 rtu_msgp = (ibcm_rtu_msg_t *) 6944 IBCM_OUT_MSGP(statep->stored_msg); 6945 bcopy(clnt_info->priv_data, rtu_msgp->rtu_private_data, 6946 min(IBT_RTU_PRIV_DATA_SZ, 6947 clnt_info->priv_data_len)); 6948 } 6949 6950 *reject_reason = IBT_CM_SUCCESS; 6951 return (rval); 6952 } 6953 6954 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*rej_msgp)) 6955 6956 /* Fill up the REJ fields, from ret_args */ 6957 rej_msgp = (ibcm_rej_msg_t *)IBCM_OUT_MSGP(statep->stored_msg); 6958 rej_msgp->rej_msg_type_plus = IBT_CM_FAILURE_REP << 6; 6959 6960 /* if priv_len != 0 use priv_data to copy back to rej_priv_data */ 6961 if (clnt_info->priv_data_len != 0) 6962 bcopy(clnt_info->priv_data, rej_msgp->rej_private_data, 6963 min(IBT_REJ_PRIV_DATA_SZ, clnt_info->priv_data_len)); 6964 6965 if (clnt_info->reply_event != NULL) 6966 *arej_len = 6967 min(clnt_info->reply_event->rej.ari_consumer.rej_ari_len, 6968 IBT_CM_ADDL_REJ_LEN); 6969 6970 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(clnt_info->reply_event->rej)) 6971 6972 if (*arej_len != 0) /* asserts that clnt_info->reply_event != 0 */ 6973 bcopy(clnt_info->reply_event->rej.ari_consumer.rej_ari, 6974 &rej_msgp->rej_addl_rej_info, *arej_len); 6975 6976 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(clnt_info->reply_event->rej)) 6977 6978 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*rej_msgp)) 6979 6980 rval = IBCM_SEND_REJ; 6981 6982 /* Disassociate statep and QP */ 6983 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 6984 6985 /* callback client, to enable client to do resource cleanup */ 6986 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 6987 IBT_CM_FAILURE_REP, *reject_reason, NULL, 0); 6988 6989 return (rval); 6990 } 6991 6992 /* 6993 * ibcm_invoke_rtu_qp_modify: 6994 * Helper function to modify QP for RTU only called from 6995 * ibcm_cep_state_rtu() and ibcm_cep_send_rtu() 6996 * 6997 * INPUTS: 6998 * statep - connection state pointer 6999 * 7000 * RETURN VALUE: 7001 */ 7002 static ibt_status_t 7003 ibcm_invoke_rtu_qp_modify(ibcm_state_data_t *statep, ib_time_t timeout, 7004 ibcm_rep_msg_t *rep_msg) 7005 { 7006 ibt_status_t status; 7007 ibt_qp_info_t qp_info; 7008 ibt_cep_modify_flags_t cep_flags = IBT_CEP_SET_RTR_RTS; 7009 7010 /* Start filling up ibt_qp_info_t. */ 7011 bzero(&qp_info, sizeof (qp_info)); 7012 qp_info.qp_trans = ibtl_cm_get_chan_type(statep->channel); 7013 qp_info.qp_current_state = IBT_STATE_RTR; 7014 7015 switch (qp_info.qp_trans) { 7016 case IBT_RC_SRV: 7017 IBCM_QPINFO_RC_PATH(qp_info).cep_timeout = timeout; 7018 IBCM_QPINFO_RC(qp_info).rc_retry_cnt = statep->cep_retry_cnt; 7019 IBCM_QPINFO_RC(qp_info).rc_rnr_retry_cnt = 7020 statep->local_qp_rnr_cnt; 7021 IBCM_QPINFO_RC(qp_info).rc_sq_psn = statep->starting_psn; 7022 7023 if (statep->mode == IBCM_ACTIVE_MODE) { 7024 IBCM_QPINFO_RC(qp_info).rc_rdma_ra_out = 7025 rep_msg->rep_resp_resources; 7026 } else { 7027 IBCM_QPINFO_RC(qp_info).rc_rdma_ra_out = 7028 rep_msg->rep_initiator_depth; 7029 } 7030 if (statep->alt_port && 7031 (((rep_msg->rep_target_delay_plus >> 1) & 0x3) == 7032 IBT_CM_FAILOVER_ACCEPT)) { 7033 /* failover was accepted */ 7034 cep_flags |= IBT_CEP_SET_MIG; 7035 IBCM_QPINFO_RC(qp_info).rc_mig_state = 7036 IBT_STATE_REARMED; 7037 } 7038 7039 break; 7040 /* XXX RD? */ 7041 case IBT_UC_SRV: 7042 IBCM_QPINFO_UC_PATH(qp_info).cep_timeout = timeout; 7043 break; 7044 default: 7045 IBTF_DPRINTF_L2(cmlog, "ibcm_invoke_rtu_qp_modify: " 7046 "unknow svc_type = %x", qp_info.qp_trans); 7047 break; 7048 } 7049 7050 /* Call modify_qp */ 7051 status = ibt_modify_qp(statep->channel, cep_flags, &qp_info, NULL); 7052 IBTF_DPRINTF_L4(cmlog, "ibcm_invoke_rtu_qp_modify: statep 0x%p " 7053 "modify qp status = %d", statep, status); 7054 7055 if (status == IBT_SUCCESS) 7056 ibcm_insert_trace(statep, IBCM_TRACE_RTR_RTS); 7057 else 7058 ibcm_insert_trace(statep, IBCM_TRACE_RTR_RTS_FAIL); 7059 7060 #ifdef DEBUG 7061 print_modify_qp("RTR to RTS", statep->channel, cep_flags, &qp_info); 7062 7063 if (statep->channel != NULL) { 7064 ibt_qp_query_attr_t qp_attrs; 7065 7066 (void) ibt_query_qp(statep->channel, &qp_attrs); 7067 IBTF_DPRINTF_L4(cmlog, "ibcm_invoke_rtu_qp_modify: " 7068 "qp_info.qp_state = %x", qp_attrs.qp_info.qp_state); 7069 } 7070 #endif 7071 return (status); 7072 } 7073 7074 7075 /* 7076 * ibcm_cep_state_rtu: 7077 * QP state transition function called for an incoming RTU 7078 * on passive side. 7079 * 7080 * INPUTS: 7081 * statep - connection state pointer 7082 * cm_rtu_msg - RTU message pointer 7083 * 7084 */ 7085 void 7086 ibcm_cep_state_rtu(ibcm_state_data_t *statep, ibcm_rtu_msg_t *cm_rtu_msgp) 7087 { 7088 ibt_status_t status; 7089 ibt_cm_event_t event; 7090 ibcm_rep_msg_t *rep_msgp = (ibcm_rep_msg_t *) 7091 IBCM_OUT_MSGP(statep->stored_msg); 7092 7093 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_rtu: statep 0x%p", statep); 7094 7095 ASSERT(statep->channel != NULL); 7096 7097 /* RDMA initiator depth taken from negotiated REP values */ 7098 status = ibcm_invoke_rtu_qp_modify(statep, 7099 ibt_usec2ib(statep->remote_ack_delay), rep_msgp); 7100 7101 if (status != IBT_SUCCESS) { 7102 7103 (void) ibcm_cep_to_error_state(statep); 7104 /* 7105 * Disassociate statep and QP, as there is a 7106 * QP associated with this statep. 7107 */ 7108 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 7109 7110 ibcm_post_rej_mad(statep, IBT_CM_NO_RESC, 7111 IBT_CM_FAILURE_UNKNOWN, NULL, 0); 7112 /* 7113 * Invoke CM handler, so client/server can do 7114 * resource cleanup. No private data can be returned here 7115 */ 7116 ibcm_handler_conn_fail(statep, IBT_CM_FAILURE_REJ_SENT, 7117 IBT_CM_FAILURE_UNKNOWN, IBT_CM_NO_RESC, NULL, 0); 7118 7119 /* unblock any pending DREQ threads */ 7120 mutex_enter(&statep->state_mutex); 7121 statep->cep_in_rts = IBCM_FAIL; 7122 cv_broadcast(&statep->block_mad_cv); 7123 mutex_exit(&statep->state_mutex); 7124 return; 7125 } 7126 7127 mutex_enter(&statep->state_mutex); 7128 statep->state = IBCM_STATE_ESTABLISHED; 7129 ibtl_cm_chan_is_open(statep->channel); 7130 mutex_exit(&statep->state_mutex); 7131 7132 /* invoke the CM handler */ 7133 ASSERT(statep->cm_handler != NULL); 7134 7135 bzero(&event, sizeof (event)); 7136 event.cm_channel = statep->channel; 7137 event.cm_session_id = NULL; 7138 7139 event.cm_type = IBT_CM_EVENT_CONN_EST; 7140 if (cm_rtu_msgp != NULL) { 7141 event.cm_priv_data = &(cm_rtu_msgp->rtu_private_data[0]); 7142 event.cm_priv_data_len = IBT_RTU_PRIV_DATA_SZ; 7143 } 7144 7145 ibcm_insert_trace(statep, IBCM_TRACE_CALLED_CONN_EST_EVENT); 7146 7147 (void) statep->cm_handler(statep->state_cm_private, &event, NULL, 7148 NULL, 0); 7149 7150 ibcm_insert_trace(statep, IBCM_TRACE_RET_CONN_EST_EVENT); 7151 if (ibcm_enable_trace & 4) 7152 ibcm_dump_conn_trace(statep); 7153 else 7154 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_state_rtu CONN_EST Channel %p", 7155 statep->channel); 7156 7157 /* unblock any pending DREQ threads */ 7158 mutex_enter(&statep->state_mutex); 7159 statep->cep_in_rts = IBCM_UNBLOCK; 7160 cv_broadcast(&statep->block_mad_cv); 7161 mutex_exit(&statep->state_mutex); 7162 } 7163 7164 7165 /* 7166 * ibcm_cep_send_rtu: 7167 * QP state transition function called for an outgoing RTU 7168 * on active side. 7169 * 7170 * INPUTS: 7171 * statep - connection state pointer 7172 * 7173 * RETURN VALUE: 7174 */ 7175 void 7176 ibcm_cep_send_rtu(ibcm_state_data_t *statep) 7177 { 7178 /* invoke the CM handler */ 7179 if (statep->cm_handler) { 7180 ibt_cm_event_t event; 7181 7182 bzero(&event, sizeof (event)); 7183 event.cm_type = IBT_CM_EVENT_CONN_EST; 7184 event.cm_channel = statep->channel; 7185 event.cm_session_id = NULL; 7186 event.cm_priv_data = NULL; 7187 event.cm_priv_data_len = 0; 7188 7189 ibcm_insert_trace(statep, IBCM_TRACE_CALLED_CONN_EST_EVENT); 7190 7191 (void) statep->cm_handler(statep->state_cm_private, &event, 7192 NULL, NULL, 0); 7193 7194 ibcm_insert_trace(statep, IBCM_TRACE_RET_CONN_EST_EVENT); 7195 7196 } else { 7197 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_send_rtu: cm_handler NULL"); 7198 } 7199 if (ibcm_enable_trace & 4) 7200 ibcm_dump_conn_trace(statep); 7201 else 7202 IBTF_DPRINTF_L2(cmlog, "ibcm_cep_send_rtu CONN_EST Channel %p", 7203 statep->channel); 7204 7205 /* unblock any pending DREQ threads */ 7206 mutex_enter(&statep->state_mutex); 7207 statep->cep_in_rts = IBCM_UNBLOCK; 7208 cv_broadcast(&statep->block_mad_cv); 7209 mutex_exit(&statep->state_mutex); 7210 } 7211 7212 7213 /* 7214 * ibcm_cep_to_error_state: 7215 * CEP state transition function. Changes state to IBT_STATE_ERROR 7216 * 7217 * INPUTS: 7218 * statep - connection state pointer 7219 * 7220 * RETURN VALUE: 7221 * IBT_SUCCESS - if able to change state otherwise failure 7222 */ 7223 ibt_status_t 7224 ibcm_cep_to_error_state(ibcm_state_data_t *statep) 7225 { 7226 ibt_status_t status = IBT_SUCCESS; 7227 7228 if (statep->channel != NULL) { 7229 ibt_qp_info_t qp_info; 7230 7231 bzero(&qp_info, sizeof (qp_info)); 7232 /* For now, set it to RC type */ 7233 qp_info.qp_trans = IBT_RC_SRV; 7234 qp_info.qp_state = IBT_STATE_ERROR; 7235 7236 /* Call modify_qp to move to ERROR state */ 7237 status = ibt_modify_qp(statep->channel, IBT_CEP_SET_STATE, 7238 &qp_info, NULL); 7239 7240 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_to_error_state: " 7241 "statep %p ibt_modify_qp() = %d", statep, status); 7242 7243 if (status == IBT_SUCCESS) 7244 ibcm_insert_trace(statep, IBCM_TRACE_ERROR); 7245 else 7246 ibcm_insert_trace(statep, IBCM_TRACE_ERROR_FAIL); 7247 7248 } 7249 7250 #ifdef NO_EEC_SUPPORT_YET 7251 if (statep->channel.ch_eec != NULL) { 7252 ibt_eec_info_t eec_info; 7253 7254 bzero(&eec_info, sizeof (ibt_eec_info_t)); 7255 eec_info.eec_state = what; 7256 7257 /* Call modify_eec */ 7258 status = ibtl_cm_modify_eec(statep->channel.ch_eec, &eec_info, 7259 IBT_CEP_SET_NOTHING); 7260 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_to_error_state: " 7261 "ibtl_cm_modify_eec() returned = %x", status); 7262 } 7263 #endif 7264 7265 return (status); 7266 } 7267 7268 7269 /* 7270 * ibcm_cep_state_rej: 7271 * QP state transition function called for an incoming REJ 7272 * on active/passive side 7273 * 7274 * INPUTS: 7275 * statep - connection state pointer 7276 * rej_msgp - REJ message pointer 7277 * rej_state - State where REJ processing began 7278 * 7279 * RETURN VALUE: 7280 */ 7281 void 7282 ibcm_cep_state_rej(ibcm_state_data_t *statep, ibcm_rej_msg_t *rej_msgp, 7283 ibcm_conn_state_t rej_state) 7284 { 7285 ibt_cm_event_t event; 7286 ibt_status_t status; 7287 7288 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_rej: statep 0x%p", statep); 7289 7290 ibcm_path_cache_purge(); 7291 7292 if ((rej_state == IBCM_STATE_REP_SENT) || 7293 (rej_state == IBCM_STATE_MRA_REP_RCVD)) { 7294 status = ibcm_cep_to_error_state(statep); 7295 IBTF_DPRINTF_L5(cmlog, "ibcm_cep_state_rej: statep 0x%p " 7296 "ibcm_cep_to_error_state returned %d", statep, 7297 status); 7298 } 7299 7300 if (statep->channel) 7301 ibtl_cm_chan_open_is_aborted(statep->channel); 7302 7303 /* Disassociate state structure and CM */ 7304 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 7305 7306 /* invoke the CM handler */ 7307 bzero(&event, sizeof (event)); 7308 if (statep->cm_handler) { 7309 event.cm_type = IBT_CM_EVENT_FAILURE; 7310 event.cm_channel = statep->channel; 7311 event.cm_session_id = NULL; 7312 7313 /* 7314 * copy rej_msgp->rej_private_data to 7315 * event.cm_event.cm_priv_data 7316 */ 7317 event.cm_priv_data = &(rej_msgp->rej_private_data[0]); 7318 event.cm_priv_data_len = IBT_REJ_PRIV_DATA_SZ; 7319 7320 event.cm_event.failed.cf_code = IBT_CM_FAILURE_REJ_RCV; 7321 event.cm_event.failed.cf_msg = rej_msgp->rej_msg_type_plus >> 6; 7322 event.cm_event.failed.cf_reason = 7323 b2h16(rej_msgp->rej_rejection_reason); 7324 7325 IBTF_DPRINTF_L3(cmlog, "ibcm_cep_state_rej: rej_reason = %d", 7326 event.cm_event.failed.cf_reason); 7327 7328 ibcm_copy_addl_rej(statep, rej_msgp, &event.cm_event.failed); 7329 7330 (void) statep->cm_handler(statep->state_cm_private, &event, 7331 NULL, NULL, 0); 7332 } 7333 7334 if (statep->open_return_data != NULL) 7335 bcopy(&event.cm_event.failed.cf_additional, 7336 &statep->open_return_data->rc_arej_info, 7337 sizeof (ibt_arej_info_t)); 7338 if (ibcm_enable_trace != 0) 7339 ibcm_dump_conn_trace(statep); 7340 mutex_enter(&statep->state_mutex); 7341 ibcm_open_done(statep); 7342 mutex_exit(&statep->state_mutex); 7343 } 7344 7345 /* Used to initialize client args with addl rej information from REJ MAD */ 7346 static void 7347 ibcm_copy_addl_rej(ibcm_state_data_t *statep, ibcm_rej_msg_t *rej_msgp, 7348 ibt_cm_conn_failed_t *failed) 7349 { 7350 uint16_t rej_reason = b2h16(rej_msgp->rej_rejection_reason); 7351 uint8_t ari_len = rej_msgp->rej_reject_info_len_plus >> 1; 7352 ibcm_classportinfo_msg_t tclp; 7353 ibt_arej_info_t *cf_addl = &failed->cf_additional; 7354 7355 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cf_addl)) 7356 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(failed->cf_arej_info_valid)) 7357 7358 failed->cf_arej_info_valid = B_FALSE; 7359 7360 IBTF_DPRINTF_L3(cmlog, "ibcm_copy_addl_rej: rej_reason = %d " 7361 "ari_len = %d", rej_reason, ari_len); 7362 7363 if ((statep->mode == IBCM_PASSIVE_MODE) && 7364 (rej_reason != IBT_CM_CONSUMER)) 7365 return; 7366 7367 switch (rej_reason) { 7368 case IBT_CM_PRIM_GID: 7369 case IBT_CM_ALT_GID: 7370 case IBT_CM_PORT_REDIRECT: 7371 if (ari_len < sizeof (ib_gid_t)) 7372 break; 7373 failed->cf_arej_info_valid = B_TRUE; 7374 bcopy(rej_msgp->rej_addl_rej_info, &cf_addl->ari_gid, 7375 sizeof (ib_gid_t)); 7376 cf_addl->ari_gid.gid_guid = b2h64(cf_addl->ari_gid.gid_guid); 7377 cf_addl->ari_gid.gid_prefix = 7378 b2h64(cf_addl->ari_gid.gid_prefix); 7379 7380 IBTF_DPRINTF_L4(cmlog, "ibcm_copy_addl_rej: ari_gid= %llX:%llX", 7381 cf_addl->ari_gid.gid_prefix, cf_addl->ari_gid.gid_guid); 7382 7383 break; 7384 case IBT_CM_PRIM_LID: 7385 case IBT_CM_ALT_LID: 7386 if (ari_len < sizeof (ib_lid_t)) 7387 break; 7388 failed->cf_arej_info_valid = B_TRUE; 7389 bcopy(rej_msgp->rej_addl_rej_info, &cf_addl->ari_lid, 7390 sizeof (ib_lid_t)); 7391 cf_addl->ari_lid = b2h16(cf_addl->ari_lid); 7392 IBTF_DPRINTF_L4(cmlog, "ibcm_copy_addl_rej: ari_lid= 0x%lX", 7393 cf_addl->ari_lid); 7394 7395 break; 7396 case IBT_CM_INVALID_PRIM_SL: 7397 case IBT_CM_INVALID_ALT_SL: 7398 if (ari_len < 1) 7399 break; 7400 failed->cf_arej_info_valid = B_TRUE; 7401 /* take the first 4 bits */ 7402 cf_addl->ari_sl = rej_msgp->rej_addl_rej_info[0] >> 4; 7403 break; 7404 case IBT_CM_INVALID_PRIM_TC: 7405 case IBT_CM_INVALID_ALT_TC: 7406 if (ari_len < 1) 7407 break; 7408 failed->cf_arej_info_valid = B_TRUE; 7409 /* take the first byte */ 7410 cf_addl->ari_tclass = rej_msgp->rej_addl_rej_info[0]; 7411 break; 7412 case IBT_CM_INVALID_PRIM_HOP: 7413 case IBT_CM_INVALID_ALT_HOP: 7414 if (ari_len < 1) 7415 break; 7416 failed->cf_arej_info_valid = B_TRUE; 7417 /* take the first byte */ 7418 cf_addl->ari_hop = rej_msgp->rej_addl_rej_info[0]; 7419 break; 7420 case IBT_CM_INVALID_PRIM_RATE: 7421 case IBT_CM_INVALID_ALT_RATE: 7422 if (ari_len < 1) 7423 break; 7424 failed->cf_arej_info_valid = B_TRUE; 7425 /* take the first 6 bits */ 7426 cf_addl->ari_rate = rej_msgp->rej_addl_rej_info[0] >> 2; 7427 break; 7428 case IBT_CM_REDIRECT_CM: 7429 if (ari_len < sizeof (ibcm_classportinfo_msg_t)) 7430 break; 7431 failed->cf_arej_info_valid = B_TRUE; 7432 bcopy(rej_msgp->rej_addl_rej_info, &tclp, sizeof (tclp)); 7433 ibcm_init_clp_from_mad(&tclp, &cf_addl->ari_redirect); 7434 break; 7435 case IBT_CM_INVALID_MTU: 7436 if (ari_len < 1) 7437 break; 7438 failed->cf_arej_info_valid = B_TRUE; 7439 /* take the first 4 bits */ 7440 cf_addl->ari_mtu = rej_msgp->rej_addl_rej_info[0] >> 4; 7441 break; 7442 case IBT_CM_CONSUMER: 7443 if (ari_len == 0) 7444 break; 7445 failed->cf_arej_info_valid = B_TRUE; 7446 if (ari_len > IBT_CM_ADDL_REJ_LEN) 7447 ari_len = IBT_CM_ADDL_REJ_LEN; 7448 bcopy(&rej_msgp->rej_addl_rej_info, 7449 cf_addl->ari_consumer.rej_ari, ari_len); 7450 cf_addl->ari_consumer.rej_ari_len = ari_len; 7451 break; 7452 case IBT_CM_INVALID_PRIM_FLOW: 7453 case IBT_CM_INVALID_ALT_FLOW: 7454 if (ari_len < 3) /* 3 bytes needed for 20 bits */ 7455 break; 7456 failed->cf_arej_info_valid = B_TRUE; 7457 /* take the first 20 bits */ 7458 cf_addl->ari_flow = 7459 b2h32(*(uint32_t *)&rej_msgp->rej_addl_rej_info) >> 12; 7460 break; 7461 default: 7462 break; 7463 } 7464 7465 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(failed->cf_arej_info_valid)) 7466 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cf_addl)) 7467 } 7468 7469 7470 /* Used to copy classportinfo to MAD from client initialized args */ 7471 static void 7472 ibcm_init_clp_to_mad(ibcm_classportinfo_msg_t *clp, ibt_redirect_info_t *rinfo) 7473 { 7474 7475 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*clp)) 7476 7477 bcopy(&ibcm_clpinfo, clp, sizeof (ibcm_clpinfo)); 7478 7479 clp->RedirectGID_hi = h2b64(rinfo->rdi_gid.gid_prefix); 7480 clp->RedirectGID_lo = h2b64(rinfo->rdi_gid.gid_guid); 7481 clp->RedirectTC_plus = 7482 h2b32((rinfo->rdi_tclass << 24) | (rinfo->rdi_sl << 20) | 7483 (rinfo->rdi_flow & 0xfffff)); 7484 clp->RedirectLID = h2b16(rinfo->rdi_dlid); 7485 clp->RedirectQP_plus = h2b32(rinfo->rdi_qpn & 0xffffff); 7486 clp->RedirectQ_Key = h2b32(rinfo->rdi_qkey); 7487 clp->RedirectP_Key = h2b16(rinfo->rdi_pkey); 7488 7489 IBTF_DPRINTF_L4(cmlog, "ibcm_init_clp_to_mad: RedirectGID= %llX:%llX," 7490 " RedirectLID= 0x%lX", clp->RedirectGID_hi, clp->RedirectGID_lo, 7491 clp->RedirectLID); 7492 7493 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*clp)) 7494 } 7495 7496 7497 /* Used to initialize classportinfo to be returned to clients, from MAD */ 7498 static void 7499 ibcm_init_clp_from_mad(ibcm_classportinfo_msg_t *clp, 7500 ibt_redirect_info_t *rinfo) 7501 { 7502 uint32_t temp32; 7503 7504 rinfo->rdi_gid.gid_prefix = b2h64(clp->RedirectGID_hi); 7505 rinfo->rdi_gid.gid_guid = b2h64(clp->RedirectGID_lo); 7506 temp32 = b2h32(clp->RedirectTC_plus); 7507 rinfo->rdi_tclass = temp32 >> 24; 7508 rinfo->rdi_sl = (temp32 >> 20) & 0xf; 7509 rinfo->rdi_flow = temp32 & 0xffff; 7510 rinfo->rdi_dlid = b2h16(clp->RedirectLID); 7511 rinfo->rdi_qpn = b2h32(clp->RedirectQP_plus & 0xffffff); 7512 rinfo->rdi_qkey = b2h32(clp->RedirectQ_Key); 7513 rinfo->rdi_pkey = b2h16(clp->RedirectP_Key); 7514 7515 IBTF_DPRINTF_L4(cmlog, "ibcm_init_clp_from_mad: RedirectGID= %llX:%llX," 7516 " RedirectLID= 0x%lX", rinfo->rdi_gid.gid_prefix, 7517 rinfo->rdi_gid.gid_guid, rinfo->rdi_dlid); 7518 } 7519 7520 7521 /* 7522 * ibcm_cep_state_rej_est: 7523 * QP state transition function called for an incoming REJ 7524 * on active side in established state 7525 * 7526 * INPUTS: 7527 * statep - connection state pointer 7528 * 7529 * RETURN VALUE: 7530 */ 7531 void 7532 ibcm_cep_state_rej_est(ibcm_state_data_t *statep) 7533 { 7534 ibt_cm_event_t event; 7535 ibt_status_t status; 7536 7537 IBTF_DPRINTF_L3(cmlog, "ibcm_cep_state_rej_est:"); 7538 7539 status = ibcm_cep_to_error_state(statep); 7540 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_rej_est: statep 0x%p " 7541 "ibcm_cep_to_error_state returned %d", statep, status); 7542 7543 /* Disassociate state structure and CM */ 7544 IBCM_SET_CHAN_PRIVATE(statep->channel, NULL); 7545 7546 ibtl_cm_chan_is_closing(statep->channel); 7547 7548 /* invoke the CM handler */ 7549 if (statep->cm_handler) { 7550 bzero(&event, sizeof (event)); 7551 event.cm_type = IBT_CM_EVENT_CONN_CLOSED; 7552 event.cm_channel = statep->channel; 7553 event.cm_session_id = NULL; 7554 7555 event.cm_priv_data = NULL; 7556 event.cm_priv_data_len = 0; 7557 7558 event.cm_event.closed = IBT_CM_CLOSED_REJ_RCVD; 7559 7560 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_rej_est: " 7561 "rej_reason = %d", event.cm_event.failed.cf_reason); 7562 7563 ibcm_insert_trace(statep, IBCM_TRACE_CALLED_CONN_CLOSE_EVENT); 7564 7565 (void) statep->cm_handler(statep->state_cm_private, &event, 7566 NULL, NULL, 0); 7567 7568 ibcm_insert_trace(statep, IBCM_TRACE_RET_CONN_CLOSE_EVENT); 7569 7570 } 7571 } 7572 7573 7574 /* 7575 * ibcm_sidr_req_ud_handler: 7576 * Invoke Client's UD handler For SIDR_REQ msg 7577 * 7578 * INPUTS: 7579 * ud_statep - ud_state pointer 7580 * sidr_reqp - SIDR_REQ message pointer 7581 * 7582 * RETURN VALUE: IBCM_SEND_REP/IBCM_SEND_REJ 7583 */ 7584 static ibcm_status_t 7585 ibcm_sidr_req_ud_handler(ibcm_ud_state_data_t *ud_statep, 7586 ibcm_sidr_req_msg_t *sidr_reqp, ibcm_mad_addr_t *cm_mad_addr, 7587 ibt_sidr_status_t *sidr_status) 7588 { 7589 void *priv_data = NULL; 7590 ibt_cm_ud_event_t ud_event; 7591 ibcm_sidr_rep_msg_t *sidr_repp; 7592 ibt_cm_ud_return_args_t ud_ret_args; 7593 ibt_cm_status_t cb_status; 7594 ibt_qp_query_attr_t qp_attr; 7595 ibt_status_t retval; 7596 ibcm_ud_clnt_reply_info_t ud_clnt_info; 7597 7598 /* Check first if UD client handler is valid */ 7599 ASSERT(ud_statep->ud_cm_handler != NULL); 7600 7601 /* Fill in ibt_cm_ud_event_t */ 7602 ud_event.cm_type = IBT_CM_UD_EVENT_SIDR_REQ; 7603 ud_event.cm_session_id = ud_statep; 7604 ud_event.cm_event.sidr_req.sreq_service_id = ud_statep->ud_svc_id; 7605 ud_event.cm_event.sidr_req.sreq_hca_guid = ud_statep->ud_hcap->hca_guid; 7606 ud_event.cm_event.sidr_req.sreq_pkey = b2h16(sidr_reqp->sidr_req_pkey); 7607 ud_event.cm_event.sidr_req.sreq_hca_port = cm_mad_addr->port_num; 7608 7609 ud_event.cm_priv_data = 7610 &(sidr_reqp->sidr_req_private_data[0]); 7611 ud_event.cm_priv_data_len = IBT_SIDR_REQ_PRIV_DATA_SZ; 7612 7613 sidr_repp = 7614 (ibcm_sidr_rep_msg_t *)IBCM_OUT_MSGP(ud_statep->ud_stored_msg); 7615 7616 priv_data = &(sidr_repp->sidr_rep_private_data[0]); 7617 7618 bzero(&ud_ret_args, sizeof (ud_ret_args)); 7619 7620 /* Invoke the client handler */ 7621 cb_status = ud_statep->ud_cm_handler(ud_statep->ud_state_cm_private, 7622 &ud_event, &ud_ret_args, priv_data, IBT_SIDR_REP_PRIV_DATA_SZ); 7623 7624 if (cb_status == IBT_CM_DEFER) { 7625 7626 /* unblock any blocked cm ud proceed api calls */ 7627 mutex_enter(&ud_statep->ud_state_mutex); 7628 ud_statep->ud_clnt_proceed = IBCM_UNBLOCK; 7629 cv_broadcast(&ud_statep->ud_block_client_cv); 7630 mutex_exit(&ud_statep->ud_state_mutex); 7631 7632 return (IBCM_DEFER); 7633 } 7634 7635 /* fail any blocked ud cm proceed api calls - client bug */ 7636 mutex_enter(&ud_statep->ud_state_mutex); 7637 ud_statep->ud_clnt_proceed = IBCM_FAIL; 7638 cv_broadcast(&ud_statep->ud_block_client_cv); 7639 mutex_exit(&ud_statep->ud_state_mutex); 7640 7641 /* do the query qp as soon as possible, after return from cm handler */ 7642 if (cb_status == IBT_CM_ACCEPT) { 7643 retval = ibt_query_qp(ud_ret_args.ud_channel, &qp_attr); 7644 if (retval != IBT_SUCCESS) { 7645 IBTF_DPRINTF_L2(cmlog, "ibcm_sidr_req_ud_handler: " 7646 "Failed to retrieve QPN from the channel: %d", 7647 retval); 7648 *sidr_status = IBT_CM_SREP_NO_CHAN; 7649 return (IBCM_SEND_SIDR_REP); 7650 } else if (qp_attr.qp_info.qp_trans != IBT_UD_SRV) { 7651 IBTF_DPRINTF_L2(cmlog, "ibcm_sidr_req_ud_handler: " 7652 "Server/Passive returned non-UD %d transport type " 7653 "QP", qp_attr.qp_info.qp_trans); 7654 *sidr_status = IBT_CM_SREP_NO_CHAN; 7655 return (IBCM_SEND_SIDR_REP); 7656 } 7657 7658 ud_clnt_info.ud_qkey = qp_attr.qp_info.qp_transport.ud.ud_qkey; 7659 ud_clnt_info.ud_qpn = qp_attr.qp_qpn; 7660 } 7661 7662 ud_clnt_info.priv_data = priv_data; 7663 ud_clnt_info.priv_data_len = ud_ret_args.ud_ret_len; 7664 7665 ud_clnt_info.redirect_infop = &ud_ret_args.ud_redirect; 7666 7667 ibcm_process_sidr_req_cm_hdlr(ud_statep, cb_status, &ud_clnt_info, 7668 sidr_status, sidr_repp); 7669 7670 return (IBCM_SEND_SIDR_REP); 7671 } 7672 7673 /*ARGSUSED*/ 7674 void 7675 ibcm_process_sidr_req_cm_hdlr(ibcm_ud_state_data_t *ud_statep, 7676 ibt_cm_status_t cb_status, ibcm_ud_clnt_reply_info_t *ud_clnt_info, 7677 ibt_sidr_status_t *sidr_status, ibcm_sidr_rep_msg_t *sidr_repp) 7678 { 7679 void *sidr_rep_privp; 7680 7681 IBTF_DPRINTF_L5(cmlog, "ibcm_process_sidr_req_cm_hdlr(%p, %x, " 7682 "%p, %p, %p)", ud_statep, cb_status, ud_clnt_info, 7683 sidr_status, sidr_repp); 7684 7685 if (cb_status == IBT_CM_DEFAULT) 7686 cb_status = IBT_CM_REJECT; 7687 7688 if (cb_status == IBT_CM_ACCEPT) 7689 *sidr_status = IBT_CM_SREP_CHAN_VALID; 7690 else if ((cb_status == IBT_CM_REJECT) || 7691 (cb_status == IBT_CM_NO_RESOURCE)) 7692 *sidr_status = IBT_CM_SREP_REJ; 7693 else if (cb_status == IBT_CM_NO_CHANNEL) 7694 *sidr_status = IBT_CM_SREP_NO_CHAN; 7695 else if (cb_status == IBT_CM_REDIRECT) 7696 *sidr_status = IBT_CM_SREP_REDIRECT; 7697 else *sidr_status = IBT_CM_SREP_REJ; 7698 7699 /* 7700 * For Accept and reject copy the private data, if ud_clnt_info 7701 * priv_data does not point to SIDR Response private data. This 7702 * copy is needed for ibt_cm_ud_proceed(). 7703 */ 7704 sidr_rep_privp = (void *)(&(sidr_repp->sidr_rep_private_data[0])); 7705 if ((cb_status == IBT_CM_ACCEPT || cb_status == IBT_CM_REJECT) && 7706 (ud_clnt_info->priv_data != sidr_rep_privp) && 7707 ud_clnt_info->priv_data_len) { 7708 bcopy(ud_clnt_info->priv_data, sidr_rep_privp, 7709 min(ud_clnt_info->priv_data_len, 7710 IBT_SIDR_REP_PRIV_DATA_SZ)); 7711 } 7712 7713 if (*sidr_status != IBT_CM_SREP_CHAN_VALID) { 7714 IBTF_DPRINTF_L2(cmlog, "ibcm_process_sidr_req_cm_hdlr: " 7715 "ud_handler return a failure: %d", cb_status); 7716 if (*sidr_status == IBT_CM_SREP_REDIRECT) { 7717 /* 7718 * typecasting to ibcm_classportinfo_msg_t is ok, as addl info 7719 * begins at offset 24 in sidr rep 7720 */ 7721 ibcm_init_clp_to_mad( 7722 (ibcm_classportinfo_msg_t *) 7723 &sidr_repp->sidr_rep_class_port_info, 7724 ud_clnt_info->redirect_infop); 7725 } 7726 return; 7727 } 7728 7729 7730 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sidr_repp)) 7731 7732 sidr_repp->sidr_rep_qkey = 7733 h2b32(ud_clnt_info->ud_qkey); 7734 sidr_repp->sidr_rep_qpn_plus = h2b32(ud_clnt_info->ud_qpn << 8); 7735 7736 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sidr_repp)) 7737 } 7738 7739 /* 7740 * ibcm_sidr_rep_ud_handler: 7741 * Invoke Client's UD handler For SIDR_REP msg 7742 * 7743 * INPUTS: 7744 * ud_statep - ud_state pointer 7745 * sidr_rep_msgp - SIDR_REQ message pointer 7746 * 7747 */ 7748 static void 7749 ibcm_sidr_rep_ud_handler(ibcm_ud_state_data_t *ud_statep, 7750 ibcm_sidr_rep_msg_t *sidr_rep_msgp) 7751 { 7752 ibt_cm_ud_event_t ud_event; 7753 7754 IBTF_DPRINTF_L5(cmlog, "ibcm_sidr_rep_ud_handler: ud_statep 0x%p", 7755 ud_statep); 7756 7757 /* Check first if UD client handler is valid */ 7758 if (ud_statep->ud_cm_handler == NULL) { 7759 IBTF_DPRINTF_L2(cmlog, "ibcm_sidr_rep_ud_handler: " 7760 "cm_handler NULL"); 7761 return; 7762 } 7763 7764 /* Fill in ibt_cm_ud_event_t */ 7765 ud_event.cm_type = IBT_CM_UD_EVENT_SIDR_REP; 7766 ud_event.cm_session_id = NULL; 7767 ud_event.cm_event.sidr_rep.srep_status = 7768 sidr_rep_msgp->sidr_rep_rep_status; 7769 ud_event.cm_event.sidr_rep.srep_remote_qpn = 7770 b2h32(sidr_rep_msgp->sidr_rep_qpn_plus) >> 8; 7771 ud_event.cm_event.sidr_rep.srep_remote_qkey = 7772 h2b32(sidr_rep_msgp->sidr_rep_qkey); 7773 7774 if (ud_event.cm_event.sidr_rep.srep_status == IBT_CM_SREP_REDIRECT) { 7775 /* 7776 * typecasting to ibcm_classportinfo_msg_t is ok, as addl info 7777 * begins at offset 24 in sidr rep 7778 */ 7779 ibcm_init_clp_from_mad( 7780 (ibcm_classportinfo_msg_t *) 7781 sidr_rep_msgp->sidr_rep_class_port_info, 7782 &ud_event.cm_event.sidr_rep.srep_redirect); 7783 7784 if (ud_statep->ud_return_data != NULL) 7785 bcopy(&ud_event.cm_event.sidr_rep.srep_redirect, 7786 &ud_statep->ud_return_data->ud_redirect, 7787 sizeof (ibt_redirect_info_t)); 7788 } 7789 7790 ud_event.cm_priv_data = &(sidr_rep_msgp->sidr_rep_private_data[0]); 7791 ud_event.cm_priv_data_len = IBT_SIDR_REP_PRIV_DATA_SZ; 7792 7793 /* Invoke the client handler - inform only, so ignore retval */ 7794 (void) ud_statep->ud_cm_handler(ud_statep->ud_state_cm_private, 7795 &ud_event, NULL, NULL, 0); 7796 7797 7798 } 7799 7800 /* 7801 * ibcm_process_lap_msg: 7802 * This call processes an incoming LAP message 7803 * 7804 * INPUTS: 7805 * hcap - HCA entry pointer 7806 * input_madp - incoming CM LAP MAD 7807 * cm_mad_addr - Address information for the MAD 7808 * 7809 * RETURN VALUE: NONE 7810 */ 7811 /* ARGSUSED */ 7812 void 7813 ibcm_process_lap_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 7814 ibcm_mad_addr_t *cm_mad_addr) 7815 { 7816 ibcm_status_t state_lookup_status; 7817 ibcm_lap_msg_t *lap_msg = (ibcm_lap_msg_t *) 7818 (&input_madp[IBCM_MAD_HDR_SIZE]); 7819 ibcm_apr_msg_t *apr_msg; 7820 ibcm_state_data_t *statep = NULL; 7821 7822 IBTF_DPRINTF_L4(cmlog, "ibcm_process_lap_msg:"); 7823 7824 rw_enter(&hcap->hca_state_rwlock, RW_READER); 7825 7826 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_LAP, 7827 b2h32(lap_msg->lap_remote_comm_id), 0, 0, hcap, &statep); 7828 7829 rw_exit(&hcap->hca_state_rwlock); 7830 7831 IBTF_DPRINTF_L4(cmlog, "ibcm_process_lap_msg: lookup status %x" 7832 " com id %x", state_lookup_status, 7833 b2h32(lap_msg->lap_remote_comm_id)); 7834 7835 if (state_lookup_status != IBCM_LOOKUP_EXISTS) { 7836 /* Post a REJ message ? - but spec doesn't state so */ 7837 return; 7838 } 7839 7840 /* There is an existing state structure entry with active comid */ 7841 7842 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_LAP); 7843 7844 mutex_enter(&statep->state_mutex); 7845 7846 if ((statep->state == IBCM_STATE_ESTABLISHED) && 7847 (statep->ap_state == IBCM_AP_STATE_IDLE) && 7848 (statep->mode == IBCM_PASSIVE_MODE)) { 7849 if ((statep->lapr_msg) && 7850 (IBCM_OUT_HDRP(statep->lapr_msg)->TransactionID == 7851 ((ib_mad_hdr_t *)(input_madp))->TransactionID)) 7852 ibcm_post_stored_apr_mad(statep, input_madp); 7853 else { 7854 ibcm_status_t clnt_response; 7855 7856 statep->ap_state = IBCM_AP_STATE_LAP_RCVD; 7857 statep->clnt_proceed = IBCM_BLOCK; 7858 mutex_exit(&statep->state_mutex); 7859 7860 if (statep->lapr_msg == NULL) { 7861 if (ibcm_alloc_out_msg( 7862 statep->stored_reply_addr.ibmf_hdl, 7863 &statep->lapr_msg, MAD_METHOD_SEND) != 7864 IBT_SUCCESS) { 7865 7866 mutex_enter(&statep->state_mutex); 7867 statep->clnt_proceed = IBCM_FAIL; 7868 cv_broadcast(&statep->block_client_cv); 7869 IBCM_REF_CNT_DECR(statep); 7870 mutex_exit(&statep->state_mutex); 7871 return; 7872 } 7873 } 7874 apr_msg = (ibcm_apr_msg_t *) 7875 IBCM_OUT_MSGP(statep->lapr_msg); 7876 IBCM_OUT_HDRP(statep->lapr_msg)->TransactionID = 7877 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 7878 clnt_response = 7879 ibcm_cep_state_lap(statep, lap_msg, apr_msg); 7880 IBTF_DPRINTF_L4(cmlog, "ibcm_process_lap_msg:" 7881 " statep 0x%p apr status %d", statep, 7882 apr_msg->apr_ap_status); 7883 7884 if (clnt_response == IBCM_DEFER) { 7885 IBTF_DPRINTF_L4(cmlog, "ibcm_process_lap_msg: " 7886 "client returned DEFER response"); 7887 return; 7888 } 7889 7890 /* fail any blocked cm proceed api calls - client bug */ 7891 mutex_enter(&statep->state_mutex); 7892 statep->clnt_proceed = IBCM_FAIL; 7893 cv_broadcast(&statep->block_client_cv); 7894 mutex_exit(&statep->state_mutex); 7895 7896 ibcm_post_apr_mad(statep); 7897 return; 7898 } 7899 } /* drop the LAP MAD in any other state */ 7900 7901 IBCM_REF_CNT_DECR(statep); /* decrement the ref count */ 7902 mutex_exit(&statep->state_mutex); 7903 } 7904 7905 /* 7906 * ibcm_post_stored_apr_mad: 7907 * Builds and posts an APR MAD from the stored APR MAD 7908 * 7909 * INPUTS: 7910 * statep - pointer to ibcm_state_data_t 7911 * input_madp - pointer to incoming lap mad 7912 * 7913 * RETURN VALUE: 7914 * NONE 7915 * 7916 * This function is called holding the state mutex, and returns 7917 * holding the state mutex 7918 */ 7919 static void 7920 ibcm_post_stored_apr_mad(ibcm_state_data_t *statep, uint8_t *input_madp) 7921 { 7922 ibmf_msg_t *ibmf_apr_msg; 7923 uint8_t apr_msg[IBCM_MSG_SIZE]; 7924 7925 /* Need to make a copy, else an incoming new LAP may modify lapr_msg */ 7926 bcopy(IBCM_OUT_MSGP(statep->lapr_msg), apr_msg, IBCM_MSG_SIZE); 7927 7928 mutex_exit(&statep->state_mutex); 7929 7930 if (ibcm_alloc_out_msg(statep->stored_reply_addr.ibmf_hdl, 7931 &ibmf_apr_msg, MAD_METHOD_SEND) != IBT_SUCCESS) { 7932 IBTF_DPRINTF_L2(cmlog, "ibcm_post_stored_apr_mad: " 7933 "ibcm_alloc_out_msg failed"); 7934 mutex_enter(&statep->state_mutex); 7935 return; 7936 } 7937 7938 bcopy(apr_msg, IBCM_OUT_MSGP(ibmf_apr_msg), IBCM_MSG_SIZE); 7939 7940 IBCM_OUT_HDRP(ibmf_apr_msg)->AttributeID = 7941 h2b16(IBCM_INCOMING_APR + IBCM_ATTR_BASE_ID); 7942 7943 IBCM_OUT_HDRP(ibmf_apr_msg)->TransactionID = 7944 ((ib_mad_hdr_t *)(input_madp))->TransactionID; 7945 7946 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_APR); 7947 7948 ibcm_post_rc_mad(statep, ibmf_apr_msg, ibcm_post_stored_apr_complete, 7949 ibmf_apr_msg); 7950 7951 /* ibcm_free_out_msg done in ibcm_post_stored_apr_complete */ 7952 7953 mutex_enter(&statep->state_mutex); 7954 } 7955 7956 /* 7957 * ibcm_cep_state_lap: 7958 * This call processes an incoming LAP message for cep state 7959 * transition and invoking cm handler 7960 * 7961 * INPUTS: 7962 * statep - pointer to ibcm_state_data_t 7963 * lap_msg - lap msg received 7964 * apr_msg - apr msg to be sent 7965 * 7966 * RETURN VALUE: NONE 7967 */ 7968 ibcm_status_t 7969 ibcm_cep_state_lap(ibcm_state_data_t *statep, ibcm_lap_msg_t *lap_msg, 7970 ibcm_apr_msg_t *apr_msg) 7971 { 7972 ibt_cm_event_t event; 7973 ibt_cm_return_args_t ret_args; 7974 ibt_cm_status_t cb_status; 7975 ibcm_clnt_reply_info_t clnt_info; 7976 7977 7978 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_lap: statep 0x%p", statep); 7979 7980 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*apr_msg)) 7981 7982 /* If APM is not supported, return error */ 7983 if (!(statep->hcap->hca_caps & IBT_HCA_AUTO_PATH_MIG)) { 7984 apr_msg->apr_ap_status = IBT_CM_AP_NOT_SUPPORTED; 7985 return (IBCM_SEND_APR); 7986 } 7987 7988 if (statep->local_qpn != 7989 b2h32(lap_msg->lap_remote_qpn_eecn_plus) >> 8) { 7990 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 7991 IBTF_DPRINTF_L4(cmlog, "ibcm_cep_state_lap: local_qpn %x does " 7992 "not match remote's remote_qpn %x", statep->local_qpn, 7993 b2h32(lap_msg->lap_remote_qpn_eecn_plus) >> 8); 7994 return (IBCM_SEND_APR); 7995 } 7996 7997 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*apr_msg)) 7998 7999 /* Fill up the event */ 8000 bzero(&event, sizeof (event)); 8001 event.cm_type = IBT_CM_EVENT_LAP_RCV; 8002 event.cm_channel = statep->channel; 8003 event.cm_session_id = statep; 8004 event.cm_priv_data = lap_msg->lap_private_data; 8005 event.cm_priv_data_len = IBT_LAP_PRIV_DATA_SZ; 8006 event.cm_event.lap.lap_timeout = ibt_ib2usec( 8007 ((uint8_t *)&lap_msg->lap_remote_qpn_eecn_plus)[3] >> 3); 8008 8009 ibcm_fill_adds_from_lap(&event.cm_event.lap.lap_alternate_path, 8010 lap_msg, IBCM_PASSIVE_MODE); 8011 8012 cb_status = statep->cm_handler(statep->state_cm_private, &event, 8013 &ret_args, apr_msg->apr_private_data, IBT_APR_PRIV_DATA_SZ); 8014 8015 IBTF_DPRINTF_L3(cmlog, "ibcm_cep_state_lap: cb_status = %d", cb_status); 8016 if (cb_status == IBT_CM_DEFER) { 8017 8018 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(statep->defer_cm_msg)) 8019 8020 if (statep->defer_cm_msg == NULL) 8021 statep->defer_cm_msg = 8022 kmem_zalloc(IBCM_MSG_SIZE, KM_SLEEP); 8023 bcopy(lap_msg, statep->defer_cm_msg, IBCM_MSG_SIZE); 8024 8025 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(statep->defer_cm_msg)) 8026 8027 /* unblock any blocked cm proceed api calls */ 8028 mutex_enter(&statep->state_mutex); 8029 statep->clnt_proceed = IBCM_UNBLOCK; 8030 cv_broadcast(&statep->block_client_cv); 8031 mutex_exit(&statep->state_mutex); 8032 8033 return (IBCM_DEFER); 8034 } 8035 8036 clnt_info.reply_event = (ibt_cm_proceed_reply_t *)&ret_args.cm_ret; 8037 clnt_info.priv_data = NULL; 8038 clnt_info.priv_data_len = 0; 8039 8040 ibcm_process_cep_lap_cm_hdlr(statep, cb_status, &clnt_info, lap_msg, 8041 apr_msg); 8042 return (IBCM_SEND_APR); 8043 } 8044 8045 /* 8046 * ibcm_fill_adds_from_lap: 8047 * Fills the address vector (part of event structure passed to 8048 * client) from the LAP message 8049 * 8050 * INPUTS: 8051 * adds - Address vector to be filled-in 8052 * lap_msg - LAP message used to fill the address vector 8053 * 8054 * RETURN VALUE: NONE 8055 */ 8056 static void 8057 ibcm_fill_adds_from_lap(ibt_adds_vect_t *adds, ibcm_lap_msg_t *lap_msg, 8058 ibcm_mode_t mode) 8059 { 8060 adds->av_srvl = lap_msg->lap_alt_sl_plus >> 4; 8061 if (mode == IBCM_PASSIVE_MODE) { 8062 adds->av_dgid.gid_prefix = 8063 b2h64(lap_msg->lap_alt_l_port_gid.gid_prefix); 8064 adds->av_dgid.gid_guid = 8065 b2h64(lap_msg->lap_alt_l_port_gid.gid_guid); 8066 adds->av_sgid.gid_prefix = 8067 b2h64(lap_msg->lap_alt_r_port_gid.gid_prefix); 8068 adds->av_sgid.gid_guid = 8069 b2h64(lap_msg->lap_alt_r_port_gid.gid_guid); 8070 adds->av_dlid = b2h16(lap_msg->lap_alt_l_port_lid); 8071 } else { 8072 adds->av_sgid.gid_prefix = 8073 b2h64(lap_msg->lap_alt_l_port_gid.gid_prefix); 8074 adds->av_sgid.gid_guid = 8075 b2h64(lap_msg->lap_alt_l_port_gid.gid_guid); 8076 adds->av_dgid.gid_prefix = 8077 b2h64(lap_msg->lap_alt_r_port_gid.gid_prefix); 8078 adds->av_dgid.gid_guid = 8079 b2h64(lap_msg->lap_alt_r_port_gid.gid_guid); 8080 adds->av_dlid = b2h16(lap_msg->lap_alt_r_port_lid); 8081 } 8082 8083 IBTF_DPRINTF_L4(cmlog, "ibcm_fill_adds_from_lap: SGID=(%llX:%llX)", 8084 adds->av_sgid.gid_prefix, adds->av_sgid.gid_guid); 8085 8086 IBTF_DPRINTF_L4(cmlog, "ibcm_fill_adds_from_lap: DGID=(%llX:%llX)", 8087 adds->av_dgid.gid_prefix, adds->av_dgid.gid_guid); 8088 8089 adds->av_srate = lap_msg->lap_alt_srate_plus & 0x3f; 8090 8091 /* next copy off the GRH info if it exists */ 8092 if ((lap_msg->lap_alt_sl_plus & 0x8) == 0) { 8093 uint32_t flow_tclass = b2h32(lap_msg->lap_alt_flow_label_plus); 8094 8095 adds->av_send_grh = B_TRUE; 8096 adds->av_flow = flow_tclass >> 12; 8097 adds->av_tclass = flow_tclass & 0xff; 8098 adds->av_hop = lap_msg->lap_alt_hop_limit; 8099 } else { 8100 adds->av_send_grh = B_FALSE; 8101 } 8102 } 8103 8104 /* 8105 * ibcm_process_cep_lap_cm_hdlr: 8106 * Processes the cm handler response for an incoming LAP. 8107 */ 8108 8109 void 8110 ibcm_process_cep_lap_cm_hdlr(ibcm_state_data_t *statep, 8111 ibt_cm_status_t cb_status, ibcm_clnt_reply_info_t *clnt_info, 8112 ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg) 8113 { 8114 ibtl_cm_hca_port_t port; 8115 ibt_qp_query_attr_t qp_attrs; 8116 ibt_cep_modify_flags_t cep_flags; 8117 ibt_status_t status; 8118 ibt_adds_vect_t *adds; 8119 8120 if (cb_status == IBT_CM_DEFAULT) 8121 cb_status = IBT_CM_REJECT; 8122 8123 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*apr_msg)) 8124 8125 /* verify status */ 8126 apr_msg->apr_addl_info_len = 0; 8127 if (cb_status == IBT_CM_ACCEPT) { 8128 apr_msg->apr_ap_status = IBT_CM_AP_LOADED; 8129 } else if (cb_status == IBT_CM_REJECT) { 8130 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8131 } else if (cb_status == IBT_CM_REDIRECT) { 8132 apr_msg->apr_ap_status = IBT_CM_AP_REDIRECT; 8133 /* copy redirect info to APR */ 8134 apr_msg->apr_addl_info_len = sizeof (ibcm_classportinfo_msg_t); 8135 ibcm_init_clp_to_mad( 8136 (ibcm_classportinfo_msg_t *)apr_msg->apr_addl_info, 8137 &clnt_info->reply_event->apr); 8138 } else if (cb_status == IBT_CM_NO_RESOURCE) { 8139 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8140 } else { 8141 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_lap_cm_hdlr: statep %p" 8142 " Client handler unexpected return %x", statep, cb_status); 8143 cb_status = IBT_CM_REJECT; 8144 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8145 } 8146 8147 IBTF_DPRINTF_L4(cmlog, "ibcm_process_cep_lap_cm_hdlr: statep 0x%p " 8148 " client handler returned %d, apr status %d", statep, cb_status, 8149 apr_msg->apr_ap_status); 8150 8151 /* copy private data to outgoing apr, specified via priv_data */ 8152 if ((clnt_info->priv_data != NULL) && (clnt_info->priv_data_len > 0)) 8153 bcopy(clnt_info->priv_data, apr_msg->apr_private_data, 8154 min(clnt_info->priv_data_len, IBT_APR_PRIV_DATA_SZ)); 8155 8156 if (cb_status != IBT_CM_ACCEPT) 8157 return; 8158 8159 if (ibt_query_qp(statep->channel, &qp_attrs) != IBT_SUCCESS || 8160 (qp_attrs.qp_info.qp_state != IBT_STATE_RTS && 8161 qp_attrs.qp_info.qp_state != IBT_STATE_SQD)) { 8162 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8163 return; 8164 } 8165 8166 /* Fill up input args for ibt_modify_qp */ 8167 cep_flags = IBT_CEP_SET_ALT_PATH | IBT_CEP_SET_STATE; 8168 8169 /* do RTS=>RTS or SQD=>SQD. The next line is needed for RTS=>RTS. */ 8170 qp_attrs.qp_info.qp_current_state = qp_attrs.qp_info.qp_state; 8171 8172 adds = &IBCM_QP_RC(qp_attrs).rc_alt_path.cep_adds_vect; 8173 ibcm_fill_adds_from_lap(adds, lap_msg, IBCM_PASSIVE_MODE); 8174 8175 if ((status = ibtl_cm_get_hca_port(adds->av_sgid, 8176 statep->local_hca_guid, &port)) != IBT_SUCCESS) { 8177 8178 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_lap_cm_hdlr:" 8179 " ibtl_cm_get_hca_port failed status %d", status); 8180 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8181 return; 8182 } 8183 8184 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_hca_port_num = port.hp_port; 8185 8186 IBTF_DPRINTF_L4(cmlog, "ibcm_process_cep_lap_cm_hdlr: statep 0x%p " 8187 "gid = (%llx, %llx), port_num = %d", statep, 8188 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_adds_vect.av_dgid. 8189 gid_prefix, 8190 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_adds_vect.av_dgid.gid_guid, 8191 port.hp_port); 8192 8193 /* The pkey is same as the primary path */ 8194 status = ibt_pkey2index_byguid(statep->local_hca_guid, 8195 port.hp_port, statep->pkey, 8196 &IBCM_QP_RC(qp_attrs).rc_alt_path.cep_pkey_ix); 8197 8198 if (status != IBT_SUCCESS) { 8199 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_lap_cm_hdlr: statep %p" 8200 " ibt_pkey2index_byguid failed %d", statep, status); 8201 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8202 return; 8203 } 8204 8205 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_timeout = 8206 lap_msg->lap_alt_local_acktime_plus >> 3; 8207 8208 qp_attrs.qp_info.qp_trans = IBT_RC_SRV; 8209 if (IBCM_QP_RC(qp_attrs).rc_mig_state == IBT_STATE_MIGRATED) { 8210 IBTF_DPRINTF_L3(cmlog, "ibcm_process_cep_lap_cm_hdlr: statep %p" 8211 ": rearming APM", statep); 8212 cep_flags |= IBT_CEP_SET_MIG; 8213 IBCM_QP_RC(qp_attrs).rc_mig_state = IBT_STATE_REARMED; 8214 } 8215 status = ibt_modify_qp(statep->channel, cep_flags, &qp_attrs.qp_info, 8216 NULL); 8217 8218 if (status != IBT_SUCCESS) { 8219 ibcm_insert_trace(statep, IBCM_TRACE_SET_ALT_FAIL); 8220 } else 8221 ibcm_insert_trace(statep, IBCM_TRACE_SET_ALT); 8222 8223 #ifdef DEBUG 8224 (void) ibt_query_qp(statep->channel, &qp_attrs); 8225 print_modify_qp("PASSIVE LAP QUERY", statep->channel, 8226 cep_flags, &qp_attrs.qp_info); 8227 #endif 8228 8229 if (status != IBT_SUCCESS) { 8230 apr_msg->apr_ap_status = IBT_CM_AP_REJECT; 8231 IBTF_DPRINTF_L2(cmlog, "ibcm_process_cep_lap_cm_hdlr:" 8232 " ibt_modify_qp() returned = %d", status); 8233 return; 8234 } 8235 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*apr_msg)) 8236 } 8237 8238 8239 /* 8240 * ibcm_post_apr_mad: 8241 * Posts a APR MAD and starts timer 8242 * 8243 * INPUTS: 8244 * statep - state pointer 8245 * 8246 * RETURN VALUE: NONE 8247 */ 8248 void 8249 ibcm_post_apr_mad(ibcm_state_data_t *statep) 8250 { 8251 ibcm_apr_msg_t *apr_msgp; 8252 8253 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*apr_msgp)) 8254 8255 apr_msgp = (ibcm_apr_msg_t *)IBCM_OUT_MSGP(statep->lapr_msg); 8256 8257 apr_msgp->apr_local_comm_id = h2b32(statep->local_comid); 8258 apr_msgp->apr_remote_comm_id = h2b32(statep->remote_comid); 8259 IBCM_OUT_HDRP(statep->lapr_msg)->AttributeID = 8260 h2b16(IBCM_INCOMING_APR + IBCM_ATTR_BASE_ID); 8261 8262 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*apr_msgp)) 8263 8264 ibcm_insert_trace(statep, IBCM_TRACE_OUTGOING_APR); 8265 8266 ibcm_post_rc_mad(statep, statep->lapr_msg, ibcm_post_apr_complete, 8267 statep); 8268 } 8269 8270 /* 8271 * ibcm_process_apr_msg: 8272 * This call processes an incoming APR message 8273 * 8274 * INPUTS: 8275 * hcap - HCA entry pointer 8276 * input_madp - incoming CM SIDR REP MAD 8277 * cm_mad_addr - Address information for the MAD to be posted 8278 * 8279 * RETURN VALUE: NONE 8280 */ 8281 /*ARGSUSED*/ 8282 void 8283 ibcm_process_apr_msg(ibcm_hca_info_t *hcap, uint8_t *input_madp, 8284 ibcm_mad_addr_t *cm_mad_addr) 8285 { 8286 ibcm_status_t state_lookup_status; 8287 ibcm_apr_msg_t *apr_msg = (ibcm_apr_msg_t *) 8288 (&input_madp[IBCM_MAD_HDR_SIZE]); 8289 ibcm_state_data_t *statep = NULL; 8290 8291 IBTF_DPRINTF_L4(cmlog, "ibcm_process_apr_msg:"); 8292 8293 rw_enter(&hcap->hca_state_rwlock, RW_READER); 8294 state_lookup_status = ibcm_lookup_msg(IBCM_INCOMING_APR, 8295 b2h32(apr_msg->apr_remote_comm_id), 0, 0, hcap, &statep); 8296 rw_exit(&hcap->hca_state_rwlock); 8297 8298 if (state_lookup_status != IBCM_LOOKUP_EXISTS) { 8299 return; 8300 } 8301 8302 /* if transaction id is not as expected, drop the APR mad */ 8303 if (IBCM_OUT_HDRP(statep->lapr_msg)->TransactionID != 8304 ((ib_mad_hdr_t *)(input_madp))->TransactionID) { 8305 mutex_enter(&statep->state_mutex); 8306 IBCM_REF_CNT_DECR(statep); 8307 mutex_exit(&statep->state_mutex); 8308 IBTF_DPRINTF_L3(cmlog, "ibcm_process_apr_msg: statep 0x%p" 8309 ": rcv'd APR MAD with comid 0x%x", 8310 statep, b2h32(apr_msg->apr_remote_comm_id)); 8311 IBTF_DPRINTF_L3(cmlog, "ibcm_process_apr_msg: " 8312 "tid expected 0x%llX tid found 0x%llX", 8313 b2h64(IBCM_OUT_HDRP(statep->lapr_msg)->TransactionID), 8314 b2h64(((ib_mad_hdr_t *)(input_madp))->TransactionID)); 8315 return; 8316 } 8317 8318 IBTF_DPRINTF_L4(cmlog, "ibcm_process_apr_msg: statep 0x%p " 8319 "lookup status %x", statep, state_lookup_status); 8320 8321 mutex_enter(&statep->state_mutex); 8322 8323 if (!((statep->state == IBCM_STATE_ESTABLISHED) && 8324 ((statep->ap_state == IBCM_AP_STATE_LAP_SENT) || 8325 (statep->ap_state == IBCM_AP_STATE_MRA_LAP_RCVD)))) { 8326 IBCM_REF_CNT_DECR(statep); /* decrement the ref count */ 8327 mutex_exit(&statep->state_mutex); 8328 return; 8329 } 8330 8331 statep->ap_state = IBCM_AP_STATE_APR_RCVD; 8332 8333 /* cancel the LAP timer */ 8334 if (statep->timerid != 0) { 8335 timeout_id_t timer_val; 8336 timer_val = statep->timerid; 8337 statep->timerid = 0; 8338 mutex_exit(&statep->state_mutex); 8339 (void) untimeout(timer_val); 8340 } else { 8341 mutex_exit(&statep->state_mutex); 8342 } 8343 8344 ibcm_insert_trace(statep, IBCM_TRACE_INCOMING_APR); 8345 8346 ibcm_cep_state_apr(statep, 8347 (ibcm_lap_msg_t *)IBCM_OUT_MSGP(statep->lapr_msg), apr_msg); 8348 8349 mutex_enter(&statep->state_mutex); 8350 statep->ap_state = IBCM_AP_STATE_IDLE; 8351 8352 /* unblock any DREQ threads and close channels */ 8353 cv_broadcast(&statep->block_mad_cv); 8354 8355 statep->ap_done = B_TRUE; 8356 8357 /* wake up blocking ibt_set_alt_path */ 8358 cv_broadcast(&statep->block_client_cv); 8359 8360 IBCM_REF_CNT_DECR(statep); /* decrement the ref count */ 8361 mutex_exit(&statep->state_mutex); 8362 } 8363 8364 static void 8365 ibcm_set_apr_arej(int ap_status, ibcm_apr_msg_t *apr_msgp, 8366 ibt_arej_info_t *ari, boolean_t *ari_valid) 8367 { 8368 uint8_t ari_len = apr_msgp->apr_addl_info_len; 8369 ibcm_classportinfo_msg_t tclp; 8370 8371 *ari_valid = B_FALSE; 8372 8373 IBTF_DPRINTF_L3(cmlog, "ibcm_set_apr_arej: apr_status = %d " 8374 "ari_len = %d", ap_status, ari_len); 8375 8376 _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ari)) 8377 8378 switch (ap_status) { 8379 case IBT_CM_AP_REDIRECT: 8380 if (ari_len < sizeof (ibcm_classportinfo_msg_t)) 8381 break; 8382 *ari_valid = B_TRUE; 8383 bcopy(apr_msgp->apr_addl_info, &tclp, sizeof (tclp)); 8384 ibcm_init_clp_from_mad(&tclp, &ari->ari_redirect); 8385 break; 8386 case IBT_CM_AP_RLID_REJECTED: 8387 if (ari_len < sizeof (ib_lid_t)) 8388 break; 8389 *ari_valid = B_TRUE; 8390 bcopy(apr_msgp->apr_addl_info, &ari->ari_lid, 8391 sizeof (ib_lid_t)); 8392 ari->ari_lid = b2h16(ari->ari_lid); 8393 break; 8394 case IBT_CM_AP_RGID_REJECTED: 8395 if (ari_len < sizeof (ib_gid_t)) 8396 break; 8397 *ari_valid = B_TRUE; 8398 bcopy(apr_msgp->apr_addl_info, &ari->ari_gid, 8399 sizeof (ib_gid_t)); 8400 ari->ari_gid.gid_guid = b2h64(ari->ari_gid.gid_guid); 8401 ari->ari_gid.gid_prefix = b2h64(ari->ari_gid.gid_prefix); 8402 8403 IBTF_DPRINTF_L4(cmlog, "ibcm_set_apr_arej: ari_gid= %llX:%llX", 8404 ari->ari_gid.gid_prefix, ari->ari_gid.gid_guid); 8405 break; 8406 case IBT_CM_AP_FLOW_REJECTED: 8407 if (ari_len < 3) /* 3 bytes needed for 20 bits */ 8408 break; 8409 *ari_valid = B_TRUE; 8410 /* take the first 20 bits */ 8411 ari->ari_flow = 8412 b2h32(*(uint32_t *)&apr_msgp->apr_addl_info) >> 12; 8413 break; 8414 case IBT_CM_AP_TCLASS_REJECTED: 8415 if (ari_len < 1) 8416 break; 8417 *ari_valid = B_TRUE; 8418 /* take the first byte */ 8419 ari->ari_tclass = apr_msgp->apr_addl_info[0]; 8420 break; 8421 case IBT_CM_AP_HOP_REJECTED: 8422 if (ari_len < 1) 8423 break; 8424 *ari_valid = B_TRUE; 8425 /* take the first byte */ 8426 ari->ari_hop = apr_msgp->apr_addl_info[0]; 8427 break; 8428 case IBT_CM_AP_RATE_REJECTED: 8429 if (ari_len < 1) 8430 break; 8431 *ari_valid = B_TRUE; 8432 /* take the first 6 bits */ 8433 ari->ari_rate = apr_msgp->apr_addl_info[0] >> 2; 8434 break; 8435 case IBT_CM_AP_SL_REJECTED: 8436 if (ari_len < 1) 8437 break; 8438 *ari_valid = B_TRUE; 8439 /* take the first 4 bits */ 8440 ari->ari_sl = apr_msgp->apr_addl_info[0] >> 4; 8441 break; 8442 default: 8443 break; 8444 } 8445 _NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*ari)) 8446 } 8447 8448 /* 8449 * ibcm_cep_state_apr: 8450 * This call processes an incoming APR message 8451 * 8452 * INPUTS: 8453 * statep - pointer to ibcm_state_data_t 8454 * lap_msg - lap msg sent earlier 8455 * apr_msg - apr msg received 8456 * 8457 * RETURN VALUE: NONE 8458 */ 8459 void 8460 ibcm_cep_state_apr(ibcm_state_data_t *statep, ibcm_lap_msg_t *lap_msg, 8461 ibcm_apr_msg_t *apr_msg) 8462 { 8463 ibt_cm_event_t event; 8464 ibcm_status_t status = IBCM_SUCCESS; 8465 uint8_t ap_status = apr_msg->apr_ap_status; 8466 8467 IBTF_DPRINTF_L3(cmlog, "ibcm_cep_state_apr: statep 0x%p, ap_status %d", 8468 statep, ap_status); 8469 8470 if (ap_status == IBT_CM_AP_LOADED) 8471 status = ibcm_set_qp_from_apr(statep, lap_msg); 8472 8473 if (statep->ap_return_data != NULL) { /* blocking call */ 8474 8475 /* copy the private data */ 8476 if ((statep->ap_return_data->ap_priv_data != NULL) && 8477 (statep->ap_return_data->ap_priv_data_len > 0)) 8478 bcopy(apr_msg->apr_private_data, 8479 statep->ap_return_data->ap_priv_data, 8480 statep->ap_return_data->ap_priv_data_len); 8481 8482 /* initialize the ap status */ 8483 if (status == IBCM_FAILURE) { 8484 statep->ap_return_data->ap_status = IBT_CM_AP_REJECT; 8485 statep->ap_return_data->ap_arej_info_valid = B_FALSE; 8486 } else { 8487 statep->ap_return_data->ap_status = ap_status; 8488 ibcm_set_apr_arej(ap_status, apr_msg, 8489 &statep->ap_return_data->ap_arej_info, 8490 &statep->ap_return_data->ap_arej_info_valid); 8491 } 8492 8493 /* do a cv signal for a blocking ibt_set_alt_path */ 8494 mutex_enter(&statep->state_mutex); 8495 statep->ap_done = B_TRUE; 8496 cv_broadcast(&statep->block_client_cv); 8497 mutex_exit(&statep->state_mutex); 8498 8499 } else { /* Non blocking call */ 8500 /* Fill up the event */ 8501 8502 bzero(&event, sizeof (event)); 8503 event.cm_type = IBT_CM_EVENT_APR_RCV; 8504 event.cm_channel = statep->channel; 8505 event.cm_session_id = NULL; 8506 event.cm_priv_data = apr_msg->apr_private_data; 8507 event.cm_priv_data_len = IBT_APR_PRIV_DATA_SZ; 8508 if (status == IBCM_FAILURE) { 8509 event.cm_event.apr.apr_status = IBT_CM_AP_REJECT; 8510 event.cm_event.apr.apr_arej_info_valid = B_FALSE; 8511 } else { 8512 event.cm_event.apr.apr_status = ap_status; 8513 ibcm_set_apr_arej(ap_status, apr_msg, 8514 &event.cm_event.apr.apr_arej_info, 8515 &event.cm_event.apr.apr_arej_info_valid); 8516 } 8517 8518 /* initialize the ap status */ 8519 statep->cm_handler(statep->state_cm_private, &event, 8520 NULL, apr_msg->apr_private_data, IBT_APR_PRIV_DATA_SZ); 8521 } 8522 mutex_enter(&statep->state_mutex); 8523 ibcm_open_done(statep); 8524 mutex_exit(&statep->state_mutex); 8525 } 8526 8527 /* 8528 * ibcm_set_qp_from_apr: 8529 * This call sets QP's alt path info based on APR message contents 8530 * 8531 * INPUTS: 8532 * statep - pointer to ibcm_state_data_t 8533 * lap_msg - lap msg sent earlier 8534 * 8535 * RETURN VALUE: ibcm_status_t 8536 */ 8537 static ibcm_status_t 8538 ibcm_set_qp_from_apr(ibcm_state_data_t *statep, ibcm_lap_msg_t *lap_msg) 8539 { 8540 ibtl_cm_hca_port_t port; 8541 ibt_adds_vect_t *adds; 8542 8543 ibt_qp_query_attr_t qp_attrs; 8544 ibt_cep_modify_flags_t cep_flags; 8545 ibt_status_t status; 8546 8547 IBTF_DPRINTF_L3(cmlog, "ibcm_set_qp_from_apr: statep 0x%p", statep); 8548 8549 status = ibt_query_qp(statep->channel, &qp_attrs); 8550 if (status != IBT_SUCCESS || 8551 (qp_attrs.qp_info.qp_state != IBT_STATE_RTS && 8552 qp_attrs.qp_info.qp_state != IBT_STATE_SQD)) { 8553 IBTF_DPRINTF_L2(cmlog, "ibcm_set_qp_from_apr: ibt_query_qp " 8554 "failed, status = %d, qp_state = %d", statep, status, 8555 qp_attrs.qp_info.qp_state); 8556 return (IBCM_FAILURE); 8557 } 8558 8559 /* Fill up input args for ibt_modify_qp */ 8560 cep_flags = IBT_CEP_SET_ALT_PATH | IBT_CEP_SET_STATE; 8561 8562 /* do RTS=>RTS or SQD=>SQD. The next line is needed for RTS=>RTS. */ 8563 qp_attrs.qp_info.qp_current_state = qp_attrs.qp_info.qp_state; 8564 8565 /* Fill up input args for ibt_modify_qp */ 8566 adds = &IBCM_QP_RC(qp_attrs).rc_alt_path.cep_adds_vect; 8567 8568 ibcm_fill_adds_from_lap(adds, lap_msg, IBCM_ACTIVE_MODE); 8569 8570 if ((status = ibtl_cm_get_hca_port(adds->av_sgid, 8571 statep->local_hca_guid, &port)) != IBT_SUCCESS) { 8572 IBTF_DPRINTF_L2(cmlog, "ibcm_set_qp_from_apr: " 8573 "ibtl_cm_get_hca_port failed status = %d", status); 8574 IBTF_DPRINTF_L5(cmlog, "ibcm_set_qp_from_apr:" 8575 " ibtl_cm_get_hca_port sgid guid %llX", 8576 adds->av_sgid.gid_guid); 8577 IBTF_DPRINTF_L5(cmlog, "ibcm_set_qp_from_apr:" 8578 " ibtl_cm_get_hca_port sgid prefix %llX ", 8579 adds->av_sgid.gid_prefix); 8580 return (IBCM_FAILURE); 8581 } 8582 8583 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_hca_port_num = 8584 port.hp_port; 8585 8586 IBTF_DPRINTF_L4(cmlog, "ibcm_set_qp_from_apr: " 8587 "gid = %llx:%llx, port_num = %d", 8588 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_adds_vect.av_sgid. 8589 gid_prefix, 8590 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_adds_vect.av_sgid.gid_guid, 8591 port.hp_port); 8592 8593 /* The pkey is same as the primary path */ 8594 status = ibt_pkey2index_byguid(statep->local_hca_guid, 8595 port.hp_port, statep->pkey, 8596 &IBCM_QP_RC(qp_attrs).rc_alt_path.cep_pkey_ix); 8597 8598 if (status != IBT_SUCCESS) { 8599 IBTF_DPRINTF_L2(cmlog, "ibcm_set_qp_from_apr: " 8600 "ibt_pkey2index_byguid failed %d", status); 8601 return (IBCM_FAILURE); 8602 } 8603 qp_attrs.qp_info.qp_trans = IBT_RC_SRV; 8604 IBCM_QP_RC(qp_attrs).rc_alt_path.cep_timeout = 8605 ibt_usec2ib(statep->remote_ack_delay + 8606 2 * statep->rc_alt_pkt_lt); 8607 if (IBCM_QP_RC(qp_attrs).rc_mig_state == IBT_STATE_MIGRATED) { 8608 /* Need to rearm */ 8609 IBTF_DPRINTF_L3(cmlog, "ibcm_set_qp_from_apr: statep 0x%p: " 8610 "rearming APM", statep); 8611 cep_flags |= IBT_CEP_SET_MIG; 8612 IBCM_QP_RC(qp_attrs).rc_mig_state = IBT_STATE_REARMED; 8613 } 8614 8615 status = ibt_modify_qp(statep->channel, cep_flags, &qp_attrs.qp_info, 8616 NULL); 8617 8618 if (status != IBT_SUCCESS) 8619 ibcm_insert_trace(statep, IBCM_TRACE_SET_ALT_FAIL); 8620 else 8621 ibcm_insert_trace(statep, IBCM_TRACE_SET_ALT); 8622 8623 #ifdef DEBUG 8624 (void) ibt_query_qp(statep->channel, &qp_attrs); 8625 print_modify_qp("ACTIVE LAP QUERY", statep->channel, 8626 cep_flags, &qp_attrs.qp_info); 8627 #endif 8628 8629 if (status != IBT_SUCCESS) { 8630 IBTF_DPRINTF_L2(cmlog, "ibcm_set_qp_from_apr:" 8631 " ibt_modify_qp() failed, status = %d", status); 8632 return (IBCM_FAILURE); 8633 } 8634 8635 return (IBCM_SUCCESS); 8636 } 8637 8638 /* 8639 * ibcm_sync_lapr_idle: 8640 * 8641 * This call either cancels a LAP/APR operation or waits 8642 * until the operation is complete 8643 * 8644 * INPUTS: 8645 * statep Pointer to ibcm_state_data_t 8646 * 8647 * RETURN VALUE: NONE 8648 * 8649 * This function is called holding state mutex 8650 * This function returns, releasing the state mutex 8651 */ 8652 void 8653 ibcm_sync_lapr_idle(ibcm_state_data_t *statep) 8654 { 8655 timeout_id_t timer_val = statep->timerid; 8656 ibt_cm_event_t event; 8657 8658 IBTF_DPRINTF_L3(cmlog, "ibcm_sync_lapr_idle:" 8659 "statep %p state %d ap_state %d", statep, statep->state, 8660 statep->ap_state); 8661 8662 ASSERT(MUTEX_HELD(&statep->state_mutex)); 8663 _NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&statep->state_mutex)) 8664 8665 /* Busy AP states on active/passive sides */ 8666 if ((statep->ap_state == IBCM_AP_STATE_LAP_RCVD) || 8667 (statep->ap_state == IBCM_AP_STATE_APR_RCVD) || 8668 (statep->ap_state == IBCM_AP_STATE_MRA_LAP_SENT) || 8669 (statep->ap_state == IBCM_AP_STATE_TIMED_OUT)) { 8670 8671 /* wait till ap_state becomes IBCM_AP_STATE_IDLE */ 8672 while (statep->ap_state != IBCM_AP_STATE_IDLE) 8673 cv_wait(&statep->block_mad_cv, &statep->state_mutex); 8674 8675 mutex_exit(&statep->state_mutex); 8676 8677 } else if ((statep->ap_state == IBCM_AP_STATE_LAP_SENT) || 8678 (statep->ap_state == IBCM_AP_STATE_MRA_LAP_RCVD)) { 8679 8680 /* fail the client's ibt_set_alt_path */ 8681 8682 /* blocking ibt_set_alt_path */ 8683 if (statep->ap_return_data != NULL) { 8684 statep->ap_return_data->ap_status = 8685 IBT_CM_AP_ABORT; 8686 statep->ap_state = IBCM_AP_STATE_IDLE; 8687 cv_broadcast(&statep->block_client_cv); 8688 IBTF_DPRINTF_L3(cmlog, "ibcm_sync_lapr_idle:" 8689 "blocked wait"); 8690 } 8691 8692 statep->timerid = 0; 8693 /* Cancel the timeout */ 8694 mutex_exit(&statep->state_mutex); 8695 if (timer_val != 0) 8696 (void) untimeout(timer_val); 8697 8698 /* Non blocking ibt_set_alt_path */ 8699 if (statep->ap_return_data == NULL) { 8700 8701 /* Fill up the event */ 8702 8703 bzero(&event, sizeof (event)); 8704 event.cm_type = IBT_CM_EVENT_APR_RCV; 8705 event.cm_channel = statep->channel; 8706 event.cm_session_id = NULL; 8707 event.cm_priv_data = NULL; 8708 event.cm_priv_data_len = 0; 8709 event.cm_event.apr.apr_status = IBT_CM_AP_ABORT; 8710 8711 /* Call the cm handler */ 8712 statep->cm_handler(statep->state_cm_private, &event, 8713 NULL, NULL, 0); 8714 IBTF_DPRINTF_L3(cmlog, "ibcm_sync_lapr_idle:" 8715 "non-blocked wait"); 8716 } 8717 } else mutex_exit(&statep->state_mutex); 8718 8719 ASSERT(!MUTEX_HELD(&statep->state_mutex)); 8720 } 8721 8722 #ifdef DEBUG 8723 8724 /* 8725 * Debug function used to print all the modify qp attributes. 8726 * Useful to manually verify the modify qp parameters are as 8727 * expected 8728 */ 8729 static void 8730 print_modify_qp(char *prefix, ibt_qp_hdl_t ibt_qp, 8731 ibt_cep_modify_flags_t flags, ibt_qp_info_t *qp_attr) 8732 { 8733 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP %s %p", prefix, ibt_qp); 8734 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP flags 0x%x", flags); 8735 8736 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP " 8737 "rc_rdma_ra_in %d rc_rdma_ra_out %d", 8738 qp_attr->qp_transport.rc.rc_rdma_ra_in, 8739 qp_attr->qp_transport.rc.rc_rdma_ra_out); 8740 8741 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP primary: " 8742 "port %d path bits %d dlid %X", 8743 qp_attr->qp_transport.rc.rc_path.cep_hca_port_num, 8744 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_src_path, 8745 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_dlid); 8746 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP primary: " 8747 "pkey index %d cep_timeout %d", 8748 qp_attr->qp_transport.rc.rc_path.cep_pkey_ix, 8749 qp_attr->qp_transport.rc.rc_path.cep_timeout); 8750 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP primary: " 8751 "srvl %d flow label %d tclass %d", 8752 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_srvl, 8753 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_flow, 8754 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_tclass); 8755 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP primary: " 8756 "hop %d srate %d sgid_ix %d send_grh %d", 8757 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_hop, 8758 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_srate, 8759 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_sgid_ix, 8760 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_send_grh); 8761 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP primary: " 8762 "dgid prefix %llX dgid guid %llX", 8763 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_dgid.gid_prefix, 8764 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_dgid.gid_guid); 8765 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP primary: " 8766 "sgid prefix %llX sgid guid %llX", 8767 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_sgid.gid_prefix, 8768 qp_attr->qp_transport.rc.rc_path.cep_adds_vect.av_sgid.gid_guid); 8769 8770 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP alternate: " 8771 "port %d path bits %d dlid %X", 8772 qp_attr->qp_transport.rc.rc_alt_path.cep_hca_port_num, 8773 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_src_path, 8774 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_dlid); 8775 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP alternate: " 8776 "pkey index %d cep_timeout %d", 8777 qp_attr->qp_transport.rc.rc_alt_path.cep_pkey_ix, 8778 qp_attr->qp_transport.rc.rc_alt_path.cep_timeout); 8779 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP alternate: " 8780 "srvl %d flow label %d tclass %d", 8781 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_srvl, 8782 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_flow, 8783 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_tclass); 8784 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP alternate: " 8785 "hop %d srate %d sgid_ix %d send_grh %d", 8786 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_hop, 8787 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_srate, 8788 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_sgid_ix, 8789 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_send_grh); 8790 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP alternate: " 8791 "dgid prefix %llX dgid guid %llX", 8792 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_dgid. 8793 gid_prefix, 8794 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_dgid. 8795 gid_guid); 8796 IBTF_DPRINTF_L4(cmlog, "PRINT_MODIFY_QP alternate: " 8797 "sgid prefix %llX sgid guid %llX", 8798 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_sgid. 8799 gid_prefix, 8800 qp_attr->qp_transport.rc.rc_alt_path.cep_adds_vect.av_sgid. 8801 gid_guid); 8802 } 8803 #endif 8804