1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * iSCSI lib definitions 4 * 5 * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 6 * Copyright (C) 2004 - 2006 Mike Christie 7 * Copyright (C) 2004 - 2005 Dmitry Yusupov 8 * Copyright (C) 2004 - 2005 Alex Aizman 9 */ 10 #ifndef LIBISCSI_H 11 #define LIBISCSI_H 12 13 #include <linux/types.h> 14 #include <linux/wait.h> 15 #include <linux/mutex.h> 16 #include <linux/timer.h> 17 #include <linux/workqueue.h> 18 #include <linux/kfifo.h> 19 #include <linux/refcount.h> 20 #include <scsi/iscsi_proto.h> 21 #include <scsi/iscsi_if.h> 22 #include <scsi/scsi_transport_iscsi.h> 23 24 struct scsi_transport_template; 25 struct scsi_host_template; 26 struct scsi_device; 27 struct Scsi_Host; 28 struct scsi_target; 29 struct scsi_cmnd; 30 struct socket; 31 struct iscsi_transport; 32 struct iscsi_cls_session; 33 struct iscsi_cls_conn; 34 struct iscsi_session; 35 struct iscsi_nopin; 36 struct device; 37 38 #define ISCSI_DEF_XMIT_CMDS_MAX 128 /* must be power of 2 */ 39 #define ISCSI_MGMT_CMDS_MAX 15 40 41 #define ISCSI_DEF_CMD_PER_LUN 32 42 43 /* Task Mgmt states */ 44 enum { 45 TMF_INITIAL, 46 TMF_QUEUED, 47 TMF_SUCCESS, 48 TMF_FAILED, 49 TMF_TIMEDOUT, 50 TMF_NOT_FOUND, 51 }; 52 53 #define ISID_SIZE 6 54 55 /* Connection suspend "bit" */ 56 #define ISCSI_SUSPEND_BIT 1 57 58 #define ISCSI_ITT_MASK 0x1fff 59 #define ISCSI_TOTAL_CMDS_MAX 4096 60 /* this must be a power of two greater than ISCSI_MGMT_CMDS_MAX */ 61 #define ISCSI_TOTAL_CMDS_MIN 16 62 #define ISCSI_AGE_SHIFT 28 63 #define ISCSI_AGE_MASK 0xf 64 65 #define ISCSI_ADDRESS_BUF_LEN 64 66 67 enum { 68 /* this is the maximum possible storage for AHSs */ 69 ISCSI_MAX_AHS_SIZE = sizeof(struct iscsi_ecdb_ahdr) + 70 sizeof(struct iscsi_rlength_ahdr), 71 ISCSI_DIGEST_SIZE = sizeof(__u32), 72 }; 73 74 75 enum { 76 ISCSI_TASK_FREE, 77 ISCSI_TASK_COMPLETED, 78 ISCSI_TASK_PENDING, 79 ISCSI_TASK_RUNNING, 80 ISCSI_TASK_ABRT_TMF, /* aborted due to TMF */ 81 ISCSI_TASK_ABRT_SESS_RECOV, /* aborted due to session recovery */ 82 ISCSI_TASK_REQUEUE_SCSIQ, /* qcmd requeueing to scsi-ml */ 83 }; 84 85 struct iscsi_r2t_info { 86 __be32 ttt; /* copied from R2T */ 87 __be32 exp_statsn; /* copied from R2T */ 88 uint32_t data_length; /* copied from R2T */ 89 uint32_t data_offset; /* copied from R2T */ 90 int data_count; /* DATA-Out payload progress */ 91 int datasn; 92 /* LLDs should set/update these values */ 93 int sent; /* R2T sequence progress */ 94 }; 95 96 struct iscsi_task { 97 /* 98 * Because LLDs allocate their hdr differently, this is a pointer 99 * and length to that storage. It must be setup at session 100 * creation time. 101 */ 102 struct iscsi_hdr *hdr; 103 unsigned short hdr_max; 104 unsigned short hdr_len; /* accumulated size of hdr used */ 105 /* copied values in case we need to send tmfs */ 106 itt_t hdr_itt; 107 __be32 cmdsn; 108 struct scsi_lun lun; 109 110 int itt; /* this ITT */ 111 112 unsigned imm_count; /* imm-data (bytes) */ 113 /* offset in unsolicited stream (bytes); */ 114 struct iscsi_r2t_info unsol_r2t; 115 char *data; /* mgmt payload */ 116 unsigned data_count; 117 struct scsi_cmnd *sc; /* associated SCSI cmd*/ 118 struct iscsi_conn *conn; /* used connection */ 119 120 /* data processing tracking */ 121 unsigned long last_xfer; 122 unsigned long last_timeout; 123 bool have_checked_conn; 124 125 /* T10 protection information */ 126 bool protected; 127 128 /* state set/tested under session->lock */ 129 int state; 130 refcount_t refcount; 131 struct list_head running; /* running cmd list */ 132 void *dd_data; /* driver/transport data */ 133 }; 134 135 static inline int iscsi_task_has_unsol_data(struct iscsi_task *task) 136 { 137 return task->unsol_r2t.data_length > task->unsol_r2t.sent; 138 } 139 140 static inline void* iscsi_next_hdr(struct iscsi_task *task) 141 { 142 return (void*)task->hdr + task->hdr_len; 143 } 144 145 /* Connection's states */ 146 enum { 147 ISCSI_CONN_INITIAL_STAGE, 148 ISCSI_CONN_STARTED, 149 ISCSI_CONN_STOPPED, 150 ISCSI_CONN_CLEANUP_WAIT, 151 }; 152 153 struct iscsi_conn { 154 struct iscsi_cls_conn *cls_conn; /* ptr to class connection */ 155 void *dd_data; /* iscsi_transport data */ 156 struct iscsi_session *session; /* parent session */ 157 /* 158 * conn_stop() flag: stop to recover, stop to terminate 159 */ 160 int stop_stage; 161 struct timer_list transport_timer; 162 unsigned long last_recv; 163 unsigned long last_ping; 164 int ping_timeout; 165 int recv_timeout; 166 struct iscsi_task *ping_task; 167 168 /* iSCSI connection-wide sequencing */ 169 uint32_t exp_statsn; 170 uint32_t statsn; 171 172 /* control data */ 173 int id; /* CID */ 174 int c_stage; /* connection state */ 175 /* 176 * Preallocated buffer for pdus that have data but do not 177 * originate from scsi-ml. We never have two pdus using the 178 * buffer at the same time. It is only allocated to 179 * the default max recv size because the pdus we support 180 * should always fit in this buffer 181 */ 182 char *data; 183 struct iscsi_task *login_task; /* mtask used for login/text */ 184 struct iscsi_task *task; /* xmit task in progress */ 185 186 /* xmit */ 187 spinlock_t taskqueuelock; /* protects the next three lists */ 188 struct list_head mgmtqueue; /* mgmt (control) xmit queue */ 189 struct list_head cmdqueue; /* data-path cmd queue */ 190 struct list_head requeue; /* tasks needing another run */ 191 struct work_struct xmitwork; /* per-conn. xmit workqueue */ 192 unsigned long suspend_tx; /* suspend Tx */ 193 unsigned long suspend_rx; /* suspend Rx */ 194 195 /* abort */ 196 wait_queue_head_t ehwait; /* used in eh_abort() */ 197 struct iscsi_tm tmhdr; 198 struct timer_list tmf_timer; 199 int tmf_state; /* see TMF_INITIAL, etc.*/ 200 201 /* negotiated params */ 202 unsigned max_recv_dlength; /* initiator_max_recv_dsl*/ 203 unsigned max_xmit_dlength; /* target_max_recv_dsl */ 204 int hdrdgst_en; 205 int datadgst_en; 206 int ifmarker_en; 207 int ofmarker_en; 208 /* values userspace uses to id a conn */ 209 int persistent_port; 210 char *persistent_address; 211 212 unsigned max_segment_size; 213 unsigned tcp_xmit_wsf; 214 unsigned tcp_recv_wsf; 215 uint16_t keepalive_tmo; 216 uint16_t local_port; 217 uint8_t tcp_timestamp_stat; 218 uint8_t tcp_nagle_disable; 219 uint8_t tcp_wsf_disable; 220 uint8_t tcp_timer_scale; 221 uint8_t tcp_timestamp_en; 222 uint8_t fragment_disable; 223 uint8_t ipv4_tos; 224 uint8_t ipv6_traffic_class; 225 uint8_t ipv6_flow_label; 226 uint8_t is_fw_assigned_ipv6; 227 char *local_ipaddr; 228 229 /* MIB-statistics */ 230 uint64_t txdata_octets; 231 uint64_t rxdata_octets; 232 uint32_t scsicmd_pdus_cnt; 233 uint32_t dataout_pdus_cnt; 234 uint32_t scsirsp_pdus_cnt; 235 uint32_t datain_pdus_cnt; 236 uint32_t r2t_pdus_cnt; 237 uint32_t tmfcmd_pdus_cnt; 238 int32_t tmfrsp_pdus_cnt; 239 240 /* custom statistics */ 241 uint32_t eh_abort_cnt; 242 uint32_t fmr_unalign_cnt; 243 }; 244 245 struct iscsi_pool { 246 struct kfifo queue; /* FIFO Queue */ 247 void **pool; /* Pool of elements */ 248 int max; /* Max number of elements */ 249 }; 250 251 /* Session's states */ 252 enum { 253 ISCSI_STATE_FREE = 1, 254 ISCSI_STATE_LOGGED_IN, 255 ISCSI_STATE_FAILED, 256 ISCSI_STATE_TERMINATE, 257 ISCSI_STATE_IN_RECOVERY, 258 ISCSI_STATE_RECOVERY_FAILED, 259 ISCSI_STATE_LOGGING_OUT, 260 }; 261 262 struct iscsi_session { 263 struct iscsi_cls_session *cls_session; 264 /* 265 * Syncs up the scsi eh thread with the iscsi eh thread when sending 266 * task management functions. This must be taken before the session 267 * and recv lock. 268 */ 269 struct mutex eh_mutex; 270 271 /* iSCSI session-wide sequencing */ 272 uint32_t cmdsn; 273 uint32_t exp_cmdsn; 274 uint32_t max_cmdsn; 275 276 /* This tracks the reqs queued into the initiator */ 277 uint32_t queued_cmdsn; 278 279 /* configuration */ 280 int abort_timeout; 281 int lu_reset_timeout; 282 int tgt_reset_timeout; 283 int initial_r2t_en; 284 unsigned short max_r2t; 285 int imm_data_en; 286 unsigned first_burst; 287 unsigned max_burst; 288 int time2wait; 289 int time2retain; 290 int pdu_inorder_en; 291 int dataseq_inorder_en; 292 int erl; 293 int fast_abort; 294 int tpgt; 295 char *username; 296 char *username_in; 297 char *password; 298 char *password_in; 299 char *targetname; 300 char *targetalias; 301 char *ifacename; 302 char *initiatorname; 303 char *boot_root; 304 char *boot_nic; 305 char *boot_target; 306 char *portal_type; 307 char *discovery_parent_type; 308 uint16_t discovery_parent_idx; 309 uint16_t def_taskmgmt_tmo; 310 uint16_t tsid; 311 uint8_t auto_snd_tgt_disable; 312 uint8_t discovery_sess; 313 uint8_t chap_auth_en; 314 uint8_t discovery_logout_en; 315 uint8_t bidi_chap_en; 316 uint8_t discovery_auth_optional; 317 uint8_t isid[ISID_SIZE]; 318 319 /* control data */ 320 struct iscsi_transport *tt; 321 struct Scsi_Host *host; 322 struct iscsi_conn *leadconn; /* leading connection */ 323 /* Between the forward and the backward locks exists a strict locking 324 * hierarchy. The mutual exclusion zone protected by the forward lock 325 * can enclose the mutual exclusion zone protected by the backward lock 326 * but not vice versa. 327 */ 328 spinlock_t frwd_lock; /* protects session state, * 329 * cmdsn, queued_cmdsn * 330 * session resources: * 331 * - cmdpool kfifo_out , * 332 * - mgmtpool, */ 333 spinlock_t back_lock; /* protects cmdsn_exp * 334 * cmdsn_max, * 335 * cmdpool kfifo_in */ 336 int state; /* session state */ 337 int age; /* counts session re-opens */ 338 339 int scsi_cmds_max; /* max scsi commands */ 340 int cmds_max; /* size of cmds array */ 341 struct iscsi_task **cmds; /* Original Cmds arr */ 342 struct iscsi_pool cmdpool; /* PDU's pool */ 343 void *dd_data; /* LLD private data */ 344 }; 345 346 enum { 347 ISCSI_HOST_SETUP, 348 ISCSI_HOST_REMOVED, 349 }; 350 351 struct iscsi_host { 352 char *initiatorname; 353 /* hw address or netdev iscsi connection is bound to */ 354 char *hwaddress; 355 char *netdev; 356 357 wait_queue_head_t session_removal_wq; 358 /* protects sessions and state */ 359 spinlock_t lock; 360 int num_sessions; 361 int state; 362 363 struct workqueue_struct *workq; 364 char workq_name[20]; 365 }; 366 367 /* 368 * scsi host template 369 */ 370 extern int iscsi_eh_abort(struct scsi_cmnd *sc); 371 extern int iscsi_eh_recover_target(struct scsi_cmnd *sc); 372 extern int iscsi_eh_session_reset(struct scsi_cmnd *sc); 373 extern int iscsi_eh_device_reset(struct scsi_cmnd *sc); 374 extern int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc); 375 extern enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc); 376 377 /* 378 * iSCSI host helpers. 379 */ 380 #define iscsi_host_priv(_shost) \ 381 (shost_priv(_shost) + sizeof(struct iscsi_host)) 382 383 extern int iscsi_host_set_param(struct Scsi_Host *shost, 384 enum iscsi_host_param param, char *buf, 385 int buflen); 386 extern int iscsi_host_get_param(struct Scsi_Host *shost, 387 enum iscsi_host_param param, char *buf); 388 extern int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev); 389 extern struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 390 int dd_data_size, 391 bool xmit_can_sleep); 392 extern void iscsi_host_remove(struct Scsi_Host *shost); 393 extern void iscsi_host_free(struct Scsi_Host *shost); 394 extern int iscsi_target_alloc(struct scsi_target *starget); 395 396 /* 397 * session management 398 */ 399 extern struct iscsi_cls_session * 400 iscsi_session_setup(struct iscsi_transport *, struct Scsi_Host *shost, 401 uint16_t, int, int, uint32_t, unsigned int); 402 extern void iscsi_session_teardown(struct iscsi_cls_session *); 403 extern void iscsi_session_recovery_timedout(struct iscsi_cls_session *); 404 extern int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 405 enum iscsi_param param, char *buf, int buflen); 406 extern int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 407 enum iscsi_param param, char *buf); 408 409 #define iscsi_session_printk(prefix, _sess, fmt, a...) \ 410 iscsi_cls_session_printk(prefix, _sess->cls_session, fmt, ##a) 411 412 /* 413 * connection management 414 */ 415 extern struct iscsi_cls_conn *iscsi_conn_setup(struct iscsi_cls_session *, 416 int, uint32_t); 417 extern void iscsi_conn_teardown(struct iscsi_cls_conn *); 418 extern int iscsi_conn_start(struct iscsi_cls_conn *); 419 extern void iscsi_conn_stop(struct iscsi_cls_conn *, int); 420 extern int iscsi_conn_bind(struct iscsi_cls_session *, struct iscsi_cls_conn *, 421 int); 422 extern void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err); 423 extern void iscsi_session_failure(struct iscsi_session *session, 424 enum iscsi_err err); 425 extern int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 426 enum iscsi_param param, char *buf); 427 extern int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 428 enum iscsi_param param, char *buf); 429 extern void iscsi_suspend_tx(struct iscsi_conn *conn); 430 extern void iscsi_suspend_queue(struct iscsi_conn *conn); 431 extern void iscsi_conn_queue_work(struct iscsi_conn *conn); 432 433 #define iscsi_conn_printk(prefix, _c, fmt, a...) \ 434 iscsi_cls_conn_printk(prefix, ((struct iscsi_conn *)_c)->cls_conn, \ 435 fmt, ##a) 436 437 /* 438 * pdu and task processing 439 */ 440 extern void iscsi_update_cmdsn(struct iscsi_session *, struct iscsi_nopin *); 441 extern void iscsi_prep_data_out_pdu(struct iscsi_task *task, 442 struct iscsi_r2t_info *r2t, 443 struct iscsi_data *hdr); 444 extern int iscsi_conn_send_pdu(struct iscsi_cls_conn *, struct iscsi_hdr *, 445 char *, uint32_t); 446 extern int iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *, 447 char *, int); 448 extern int __iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *, 449 char *, int); 450 extern int iscsi_verify_itt(struct iscsi_conn *, itt_t); 451 extern struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *, itt_t); 452 extern struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *, itt_t); 453 extern void iscsi_requeue_task(struct iscsi_task *task); 454 extern void iscsi_put_task(struct iscsi_task *task); 455 extern void __iscsi_put_task(struct iscsi_task *task); 456 extern void __iscsi_get_task(struct iscsi_task *task); 457 extern void iscsi_complete_scsi_task(struct iscsi_task *task, 458 uint32_t exp_cmdsn, uint32_t max_cmdsn); 459 460 /* 461 * generic helpers 462 */ 463 extern void iscsi_pool_free(struct iscsi_pool *); 464 extern int iscsi_pool_init(struct iscsi_pool *, int, void ***, int); 465 extern int iscsi_switch_str_param(char **, char *); 466 467 /* 468 * inline functions to deal with padding. 469 */ 470 static inline unsigned int 471 iscsi_padded(unsigned int len) 472 { 473 return (len + ISCSI_PAD_LEN - 1) & ~(ISCSI_PAD_LEN - 1); 474 } 475 476 static inline unsigned int 477 iscsi_padding(unsigned int len) 478 { 479 len &= (ISCSI_PAD_LEN - 1); 480 if (len) 481 len = ISCSI_PAD_LEN - len; 482 return len; 483 } 484 485 #endif 486