1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>. 5 * Copyright (c) Intel Corporation. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * * Neither the name of Intel Corporation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #ifndef SPDK_ISCSI_H 36 #define SPDK_ISCSI_H 37 38 #include "spdk/stdinc.h" 39 40 #include "spdk/bdev.h" 41 #include "spdk/iscsi_spec.h" 42 #include "spdk/thread.h" 43 #include "spdk/sock.h" 44 45 #include "spdk/scsi.h" 46 #include "iscsi/param.h" 47 48 #include "spdk/assert.h" 49 #include "spdk/dif.h" 50 #include "spdk/util.h" 51 52 #define SPDK_ISCSI_DEFAULT_NODEBASE "iqn.2016-06.io.spdk" 53 54 #define DEFAULT_MAXR2T 4 55 #define MAX_INITIATOR_PORT_NAME 256 56 #define MAX_INITIATOR_NAME 223 57 #define MAX_TARGET_NAME 223 58 59 #define MAX_PORTAL 1024 60 #define MAX_INITIATOR 256 61 #define MAX_NETMASK 256 62 #define MAX_ISCSI_CONNECTIONS 1024 63 #define MAX_PORTAL_ADDR 256 64 #define MAX_PORTAL_PORT 32 65 66 #define DEFAULT_PORT 3260 67 #define DEFAULT_MAX_SESSIONS 128 68 #define DEFAULT_MAX_CONNECTIONS_PER_SESSION 2 69 #define DEFAULT_MAXOUTSTANDINGR2T 1 70 #define DEFAULT_DEFAULTTIME2WAIT 2 71 #define DEFAULT_DEFAULTTIME2RETAIN 20 72 #define DEFAULT_INITIALR2T true 73 #define DEFAULT_IMMEDIATEDATA true 74 #define DEFAULT_DATAPDUINORDER true 75 #define DEFAULT_DATASEQUENCEINORDER true 76 #define DEFAULT_ERRORRECOVERYLEVEL 0 77 #define DEFAULT_TIMEOUT 60 78 #define MAX_NOPININTERVAL 60 79 #define DEFAULT_NOPININTERVAL 30 80 81 /* 82 * SPDK iSCSI target currently only supports 64KB as the maximum data segment length 83 * it can receive from initiators. Other values may work, but no guarantees. 84 */ 85 #define SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH 65536 86 87 /* 88 * Defines maximum number of data out buffers each connection can have in 89 * use at any given time. 90 */ 91 #define MAX_DATA_OUT_PER_CONNECTION 16 92 93 /* 94 * Defines default maximum number of data in buffers each connection can have in 95 * use at any given time. So this limit does not affect I/O smaller than 96 * SPDK_BDEV_SMALL_BUF_MAX_SIZE. 97 */ 98 #define DEFAULT_MAX_LARGE_DATAIN_PER_CONNECTION 64 99 100 #define SPDK_ISCSI_MAX_BURST_LENGTH \ 101 (SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH * MAX_DATA_OUT_PER_CONNECTION) 102 103 /* 104 * Defines default maximum amount in bytes of unsolicited data the iSCSI 105 * initiator may send to the SPDK iSCSI target during the execution of 106 * a single SCSI command. And it is smaller than the MaxBurstLength. 107 */ 108 #define SPDK_ISCSI_FIRST_BURST_LENGTH 8192 109 110 /* 111 * Defines minimum amount in bytes of unsolicited data the iSCSI initiator 112 * may send to the SPDK iSCSI target during the execution of a single 113 * SCSI command. 114 */ 115 #define SPDK_ISCSI_MIN_FIRST_BURST_LENGTH 512 116 117 #define SPDK_ISCSI_MAX_FIRST_BURST_LENGTH 16777215 118 119 /* 120 * Defines default maximum queue depth per connection and this can be 121 * changed by configuration file. 122 */ 123 #define DEFAULT_MAX_QUEUE_DEPTH 64 124 125 /** Defines how long we should wait for a logout request when the target 126 * requests logout to the initiator asynchronously. 127 */ 128 #define ISCSI_LOGOUT_REQUEST_TIMEOUT 30 /* in seconds */ 129 130 /** Defines how long we should wait for a TCP close after responding to a 131 * logout request, before terminating the connection ourselves. 132 */ 133 #define ISCSI_LOGOUT_TIMEOUT 5 /* in seconds */ 134 135 /** Defines how long we should wait until login process completes. */ 136 #define ISCSI_LOGIN_TIMEOUT 30 /* in seconds */ 137 138 /* For spdk_iscsi_login_in related function use, we need to avoid the conflict 139 * with other errors 140 * */ 141 #define SPDK_ISCSI_LOGIN_ERROR_RESPONSE -1000 142 #define SPDK_ISCSI_LOGIN_ERROR_PARAMETER -1001 143 #define SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE -1002 144 145 #define ISCSI_AHS_LEN 60 146 147 struct spdk_mobj { 148 struct spdk_mempool *mp; 149 void *buf; 150 }; 151 152 /* 153 * Maximum number of SGL elements, i.e., 154 * BHS, AHS, Header Digest, Data Segment and Data Digest. 155 */ 156 #define SPDK_ISCSI_MAX_SGL_DESCRIPTORS (5) 157 158 typedef void (*iscsi_conn_xfer_complete_cb)(void *cb_arg); 159 160 struct spdk_iscsi_pdu { 161 struct iscsi_bhs bhs; 162 struct spdk_mobj *mobj; 163 bool is_rejected; 164 uint8_t *data_buf; 165 uint8_t *data; 166 uint8_t header_digest[ISCSI_DIGEST_LEN]; 167 uint8_t data_digest[ISCSI_DIGEST_LEN]; 168 size_t data_segment_len; 169 int bhs_valid_bytes; 170 int ahs_valid_bytes; 171 uint32_t data_valid_bytes; 172 int hdigest_valid_bytes; 173 int ddigest_valid_bytes; 174 int ref; 175 bool data_from_mempool; /* indicate whether the data buffer is allocated from mempool */ 176 struct spdk_iscsi_task *task; /* data tied to a task buffer */ 177 uint32_t cmd_sn; 178 uint32_t writev_offset; 179 uint32_t data_buf_len; 180 bool dif_insert_or_strip; 181 struct spdk_dif_ctx dif_ctx; 182 struct spdk_iscsi_conn *conn; 183 184 iscsi_conn_xfer_complete_cb cb_fn; 185 void *cb_arg; 186 187 /* The sock request ends with a 0 length iovec. Place the actual iovec immediately 188 * after it. There is a static assert below to check if the compiler inserted 189 * any unwanted padding */ 190 int32_t mapped_length; 191 struct spdk_sock_request sock_req; 192 struct iovec iov[SPDK_ISCSI_MAX_SGL_DESCRIPTORS]; 193 TAILQ_ENTRY(spdk_iscsi_pdu) tailq; 194 195 196 /* 197 * 60 bytes of AHS should suffice for now. 198 * This should always be at the end of PDU data structure. 199 * we need to not zero this out when doing memory clear. 200 */ 201 uint8_t ahs[ISCSI_AHS_LEN]; 202 203 struct { 204 uint16_t length; /* iSCSI SenseLength (big-endian) */ 205 uint8_t data[32]; 206 } sense; 207 }; 208 SPDK_STATIC_ASSERT(offsetof(struct spdk_iscsi_pdu, 209 sock_req) + sizeof(struct spdk_sock_request) == offsetof(struct spdk_iscsi_pdu, iov), 210 "Compiler inserted padding between iov and sock_req"); 211 212 enum iscsi_connection_state { 213 ISCSI_CONN_STATE_INVALID = 0, 214 ISCSI_CONN_STATE_RUNNING = 1, 215 ISCSI_CONN_STATE_EXITING = 2, 216 ISCSI_CONN_STATE_EXITED = 3, 217 }; 218 219 enum iscsi_chap_phase { 220 ISCSI_CHAP_PHASE_NONE = 0, 221 ISCSI_CHAP_PHASE_WAIT_A = 1, 222 ISCSI_CHAP_PHASE_WAIT_NR = 2, 223 ISCSI_CHAP_PHASE_END = 3, 224 }; 225 226 enum session_type { 227 SESSION_TYPE_INVALID = 0, 228 SESSION_TYPE_NORMAL = 1, 229 SESSION_TYPE_DISCOVERY = 2, 230 }; 231 232 #define ISCSI_CHAP_CHALLENGE_LEN 1024 233 #define ISCSI_CHAP_MAX_USER_LEN 255 234 #define ISCSI_CHAP_MAX_SECRET_LEN 255 235 236 struct iscsi_chap_auth { 237 enum iscsi_chap_phase chap_phase; 238 239 char user[ISCSI_CHAP_MAX_USER_LEN + 1]; 240 char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 241 char muser[ISCSI_CHAP_MAX_USER_LEN + 1]; 242 char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 243 244 uint8_t chap_id[1]; 245 uint8_t chap_mid[1]; 246 int chap_challenge_len; 247 uint8_t chap_challenge[ISCSI_CHAP_CHALLENGE_LEN]; 248 int chap_mchallenge_len; 249 uint8_t chap_mchallenge[ISCSI_CHAP_CHALLENGE_LEN]; 250 }; 251 252 struct spdk_iscsi_auth_secret { 253 char user[ISCSI_CHAP_MAX_USER_LEN + 1]; 254 char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 255 char muser[ISCSI_CHAP_MAX_USER_LEN + 1]; 256 char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 257 TAILQ_ENTRY(spdk_iscsi_auth_secret) tailq; 258 }; 259 260 struct spdk_iscsi_auth_group { 261 int32_t tag; 262 TAILQ_HEAD(, spdk_iscsi_auth_secret) secret_head; 263 TAILQ_ENTRY(spdk_iscsi_auth_group) tailq; 264 }; 265 266 struct spdk_iscsi_sess { 267 uint32_t connections; 268 struct spdk_iscsi_conn **conns; 269 270 struct spdk_scsi_port *initiator_port; 271 int tag; 272 273 uint64_t isid; 274 uint16_t tsih; 275 struct spdk_iscsi_tgt_node *target; 276 int queue_depth; 277 278 struct iscsi_param *params; 279 280 enum session_type session_type; 281 uint32_t MaxConnections; 282 uint32_t MaxOutstandingR2T; 283 uint32_t DefaultTime2Wait; 284 uint32_t DefaultTime2Retain; 285 uint32_t FirstBurstLength; 286 uint32_t MaxBurstLength; 287 bool InitialR2T; 288 bool ImmediateData; 289 bool DataPDUInOrder; 290 bool DataSequenceInOrder; 291 uint32_t ErrorRecoveryLevel; 292 293 uint32_t ExpCmdSN; 294 uint32_t MaxCmdSN; 295 296 uint32_t current_text_itt; 297 }; 298 299 struct spdk_iscsi_poll_group { 300 struct spdk_poller *poller; 301 struct spdk_poller *nop_poller; 302 STAILQ_HEAD(connections, spdk_iscsi_conn) connections; 303 struct spdk_sock_group *sock_group; 304 TAILQ_ENTRY(spdk_iscsi_poll_group) link; 305 }; 306 307 struct spdk_iscsi_opts { 308 char *authfile; 309 char *nodebase; 310 int32_t timeout; 311 int32_t nopininterval; 312 bool disable_chap; 313 bool require_chap; 314 bool mutual_chap; 315 int32_t chap_group; 316 uint32_t MaxSessions; 317 uint32_t MaxConnectionsPerSession; 318 uint32_t MaxConnections; 319 uint32_t MaxQueueDepth; 320 uint32_t DefaultTime2Wait; 321 uint32_t DefaultTime2Retain; 322 uint32_t FirstBurstLength; 323 bool ImmediateData; 324 uint32_t ErrorRecoveryLevel; 325 bool AllowDuplicateIsid; 326 uint32_t MaxLargeDataInPerConnection; 327 uint32_t MaxR2TPerConnection; 328 }; 329 330 struct spdk_iscsi_globals { 331 char *authfile; 332 char *nodebase; 333 pthread_mutex_t mutex; 334 uint32_t refcnt; 335 TAILQ_HEAD(, spdk_iscsi_portal) portal_head; 336 TAILQ_HEAD(, spdk_iscsi_portal_grp) pg_head; 337 TAILQ_HEAD(, spdk_iscsi_init_grp) ig_head; 338 TAILQ_HEAD(, spdk_iscsi_tgt_node) target_head; 339 TAILQ_HEAD(, spdk_iscsi_auth_group) auth_group_head; 340 TAILQ_HEAD(, spdk_iscsi_poll_group) poll_group_head; 341 342 int32_t timeout; 343 int32_t nopininterval; 344 bool disable_chap; 345 bool require_chap; 346 bool mutual_chap; 347 int32_t chap_group; 348 349 uint32_t MaxSessions; 350 uint32_t MaxConnectionsPerSession; 351 uint32_t MaxConnections; 352 uint32_t MaxQueueDepth; 353 uint32_t DefaultTime2Wait; 354 uint32_t DefaultTime2Retain; 355 uint32_t FirstBurstLength; 356 bool ImmediateData; 357 uint32_t ErrorRecoveryLevel; 358 bool AllowDuplicateIsid; 359 uint32_t MaxLargeDataInPerConnection; 360 uint32_t MaxR2TPerConnection; 361 362 struct spdk_mempool *pdu_pool; 363 struct spdk_mempool *pdu_immediate_data_pool; 364 struct spdk_mempool *pdu_data_out_pool; 365 struct spdk_mempool *session_pool; 366 struct spdk_mempool *task_pool; 367 368 struct spdk_iscsi_sess **session; 369 }; 370 371 #define ISCSI_SECURITY_NEGOTIATION_PHASE 0 372 #define ISCSI_OPERATIONAL_NEGOTIATION_PHASE 1 373 #define ISCSI_NSG_RESERVED_CODE 2 374 #define ISCSI_FULL_FEATURE_PHASE 3 375 376 /* logout reason */ 377 #define ISCSI_LOGOUT_REASON_CLOSE_SESSION 0 378 #define ISCSI_LOGOUT_REASON_CLOSE_CONNECTION 1 379 #define ISCSI_LOGOUT_REASON_REMOVE_CONN_FOR_RECOVERY 2 380 381 enum spdk_error_codes { 382 SPDK_ISCSI_CONNECTION_FATAL = -1, 383 SPDK_PDU_FATAL = -2, 384 }; 385 386 #define DGET24(B) \ 387 ((( (uint32_t) *((uint8_t *)(B)+0)) << 16) \ 388 | (((uint32_t) *((uint8_t *)(B)+1)) << 8) \ 389 | (((uint32_t) *((uint8_t *)(B)+2)) << 0)) 390 391 #define DSET24(B,D) \ 392 (((*((uint8_t *)(B)+0)) = (uint8_t)((uint32_t)(D) >> 16)), \ 393 ((*((uint8_t *)(B)+1)) = (uint8_t)((uint32_t)(D) >> 8)), \ 394 ((*((uint8_t *)(B)+2)) = (uint8_t)((uint32_t)(D) >> 0))) 395 396 #define xstrdup(s) (s ? strdup(s) : (char *)NULL) 397 398 extern struct spdk_iscsi_globals g_iscsi; 399 extern struct spdk_iscsi_opts *g_spdk_iscsi_opts; 400 401 struct spdk_iscsi_task; 402 struct spdk_json_write_ctx; 403 404 typedef void (*spdk_iscsi_init_cb)(void *cb_arg, int rc); 405 406 void spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg); 407 typedef void (*spdk_iscsi_fini_cb)(void *arg); 408 void spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg); 409 void shutdown_iscsi_conns_done(void); 410 void spdk_iscsi_config_json(struct spdk_json_write_ctx *w); 411 412 struct spdk_iscsi_opts *iscsi_opts_alloc(void); 413 void iscsi_opts_free(struct spdk_iscsi_opts *opts); 414 struct spdk_iscsi_opts *iscsi_opts_copy(struct spdk_iscsi_opts *src); 415 void iscsi_opts_info_json(struct spdk_json_write_ctx *w); 416 int iscsi_set_discovery_auth(bool disable_chap, bool require_chap, 417 bool mutual_chap, int32_t chap_group); 418 int iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser, 419 int ag_tag); 420 int iscsi_add_auth_group(int32_t tag, struct spdk_iscsi_auth_group **_group); 421 struct spdk_iscsi_auth_group *iscsi_find_auth_group_by_tag(int32_t tag); 422 void iscsi_delete_auth_group(struct spdk_iscsi_auth_group *group); 423 int iscsi_auth_group_add_secret(struct spdk_iscsi_auth_group *group, 424 const char *user, const char *secret, 425 const char *muser, const char *msecret); 426 int iscsi_auth_group_delete_secret(struct spdk_iscsi_auth_group *group, 427 const char *user); 428 void iscsi_auth_groups_info_json(struct spdk_json_write_ctx *w); 429 430 void iscsi_task_response(struct spdk_iscsi_conn *conn, 431 struct spdk_iscsi_task *task); 432 int iscsi_build_iovs(struct spdk_iscsi_conn *conn, struct iovec *iovs, int iovcnt, 433 struct spdk_iscsi_pdu *pdu, uint32_t *mapped_length); 434 int iscsi_handle_incoming_pdus(struct spdk_iscsi_conn *conn); 435 void iscsi_task_mgmt_response(struct spdk_iscsi_conn *conn, 436 struct spdk_iscsi_task *task); 437 438 void iscsi_free_sess(struct spdk_iscsi_sess *sess); 439 void iscsi_clear_all_transfer_task(struct spdk_iscsi_conn *conn, 440 struct spdk_scsi_lun *lun, 441 struct spdk_iscsi_pdu *pdu); 442 bool iscsi_del_transfer_task(struct spdk_iscsi_conn *conn, uint32_t CmdSN); 443 444 uint32_t iscsi_pdu_calc_header_digest(struct spdk_iscsi_pdu *pdu); 445 uint32_t iscsi_pdu_calc_data_digest(struct spdk_iscsi_pdu *pdu); 446 447 /* Memory management */ 448 void iscsi_put_pdu(struct spdk_iscsi_pdu *pdu); 449 struct spdk_iscsi_pdu *iscsi_get_pdu(struct spdk_iscsi_conn *conn); 450 void iscsi_op_abort_task_set(struct spdk_iscsi_task *task, 451 uint8_t function); 452 void iscsi_queue_task(struct spdk_iscsi_conn *conn, struct spdk_iscsi_task *task); 453 454 static inline uint32_t 455 iscsi_get_max_immediate_data_size(void) 456 { 457 /* 458 * Specify enough extra space in addition to FirstBurstLength to 459 * account for a header digest, data digest and additional header 460 * segments (AHS). These are not normally used but they do not 461 * take up much space and we need to make sure the worst-case scenario 462 * can be satisified by the size returned here. 463 */ 464 return g_iscsi.FirstBurstLength + 465 ISCSI_DIGEST_LEN + /* data digest */ 466 ISCSI_DIGEST_LEN + /* header digest */ 467 8 + /* bidirectional AHS */ 468 52; /* extended CDB AHS (for a 64-byte CDB) */ 469 } 470 471 #endif /* SPDK_ISCSI_H */ 472