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 /* 23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * Copyright 2019, Joyent, Inc. 28 */ 29 30 #ifndef _SRPT_IMPL_H_ 31 #define _SRPT_IMPL_H_ 32 33 /* 34 * Prototypes and data structures for the SRP Target Port Provider. 35 */ 36 37 #include <sys/types.h> 38 #include <sys/ddi.h> 39 #include <sys/ib/ibtl/ibti.h> 40 #include <sys/modctl.h> 41 42 #include <sys/stmf.h> 43 #include <sys/stmf_ioctl.h> 44 #include <sys/portif.h> 45 46 #include <sys/ib/mgt/ibdma/ibdma.h> 47 48 #ifdef __cplusplus 49 extern "C" { 50 #endif 51 52 /* Format the session identifier */ 53 #define ALIAS_STR(s, a, b) \ 54 ((void) snprintf((s), sizeof ((s)), "%016llx:%016llx", \ 55 (u_longlong_t)(a), (u_longlong_t)(b))) 56 57 /* Format the EUI name */ 58 #define EUI_STR(s, a) \ 59 ((void) snprintf((s), sizeof ((s)), "eui.%016llX", (u_longlong_t)(a))) 60 61 /* 62 * We should/could consider making some of these values tunables. 63 * Specifically, SEND_MSG_SIZE and SEND_MSG_DEPTH. 64 */ 65 enum { 66 SRPT_DEFAULT_IOC_SRQ_SIZE = 4096, 67 SRPT_DEFAULT_SEND_MSG_DEPTH = 128, 68 /* 69 * SEND_MSG_SIZE must be a multiple of 64 as it is registered 70 * as memory regions with IB. To support a scatter/gather table 71 * size of 32, the size must be at not less than 960. To support 72 * the maximum scatter/gather table size of 255, the IU must 73 * be at least 4160 bytes. 74 */ 75 SRPT_DEFAULT_SEND_MSG_SIZE = 4160, 76 SRPT_DEFAULT_MAX_RDMA_SIZE = 65536, 77 SRPT_MIN_T_I_IU_LEN = 52, 78 SRPT_EUI_ID_LEN = 20, 79 SRPT_RECV_WC_POLL_SIZE = 16, 80 SRPT_SEND_WC_POLL_SIZE = 16, 81 SRPT_MAX_OUT_IO_PER_CMD = 16, 82 SRPT_FENCE_SEND = 1, 83 SRPT_NO_FENCE_SEND = 0 84 }; 85 86 struct srpt_target_port_s; 87 88 #define SRPT_ALIAS_LEN (SRP_PORT_ID_LEN * 2 + 2) 89 90 /* 91 * SRP Session - represents a SCSI I_T_Nexus. 92 * 93 * Sessions map 1 or more initiator logins to a specific I/O 94 * Controller SCSI Target Port. Targets create sessions 95 * at initiator login and release when no longer referenced 96 * by a login. 97 */ 98 typedef struct srpt_session_s { 99 krwlock_t ss_rwlock; 100 list_node_t ss_node; 101 102 /* 103 * ADVANCED FEATURE, NOT YET SUPPORTED. 104 * In multi-channel mode, multiple RDMA communication 105 * channels may reference the same SCSI session. When 106 * a channel releases its reference to the SCSI session, 107 * it should have no tasks associated with the session. 108 * 109 * If multi-channel is implemented, add a channel list 110 * to this object instead of tracking it on the target. 111 * 112 * Will also need a session state & mode. Mode is to 113 * track if the session is MULTI or SINGLE channel. 114 */ 115 116 stmf_scsi_session_t *ss_ss; 117 struct srpt_target_port_s *ss_tgt; 118 list_t ss_task_list; 119 120 /* 121 * SRP Initiator and target identifiers are 128-bit. 122 * 123 * The specification defines the initiator to be 64-bits of 124 * ID extension and 64 bits of GUID, but these are really 125 * just a recommendation. Generally the extension is used 126 * to create unique I_T_Nexus from the same initiator and 127 * target. Initiators are inconsistent on the GUID they 128 * use, some use the HCA Node, some the HCA port. 129 * 130 * The specification defines the target to be 64-bits of 131 * service ID followed by 64-bits of I/O Controller GUID. 132 * In the case where there is a single default target 133 * service, they will be the same (our default). 134 */ 135 uint8_t ss_i_id[SRP_PORT_ID_LEN]; 136 uint8_t ss_t_id[SRP_PORT_ID_LEN]; 137 138 /* So we can see the full 128-bit initiator login from stmfadm */ 139 char ss_i_alias[SRPT_ALIAS_LEN]; 140 uint8_t ss_hw_port; 141 142 char ss_t_alias[SRPT_ALIAS_LEN]; 143 char ss_i_name[SRPT_EUI_ID_LEN + 1]; 144 char ss_t_name[SRPT_EUI_ID_LEN + 1]; 145 char ss_i_gid[SRPT_ALIAS_LEN]; 146 char ss_t_gid[SRPT_ALIAS_LEN]; 147 } srpt_session_t; 148 149 /* 150 * Send work request types. 151 */ 152 typedef enum srpt_swqe_type_e { 153 SRPT_SWQE_TYPE_DATA = 1, 154 SRPT_SWQE_TYPE_RESP 155 } srpt_swqe_type_t; 156 157 typedef struct srpt_swqe_s { 158 srpt_swqe_type_t sw_type; 159 void *sw_addr; 160 ibt_wrid_t sw_next; 161 } srpt_swqe_t; 162 163 /* 164 * SRP Channel - the RDMA communications channel associated with 165 * a specific SRP login. 166 */ 167 typedef enum srpt_channel_state_e { 168 SRPT_CHANNEL_CONNECTING = 0, 169 SRPT_CHANNEL_CONNECTED, 170 SRPT_CHANNEL_DISCONNECTING 171 } srpt_channel_state_t; 172 173 typedef struct srpt_channel_s { 174 krwlock_t ch_rwlock; 175 176 kmutex_t ch_reflock; 177 uint_t ch_refcnt; 178 kcondvar_t ch_cv_complete; 179 uint_t ch_cv_waiters; 180 181 list_node_t ch_stp_node; 182 srpt_channel_state_t ch_state; 183 ibt_cq_hdl_t ch_scq_hdl; 184 ibt_cq_hdl_t ch_rcq_hdl; 185 ibt_channel_hdl_t ch_chan_hdl; 186 ibt_chan_sizes_t ch_sizes; 187 188 uint32_t ch_req_lim_delta; 189 uint32_t ch_ti_iu_len; 190 struct srpt_target_port_s *ch_tgt; 191 srpt_session_t *ch_session; 192 193 /* 194 * Map IB send WQE request IDs to the 195 * apporpriate operation type (for errors). 196 */ 197 kmutex_t ch_swqe_lock; 198 srpt_swqe_t *ch_swqe; 199 uint32_t ch_num_swqe; 200 uint32_t ch_head; 201 uint32_t ch_tail; 202 uint32_t ch_swqe_posted; 203 } srpt_channel_t; 204 205 /* 206 * SRP Information Unit (IU). Each IU structure contains 207 * the buffer for the IU itself (received over the RC 208 * channel), and all of the context required by the target 209 * to process this request represented by the IU. 210 * Available IU structures are managed on the I/O Controller 211 * shared receive queue. 212 */ 213 enum { 214 SRPT_IU_STMF_ABORTING = 1 << 0, /* STMF called abort */ 215 SRPT_IU_SRP_ABORTING = 1 << 1, /* SRP initiator aborting */ 216 SRPT_IU_ABORTED = 1 << 2, /* Task has been aborted */ 217 SRPT_IU_RESP_SENT = 1 << 3 /* Response queued */ 218 }; 219 220 typedef struct srpt_iu_s { 221 /* 222 * The buffer for the IU itself. When unused (a 223 * reference count of zero), this buffer is posted 224 * on the I/O Controllers SRPT SRQ. 225 */ 226 void *iu_buf; 227 ibt_wr_ds_t iu_sge; 228 struct srpt_ioc_s *iu_ioc; 229 uint_t iu_pool_ndx; 230 kmutex_t iu_lock; 231 232 /* 233 * The following are reset for each IU request 234 * processed by this buffer. 235 */ 236 list_node_t iu_ss_task_node; 237 srpt_channel_t *iu_ch; 238 239 uint_t iu_num_rdescs; 240 srp_direct_desc_t *iu_rdescs; 241 uint_t iu_tot_xfer_len; 242 243 uint64_t iu_tag; 244 uint_t iu_flags; 245 uint32_t iu_sq_posted_cnt; 246 scsi_task_t *iu_stmf_task; 247 } srpt_iu_t; 248 249 /* 250 * SRP SCSI Target Port. By default each HCA creates a single 251 * SCSI Target Port based on the associated I/O Controller 252 * (HCA) node GUID and made available through each physical 253 * hardware port of the I/O Controller. 254 */ 255 typedef enum srpt_target_state_e { 256 SRPT_TGT_STATE_OFFLINE = 0, 257 SRPT_TGT_STATE_ONLINING, 258 SRPT_TGT_STATE_ONLINE, 259 SRPT_TGT_STATE_OFFLINING 260 } srpt_target_state_t; 261 262 typedef struct srpt_hw_port_s { 263 ibt_sbind_hdl_t hwp_bind_hdl; 264 ib_gid_t hwp_gid; 265 } srpt_hw_port_t; 266 267 typedef struct srpt_target_port_s { 268 stmf_local_port_t *tp_lport; 269 struct srpt_ioc_s *tp_ioc; 270 271 kmutex_t tp_lock; 272 srpt_target_state_t tp_state; 273 kcondvar_t tp_offline_complete; 274 uint_t tp_drv_disabled; 275 276 /* 277 * We are using a simple list for channels right now, we 278 * probably should switch this over to the AVL 279 * implementation eventually (but lookups are not done 280 * in the data path so this is not urgent). 281 */ 282 kmutex_t tp_ch_list_lock; 283 list_t tp_ch_list; 284 285 /* 286 * A list of active sessions. Session lifetime is 287 * determined by having active channels, but track 288 * them here for easier determination to when a 289 * target can truly be offlined, and as a step toward 290 * being session-focused rather than channel-focused. 291 * If we ever truly support multi-channel, move the 292 * channels to be part of the session object. 293 * 294 * Sessions should remain on this list until they 295 * are deregistered from STMF. This allows the target 296 * to properly track when it can consider itself 'offline'. 297 */ 298 kmutex_t tp_sess_list_lock; 299 kcondvar_t tp_sess_complete; 300 list_t tp_sess_list; 301 302 uint_t tp_srp_enabled; 303 ibt_srv_hdl_t tp_ibt_svc_hdl; 304 ibt_srv_desc_t tp_ibt_svc_desc; 305 ib_svc_id_t tp_ibt_svc_id; 306 scsi_devid_desc_t *tp_scsi_devid; 307 uint8_t tp_srp_port_id[SRP_PORT_ID_LEN]; 308 309 uint_t tp_nports; 310 srpt_hw_port_t *tp_hw_port; 311 /* 312 * track the number of active ports so we can offline the target if 313 * none 314 */ 315 uint32_t tp_num_active_ports; 316 /* state STMF wants the target in. We may be offline due to no ports */ 317 srpt_target_state_t tp_requested_state; 318 } srpt_target_port_t; 319 320 /* 321 * SRP Target hardware device. A SRP Target hardware device 322 * is an IB HCA. All ports of the HCA comprise a single 323 * I/O Controller that is registered with the IB Device 324 * Managment Agent. 325 */ 326 typedef struct srpt_ioc_s { 327 list_node_t ioc_node; 328 329 krwlock_t ioc_rwlock; 330 ibt_hca_hdl_t ioc_ibt_hdl; 331 ibt_hca_attr_t ioc_attr; 332 ib_guid_t ioc_guid; 333 334 /* 335 * By default each HCA is a single SRP.T10 service based on 336 * the HCA GUID. We have implemented the target here as a 337 * pointer to facilitate moving to a list of targets if 338 * appropriate down the road. 339 */ 340 srpt_target_port_t *ioc_tgt_port; 341 342 343 /* 344 * Each HCA registers a single I/O Controller with the 345 * IB Device Management Agent. 346 */ 347 ibdma_hdl_t ioc_ibdma_hdl; 348 ib_dm_ioc_ctrl_profile_t ioc_profile; 349 ib_dm_srv_t ioc_svc; 350 351 ibt_pd_hdl_t ioc_pd_hdl; 352 ibt_srq_sizes_t ioc_srq_attr; 353 ibt_srq_hdl_t ioc_srq_hdl; 354 355 /* 356 * The I/O Controller pool of IU resources allocated 357 * at controller creation. 358 */ 359 uint32_t ioc_num_iu_entries; 360 srpt_iu_t *ioc_iu_pool; 361 ibt_mr_hdl_t ioc_iu_mr_hdl; 362 void *ioc_iu_bufs; /* iu buffer space */ 363 364 /* 365 * Each I/O Controller has it's own data buffer 366 * vmem arena. Pool is created at controller creation, 367 * and expanded as required. This keeps IB memory 368 * registrations to a minimum in the data path. 369 */ 370 struct srpt_vmem_pool_s *ioc_dbuf_pool; 371 stmf_dbuf_store_t *ioc_stmf_ds; 372 } srpt_ioc_t; 373 374 /* 375 * Memory regions 376 */ 377 typedef struct srpt_mr_s { 378 ibt_mr_hdl_t mr_hdl; 379 ib_vaddr_t mr_va; 380 ib_memlen_t mr_len; 381 ibt_lkey_t mr_lkey; 382 ibt_rkey_t mr_rkey; 383 avl_node_t mr_avl; 384 } srpt_mr_t; 385 386 /* 387 * SRP Target vmem arena definition 388 */ 389 typedef struct srpt_vmem_pool_s { 390 srpt_ioc_t *svp_ioc; 391 ib_memlen_t svp_chunksize; 392 vmem_t *svp_vmem; 393 uint64_t svp_total_size; 394 uint64_t svp_max_size; 395 avl_tree_t svp_mr_list; 396 krwlock_t svp_lock; 397 ibt_mr_flags_t svp_flags; 398 } srpt_vmem_pool_t; 399 400 /* 401 * SRP port provider data buffer, allocated and freed 402 * via calls to the IOC datastore. 403 */ 404 typedef struct srpt_ds_dbuf_s { 405 stmf_data_buf_t *db_stmf_buf; 406 srpt_ioc_t *db_ioc; 407 ibt_mr_hdl_t db_mr_hdl; 408 ibt_wr_ds_t db_sge; 409 srpt_iu_t *db_iu; 410 } srpt_ds_dbuf_t; 411 412 /* 413 * SRP Target service state 414 */ 415 typedef enum { 416 SRPT_SVC_DISABLED, 417 SRPT_SVC_ENABLED 418 } srpt_svc_state_t; 419 420 typedef struct { 421 ddi_modhandle_t ibdmah; 422 ibdma_hdl_t (*ibdma_register)(ib_guid_t, 423 ib_dm_ioc_ctrl_profile_t *, ib_dm_srv_t *); 424 ibdma_status_t (*ibdma_unregister)(ibdma_hdl_t); 425 ibdma_status_t (*ibdma_update)(ibdma_hdl_t, 426 ib_dm_ioc_ctrl_profile_t *, ib_dm_srv_t *); 427 } srpt_ibdma_ops_t; 428 429 /* 430 * SRP Target protocol driver context data structure, maintaining 431 * the global state of the protocol. 432 */ 433 typedef struct srpt_ctxt_s { 434 dev_info_t *sc_dip; 435 krwlock_t sc_rwlock; 436 srpt_svc_state_t sc_svc_state; 437 438 ibt_clnt_hdl_t sc_ibt_hdl; 439 440 /* 441 * SRP Target I/O Controllers. Each IBT HCA represents an 442 * I/O Controller. Must hold rwlock as a writer to update. 443 */ 444 list_t sc_ioc_list; 445 uint_t sc_num_iocs; 446 447 /* Back-end COMSTAR port provider interface. */ 448 stmf_port_provider_t *sc_pp; 449 450 /* IBDMA entry points */ 451 srpt_ibdma_ops_t sc_ibdma_ops; 452 453 /* 454 * List of explicitly configured HCAs and their configurable 455 * attributes. 456 */ 457 nvlist_t *sc_cfg_hca_nv; 458 } srpt_ctxt_t; 459 460 typedef struct srpt_iu_data_s { 461 union { 462 uint8_t srp_op; 463 srp_cmd_req_t srp_cmd; 464 srp_tsk_mgmt_t srp_tsk_mgmt; 465 srp_i_logout_t srp_i_logout; 466 srp_rsp_t srp_rsp; 467 } rx_iu; 468 } srpt_iu_data_t; 469 470 extern srpt_ctxt_t *srpt_ctxt; 471 472 /* 473 * For Non recoverable or Major Errors 474 */ 475 #define SRPT_LOG_L0 0 476 477 /* 478 * For additional information on Non recoverable errors and 479 * warnings/informational message for sys-admin types. 480 */ 481 #define SRPT_LOG_L1 1 482 483 /* 484 * debug only 485 * for more verbose trace than L1, for e.g. recoverable errors, 486 * or intersting trace 487 */ 488 #define SRPT_LOG_L2 2 489 490 /* 491 * debug only 492 * for more verbose trace than L2, for e.g. printing function entries.... 493 */ 494 #define SRPT_LOG_L3 3 495 496 /* 497 * debug only 498 * for more verbose trace than L3, for e.g. printing minor function entries... 499 */ 500 #define SRPT_LOG_L4 4 501 502 /* 503 * srpt_errlevel can be set in the debugger to enable additional logging. 504 * You can also add set srpt:srpt_errlevel={0,1,2,3,4} in /etc/system. 505 * The default log level is L1. 506 */ 507 #define SRPT_LOG_DEFAULT_LEVEL SRPT_LOG_L1 508 509 extern uint_t srpt_errlevel; 510 511 512 #define SRPT_DPRINTF_L0(...) cmn_err(CE_WARN, __VA_ARGS__) 513 #define SRPT_DPRINTF_L1(...) cmn_err(CE_NOTE, __VA_ARGS__) 514 #define SRPT_DPRINTF_L2(...) if (srpt_errlevel >= SRPT_LOG_L2) { \ 515 cmn_err(CE_NOTE, __VA_ARGS__);\ 516 } 517 #ifdef DEBUG 518 #define SRPT_DPRINTF_L3(...) if (srpt_errlevel >= SRPT_LOG_L3) { \ 519 cmn_err(CE_NOTE, __VA_ARGS__);\ 520 } 521 #define SRPT_DPRINTF_L4(...) if (srpt_errlevel >= SRPT_LOG_L4) { \ 522 cmn_err(CE_NOTE, __VA_ARGS__);\ 523 } 524 #else 525 #define SRPT_DPRINTF_L3(...) (void)(0) 526 #define SRPT_DPRINTF_L4(...) (void)(0) 527 #endif 528 529 #ifdef __cplusplus 530 } 531 #endif 532 533 #endif /* _SRPT_IMPL_H_ */ 534