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/event.h" 43 #include "spdk/thread.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 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 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 TCP close after responding to a 126 * logout request, before terminating the connection ourselves. 127 */ 128 #define ISCSI_LOGOUT_TIMEOUT 5 /* in seconds */ 129 130 /* according to RFC1982 */ 131 #define SN32_CMPMAX (((uint32_t)1U) << (32 - 1)) 132 #define SN32_LT(S1,S2) \ 133 (((uint32_t)(S1) != (uint32_t)(S2)) \ 134 && (((uint32_t)(S1) < (uint32_t)(S2) \ 135 && ((uint32_t)(S2) - (uint32_t)(S1) < SN32_CMPMAX)) \ 136 || ((uint32_t)(S1) > (uint32_t)(S2) \ 137 && ((uint32_t)(S1) - (uint32_t)(S2) > SN32_CMPMAX)))) 138 #define SN32_GT(S1,S2) \ 139 (((uint32_t)(S1) != (uint32_t)(S2)) \ 140 && (((uint32_t)(S1) < (uint32_t)(S2) \ 141 && ((uint32_t)(S2) - (uint32_t)(S1) > SN32_CMPMAX)) \ 142 || ((uint32_t)(S1) > (uint32_t)(S2) \ 143 && ((uint32_t)(S1) - (uint32_t)(S2) < SN32_CMPMAX)))) 144 145 /* For spdk_iscsi_login_in related function use, we need to avoid the conflict 146 * with other errors 147 * */ 148 #define SPDK_ISCSI_LOGIN_ERROR_RESPONSE -1000 149 #define SPDK_ISCSI_LOGIN_ERROR_PARAMETER -1001 150 #define SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE -1002 151 152 #define ISCSI_AHS_LEN 60 153 154 struct spdk_mobj { 155 struct spdk_mempool *mp; 156 void *buf; 157 }; 158 159 struct spdk_iscsi_pdu { 160 struct iscsi_bhs bhs; 161 struct spdk_mobj *mobj; 162 uint8_t *data_buf; 163 uint8_t *data; 164 uint8_t header_digest[ISCSI_DIGEST_LEN]; 165 uint8_t data_digest[ISCSI_DIGEST_LEN]; 166 size_t data_segment_len; 167 int bhs_valid_bytes; 168 int ahs_valid_bytes; 169 int data_valid_bytes; 170 int hdigest_valid_bytes; 171 int ddigest_valid_bytes; 172 int ref; 173 bool data_from_mempool; /* indicate whether the data buffer is allocated from mempool */ 174 struct spdk_iscsi_task *task; /* data tied to a task buffer */ 175 uint32_t cmd_sn; 176 uint32_t writev_offset; 177 uint32_t data_buf_len; 178 bool dif_insert_or_strip; 179 struct spdk_dif_ctx dif_ctx; 180 TAILQ_ENTRY(spdk_iscsi_pdu) tailq; 181 182 183 /* 184 * 60 bytes of AHS should suffice for now. 185 * This should always be at the end of PDU data structure. 186 * we need to not zero this out when doing memory clear. 187 */ 188 uint8_t ahs[ISCSI_AHS_LEN]; 189 190 struct { 191 uint16_t length; /* iSCSI SenseLength (big-endian) */ 192 uint8_t data[32]; 193 } sense; 194 }; 195 196 enum iscsi_connection_state { 197 ISCSI_CONN_STATE_INVALID = 0, 198 ISCSI_CONN_STATE_RUNNING = 1, 199 ISCSI_CONN_STATE_LOGGED_OUT = 2, 200 ISCSI_CONN_STATE_EXITING = 3, 201 ISCSI_CONN_STATE_EXITED = 4, 202 }; 203 204 enum iscsi_chap_phase { 205 ISCSI_CHAP_PHASE_NONE = 0, 206 ISCSI_CHAP_PHASE_WAIT_A = 1, 207 ISCSI_CHAP_PHASE_WAIT_NR = 2, 208 ISCSI_CHAP_PHASE_END = 3, 209 }; 210 211 enum session_type { 212 SESSION_TYPE_INVALID = 0, 213 SESSION_TYPE_NORMAL = 1, 214 SESSION_TYPE_DISCOVERY = 2, 215 }; 216 217 #define ISCSI_CHAP_CHALLENGE_LEN 1024 218 #define ISCSI_CHAP_MAX_USER_LEN 255 219 #define ISCSI_CHAP_MAX_SECRET_LEN 255 220 221 struct iscsi_chap_auth { 222 enum iscsi_chap_phase chap_phase; 223 224 char user[ISCSI_CHAP_MAX_USER_LEN + 1]; 225 char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 226 char muser[ISCSI_CHAP_MAX_USER_LEN + 1]; 227 char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 228 229 uint8_t chap_id[1]; 230 uint8_t chap_mid[1]; 231 int chap_challenge_len; 232 uint8_t chap_challenge[ISCSI_CHAP_CHALLENGE_LEN]; 233 int chap_mchallenge_len; 234 uint8_t chap_mchallenge[ISCSI_CHAP_CHALLENGE_LEN]; 235 }; 236 237 struct spdk_iscsi_auth_secret { 238 char user[ISCSI_CHAP_MAX_USER_LEN + 1]; 239 char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 240 char muser[ISCSI_CHAP_MAX_USER_LEN + 1]; 241 char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1]; 242 TAILQ_ENTRY(spdk_iscsi_auth_secret) tailq; 243 }; 244 245 struct spdk_iscsi_auth_group { 246 int32_t tag; 247 TAILQ_HEAD(, spdk_iscsi_auth_secret) secret_head; 248 TAILQ_ENTRY(spdk_iscsi_auth_group) tailq; 249 }; 250 251 struct spdk_iscsi_sess { 252 uint32_t connections; 253 struct spdk_iscsi_conn **conns; 254 255 struct spdk_scsi_port *initiator_port; 256 int tag; 257 258 uint64_t isid; 259 uint16_t tsih; 260 struct spdk_iscsi_tgt_node *target; 261 int queue_depth; 262 263 struct iscsi_param *params; 264 265 enum session_type session_type; 266 uint32_t MaxConnections; 267 uint32_t MaxOutstandingR2T; 268 uint32_t DefaultTime2Wait; 269 uint32_t DefaultTime2Retain; 270 uint32_t FirstBurstLength; 271 uint32_t MaxBurstLength; 272 bool InitialR2T; 273 bool ImmediateData; 274 bool DataPDUInOrder; 275 bool DataSequenceInOrder; 276 uint32_t ErrorRecoveryLevel; 277 278 uint32_t ExpCmdSN; 279 uint32_t MaxCmdSN; 280 281 uint32_t current_text_itt; 282 }; 283 284 struct spdk_iscsi_poll_group { 285 struct spdk_poller *poller; 286 struct spdk_poller *nop_poller; 287 STAILQ_HEAD(connections, spdk_iscsi_conn) connections; 288 struct spdk_sock_group *sock_group; 289 TAILQ_ENTRY(spdk_iscsi_poll_group) link; 290 }; 291 292 struct spdk_iscsi_opts { 293 char *authfile; 294 char *nodebase; 295 int32_t timeout; 296 int32_t nopininterval; 297 bool disable_chap; 298 bool require_chap; 299 bool mutual_chap; 300 int32_t chap_group; 301 uint32_t MaxSessions; 302 uint32_t MaxConnectionsPerSession; 303 uint32_t MaxConnections; 304 uint32_t MaxQueueDepth; 305 uint32_t DefaultTime2Wait; 306 uint32_t DefaultTime2Retain; 307 uint32_t FirstBurstLength; 308 bool ImmediateData; 309 uint32_t ErrorRecoveryLevel; 310 bool AllowDuplicateIsid; 311 }; 312 313 struct spdk_iscsi_globals { 314 char *authfile; 315 char *nodebase; 316 pthread_mutex_t mutex; 317 TAILQ_HEAD(, spdk_iscsi_portal) portal_head; 318 TAILQ_HEAD(, spdk_iscsi_portal_grp) pg_head; 319 TAILQ_HEAD(, spdk_iscsi_init_grp) ig_head; 320 TAILQ_HEAD(, spdk_iscsi_tgt_node) target_head; 321 TAILQ_HEAD(, spdk_iscsi_auth_group) auth_group_head; 322 TAILQ_HEAD(, spdk_iscsi_poll_group) poll_group_head; 323 324 int32_t timeout; 325 int32_t nopininterval; 326 bool disable_chap; 327 bool require_chap; 328 bool mutual_chap; 329 int32_t chap_group; 330 331 uint32_t MaxSessions; 332 uint32_t MaxConnectionsPerSession; 333 uint32_t MaxConnections; 334 uint32_t MaxQueueDepth; 335 uint32_t DefaultTime2Wait; 336 uint32_t DefaultTime2Retain; 337 uint32_t FirstBurstLength; 338 bool ImmediateData; 339 uint32_t ErrorRecoveryLevel; 340 bool AllowDuplicateIsid; 341 342 struct spdk_mempool *pdu_pool; 343 struct spdk_mempool *pdu_immediate_data_pool; 344 struct spdk_mempool *pdu_data_out_pool; 345 struct spdk_mempool *session_pool; 346 struct spdk_mempool *task_pool; 347 348 struct spdk_iscsi_sess **session; 349 }; 350 351 #define ISCSI_SECURITY_NEGOTIATION_PHASE 0 352 #define ISCSI_OPERATIONAL_NEGOTIATION_PHASE 1 353 #define ISCSI_NSG_RESERVED_CODE 2 354 #define ISCSI_FULL_FEATURE_PHASE 3 355 356 enum spdk_error_codes { 357 SPDK_ISCSI_CONNECTION_FATAL = -1, 358 SPDK_PDU_FATAL = -2, 359 }; 360 361 #define DGET24(B) \ 362 ((( (uint32_t) *((uint8_t *)(B)+0)) << 16) \ 363 | (((uint32_t) *((uint8_t *)(B)+1)) << 8) \ 364 | (((uint32_t) *((uint8_t *)(B)+2)) << 0)) 365 366 #define DSET24(B,D) \ 367 (((*((uint8_t *)(B)+0)) = (uint8_t)((uint32_t)(D) >> 16)), \ 368 ((*((uint8_t *)(B)+1)) = (uint8_t)((uint32_t)(D) >> 8)), \ 369 ((*((uint8_t *)(B)+2)) = (uint8_t)((uint32_t)(D) >> 0))) 370 371 #define xstrdup(s) (s ? strdup(s) : (char *)NULL) 372 373 extern struct spdk_iscsi_globals g_spdk_iscsi; 374 extern struct spdk_iscsi_opts *g_spdk_iscsi_opts; 375 376 struct spdk_iscsi_task; 377 struct spdk_json_write_ctx; 378 379 typedef void (*spdk_iscsi_init_cb)(void *cb_arg, int rc); 380 381 void spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg); 382 typedef void (*spdk_iscsi_fini_cb)(void *arg); 383 void spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg); 384 void spdk_shutdown_iscsi_conns_done(void); 385 void spdk_iscsi_config_text(FILE *fp); 386 void spdk_iscsi_config_json(struct spdk_json_write_ctx *w); 387 388 struct spdk_iscsi_opts *spdk_iscsi_opts_alloc(void); 389 void spdk_iscsi_opts_free(struct spdk_iscsi_opts *opts); 390 struct spdk_iscsi_opts *spdk_iscsi_opts_copy(struct spdk_iscsi_opts *src); 391 void spdk_iscsi_opts_info_json(struct spdk_json_write_ctx *w); 392 int spdk_iscsi_set_discovery_auth(bool disable_chap, bool require_chap, 393 bool mutual_chap, int32_t chap_group); 394 int spdk_iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser, 395 int ag_tag); 396 int spdk_iscsi_add_auth_group(int32_t tag, struct spdk_iscsi_auth_group **_group); 397 struct spdk_iscsi_auth_group *spdk_iscsi_find_auth_group_by_tag(int32_t tag); 398 void spdk_iscsi_delete_auth_group(struct spdk_iscsi_auth_group *group); 399 int spdk_iscsi_auth_group_add_secret(struct spdk_iscsi_auth_group *group, 400 const char *user, const char *secret, 401 const char *muser, const char *msecret); 402 int spdk_iscsi_auth_group_delete_secret(struct spdk_iscsi_auth_group *group, 403 const char *user); 404 void spdk_iscsi_auth_groups_info_json(struct spdk_json_write_ctx *w); 405 406 void spdk_iscsi_send_nopin(struct spdk_iscsi_conn *conn); 407 void spdk_iscsi_task_response(struct spdk_iscsi_conn *conn, 408 struct spdk_iscsi_task *task); 409 int spdk_iscsi_execute(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu); 410 int spdk_iscsi_build_iovs(struct spdk_iscsi_conn *conn, struct iovec *iovs, int iovcnt, 411 struct spdk_iscsi_pdu *pdu, uint32_t *mapped_length); 412 int spdk_iscsi_read_pdu(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu **_pdu); 413 bool spdk_iscsi_get_dif_ctx(struct spdk_iscsi_conn *conn, struct spdk_iscsi_pdu *pdu, 414 struct spdk_dif_ctx *dif_ctx); 415 void spdk_iscsi_task_mgmt_response(struct spdk_iscsi_conn *conn, 416 struct spdk_iscsi_task *task); 417 418 int spdk_iscsi_conn_params_init(struct iscsi_param **params); 419 int spdk_iscsi_sess_params_init(struct iscsi_param **params); 420 421 void spdk_free_sess(struct spdk_iscsi_sess *sess); 422 void spdk_clear_all_transfer_task(struct spdk_iscsi_conn *conn, 423 struct spdk_scsi_lun *lun, 424 struct spdk_iscsi_pdu *pdu); 425 void spdk_del_transfer_task(struct spdk_iscsi_conn *conn, uint32_t CmdSN); 426 bool spdk_iscsi_is_deferred_free_pdu(struct spdk_iscsi_pdu *pdu); 427 428 int spdk_iscsi_negotiate_params(struct spdk_iscsi_conn *conn, 429 struct iscsi_param **params_p, uint8_t *data, 430 int alloc_len, int data_len); 431 int spdk_iscsi_copy_param2var(struct spdk_iscsi_conn *conn); 432 433 void spdk_iscsi_task_cpl(struct spdk_scsi_task *scsi_task); 434 void spdk_iscsi_task_mgmt_cpl(struct spdk_scsi_task *scsi_task); 435 uint32_t spdk_iscsi_pdu_calc_header_digest(struct spdk_iscsi_pdu *pdu); 436 uint32_t spdk_iscsi_pdu_calc_data_digest(struct spdk_iscsi_pdu *pdu); 437 438 /* Memory management */ 439 void spdk_put_pdu(struct spdk_iscsi_pdu *pdu); 440 struct spdk_iscsi_pdu *spdk_get_pdu(void); 441 int spdk_iscsi_conn_handle_queued_datain_tasks(struct spdk_iscsi_conn *conn); 442 void spdk_iscsi_op_abort_task_set(struct spdk_iscsi_task *task, 443 uint8_t function); 444 445 static inline int 446 spdk_get_max_immediate_data_size(void) 447 { 448 /* 449 * Specify enough extra space in addition to FirstBurstLength to 450 * account for a header digest, data digest and additional header 451 * segments (AHS). These are not normally used but they do not 452 * take up much space and we need to make sure the worst-case scenario 453 * can be satisified by the size returned here. 454 */ 455 return g_spdk_iscsi.FirstBurstLength + 456 ISCSI_DIGEST_LEN + /* data digest */ 457 ISCSI_DIGEST_LEN + /* header digest */ 458 8 + /* bidirectional AHS */ 459 52; /* extended CDB AHS (for a 64-byte CDB) */ 460 } 461 462 #endif /* SPDK_ISCSI_H */ 463