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 #ifndef _SYS_IB_MGT_IBCM_IBCM_IMPL_H 26 #define _SYS_IB_MGT_IBCM_IBCM_IMPL_H 27 28 /* 29 * ibcm_impl.h 30 * 31 * This file contains all of the internal data structures and 32 * definitions for IBCM. 33 * 34 * The general state transition processing of CM is achieved by the 35 * following callgraph: 36 * 37 * CM INIT : Register for hca attach and detach callbacks, and other asyncs 38 * 39 * On new HCA attach: Register with IBMF on all ports of upcoming HCA 40 * Specify CM callback and callback "per HCA arg" 41 * Register with SA, allocate AVL trees etc. 42 * 43 * IBMF Callback 44 * Validate combination of method and attribute Id in the generic MAD hdr 45 * -> Call CM Connection state transition function based on attribute ID 46 * Create/lookup/delete CM state structure and save it into avl tree 47 * Handle duplicate messages and MRA to adjust timers etc. 48 * Handle stale connections 49 * Allocate reply MADs 50 * -> Call CM QP/EEC state transition function based on CM message 51 * Change QP/EEC state (to enable recvQ posting by client) 52 * Call Client/Server handler callback function 53 * Modify QP/EEC attributes 54 * Optionally fill up some fields of response MAD 55 * Post reply MADs 56 * Store reply MADs and reply MAD address, if necessary 57 * Initialize timeouts for the message 58 * Change CM state 59 * Deallocate reply MADs 60 * 61 * NOTES: 62 * o There are *NO* explicit CM allocation and deallocation routines for 63 * CM MADs and state data structures 64 * o CM timeouts are scheduled using timeout(9f), and cancelled using 65 * untimeout(9f) 66 * o svc_id allocation scheme 67 * A new counter for svcid is maintained in ibcm_hca_info_t 68 * which is used to allocate svcid. The svcids are incremented 69 * sequentially and allocated (with wrap around on overflow) with 70 * these considerations: 71 * The WellKnown service id's and locally allocated svcid's 72 * could be maintained in separate lists, thus allowing the 73 * lists to be kept apart and sorted easily. 74 * The insertions are done at the end of the list 75 * o reqid allocation scheme 76 * The list is a sorted one (as reqid's are allocated sequentially). 77 * If there is a code required for wrap around, it would search for 78 * a reqid from the head of the list. 79 * The insertions are always done at the end of the lists 80 * o XXX svc_id allocation scheme and req_id allocation scheme will 81 * be revisited. 82 */ 83 84 #include <sys/sysmacros.h> 85 #include <sys/systm.h> 86 #include <sys/kmem.h> 87 #include <sys/modctl.h> 88 #include <sys/avl.h> 89 #include <sys/taskq.h> 90 #include <sys/vmem.h> 91 #include <sys/note.h> 92 #include <sys/t_lock.h> 93 94 #include <sys/ib/ibtl/ibvti.h> 95 #include <sys/ib/ibtl/impl/ibtl_cm.h> 96 #include <sys/ib/ibtl/impl/ibtl_util.h> 97 #include <sys/ib/mgt/ibmf/ibmf.h> 98 #include <sys/ib/mgt/ibcm/ibcm_trace.h> 99 #include <inet/ip.h> 100 101 #ifdef __cplusplus 102 extern "C" { 103 #endif 104 105 _NOTE(SCHEME_PROTECTS_DATA("Private", sa_service_record_s)) 106 _NOTE(SCHEME_PROTECTS_DATA("Exclusive access to ibmf msg buf based on state", 107 ib_mad_hdr_t)) 108 _NOTE(SCHEME_PROTECTS_DATA("Exclusive access to ibmf msg buf based on state", 109 _ibmf_msg)) 110 111 /* 112 * Defines for all CM state machine states, as defined in 113 * section 12.9.7. IBCM_REJ_SENT is a state not defined in 114 * the spec and is added for implementation purposes. 115 */ 116 typedef enum ibcm_conn_state_e { 117 /* Initial states */ 118 IBCM_STATE_IDLE = 0, 119 IBCM_STATE_LISTEN, 120 121 /* States during connection establishment */ 122 IBCM_STATE_REQ_SENT, 123 IBCM_STATE_REQ_RCVD, 124 IBCM_STATE_REP_SENT, 125 IBCM_STATE_REP_RCVD, 126 IBCM_STATE_REP_WAIT, 127 IBCM_STATE_MRA_SENT, 128 IBCM_STATE_MRA_REP_SENT, 129 IBCM_STATE_MRA_REP_RCVD, 130 131 /* States during connection establishment failures */ 132 IBCM_STATE_TIMED_OUT, 133 IBCM_STATE_ABORTED, 134 IBCM_STATE_REJ_SENT, 135 136 /* Established state */ 137 IBCM_STATE_TRANSIENT_ESTABLISHED, 138 IBCM_STATE_ESTABLISHED, 139 140 /* States during connection teardown */ 141 IBCM_STATE_TRANSIENT_DREQ_SENT, 142 IBCM_STATE_DREQ_SENT, 143 IBCM_STATE_DREQ_RCVD, 144 IBCM_STATE_DREP_RCVD, 145 IBCM_STATE_TIMEWAIT, 146 147 /* states for UD side of things */ 148 IBCM_STATE_SIDR_REQ_SENT, 149 IBCM_STATE_SIDR_REQ_RCVD, 150 IBCM_STATE_SIDR_REP_SENT, 151 IBCM_STATE_SIDR_REP_RCVD, 152 153 /* states common to RC and UD, during state resource deletion */ 154 IBCM_STATE_DELETE 155 } ibcm_conn_state_t; 156 157 /* Defines the AP states for LAP/APR */ 158 typedef enum ibcm_ap_state_e { 159 IBCM_AP_STATE_IDLE = 0x0, 160 IBCM_AP_STATE_LAP_SENT, 161 IBCM_AP_STATE_LAP_RCVD, 162 IBCM_AP_STATE_APR_RCVD, 163 IBCM_AP_STATE_MRA_LAP_RCVD, 164 IBCM_AP_STATE_MRA_LAP_SENT, 165 IBCM_AP_STATE_TIMED_OUT 166 } ibcm_ap_state_t; 167 168 /* 169 * Defines for the CM event types/MAD attribute IDs 170 */ 171 typedef enum ibcm_event_type_e { 172 IBCM_INCOMING_REQ = 0x0, 173 IBCM_INCOMING_MRA = 0x1, 174 IBCM_INCOMING_REJ = 0x2, 175 IBCM_INCOMING_REP = 0x3, 176 IBCM_INCOMING_RTU = 0x4, 177 IBCM_INCOMING_DREQ = 0x5, 178 IBCM_INCOMING_DREP = 0x6, 179 IBCM_INCOMING_SIDR_REQ = 0x7, 180 IBCM_INCOMING_SIDR_REP = 0x8, 181 IBCM_INCOMING_LAP = 0x9, 182 IBCM_INCOMING_APR = 0xA, 183 IBCM_OUTGOING_REQ = 0xB, /* REQ Sent on active CM side */ 184 IBCM_INCOMING_REQ_STALE = 0xC, /* lookup by remote HCA and */ 185 /* remote comid */ 186 IBCM_INCOMING_REP_STALE = 0xD, /* lookup by passive HCA and QPN */ 187 IBCM_INCOMING_REJ_RCOMID = 0xE /* lookup by remote com id */ 188 } ibcm_event_type_t; 189 190 /* 191 * IBMF calls back into CM on only the first 11 events defined in 192 * ibcm_event_type_t. CM has pre-defined functions for these 11 events 193 * 194 */ 195 #define IBCM_MAX_EVENTS 11 196 197 /* 198 * CM message attribute IDs begin at this "base ID". The first 11 event types 199 * in ibcm_event_type_t are CM protocol messages that are posted to IBMF by 200 * adding the "base_id" to the respective event type value. By subtracting 201 * the "base_id" in IBMF callback in CM MAD, the message type is gotten back 202 */ 203 #define IBCM_ATTR_BASE_ID 0x10 204 205 #define IBCM_MAX_RETRY_CNT 15 206 #define IBCM_ATTRID_FIELD_SIZE 4 207 #define IBCM_TRANID_PRIV_FIELD_SIZE 28 208 209 #define IBCM_RNR_RETRY_CNT_MASK 0x7 /* 3 bits */ 210 #define IBCM_MAX_RNR_RETRY_CNT 7 211 212 #define IBCM_INITIAL_COMID 1 213 #define IBCM_INITIAL_REQID 1 214 #define IBCM_INITIAL_SID 1 215 216 /* 217 * Maximum number of com ids / req ids that can be active at any given time 218 * MUST ENSURE THAT (INITIAL ID + MAX IDS -1), for any of the IDs does not 219 * exceed the max 32 bit 220 */ 221 222 /* An hca can have max of 2^24 -2 RC connections */ 223 #define IBCM_MAX_COMIDS (0x01000000 - 2) 224 #define IBCM_MAX_REQIDS 0xFFFFFFFF 225 #define IBCM_MAX_LOCAL_SIDS 0xFFFFFFFF 226 #define IBCM_MAX_IP_SIDS 0xFFFF 227 228 typedef uint32_t ib_com_id_t; /* CM Communication ID */ 229 230 /* 231 * Defines the CM Mode of operation for a connection 232 */ 233 typedef enum ibcm_mode_e { 234 IBCM_ACTIVE_MODE = 1, /* Active side CM */ 235 IBCM_PASSIVE_MODE = 2 /* Passive side CM */ 236 } ibcm_mode_t; 237 238 239 /* different IBCM return values */ 240 typedef enum ibcm_status_e { 241 IBCM_SUCCESS = 0, /* good status */ 242 IBCM_LOOKUP_EXISTS, /* statep lookup found existing entry */ 243 IBCM_LOOKUP_NEW, /* lookup created new statep entry */ 244 IBCM_LOOKUP_FAIL, /* lookup found no statep entry */ 245 IBCM_SEND_REJ, /* CM QP state change sent REJ msg */ 246 IBCM_SEND_REP, /* CM QP state change sent REP msg */ 247 IBCM_SEND_RTU, /* CM QP state change sent RTU msg */ 248 IBCM_SEND_APR, /* CM to send APR MAD as response */ 249 IBCM_SEND_SIDR_REP, /* client's UD handler returned this */ 250 IBCM_DEFER, /* client's handler returned this */ 251 IBCM_FAILURE /* generic IBCM failure */ 252 } ibcm_status_t; 253 254 /* 255 * Struct definition for addressing information that CM maintains for 256 * each of the incoming MADs 257 */ 258 typedef struct ibcm_mad_addr { 259 ibmf_global_addr_info_t grh_hdr; /* GRH related fields of MAD */ 260 ibmf_addr_info_t rcvd_addr; /* Outgoing/Incoming MAD addr */ 261 ibmf_handle_t ibmf_hdl; /* IBMF handle */ 262 boolean_t grh_exists; /* TRUE if grh exists */ 263 uint8_t port_num; 264 struct ibcm_qp_list_s *cm_qp_entry; /* IBMF hdl on which MAD rcvd */ 265 /* or on which MAD shall be */ 266 /* sent out */ 267 } ibcm_mad_addr_t; 268 269 _NOTE(READ_ONLY_DATA(ibcm_mad_addr)) 270 271 #define IBCM_MAD_SIZE 0x100 /* size of MAD */ 272 #define IBCM_MAD_HDR_SIZE sizeof (ib_mad_hdr_t) /* size of MAD HDR */ 273 #define IBCM_MSG_SIZE IBCM_MAD_SIZE-IBCM_MAD_HDR_SIZE 274 275 typedef enum ibcm_abort_flag_e { 276 IBCM_ABORT_INIT = 0, /* no abort flag is set */ 277 IBCM_ABORT_CLIENT = 1, /* client requested connection abort */ 278 IBCM_ABORT_REJ = 2 /* REJ received with timeout reason */ 279 } ibcm_abort_flag_t; 280 281 typedef enum ibcm_isync_e { 282 IBCM_BLOCK = 0, /* Block cm operation */ 283 IBCM_UNBLOCK = 1, /* Unblock cm operation */ 284 IBCM_FAIL = 2 /* fail cm operation */ 285 } ibcm_isync_t; 286 287 /* 288 * Define a connection state structure, used by the IBTF CM 289 * to maintain state about connected QPs. 290 * 291 * mode : CM connection mode active/passive 292 * state : CM connection state 293 * ap_state : CM AP Internal state to manage LAP/APR state machine 294 * state_mutex : lock for this structure 295 * channel : Channel associated with this RC state structure 296 * ref_cnt : Number of active threads that may reference this 297 * state structure 298 * svcid : Service ID 299 * cm_handler : Client handler callback address 300 * stored_reply_addr : Address for replying using the stored mad 301 * hcap : A pointer to the HCA's entry 302 * stored_msg : Stores the response REP/REJ/RTU MAD 303 * mra_msg : Stores the response MRA MAD 304 * dreq_msg : Stores the DREQ MAD 305 * drep_msg : Stores the DREP MAD 306 * lapr_msg : Stores the LAP/APR MAD 307 * detect duplicate LAP messages 308 * local_comid : Local communication id 309 * local_hca_guid : Local HCA GUID 310 * local_qpn : Local QPN 311 * 312 * remote_comid : Remote communication id 313 * remote_hca_guid : Remote HCA GUID 314 * remote_qpn : Remote QPN 315 * 316 * timerid : Timer id for the timeout either for re-sending the 317 * stored mad or deleting the stored mad 318 * Ex: A REJ/RTU response for an incoming REP 319 * A REP response to an incoming REQ 320 * An outgoing REQ on active connection side 321 * timer_value : Time for any of the above timers in HZ 322 * pkt_life_time : pkt life time from source to destination 323 * remote_ack_delay : Remote hca's ack delay in clock_t 324 * rc_alt_pkt_lt : Life time for new ALT path specified in LAP 325 * stale_clock : clock used to detect stale vs duplicate REQs 326 * timer_stored_state : state of connection for timeout() validation 327 * timer_stored_ap_state: CM ap_state for timeout validation 328 * remaining_retry_count: Remaining count for retries ie., posting stored MADs 329 * max_cm_retries : Max retry count for sending a REQ/REP/DREQ 330 * delete_mra_msg : Set to TRUE for deletion, if MRA re-send in progress 331 * resend_mad : B_TRUE, if REQ/REP/RTU/REJ MAD re-send is in progress 332 * resend_mra_mad : B_TRUE, if a MRA mad re-sens is in progress 333 * cep_retry_cnt : Retry count for CEP. 334 * stale : B_TRUE, if connection has become stale 335 * blocking_done : B_TRUE, if cv_signal been issued to block_client_cv 336 * clnt_hdl : Clnt_hdl passed in ibt_open_channel 337 * return_data : RC return args, valid for blocking 338 * ibt_open_channel 339 * drep_priv_data; : The pointer to client specified outgoing private 340 * data, from close channel API call 341 * drep_priv_data_len : The length of DREP private data that client would 342 * like to be returned from close channel API call 343 * delete_state_data : B_TRUE, if CM decides to delete state data, but 344 * there is some thread that could access state data 345 * 346 * avl_active_link : For inserting this state-data into active AVL tree 347 * avl_passive_link : For inserting this state-data into passive AVL tree 348 * Note : All timer values that are of type "clock_t" below are in usecs 349 */ 350 typedef struct ibcm_state_data_s { 351 /* for AVL tree */ 352 avl_node_t avl_active_link; 353 avl_node_t avl_passive_link; 354 avl_node_t avl_passive_comid_link; 355 356 /* remote stuff */ 357 ib_guid_t remote_hca_guid; 358 ib_com_id_t remote_comid; 359 ib_qpn_t remote_qpn; 360 361 /* local stuff */ 362 ib_com_id_t local_comid; 363 ib_qpn_t local_qpn; 364 ib_guid_t local_hca_guid; 365 366 ibcm_mode_t mode; 367 ibcm_conn_state_t state; 368 ibcm_ap_state_t ap_state; 369 kmutex_t state_mutex; 370 ibt_channel_hdl_t channel; /* save a copy */ 371 372 /* ref_cnt so others cannot delete a statep that may be referenced */ 373 int ref_cnt; 374 375 ib_svc_id_t svcid; 376 ibt_cm_handler_t cm_handler; 377 378 ibcm_mad_addr_t stored_reply_addr; 379 380 struct ibcm_hca_info_s *hcap; 381 382 ibmf_msg_t *stored_msg; 383 ibmf_msg_t *mra_msg; 384 ibmf_msg_t *dreq_msg; 385 ibmf_msg_t *drep_msg; 386 ibmf_msg_t *lapr_msg; 387 388 void *defer_cm_msg; 389 390 /* timeout related stuff */ 391 timeout_id_t timerid; 392 clock_t timer_value; 393 clock_t pkt_life_time; 394 clock_t remote_ack_delay; 395 clock_t rc_alt_pkt_lt; 396 397 hrtime_t stale_clock; 398 hrtime_t post_time; 399 hrtime_t mra_time; 400 401 ibcm_conn_state_t timer_stored_state; 402 ibcm_ap_state_t timer_stored_ap_state; 403 uint8_t remaining_retry_cnt; 404 uint8_t max_cm_retries; 405 uint8_t cm_retries; 406 407 uint8_t drep_in_progress; 408 409 /* some cep stuff, stored here temporarily during connection est */ 410 uint8_t cep_retry_cnt:3; 411 ibt_srate_t local_srate; 412 ibt_srate_t local_alt_srate; 413 ib_pkey_t pkey; 414 uint8_t prim_port; 415 uint8_t alt_port; 416 uint32_t starting_psn; 417 ib_path_bits_t prim_src_path_bits; 418 ib_path_bits_t alt_src_path_bits; 419 420 boolean_t delete_mra_msg; 421 boolean_t stale; 422 boolean_t delete_state_data; 423 boolean_t is_this_ofuv_chan; 424 425 boolean_t open_done; 426 boolean_t close_done; 427 boolean_t ap_done; 428 429 uint8_t send_mad_flags; 430 uint8_t close_flow; 431 uint8_t open_flow; 432 ibcm_abort_flag_t abort_flag; 433 434 struct ibcm_state_data_s *timeout_next; 435 436 ibcm_conn_state_t timedout_state; 437 438 ibcm_isync_t cep_in_rts; 439 ibcm_isync_t clnt_proceed; 440 ibcm_isync_t close_nocb_state; 441 442 /* Clients' information */ 443 void *state_cm_private; 444 445 /* pointer to service info */ 446 struct ibcm_svc_info_s *state_svc_infop; 447 448 kcondvar_t block_client_cv; 449 kcondvar_t block_mad_cv; 450 451 /* Data for recycle function */ 452 struct ibcm_taskq_recycle_arg_s *recycle_arg; 453 454 /* Return data pointers in various cm api calls */ 455 ibt_rc_returns_t *open_return_data; 456 ibt_ap_returns_t *ap_return_data; 457 uint8_t *close_ret_priv_data; 458 ibt_priv_data_len_t *close_ret_priv_data_len; 459 uint8_t *close_ret_status; 460 461 /* for queuing of open_rc_channel requests */ 462 struct ibcm_state_data_s *open_link; 463 /* for queuing of non-blocking close_rc_channel requests */ 464 struct ibcm_state_data_s *close_link; 465 466 struct ibcm_conn_trace_s *conn_trace; 467 468 /* For ibt_ofuvcm_get_req_data() */ 469 void *req_msgp; 470 471 /* Stored RNR retry count from incoming REQ or REP */ 472 ibt_rnr_retry_cnt_t local_qp_rnr_cnt; 473 474 } ibcm_state_data_t; 475 476 _NOTE(MUTEX_PROTECTS_DATA(ibcm_state_data_s::state_mutex, 477 ibcm_state_data_s::{state ref_cnt timer_stored_state timer_value 478 timer_stored_ap_state remaining_retry_cnt clnt_proceed cep_in_rts 479 close_nocb_state block_client_cv block_mad_cv timedout_state cm_handler 480 abort_flag mra_msg})) 481 482 _NOTE(READ_ONLY_DATA(ibcm_state_data_s::{mode channel svcid hcap 483 local_comid local_hca_guid local_qpn remote_comid remote_hca_guid 484 remote_qpn pkt_life_time remote_ack_delay rc_alt_pkt_lt stored_reply_addr 485 max_cm_retries cep_retry_cnt local_srate local_alt_srate pkey 486 prim_port alt_port starting_psn state_svc_infop avl_active_link 487 avl_passive_link avl_passive_comid_link defer_cm_msg recycle_arg 488 conn_trace})) 489 490 _NOTE(SCHEME_PROTECTS_DATA("Serailized access by block_client_cv", 491 ibcm_state_data_s::{open_return_data ap_return_data close_ret_priv_data 492 close_ret_priv_data_len close_ret_status})) 493 494 _NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_state_data_s::{timedout_state 495 cm_handler mra_msg abort_flag local_qp_rnr_cnt})) 496 497 /* 498 * Definitions for send mad flags. Respective bits in send_mad_flags or 499 * ud_send_mad_flags are set to 1, during MAD transmission, and reset in 500 * ibmf send completion callback or on completion of a blocking ibmf mad post. 501 */ 502 #define IBCM_REP_POST_BUSY 1 /* REP post in progress */ 503 #define IBCM_REJ_POST_BUSY 2 /* REJ post in progress */ 504 #define IBCM_RTU_POST_BUSY 4 /* RTU post in progress */ 505 #define IBCM_MRA_POST_BUSY 8 /* MRA post in progress */ 506 #define IBCM_DREP_POST_BUSY 16 /* DREQ post in progress */ 507 #define IBCM_SREP_POST_BUSY 32 /* SIDR REP post in progress */ 508 509 /* MADs that are retransmitted only because of a timeout */ 510 #define IBCM_REQ_POST_BUSY 64 /* REQ post in progress */ 511 512 513 /* Incr/Decr ref_cnt by 1 */ 514 #define IBCM_REF_CNT_INCR(s) (s->ref_cnt++) 515 #define IBCM_REF_CNT_DECR(s) \ 516 if ((--(s->ref_cnt) == 0) && (s->delete_state_data == B_TRUE)) { \ 517 ibcm_add_tlist(s);\ 518 } \ 519 ASSERT(s->ref_cnt >= 0); 520 521 /* 522 * This macro checks if ch_qp/ch_eec handles are both not set for a channel 523 */ 524 #define IBCM_INVALID_CHANNEL(chan) (chan == NULL) 525 526 /* 527 * The next macros are used to get/set the statep from the QP 528 * handles, using the CM private data. These call into IBTL. 529 * The WAIT and RELEASE macros deal with related issues that 530 * require use of the same lock within IBTL. 531 */ 532 #define IBCM_GET_CHAN_PRIVATE(ch, s) \ 533 if ((ch) != NULL) { \ 534 s = ibtl_cm_get_chan_private(ch); \ 535 } else \ 536 s = NULL; 537 538 #define IBCM_SET_CHAN_PRIVATE(ch, s) \ 539 if ((ch) != NULL) { \ 540 ibtl_cm_set_chan_private(ch, (void *)(s)); \ 541 } 542 543 #define IBCM_RELEASE_CHAN_PRIVATE(ch) \ 544 if ((ch) != NULL) { \ 545 ibtl_cm_release_chan_private(ch); \ 546 } 547 548 #define IBCM_WAIT_CHAN_PRIVATE(ch) \ 549 ibtl_cm_wait_chan_private(ch); 550 551 /* In future, if we intend to change it to realtime_timeout, it's easy */ 552 #define IBCM_TIMEOUT(arg1, arg2) timeout(ibcm_timeout_cb, arg1,\ 553 drv_usectohz(arg2)) 554 #define IBCM_UD_TIMEOUT(arg1, arg2) timeout(ibcm_sidr_timeout_cb, arg1,\ 555 drv_usectohz(arg2)) 556 557 extern void ibcm_open_enqueue(ibcm_state_data_t *statep); 558 extern void ibcm_open_done(ibcm_state_data_t *statep); 559 extern void ibcm_close_enqueue(ibcm_state_data_t *statep); 560 extern void ibcm_close_done(ibcm_state_data_t *statep, int send_done); 561 extern void ibcm_close_enter(void); 562 extern void ibcm_close_exit(void); 563 extern void ibcm_lapr_enter(void); 564 extern void ibcm_lapr_exit(void); 565 extern void ibcm_check_for_opens(void); 566 extern void ibcm_check_for_async_close(void); 567 extern void ibcm_close_start(ibcm_state_data_t *statep); 568 extern void ibcm_run_tlist_thread(void); 569 570 /* 571 * Structures & defines for SIDR 572 */ 573 574 /* 575 * Define a connection state structure, used for SIDR REQ and REP 576 * (ibcm_ud_state_data_t - struct for SIDR connection) 577 * 578 * ud_state: CM connection state (See ibcm_conn_state_t) 579 * ud_req_id: Request ID 580 * ud_svcid: Service ID 581 * ud_state_mutex: CM connection state 582 * 583 * ud_max_cm_retries: Max retry count for sending a SIDR REQ 584 * ud_ref_cnt: State ref count for not deleting accidentally 585 * ud_remaining_retry_count: Remaining count for retries ie., posting 586 * stored MADs 587 * ud_cm_handler: Server's handler callback address 588 * 589 * ud_nextp: CM link for IBTF list 590 * ud_hcap: A pointer to the HCA's entry 591 * 592 * ud_timerid: Timer id for the timeout either for re-sending the 593 * stored mad or deleting the stored mad 594 * Ex: A SIDR REP response for an incoming SIDR REQ 595 * An outgoing SIDR REQ on active connection side 596 * ud_timer_value: Time for any of the above timers in HZ 597 * ud_pkt_life_time: pkt life time from source to destination 598 * ud_stored_reply_addr: Address for replying using the stored mad 599 * 600 * ud_sidr_req_lid: SIDR REQ sender's port LID 601 * ud_sidr_req_gid: SIDR REQ sender's port GID 602 * ud_grh_exists: TRUE if GRH exists in the incoming SIDR REQ 603 * 604 * ud_passive_qpn: QPN allocated by server for a SIDR REQ 605 * ud_passive_qpn_qkey: QPN's QKEY allocated by server 606 * 607 * ud_block_client_cv: CV condition variable on which ibt_ud_get_dqpn() waits, 608 * if called in blocking mode. 609 * ud_return_data: UD return args, valid for blocking ibt_ud_get_dqpn 610 * ud_timer_stored_state: State stored for timeout handling 611 * ud_blocking_done : Tells if cv_wait is needed or not. To handle the 612 * case where a cv_signal is received prior to its 613 * cv_wait(). 614 * Note : All timer values that are of type "clock_t" below are in usec 615 */ 616 typedef struct ibcm_ud_state_data_s { 617 kmutex_t ud_state_mutex; 618 ibcm_conn_state_t ud_state; 619 ibcm_mode_t ud_mode; 620 621 int ud_ref_cnt; 622 623 uint32_t ud_req_id; 624 ib_svc_id_t ud_svc_id; 625 626 uint8_t ud_max_cm_retries; 627 uint8_t ud_remaining_retry_cnt; 628 ibt_cm_ud_handler_t ud_cm_handler; 629 630 struct ibcm_ud_state_data_s *ud_nextp; 631 struct ibcm_hca_info_s *ud_hcap; 632 633 /* timeout related stuff */ 634 timeout_id_t ud_timerid; 635 clock_t ud_timer_value; 636 clock_t ud_pkt_life_time; 637 ibcm_mad_addr_t ud_stored_reply_addr; 638 ibmf_msg_t *ud_stored_msg; 639 640 641 /* SIDR REQ side related */ 642 ib_lid_t ud_sidr_req_lid; 643 ib_gid_t ud_sidr_req_gid; 644 boolean_t ud_grh_exists; 645 646 /* Stored values on server/SIDR REP side for re-transmits */ 647 ib_qpn_t ud_passive_qpn; 648 ib_qkey_t ud_passive_qp_qkey; 649 650 /* Clients' information */ 651 void *ud_state_cm_private; 652 653 struct ibcm_ud_state_data_s *ud_timeout_next; 654 boolean_t ud_delete_state_data; 655 boolean_t ud_blocking_done; 656 657 uint8_t ud_send_mad_flags; 658 659 ibcm_isync_t ud_clnt_proceed; 660 661 /* The following fields are not used by server side connection */ 662 kcondvar_t ud_block_client_cv; 663 ibt_ud_returns_t *ud_return_data; 664 ibcm_conn_state_t ud_timer_stored_state; 665 } ibcm_ud_state_data_t; 666 667 _NOTE(MUTEX_PROTECTS_DATA(ibcm_ud_state_data_s::ud_state_mutex, 668 ibcm_ud_state_data_s::{ud_state ud_ref_cnt ud_timerid 669 ud_delete_state_data ud_blocking_done ud_send_mad_flags ud_clnt_proceed 670 ud_timer_stored_state ud_send_mad_flags ud_clnt_proceed 671 ud_block_client_cv ud_timer_value ud_remaining_retry_cnt})) 672 673 _NOTE(READ_ONLY_DATA(ibcm_ud_state_data_s::{ud_mode ud_req_id ud_svc_id 674 ud_max_cm_retries ud_pkt_life_time ud_stored_reply_addr ud_stored_msg 675 ud_sidr_req_lid ud_sidr_req_gid ud_grh_exists ud_passive_qpn 676 ud_passive_qp_qkey ud_state_cm_private ud_stored_reply_addr ud_stored_msg})) 677 678 _NOTE(SCHEME_PROTECTS_DATA("Serailized access by ud_block_client_cv", 679 ibcm_ud_state_data_s::{ud_return_data})) 680 681 _NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_ud_state_data_s::{ud_cm_handler})) 682 683 /* 684 * Structure used to specify the SIDR search parameters 685 */ 686 typedef struct ibcm_sidr_srch_s { 687 ib_lid_t srch_lid; 688 ib_gid_t srch_gid; 689 boolean_t srch_grh_exists; 690 uint32_t srch_req_id; 691 ibcm_mode_t srch_mode; 692 } ibcm_sidr_srch_t; 693 694 _NOTE(READ_ONLY_DATA(ibcm_sidr_srch_s)) 695 696 /* 697 * Incr/Decr ud_ref_cnt by 1 698 */ 699 #define IBCM_UD_REF_CNT_INCR(s) ((s)->ud_ref_cnt++) 700 #define IBCM_UD_REF_CNT_DECR(s) \ 701 if ((--(s->ud_ref_cnt) == 0) && (s->ud_delete_state_data == B_TRUE)) { \ 702 ibcm_add_ud_tlist(s);\ 703 } \ 704 ASSERT(s->ud_ref_cnt >= 0); 705 706 /* 707 * Structure to store the Service Registration and Service Bind entries. 708 * 709 * Well known service id's are unique on a given HCA, but can be registered 710 * only at some GID's. Hence can be multiple GID's per Service ID. For each 711 * such GID and PKEY combination registered, there will be an ibcm_svc_info_t 712 * entry in the CM global service list. 713 * 714 * Annex A of the spec constrains that there shall be one service provider per 715 * service id, which implies same svc_rc_handler for all such entries 716 * There can be multiple transport types (svc_tran_type) per Service ID. For 717 * each such transport type, there will be an ibcm_svc_info_t entry in the 718 * CM global service list and cm handler can be different 719 * 720 * For locally allocated service id's (maintained by OS), there can be only 721 * one GID, where the service can be registered 722 * 723 * svc_id: Service ID 724 * svc_num_sids: Number (Range) of service-ids supported 725 * svc_flags: Service flags specified at registration time 726 * svc_link: Global AVL tree of ibcm_svc_info_t structs 727 * svc_rc_handler: Server handler for RC (only one is valid at a time) 728 * svc_ud_handler: Server handler for UD (only one is valid at a time) 729 * svc_ref_cnt: Reference count 730 * svc_to_delete: If 1, then the entry is marked to be deleted 731 * 732 * sbind_gid: GID 733 * sbind_pkey: P_Key 734 * sbind_lease: Service Lease 735 * sbind_name: Service Name 736 */ 737 typedef struct ibcm_svc_info_s { 738 avl_node_t svc_link; 739 struct ibcm_svc_bind_s *svc_bind_list; 740 ibt_cm_handler_t svc_rc_handler; 741 ibt_cm_ud_handler_t svc_ud_handler; 742 int svc_ref_cnt; 743 int svc_to_delete; 744 ib_svc_id_t svc_id; 745 int svc_num_sids; 746 ibt_service_flags_t svc_flags; 747 } ibcm_svc_info_t; 748 749 typedef struct ibcm_svc_bind_s { 750 struct ibcm_svc_bind_s *sbind_link; 751 void *sbind_cm_private; 752 ib_gid_t sbind_gid; 753 ib_guid_t sbind_hcaguid; 754 uint64_t sbind_key[2]; 755 /* sbind_data is assumed to be 8-byte aligned */ 756 uint8_t sbind_data[IB_SVC_DATA_LEN]; /* ServiceData */ 757 uint32_t sbind_lease; 758 ib_pkey_t sbind_pkey; 759 uint8_t sbind_port; 760 uint8_t sbind_rewrite_state; 761 char sbind_name[IB_SVC_NAME_LEN]; 762 } ibcm_svc_bind_t; 763 764 /* 765 * Service records may be lost by the SM/SA (reboot, change in who 766 * is the master, etc.). When any of the above occurs, a PORT_UP 767 * async event is supposed to occur, at which point we mark all of 768 * our service record information as stale (REWRITE_NEEDED), and 769 * subsequently make the necessary sa_update calls to get the 770 * SM/SA in sync with all the service records we previously wrote. 771 * 772 * Values for sbind_rewrite_state follow. This field is protected by 773 * ibcm_svc_info_lock. ibt_unbind_service has to wait until a service 774 * binding is either idle or needed, sleeping on ibcm_svc_info_cv if 775 * busy (rewrite in progress). 776 */ 777 #define IBCM_REWRITE_IDLE 0 778 #define IBCM_REWRITE_NEEDED 1 779 #define IBCM_REWRITE_BUSY 2 780 781 typedef struct ibcm_port_up_s { 782 ib_guid_t pup_hca_guid; 783 uint8_t pup_port; 784 } ibcm_port_up_t; 785 786 /* arg is a pointer to ibcm_port_up_t */ 787 extern void ibcm_service_record_rewrite_task(void *); 788 789 #define IBCM_SVC_INCR(svcinfop) (svcinfop)->svc_ref_cnt++ 790 #define IBCM_SVC_DECR(svcinfop) \ 791 if (--((svcinfop)->svc_ref_cnt) == 0 && \ 792 (svcinfop)->svc_to_delete) \ 793 cv_broadcast(&ibcm_svc_info_cv); \ 794 ASSERT(svcinfop->svc_ref_cnt >= 0); 795 796 _NOTE(READ_ONLY_DATA(ibcm_svc_info_s::{svc_rc_handler svc_ud_handler svc_id 797 svc_num_sids svc_flags})) 798 799 _NOTE(READ_ONLY_DATA(ibcm_svc_bind_s::{sbind_cm_private sbind_gid sbind_hcaguid 800 sbind_key sbind_data sbind_lease sbind_pkey sbind_port sbind_name})) 801 802 /* for avl tree search */ 803 typedef struct ibcm_svc_lookup_s { 804 ib_svc_id_t sid; 805 int num_sids; 806 } ibcm_svc_lookup_t; 807 808 typedef struct ibcm_ar_ref_s { 809 struct ibcm_ar_ref_s *ar_ref_link; 810 ibt_clnt_hdl_t ar_ibt_hdl; 811 } ibcm_ar_ref_t; 812 813 typedef struct ibcm_ar_s { 814 ibt_ar_t ar; 815 int ar_flags; /* 1 = INITING, 2 = FAILED */ 816 int ar_waiters; /* # of waiters */ 817 kcondvar_t ar_cv; 818 uint8_t ar_port; 819 uint8_t ar_rewrite_state; /* see sbind_rewrite_state */ 820 ibcm_ar_ref_t *ar_ibt_hdl_list; 821 struct ibcm_ar_s *ar_link; 822 sa_service_record_t *ar_srv_recp; 823 ibmf_saa_handle_t ar_saa_handle; 824 struct ibcm_hca_info_s *ar_hcap; 825 } ibcm_ar_t; 826 827 /* ar_flags */ 828 #define IBCM_AR_SUCCESS 0 829 #define IBCM_AR_FAILED 1 830 #define IBCM_AR_INITING 2 831 832 833 /* 834 * These flags are used for adding (if an entry does not exist) or 835 * for just looking one up 836 */ 837 typedef enum ibcm_lookup_flag_e { 838 IBCM_FLAG_LOOKUP = 0, /* just lookup */ 839 IBCM_FLAG_ADD = 1, /* just add */ 840 IBCM_FLAG_LOOKUP_AND_ADD = 2 /* lookup first. add if */ 841 /* lookup failed */ 842 } ibcm_lookup_flag_t; 843 844 typedef enum ibcm_finit_state_e { 845 IBCM_FINIT_INIT, /* CM's init is not yet completed */ 846 IBCM_FINIT_IDLE, /* CM not in either init or fini */ 847 IBCM_FINIT_BUSY, /* CM busy either in init or fini */ 848 IBCM_FINIT_FAIL, /* Init failed */ 849 IBCM_FINIT_SUCCESS /* Fini has succeeded */ 850 } ibcm_finit_state_t; 851 852 /* 853 * Identifies HCA's state. Used in the definition of ibcm_hca_info_t 854 * If HCA is in ACTIVE state only does CM allow any MAD processing. 855 */ 856 typedef enum ibcm_hca_state_e { 857 IBCM_HCA_INIT, 858 IBCM_HCA_ACTIVE, 859 IBCM_HCA_NOT_ACTIVE 860 } ibcm_hca_state_t; 861 862 /* QP information per pkey, stored in port information */ 863 typedef struct ibcm_qp_list_s { 864 ib_pkey_t qp_pkey; 865 ibmf_qp_handle_t qp_cm; 866 uint32_t qp_ref_cnt; 867 struct ibcm_port_info_s *qp_port; 868 struct ibcm_qp_list_s *qp_next; 869 } ibcm_qp_list_t; 870 871 _NOTE(READ_ONLY_DATA(ibcm_qp_list_s::{qp_pkey qp_cm qp_port qp_next})) 872 _NOTE(DATA_READABLE_WITHOUT_LOCK(ibcm_qp_list_s)) 873 874 /* 875 * port information per HCA 876 * port_ibmf_hdl - contains IBMF handle for that port if valid 877 * otherwise is NULL 878 * port_ibmf_saa_hdl - contains SA Access handle for that port if valid 879 * otherwise is NULL 880 */ 881 typedef struct ibcm_port_info_s { 882 ibmf_handle_t port_ibmf_hdl; 883 ibmf_saa_handle_t port_ibmf_saa_hdl; 884 ib_gid_t port_sgid0; 885 uint8_t port_event_status; 886 uint8_t port_saa_open_in_progress; 887 uint8_t port_num; 888 ibmf_register_info_t port_ibmf_reg; 889 ibmf_impl_caps_t port_ibmf_caps; 890 ibcm_qp_list_t port_qp1; 891 ibcm_qp_list_t *port_qplist; 892 struct ibcm_hca_info_s *port_hcap; 893 } ibcm_port_info_t; 894 895 _NOTE(READ_ONLY_DATA(ibcm_port_info_s::{port_num port_ibmf_caps port_qp1 896 port_hcap})) 897 898 /* Value to indicate to exit the timeout list processing thread */ 899 #define IBCM_TIMEOUT_THREAD_EXIT 01 900 901 /* 902 * IBCM code relies on AVL routines already in kernel for faster lookups. 903 * AVL was chosen over mod hashing mechanism based on the its internal 904 * limitations in the kernel (no support for over 100,000 keys). 905 * 906 * IBCM uses two AVL trees on the passive side and one on active side per HCA. 907 * The two trees are need on the passive side because the tree lookup criteria 908 * changes based on the type of message being processed. On passive side it is 909 * based on remote_qpn and remote_hca_guid for only incoming REQ message and for 910 * for all other messages the search criteria is based upon remote_comid. 911 * On active side the lookup criteria remains static based upon local_comid. 912 * 913 * AVL tree insertions are done by grabbing the writer lock (hca_state_rwlock) 914 * and lookups are done by grabbing the reader lock. 915 */ 916 917 /* 918 * CM's per HCA data structure. 919 * 920 * One such entry is added/removed on hca attach/detach notifications to CM 921 * respectively. 922 * 923 * Comids are used for all connections. Req ids are used for SIDR REQ and 924 * SIDR REP messages. These are simple counters that wrap around INT_MAX. 925 * NOTE: The starting value for comid, per HCA, is 2. 926 * 927 * hca_state: HCA's current state (ibcm_hca_state_t) - whether 928 * IBT_HCA_ACTIVE, IBT_HCA_NOT_ACTIVE, 929 * hca_guid: Active HCA guid 930 * hca_caps: HCA capability mask 931 * hca_ack_delay: HCA ack delay 932 * hca_max_rdma_rd Max RDMA in Reads 933 * hca_max_rdma_dpt Max RDMA out Reads 934 * hca_active_tree: This tree is used for lookups on Active/Passive side 935 * CM based on communication id ONLY. 936 * hca_passive_tree: This tree is used to lookup/create ibcm_state_data_t on 937 * Passive Side CM based on remote_qpn and remote_hca_guid. 938 * hca_passive_comid_tree: 939 * This tree is used to lookup/create ibcm_state_data_t on 940 * Passive Side CM based on remote_comid and 941 * remote_hca_guid. 942 * hca_state_rwlock: reader/writer Lock for the hca entry 943 * for hca_active_tree 944 * for hca_passive_tree 945 * for hca_next_comid 946 * hca_sidr_list: List for UD side 947 * hca_sidr_list_lock: List lock for UD side 948 * for hca_sidr_list 949 * for hca_next_reqid 950 * hca_next_reqid: Next active ReqId 951 * hca_next_comid: Next active ComID 952 * hca_next: Pointer to the next HCA 953 * hca_svc_cnt: A count of services registered on this hca 954 * hca_acc_cnt: A count of active references to this ibcm_hca_info_t 955 * hca_res_cnt: A count of client's active resources on this hca 956 * hca_num_ports: Number of ports that this HCA has 957 * hca_port_info: Per port information (IBMA/SA access handles etc.) 958 * 959 * Note : The global mutex ibcm_global_hca_mutex declared in CM is used for 960 * accesses to the following fields : 961 * hca_acc_cnt, hca_res_cnt, hca_svc_cnt, hca_state 962 */ 963 typedef struct ibcm_hca_info_s { 964 ibcm_hca_state_t hca_state; /* Is HCA attached? */ 965 ib_guid_t hca_guid; /* HCA's guid value */ 966 ibt_hca_flags_t hca_caps; /* HCA capabilities */ 967 uint32_t hca_vendor_id:24; 968 uint16_t hca_device_id; 969 ib_time_t hca_ack_delay; /* HCA ack delay */ 970 uint8_t hca_max_rdma_in_qp; /* Max RDMA in Reads */ 971 uint8_t hca_max_rdma_out_qp; /* Max RDMA out Reads */ 972 vmem_t *hca_comid_arena; /* arena for com ids */ 973 vmem_t *hca_reqid_arena; /* arena for req ids */ 974 avl_tree_t hca_active_tree; /* active node tree */ 975 avl_tree_t hca_passive_tree; /* passive node tree */ 976 avl_tree_t hca_passive_comid_tree; /* passive comid tree */ 977 krwlock_t hca_state_rwlock; /* per HCA lock */ 978 ibcm_ud_state_data_t *hca_sidr_list; /* SIDR state list */ 979 krwlock_t hca_sidr_list_lock; 980 981 struct ibcm_hca_info_s *hca_next; /* Next HCA entry */ 982 983 int hca_svc_cnt; /* # of */ 984 /* services allocated */ 985 int hca_acc_cnt; /* active references */ 986 int hca_res_cnt; /* total resources */ 987 uint8_t hca_num_ports; /* #ports on this HCA */ 988 ibcm_port_info_t hca_port_info[1]; /* Per portinfo array */ 989 } ibcm_hca_info_t; 990 991 _NOTE(RWLOCK_PROTECTS_DATA(ibcm_hca_info_s::hca_state_rwlock, 992 ibcm_hca_info_s::{hca_active_tree hca_passive_tree hca_passive_comid_tree})) 993 994 _NOTE(SCHEME_PROTECTS_DATA("hca_sidr_list_lock protects hca_sidr_list", 995 ibcm_hca_info_s::{hca_sidr_list})) 996 997 _NOTE(READ_ONLY_DATA(ibcm_hca_info_s::{hca_guid hca_caps hca_ack_delay 998 hca_max_rdma_in_qp hca_max_rdma_out_qp hca_comid_arena hca_reqid_arena 999 hca_passive_tree hca_active_tree hca_passive_comid_tree hca_num_ports })) 1000 1001 /* Are we on Tavor HCA */ 1002 #define IBCM_IS_HCA_TAVOR(hcap) \ 1003 (((hcap)->hca_device_id == 0x5a44) && ((hcap)->hca_vendor_id == 0x15b3)) 1004 1005 /* 1006 * called to ensure that HCA is in "attached" state and is willing to 1007 * process connections etc. 1008 */ 1009 #define IBCM_ACCESS_HCA_OK(s) ((s)->hca_state == IBCM_HCA_ACTIVE) 1010 1011 /* 1012 * Passive AVL tree lookup info (for hca_passive_tree) 1013 * CM needs this structure as passive tree lookups are based on 1014 * QPN and HCA GUID. 1015 */ 1016 typedef struct ibcm_passive_node_info_s { 1017 ib_qpn_t info_qpn; 1018 ib_guid_t info_hca_guid; 1019 } ibcm_passive_node_info_t; 1020 1021 /* 1022 * Passive Com ID AVL tree lookup info (for hca_passive_comid_tree) 1023 * CM needs this structure as passive comid tree lookups are based on 1024 * Remote Com ID and Remote HCA GUID. 1025 */ 1026 typedef struct ibcm_passive_comid_node_info_s { 1027 ib_com_id_t info_comid; 1028 ib_guid_t info_hca_guid; 1029 } ibcm_passive_comid_node_info_t; 1030 1031 /* CM proceed task args structure definition */ 1032 typedef struct ibcm_proceed_targs_s { 1033 ibt_cm_event_type_t event; 1034 ibt_cm_status_t status; 1035 union tst_t { 1036 struct rc_s { 1037 ibcm_state_data_t *statep; 1038 ibt_cm_proceed_reply_t rc_cm_event_data; 1039 } rc; 1040 struct ud_s { 1041 ibcm_ud_state_data_t *ud_statep; 1042 ib_qpn_t ud_qpn; 1043 ib_qkey_t ud_qkey; 1044 ibt_redirect_info_t ud_redirect_info; 1045 } ud; 1046 } tst; 1047 ibt_priv_data_len_t priv_data_len; 1048 /* keep priv_data as the last field */ 1049 uint8_t priv_data[IBT_MAX_PRIV_DATA_SZ]; 1050 } ibcm_proceed_targs_t; 1051 1052 _NOTE(READ_ONLY_DATA(ibcm_proceed_targs_s)) 1053 1054 1055 /* 1056 * function prototypes for AVL tree compares 1057 */ 1058 int ibcm_active_node_compare(const void *, const void *); 1059 int ibcm_passive_node_compare(const void *, const void *); 1060 int ibcm_passive_comid_node_compare(const void *, const void *); 1061 1062 /* 1063 * function prototypes to allocate IBMF/SA_ACCESS handles 1064 */ 1065 ibt_status_t ibcm_hca_reinit_port(ibcm_hca_info_t *hca_p, 1066 uint8_t port_index); 1067 1068 /* function prototypes to Manage CM's IBMF QP's */ 1069 1070 ibcm_qp_list_t *ibcm_find_qp(ibcm_hca_info_t *hcap, int port_no, 1071 ib_pkey_t pkey); 1072 1073 void ibcm_release_qp(ibcm_qp_list_t *cm_qp_entry); 1074 1075 ibcm_status_t ibcm_free_qp(ibcm_qp_list_t *cm_qp_entry); 1076 1077 ibcm_status_t ibcm_free_allqps(ibcm_hca_info_t *hcap, int port_no); 1078 1079 /* 1080 * function prototypes to allocate and free outgoing CM messages 1081 */ 1082 ibt_status_t 1083 ibcm_alloc_out_msg(ibmf_handle_t ibmf_handle, ibmf_msg_t **ibmf_msgpp, 1084 uint8_t method); 1085 ibcm_status_t 1086 ibcm_free_out_msg(ibmf_handle_t ibmf_handle, ibmf_msg_t **ibmf_msgpp); 1087 1088 /* 1089 * Definition for CM state transition processing function 1090 */ 1091 typedef void (*ibcm_state_handler_t)(ibcm_hca_info_t *hcap, 1092 uint8_t *cm_input_mad, ibcm_mad_addr_t *cm_mad_addr); 1093 1094 /* 1095 * CM REQ Message structure 1096 * 1097 * Request for communication. 1098 * 1099 * Things of interest are:- 1100 * ib_qpn_t cannot be used - it is typecast to uint32_t but is 24 bits 1101 * ib_eecn_t cannot be used - it is typecast to uint32_t but is 24 bits 1102 * 1103 * (See Table 85 REQ Message Contents - chapter 12 in IB Spec v1.0a) 1104 * 1105 */ 1106 typedef struct ibcm_req_msg_s { 1107 ib_com_id_t req_local_comm_id; /* Local communication id */ 1108 /* 32 bits */ 1109 uint32_t req_rsvd1; /* Reserved1 - 32 bits */ 1110 ib_svc_id_t req_svc_id; /* Service Id - 64 bits */ 1111 ib_guid_t req_local_ca_guid; /* Local CA GUID - 64 bits */ 1112 uint32_t req_rsvd1p; /* Reserved1+ - 32 bits */ 1113 ib_qkey_t req_local_qkey; /* Local Q_KEY - 32 bits */ 1114 uint32_t req_local_qpn_plus; /* QPN_24 RESP_RSRC_8 */ 1115 /* local side QPN - 24 bits */ 1116 /* Offered responder */ 1117 /* resources - 8 bits */ 1118 uint32_t req_local_eec_no_plus; /* LOCAL_EECN_24 INIT_DEPTH_8 */ 1119 /* Local side EECN - 24 bits */ 1120 /* Offered initiator */ 1121 /* depth - 8 bits */ 1122 uint32_t req_remote_eecn_plus; /* REM_EECN_24 TO_5 TT_2 EE_1 */ 1123 /* Remote side EECN - 24 bits */ 1124 /* Remote CM timeout - 5 bits */ 1125 /* Transport srvtype - 2 bits */ 1126 /* End-to-End flow - 1 bit */ 1127 uint32_t req_starting_psn_plus; /* START_PSN_24 TO_5 RETRY_3 */ 1128 /* Starting PSN - 24 bits */ 1129 /* Local CM timeout - 5 bits */ 1130 /* Retry count - 3 bits */ 1131 ib_pkey_t req_part_key; /* Partition key - 16 bits */ 1132 uint8_t req_mtu_plus; /* PATH_MTU_4 RDC_1 RNR_3 */ 1133 /* Path Pkt MTU - 4 bits */ 1134 /* Does RDC exist? - 1 bits */ 1135 /* RNR retry count - 3 bits */ 1136 uint8_t req_max_cm_retries_plus; /* MAX_CM_RET_4 SRQ_1 RSV_3 */ 1137 /* Max CM retries - 4 bits */ 1138 /* SRQ Exists - 1 bit */ 1139 /* Reserved2 - 3 bits */ 1140 ib_lid_t req_primary_l_port_lid; /* Primary local port LID */ 1141 ib_lid_t req_primary_r_port_lid; /* Primary Remote port LID */ 1142 ib_gid_t req_primary_l_port_gid; /* Primary local port GID */ 1143 ib_gid_t req_primary_r_port_gid; /* Primary remote port GID */ 1144 uint32_t req_primary_flow_label_plus; /* FLOW_20 RSV_4 SRATE_6 */ 1145 /* Prim. flow label - 20 bits */ 1146 /* Reserved3 - 6 bits */ 1147 /* Primary rate - 6 bits */ 1148 uint8_t req_primary_traffic_class; 1149 /* Primary Traffic class */ 1150 uint8_t req_primary_hop_limit; /* Prim Hop Limit */ 1151 uint8_t req_primary_sl_plus; /* PRIMARY_SL_4 LOCAL_1 RSV_3 */ 1152 /* Primary SL - 4 bits */ 1153 /* Prim. subnet local - 1 bit */ 1154 /* Reserved4 - 3 bits */ 1155 uint8_t req_primary_localtime_plus; /* LOCAL_TO_5 RSV_3 */ 1156 /* Primary local */ 1157 /* timeout - 5 bits */ 1158 /* Reserved5 - 3 bits */ 1159 ib_lid_t req_alt_l_port_lid; /* Alt local port LID */ 1160 ib_lid_t req_alt_r_port_lid; /* Alt Remote port LID */ 1161 /* Note: req_alt_l_port_gid/req_alt_r_port_gid are not 8-byte aligned */ 1162 uint8_t req_alt_l_port_gid[16]; /* Alt local port GID */ 1163 uint8_t req_alt_r_port_gid[16]; /* Alt remote port GID */ 1164 uint32_t req_alt_flow_label_plus; /* ALT_FLOW_20 RSV_6 ARATE_6 */ 1165 /* Alt flow label - 20 bits */ 1166 /* Reserved6 - 6 bits */ 1167 /* Alternate rate - 6 bits */ 1168 uint8_t req_alt_traffic_class; /* Alt traffic class */ 1169 uint8_t req_alt_hop_limit; /* Alt hop limit */ 1170 uint8_t req_alt_sl_plus; /* ALT_SL_4 A_LOCAL_1 RSV_3 */ 1171 /* Alternate SL - 4 bits */ 1172 /* Alt subnet local - 1 bit */ 1173 /* Reserved7 - 3 bits */ 1174 uint8_t req_alt_localtime_plus; /* ALT_LOCAL_ACK_TO_5 RSV_3 */ 1175 /* Alt Local ACK */ 1176 /* timeout - 5 bits */ 1177 /* Reserved8 - 3 bits */ 1178 uint8_t req_private_data[IBT_REQ_PRIV_DATA_SZ]; 1179 /* Private data */ 1180 } ibcm_req_msg_t; 1181 1182 1183 /* 1184 * The following set of defines are short-cuts to CEP_PATH or GRH info 1185 */ 1186 #define IBCM_PRIM_CEP_PATH(s) (s)->oc_path->pi_prim_cep_path 1187 #define IBCM_PRIM_ADDS_VECT(s) (s)->oc_path->pi_prim_cep_path.cep_adds_vect 1188 1189 #define IBCM_ALT_CEP_PATH(s) (s)->oc_path->pi_alt_cep_path 1190 #define IBCM_ALT_ADDS_VECT(s) (s)->oc_path->pi_alt_cep_path.cep_adds_vect 1191 1192 #define IBCM_UD_CEP_PATH(s) (s)->us_path_info->ai_cep_path 1193 #define IBCM_UD_ADDS_VECT(s) (s)->us_path_info->ai_cep_path.cep_adds_vect 1194 1195 /* 1196 * The following set of defines are short-cuts to ibt_cm_event_t 1197 */ 1198 #define IBCM_EVT_REQ(e) (e).cm_event.req 1199 #define IBCM_EVT_REP(e) (e).cm_event.rep 1200 1201 /* 1202 * The following set of defines are short-cuts to qp_attrs or qp_info 1203 */ 1204 #define IBCM_QP_RC(q) (q).qp_info.qp_transport.rc 1205 #define IBCM_QP_UD(q) (q).qp_info.qp_transport.ud 1206 #define IBCM_QP_UC(q) (q).qp_info.qp_transport.uc 1207 1208 #define IBCM_QPINFO(q) (q).qp_transport 1209 #define IBCM_QPINFO_RC(q) (q).qp_transport.rc 1210 #define IBCM_QPINFO_RC_PATH(q) (q).qp_transport.rc.rc_path 1211 #define IBCM_QPINFO_UC(q) (q).qp_transport.uc 1212 #define IBCM_QPINFO_UC_PATH(q) (q).qp_transport.uc.uc_path 1213 #define IBCM_QPINFO_UD(q) (q).qp_transport.ud 1214 1215 1216 /* The following set of defines are short-cuts to RC and SIDR MAD HDRs */ 1217 1218 #define IBCM_OUT_MADP(msgp) (msgp->im_msgbufs_send.im_bufs_mad_hdr) 1219 #define IBCM_OUT_HDRP(msgp) ((ib_mad_hdr_t *)IBCM_OUT_MADP(msgp)) 1220 #define IBCM_OUT_MSGP(msgp) (msgp->im_msgbufs_send.im_bufs_cl_data) 1221 1222 #define IBCM_IN_MADP(msgp) (msgp->im_msgbufs_recv.im_bufs_mad_hdr) 1223 #define IBCM_IN_HDRP(msgp) ((ib_mad_hdr_t *)IBCM_IN_MADP(msgp)) 1224 #define IBCM_IN_MSGP(msgp) (msgp->im_msgbufs_recv.im_bufs_cl_data) 1225 1226 #define IBCM_REJ_PRIV(msgp) &(((ibcm_rej_msg_t *) \ 1227 IBCM_OUT_MSGP(statep->stored_msg))->rej_private_data[0]) 1228 /* 1229 * CM MRA Message structure 1230 * 1231 * Message Receipt Acknowledgement (MRA). 1232 * 1233 * NOTE: IB hosts and targets are required to be able to receive and 1234 * act upon an MRA, but the ability to send an MRA is optional. 1235 */ 1236 typedef struct ibcm_mra_msg_s { 1237 ib_com_id_t mra_local_comm_id; /* Local communication id */ 1238 ib_com_id_t mra_remote_comm_id; /* Remote communication id */ 1239 uint8_t mra_message_type_plus; /* Message Type - 2 bits */ 1240 /* Reserved1 - 6 bits */ 1241 uint8_t mra_service_timeout_plus; /* SVC_TO_5 RSV_3 */ 1242 /* Service timeout - 5 bits */ 1243 /* Reserved2 - 3 bits */ 1244 uint8_t mra_private_data[IBT_MRA_PRIV_DATA_SZ]; 1245 /* Private data */ 1246 } ibcm_mra_msg_t; 1247 1248 /* 1249 * CM REJ Message structure 1250 * REJ indicates that the sender will not continue through the communication 1251 * establishment sequence and the reason why it will not. 1252 * 1253 * NOTE: See ibt_cm_reason_t in common/sys/ib/ib_cm.h for complete list 1254 * of rejection reasons supported. 1255 */ 1256 typedef struct ibcm_rej_msg_s { 1257 ib_com_id_t rej_local_comm_id; /* Local communication id */ 1258 ib_com_id_t rej_remote_comm_id; /* Remote communication id */ 1259 uint8_t rej_msg_type_plus; /* REJ_MSG_TYPE_2 RSV_6 */ 1260 /* Msg being REJed - 2 bits */ 1261 /* Reserved1 - 6 bits */ 1262 uint8_t rej_reject_info_len_plus; /* REJ_INFO_LEN_7 RSV_1 */ 1263 /* Rej. Info Length - 7 bits */ 1264 /* Reserved2 - 1 bit */ 1265 uint16_t rej_rejection_reason; /* Reject err code - 16 bits */ 1266 uint8_t rej_addl_rej_info[IBT_CM_ADDL_REJ_LEN]; 1267 /* Additional Reject Info */ 1268 uint8_t rej_private_data[IBT_REJ_PRIV_DATA_SZ]; 1269 /* Private data */ 1270 } ibcm_rej_msg_t; 1271 1272 /* 1273 * CM REP Message structure 1274 * 1275 * REP is returned in response to REQ, indicating that the respondent 1276 * accepts the Service-ID, proposed primary port, and any parameters 1277 * specified in the PrivateData of the REQ. 1278 */ 1279 typedef struct ibcm_rep_msg_s { 1280 ib_com_id_t rep_local_comm_id; /* Local communication id */ 1281 ib_com_id_t rep_remote_comm_id; /* Remote communication id */ 1282 ib_qkey_t rep_local_qkey; /* Local Q_KEY */ 1283 uint32_t rep_local_qpn_plus; /* LOCAL_QPN_24 RSV_8 */ 1284 /* Local side QPN - 24 bits */ 1285 /* Reserved1 - 8 bits */ 1286 uint32_t rep_local_eecn_plus; /* LOCAL_EECN_24 RSV_8 */ 1287 /* Local side EECN - 24 bits */ 1288 /* Reserved2 - 8 bits */ 1289 uint32_t rep_starting_psn_plus; /* STARTING_PSN_24 RSV_8 */ 1290 /* Starting PSN - 24 bits */ 1291 /* Reserved3 - 8 bits */ 1292 uint8_t rep_resp_resources; /* Responder resources 8 bits */ 1293 uint8_t rep_initiator_depth; /* Initiator depth - 8 bits */ 1294 uint8_t rep_target_delay_plus; /* TGT_ACK_DLY_5 FAIL_2 EE_1 */ 1295 /* Target ACK delay - 5 bits */ 1296 /* Failover accepted - 2 bits */ 1297 /* End-to-End flow control - */ 1298 /* 1 bit */ 1299 uint8_t rep_rnr_retry_cnt_plus; /* RNR_COUNT_3 SRQ_1 RSV_4 */ 1300 /* RNR retry count - 3 bits */ 1301 /* SRQ Exists - 1 bit */ 1302 /* Reserved4 - 4 bits */ 1303 uint8_t rep_local_ca_guid[8]; /* Local CA GUID - 64 bits */ 1304 uint8_t rep_private_data[IBT_REP_PRIV_DATA_SZ]; 1305 /* Private data */ 1306 } ibcm_rep_msg_t; 1307 1308 1309 /* 1310 * CM RTU Message structure 1311 * 1312 * RTU indicates that the connection is established, and that the 1313 * recipient may begin transmitting. 1314 */ 1315 typedef struct ibcm_rtu_msg_s { 1316 ib_com_id_t rtu_local_comm_id; /* Local communication id */ 1317 ib_com_id_t rtu_remote_comm_id; /* Remote communication id */ 1318 uint8_t rtu_private_data[IBT_RTU_PRIV_DATA_SZ]; 1319 /* Private data */ 1320 } ibcm_rtu_msg_t; 1321 1322 1323 /* 1324 * CM DREQ Message structure 1325 * 1326 * DREQ is sent to initiate the connection release sequence. 1327 */ 1328 typedef struct ibcm_dreq_msg_s { 1329 ib_com_id_t dreq_local_comm_id; /* Local communication id */ 1330 ib_com_id_t dreq_remote_comm_id; /* Remote communication id */ 1331 uint32_t dreq_remote_qpn_eecn_plus; /* REM_EECN_24 RSV_8 */ 1332 /* Remote QPN/EECN - 24 bits */ 1333 /* reserved - 8 bits */ 1334 uint8_t dreq_private_data[IBT_DREQ_PRIV_DATA_SZ]; 1335 /* Private data */ 1336 } ibcm_dreq_msg_t; 1337 1338 1339 /* 1340 * CM DREP Message structure 1341 * 1342 * DREP is sent in response to DREQ, and signifies that the sender has 1343 * received DREQ. 1344 */ 1345 typedef struct ibcm_drep_msg_s { 1346 ib_com_id_t drep_local_comm_id; /* Local communication id */ 1347 ib_com_id_t drep_remote_comm_id; /* Remote communication id */ 1348 uint8_t drep_private_data[IBT_DREP_PRIV_DATA_SZ]; 1349 /* Private Data */ 1350 } ibcm_drep_msg_t; 1351 1352 1353 /* 1354 * CM LAP Message structure 1355 * 1356 * NOTE: LAP and APR messages are optional. These are needed if CM 1357 * accepts REQ messages and agrees to perform Automatic Path Migration. 1358 * 1359 * This message is used to change the alternate path information for a 1360 * specific connection. 1361 */ 1362 typedef struct ibcm_lap_msg_s { 1363 ib_com_id_t lap_local_comm_id; /* Local communication id */ 1364 ib_com_id_t lap_remote_comm_id; /* Remote communication id */ 1365 uint32_t lap_rsvd1; /* Reserved - 32 bits */ 1366 uint32_t lap_remote_qpn_eecn_plus; /* REM_EECN_24 TO_5 RSV_3 */ 1367 /* Remote QPN/EECN - 24 bits */ 1368 /* Remote CM response */ 1369 /* timeout - 5 bits */ 1370 /* Reserved1 - 3 bits */ 1371 uint32_t lap_rsvd2; /* Reserved2 - 32 bits */ 1372 ib_lid_t lap_alt_l_port_lid; /* Alt local port LID */ 1373 ib_lid_t lap_alt_r_port_lid; /* Alt Remote port LID */ 1374 ib_gid_t lap_alt_l_port_gid; /* Alt local port GID */ 1375 ib_gid_t lap_alt_r_port_gid; /* Alt remote port GID */ 1376 uint32_t lap_alt_flow_label_plus; /* ALT_FLOW_20 RSV_4 TCL_8 */ 1377 /* Alt flow label - 20 bits */ 1378 /* Reserved3 - 4 bits */ 1379 /* Alt traffic class - 8 bits */ 1380 uint8_t lap_alt_hop_limit; /* Alt hop limit */ 1381 uint8_t lap_alt_srate_plus; /* Reserved4 - 2 bits */ 1382 /* Alt. static rate - 6 bits */ 1383 uint8_t lap_alt_sl_plus; /* ALT_SL_4 A_LOCAL_1 RSV_3 */ 1384 /* Alternate SL - 4 bits */ 1385 /* Alt subnet local - 1 bit */ 1386 /* Reserved5 - 3 bits */ 1387 uint8_t lap_alt_local_acktime_plus; /* ALT_TO_5 RSV_3 */ 1388 /* Alt Local ACK */ 1389 /* timeout - 5 bits */ 1390 /* Reserved6 - 3 bits */ 1391 uint8_t lap_private_data[IBT_LAP_PRIV_DATA_SZ]; 1392 /* Private data */ 1393 } ibcm_lap_msg_t; 1394 1395 1396 /* 1397 * CM APR Message structure 1398 * 1399 * APR is sent in response to a LAP request. MRA may be sent to allow 1400 * processing of the LAP. 1401 */ 1402 typedef struct ibcm_apr_msg_s { 1403 ib_com_id_t apr_local_comm_id; /* Local communication id */ 1404 ib_com_id_t apr_remote_comm_id; /* Remote communication id */ 1405 uint8_t apr_addl_info_len; /* Add'l Info Len - 8 bits */ 1406 uint8_t apr_ap_status; /* AP status - 8 bits */ 1407 uint16_t apr_rsvd1; /* Reserved1 - 16 bits */ 1408 uint8_t apr_addl_info[IBT_CM_APR_ADDL_LEN]; 1409 /* Additional Information */ 1410 uint8_t apr_private_data[IBT_APR_PRIV_DATA_SZ]; 1411 /* Private data */ 1412 } ibcm_apr_msg_t; 1413 1414 1415 /* 1416 * CM SIDR_REQ Message structure 1417 * 1418 * NOTE: SIDR_REQ and SIDR_REP messages are conditionally required. 1419 * These are needed if non-management services are provided on the Channel 1420 * Adapter other than fixed QPNs. Management services include those 1421 * provided thru Subnet Manager Packets or thru General Management Packets. 1422 * 1423 * SIDR_REQ requests that the recipient return the information necessary 1424 * to communicate via UD messages with the entity specified by 1425 * SIDR_REQ:ServiceID 1426 */ 1427 typedef struct ibcm_sidr_req_msg_s { 1428 uint32_t sidr_req_request_id; /* Request id */ 1429 ib_pkey_t sidr_req_pkey; /* P_Key */ 1430 uint8_t sidr_req_reserved[2]; /* Reserved */ 1431 ib_svc_id_t sidr_req_service_id; /* Service Id */ 1432 uint8_t sidr_req_private_data[IBT_SIDR_REQ_PRIV_DATA_SZ]; 1433 /* Private Data */ 1434 } ibcm_sidr_req_msg_t; 1435 1436 1437 /* 1438 * CM SIDR_REP Message structure 1439 * 1440 * SIDR_REP returns the information necessary to communicate via UD 1441 * messages with the entity specified by SIDR_REQ:ServiceID 1442 */ 1443 typedef struct ibcm_sidr_rep_msg_s { 1444 uint32_t sidr_rep_request_id; /* Request id */ 1445 uint8_t sidr_rep_rep_status; /* Status */ 1446 uint8_t sidr_rep_add_info_len; /* Length of Add Info */ 1447 uint8_t sidr_rep_reserved1[2]; /* Reserved */ 1448 uint32_t sidr_rep_qpn_plus; /* QPN_24 RSV_8 */ 1449 /* since the 64-bit SID is not aligned, treat it as a byte array */ 1450 uint8_t sidr_rep_service_id[8]; /* Service Id */ 1451 ib_qkey_t sidr_rep_qkey; /* Q_KEY */ 1452 uint8_t sidr_rep_class_port_info[IBT_CM_SIDR_CP_LEN]; 1453 /* Class Port Info */ 1454 /* aka., add'l info */ 1455 uint8_t sidr_rep_private_data[IBT_SIDR_REP_PRIV_DATA_SZ]; 1456 /* Private data */ 1457 } ibcm_sidr_rep_msg_t; 1458 1459 typedef struct ibcm_classportinfo_msg_s { 1460 uint8_t BaseVersion; /* ver. of MAD base format */ 1461 uint8_t ClassVersion; /* ver. of MAD class format */ 1462 uint16_t CapabilityMask; /* capabilities of this class */ 1463 uint32_t RespTimeValue_plus; /* reserved : 27 bits */ 1464 /* resptime value : 5 bits */ 1465 uint64_t RedirectGID_hi; /* dest gid of redirect msgs */ 1466 uint64_t RedirectGID_lo; /* dest gid of redirect msgs */ 1467 uint32_t RedirectTC_plus; /* traffic class: 8 bits */ 1468 /* SL: 4 bits */ 1469 /* Flow label: 20 bits */ 1470 ib_lid_t RedirectLID; /* dlid for class services */ 1471 ib_pkey_t RedirectP_Key; /* p_key for class services */ 1472 uint32_t RedirectQP_plus; /* Reserved: 8 bits */ 1473 /* QPN: 24 bits */ 1474 ib_qkey_t RedirectQ_Key; /* q_key for class services */ 1475 uint64_t TrapGID_hi; /* dest gid of trap msgs */ 1476 uint64_t TrapGID_lo; /* dest gid of trap msgs */ 1477 uint32_t TrapTC_plus; /* Trap traffic class, etc., */ 1478 ib_lid_t TrapLID; /* dlid for traps */ 1479 ib_pkey_t TrapP_Key; /* p_key for traps */ 1480 uint32_t TrapHL_plus; /* Trap hop limit,etc., */ 1481 ib_qkey_t TrapQ_Key; /* q_key for traps */ 1482 } ibcm_classportinfo_msg_t; 1483 1484 /* All msgs are readonly on receiving side */ 1485 _NOTE(READ_ONLY_DATA(ibcm_req_msg_s)) 1486 _NOTE(READ_ONLY_DATA(ibcm_rep_msg_s)) 1487 _NOTE(READ_ONLY_DATA(ibcm_mra_msg_s)) 1488 _NOTE(READ_ONLY_DATA(ibcm_rej_msg_s)) 1489 _NOTE(READ_ONLY_DATA(ibcm_lap_msg_s)) 1490 _NOTE(READ_ONLY_DATA(ibcm_apr_msg_s)) 1491 _NOTE(READ_ONLY_DATA(ibcm_sidr_req_msg_s)) 1492 _NOTE(READ_ONLY_DATA(ibcm_sidr_rep_msg_s)) 1493 _NOTE(READ_ONLY_DATA(ibcm_rtu_msg_s)) 1494 _NOTE(READ_ONLY_DATA(ibcm_dreq_msg_s)) 1495 _NOTE(READ_ONLY_DATA(ibcm_drep_msg_s)) 1496 _NOTE(READ_ONLY_DATA(ibcm_classportinfo_msg_s)) 1497 1498 /* Prototype definitions for CM implementation functions */ 1499 1500 /* 1501 * The callback from IBMF to CM. This routines calls one of the CM 1502 * state processing functions depending upon mesg/attribute id 1503 * 1504 * ibmf_handle : IBMF handle on which CM MAD was received 1505 * pktp : MAD packet 1506 * args : IBMF receive mad callback arg 1507 */ 1508 void ibcm_recv_cb(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, void *args); 1509 1510 /* 1511 * Prototypes for CM state transition handling functions 1512 */ 1513 1514 /* 1515 * The following are the CM state processing functions called on an 1516 * incoming REQ/REP/RTU/MRA/REJ/DREQ/DREP on active/passive sides 1517 * (Also handled are SIDR_REP and SIDR_REQ) 1518 * The brief description of these functions 1519 * Search based on CM message fields in CM's HCA entry. 1520 * Create/Delete state structures based on incoming message 1521 * Handle duplicate messages and state transitions 1522 * Set and Cancel timeouts 1523 * Handle stale connections 1524 * Change CM connection state 1525 * Call CM CEP state transition functions to update CEP state 1526 * and set CEP attributes 1527 * 1528 * INPUTS: 1529 * hcap: - IBMF callback argument 1530 * cm_input_mad: - ibmf message pointer of incoming MAD 1531 * cm_mad_addr - CM MAD address 1532 * 1533 * The state transition processing is specified in different functions based 1534 * on incoming message type rather than as one function because, the CM 1535 * processing is different for each of them. 1536 * 1537 * A global call table is initialized with these function addresses 1538 * (is defined in ibcm_impl.c), and invoked from ibcm_recv_cb 1539 * (IBMF's recv callback to CM) based on mesg/attribute id. 1540 */ 1541 void ibcm_process_req_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1542 ibcm_mad_addr_t *cm_mad_addr); 1543 void ibcm_process_rep_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1544 ibcm_mad_addr_t *cm_mad_addr); 1545 void ibcm_process_rtu_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1546 ibcm_mad_addr_t *cm_mad_addr); 1547 void ibcm_process_dreq_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1548 ibcm_mad_addr_t *cm_mad_addr); 1549 void ibcm_process_drep_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1550 ibcm_mad_addr_t *cm_mad_addr); 1551 void ibcm_process_rej_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1552 ibcm_mad_addr_t *cm_mad_addr); 1553 void ibcm_process_mra_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1554 ibcm_mad_addr_t *cm_mad_addr); 1555 void ibcm_process_apr_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1556 ibcm_mad_addr_t *cm_mad_addr); 1557 void ibcm_process_lap_msg(ibcm_hca_info_t *hcap, uint8_t *cm_input_mad, 1558 ibcm_mad_addr_t *cm_mad_addr); 1559 void ibcm_process_sidr_req_msg(ibcm_hca_info_t *hcap, 1560 uint8_t *cm_input_mad, ibcm_mad_addr_t *cm_mad_addr); 1561 void ibcm_process_sidr_rep_msg(ibcm_hca_info_t *hcap, 1562 uint8_t *cm_input_mad, ibcm_mad_addr_t *cm_mad_addr); 1563 1564 typedef enum ibcm_proceed_error_e { 1565 IBCM_PROCEED_INVALID_NONE = 0, 1566 IBCM_PROCEED_INVALID_EVENT, 1567 IBCM_PROCEED_INVALID_EVENT_STATE, 1568 IBCM_PROCEED_INVALID_PRIV_SZ, 1569 IBCM_PROCEED_INVALID_LAP 1570 } ibcm_proceed_error_t; 1571 1572 /* Encapsulates the information that client returns back from CM callback */ 1573 typedef struct ibcm_clnt_reply_info_s { 1574 ibt_cm_proceed_reply_t *reply_event; 1575 void *priv_data; 1576 ibt_priv_data_len_t priv_data_len; 1577 } ibcm_clnt_reply_info_t; 1578 1579 /* Encapsulates the information that UD client returns back from CM callback */ 1580 typedef struct ibcm_ud_clnt_reply_info_s { 1581 ib_qpn_t ud_qpn; 1582 ib_qkey_t ud_qkey; 1583 ibt_redirect_info_t *redirect_infop; 1584 void *priv_data; 1585 ibt_priv_data_len_t priv_data_len; 1586 } ibcm_ud_clnt_reply_info_t; 1587 1588 /* 1589 * Prototypes for CM CEP state transition handling functions. These are 1590 * called from CM connection state transition handling functions. 1591 * 1592 * The brief description of these functions : 1593 * Validate CEP related attributes in the messages 1594 * Change CEP state 1595 * Set CEP attributes (modify CEP) 1596 * Call client/server callback handlers 1597 * Fill up the response MADs 1598 * 1599 * The arguments are : 1600 * statep: Connection state structure 1601 * cm_req/rep/rtu/rej msg : Received CM message 1602 * cm_output_mad : The response CM MAD with some of the fields filled in 1603 * The cm output mad is allocated by CM state transition 1604 * functions and has generic MAD header 1605 * Certain fields like com id, etc., are filled by CM 1606 * connection state transition functions that are above 1607 */ 1608 1609 /* QP state transition function called for an incoming REQ on passive side */ 1610 ibcm_status_t ibcm_cep_state_req(ibcm_state_data_t *statep, 1611 ibcm_req_msg_t *cm_req_msg, ibt_cm_reason_t *reason, 1612 uint8_t *arej_info_len); 1613 1614 /* Processes QP state machine based on return values from cm handler */ 1615 ibcm_status_t ibcm_process_cep_req_cm_hdlr(ibcm_state_data_t *statep, 1616 ibt_cm_status_t cb_status, 1617 ibcm_clnt_reply_info_t *clnt_info, 1618 ibt_cm_reason_t *reject_reason, uint8_t *arej_len, 1619 ibcm_req_msg_t *cm_req_msgp); 1620 1621 /* Processes CM state machine based on return values from ibcm_cep_state_req */ 1622 void ibcm_handle_cep_req_response(ibcm_state_data_t *statep, 1623 ibcm_status_t response, ibt_cm_reason_t reject_reason, 1624 uint8_t arej_info_len); 1625 1626 /* QP state transition function called for an incoming REP on active side */ 1627 ibcm_status_t ibcm_cep_state_rep(ibcm_state_data_t *statep, 1628 ibcm_rep_msg_t *cm_rep_msg, ibt_cm_reason_t *reason, 1629 uint8_t *arej_info_len); 1630 1631 /* Processes QP state machine based on return values from cm handler */ 1632 ibcm_status_t ibcm_process_cep_rep_cm_hdlr(ibcm_state_data_t *statep, 1633 ibt_cm_status_t cb_status, 1634 ibcm_clnt_reply_info_t *clnt_info, 1635 ibt_cm_reason_t *reject_reason, uint8_t *arej_len, 1636 ibcm_rep_msg_t *cm_rep_msgp); 1637 1638 /* Processes CM state machine based on return values from ibcm_cep_state_rep */ 1639 void ibcm_handle_cep_rep_response(ibcm_state_data_t *statep, 1640 ibcm_status_t response, ibt_cm_reason_t reject_reason, 1641 uint8_t arej_info_len, ibcm_rep_msg_t *rep_msgp); 1642 1643 /* QP state transition function called for an incoming RTU on passive side */ 1644 void ibcm_cep_state_rtu(ibcm_state_data_t *statep, 1645 ibcm_rtu_msg_t *cm_rtu_msg); 1646 1647 /* QP state transition func called for an incoming REJ on active/passive side */ 1648 void ibcm_cep_state_rej(ibcm_state_data_t *statep, 1649 ibcm_rej_msg_t *cm_rej_msg, ibcm_conn_state_t rej_state); 1650 1651 /* QP state transition func for an incoming REJ on active side in est state */ 1652 void ibcm_cep_state_rej_est(ibcm_state_data_t *statep); 1653 1654 /* 1655 * QP state transition function called for an outgoing RTU on active side, 1656 * after setting CEP to RTS state active/passive side 1657 */ 1658 void ibcm_cep_send_rtu(ibcm_state_data_t *statep); 1659 1660 1661 /* QP state transition function called for an incoming LAP */ 1662 ibcm_status_t ibcm_cep_state_lap(ibcm_state_data_t *statep, 1663 ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg); 1664 1665 /* Processes QP state machine based on return value from cm handler for LAP */ 1666 void ibcm_process_cep_lap_cm_hdlr(ibcm_state_data_t *statep, 1667 ibt_cm_status_t cb_status, 1668 ibcm_clnt_reply_info_t *clnt_info, 1669 ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg); 1670 1671 void ibcm_post_apr_mad(ibcm_state_data_t *statep); 1672 1673 void ibcm_cep_state_apr(ibcm_state_data_t *statep, 1674 ibcm_lap_msg_t *lap_msg, ibcm_apr_msg_t *apr_msg); 1675 1676 /* Processes CM state machine based on return value from cm handler */ 1677 void ibcm_handle_cep_dreq_response(ibcm_state_data_t *statep, 1678 void *priv_data, ibt_priv_data_len_t priv_data_len); 1679 1680 /* Processes CM UD state machine based on return values from cm handler */ 1681 void ibcm_process_sidr_req_cm_hdlr(ibcm_ud_state_data_t *ud_statep, 1682 ibt_cm_status_t cb_status, 1683 ibcm_ud_clnt_reply_info_t *ud_clnt_info, 1684 ibt_sidr_status_t *sidr_status, 1685 ibcm_sidr_rep_msg_t *sidr_repp); 1686 1687 void ibcm_proceed_via_taskq(void *targs); 1688 void ibcm_ud_proceed_via_taskq(void *targs); 1689 1690 /* 1691 * Builds the reply MAD address based on "incoming mad addr" that is 1692 * supplied to it as an arg. 1693 * Swaps the source and destination lids in ibmf_addr_info_t 1694 * Swaps the source and destination gids in ib_grh_t 1695 * 1696 * INPUTS: 1697 * incoming_cm_mad_addr - Address information in the incoming MAD 1698 * reply_cm_mad_addr - Derived address for the reply MAD 1699 * The reply MAD address is derived based 1700 * address information of incoming CM MAD 1701 */ 1702 void ibcm_build_reply_mad_addr(ibcm_mad_addr_t *incoming_cm_mad_addr, 1703 ibcm_mad_addr_t *reply_cm_mad_addr); 1704 1705 /* Posts RC CM MAD using IBMF */ 1706 void ibcm_post_rc_mad(ibcm_state_data_t *statep, ibmf_msg_t *msgp, 1707 ibmf_msg_cb_t post_cb, void *args); 1708 1709 /* Posts UD CM MAD using IBMF */ 1710 void ibcm_post_ud_mad(ibcm_ud_state_data_t *ud_statep, ibmf_msg_t *msgp, 1711 ibmf_msg_cb_t ud_post_cb, void *args); 1712 1713 /* Posts CM MAD using IBMF */ 1714 ibt_status_t ibcm_post_mad(ibmf_msg_t *msgp, ibcm_mad_addr_t *cm_mad_addr, 1715 ibmf_msg_cb_t post_cb, void *args); 1716 1717 /* Post REJ MAD */ 1718 void ibcm_post_rej_mad(ibcm_state_data_t *statep, ibt_cm_reason_t reason, 1719 int who, void *addl_rej_info, uint8_t arej_info_len); 1720 1721 /* Post REP MAD */ 1722 void ibcm_post_rep_mad(ibcm_state_data_t *statep); 1723 1724 /* Post RTU MAD */ 1725 ibcm_status_t ibcm_post_rtu_mad(ibcm_state_data_t *statep); 1726 1727 /* Post DREQ MAD */ 1728 void ibcm_post_dreq_mad(void *statep); 1729 1730 /* Post LAP MAD */ 1731 void ibcm_post_lap_mad(ibcm_state_data_t *statep); 1732 1733 1734 /* 1735 * Posts CM SIDR MAD using IBMF in blocking mode 1736 * 1737 * INPUTS: 1738 * ud_statep: UD statep which is posting the mad 1739 * cm_mad_addr: Address information for the MAD to be posted 1740 * status: SIDR status 1741 */ 1742 void ibcm_post_sidr_rep_mad(ibcm_ud_state_data_t *ud_statep, 1743 ibt_sidr_status_t status); 1744 1745 /* prototypes to resend RC mad and UD MAD */ 1746 void ibcm_resend_rep_mad(ibcm_state_data_t *statep); 1747 void ibcm_resend_rtu_mad(ibcm_state_data_t *statep); 1748 void ibcm_resend_rej_mad(ibcm_state_data_t *statep); 1749 void ibcm_resend_mra_mad(ibcm_state_data_t *statep); 1750 void ibcm_resend_srep_mad(ibcm_ud_state_data_t *statep); 1751 1752 1753 /* Helper function used in connection abort processing */ 1754 void ibcm_process_abort(ibcm_state_data_t *statep); 1755 1756 /* 1757 * Prototypes for CM functions that lookup for a connection state structure 1758 */ 1759 1760 /* 1761 * ibcm_lookup_msg: 1762 * 1763 * Retrieves an existing state structure or creates a new one if none found. 1764 * This function is used during passive side of connection establishment for 1765 * INCOMING REQ/REJ/RTU/MRA 1766 * This function is used during active side of connection establishment for 1767 * INCOMING REP/REJ/MRA 1768 * This function is used during active side of connection establishment for 1769 * an outgoing REQ. 1770 * 1771 * NOTE: IBCM_LOOKP_FAIL is only returned if a new entry wasn't created and 1772 * a match wasn't found. 1773 * 1774 * Arguments are:- 1775 * ibcm_event_type_t - what type of message 1776 * incoming REQ, REP, REJ, MRA, RTU, DREQ, DREP 1777 * local_comid - ONLY *NOT* valid for incoming REQ. 1778 * needed for others 1779 * remote_qpn - Remote CM's QP number 1780 * remote_hca_guid - ONLY VALID FOR incoming REQ. 1781 * Ignored for others 1782 * hcap - HCA entry table pointer 1783 * statep - "return"ed state pointer 1784 * 1785 * Return Values: 1786 * IBCM_LOOKUP_NEW - new statep allocated 1787 * IBCM_LOOKUP_EXISTS - found an existing entry 1788 * IBCM_LOOKUP_FAIL - failed to find an entry 1789 * IBCM_MEMORY_FAILURE - failed to get memory 1790 * iff flags != IBT_CHAN_BLOCKING 1791 */ 1792 ibcm_status_t ibcm_lookup_msg(ibcm_event_type_t event_type, 1793 ib_com_id_t local_comid, ib_qpn_t remote_qpn, 1794 ib_guid_t remote_hca_guid, ibcm_hca_info_t *hcap, 1795 ibcm_state_data_t **statep); 1796 1797 1798 /* 1799 * Routines for CM SIDR state structure list manipulation 1800 * Wherever possible, the list routines of ibtl are used 1801 * for list manipulation 1802 */ 1803 1804 /* 1805 * Finds an entry based on lid, gid and grh exists fields 1806 * lid: LID of incoming SIDR REQ 1807 * gid: GID of incoming SIDR REQ 1808 * grh_exists: TRUE if GRH exists in the incoming SIDR REQ 1809 * hcap: CM State HCA entry ptr to search for SIDR state structure 1810 * statep: Returns a valid state structure, if one exists based 1811 * on lid, gid and grh_exists fields 1812 * flag: whether to just look OR to look and add if it doesn't exist. 1813 */ 1814 ibcm_status_t ibcm_find_sidr_entry(ibcm_sidr_srch_t *srch_param, 1815 ibcm_hca_info_t *hcap, 1816 ibcm_ud_state_data_t **statep, 1817 ibcm_lookup_flag_t flag); 1818 1819 ibcm_ud_state_data_t *ibcm_add_sidr_entry(ibcm_sidr_srch_t *srch_param, 1820 ibcm_hca_info_t *hcap); 1821 1822 /* 1823 * Deletes a given state structure, from both hca state and passive trees 1824 * If ref cnt is zero, deallocates all buffers and memory of state data 1825 */ 1826 void ibcm_delete_state_data(ibcm_state_data_t *statep); 1827 1828 /* 1829 * Deallocates all the buffers and memory of state data. 1830 * This function must be called, only when ref_cnt is zero. 1831 */ 1832 void ibcm_dealloc_state_data(ibcm_state_data_t *statep); 1833 1834 /* 1835 * Deletes a given UD state structure, from SIDR list. 1836 * The routine acquires and releases the SIDR list lock. 1837 */ 1838 void ibcm_delete_ud_state_data(ibcm_ud_state_data_t *statep); 1839 void ibcm_dealloc_ud_state_data(ibcm_ud_state_data_t *statep); 1840 1841 /* 1842 * Service ID entry create and lookup functions 1843 */ 1844 1845 /* 1846 * Adds/looks-up an ibcm_svc_info_t entry in the CM's global table. 1847 * This global table is defined in ibcm_impl.c. 1848 * 1849 * svc_info_list_lock must be held for RW_READER by caller of 1850 * ibcm_find_svc_entry(). 1851 * 1852 * Arguments are:- 1853 * sid - service id 1854 * num_sids - Number (Range) of service-ids 1855 * 1856 * Return values: 1857 * Pointer to ibcm_svc_info_t on success, otherwise NULL. 1858 */ 1859 int ibcm_svc_compare(const void *p1, const void *p2); 1860 ibcm_svc_info_t *ibcm_create_svc_entry(ib_svc_id_t sid, int num_sids); 1861 ibcm_svc_info_t *ibcm_find_svc_entry(ib_svc_id_t sid); 1862 1863 /* 1864 * The following are the function prototypes for various id initialization, 1865 * allocation, free and destroy operations. The cm id allocations are based 1866 * on vmem operations 1867 * The service id's are maintained globally per host 1868 * The com id and req id's are maintained per hca 1869 * To maintain compatibility with intel, service ids are allocated on a 32 bit 1870 * range, though spec has 64 bit range for service id's 1871 */ 1872 ibcm_status_t ibcm_init_ids(); 1873 void ibcm_fini_ids(); 1874 1875 ibcm_status_t ibcm_init_hca_ids(ibcm_hca_info_t *hcap); 1876 void ibcm_fini_hca_ids(ibcm_hca_info_t *hcap); 1877 1878 ibcm_status_t ibcm_alloc_comid(ibcm_hca_info_t *hcap, ib_com_id_t *comid); 1879 void ibcm_free_comid(ibcm_hca_info_t *hcap, ib_com_id_t comid); 1880 1881 ibcm_status_t ibcm_alloc_reqid(ibcm_hca_info_t *hcap, uint32_t *reqid); 1882 void ibcm_free_reqid(ibcm_hca_info_t *hcap, uint32_t reqid); 1883 1884 ib_svc_id_t ibcm_alloc_local_sids(int num_sids); 1885 void ibcm_free_local_sids(ib_svc_id_t service_id, int num_sids); 1886 1887 ib_svc_id_t ibcm_alloc_ip_sid(); 1888 void ibcm_free_ip_sid(ib_svc_id_t sid); 1889 1890 uint64_t ibcm_generate_tranid(uint8_t event, uint32_t id, 1891 uint32_t cm_tran_priv); 1892 1893 void ibcm_decode_tranid(uint64_t tran_id, uint32_t *cm_tran_priv); 1894 1895 ibcm_status_t ibcm_ar_init(void); 1896 ibcm_status_t ibcm_ar_fini(void); 1897 1898 /* IP Addressing API debugging */ 1899 extern int ibcm_printip; /* set to 1 to enable IBTF DPRINTFs */ 1900 extern void ibcm_ip_print(char *label, ibt_ip_addr_t *ipa); 1901 1902 #define IBCM_PRINT_IP(LABEL, IP_ADDR) \ 1903 if (ibcm_printip) { \ 1904 ibcm_ip_print(LABEL, IP_ADDR); \ 1905 } 1906 /* 1907 * These functions are called to do timeout processing from CM connection 1908 * state transitions. (Also for SIDR REQ and SIDR REP processing) 1909 * 1910 * Brief description : 1911 * If retry count is below max retry value, then post the stored response 1912 * MAD using IBMF in blocking mode, adjusts remaining retry counters. 1913 * If retry counter reaches max value, then retry failure handling is 1914 * done here 1915 * 1916 * CM will ensure that the state data structure of the associated 1917 * timeout is valid when this timeout function is called. 1918 * (See timer_stored_state in ibcm_state_data_t and 1919 * ud_timer_stored_state in ibcm_ud_state_data_t) 1920 */ 1921 void ibcm_timeout_cb(void *arg); 1922 void ibcm_sidr_timeout_cb(void *arg); 1923 1924 /* 1925 * function prototypes for IBMF send completion callbacks on non-blocking 1926 * MAD posts 1927 */ 1928 void ibcm_post_req_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1929 void *args); 1930 void ibcm_post_rep_wait_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1931 void *args); /* MRA Rcvd on active side */ 1932 void ibcm_post_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1933 void *args); 1934 void ibcm_resend_post_rep_complete(ibmf_handle_t ibmf_handle, 1935 ibmf_msg_t *msgp, void *args); 1936 void ibcm_post_mra_rep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1937 void *args); /* MRA Rcvd on passive side */ 1938 void ibcm_post_rej_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1939 void *args); 1940 void ibcm_post_dreq_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1941 void *args); 1942 void ibcm_post_drep_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1943 void *args); 1944 void ibcm_post_lap_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1945 void *args); 1946 void ibcm_post_apr_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1947 void *args); 1948 void ibcm_post_stored_apr_complete(ibmf_handle_t ibmf_handle, 1949 ibmf_msg_t *msgp, void *args); 1950 void ibcm_post_mra_lap_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1951 void *args); /* MRA Rcvd for LAP on active side */ 1952 void ibcm_post_mra_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1953 void *args); /* for MRA sender */ 1954 void ibcm_post_rtu_complete(ibmf_handle_t ibmf_handle, ibmf_msg_t *msgp, 1955 void *args); 1956 1957 void ibcm_post_sidr_req_complete(ibmf_handle_t ibmf_handle, 1958 ibmf_msg_t *msgp, void *args); 1959 1960 /* 1961 * ibcm_find_hca_entry: 1962 * Given a HCA's GUID find out ibcm_hca_info_t entry for that HCA 1963 * This entry can be then used to access AVL tree/SIDR list etc. 1964 * 1965 * NOTE: This entry is not removed from the "ibcm_hca_listp". 1966 * And this function is called with ibcm_hca_list_mutex mutex held. 1967 * 1968 * INPUTS: 1969 * hca_guid - HCA's guid 1970 * 1971 * RETURN VALUE: 1972 * hcap - if a match is found, else NULL 1973 */ 1974 ibcm_hca_info_t *ibcm_find_hca_entry(ib_guid_t hca_guid); 1975 ibcm_hca_info_t *ibcm_find_hcap_entry(ib_guid_t hca_guid); 1976 void ibcm_delete_hca_entry(ibcm_hca_info_t *hcap); 1977 1978 /* Routines that manage the hca's temporary access count */ 1979 ibcm_status_t ibcm_inc_hca_acc_cnt(ibcm_hca_info_t *hca); 1980 void ibcm_dec_hca_acc_cnt(ibcm_hca_info_t *hca); 1981 1982 /* Routines that manage the hca's resource count */ 1983 void ibcm_inc_hca_res_cnt(ibcm_hca_info_t *hca); 1984 void ibcm_dec_hca_res_cnt(ibcm_hca_info_t *hca); 1985 1986 /* Routines that manage the hca's service count */ 1987 void ibcm_inc_hca_svc_cnt(ibcm_hca_info_t *hca); 1988 void ibcm_dec_hca_svc_cnt(ibcm_hca_info_t *hca); 1989 1990 /* Routine to fetch the saa_handle */ 1991 ibmf_saa_handle_t ibcm_get_saa_handle(ibcm_hca_info_t *hcap, uint8_t port); 1992 1993 /* Allow some flow control of RC connection initiations */ 1994 void ibcm_flow_inc(void); 1995 void ibcm_flow_dec(hrtime_t delta, char *mad_type); 1996 1997 /* Allow some flow control of SA requests */ 1998 void ibcm_sa_access_enter(void); 1999 void ibcm_sa_access_exit(void); 2000 2001 /* 2002 * ibcm_cep_to_error_state: 2003 * Helper function to transition a CEP to ERROR state 2004 * 2005 * NOTE: This function checks if ch_qp is valid or ch_eec and calls 2006 * into IBTL to transition the CEP. 2007 * 2008 * INPUTS: 2009 * statep - Connection state pointer 2010 * 2011 * RETURN VALUE: 2012 * IBT_SUCCESS - if CEP transition succeeded; else error 2013 */ 2014 ibt_status_t ibcm_cep_to_error_state(ibcm_state_data_t *statep); 2015 2016 /* 2017 * Processes the pending stateps in a linked list. The operations are to 2018 * invoke a cm handler or delete statep 2019 * When the above operations are required on statep from a timeout handler, 2020 * they are linked for later processing by an independent thread 2021 */ 2022 void ibcm_process_tlist(); 2023 /* Links RC stateps to an RC timeout processing list */ 2024 void ibcm_add_tlist(ibcm_state_data_t *statep); 2025 2026 /* Links SIDR/UD stateps to an SIDR/UD timeout processing list */ 2027 void ibcm_add_ud_tlist(ibcm_ud_state_data_t *ud_statep); 2028 2029 /* 2030 * This call either aborts a pending or completes a in-progress LAP/APR 2031 * operation 2032 */ 2033 void ibcm_sync_lapr_idle(ibcm_state_data_t *statep); 2034 2035 void ibcm_process_rc_recycle(void *recycle_arg); 2036 2037 /* 2038 * Helper function to handle endianess in case of Service Data. 2039 * Used by ibt_bind_service() and ibt_get_paths(). 2040 */ 2041 void ibcm_swizzle_from_srv(ibt_srv_data_t *sb_data, uint8_t *service_bytes); 2042 void ibcm_swizzle_to_srv(uint8_t *service_bytes, ibt_srv_data_t *sb_data); 2043 2044 /* Misc ibcm global variables */ 2045 extern char cmlog[]; 2046 extern ibt_clnt_hdl_t ibcm_ibt_handle; 2047 extern taskq_t *ibcm_taskq; 2048 extern ibcm_state_handler_t ibcm_sm_funcs_tbl[]; 2049 extern uint8_t ibcm_timeout_list_flags; 2050 extern ibcm_classportinfo_msg_t ibcm_clpinfo; 2051 2052 /* Global lists */ 2053 extern avl_tree_t ibcm_svc_avl_tree; /* global service id tree */ 2054 extern ibcm_state_data_t *ibcm_timeout_list_hdr, *ibcm_timeout_list_tail; 2055 extern ibcm_ud_state_data_t *ibcm_ud_timeout_list_hdr, 2056 *ibcm_ud_timeout_list_tail; 2057 /* Default global retry counts */ 2058 extern uint8_t ibcm_max_retries; 2059 extern uint32_t ibcm_max_sa_retries; 2060 extern int ibcm_sa_timeout_delay; /* in ticks */ 2061 2062 /* Various default global timers */ 2063 extern ibt_rnr_nak_time_t ibcm_default_rnr_nak_time; 2064 2065 extern clock_t ibcm_local_processing_time; /* usecs */ 2066 extern clock_t ibcm_remote_response_time; 2067 extern ib_time_t ibcm_max_sidr_rep_proctime; 2068 extern ib_time_t ibcm_max_sidr_rep_store_time; 2069 extern uint32_t ibcm_adj_btime; 2070 extern uint32_t ibcm_sw_delay; 2071 2072 extern ib_time_t ibcm_max_ib_pkt_lt; 2073 extern ib_time_t ibcm_max_ib_mad_pkt_lt; 2074 2075 /* Global locks */ 2076 extern kmutex_t ibcm_svc_info_lock; 2077 extern kmutex_t ibcm_mcglist_lock; 2078 extern kmutex_t ibcm_global_hca_lock; 2079 extern kmutex_t ibcm_qp_list_lock; 2080 extern kmutex_t ibcm_timeout_list_lock; 2081 extern kmutex_t ibcm_recv_mutex; 2082 2083 /* Global cond variables */ 2084 extern kcondvar_t ibcm_global_hca_cv; 2085 extern kcondvar_t ibcm_svc_info_cv; 2086 extern kcondvar_t ibcm_timeout_list_cv; 2087 extern kcondvar_t ibcm_timeout_thread_done_cv; 2088 2089 _NOTE(LOCK_ORDER(ibcm_state_data_s::state_mutex ibcm_timeout_list_lock)) 2090 _NOTE(LOCK_ORDER(ibcm_ud_state_data_s::ud_state_mutex ibcm_timeout_list_lock)) 2091 _NOTE(LOCK_ORDER(ibcm_hca_info_s::hca_state_rwlock 2092 ibcm_state_data_s::state_mutex)) 2093 _NOTE(LOCK_ORDER(ibcm_hca_info_s::hca_sidr_list_lock 2094 ibcm_ud_state_data_s::ud_state_mutex)) 2095 2096 _NOTE(READ_ONLY_DATA(ibcm_local_processing_time ibcm_remote_response_time 2097 ibcm_max_sidr_rep_proctime ibcm_max_sidr_rep_store_time ibcm_adj_btime 2098 ibcm_sw_delay ibcm_max_retries ibcm_max_sa_retries)) 2099 2100 /* 2101 * miscellaneous defines for retries, times etc. 2102 */ 2103 #define IBCM_MAX_RETRIES 11 /* Max CM retries for a msg */ 2104 #define IBCM_LOCAL_RESPONSE_TIME 300000 /* Local CM processing time */ 2105 /* in usecs */ 2106 #define IBCM_REMOTE_RESPONSE_TIME 300000 /* Remote CM response time */ 2107 /* in usecs */ 2108 #define IBCM_MAX_SIDR_PROCESS_TIME 16 /* Time to process SIDR REP */ 2109 #define IBCM_MAX_SIDR_PKT_LIFE_TIME 9 /* Approx pkt lt for UD srver */ 2110 2111 #define IBCM_MAX_IB_PKT_LT 20 /* 4 second */ 2112 #define IBCM_MAX_IB_MAD_PKT_LT 18 /* 1 second */ 2113 2114 #define IBCM_MAX_SA_RETRIES 0 /* Max CM retry for SA update */ 2115 2116 /* versions for CM MADs */ 2117 #define IBCM_MAD_BASE_VERSION 1 2118 #define IBCM_MAD_CLASS_VERSION 2 2119 2120 /* for Class_Port_Info stuff - see section 16.7.3.1 in Vol1 IB Spec */ 2121 #define IBCM_CPINFO_CAP_RC 0x0200 /* RC is supported */ 2122 #define IBCM_CPINFO_CAP_RD 0x0400 /* RD is supported */ 2123 #define IBCM_CPINFO_CAP_RAW 0x0800 /* Raw Datagrams supported */ 2124 #define IBCM_CPINFO_CAP_UC 0x1000 /* UC supported */ 2125 #define IBCM_CPINFO_CAP_SIDR 0x2000 /* SIDR supported */ 2126 2127 #define IBCM_V4_PART_OF_V6(v6) v6.s6_addr32[3] 2128 /* RDMA CM IP Service's Private Data Format. */ 2129 #ifdef _BIG_ENDIAN 2130 typedef struct ibcm_ip_pvtdata_s { 2131 uint8_t ip_MajV:4, 2132 ip_MinV:4; 2133 uint8_t ip_ipv:4, 2134 ip_rsvd:4; /* 0-3: rsvd, 4-7: ipv */ 2135 uint16_t ip_srcport; /* Source Port */ 2136 in6_addr_t ip_srcip; /* Source IP address. */ 2137 in6_addr_t ip_dstip; /* Remote IP address. */ 2138 #define ip_srcv4 IBCM_V4_PART_OF_V6(ip_srcip) 2139 #define ip_dstv4 IBCM_V4_PART_OF_V6(ip_dstip) 2140 #define ip_srcv6 ip_srcip 2141 #define ip_dstv6 ip_dstip 2142 } ibcm_ip_pvtdata_t; 2143 #else 2144 typedef struct ibcm_ip_pvtdata_s { 2145 uint8_t ip_MinV:4, 2146 ip_MajV:4; 2147 uint8_t ip_rsvd:4, 2148 ip_ipv:4; /* 0-3: rsvd, 4-7: ipv */ 2149 uint16_t ip_srcport; /* Source Port */ 2150 in6_addr_t ip_srcip; /* Source IP address. */ 2151 in6_addr_t ip_dstip; /* Remote IP address. */ 2152 #define ip_srcv4 IBCM_V4_PART_OF_V6(ip_srcip) 2153 #define ip_dstv4 IBCM_V4_PART_OF_V6(ip_dstip) 2154 #define ip_srcv6 ip_srcip 2155 #define ip_dstv6 ip_dstip 2156 } ibcm_ip_pvtdata_t; 2157 #endif 2158 2159 /* 2160 * for debug purposes 2161 */ 2162 #ifdef DEBUG 2163 extern int ibcm_test_mode; 2164 2165 void ibcm_query_qp(ibmf_handle_t ibmf_hdl, ibmf_qp_handle_t ibmf_qp); 2166 void ibcm_dump_raw_message(uchar_t *); 2167 void ibcm_dump_srvrec(sa_service_record_t *); 2168 void ibcm_dump_pathrec(sa_path_record_t *); 2169 void ibcm_dump_noderec(sa_node_record_t *); 2170 2171 void ibcm_query_classport_info(ibt_channel_hdl_t channel); 2172 2173 #define IBCM_DUMP_RAW_MSG(x) ibcm_dump_raw_message(x) 2174 #define IBCM_DUMP_SERVICE_REC(x) ibcm_dump_srvrec(x) 2175 #define IBCM_DUMP_PATH_REC(x) ibcm_dump_pathrec(x) 2176 #define IBCM_DUMP_NODE_REC(x) ibcm_dump_noderec(x) 2177 #else 2178 #define IBCM_DUMP_RAW_MSG(x) 2179 #define IBCM_DUMP_SERVICE_REC(x) 2180 #define IBCM_DUMP_PATH_REC(x) 2181 #define IBCM_DUMP_NODE_REC(x) 2182 #endif 2183 2184 ibt_status_t ibcm_ibmf_analyze_error(int ibmf_status); 2185 2186 ibt_status_t ibcm_contact_sa_access(ibmf_saa_handle_t saa_handle, 2187 ibmf_saa_access_args_t *access_args, size_t *length, void **results_p); 2188 2189 ibt_status_t ibcm_ibtl_node_info(ib_guid_t, uint8_t, ib_lid_t, 2190 ibt_node_info_t *node_info); 2191 2192 void ibcm_path_cache_init(void); 2193 void ibcm_path_cache_fini(void); 2194 void ibcm_path_cache_purge(void); 2195 2196 #ifdef __cplusplus 2197 } 2198 #endif 2199 2200 2201 #endif /* _SYS_IB_MGT_IBCM_IBCM_IMPL_H */ 2202