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