[ceph.git] / ceph / src / spdk / lib / iscsi / iscsi.h

/*-
 *   BSD LICENSE
 *
 *   Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>.
 *   Copyright (c) Intel Corporation.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef SPDK_ISCSI_H
#define SPDK_ISCSI_H

#include "spdk/stdinc.h"

#include "spdk/bdev.h"
#include "spdk/iscsi_spec.h"
#include "spdk/thread.h"
#include "spdk/sock.h"

#include "spdk/scsi.h"
#include "iscsi/param.h"

#include "spdk/assert.h"
#include "spdk/dif.h"
#include "spdk/util.h"

#define SPDK_ISCSI_DEFAULT_NODEBASE "iqn.2016-06.io.spdk"

#define DEFAULT_MAXR2T 4
#define MAX_INITIATOR_PORT_NAME 256
#define MAX_INITIATOR_NAME 223
#define MAX_TARGET_NAME 223

#define MAX_PORTAL 1024
#define MAX_INITIATOR 256
#define MAX_NETMASK 256
#define MAX_ISCSI_CONNECTIONS 1024
#define MAX_PORTAL_ADDR 256
#define MAX_PORTAL_PORT 32

#define DEFAULT_PORT 3260
#define DEFAULT_MAX_SESSIONS 128
#define DEFAULT_MAX_CONNECTIONS_PER_SESSION 2
#define DEFAULT_MAXOUTSTANDINGR2T 1
#define DEFAULT_DEFAULTTIME2WAIT 2
#define DEFAULT_DEFAULTTIME2RETAIN 20
#define DEFAULT_INITIALR2T true
#define DEFAULT_IMMEDIATEDATA true
#define DEFAULT_DATAPDUINORDER true
#define DEFAULT_DATASEQUENCEINORDER true
#define DEFAULT_ERRORRECOVERYLEVEL 0
#define DEFAULT_TIMEOUT 60
#define MAX_NOPININTERVAL 60
#define DEFAULT_NOPININTERVAL 30

/*
 * SPDK iSCSI target currently only supports 64KB as the maximum data segment length
 *  it can receive from initiators.  Other values may work, but no guarantees.
 */
#define SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH  65536

/*
 * Defines maximum number of data out buffers each connection can have in
 *  use at any given time.
 */
#define MAX_DATA_OUT_PER_CONNECTION 16

/*
 * Defines maximum number of data in buffers each connection can have in
 *  use at any given time. So this limit does not affect I/O smaller than
 *  SPDK_BDEV_SMALL_BUF_MAX_SIZE.
 */
#define MAX_LARGE_DATAIN_PER_CONNECTION 64

#define SPDK_ISCSI_MAX_BURST_LENGTH	\
		(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH * MAX_DATA_OUT_PER_CONNECTION)

/*
 * Defines default maximum amount in bytes of unsolicited data the iSCSI
 *  initiator may send to the SPDK iSCSI target during the execution of
 *  a single SCSI command. And it is smaller than the MaxBurstLength.
 */
#define SPDK_ISCSI_FIRST_BURST_LENGTH	8192

/*
 * Defines minimum amount in bytes of unsolicited data the iSCSI initiator
 *  may send to the SPDK iSCSI target during the execution of a single
 *  SCSI command.
 */
#define SPDK_ISCSI_MIN_FIRST_BURST_LENGTH	512

#define SPDK_ISCSI_MAX_FIRST_BURST_LENGTH	16777215

/*
 * Defines default maximum queue depth per connection and this can be
 * changed by configuration file.
 */
#define DEFAULT_MAX_QUEUE_DEPTH	64

/** Defines how long we should wait for a logout request when the target
 *   requests logout to the initiator asynchronously.
 */
#define ISCSI_LOGOUT_REQUEST_TIMEOUT 30 /* in seconds */

/** Defines how long we should wait for a TCP close after responding to a
 *   logout request, before terminating the connection ourselves.
 */
#define ISCSI_LOGOUT_TIMEOUT 5 /* in seconds */

/* For spdk_iscsi_login_in related function use, we need to avoid the conflict
 * with other errors
 * */
#define SPDK_ISCSI_LOGIN_ERROR_RESPONSE -1000
#define SPDK_ISCSI_LOGIN_ERROR_PARAMETER -1001
#define SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE -1002

#define ISCSI_AHS_LEN 60

struct spdk_mobj {
	struct spdk_mempool *mp;
	void *buf;
};

/*
 * Maximum number of SGL elements, i.e.,
 * BHS, AHS, Header Digest, Data Segment and Data Digest.
 */
#define SPDK_ISCSI_MAX_SGL_DESCRIPTORS	(5)

typedef void (*iscsi_conn_xfer_complete_cb)(void *cb_arg);

struct spdk_iscsi_pdu {
	struct iscsi_bhs bhs;
	struct spdk_mobj *mobj;
	bool is_rejected;
	uint8_t *data_buf;
	uint8_t *data;
	uint8_t header_digest[ISCSI_DIGEST_LEN];
	uint8_t data_digest[ISCSI_DIGEST_LEN];
	size_t data_segment_len;
	int bhs_valid_bytes;
	int ahs_valid_bytes;
	uint32_t data_valid_bytes;
	int hdigest_valid_bytes;
	int ddigest_valid_bytes;
	int ref;
	bool data_from_mempool;  /* indicate whether the data buffer is allocated from mempool */
	struct spdk_iscsi_task *task; /* data tied to a task buffer */
	uint32_t cmd_sn;
	uint32_t writev_offset;
	uint32_t data_buf_len;
	bool dif_insert_or_strip;
	struct spdk_dif_ctx dif_ctx;
	struct spdk_iscsi_conn *conn;

	iscsi_conn_xfer_complete_cb		cb_fn;
	void					*cb_arg;

	/* The sock request ends with a 0 length iovec. Place the actual iovec immediately
	 * after it. There is a static assert below to check if the compiler inserted
	 * any unwanted padding */
	int32_t						mapped_length;
	struct spdk_sock_request			sock_req;
	struct iovec					iov[SPDK_ISCSI_MAX_SGL_DESCRIPTORS];
	TAILQ_ENTRY(spdk_iscsi_pdu)	tailq;


	/*
	 * 60 bytes of AHS should suffice for now.
	 * This should always be at the end of PDU data structure.
	 * we need to not zero this out when doing memory clear.
	 */
	uint8_t ahs[ISCSI_AHS_LEN];

	struct {
		uint16_t length; /* iSCSI SenseLength (big-endian) */
		uint8_t data[32];
	} sense;
};
SPDK_STATIC_ASSERT(offsetof(struct spdk_iscsi_pdu,
			    sock_req) + sizeof(struct spdk_sock_request) == offsetof(struct spdk_iscsi_pdu, iov),
		   "Compiler inserted padding between iov and sock_req");

enum iscsi_connection_state {
	ISCSI_CONN_STATE_INVALID = 0,
	ISCSI_CONN_STATE_RUNNING = 1,
	ISCSI_CONN_STATE_EXITING = 2,
	ISCSI_CONN_STATE_EXITED = 3,
};

enum iscsi_chap_phase {
	ISCSI_CHAP_PHASE_NONE = 0,
	ISCSI_CHAP_PHASE_WAIT_A = 1,
	ISCSI_CHAP_PHASE_WAIT_NR = 2,
	ISCSI_CHAP_PHASE_END = 3,
};

enum session_type {
	SESSION_TYPE_INVALID = 0,
	SESSION_TYPE_NORMAL = 1,
	SESSION_TYPE_DISCOVERY = 2,
};

#define ISCSI_CHAP_CHALLENGE_LEN	1024
#define ISCSI_CHAP_MAX_USER_LEN		255
#define ISCSI_CHAP_MAX_SECRET_LEN	255

struct iscsi_chap_auth {
	enum iscsi_chap_phase chap_phase;

	char user[ISCSI_CHAP_MAX_USER_LEN + 1];
	char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
	char muser[ISCSI_CHAP_MAX_USER_LEN + 1];
	char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1];

	uint8_t chap_id[1];
	uint8_t chap_mid[1];
	int chap_challenge_len;
	uint8_t chap_challenge[ISCSI_CHAP_CHALLENGE_LEN];
	int chap_mchallenge_len;
	uint8_t chap_mchallenge[ISCSI_CHAP_CHALLENGE_LEN];
};

struct spdk_iscsi_auth_secret {
	char user[ISCSI_CHAP_MAX_USER_LEN + 1];
	char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
	char muser[ISCSI_CHAP_MAX_USER_LEN + 1];
	char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
	TAILQ_ENTRY(spdk_iscsi_auth_secret) tailq;
};

struct spdk_iscsi_auth_group {
	int32_t tag;
	TAILQ_HEAD(, spdk_iscsi_auth_secret) secret_head;
	TAILQ_ENTRY(spdk_iscsi_auth_group) tailq;
};

struct spdk_iscsi_sess {
	uint32_t connections;
	struct spdk_iscsi_conn **conns;

	struct spdk_scsi_port *initiator_port;
	int tag;

	uint64_t isid;
	uint16_t tsih;
	struct spdk_iscsi_tgt_node *target;
	int queue_depth;

	struct iscsi_param *params;

	enum session_type session_type;
	uint32_t MaxConnections;
	uint32_t MaxOutstandingR2T;
	uint32_t DefaultTime2Wait;
	uint32_t DefaultTime2Retain;
	uint32_t FirstBurstLength;
	uint32_t MaxBurstLength;
	bool InitialR2T;
	bool ImmediateData;
	bool DataPDUInOrder;
	bool DataSequenceInOrder;
	uint32_t ErrorRecoveryLevel;

	uint32_t ExpCmdSN;
	uint32_t MaxCmdSN;

	uint32_t current_text_itt;
};

struct spdk_iscsi_poll_group {
	struct spdk_poller				*poller;
	struct spdk_poller				*nop_poller;
	STAILQ_HEAD(connections, spdk_iscsi_conn)	connections;
	struct spdk_sock_group				*sock_group;
	TAILQ_ENTRY(spdk_iscsi_poll_group)		link;
};

struct spdk_iscsi_opts {
	char *authfile;
	char *nodebase;
	int32_t timeout;
	int32_t nopininterval;
	bool disable_chap;
	bool require_chap;
	bool mutual_chap;
	int32_t chap_group;
	uint32_t MaxSessions;
	uint32_t MaxConnectionsPerSession;
	uint32_t MaxConnections;
	uint32_t MaxQueueDepth;
	uint32_t DefaultTime2Wait;
	uint32_t DefaultTime2Retain;
	uint32_t FirstBurstLength;
	bool ImmediateData;
	uint32_t ErrorRecoveryLevel;
	bool AllowDuplicateIsid;
};

struct spdk_iscsi_globals {
	char *authfile;
	char *nodebase;
	pthread_mutex_t mutex;
	uint32_t refcnt;
	TAILQ_HEAD(, spdk_iscsi_portal)		portal_head;
	TAILQ_HEAD(, spdk_iscsi_portal_grp)	pg_head;
	TAILQ_HEAD(, spdk_iscsi_init_grp)	ig_head;
	TAILQ_HEAD(, spdk_iscsi_tgt_node)	target_head;
	TAILQ_HEAD(, spdk_iscsi_auth_group)	auth_group_head;
	TAILQ_HEAD(, spdk_iscsi_poll_group)	poll_group_head;

	int32_t timeout;
	int32_t nopininterval;
	bool disable_chap;
	bool require_chap;
	bool mutual_chap;
	int32_t chap_group;

	uint32_t MaxSessions;
	uint32_t MaxConnectionsPerSession;
	uint32_t MaxConnections;
	uint32_t MaxQueueDepth;
	uint32_t DefaultTime2Wait;
	uint32_t DefaultTime2Retain;
	uint32_t FirstBurstLength;
	bool ImmediateData;
	uint32_t ErrorRecoveryLevel;
	bool AllowDuplicateIsid;

	struct spdk_mempool *pdu_pool;
	struct spdk_mempool *pdu_immediate_data_pool;
	struct spdk_mempool *pdu_data_out_pool;
	struct spdk_mempool *session_pool;
	struct spdk_mempool *task_pool;

	struct spdk_iscsi_sess	**session;
};

#define ISCSI_SECURITY_NEGOTIATION_PHASE	0
#define ISCSI_OPERATIONAL_NEGOTIATION_PHASE	1
#define ISCSI_NSG_RESERVED_CODE			2
#define ISCSI_FULL_FEATURE_PHASE		3

/* logout reason */
#define ISCSI_LOGOUT_REASON_CLOSE_SESSION		0
#define ISCSI_LOGOUT_REASON_CLOSE_CONNECTION		1
#define ISCSI_LOGOUT_REASON_REMOVE_CONN_FOR_RECOVERY	2

enum spdk_error_codes {
	SPDK_ISCSI_CONNECTION_FATAL	= -1,
	SPDK_PDU_FATAL		= -2,
};

#define DGET24(B)											\
	(((  (uint32_t) *((uint8_t *)(B)+0)) << 16)				\
	 | (((uint32_t) *((uint8_t *)(B)+1)) << 8)				\
	 | (((uint32_t) *((uint8_t *)(B)+2)) << 0))

#define DSET24(B,D)													\
	(((*((uint8_t *)(B)+0)) = (uint8_t)((uint32_t)(D) >> 16)),		\
	 ((*((uint8_t *)(B)+1)) = (uint8_t)((uint32_t)(D) >> 8)),		\
	 ((*((uint8_t *)(B)+2)) = (uint8_t)((uint32_t)(D) >> 0)))

#define xstrdup(s) (s ? strdup(s) : (char *)NULL)

extern struct spdk_iscsi_globals g_iscsi;
extern struct spdk_iscsi_opts *g_spdk_iscsi_opts;

struct spdk_iscsi_task;
struct spdk_json_write_ctx;

typedef void (*spdk_iscsi_init_cb)(void *cb_arg, int rc);

void spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg);
typedef void (*spdk_iscsi_fini_cb)(void *arg);
void spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg);
void shutdown_iscsi_conns_done(void);
void spdk_iscsi_config_text(FILE *fp);
void spdk_iscsi_config_json(struct spdk_json_write_ctx *w);

struct spdk_iscsi_opts *iscsi_opts_alloc(void);
void iscsi_opts_free(struct spdk_iscsi_opts *opts);
struct spdk_iscsi_opts *iscsi_opts_copy(struct spdk_iscsi_opts *src);
void iscsi_opts_info_json(struct spdk_json_write_ctx *w);
int iscsi_set_discovery_auth(bool disable_chap, bool require_chap,
			     bool mutual_chap, int32_t chap_group);
int iscsi_chap_get_authinfo(struct iscsi_chap_auth *auth, const char *authuser,
			    int ag_tag);
int iscsi_add_auth_group(int32_t tag, struct spdk_iscsi_auth_group **_group);
struct spdk_iscsi_auth_group *iscsi_find_auth_group_by_tag(int32_t tag);
void iscsi_delete_auth_group(struct spdk_iscsi_auth_group *group);
int iscsi_auth_group_add_secret(struct spdk_iscsi_auth_group *group,
				const char *user, const char *secret,
				const char *muser, const char *msecret);
int iscsi_auth_group_delete_secret(struct spdk_iscsi_auth_group *group,
				   const char *user);
void iscsi_auth_groups_info_json(struct spdk_json_write_ctx *w);

void iscsi_task_response(struct spdk_iscsi_conn *conn,
			 struct spdk_iscsi_task *task);
int iscsi_build_iovs(struct spdk_iscsi_conn *conn, struct iovec *iovs, int iovcnt,
		     struct spdk_iscsi_pdu *pdu, uint32_t *mapped_length);
int iscsi_handle_incoming_pdus(struct spdk_iscsi_conn *conn);
void iscsi_task_mgmt_response(struct spdk_iscsi_conn *conn,
			      struct spdk_iscsi_task *task);

void iscsi_free_sess(struct spdk_iscsi_sess *sess);
void iscsi_clear_all_transfer_task(struct spdk_iscsi_conn *conn,
				   struct spdk_scsi_lun *lun,
				   struct spdk_iscsi_pdu *pdu);
bool iscsi_del_transfer_task(struct spdk_iscsi_conn *conn, uint32_t CmdSN);

uint32_t iscsi_pdu_calc_header_digest(struct spdk_iscsi_pdu *pdu);
uint32_t iscsi_pdu_calc_data_digest(struct spdk_iscsi_pdu *pdu);

/* Memory management */
void iscsi_put_pdu(struct spdk_iscsi_pdu *pdu);
struct spdk_iscsi_pdu *iscsi_get_pdu(struct spdk_iscsi_conn *conn);
void iscsi_op_abort_task_set(struct spdk_iscsi_task *task,
			     uint8_t function);
void iscsi_queue_task(struct spdk_iscsi_conn *conn, struct spdk_iscsi_task *task);

static inline uint32_t
iscsi_get_max_immediate_data_size(void)
{
	/*
	 * Specify enough extra space in addition to FirstBurstLength to
	 *  account for a header digest, data digest and additional header
	 *  segments (AHS).  These are not normally used but they do not
	 *  take up much space and we need to make sure the worst-case scenario
	 *  can be satisified by the size returned here.
	 */
	return g_iscsi.FirstBurstLength +
	       ISCSI_DIGEST_LEN + /* data digest */
	       ISCSI_DIGEST_LEN + /* header digest */
	       8 +		   /* bidirectional AHS */
	       52;		   /* extended CDB AHS (for a 64-byte CDB) */
}

#endif /* SPDK_ISCSI_H */
Commit	Line	Data
7c673cae FG	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
11fdf7f2	38	#include "spdk/stdinc.h"
7c673cae FG	39
	40	#include "spdk/bdev.h"
	41	#include "spdk/iscsi_spec.h"
11fdf7f2	42	#include "spdk/thread.h"
f67539c2	43	#include "spdk/sock.h"
7c673cae	44
f67539c2	45	#include "spdk/scsi.h"
7c673cae	46	#include "iscsi/param.h"
7c673cae FG	47
7c673cae FG	48	#include "spdk/assert.h"
9f95a23c	49	#include "spdk/dif.h"
11fdf7f2	50	#include "spdk/util.h"
7c673cae	51
7c673cae FG	52	#define SPDK_ISCSI_DEFAULT_NODEBASE "iqn.2016-06.io.spdk"
	53
	54	#define DEFAULT_MAXR2T 4
9f95a23c TL	55	#define MAX_INITIATOR_PORT_NAME 256
	56	#define MAX_INITIATOR_NAME 223
	57	#define MAX_TARGET_NAME 223
7c673cae	58
7c673cae FG	59	#define MAX_PORTAL 1024
	60	#define MAX_INITIATOR 256
	61	#define MAX_NETMASK 256
9f95a23c	62	#define MAX_ISCSI_CONNECTIONS 1024
f67539c2 TL	63	#define MAX_PORTAL_ADDR 256
f67539c2 TL	64	#define MAX_PORTAL_PORT 32
7c673cae FG	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
11fdf7f2 TL	72	#define DEFAULT_INITIALR2T true
	73	#define DEFAULT_IMMEDIATEDATA true
	74	#define DEFAULT_DATAPDUINORDER true
	75	#define DEFAULT_DATASEQUENCEINORDER true
7c673cae FG	76	#define DEFAULT_ERRORRECOVERYLEVEL 0
	77	#define DEFAULT_TIMEOUT 60
	78	#define MAX_NOPININTERVAL 60
	79	#define DEFAULT_NOPININTERVAL 30
7c673cae FG	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
7c673cae FG	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
11fdf7f2	96	* SPDK_BDEV_SMALL_BUF_MAX_SIZE.
7c673cae FG	97	*/
	98	#define MAX_LARGE_DATAIN_PER_CONNECTION 64
	99
7c673cae FG	100	#define SPDK_ISCSI_MAX_BURST_LENGTH \
	101	(SPDK_ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH * MAX_DATA_OUT_PER_CONNECTION)
	102
11fdf7f2 TL	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	*/
7c673cae FG	108	#define SPDK_ISCSI_FIRST_BURST_LENGTH 8192
7c673cae FG	109
11fdf7f2 TL	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
9f95a23c TL	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
f67539c2 TL	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
7c673cae FG	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
7c673cae FG	135	/* For spdk_iscsi_login_in related function use, we need to avoid the conflict
	136	* with other errors
	137	* */
	138	#define SPDK_ISCSI_LOGIN_ERROR_RESPONSE -1000
	139	#define SPDK_ISCSI_LOGIN_ERROR_PARAMETER -1001
	140	#define SPDK_ISCSI_PARAMETER_EXCHANGE_NOT_ONCE -1002
	141
	142	#define ISCSI_AHS_LEN 60
	143
	144	struct spdk_mobj {
11fdf7f2	145	struct spdk_mempool *mp;
7c673cae	146	void *buf;
7c673cae FG	147	};
7c673cae FG	148
f67539c2 TL	149	/*
	150	* Maximum number of SGL elements, i.e.,
	151	* BHS, AHS, Header Digest, Data Segment and Data Digest.
	152	*/
	153	#define SPDK_ISCSI_MAX_SGL_DESCRIPTORS (5)
	154
	155	typedef void (iscsi_conn_xfer_complete_cb)(void cb_arg);
	156
7c673cae FG	157	struct spdk_iscsi_pdu {
7c673cae FG	158	struct iscsi_bhs bhs;
7c673cae	159	struct spdk_mobj *mobj;
f67539c2	160	bool is_rejected;
7c673cae FG	161	uint8_t *data_buf;
	162	uint8_t *data;
	163	uint8_t header_digest[ISCSI_DIGEST_LEN];
	164	uint8_t data_digest[ISCSI_DIGEST_LEN];
	165	size_t data_segment_len;
	166	int bhs_valid_bytes;
	167	int ahs_valid_bytes;
f67539c2	168	uint32_t data_valid_bytes;
7c673cae FG	169	int hdigest_valid_bytes;
	170	int ddigest_valid_bytes;
	171	int ref;
	172	bool data_from_mempool; /* indicate whether the data buffer is allocated from mempool */
	173	struct spdk_iscsi_task task; / data tied to a task buffer */
	174	uint32_t cmd_sn;
	175	uint32_t writev_offset;
9f95a23c TL	176	uint32_t data_buf_len;
	177	bool dif_insert_or_strip;
	178	struct spdk_dif_ctx dif_ctx;
f67539c2 TL	179	struct spdk_iscsi_conn *conn;
	180
	181	iscsi_conn_xfer_complete_cb cb_fn;
	182	void *cb_arg;
	183
	184	/* The sock request ends with a 0 length iovec. Place the actual iovec immediately
	185	* after it. There is a static assert below to check if the compiler inserted
	186	* any unwanted padding */
	187	int32_t mapped_length;
	188	struct spdk_sock_request sock_req;
	189	struct iovec iov[SPDK_ISCSI_MAX_SGL_DESCRIPTORS];
7c673cae FG	190	TAILQ_ENTRY(spdk_iscsi_pdu) tailq;
	191
	192
	193	/*
	194	* 60 bytes of AHS should suffice for now.
	195	* This should always be at the end of PDU data structure.
	196	* we need to not zero this out when doing memory clear.
	197	*/
11fdf7f2	198	uint8_t ahs[ISCSI_AHS_LEN];
7c673cae FG	199
	200	struct {
	201	uint16_t length; /* iSCSI SenseLength (big-endian) */
	202	uint8_t data[32];
	203	} sense;
	204	};
f67539c2 TL	205	SPDK_STATIC_ASSERT(offsetof(struct spdk_iscsi_pdu,
	206	sock_req) + sizeof(struct spdk_sock_request) == offsetof(struct spdk_iscsi_pdu, iov),
	207	"Compiler inserted padding between iov and sock_req");
7c673cae FG	208
	209	enum iscsi_connection_state {
	210	ISCSI_CONN_STATE_INVALID = 0,
	211	ISCSI_CONN_STATE_RUNNING = 1,
f67539c2 TL	212	ISCSI_CONN_STATE_EXITING = 2,
f67539c2 TL	213	ISCSI_CONN_STATE_EXITED = 3,
7c673cae FG	214	};
	215
	216	enum iscsi_chap_phase {
	217	ISCSI_CHAP_PHASE_NONE = 0,
	218	ISCSI_CHAP_PHASE_WAIT_A = 1,
	219	ISCSI_CHAP_PHASE_WAIT_NR = 2,
	220	ISCSI_CHAP_PHASE_END = 3,
	221	};
	222
	223	enum session_type {
	224	SESSION_TYPE_INVALID = 0,
	225	SESSION_TYPE_NORMAL = 1,
	226	SESSION_TYPE_DISCOVERY = 2,
	227	};
	228
11fdf7f2 TL	229	#define ISCSI_CHAP_CHALLENGE_LEN 1024
	230	#define ISCSI_CHAP_MAX_USER_LEN 255
	231	#define ISCSI_CHAP_MAX_SECRET_LEN 255
	232
7c673cae FG	233	struct iscsi_chap_auth {
	234	enum iscsi_chap_phase chap_phase;
	235
11fdf7f2 TL	236	char user[ISCSI_CHAP_MAX_USER_LEN + 1];
	237	char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
	238	char muser[ISCSI_CHAP_MAX_USER_LEN + 1];
	239	char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
7c673cae FG	240
	241	uint8_t chap_id[1];
	242	uint8_t chap_mid[1];
	243	int chap_challenge_len;
	244	uint8_t chap_challenge[ISCSI_CHAP_CHALLENGE_LEN];
	245	int chap_mchallenge_len;
	246	uint8_t chap_mchallenge[ISCSI_CHAP_CHALLENGE_LEN];
	247	};
	248
11fdf7f2 TL	249	struct spdk_iscsi_auth_secret {
	250	char user[ISCSI_CHAP_MAX_USER_LEN + 1];
	251	char secret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
	252	char muser[ISCSI_CHAP_MAX_USER_LEN + 1];
	253	char msecret[ISCSI_CHAP_MAX_SECRET_LEN + 1];
	254	TAILQ_ENTRY(spdk_iscsi_auth_secret) tailq;
	255	};
	256
	257	struct spdk_iscsi_auth_group {
	258	int32_t tag;
	259	TAILQ_HEAD(, spdk_iscsi_auth_secret) secret_head;
	260	TAILQ_ENTRY(spdk_iscsi_auth_group) tailq;
	261	};
	262
7c673cae FG	263	struct spdk_iscsi_sess {
	264	uint32_t connections;
	265	struct spdk_iscsi_conn **conns;
	266
11fdf7f2	267	struct spdk_scsi_port *initiator_port;
7c673cae FG	268	int tag;
	269
	270	uint64_t isid;
	271	uint16_t tsih;
	272	struct spdk_iscsi_tgt_node *target;
	273	int queue_depth;
	274
	275	struct iscsi_param *params;
	276
	277	enum session_type session_type;
	278	uint32_t MaxConnections;
	279	uint32_t MaxOutstandingR2T;
	280	uint32_t DefaultTime2Wait;
	281	uint32_t DefaultTime2Retain;
	282	uint32_t FirstBurstLength;
	283	uint32_t MaxBurstLength;
11fdf7f2 TL	284	bool InitialR2T;
	285	bool ImmediateData;
	286	bool DataPDUInOrder;
	287	bool DataSequenceInOrder;
7c673cae FG	288	uint32_t ErrorRecoveryLevel;
	289
	290	uint32_t ExpCmdSN;
	291	uint32_t MaxCmdSN;
	292
	293	uint32_t current_text_itt;
	294	};
	295
11fdf7f2	296	struct spdk_iscsi_poll_group {
11fdf7f2 TL	297	struct spdk_poller *poller;
	298	struct spdk_poller *nop_poller;
	299	STAILQ_HEAD(connections, spdk_iscsi_conn) connections;
	300	struct spdk_sock_group *sock_group;
f67539c2	301	TAILQ_ENTRY(spdk_iscsi_poll_group) link;
11fdf7f2 TL	302	};
	303
	304	struct spdk_iscsi_opts {
	305	char *authfile;
	306	char *nodebase;
	307	int32_t timeout;
	308	int32_t nopininterval;
	309	bool disable_chap;
	310	bool require_chap;
	311	bool mutual_chap;
	312	int32_t chap_group;
	313	uint32_t MaxSessions;
	314	uint32_t MaxConnectionsPerSession;
	315	uint32_t MaxConnections;
	316	uint32_t MaxQueueDepth;
	317	uint32_t DefaultTime2Wait;
	318	uint32_t DefaultTime2Retain;
	319	uint32_t FirstBurstLength;
	320	bool ImmediateData;
	321	uint32_t ErrorRecoveryLevel;
	322	bool AllowDuplicateIsid;
11fdf7f2 TL	323	};
11fdf7f2 TL	324
7c673cae FG	325	struct spdk_iscsi_globals {
	326	char *authfile;
	327	char *nodebase;
	328	pthread_mutex_t mutex;
f67539c2	329	uint32_t refcnt;
11fdf7f2	330	TAILQ_HEAD(, spdk_iscsi_portal) portal_head;
7c673cae FG	331	TAILQ_HEAD(, spdk_iscsi_portal_grp) pg_head;
7c673cae FG	332	TAILQ_HEAD(, spdk_iscsi_init_grp) ig_head;
11fdf7f2 TL	333	TAILQ_HEAD(, spdk_iscsi_tgt_node) target_head;
11fdf7f2 TL	334	TAILQ_HEAD(, spdk_iscsi_auth_group) auth_group_head;
f67539c2	335	TAILQ_HEAD(, spdk_iscsi_poll_group) poll_group_head;
7c673cae	336
11fdf7f2 TL	337	int32_t timeout;
	338	int32_t nopininterval;
	339	bool disable_chap;
	340	bool require_chap;
	341	bool mutual_chap;
	342	int32_t chap_group;
7c673cae FG	343
	344	uint32_t MaxSessions;
	345	uint32_t MaxConnectionsPerSession;
	346	uint32_t MaxConnections;
11fdf7f2	347	uint32_t MaxQueueDepth;
7c673cae FG	348	uint32_t DefaultTime2Wait;
	349	uint32_t DefaultTime2Retain;
	350	uint32_t FirstBurstLength;
11fdf7f2	351	bool ImmediateData;
7c673cae	352	uint32_t ErrorRecoveryLevel;
11fdf7f2	353	bool AllowDuplicateIsid;
7c673cae	354
11fdf7f2 TL	355	struct spdk_mempool *pdu_pool;
	356	struct spdk_mempool *pdu_immediate_data_pool;
	357	struct spdk_mempool *pdu_data_out_pool;
	358	struct spdk_mempool *session_pool;
	359	struct spdk_mempool *task_pool;
7c673cae FG	360
	361	struct spdk_iscsi_sess **session;
	362	};
	363
	364	#define ISCSI_SECURITY_NEGOTIATION_PHASE 0
	365	#define ISCSI_OPERATIONAL_NEGOTIATION_PHASE 1
	366	#define ISCSI_NSG_RESERVED_CODE 2
	367	#define ISCSI_FULL_FEATURE_PHASE 3
	368
f67539c2 TL	369	/* logout reason */
	370	#define ISCSI_LOGOUT_REASON_CLOSE_SESSION 0
	371	#define ISCSI_LOGOUT_REASON_CLOSE_CONNECTION 1
	372	#define ISCSI_LOGOUT_REASON_REMOVE_CONN_FOR_RECOVERY 2
	373
7c673cae	374	enum spdk_error_codes {
7c673cae FG	375	SPDK_ISCSI_CONNECTION_FATAL = -1,
	376	SPDK_PDU_FATAL = -2,
	377	};
	378
	379	#define DGET24(B) \
	380	((( (uint32_t) ((uint8_t )(B)+0)) << 16) \
	381	\| (((uint32_t) ((uint8_t )(B)+1)) << 8) \
	382	\| (((uint32_t) ((uint8_t )(B)+2)) << 0))
	383
	384	#define DSET24(B,D) \
	385	(((((uint8_t )(B)+0)) = (uint8_t)((uint32_t)(D) >> 16)), \
	386	((((uint8_t )(B)+1)) = (uint8_t)((uint32_t)(D) >> 8)), \
	387	((((uint8_t )(B)+2)) = (uint8_t)((uint32_t)(D) >> 0)))
	388
	389	#define xstrdup(s) (s ? strdup(s) : (char *)NULL)
	390
f67539c2	391	extern struct spdk_iscsi_globals g_iscsi;
11fdf7f2	392	extern struct spdk_iscsi_opts *g_spdk_iscsi_opts;
7c673cae FG	393
7c673cae FG	394	struct spdk_iscsi_task;
11fdf7f2 TL	395	struct spdk_json_write_ctx;
	396
	397	typedef void (spdk_iscsi_init_cb)(void cb_arg, int rc);
	398
	399	void spdk_iscsi_init(spdk_iscsi_init_cb cb_fn, void *cb_arg);
	400	typedef void (spdk_iscsi_fini_cb)(void arg);
	401	void spdk_iscsi_fini(spdk_iscsi_fini_cb cb_fn, void *cb_arg);
f67539c2	402	void shutdown_iscsi_conns_done(void);
11fdf7f2 TL	403	void spdk_iscsi_config_text(FILE *fp);
	404	void spdk_iscsi_config_json(struct spdk_json_write_ctx *w);
	405
f67539c2 TL	406	struct spdk_iscsi_opts *iscsi_opts_alloc(void);
	407	void iscsi_opts_free(struct spdk_iscsi_opts *opts);
	408	struct spdk_iscsi_opts iscsi_opts_copy(struct spdk_iscsi_opts src);
	409	void iscsi_opts_info_json(struct spdk_json_write_ctx *w);
	410	int iscsi_set_discovery_auth(bool disable_chap, bool require_chap,
	411	bool mutual_chap, int32_t chap_group);
	412	int iscsi_chap_get_authinfo(struct iscsi_chap_auth auth, const char authuser,
	413	int ag_tag);
	414	int iscsi_add_auth_group(int32_t tag, struct spdk_iscsi_auth_group **_group);
	415	struct spdk_iscsi_auth_group *iscsi_find_auth_group_by_tag(int32_t tag);
	416	void iscsi_delete_auth_group(struct spdk_iscsi_auth_group *group);
	417	int iscsi_auth_group_add_secret(struct spdk_iscsi_auth_group *group,
	418	const char user, const char secret,
	419	const char muser, const char msecret);
	420	int iscsi_auth_group_delete_secret(struct spdk_iscsi_auth_group *group,
	421	const char *user);
	422	void iscsi_auth_groups_info_json(struct spdk_json_write_ctx *w);
	423
	424	void iscsi_task_response(struct spdk_iscsi_conn *conn,
	425	struct spdk_iscsi_task *task);
	426	int iscsi_build_iovs(struct spdk_iscsi_conn conn, struct iovec iovs, int iovcnt,
	427	struct spdk_iscsi_pdu pdu, uint32_t mapped_length);
	428	int iscsi_handle_incoming_pdus(struct spdk_iscsi_conn *conn);
	429	void iscsi_task_mgmt_response(struct spdk_iscsi_conn *conn,
7c673cae	430	struct spdk_iscsi_task *task);
f67539c2 TL	431
	432	void iscsi_free_sess(struct spdk_iscsi_sess *sess);
	433	void iscsi_clear_all_transfer_task(struct spdk_iscsi_conn *conn,
	434	struct spdk_scsi_lun *lun,
	435	struct spdk_iscsi_pdu *pdu);
	436	bool iscsi_del_transfer_task(struct spdk_iscsi_conn *conn, uint32_t CmdSN);
	437
	438	uint32_t iscsi_pdu_calc_header_digest(struct spdk_iscsi_pdu *pdu);
	439	uint32_t iscsi_pdu_calc_data_digest(struct spdk_iscsi_pdu *pdu);
7c673cae FG	440
7c673cae FG	441	/* Memory management */
f67539c2 TL	442	void iscsi_put_pdu(struct spdk_iscsi_pdu *pdu);
	443	struct spdk_iscsi_pdu iscsi_get_pdu(struct spdk_iscsi_conn conn);
	444	void iscsi_op_abort_task_set(struct spdk_iscsi_task *task,
	445	uint8_t function);
	446	void iscsi_queue_task(struct spdk_iscsi_conn conn, struct spdk_iscsi_task task);
	447
	448	static inline uint32_t
	449	iscsi_get_max_immediate_data_size(void)
7c673cae FG	450	{
	451	/*
	452	* Specify enough extra space in addition to FirstBurstLength to
	453	* account for a header digest, data digest and additional header
	454	* segments (AHS). These are not normally used but they do not
	455	* take up much space and we need to make sure the worst-case scenario
	456	* can be satisified by the size returned here.
	457	*/
f67539c2	458	return g_iscsi.FirstBurstLength +
7c673cae FG	459	ISCSI_DIGEST_LEN + /* data digest */
	460	ISCSI_DIGEST_LEN + /* header digest */
	461	8 + /* bidirectional AHS */
	462	52; /* extended CDB AHS (for a 64-byte CDB) */
	463	}
	464
7c673cae	465	#endif /* SPDK_ISCSI_H */